Add parsing support for functions

1 files changed, 144 insertions, 0 deletions

diff --git a/src/parser.c b/src/parser.c
index 84f3424..dbab4af 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -53,6 +53,11 @@ typedef enum NodeKind {
     NODE_BREAK,
     NODE_CONTINUE,
     NODE_WHILE,
+    // Functions.
+    NODE_FUN,
+    NODE_FUN_PARAM,
+    NODE_FUNCALL,
+    NODE_RETURN,
     // Helpers.
     NODE_SYMBOL_IDX,
     NODE_TYPE,
@@ -95,6 +100,11 @@ Str node_str[] = {
     [NODE_FALSE] = cstr("FALSE"),
     [NODE_NIL] = cstr("NIL"),
     [NODE_STRUCT_LIT] = cstr("STRUCT LIT"),
+    // Functions.
+    [NODE_FUN] = cstr("FUNCTION"),
+    [NODE_FUN_PARAM] = cstr("PARAM"),
+    [NODE_FUNCALL] = cstr("FUNCALL"),
+    [NODE_RETURN] = cstr("RETURN"),
     // Keywords.
     [NODE_LET] = cstr("LET"),
     [NODE_SET] = cstr("SET"),
@@ -158,6 +168,10 @@ typedef struct Node {
             struct Node *field_val;
         };
         struct {
+            struct Node *param_name;
+            struct Node *param_type;
+        };
+        struct {
             struct Node *match_expr;
             struct Node **match_cases;
         };
@@ -168,6 +182,13 @@ typedef struct Node {
         struct Node **struct_field;
         struct Node **elements;
         struct Node **statements;
+        struct Node **expressions;
+        struct {
+            struct Node *func_name;
+            struct Node **func_params;
+            struct Node **func_ret;
+            struct Node *func_body;
+        };
     };
     bool is_ptr;
 } Node;
@@ -671,6 +692,107 @@ parse_keyword(Parser *parser) {
             parse_expr(parser, PREC_LOW);
             node->while_expr = array_pop(parser->nodes);
         } break;
+        case TOK_FUN: {
+            node = node_alloc(parser, NODE_FUN, prev);
+            if (!node) return;
+            parse_consume(parser, TOK_SYMBOL, cstr("expected function name"));
+            parse_consume(parser, TOK_LPAREN,
+                          cstr("expected '(' on function definition"));
+            // Parameters.
+            while (!parse_match(parser, TOK_RPAREN) && !parser->panic) {
+                Node *param =
+                    node_alloc(parser, NODE_FUN_PARAM, parser->current);
+                if (!param) return;
+                Node *name = node_alloc(parser, NODE_SYMBOL, prev);
+                if (!name) return;
+                parse_consume(parser, TOK_SYMBOL, cstr("expected symbol name"));
+                name->value.sym = parser->previous.val;
+                param->param_name = name;
+
+                Node *type = node_alloc(parser, NODE_TYPE, prev);
+                if (!type) return;
+                parse_consume(parser, TOK_COLON, cstr("expected param type"));
+                if (parse_match(parser, TOK_AT)) {
+                    type->is_ptr = true;
+                }
+                parse_consume(parser, TOK_SYMBOL, cstr("expected param type"));
+                type->value.sym = parser->previous.val;
+                param->param_type = type;
+                if (parse_match(parser, TOK_LSQUARE)) {
+                    type->kind = NODE_ARR_TYPE,
+                    parse_consume(parser, TOK_NUM_INT,
+                                  cstr("no array size given"));
+                    parse_number(parser);
+                    type->arr_size = array_pop(parser->nodes);
+                    parse_consume(parser, TOK_RSQUARE,
+                                  cstr("unmatched brackets ']' in array type"));
+                }
+                array_push(node->func_params, param, parser->storage);
+            }
+            parse_consume(parser, TOK_COLON, cstr("expected param type"));
+
+            // Return type(s).
+            if (!parse_match(parser, TOK_NIL)) {
+                if (parse_match(parser, TOK_LPAREN)) {
+                    while (!parse_match(parser, TOK_RPAREN) && !parser->panic) {
+                        Node *ret = node_alloc(parser, NODE_TYPE, prev);
+                        if (!ret) return;
+                        if (parse_match(parser, TOK_AT)) {
+                            ret->is_ptr = true;
+                        }
+                        parse_consume(parser, TOK_SYMBOL,
+                                      cstr("expected type name"));
+                        ret->value.sym = parser->previous.val;
+                        if (parse_match(parser, TOK_LSQUARE)) {
+                            ret->kind = NODE_ARR_TYPE,
+                            parse_consume(parser, TOK_NUM_INT,
+                                          cstr("no array size given"));
+                            parse_number(parser);
+                            ret->arr_size = array_pop(parser->nodes);
+                            parse_consume(
+                                parser, TOK_RSQUARE,
+                                cstr("unmatched brackets ']' in array type"));
+                        }
+                        array_push(node->func_ret, ret, parser->storage);
+                    }
+                } else {
+                    Node *ret = node_alloc(parser, NODE_TYPE, prev);
+                    if (!ret) return;
+                    if (parse_match(parser, TOK_AT)) {
+                        ret->is_ptr = true;
+                    }
+                    parse_consume(parser, TOK_SYMBOL,
+                                  cstr("expected type name"));
+                    ret->value.sym = parser->previous.val;
+                    if (parse_match(parser, TOK_LSQUARE)) {
+                        ret->kind = NODE_ARR_TYPE,
+                        parse_consume(parser, TOK_NUM_INT,
+                                      cstr("no array size given"));
+                        parse_number(parser);
+                        ret->arr_size = array_pop(parser->nodes);
+                        parse_consume(
+                            parser, TOK_RSQUARE,
+                            cstr("unmatched brackets ']' in array type"));
+                    }
+                    array_push(node->func_ret, ret, parser->storage);
+                }
+            }
+
+            // Body.
+            parse_expr(parser, PREC_LOW);
+            node->func_body = array_pop(parser->nodes);
+        } break;
+        case TOK_RETURN: {
+            node = node_alloc(parser, NODE_RETURN, prev);
+            if (!node) return;
+            parse_consume(parser, TOK_LPAREN,
+                          cstr("expected '(' after return"));
+            while (!parse_match(parser, TOK_RPAREN) && !parser->panic) {
+                parse_expr(parser, PREC_LOW);
+                array_push(node->expressions, array_pop(parser->nodes),
+                           parser->storage);
+            }
+        } break;
         default: return;  // Unreachable.
     }
     array_push(parser->nodes, node, parser->storage);
@@ -865,6 +987,7 @@ graph_node(Node *node) {
         case NODE_STRUCT:
         case NODE_STRUCT_LIT: print("| Name: %s", node->value.sym); break;
         case NODE_SYMBOL:
+        case NODE_ARR_TYPE:
         case NODE_TYPE: {
             if (node->is_ptr) {
                 print("| Name: @%s", node->value.sym);
@@ -877,6 +1000,26 @@ graph_node(Node *node) {
     println("\"];");
 
     switch (node->kind) {
+        case NODE_FUN: {
+            for (sz i = 0; i < array_size(node->func_params); i++) {
+                Node *next = node->func_params[i];
+                println("%d:e->%d:w;", node->id, next->id);
+                graph_node(next);
+            }
+            for (sz i = 0; i < array_size(node->func_ret); i++) {
+                Node *next = node->func_ret[i];
+                println("%d:e->%d:w;", node->id, next->id);
+                graph_node(next);
+            }
+            if (node->func_name) {
+                println("%d:e->%d:w;", node->id, node->func_name->id);
+                graph_node(node->func_name);
+            }
+            if (node->func_body) {
+                println("%d:e->%d:w;", node->id, node->func_body->id);
+                graph_node(node->func_body);
+            }
+        } break;
         case NODE_COND:
         case NODE_MATCH: {
             if (node->match_expr) {
@@ -889,6 +1032,7 @@ graph_node(Node *node) {
                 graph_node(next);
             }
         } break;
+        case NODE_RETURN:
         case NODE_BLOCK:
         case NODE_STRUCT_LIT:
         case NODE_COMPOUND_TYPE: {