ast_block_collect: add to ast_block->collect and set the node's .keep=true, those...

[xonotic/gmqcc.git] / parser.c

diff --git a/parser.c b/parser.c
index 4105ce75ce47daa91e0abc350bc1fc6a088d6640..1d9ae74577f9b9063f6d22c6d81da788b406f5c3 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -60,8 +60,6 @@ void parseerror(parser_t *parser, const char *fmt, ...)
        va_start(ap, fmt);
     vprintmsg(LVL_ERROR, parser->lex->tok->ctx.file, parser->lex->tok->ctx.line, "parse error", fmt, ap);
        va_end(ap);
-
-       printf("\n");
 }
 
 /* returns true if it counts as an error */
@@ -73,7 +71,7 @@ bool GMQCC_WARN parsewarning(parser_t *parser, int warntype, const char *fmt, ..
     if (!OPTS_WARN(warntype))
         return false;
 
-    if (OPTS_WARN(WARN_ERROR)) {
+    if (opts_werror) {
            parser->errors++;
            lvl = LVL_ERROR;
        }
@@ -82,7 +80,7 @@ bool GMQCC_WARN parsewarning(parser_t *parser, int warntype, const char *fmt, ..
     vprintmsg(lvl, parser->lex->tok->ctx.file, parser->lex->tok->ctx.line, "warning", fmt, ap);
        va_end(ap);
 
-       return OPTS_WARN(WARN_ERROR);
+       return opts_werror;
 }
 
 /**********************************************************************
@@ -171,6 +169,17 @@ ast_value* parser_const_float_0(parser_t *parser)
     return parser->imm_float_zero;
 }
 
+char *parser_strdup(const char *str)
+{
+    if (str && !*str) {
+        /* actually dup empty strings */
+        char *out = mem_a(1);
+        *out = 0;
+        return out;
+    }
+    return util_strdup(str);
+}
+
 ast_value* parser_const_string(parser_t *parser, const char *str)
 {
     size_t i;
@@ -181,7 +190,7 @@ ast_value* parser_const_string(parser_t *parser, const char *str)
     }
     out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_STRING);
     out->isconst = true;
-    out->constval.vstring = util_strdup(str);
+    out->constval.vstring = parser_strdup(str);
     if (!parser_t_imm_string_add(parser, out)) {
         ast_value_delete(out);
         return NULL;
@@ -910,7 +919,7 @@ static bool parser_close_call(parser_t *parser, shunt *sy)
     sy->out[fid] = syexp(call->expression.node.context, (ast_expression*)call);
 
     if (fun->expression.vtype != TYPE_FUNCTION) {
-        parseerror(parser, "not a function");
+        parseerror(parser, "not a function (%s)", type_name[fun->expression.vtype]);
         return false;
     }
 
@@ -1101,23 +1110,8 @@ static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomm
                                 parser_token(parser)->constval.v.z));
         }
         else if (parser->tok == '(') {
-            if (wantop) {
-                DEBUGSHUNTDO(printf("push (\n"));
-                ++parens;
-                /* we expected an operator, this is the function-call operator */
-                if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 'f', sy.out_count-1))) {
-                    parseerror(parser, "out of memory");
-                    goto onerr;
-                }
-            } else {
-                ++parens;
-                if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 1, 0))) {
-                    parseerror(parser, "out of memory");
-                    goto onerr;
-                }
-                DEBUGSHUNTDO(printf("push (\n"));
-            }
-            wantop = false;
+            parseerror(parser, "internal error: '(' should be classified as operator");
+            goto onerr;
         }
         else if (parser->tok == ')') {
             if (wantop) {
@@ -1162,7 +1156,6 @@ static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomm
                     break;
                 }
             }
-            wantop = false;
             if (o == operator_count) {
                 /* no operator found... must be the end of the statement */
                 break;
@@ -1207,9 +1200,30 @@ static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomm
                     olast = NULL;
             }
 
-            DEBUGSHUNTDO(printf("push operator %s\n", op->op));
-            if (!shunt_ops_add(&sy, syop(parser_ctx(parser), op)))
-                goto onerr;
+            if (op->id == opid1('(')) {
+                if (wantop) {
+                    DEBUGSHUNTDO(printf("push (\n"));
+                    ++parens;
+                    /* we expected an operator, this is the function-call operator */
+                    if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 'f', sy.out_count-1))) {
+                        parseerror(parser, "out of memory");
+                        goto onerr;
+                    }
+                } else {
+                    ++parens;
+                    if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 1, 0))) {
+                        parseerror(parser, "out of memory");
+                        goto onerr;
+                    }
+                    DEBUGSHUNTDO(printf("push (\n"));
+                }
+                wantop = false;
+            } else {
+                DEBUGSHUNTDO(printf("push operator %s\n", op->op));
+                if (!shunt_ops_add(&sy, syop(parser_ctx(parser), op)))
+                    goto onerr;
+                wantop = false;
+            }
         }
         if (!parser_next(parser)) {
             goto onerr;
@@ -1874,6 +1888,18 @@ static bool parser_variable(parser_t *parser, ast_block *localblock)
                 (void)!parser_t_locals_add(parser, vx);
                 (void)!parser_t_locals_add(parser, vy);
                 (void)!parser_t_locals_add(parser, vz);
+                if (!ast_block_locals_add(localblock, var) ||
+                    !ast_block_collect(localblock, vx.var) ||
+                    !ast_block_collect(localblock, vy.var) ||
+                    !ast_block_collect(localblock, vz.var))
+                {
+                    parser_pop_local(parser);
+                    parser_pop_local(parser);
+                    parser_pop_local(parser);
+                    parser_pop_local(parser);
+                    ast_value_delete(var);
+                    return false;
+                }
             }
         }
         else
@@ -1884,12 +1910,12 @@ static bool parser_variable(parser_t *parser, ast_block *localblock)
                 ast_value_delete(var);
                 return false;
             }
-        }
-        if (localblock && !ast_block_locals_add(localblock, var))
-        {
-            parser_pop_local(parser);
-            ast_value_delete(var);
-            return false;
+            if (localblock && !ast_block_locals_add(localblock, var))
+            {
+                parser_pop_local(parser);
+                ast_value_delete(var);
+                return false;
+            }
         }
 
         if (!parser_next(parser)) {
@@ -2160,6 +2186,13 @@ nextfield:
 
         return true;
     }
+    else if (parser->tok == '$')
+    {
+        if (!parser_next(parser)) {
+            parseerror(parser, "parse error");
+            return false;
+        }
+    }
     else
     {
         parseerror(parser, "unexpected token: %s", parser->lex->tok->value);
@@ -2227,11 +2260,21 @@ void parser_cleanup()
     for (i = 0; i < parser->imm_float_count; ++i) {
         ast_delete(parser->imm_float[i]);
     }
+    for (i = 0; i < parser->fields_count; ++i) {
+        ast_delete(parser->fields[i].var);
+        mem_d(parser->fields[i].name);
+    }
     for (i = 0; i < parser->globals_count; ++i) {
         ast_delete(parser->globals[i].var);
         mem_d(parser->globals[i].name);
     }
+    MEM_VECTOR_CLEAR(parser, functions);
+    MEM_VECTOR_CLEAR(parser, imm_vector);
+    MEM_VECTOR_CLEAR(parser, imm_string);
+    MEM_VECTOR_CLEAR(parser, imm_float);
     MEM_VECTOR_CLEAR(parser, globals);
+    MEM_VECTOR_CLEAR(parser, fields);
+    MEM_VECTOR_CLEAR(parser, locals);
 
     mem_d(parser);
 }