fixing ast_binstore_codegen's lvalue flag setting, now += on entfields works correctly

[xonotic/gmqcc.git] / parser.c

diff --git a/parser.c b/parser.c
index 05c4313f8bb22ff127b2079e57e91104d32cf638..e65eff3fde8425282a74154f3db268fc18ab8f5c 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -62,7 +62,7 @@ void parseerror(parser_t *parser, const char *fmt, ...)
 }
 
 /* returns true if it counts as an error */
-bool parsewarning(parser_t *parser, int warntype, const char *fmt, ...)
+bool GMQCC_WARN parsewarning(parser_t *parser, int warntype, const char *fmt, ...)
 {
        va_list ap;
        int lvl = LVL_WARNING;
@@ -432,13 +432,13 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
 
         case opid1('+'):
             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) {
-                parseerror(parser, "Cannot add type %s and %s",
+                parseerror(parser, "invalid types used in expression: cannot add type %s and %s",
                            type_name[exprs[0]->expression.vtype],
                            type_name[exprs[1]->expression.vtype]);
                 return false;
             }
             if (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) {
-                parseerror(parser, "type error: %s - %s not defined",
+                parseerror(parser, "invalid types used in expression: cannot add type %s and %s",
                            type_name[exprs[0]->expression.vtype],
                            type_name[exprs[1]->expression.vtype]);
                 return false;
@@ -451,7 +451,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
                     out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_V, exprs[0], exprs[1]);
                     break;
                 default:
-                    parseerror(parser, "type error: cannot add type %s to %s",
+                    parseerror(parser, "invalid types used in expression: cannot add type %s and %s",
                                type_name[exprs[0]->expression.vtype],
                                type_name[exprs[1]->expression.vtype]);
                     return false;
@@ -459,13 +459,13 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
             break;
         case opid1('-'):
             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) {
-                parseerror(parser, "type error: cannot subtract type %s from %s",
+                parseerror(parser, "invalid types used in expression: cannot subtract type %s from %s",
                            type_name[exprs[1]->expression.vtype],
                            type_name[exprs[0]->expression.vtype]);
                 return false;
             }
             if (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) {
-                parseerror(parser, "type error: %s - %s not defined",
+                parseerror(parser, "invalid types used in expression: cannot subtract type %s from %s",
                            type_name[exprs[0]->expression.vtype],
                            type_name[exprs[1]->expression.vtype]);
                 return false;
@@ -478,7 +478,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
                     out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V, exprs[0], exprs[1]);
                     break;
                 default:
-                    parseerror(parser, "type error: cannot subtract type %s from %s",
+                    parseerror(parser, "invalid types used in expression: cannot subtract type %s from %s",
                                type_name[exprs[1]->expression.vtype],
                                type_name[exprs[0]->expression.vtype]);
                     return false;
@@ -491,7 +491,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
                 exprs[1]->expression.vtype != TYPE_VECTOR &&
                 exprs[1]->expression.vtype != TYPE_FLOAT)
             {
-                parseerror(parser, "type error: cannot multiply type %s by %s",
+                parseerror(parser, "invalid types used in expression: cannot multiply types %s and %s",
                            type_name[exprs[1]->expression.vtype],
                            type_name[exprs[0]->expression.vtype]);
                 return false;
@@ -510,7 +510,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
                         out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_V, exprs[0], exprs[1]);
                     break;
                 default:
-                    parseerror(parser, "type error: cannot multiplye type %s by %s",
+                    parseerror(parser, "invalid types used in expression: cannot multiply types %s and %s",
                                type_name[exprs[1]->expression.vtype],
                                type_name[exprs[0]->expression.vtype]);
                     return false;
@@ -518,7 +518,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
             break;
         case opid1('/'):
             if (NotSameType(TYPE_FLOAT)) {
-                parseerror(parser, "type error: cannot divide types %s and %s",
+                parseerror(parser, "invalid types used in expression: cannot divide types %s and %s",
                            type_name[exprs[0]->expression.vtype],
                            type_name[exprs[1]->expression.vtype]);
                 return false;
@@ -532,7 +532,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
         case opid1('|'):
         case opid1('&'):
             if (NotSameType(TYPE_FLOAT)) {
-                parseerror(parser, "type error: cannot perform bit operations on types %s and %s",
+                parseerror(parser, "invalid types used in expression: cannot perform bit operations between types %s and %s",
                            type_name[exprs[0]->expression.vtype],
                            type_name[exprs[1]->expression.vtype]);
                 return false;
@@ -557,7 +557,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
         case opid2('&','&'):
             generated_op += INSTR_AND;
             if (NotSameType(TYPE_FLOAT)) {
-                parseerror(parser, "type error: cannot apply logical operation on types %s and %s",
+                parseerror(parser, "invalid types used in expression: cannot perform logical operations between types %s and %s",
                            type_name[exprs[0]->expression.vtype],
                            type_name[exprs[1]->expression.vtype]);
                 parseerror(parser, "TODO: logical ops for arbitrary types using INSTR_NOT");
@@ -578,7 +578,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
         case opid2('<', '='):
             generated_op += INSTR_LE;
             if (NotSameType(TYPE_FLOAT)) {
-                parseerror(parser, "type error: cannot compare types %s and %s",
+                parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s",
                            type_name[exprs[0]->expression.vtype],
                            type_name[exprs[1]->expression.vtype]);
                 return false;
@@ -587,7 +587,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
             break;
         case opid2('!', '='):
             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) {
-                parseerror(parser, "type error: cannot compare types %s and %s",
+                parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s",
                            type_name[exprs[0]->expression.vtype],
                            type_name[exprs[1]->expression.vtype]);
                 return false;
@@ -596,7 +596,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
             break;
         case opid2('=', '='):
             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) {
-                parseerror(parser, "type error: cannot compare types %s and %s",
+                parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s",
                            type_name[exprs[0]->expression.vtype],
                            type_name[exprs[1]->expression.vtype]);
                 return false;
@@ -613,26 +613,30 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
             break;
         case opid2('+','='):
             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) {
-                parseerror(parser, "Cannot add type %s and %s",
+                parseerror(parser, "invalid types used in expression: cannot add type %s and %s",
                            type_name[exprs[0]->expression.vtype],
                            type_name[exprs[1]->expression.vtype]);
                 return false;
             }
             if (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) {
-                parseerror(parser, "type error: %s - %s not defined",
+                parseerror(parser, "invalid types used in expression: cannot add type %s and %s",
                            type_name[exprs[0]->expression.vtype],
                            type_name[exprs[1]->expression.vtype]);
                 return false;
             }
+            if (ast_istype(exprs[0], ast_entfield))
+                assignop = type_storep_instr[exprs[0]->expression.vtype];
+            else
+                assignop = type_store_instr[exprs[0]->expression.vtype];
             switch (exprs[0]->expression.vtype) {
                 case TYPE_FLOAT:
-                    out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_F, exprs[0], exprs[1]);
+                    out = (ast_expression*)ast_binstore_new(ctx, assignop, INSTR_ADD_F, exprs[0], exprs[1]);
                     break;
                 case TYPE_VECTOR:
-                    out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_V, exprs[0], exprs[1]);
+                    out = (ast_expression*)ast_binstore_new(ctx, assignop, INSTR_ADD_V, exprs[0], exprs[1]);
                     break;
                 default:
-                    parseerror(parser, "type error: cannot add type %s to %s",
+                    parseerror(parser, "invalid types used in expression: cannot add type %s and %s",
                                type_name[exprs[0]->expression.vtype],
                                type_name[exprs[1]->expression.vtype]);
                     return false;
@@ -1114,6 +1118,74 @@ static bool parser_parse_while(parser_t *parser, ast_block *block, ast_expressio
     return true;
 }
 
+static bool parser_parse_dowhile(parser_t *parser, ast_block *block, ast_expression **out)
+{
+    ast_loop *aloop;
+    ast_expression *cond, *ontrue;
+
+    lex_ctx ctx = parser_ctx(parser);
+
+    /* skip the 'do' and get the body */
+    if (!parser_next(parser)) {
+        parseerror(parser, "expected loop body");
+        return false;
+    }
+    ontrue = parser_parse_statement_or_block(parser);
+    if (!ontrue)
+        return false;
+
+    /* expect the "while" */
+    if (parser->tok != TOKEN_KEYWORD ||
+        strcmp(parser_tokval(parser), "while"))
+    {
+        parseerror(parser, "expected 'while' and condition");
+        ast_delete(ontrue);
+        return false;
+    }
+
+    /* skip the 'while' and check for opening paren */
+    if (!parser_next(parser) || parser->tok != '(') {
+        parseerror(parser, "expected 'while' condition in parenthesis");
+        ast_delete(ontrue);
+        return false;
+    }
+    /* parse into the expression */
+    if (!parser_next(parser)) {
+        parseerror(parser, "expected 'while' condition after opening paren");
+        ast_delete(ontrue);
+        return false;
+    }
+    /* parse the condition */
+    cond = parser_expression_leave(parser);
+    if (!cond)
+        return false;
+    /* closing paren */
+    if (parser->tok != ')') {
+        parseerror(parser, "expected closing paren after 'while' condition");
+        ast_delete(ontrue);
+        ast_delete(cond);
+        return false;
+    }
+    /* parse on */
+    if (!parser_next(parser) || parser->tok != ';') {
+        parseerror(parser, "expected semicolon after condition");
+        ast_delete(ontrue);
+        ast_delete(cond);
+        return false;
+    }
+
+    if (!parser_next(parser)) {
+        parseerror(parser, "parse error");
+        ast_delete(ontrue);
+        ast_delete(cond);
+        return false;
+    }
+
+    aloop = ast_loop_new(ctx, NULL, NULL, cond, NULL, ontrue);
+    *out = (ast_expression*)aloop;
+    return true;
+}
+
 static bool parser_parse_for(parser_t *parser, ast_block *block, ast_expression **out)
 {
     ast_loop *aloop;
@@ -1172,11 +1244,9 @@ static bool parser_parse_for(parser_t *parser, ast_block *block, ast_expression
 
     /* parse the condition */
     if (parser->tok != ';') {
-        printf("going cond!\n");
         cond = parser_expression_leave(parser);
         if (!cond)
             goto onerr;
-        printf("going cond!\n");
     }
 
     /* move on to incrementor */
@@ -1237,6 +1307,10 @@ static bool parser_parse_statement(parser_t *parser, ast_block *block, ast_expre
             parseerror(parser, "cannot declare a variable from here");
             return false;
         }
+        if (opts_standard == COMPILER_QCC) {
+            if (parsewarning(parser, WARN_EXTENSIONS, "missing 'local' keyword when declaring a local variable"))
+                return false;
+        }
         if (!parser_variable(parser, block))
             return false;
         *out = NULL;
@@ -1244,7 +1318,22 @@ static bool parser_parse_statement(parser_t *parser, ast_block *block, ast_expre
     }
     else if (parser->tok == TOKEN_KEYWORD)
     {
-        if (!strcmp(parser_tokval(parser), "return"))
+        if (!strcmp(parser_tokval(parser), "local"))
+        {
+            if (!block) {
+                parseerror(parser, "cannot declare a local variable here");
+                return false;
+            }
+            if (!parser_next(parser)) {
+                parseerror(parser, "expected variable declaration");
+                return false;
+            }
+            if (!parser_variable(parser, block))
+                return false;
+            *out = NULL;
+            return true;
+        }
+        else if (!strcmp(parser_tokval(parser), "return"))
         {
             ast_expression *exp = NULL;
             ast_return     *ret = NULL;
@@ -1287,8 +1376,16 @@ static bool parser_parse_statement(parser_t *parser, ast_block *block, ast_expre
         {
             return parser_parse_while(parser, block, out);
         }
+        else if (!strcmp(parser_tokval(parser), "do"))
+        {
+            return parser_parse_dowhile(parser, block, out);
+        }
         else if (!strcmp(parser_tokval(parser), "for"))
         {
+            if (opts_standard == COMPILER_QCC) {
+                if (parsewarning(parser, WARN_EXTENSIONS, "for loops are not recognized in the original Quake C standard, to enable try an alternate standard --std=?"))
+                    return false;
+            }
             return parser_parse_for(parser, block, out);
         }
         parseerror(parser, "Unexpected keyword");
@@ -1483,7 +1580,7 @@ static bool parser_variable(parser_t *parser, ast_block *localblock)
             if (proto) {
                 if (!ast_compare_type((ast_expression*)proto, (ast_expression*)fval)) {
                     parseerror(parser, "prototype declared at %s:%i had a different type",
-                               ast_ctx(fval).file, ast_ctx(fval).line);
+                               ast_ctx(proto).file, ast_ctx(proto).line);
                     ast_function_delete(func);
                     ast_value_delete(fval);
                     return false;
@@ -1622,6 +1719,11 @@ static bool parser_variable(parser_t *parser, ast_block *localblock)
                 ast_block_delete(block);
                 return false;
             }
+
+            if (parser->tok == ';')
+                return parser_next(parser) || parser->tok == TOKEN_EOF;
+            else if (opts_standard == COMPILER_QCC)
+                parseerror(parser, "missing semicolon after function body (mandatory with -std=qcc)");
             return true;
         } else {
             parseerror(parser, "TODO, const assignment");
@@ -1918,7 +2020,8 @@ bool parser_finish(const char *output)
             }
         }
 
-        ir_builder_dump(ir, printf);
+        if (opts_dump)
+            ir_builder_dump(ir, printf);
 
         if (!ir_builder_generate(ir, output)) {
             printf("*** failed to generate output file\n");