minor implementation

basic expr parsing (not complex like compound, lambda)

src/parse.c

@@ -48,14 +48,13 @@ ASTNode *parser_parse_program(Parser *parser) {
 
     while (parser->current.type == VAL) {
         ASTNode *defn_node = parser_parse_defn(parser);
-        
+
         if (defn_node == NULL) {
             ast_node_free(root);
             parser->flag_error = 1;
             return NULL;
         }
         ast_node_add_child(root, defn_node);
-        printf(":%zu\n", root->capacity);
     }
 
     return root;
@@ -71,8 +70,6 @@ ASTNode *parser_parse_defn(Parser *parser) {
     if (type_node == NULL) {
         return NULL;
     }
-    printf("%d", type_node->kind);
-    printf("rogally%d\n", parser->current.type);
     if (parser->current.type != ID) {
         parser->flag_error = 1;
         return NULL;
@@ -81,28 +78,26 @@ ASTNode *parser_parse_defn(Parser *parser) {
     ASTNode *id_node = ast_node_id(id_tok);
     parser_next(parser);
 
-    printf("%d", id_node->kind);
-
     ASTNode *expr_node = NULL;
-    printf("rogally%d\n", parser->current.type);
     if (parser->current.type != SEMI) {
-        perror("Parsing expression in definition not implemented yet.\n");
-        //expr_node = parser_parse_expr(parser);
-        return NULL;
+        expr_node = parser_parse_expr(parser);
         if (expr_node == NULL) {
+            parser->flag_error = 1;
             return NULL;
         }
     }
-    printf("rogally\n");
     if (!parser_expect(parser, SEMI)) {
         return NULL;
     }
-    printf("rogally\n");
 
     ASTNode *defn_node = ast_node_defn(val_tok, type_node, id_node, expr_node);
     return defn_node;
 }
 
+/*
+    PARSING TYPE
+*/
+
 ASTNode *parser_parse_type(Parser *parser) {
     ASTNode *type_node = NULL;
     if (parser->current.type == ID) {
@@ -163,7 +158,7 @@ ASTNode *parser_parse_type_complex(Parser *parser) {
             type_ret = ast_node_type_void(parser);
         }
 
-        ASTNode * type_param = ast_node_type_param();
+        ASTNode *type_param = ast_node_type_param();
         for (size_t i = 0; i < cnt; i++) {
             ast_node_add_child(type_param, types[i]);
         }
@@ -172,7 +167,7 @@ ASTNode *parser_parse_type_complex(Parser *parser) {
         ast_node_add_child(type_out, type_ret);
         ret = ast_node_type_complex(tok, type_param, type_out);
     } else if (parser->current.type == RBRACK) {
-        
+
         if (cnt >= 2) {
             parser->flag_error = 1;// too many args
             return NULL;
@@ -188,4 +183,64 @@ ASTNode *parser_parse_type_complex(Parser *parser) {
     }
     parser_next(parser);
     return ret;
+}
+
+/*
+    PARSING EXPR
+*/
+
+ASTNode *parser_parse_expr(Parser *parser) {
+    ASTNode *atoms[256];
+    size_t cnt = 1;
+    ASTNode *atom_head = parser_parse_atom(parser);
+    if (atom_head == NULL) {
+        parser->flag_error = 1;
+        return NULL;
+    }
+    atoms[0] = atom_head;
+
+    ASTNode *atom;
+    while (true) {
+        atom = parser_parse_atom(parser);
+        if (atom == NULL) {
+            break;
+        }
+        atoms[cnt] = atom;
+        cnt++;
+    }
+
+    ASTNode *node = ast_node_expr(atom_head->token);
+    for (size_t i = 0; i < cnt; i++) {
+        ast_node_add_child(node, atoms[i]);
+    }
+
+    return node;
+}
+
+ASTNode *parser_parse_atom(Parser *parser) {
+    if (parser->current.type == NUM) {
+        Token num_tok = parser->current;
+        parser_next(parser);
+        return ast_node_num(num_tok);
+    } else if (parser->current.type == ID) {
+        Token id_tok = parser->current;
+        parser_next(parser);
+        return ast_node_id(id_tok);
+    } else if (parser->current.type == STRING_LITERAL) {
+        Token str_tok = parser->current;
+        parser_next(parser);
+        return ast_node_str(str_tok);
+    } else if (parser->current.type == STAR) {
+        Token star_tok = parser->current;
+        parser_next(parser);
+        return ast_node_star(star_tok);
+    } else if (parser->current.type == ANDREF) {
+        Token andref_tok = parser->current;
+        parser_next(parser);
+        return ast_node_andref(andref_tok);
+    }
+    
+    else {
+        return NULL;
+    }
 }