parser.c

   1 /*
   2  * Copyright (C) 2012
   3  *     Wolfgang Bumiller
   4  *     Dale Weiler
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy of
   7  * this software and associated documentation files (the "Software"), to deal in
   8  * the Software without restriction, including without limitation the rights to
   9  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
  10  * of the Software, and to permit persons to whom the Software is furnished to do
  11  * so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in all
  14  * copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  */
  24 #include <stdio.h>
  25 #include <stdarg.h>
  26
  27 #include "gmqcc.h"
  28 #include "lexer.h"
  29
  30 /* beginning of locals */
  31 #define PARSER_HT_LOCALS  2
  32
  33 #define PARSER_HT_SIZE    1024
  34 #define TYPEDEF_HT_SIZE   16
  35
  36 enum parser_pot { POT_PAREN, POT_TERNARY1, POT_TERNARY2 };
  37 typedef struct {
  38     lex_file *lex;
  39     int      tok;
  40
  41     ast_expression **globals;
  42     ast_expression **fields;
  43     ast_function **functions;
  44     ast_value    **imm_float;
  45     ast_value    **imm_string;
  46     ast_value    **imm_vector;
  47     size_t         translated;
  48
  49     /* must be deleted first, they reference immediates and values */
  50     ast_value    **accessors;
  51
  52     ast_value *imm_float_zero;
  53     ast_value *imm_float_one;
  54     ast_value *imm_vector_zero;
  55     ast_value *nil;
  56
  57     size_t crc_globals;
  58     size_t crc_fields;
  59
  60     ast_function *function;
  61
  62     /* All the labels the function defined...
  63      * Should they be in ast_function instead?
  64      */
  65     ast_label  **labels;
  66     ast_goto   **gotos;
  67     const char **breaks;
  68     const char **continues;
  69
  70     /* A list of hashtables for each scope */
  71     ht *variables;
  72     ht htfields;
  73     ht htglobals;
  74     ht *typedefs;
  75
  76     /* not to be used directly, we use the hash table */
  77     ast_expression **_locals;
  78     size_t          *_blocklocals;
  79     ast_value      **_typedefs;
  80     size_t          *_blocktypedefs;
  81     lex_ctx         *_block_ctx;
  82
  83     /* we store the '=' operator info */
  84     const oper_info *assign_op;
  85
  86     /* TYPE_FIELD -> parser_find_fields is used instead of find_var
  87      * TODO: TYPE_VECTOR -> x, y and z are accepted in the gmqcc standard
  88      * anything else: type error
  89      */
  90     qcint  memberof;
  91
  92     /* Keep track of our ternary vs parenthesis nesting state.
  93      * If we reach a 'comma' operator in a ternary without a paren,
  94      * we shall trigger -Wternary-precedence.
  95      */
  96     enum parser_pot *pot;
  97
  98     /* pragma flags */
  99     bool noref;
 100 } parser_t;
 101
 102 static const ast_expression *intrinsic_debug_typestring = (ast_expression*)0x10;
 103
 104 static void parser_enterblock(parser_t *parser);
 105 static bool parser_leaveblock(parser_t *parser);
 106 static void parser_addlocal(parser_t *parser, const char *name, ast_expression *e);
 107 static bool parse_typedef(parser_t *parser);
 108 static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, int qualifier, ast_value *cached_typedef, bool noref, bool is_static, uint32_t qflags, char *vstring);
 109 static ast_block* parse_block(parser_t *parser);
 110 static bool parse_block_into(parser_t *parser, ast_block *block);
 111 static bool parse_statement_or_block(parser_t *parser, ast_expression **out);
 112 static bool parse_statement(parser_t *parser, ast_block *block, ast_expression **out, bool allow_cases);
 113 static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma, bool truthvalue);
 114 static ast_expression* parse_expression(parser_t *parser, bool stopatcomma);
 115
 116 static void parseerror(parser_t *parser, const char *fmt, ...)
 117 {
 118     va_list ap;
 119     va_start(ap, fmt);
 120     vcompile_error(parser->lex->tok.ctx, fmt, ap);
 121     va_end(ap);
 122 }
 123
 124 /* returns true if it counts as an error */
 125 static bool GMQCC_WARN parsewarning(parser_t *parser, int warntype, const char *fmt, ...)
 126 {
 127     bool    r;
 128     va_list ap;
 129     va_start(ap, fmt);
 130     r = vcompile_warning(parser->lex->tok.ctx, warntype, fmt, ap);
 131     va_end(ap);
 132     return r;
 133 }
 134
 135 static bool GMQCC_WARN genwarning(lex_ctx ctx, int warntype, const char *fmt, ...)
 136 {
 137     bool    r;
 138     va_list ap;
 139     va_start(ap, fmt);
 140     r = vcompile_warning(ctx, warntype, fmt, ap);
 141     va_end(ap);
 142     return r;
 143 }
 144
 145 /**********************************************************************
 146  * some maths used for constant folding
 147  */
 148
 149 vector vec3_add(vector a, vector b)
 150 {
 151     vector out;
 152     out.x = a.x + b.x;
 153     out.y = a.y + b.y;
 154     out.z = a.z + b.z;
 155     return out;
 156 }
 157
 158 vector vec3_sub(vector a, vector b)
 159 {
 160     vector out;
 161     out.x = a.x - b.x;
 162     out.y = a.y - b.y;
 163     out.z = a.z - b.z;
 164     return out;
 165 }
 166
 167 qcfloat vec3_mulvv(vector a, vector b)
 168 {
 169     return (a.x * b.x + a.y * b.y + a.z * b.z);
 170 }
 171
 172 vector vec3_mulvf(vector a, float b)
 173 {
 174     vector out;
 175     out.x = a.x * b;
 176     out.y = a.y * b;
 177     out.z = a.z * b;
 178     return out;
 179 }
 180
 181 /**********************************************************************
 182  * parsing
 183  */
 184
 185 bool parser_next(parser_t *parser)
 186 {
 187     /* lex_do kills the previous token */
 188     parser->tok = lex_do(parser->lex);
 189     if (parser->tok == TOKEN_EOF)
 190         return true;
 191     if (parser->tok >= TOKEN_ERROR) {
 192         parseerror(parser, "lex error");
 193         return false;
 194     }
 195     return true;
 196 }
 197
 198 #define parser_tokval(p) ((p)->lex->tok.value)
 199 #define parser_token(p)  (&((p)->lex->tok))
 200 #define parser_ctx(p)    ((p)->lex->tok.ctx)
 201
 202 static ast_value* parser_const_float(parser_t *parser, double d)
 203 {
 204     size_t i;
 205     ast_value *out;
 206     for (i = 0; i < vec_size(parser->imm_float); ++i) {
 207         const double compare = parser->imm_float[i]->constval.vfloat;
 208         if (memcmp((const void*)&compare, (const void *)&d, sizeof(double)) == 0)
 209             return parser->imm_float[i];
 210     }
 211     out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_FLOAT);
 212     out->cvq      = CV_CONST;
 213     out->hasvalue = true;
 214     out->constval.vfloat = d;
 215     vec_push(parser->imm_float, out);
 216     return out;
 217 }
 218
 219 static ast_value* parser_const_float_0(parser_t *parser)
 220 {
 221     if (!parser->imm_float_zero)
 222         parser->imm_float_zero = parser_const_float(parser, 0);
 223     return parser->imm_float_zero;
 224 }
 225
 226 static ast_value* parser_const_float_1(parser_t *parser)
 227 {
 228     if (!parser->imm_float_one)
 229         parser->imm_float_one = parser_const_float(parser, 1);
 230     return parser->imm_float_one;
 231 }
 232
 233 static char *parser_strdup(const char *str)
 234 {
 235     if (str && !*str) {
 236         /* actually dup empty strings */
 237         char *out = (char*)mem_a(1);
 238         *out = 0;
 239         return out;
 240     }
 241     return util_strdup(str);
 242 }
 243
 244 static ast_value* parser_const_string(parser_t *parser, const char *str, bool dotranslate)
 245 {
 246     size_t i;
 247     ast_value *out;
 248     for (i = 0; i < vec_size(parser->imm_string); ++i) {
 249         if (!strcmp(parser->imm_string[i]->constval.vstring, str))
 250             return parser->imm_string[i];
 251     }
 252     if (dotranslate) {
 253         char name[32];
 254         snprintf(name, sizeof(name), "dotranslate_%lu", (unsigned long)(parser->translated++));
 255         out = ast_value_new(parser_ctx(parser), name, TYPE_STRING);
 256     } else
 257         out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_STRING);
 258     out->cvq      = CV_CONST;
 259     out->hasvalue = true;
 260     out->constval.vstring = parser_strdup(str);
 261     vec_push(parser->imm_string, out);
 262     return out;
 263 }
 264
 265 static ast_value* parser_const_vector(parser_t *parser, vector v)
 266 {
 267     size_t i;
 268     ast_value *out;
 269     for (i = 0; i < vec_size(parser->imm_vector); ++i) {
 270         if (!memcmp(&parser->imm_vector[i]->constval.vvec, &v, sizeof(v)))
 271             return parser->imm_vector[i];
 272     }
 273     out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_VECTOR);
 274     out->cvq      = CV_CONST;
 275     out->hasvalue = true;
 276     out->constval.vvec = v;
 277     vec_push(parser->imm_vector, out);
 278     return out;
 279 }
 280
 281 static ast_value* parser_const_vector_f(parser_t *parser, float x, float y, float z)
 282 {
 283     vector v;
 284     v.x = x;
 285     v.y = y;
 286     v.z = z;
 287     return parser_const_vector(parser, v);
 288 }
 289
 290 static ast_value* parser_const_vector_0(parser_t *parser)
 291 {
 292     if (!parser->imm_vector_zero)
 293         parser->imm_vector_zero = parser_const_vector_f(parser, 0, 0, 0);
 294     return parser->imm_vector_zero;
 295 }
 296
 297 static ast_expression* parser_find_field(parser_t *parser, const char *name)
 298 {
 299     return ( ast_expression*)util_htget(parser->htfields, name);
 300 }
 301
 302 static ast_expression* parser_find_global(parser_t *parser, const char *name)
 303 {
 304     return (ast_expression*)util_htget(parser->htglobals, name);
 305 }
 306
 307 static ast_expression* parser_find_param(parser_t *parser, const char *name)
 308 {
 309     size_t i;
 310     ast_value *fun;
 311     if (!parser->function)
 312         return NULL;
 313     fun = parser->function->vtype;
 314     for (i = 0; i < vec_size(fun->expression.params); ++i) {
 315         if (!strcmp(fun->expression.params[i]->name, name))
 316             return (ast_expression*)(fun->expression.params[i]);
 317     }
 318     return NULL;
 319 }
 320
 321 static ast_expression* parser_find_local(parser_t *parser, const char *name, size_t upto, bool *isparam)
 322 {
 323     size_t          i, hash;
 324     ast_expression *e;
 325
 326     hash = util_hthash(parser->htglobals, name);
 327
 328     *isparam = false;
 329     for (i = vec_size(parser->variables); i > upto;) {
 330         --i;
 331         if ( (e = (ast_expression*)util_htgeth(parser->variables[i], name, hash)) )
 332             return e;
 333     }
 334     *isparam = true;
 335     return parser_find_param(parser, name);
 336 }
 337
 338 static ast_expression* parser_find_var(parser_t *parser, const char *name)
 339 {
 340     bool dummy;
 341     ast_expression *v;
 342     v         = parser_find_local(parser, name, 0, &dummy);
 343     if (!v) v = parser_find_global(parser, name);
 344     return v;
 345 }
 346
 347 static ast_value* parser_find_typedef(parser_t *parser, const char *name, size_t upto)
 348 {
 349     size_t     i, hash;
 350     ast_value *e;
 351     hash = util_hthash(parser->typedefs[0], name);
 352
 353     for (i = vec_size(parser->typedefs); i > upto;) {
 354         --i;
 355         if ( (e = (ast_value*)util_htgeth(parser->typedefs[i], name, hash)) )
 356             return e;
 357     }
 358     return NULL;
 359 }
 360
 361 typedef struct
 362 {
 363     size_t etype; /* 0 = expression, others are operators */
 364     int             paren;
 365     size_t          off;
 366     ast_expression *out;
 367     ast_block      *block; /* for commas and function calls */
 368     lex_ctx ctx;
 369 } sy_elem;
 370 typedef struct
 371 {
 372     sy_elem *out;
 373     sy_elem *ops;
 374 } shunt;
 375
 376 #define SY_PAREN_EXPR '('
 377 #define SY_PAREN_FUNC 'f'
 378 #define SY_PAREN_INDEX '['
 379 #define SY_PAREN_TERNARY '?'
 380
 381 static sy_elem syexp(lex_ctx ctx, ast_expression *v) {
 382     sy_elem e;
 383     e.etype = 0;
 384     e.off   = 0;
 385     e.out   = v;
 386     e.block = NULL;
 387     e.ctx   = ctx;
 388     e.paren = 0;
 389     return e;
 390 }
 391
 392 static sy_elem syblock(lex_ctx ctx, ast_block *v) {
 393     sy_elem e;
 394     e.etype = 0;
 395     e.off   = 0;
 396     e.out   = (ast_expression*)v;
 397     e.block = v;
 398     e.ctx   = ctx;
 399     e.paren = 0;
 400     return e;
 401 }
 402
 403 static sy_elem syop(lex_ctx ctx, const oper_info *op) {
 404     sy_elem e;
 405     e.etype = 1 + (op - operators);
 406     e.off   = 0;
 407     e.out   = NULL;
 408     e.block = NULL;
 409     e.ctx   = ctx;
 410     e.paren = 0;
 411     return e;
 412 }
 413
 414 static sy_elem syparen(lex_ctx ctx, int p, size_t off) {
 415     sy_elem e;
 416     e.etype = 0;
 417     e.off   = off;
 418     e.out   = NULL;
 419     e.block = NULL;
 420     e.ctx   = ctx;
 421     e.paren = p;
 422     return e;
 423 }
 424
 425 #ifdef DEBUGSHUNT
 426 # define DEBUGSHUNTDO(x) x
 427 #else
 428 # define DEBUGSHUNTDO(x)
 429 #endif
 430
 431 /* With regular precedence rules, ent.foo[n] is the same as (ent.foo)[n],
 432  * so we need to rotate it to become ent.(foo[n]).
 433  */
 434 static bool rotate_entfield_array_index_nodes(ast_expression **out)
 435 {
 436     ast_array_index *index;
 437     ast_entfield    *entfield;
 438
 439     ast_value       *field;
 440     ast_expression  *sub;
 441     ast_expression  *entity;
 442
 443     lex_ctx ctx = ast_ctx(*out);
 444
 445     if (!ast_istype(*out, ast_array_index))
 446         return false;
 447     index = (ast_array_index*)*out;
 448
 449     if (!ast_istype(index->array, ast_entfield))
 450         return false;
 451     entfield = (ast_entfield*)index->array;
 452
 453     if (!ast_istype(entfield->field, ast_value))
 454         return false;
 455     field = (ast_value*)entfield->field;
 456
 457     sub    = index->index;
 458     entity = entfield->entity;
 459
 460     ast_delete(index);
 461
 462     index = ast_array_index_new(ctx, (ast_expression*)field, sub);
 463     entfield = ast_entfield_new(ctx, entity, (ast_expression*)index);
 464     *out = (ast_expression*)entfield;
 465
 466     return true;
 467 }
 468
 469 static bool immediate_is_true(lex_ctx ctx, ast_value *v)
 470 {
 471     switch (v->expression.vtype) {
 472         case TYPE_FLOAT:
 473             return !!v->constval.vfloat;
 474         case TYPE_INTEGER:
 475             return !!v->constval.vint;
 476         case TYPE_VECTOR:
 477             if (OPTS_FLAG(CORRECT_LOGIC))
 478                 return v->constval.vvec.x &&
 479                        v->constval.vvec.y &&
 480                        v->constval.vvec.z;
 481             else
 482                 return !!(v->constval.vvec.x);
 483         case TYPE_STRING:
 484             if (!v->constval.vstring)
 485                 return false;
 486             if (v->constval.vstring && OPTS_FLAG(TRUE_EMPTY_STRINGS))
 487                 return true;
 488             return !!v->constval.vstring[0];
 489         default:
 490             compile_error(ctx, "internal error: immediate_is_true on invalid type");
 491             return !!v->constval.vfunc;
 492     }
 493 }
 494
 495 static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
 496 {
 497     const oper_info *op;
 498     lex_ctx ctx;
 499     ast_expression *out = NULL;
 500     ast_expression *exprs[3];
 501     ast_block      *blocks[3];
 502     ast_value      *asvalue[3];
 503     ast_binstore   *asbinstore;
 504     size_t i, assignop, addop, subop;
 505     qcint  generated_op = 0;
 506
 507     char ty1[1024];
 508     char ty2[1024];
 509
 510     if (!vec_size(sy->ops)) {
 511         parseerror(parser, "internal error: missing operator");
 512         return false;
 513     }
 514
 515     if (vec_last(sy->ops).paren) {
 516         parseerror(parser, "unmatched parenthesis");
 517         return false;
 518     }
 519
 520     op = &operators[vec_last(sy->ops).etype - 1];
 521     ctx = vec_last(sy->ops).ctx;
 522
 523     DEBUGSHUNTDO(con_out("apply %s\n", op->op));
 524
 525     if (vec_size(sy->out) < op->operands) {
 526         parseerror(parser, "internal error: not enough operands: %i (operator %s (%i))", vec_size(sy->out),
 527                    op->op, (int)op->id);
 528         return false;
 529     }
 530
 531     vec_shrinkby(sy->ops, 1);
 532
 533     /* op(:?) has no input and no output */
 534     if (!op->operands)
 535         return true;
 536
 537     vec_shrinkby(sy->out, op->operands);
 538     for (i = 0; i < op->operands; ++i) {
 539         exprs[i]  = sy->out[vec_size(sy->out)+i].out;
 540         blocks[i] = sy->out[vec_size(sy->out)+i].block;
 541         asvalue[i] = (ast_value*)exprs[i];
 542     }
 543
 544     if (blocks[0] && !vec_size(blocks[0]->exprs) && op->id != opid1(',')) {
 545         parseerror(parser, "internal error: operator cannot be applied on empty blocks");
 546         return false;
 547     }
 548
 549 #define NotSameType(T) \
 550              (exprs[0]->expression.vtype != exprs[1]->expression.vtype || \
 551               exprs[0]->expression.vtype != T)
 552 #define CanConstFold1(A) \
 553              (ast_istype((A), ast_value) && ((ast_value*)(A))->hasvalue && (((ast_value*)(A))->cvq == CV_CONST) &&\
 554               (A)->expression.vtype != TYPE_FUNCTION)
 555 #define CanConstFold(A, B) \
 556              (CanConstFold1(A) && CanConstFold1(B))
 557 #define ConstV(i) (asvalue[(i)]->constval.vvec)
 558 #define ConstF(i) (asvalue[(i)]->constval.vfloat)
 559 #define ConstS(i) (asvalue[(i)]->constval.vstring)
 560     switch (op->id)
 561     {
 562         default:
 563             parseerror(parser, "internal error: unhandled operator: %s (%i)", op->op, (int)op->id);
 564             return false;
 565
 566         case opid1('.'):
 567             if (exprs[0]->expression.vtype == TYPE_ENTITY) {
 568                 if (exprs[1]->expression.vtype != TYPE_FIELD) {
 569                     parseerror(parser, "type error: right hand of member-operand should be an entity-field");
 570                     return false;
 571                 }
 572                 out = (ast_expression*)ast_entfield_new(ctx, exprs[0], exprs[1]);
 573             }
 574             else if (exprs[0]->expression.vtype == TYPE_VECTOR) {
 575                 parseerror(parser, "internal error: vector access is not supposed to be handled at this point");
 576                 return false;
 577             }
 578             else {
 579                 parseerror(parser, "type error: member-of operator on something that is not an entity or vector");
 580                 return false;
 581             }
 582             break;
 583
 584         case opid1('['):
 585             if (exprs[0]->expression.vtype != TYPE_ARRAY &&
 586                 !(exprs[0]->expression.vtype == TYPE_FIELD &&
 587                   exprs[0]->expression.next->expression.vtype == TYPE_ARRAY))
 588             {
 589                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
 590                 parseerror(parser, "cannot index value of type %s", ty1);
 591                 return false;
 592             }
 593             if (exprs[1]->expression.vtype != TYPE_FLOAT) {
 594                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
 595                 parseerror(parser, "index must be of type float, not %s", ty1);
 596                 return false;
 597             }
 598             out = (ast_expression*)ast_array_index_new(ctx, exprs[0], exprs[1]);
 599             if (rotate_entfield_array_index_nodes(&out))
 600             {
 601 #if 0
 602                 /* This is not broken in fteqcc anymore */
 603                 if (opts.standard != COMPILER_GMQCC) {
 604                     /* this error doesn't need to make us bail out */
 605                     (void)!parsewarning(parser, WARN_EXTENSIONS,
 606                                         "accessing array-field members of an entity without parenthesis\n"
 607                                         " -> this is an extension from -std=gmqcc");
 608                 }
 609 #endif
 610             }
 611             break;
 612
 613         case opid1(','):
 614             if (blocks[0]) {
 615                 if (!ast_block_add_expr(blocks[0], exprs[1]))
 616                     return false;
 617             } else {
 618                 blocks[0] = ast_block_new(ctx);
 619                 if (!ast_block_add_expr(blocks[0], exprs[0]) ||
 620                     !ast_block_add_expr(blocks[0], exprs[1]))
 621                 {
 622                     return false;
 623                 }
 624             }
 625             if (!ast_block_set_type(blocks[0], exprs[1]))
 626                 return false;
 627
 628             vec_push(sy->out, syblock(ctx, blocks[0]));
 629             return true;
 630
 631         case opid2('+','P'):
 632             out = exprs[0];
 633             break;
 634         case opid2('-','P'):
 635             switch (exprs[0]->expression.vtype) {
 636                 case TYPE_FLOAT:
 637                     if (CanConstFold1(exprs[0]))
 638                         out = (ast_expression*)parser_const_float(parser, -ConstF(0));
 639                     else
 640                         out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F,
 641                                                               (ast_expression*)parser_const_float_0(parser),
 642                                                               exprs[0]);
 643                     break;
 644                 case TYPE_VECTOR:
 645                     if (CanConstFold1(exprs[0]))
 646                         out = (ast_expression*)parser_const_vector_f(parser,
 647                             -ConstV(0).x, -ConstV(0).y, -ConstV(0).z);
 648                     else
 649                         out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V,
 650                                                               (ast_expression*)parser_const_vector_0(parser),
 651                                                               exprs[0]);
 652                     break;
 653                 default:
 654                 parseerror(parser, "invalid types used in expression: cannot negate type %s",
 655                            type_name[exprs[0]->expression.vtype]);
 656                 return false;
 657             }
 658             break;
 659
 660         case opid2('!','P'):
 661             switch (exprs[0]->expression.vtype) {
 662                 case TYPE_FLOAT:
 663                     if (CanConstFold1(exprs[0]))
 664                         out = (ast_expression*)parser_const_float(parser, !ConstF(0));
 665                     else
 666                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, exprs[0]);
 667                     break;
 668                 case TYPE_VECTOR:
 669                     if (CanConstFold1(exprs[0]))
 670                         out = (ast_expression*)parser_const_float(parser,
 671                             (!ConstV(0).x && !ConstV(0).y && !ConstV(0).z));
 672                     else
 673                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_V, exprs[0]);
 674                     break;
 675                 case TYPE_STRING:
 676                     if (CanConstFold1(exprs[0])) {
 677                         if (OPTS_FLAG(TRUE_EMPTY_STRINGS))
 678                             out = (ast_expression*)parser_const_float(parser, !ConstS(0));
 679                         else
 680                             out = (ast_expression*)parser_const_float(parser, !ConstS(0) || !*ConstS(0));
 681                     } else {
 682                         if (OPTS_FLAG(TRUE_EMPTY_STRINGS))
 683                             out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, exprs[0]);
 684                         else
 685                             out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_S, exprs[0]);
 686                     }
 687                     break;
 688                 /* we don't constant-fold NOT for these types */
 689                 case TYPE_ENTITY:
 690                     out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_ENT, exprs[0]);
 691                     break;
 692                 case TYPE_FUNCTION:
 693                     out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_FNC, exprs[0]);
 694                     break;
 695                 default:
 696                 parseerror(parser, "invalid types used in expression: cannot logically negate type %s",
 697                            type_name[exprs[0]->expression.vtype]);
 698                 return false;
 699             }
 700             break;
 701
 702         case opid1('+'):
 703             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
 704                 (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) )
 705             {
 706                 parseerror(parser, "invalid types used in expression: cannot add type %s and %s",
 707                            type_name[exprs[0]->expression.vtype],
 708                            type_name[exprs[1]->expression.vtype]);
 709                 return false;
 710             }
 711             switch (exprs[0]->expression.vtype) {
 712                 case TYPE_FLOAT:
 713                     if (CanConstFold(exprs[0], exprs[1]))
 714                     {
 715                         out = (ast_expression*)parser_const_float(parser, ConstF(0) + ConstF(1));
 716                     }
 717                     else
 718                         out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_F, exprs[0], exprs[1]);
 719                     break;
 720                 case TYPE_VECTOR:
 721                     if (CanConstFold(exprs[0], exprs[1]))
 722                         out = (ast_expression*)parser_const_vector(parser, vec3_add(ConstV(0), ConstV(1)));
 723                     else
 724                         out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_V, exprs[0], exprs[1]);
 725                     break;
 726                 default:
 727                     parseerror(parser, "invalid types used in expression: cannot add type %s and %s",
 728                                type_name[exprs[0]->expression.vtype],
 729                                type_name[exprs[1]->expression.vtype]);
 730                     return false;
 731             };
 732             break;
 733         case opid1('-'):
 734             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
 735                 (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) )
 736             {
 737                 parseerror(parser, "invalid types used in expression: cannot subtract type %s from %s",
 738                            type_name[exprs[1]->expression.vtype],
 739                            type_name[exprs[0]->expression.vtype]);
 740                 return false;
 741             }
 742             switch (exprs[0]->expression.vtype) {
 743                 case TYPE_FLOAT:
 744                     if (CanConstFold(exprs[0], exprs[1]))
 745                         out = (ast_expression*)parser_const_float(parser, ConstF(0) - ConstF(1));
 746                     else
 747                         out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F, exprs[0], exprs[1]);
 748                     break;
 749                 case TYPE_VECTOR:
 750                     if (CanConstFold(exprs[0], exprs[1]))
 751                         out = (ast_expression*)parser_const_vector(parser, vec3_sub(ConstV(0), ConstV(1)));
 752                     else
 753                         out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V, exprs[0], exprs[1]);
 754                     break;
 755                 default:
 756                     parseerror(parser, "invalid types used in expression: cannot subtract type %s from %s",
 757                                type_name[exprs[1]->expression.vtype],
 758                                type_name[exprs[0]->expression.vtype]);
 759                     return false;
 760             };
 761             break;
 762         case opid1('*'):
 763             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype &&
 764                 !(exprs[0]->expression.vtype == TYPE_VECTOR &&
 765                   exprs[1]->expression.vtype == TYPE_FLOAT) &&
 766                 !(exprs[1]->expression.vtype == TYPE_VECTOR &&
 767                   exprs[0]->expression.vtype == TYPE_FLOAT)
 768                 )
 769             {
 770                 parseerror(parser, "invalid types used in expression: cannot multiply types %s and %s",
 771                            type_name[exprs[1]->expression.vtype],
 772                            type_name[exprs[0]->expression.vtype]);
 773                 return false;
 774             }
 775             switch (exprs[0]->expression.vtype) {
 776                 case TYPE_FLOAT:
 777                     if (exprs[1]->expression.vtype == TYPE_VECTOR)
 778                     {
 779                         if (CanConstFold(exprs[0], exprs[1]))
 780                             out = (ast_expression*)parser_const_vector(parser, vec3_mulvf(ConstV(1), ConstF(0)));
 781                         else
 782                             out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_FV, exprs[0], exprs[1]);
 783                     }
 784                     else
 785                     {
 786                         if (CanConstFold(exprs[0], exprs[1]))
 787                             out = (ast_expression*)parser_const_float(parser, ConstF(0) * ConstF(1));
 788                         else
 789                             out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, exprs[0], exprs[1]);
 790                     }
 791                     break;
 792                 case TYPE_VECTOR:
 793                     if (exprs[1]->expression.vtype == TYPE_FLOAT)
 794                     {
 795                         if (CanConstFold(exprs[0], exprs[1]))
 796                             out = (ast_expression*)parser_const_vector(parser, vec3_mulvf(ConstV(0), ConstF(1)));
 797                         else
 798                             out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_VF, exprs[0], exprs[1]);
 799                     }
 800                     else
 801                     {
 802                         if (CanConstFold(exprs[0], exprs[1]))
 803                             out = (ast_expression*)parser_const_float(parser, vec3_mulvv(ConstV(0), ConstV(1)));
 804                         else if (OPTS_OPTIMIZATION(OPTIM_VECTOR_COMPONENTS) && CanConstFold1(exprs[0])) {
 805                             vector vec = ConstV(0);
 806                             if (!vec.y && !vec.z) { /* 'n 0 0' * v */
 807                                 ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS];
 808                                 out = (ast_expression*)ast_member_new(ctx, exprs[1], 0, NULL);
 809                                 out->expression.node.keep = false;
 810                                 ((ast_member*)out)->rvalue = true;
 811                                 if (vec.x != 1)
 812                                     out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, (ast_expression*)parser_const_float(parser, vec.x), out);
 813                             }
 814                             else if (!vec.x && !vec.z) { /* '0 n 0' * v */
 815                                 ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS];
 816                                 out = (ast_expression*)ast_member_new(ctx, exprs[1], 1, NULL);
 817                                 out->expression.node.keep = false;
 818                                 ((ast_member*)out)->rvalue = true;
 819                                 if (vec.y != 1)
 820                                     out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, (ast_expression*)parser_const_float(parser, vec.y), out);
 821                             }
 822                             else if (!vec.x && !vec.y) { /* '0 n 0' * v */
 823                                 ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS];
 824                                 out = (ast_expression*)ast_member_new(ctx, exprs[1], 2, NULL);
 825                                 out->expression.node.keep = false;
 826                                 ((ast_member*)out)->rvalue = true;
 827                                 if (vec.z != 1)
 828                                     out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, (ast_expression*)parser_const_float(parser, vec.z), out);
 829                             }
 830                             else
 831                                 out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_V, exprs[0], exprs[1]);
 832                         }
 833                         else if (OPTS_OPTIMIZATION(OPTIM_VECTOR_COMPONENTS) && CanConstFold1(exprs[1])) {
 834                             vector vec = ConstV(1);
 835                             if (!vec.y && !vec.z) { /* v * 'n 0 0' */
 836                                 ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS];
 837                                 out = (ast_expression*)ast_member_new(ctx, exprs[0], 0, NULL);
 838                                 out->expression.node.keep = false;
 839                                 ((ast_member*)out)->rvalue = true;
 840                                 if (vec.x != 1)
 841                                     out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, out, (ast_expression*)parser_const_float(parser, vec.x));
 842                             }
 843                             else if (!vec.x && !vec.z) { /* v * '0 n 0' */
 844                                 ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS];
 845                                 out = (ast_expression*)ast_member_new(ctx, exprs[0], 1, NULL);
 846                                 out->expression.node.keep = false;
 847                                 ((ast_member*)out)->rvalue = true;
 848                                 if (vec.y != 1)
 849                                     out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, out, (ast_expression*)parser_const_float(parser, vec.y));
 850                             }
 851                             else if (!vec.x && !vec.y) { /* v * '0 n 0' */
 852                                 ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS];
 853                                 out = (ast_expression*)ast_member_new(ctx, exprs[0], 2, NULL);
 854                                 out->expression.node.keep = false;
 855                                 ((ast_member*)out)->rvalue = true;
 856                                 if (vec.z != 1)
 857                                     out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, out, (ast_expression*)parser_const_float(parser, vec.z));
 858                             }
 859                             else
 860                                 out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_V, exprs[0], exprs[1]);
 861                         }
 862                         else
 863                             out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_V, exprs[0], exprs[1]);
 864                     }
 865                     break;
 866                 default:
 867                     parseerror(parser, "invalid types used in expression: cannot multiply types %s and %s",
 868                                type_name[exprs[1]->expression.vtype],
 869                                type_name[exprs[0]->expression.vtype]);
 870                     return false;
 871             };
 872             break;
 873         case opid1('/'):
 874             if (NotSameType(TYPE_FLOAT)) {
 875                 parseerror(parser, "invalid types used in expression: cannot divide types %s and %s",
 876                            type_name[exprs[0]->expression.vtype],
 877                            type_name[exprs[1]->expression.vtype]);
 878                 return false;
 879             }
 880             if (CanConstFold(exprs[0], exprs[1]))
 881                 out = (ast_expression*)parser_const_float(parser, ConstF(0) / ConstF(1));
 882             else
 883                 out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F, exprs[0], exprs[1]);
 884             break;
 885         case opid1('%'):
 886         case opid2('%','='):
 887             parseerror(parser, "qc does not have a modulo operator");
 888             return false;
 889         case opid1('|'):
 890         case opid1('&'):
 891             if (NotSameType(TYPE_FLOAT)) {
 892                 parseerror(parser, "invalid types used in expression: cannot perform bit operations between types %s and %s",
 893                            type_name[exprs[0]->expression.vtype],
 894                            type_name[exprs[1]->expression.vtype]);
 895                 return false;
 896             }
 897             if (CanConstFold(exprs[0], exprs[1]))
 898                 out = (ast_expression*)parser_const_float(parser,
 899                     (op->id == opid1('|') ? (float)( ((qcint)ConstF(0)) | ((qcint)ConstF(1)) ) :
 900                                             (float)( ((qcint)ConstF(0)) & ((qcint)ConstF(1)) ) ));
 901             else
 902                 out = (ast_expression*)ast_binary_new(ctx,
 903                     (op->id == opid1('|') ? INSTR_BITOR : INSTR_BITAND),
 904                     exprs[0], exprs[1]);
 905             break;
 906         case opid1('^'):
 907             parseerror(parser, "TODO: bitxor");
 908             return false;
 909
 910         case opid2('<','<'):
 911         case opid2('>','>'):
 912         case opid3('<','<','='):
 913         case opid3('>','>','='):
 914             parseerror(parser, "TODO: shifts");
 915             return false;
 916
 917         case opid2('|','|'):
 918             generated_op += 1; /* INSTR_OR */
 919         case opid2('&','&'):
 920             generated_op += INSTR_AND;
 921 #if 0
 922             if (NotSameType(TYPE_FLOAT)) {
 923                 parseerror(parser, "invalid types used in expression: cannot perform logical operations between types %s and %s",
 924                            type_name[exprs[0]->expression.vtype],
 925                            type_name[exprs[1]->expression.vtype]);
 926                 parseerror(parser, "TODO: logical ops for arbitrary types using INSTR_NOT");
 927                 parseerror(parser, "TODO: optional early out");
 928                 return false;
 929             }
 930 #endif
 931             if (CanConstFold(exprs[0], exprs[1]))
 932             {
 933                 if (OPTS_FLAG(PERL_LOGIC)) {
 934                     if (immediate_is_true(ctx, asvalue[0]))
 935                         out = exprs[1];
 936                 }
 937                 else
 938                     out = (ast_expression*)parser_const_float(parser,
 939                           ( (generated_op == INSTR_OR)
 940                             ? (immediate_is_true(ctx, asvalue[0]) || immediate_is_true(ctx, asvalue[1]))
 941                             : (immediate_is_true(ctx, asvalue[0]) && immediate_is_true(ctx, asvalue[1])) )
 942                           ? 1 : 0);
 943             }
 944             else
 945             {
 946                 if (OPTS_FLAG(PERL_LOGIC) && !ast_compare_type(exprs[0], exprs[1])) {
 947                     ast_type_to_string(exprs[0], ty1, sizeof(ty1));
 948                     ast_type_to_string(exprs[1], ty2, sizeof(ty2));
 949                     parseerror(parser, "invalid types for logical operation with -fperl-logic: %s and %s", ty1, ty2);
 950                     return false;
 951                 }
 952                 for (i = 0; i < 2; ++i) {
 953                     if (OPTS_FLAG(CORRECT_LOGIC) && exprs[i]->expression.vtype == TYPE_VECTOR) {
 954                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_V, exprs[i]);
 955                         if (!out) break;
 956                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, out);
 957                         if (!out) break;
 958                         exprs[i] = out; out = NULL;
 959                         if (OPTS_FLAG(PERL_LOGIC)) {
 960                             /* here we want to keep the right expressions' type */
 961                             break;
 962                         }
 963                     }
 964                     else if (OPTS_FLAG(FALSE_EMPTY_STRINGS) && exprs[i]->expression.vtype == TYPE_STRING) {
 965                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_S, exprs[i]);
 966                         if (!out) break;
 967                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, out);
 968                         if (!out) break;
 969                         exprs[i] = out; out = NULL;
 970                         if (OPTS_FLAG(PERL_LOGIC)) {
 971                             /* here we want to keep the right expressions' type */
 972                             break;
 973                         }
 974                     }
 975                 }
 976                 out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
 977             }
 978             break;
 979
 980         case opid2('?',':'):
 981             if (vec_last(parser->pot) != POT_TERNARY2) {
 982                 parseerror(parser, "mismatched parenthesis/ternary");
 983                 return false;
 984             }
 985             vec_pop(parser->pot);
 986             if (!ast_compare_type(exprs[1], exprs[2])) {
 987                 ast_type_to_string(exprs[1], ty1, sizeof(ty1));
 988                 ast_type_to_string(exprs[2], ty2, sizeof(ty2));
 989                 parseerror(parser, "operands of ternary expression must have the same type, got %s and %s", ty1, ty2);
 990                 return false;
 991             }
 992             if (CanConstFold1(exprs[0]))
 993                 out = (immediate_is_true(ctx, asvalue[0]) ? exprs[1] : exprs[2]);
 994             else
 995                 out = (ast_expression*)ast_ternary_new(ctx, exprs[0], exprs[1], exprs[2]);
 996             break;
 997
 998         case opid1('>'):
 999             generated_op += 1; /* INSTR_GT */
1000         case opid1('<'):
1001             generated_op += 1; /* INSTR_LT */
1002         case opid2('>', '='):
1003             generated_op += 1; /* INSTR_GE */
1004         case opid2('<', '='):
1005             generated_op += INSTR_LE;
1006             if (NotSameType(TYPE_FLOAT)) {
1007                 parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s",
1008                            type_name[exprs[0]->expression.vtype],
1009                            type_name[exprs[1]->expression.vtype]);
1010                 return false;
1011             }
1012             out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
1013             break;
1014         case opid2('!', '='):
1015             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) {
1016                 parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s",
1017                            type_name[exprs[0]->expression.vtype],
1018                            type_name[exprs[1]->expression.vtype]);
1019                 return false;
1020             }
1021             out = (ast_expression*)ast_binary_new(ctx, type_ne_instr[exprs[0]->expression.vtype], exprs[0], exprs[1]);
1022             break;
1023         case opid2('=', '='):
1024             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) {
1025                 parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s",
1026                            type_name[exprs[0]->expression.vtype],
1027                            type_name[exprs[1]->expression.vtype]);
1028                 return false;
1029             }
1030             out = (ast_expression*)ast_binary_new(ctx, type_eq_instr[exprs[0]->expression.vtype], exprs[0], exprs[1]);
1031             break;
1032
1033         case opid1('='):
1034             if (ast_istype(exprs[0], ast_entfield)) {
1035                 ast_expression *field = ((ast_entfield*)exprs[0])->field;
1036                 if (OPTS_FLAG(ADJUST_VECTOR_FIELDS) &&
1037                     exprs[0]->expression.vtype == TYPE_FIELD &&
1038                     exprs[0]->expression.next->expression.vtype == TYPE_VECTOR)
1039                 {
1040                     assignop = type_storep_instr[TYPE_VECTOR];
1041                 }
1042                 else
1043                     assignop = type_storep_instr[exprs[0]->expression.vtype];
1044                 if (assignop == AINSTR_END || !ast_compare_type(field->expression.next, exprs[1]))
1045                 {
1046                     ast_type_to_string(field->expression.next, ty1, sizeof(ty1));
1047                     ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1048                     if (OPTS_FLAG(ASSIGN_FUNCTION_TYPES) &&
1049                         field->expression.next->expression.vtype == TYPE_FUNCTION &&
1050                         exprs[1]->expression.vtype == TYPE_FUNCTION)
1051                     {
1052                         (void)!parsewarning(parser, WARN_ASSIGN_FUNCTION_TYPES,
1053                                             "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
1054                     }
1055                     else
1056                         parseerror(parser, "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
1057                 }
1058             }
1059             else
1060             {
1061                 if (OPTS_FLAG(ADJUST_VECTOR_FIELDS) &&
1062                     exprs[0]->expression.vtype == TYPE_FIELD &&
1063                     exprs[0]->expression.next->expression.vtype == TYPE_VECTOR)
1064                 {
1065                     assignop = type_store_instr[TYPE_VECTOR];
1066                 }
1067                 else {
1068                     assignop = type_store_instr[exprs[0]->expression.vtype];
1069                 }
1070
1071                 if (assignop == AINSTR_END) {
1072                     ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1073                     ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1074                     parseerror(parser, "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
1075                 }
1076                 else if (!ast_compare_type(exprs[0], exprs[1]))
1077                 {
1078                     ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1079                     ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1080                     if (OPTS_FLAG(ASSIGN_FUNCTION_TYPES) &&
1081                         exprs[0]->expression.vtype == TYPE_FUNCTION &&
1082                         exprs[1]->expression.vtype == TYPE_FUNCTION)
1083                     {
1084                         (void)!parsewarning(parser, WARN_ASSIGN_FUNCTION_TYPES,
1085                                             "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
1086                     }
1087                     else
1088                         parseerror(parser, "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
1089                 }
1090             }
1091             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1092                 parseerror(parser, "assignment to constant `%s`", asvalue[0]->name);
1093             }
1094             out = (ast_expression*)ast_store_new(ctx, assignop, exprs[0], exprs[1]);
1095             break;
1096         case opid3('+','+','P'):
1097         case opid3('-','-','P'):
1098             /* prefix ++ */
1099             if (exprs[0]->expression.vtype != TYPE_FLOAT) {
1100                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1101                 parseerror(parser, "invalid type for prefix increment: %s", ty1);
1102                 return false;
1103             }
1104             if (op->id == opid3('+','+','P'))
1105                 addop = INSTR_ADD_F;
1106             else
1107                 addop = INSTR_SUB_F;
1108             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1109                 parseerror(parser, "assignment to constant `%s`", asvalue[0]->name);
1110             }
1111             if (ast_istype(exprs[0], ast_entfield)) {
1112                 out = (ast_expression*)ast_binstore_new(ctx, INSTR_STOREP_F, addop,
1113                                                         exprs[0],
1114                                                         (ast_expression*)parser_const_float_1(parser));
1115             } else {
1116                 out = (ast_expression*)ast_binstore_new(ctx, INSTR_STORE_F, addop,
1117                                                         exprs[0],
1118                                                         (ast_expression*)parser_const_float_1(parser));
1119             }
1120             break;
1121         case opid3('S','+','+'):
1122         case opid3('S','-','-'):
1123             /* prefix ++ */
1124             if (exprs[0]->expression.vtype != TYPE_FLOAT) {
1125                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1126                 parseerror(parser, "invalid type for suffix increment: %s", ty1);
1127                 return false;
1128             }
1129             if (op->id == opid3('S','+','+')) {
1130                 addop = INSTR_ADD_F;
1131                 subop = INSTR_SUB_F;
1132             } else {
1133                 addop = INSTR_SUB_F;
1134                 subop = INSTR_ADD_F;
1135             }
1136             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1137                 parseerror(parser, "assignment to constant `%s`", asvalue[0]->name);
1138             }
1139             if (ast_istype(exprs[0], ast_entfield)) {
1140                 out = (ast_expression*)ast_binstore_new(ctx, INSTR_STOREP_F, addop,
1141                                                         exprs[0],
1142                                                         (ast_expression*)parser_const_float_1(parser));
1143             } else {
1144                 out = (ast_expression*)ast_binstore_new(ctx, INSTR_STORE_F, addop,
1145                                                         exprs[0],
1146                                                         (ast_expression*)parser_const_float_1(parser));
1147             }
1148             if (!out)
1149                 return false;
1150             out = (ast_expression*)ast_binary_new(ctx, subop,
1151                                                   out,
1152                                                   (ast_expression*)parser_const_float_1(parser));
1153             break;
1154         case opid2('+','='):
1155         case opid2('-','='):
1156             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
1157                 (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) )
1158             {
1159                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1160                 ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1161                 parseerror(parser, "invalid types used in expression: cannot add or subtract type %s and %s",
1162                            ty1, ty2);
1163                 return false;
1164             }
1165             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1166                 parseerror(parser, "assignment to constant `%s`", asvalue[0]->name);
1167             }
1168             if (ast_istype(exprs[0], ast_entfield))
1169                 assignop = type_storep_instr[exprs[0]->expression.vtype];
1170             else
1171                 assignop = type_store_instr[exprs[0]->expression.vtype];
1172             switch (exprs[0]->expression.vtype) {
1173                 case TYPE_FLOAT:
1174                     out = (ast_expression*)ast_binstore_new(ctx, assignop,
1175                                                             (op->id == opid2('+','=') ? INSTR_ADD_F : INSTR_SUB_F),
1176                                                             exprs[0], exprs[1]);
1177                     break;
1178                 case TYPE_VECTOR:
1179                     out = (ast_expression*)ast_binstore_new(ctx, assignop,
1180                                                             (op->id == opid2('+','=') ? INSTR_ADD_V : INSTR_SUB_V),
1181                                                             exprs[0], exprs[1]);
1182                     break;
1183                 default:
1184                     parseerror(parser, "invalid types used in expression: cannot add or subtract type %s and %s",
1185                                type_name[exprs[0]->expression.vtype],
1186                                type_name[exprs[1]->expression.vtype]);
1187                     return false;
1188             };
1189             break;
1190         case opid2('*','='):
1191         case opid2('/','='):
1192             if (exprs[1]->expression.vtype != TYPE_FLOAT ||
1193                 !(exprs[0]->expression.vtype == TYPE_FLOAT ||
1194                   exprs[0]->expression.vtype == TYPE_VECTOR))
1195             {
1196                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1197                 ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1198                 parseerror(parser, "invalid types used in expression: %s and %s",
1199                            ty1, ty2);
1200                 return false;
1201             }
1202             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1203                 parseerror(parser, "assignment to constant `%s`", asvalue[0]->name);
1204             }
1205             if (ast_istype(exprs[0], ast_entfield))
1206                 assignop = type_storep_instr[exprs[0]->expression.vtype];
1207             else
1208                 assignop = type_store_instr[exprs[0]->expression.vtype];
1209             switch (exprs[0]->expression.vtype) {
1210                 case TYPE_FLOAT:
1211                     out = (ast_expression*)ast_binstore_new(ctx, assignop,
1212                                                             (op->id == opid2('*','=') ? INSTR_MUL_F : INSTR_DIV_F),
1213                                                             exprs[0], exprs[1]);
1214                     break;
1215                 case TYPE_VECTOR:
1216                     if (op->id == opid2('*','=')) {
1217                         out = (ast_expression*)ast_binstore_new(ctx, assignop, INSTR_MUL_VF,
1218                                                                 exprs[0], exprs[1]);
1219                     } else {
1220                         /* there's no DIV_VF */
1221                         out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F,
1222                                                               (ast_expression*)parser_const_float_1(parser),
1223                                                               exprs[1]);
1224                         if (!out)
1225                             return false;
1226                         out = (ast_expression*)ast_binstore_new(ctx, assignop, INSTR_MUL_VF,
1227                                                                 exprs[0], out);
1228                     }
1229                     break;
1230                 default:
1231                     parseerror(parser, "invalid types used in expression: cannot add or subtract type %s and %s",
1232                                type_name[exprs[0]->expression.vtype],
1233                                type_name[exprs[1]->expression.vtype]);
1234                     return false;
1235             };
1236             break;
1237         case opid2('&','='):
1238         case opid2('|','='):
1239             if (NotSameType(TYPE_FLOAT)) {
1240                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1241                 ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1242                 parseerror(parser, "invalid types used in expression: %s and %s",
1243                            ty1, ty2);
1244                 return false;
1245             }
1246             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1247                 parseerror(parser, "assignment to constant `%s`", asvalue[0]->name);
1248             }
1249             if (ast_istype(exprs[0], ast_entfield))
1250                 assignop = type_storep_instr[exprs[0]->expression.vtype];
1251             else
1252                 assignop = type_store_instr[exprs[0]->expression.vtype];
1253             out = (ast_expression*)ast_binstore_new(ctx, assignop,
1254                                                     (op->id == opid2('&','=') ? INSTR_BITAND : INSTR_BITOR),
1255                                                     exprs[0], exprs[1]);
1256             break;
1257         case opid3('&','~','='):
1258             /* This is like: a &= ~(b);
1259              * But QC has no bitwise-not, so we implement it as
1260              * a -= a & (b);
1261              */
1262             if (NotSameType(TYPE_FLOAT)) {
1263                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1264                 ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1265                 parseerror(parser, "invalid types used in expression: %s and %s",
1266                            ty1, ty2);
1267                 return false;
1268             }
1269             if (ast_istype(exprs[0], ast_entfield))
1270                 assignop = type_storep_instr[exprs[0]->expression.vtype];
1271             else
1272                 assignop = type_store_instr[exprs[0]->expression.vtype];
1273             out = (ast_expression*)ast_binary_new(ctx, INSTR_BITAND, exprs[0], exprs[1]);
1274             if (!out)
1275                 return false;
1276             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1277                 parseerror(parser, "assignment to constant `%s`", asvalue[0]->name);
1278             }
1279             asbinstore = ast_binstore_new(ctx, assignop, INSTR_SUB_F, exprs[0], out);
1280             asbinstore->keep_dest = true;
1281             out = (ast_expression*)asbinstore;
1282             break;
1283     }
1284 #undef NotSameType
1285
1286     if (!out) {
1287         parseerror(parser, "failed to apply operand %s", op->op);
1288         return false;
1289     }
1290
1291     DEBUGSHUNTDO(con_out("applied %s\n", op->op));
1292     vec_push(sy->out, syexp(ctx, out));
1293     return true;
1294 }
1295
1296 static bool parser_close_call(parser_t *parser, shunt *sy)
1297 {
1298     /* was a function call */
1299     ast_expression *fun;
1300     ast_call       *call;
1301
1302     size_t          fid;
1303     size_t          paramcount;
1304
1305     vec_shrinkby(sy->ops, 1);
1306     fid = sy->ops[vec_size(sy->ops)].off;
1307
1308     /* out[fid] is the function
1309      * everything above is parameters...
1310      * 0 params = nothing
1311      * 1 params = ast_expression
1312      * more = ast_block
1313      */
1314
1315     if (vec_size(sy->out) < 1 || vec_size(sy->out) <= fid) {
1316         parseerror(parser, "internal error: function call needs function and parameter list...");
1317         return false;
1318     }
1319
1320     fun = sy->out[fid].out;
1321
1322     if (fun == intrinsic_debug_typestring) {
1323         char ty[1024];
1324         if (fid+2 != vec_size(sy->out) ||
1325             vec_last(sy->out).block)
1326         {
1327             parseerror(parser, "intrinsic __builtin_debug_typestring requires exactly 1 parameter");
1328             return false;
1329         }
1330         ast_type_to_string(vec_last(sy->out).out, ty, sizeof(ty));
1331         ast_unref(vec_last(sy->out).out);
1332         sy->out[fid] = syexp(ast_ctx(vec_last(sy->out).out),
1333                              (ast_expression*)parser_const_string(parser, ty, false));
1334         vec_shrinkby(sy->out, 1);
1335         return true;
1336     }
1337
1338     call = ast_call_new(sy->ops[vec_size(sy->ops)].ctx, fun);
1339     if (!call) {
1340         parseerror(parser, "internal error: failed to create ast_call node");
1341         return false;
1342     }
1343
1344     if (fid+1 == vec_size(sy->out)) {
1345         /* no arguments */
1346         paramcount = 0;
1347     } else if (fid+2 == vec_size(sy->out)) {
1348         ast_block *params;
1349         vec_shrinkby(sy->out, 1);
1350         params = sy->out[vec_size(sy->out)].block;
1351         if (!params) {
1352             /* 1 param */
1353             paramcount = 1;
1354             vec_push(call->params, sy->out[vec_size(sy->out)].out);
1355         } else {
1356             paramcount = vec_size(params->exprs);
1357             call->params = params->exprs;
1358             params->exprs = NULL;
1359             ast_delete(params);
1360         }
1361         (void)!ast_call_check_types(call);
1362     } else {
1363         parseerror(parser, "invalid function call");
1364         return false;
1365     }
1366
1367     /* overwrite fid, the function, with a call */
1368     sy->out[fid] = syexp(call->expression.node.context, (ast_expression*)call);
1369
1370     if (fun->expression.vtype != TYPE_FUNCTION) {
1371         parseerror(parser, "not a function (%s)", type_name[fun->expression.vtype]);
1372         return false;
1373     }
1374
1375     if (!fun->expression.next) {
1376         parseerror(parser, "could not determine function return type");
1377         return false;
1378     } else {
1379         ast_value *fval = (ast_istype(fun, ast_value) ? ((ast_value*)fun) : NULL);
1380
1381         if (fun->expression.flags & AST_FLAG_DEPRECATED) {
1382             if (!fval) {
1383                 return !parsewarning(parser, WARN_DEPRECATED,
1384                         "call to function (which is marked deprecated)\n",
1385                         "-> it has been declared here: %s:%i",
1386                         ast_ctx(fun).file, ast_ctx(fun).line);
1387             }
1388             if (!fval->desc) {
1389                 return !parsewarning(parser, WARN_DEPRECATED,
1390                         "call to `%s` (which is marked deprecated)\n"
1391                         "-> `%s` declared here: %s:%i",
1392                         fval->name, fval->name, ast_ctx(fun).file, ast_ctx(fun).line);
1393             }
1394             return !parsewarning(parser, WARN_DEPRECATED,
1395                     "call to `%s` (deprecated: %s)\n"
1396                     "-> `%s` declared here: %s:%i",
1397                     fval->name, fval->desc, fval->name, ast_ctx(fun).file,
1398                     ast_ctx(fun).line);
1399         }
1400
1401         if (vec_size(fun->expression.params) != paramcount &&
1402             !((fun->expression.flags & AST_FLAG_VARIADIC) &&
1403               vec_size(fun->expression.params) < paramcount))
1404         {
1405             const char *fewmany = (vec_size(fun->expression.params) > paramcount) ? "few" : "many";
1406             if (fval)
1407                 return !parsewarning(parser, WARN_INVALID_PARAMETER_COUNT,
1408                                      "too %s parameters for call to %s: expected %i, got %i\n"
1409                                      " -> `%s` has been declared here: %s:%i",
1410                                      fewmany, fval->name, (int)vec_size(fun->expression.params), (int)paramcount,
1411                                      fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line);
1412             else
1413                 return !parsewarning(parser, WARN_INVALID_PARAMETER_COUNT,
1414                                      "too %s parameters for function call: expected %i, got %i\n"
1415                                      " -> it has been declared here: %s:%i",
1416                                      fewmany, (int)vec_size(fun->expression.params), (int)paramcount,
1417                                      ast_ctx(fun).file, (int)ast_ctx(fun).line);
1418         }
1419     }
1420
1421     return true;
1422 }
1423
1424 static bool parser_close_paren(parser_t *parser, shunt *sy, bool functions_only)
1425 {
1426     if (!vec_size(sy->ops)) {
1427         parseerror(parser, "unmatched closing paren");
1428         return false;
1429     }
1430     /* this would for bit a + (x) because there are no operators inside (x)
1431     if (sy->ops[vec_size(sy->ops)-1].paren == 1) {
1432         parseerror(parser, "empty parenthesis expression");
1433         return false;
1434     }
1435     */
1436     while (vec_size(sy->ops)) {
1437         if (sy->ops[vec_size(sy->ops)-1].paren == SY_PAREN_FUNC) {
1438             if (!parser_close_call(parser, sy))
1439                 return false;
1440             break;
1441         }
1442         if (sy->ops[vec_size(sy->ops)-1].paren == SY_PAREN_EXPR) {
1443             vec_shrinkby(sy->ops, 1);
1444             return !functions_only;
1445         }
1446         if (sy->ops[vec_size(sy->ops)-1].paren == SY_PAREN_INDEX) {
1447             if (functions_only)
1448                 return false;
1449             /* pop off the parenthesis */
1450             vec_shrinkby(sy->ops, 1);
1451             /* then apply the index operator */
1452             if (!parser_sy_apply_operator(parser, sy))
1453                 return false;
1454             return true;
1455         }
1456         if (sy->ops[vec_size(sy->ops)-1].paren == SY_PAREN_TERNARY) {
1457             if (functions_only)
1458                 return false;
1459             if (vec_last(parser->pot) != POT_TERNARY1) {
1460                 parseerror(parser, "mismatched colon in ternary expression (missing closing paren?)");
1461                 return false;
1462             }
1463             vec_last(parser->pot) = POT_TERNARY2;
1464             /* pop off the parenthesis */
1465             vec_shrinkby(sy->ops, 1);
1466             return true;
1467         }
1468         if (!parser_sy_apply_operator(parser, sy))
1469             return false;
1470     }
1471     return true;
1472 }
1473
1474 static void parser_reclassify_token(parser_t *parser)
1475 {
1476     size_t i;
1477     for (i = 0; i < operator_count; ++i) {
1478         if (!strcmp(parser_tokval(parser), operators[i].op)) {
1479             parser->tok = TOKEN_OPERATOR;
1480             return;
1481         }
1482     }
1483 }
1484
1485 static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma, bool truthvalue)
1486 {
1487     ast_expression *expr = NULL;
1488     shunt sy;
1489     bool wantop = false;
1490     bool gotmemberof = false;
1491     /* only warn once about an assignment in a truth value because the current code
1492      * would trigger twice on: if(a = b && ...), once for the if-truth-value, once for the && part
1493      */
1494     bool warn_truthvalue = true;
1495
1496     /* count the parens because an if starts with one, so the
1497      * end of a condition is an unmatched closing paren
1498      */
1499     int parens = 0;
1500     int ternaries = 0;
1501
1502     sy.out = NULL;
1503     sy.ops = NULL;
1504
1505     parser->lex->flags.noops = false;
1506
1507     parser_reclassify_token(parser);
1508
1509     while (true)
1510     {
1511         if (gotmemberof)
1512             gotmemberof = false;
1513         else
1514             parser->memberof = 0;
1515
1516         if (OPTS_FLAG(TRANSLATABLE_STRINGS) &&
1517             parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "_"))
1518         {
1519             /* a translatable string */
1520             ast_value *val;
1521
1522             if (wantop) {
1523                 parseerror(parser, "expected operator or end of statement, got constant");
1524                 goto onerr;
1525             }
1526
1527             parser->lex->flags.noops = true;
1528             if (!parser_next(parser) || parser->tok != '(') {
1529                 parseerror(parser, "use _(\"string\") to create a translatable string constant");
1530                 goto onerr;
1531             }
1532             parser->lex->flags.noops = false;
1533             if (!parser_next(parser) || parser->tok != TOKEN_STRINGCONST) {
1534                 parseerror(parser, "expected a constant string in translatable-string extension");
1535                 goto onerr;
1536             }
1537             val = parser_const_string(parser, parser_tokval(parser), true);
1538             wantop = true;
1539             if (!val)
1540                 return NULL;
1541             vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val));
1542             DEBUGSHUNTDO(con_out("push string\n"));
1543
1544             if (!parser_next(parser) || parser->tok != ')') {
1545                 parseerror(parser, "expected closing paren after translatable string");
1546                 goto onerr;
1547             }
1548         }
1549         else if (parser->tok == TOKEN_IDENT)
1550         {
1551             ast_expression *var;
1552             if (wantop) {
1553                 parseerror(parser, "expected operator or end of statement");
1554                 goto onerr;
1555             }
1556             wantop = true;
1557             /* variable */
1558             if (opts.standard == COMPILER_GMQCC)
1559             {
1560                 if (parser->memberof == TYPE_ENTITY) {
1561                     /* still get vars first since there could be a fieldpointer */
1562                     var = parser_find_var(parser, parser_tokval(parser));
1563                     if (!var)
1564                         var = parser_find_field(parser, parser_tokval(parser));
1565                 }
1566                 else if (parser->memberof == TYPE_VECTOR)
1567                 {
1568                     parseerror(parser, "TODO: implement effective vector member access");
1569                     goto onerr;
1570                 }
1571                 else if (parser->memberof) {
1572                     parseerror(parser, "namespace for member not found");
1573                     goto onerr;
1574                 }
1575                 else
1576                     var = parser_find_var(parser, parser_tokval(parser));
1577             } else {
1578                 var = parser_find_var(parser, parser_tokval(parser));
1579                 if (!var)
1580                     var = parser_find_field(parser, parser_tokval(parser));
1581             }
1582             if (!var) {
1583                 /* intrinsics */
1584                 if (!strcmp(parser_tokval(parser), "__builtin_debug_typestring")) {
1585                     var = (ast_expression*)intrinsic_debug_typestring;
1586
1587                 }
1588                 else
1589                 {
1590                     parseerror(parser, "unexpected ident: %s", parser_tokval(parser));
1591                     goto onerr;
1592                 }
1593             }
1594             else
1595             {
1596                 if (ast_istype(var, ast_value)) {
1597                     ((ast_value*)var)->uses++;
1598                 }
1599                 else if (ast_istype(var, ast_member)) {
1600                     ast_member *mem = (ast_member*)var;
1601                     if (ast_istype(mem->owner, ast_value))
1602                         ((ast_value*)(mem->owner))->uses++;
1603                 }
1604             }
1605             vec_push(sy.out, syexp(parser_ctx(parser), var));
1606             DEBUGSHUNTDO(con_out("push %s\n", parser_tokval(parser)));
1607         }
1608         else if (parser->tok == TOKEN_FLOATCONST) {
1609             ast_value *val;
1610             if (wantop) {
1611                 parseerror(parser, "expected operator or end of statement, got constant");
1612                 goto onerr;
1613             }
1614             wantop = true;
1615             val = parser_const_float(parser, (parser_token(parser)->constval.f));
1616             if (!val)
1617                 return NULL;
1618             vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val));
1619             DEBUGSHUNTDO(con_out("push %g\n", parser_token(parser)->constval.f));
1620         }
1621         else if (parser->tok == TOKEN_INTCONST || parser->tok == TOKEN_CHARCONST) {
1622             ast_value *val;
1623             if (wantop) {
1624                 parseerror(parser, "expected operator or end of statement, got constant");
1625                 goto onerr;
1626             }
1627             wantop = true;
1628             val = parser_const_float(parser, (double)(parser_token(parser)->constval.i));
1629             if (!val)
1630                 return NULL;
1631             vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val));
1632             DEBUGSHUNTDO(con_out("push %i\n", parser_token(parser)->constval.i));
1633         }
1634         else if (parser->tok == TOKEN_STRINGCONST) {
1635             ast_value *val;
1636             if (wantop) {
1637                 parseerror(parser, "expected operator or end of statement, got constant");
1638                 goto onerr;
1639             }
1640             wantop = true;
1641             val = parser_const_string(parser, parser_tokval(parser), false);
1642             if (!val)
1643                 return NULL;
1644             vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val));
1645             DEBUGSHUNTDO(con_out("push string\n"));
1646         }
1647         else if (parser->tok == TOKEN_VECTORCONST) {
1648             ast_value *val;
1649             if (wantop) {
1650                 parseerror(parser, "expected operator or end of statement, got constant");
1651                 goto onerr;
1652             }
1653             wantop = true;
1654             val = parser_const_vector(parser, parser_token(parser)->constval.v);
1655             if (!val)
1656                 return NULL;
1657             vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val));
1658             DEBUGSHUNTDO(con_out("push '%g %g %g'\n",
1659                                 parser_token(parser)->constval.v.x,
1660                                 parser_token(parser)->constval.v.y,
1661                                 parser_token(parser)->constval.v.z));
1662         }
1663         else if (parser->tok == '(') {
1664             parseerror(parser, "internal error: '(' should be classified as operator");
1665             goto onerr;
1666         }
1667         else if (parser->tok == '[') {
1668             parseerror(parser, "internal error: '[' should be classified as operator");
1669             goto onerr;
1670         }
1671         else if (parser->tok == ')') {
1672             if (wantop) {
1673                 DEBUGSHUNTDO(con_out("do[op] )\n"));
1674                 --parens;
1675                 if (parens < 0)
1676                     break;
1677                 /* we do expect an operator next */
1678                 /* closing an opening paren */
1679                 if (!parser_close_paren(parser, &sy, false))
1680                     goto onerr;
1681                 if (vec_last(parser->pot) != POT_PAREN) {
1682                     parseerror(parser, "mismatched parentheses (closing paren during ternary expression?)");
1683                     goto onerr;
1684                 }
1685                 vec_pop(parser->pot);
1686             } else {
1687                 DEBUGSHUNTDO(con_out("do[nop] )\n"));
1688                 --parens;
1689                 if (parens < 0)
1690                     break;
1691                 /* allowed for function calls */
1692                 if (!parser_close_paren(parser, &sy, true))
1693                     goto onerr;
1694                 if (vec_last(parser->pot) != POT_PAREN) {
1695                     parseerror(parser, "mismatched parentheses (closing paren during ternary expression?)");
1696                     goto onerr;
1697                 }
1698                 vec_pop(parser->pot);
1699             }
1700             wantop = true;
1701         }
1702         else if (parser->tok == ']') {
1703             if (!wantop)
1704                 parseerror(parser, "operand expected");
1705             --parens;
1706             if (parens < 0)
1707                 break;
1708             if (!parser_close_paren(parser, &sy, false))
1709                 goto onerr;
1710             if (vec_last(parser->pot) != POT_PAREN) {
1711                 parseerror(parser, "mismatched parentheses (closing paren during ternary expression?)");
1712                 goto onerr;
1713             }
1714             vec_pop(parser->pot);
1715             wantop = true;
1716         }
1717         else if (parser->tok == TOKEN_TYPENAME) {
1718             parseerror(parser, "unexpected typename");
1719             goto onerr;
1720         }
1721         else if (parser->tok != TOKEN_OPERATOR) {
1722             if (wantop) {
1723                 parseerror(parser, "expected operator or end of statement");
1724                 goto onerr;
1725             }
1726             break;
1727         }
1728         else
1729         {
1730             /* classify the operator */
1731             const oper_info *op;
1732             const oper_info *olast = NULL;
1733             size_t o;
1734             for (o = 0; o < operator_count; ++o) {
1735                 if (((!(operators[o].flags & OP_PREFIX) == !!wantop)) &&
1736                     /* !(operators[o].flags & OP_SUFFIX) && / * remove this */
1737                     !strcmp(parser_tokval(parser), operators[o].op))
1738                 {
1739                     break;
1740                 }
1741             }
1742             if (o == operator_count) {
1743                 /* no operator found... must be the end of the statement */
1744                 break;
1745             }
1746             /* found an operator */
1747             op = &operators[o];
1748
1749             /* when declaring variables, a comma starts a new variable */
1750             if (op->id == opid1(',') && !parens && stopatcomma) {
1751                 /* fixup the token */
1752                 parser->tok = ',';
1753                 break;
1754             }
1755
1756             /* a colon without a pervious question mark cannot be a ternary */
1757             if (!ternaries && op->id == opid2(':','?')) {
1758                 parser->tok = ':';
1759                 break;
1760             }
1761
1762             if (op->id == opid1(',')) {
1763                 if (vec_size(parser->pot) && vec_last(parser->pot) == POT_TERNARY2) {
1764                     (void)!parsewarning(parser, WARN_TERNARY_PRECEDENCE, "suggesting parenthesis around ternary expression");
1765                 }
1766             }
1767
1768             if (vec_size(sy.ops) && !vec_last(sy.ops).paren)
1769                 olast = &operators[vec_last(sy.ops).etype-1];
1770
1771 #define IsAssignOp(x) (\
1772                 (x) == opid1('=') || \
1773                 (x) == opid2('+','=') || \
1774                 (x) == opid2('-','=') || \
1775                 (x) == opid2('*','=') || \
1776                 (x) == opid2('/','=') || \
1777                 (x) == opid2('%','=') || \
1778                 (x) == opid2('&','=') || \
1779                 (x) == opid2('|','=') || \
1780                 (x) == opid3('&','~','=') \
1781                 )
1782             if (warn_truthvalue) {
1783                 if ( (olast && IsAssignOp(olast->id) && (op->id == opid2('&','&') || op->id == opid2('|','|'))) ||
1784                      (olast && IsAssignOp(op->id) && (olast->id == opid2('&','&') || olast->id == opid2('|','|'))) ||
1785                      (truthvalue && !vec_size(parser->pot) && IsAssignOp(op->id))
1786                    )
1787                 {
1788                     (void)!parsewarning(parser, WARN_PARENTHESIS, "suggesting parenthesis around assignment used as truth value");
1789                     warn_truthvalue = false;
1790                 }
1791             }
1792
1793             while (olast && (
1794                     (op->prec < olast->prec) ||
1795                     (op->assoc == ASSOC_LEFT && op->prec <= olast->prec) ) )
1796             {
1797                 if (!parser_sy_apply_operator(parser, &sy))
1798                     goto onerr;
1799                 if (vec_size(sy.ops) && !vec_last(sy.ops).paren)
1800                     olast = &operators[vec_last(sy.ops).etype-1];
1801                 else
1802                     olast = NULL;
1803             }
1804
1805             if (op->id == opid1('.') && opts.standard == COMPILER_GMQCC) {
1806                 /* for gmqcc standard: open up the namespace of the previous type */
1807                 ast_expression *prevex = vec_last(sy.out).out;
1808                 if (!prevex) {
1809                     parseerror(parser, "unexpected member operator");
1810                     goto onerr;
1811                 }
1812                 if (prevex->expression.vtype == TYPE_ENTITY)
1813                     parser->memberof = TYPE_ENTITY;
1814                 else if (prevex->expression.vtype == TYPE_VECTOR)
1815                     parser->memberof = TYPE_VECTOR;
1816                 else {
1817                     parseerror(parser, "type error: type has no members");
1818                     goto onerr;
1819                 }
1820                 gotmemberof = true;
1821             }
1822
1823             if (op->id == opid1('(')) {
1824                 if (wantop) {
1825                     size_t sycount = vec_size(sy.out);
1826                     DEBUGSHUNTDO(con_out("push [op] (\n"));
1827                     ++parens; vec_push(parser->pot, POT_PAREN);
1828                     /* we expected an operator, this is the function-call operator */
1829                     vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_FUNC, sycount-1));
1830                 } else {
1831                     ++parens; vec_push(parser->pot, POT_PAREN);
1832                     vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_EXPR, 0));
1833                     DEBUGSHUNTDO(con_out("push [nop] (\n"));
1834                 }
1835                 wantop = false;
1836             } else if (op->id == opid1('[')) {
1837                 if (!wantop) {
1838                     parseerror(parser, "unexpected array subscript");
1839                     goto onerr;
1840                 }
1841                 ++parens; vec_push(parser->pot, POT_PAREN);
1842                 /* push both the operator and the paren, this makes life easier */
1843                 vec_push(sy.ops, syop(parser_ctx(parser), op));
1844                 vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_INDEX, 0));
1845                 wantop = false;
1846             } else if (op->id == opid2('?',':')) {
1847                 vec_push(sy.ops, syop(parser_ctx(parser), op));
1848                 vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_TERNARY, 0));
1849                 wantop = false;
1850                 ++ternaries;
1851                 vec_push(parser->pot, POT_TERNARY1);
1852             } else if (op->id == opid2(':','?')) {
1853                 if (!vec_size(parser->pot)) {
1854                     parseerror(parser, "unexpected colon outside ternary expression (missing parenthesis?)");
1855                     goto onerr;
1856                 }
1857                 if (vec_last(parser->pot) != POT_TERNARY1) {
1858                     parseerror(parser, "unexpected colon outside ternary expression (missing parenthesis?)");
1859                     goto onerr;
1860                 }
1861                 if (!parser_close_paren(parser, &sy, false))
1862                     goto onerr;
1863                 vec_push(sy.ops, syop(parser_ctx(parser), op));
1864                 wantop = false;
1865                 --ternaries;
1866             } else {
1867                 DEBUGSHUNTDO(con_out("push operator %s\n", op->op));
1868                 vec_push(sy.ops, syop(parser_ctx(parser), op));
1869                 wantop = !!(op->flags & OP_SUFFIX);
1870             }
1871         }
1872         if (!parser_next(parser)) {
1873             goto onerr;
1874         }
1875         if (parser->tok == ';' ||
1876             (!parens && parser->tok == ']'))
1877         {
1878             break;
1879         }
1880     }
1881
1882     while (vec_size(sy.ops)) {
1883         if (!parser_sy_apply_operator(parser, &sy))
1884             goto onerr;
1885     }
1886
1887     parser->lex->flags.noops = true;
1888     if (!vec_size(sy.out)) {
1889         parseerror(parser, "empty expression");
1890         expr = NULL;
1891     } else
1892         expr = sy.out[0].out;
1893     vec_free(sy.out);
1894     vec_free(sy.ops);
1895     DEBUGSHUNTDO(con_out("shunt done\n"));
1896     if (vec_size(parser->pot)) {
1897         parseerror(parser, "internal error: vec_size(parser->pot) = %lu", (unsigned long)vec_size(parser->pot));
1898         return NULL;
1899     }
1900     vec_free(parser->pot);
1901     return expr;
1902
1903 onerr:
1904     parser->lex->flags.noops = true;
1905     vec_free(sy.out);
1906     vec_free(sy.ops);
1907     return NULL;
1908 }
1909
1910 static ast_expression* parse_expression(parser_t *parser, bool stopatcomma)
1911 {
1912     ast_expression *e = parse_expression_leave(parser, stopatcomma, false);
1913     if (!e)
1914         return NULL;
1915     if (!parser_next(parser)) {
1916         ast_delete(e);
1917         return NULL;
1918     }
1919     return e;
1920 }
1921
1922 static void parser_enterblock(parser_t *parser)
1923 {
1924     vec_push(parser->variables, util_htnew(PARSER_HT_SIZE));
1925     vec_push(parser->_blocklocals, vec_size(parser->_locals));
1926     vec_push(parser->typedefs, util_htnew(TYPEDEF_HT_SIZE));
1927     vec_push(parser->_blocktypedefs, vec_size(parser->_typedefs));
1928     vec_push(parser->_block_ctx, parser_ctx(parser));
1929 }
1930
1931 static bool parser_leaveblock(parser_t *parser)
1932 {
1933     bool   rv = true;
1934     size_t locals, typedefs;
1935
1936     if (vec_size(parser->variables) <= PARSER_HT_LOCALS) {
1937         parseerror(parser, "internal error: parser_leaveblock with no block");
1938         return false;
1939     }
1940
1941     util_htdel(vec_last(parser->variables));
1942     vec_pop(parser->variables);
1943     if (!vec_size(parser->_blocklocals)) {
1944         parseerror(parser, "internal error: parser_leaveblock with no block (2)");
1945         return false;
1946     }
1947
1948     locals = vec_last(parser->_blocklocals);
1949     vec_pop(parser->_blocklocals);
1950     while (vec_size(parser->_locals) != locals) {
1951         ast_expression *e = vec_last(parser->_locals);
1952         ast_value      *v = (ast_value*)e;
1953         vec_pop(parser->_locals);
1954         if (ast_istype(e, ast_value) && !v->uses) {
1955             if (compile_warning(ast_ctx(v), WARN_UNUSED_VARIABLE, "unused variable: `%s`", v->name))
1956                 rv = false;
1957         }
1958     }
1959
1960     typedefs = vec_last(parser->_blocktypedefs);
1961     while (vec_size(parser->_typedefs) != typedefs) {
1962         ast_delete(vec_last(parser->_typedefs));
1963         vec_pop(parser->_typedefs);
1964     }
1965     util_htdel(vec_last(parser->typedefs));
1966     vec_pop(parser->typedefs);
1967
1968     vec_pop(parser->_block_ctx);
1969     return rv;
1970 }
1971
1972 static void parser_addlocal(parser_t *parser, const char *name, ast_expression *e)
1973 {
1974     vec_push(parser->_locals, e);
1975     util_htset(vec_last(parser->variables), name, (void*)e);
1976 }
1977
1978 static ast_expression* process_condition(parser_t *parser, ast_expression *cond, bool *_ifnot)
1979 {
1980     bool       ifnot = false;
1981     ast_unary *unary;
1982     ast_expression *prev;
1983
1984     if (OPTS_FLAG(FALSE_EMPTY_STRINGS) && cond->expression.vtype == TYPE_STRING)
1985     {
1986         prev = cond;
1987         cond = (ast_expression*)ast_unary_new(ast_ctx(cond), INSTR_NOT_S, cond);
1988         if (!cond) {
1989             ast_unref(prev);
1990             parseerror(parser, "internal error: failed to process condition");
1991             return NULL;
1992         }
1993         ifnot = !ifnot;
1994     }
1995     else if (OPTS_FLAG(CORRECT_LOGIC) && cond->expression.vtype == TYPE_VECTOR)
1996     {
1997         /* vector types need to be cast to true booleans */
1998         ast_binary *bin = (ast_binary*)cond;
1999         if (!OPTS_FLAG(PERL_LOGIC) || !ast_istype(cond, ast_binary) || !(bin->op == INSTR_AND || bin->op == INSTR_OR))
2000         {
2001             /* in perl-logic, AND and OR take care of the -fcorrect-logic */
2002             prev = cond;
2003             cond = (ast_expression*)ast_unary_new(ast_ctx(cond), INSTR_NOT_V, cond);
2004             if (!cond) {
2005                 ast_unref(prev);
2006                 parseerror(parser, "internal error: failed to process condition");
2007                 return NULL;
2008             }
2009             ifnot = !ifnot;
2010         }
2011     }
2012
2013     unary = (ast_unary*)cond;
2014     while (ast_istype(cond, ast_unary) && unary->op == INSTR_NOT_F)
2015     {
2016         cond = unary->operand;
2017         unary->operand = NULL;
2018         ast_delete(unary);
2019         ifnot = !ifnot;
2020         unary = (ast_unary*)cond;
2021     }
2022
2023     if (!cond)
2024         parseerror(parser, "internal error: failed to process condition");
2025
2026     if (ifnot) *_ifnot = !*_ifnot;
2027     return cond;
2028 }
2029
2030 static bool parse_if(parser_t *parser, ast_block *block, ast_expression **out)
2031 {
2032     ast_ifthen *ifthen;
2033     ast_expression *cond, *ontrue = NULL, *onfalse = NULL;
2034     bool ifnot = false;
2035
2036     lex_ctx ctx = parser_ctx(parser);
2037
2038     (void)block; /* not touching */
2039
2040     /* skip the 'if', parse an optional 'not' and check for an opening paren */
2041     if (!parser_next(parser)) {
2042         parseerror(parser, "expected condition or 'not'");
2043         return false;
2044     }
2045     if (parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "not")) {
2046         ifnot = true;
2047         if (!parser_next(parser)) {
2048             parseerror(parser, "expected condition in parenthesis");
2049             return false;
2050         }
2051     }
2052     if (parser->tok != '(') {
2053         parseerror(parser, "expected 'if' condition in parenthesis");
2054         return false;
2055     }
2056     /* parse into the expression */
2057     if (!parser_next(parser)) {
2058         parseerror(parser, "expected 'if' condition after opening paren");
2059         return false;
2060     }
2061     /* parse the condition */
2062     cond = parse_expression_leave(parser, false, true);
2063     if (!cond)
2064         return false;
2065     /* closing paren */
2066     if (parser->tok != ')') {
2067         parseerror(parser, "expected closing paren after 'if' condition");
2068         ast_delete(cond);
2069         return false;
2070     }
2071     /* parse into the 'then' branch */
2072     if (!parser_next(parser)) {
2073         parseerror(parser, "expected statement for on-true branch of 'if'");
2074         ast_delete(cond);
2075         return false;
2076     }
2077     if (!parse_statement_or_block(parser, &ontrue)) {
2078         ast_delete(cond);
2079         return false;
2080     }
2081     /* check for an else */
2082     if (!strcmp(parser_tokval(parser), "else")) {
2083         /* parse into the 'else' branch */
2084         if (!parser_next(parser)) {
2085             parseerror(parser, "expected on-false branch after 'else'");
2086             ast_delete(ontrue);
2087             ast_delete(cond);
2088             return false;
2089         }
2090         if (!parse_statement_or_block(parser, &onfalse)) {
2091             ast_delete(ontrue);
2092             ast_delete(cond);
2093             return false;
2094         }
2095     }
2096
2097     cond = process_condition(parser, cond, &ifnot);
2098     if (!cond) {
2099         if (ontrue)  ast_delete(ontrue);
2100         if (onfalse) ast_delete(onfalse);
2101         return false;
2102     }
2103
2104     if (ifnot)
2105         ifthen = ast_ifthen_new(ctx, cond, onfalse, ontrue);
2106     else
2107         ifthen = ast_ifthen_new(ctx, cond, ontrue, onfalse);
2108     *out = (ast_expression*)ifthen;
2109     return true;
2110 }
2111
2112 static bool parse_while_go(parser_t *parser, ast_block *block, ast_expression **out);
2113 static bool parse_while(parser_t *parser, ast_block *block, ast_expression **out)
2114 {
2115     bool rv;
2116     char *label = NULL;
2117
2118     /* skip the 'while' and get the body */
2119     if (!parser_next(parser)) {
2120         if (OPTS_FLAG(LOOP_LABELS))
2121             parseerror(parser, "expected loop label or 'while' condition in parenthesis");
2122         else
2123             parseerror(parser, "expected 'while' condition in parenthesis");
2124         return false;
2125     }
2126
2127     if (parser->tok == ':') {
2128         if (!OPTS_FLAG(LOOP_LABELS))
2129             parseerror(parser, "labeled loops not activated, try using -floop-labels");
2130         if (!parser_next(parser) || parser->tok != TOKEN_IDENT) {
2131             parseerror(parser, "expected loop label");
2132             return false;
2133         }
2134         label = util_strdup(parser_tokval(parser));
2135         if (!parser_next(parser)) {
2136             mem_d(label);
2137             parseerror(parser, "expected 'while' condition in parenthesis");
2138             return false;
2139         }
2140     }
2141
2142     if (parser->tok != '(') {
2143         parseerror(parser, "expected 'while' condition in parenthesis");
2144         return false;
2145     }
2146
2147     vec_push(parser->breaks, label);
2148     vec_push(parser->continues, label);
2149
2150     rv = parse_while_go(parser, block, out);
2151     if (label)
2152         mem_d(label);
2153     if (vec_last(parser->breaks) != label || vec_last(parser->continues) != label) {
2154         parseerror(parser, "internal error: label stack corrupted");
2155         rv = false;
2156         ast_delete(*out);
2157         *out = NULL;
2158     }
2159     else {
2160         vec_pop(parser->breaks);
2161         vec_pop(parser->continues);
2162     }
2163     return rv;
2164 }
2165
2166 static bool parse_while_go(parser_t *parser, ast_block *block, ast_expression **out)
2167 {
2168     ast_loop *aloop;
2169     ast_expression *cond, *ontrue;
2170
2171     bool ifnot = false;
2172
2173     lex_ctx ctx = parser_ctx(parser);
2174
2175     (void)block; /* not touching */
2176
2177     /* parse into the expression */
2178     if (!parser_next(parser)) {
2179         parseerror(parser, "expected 'while' condition after opening paren");
2180         return false;
2181     }
2182     /* parse the condition */
2183     cond = parse_expression_leave(parser, false, true);
2184     if (!cond)
2185         return false;
2186     /* closing paren */
2187     if (parser->tok != ')') {
2188         parseerror(parser, "expected closing paren after 'while' condition");
2189         ast_delete(cond);
2190         return false;
2191     }
2192     /* parse into the 'then' branch */
2193     if (!parser_next(parser)) {
2194         parseerror(parser, "expected while-loop body");
2195         ast_delete(cond);
2196         return false;
2197     }
2198     if (!parse_statement_or_block(parser, &ontrue)) {
2199         ast_delete(cond);
2200         return false;
2201     }
2202
2203     cond = process_condition(parser, cond, &ifnot);
2204     if (!cond) {
2205         ast_delete(ontrue);
2206         return false;
2207     }
2208     aloop = ast_loop_new(ctx, NULL, cond, ifnot, NULL, false, NULL, ontrue);
2209     *out = (ast_expression*)aloop;
2210     return true;
2211 }
2212
2213 static bool parse_dowhile_go(parser_t *parser, ast_block *block, ast_expression **out);
2214 static bool parse_dowhile(parser_t *parser, ast_block *block, ast_expression **out)
2215 {
2216     bool rv;
2217     char *label = NULL;
2218
2219     /* skip the 'do' and get the body */
2220     if (!parser_next(parser)) {
2221         if (OPTS_FLAG(LOOP_LABELS))
2222             parseerror(parser, "expected loop label or body");
2223         else
2224             parseerror(parser, "expected loop body");
2225         return false;
2226     }
2227
2228     if (parser->tok == ':') {
2229         if (!OPTS_FLAG(LOOP_LABELS))
2230             parseerror(parser, "labeled loops not activated, try using -floop-labels");
2231         if (!parser_next(parser) || parser->tok != TOKEN_IDENT) {
2232             parseerror(parser, "expected loop label");
2233             return false;
2234         }
2235         label = util_strdup(parser_tokval(parser));
2236         if (!parser_next(parser)) {
2237             mem_d(label);
2238             parseerror(parser, "expected loop body");
2239             return false;
2240         }
2241     }
2242
2243     vec_push(parser->breaks, label);
2244     vec_push(parser->continues, label);
2245
2246     rv = parse_dowhile_go(parser, block, out);
2247     if (label)
2248         mem_d(label);
2249     if (vec_last(parser->breaks) != label || vec_last(parser->continues) != label) {
2250         parseerror(parser, "internal error: label stack corrupted");
2251         rv = false;
2252         ast_delete(*out);
2253         *out = NULL;
2254     }
2255     else {
2256         vec_pop(parser->breaks);
2257         vec_pop(parser->continues);
2258     }
2259     return rv;
2260 }
2261
2262 static bool parse_dowhile_go(parser_t *parser, ast_block *block, ast_expression **out)
2263 {
2264     ast_loop *aloop;
2265     ast_expression *cond, *ontrue;
2266
2267     bool ifnot = false;
2268
2269     lex_ctx ctx = parser_ctx(parser);
2270
2271     (void)block; /* not touching */
2272
2273     if (!parse_statement_or_block(parser, &ontrue))
2274         return false;
2275
2276     /* expect the "while" */
2277     if (parser->tok != TOKEN_KEYWORD ||
2278         strcmp(parser_tokval(parser), "while"))
2279     {
2280         parseerror(parser, "expected 'while' and condition");
2281         ast_delete(ontrue);
2282         return false;
2283     }
2284
2285     /* skip the 'while' and check for opening paren */
2286     if (!parser_next(parser) || parser->tok != '(') {
2287         parseerror(parser, "expected 'while' condition in parenthesis");
2288         ast_delete(ontrue);
2289         return false;
2290     }
2291     /* parse into the expression */
2292     if (!parser_next(parser)) {
2293         parseerror(parser, "expected 'while' condition after opening paren");
2294         ast_delete(ontrue);
2295         return false;
2296     }
2297     /* parse the condition */
2298     cond = parse_expression_leave(parser, false, true);
2299     if (!cond)
2300         return false;
2301     /* closing paren */
2302     if (parser->tok != ')') {
2303         parseerror(parser, "expected closing paren after 'while' condition");
2304         ast_delete(ontrue);
2305         ast_delete(cond);
2306         return false;
2307     }
2308     /* parse on */
2309     if (!parser_next(parser) || parser->tok != ';') {
2310         parseerror(parser, "expected semicolon after condition");
2311         ast_delete(ontrue);
2312         ast_delete(cond);
2313         return false;
2314     }
2315
2316     if (!parser_next(parser)) {
2317         parseerror(parser, "parse error");
2318         ast_delete(ontrue);
2319         ast_delete(cond);
2320         return false;
2321     }
2322
2323     cond = process_condition(parser, cond, &ifnot);
2324     if (!cond) {
2325         ast_delete(ontrue);
2326         return false;
2327     }
2328     aloop = ast_loop_new(ctx, NULL, NULL, false, cond, ifnot, NULL, ontrue);
2329     *out = (ast_expression*)aloop;
2330     return true;
2331 }
2332
2333 static bool parse_for_go(parser_t *parser, ast_block *block, ast_expression **out);
2334 static bool parse_for(parser_t *parser, ast_block *block, ast_expression **out)
2335 {
2336     bool rv;
2337     char *label = NULL;
2338
2339     /* skip the 'for' and check for opening paren */
2340     if (!parser_next(parser)) {
2341         if (OPTS_FLAG(LOOP_LABELS))
2342             parseerror(parser, "expected loop label or 'for' expressions in parenthesis");
2343         else
2344             parseerror(parser, "expected 'for' expressions in parenthesis");
2345         return false;
2346     }
2347
2348     if (parser->tok == ':') {
2349         if (!OPTS_FLAG(LOOP_LABELS))
2350             parseerror(parser, "labeled loops not activated, try using -floop-labels");
2351         if (!parser_next(parser) || parser->tok != TOKEN_IDENT) {
2352             parseerror(parser, "expected loop label");
2353             return false;
2354         }
2355         label = util_strdup(parser_tokval(parser));
2356         if (!parser_next(parser)) {
2357             mem_d(label);
2358             parseerror(parser, "expected 'for' expressions in parenthesis");
2359             return false;
2360         }
2361     }
2362
2363     if (parser->tok != '(') {
2364         parseerror(parser, "expected 'for' expressions in parenthesis");
2365         return false;
2366     }
2367
2368     vec_push(parser->breaks, label);
2369     vec_push(parser->continues, label);
2370
2371     rv = parse_for_go(parser, block, out);
2372     if (label)
2373         mem_d(label);
2374     if (vec_last(parser->breaks) != label || vec_last(parser->continues) != label) {
2375         parseerror(parser, "internal error: label stack corrupted");
2376         rv = false;
2377         ast_delete(*out);
2378         *out = NULL;
2379     }
2380     else {
2381         vec_pop(parser->breaks);
2382         vec_pop(parser->continues);
2383     }
2384     return rv;
2385 }
2386 static bool parse_for_go(parser_t *parser, ast_block *block, ast_expression **out)
2387 {
2388     ast_loop       *aloop;
2389     ast_expression *initexpr, *cond, *increment, *ontrue;
2390     ast_value      *typevar;
2391
2392     bool retval = true;
2393     bool ifnot  = false;
2394
2395     lex_ctx ctx = parser_ctx(parser);
2396
2397     parser_enterblock(parser);
2398
2399     initexpr  = NULL;
2400     cond      = NULL;
2401     increment = NULL;
2402     ontrue    = NULL;
2403
2404     /* parse into the expression */
2405     if (!parser_next(parser)) {
2406         parseerror(parser, "expected 'for' initializer after opening paren");
2407         goto onerr;
2408     }
2409
2410     typevar = NULL;
2411     if (parser->tok == TOKEN_IDENT)
2412         typevar = parser_find_typedef(parser, parser_tokval(parser), 0);
2413
2414     if (typevar || parser->tok == TOKEN_TYPENAME) {
2415         if (opts.standard != COMPILER_GMQCC) {
2416             if (parsewarning(parser, WARN_EXTENSIONS,
2417                              "current standard does not allow variable declarations in for-loop initializers"))
2418                 goto onerr;
2419         }
2420         if (!parse_variable(parser, block, true, CV_VAR, typevar, false, false, 0, NULL))
2421             goto onerr;
2422     }
2423     else if (parser->tok != ';')
2424     {
2425         initexpr = parse_expression_leave(parser, false, false);
2426         if (!initexpr)
2427             goto onerr;
2428     }
2429
2430     /* move on to condition */
2431     if (parser->tok != ';') {
2432         parseerror(parser, "expected semicolon after for-loop initializer");
2433         goto onerr;
2434     }
2435     if (!parser_next(parser)) {
2436         parseerror(parser, "expected for-loop condition");
2437         goto onerr;
2438     }
2439
2440     /* parse the condition */
2441     if (parser->tok != ';') {
2442         cond = parse_expression_leave(parser, false, true);
2443         if (!cond)
2444             goto onerr;
2445     }
2446
2447     /* move on to incrementor */
2448     if (parser->tok != ';') {
2449         parseerror(parser, "expected semicolon after for-loop initializer");
2450         goto onerr;
2451     }
2452     if (!parser_next(parser)) {
2453         parseerror(parser, "expected for-loop condition");
2454         goto onerr;
2455     }
2456
2457     /* parse the incrementor */
2458     if (parser->tok != ')') {
2459         increment = parse_expression_leave(parser, false, false);
2460         if (!increment)
2461             goto onerr;
2462         if (!ast_side_effects(increment)) {
2463             if (genwarning(ast_ctx(increment), WARN_EFFECTLESS_STATEMENT, "statement has no effect"))
2464                 goto onerr;
2465         }
2466     }
2467
2468     /* closing paren */
2469     if (parser->tok != ')') {
2470         parseerror(parser, "expected closing paren after 'for-loop' incrementor");
2471         goto onerr;
2472     }
2473     /* parse into the 'then' branch */
2474     if (!parser_next(parser)) {
2475         parseerror(parser, "expected for-loop body");
2476         goto onerr;
2477     }
2478     if (!parse_statement_or_block(parser, &ontrue))
2479         goto onerr;
2480
2481     if (cond) {
2482         cond = process_condition(parser, cond, &ifnot);
2483         if (!cond)
2484             goto onerr;
2485     }
2486     aloop = ast_loop_new(ctx, initexpr, cond, ifnot, NULL, false, increment, ontrue);
2487     *out = (ast_expression*)aloop;
2488
2489     if (!parser_leaveblock(parser))
2490         retval = false;
2491     return retval;
2492 onerr:
2493     if (initexpr)  ast_delete(initexpr);
2494     if (cond)      ast_delete(cond);
2495     if (increment) ast_delete(increment);
2496     (void)!parser_leaveblock(parser);
2497     return false;
2498 }
2499
2500 static bool parse_return(parser_t *parser, ast_block *block, ast_expression **out)
2501 {
2502     ast_expression *exp = NULL;
2503     ast_return     *ret = NULL;
2504     ast_value      *expected = parser->function->vtype;
2505
2506     lex_ctx ctx = parser_ctx(parser);
2507
2508     (void)block; /* not touching */
2509
2510     if (!parser_next(parser)) {
2511         parseerror(parser, "expected return expression");
2512         return false;
2513     }
2514
2515     if (parser->tok != ';') {
2516         exp = parse_expression(parser, false);
2517         if (!exp)
2518             return false;
2519
2520         if (exp->expression.vtype != TYPE_NIL &&
2521             exp->expression.vtype != expected->expression.next->expression.vtype)
2522         {
2523             parseerror(parser, "return with invalid expression");
2524         }
2525
2526         ret = ast_return_new(ctx, exp);
2527         if (!ret) {
2528             ast_delete(exp);
2529             return false;
2530         }
2531     } else {
2532         if (!parser_next(parser))
2533             parseerror(parser, "parse error");
2534         if (expected->expression.next->expression.vtype != TYPE_VOID) {
2535             if (opts.standard != COMPILER_GMQCC)
2536                 (void)!parsewarning(parser, WARN_MISSING_RETURN_VALUES, "return without value");
2537             else
2538                 parseerror(parser, "return without value");
2539         }
2540         ret = ast_return_new(ctx, NULL);
2541     }
2542     *out = (ast_expression*)ret;
2543     return true;
2544 }
2545
2546 static bool parse_break_continue(parser_t *parser, ast_block *block, ast_expression **out, bool is_continue)
2547 {
2548     size_t       i;
2549     unsigned int levels = 0;
2550     lex_ctx      ctx = parser_ctx(parser);
2551     const char **loops = (is_continue ? parser->continues : parser->breaks);
2552
2553     (void)block; /* not touching */
2554     if (!parser_next(parser)) {
2555         parseerror(parser, "expected semicolon or loop label");
2556         return false;
2557     }
2558
2559     if (parser->tok == TOKEN_IDENT) {
2560         if (!OPTS_FLAG(LOOP_LABELS))
2561             parseerror(parser, "labeled loops not activated, try using -floop-labels");
2562         i = vec_size(loops);
2563         while (i--) {
2564             if (loops[i] && !strcmp(loops[i], parser_tokval(parser)))
2565                 break;
2566             if (!i) {
2567                 parseerror(parser, "no such loop to %s: `%s`",
2568                            (is_continue ? "continue" : "break out of"),
2569                            parser_tokval(parser));
2570                 return false;
2571             }
2572             ++levels;
2573         }
2574         if (!parser_next(parser)) {
2575             parseerror(parser, "expected semicolon");
2576             return false;
2577         }
2578     }
2579
2580     if (parser->tok != ';') {
2581         parseerror(parser, "expected semicolon");
2582         return false;
2583     }
2584
2585     if (!parser_next(parser))
2586         parseerror(parser, "parse error");
2587
2588     *out = (ast_expression*)ast_breakcont_new(ctx, is_continue, levels);
2589     return true;
2590 }
2591
2592 /* returns true when it was a variable qualifier, false otherwise!
2593  * on error, cvq is set to CV_WRONG
2594  */
2595 static bool parse_qualifiers(parser_t *parser, bool with_local, int *cvq, bool *noref, bool *is_static, uint32_t *_flags, char **message)
2596 {
2597     bool had_const    = false;
2598     bool had_var      = false;
2599     bool had_noref    = false;
2600     bool had_attrib   = false;
2601     bool had_static   = false;
2602     uint32_t flags    = 0;
2603
2604     *cvq = CV_NONE;
2605     for (;;) {
2606         if (parser->tok == TOKEN_ATTRIBUTE_OPEN) {
2607             had_attrib = true;
2608             /* parse an attribute */
2609             if (!parser_next(parser)) {
2610                 parseerror(parser, "expected attribute after `[[`");
2611                 *cvq = CV_WRONG;
2612                 return false;
2613             }
2614             if (!strcmp(parser_tokval(parser), "noreturn")) {
2615                 flags |= AST_FLAG_NORETURN;
2616                 if (!parser_next(parser) || parser->tok != TOKEN_ATTRIBUTE_CLOSE) {
2617                     parseerror(parser, "`noreturn` attribute has no parameters, expected `]]`");
2618                     *cvq = CV_WRONG;
2619                     return false;
2620                 }
2621             }
2622             else if (!strcmp(parser_tokval(parser), "noref")) {
2623                 had_noref = true;
2624                 if (!parser_next(parser) || parser->tok != TOKEN_ATTRIBUTE_CLOSE) {
2625                     parseerror(parser, "`noref` attribute has no parameters, expected `]]`");
2626                     *cvq = CV_WRONG;
2627                     return false;
2628                 }
2629             }
2630             else if (!strcmp(parser_tokval(parser), "inline")) {
2631                 flags |= AST_FLAG_INLINE;
2632                 if (!parser_next(parser) || parser->tok != TOKEN_ATTRIBUTE_CLOSE) {
2633                     parseerror(parser, "`noref` attribute has no parameters, expected `]]`");
2634                     *cvq = CV_WRONG;
2635                     return false;
2636                 }
2637             }
2638
2639
2640             else if (!strcmp(parser_tokval(parser), "deprecated") && !(flags & AST_FLAG_DEPRECATED)) {
2641                 flags   |= AST_FLAG_DEPRECATED;
2642                 *message = NULL;
2643
2644                 if (!parser_next(parser)) {
2645                     parseerror(parser, "parse error in attribute");
2646                     goto argerr;
2647                 }
2648
2649                 if (parser->tok == '(') {
2650                     if (!parser_next(parser) || parser->tok != TOKEN_STRINGCONST) {
2651                         parseerror(parser, "`deprecated` attribute missing parameter");
2652                         goto argerr;
2653                     }
2654
2655                     *message = util_strdup(parser_tokval(parser));
2656
2657                     if (!parser_next(parser)) {
2658                         parseerror(parser, "parse error in attribute");
2659                         goto argerr;
2660                     }
2661
2662                     if(parser->tok != ')') {
2663                         parseerror(parser, "`deprecated` attribute expected `)` after parameter");
2664                         goto argerr;
2665                     }
2666
2667                     if (!parser_next(parser)) {
2668                         parseerror(parser, "parse error in attribute");
2669                         goto argerr;
2670                     }
2671                 }
2672                 /* no message */
2673                 if (parser->tok != TOKEN_ATTRIBUTE_CLOSE) {
2674                     parseerror(parser, "`deprecated` attribute expected `]]`");
2675
2676                     argerr: /* ugly */
2677                     if (*message) mem_d(*message);
2678                     *message = NULL;
2679                     *cvq     = CV_WRONG;
2680                     return false;
2681                 }
2682             }
2683             else
2684             {
2685                 /* Skip tokens until we hit a ]] */
2686                 (void)!parsewarning(parser, WARN_UNKNOWN_ATTRIBUTE, "unknown attribute starting with `%s`", parser_tokval(parser));
2687                 while (parser->tok != TOKEN_ATTRIBUTE_CLOSE) {
2688                     if (!parser_next(parser)) {
2689                         parseerror(parser, "error inside attribute");
2690                         *cvq = CV_WRONG;
2691                         return false;
2692                     }
2693                 }
2694             }
2695         }
2696         else if (!strcmp(parser_tokval(parser), "static"))
2697             had_static = true;
2698         else if (!strcmp(parser_tokval(parser), "const"))
2699             had_const = true;
2700         else if (!strcmp(parser_tokval(parser), "var"))
2701             had_var = true;
2702         else if (with_local && !strcmp(parser_tokval(parser), "local"))
2703             had_var = true;
2704         else if (!strcmp(parser_tokval(parser), "noref"))
2705             had_noref = true;
2706         else if (!had_const && !had_var && !had_noref && !had_attrib && !had_static && !flags) {
2707             return false;
2708         }
2709         else
2710             break;
2711         if (!parser_next(parser))
2712             goto onerr;
2713     }
2714     if (had_const)
2715         *cvq = CV_CONST;
2716     else if (had_var)
2717         *cvq = CV_VAR;
2718     else
2719         *cvq = CV_NONE;
2720     *noref     = had_noref;
2721     *is_static = had_static;
2722     *_flags    = flags;
2723     return true;
2724 onerr:
2725     parseerror(parser, "parse error after variable qualifier");
2726     *cvq = CV_WRONG;
2727     return true;
2728 }
2729
2730 static bool parse_switch_go(parser_t *parser, ast_block *block, ast_expression **out);
2731 static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **out)
2732 {
2733     bool rv;
2734     char *label = NULL;
2735
2736     /* skip the 'while' and get the body */
2737     if (!parser_next(parser)) {
2738         if (OPTS_FLAG(LOOP_LABELS))
2739             parseerror(parser, "expected loop label or 'switch' operand in parenthesis");
2740         else
2741             parseerror(parser, "expected 'switch' operand in parenthesis");
2742         return false;
2743     }
2744
2745     if (parser->tok == ':') {
2746         if (!OPTS_FLAG(LOOP_LABELS))
2747             parseerror(parser, "labeled loops not activated, try using -floop-labels");
2748         if (!parser_next(parser) || parser->tok != TOKEN_IDENT) {
2749             parseerror(parser, "expected loop label");
2750             return false;
2751         }
2752         label = util_strdup(parser_tokval(parser));
2753         if (!parser_next(parser)) {
2754             mem_d(label);
2755             parseerror(parser, "expected 'switch' operand in parenthesis");
2756             return false;
2757         }
2758     }
2759
2760     if (parser->tok != '(') {
2761         parseerror(parser, "expected 'switch' operand in parenthesis");
2762         return false;
2763     }
2764
2765     vec_push(parser->breaks, label);
2766
2767     rv = parse_switch_go(parser, block, out);
2768     if (label)
2769         mem_d(label);
2770     if (vec_last(parser->breaks) != label) {
2771         parseerror(parser, "internal error: label stack corrupted");
2772         rv = false;
2773         ast_delete(*out);
2774         *out = NULL;
2775     }
2776     else {
2777         vec_pop(parser->breaks);
2778     }
2779     return rv;
2780 }
2781
2782 static bool parse_switch_go(parser_t *parser, ast_block *block, ast_expression **out)
2783 {
2784     ast_expression *operand;
2785     ast_value      *opval;
2786     ast_value      *typevar;
2787     ast_switch     *switchnode;
2788     ast_switch_case swcase;
2789
2790     int  cvq;
2791     bool noref, is_static;
2792     uint32_t qflags = 0;
2793
2794     lex_ctx ctx = parser_ctx(parser);
2795
2796     (void)block; /* not touching */
2797     (void)opval;
2798
2799     /* parse into the expression */
2800     if (!parser_next(parser)) {
2801         parseerror(parser, "expected switch operand");
2802         return false;
2803     }
2804     /* parse the operand */
2805     operand = parse_expression_leave(parser, false, false);
2806     if (!operand)
2807         return false;
2808
2809     switchnode = ast_switch_new(ctx, operand);
2810
2811     /* closing paren */
2812     if (parser->tok != ')') {
2813         ast_delete(switchnode);
2814         parseerror(parser, "expected closing paren after 'switch' operand");
2815         return false;
2816     }
2817
2818     /* parse over the opening paren */
2819     if (!parser_next(parser) || parser->tok != '{') {
2820         ast_delete(switchnode);
2821         parseerror(parser, "expected list of cases");
2822         return false;
2823     }
2824
2825     if (!parser_next(parser)) {
2826         ast_delete(switchnode);
2827         parseerror(parser, "expected 'case' or 'default'");
2828         return false;
2829     }
2830
2831     /* new block; allow some variables to be declared here */
2832     parser_enterblock(parser);
2833     while (true) {
2834         typevar = NULL;
2835         if (parser->tok == TOKEN_IDENT)
2836             typevar = parser_find_typedef(parser, parser_tokval(parser), 0);
2837         if (typevar || parser->tok == TOKEN_TYPENAME) {
2838             if (!parse_variable(parser, block, false, CV_NONE, typevar, false, false, 0, NULL)) {
2839                 ast_delete(switchnode);
2840                 return false;
2841             }
2842             continue;
2843         }
2844         if (parse_qualifiers(parser, true, &cvq, &noref, &is_static, &qflags, NULL))
2845         {
2846             if (cvq == CV_WRONG) {
2847                 ast_delete(switchnode);
2848                 return false;
2849             }
2850             if (!parse_variable(parser, block, false, cvq, NULL, noref, is_static, qflags, NULL)) {
2851                 ast_delete(switchnode);
2852                 return false;
2853             }
2854             continue;
2855         }
2856         break;
2857     }
2858
2859     /* case list! */
2860     while (parser->tok != '}') {
2861         ast_block *caseblock;
2862
2863         if (!strcmp(parser_tokval(parser), "case")) {
2864             if (!parser_next(parser)) {
2865                 ast_delete(switchnode);
2866                 parseerror(parser, "expected expression for case");
2867                 return false;
2868             }
2869             swcase.value = parse_expression_leave(parser, false, false);
2870             if (!swcase.value) {
2871                 ast_delete(switchnode);
2872                 parseerror(parser, "expected expression for case");
2873                 return false;
2874             }
2875             if (!OPTS_FLAG(RELAXED_SWITCH)) {
2876                 if (!ast_istype(swcase.value, ast_value)) { /* || ((ast_value*)swcase.value)->cvq != CV_CONST) { */
2877                     parseerror(parser, "case on non-constant values need to be explicitly enabled via -frelaxed-switch");
2878                     ast_unref(operand);
2879                     return false;
2880                 }
2881             }
2882         }
2883         else if (!strcmp(parser_tokval(parser), "default")) {
2884             swcase.value = NULL;
2885             if (!parser_next(parser)) {
2886                 ast_delete(switchnode);
2887                 parseerror(parser, "expected colon");
2888                 return false;
2889             }
2890         }
2891         else {
2892             ast_delete(switchnode);
2893             parseerror(parser, "expected 'case' or 'default'");
2894             return false;
2895         }
2896
2897         /* Now the colon and body */
2898         if (parser->tok != ':') {
2899             if (swcase.value) ast_unref(swcase.value);
2900             ast_delete(switchnode);
2901             parseerror(parser, "expected colon");
2902             return false;
2903         }
2904
2905         if (!parser_next(parser)) {
2906             if (swcase.value) ast_unref(swcase.value);
2907             ast_delete(switchnode);
2908             parseerror(parser, "expected statements or case");
2909             return false;
2910         }
2911         caseblock = ast_block_new(parser_ctx(parser));
2912         if (!caseblock) {
2913             if (swcase.value) ast_unref(swcase.value);
2914             ast_delete(switchnode);
2915             return false;
2916         }
2917         swcase.code = (ast_expression*)caseblock;
2918         vec_push(switchnode->cases, swcase);
2919         while (true) {
2920             ast_expression *expr;
2921             if (parser->tok == '}')
2922                 break;
2923             if (parser->tok == TOKEN_KEYWORD) {
2924                 if (!strcmp(parser_tokval(parser), "case") ||
2925                     !strcmp(parser_tokval(parser), "default"))
2926                 {
2927                     break;
2928                 }
2929             }
2930             if (!parse_statement(parser, caseblock, &expr, true)) {
2931                 ast_delete(switchnode);
2932                 return false;
2933             }
2934             if (!expr)
2935                 continue;
2936             if (!ast_block_add_expr(caseblock, expr)) {
2937                 ast_delete(switchnode);
2938                 return false;
2939             }
2940         }
2941     }
2942
2943     parser_leaveblock(parser);
2944
2945     /* closing paren */
2946     if (parser->tok != '}') {
2947         ast_delete(switchnode);
2948         parseerror(parser, "expected closing paren of case list");
2949         return false;
2950     }
2951     if (!parser_next(parser)) {
2952         ast_delete(switchnode);
2953         parseerror(parser, "parse error after switch");
2954         return false;
2955     }
2956     *out = (ast_expression*)switchnode;
2957     return true;
2958 }
2959
2960 static bool parse_goto(parser_t *parser, ast_expression **out)
2961 {
2962     size_t    i;
2963     ast_goto *gt;
2964
2965     if (!parser_next(parser) || parser->tok != TOKEN_IDENT) {
2966         parseerror(parser, "expected label name after `goto`");
2967         return false;
2968     }
2969
2970     gt = ast_goto_new(parser_ctx(parser), parser_tokval(parser));
2971
2972     for (i = 0; i < vec_size(parser->labels); ++i) {
2973         if (!strcmp(parser->labels[i]->name, parser_tokval(parser))) {
2974             ast_goto_set_label(gt, parser->labels[i]);
2975             break;
2976         }
2977     }
2978     if (i == vec_size(parser->labels))
2979         vec_push(parser->gotos, gt);
2980
2981     if (!parser_next(parser) || parser->tok != ';') {
2982         parseerror(parser, "semicolon expected after goto label");
2983         return false;
2984     }
2985     if (!parser_next(parser)) {
2986         parseerror(parser, "parse error after goto");
2987         return false;
2988     }
2989
2990     *out = (ast_expression*)gt;
2991     return true;
2992 }
2993
2994 static bool parse_skipwhite(parser_t *parser)
2995 {
2996     do {
2997         if (!parser_next(parser))
2998             return false;
2999     } while (parser->tok == TOKEN_WHITE && parser->tok < TOKEN_ERROR);
3000     return parser->tok < TOKEN_ERROR;
3001 }
3002
3003 static bool parse_eol(parser_t *parser)
3004 {
3005     if (!parse_skipwhite(parser))
3006         return false;
3007     return parser->tok == TOKEN_EOL;
3008 }
3009
3010 static bool parse_pragma_do(parser_t *parser)
3011 {
3012     if (!parser_next(parser) ||
3013         parser->tok != TOKEN_IDENT ||
3014         strcmp(parser_tokval(parser), "pragma"))
3015     {
3016         parseerror(parser, "expected `pragma` keyword after `#`, got `%s`", parser_tokval(parser));
3017         return false;
3018     }
3019     if (!parse_skipwhite(parser) || parser->tok != TOKEN_IDENT) {
3020         parseerror(parser, "expected pragma, got `%s`", parser_tokval(parser));
3021         return false;
3022     }
3023
3024     if (!strcmp(parser_tokval(parser), "noref")) {
3025         if (!parse_skipwhite(parser) || parser->tok != TOKEN_INTCONST) {
3026             parseerror(parser, "`noref` pragma requires an argument: 0 or 1");
3027             return false;
3028         }
3029         parser->noref = !!parser_token(parser)->constval.i;
3030         if (!parse_eol(parser)) {
3031             parseerror(parser, "parse error after `noref` pragma");
3032             return false;
3033         }
3034     }
3035     else
3036     {
3037         (void)!parsewarning(parser, WARN_UNKNOWN_PRAGMAS, "ignoring #pragma %s", parser_tokval(parser));
3038         return false;
3039     }
3040
3041     return true;
3042 }
3043
3044 static bool parse_pragma(parser_t *parser)
3045 {
3046     bool rv;
3047     parser->lex->flags.preprocessing = true;
3048     parser->lex->flags.mergelines = true;
3049     rv = parse_pragma_do(parser);
3050     if (parser->tok != TOKEN_EOL) {
3051         parseerror(parser, "junk after pragma");
3052         rv = false;
3053     }
3054     parser->lex->flags.preprocessing = false;
3055     parser->lex->flags.mergelines = false;
3056     if (!parser_next(parser)) {
3057         parseerror(parser, "parse error after pragma");
3058         rv = false;
3059     }
3060     return rv;
3061 }
3062
3063 static bool parse_statement(parser_t *parser, ast_block *block, ast_expression **out, bool allow_cases)
3064 {
3065     bool       noref, is_static;
3066     int        cvq     = CV_NONE;
3067     uint32_t   qflags  = 0;
3068     ast_value *typevar = NULL;
3069     char      *vstring = NULL;
3070
3071     *out = NULL;
3072
3073     if (parser->tok == TOKEN_IDENT)
3074         typevar = parser_find_typedef(parser, parser_tokval(parser), 0);
3075
3076     if (typevar || parser->tok == TOKEN_TYPENAME || parser->tok == '.')
3077     {
3078         /* local variable */
3079         if (!block) {
3080             parseerror(parser, "cannot declare a variable from here");
3081             return false;
3082         }
3083         if (opts.standard == COMPILER_QCC) {
3084             if (parsewarning(parser, WARN_EXTENSIONS, "missing 'local' keyword when declaring a local variable"))
3085                 return false;
3086         }
3087         if (!parse_variable(parser, block, false, CV_NONE, typevar, false, false, 0, NULL))
3088             return false;
3089         return true;
3090     }
3091     else if (parse_qualifiers(parser, !!block, &cvq, &noref, &is_static, &qflags, &vstring))
3092     {
3093         if (cvq == CV_WRONG)
3094             return false;
3095         return parse_variable(parser, block, true, cvq, NULL, noref, is_static, qflags, vstring);
3096     }
3097     else if (parser->tok == TOKEN_KEYWORD)
3098     {
3099         if (!strcmp(parser_tokval(parser), "__builtin_debug_printtype"))
3100         {
3101             char ty[1024];
3102             ast_value *tdef;
3103
3104             if (!parser_next(parser)) {
3105                 parseerror(parser, "parse error after __builtin_debug_printtype");
3106                 return false;
3107             }
3108
3109             if (parser->tok == TOKEN_IDENT && (tdef = parser_find_typedef(parser, parser_tokval(parser), 0)))
3110             {
3111                 ast_type_to_string((ast_expression*)tdef, ty, sizeof(ty));
3112                 con_out("__builtin_debug_printtype: `%s`=`%s`\n", tdef->name, ty);
3113                 if (!parser_next(parser)) {
3114                     parseerror(parser, "parse error after __builtin_debug_printtype typename argument");
3115                     return false;
3116                 }
3117             }
3118             else
3119             {
3120                 if (!parse_statement(parser, block, out, allow_cases))
3121                     return false;
3122                 if (!*out)
3123                     con_out("__builtin_debug_printtype: got no output node\n");
3124                 else
3125                 {
3126                     ast_type_to_string(*out, ty, sizeof(ty));
3127                     con_out("__builtin_debug_printtype: `%s`\n", ty);
3128                 }
3129             }
3130             return true;
3131         }
3132         else if (!strcmp(parser_tokval(parser), "return"))
3133         {
3134             return parse_return(parser, block, out);
3135         }
3136         else if (!strcmp(parser_tokval(parser), "if"))
3137         {
3138             return parse_if(parser, block, out);
3139         }
3140         else if (!strcmp(parser_tokval(parser), "while"))
3141         {
3142             return parse_while(parser, block, out);
3143         }
3144         else if (!strcmp(parser_tokval(parser), "do"))
3145         {
3146             return parse_dowhile(parser, block, out);
3147         }
3148         else if (!strcmp(parser_tokval(parser), "for"))
3149         {
3150             if (opts.standard == COMPILER_QCC) {
3151                 if (parsewarning(parser, WARN_EXTENSIONS, "for loops are not recognized in the original Quake C standard, to enable try an alternate standard --std=?"))
3152                     return false;
3153             }
3154             return parse_for(parser, block, out);
3155         }
3156         else if (!strcmp(parser_tokval(parser), "break"))
3157         {
3158             return parse_break_continue(parser, block, out, false);
3159         }
3160         else if (!strcmp(parser_tokval(parser), "continue"))
3161         {
3162             return parse_break_continue(parser, block, out, true);
3163         }
3164         else if (!strcmp(parser_tokval(parser), "switch"))
3165         {
3166             return parse_switch(parser, block, out);
3167         }
3168         else if (!strcmp(parser_tokval(parser), "case") ||
3169                  !strcmp(parser_tokval(parser), "default"))
3170         {
3171             if (!allow_cases) {
3172                 parseerror(parser, "unexpected 'case' label");
3173                 return false;
3174             }
3175             return true;
3176         }
3177         else if (!strcmp(parser_tokval(parser), "goto"))
3178         {
3179             return parse_goto(parser, out);
3180         }
3181         else if (!strcmp(parser_tokval(parser), "typedef"))
3182         {
3183             if (!parser_next(parser)) {
3184                 parseerror(parser, "expected type definition after 'typedef'");
3185                 return false;
3186             }
3187             return parse_typedef(parser);
3188         }
3189         parseerror(parser, "Unexpected keyword");
3190         return false;
3191     }
3192     else if (parser->tok == '{')
3193     {
3194         ast_block *inner;
3195         inner = parse_block(parser);
3196         if (!inner)
3197             return false;
3198         *out = (ast_expression*)inner;
3199         return true;
3200     }
3201     else if (parser->tok == ':')
3202     {
3203         size_t i;
3204         ast_label *label;
3205         if (!parser_next(parser)) {
3206             parseerror(parser, "expected label name");
3207             return false;
3208         }
3209         if (parser->tok != TOKEN_IDENT) {
3210             parseerror(parser, "label must be an identifier");
3211             return false;
3212         }
3213         label = ast_label_new(parser_ctx(parser), parser_tokval(parser));
3214         if (!label)
3215             return false;
3216         vec_push(parser->labels, label);
3217         *out = (ast_expression*)label;
3218         if (!parser_next(parser)) {
3219             parseerror(parser, "parse error after label");
3220             return false;
3221         }
3222         for (i = 0; i < vec_size(parser->gotos); ++i) {
3223             if (!strcmp(parser->gotos[i]->name, label->name)) {
3224                 ast_goto_set_label(parser->gotos[i], label);
3225                 vec_remove(parser->gotos, i, 1);
3226                 --i;
3227             }
3228         }
3229         return true;
3230     }
3231     else if (parser->tok == ';')
3232     {
3233         if (!parser_next(parser)) {
3234             parseerror(parser, "parse error after empty statement");
3235             return false;
3236         }
3237         return true;
3238     }
3239     else
3240     {
3241         ast_expression *exp = parse_expression(parser, false);
3242         if (!exp)
3243             return false;
3244         *out = exp;
3245         if (!ast_side_effects(exp)) {
3246             if (genwarning(ast_ctx(exp), WARN_EFFECTLESS_STATEMENT, "statement has no effect"))
3247                 return false;
3248         }
3249         return true;
3250     }
3251 }
3252
3253 static bool parse_block_into(parser_t *parser, ast_block *block)
3254 {
3255     bool   retval = true;
3256
3257     parser_enterblock(parser);
3258
3259     if (!parser_next(parser)) { /* skip the '{' */
3260         parseerror(parser, "expected function body");
3261         goto cleanup;
3262     }
3263
3264     while (parser->tok != TOKEN_EOF && parser->tok < TOKEN_ERROR)
3265     {
3266         ast_expression *expr = NULL;
3267         if (parser->tok == '}')
3268             break;
3269
3270         if (!parse_statement(parser, block, &expr, false)) {
3271             /* parseerror(parser, "parse error"); */
3272             block = NULL;
3273             goto cleanup;
3274         }
3275         if (!expr)
3276             continue;
3277         if (!ast_block_add_expr(block, expr)) {
3278             ast_delete(block);
3279             block = NULL;
3280             goto cleanup;
3281         }
3282     }
3283
3284     if (parser->tok != '}') {
3285         block = NULL;
3286     } else {
3287         (void)parser_next(parser);
3288     }
3289
3290 cleanup:
3291     if (!parser_leaveblock(parser))
3292         retval = false;
3293     return retval && !!block;
3294 }
3295
3296 static ast_block* parse_block(parser_t *parser)
3297 {
3298     ast_block *block;
3299     block = ast_block_new(parser_ctx(parser));
3300     if (!block)
3301         return NULL;
3302     if (!parse_block_into(parser, block)) {
3303         ast_block_delete(block);
3304         return NULL;
3305     }
3306     return block;
3307 }
3308
3309 static bool parse_statement_or_block(parser_t *parser, ast_expression **out)
3310 {
3311     if (parser->tok == '{') {
3312         *out = (ast_expression*)parse_block(parser);
3313         return !!*out;
3314     }
3315     return parse_statement(parser, NULL, out, false);
3316 }
3317
3318 static bool create_vector_members(ast_value *var, ast_member **me)
3319 {
3320     size_t i;
3321     size_t len = strlen(var->name);
3322
3323     for (i = 0; i < 3; ++i) {
3324         char *name = (char*)mem_a(len+3);
3325         memcpy(name, var->name, len);
3326         name[len+0] = '_';
3327         name[len+1] = 'x'+i;
3328         name[len+2] = 0;
3329         me[i] = ast_member_new(ast_ctx(var), (ast_expression*)var, i, name);
3330         mem_d(name);
3331         if (!me[i])
3332             break;
3333     }
3334     if (i == 3)
3335         return true;
3336
3337     /* unroll */
3338     do { ast_member_delete(me[--i]); } while(i);
3339     return false;
3340 }
3341
3342 static bool parse_function_body(parser_t *parser, ast_value *var)
3343 {
3344     ast_block      *block = NULL;
3345     ast_function   *func;
3346     ast_function   *old;
3347     size_t          parami;
3348
3349     ast_expression *framenum  = NULL;
3350     ast_expression *nextthink = NULL;
3351     /* None of the following have to be deleted */
3352     ast_expression *fld_think = NULL, *fld_nextthink = NULL, *fld_frame = NULL;
3353     ast_expression *gbl_time = NULL, *gbl_self = NULL;
3354     bool            has_frame_think;
3355
3356     bool retval = true;
3357
3358     has_frame_think = false;
3359     old = parser->function;
3360
3361     if (vec_size(parser->gotos) || vec_size(parser->labels)) {
3362         parseerror(parser, "gotos/labels leaking");
3363         return false;
3364     }
3365
3366     if (var->expression.flags & AST_FLAG_VARIADIC) {
3367         if (parsewarning(parser, WARN_VARIADIC_FUNCTION,
3368                          "variadic function with implementation will not be able to access additional parameters"))
3369         {
3370             return false;
3371         }
3372     }
3373
3374     if (parser->tok == '[') {
3375         /* got a frame definition: [ framenum, nextthink ]
3376          * this translates to:
3377          * self.frame = framenum;
3378          * self.nextthink = time + 0.1;
3379          * self.think = nextthink;
3380          */
3381         nextthink = NULL;
3382
3383         fld_think     = parser_find_field(parser, "think");
3384         fld_nextthink = parser_find_field(parser, "nextthink");
3385         fld_frame     = parser_find_field(parser, "frame");
3386         if (!fld_think || !fld_nextthink || !fld_frame) {
3387             parseerror(parser, "cannot use [frame,think] notation without the required fields");
3388             parseerror(parser, "please declare the following entityfields: `frame`, `think`, `nextthink`");
3389             return false;
3390         }
3391         gbl_time      = parser_find_global(parser, "time");
3392         gbl_self      = parser_find_global(parser, "self");
3393         if (!gbl_time || !gbl_self) {
3394             parseerror(parser, "cannot use [frame,think] notation without the required globals");
3395             parseerror(parser, "please declare the following globals: `time`, `self`");
3396             return false;
3397         }
3398
3399         if (!parser_next(parser))
3400             return false;
3401
3402         framenum = parse_expression_leave(parser, true, false);
3403         if (!framenum) {
3404             parseerror(parser, "expected a framenumber constant in[frame,think] notation");
3405             return false;
3406         }
3407         if (!ast_istype(framenum, ast_value) || !( (ast_value*)framenum )->hasvalue) {
3408             ast_unref(framenum);
3409             parseerror(parser, "framenumber in [frame,think] notation must be a constant");
3410             return false;
3411         }
3412
3413         if (parser->tok != ',') {
3414             ast_unref(framenum);
3415             parseerror(parser, "expected comma after frame number in [frame,think] notation");
3416             parseerror(parser, "Got a %i\n", parser->tok);
3417             return false;
3418         }
3419
3420         if (!parser_next(parser)) {
3421             ast_unref(framenum);
3422             return false;
3423         }
3424
3425         if (parser->tok == TOKEN_IDENT && !parser_find_var(parser, parser_tokval(parser)))
3426         {
3427             /* qc allows the use of not-yet-declared functions here
3428              * - this automatically creates a prototype */
3429             ast_value      *thinkfunc;
3430             ast_expression *functype = fld_think->expression.next;
3431
3432             thinkfunc = ast_value_new(parser_ctx(parser), parser_tokval(parser), functype->expression.vtype);
3433             if (!thinkfunc || !ast_type_adopt(thinkfunc, functype)) {
3434                 ast_unref(framenum);
3435                 parseerror(parser, "failed to create implicit prototype for `%s`", parser_tokval(parser));
3436                 return false;
3437             }
3438
3439             if (!parser_next(parser)) {
3440                 ast_unref(framenum);
3441                 ast_delete(thinkfunc);
3442                 return false;
3443             }
3444
3445             vec_push(parser->globals, (ast_expression*)thinkfunc);
3446             util_htset(parser->htglobals, thinkfunc->name, thinkfunc);
3447             nextthink = (ast_expression*)thinkfunc;
3448
3449         } else {
3450             nextthink = parse_expression_leave(parser, true, false);
3451             if (!nextthink) {
3452                 ast_unref(framenum);
3453                 parseerror(parser, "expected a think-function in [frame,think] notation");
3454                 return false;
3455             }
3456         }
3457
3458         if (!ast_istype(nextthink, ast_value)) {
3459             parseerror(parser, "think-function in [frame,think] notation must be a constant");
3460             retval = false;
3461         }
3462
3463         if (retval && parser->tok != ']') {
3464             parseerror(parser, "expected closing `]` for [frame,think] notation");
3465             retval = false;
3466         }
3467
3468         if (retval && !parser_next(parser)) {
3469             retval = false;
3470         }
3471
3472         if (retval && parser->tok != '{') {
3473             parseerror(parser, "a function body has to be declared after a [frame,think] declaration");
3474             retval = false;
3475         }
3476
3477         if (!retval) {
3478             ast_unref(nextthink);
3479             ast_unref(framenum);
3480             return false;
3481         }
3482
3483         has_frame_think = true;
3484     }
3485
3486     block = ast_block_new(parser_ctx(parser));
3487     if (!block) {
3488         parseerror(parser, "failed to allocate block");
3489         if (has_frame_think) {
3490             ast_unref(nextthink);
3491             ast_unref(framenum);
3492         }
3493         return false;
3494     }
3495
3496     if (has_frame_think) {
3497         lex_ctx ctx;
3498         ast_expression *self_frame;
3499         ast_expression *self_nextthink;
3500         ast_expression *self_think;
3501         ast_expression *time_plus_1;
3502         ast_store *store_frame;
3503         ast_store *store_nextthink;
3504         ast_store *store_think;
3505
3506         ctx = parser_ctx(parser);
3507         self_frame     = (ast_expression*)ast_entfield_new(ctx, gbl_self, fld_frame);
3508         self_nextthink = (ast_expression*)ast_entfield_new(ctx, gbl_self, fld_nextthink);
3509         self_think     = (ast_expression*)ast_entfield_new(ctx, gbl_self, fld_think);
3510
3511         time_plus_1    = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_F,
3512                          gbl_time, (ast_expression*)parser_const_float(parser, 0.1));
3513
3514         if (!self_frame || !self_nextthink || !self_think || !time_plus_1) {
3515             if (self_frame)     ast_delete(self_frame);
3516             if (self_nextthink) ast_delete(self_nextthink);
3517             if (self_think)     ast_delete(self_think);
3518             if (time_plus_1)    ast_delete(time_plus_1);
3519             retval = false;
3520         }
3521
3522         if (retval)
3523         {
3524             store_frame     = ast_store_new(ctx, INSTR_STOREP_F,   self_frame,     framenum);
3525             store_nextthink = ast_store_new(ctx, INSTR_STOREP_F,   self_nextthink, time_plus_1);
3526             store_think     = ast_store_new(ctx, INSTR_STOREP_FNC, self_think,     nextthink);
3527
3528             if (!store_frame) {
3529                 ast_delete(self_frame);
3530                 retval = false;
3531             }
3532             if (!store_nextthink) {
3533                 ast_delete(self_nextthink);
3534                 retval = false;
3535             }
3536             if (!store_think) {
3537                 ast_delete(self_think);
3538                 retval = false;
3539             }
3540             if (!retval) {
3541                 if (store_frame)     ast_delete(store_frame);
3542                 if (store_nextthink) ast_delete(store_nextthink);
3543                 if (store_think)     ast_delete(store_think);
3544                 retval = false;
3545             }
3546             if (!ast_block_add_expr(block, (ast_expression*)store_frame) ||
3547                 !ast_block_add_expr(block, (ast_expression*)store_nextthink) ||
3548                 !ast_block_add_expr(block, (ast_expression*)store_think))
3549             {
3550                 retval = false;
3551             }
3552         }
3553
3554         if (!retval) {
3555             parseerror(parser, "failed to generate code for [frame,think]");
3556             ast_unref(nextthink);
3557             ast_unref(framenum);
3558             ast_delete(block);
3559             return false;
3560         }
3561     }
3562
3563     parser_enterblock(parser);
3564
3565     for (parami = 0; parami < vec_size(var->expression.params); ++parami) {
3566         size_t     e;
3567         ast_value *param = var->expression.params[parami];
3568         ast_member *me[3];
3569
3570         if (param->expression.vtype != TYPE_VECTOR &&
3571             (param->expression.vtype != TYPE_FIELD ||
3572              param->expression.next->expression.vtype != TYPE_VECTOR))
3573         {
3574             continue;
3575         }
3576
3577         if (!create_vector_members(param, me)) {
3578             ast_block_delete(block);
3579             return false;
3580         }
3581
3582         for (e = 0; e < 3; ++e) {
3583             parser_addlocal(parser, me[e]->name, (ast_expression*)me[e]);
3584             ast_block_collect(block, (ast_expression*)me[e]);
3585         }
3586     }
3587
3588     func = ast_function_new(ast_ctx(var), var->name, var);
3589     if (!func) {
3590         parseerror(parser, "failed to allocate function for `%s`", var->name);
3591         ast_block_delete(block);
3592         goto enderr;
3593     }
3594     vec_push(parser->functions, func);
3595
3596     parser->function = func;
3597     if (!parse_block_into(parser, block)) {
3598         ast_block_delete(block);
3599         goto enderrfn;
3600     }
3601
3602     vec_push(func->blocks, block);
3603
3604     parser->function = old;
3605     if (!parser_leaveblock(parser))
3606         retval = false;
3607     if (vec_size(parser->variables) != PARSER_HT_LOCALS) {
3608         parseerror(parser, "internal error: local scopes left");
3609         retval = false;
3610     }
3611
3612     if (parser->tok == ';')
3613         return parser_next(parser);
3614     else if (opts.standard == COMPILER_QCC)
3615         parseerror(parser, "missing semicolon after function body (mandatory with -std=qcc)");
3616     return retval;
3617
3618 enderrfn:
3619     vec_pop(parser->functions);
3620     ast_function_delete(func);
3621     var->constval.vfunc = NULL;
3622
3623 enderr:
3624     (void)!parser_leaveblock(parser);
3625     parser->function = old;
3626     return false;
3627 }
3628
3629 static ast_expression *array_accessor_split(
3630     parser_t  *parser,
3631     ast_value *array,
3632     ast_value *index,
3633     size_t     middle,
3634     ast_expression *left,
3635     ast_expression *right
3636     )
3637 {
3638     ast_ifthen *ifthen;
3639     ast_binary *cmp;
3640
3641     lex_ctx ctx = ast_ctx(array);
3642
3643     if (!left || !right) {
3644         if (left)  ast_delete(left);
3645         if (right) ast_delete(right);
3646         return NULL;
3647     }
3648
3649     cmp = ast_binary_new(ctx, INSTR_LT,
3650                          (ast_expression*)index,
3651                          (ast_expression*)parser_const_float(parser, middle));
3652     if (!cmp) {
3653         ast_delete(left);
3654         ast_delete(right);
3655         parseerror(parser, "internal error: failed to create comparison for array setter");
3656         return NULL;
3657     }
3658
3659     ifthen = ast_ifthen_new(ctx, (ast_expression*)cmp, left, right);
3660     if (!ifthen) {
3661         ast_delete(cmp); /* will delete left and right */
3662         parseerror(parser, "internal error: failed to create conditional jump for array setter");
3663         return NULL;
3664     }
3665
3666     return (ast_expression*)ifthen;
3667 }
3668
3669 static ast_expression *array_setter_node(parser_t *parser, ast_value *array, ast_value *index, ast_value *value, size_t from, size_t afterend)
3670 {
3671     lex_ctx ctx = ast_ctx(array);
3672
3673     if (from+1 == afterend) {
3674         /* set this value */
3675         ast_block       *block;
3676         ast_return      *ret;
3677         ast_array_index *subscript;
3678         ast_store       *st;
3679         int assignop = type_store_instr[value->expression.vtype];
3680
3681         if (value->expression.vtype == TYPE_FIELD && value->expression.next->expression.vtype == TYPE_VECTOR)
3682             assignop = INSTR_STORE_V;
3683
3684         subscript = ast_array_index_new(ctx, (ast_expression*)array, (ast_expression*)parser_const_float(parser, from));
3685         if (!subscript)
3686             return NULL;
3687
3688         st = ast_store_new(ctx, assignop, (ast_expression*)subscript, (ast_expression*)value);
3689         if (!st) {
3690             ast_delete(subscript);
3691             return NULL;
3692         }
3693
3694         block = ast_block_new(ctx);
3695         if (!block) {
3696             ast_delete(st);
3697             return NULL;
3698         }
3699
3700         if (!ast_block_add_expr(block, (ast_expression*)st)) {
3701             ast_delete(block);
3702             return NULL;
3703         }
3704
3705         ret = ast_return_new(ctx, NULL);
3706         if (!ret) {
3707             ast_delete(block);
3708             return NULL;
3709         }
3710
3711         if (!ast_block_add_expr(block, (ast_expression*)ret)) {
3712             ast_delete(block);
3713             return NULL;
3714         }
3715
3716         return (ast_expression*)block;
3717     } else {
3718         ast_expression *left, *right;
3719         size_t diff = afterend - from;
3720         size_t middle = from + diff/2;
3721         left  = array_setter_node(parser, array, index, value, from, middle);
3722         right = array_setter_node(parser, array, index, value, middle, afterend);
3723         return array_accessor_split(parser, array, index, middle, left, right);
3724     }
3725 }
3726
3727 static ast_expression *array_field_setter_node(
3728     parser_t  *parser,
3729     ast_value *array,
3730     ast_value *entity,
3731     ast_value *index,
3732     ast_value *value,
3733     size_t     from,
3734     size_t     afterend)
3735 {
3736     lex_ctx ctx = ast_ctx(array);
3737
3738     if (from+1 == afterend) {
3739         /* set this value */
3740         ast_block       *block;
3741         ast_return      *ret;
3742         ast_entfield    *entfield;
3743         ast_array_index *subscript;
3744         ast_store       *st;
3745         int assignop = type_storep_instr[value->expression.vtype];
3746
3747         if (value->expression.vtype == TYPE_FIELD && value->expression.next->expression.vtype == TYPE_VECTOR)
3748             assignop = INSTR_STOREP_V;
3749
3750         subscript = ast_array_index_new(ctx, (ast_expression*)array, (ast_expression*)parser_const_float(parser, from));
3751         if (!subscript)
3752             return NULL;
3753
3754         entfield = ast_entfield_new_force(ctx,
3755                                           (ast_expression*)entity,
3756                                           (ast_expression*)subscript,
3757                                           (ast_expression*)subscript);
3758         if (!entfield) {
3759             ast_delete(subscript);
3760             return NULL;
3761         }
3762
3763         st = ast_store_new(ctx, assignop, (ast_expression*)entfield, (ast_expression*)value);
3764         if (!st) {
3765             ast_delete(entfield);
3766             return NULL;
3767         }
3768
3769         block = ast_block_new(ctx);
3770         if (!block) {
3771             ast_delete(st);
3772             return NULL;
3773         }
3774
3775         if (!ast_block_add_expr(block, (ast_expression*)st)) {
3776             ast_delete(block);
3777             return NULL;
3778         }
3779
3780         ret = ast_return_new(ctx, NULL);
3781         if (!ret) {
3782             ast_delete(block);
3783             return NULL;
3784         }
3785
3786         if (!ast_block_add_expr(block, (ast_expression*)ret)) {
3787             ast_delete(block);
3788             return NULL;
3789         }
3790
3791         return (ast_expression*)block;
3792     } else {
3793         ast_expression *left, *right;
3794         size_t diff = afterend - from;
3795         size_t middle = from + diff/2;
3796         left  = array_field_setter_node(parser, array, entity, index, value, from, middle);
3797         right = array_field_setter_node(parser, array, entity, index, value, middle, afterend);
3798         return array_accessor_split(parser, array, index, middle, left, right);
3799     }
3800 }
3801
3802 static ast_expression *array_getter_node(parser_t *parser, ast_value *array, ast_value *index, size_t from, size_t afterend)
3803 {
3804     lex_ctx ctx = ast_ctx(array);
3805
3806     if (from+1 == afterend) {
3807         ast_return      *ret;
3808         ast_array_index *subscript;
3809
3810         subscript = ast_array_index_new(ctx, (ast_expression*)array, (ast_expression*)parser_const_float(parser, from));
3811         if (!subscript)
3812             return NULL;
3813
3814         ret = ast_return_new(ctx, (ast_expression*)subscript);
3815         if (!ret) {
3816             ast_delete(subscript);
3817             return NULL;
3818         }
3819
3820         return (ast_expression*)ret;
3821     } else {
3822         ast_expression *left, *right;
3823         size_t diff = afterend - from;
3824         size_t middle = from + diff/2;
3825         left  = array_getter_node(parser, array, index, from, middle);
3826         right = array_getter_node(parser, array, index, middle, afterend);
3827         return array_accessor_split(parser, array, index, middle, left, right);
3828     }
3829 }
3830
3831 static bool parser_create_array_accessor(parser_t *parser, ast_value *array, const char *funcname, ast_value **out)
3832 {
3833     ast_function   *func = NULL;
3834     ast_value      *fval = NULL;
3835     ast_block      *body = NULL;
3836
3837     fval = ast_value_new(ast_ctx(array), funcname, TYPE_FUNCTION);
3838     if (!fval) {
3839         parseerror(parser, "failed to create accessor function value");
3840         return false;
3841     }
3842
3843     func = ast_function_new(ast_ctx(array), funcname, fval);
3844     if (!func) {
3845         ast_delete(fval);
3846         parseerror(parser, "failed to create accessor function node");
3847         return false;
3848     }
3849
3850     body = ast_block_new(ast_ctx(array));
3851     if (!body) {
3852         parseerror(parser, "failed to create block for array accessor");
3853         ast_delete(fval);
3854         ast_delete(func);
3855         return false;
3856     }
3857
3858     vec_push(func->blocks, body);
3859     *out = fval;
3860
3861     vec_push(parser->accessors, fval);
3862
3863     return true;
3864 }
3865
3866 static bool parser_create_array_setter(parser_t *parser, ast_value *array, const char *funcname)
3867 {
3868     ast_expression *root = NULL;
3869     ast_value      *index = NULL;
3870     ast_value      *value = NULL;
3871     ast_function   *func;
3872     ast_value      *fval;
3873
3874     if (!ast_istype(array->expression.next, ast_value)) {
3875         parseerror(parser, "internal error: array accessor needs to build an ast_value with a copy of the element type");
3876         return false;
3877     }
3878
3879     if (!parser_create_array_accessor(parser, array, funcname, &fval))
3880         return false;
3881     func = fval->constval.vfunc;
3882     fval->expression.next = (ast_expression*)ast_value_new(ast_ctx(array), "<void>", TYPE_VOID);
3883
3884     index = ast_value_new(ast_ctx(array), "index", TYPE_FLOAT);
3885     value = ast_value_copy((ast_value*)array->expression.next);
3886
3887     if (!index || !value) {
3888         parseerror(parser, "failed to create locals for array accessor");
3889         goto cleanup;
3890     }
3891     (void)!ast_value_set_name(value, "value"); /* not important */
3892     vec_push(fval->expression.params, index);
3893     vec_push(fval->expression.params, value);
3894
3895     root = array_setter_node(parser, array, index, value, 0, array->expression.count);
3896     if (!root) {
3897         parseerror(parser, "failed to build accessor search tree");
3898         goto cleanup;
3899     }
3900
3901     array->setter = fval;
3902     return ast_block_add_expr(func->blocks[0], root);
3903 cleanup:
3904     if (index) ast_delete(index);
3905     if (value) ast_delete(value);
3906     if (root)  ast_delete(root);
3907     ast_delete(func);
3908     ast_delete(fval);
3909     return false;
3910 }
3911
3912 static bool parser_create_array_field_setter(parser_t *parser, ast_value *array, const char *funcname)
3913 {
3914     ast_expression *root = NULL;
3915     ast_value      *entity = NULL;
3916     ast_value      *index = NULL;
3917     ast_value      *value = NULL;
3918     ast_function   *func;
3919     ast_value      *fval;
3920
3921     if (!ast_istype(array->expression.next, ast_value)) {
3922         parseerror(parser, "internal error: array accessor needs to build an ast_value with a copy of the element type");
3923         return false;
3924     }
3925
3926     if (!parser_create_array_accessor(parser, array, funcname, &fval))
3927         return false;
3928     func = fval->constval.vfunc;
3929     fval->expression.next = (ast_expression*)ast_value_new(ast_ctx(array), "<void>", TYPE_VOID);
3930
3931     entity = ast_value_new(ast_ctx(array), "entity", TYPE_ENTITY);
3932     index  = ast_value_new(ast_ctx(array), "index",  TYPE_FLOAT);
3933     value  = ast_value_copy((ast_value*)array->expression.next);
3934     if (!entity || !index || !value) {
3935         parseerror(parser, "failed to create locals for array accessor");
3936         goto cleanup;
3937     }
3938     (void)!ast_value_set_name(value, "value"); /* not important */
3939     vec_push(fval->expression.params, entity);
3940     vec_push(fval->expression.params, index);
3941     vec_push(fval->expression.params, value);
3942
3943     root = array_field_setter_node(parser, array, entity, index, value, 0, array->expression.count);
3944     if (!root) {
3945         parseerror(parser, "failed to build accessor search tree");
3946         goto cleanup;
3947     }
3948
3949     array->setter = fval;
3950     return ast_block_add_expr(func->blocks[0], root);
3951 cleanup:
3952     if (entity) ast_delete(entity);
3953     if (index)  ast_delete(index);
3954     if (value)  ast_delete(value);
3955     if (root)   ast_delete(root);
3956     ast_delete(func);
3957     ast_delete(fval);
3958     return false;
3959 }
3960
3961 static bool parser_create_array_getter(parser_t *parser, ast_value *array, const ast_expression *elemtype, const char *funcname)
3962 {
3963     ast_expression *root = NULL;
3964     ast_value      *index = NULL;
3965     ast_value      *fval;
3966     ast_function   *func;
3967
3968     /* NOTE: checking array->expression.next rather than elemtype since
3969      * for fields elemtype is a temporary fieldtype.
3970      */
3971     if (!ast_istype(array->expression.next, ast_value)) {
3972         parseerror(parser, "internal error: array accessor needs to build an ast_value with a copy of the element type");
3973         return false;
3974     }
3975
3976     if (!parser_create_array_accessor(parser, array, funcname, &fval))
3977         return false;
3978     func = fval->constval.vfunc;
3979     fval->expression.next = ast_type_copy(ast_ctx(array), elemtype);
3980
3981     index = ast_value_new(ast_ctx(array), "index", TYPE_FLOAT);
3982
3983     if (!index) {
3984         parseerror(parser, "failed to create locals for array accessor");
3985         goto cleanup;
3986     }
3987     vec_push(fval->expression.params, index);
3988
3989     root = array_getter_node(parser, array, index, 0, array->expression.count);
3990     if (!root) {
3991         parseerror(parser, "failed to build accessor search tree");
3992         goto cleanup;
3993     }
3994
3995     array->getter = fval;
3996     return ast_block_add_expr(func->blocks[0], root);
3997 cleanup:
3998     if (index) ast_delete(index);
3999     if (root)  ast_delete(root);
4000     ast_delete(func);
4001     ast_delete(fval);
4002     return false;
4003 }
4004
4005 static ast_value *parse_typename(parser_t *parser, ast_value **storebase, ast_value *cached_typedef);
4006 static ast_value *parse_parameter_list(parser_t *parser, ast_value *var)
4007 {
4008     lex_ctx     ctx;
4009     size_t      i;
4010     ast_value **params;
4011     ast_value  *param;
4012     ast_value  *fval;
4013     bool        first = true;
4014     bool        variadic = false;
4015
4016     ctx = parser_ctx(parser);
4017
4018     /* for the sake of less code we parse-in in this function */
4019     if (!parser_next(parser)) {
4020         parseerror(parser, "expected parameter list");
4021         return NULL;
4022     }
4023
4024     params = NULL;
4025
4026     /* parse variables until we hit a closing paren */
4027     while (parser->tok != ')') {
4028         if (!first) {
4029             /* there must be commas between them */
4030             if (parser->tok != ',') {
4031                 parseerror(parser, "expected comma or end of parameter list");
4032                 goto on_error;
4033             }
4034             if (!parser_next(parser)) {
4035                 parseerror(parser, "expected parameter");
4036                 goto on_error;
4037             }
4038         }
4039         first = false;
4040
4041         if (parser->tok == TOKEN_DOTS) {
4042             /* '...' indicates a varargs function */
4043             variadic = true;
4044             if (!parser_next(parser)) {
4045                 parseerror(parser, "expected parameter");
4046                 return NULL;
4047             }
4048             if (parser->tok != ')') {
4049                 parseerror(parser, "`...` must be the last parameter of a variadic function declaration");
4050                 goto on_error;
4051             }
4052         }
4053         else
4054         {
4055             /* for anything else just parse a typename */
4056             param = parse_typename(parser, NULL, NULL);
4057             if (!param)
4058                 goto on_error;
4059             vec_push(params, param);
4060             if (param->expression.vtype >= TYPE_VARIANT) {
4061                 char tname[1024]; /* typename is reserved in C++ */
4062                 ast_type_to_string((ast_expression*)param, tname, sizeof(tname));
4063                 parseerror(parser, "type not supported as part of a parameter list: %s", tname);
4064                 goto on_error;
4065             }
4066         }
4067     }
4068
4069     if (vec_size(params) == 1 && params[0]->expression.vtype == TYPE_VOID)
4070         vec_free(params);
4071
4072     /* sanity check */
4073     if (vec_size(params) > 8 && opts.standard == COMPILER_QCC)
4074         (void)!parsewarning(parser, WARN_EXTENSIONS, "more than 8 parameters are not supported by this standard");
4075
4076     /* parse-out */
4077     if (!parser_next(parser)) {
4078         parseerror(parser, "parse error after typename");
4079         goto on_error;
4080     }
4081
4082     /* now turn 'var' into a function type */
4083     fval = ast_value_new(ctx, "<type()>", TYPE_FUNCTION);
4084     fval->expression.next     = (ast_expression*)var;
4085     if (variadic)
4086         fval->expression.flags |= AST_FLAG_VARIADIC;
4087     var = fval;
4088
4089     var->expression.params = params;
4090     params = NULL;
4091
4092     return var;
4093
4094 on_error:
4095     ast_delete(var);
4096     for (i = 0; i < vec_size(params); ++i)
4097         ast_delete(params[i]);
4098     vec_free(params);
4099     return NULL;
4100 }
4101
4102 static ast_value *parse_arraysize(parser_t *parser, ast_value *var)
4103 {
4104     ast_expression *cexp;
4105     ast_value      *cval, *tmp;
4106     lex_ctx ctx;
4107
4108     ctx = parser_ctx(parser);
4109
4110     if (!parser_next(parser)) {
4111         ast_delete(var);
4112         parseerror(parser, "expected array-size");
4113         return NULL;
4114     }
4115
4116     cexp = parse_expression_leave(parser, true, false);
4117
4118     if (!cexp || !ast_istype(cexp, ast_value)) {
4119         if (cexp)
4120             ast_unref(cexp);
4121         ast_delete(var);
4122         parseerror(parser, "expected array-size as constant positive integer");
4123         return NULL;
4124     }
4125     cval = (ast_value*)cexp;
4126
4127     tmp = ast_value_new(ctx, "<type[]>", TYPE_ARRAY);
4128     tmp->expression.next = (ast_expression*)var;
4129     var = tmp;
4130
4131     if (cval->expression.vtype == TYPE_INTEGER)
4132         tmp->expression.count = cval->constval.vint;
4133     else if (cval->expression.vtype == TYPE_FLOAT)
4134         tmp->expression.count = cval->constval.vfloat;
4135     else {
4136         ast_unref(cexp);
4137         ast_delete(var);
4138         parseerror(parser, "array-size must be a positive integer constant");
4139         return NULL;
4140     }
4141     ast_unref(cexp);
4142
4143     if (parser->tok != ']') {
4144         ast_delete(var);
4145         parseerror(parser, "expected ']' after array-size");
4146         return NULL;
4147     }
4148     if (!parser_next(parser)) {
4149         ast_delete(var);
4150         parseerror(parser, "error after parsing array size");
4151         return NULL;
4152     }
4153     return var;
4154 }
4155
4156 /* Parse a complete typename.
4157  * for single-variables (ie. function parameters or typedefs) storebase should be NULL
4158  * but when parsing variables separated by comma
4159  * 'storebase' should point to where the base-type should be kept.
4160  * The base type makes up every bit of type information which comes *before* the
4161  * variable name.
4162  *
4163  * The following will be parsed in its entirety:
4164  *     void() foo()
4165  * The 'basetype' in this case is 'void()'
4166  * and if there's a comma after it, say:
4167  *     void() foo(), bar
4168  * then the type-information 'void()' can be stored in 'storebase'
4169  */
4170 static ast_value *parse_typename(parser_t *parser, ast_value **storebase, ast_value *cached_typedef)
4171 {
4172     ast_value *var, *tmp;
4173     lex_ctx    ctx;
4174
4175     const char *name = NULL;
4176     bool        isfield  = false;
4177     bool        wasarray = false;
4178     size_t      morefields = 0;
4179
4180     ctx = parser_ctx(parser);
4181
4182     /* types may start with a dot */
4183     if (parser->tok == '.') {
4184         isfield = true;
4185         /* if we parsed a dot we need a typename now */
4186         if (!parser_next(parser)) {
4187             parseerror(parser, "expected typename for field definition");
4188             return NULL;
4189         }
4190
4191         /* Further dots are handled seperately because they won't be part of the
4192          * basetype
4193          */
4194         while (parser->tok == '.') {
4195             ++morefields;
4196             if (!parser_next(parser)) {
4197                 parseerror(parser, "expected typename for field definition");
4198                 return NULL;
4199             }
4200         }
4201     }
4202     if (parser->tok == TOKEN_IDENT)
4203         cached_typedef = parser_find_typedef(parser, parser_tokval(parser), 0);
4204     if (!cached_typedef && parser->tok != TOKEN_TYPENAME) {
4205         parseerror(parser, "expected typename");
4206         return NULL;
4207     }
4208
4209     /* generate the basic type value */
4210     if (cached_typedef) {
4211         var = ast_value_copy(cached_typedef);
4212         ast_value_set_name(var, "<type(from_def)>");
4213     } else
4214         var = ast_value_new(ctx, "<type>", parser_token(parser)->constval.t);
4215
4216     for (; morefields; --morefields) {
4217         tmp = ast_value_new(ctx, "<.type>", TYPE_FIELD);
4218         tmp->expression.next = (ast_expression*)var;
4219         var = tmp;
4220     }
4221
4222     /* do not yet turn into a field - remember:
4223      * .void() foo; is a field too
4224      * .void()() foo; is a function
4225      */
4226
4227     /* parse on */
4228     if (!parser_next(parser)) {
4229         ast_delete(var);
4230         parseerror(parser, "parse error after typename");
4231         return NULL;
4232     }
4233
4234     /* an opening paren now starts the parameter-list of a function
4235      * this is where original-QC has parameter lists.
4236      * We allow a single parameter list here.
4237      * Much like fteqcc we don't allow `float()() x`
4238      */
4239     if (parser->tok == '(') {
4240         var = parse_parameter_list(parser, var);
4241         if (!var)
4242             return NULL;
4243     }
4244
4245     /* store the base if requested */
4246     if (storebase) {
4247         *storebase = ast_value_copy(var);
4248         if (isfield) {
4249             tmp = ast_value_new(ctx, "<type:f>", TYPE_FIELD);
4250             tmp->expression.next = (ast_expression*)*storebase;
4251             *storebase = tmp;
4252         }
4253     }
4254
4255     /* there may be a name now */
4256     if (parser->tok == TOKEN_IDENT) {
4257         name = util_strdup(parser_tokval(parser));
4258         /* parse on */
4259         if (!parser_next(parser)) {
4260             ast_delete(var);
4261             parseerror(parser, "error after variable or field declaration");
4262             return NULL;
4263         }
4264     }
4265
4266     /* now this may be an array */
4267     if (parser->tok == '[') {
4268         wasarray = true;
4269         var = parse_arraysize(parser, var);
4270         if (!var)
4271             return NULL;
4272     }
4273
4274     /* This is the point where we can turn it into a field */
4275     if (isfield) {
4276         /* turn it into a field if desired */
4277         tmp = ast_value_new(ctx, "<type:f>", TYPE_FIELD);
4278         tmp->expression.next = (ast_expression*)var;
4279         var = tmp;
4280     }
4281
4282     /* now there may be function parens again */
4283     if (parser->tok == '(' && opts.standard == COMPILER_QCC)
4284         parseerror(parser, "C-style function syntax is not allowed in -std=qcc");
4285     if (parser->tok == '(' && wasarray)
4286         parseerror(parser, "arrays as part of a return type is not supported");
4287     while (parser->tok == '(') {
4288         var = parse_parameter_list(parser, var);
4289         if (!var) {
4290             if (name)
4291                 mem_d((void*)name);
4292             ast_delete(var);
4293             return NULL;
4294         }
4295     }
4296
4297     /* finally name it */
4298     if (name) {
4299         if (!ast_value_set_name(var, name)) {
4300             ast_delete(var);
4301             parseerror(parser, "internal error: failed to set name");
4302             return NULL;
4303         }
4304         /* free the name, ast_value_set_name duplicates */
4305         mem_d((void*)name);
4306     }
4307
4308     return var;
4309 }
4310
4311 static bool parse_typedef(parser_t *parser)
4312 {
4313     ast_value      *typevar, *oldtype;
4314     ast_expression *old;
4315
4316     typevar = parse_typename(parser, NULL, NULL);
4317
4318     if (!typevar)
4319         return false;
4320
4321     if ( (old = parser_find_var(parser, typevar->name)) ) {
4322         parseerror(parser, "cannot define a type with the same name as a variable: %s\n"
4323                    " -> `%s` has been declared here: %s:%i",
4324                    typevar->name, ast_ctx(old).file, ast_ctx(old).line);
4325         ast_delete(typevar);
4326         return false;
4327     }
4328
4329     if ( (oldtype = parser_find_typedef(parser, typevar->name, vec_last(parser->_blocktypedefs))) ) {
4330         parseerror(parser, "type `%s` has already been declared here: %s:%i",
4331                    typevar->name, ast_ctx(oldtype).file, ast_ctx(oldtype).line);
4332         ast_delete(typevar);
4333         return false;
4334     }
4335
4336     vec_push(parser->_typedefs, typevar);
4337     util_htset(vec_last(parser->typedefs), typevar->name, typevar);
4338
4339     if (parser->tok != ';') {
4340         parseerror(parser, "expected semicolon after typedef");
4341         return false;
4342     }
4343     if (!parser_next(parser)) {
4344         parseerror(parser, "parse error after typedef");
4345         return false;
4346     }
4347
4348     return true;
4349 }
4350
4351 static const char *cvq_to_str(int cvq) {
4352     switch (cvq) {
4353         case CV_NONE:  return "none";
4354         case CV_VAR:   return "`var`";
4355         case CV_CONST: return "`const`";
4356         default:       return "<INVALID>";
4357     }
4358 }
4359
4360 static bool parser_check_qualifiers(parser_t *parser, const ast_value *var, const ast_value *proto)
4361 {
4362     bool av, ao;
4363     if (proto->cvq != var->cvq) {
4364         if (!(proto->cvq == CV_CONST && var->cvq == CV_NONE &&
4365               !OPTS_FLAG(INITIALIZED_NONCONSTANTS) &&
4366               parser->tok == '='))
4367         {
4368             return !parsewarning(parser, WARN_DIFFERENT_QUALIFIERS,
4369                                  "`%s` declared with different qualifiers: %s\n"
4370                                  " -> previous declaration here: %s:%i uses %s",
4371                                  var->name, cvq_to_str(var->cvq),
4372                                  ast_ctx(proto).file, ast_ctx(proto).line,
4373                                  cvq_to_str(proto->cvq));
4374         }
4375     }
4376     av = (var  ->expression.flags & AST_FLAG_NORETURN);
4377     ao = (proto->expression.flags & AST_FLAG_NORETURN);
4378     if (!av != !ao) {
4379         return !parsewarning(parser, WARN_DIFFERENT_ATTRIBUTES,
4380                              "`%s` declared with different attributes%s\n"
4381                              " -> previous declaration here: %s:%i",
4382                              var->name, (av ? ": noreturn" : ""),
4383                              ast_ctx(proto).file, ast_ctx(proto).line,
4384                              (ao ? ": noreturn" : ""));
4385     }
4386     return true;
4387 }
4388
4389 static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, int qualifier, ast_value *cached_typedef, bool noref, bool is_static, uint32_t qflags, char *vstring)
4390 {
4391     ast_value *var;
4392     ast_value *proto;
4393     ast_expression *old;
4394     bool       was_end;
4395     size_t     i;
4396
4397     ast_value *basetype = NULL;
4398     bool      retval    = true;
4399     bool      isparam   = false;
4400     bool      isvector  = false;
4401     bool      cleanvar  = true;
4402     bool      wasarray  = false;
4403
4404     ast_member *me[3];
4405
4406     if (!localblock && is_static)
4407         parseerror(parser, "`static` qualifier is not supported in global scope");
4408
4409     /* get the first complete variable */
4410     var = parse_typename(parser, &basetype, cached_typedef);
4411     if (!var) {
4412         if (basetype)
4413             ast_delete(basetype);
4414         return false;
4415     }
4416
4417     while (true) {
4418         proto = NULL;
4419         wasarray = false;
4420
4421         /* Part 0: finish the type */
4422         if (parser->tok == '(') {
4423             if (opts.standard == COMPILER_QCC)
4424                 parseerror(parser, "C-style function syntax is not allowed in -std=qcc");
4425             var = parse_parameter_list(parser, var);
4426             if (!var) {
4427                 retval = false;
4428                 goto cleanup;
4429             }
4430         }
4431         /* we only allow 1-dimensional arrays */
4432         if (parser->tok == '[') {
4433             wasarray = true;
4434             var = parse_arraysize(parser, var);
4435             if (!var) {
4436                 retval = false;
4437                 goto cleanup;
4438             }
4439         }
4440         if (parser->tok == '(' && wasarray) {
4441             parseerror(parser, "arrays as part of a return type is not supported");
4442             /* we'll still parse the type completely for now */
4443         }
4444         /* for functions returning functions */
4445         while (parser->tok == '(') {
4446             if (opts.standard == COMPILER_QCC)
4447                 parseerror(parser, "C-style function syntax is not allowed in -std=qcc");
4448             var = parse_parameter_list(parser, var);
4449             if (!var) {
4450                 retval = false;
4451                 goto cleanup;
4452             }
4453         }
4454
4455         var->cvq = qualifier;
4456         var->expression.flags |= qflags;
4457         if (var->expression.flags & AST_FLAG_DEPRECATED)
4458             var->desc = vstring;
4459
4460         /* Part 1:
4461          * check for validity: (end_sys_..., multiple-definitions, prototypes, ...)
4462          * Also: if there was a prototype, `var` will be deleted and set to `proto` which
4463          * is then filled with the previous definition and the parameter-names replaced.
4464          */
4465         if (!strcmp(var->name, "nil")) {
4466             if (OPTS_FLAG(UNTYPED_NIL)) {
4467                 if (!localblock || !OPTS_FLAG(PERMISSIVE))
4468                     parseerror(parser, "name `nil` not allowed (try -fpermissive)");
4469             } else
4470                 (void)!parsewarning(parser, WARN_RESERVED_NAMES, "variable name `nil` is reserved");
4471         }
4472         if (!localblock) {
4473             /* Deal with end_sys_ vars */
4474             was_end = false;
4475             if (!strcmp(var->name, "end_sys_globals")) {
4476                 var->uses++;
4477                 parser->crc_globals = vec_size(parser->globals);
4478                 was_end = true;
4479             }
4480             else if (!strcmp(var->name, "end_sys_fields")) {
4481                 var->uses++;
4482                 parser->crc_fields = vec_size(parser->fields);
4483                 was_end = true;
4484             }
4485             if (was_end && var->expression.vtype == TYPE_FIELD) {
4486                 if (parsewarning(parser, WARN_END_SYS_FIELDS,
4487                                  "global '%s' hint should not be a field",
4488                                  parser_tokval(parser)))
4489                 {
4490                     retval = false;
4491                     goto cleanup;
4492                 }
4493             }
4494
4495             if (!nofields && var->expression.vtype == TYPE_FIELD)
4496             {
4497                 /* deal with field declarations */
4498                 old = parser_find_field(parser, var->name);
4499                 if (old) {
4500                     if (parsewarning(parser, WARN_FIELD_REDECLARED, "field `%s` already declared here: %s:%i",
4501                                      var->name, ast_ctx(old).file, (int)ast_ctx(old).line))
4502                     {
4503                         retval = false;
4504                         goto cleanup;
4505                     }
4506                     ast_delete(var);
4507                     var = NULL;
4508                     goto skipvar;
4509                     /*
4510                     parseerror(parser, "field `%s` already declared here: %s:%i",
4511                                var->name, ast_ctx(old).file, ast_ctx(old).line);
4512                     retval = false;
4513                     goto cleanup;
4514                     */
4515                 }
4516                 if (opts.standard == COMPILER_QCC &&
4517                     (old = parser_find_global(parser, var->name)))
4518                 {
4519                     parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc");
4520                     parseerror(parser, "field `%s` already declared here: %s:%i",
4521                                var->name, ast_ctx(old).file, ast_ctx(old).line);
4522                     retval = false;
4523                     goto cleanup;
4524                 }
4525             }
4526             else
4527             {
4528                 /* deal with other globals */
4529                 old = parser_find_global(parser, var->name);
4530                 if (old && var->expression.vtype == TYPE_FUNCTION && old->expression.vtype == TYPE_FUNCTION)
4531                 {
4532                     /* This is a function which had a prototype */
4533                     if (!ast_istype(old, ast_value)) {
4534                         parseerror(parser, "internal error: prototype is not an ast_value");
4535                         retval = false;
4536                         goto cleanup;
4537                     }
4538                     proto = (ast_value*)old;
4539                     proto->desc = var->desc;
4540                     if (!ast_compare_type((ast_expression*)proto, (ast_expression*)var)) {
4541                         parseerror(parser, "conflicting types for `%s`, previous declaration was here: %s:%i",
4542                                    proto->name,
4543                                    ast_ctx(proto).file, ast_ctx(proto).line);
4544                         retval = false;
4545                         goto cleanup;
4546                     }
4547                     /* we need the new parameter-names */
4548                     for (i = 0; i < vec_size(proto->expression.params); ++i)
4549                         ast_value_set_name(proto->expression.params[i], var->expression.params[i]->name);
4550                     if (!parser_check_qualifiers(parser, var, proto)) {
4551                         retval = false;
4552                         if (proto->desc)
4553                             mem_d(proto->desc);
4554                         proto = NULL;
4555                         goto cleanup;
4556                     }
4557                     proto->expression.flags |= var->expression.flags;
4558                     ast_delete(var);
4559                     var = proto;
4560                 }
4561                 else
4562                 {
4563                     /* other globals */
4564                     if (old) {
4565                         if (opts.standard == COMPILER_GMQCC) {
4566                             parseerror(parser, "global `%s` already declared here: %s:%i",
4567                                        var->name, ast_ctx(old).file, ast_ctx(old).line);
4568                             retval = false;
4569                             goto cleanup;
4570                         } else {
4571                             if (parsewarning(parser, WARN_DOUBLE_DECLARATION,
4572                                              "global `%s` already declared here: %s:%i",
4573                                              var->name, ast_ctx(old).file, ast_ctx(old).line))
4574                             {
4575                                 retval = false;
4576                                 goto cleanup;
4577                             }
4578                             proto = (ast_value*)old;
4579                             if (!ast_istype(old, ast_value)) {
4580                                 parseerror(parser, "internal error: not an ast_value");
4581                                 retval = false;
4582                                 proto = NULL;
4583                                 goto cleanup;
4584                             }
4585                             if (!parser_check_qualifiers(parser, var, proto)) {
4586                                 retval = false;
4587                                 proto = NULL;
4588                                 goto cleanup;
4589                             }
4590                             proto->expression.flags |= var->expression.flags;
4591                             ast_delete(var);
4592                             var = proto;
4593                         }
4594                     }
4595                     if (opts.standard == COMPILER_QCC &&
4596                         (old = parser_find_field(parser, var->name)))
4597                     {
4598                         parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc");
4599                         parseerror(parser, "global `%s` already declared here: %s:%i",
4600                                    var->name, ast_ctx(old).file, ast_ctx(old).line);
4601                         retval = false;
4602                         goto cleanup;
4603                     }
4604                 }
4605             }
4606         }
4607         else /* it's not a global */
4608         {
4609             old = parser_find_local(parser, var->name, vec_size(parser->variables)-1, &isparam);
4610             if (old && !isparam) {
4611                 parseerror(parser, "local `%s` already declared here: %s:%i",
4612                            var->name, ast_ctx(old).file, (int)ast_ctx(old).line);
4613                 retval = false;
4614                 goto cleanup;
4615             }
4616             old = parser_find_local(parser, var->name, 0, &isparam);
4617             if (old && isparam) {
4618                 if (parsewarning(parser, WARN_LOCAL_SHADOWS,
4619                                  "local `%s` is shadowing a parameter", var->name))
4620                 {
4621                     parseerror(parser, "local `%s` already declared here: %s:%i",
4622                                var->name, ast_ctx(old).file, (int)ast_ctx(old).line);
4623                     retval = false;
4624                     goto cleanup;
4625                 }
4626                 if (opts.standard != COMPILER_GMQCC) {
4627                     ast_delete(var);
4628                     var = NULL;
4629                     goto skipvar;
4630                 }
4631             }
4632         }
4633
4634         /* in a noref section we simply bump the usecount */
4635         if (noref || parser->noref)
4636             var->uses++;
4637
4638         /* Part 2:
4639          * Create the global/local, and deal with vector types.
4640          */
4641         if (!proto) {
4642             if (var->expression.vtype == TYPE_VECTOR)
4643                 isvector = true;
4644             else if (var->expression.vtype == TYPE_FIELD &&
4645                      var->expression.next->expression.vtype == TYPE_VECTOR)
4646                 isvector = true;
4647
4648             if (isvector) {
4649                 if (!create_vector_members(var, me)) {
4650                     retval = false;
4651                     goto cleanup;
4652                 }
4653             }
4654
4655             if (!localblock) {
4656                 /* deal with global variables, fields, functions */
4657                 if (!nofields && var->expression.vtype == TYPE_FIELD && parser->tok != '=') {
4658                     var->isfield = true;
4659                     vec_push(parser->fields, (ast_expression*)var);
4660                     util_htset(parser->htfields, var->name, var);
4661                     if (isvector) {
4662                         for (i = 0; i < 3; ++i) {
4663                             vec_push(parser->fields, (ast_expression*)me[i]);
4664                             util_htset(parser->htfields, me[i]->name, me[i]);
4665                         }
4666                     }
4667                 }
4668                 else {
4669                     vec_push(parser->globals, (ast_expression*)var);
4670                     util_htset(parser->htglobals, var->name, var);
4671                     if (isvector) {
4672                         for (i = 0; i < 3; ++i) {
4673                             vec_push(parser->globals, (ast_expression*)me[i]);
4674                             util_htset(parser->htglobals, me[i]->name, me[i]);
4675                         }
4676                     }
4677                 }
4678             } else {
4679                 if (is_static) {
4680                     /* a static adds itself to be generated like any other global
4681                      * but is added to the local namespace instead
4682                      */
4683                     char   *defname = NULL;
4684                     size_t  prefix_len, ln;
4685
4686                     ln = strlen(parser->function->name);
4687                     vec_append(defname, ln, parser->function->name);
4688
4689                     vec_append(defname, 2, "::");
4690                     /* remember the length up to here */
4691                     prefix_len = vec_size(defname);
4692
4693                     /* Add it to the local scope */
4694                     util_htset(vec_last(parser->variables), var->name, (void*)var);
4695                     /* now rename the global */
4696                     ln = strlen(var->name);
4697                     vec_append(defname, ln, var->name);
4698                     ast_value_set_name(var, defname);
4699
4700                     /* push it to the to-be-generated globals */
4701                     vec_push(parser->globals, (ast_expression*)var);
4702
4703                     /* same game for the vector members */
4704                     if (isvector) {
4705                         for (i = 0; i < 3; ++i) {
4706                             util_htset(vec_last(parser->variables), me[i]->name, (void*)(me[i]));
4707
4708                             vec_shrinkto(defname, prefix_len);
4709                             ln = strlen(me[i]->name);
4710                             vec_append(defname, ln, me[i]->name);
4711                             ast_member_set_name(me[i], defname);
4712
4713                             vec_push(parser->globals, (ast_expression*)me[i]);
4714                         }
4715                     }
4716                     vec_free(defname);
4717                 } else {
4718                     vec_push(localblock->locals, var);
4719                     parser_addlocal(parser, var->name, (ast_expression*)var);
4720                     if (isvector) {
4721                         for (i = 0; i < 3; ++i) {
4722                             parser_addlocal(parser, me[i]->name, (ast_expression*)me[i]);
4723                             ast_block_collect(localblock, (ast_expression*)me[i]);
4724                         }
4725                     }
4726                 }
4727             }
4728         }
4729         me[0] = me[1] = me[2] = NULL;
4730         cleanvar = false;
4731         /* Part 2.2
4732          * deal with arrays
4733          */
4734         if (var->expression.vtype == TYPE_ARRAY) {
4735             char name[1024];
4736             snprintf(name, sizeof(name), "%s##SET", var->name);
4737             if (!parser_create_array_setter(parser, var, name))
4738                 goto cleanup;
4739             snprintf(name, sizeof(name), "%s##GET", var->name);
4740             if (!parser_create_array_getter(parser, var, var->expression.next, name))
4741                 goto cleanup;
4742         }
4743         else if (!localblock && !nofields &&
4744                  var->expression.vtype == TYPE_FIELD &&
4745                  var->expression.next->expression.vtype == TYPE_ARRAY)
4746         {
4747             char name[1024];
4748             ast_expression *telem;
4749             ast_value      *tfield;
4750             ast_value      *array = (ast_value*)var->expression.next;
4751
4752             if (!ast_istype(var->expression.next, ast_value)) {
4753                 parseerror(parser, "internal error: field element type must be an ast_value");
4754                 goto cleanup;
4755             }
4756
4757             snprintf(name, sizeof(name), "%s##SETF", var->name);
4758             if (!parser_create_array_field_setter(parser, array, name))
4759                 goto cleanup;
4760
4761             telem = ast_type_copy(ast_ctx(var), array->expression.next);
4762             tfield = ast_value_new(ast_ctx(var), "<.type>", TYPE_FIELD);
4763             tfield->expression.next = telem;
4764             snprintf(name, sizeof(name), "%s##GETFP", var->name);
4765             if (!parser_create_array_getter(parser, array, (ast_expression*)tfield, name)) {
4766                 ast_delete(tfield);
4767                 goto cleanup;
4768             }
4769             ast_delete(tfield);
4770         }
4771
4772 skipvar:
4773         if (parser->tok == ';') {
4774             ast_delete(basetype);
4775             if (!parser_next(parser)) {
4776                 parseerror(parser, "error after variable declaration");
4777                 return false;
4778             }
4779             return true;
4780         }
4781
4782         if (parser->tok == ',')
4783             goto another;
4784
4785         /*
4786         if (!var || (!localblock && !nofields && basetype->expression.vtype == TYPE_FIELD)) {
4787         */
4788         if (!var) {
4789             parseerror(parser, "missing comma or semicolon while parsing variables");
4790             break;
4791         }
4792
4793         if (localblock && opts.standard == COMPILER_QCC) {
4794             if (parsewarning(parser, WARN_LOCAL_CONSTANTS,
4795                              "initializing expression turns variable `%s` into a constant in this standard",
4796                              var->name) )
4797             {
4798                 break;
4799             }
4800         }
4801
4802         if (parser->tok != '{') {
4803             if (parser->tok != '=') {
4804                 parseerror(parser, "missing semicolon or initializer, got: `%s`", parser_tokval(parser));
4805                 break;
4806             }
4807
4808             if (!parser_next(parser)) {
4809                 parseerror(parser, "error parsing initializer");
4810                 break;
4811             }
4812         }
4813         else if (opts.standard == COMPILER_QCC) {
4814             parseerror(parser, "expected '=' before function body in this standard");
4815         }
4816
4817         if (parser->tok == '#') {
4818             ast_function *func = NULL;
4819
4820             if (localblock) {
4821                 parseerror(parser, "cannot declare builtins within functions");
4822                 break;
4823             }
4824             if (var->expression.vtype != TYPE_FUNCTION) {
4825                 parseerror(parser, "unexpected builtin number, '%s' is not a function", var->name);
4826                 break;
4827             }
4828             if (!parser_next(parser)) {
4829                 parseerror(parser, "expected builtin number");
4830                 break;
4831             }
4832             if (parser->tok != TOKEN_INTCONST) {
4833                 parseerror(parser, "builtin number must be an integer constant");
4834                 break;
4835             }
4836             if (parser_token(parser)->constval.i < 0) {
4837                 parseerror(parser, "builtin number must be an integer greater than zero");
4838                 break;
4839             }
4840
4841             if (var->hasvalue) {
4842                 (void)!parsewarning(parser, WARN_DOUBLE_DECLARATION,
4843                                     "builtin `%s` has already been defined\n"
4844                                     " -> previous declaration here: %s:%i",
4845                                     var->name, ast_ctx(var).file, (int)ast_ctx(var).line);
4846             }
4847             else
4848             {
4849                 func = ast_function_new(ast_ctx(var), var->name, var);
4850                 if (!func) {
4851                     parseerror(parser, "failed to allocate function for `%s`", var->name);
4852                     break;
4853                 }
4854                 vec_push(parser->functions, func);
4855
4856                 func->builtin = -parser_token(parser)->constval.i-1;
4857             }
4858
4859             if (!parser_next(parser)) {
4860                 parseerror(parser, "expected comma or semicolon");
4861                 if (func)
4862                     ast_function_delete(func);
4863                 var->constval.vfunc = NULL;
4864                 break;
4865             }
4866         }
4867         else if (parser->tok == '{' || parser->tok == '[')
4868         {
4869             if (localblock) {
4870                 parseerror(parser, "cannot declare functions within functions");
4871                 break;
4872             }
4873
4874             if (proto)
4875                 ast_ctx(proto) = parser_ctx(parser);
4876
4877             if (!parse_function_body(parser, var))
4878                 break;
4879             ast_delete(basetype);
4880             for (i = 0; i < vec_size(parser->gotos); ++i)
4881                 parseerror(parser, "undefined label: `%s`", parser->gotos[i]->name);
4882             vec_free(parser->gotos);
4883             vec_free(parser->labels);
4884             return true;
4885         } else {
4886             ast_expression *cexp;
4887             ast_value      *cval;
4888
4889             cexp = parse_expression_leave(parser, true, false);
4890             if (!cexp)
4891                 break;
4892
4893             if (!localblock) {
4894                 cval = (ast_value*)cexp;
4895                 if (cval != parser->nil &&
4896                     (!ast_istype(cval, ast_value) || ((!cval->hasvalue || cval->cvq != CV_CONST) && !cval->isfield))
4897                    )
4898                 {
4899                     parseerror(parser, "cannot initialize a global constant variable with a non-constant expression");
4900                 }
4901                 else
4902                 {
4903                     if (opts.standard != COMPILER_GMQCC &&
4904                         !OPTS_FLAG(INITIALIZED_NONCONSTANTS) &&
4905                         qualifier != CV_VAR)
4906                     {
4907                         var->cvq = CV_CONST;
4908                     }
4909                     if (cval == parser->nil)
4910                         var->expression.flags |= AST_FLAG_INITIALIZED;
4911                     else
4912                     {
4913                         var->hasvalue = true;
4914                         if (cval->expression.vtype == TYPE_STRING)
4915                             var->constval.vstring = parser_strdup(cval->constval.vstring);
4916                         else if (cval->expression.vtype == TYPE_FIELD)
4917                             var->constval.vfield = cval;
4918                         else
4919                             memcpy(&var->constval, &cval->constval, sizeof(var->constval));
4920                         ast_unref(cval);
4921                     }
4922                 }
4923             } else {
4924                 int cvq;
4925                 shunt sy = { NULL, NULL };
4926                 cvq = var->cvq;
4927                 var->cvq = CV_NONE;
4928                 vec_push(sy.out, syexp(ast_ctx(var), (ast_expression*)var));
4929                 vec_push(sy.out, syexp(ast_ctx(cexp), (ast_expression*)cexp));
4930                 vec_push(sy.ops, syop(ast_ctx(var), parser->assign_op));
4931                 if (!parser_sy_apply_operator(parser, &sy))
4932                     ast_unref(cexp);
4933                 else {
4934                     if (vec_size(sy.out) != 1 && vec_size(sy.ops) != 0)
4935                         parseerror(parser, "internal error: leaked operands");
4936                     if (!ast_block_add_expr(localblock, (ast_expression*)sy.out[0].out))
4937                         break;
4938                 }
4939                 vec_free(sy.out);
4940                 vec_free(sy.ops);
4941                 var->cvq = cvq;
4942             }
4943         }
4944
4945 another:
4946         if (parser->tok == ',') {
4947             if (!parser_next(parser)) {
4948                 parseerror(parser, "expected another variable");
4949                 break;
4950             }
4951
4952             if (parser->tok != TOKEN_IDENT) {
4953                 parseerror(parser, "expected another variable");
4954                 break;
4955             }
4956             var = ast_value_copy(basetype);
4957             cleanvar = true;
4958             ast_value_set_name(var, parser_tokval(parser));
4959             if (!parser_next(parser)) {
4960                 parseerror(parser, "error parsing variable declaration");
4961                 break;
4962             }
4963             continue;
4964         }
4965
4966         if (parser->tok != ';') {
4967             parseerror(parser, "missing semicolon after variables");
4968             break;
4969         }
4970
4971         if (!parser_next(parser)) {
4972             parseerror(parser, "parse error after variable declaration");
4973             break;
4974         }
4975
4976         ast_delete(basetype);
4977         return true;
4978     }
4979
4980     if (cleanvar && var)
4981         ast_delete(var);
4982     ast_delete(basetype);
4983     return false;
4984
4985 cleanup:
4986     ast_delete(basetype);
4987     if (cleanvar && var)
4988         ast_delete(var);
4989     if (me[0]) ast_member_delete(me[0]);
4990     if (me[1]) ast_member_delete(me[1]);
4991     if (me[2]) ast_member_delete(me[2]);
4992     return retval;
4993 }
4994
4995 static bool parser_global_statement(parser_t *parser)
4996 {
4997     int        cvq       = CV_WRONG;
4998     bool       noref     = false;
4999     bool       is_static = false;
5000     uint32_t   qflags    = 0;
5001     ast_value *istype    = NULL;
5002     char      *vstring   = NULL;
5003
5004     if (parser->tok == TOKEN_IDENT)
5005         istype = parser_find_typedef(parser, parser_tokval(parser), 0);
5006
5007     if (istype || parser->tok == TOKEN_TYPENAME || parser->tok == '.')
5008     {
5009         return parse_variable(parser, NULL, false, CV_NONE, istype, false, false, 0, NULL);
5010     }
5011     else if (parse_qualifiers(parser, false, &cvq, &noref, &is_static, &qflags, &vstring))
5012     {
5013         if (cvq == CV_WRONG)
5014             return false;
5015         return parse_variable(parser, NULL, true, cvq, NULL, noref, is_static, qflags, vstring);
5016     }
5017     else if (parser->tok == TOKEN_KEYWORD)
5018     {
5019         if (!strcmp(parser_tokval(parser), "typedef")) {
5020             if (!parser_next(parser)) {
5021                 parseerror(parser, "expected type definition after 'typedef'");
5022                 return false;
5023             }
5024             return parse_typedef(parser);
5025         }
5026         parseerror(parser, "unrecognized keyword `%s`", parser_tokval(parser));
5027         return false;
5028     }
5029     else if (parser->tok == '#')
5030     {
5031         return parse_pragma(parser);
5032     }
5033     else if (parser->tok == '$')
5034     {
5035         if (!parser_next(parser)) {
5036             parseerror(parser, "parse error");
5037             return false;
5038         }
5039     }
5040     else
5041     {
5042         parseerror(parser, "unexpected token: %s", parser->lex->tok.value);
5043         return false;
5044     }
5045     return true;
5046 }
5047
5048 static uint16_t progdefs_crc_sum(uint16_t old, const char *str)
5049 {
5050     return util_crc16(old, str, strlen(str));
5051 }
5052
5053 static void progdefs_crc_file(const char *str)
5054 {
5055     /* write to progdefs.h here */
5056     (void)str;
5057 }
5058
5059 static uint16_t progdefs_crc_both(uint16_t old, const char *str)
5060 {
5061     old = progdefs_crc_sum(old, str);
5062     progdefs_crc_file(str);
5063     return old;
5064 }
5065
5066 static void generate_checksum(parser_t *parser)
5067 {
5068     uint16_t   crc = 0xFFFF;
5069     size_t     i;
5070     ast_value *value;
5071
5072     crc = progdefs_crc_both(crc, "\n/* file generated by qcc, do not modify */\n\ntypedef struct\n{");
5073     crc = progdefs_crc_sum(crc, "\tint\tpad[28];\n");
5074     /*
5075     progdefs_crc_file("\tint\tpad;\n");
5076     progdefs_crc_file("\tint\tofs_return[3];\n");
5077     progdefs_crc_file("\tint\tofs_parm0[3];\n");
5078     progdefs_crc_file("\tint\tofs_parm1[3];\n");
5079     progdefs_crc_file("\tint\tofs_parm2[3];\n");
5080     progdefs_crc_file("\tint\tofs_parm3[3];\n");
5081     progdefs_crc_file("\tint\tofs_parm4[3];\n");
5082     progdefs_crc_file("\tint\tofs_parm5[3];\n");
5083     progdefs_crc_file("\tint\tofs_parm6[3];\n");
5084     progdefs_crc_file("\tint\tofs_parm7[3];\n");
5085     */
5086     for (i = 0; i < parser->crc_globals; ++i) {
5087         if (!ast_istype(parser->globals[i], ast_value))
5088             continue;
5089         value = (ast_value*)(parser->globals[i]);
5090         switch (value->expression.vtype) {
5091             case TYPE_FLOAT:    crc = progdefs_crc_both(crc, "\tfloat\t"); break;
5092             case TYPE_VECTOR:   crc = progdefs_crc_both(crc, "\tvec3_t\t"); break;
5093             case TYPE_STRING:   crc = progdefs_crc_both(crc, "\tstring_t\t"); break;
5094             case TYPE_FUNCTION: crc = progdefs_crc_both(crc, "\tfunc_t\t"); break;
5095             default:
5096                 crc = progdefs_crc_both(crc, "\tint\t");
5097                 break;
5098         }
5099         crc = progdefs_crc_both(crc, value->name);
5100         crc = progdefs_crc_both(crc, ";\n");
5101     }
5102     crc = progdefs_crc_both(crc, "} globalvars_t;\n\ntypedef struct\n{\n");
5103     for (i = 0; i < parser->crc_fields; ++i) {
5104         if (!ast_istype(parser->fields[i], ast_value))
5105             continue;
5106         value = (ast_value*)(parser->fields[i]);
5107         switch (value->expression.next->expression.vtype) {
5108             case TYPE_FLOAT:    crc = progdefs_crc_both(crc, "\tfloat\t"); break;
5109             case TYPE_VECTOR:   crc = progdefs_crc_both(crc, "\tvec3_t\t"); break;
5110             case TYPE_STRING:   crc = progdefs_crc_both(crc, "\tstring_t\t"); break;
5111             case TYPE_FUNCTION: crc = progdefs_crc_both(crc, "\tfunc_t\t"); break;
5112             default:
5113                 crc = progdefs_crc_both(crc, "\tint\t");
5114                 break;
5115         }
5116         crc = progdefs_crc_both(crc, value->name);
5117         crc = progdefs_crc_both(crc, ";\n");
5118     }
5119     crc = progdefs_crc_both(crc, "} entvars_t;\n\n");
5120
5121     code_crc = crc;
5122 }
5123
5124 static parser_t *parser;
5125
5126 bool parser_init()
5127 {
5128     lex_ctx empty_ctx;
5129     size_t i;
5130
5131     parser = (parser_t*)mem_a(sizeof(parser_t));
5132     if (!parser)
5133         return false;
5134
5135     memset(parser, 0, sizeof(*parser));
5136
5137     for (i = 0; i < operator_count; ++i) {
5138         if (operators[i].id == opid1('=')) {
5139             parser->assign_op = operators+i;
5140             break;
5141         }
5142     }
5143     if (!parser->assign_op) {
5144         printf("internal error: initializing parser: failed to find assign operator\n");
5145         mem_d(parser);
5146         return false;
5147     }
5148
5149     vec_push(parser->variables, parser->htfields  = util_htnew(PARSER_HT_SIZE));
5150     vec_push(parser->variables, parser->htglobals = util_htnew(PARSER_HT_SIZE));
5151     vec_push(parser->typedefs, util_htnew(TYPEDEF_HT_SIZE));
5152     vec_push(parser->_blocktypedefs, 0);
5153
5154     empty_ctx.file = "<internal>";
5155     empty_ctx.line = 0;
5156     parser->nil = ast_value_new(empty_ctx, "nil", TYPE_NIL);
5157     parser->nil->cvq = CV_CONST;
5158     if (OPTS_FLAG(UNTYPED_NIL))
5159         util_htset(parser->htglobals, "nil", (void*)parser->nil);
5160     return true;
5161 }
5162
5163 bool parser_compile()
5164 {
5165     /* initial lexer/parser state */
5166     parser->lex->flags.noops = true;
5167
5168     if (parser_next(parser))
5169     {
5170         while (parser->tok != TOKEN_EOF && parser->tok < TOKEN_ERROR)
5171         {
5172             if (!parser_global_statement(parser)) {
5173                 if (parser->tok == TOKEN_EOF)
5174                     parseerror(parser, "unexpected eof");
5175                 else if (compile_errors)
5176                     parseerror(parser, "there have been errors, bailing out");
5177                 lex_close(parser->lex);
5178                 parser->lex = NULL;
5179                 return false;
5180             }
5181         }
5182     } else {
5183         parseerror(parser, "parse error");
5184         lex_close(parser->lex);
5185         parser->lex = NULL;
5186         return false;
5187     }
5188
5189     lex_close(parser->lex);
5190     parser->lex = NULL;
5191
5192     return !compile_errors;
5193 }
5194
5195 bool parser_compile_file(const char *filename)
5196 {
5197     parser->lex = lex_open(filename);
5198     if (!parser->lex) {
5199         con_err("failed to open file \"%s\"\n", filename);
5200         return false;
5201     }
5202     return parser_compile();
5203 }
5204
5205 bool parser_compile_string(const char *name, const char *str, size_t len)
5206 {
5207     parser->lex = lex_open_string(str, len, name);
5208     if (!parser->lex) {
5209         con_err("failed to create lexer for string \"%s\"\n", name);
5210         return false;
5211     }
5212     return parser_compile();
5213 }
5214
5215 void parser_cleanup()
5216 {
5217     size_t i;
5218     for (i = 0; i < vec_size(parser->accessors); ++i) {
5219         ast_delete(parser->accessors[i]->constval.vfunc);
5220         parser->accessors[i]->constval.vfunc = NULL;
5221         ast_delete(parser->accessors[i]);
5222     }
5223     for (i = 0; i < vec_size(parser->functions); ++i) {
5224         ast_delete(parser->functions[i]);
5225     }
5226     for (i = 0; i < vec_size(parser->imm_vector); ++i) {
5227         ast_delete(parser->imm_vector[i]);
5228     }
5229     for (i = 0; i < vec_size(parser->imm_string); ++i) {
5230         ast_delete(parser->imm_string[i]);
5231     }
5232     for (i = 0; i < vec_size(parser->imm_float); ++i) {
5233         ast_delete(parser->imm_float[i]);
5234     }
5235     for (i = 0; i < vec_size(parser->fields); ++i) {
5236         ast_delete(parser->fields[i]);
5237     }
5238     for (i = 0; i < vec_size(parser->globals); ++i) {
5239         ast_delete(parser->globals[i]);
5240     }
5241     vec_free(parser->accessors);
5242     vec_free(parser->functions);
5243     vec_free(parser->imm_vector);
5244     vec_free(parser->imm_string);
5245     vec_free(parser->imm_float);
5246     vec_free(parser->globals);
5247     vec_free(parser->fields);
5248
5249     for (i = 0; i < vec_size(parser->variables); ++i)
5250         util_htdel(parser->variables[i]);
5251     vec_free(parser->variables);
5252     vec_free(parser->_blocklocals);
5253     vec_free(parser->_locals);
5254
5255     for (i = 0; i < vec_size(parser->_typedefs); ++i)
5256         ast_delete(parser->_typedefs[i]);
5257     vec_free(parser->_typedefs);
5258     for (i = 0; i < vec_size(parser->typedefs); ++i)
5259         util_htdel(parser->typedefs[i]);
5260     vec_free(parser->typedefs);
5261     vec_free(parser->_blocktypedefs);
5262
5263     vec_free(parser->_block_ctx);
5264
5265     vec_free(parser->labels);
5266     vec_free(parser->gotos);
5267     vec_free(parser->breaks);
5268     vec_free(parser->continues);
5269
5270     ast_value_delete(parser->nil);
5271
5272     mem_d(parser);
5273 }
5274
5275 bool parser_finish(const char *output)
5276 {
5277     size_t i;
5278     ir_builder *ir;
5279     bool retval = true;
5280
5281     if (compile_errors) {
5282         con_out("*** there were compile errors\n");
5283         return false;
5284     }
5285
5286     ir = ir_builder_new("gmqcc_out");
5287     if (!ir) {
5288         con_out("failed to allocate builder\n");
5289         return false;
5290     }
5291
5292     for (i = 0; i < vec_size(parser->fields); ++i) {
5293         ast_value *field;
5294         bool hasvalue;
5295         if (!ast_istype(parser->fields[i], ast_value))
5296             continue;
5297         field = (ast_value*)parser->fields[i];
5298         hasvalue = field->hasvalue;
5299         field->hasvalue = false;
5300         if (!ast_global_codegen((ast_value*)field, ir, true)) {
5301             con_out("failed to generate field %s\n", field->name);
5302             ir_builder_delete(ir);
5303             return false;
5304         }
5305         if (hasvalue) {
5306             ir_value *ifld;
5307             ast_expression *subtype;
5308             field->hasvalue = true;
5309             subtype = field->expression.next;
5310             ifld = ir_builder_create_field(ir, field->name, subtype->expression.vtype);
5311             if (subtype->expression.vtype == TYPE_FIELD)
5312                 ifld->fieldtype = subtype->expression.next->expression.vtype;
5313             else if (subtype->expression.vtype == TYPE_FUNCTION)
5314                 ifld->outtype = subtype->expression.next->expression.vtype;
5315             (void)!ir_value_set_field(field->ir_v, ifld);
5316         }
5317     }
5318     for (i = 0; i < vec_size(parser->globals); ++i) {
5319         ast_value *asvalue;
5320         if (!ast_istype(parser->globals[i], ast_value))
5321             continue;
5322         asvalue = (ast_value*)(parser->globals[i]);
5323         if (!asvalue->uses && !asvalue->hasvalue && asvalue->expression.vtype != TYPE_FUNCTION) {
5324             retval = retval && !genwarning(ast_ctx(asvalue), WARN_UNUSED_VARIABLE,
5325                                            "unused global: `%s`", asvalue->name);
5326         }
5327         if (!ast_global_codegen(asvalue, ir, false)) {
5328             con_out("failed to generate global %s\n", asvalue->name);
5329             ir_builder_delete(ir);
5330             return false;
5331         }
5332     }
5333     for (i = 0; i < vec_size(parser->imm_float); ++i) {
5334         if (!ast_global_codegen(parser->imm_float[i], ir, false)) {
5335             con_out("failed to generate global %s\n", parser->imm_float[i]->name);
5336             ir_builder_delete(ir);
5337             return false;
5338         }
5339     }
5340     for (i = 0; i < vec_size(parser->imm_string); ++i) {
5341         if (!ast_global_codegen(parser->imm_string[i], ir, false)) {
5342             con_out("failed to generate global %s\n", parser->imm_string[i]->name);
5343             ir_builder_delete(ir);
5344             return false;
5345         }
5346     }
5347     for (i = 0; i < vec_size(parser->imm_vector); ++i) {
5348         if (!ast_global_codegen(parser->imm_vector[i], ir, false)) {
5349             con_out("failed to generate global %s\n", parser->imm_vector[i]->name);
5350             ir_builder_delete(ir);
5351             return false;
5352         }
5353     }
5354     for (i = 0; i < vec_size(parser->globals); ++i) {
5355         ast_value *asvalue;
5356         if (!ast_istype(parser->globals[i], ast_value))
5357             continue;
5358         asvalue = (ast_value*)(parser->globals[i]);
5359         if (!(asvalue->expression.flags & AST_FLAG_INITIALIZED))
5360         {
5361             if (asvalue->cvq == CV_CONST && !asvalue->hasvalue)
5362                 (void)!compile_warning(ast_ctx(asvalue), WARN_UNINITIALIZED_CONSTANT,
5363                                        "uninitialized constant: `%s`",
5364                                        asvalue->name);
5365             else if ((asvalue->cvq == CV_NONE || asvalue->cvq == CV_CONST) && !asvalue->hasvalue)
5366                 (void)!compile_warning(ast_ctx(asvalue), WARN_UNINITIALIZED_GLOBAL,
5367                                        "uninitialized global: `%s`",
5368                                        asvalue->name);
5369         }
5370         if (!ast_generate_accessors(asvalue, ir)) {
5371             ir_builder_delete(ir);
5372             return false;
5373         }
5374     }
5375     for (i = 0; i < vec_size(parser->fields); ++i) {
5376         ast_value *asvalue;
5377         asvalue = (ast_value*)(parser->fields[i]->expression.next);
5378
5379         if (!ast_istype((ast_expression*)asvalue, ast_value))
5380             continue;
5381         if (asvalue->expression.vtype != TYPE_ARRAY)
5382             continue;
5383         if (!ast_generate_accessors(asvalue, ir)) {
5384             ir_builder_delete(ir);
5385             return false;
5386         }
5387     }
5388     for (i = 0; i < vec_size(parser->functions); ++i) {
5389         if (!ast_function_codegen(parser->functions[i], ir)) {
5390             con_out("failed to generate function %s\n", parser->functions[i]->name);
5391             ir_builder_delete(ir);
5392             return false;
5393         }
5394     }
5395     if (opts.dump)
5396         ir_builder_dump(ir, con_out);
5397     for (i = 0; i < vec_size(parser->functions); ++i) {
5398         if (!ir_function_finalize(parser->functions[i]->ir_func)) {
5399             con_out("failed to finalize function %s\n", parser->functions[i]->name);
5400             ir_builder_delete(ir);
5401             return false;
5402         }
5403     }
5404
5405     if (compile_Werrors) {
5406         con_out("*** there were warnings treated as errors\n");
5407         compile_show_werrors();
5408         retval = false;
5409     }
5410
5411     if (retval) {
5412         if (opts.dumpfin)
5413             ir_builder_dump(ir, con_out);
5414
5415         generate_checksum(parser);
5416
5417         if (!ir_builder_generate(ir, output)) {
5418             con_out("*** failed to generate output file\n");
5419             ir_builder_delete(ir);
5420             return false;
5421         }
5422     }
5423
5424     ir_builder_delete(ir);
5425     return retval;
5426 }