Add parsing for match-case statements

1 files changed, 55 insertions, 4 deletions

diff --git a/src/main.c b/src/main.c
index 0679558..1bb5ff6 100644
--- a/src/main.c
+++ b/src/main.c
@@ -76,6 +76,8 @@ typedef enum NodeKind {
     NODE_SET,
     NODE_STRUCT,
     NODE_IF,
+    NODE_MATCH,
+    NODE_CASE,
     // Helpers.
     NODE_SYMBOL_IDX,
     NODE_TYPE,
@@ -123,6 +125,8 @@ Str node_str[] = {
     [NODE_SET] = cstr("SET"),
     [NODE_STRUCT] = cstr("STRUCT DEF"),
     [NODE_IF] = cstr("IF"),
+    [NODE_MATCH] = cstr("MATCH"),
+    [NODE_CASE] = cstr("CASE"),
     // Helpers.
     [NODE_TYPE] = cstr("TYPE"),
     [NODE_ARR_TYPE] = cstr("TYPE (ARR)"),
@@ -169,6 +173,14 @@ typedef struct Node {
             struct Node *field_type;
             struct Node *field_val;
         };
+        struct {
+            struct Node *match_expr;
+            struct Node **match_cases;
+        };
+        struct {
+            struct Node *case_value;
+            struct Node *case_expr;
+        };
         struct Node **struct_field;
         struct Node **elements;
         struct Node **statements;
@@ -280,7 +292,6 @@ ParseRule parse_rules[] = {
     [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},
@@ -345,11 +356,11 @@ parse_consume(Parser *parser, TokenKind kind, Str msg) {
     parse_emit_err(parser, parser->current, msg);
 }
 
-void 
+void
 parse_block(Parser *parser) {
 #if DEBUG == 1
     print("parsing block ");
-    print_token(prev);
+    print_token(parser->previous);
 #endif
     Node *block = node_alloc(parser, NODE_BLOCK, parser->previous);
     if (!block) return;
@@ -563,6 +574,34 @@ parse_keyword(Parser *parser) {
                 node->cond_else = array_pop(parser->nodes);
             }
         } break;
+        case TOK_MATCH: {
+            node = node_alloc(parser, NODE_MATCH, prev);
+            if (!node) return;
+            parse_expr(parser, PREC_LOW);
+            node->match_expr = array_pop(parser->nodes);
+            parse_consume(parser, TOK_LCURLY,
+                          cstr("expected block of match cases"));
+            while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
+                parse_consume(parser, TOK_CASE,
+                              cstr("expected case statement"));
+                Node *tmp = node_alloc(parser, NODE_CASE, parser->previous);
+                if (!tmp) return;
+                // Are we on the default case.
+                if (!parse_match(parser, TOK_ASSIGN)) {
+                    parse_expr(parser, PREC_LOW);
+                    tmp->case_value = array_pop(parser->nodes);
+                    parse_consume(parser, TOK_ASSIGN,
+                                  cstr("malformed case statement"));
+                }
+                parse_expr(parser, PREC_LOW);
+                tmp->case_expr = array_pop(parser->nodes);
+                array_push(node->match_cases, tmp, parser->storage);
+            }
+            // TODO: Check that we only have literals on the match case, this
+            // could be done on the analysis step, but also here...
+            // TODO: Check that there are no multiple default or duplicated
+            // cases.
+        } break;
         default: return;  // Unreachable.
     }
     array_push(parser->nodes, node, parser->storage);
@@ -770,6 +809,17 @@ graph_node(Node *node) {
     println("\"];");
 
     switch (node->kind) {
+        case NODE_MATCH: {
+            if (node->match_expr) {
+                println("%d:e->%d:w;", node->id, node->match_expr->id);
+                graph_node(node->match_expr);
+            }
+            for (sz i = 0; i < array_size(node->match_cases); i++) {
+                Node *next = node->match_cases[i];
+                println("%d:e->%d:w;", node->id, next->id);
+                graph_node(next);
+            }
+        } break;
         case NODE_BLOCK:
         case NODE_STRUCT_LIT:
         case NODE_COMPOUND_TYPE: {
@@ -929,7 +979,8 @@ print_usage(void) {
     printf("\n");
     printf("\t-h \t\tShow usage.\n");
     printf(
-        "\t-p [l|p|s|t]\tPrint mode for [l]exing, [p]arsing, [s]emantic "
+        "\t-p [l|p|s|t]\tPrint mode for [l]exing, [p]arsing, "
+        "[s]emantic "
         "analysis, symbol [t]ables\n");
     printf("\n");
 }