-_- file->filename

[xonotic/gmqcc.git] / parser.c

diff --git a/parser.c b/parser.c
index f45bfdca8728489141a361481d0c792b86d3c643..aa172166c95af0da8c55f61dbe9c432e68c68273 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -45,8 +45,8 @@ static void parser_pop_local(parser_t *parser);
 static bool parser_variable(parser_t *parser, ast_block *localblock);
 static ast_block* parser_parse_block(parser_t *parser);
 static ast_expression* parser_parse_statement_or_block(parser_t *parser);
-static ast_expression* parser_expression_leave(parser_t *parser);
-static ast_expression* parser_expression(parser_t *parser);
+static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomma);
+static ast_expression* parser_expression(parser_t *parser, bool stopatcomma);
 
 void parseerror(parser_t *parser, const char *fmt, ...)
 {
@@ -226,6 +226,8 @@ ast_expression* parser_find_local(parser_t *parser, const char *name, size_t upt
         if (!strcmp(parser->locals[i].name, name))
             return parser->locals[i].var;
     }
+    if (!parser->function)
+        return NULL;
     fun = parser->function->vtype;
     for (i = 0; i < fun->expression.params_count; ++i) {
         if (!strcmp(fun->expression.params[i]->name, name))
@@ -616,7 +618,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
             if (CanConstFold(exprs[0], exprs[1]))
                 out = (ast_expression*)parser_const_float(parser,
                     (op->id == opid1('|') ? (float)( ((qcint)ConstF(0)) | ((qcint)ConstF(1)) ) :
-                                            (float)( ((qcint)ConstF(0)) | ((qcint)ConstF(1)) ) ));
+                                            (float)( ((qcint)ConstF(0)) & ((qcint)ConstF(1)) ) ));
             else
                 out = (ast_expression*)ast_binary_new(ctx,
                     (op->id == opid1('|') ? INSTR_BITOR : INSTR_BITAND),
@@ -845,7 +847,7 @@ static bool parser_close_paren(parser_t *parser, shunt *sy, bool functions_only)
     return true;
 }
 
-static ast_expression* parser_expression_leave(parser_t *parser)
+static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomma)
 {
     ast_expression *expr = NULL;
     shunt sy;
@@ -1017,6 +1019,11 @@ static ast_expression* parser_expression_leave(parser_t *parser)
                 }
                 /* found an operator */
                 op = &operators[o];
+
+                /* when declaring variables, a comma starts a new variable */
+                if (op->id == opid1(',') && !parens && stopatcomma)
+                    break;
+
                 if (op->id == opid1('.')) {
                     /* for gmqcc standard: open up the namespace of the previous type */
                     ast_expression *prevex = sy.out[sy.out_count-1].out;
@@ -1088,9 +1095,9 @@ onerr:
     return NULL;
 }
 
-static ast_expression* parser_expression(parser_t *parser)
+static ast_expression* parser_expression(parser_t *parser, bool stopatcomma)
 {
-    ast_expression *e = parser_expression_leave(parser);
+    ast_expression *e = parser_expression_leave(parser, stopatcomma);
     if (!e)
         return NULL;
     if (!parser_next(parser)) {
@@ -1118,7 +1125,7 @@ static bool parser_parse_if(parser_t *parser, ast_block *block, ast_expression *
         return false;
     }
     /* parse the condition */
-    cond = parser_expression_leave(parser);
+    cond = parser_expression_leave(parser, false);
     if (!cond)
         return false;
     /* closing paren */
@@ -1178,7 +1185,7 @@ static bool parser_parse_while(parser_t *parser, ast_block *block, ast_expressio
         return false;
     }
     /* parse the condition */
-    cond = parser_expression_leave(parser);
+    cond = parser_expression_leave(parser, false);
     if (!cond)
         return false;
     /* closing paren */
@@ -1242,7 +1249,7 @@ static bool parser_parse_dowhile(parser_t *parser, ast_block *block, ast_express
         return false;
     }
     /* parse the condition */
-    cond = parser_expression_leave(parser);
+    cond = parser_expression_leave(parser, false);
     if (!cond)
         return false;
     /* closing paren */
@@ -1313,7 +1320,7 @@ static bool parser_parse_for(parser_t *parser, ast_block *block, ast_expression
     }
     else if (parser->tok != ';')
     {
-        initexpr = parser_expression_leave(parser);
+        initexpr = parser_expression_leave(parser, false);
         if (!initexpr)
             goto onerr;
     }
@@ -1330,7 +1337,7 @@ static bool parser_parse_for(parser_t *parser, ast_block *block, ast_expression
 
     /* parse the condition */
     if (parser->tok != ';') {
-        cond = parser_expression_leave(parser);
+        cond = parser_expression_leave(parser, false);
         if (!cond)
             goto onerr;
     }
@@ -1347,7 +1354,7 @@ static bool parser_parse_for(parser_t *parser, ast_block *block, ast_expression
 
     /* parse the incrementor */
     if (parser->tok != ')') {
-        increment = parser_expression_leave(parser);
+        increment = parser_expression_leave(parser, false);
         if (!increment)
             goto onerr;
     }
@@ -1431,7 +1438,7 @@ static bool parser_parse_statement(parser_t *parser, ast_block *block, ast_expre
             }
 
             if (parser->tok != ';') {
-                exp = parser_expression(parser);
+                exp = parser_expression(parser, false);
                 if (!exp)
                     return false;
 
@@ -1488,7 +1495,7 @@ static bool parser_parse_statement(parser_t *parser, ast_block *block, ast_expre
     }
     else
     {
-        ast_expression *exp = parser_expression(parser);
+        ast_expression *exp = parser_expression(parser, false);
         if (!exp)
             return false;
         *out = exp;
@@ -1698,12 +1705,12 @@ static bool parser_variable(parser_t *parser, ast_block *localblock)
             vx.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 0);
             vy.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 1);
             vz.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 2);
-            vx.name = mem_a(len+3);
-            vy.name = mem_a(len+3);
-            vz.name = mem_a(len+3);
-            strcpy(vx.name, varent.name);
-            strcpy(vy.name, varent.name);
-            strcpy(vz.name, varent.name);
+            vx.name = (char*)mem_a(len+3);
+            vy.name = (char*)mem_a(len+3);
+            vz.name = (char*)mem_a(len+3);
+            memcpy(vx.name, varent.name, len);
+            memcpy(vy.name, varent.name, len);
+            memcpy(vz.name, varent.name, len);
             vx.name[len] = vy.name[len] = vz.name[len] = '_';
             vx.name[len+1] = 'x';
             vy.name[len+1] = 'y';
@@ -1785,6 +1792,9 @@ static bool parser_variable(parser_t *parser, ast_block *localblock)
             }
 
             func->builtin = -parser_token(parser)->constval.i;
+
+            if (!parser_next(parser))
+                return false;
         } else if (parser->tok == '{') {
             /* function body */
             ast_block *block;
@@ -1813,11 +1823,21 @@ static bool parser_variable(parser_t *parser, ast_block *localblock)
                 parseerror(parser, "missing semicolon after function body (mandatory with -std=qcc)");
             return true;
         } else {
-            parseerror(parser, "TODO, const assignment");
-        }
+            ast_expression *cexp;
+            ast_value      *cval;
 
-        if (!parser_next(parser))
-            return false;
+            cexp = parser_expression_leave(parser, true);
+            cval = (ast_value*)cexp;
+            if (!ast_istype(cval, ast_value) || !cval->isconst)
+                parseerror(parser, "cannot initialize a global constant variable with a non-constant expression");
+            else
+            {
+                var->isconst = true;
+                memcpy(&var->constval, &cval->constval, sizeof(var->constval));
+                memset(&cval->constval, 0, sizeof(cval->constval));
+                ast_unref(cval);
+            }
+        }
 
         if (parser->tok == ',') {
             /* another */
@@ -1825,7 +1845,7 @@ static bool parser_variable(parser_t *parser, ast_block *localblock)
         }
 
         if (parser->tok != ';') {
-            parseerror(parser, "expected semicolon");
+            parseerror(parser, "missing semicolon");
             return false;
         }
 
@@ -1937,12 +1957,12 @@ static bool parser_do(parser_t *parser)
                 vx.var = (ast_expression*)ast_member_new(ast_ctx(fld), (ast_expression*)fld, 0);
                 vy.var = (ast_expression*)ast_member_new(ast_ctx(fld), (ast_expression*)fld, 1);
                 vz.var = (ast_expression*)ast_member_new(ast_ctx(fld), (ast_expression*)fld, 2);
-                vx.name = mem_a(len+3);
-                vy.name = mem_a(len+3);
-                vz.name = mem_a(len+3);
-                strcpy(vx.name, varent.name);
-                strcpy(vy.name, varent.name);
-                strcpy(vz.name, varent.name);
+                vx.name = (char*)mem_a(len+3);
+                vy.name = (char*)mem_a(len+3);
+                vz.name = (char*)mem_a(len+3);
+                memcpy(vx.name, varent.name, len);
+                memcpy(vy.name, varent.name, len);
+                memcpy(vz.name, varent.name, len);
                 vx.name[len] = vy.name[len] = vz.name[len] = '_';
                 vx.name[len+1] = 'x';
                 vy.name[len+1] = 'y';
@@ -1987,10 +2007,7 @@ bool parser_init()
     if (!parser)
         return false;
 
-    memset(parser, 0, sizeof(parser));
-
-    MEM_VECTOR_INIT(parser, globals);
-    MEM_VECTOR_INIT(parser, locals);
+    memset(parser, 0, sizeof(*parser));
     return true;
 }