Add let/set/struct parsing

1 files changed, 288 insertions, 48 deletions

diff --git a/src/main.c b/src/main.c
index 8dc645e..d456381 100644
--- a/src/main.c
+++ b/src/main.c
@@ -70,6 +70,13 @@ typedef enum NodeKind {
     NODE_TRUE,
     NODE_FALSE,
     NODE_NIL,
+    // Keywords.
+    NODE_LET,
+    NODE_SET,
+    NODE_STRUCT,
+    // Helpers.
+    NODE_NODE_LIST,
+    NODE_NODE_TYPE,
 } NodeKind;
 
 Str node_str[] = {
@@ -104,6 +111,12 @@ Str node_str[] = {
     [NODE_TRUE] = cstr("TRUE"),
     [NODE_FALSE] = cstr("FALSE"),
     [NODE_NIL] = cstr("NIL"),
+    [NODE_LET] = cstr("LET"),
+    [NODE_SET] = cstr("SET"),
+    [NODE_STRUCT] = cstr("STRUCT"),
+    // Helpers.
+    [NODE_NODE_LIST] = cstr("..."),
+    [NODE_NODE_TYPE] = cstr("TYPE"),
 };
 
 typedef struct Node {
@@ -119,21 +132,17 @@ typedef struct Node {
         Str str;
         Str sym;
     } value;
-    struct Node *left;
-    struct Node *right;
+    union {
+        struct Node *left;
+        struct Node *varname;
+    };
+    union {
+        struct Node *right;
+        struct Node *vartype;
+        struct Node *varvalue;
+    };
 } Node;
 
-Node *
-node_alloc(NodeKind kind, Token tok, Arena *a) {
-    static sz id = 0;
-    Node *node = arena_calloc((sz)sizeof(Node), a);
-    node->id = id++;
-    node->kind = kind;
-    node->line = tok.line;
-    node->col = tok.col;
-    return node;
-}
-
 //
 // Parsing.
 //
@@ -179,6 +188,7 @@ typedef struct {
 
 void parse_expr(Parser *parser, ParsePrecedence precedence);
 void parse_advance(Parser *parser);
+bool parse_match(Parser *parser, TokenKind kind);
 
 void parse_grouping(Parser *parser);
 void parse_unary(Parser *parser);
@@ -187,6 +197,11 @@ void parse_number(Parser *parser);
 void parse_literal(Parser *parser);
 void parse_string(Parser *parser);
 void parse_symbol(Parser *parser);
+void parse_symbol_chain(Parser *parser);
+void parse_keyword(Parser *parser);
+void parse_struct(Parser *parser);
+Node *parse_struct_field(Parser *parser);
+Node *parse_type(Parser *parser);
 
 ParseRule parse_rules[] = {
     [TOK_LPAREN] = {parse_grouping, NULL, PREC_NONE},
@@ -196,6 +211,7 @@ ParseRule parse_rules[] = {
     [TOK_DIV] = {NULL, parse_binary, PREC_FACTOR},
     [TOK_MUL] = {NULL, parse_binary, PREC_FACTOR},
     [TOK_MOD] = {NULL, parse_binary, PREC_FACTOR},
+
     // Logical.
     [TOK_NOT] = {parse_unary, NULL, PREC_NONE},
     [TOK_AND] = {NULL, parse_binary, PREC_AND},
@@ -206,23 +222,53 @@ ParseRule parse_rules[] = {
     [TOK_GT] = {NULL, parse_binary, PREC_COMPARISON},
     [TOK_LE] = {NULL, parse_binary, PREC_COMPARISON},
     [TOK_GE] = {NULL, parse_binary, PREC_COMPARISON},
+
     // Bitwise ops.
     [TOK_BITNOT] = {parse_unary, NULL, PREC_NONE},
     [TOK_BITAND] = {NULL, parse_binary, PREC_BITLOGIC},
     [TOK_BITOR] = {NULL, parse_binary, PREC_BITLOGIC},
     [TOK_BITLSHIFT] = {NULL, parse_binary, PREC_BITSHIFT},
     [TOK_BITRSHIFT] = {NULL, parse_binary, PREC_BITSHIFT},
+
     // Literals.
     [TOK_STRING] = {parse_string, NULL, PREC_NONE},
-    [TOK_SYMBOL] = {parse_symbol, NULL, PREC_NONE},
+    [TOK_SYMBOL] = {parse_symbol_chain, NULL, PREC_NONE},
     [TOK_NUM_INT] = {parse_number, NULL, PREC_NONE},
     [TOK_NUM_FLOAT] = {parse_number, NULL, PREC_NONE},
     [TOK_TRUE] = {parse_literal, NULL, PREC_NONE},
     [TOK_FALSE] = {parse_literal, NULL, PREC_NONE},
     [TOK_NIL] = {parse_literal, NULL, PREC_NONE},
+
+    // Statements.
+    [TOK_LET] = {parse_keyword, NULL, PREC_NONE},
+    [TOK_SET] = {parse_keyword, NULL, PREC_NONE},
+    [TOK_STRUCT] = {parse_keyword, NULL, PREC_NONE},
+    [TOK_IF] = {parse_keyword, NULL, PREC_NONE},
+    [TOK_MATCH] = {parse_keyword, NULL, PREC_NONE},
+    [TOK_CASE] = {parse_keyword, NULL, PREC_NONE},
+    [TOK_WHILE] = {parse_keyword, NULL, PREC_NONE},
+    [TOK_CONTINUE] = {parse_keyword, NULL, PREC_NONE},
+    [TOK_BREAK] = {parse_keyword, NULL, PREC_NONE},
+    [TOK_FUN] = {parse_keyword, NULL, PREC_NONE},
+    [TOK_RETURN] = {parse_keyword, NULL, PREC_NONE},
+
     [TOK_EOF] = {NULL, NULL, PREC_NONE},
 };
 
+Node *
+node_alloc(NodeKind kind, Token tok, Parser *p) {
+    if (p->panic) {
+        return NULL;
+    }
+    static sz id = 0;
+    Node *node = arena_calloc((sz)sizeof(Node), p->storage);
+    node->id = id++;
+    node->kind = kind;
+    node->line = tok.line;
+    node->col = tok.col;
+    return node;
+}
+
 void
 parse_emit_err(Parser *parser, Token token, Str msg) {
     if (parser->panic) {
@@ -243,9 +289,22 @@ void
 parse_advance(Parser *parser) {
     assert(parser);
     parser->previous = parser->current;
+    if (parser->previous.kind == TOK_EOF) {
+        return;
+    }
     parser->current = parser->tokens[parser->idx++];
 }
 
+bool
+parse_match(Parser *parser, TokenKind kind) {
+    assert(parser);
+    if (parser->current.kind != kind) {
+        return false;
+    }
+    parse_advance(parser);
+    return true;
+}
+
 static void
 parse_consume(Parser *parser, TokenKind kind, Str msg) {
     if (parser->current.kind == kind) {
@@ -258,6 +317,10 @@ parse_consume(Parser *parser, TokenKind kind, Str msg) {
 void
 parse_expr(Parser *parser, ParsePrecedence precedence) {
     parse_advance(parser);
+    // TODO: synchronize panic mode on keywords.
+    if (parser->panic) {
+        return;
+    }
     ParseFn prefix = parse_rules[parser->previous.kind].prefix;
     if (prefix == NULL) {
         parse_emit_err(parser, parser->previous, cstr("expected expression"));
@@ -287,12 +350,13 @@ parse_unary(Parser *parser) {
     parse_expr(parser, PREC_UNARY);
     Node *node = NULL;
     switch (prev.kind) {
-        case TOK_NOT: node = node_alloc(NODE_NOT, prev, parser->storage); break;
-        case TOK_BITNOT: {
-            node = node_alloc(NODE_BITNOT, prev, parser->storage);
-        } break;
+        case TOK_NOT: node = node_alloc(NODE_NOT, prev, parser); break;
+        case TOK_BITNOT: node = node_alloc(NODE_BITNOT, prev, parser); break;
         default: break;  // Unreachable.
     }
+    if (!node) {
+        return;
+    }
     node->left = array_pop(parser->nodes);
     array_push(parser->nodes, node, parser->storage);
 }
@@ -307,13 +371,142 @@ parse_literal(Parser *parser) {
     Node *node = NULL;
     switch (prev.kind) {
         case TOK_TRUE: {
-            node = node_alloc(NODE_TRUE, prev, parser->storage);
+            node = node_alloc(NODE_TRUE, prev, parser);
         } break;
         case TOK_FALSE: {
-            node = node_alloc(NODE_FALSE, prev, parser->storage);
+            node = node_alloc(NODE_FALSE, prev, parser);
         } break;
         case TOK_NIL: {
-            node = node_alloc(NODE_NIL, prev, parser->storage);
+            node = node_alloc(NODE_NIL, prev, parser);
+        } break;
+        default: return;  // Unreachable.
+    }
+    array_push(parser->nodes, node, parser->storage);
+}
+
+Node *
+parse_type(Parser *parser) {
+    Token prev = parser->previous;
+#if DEBUG == 1
+    print("parsing type ");
+    print_token(prev);
+#endif
+    Node *node = node_alloc(NODE_NODE_TYPE, prev, parser);
+    if (parse_match(parser, TOK_LCURLY)) {
+        node->value.sym = cstr("...");
+        Node *l = parse_struct_field(parser);
+        if (!l) {
+            return NULL;
+        }
+        node->vartype = l;
+        while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
+            Node *tmp = parse_struct_field(parser);
+            if (!tmp) {
+                return NULL;
+            }
+            l->vartype = tmp;
+            l = tmp;
+        }
+        return node;
+    }
+    parse_consume(parser, TOK_SYMBOL, cstr("no type given for struct field"));
+    node->value.sym = parser->previous.val;
+    return node;
+}
+
+Node *
+parse_struct_field(Parser *parser) {
+#if DEBUG == 1
+    println("parsing struct field ");
+    print_token(parser->previous);
+#endif
+    parse_consume(parser, TOK_SYMBOL, cstr("expected struct field name"));
+    parse_symbol(parser);
+    Node *field = array_pop(parser->nodes);
+    parse_consume(parser, TOK_COLON,
+                  cstr("invalid type name given for struct field"));
+    field->vartype = parse_type(parser);
+    if (parse_match(parser, TOK_ASSIGN)) {
+        parse_expr(parser, PREC_LOW);
+        field->varname = array_pop(parser->nodes);
+    }
+
+    Node *list = node_alloc(NODE_NODE_LIST, parser->previous, parser);
+    list->varname = field;
+    return list;
+}
+
+void
+parse_keyword(Parser *parser) {
+    Token prev = parser->previous;
+#if DEBUG == 1
+    print("parsing keyword ");
+    print_token(prev);
+#endif
+    Node *node = NULL;
+    switch (prev.kind) {
+        case TOK_LET: {
+            parse_consume(parser, TOK_SYMBOL,
+                          cstr("expected symbol name on let expression"));
+            parse_symbol(parser);
+
+            // Optional type declaration.
+            Node *type = NULL;
+            if (parse_match(parser, TOK_COLON)) {
+                type = parse_type(parser);
+            }
+
+            node = node_alloc(NODE_LET, prev, parser);
+            if (!node) {
+                return;
+            }
+
+            // Optional assignment.
+            if (parse_match(parser, TOK_ASSIGN)) {
+                parse_expr(parser, PREC_LOW);
+                node->varvalue = array_pop(parser->nodes);
+            }
+            node->varname = array_pop(parser->nodes);
+            node->varname->vartype = type;
+        } break;
+        case TOK_SET: {
+            parse_consume(parser, TOK_SYMBOL,
+                          cstr("expected symbol name on set expression"));
+            parse_symbol_chain(parser);
+            parse_consume(parser, TOK_ASSIGN,
+                          cstr("expected assignment on set expression"));
+            parse_expr(parser, PREC_LOW);
+            node = node_alloc(NODE_SET, prev, parser);
+            if (!node) {
+                return;
+            }
+            node->varvalue = array_pop(parser->nodes);
+            node->varname = array_pop(parser->nodes);
+        } break;
+        case TOK_STRUCT: {
+            parse_consume(parser, TOK_SYMBOL,
+                          cstr("expected symbol name on struct definition"));
+            parse_symbol(parser);
+            parse_consume(parser, TOK_LCURLY,
+                          cstr("expected '{' on struct definition"));
+            node = node_alloc(NODE_STRUCT, prev, parser);
+            if (!node) {
+                return;
+            }
+            node->varname = array_pop(parser->nodes);
+            Node *l = parse_struct_field(parser);
+            if (!l) {
+                return;
+            }
+            node->vartype = l;
+            while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
+                Node *tmp = parse_struct_field(parser);
+                if (!tmp) {
+                    return;
+                }
+                l->vartype = tmp;
+                l = tmp;
+            }
         } break;
         default: return;  // Unreachable.
     }
@@ -332,36 +525,39 @@ parse_binary(Parser *parser) {
 
     Node *node;
     switch (prev.kind) {
-        case TOK_ADD: node = node_alloc(NODE_ADD, prev, parser->storage); break;
-        case TOK_SUB: node = node_alloc(NODE_SUB, prev, parser->storage); break;
-        case TOK_MUL: node = node_alloc(NODE_MUL, prev, parser->storage); break;
-        case TOK_DIV: node = node_alloc(NODE_DIV, prev, parser->storage); break;
-        case TOK_MOD: node = node_alloc(NODE_MOD, prev, parser->storage); break;
-        case TOK_AND: node = node_alloc(NODE_AND, prev, parser->storage); break;
-        case TOK_OR: node = node_alloc(NODE_OR, prev, parser->storage); break;
-        case TOK_EQ: node = node_alloc(NODE_EQ, prev, parser->storage); break;
-        case TOK_NEQ: node = node_alloc(NODE_NEQ, prev, parser->storage); break;
-        case TOK_LT: node = node_alloc(NODE_LT, prev, parser->storage); break;
-        case TOK_GT: node = node_alloc(NODE_GT, prev, parser->storage); break;
-        case TOK_LE: node = node_alloc(NODE_LE, prev, parser->storage); break;
-        case TOK_GE: node = node_alloc(NODE_GE, prev, parser->storage); break;
+        case TOK_ADD: node = node_alloc(NODE_ADD, prev, parser); break;
+        case TOK_SUB: node = node_alloc(NODE_SUB, prev, parser); break;
+        case TOK_MUL: node = node_alloc(NODE_MUL, prev, parser); break;
+        case TOK_DIV: node = node_alloc(NODE_DIV, prev, parser); break;
+        case TOK_MOD: node = node_alloc(NODE_MOD, prev, parser); break;
+        case TOK_AND: node = node_alloc(NODE_AND, prev, parser); break;
+        case TOK_OR: node = node_alloc(NODE_OR, prev, parser); break;
+        case TOK_EQ: node = node_alloc(NODE_EQ, prev, parser); break;
+        case TOK_NEQ: node = node_alloc(NODE_NEQ, prev, parser); break;
+        case TOK_LT: node = node_alloc(NODE_LT, prev, parser); break;
+        case TOK_GT: node = node_alloc(NODE_GT, prev, parser); break;
+        case TOK_LE: node = node_alloc(NODE_LE, prev, parser); break;
+        case TOK_GE: node = node_alloc(NODE_GE, prev, parser); break;
         case TOK_BITAND: {
-            node = node_alloc(NODE_BITAND, prev, parser->storage);
+            node = node_alloc(NODE_BITAND, prev, parser);
         } break;
         case TOK_BITOR: {
-            node = node_alloc(NODE_BITOR, prev, parser->storage);
+            node = node_alloc(NODE_BITOR, prev, parser);
         } break;
         case TOK_BITLSHIFT: {
-            node = node_alloc(NODE_BITLSHIFT, prev, parser->storage);
+            node = node_alloc(NODE_BITLSHIFT, prev, parser);
         } break;
         case TOK_BITRSHIFT: {
-            node = node_alloc(NODE_BITRSHIFT, prev, parser->storage);
+            node = node_alloc(NODE_BITRSHIFT, prev, parser);
         } break;
         default: {
             parse_emit_err(parser, prev, cstr("unreachable"));
             return;
         }
     }
+    if (!node) {
+        return;
+    }
     node->right = array_pop(parser->nodes);
     node->left = array_pop(parser->nodes);
     array_push(parser->nodes, node, parser->storage);
@@ -379,15 +575,24 @@ parse_number(Parser *parser) {
         case TOK_NUM_INT: {
             if (str_has_prefix(prev.val, cstr("0x")) ||
                 str_has_prefix(prev.val, cstr("0b"))) {
-                node = node_alloc(NODE_NUM_UINT, prev, parser->storage);
+                node = node_alloc(NODE_NUM_UINT, prev, parser);
+                if (!node) {
+                    return;
+                }
                 node->value.u = str_to_uint(prev.val);
             } else {
-                node = node_alloc(NODE_NUM_INT, prev, parser->storage);
+                node = node_alloc(NODE_NUM_INT, prev, parser);
+                if (!node) {
+                    return;
+                }
                 node->value.i = str_to_int(prev.val);
             }
         } break;
         case TOK_NUM_FLOAT: {
-            node = node_alloc(NODE_NUM_FLOAT, prev, parser->storage);
+            node = node_alloc(NODE_NUM_FLOAT, prev, parser);
+            if (!node) {
+                return;
+            }
             node->value.d = str_to_float(prev.val);
         } break;
         default: break;
@@ -402,7 +607,10 @@ parse_string(Parser *parser) {
     print("parsing string ");
     print_token(prev);
 #endif
-    Node *node = node_alloc(NODE_STRING, prev, parser->storage);
+    Node *node = node_alloc(NODE_STRING, prev, parser);
+    if (!node) {
+        return;
+    }
     node->value.str = str_remove_prefix(prev.val, cstr("\""));
     node->value.str = str_remove_suffix(node->value.str, cstr("\""));
     array_push(parser->nodes, node, parser->storage);
@@ -412,15 +620,39 @@ void
 parse_symbol(Parser *parser) {
     Token prev = parser->previous;
 #if DEBUG == 1
-    print("parsing string ");
+    print("parsing symbol ");
     print_token(prev);
 #endif
-    Node *node = node_alloc(NODE_STRING, prev, parser->storage);
+    Node *node = node_alloc(NODE_SYMBOL, prev, parser);
+    if (!node) {
+        return;
+    }
     node->value.sym = prev.val;
     array_push(parser->nodes, node, parser->storage);
 }
 
 void
+parse_symbol_chain(Parser *parser) {
+    Token prev = parser->previous;
+#if DEBUG == 1
+    print("parsing symbol ");
+    print_token(prev);
+#endif
+    Node *node = node_alloc(NODE_SYMBOL, prev, parser);
+    if (!node) {
+        return;
+    }
+    node->value.sym = prev.val;
+    if (parse_match(parser, TOK_DOT)) {
+        parse_consume(parser, TOK_SYMBOL,
+                      cstr("expected symbol after '.' operator"));
+        parse_symbol_chain(parser);
+        node->varname = array_pop(parser->nodes);
+    }
+    array_push(parser->nodes, node, parser->storage);
+}
+
+void
 parse_grouping(Parser *parser) {
 #if DEBUG == 1
     print("parsing group  ");
@@ -436,23 +668,24 @@ graph_node(Node *node) {
         return;
     }
     print("%d [width=2.5,shape=Mrecord,label=\"", node->id);
-    print("<top> %s ", node_str[node->kind]);
+    print("{ %s | { L: %d | C: %d } } ", node_str[node->kind], node->line,
+          node->col);
     switch (node->kind) {
         case NODE_NUM_INT: print("| Value: %d", node->value.i); break;
         case NODE_NUM_UINT: print("| Value: %x", node->value.u); break;
         case NODE_NUM_FLOAT: print("| Value: %f{2}", node->value.d); break;
         case NODE_STRING: print("| Value: %s", node->value.str); break;
         case NODE_SYMBOL: print("| Value: %s", node->value.sym); break;
+        case NODE_NODE_TYPE: print("| Value: %s", node->value.sym); break;
         default: break;
     }
-    print("| Line: %d | Col: %d ", node->line, node->col);
     println("\"];");
     if (node->left) {
-        println("%d:top:e->%d:top:w;", node->id, node->left->id);
+        println("%d:e->%d:w;", node->id, node->left->id);
         graph_node(node->left);
     }
     if (node->right) {
-        println("%d:top:e->%d:top:w;", node->id, node->right->id);
+        println("%d:e->%d:w;", node->id, node->right->id);
         graph_node(node->right);
     }
 }
@@ -516,7 +749,14 @@ process_file(Str path) {
     array_init(parser.nodes, 256, parser.storage);
     parse_advance(&parser);
     while (parser.current.kind != TOK_EOF) {
+#if DEBUG == 1
+        static sz ctr = 0;
+        println("parsing root: %d", ctr++);
+#endif
         parse_expr(&parser, PREC_LOW);
+        if (parser.panic) {
+            break;
+        }
     }
     if (parser.err) {
         goto stop;