X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=parser.c;h=7c6ec8a4545134d52bcfb7a4f39a338b6fb5f7f9;hp=f53f60344ac4324fc22514e2047b8bc9057858d8;hb=6e400ca81f36fd1984f41dda43c9e6bb9539be9e;hpb=63d89f9f5ae2287f4c52c7da0b511fdb42ad3c2a

diff --git a/parser.c b/parser.c
index f53f603..7c6ec8a 100644
--- a/parser.c
+++ b/parser.c
@@ -211,7 +211,7 @@ static ast_value* parser_const_float(parser_t *parser, double d)
             return parser->imm_float[i];
     }
     out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_FLOAT);
-    out->isconst = true;
+    out->hasvalue = true;
     out->constval.vfloat = d;
     vec_push(parser->imm_float, out);
     return out;
@@ -256,7 +256,7 @@ static ast_value* parser_const_string(parser_t *parser, const char *str, bool do
         out = ast_value_new(parser_ctx(parser), name, TYPE_STRING);
     } else
         out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_STRING);
-    out->isconst = true;
+    out->hasvalue = true;
     out->constval.vstring = parser_strdup(str);
     vec_push(parser->imm_string, out);
     return out;
@@ -271,7 +271,7 @@ static ast_value* parser_const_vector(parser_t *parser, vector v)
             return parser->imm_vector[i];
     }
     out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_VECTOR);
-    out->isconst = true;
+    out->hasvalue = true;
     out->constval.vvec = v;
     vec_push(parser->imm_vector, out);
     return out;
@@ -517,7 +517,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
              (exprs[0]->expression.vtype != exprs[1]->expression.vtype || \
               exprs[0]->expression.vtype != T)
 #define CanConstFold1(A) \
-             (ast_istype((A), ast_value) && ((ast_value*)(A))->isconst)
+             (ast_istype((A), ast_value) && ((ast_value*)(A))->hasvalue)
 #define CanConstFold(A, B) \
              (CanConstFold1(A) && CanConstFold1(B))
 #define ConstV(i) (asvalue[(i)]->constval.vvec)
@@ -575,11 +575,11 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
 
         case opid1(','):
             if (blocks[0]) {
-                vec_push(blocks[0]->exprs, exprs[1]);
+                ast_block_add_expr(blocks[0], exprs[1]);
             } else {
                 blocks[0] = ast_block_new(ctx);
-                vec_push(blocks[0]->exprs, exprs[0]);
-                vec_push(blocks[0]->exprs, exprs[1]);
+                ast_block_add_expr(blocks[0], exprs[0]);
+                ast_block_add_expr(blocks[0], exprs[1]);
             }
             if (!ast_block_set_type(blocks[0], exprs[1]))
                 return false;
@@ -1701,7 +1701,7 @@ static bool parse_if(parser_t *parser, ast_block *block, ast_expression **out)
         parseerror(parser, "expected condition or 'not'");
         return false;
     }
-    if (parser->tok == TOKEN_KEYWORD && !strcmp(parser_tokval(parser), "not")) {
+    if (parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "not")) {
         ifnot = true;
         if (!parser_next(parser)) {
             parseerror(parser, "expected condition in parenthesis");
@@ -1961,10 +1961,7 @@ static bool parse_for(parser_t *parser, ast_block *block, ast_expression **out)
         increment = parse_expression_leave(parser, false);
         if (!increment)
             goto onerr;
-        if (!ast_istype(increment, ast_store) &&
-            !ast_istype(increment, ast_call) &&
-            !ast_istype(increment, ast_binstore))
-        {
+        if (!ast_side_effects(increment)) {
             if (genwarning(ast_ctx(increment), WARN_EFFECTLESS_STATEMENT, "statement has no effect"))
                 goto onerr;
         }
@@ -2088,7 +2085,7 @@ static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **ou
 
     if (!OPTS_FLAG(RELAXED_SWITCH)) {
         opval = (ast_value*)operand;
-        if (!ast_istype(operand, ast_value) || !opval->isconst) {
+        if (!ast_istype(operand, ast_value) || !opval->hasvalue) {
             parseerror(parser, "case on non-constant values need to be explicitly enabled via -frelaxed-switch");
             ast_unref(operand);
             return false;
@@ -2187,7 +2184,7 @@ static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **ou
             }
             if (!expr)
                 continue;
-            vec_push(caseblock->exprs, expr);
+            ast_block_add_expr(caseblock, expr);
         }
     }
 
@@ -2316,10 +2313,7 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression *
         if (!exp)
             return false;
         *out = exp;
-        if (!ast_istype(exp, ast_store) &&
-            !ast_istype(exp, ast_call) &&
-            !ast_istype(exp, ast_binstore))
-        {
+        if (!ast_side_effects(exp)) {
             if (genwarning(ast_ctx(exp), WARN_EFFECTLESS_STATEMENT, "statement has no effect"))
                 return false;
         }
@@ -2351,7 +2345,7 @@ static bool parse_block_into(parser_t *parser, ast_block *block, bool warnreturn
         }
         if (!expr)
             continue;
-        vec_push(block->exprs, expr);
+        ast_block_add_expr(block, expr);
     }
 
     if (parser->tok != '}') {
@@ -2484,7 +2478,7 @@ static bool parse_function_body(parser_t *parser, ast_value *var)
             parseerror(parser, "expected a framenumber constant in[frame,think] notation");
             return false;
         }
-        if (!ast_istype(framenum, ast_value) || !( (ast_value*)framenum )->isconst) {
+        if (!ast_istype(framenum, ast_value) || !( (ast_value*)framenum )->hasvalue) {
             ast_unref(framenum);
             parseerror(parser, "framenumber in [frame,think] notation must be a constant");
             return false;
@@ -2623,9 +2617,9 @@ static bool parse_function_body(parser_t *parser, ast_value *var)
                 if (store_think)     ast_delete(store_think);
                 retval = false;
             }
-            vec_push(block->exprs, (ast_expression*)store_frame);
-            vec_push(block->exprs, (ast_expression*)store_nextthink);
-            vec_push(block->exprs, (ast_expression*)store_think);
+            ast_block_add_expr(block, (ast_expression*)store_frame);
+            ast_block_add_expr(block, (ast_expression*)store_nextthink);
+            ast_block_add_expr(block, (ast_expression*)store_think);
         }
 
         if (!retval) {
@@ -2774,7 +2768,7 @@ static ast_expression *array_setter_node(parser_t *parser, ast_value *array, ast
             return NULL;
         }
 
-        vec_push(block->exprs, (ast_expression*)st);
+        ast_block_add_expr(block, (ast_expression*)st);
 
         ret = ast_return_new(ctx, NULL);
         if (!ret) {
@@ -2782,7 +2776,7 @@ static ast_expression *array_setter_node(parser_t *parser, ast_value *array, ast
             return NULL;
         }
 
-        vec_push(block->exprs, (ast_expression*)ret);
+        ast_block_add_expr(block, (ast_expression*)ret);
 
         return (ast_expression*)block;
     } else {
@@ -2843,7 +2837,7 @@ static ast_expression *array_field_setter_node(
             return NULL;
         }
 
-        vec_push(block->exprs, (ast_expression*)st);
+        ast_block_add_expr(block, (ast_expression*)st);
 
         ret = ast_return_new(ctx, NULL);
         if (!ret) {
@@ -2851,7 +2845,7 @@ static ast_expression *array_field_setter_node(
             return NULL;
         }
 
-        vec_push(block->exprs, (ast_expression*)ret);
+        ast_block_add_expr(block, (ast_expression*)ret);
 
         return (ast_expression*)block;
     } else {
@@ -2963,7 +2957,7 @@ static bool parser_create_array_setter(parser_t *parser, ast_value *array, const
         goto cleanup;
     }
 
-    vec_push(func->blocks[0]->exprs, root);
+    ast_block_add_expr(func->blocks[0], root);
     array->setter = fval;
     return true;
 cleanup:
@@ -3012,7 +3006,7 @@ static bool parser_create_array_field_setter(parser_t *parser, ast_value *array,
         goto cleanup;
     }
 
-    vec_push(func->blocks[0]->exprs, root);
+    ast_block_add_expr(func->blocks[0], root);
     array->setter = fval;
     return true;
 cleanup:
@@ -3059,7 +3053,7 @@ static bool parser_create_array_getter(parser_t *parser, ast_value *array, const
         goto cleanup;
     }
 
-    vec_push(func->blocks[0]->exprs, root);
+    ast_block_add_expr(func->blocks[0], root);
     array->getter = fval;
     return true;
 cleanup:
@@ -3617,9 +3611,6 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield
             }
         }
 
-        if (is_const)
-            var->isconst = true;
-
         /* Part 2:
          * Create the global/local, and deal with vector types.
          */
@@ -3780,7 +3771,7 @@ skipvar:
                 break;
             }
 
-            if (var->isconst) {
+            if (var->hasvalue) {
                 (void)!parsewarning(parser, WARN_DOUBLE_DECLARATION,
                                     "builtin `%s` has already been defined\n"
                                     " -> previous declaration here: %s:%i",
@@ -3827,11 +3818,11 @@ skipvar:
 
             if (!localblock) {
                 cval = (ast_value*)cexp;
-                if (!ast_istype(cval, ast_value) || !cval->isconst)
+                if (!ast_istype(cval, ast_value) || !cval->hasvalue)
                     parseerror(parser, "cannot initialize a global constant variable with a non-constant expression");
                 else
                 {
-                    var->isconst = true;
+                    var->hasvalue = true;
                     if (cval->expression.vtype == TYPE_STRING)
                         var->constval.vstring = parser_strdup(cval->constval.vstring);
                     else
@@ -3848,7 +3839,7 @@ skipvar:
                 else {
                     if (vec_size(sy.out) != 1 && vec_size(sy.ops) != 0)
                         parseerror(parser, "internal error: leaked operands");
-                    vec_push(localblock->exprs, (ast_expression*)sy.out[0].out);
+                    ast_block_add_expr(localblock, (ast_expression*)sy.out[0].out);
                 }
                 vec_free(sy.out);
                 vec_free(sy.ops);
@@ -4202,21 +4193,21 @@ bool parser_finish(const char *output)
 
         for (i = 0; i < vec_size(parser->fields); ++i) {
             ast_value *field;
-            bool isconst;
+            bool hasvalue;
             if (!ast_istype(parser->fields[i], ast_value))
                 continue;
             field = (ast_value*)parser->fields[i];
-            isconst = field->isconst;
-            field->isconst = false;
+            hasvalue = field->hasvalue;
+            field->hasvalue = false;
             if (!ast_global_codegen((ast_value*)field, ir, true)) {
                 con_out("failed to generate field %s\n", field->name);
                 ir_builder_delete(ir);
                 return false;
             }
-            if (isconst) {
+            if (hasvalue) {
                 ir_value *ifld;
                 ast_expression *subtype;
-                field->isconst = true;
+                field->hasvalue = true;
                 subtype = field->expression.next;
                 ifld = ir_builder_create_field(ir, field->name, subtype->expression.vtype);
                 if (subtype->expression.vtype == TYPE_FIELD)
@@ -4231,7 +4222,7 @@ bool parser_finish(const char *output)
             if (!ast_istype(parser->globals[i], ast_value))
                 continue;
             asvalue = (ast_value*)(parser->globals[i]);
-            if (!asvalue->uses && !asvalue->isconst && asvalue->expression.vtype != TYPE_FUNCTION) {
+            if (!asvalue->uses && !asvalue->hasvalue && asvalue->expression.vtype != TYPE_FUNCTION) {
                 if (strcmp(asvalue->name, "end_sys_globals") &&
                     strcmp(asvalue->name, "end_sys_fields"))
                 {