Add `cond` conditionals

2 files changed, 58 insertions, 33 deletions

diff --git a/src/main.c b/src/main.c
index f73c7cc..68ad857 100644
--- a/src/main.c
+++ b/src/main.c
@@ -641,6 +641,28 @@ parse_keyword(Parser *parser) {
                 array_push(node->struct_field, field, parser->storage);
             }
         } break;
+        case TOK_COND: {
+            node = node_alloc(parser, NODE_COND, prev);
+            if (!node) return;
+            parse_consume(parser, TOK_LCURLY,
+                          cstr("expected '{' on cond expression"));
+            while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
+                Node *tmp = node_alloc(parser, NODE_CASE, parser->previous);
+                if (!tmp) return;
+                // Are we on the default case.
+                if (!parse_match(parser, TOK_ELSE)) {
+                    parse_consume(parser, TOK_CASE,
+                                  cstr("expected case statement"));
+                    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);
+            }
+        } break;
         default: return;  // Unreachable.
     }
     array_push(parser->nodes, node, parser->storage);
@@ -847,6 +869,7 @@ graph_node(Node *node) {
     println("\"];");
 
     switch (node->kind) {
+        case NODE_COND:
         case NODE_MATCH: {
             if (node->match_expr) {
                 println("%d:e->%d:w;", node->id, node->match_expr->id);
diff --git a/tests/conditionals.bad b/tests/conditionals.bad
index 44467a8..856ac8a 100644
--- a/tests/conditionals.bad
+++ b/tests/conditionals.bad
@@ -1,36 +1,30 @@
-; ; Basic if expressions.
-; if true "hello"
-
-; ; These can produce values and the result bound to a name.
-; let a = if (2 + 2 >= 4) 42
-
-; ; We support a single if expression.
-; let b = if 0xff == 255 "hello" else "world"
-
-; ; ... but these can compound on each other
-; if 1 < 2        6
-; else if 1 > 2   7
-; else            8
-
-; ; A block is an expression, and if raise the scope level regardless if a block
-; ; is used or not.
-; if true != false {
-;     let a = "yo"
-; }
-
-; ; Match cases should only apply to literal values, for example `case 1 + 2`
-; ; isn't allowed. They should generally convert to a lookup table.
-; match a = {
-;     case 8 = "hello"
-;     case 9 = "world"
-;     else   = "what"
-; }
-
-; cond {
-;     case a == b = "hello"
-;     case a != c = "world"
-;     else        = "what"
-; }
+; Basic if expressions.
+if true "hello"
+
+; These can produce values and the result bound to a name.
+let a = if (2 + 2 >= 4) 42
+
+; We support a single if expression.
+let b = if 0xff == 255 "hello" else "world"
+
+; ... but these can compound on each other
+if 1 < 2        6
+else if 1 > 2   7
+else            8
+
+; A block is an expression, and if raise the scope level regardless if a block
+; is used or not.
+if true != false {
+    let a = "yo"
+}
+
+; Match cases should only apply to literal values, for example `case 1 + 2`
+; isn't allowed. They should generally convert to a lookup table.
+match a = {
+    case 8 = "hello"
+    case 9 = "world"
+    else   = "what"
+}
 
 ; Enums are integers with values that increase automatically or that can be set
 ; with a constexpr.
@@ -48,3 +42,11 @@ match a = {
     case node_add = "subbing something..."
     else          = "default case"
 }
+
+; Conditional `cond` statements are syntactic sugar for a chain of if-else
+; statements.
+let msg:str = cond {
+    case a == b = "hello"
+    case a != c = "world"
+    else        = "what"
+}