factoring out the closing-paren handling code since it'll be used recursively

[xonotic/gmqcc.git] / parser.c

diff --git a/parser.c b/parser.c
index 4717e4e2020526b15dad85e72a1dc22ead4536c6..f95e7e087bdfc3784f1a36a493b3cddc57fe9759 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -90,11 +90,17 @@ ast_value* parser_find_global(parser_t *parser, const char *name)
 ast_value* parser_find_local(parser_t *parser, const char *name, size_t upto)
 {
     size_t i;
+    ast_value *fun;
     for (i = parser->locals_count; i > upto;) {
         --i;
         if (!strcmp(parser->locals[i]->name, name))
             return parser->locals[i];
     }
+    fun = parser->function->vtype;
+    for (i = 0; i < fun->params_count; ++i) {
+        if (!strcmp(fun->params[i]->name, name))
+            return fun->params[i];
+    }
     return NULL;
 }
 
@@ -118,6 +124,7 @@ static ast_value *parser_parse_type(parser_t *parser, int basetype, bool *isfunc
     lex_ctx   ctx = parser_ctx(parser);
     int vtype = basetype;
     int temptype;
+    size_t i;
 
     MEM_VECTOR_INIT(&params, p);
 
@@ -129,54 +136,56 @@ static ast_value *parser_parse_type(parser_t *parser, int basetype, bool *isfunc
             ast_value *param;
             bool dummy;
 
-            if (!parser_next(parser)) {
-                MEM_VECTOR_CLEAR(&params, p);
-                return NULL;
-            }
+            if (!parser_next(parser))
+                goto on_error;
 
             if (parser->tok == ')')
                 break;
 
             temptype = parser_token(parser)->constval.t;
-            if (!parser_next(parser)) {
-                MEM_VECTOR_CLEAR(&params, p);
-                return NULL;
-            }
+            if (!parser_next(parser))
+                goto on_error;
+
             param = parser_parse_type(parser, temptype, &dummy);
             (void)dummy;
 
-            if (!param) {
-                MEM_VECTOR_CLEAR(&params, p);
-                return NULL;
+            if (!param)
+                goto on_error;
+
+            if (parser->tok == TOKEN_IDENT) {
+                /* named parameter */
+                if (!ast_value_set_name(param, parser_tokval(parser)))
+                    goto on_error;
+                if (!parser_next(parser))
+                    goto on_error;
             }
 
             if (!paramlist_t_p_add(&params, param)) {
-                MEM_VECTOR_CLEAR(&params, p);
                 parseerror(parser, "Out of memory while parsing typename");
-                return NULL;
+                goto on_error;
             }
 
             if (parser->tok == ',')
                 continue;
             if (parser->tok == ')')
                 break;
-            MEM_VECTOR_CLEAR(&params, p);
             parseerror(parser, "Unexpected token");
-            return NULL;
-        }
-        if (!parser_next(parser)) {
-            MEM_VECTOR_CLEAR(&params, p);
-            return NULL;
+            goto on_error;
         }
+        if (!parser_next(parser))
+            goto on_error;
     }
 
     var = ast_value_new(ctx, "<unnamed>", vtype);
-    if (!var) {
-        MEM_VECTOR_CLEAR(&params, p);
-        return NULL;
-    }
+    if (!var)
+        goto on_error;
     MEM_VECTOR_MOVE(&params, p, var, params);
     return var;
+on_error:
+    for (i = 0; i < params.p_count; ++i)
+        ast_value_delete(params.p[i]);
+    MEM_VECTOR_CLEAR(&params, p);
+    return NULL;
 }
 
 typedef struct
@@ -269,7 +278,6 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
         vars[i]  = sy->out[sy->out_count+i].value;
     }
 
-    printf("Applying operator %s\n", op->op);
     switch (op->id)
     {
         default:
@@ -383,6 +391,27 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
     return true;
 }
 
+static bool parser_close_paren(parser_t *parser, shunt *sy)
+{
+    if (!sy->ops_count) {
+        parseerror(parser, "unmatched closing paren");
+        return false;
+    }
+    if (sy->ops[sy->ops_count-1].paren == 1) {
+        parseerror(parser, "empty parenthesis expression");
+        return false;
+    }
+    while (sy->ops_count) {
+        if (sy->ops[sy->ops_count-1].paren == 1) {
+            sy->ops_count--;
+            break;
+        }
+        if (!parser_sy_pop(parser, sy))
+            return false;
+    }
+    return true;
+}
+
 static ast_expression* parser_expression(parser_t *parser)
 {
     ast_expression *expr = NULL;
@@ -409,7 +438,6 @@ static ast_expression* parser_expression(parser_t *parser)
                     parseerror(parser, "out of memory");
                     goto onerr;
                 }
-                printf("Added: %s\n", var->name);
             }
             else if (parser->tok == TOKEN_FLOATCONST) {
                 ast_value *val = parser_const_float(parser, (parser_token(parser)->constval.f));
@@ -428,7 +456,6 @@ static ast_expression* parser_expression(parser_t *parser)
                     parseerror(parser, "out of memory");
                     goto onerr;
                 }
-                printf("Added: %i\n", parser_token(parser)->constval.i);
             }
             else if (parser->tok == '(') {
                 nextwant = false; /* not expecting an operator next */
@@ -445,26 +472,18 @@ static ast_expression* parser_expression(parser_t *parser)
             wantop = nextwant;
             parser->lex->flags.noops = !wantop;
         } else {
-            if (parser->tok == ')') {
-                /* we do expect an operator next */
-                /* closing an opening paren */
-                printf("Applying closing paren\n");
-                if (!sy.ops_count) {
-                    parseerror(parser, "unmatched closing paren");
+            if (parser->tok == '(') {
+                /* we expected an operator, this is the function-call operator */
+                if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 'f'))) {
+                    parseerror(parser, "out of memory");
                     goto onerr;
                 }
-                if (sy.ops[sy.ops_count-1].paren == 1) {
-                    parseerror(parser, "empty parenthesis expression");
+            }
+            else if (parser->tok == ')') {
+                /* we do expect an operator next */
+                /* closing an opening paren */
+                if (!parser_close_paren(parser, &sy))
                     goto onerr;
-                }
-                while (sy.ops_count) {
-                    if (sy.ops[sy.ops_count-1].paren == 1) {
-                        sy.ops_count--;
-                        break;
-                    }
-                    if (!parser_sy_pop(parser, &sy))
-                        goto onerr;
-                }
             }
             else if (parser->tok != TOKEN_OPERATOR) {
                 parseerror(parser, "expected operator or end of statement");
@@ -506,7 +525,6 @@ static ast_expression* parser_expression(parser_t *parser)
 
                 if (!shunt_ops_add(&sy, syop(parser_ctx(parser), op)))
                     goto onerr;
-                printf("Added op %s\n", op->op);
             }
             wantop = false;
             parser->lex->flags.noops = true;
@@ -515,7 +533,6 @@ static ast_expression* parser_expression(parser_t *parser)
             goto onerr;
         }
         if (parser->tok == ';') {
-            printf("End of statement\n");
             break;
         }
     }
@@ -560,8 +577,15 @@ static bool parser_body_do(parser_t *parser, ast_block *block)
     {
         if (!strcmp(parser_tokval(parser), "return"))
         {
-            ast_expression *exp = parser_expression(parser);
+            ast_expression *exp;
             ast_return *ret;
+
+            if (!parser_next(parser)) {
+                parseerror(parser, "expected return expression");
+                return false;
+            }
+
+            exp = parser_expression(parser);
             if (!exp)
                 return false;
             ret = ast_return_new(exp->expression.node.context, exp);
@@ -575,11 +599,13 @@ static bool parser_body_do(parser_t *parser, ast_block *block)
             }
             return true;
         }
+        parseerror(parser, "Unexpected keyword");
+        return false;
     }
     else if (parser->tok == '{')
     {
         /* a block */
-        parseerror(parser, "TODO: inner blocks");
+        parseerror(parser, "TODO: inner blocks: %s", parser_tokval(parser));
         return false;
     }
     else