Skip to content

Commit 3b9bd27

Browse files
martcppmartcpp
committed
added logic for float
1 parent c6e5cdb commit 3b9bd27

3 files changed

Lines changed: 159 additions & 21 deletions

File tree

‎src/lexericals/lexer.rs‎

Lines changed: 50 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -51,11 +51,21 @@ impl Lexer {
5151
let kind = Tokenkind::lookup_ident(&literal);
5252
Token::new(kind, literal)
5353
}else if Lexer::is_digit(self.ch) {
54-
let kind = Tokenkind::Int;
5554
let literal = self.read_number();
55+
let kind = if literal.contains('.') {
56+
Tokenkind::Float // If it contains a dot, treat it as a float
57+
} else {
58+
Tokenkind::Int // Otherwise, treat it as an integer
59+
};
5660
Token::new(kind, literal)
5761

58-
} else {
62+
}
63+
//else if Lexer::is_float(self.ch){
64+
// let kind = Tokenkind::Float;
65+
// let literal = self.read_float();
66+
// Token::new(kind, literal)
67+
// }
68+
else {
5969
Token::new(Tokenkind::Illegal, self.ch.to_string())
6070
},
6171

@@ -79,15 +89,40 @@ impl Lexer {
7989
ch.is_alphabetic() || ch == '_'
8090
}
8191

92+
// fn is_float(ch: char) -> bool {
93+
// ch.is_numeric() || ch == '.'
94+
// }
95+
8296
fn read_number(&mut self) -> String {
8397
let mut literal = String::new();
8498
while Lexer::is_digit(self.ch) {
8599
literal.push(self.ch);
86100
self.read_token();
87101
}
102+
if self.ch == '.' {
103+
literal.push(self.ch);
104+
self.read_token();
105+
}
106+
while Lexer::is_digit(self.ch) {
107+
literal.push(self.ch);
108+
self.read_token();
109+
}
88110
literal
89111
}
90112

113+
// fn read_float(&mut self) -> String {
114+
// let mut literal = String::new();
115+
// if self.ch == '.' {
116+
// literal.push(self.ch);
117+
// self.read_token();
118+
// }
119+
// while Lexer::is_float(self.ch) {
120+
// literal.push(self.ch);
121+
// self.read_token();
122+
// }
123+
// literal
124+
// }
125+
91126
fn read_identifier(&mut self) -> String {
92127
let mut literal = String::new();
93128
while Lexer::is_letter(self.ch){
@@ -106,7 +141,8 @@ mod test {
106141
#[test]
107142
fn read_token() {
108143
let input =r#"
109-
let five = 5;
144+
let five = 5000000;
145+
let floattest = 5.0;
110146
let ten = 10;
111147
let add = fn(x, y) {
112148
x + y;
@@ -118,13 +154,23 @@ mod test {
118154
Token::new(Tokenkind::Let, String::from("let")),
119155
Token::new(Tokenkind::Ident, String::from("five")),
120156
Token::new(Tokenkind::Assign, String::from("=")),
121-
Token::new(Tokenkind::Int, String::from("5")),
157+
Token::new(Tokenkind::Int, String::from("5000000")),
158+
Token::new(Tokenkind::Semicolon, String::from(";")),
159+
Token::new(Tokenkind::Let, String::from("let")),
160+
Token::new(Tokenkind::Ident, String::from("floattest")),
161+
Token::new(Tokenkind::Assign, String::from("=")),
162+
Token::new(Tokenkind::Float, String::from("5.0")),
122163
Token::new(Tokenkind::Semicolon, String::from(";")),
123164
Token::new(Tokenkind::Let, String::from("let")),
124165
Token::new(Tokenkind::Ident, String::from("ten")),
125166
Token::new(Tokenkind::Assign, String::from("=")),
126167
Token::new(Tokenkind::Int, String::from("10")),
127168
Token::new(Tokenkind::Semicolon, String::from(";")),
169+
// Token::new(Tokenkind::Let, String::from("let")),
170+
// Token::new(Tokenkind::Ident, String::from("ten")),
171+
// Token::new(Tokenkind::Assign, String::from("=")),
172+
// Token::new(Tokenkind::Int, String::from("10")),
173+
// Token::new(Tokenkind::Semicolon, String::from(";")),
128174
Token::new(Tokenkind::Let, String::from("let")),
129175
Token::new(Tokenkind::Ident, String::from("add")),
130176
Token::new(Tokenkind::Assign, String::from("=")),

‎src/lexericals/tokenizer.rs‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -21,6 +21,7 @@ pub enum Tokenkind {
2121
Eof,
2222
Ident,
2323
Int,
24+
Float,
2425
String,
2526
Assign,
2627
Plus,
@@ -55,6 +56,7 @@ impl Display for Tokenkind {
5556
Tokenkind::Eof => write!(f, "Eof"),
5657
Tokenkind::Ident => write!(f, "Ident"),
5758
Tokenkind::Int => write!(f, "Int"),
59+
Tokenkind::Float => write!(f, "Float"),
5860
Tokenkind::String => write!(f, "String"),
5961
Tokenkind::Assign => write!(f, "Assign"),
6062
Tokenkind::Plus => write!(f, "Plus"),

‎src/main.rs‎

Lines changed: 107 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
11
mod lexericals;
22
use crate::lexericals::lexer::Lexer;
3+
use crate::lexericals::tokenizer::{Token, Tokenkind};
34

45

56
fn main() {
@@ -11,7 +12,8 @@ fn main() {
1112
// println!("Token {:?}", token);
1213

1314
let input =r#"
14-
let five = 5;
15+
let five = 5000000;
16+
let floattest = 5.0;
1517
let ten = 10;
1618
let add = fn(x, y) {
1719
x + y;
@@ -20,13 +22,15 @@ fn main() {
2022
"#;
2123

2224
let mut lexer = Lexer::new(input);
23-
println!("Lexer initialized with input: {}", input);
24-
let mut tokens = Vec::new();
25-
let mut token = lexer.next_token();
26-
while token.kind != lexericals::tokenizer::Tokenkind::Eof {
27-
tokens.push(token.literal);
28-
token = lexer.next_token();
29-
}
25+
let runer = read();
26+
//println!("Lexer initialized with input: {}", input);
27+
28+
// let mut tokens = Vec::new();
29+
// // let mut token = lexer.next_token();
30+
// // while token.kind != lexericals::tokenizer::Tokenkind::Eof {
31+
// // tokens.push(token.literal);
32+
// // token = lexer.next_token();
33+
// // }
3034

3135
// loop {
3236
// let token = lexer.next_token();
@@ -35,19 +39,105 @@ fn main() {
3539
// }
3640
// tokens.push(token.literal);
3741
// }
38-
println!("Tokens: {:?}", tokens);
42+
// println!("Tokens: {:?}", tokens);
43+
// println!("Tokens: {:?}", lexer);
3944

40-
// for (idx,token) in lexer.input.clone().into_iter().enumerate() {
41-
// println!("charater at index:{} token:{}", idx, token);
42-
// let token = lexer.next_token();
43-
// println!("Tokenkind at index:{} is:{}", idx, token.kind);
44-
// println!("literal at index:{} is:{} ", idx, token.literal);
45-
// }
45+
for (idx,token) in runer.into_iter().enumerate() {
46+
// println!("charater at index:{} token:{:?}", idx, token);
47+
let inside_token = lexer.next_token();
48+
println!("Tokenkind at index:{} expected is:{} gotten is:{}", idx,token.kind, inside_token.kind);
49+
println!("literal at index:{} expected is:{} gotten is:{}", idx,token.literal, inside_token.literal);
50+
}
4651

4752
// println!(" last Current character: {:?}", lexer.next_token());
4853

4954
}
5055

51-
fn read_string(ch:char) -> String {
52-
todo!("Implement string reading logic");
56+
// fn read_string(ch:char) -> String {
57+
// todo!("Implement string reading logic");
58+
// }
59+
60+
fn read() -> Vec<Token> {
61+
62+
let expected_token= vec![
63+
Token::new(Tokenkind::Let, String::from("let")),
64+
Token::new(Tokenkind::Ident, String::from("five")),
65+
Token::new(Tokenkind::Assign, String::from("=")),
66+
Token::new(Tokenkind::Int, String::from("5000000")),
67+
Token::new(Tokenkind::Semicolon, String::from(";")),
68+
Token::new(Tokenkind::Let, String::from("let")),
69+
Token::new(Tokenkind::Ident, String::from("floattest")),
70+
Token::new(Tokenkind::Assign, String::from("=")),
71+
Token::new(Tokenkind::Float, String::from("5.0")),
72+
Token::new(Tokenkind::Semicolon, String::from(";")),
73+
Token::new(Tokenkind::Let, String::from("let")),
74+
Token::new(Tokenkind::Ident, String::from("ten")),
75+
Token::new(Tokenkind::Assign, String::from("=")),
76+
Token::new(Tokenkind::Int, String::from("10")),
77+
Token::new(Tokenkind::Semicolon, String::from(";")),
78+
// Token::new(Tokenkind::Let, String::from("let")),
79+
// Token::new(Tokenkind::Ident, String::from("ten")),
80+
// Token::new(Tokenkind::Assign, String::from("=")),
81+
// Token::new(Tokenkind::Int, String::from("10")),
82+
// Token::new(Tokenkind::Semicolon, String::from(";")),
83+
Token::new(Tokenkind::Let, String::from("let")),
84+
Token::new(Tokenkind::Ident, String::from("add")),
85+
Token::new(Tokenkind::Assign, String::from("=")),
86+
Token::new(Tokenkind::Function, String::from("fn")),
87+
Token::new(Tokenkind::Lparen, String::from("(")),
88+
Token::new(Tokenkind::Ident, String::from("x")),
89+
Token::new(Tokenkind::Comma, String::from(",")),
90+
Token::new(Tokenkind::Ident, String::from("y")),
91+
Token::new(Tokenkind::Rparen, String::from(")")),
92+
Token::new(Tokenkind::Lbrace, String::from("{")),
93+
Token::new(Tokenkind::Ident, String::from("x")),
94+
Token::new(Tokenkind::Plus, String::from("+")),
95+
Token::new(Tokenkind::Ident, String::from("y")),
96+
Token::new(Tokenkind::Semicolon, String::from(";")),
97+
Token::new(Tokenkind::Rbrace, String::from("}")),
98+
Token::new(Tokenkind::Semicolon, String::from(";")),
99+
Token::new(Tokenkind::Let, String::from("let")),
100+
Token::new(Tokenkind::Ident, String::from("result")),
101+
Token::new(Tokenkind::Assign, String::from("=")),
102+
Token::new(Tokenkind::Ident, String::from("add")),
103+
Token::new(Tokenkind::Lparen, String::from("(")),
104+
Token::new(Tokenkind::Ident, String::from("five")),
105+
Token::new(Tokenkind::Comma, String::from(",")),
106+
Token::new(Tokenkind::Ident, String::from("ten")),
107+
Token::new(Tokenkind::Rparen, String::from(")")),
108+
Token::new(Tokenkind::Semicolon, String::from(";")),
109+
Token::new(Tokenkind::Eof, String::new()),
110+
111+
];
112+
expected_token
53113
}
114+
115+
// fn main() {
116+
// let input = r#"
117+
// let five = 5;
118+
// let ten = 10;
119+
// let add = fn(x, y) {
120+
// x + y;
121+
// };
122+
// let result = add(five, ten);
123+
// "#;
124+
125+
// let mut lexer = Lexer::new(input);
126+
// println!("Lexer initialized with input: {}", input);
127+
128+
// let mut tokens = Vec::new();
129+
130+
// loop {
131+
// let token = lexer.next_token();
132+
// if token.kind == lexericals::tokenizer::Tokenkind::Eof {
133+
// break;
134+
// }
135+
// tokens.push(token); // push the whole token (no clone)
136+
// }
137+
138+
// for (idx, token) in tokens.into_iter().enumerate() {
139+
// println!("character at index:{} token:{:?}", idx, token);
140+
// println!("Tokenkind at index:{} is:{:?}", idx, token.kind);
141+
// println!("literal at index:{} is:{} ", idx, token.literal);
142+
// }
143+
// }

0 commit comments

Comments
 (0)