-_- file->filename

[xonotic/gmqcc.git] / parser.c

diff --git a/parser.c b/parser.c
index 4b09b4546ba2c917b2ad97ec386621a22f510913..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))
@@ -433,6 +435,8 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
 #define CanConstFold(A, B)                                                \
              (ast_istype((A), ast_value) && ast_istype((B), ast_value) && \
               ((ast_value*)(A))->isconst && ((ast_value*)(B))->isconst)
+#define ConstV(i) (asvalue[(i)]->constval.vvec)
+#define ConstF(i) (asvalue[(i)]->constval.vfloat)
     switch (op->id)
     {
         default:
@@ -488,18 +492,14 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
                 case TYPE_FLOAT:
                     if (CanConstFold(exprs[0], exprs[1]))
                     {
-                        out = (ast_expression*)parser_const_float(parser,
-                            asvalue[0]->constval.vfloat + asvalue[1]->constval.vfloat);
+                        out = (ast_expression*)parser_const_float(parser, ConstF(0) + ConstF(1));
                     }
                     else
                         out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_F, exprs[0], exprs[1]);
                     break;
                 case TYPE_VECTOR:
                     if (CanConstFold(exprs[0], exprs[1]))
-                    {
-                        out = (ast_expression*)parser_const_vector(parser,
-                            vec3_add(asvalue[0]->constval.vvec, asvalue[1]->constval.vvec));
-                    }
+                        out = (ast_expression*)parser_const_vector(parser, vec3_add(ConstV(0), ConstV(1)));
                     else
                         out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_V, exprs[0], exprs[1]);
                     break;
@@ -522,19 +522,13 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
             switch (exprs[0]->expression.vtype) {
                 case TYPE_FLOAT:
                     if (CanConstFold(exprs[0], exprs[1]))
-                    {
-                        out = (ast_expression*)parser_const_float(parser,
-                            asvalue[0]->constval.vfloat - asvalue[1]->constval.vfloat);
-                    }
+                        out = (ast_expression*)parser_const_float(parser, ConstF(0) - ConstF(1));
                     else
                         out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F, exprs[0], exprs[1]);
                     break;
                 case TYPE_VECTOR:
                     if (CanConstFold(exprs[0], exprs[1]))
-                    {
-                        out = (ast_expression*)parser_const_vector(parser,
-                            vec3_sub(asvalue[0]->constval.vvec, asvalue[1]->constval.vvec));
-                    }
+                        out = (ast_expression*)parser_const_vector(parser, vec3_sub(ConstV(0), ConstV(1)));
                     else
                         out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V, exprs[0], exprs[1]);
                     break;
@@ -562,16 +556,14 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
                     if (exprs[1]->expression.vtype == TYPE_VECTOR)
                     {
                         if (CanConstFold(exprs[0], exprs[1]))
-                            out = (ast_expression*)parser_const_vector(parser,
-                                vec3_mulvf(asvalue[1]->constval.vvec, asvalue[0]->constval.vfloat));
+                            out = (ast_expression*)parser_const_vector(parser, vec3_mulvf(ConstV(1), ConstF(0)));
                         else
                             out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_FV, exprs[0], exprs[1]);
                     }
                     else
                     {
                         if (CanConstFold(exprs[0], exprs[1]))
-                            out = (ast_expression*)parser_const_float(parser,
-                                asvalue[0]->constval.vfloat * asvalue[1]->constval.vfloat);
+                            out = (ast_expression*)parser_const_float(parser, ConstF(0) * ConstF(1));
                         else
                             out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, exprs[0], exprs[1]);
                     }
@@ -580,16 +572,14 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
                     if (exprs[1]->expression.vtype == TYPE_FLOAT)
                     {
                         if (CanConstFold(exprs[0], exprs[1]))
-                            out = (ast_expression*)parser_const_vector(parser,
-                                vec3_mulvf(asvalue[0]->constval.vvec, asvalue[1]->constval.vfloat));
+                            out = (ast_expression*)parser_const_vector(parser, vec3_mulvf(ConstV(0), ConstF(1)));
                         else
                             out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_VF, exprs[0], exprs[1]);
                     }
                     else
                     {
                         if (CanConstFold(exprs[0], exprs[1]))
-                            out = (ast_expression*)parser_const_float(parser,
-                                vec3_mulvv(asvalue[0]->constval.vvec, asvalue[1]->constval.vvec));
+                            out = (ast_expression*)parser_const_float(parser, vec3_mulvv(ConstV(0), ConstV(1)));
                         else
                             out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_V, exprs[0], exprs[1]);
                     }
@@ -609,8 +599,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
                 return false;
             }
             if (CanConstFold(exprs[0], exprs[1]))
-                out = (ast_expression*)parser_const_float(parser,
-                    asvalue[0]->constval.vfloat / asvalue[1]->constval.vfloat);
+                out = (ast_expression*)parser_const_float(parser, ConstF(0) / ConstF(1));
             else
                 out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F, exprs[0], exprs[1]);
             break;
@@ -626,9 +615,14 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
                            type_name[exprs[1]->expression.vtype]);
                 return false;
             }
-            out = (ast_expression*)ast_binary_new(ctx,
-                                                  (op->id == opid1('|') ? INSTR_BITOR : INSTR_BITAND),
-                                                  exprs[0], exprs[1]);
+            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)) ) ));
+            else
+                out = (ast_expression*)ast_binary_new(ctx,
+                    (op->id == opid1('|') ? INSTR_BITOR : INSTR_BITAND),
+                    exprs[0], exprs[1]);
             break;
         case opid1('^'):
             parseerror(parser, "TODO: bitxor");
@@ -655,7 +649,11 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
             }
             if (opts_standard == COMPILER_GMQCC)
                 printf("TODO: early out logic\n");
-            out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
+            if (CanConstFold(exprs[0], exprs[1]))
+                out = (ast_expression*)parser_const_float(parser,
+                    (generated_op == INSTR_OR ? (ConstF(0) || ConstF(1)) : (ConstF(0) && ConstF(1))));
+            else
+                out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
             break;
 
         case opid1('>'):
@@ -849,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;
@@ -1021,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;
@@ -1092,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)) {
@@ -1122,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 */
@@ -1182,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 */
@@ -1246,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 */
@@ -1317,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;
     }
@@ -1334,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;
     }
@@ -1351,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;
     }
@@ -1435,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;
 
@@ -1492,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;
@@ -1702,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';
@@ -1789,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;
@@ -1817,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 */
@@ -1829,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;
         }
 
@@ -1941,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';
@@ -1991,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;
 }