Make parsing more modular...

- Can parse Floats.

diff --git a/main.c b/main.c
index 70375d7188e84a736379a96c0b8d581cb31e33a9..6a9d0ef68708abfe3bb44478fb82230d596549d2 100644 (file)
--- a/main.c
+++ b/main.c
@@ -296,6 +296,7 @@ typedef struct Ast_Binop Ast_Binop;
 
 typedef enum {
        AST_INT,
+       AST_FLOAT,
        AST_ADD,
        AST_COUNT
 } Ast_Node_Type;
@@ -303,6 +304,7 @@ typedef enum {
 const char *ast_type_as_str(const Ast_Node_Type t) {
        switch (t) {
                case AST_INT: return "INT";
+               case AST_FLOAT: return "FLOAT";
                case AST_ADD: return "ADD";
                case AST_COUNT:
                default: ASSERT(false, "Unreachable!");
@@ -315,6 +317,8 @@ struct Ast_Node {
     Location loc;
     Ast_Node_Type type;
 
+    Token token;
+
     union {
         uint u;
         int i;
@@ -342,6 +346,9 @@ void print_ast_node(FILE *f, Ast_Node node) {
            case AST_INT: {
                fprintf(f, "<%s>{%d}", ast_type_as_str(node.type), node.as.i);
            } break;
+           case AST_FLOAT: {
+               fprintf(f, "<%s>{%f}", ast_type_as_str(node.type), node.as.f);
+           } break;
            case AST_ADD: {
                fprintf(f, "Binop.{%s} (", ast_type_as_str(node.type));
                print_ast_node(f, node.binop->lhs);
@@ -354,6 +361,28 @@ void print_ast_node(FILE *f, Ast_Node node) {
     }
 }
 
+bool parse_int(Token t, Ast_Node *ast_out) {
+       if (t.type != TK_INT) return false;
+       int value = sv_to_int(t.lexeme);
+       ast_out->as.i = value;
+       ast_out->loc = t.loc;
+       ast_out->type = AST_INT;
+       ast_out->token = t;
+
+       return true;
+}
+
+bool parse_float(Token t, Ast_Node *ast_out) {
+       if (t.type != TK_FLOAT) return false;
+       float value = sv_to_float(t.lexeme);
+       ast_out->as.f = value;
+       ast_out->loc = t.loc;
+       ast_out->type = AST_FLOAT;
+       ast_out->token = t;
+
+       return true;
+}
+
 void parse(Parser *p) {
     // NOTE: So we don't loose the tokens ptr to free it.
     Tokens tokens_copy = p->tokens;
@@ -405,6 +434,7 @@ void parse(Parser *p) {
                 ast.binop->lhs = ast_nodes.items[ast_nodes.count-1];
                 ast.loc = t.loc;
                ast.type = AST_ADD;
+               ast.token = t;
 
                 if (tokens_copy.count <= 0) {
                     compiler_error(t.loc, "Unterminated '+' Operation!");
@@ -412,21 +442,14 @@ void parse(Parser *p) {
 
                 Token next_token = da_shift(tokens_copy);
 
-               // TODO: Allow addition of floats as well
-                if (next_token.type != TK_INT) {
-                    compiler_error(t.loc, "Cannot add and '%s' and '%s'", token_type_as_str(t.type), token_type_as_str(next_token.type));
-                }
-
-                // NOTE: COPY-PASTED FROM parse.switch.TK_INT:
-                // TODO: Better way to check for error...
-                // For now we just assume the lexeme is an int; else there is a bug in lexing.
-                int value = sv_to_int(next_token.lexeme);
-                Ast_Node rhs_ast = {
-                    .as.i = value
-                };
-
-                rhs_ast.loc = next_token.loc;
-               rhs_ast.type = AST_INT;
+                               /*            if (next_token.type != TK_INT &&*/
+                               /*next_token.type != TK_FLOAT) {*/
+                               /*                compiler_error(t.loc, "Cannot add '%s' and '%s'", token_type_as_str(ast.binop->lhs.token.type), token_type_as_str(next_token.type));*/
+                               /*            }*/
+               Ast_Node rhs_ast = {0};
+               if (!parse_int(next_token, &rhs_ast)) {
+                       ASSERT((parse_float(next_token, &rhs_ast)), "This should never happen cuz of the check above");
+               }
 
                 ast.binop->rhs = rhs_ast;
 
@@ -490,19 +513,23 @@ void parse(Parser *p) {
             } break;
 
             case TK_INT: {
+               Ast_Node ast = {0};
+               ASSERT(parse_int(t, &ast), "We fucked up in lexing.");
+               da_append(ast_nodes, ast);
+            } break;
+            case TK_FLOAT: {
                 // TODO: Better way to check for error...
                 // For now we just assume the lexeme is an int; else there is a bug in lexing.
-                int value = sv_to_int(t.lexeme);
+                float value = sv_to_float(t.lexeme);
                 Ast_Node ast = {
-                    .as.i = value
+                    .as.f = value
                 };
                 ast.loc = t.loc;
-               ast.type = AST_INT;
+               ast.type = AST_FLOAT;
+               ast.token = t;
 
                 da_append(ast_nodes, ast);
             } break;
-            case TK_FLOAT: {
-            } break;
 
             case TK_BITWISE_AND: {
             } break;