1 files changed, 126 insertions, 25 deletions

diff --git a/src/parser.c b/src/parser.c
index b36ddc9..cfbefaf 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -16,9 +16,33 @@ has_next(Parser *parser) {
     return parser->current < array_size(parser->tokens);
 }
 
+bool
+consume_rparen(Parser *parser) {
+    Token tok = next_token(parser);
+    if (tok.type != TOKEN_RPAREN) {
+        push_error(ERR_TYPE_PARSER, ERR_NOT_A_RPAREN, tok.line, tok.col);
+        return false;
+    }
+    return true;
+}
+
+bool
+consume_lparen(Parser *parser) {
+    Token tok = next_token(parser);
+    if (tok.type != TOKEN_LPAREN) {
+        push_error(ERR_TYPE_PARSER, ERR_NOT_A_LPAREN, tok.line, tok.col);
+        return false;
+    }
+    return true;
+}
+
 Node *
 parse_number(Parser *parser) {
     Token tok = next_token(parser);
+    if (tok.type != TOKEN_NUMBER) {
+        push_error(ERR_TYPE_PARSER, ERR_NOT_A_NUMBER, tok.line, tok.col);
+        return NULL;
+    }
 
     bool negative = false;
     int base = 10;
@@ -93,6 +117,10 @@ parse_number(Parser *parser) {
 Node *
 parse_string(Parser *parser) {
     Token tok = next_token(parser);
+    if (tok.type != TOKEN_STRING) {
+        push_error(ERR_TYPE_PARSER, ERR_NOT_A_STRING, tok.line, tok.col);
+        return NULL;
+    }
     Node *node = alloc_node(NODE_STRING);
     node->string = tok.value;
     return node;
@@ -101,14 +129,39 @@ parse_string(Parser *parser) {
 Node *
 parse_symbol(Parser *parser) {
     Token tok = next_token(parser);
+    if (tok.type != TOKEN_SYMBOL) {
+        push_error(ERR_TYPE_PARSER, ERR_NOT_A_SYMBOL, tok.line, tok.col);
+        return NULL;
+    }
     Node *node = alloc_node(NODE_SYMBOL);
     node->string = tok.value;
     return node;
 }
 
 Node *
+parse_type(Parser *parser) {
+    Token tok = next_token(parser);
+    if (tok.type != TOKEN_COLON) {
+        push_error(ERR_TYPE_PARSER, ERR_NOT_A_TYPE, tok.line, tok.col);
+        return NULL;
+    }
+    tok = next_token(parser);
+    if (tok.type != TOKEN_SYMBOL) {
+        push_error(ERR_TYPE_PARSER, ERR_NOT_A_TYPE, tok.line, tok.col);
+        return NULL;
+    }
+    Node *node = alloc_node(NODE_TYPE);
+    node->string = tok.value;
+    return node;
+}
+
+Node *
 parse_bool(Parser *parser) {
     Token tok = next_token(parser);
+    if (!(tok.type == TOKEN_TRUE || tok.type == TOKEN_FALSE)) {
+        push_error(ERR_TYPE_PARSER, ERR_NOT_A_BOOL, tok.line, tok.col);
+        return NULL;
+    }
     Node *node = alloc_node(NODE_BOOL);
     node->boolean = tok.type == TOKEN_TRUE;
     return node;
@@ -138,63 +191,51 @@ parse_builtin(Parser *parser) {
 
 Node *
 parse_def(Parser *parser) {
-    Token op = next_token(parser);
-    Node *symbol = parse_next(parser);
-    if (symbol == NULL || symbol->type != NODE_SYMBOL) {
-        push_error(ERR_TYPE_PARSER, ERR_MALFORMED_EXPR, op.line, op.col);
+    next_token(parser); // Skip keyword.
+
+    Node *symbol = parse_symbol(parser);
+    if (symbol == NULL) {
         return NULL;
     }
 
     // TODO: Making type checking mandatory for now until we introduce
     // type inference.
-    Token next = next_token(parser);
-    if (next.type != TOKEN_COLON) {
-        push_error(ERR_TYPE_PARSER, ERR_MALFORMED_EXPR, op.line, op.col);
-        return NULL;
-    }
-    Token type_name = next_token(parser);
-    if (type_name.type != TOKEN_SYMBOL) {
-        push_error(ERR_TYPE_PARSER, ERR_MALFORMED_EXPR, op.line, op.col);
+    Node *type = parse_type(parser);
+    if (type == NULL) {
         return NULL;
     }
 
     Node *value = parse_next(parser);
     if (value == NULL) {
-        push_error(ERR_TYPE_PARSER, ERR_MALFORMED_EXPR, op.line, op.col);
         return NULL;
     }
 
-    Token end = next_token(parser);
-    if (end.type != TOKEN_RPAREN) {
-        push_error(ERR_TYPE_PARSER, ERR_MALFORMED_EXPR, op.line, op.col);
+    if (!consume_rparen(parser)) {
         return NULL;
     }
 
     Node *node = alloc_node(NODE_DEF);
     node->def.symbol = symbol;
     node->def.value = value;
-    node->def.type = type_name.value;
+    node->def.type = type;
     return node;
 }
 
 Node *
 parse_set(Parser *parser) {
-    Token op = next_token(parser);
-    Node *symbol = parse_next(parser);
-    if (symbol == NULL || symbol->type != NODE_SYMBOL) {
-        push_error(ERR_TYPE_PARSER, ERR_MALFORMED_EXPR, op.line, op.col);
+    next_token(parser); // Skip keyword.
+
+    Node *symbol = parse_symbol(parser);
+    if (symbol == NULL) {
         return NULL;
     }
 
     Node *value = parse_next(parser);
     if (value == NULL) {
-        push_error(ERR_TYPE_PARSER, ERR_MALFORMED_EXPR, op.line, op.col);
         return NULL;
     }
 
-    Token end = next_token(parser);
-    if (end.type != TOKEN_RPAREN) {
-        push_error(ERR_TYPE_PARSER, ERR_MALFORMED_EXPR, op.line, op.col);
+    if (!consume_rparen(parser)) {
         return NULL;
     }
 
@@ -205,6 +246,65 @@ parse_set(Parser *parser) {
 }
 
 Node *
+parse_fun(Parser *parser) {
+    next_token(parser); // Skip keyword.
+
+    Node *name = parse_symbol(parser);
+    if (name == NULL) {
+        return NULL;
+    }
+
+    Node *node = alloc_node(NODE_FUN);
+    node->fun.name = name;
+    array_init(node->fun.param_names, 0);
+    array_init(node->fun.param_types, 0);
+    array_init(node->fun.body, 0);
+
+    // Parse parameter list and return type.
+    if (!consume_lparen(parser)) {
+        return NULL;
+    }
+    while (true) {
+        Token next = peek_token(parser);
+        if (next.type == TOKEN_RPAREN) {
+            next_token(parser);
+            break;
+        }
+        Node *name = parse_symbol(parser);
+        if (name == NULL) {
+            return NULL;
+        }
+        Node *type = parse_type(parser);
+        if (type == NULL) {
+            return NULL;
+        }
+        array_push(node->fun.param_names, name);
+        array_push(node->fun.param_types, type);
+    }
+    Node *ret_type = parse_type(parser);
+    if (ret_type == NULL) {
+        return NULL;
+    }
+    node->fun.return_type = ret_type;
+
+    // Parse body.
+    while (true) {
+        Token next = peek_token(parser);
+        if (next.type == TOKEN_RPAREN) {
+            next_token(parser);
+            break;
+        }
+        Node *expr = parse_next(parser);
+        if (expr == NULL) {
+            return NULL;
+        }
+        array_push(node->fun.body, expr);
+    }
+
+    return node;
+}
+
+Node *
 parse_paren(Parser *parser) {
     next_token(parser); // Skip paren.
     Token tok = peek_token(parser);
@@ -222,6 +322,7 @@ parse_paren(Parser *parser) {
         // Special functions.
         case TOKEN_DEF: { return parse_def(parser); } break;
         case TOKEN_SET: { return parse_set(parser); } break;
+        case TOKEN_FUN: { return parse_fun(parser); } break;
         default: break;
     }