Feat: Add Character, String and float literals

lib/analyzer/lexer.mll

@@ -40,20 +40,28 @@ rule token = parse
 
   (* Literals *)
   | interger as i { INT (int_of_string i) }
-(*  | float as f { FLOAT (float_of_string f) } *)
+  | float as f { FLOAT (float_of_string f) }
+  | '"' { Buffer.clear buffer; STRING(string lexbuf) }
+  | "''" { NULL }
+  | "'\\''"    { CHARACTER '\'' }
+  | "'\\n'"    { CHARACTER '\n' }
+  | "'\\t'"    { CHARACTER '\t' }
+  | "'\\\\'"   { CHARACTER '\\' }
+  | "'\\r'"    { CHARACTER '\r' }
+  | "'\\b'"    { CHARACTER '\b' }
+  | "'" [^'\\'] "'" { CHARACTER (String.get (Lexing.lexeme lexbuf) 1) }
 
   (* Identifiers *)
-  (* ... *)
+  | identifier as lxm { IDENTIFIER(lxm) }
 
   | eof { EOF }
   | _ as c { raise (Error c) }
 
 and string = parse
-  | '"' { token lexbuf }
+  | '\"' { Buffer.contents buffer}
+  | "\\\"" { Buffer.add_char buffer '"'; string lexbuf }
   | '\\' { Buffer.add_char buffer '\\'; string lexbuf }
-  | '\n' { Buffer.add_char buffer '\n'; string lexbuf }
-  | eof { raise (Error '"') }
-  | _ { Buffer.add_char buffer (Lexing.lexeme_char lexbuf 0); string lexbuf }
+  | _ as c { Buffer.add_char buffer c; string lexbuf }
 
 and line_comment = parse
   | '\n' { Lexing.new_line lexbuf; token lexbuf }

lib/analyzer/parser.mly

@@ -3,6 +3,12 @@ open Syntax
 %}
 
 %token <int> INT
+%token <float> FLOAT
+%token <char> CHARACTER
+%token <string> STRING
+%token <string> IDENTIFIER
+%token NULL
+
 %token PLUS "+"
 %token MINUS "-"
 %token TIMES "*"
@@ -36,12 +42,17 @@ statement:
 
 expression:
   | literal            { Expressions.Literal($1) }
+  | IDENTIFIER         { Expressions.Identifier($1) }
   | unary_expression   { $1 }
   | binary_expression  { $1 }
   | "(" expression ")" { $2 }
 
 literal:
   | INT { Literals.Integer($1) }
+  | FLOAT { Literals.Float($1) }
+  | CHARACTER { Literals.Character($1) }
+  | STRING { Literals.String($1) }
+  | NULL { Literals.Null }
 
 unary_expression:
   | "-" expression %prec UMINUS { Expressions.UnaryExpression(UnaryOperators.ArithmeticNegation, $2) }

lib/analyzer/typing.ml

@@ -1 +1 @@
-type environment = { variables : (string * _type) list }
+type environment = { variables : (string * Types.types) list }

lib/syntax/Expressions.ml

@@ -4,6 +4,7 @@ open BinaryOperators
 
 type expressions =
   | Literal of literals
+  | Identifier of string
   | UnaryExpression of unary_operators * expressions
   | BinaryExpression of binary_operators * expressions * expressions
 
@@ -11,6 +12,7 @@ let rec pp_expressions = function
   | Literal l ->
       let pp_l = pp_literals l in
       Printf.sprintf "Literal(%s)" pp_l
+  | Identifier i -> Printf.sprintf "Identifier(\"%s\")" i
   | UnaryExpression (op, e) ->
       let pp_op = pp_unary_operators op and pp_e = pp_expressions e in
       Printf.sprintf "UnaryExpression(%s, %s)" pp_op pp_e

test/ressources/test.🥐

@@ -1,33 +1 @@
-1 + 1;
-4 * 0;
-
-/*
-
-Root(
-  SequenceStatement(
-    ExpressionStatement(
-      BinaryExpression(
-        Add,
-        Literal(
-          Integer(1)
-        ),
-        Literal(
-          Integer(1)
-        )
-      )
-    ),
-    ExpressionStatement(
-      BinaryExpression(
-        Multiply,
-        Literal(
-          Integer(4)
-        ),
-        Literal(
-          Integer(0)
-        )
-      )
-    )
-  )
-)
-
-*/
+'a';

test/syntax/TestExpressions.ml

@@ -7,6 +7,9 @@ let test_pp_expressions () =
       ( "Should return \"Literal(...)\"",
         "Literal(Integer(1))",
         Expressions.Literal (Literals.Integer 1) );
+      ( "Should return \"Identifier(...)\"",
+        "Identifier(\"myVar\")",
+        Expressions.Identifier "myVar" );
       ( "Should return \"UnaryExpression(...)\"",
         "UnaryExpression(ArithmeticNegation, Literal(Integer(2)))",
         Expressions.UnaryExpression