parser.c

   1 /*
   2  * Copyright (C) 2012, 2013
   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 <string.h>
  25 #include <math.h>
  26 #include "parser.h"
  27
  28 #define PARSER_HT_LOCALS  2
  29 #define PARSER_HT_SIZE    512
  30 #define TYPEDEF_HT_SIZE   512
  31
  32 static void parser_enterblock(parser_t *parser);
  33 static bool parser_leaveblock(parser_t *parser);
  34 static void parser_addlocal(parser_t *parser, const char *name, ast_expression *e);
  35 static void parser_addglobal(parser_t *parser, const char *name, ast_expression *e);
  36 static bool parse_typedef(parser_t *parser);
  37 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);
  38 static ast_block* parse_block(parser_t *parser);
  39 static bool parse_block_into(parser_t *parser, ast_block *block);
  40 static bool parse_statement_or_block(parser_t *parser, ast_expression **out);
  41 static bool parse_statement(parser_t *parser, ast_block *block, ast_expression **out, bool allow_cases);
  42 static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma, bool truthvalue, bool with_labels);
  43 static ast_expression* parse_expression(parser_t *parser, bool stopatcomma, bool with_labels);
  44 static ast_value* parser_create_array_setter_proto(parser_t *parser, ast_value *array, const char *funcname);
  45 static ast_value* parser_create_array_getter_proto(parser_t *parser, ast_value *array, const ast_expression *elemtype, const char *funcname);
  46 static ast_value *parse_typename(parser_t *parser, ast_value **storebase, ast_value *cached_typedef);
  47
  48 static void parseerror(parser_t *parser, const char *fmt, ...)
  49 {
  50     va_list ap;
  51     va_start(ap, fmt);
  52     vcompile_error(parser->lex->tok.ctx, fmt, ap);
  53     va_end(ap);
  54 }
  55
  56 /* returns true if it counts as an error */
  57 static bool GMQCC_WARN parsewarning(parser_t *parser, int warntype, const char *fmt, ...)
  58 {
  59     bool    r;
  60     va_list ap;
  61     va_start(ap, fmt);
  62     r = vcompile_warning(parser->lex->tok.ctx, warntype, fmt, ap);
  63     va_end(ap);
  64     return r;
  65 }
  66
  67 /**********************************************************************
  68  * parsing
  69  */
  70
  71 static bool parser_next(parser_t *parser)
  72 {
  73     /* lex_do kills the previous token */
  74     parser->tok = lex_do(parser->lex);
  75     if (parser->tok == TOKEN_EOF)
  76         return true;
  77     if (parser->tok >= TOKEN_ERROR) {
  78         parseerror(parser, "lex error");
  79         return false;
  80     }
  81     return true;
  82 }
  83
  84 #define parser_tokval(p) ((p)->lex->tok.value)
  85 #define parser_token(p)  (&((p)->lex->tok))
  86
  87 char *parser_strdup(const char *str)
  88 {
  89     if (str && !*str) {
  90         /* actually dup empty strings */
  91         char *out = (char*)mem_a(1);
  92         *out = 0;
  93         return out;
  94     }
  95     return util_strdup(str);
  96 }
  97
  98 static ast_expression* parser_find_field(parser_t *parser, const char *name)
  99 {
 100     return ( ast_expression*)util_htget(parser->htfields, name);
 101 }
 102
 103 static ast_expression* parser_find_label(parser_t *parser, const char *name)
 104 {
 105     size_t i;
 106     for(i = 0; i < vec_size(parser->labels); i++)
 107         if (!strcmp(parser->labels[i]->name, name))
 108             return (ast_expression*)parser->labels[i];
 109     return NULL;
 110 }
 111
 112 static ast_expression* parser_find_global(parser_t *parser, const char *name)
 113 {
 114     ast_expression *var = (ast_expression*)util_htget(parser->aliases, parser_tokval(parser));
 115     if (var)
 116         return var;
 117     return (ast_expression*)util_htget(parser->htglobals, name);
 118 }
 119
 120 static ast_expression* parser_find_param(parser_t *parser, const char *name)
 121 {
 122     size_t i;
 123     ast_value *fun;
 124     if (!parser->function)
 125         return NULL;
 126     fun = parser->function->vtype;
 127     for (i = 0; i < vec_size(fun->expression.params); ++i) {
 128         if (!strcmp(fun->expression.params[i]->name, name))
 129             return (ast_expression*)(fun->expression.params[i]);
 130     }
 131     return NULL;
 132 }
 133
 134 static ast_expression* parser_find_local(parser_t *parser, const char *name, size_t upto, bool *isparam)
 135 {
 136     size_t          i, hash;
 137     ast_expression *e;
 138
 139     hash = util_hthash(parser->htglobals, name);
 140
 141     *isparam = false;
 142     for (i = vec_size(parser->variables); i > upto;) {
 143         --i;
 144         if ( (e = (ast_expression*)util_htgeth(parser->variables[i], name, hash)) )
 145             return e;
 146     }
 147     *isparam = true;
 148     return parser_find_param(parser, name);
 149 }
 150
 151 static ast_expression* parser_find_var(parser_t *parser, const char *name)
 152 {
 153     bool dummy;
 154     ast_expression *v;
 155     v         = parser_find_local(parser, name, 0, &dummy);
 156     if (!v) v = parser_find_global(parser, name);
 157     return v;
 158 }
 159
 160 static ast_value* parser_find_typedef(parser_t *parser, const char *name, size_t upto)
 161 {
 162     size_t     i, hash;
 163     ast_value *e;
 164     hash = util_hthash(parser->typedefs[0], name);
 165
 166     for (i = vec_size(parser->typedefs); i > upto;) {
 167         --i;
 168         if ( (e = (ast_value*)util_htgeth(parser->typedefs[i], name, hash)) )
 169             return e;
 170     }
 171     return NULL;
 172 }
 173
 174 /* include intrinsics */
 175 #include "intrin.h"
 176
 177 typedef struct
 178 {
 179     size_t etype; /* 0 = expression, others are operators */
 180     bool            isparen;
 181     size_t          off;
 182     ast_expression *out;
 183     ast_block      *block; /* for commas and function calls */
 184     lex_ctx_t ctx;
 185 } sy_elem;
 186
 187 enum {
 188     PAREN_EXPR,
 189     PAREN_FUNC,
 190     PAREN_INDEX,
 191     PAREN_TERNARY1,
 192     PAREN_TERNARY2
 193 };
 194 typedef struct
 195 {
 196     sy_elem        *out;
 197     sy_elem        *ops;
 198     size_t         *argc;
 199     unsigned int   *paren;
 200 } shunt;
 201
 202 static sy_elem syexp(lex_ctx_t ctx, ast_expression *v) {
 203     sy_elem e;
 204     e.etype = 0;
 205     e.off   = 0;
 206     e.out   = v;
 207     e.block = NULL;
 208     e.ctx   = ctx;
 209     e.isparen = false;
 210     return e;
 211 }
 212
 213 static sy_elem syblock(lex_ctx_t ctx, ast_block *v) {
 214     sy_elem e;
 215     e.etype = 0;
 216     e.off   = 0;
 217     e.out   = (ast_expression*)v;
 218     e.block = v;
 219     e.ctx   = ctx;
 220     e.isparen = false;
 221     return e;
 222 }
 223
 224 static sy_elem syop(lex_ctx_t ctx, const oper_info *op) {
 225     sy_elem e;
 226     e.etype = 1 + (op - operators);
 227     e.off   = 0;
 228     e.out   = NULL;
 229     e.block = NULL;
 230     e.ctx   = ctx;
 231     e.isparen = false;
 232     return e;
 233 }
 234
 235 static sy_elem syparen(lex_ctx_t ctx, size_t off) {
 236     sy_elem e;
 237     e.etype = 0;
 238     e.off   = off;
 239     e.out   = NULL;
 240     e.block = NULL;
 241     e.ctx   = ctx;
 242     e.isparen = true;
 243     return e;
 244 }
 245
 246 /* With regular precedence rules, ent.foo[n] is the same as (ent.foo)[n],
 247  * so we need to rotate it to become ent.(foo[n]).
 248  */
 249 static bool rotate_entfield_array_index_nodes(ast_expression **out)
 250 {
 251     ast_array_index *index, *oldindex;
 252     ast_entfield    *entfield;
 253
 254     ast_value       *field;
 255     ast_expression  *sub;
 256     ast_expression  *entity;
 257
 258     lex_ctx_t ctx = ast_ctx(*out);
 259
 260     if (!ast_istype(*out, ast_array_index))
 261         return false;
 262     index = (ast_array_index*)*out;
 263
 264     if (!ast_istype(index->array, ast_entfield))
 265         return false;
 266     entfield = (ast_entfield*)index->array;
 267
 268     if (!ast_istype(entfield->field, ast_value))
 269         return false;
 270     field = (ast_value*)entfield->field;
 271
 272     sub    = index->index;
 273     entity = entfield->entity;
 274
 275     oldindex = index;
 276
 277     index = ast_array_index_new(ctx, (ast_expression*)field, sub);
 278     entfield = ast_entfield_new(ctx, entity, (ast_expression*)index);
 279     *out = (ast_expression*)entfield;
 280
 281     oldindex->array = NULL;
 282     oldindex->index = NULL;
 283     ast_delete(oldindex);
 284
 285     return true;
 286 }
 287
 288 static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
 289 {
 290     const oper_info *op;
 291     lex_ctx_t ctx;
 292     ast_expression *out = NULL;
 293     ast_expression *exprs[3];
 294     ast_block      *blocks[3];
 295     ast_value      *asvalue[3];
 296     ast_binstore   *asbinstore;
 297     size_t i, assignop, addop, subop;
 298     qcint_t  generated_op = 0;
 299
 300     char ty1[1024];
 301     char ty2[1024];
 302
 303     if (!vec_size(sy->ops)) {
 304         parseerror(parser, "internal error: missing operator");
 305         return false;
 306     }
 307
 308     if (vec_last(sy->ops).isparen) {
 309         parseerror(parser, "unmatched parenthesis");
 310         return false;
 311     }
 312
 313     op = &operators[vec_last(sy->ops).etype - 1];
 314     ctx = vec_last(sy->ops).ctx;
 315
 316     if (vec_size(sy->out) < op->operands) {
 317         compile_error(ctx, "internal error: not enough operands: %i (operator %s (%i))", vec_size(sy->out),
 318                       op->op, (int)op->id);
 319         return false;
 320     }
 321
 322     vec_shrinkby(sy->ops, 1);
 323
 324     /* op(:?) has no input and no output */
 325     if (!op->operands)
 326         return true;
 327
 328     vec_shrinkby(sy->out, op->operands);
 329     for (i = 0; i < op->operands; ++i) {
 330         exprs[i]  = sy->out[vec_size(sy->out)+i].out;
 331         blocks[i] = sy->out[vec_size(sy->out)+i].block;
 332         asvalue[i] = (ast_value*)exprs[i];
 333
 334         if (exprs[i]->vtype == TYPE_NOEXPR &&
 335             !(i != 0 && op->id == opid2('?',':')) &&
 336             !(i == 1 && op->id == opid1('.')))
 337         {
 338             if (ast_istype(exprs[i], ast_label))
 339                 compile_error(ast_ctx(exprs[i]), "expected expression, got an unknown identifier");
 340             else
 341                 compile_error(ast_ctx(exprs[i]), "not an expression");
 342             (void)!compile_warning(ast_ctx(exprs[i]), WARN_DEBUG, "expression %u\n", (unsigned int)i);
 343         }
 344     }
 345
 346     if (blocks[0] && !vec_size(blocks[0]->exprs) && op->id != opid1(',')) {
 347         compile_error(ctx, "internal error: operator cannot be applied on empty blocks");
 348         return false;
 349     }
 350
 351 #define NotSameType(T) \
 352              (exprs[0]->vtype != exprs[1]->vtype || \
 353               exprs[0]->vtype != T)
 354     switch (op->id)
 355     {
 356         default:
 357             compile_error(ctx, "internal error: unhandled operator: %s (%i)", op->op, (int)op->id);
 358             return false;
 359
 360         case opid1('.'):
 361             if (exprs[0]->vtype == TYPE_VECTOR &&
 362                 exprs[1]->vtype == TYPE_NOEXPR)
 363             {
 364                 if      (exprs[1] == (ast_expression*)parser->const_vec[0])
 365                     out = (ast_expression*)ast_member_new(ctx, exprs[0], 0, NULL);
 366                 else if (exprs[1] == (ast_expression*)parser->const_vec[1])
 367                     out = (ast_expression*)ast_member_new(ctx, exprs[0], 1, NULL);
 368                 else if (exprs[1] == (ast_expression*)parser->const_vec[2])
 369                     out = (ast_expression*)ast_member_new(ctx, exprs[0], 2, NULL);
 370                 else {
 371                     compile_error(ctx, "access to invalid vector component");
 372                     return false;
 373                 }
 374             }
 375             else if (exprs[0]->vtype == TYPE_ENTITY) {
 376                 if (exprs[1]->vtype != TYPE_FIELD) {
 377                     compile_error(ast_ctx(exprs[1]), "type error: right hand of member-operand should be an entity-field");
 378                     return false;
 379                 }
 380                 out = (ast_expression*)ast_entfield_new(ctx, exprs[0], exprs[1]);
 381             }
 382             else if (exprs[0]->vtype == TYPE_VECTOR) {
 383                 compile_error(ast_ctx(exprs[1]), "vectors cannot be accessed this way");
 384                 return false;
 385             }
 386             else {
 387                 compile_error(ast_ctx(exprs[1]), "type error: member-of operator on something that is not an entity or vector");
 388                 return false;
 389             }
 390             break;
 391
 392         case opid1('['):
 393             if (exprs[0]->vtype != TYPE_ARRAY &&
 394                 !(exprs[0]->vtype == TYPE_FIELD &&
 395                   exprs[0]->next->vtype == TYPE_ARRAY))
 396             {
 397                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
 398                 compile_error(ast_ctx(exprs[0]), "cannot index value of type %s", ty1);
 399                 return false;
 400             }
 401             if (exprs[1]->vtype != TYPE_FLOAT) {
 402                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
 403                 compile_error(ast_ctx(exprs[1]), "index must be of type float, not %s", ty1);
 404                 return false;
 405             }
 406             out = (ast_expression*)ast_array_index_new(ctx, exprs[0], exprs[1]);
 407             if (rotate_entfield_array_index_nodes(&out))
 408             {
 409 #if 0
 410                 /* This is not broken in fteqcc anymore */
 411                 if (OPTS_OPTION_U32(OPTION_STANDARD) != COMPILER_GMQCC) {
 412                     /* this error doesn't need to make us bail out */
 413                     (void)!parsewarning(parser, WARN_EXTENSIONS,
 414                                         "accessing array-field members of an entity without parenthesis\n"
 415                                         " -> this is an extension from -std=gmqcc");
 416                 }
 417 #endif
 418             }
 419             break;
 420
 421         case opid1(','):
 422             if (vec_size(sy->paren) && vec_last(sy->paren) == PAREN_FUNC) {
 423                 vec_push(sy->out, syexp(ctx, exprs[0]));
 424                 vec_push(sy->out, syexp(ctx, exprs[1]));
 425                 vec_last(sy->argc)++;
 426                 return true;
 427             }
 428             if (blocks[0]) {
 429                 if (!ast_block_add_expr(blocks[0], exprs[1]))
 430                     return false;
 431             } else {
 432                 blocks[0] = ast_block_new(ctx);
 433                 if (!ast_block_add_expr(blocks[0], exprs[0]) ||
 434                     !ast_block_add_expr(blocks[0], exprs[1]))
 435                 {
 436                     return false;
 437                 }
 438             }
 439             ast_block_set_type(blocks[0], exprs[1]);
 440
 441             vec_push(sy->out, syblock(ctx, blocks[0]));
 442             return true;
 443
 444         case opid2('+','P'):
 445             out = exprs[0];
 446             break;
 447         case opid2('-','P'):
 448             if (!(out = fold_op(parser->fold, op, exprs))) {
 449                 switch (exprs[0]->vtype) {
 450                     case TYPE_FLOAT:
 451                         out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F,
 452                                                                   (ast_expression*)parser->fold->imm_float[0],
 453                                                                   exprs[0]);
 454                         break;
 455                     case TYPE_VECTOR:
 456                         out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V,
 457                                                                   (ast_expression*)parser->fold->imm_vector[0],
 458                                                                   exprs[0]);
 459                         break;
 460                     default:
 461                     compile_error(ctx, "invalid types used in expression: cannot negate type %s",
 462                                   type_name[exprs[0]->vtype]);
 463                     return false;
 464                 }
 465             }
 466             break;
 467
 468         case opid2('!','P'):
 469             if (!(out = fold_op(parser->fold, op, exprs))) {
 470                 switch (exprs[0]->vtype) {
 471                     case TYPE_FLOAT:
 472                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, exprs[0]);
 473                         break;
 474                     case TYPE_VECTOR:
 475                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_V, exprs[0]);
 476                         break;
 477                     case TYPE_STRING:
 478                         if (OPTS_FLAG(TRUE_EMPTY_STRINGS))
 479                             out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, exprs[0]);
 480                         else
 481                             out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_S, exprs[0]);
 482                         break;
 483                     /* we don't constant-fold NOT for these types */
 484                     case TYPE_ENTITY:
 485                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_ENT, exprs[0]);
 486                         break;
 487                     case TYPE_FUNCTION:
 488                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_FNC, exprs[0]);
 489                         break;
 490                     default:
 491                     compile_error(ctx, "invalid types used in expression: cannot logically negate type %s",
 492                                   type_name[exprs[0]->vtype]);
 493                     return false;
 494                 }
 495             }
 496             break;
 497
 498         case opid1('+'):
 499             if (exprs[0]->vtype != exprs[1]->vtype ||
 500                (exprs[0]->vtype != TYPE_VECTOR && exprs[0]->vtype != TYPE_FLOAT) )
 501             {
 502                 compile_error(ctx, "invalid types used in expression: cannot add type %s and %s",
 503                               type_name[exprs[0]->vtype],
 504                               type_name[exprs[1]->vtype]);
 505                 return false;
 506             }
 507             if (!(out = fold_op(parser->fold, op, exprs))) {
 508                 switch (exprs[0]->vtype) {
 509                     case TYPE_FLOAT:
 510                         out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_F, exprs[0], exprs[1]);
 511                         break;
 512                     case TYPE_VECTOR:
 513                         out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_V, exprs[0], exprs[1]);
 514                         break;
 515                     default:
 516                         compile_error(ctx, "invalid types used in expression: cannot add type %s and %s",
 517                                       type_name[exprs[0]->vtype],
 518                                       type_name[exprs[1]->vtype]);
 519                         return false;
 520                 }
 521             }
 522             break;
 523         case opid1('-'):
 524             if  (exprs[0]->vtype != exprs[1]->vtype ||
 525                 (exprs[0]->vtype != TYPE_VECTOR && exprs[0]->vtype != TYPE_FLOAT))
 526             {
 527                 compile_error(ctx, "invalid types used in expression: cannot subtract type %s from %s",
 528                               type_name[exprs[1]->vtype],
 529                               type_name[exprs[0]->vtype]);
 530                 return false;
 531             }
 532             if (!(out = fold_op(parser->fold, op, exprs))) {
 533                 switch (exprs[0]->vtype) {
 534                     case TYPE_FLOAT:
 535                         out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F, exprs[0], exprs[1]);
 536                         break;
 537                     case TYPE_VECTOR:
 538                         out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V, exprs[0], exprs[1]);
 539                         break;
 540                     default:
 541                         compile_error(ctx, "invalid types used in expression: cannot subtract type %s from %s",
 542                                       type_name[exprs[1]->vtype],
 543                                       type_name[exprs[0]->vtype]);
 544                         return false;
 545                 }
 546             }
 547             break;
 548         case opid1('*'):
 549             if (exprs[0]->vtype != exprs[1]->vtype &&
 550                 !(exprs[0]->vtype == TYPE_VECTOR &&
 551                   exprs[1]->vtype == TYPE_FLOAT) &&
 552                 !(exprs[1]->vtype == TYPE_VECTOR &&
 553                   exprs[0]->vtype == TYPE_FLOAT)
 554                 )
 555             {
 556                 compile_error(ctx, "invalid types used in expression: cannot multiply types %s and %s",
 557                               type_name[exprs[1]->vtype],
 558                               type_name[exprs[0]->vtype]);
 559                 return false;
 560             }
 561             if (!(out = fold_op(parser->fold, op, exprs))) {
 562                 switch (exprs[0]->vtype) {
 563                     case TYPE_FLOAT:
 564                         if (exprs[1]->vtype == TYPE_VECTOR)
 565                             out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_FV, exprs[0], exprs[1]);
 566                         else
 567                             out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, exprs[0], exprs[1]);
 568                         break;
 569                     case TYPE_VECTOR:
 570                         if (exprs[1]->vtype == TYPE_FLOAT)
 571                             out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_VF, exprs[0], exprs[1]);
 572                         else
 573                             out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_V, exprs[0], exprs[1]);
 574                         break;
 575                     default:
 576                         compile_error(ctx, "invalid types used in expression: cannot multiply types %s and %s",
 577                                       type_name[exprs[1]->vtype],
 578                                       type_name[exprs[0]->vtype]);
 579                         return false;
 580                 }
 581             }
 582             break;
 583
 584         case opid1('/'):
 585             if (exprs[1]->vtype != TYPE_FLOAT) {
 586                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
 587                 ast_type_to_string(exprs[1], ty2, sizeof(ty2));
 588                 compile_error(ctx, "invalid types used in expression: cannot divide types %s and %s", ty1, ty2);
 589                 return false;
 590             }
 591             if (!(out = fold_op(parser->fold, op, exprs))) {
 592                 if (exprs[0]->vtype == TYPE_FLOAT)
 593                     out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F, exprs[0], exprs[1]);
 594                 else {
 595                     ast_type_to_string(exprs[0], ty1, sizeof(ty1));
 596                     ast_type_to_string(exprs[1], ty2, sizeof(ty2));
 597                     compile_error(ctx, "invalid types used in expression: cannot divide types %s and %s", ty1, ty2);
 598                     return false;
 599                 }
 600             }
 601             break;
 602
 603         case opid1('%'):
 604             if (NotSameType(TYPE_FLOAT)) {
 605                 compile_error(ctx, "invalid types used in expression: cannot perform modulo operation between types %s and %s",
 606                     type_name[exprs[0]->vtype],
 607                     type_name[exprs[1]->vtype]);
 608                 return false;
 609             } else if (!(out = fold_op(parser->fold, op, exprs))) {
 610                 /* generate a call to __builtin_mod */
 611                 ast_expression *mod  = intrin_func(parser, "mod");
 612                 ast_call       *call = NULL;
 613                 if (!mod) return false; /* can return null for missing floor */
 614
 615                 call = ast_call_new(parser_ctx(parser), mod);
 616                 vec_push(call->params, exprs[0]);
 617                 vec_push(call->params, exprs[1]);
 618
 619                 out = (ast_expression*)call;
 620             }
 621             break;
 622
 623         case opid2('%','='):
 624             compile_error(ctx, "%= is unimplemented");
 625             return false;
 626
 627         case opid1('|'):
 628         case opid1('&'):
 629             if (NotSameType(TYPE_FLOAT)) {
 630                 compile_error(ctx, "invalid types used in expression: cannot perform bit operations between types %s and %s",
 631                               type_name[exprs[0]->vtype],
 632                               type_name[exprs[1]->vtype]);
 633                 return false;
 634             }
 635             if (!(out = fold_op(parser->fold, op, exprs)))
 636                 out = (ast_expression*)ast_binary_new(ctx,
 637                     (op->id == opid1('|') ? INSTR_BITOR : INSTR_BITAND),
 638                     exprs[0], exprs[1]);
 639             break;
 640         case opid1('^'):
 641             /*
 642              * Okay lets designate what the hell is an acceptable use
 643              * of the ^ operator. In many vector processing units, XOR
 644              * is allowed to be used on vectors, but only if the first
 645              * operand is a vector, the second operand can be a float
 646              * or vector. It's never legal for the first operand to be
 647              * a float, and then the following operand to be a vector.
 648              * Further more, the only time it is legal to do XOR otherwise
 649              * is when both operand are floats. This nicely crafted if
 650              * statement catches them all.
 651              *
 652              * In the event that the first operand is a vector, two
 653              * possible situations can arise, thus, each element of
 654              * vector A (operand A) is exclusive-ORed with the corresponding
 655              * element of vector B (operand B), If B is scalar, the
 656              * scalar value is first replicated for each element.
 657              *
 658              * The QCVM itself lacks a BITXOR instruction. Thus emulating
 659              * the mathematics of it is required. The following equation
 660              * is used: (LHS | RHS) & ~(LHS & RHS). However, due to the
 661              * QCVM also lacking a BITNEG instruction, we need to emulate
 662              * ~FOO with -1 - FOO, the whole process becoming this nicely
 663              * crafted expression: (LHS | RHS) & (-1 - (LHS & RHS)).
 664              *
 665              * When A is not scalar, this process is repeated for all
 666              * components of vector A with the value in operand B,
 667              * only if operand B is scalar. When A is not scalar, and B
 668              * is also not scalar, this process is repeated for all
 669              * components of the vector A with the components of vector B.
 670              * Finally when A is scalar and B is scalar, this process is
 671              * simply used once for A and B being LHS and RHS respectfully.
 672              *
 673              * Yes the semantics are a bit strange (no pun intended).
 674              * But then again BITXOR is strange itself, consdering it's
 675              * commutative, assocative, and elements of the BITXOR operation
 676              * are their own inverse.
 677              */
 678             if ( !(exprs[0]->vtype == TYPE_FLOAT  && exprs[1]->vtype == TYPE_FLOAT) &&
 679                  !(exprs[0]->vtype == TYPE_VECTOR && exprs[1]->vtype == TYPE_FLOAT) &&
 680                  !(exprs[0]->vtype == TYPE_VECTOR && exprs[1]->vtype == TYPE_VECTOR))
 681             {
 682                 compile_error(ctx, "invalid types used in expression: cannot perform bit operations between types %s and %s",
 683                               type_name[exprs[0]->vtype],
 684                               type_name[exprs[1]->vtype]);
 685                 return false;
 686             }
 687
 688             if (!(out = fold_op(parser->fold, op, exprs))) {
 689                 /*
 690                  * IF the first expression is float, the following will be too
 691                  * since scalar ^ vector is not allowed.
 692                  */
 693                 if (exprs[0]->vtype == TYPE_FLOAT) {
 694                     ast_binary *expr = ast_binary_new(
 695                         ctx,
 696                         INSTR_SUB_F,
 697                         (ast_expression*)parser->fold->imm_float[2],
 698                         (ast_expression*)ast_binary_new(
 699                             ctx,
 700                             INSTR_BITAND,
 701                             exprs[0],
 702                             exprs[1]
 703                         )
 704                     );
 705                     expr->refs = AST_REF_NONE;
 706
 707                     out = (ast_expression*)
 708                         ast_binary_new(
 709                             ctx,
 710                             INSTR_BITAND,
 711                             (ast_expression*)ast_binary_new(
 712                                 ctx,
 713                                 INSTR_BITOR,
 714                                 exprs[0],
 715                                 exprs[1]
 716                             ),
 717                             (ast_expression*)expr
 718                         );
 719                 } else {
 720                     /*
 721                      * The first is a vector: vector is allowed to xor with vector and
 722                      * with scalar, branch here for the second operand.
 723                      */
 724                     if (exprs[1]->vtype == TYPE_VECTOR) {
 725                         /*
 726                          * Xor all the values of the vector components against the
 727                          * vectors components in question.
 728                          */
 729                         compile_error(ast_ctx(exprs[0]), "Not Yet Implemented: bit-xor for vector against vector");
 730                         return false;
 731                     } else {
 732                         compile_error(ast_ctx(exprs[0]), "Not Yet Implemented: bit-xor for vector against float");
 733                         return false;
 734                     }
 735                 }
 736             }
 737             break;
 738
 739         case opid2('<','<'):
 740         case opid2('>','>'):
 741         case opid3('<','<','='):
 742         case opid3('>','>','='):
 743             if(!(out = fold_op(parser->fold, op, exprs))) {
 744                 compile_error(ast_ctx(exprs[0]), "Not Yet Implemented: bit-shifts");
 745                 return false;
 746             }
 747
 748         case opid2('|','|'):
 749             generated_op += 1; /* INSTR_OR */
 750         case opid2('&','&'):
 751             generated_op += INSTR_AND;
 752             if (!(out = fold_op(parser->fold, op, exprs))) {
 753                 if (OPTS_FLAG(PERL_LOGIC) && !ast_compare_type(exprs[0], exprs[1])) {
 754                     ast_type_to_string(exprs[0], ty1, sizeof(ty1));
 755                     ast_type_to_string(exprs[1], ty2, sizeof(ty2));
 756                     compile_error(ctx, "invalid types for logical operation with -fperl-logic: %s and %s", ty1, ty2);
 757                     return false;
 758                 }
 759                 for (i = 0; i < 2; ++i) {
 760                     if (OPTS_FLAG(CORRECT_LOGIC) && exprs[i]->vtype == TYPE_VECTOR) {
 761                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_V, exprs[i]);
 762                         if (!out) break;
 763                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, out);
 764                         if (!out) break;
 765                         exprs[i] = out; out = NULL;
 766                         if (OPTS_FLAG(PERL_LOGIC)) {
 767                             /* here we want to keep the right expressions' type */
 768                             break;
 769                         }
 770                     }
 771                     else if (OPTS_FLAG(FALSE_EMPTY_STRINGS) && exprs[i]->vtype == TYPE_STRING) {
 772                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_S, exprs[i]);
 773                         if (!out) break;
 774                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, out);
 775                         if (!out) break;
 776                         exprs[i] = out; out = NULL;
 777                         if (OPTS_FLAG(PERL_LOGIC)) {
 778                             /* here we want to keep the right expressions' type */
 779                             break;
 780                         }
 781                     }
 782                 }
 783                 out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
 784             }
 785             break;
 786
 787         case opid2('?',':'):
 788             if (vec_last(sy->paren) != PAREN_TERNARY2) {
 789                 compile_error(ctx, "mismatched parenthesis/ternary");
 790                 return false;
 791             }
 792             vec_pop(sy->paren);
 793             if (!ast_compare_type(exprs[1], exprs[2])) {
 794                 ast_type_to_string(exprs[1], ty1, sizeof(ty1));
 795                 ast_type_to_string(exprs[2], ty2, sizeof(ty2));
 796                 compile_error(ctx, "operands of ternary expression must have the same type, got %s and %s", ty1, ty2);
 797                 return false;
 798             }
 799             if (!(out = fold_op(parser->fold, op, exprs)))
 800                 out = (ast_expression*)ast_ternary_new(ctx, exprs[0], exprs[1], exprs[2]);
 801             break;
 802
 803         case opid2('*', '*'):
 804             if (NotSameType(TYPE_FLOAT)) {
 805                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
 806                 ast_type_to_string(exprs[1], ty2, sizeof(ty2));
 807                 compile_error(ctx, "invalid types used in exponentiation: %s and %s",
 808                     ty1, ty2);
 809                 return false;
 810             }
 811
 812             if (!(out = fold_op(parser->fold, op, exprs))) {
 813                 ast_call *gencall = ast_call_new(parser_ctx(parser), intrin_func(parser, "pow"));
 814                 vec_push(gencall->params, exprs[0]);
 815                 vec_push(gencall->params, exprs[1]);
 816                 out = (ast_expression*)gencall;
 817             }
 818             break;
 819
 820         case opid3('<','=','>'): /* -1, 0, or 1 */
 821             if (NotSameType(TYPE_FLOAT)) {
 822                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
 823                 ast_type_to_string(exprs[1], ty2, sizeof(ty2));
 824                 compile_error(ctx, "invalid types used in comparision: %s and %s",
 825                     ty1, ty2);
 826
 827                 return false;
 828             }
 829
 830             if (!(out = fold_op(parser->fold, op, exprs))) {
 831                 ast_binary *eq = ast_binary_new(ctx, INSTR_EQ_F, exprs[0], exprs[1]);
 832
 833                 eq->refs = AST_REF_NONE;
 834
 835                     /* if (lt) { */
 836                 out = (ast_expression*)ast_ternary_new(ctx,
 837                         (ast_expression*)ast_binary_new(ctx, INSTR_LT, exprs[0], exprs[1]),
 838                         /* out = -1 */
 839                         (ast_expression*)parser->fold->imm_float[2],
 840                     /* } else { */
 841                         /* if (eq) { */
 842                         (ast_expression*)ast_ternary_new(ctx, (ast_expression*)eq,
 843                             /* out = 0 */
 844                             (ast_expression*)parser->fold->imm_float[0],
 845                         /* } else { */
 846                             /* out = 1 */
 847                             (ast_expression*)parser->fold->imm_float[1]
 848                         /* } */
 849                         )
 850                     /* } */
 851                     );
 852
 853             }
 854             break;
 855
 856         case opid1('>'):
 857             generated_op += 1; /* INSTR_GT */
 858         case opid1('<'):
 859             generated_op += 1; /* INSTR_LT */
 860         case opid2('>', '='):
 861             generated_op += 1; /* INSTR_GE */
 862         case opid2('<', '='):
 863             generated_op += INSTR_LE;
 864             if (NotSameType(TYPE_FLOAT)) {
 865                 compile_error(ctx, "invalid types used in expression: cannot perform comparison between types %s and %s",
 866                               type_name[exprs[0]->vtype],
 867                               type_name[exprs[1]->vtype]);
 868                 return false;
 869             }
 870             if (!(out = fold_op(parser->fold, op, exprs)))
 871                 out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
 872             break;
 873         case opid2('!', '='):
 874             if (exprs[0]->vtype != exprs[1]->vtype) {
 875                 compile_error(ctx, "invalid types used in expression: cannot perform comparison between types %s and %s",
 876                               type_name[exprs[0]->vtype],
 877                               type_name[exprs[1]->vtype]);
 878                 return false;
 879             }
 880             if (!(out = fold_op(parser->fold, op, exprs)))
 881                 out = (ast_expression*)ast_binary_new(ctx, type_ne_instr[exprs[0]->vtype], exprs[0], exprs[1]);
 882             break;
 883         case opid2('=', '='):
 884             if (exprs[0]->vtype != exprs[1]->vtype) {
 885                 compile_error(ctx, "invalid types used in expression: cannot perform comparison between types %s and %s",
 886                               type_name[exprs[0]->vtype],
 887                               type_name[exprs[1]->vtype]);
 888                 return false;
 889             }
 890             if (!(out = fold_op(parser->fold, op, exprs)))
 891                 out = (ast_expression*)ast_binary_new(ctx, type_eq_instr[exprs[0]->vtype], exprs[0], exprs[1]);
 892             break;
 893
 894         case opid1('='):
 895             if (ast_istype(exprs[0], ast_entfield)) {
 896                 ast_expression *field = ((ast_entfield*)exprs[0])->field;
 897                 if (OPTS_FLAG(ADJUST_VECTOR_FIELDS) &&
 898                     exprs[0]->vtype == TYPE_FIELD &&
 899                     exprs[0]->next->vtype == TYPE_VECTOR)
 900                 {
 901                     assignop = type_storep_instr[TYPE_VECTOR];
 902                 }
 903                 else
 904                     assignop = type_storep_instr[exprs[0]->vtype];
 905                 if (assignop == VINSTR_END || !ast_compare_type(field->next, exprs[1]))
 906                 {
 907                     ast_type_to_string(field->next, ty1, sizeof(ty1));
 908                     ast_type_to_string(exprs[1], ty2, sizeof(ty2));
 909                     if (OPTS_FLAG(ASSIGN_FUNCTION_TYPES) &&
 910                         field->next->vtype == TYPE_FUNCTION &&
 911                         exprs[1]->vtype == TYPE_FUNCTION)
 912                     {
 913                         (void)!compile_warning(ctx, WARN_ASSIGN_FUNCTION_TYPES,
 914                                                "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
 915                     }
 916                     else
 917                         compile_error(ctx, "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
 918                 }
 919             }
 920             else
 921             {
 922                 if (OPTS_FLAG(ADJUST_VECTOR_FIELDS) &&
 923                     exprs[0]->vtype == TYPE_FIELD &&
 924                     exprs[0]->next->vtype == TYPE_VECTOR)
 925                 {
 926                     assignop = type_store_instr[TYPE_VECTOR];
 927                 }
 928                 else {
 929                     assignop = type_store_instr[exprs[0]->vtype];
 930                 }
 931
 932                 if (assignop == VINSTR_END) {
 933                     ast_type_to_string(exprs[0], ty1, sizeof(ty1));
 934                     ast_type_to_string(exprs[1], ty2, sizeof(ty2));
 935                     compile_error(ctx, "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
 936                 }
 937                 else if (!ast_compare_type(exprs[0], exprs[1]))
 938                 {
 939                     ast_type_to_string(exprs[0], ty1, sizeof(ty1));
 940                     ast_type_to_string(exprs[1], ty2, sizeof(ty2));
 941                     if (OPTS_FLAG(ASSIGN_FUNCTION_TYPES) &&
 942                         exprs[0]->vtype == TYPE_FUNCTION &&
 943                         exprs[1]->vtype == TYPE_FUNCTION)
 944                     {
 945                         (void)!compile_warning(ctx, WARN_ASSIGN_FUNCTION_TYPES,
 946                                                "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
 947                     }
 948                     else
 949                         compile_error(ctx, "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
 950                 }
 951             }
 952             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
 953                 compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name);
 954             }
 955             out = (ast_expression*)ast_store_new(ctx, assignop, exprs[0], exprs[1]);
 956             break;
 957         case opid3('+','+','P'):
 958         case opid3('-','-','P'):
 959             /* prefix ++ */
 960             if (exprs[0]->vtype != TYPE_FLOAT) {
 961                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
 962                 compile_error(ast_ctx(exprs[0]), "invalid type for prefix increment: %s", ty1);
 963                 return false;
 964             }
 965             if (op->id == opid3('+','+','P'))
 966                 addop = INSTR_ADD_F;
 967             else
 968                 addop = INSTR_SUB_F;
 969             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
 970                 compile_error(ast_ctx(exprs[0]), "assignment to constant `%s`", asvalue[0]->name);
 971             }
 972             if (ast_istype(exprs[0], ast_entfield)) {
 973                 out = (ast_expression*)ast_binstore_new(ctx, INSTR_STOREP_F, addop,
 974                                                         exprs[0],
 975                                                         (ast_expression*)parser->fold->imm_float[1]);
 976             } else {
 977                 out = (ast_expression*)ast_binstore_new(ctx, INSTR_STORE_F, addop,
 978                                                         exprs[0],
 979                                                         (ast_expression*)parser->fold->imm_float[1]);
 980             }
 981             break;
 982         case opid3('S','+','+'):
 983         case opid3('S','-','-'):
 984             /* prefix ++ */
 985             if (exprs[0]->vtype != TYPE_FLOAT) {
 986                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
 987                 compile_error(ast_ctx(exprs[0]), "invalid type for suffix increment: %s", ty1);
 988                 return false;
 989             }
 990             if (op->id == opid3('S','+','+')) {
 991                 addop = INSTR_ADD_F;
 992                 subop = INSTR_SUB_F;
 993             } else {
 994                 addop = INSTR_SUB_F;
 995                 subop = INSTR_ADD_F;
 996             }
 997             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
 998                 compile_error(ast_ctx(exprs[0]), "assignment to constant `%s`", asvalue[0]->name);
 999             }
1000             if (ast_istype(exprs[0], ast_entfield)) {
1001                 out = (ast_expression*)ast_binstore_new(ctx, INSTR_STOREP_F, addop,
1002                                                         exprs[0],
1003                                                         (ast_expression*)parser->fold->imm_float[1]);
1004             } else {
1005                 out = (ast_expression*)ast_binstore_new(ctx, INSTR_STORE_F, addop,
1006                                                         exprs[0],
1007                                                         (ast_expression*)parser->fold->imm_float[1]);
1008             }
1009             if (!out)
1010                 return false;
1011             out = (ast_expression*)ast_binary_new(ctx, subop,
1012                                                   out,
1013                                                   (ast_expression*)parser->fold->imm_float[1]);
1014             break;
1015         case opid2('+','='):
1016         case opid2('-','='):
1017             if (exprs[0]->vtype != exprs[1]->vtype ||
1018                 (exprs[0]->vtype != TYPE_VECTOR && exprs[0]->vtype != TYPE_FLOAT) )
1019             {
1020                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1021                 ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1022                 compile_error(ctx, "invalid types used in expression: cannot add or subtract type %s and %s",
1023                               ty1, ty2);
1024                 return false;
1025             }
1026             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1027                 compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name);
1028             }
1029             if (ast_istype(exprs[0], ast_entfield))
1030                 assignop = type_storep_instr[exprs[0]->vtype];
1031             else
1032                 assignop = type_store_instr[exprs[0]->vtype];
1033             switch (exprs[0]->vtype) {
1034                 case TYPE_FLOAT:
1035                     out = (ast_expression*)ast_binstore_new(ctx, assignop,
1036                                                             (op->id == opid2('+','=') ? INSTR_ADD_F : INSTR_SUB_F),
1037                                                             exprs[0], exprs[1]);
1038                     break;
1039                 case TYPE_VECTOR:
1040                     out = (ast_expression*)ast_binstore_new(ctx, assignop,
1041                                                             (op->id == opid2('+','=') ? INSTR_ADD_V : INSTR_SUB_V),
1042                                                             exprs[0], exprs[1]);
1043                     break;
1044                 default:
1045                     compile_error(ctx, "invalid types used in expression: cannot add or subtract type %s and %s",
1046                                   type_name[exprs[0]->vtype],
1047                                   type_name[exprs[1]->vtype]);
1048                     return false;
1049             };
1050             break;
1051         case opid2('*','='):
1052         case opid2('/','='):
1053             if (exprs[1]->vtype != TYPE_FLOAT ||
1054                 !(exprs[0]->vtype == TYPE_FLOAT ||
1055                   exprs[0]->vtype == TYPE_VECTOR))
1056             {
1057                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1058                 ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1059                 compile_error(ctx, "invalid types used in expression: %s and %s",
1060                               ty1, ty2);
1061                 return false;
1062             }
1063             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1064                 compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name);
1065             }
1066             if (ast_istype(exprs[0], ast_entfield))
1067                 assignop = type_storep_instr[exprs[0]->vtype];
1068             else
1069                 assignop = type_store_instr[exprs[0]->vtype];
1070             switch (exprs[0]->vtype) {
1071                 case TYPE_FLOAT:
1072                     out = (ast_expression*)ast_binstore_new(ctx, assignop,
1073                                                             (op->id == opid2('*','=') ? INSTR_MUL_F : INSTR_DIV_F),
1074                                                             exprs[0], exprs[1]);
1075                     break;
1076                 case TYPE_VECTOR:
1077                     if (op->id == opid2('*','=')) {
1078                         out = (ast_expression*)ast_binstore_new(ctx, assignop, INSTR_MUL_VF,
1079                                                                 exprs[0], exprs[1]);
1080                     } else {
1081                         out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F,
1082                                                                   (ast_expression*)parser->fold->imm_float[1],
1083                                                                   exprs[1]);
1084                         if (!out) {
1085                             compile_error(ctx, "internal error: failed to generate division");
1086                             return false;
1087                         }
1088                         out = (ast_expression*)ast_binstore_new(ctx, assignop, INSTR_MUL_VF,
1089                                                                 exprs[0], out);
1090                     }
1091                     break;
1092                 default:
1093                     compile_error(ctx, "invalid types used in expression: cannot add or subtract type %s and %s",
1094                                   type_name[exprs[0]->vtype],
1095                                   type_name[exprs[1]->vtype]);
1096                     return false;
1097             };
1098             break;
1099         case opid2('&','='):
1100         case opid2('|','='):
1101             if (NotSameType(TYPE_FLOAT)) {
1102                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1103                 ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1104                 compile_error(ctx, "invalid types used in expression: %s and %s",
1105                               ty1, ty2);
1106                 return false;
1107             }
1108             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1109                 compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name);
1110             }
1111             if (ast_istype(exprs[0], ast_entfield))
1112                 assignop = type_storep_instr[exprs[0]->vtype];
1113             else
1114                 assignop = type_store_instr[exprs[0]->vtype];
1115             out = (ast_expression*)ast_binstore_new(ctx, assignop,
1116                                                     (op->id == opid2('&','=') ? INSTR_BITAND : INSTR_BITOR),
1117                                                     exprs[0], exprs[1]);
1118             break;
1119         case opid3('&','~','='):
1120             /* This is like: a &= ~(b);
1121              * But QC has no bitwise-not, so we implement it as
1122              * a -= a & (b);
1123              */
1124             if (NotSameType(TYPE_FLOAT)) {
1125                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1126                 ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1127                 compile_error(ctx, "invalid types used in expression: %s and %s",
1128                               ty1, ty2);
1129                 return false;
1130             }
1131             if (ast_istype(exprs[0], ast_entfield))
1132                 assignop = type_storep_instr[exprs[0]->vtype];
1133             else
1134                 assignop = type_store_instr[exprs[0]->vtype];
1135             out = (ast_expression*)ast_binary_new(ctx, INSTR_BITAND, exprs[0], exprs[1]);
1136             if (!out)
1137                 return false;
1138             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1139                 compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name);
1140             }
1141             asbinstore = ast_binstore_new(ctx, assignop, INSTR_SUB_F, exprs[0], out);
1142             asbinstore->keep_dest = true;
1143             out = (ast_expression*)asbinstore;
1144             break;
1145
1146         case opid2('~', 'P'):
1147             if (exprs[0]->vtype != TYPE_FLOAT) {
1148                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1149                 compile_error(ast_ctx(exprs[0]), "invalid type for bit not: %s", ty1);
1150                 return false;
1151             }
1152             if (!(out = fold_op(parser->fold, op, exprs)))
1153                 out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F, (ast_expression*)parser->fold->imm_float[2], exprs[0]);
1154             break;
1155     }
1156 #undef NotSameType
1157     if (!out) {
1158         compile_error(ctx, "failed to apply operator %s", op->op);
1159         return false;
1160     }
1161
1162     vec_push(sy->out, syexp(ctx, out));
1163     return true;
1164 }
1165
1166 static bool parser_close_call(parser_t *parser, shunt *sy)
1167 {
1168     /* was a function call */
1169     ast_expression *fun;
1170     ast_value      *funval = NULL;
1171     ast_call       *call;
1172
1173     size_t          fid;
1174     size_t          paramcount, i;
1175
1176     fid = vec_last(sy->ops).off;
1177     vec_shrinkby(sy->ops, 1);
1178
1179     /* out[fid] is the function
1180      * everything above is parameters...
1181      */
1182     if (!vec_size(sy->argc)) {
1183         parseerror(parser, "internal error: no argument counter available");
1184         return false;
1185     }
1186
1187     paramcount = vec_last(sy->argc);
1188     vec_pop(sy->argc);
1189
1190     if (vec_size(sy->out) < fid) {
1191         parseerror(parser, "internal error: broken function call%lu < %lu+%lu\n",
1192                    (unsigned long)vec_size(sy->out),
1193                    (unsigned long)fid,
1194                    (unsigned long)paramcount);
1195         return false;
1196     }
1197
1198     /*
1199      * TODO handle this at the intrinsic level with an ast_intrinsic
1200      * node and codegen.
1201      */
1202     if ((fun = sy->out[fid].out) == intrin_debug_typestring(parser)) {
1203         char ty[1024];
1204         if (fid+2 != vec_size(sy->out) ||
1205             vec_last(sy->out).block)
1206         {
1207             parseerror(parser, "intrinsic __builtin_debug_typestring requires exactly 1 parameter");
1208             return false;
1209         }
1210         ast_type_to_string(vec_last(sy->out).out, ty, sizeof(ty));
1211         ast_unref(vec_last(sy->out).out);
1212         sy->out[fid] = syexp(ast_ctx(vec_last(sy->out).out),
1213                              (ast_expression*)fold_constgen_string(parser->fold, ty, false));
1214         vec_shrinkby(sy->out, 1);
1215         return true;
1216     }
1217     call = ast_call_new(sy->ops[vec_size(sy->ops)].ctx, fun);
1218
1219     if (!call)
1220         return false;
1221
1222     if (fid+1 < vec_size(sy->out))
1223         ++paramcount;
1224
1225     if (fid+1 + paramcount != vec_size(sy->out)) {
1226         parseerror(parser, "internal error: parameter count mismatch: (%lu+1+%lu), %lu",
1227                    (unsigned long)fid, (unsigned long)paramcount, (unsigned long)vec_size(sy->out));
1228         return false;
1229     }
1230
1231     for (i = 0; i < paramcount; ++i)
1232         vec_push(call->params, sy->out[fid+1 + i].out);
1233     vec_shrinkby(sy->out, paramcount);
1234     (void)!ast_call_check_types(call, parser->function->vtype->expression.varparam);
1235     if (parser->max_param_count < paramcount)
1236         parser->max_param_count = paramcount;
1237
1238     if (ast_istype(fun, ast_value)) {
1239         funval = (ast_value*)fun;
1240         if ((fun->flags & AST_FLAG_VARIADIC) &&
1241             !(/*funval->cvq == CV_CONST && */ funval->hasvalue && funval->constval.vfunc->builtin))
1242         {
1243             call->va_count = (ast_expression*)fold_constgen_float(parser->fold, (qcfloat_t)paramcount);
1244         }
1245     }
1246
1247     /* overwrite fid, the function, with a call */
1248     sy->out[fid] = syexp(call->expression.node.context, (ast_expression*)call);
1249
1250     if (fun->vtype != TYPE_FUNCTION) {
1251         parseerror(parser, "not a function (%s)", type_name[fun->vtype]);
1252         return false;
1253     }
1254
1255     if (!fun->next) {
1256         parseerror(parser, "could not determine function return type");
1257         return false;
1258     } else {
1259         ast_value *fval = (ast_istype(fun, ast_value) ? ((ast_value*)fun) : NULL);
1260
1261         if (fun->flags & AST_FLAG_DEPRECATED) {
1262             if (!fval) {
1263                 return !parsewarning(parser, WARN_DEPRECATED,
1264                         "call to function (which is marked deprecated)\n",
1265                         "-> it has been declared here: %s:%i",
1266                         ast_ctx(fun).file, ast_ctx(fun).line);
1267             }
1268             if (!fval->desc) {
1269                 return !parsewarning(parser, WARN_DEPRECATED,
1270                         "call to `%s` (which is marked deprecated)\n"
1271                         "-> `%s` declared here: %s:%i",
1272                         fval->name, fval->name, ast_ctx(fun).file, ast_ctx(fun).line);
1273             }
1274             return !parsewarning(parser, WARN_DEPRECATED,
1275                     "call to `%s` (deprecated: %s)\n"
1276                     "-> `%s` declared here: %s:%i",
1277                     fval->name, fval->desc, fval->name, ast_ctx(fun).file,
1278                     ast_ctx(fun).line);
1279         }
1280
1281         if (vec_size(fun->params) != paramcount &&
1282             !((fun->flags & AST_FLAG_VARIADIC) &&
1283               vec_size(fun->params) < paramcount))
1284         {
1285             const char *fewmany = (vec_size(fun->params) > paramcount) ? "few" : "many";
1286             if (fval)
1287                 return !parsewarning(parser, WARN_INVALID_PARAMETER_COUNT,
1288                                      "too %s parameters for call to %s: expected %i, got %i\n"
1289                                      " -> `%s` has been declared here: %s:%i",
1290                                      fewmany, fval->name, (int)vec_size(fun->params), (int)paramcount,
1291                                      fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line);
1292             else
1293                 return !parsewarning(parser, WARN_INVALID_PARAMETER_COUNT,
1294                                      "too %s parameters for function call: expected %i, got %i\n"
1295                                      " -> it has been declared here: %s:%i",
1296                                      fewmany, (int)vec_size(fun->params), (int)paramcount,
1297                                      ast_ctx(fun).file, (int)ast_ctx(fun).line);
1298         }
1299     }
1300
1301     return true;
1302 }
1303
1304 static bool parser_close_paren(parser_t *parser, shunt *sy)
1305 {
1306     if (!vec_size(sy->ops)) {
1307         parseerror(parser, "unmatched closing paren");
1308         return false;
1309     }
1310
1311     while (vec_size(sy->ops)) {
1312         if (vec_last(sy->ops).isparen) {
1313             if (vec_last(sy->paren) == PAREN_FUNC) {
1314                 vec_pop(sy->paren);
1315                 if (!parser_close_call(parser, sy))
1316                     return false;
1317                 break;
1318             }
1319             if (vec_last(sy->paren) == PAREN_EXPR) {
1320                 vec_pop(sy->paren);
1321                 if (!vec_size(sy->out)) {
1322                     compile_error(vec_last(sy->ops).ctx, "empty paren expression");
1323                     vec_shrinkby(sy->ops, 1);
1324                     return false;
1325                 }
1326                 vec_shrinkby(sy->ops, 1);
1327                 break;
1328             }
1329             if (vec_last(sy->paren) == PAREN_INDEX) {
1330                 vec_pop(sy->paren);
1331                 /* pop off the parenthesis */
1332                 vec_shrinkby(sy->ops, 1);
1333                 /* then apply the index operator */
1334                 if (!parser_sy_apply_operator(parser, sy))
1335                     return false;
1336                 break;
1337             }
1338             if (vec_last(sy->paren) == PAREN_TERNARY1) {
1339                 vec_last(sy->paren) = PAREN_TERNARY2;
1340                 /* pop off the parenthesis */
1341                 vec_shrinkby(sy->ops, 1);
1342                 break;
1343             }
1344             compile_error(vec_last(sy->ops).ctx, "invalid parenthesis");
1345             return false;
1346         }
1347         if (!parser_sy_apply_operator(parser, sy))
1348             return false;
1349     }
1350     return true;
1351 }
1352
1353 static void parser_reclassify_token(parser_t *parser)
1354 {
1355     size_t i;
1356     if (parser->tok >= TOKEN_START)
1357         return;
1358     for (i = 0; i < operator_count; ++i) {
1359         if (!strcmp(parser_tokval(parser), operators[i].op)) {
1360             parser->tok = TOKEN_OPERATOR;
1361             return;
1362         }
1363     }
1364 }
1365
1366 static ast_expression* parse_vararg_do(parser_t *parser)
1367 {
1368     ast_expression *idx, *out;
1369     ast_value      *typevar;
1370     ast_value      *funtype = parser->function->vtype;
1371     lex_ctx_t         ctx     = parser_ctx(parser);
1372
1373     if (!parser->function->varargs) {
1374         parseerror(parser, "function has no variable argument list");
1375         return NULL;
1376     }
1377
1378     if (!parser_next(parser) || parser->tok != '(') {
1379         parseerror(parser, "expected parameter index and type in parenthesis");
1380         return NULL;
1381     }
1382     if (!parser_next(parser)) {
1383         parseerror(parser, "error parsing parameter index");
1384         return NULL;
1385     }
1386
1387     idx = parse_expression_leave(parser, true, false, false);
1388     if (!idx)
1389         return NULL;
1390
1391     if (parser->tok != ',') {
1392         if (parser->tok != ')') {
1393             ast_unref(idx);
1394             parseerror(parser, "expected comma after parameter index");
1395             return NULL;
1396         }
1397         /* vararg piping: ...(start) */
1398         out = (ast_expression*)ast_argpipe_new(ctx, idx);
1399         return out;
1400     }
1401
1402     if (!parser_next(parser) || (parser->tok != TOKEN_IDENT && parser->tok != TOKEN_TYPENAME)) {
1403         ast_unref(idx);
1404         parseerror(parser, "expected typename for vararg");
1405         return NULL;
1406     }
1407
1408     typevar = parse_typename(parser, NULL, NULL);
1409     if (!typevar) {
1410         ast_unref(idx);
1411         return NULL;
1412     }
1413
1414     if (parser->tok != ')') {
1415         ast_unref(idx);
1416         ast_delete(typevar);
1417         parseerror(parser, "expected closing paren");
1418         return NULL;
1419     }
1420
1421     if (funtype->expression.varparam &&
1422         !ast_compare_type((ast_expression*)typevar, (ast_expression*)funtype->expression.varparam))
1423     {
1424         char ty1[1024];
1425         char ty2[1024];
1426         ast_type_to_string((ast_expression*)typevar, ty1, sizeof(ty1));
1427         ast_type_to_string((ast_expression*)funtype->expression.varparam, ty2, sizeof(ty2));
1428         compile_error(ast_ctx(typevar),
1429                       "function was declared to take varargs of type `%s`, requested type is: %s",
1430                       ty2, ty1);
1431     }
1432
1433     out = (ast_expression*)ast_array_index_new(ctx, (ast_expression*)(parser->function->varargs), idx);
1434     ast_type_adopt(out, typevar);
1435     ast_delete(typevar);
1436     return out;
1437 }
1438
1439 static ast_expression* parse_vararg(parser_t *parser)
1440 {
1441     bool           old_noops = parser->lex->flags.noops;
1442
1443     ast_expression *out;
1444
1445     parser->lex->flags.noops = true;
1446     out = parse_vararg_do(parser);
1447
1448     parser->lex->flags.noops = old_noops;
1449     return out;
1450 }
1451
1452 /* not to be exposed */
1453 extern bool ftepp_predef_exists(const char *name);
1454
1455 static bool parse_sya_operand(parser_t *parser, shunt *sy, bool with_labels)
1456 {
1457     if (OPTS_FLAG(TRANSLATABLE_STRINGS) &&
1458         parser->tok == TOKEN_IDENT &&
1459         !strcmp(parser_tokval(parser), "_"))
1460     {
1461         /* a translatable string */
1462         ast_value *val;
1463
1464         parser->lex->flags.noops = true;
1465         if (!parser_next(parser) || parser->tok != '(') {
1466             parseerror(parser, "use _(\"string\") to create a translatable string constant");
1467             return false;
1468         }
1469         parser->lex->flags.noops = false;
1470         if (!parser_next(parser) || parser->tok != TOKEN_STRINGCONST) {
1471             parseerror(parser, "expected a constant string in translatable-string extension");
1472             return false;
1473         }
1474         val = (ast_value*)fold_constgen_string(parser->fold, parser_tokval(parser), true);
1475         if (!val)
1476             return false;
1477         vec_push(sy->out, syexp(parser_ctx(parser), (ast_expression*)val));
1478
1479         if (!parser_next(parser) || parser->tok != ')') {
1480             parseerror(parser, "expected closing paren after translatable string");
1481             return false;
1482         }
1483         return true;
1484     }
1485     else if (parser->tok == TOKEN_DOTS)
1486     {
1487         ast_expression *va;
1488         if (!OPTS_FLAG(VARIADIC_ARGS)) {
1489             parseerror(parser, "cannot access varargs (try -fvariadic-args)");
1490             return false;
1491         }
1492         va = parse_vararg(parser);
1493         if (!va)
1494             return false;
1495         vec_push(sy->out, syexp(parser_ctx(parser), va));
1496         return true;
1497     }
1498     else if (parser->tok == TOKEN_FLOATCONST) {
1499         ast_expression *val = fold_constgen_float(parser->fold, (parser_token(parser)->constval.f));
1500         if (!val)
1501             return false;
1502         vec_push(sy->out, syexp(parser_ctx(parser), val));
1503         return true;
1504     }
1505     else if (parser->tok == TOKEN_INTCONST || parser->tok == TOKEN_CHARCONST) {
1506         ast_expression *val = fold_constgen_float(parser->fold, (qcfloat_t)(parser_token(parser)->constval.i));
1507         if (!val)
1508             return false;
1509         vec_push(sy->out, syexp(parser_ctx(parser), val));
1510         return true;
1511     }
1512     else if (parser->tok == TOKEN_STRINGCONST) {
1513         ast_expression *val = fold_constgen_string(parser->fold, parser_tokval(parser), false);
1514         if (!val)
1515             return false;
1516         vec_push(sy->out, syexp(parser_ctx(parser), val));
1517         return true;
1518     }
1519     else if (parser->tok == TOKEN_VECTORCONST) {
1520         ast_expression *val = fold_constgen_vector(parser->fold, parser_token(parser)->constval.v);
1521         if (!val)
1522             return false;
1523         vec_push(sy->out, syexp(parser_ctx(parser), val));
1524         return true;
1525     }
1526     else if (parser->tok == TOKEN_IDENT)
1527     {
1528         const char     *ctoken = parser_tokval(parser);
1529         ast_expression *prev = vec_size(sy->out) ? vec_last(sy->out).out : NULL;
1530         ast_expression *var;
1531         /* a_vector.{x,y,z} */
1532         if (!vec_size(sy->ops) ||
1533             !vec_last(sy->ops).etype ||
1534             operators[vec_last(sy->ops).etype-1].id != opid1('.'))
1535         {
1536             /* When adding more intrinsics, fix the above condition */
1537             prev = NULL;
1538         }
1539         if (prev && prev->vtype == TYPE_VECTOR && ctoken[0] >= 'x' && ctoken[0] <= 'z' && !ctoken[1])
1540         {
1541             var = (ast_expression*)parser->const_vec[ctoken[0]-'x'];
1542         } else {
1543             var = parser_find_var(parser, parser_tokval(parser));
1544             if (!var)
1545                 var = parser_find_field(parser, parser_tokval(parser));
1546         }
1547         if (!var && with_labels) {
1548             var = (ast_expression*)parser_find_label(parser, parser_tokval(parser));
1549             if (!with_labels) {
1550                 ast_label *lbl = ast_label_new(parser_ctx(parser), parser_tokval(parser), true);
1551                 var = (ast_expression*)lbl;
1552                 vec_push(parser->labels, lbl);
1553             }
1554         }
1555         if (!var && !strcmp(parser_tokval(parser), "__FUNC__"))
1556             var = (ast_expression*)fold_constgen_string(parser->fold, parser->function->name, false);
1557         if (!var) {
1558             /*
1559              * now we try for the real intrinsic hashtable. If the string
1560              * begins with __builtin, we simply skip past it, otherwise we
1561              * use the identifier as is.
1562              */
1563             if (!strncmp(parser_tokval(parser), "__builtin_", 10)) {
1564                 var = intrin_func(parser, parser_tokval(parser));
1565             }
1566
1567             if (!var) {
1568                 char *correct = NULL;
1569                 size_t i;
1570
1571                 /*
1572                  * sometimes people use preprocessing predefs without enabling them
1573                  * i've done this thousands of times already myself.  Lets check for
1574                  * it in the predef table.  And diagnose it better :)
1575                  */
1576                 if (!OPTS_FLAG(FTEPP_PREDEFS) && ftepp_predef_exists(parser_tokval(parser))) {
1577                     parseerror(parser, "unexpected identifier: %s (use -fftepp-predef to enable pre-defined macros)", parser_tokval(parser));
1578                     return false;
1579                 }
1580
1581                 /*
1582                  * TODO: determine the best score for the identifier: be it
1583                  * a variable, a field.
1584                  *
1585                  * We should also consider adding correction tables for
1586                  * other things as well.
1587                  */
1588                 if (OPTS_OPTION_BOOL(OPTION_CORRECTION) && strlen(parser_tokval(parser)) <= 16) {
1589                     correction_t corr;
1590                     correct_init(&corr);
1591
1592                     for (i = 0; i < vec_size(parser->correct_variables); i++) {
1593                         correct = correct_str(&corr, parser->correct_variables[i], parser_tokval(parser));
1594                         if (strcmp(correct, parser_tokval(parser))) {
1595                             break;
1596                         } else  {
1597                             mem_d(correct);
1598                             correct = NULL;
1599                         }
1600                     }
1601                     correct_free(&corr);
1602
1603                     if (correct) {
1604                         parseerror(parser, "unexpected identifier: %s (did you mean %s?)", parser_tokval(parser), correct);
1605                         mem_d(correct);
1606                         return false;
1607                     }
1608                 }
1609                 parseerror(parser, "unexpected identifier: %s", parser_tokval(parser));
1610                 return false;
1611             }
1612         }
1613         else
1614         {
1615             if (ast_istype(var, ast_value)) {
1616                 ((ast_value*)var)->uses++;
1617             }
1618             else if (ast_istype(var, ast_member)) {
1619                 ast_member *mem = (ast_member*)var;
1620                 if (ast_istype(mem->owner, ast_value))
1621                     ((ast_value*)(mem->owner))->uses++;
1622             }
1623         }
1624         vec_push(sy->out, syexp(parser_ctx(parser), var));
1625         return true;
1626     }
1627     parseerror(parser, "unexpected token `%s`", parser_tokval(parser));
1628     return false;
1629 }
1630
1631 static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma, bool truthvalue, bool with_labels)
1632 {
1633     ast_expression *expr = NULL;
1634     shunt sy;
1635     size_t i;
1636     bool wantop = false;
1637     /* only warn once about an assignment in a truth value because the current code
1638      * would trigger twice on: if(a = b && ...), once for the if-truth-value, once for the && part
1639      */
1640     bool warn_truthvalue = true;
1641
1642     /* count the parens because an if starts with one, so the
1643      * end of a condition is an unmatched closing paren
1644      */
1645     int ternaries = 0;
1646
1647     memset(&sy, 0, sizeof(sy));
1648
1649     parser->lex->flags.noops = false;
1650
1651     parser_reclassify_token(parser);
1652
1653     while (true)
1654     {
1655         if (parser->tok == TOKEN_TYPENAME) {
1656             parseerror(parser, "unexpected typename `%s`", parser_tokval(parser));
1657             goto onerr;
1658         }
1659
1660         if (parser->tok == TOKEN_OPERATOR)
1661         {
1662             /* classify the operator */
1663             const oper_info *op;
1664             const oper_info *olast = NULL;
1665             size_t o;
1666             for (o = 0; o < operator_count; ++o) {
1667                 if (((!(operators[o].flags & OP_PREFIX) == !!wantop)) &&
1668                     /* !(operators[o].flags & OP_SUFFIX) && / * remove this */
1669                     !strcmp(parser_tokval(parser), operators[o].op))
1670                 {
1671                     break;
1672                 }
1673             }
1674             if (o == operator_count) {
1675                 compile_error(parser_ctx(parser), "unknown operator: %s", parser_tokval(parser));
1676                 goto onerr;
1677             }
1678             /* found an operator */
1679             op = &operators[o];
1680
1681             /* when declaring variables, a comma starts a new variable */
1682             if (op->id == opid1(',') && !vec_size(sy.paren) && stopatcomma) {
1683                 /* fixup the token */
1684                 parser->tok = ',';
1685                 break;
1686             }
1687
1688             /* a colon without a pervious question mark cannot be a ternary */
1689             if (!ternaries && op->id == opid2(':','?')) {
1690                 parser->tok = ':';
1691                 break;
1692             }
1693
1694             if (op->id == opid1(',')) {
1695                 if (vec_size(sy.paren) && vec_last(sy.paren) == PAREN_TERNARY2) {
1696                     (void)!parsewarning(parser, WARN_TERNARY_PRECEDENCE, "suggesting parenthesis around ternary expression");
1697                 }
1698             }
1699
1700             if (vec_size(sy.ops) && !vec_last(sy.ops).isparen)
1701                 olast = &operators[vec_last(sy.ops).etype-1];
1702
1703 #define IsAssignOp(x) (\
1704                 (x) == opid1('=') || \
1705                 (x) == opid2('+','=') || \
1706                 (x) == opid2('-','=') || \
1707                 (x) == opid2('*','=') || \
1708                 (x) == opid2('/','=') || \
1709                 (x) == opid2('%','=') || \
1710                 (x) == opid2('&','=') || \
1711                 (x) == opid2('|','=') || \
1712                 (x) == opid3('&','~','=') \
1713                 )
1714             if (warn_truthvalue) {
1715                 if ( (olast && IsAssignOp(olast->id) && (op->id == opid2('&','&') || op->id == opid2('|','|'))) ||
1716                      (olast && IsAssignOp(op->id) && (olast->id == opid2('&','&') || olast->id == opid2('|','|'))) ||
1717                      (truthvalue && !vec_size(sy.paren) && IsAssignOp(op->id))
1718                    )
1719                 {
1720                     (void)!parsewarning(parser, WARN_PARENTHESIS, "suggesting parenthesis around assignment used as truth value");
1721                     warn_truthvalue = false;
1722                 }
1723             }
1724
1725             while (olast && (
1726                     (op->prec < olast->prec) ||
1727                     (op->assoc == ASSOC_LEFT && op->prec <= olast->prec) ) )
1728             {
1729                 if (!parser_sy_apply_operator(parser, &sy))
1730                     goto onerr;
1731                 if (vec_size(sy.ops) && !vec_last(sy.ops).isparen)
1732                     olast = &operators[vec_last(sy.ops).etype-1];
1733                 else
1734                     olast = NULL;
1735             }
1736
1737             if (op->id == opid1('(')) {
1738                 if (wantop) {
1739                     size_t sycount = vec_size(sy.out);
1740                     /* we expected an operator, this is the function-call operator */
1741                     vec_push(sy.paren, PAREN_FUNC);
1742                     vec_push(sy.ops, syparen(parser_ctx(parser), sycount-1));
1743                     vec_push(sy.argc, 0);
1744                 } else {
1745                     vec_push(sy.paren, PAREN_EXPR);
1746                     vec_push(sy.ops, syparen(parser_ctx(parser), 0));
1747                 }
1748                 wantop = false;
1749             } else if (op->id == opid1('[')) {
1750                 if (!wantop) {
1751                     parseerror(parser, "unexpected array subscript");
1752                     goto onerr;
1753                 }
1754                 vec_push(sy.paren, PAREN_INDEX);
1755                 /* push both the operator and the paren, this makes life easier */
1756                 vec_push(sy.ops, syop(parser_ctx(parser), op));
1757                 vec_push(sy.ops, syparen(parser_ctx(parser), 0));
1758                 wantop = false;
1759             } else if (op->id == opid2('?',':')) {
1760                 vec_push(sy.ops, syop(parser_ctx(parser), op));
1761                 vec_push(sy.ops, syparen(parser_ctx(parser), 0));
1762                 wantop = false;
1763                 ++ternaries;
1764                 vec_push(sy.paren, PAREN_TERNARY1);
1765             } else if (op->id == opid2(':','?')) {
1766                 if (!vec_size(sy.paren)) {
1767                     parseerror(parser, "unexpected colon outside ternary expression (missing parenthesis?)");
1768                     goto onerr;
1769                 }
1770                 if (vec_last(sy.paren) != PAREN_TERNARY1) {
1771                     parseerror(parser, "unexpected colon outside ternary expression (missing parenthesis?)");
1772                     goto onerr;
1773                 }
1774                 if (!parser_close_paren(parser, &sy))
1775                     goto onerr;
1776                 vec_push(sy.ops, syop(parser_ctx(parser), op));
1777                 wantop = false;
1778                 --ternaries;
1779             } else {
1780                 vec_push(sy.ops, syop(parser_ctx(parser), op));
1781                 wantop = !!(op->flags & OP_SUFFIX);
1782             }
1783         }
1784         else if (parser->tok == ')') {
1785             while (vec_size(sy.paren) && vec_last(sy.paren) == PAREN_TERNARY2) {
1786                 if (!parser_sy_apply_operator(parser, &sy))
1787                     goto onerr;
1788             }
1789             if (!vec_size(sy.paren))
1790                 break;
1791             if (wantop) {
1792                 if (vec_last(sy.paren) == PAREN_TERNARY1) {
1793                     parseerror(parser, "mismatched parentheses (closing paren in ternary expression?)");
1794                     goto onerr;
1795                 }
1796                 if (!parser_close_paren(parser, &sy))
1797                     goto onerr;
1798             } else {
1799                 /* must be a function call without parameters */
1800                 if (vec_last(sy.paren) != PAREN_FUNC) {
1801                     parseerror(parser, "closing paren in invalid position");
1802                     goto onerr;
1803                 }
1804                 if (!parser_close_paren(parser, &sy))
1805                     goto onerr;
1806             }
1807             wantop = true;
1808         }
1809         else if (parser->tok == '(') {
1810             parseerror(parser, "internal error: '(' should be classified as operator");
1811             goto onerr;
1812         }
1813         else if (parser->tok == '[') {
1814             parseerror(parser, "internal error: '[' should be classified as operator");
1815             goto onerr;
1816         }
1817         else if (parser->tok == ']') {
1818             while (vec_size(sy.paren) && vec_last(sy.paren) == PAREN_TERNARY2) {
1819                 if (!parser_sy_apply_operator(parser, &sy))
1820                     goto onerr;
1821             }
1822             if (!vec_size(sy.paren))
1823                 break;
1824             if (vec_last(sy.paren) != PAREN_INDEX) {
1825                 parseerror(parser, "mismatched parentheses, unexpected ']'");
1826                 goto onerr;
1827             }
1828             if (!parser_close_paren(parser, &sy))
1829                 goto onerr;
1830             wantop = true;
1831         }
1832         else if (!wantop) {
1833             if (!parse_sya_operand(parser, &sy, with_labels))
1834                 goto onerr;
1835 #if 0
1836             if (vec_size(sy.paren) && vec_last(sy.ops).isparen && vec_last(sy.paren) == PAREN_FUNC)
1837                 vec_last(sy.argc)++;
1838 #endif
1839             wantop = true;
1840         }
1841         else {
1842             /* in this case we might want to allow constant string concatenation */
1843             bool concatenated = false;
1844             if (parser->tok == TOKEN_STRINGCONST && vec_size(sy.out)) {
1845                 ast_expression *lexpr = vec_last(sy.out).out;
1846                 if (ast_istype(lexpr, ast_value)) {
1847                     ast_value *last = (ast_value*)lexpr;
1848                     if (last->isimm == true && last->cvq == CV_CONST &&
1849                         last->hasvalue && last->expression.vtype == TYPE_STRING)
1850                     {
1851                         char *newstr = NULL;
1852                         util_asprintf(&newstr, "%s%s", last->constval.vstring, parser_tokval(parser));
1853                         vec_last(sy.out).out = (ast_expression*)fold_constgen_string(parser->fold, newstr, false);
1854                         mem_d(newstr);
1855                         concatenated = true;
1856                     }
1857                 }
1858             }
1859             if (!concatenated) {
1860                 parseerror(parser, "expected operator or end of statement");
1861                 goto onerr;
1862             }
1863         }
1864
1865         if (!parser_next(parser)) {
1866             goto onerr;
1867         }
1868         if (parser->tok == ';' ||
1869             ((!vec_size(sy.paren) || (vec_size(sy.paren) == 1 && vec_last(sy.paren) == PAREN_TERNARY2)) &&
1870             (parser->tok == ']' || parser->tok == ')' || parser->tok == '}')))
1871         {
1872             break;
1873         }
1874     }
1875
1876     while (vec_size(sy.ops)) {
1877         if (!parser_sy_apply_operator(parser, &sy))
1878             goto onerr;
1879     }
1880
1881     parser->lex->flags.noops = true;
1882     if (vec_size(sy.out) != 1) {
1883         parseerror(parser, "expression with not 1 but %lu output values...", (unsigned long) vec_size(sy.out));
1884         expr = NULL;
1885     } else
1886         expr = sy.out[0].out;
1887     vec_free(sy.out);
1888     vec_free(sy.ops);
1889     if (vec_size(sy.paren)) {
1890         parseerror(parser, "internal error: vec_size(sy.paren) = %lu", (unsigned long)vec_size(sy.paren));
1891         return NULL;
1892     }
1893     vec_free(sy.paren);
1894     vec_free(sy.argc);
1895     return expr;
1896
1897 onerr:
1898     parser->lex->flags.noops = true;
1899     for (i = 0; i < vec_size(sy.out); ++i) {
1900         if (sy.out[i].out)
1901             ast_unref(sy.out[i].out);
1902     }
1903     vec_free(sy.out);
1904     vec_free(sy.ops);
1905     vec_free(sy.paren);
1906     vec_free(sy.argc);
1907     return NULL;
1908 }
1909
1910 static ast_expression* parse_expression(parser_t *parser, bool stopatcomma, bool with_labels)
1911 {
1912     ast_expression *e = parse_expression_leave(parser, stopatcomma, false, with_labels);
1913     if (!e)
1914         return NULL;
1915     if (parser->tok != ';') {
1916         parseerror(parser, "semicolon expected after expression");
1917         ast_unref(e);
1918         return NULL;
1919     }
1920     if (!parser_next(parser)) {
1921         ast_unref(e);
1922         return NULL;
1923     }
1924     return e;
1925 }
1926
1927 static void parser_enterblock(parser_t *parser)
1928 {
1929     vec_push(parser->variables, util_htnew(PARSER_HT_SIZE));
1930     vec_push(parser->_blocklocals, vec_size(parser->_locals));
1931     vec_push(parser->typedefs, util_htnew(TYPEDEF_HT_SIZE));
1932     vec_push(parser->_blocktypedefs, vec_size(parser->_typedefs));
1933     vec_push(parser->_block_ctx, parser_ctx(parser));
1934
1935     /* corrector */
1936     vec_push(parser->correct_variables, correct_trie_new());
1937     vec_push(parser->correct_variables_score, NULL);
1938 }
1939
1940 static bool parser_leaveblock(parser_t *parser)
1941 {
1942     bool   rv = true;
1943     size_t locals, typedefs;
1944
1945     if (vec_size(parser->variables) <= PARSER_HT_LOCALS) {
1946         parseerror(parser, "internal error: parser_leaveblock with no block");
1947         return false;
1948     }
1949
1950     util_htdel(vec_last(parser->variables));
1951     correct_del(vec_last(parser->correct_variables), vec_last(parser->correct_variables_score));
1952
1953     vec_pop(parser->variables);
1954     vec_pop(parser->correct_variables);
1955     vec_pop(parser->correct_variables_score);
1956     if (!vec_size(parser->_blocklocals)) {
1957         parseerror(parser, "internal error: parser_leaveblock with no block (2)");
1958         return false;
1959     }
1960
1961     locals = vec_last(parser->_blocklocals);
1962     vec_pop(parser->_blocklocals);
1963     while (vec_size(parser->_locals) != locals) {
1964         ast_expression *e = vec_last(parser->_locals);
1965         ast_value      *v = (ast_value*)e;
1966         vec_pop(parser->_locals);
1967         if (ast_istype(e, ast_value) && !v->uses) {
1968             if (compile_warning(ast_ctx(v), WARN_UNUSED_VARIABLE, "unused variable: `%s`", v->name))
1969                 rv = false;
1970         }
1971     }
1972
1973     typedefs = vec_last(parser->_blocktypedefs);
1974     while (vec_size(parser->_typedefs) != typedefs) {
1975         ast_delete(vec_last(parser->_typedefs));
1976         vec_pop(parser->_typedefs);
1977     }
1978     util_htdel(vec_last(parser->typedefs));
1979     vec_pop(parser->typedefs);
1980
1981     vec_pop(parser->_block_ctx);
1982
1983     return rv;
1984 }
1985
1986 static void parser_addlocal(parser_t *parser, const char *name, ast_expression *e)
1987 {
1988     vec_push(parser->_locals, e);
1989     util_htset(vec_last(parser->variables), name, (void*)e);
1990
1991     /* corrector */
1992     correct_add (
1993          vec_last(parser->correct_variables),
1994         &vec_last(parser->correct_variables_score),
1995         name
1996     );
1997 }
1998
1999 static void parser_addglobal(parser_t *parser, const char *name, ast_expression *e)
2000 {
2001     vec_push(parser->globals, e);
2002     util_htset(parser->htglobals, name, e);
2003
2004     /* corrector */
2005     correct_add (
2006          parser->correct_variables[0],
2007         &parser->correct_variables_score[0],
2008         name
2009     );
2010 }
2011
2012 static ast_expression* process_condition(parser_t *parser, ast_expression *cond, bool *_ifnot)
2013 {
2014     bool       ifnot = false;
2015     ast_unary *unary;
2016     ast_expression *prev;
2017
2018     if (cond->vtype == TYPE_VOID || cond->vtype >= TYPE_VARIANT) {
2019         char ty[1024];
2020         ast_type_to_string(cond, ty, sizeof(ty));
2021         compile_error(ast_ctx(cond), "invalid type for if() condition: %s", ty);
2022     }
2023
2024     if (OPTS_FLAG(FALSE_EMPTY_STRINGS) && cond->vtype == TYPE_STRING)
2025     {
2026         prev = cond;
2027         cond = (ast_expression*)ast_unary_new(ast_ctx(cond), INSTR_NOT_S, cond);
2028         if (!cond) {
2029             ast_unref(prev);
2030             parseerror(parser, "internal error: failed to process condition");
2031             return NULL;
2032         }
2033         ifnot = !ifnot;
2034     }
2035     else if (OPTS_FLAG(CORRECT_LOGIC) && cond->vtype == TYPE_VECTOR)
2036     {
2037         /* vector types need to be cast to true booleans */
2038         ast_binary *bin = (ast_binary*)cond;
2039         if (!OPTS_FLAG(PERL_LOGIC) || !ast_istype(cond, ast_binary) || !(bin->op == INSTR_AND || bin->op == INSTR_OR))
2040         {
2041             /* in perl-logic, AND and OR take care of the -fcorrect-logic */
2042             prev = cond;
2043             cond = (ast_expression*)ast_unary_new(ast_ctx(cond), INSTR_NOT_V, cond);
2044             if (!cond) {
2045                 ast_unref(prev);
2046                 parseerror(parser, "internal error: failed to process condition");
2047                 return NULL;
2048             }
2049             ifnot = !ifnot;
2050         }
2051     }
2052
2053     unary = (ast_unary*)cond;
2054     /* ast_istype dereferences cond, should test here for safety */
2055     while (cond && ast_istype(cond, ast_unary) && unary->op == INSTR_NOT_F)
2056     {
2057         cond = unary->operand;
2058         unary->operand = NULL;
2059         ast_delete(unary);
2060         ifnot = !ifnot;
2061         unary = (ast_unary*)cond;
2062     }
2063
2064     if (!cond)
2065         parseerror(parser, "internal error: failed to process condition");
2066
2067     if (ifnot) *_ifnot = !*_ifnot;
2068     return cond;
2069 }
2070
2071 static bool parse_if(parser_t *parser, ast_block *block, ast_expression **out)
2072 {
2073     ast_ifthen *ifthen;
2074     ast_expression *cond, *ontrue = NULL, *onfalse = NULL;
2075     bool ifnot = false;
2076
2077     lex_ctx_t ctx = parser_ctx(parser);
2078
2079     (void)block; /* not touching */
2080
2081     /* skip the 'if', parse an optional 'not' and check for an opening paren */
2082     if (!parser_next(parser)) {
2083         parseerror(parser, "expected condition or 'not'");
2084         return false;
2085     }
2086     if (parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "not")) {
2087         ifnot = true;
2088         if (!parser_next(parser)) {
2089             parseerror(parser, "expected condition in parenthesis");
2090             return false;
2091         }
2092     }
2093     if (parser->tok != '(') {
2094         parseerror(parser, "expected 'if' condition in parenthesis");
2095         return false;
2096     }
2097     /* parse into the expression */
2098     if (!parser_next(parser)) {
2099         parseerror(parser, "expected 'if' condition after opening paren");
2100         return false;
2101     }
2102     /* parse the condition */
2103     cond = parse_expression_leave(parser, false, true, false);
2104     if (!cond)
2105         return false;
2106     /* closing paren */
2107     if (parser->tok != ')') {
2108         parseerror(parser, "expected closing paren after 'if' condition");
2109         ast_unref(cond);
2110         return false;
2111     }
2112     /* parse into the 'then' branch */
2113     if (!parser_next(parser)) {
2114         parseerror(parser, "expected statement for on-true branch of 'if'");
2115         ast_unref(cond);
2116         return false;
2117     }
2118     if (!parse_statement_or_block(parser, &ontrue)) {
2119         ast_unref(cond);
2120         return false;
2121     }
2122     if (!ontrue)
2123         ontrue = (ast_expression*)ast_block_new(parser_ctx(parser));
2124     /* check for an else */
2125     if (!strcmp(parser_tokval(parser), "else")) {
2126         /* parse into the 'else' branch */
2127         if (!parser_next(parser)) {
2128             parseerror(parser, "expected on-false branch after 'else'");
2129             ast_delete(ontrue);
2130             ast_unref(cond);
2131             return false;
2132         }
2133         if (!parse_statement_or_block(parser, &onfalse)) {
2134             ast_delete(ontrue);
2135             ast_unref(cond);
2136             return false;
2137         }
2138     }
2139
2140     cond = process_condition(parser, cond, &ifnot);
2141     if (!cond) {
2142         if (ontrue)  ast_delete(ontrue);
2143         if (onfalse) ast_delete(onfalse);
2144         return false;
2145     }
2146
2147     if (ifnot)
2148         ifthen = ast_ifthen_new(ctx, cond, onfalse, ontrue);
2149     else
2150         ifthen = ast_ifthen_new(ctx, cond, ontrue, onfalse);
2151     *out = (ast_expression*)ifthen;
2152     return true;
2153 }
2154
2155 static bool parse_while_go(parser_t *parser, ast_block *block, ast_expression **out);
2156 static bool parse_while(parser_t *parser, ast_block *block, ast_expression **out)
2157 {
2158     bool rv;
2159     char *label = NULL;
2160
2161     /* skip the 'while' and get the body */
2162     if (!parser_next(parser)) {
2163         if (OPTS_FLAG(LOOP_LABELS))
2164             parseerror(parser, "expected loop label or 'while' condition in parenthesis");
2165         else
2166             parseerror(parser, "expected 'while' condition in parenthesis");
2167         return false;
2168     }
2169
2170     if (parser->tok == ':') {
2171         if (!OPTS_FLAG(LOOP_LABELS))
2172             parseerror(parser, "labeled loops not activated, try using -floop-labels");
2173         if (!parser_next(parser) || parser->tok != TOKEN_IDENT) {
2174             parseerror(parser, "expected loop label");
2175             return false;
2176         }
2177         label = util_strdup(parser_tokval(parser));
2178         if (!parser_next(parser)) {
2179             mem_d(label);
2180             parseerror(parser, "expected 'while' condition in parenthesis");
2181             return false;
2182         }
2183     }
2184
2185     if (parser->tok != '(') {
2186         parseerror(parser, "expected 'while' condition in parenthesis");
2187         return false;
2188     }
2189
2190     vec_push(parser->breaks, label);
2191     vec_push(parser->continues, label);
2192
2193     rv = parse_while_go(parser, block, out);
2194     if (label)
2195         mem_d(label);
2196     if (vec_last(parser->breaks) != label || vec_last(parser->continues) != label) {
2197         parseerror(parser, "internal error: label stack corrupted");
2198         rv = false;
2199         ast_delete(*out);
2200         *out = NULL;
2201     }
2202     else {
2203         vec_pop(parser->breaks);
2204         vec_pop(parser->continues);
2205     }
2206     return rv;
2207 }
2208
2209 static bool parse_while_go(parser_t *parser, ast_block *block, ast_expression **out)
2210 {
2211     ast_loop *aloop;
2212     ast_expression *cond, *ontrue;
2213
2214     bool ifnot = false;
2215
2216     lex_ctx_t ctx = parser_ctx(parser);
2217
2218     (void)block; /* not touching */
2219
2220     /* parse into the expression */
2221     if (!parser_next(parser)) {
2222         parseerror(parser, "expected 'while' condition after opening paren");
2223         return false;
2224     }
2225     /* parse the condition */
2226     cond = parse_expression_leave(parser, false, true, false);
2227     if (!cond)
2228         return false;
2229     /* closing paren */
2230     if (parser->tok != ')') {
2231         parseerror(parser, "expected closing paren after 'while' condition");
2232         ast_unref(cond);
2233         return false;
2234     }
2235     /* parse into the 'then' branch */
2236     if (!parser_next(parser)) {
2237         parseerror(parser, "expected while-loop body");
2238         ast_unref(cond);
2239         return false;
2240     }
2241     if (!parse_statement_or_block(parser, &ontrue)) {
2242         ast_unref(cond);
2243         return false;
2244     }
2245
2246     cond = process_condition(parser, cond, &ifnot);
2247     if (!cond) {
2248         ast_unref(ontrue);
2249         return false;
2250     }
2251     aloop = ast_loop_new(ctx, NULL, cond, ifnot, NULL, false, NULL, ontrue);
2252     *out = (ast_expression*)aloop;
2253     return true;
2254 }
2255
2256 static bool parse_dowhile_go(parser_t *parser, ast_block *block, ast_expression **out);
2257 static bool parse_dowhile(parser_t *parser, ast_block *block, ast_expression **out)
2258 {
2259     bool rv;
2260     char *label = NULL;
2261
2262     /* skip the 'do' and get the body */
2263     if (!parser_next(parser)) {
2264         if (OPTS_FLAG(LOOP_LABELS))
2265             parseerror(parser, "expected loop label or body");
2266         else
2267             parseerror(parser, "expected loop body");
2268         return false;
2269     }
2270
2271     if (parser->tok == ':') {
2272         if (!OPTS_FLAG(LOOP_LABELS))
2273             parseerror(parser, "labeled loops not activated, try using -floop-labels");
2274         if (!parser_next(parser) || parser->tok != TOKEN_IDENT) {
2275             parseerror(parser, "expected loop label");
2276             return false;
2277         }
2278         label = util_strdup(parser_tokval(parser));
2279         if (!parser_next(parser)) {
2280             mem_d(label);
2281             parseerror(parser, "expected loop body");
2282             return false;
2283         }
2284     }
2285
2286     vec_push(parser->breaks, label);
2287     vec_push(parser->continues, label);
2288
2289     rv = parse_dowhile_go(parser, block, out);
2290     if (label)
2291         mem_d(label);
2292     if (vec_last(parser->breaks) != label || vec_last(parser->continues) != label) {
2293         parseerror(parser, "internal error: label stack corrupted");
2294         rv = false;
2295         /*
2296          * Test for NULL otherwise ast_delete dereferences null pointer
2297          * and boom.
2298          */
2299         if (*out)
2300             ast_delete(*out);
2301         *out = NULL;
2302     }
2303     else {
2304         vec_pop(parser->breaks);
2305         vec_pop(parser->continues);
2306     }
2307     return rv;
2308 }
2309
2310 static bool parse_dowhile_go(parser_t *parser, ast_block *block, ast_expression **out)
2311 {
2312     ast_loop *aloop;
2313     ast_expression *cond, *ontrue;
2314
2315     bool ifnot = false;
2316
2317     lex_ctx_t ctx = parser_ctx(parser);
2318
2319     (void)block; /* not touching */
2320
2321     if (!parse_statement_or_block(parser, &ontrue))
2322         return false;
2323
2324     /* expect the "while" */
2325     if (parser->tok != TOKEN_KEYWORD ||
2326         strcmp(parser_tokval(parser), "while"))
2327     {
2328         parseerror(parser, "expected 'while' and condition");
2329         ast_delete(ontrue);
2330         return false;
2331     }
2332
2333     /* skip the 'while' and check for opening paren */
2334     if (!parser_next(parser) || parser->tok != '(') {
2335         parseerror(parser, "expected 'while' condition in parenthesis");
2336         ast_delete(ontrue);
2337         return false;
2338     }
2339     /* parse into the expression */
2340     if (!parser_next(parser)) {
2341         parseerror(parser, "expected 'while' condition after opening paren");
2342         ast_delete(ontrue);
2343         return false;
2344     }
2345     /* parse the condition */
2346     cond = parse_expression_leave(parser, false, true, false);
2347     if (!cond)
2348         return false;
2349     /* closing paren */
2350     if (parser->tok != ')') {
2351         parseerror(parser, "expected closing paren after 'while' condition");
2352         ast_delete(ontrue);
2353         ast_unref(cond);
2354         return false;
2355     }
2356     /* parse on */
2357     if (!parser_next(parser) || parser->tok != ';') {
2358         parseerror(parser, "expected semicolon after condition");
2359         ast_delete(ontrue);
2360         ast_unref(cond);
2361         return false;
2362     }
2363
2364     if (!parser_next(parser)) {
2365         parseerror(parser, "parse error");
2366         ast_delete(ontrue);
2367         ast_unref(cond);
2368         return false;
2369     }
2370
2371     cond = process_condition(parser, cond, &ifnot);
2372     if (!cond) {
2373         ast_delete(ontrue);
2374         return false;
2375     }
2376     aloop = ast_loop_new(ctx, NULL, NULL, false, cond, ifnot, NULL, ontrue);
2377     *out = (ast_expression*)aloop;
2378     return true;
2379 }
2380
2381 static bool parse_for_go(parser_t *parser, ast_block *block, ast_expression **out);
2382 static bool parse_for(parser_t *parser, ast_block *block, ast_expression **out)
2383 {
2384     bool rv;
2385     char *label = NULL;
2386
2387     /* skip the 'for' and check for opening paren */
2388     if (!parser_next(parser)) {
2389         if (OPTS_FLAG(LOOP_LABELS))
2390             parseerror(parser, "expected loop label or 'for' expressions in parenthesis");
2391         else
2392             parseerror(parser, "expected 'for' expressions in parenthesis");
2393         return false;
2394     }
2395
2396     if (parser->tok == ':') {
2397         if (!OPTS_FLAG(LOOP_LABELS))
2398             parseerror(parser, "labeled loops not activated, try using -floop-labels");
2399         if (!parser_next(parser) || parser->tok != TOKEN_IDENT) {
2400             parseerror(parser, "expected loop label");
2401             return false;
2402         }
2403         label = util_strdup(parser_tokval(parser));
2404         if (!parser_next(parser)) {
2405             mem_d(label);
2406             parseerror(parser, "expected 'for' expressions in parenthesis");
2407             return false;
2408         }
2409     }
2410
2411     if (parser->tok != '(') {
2412         parseerror(parser, "expected 'for' expressions in parenthesis");
2413         return false;
2414     }
2415
2416     vec_push(parser->breaks, label);
2417     vec_push(parser->continues, label);
2418
2419     rv = parse_for_go(parser, block, out);
2420     if (label)
2421         mem_d(label);
2422     if (vec_last(parser->breaks) != label || vec_last(parser->continues) != label) {
2423         parseerror(parser, "internal error: label stack corrupted");
2424         rv = false;
2425         ast_delete(*out);
2426         *out = NULL;
2427     }
2428     else {
2429         vec_pop(parser->breaks);
2430         vec_pop(parser->continues);
2431     }
2432     return rv;
2433 }
2434 static bool parse_for_go(parser_t *parser, ast_block *block, ast_expression **out)
2435 {
2436     ast_loop       *aloop;
2437     ast_expression *initexpr, *cond, *increment, *ontrue;
2438     ast_value      *typevar;
2439
2440     bool ifnot  = false;
2441
2442     lex_ctx_t ctx = parser_ctx(parser);
2443
2444     parser_enterblock(parser);
2445
2446     initexpr  = NULL;
2447     cond      = NULL;
2448     increment = NULL;
2449     ontrue    = NULL;
2450
2451     /* parse into the expression */
2452     if (!parser_next(parser)) {
2453         parseerror(parser, "expected 'for' initializer after opening paren");
2454         goto onerr;
2455     }
2456
2457     typevar = NULL;
2458     if (parser->tok == TOKEN_IDENT)
2459         typevar = parser_find_typedef(parser, parser_tokval(parser), 0);
2460
2461     if (typevar || parser->tok == TOKEN_TYPENAME) {
2462 #if 0
2463         if (OPTS_OPTION_U32(OPTION_STANDARD) != COMPILER_GMQCC) {
2464             if (parsewarning(parser, WARN_EXTENSIONS,
2465                              "current standard does not allow variable declarations in for-loop initializers"))
2466                 goto onerr;
2467         }
2468 #endif
2469         if (!parse_variable(parser, block, true, CV_VAR, typevar, false, false, 0, NULL))
2470             goto onerr;
2471     }
2472     else if (parser->tok != ';')
2473     {
2474         initexpr = parse_expression_leave(parser, false, false, false);
2475         if (!initexpr)
2476             goto onerr;
2477     }
2478
2479     /* move on to condition */
2480     if (parser->tok != ';') {
2481         parseerror(parser, "expected semicolon after for-loop initializer");
2482         goto onerr;
2483     }
2484     if (!parser_next(parser)) {
2485         parseerror(parser, "expected for-loop condition");
2486         goto onerr;
2487     }
2488
2489     /* parse the condition */
2490     if (parser->tok != ';') {
2491         cond = parse_expression_leave(parser, false, true, false);
2492         if (!cond)
2493             goto onerr;
2494     }
2495
2496     /* move on to incrementor */
2497     if (parser->tok != ';') {
2498         parseerror(parser, "expected semicolon after for-loop initializer");
2499         goto onerr;
2500     }
2501     if (!parser_next(parser)) {
2502         parseerror(parser, "expected for-loop condition");
2503         goto onerr;
2504     }
2505
2506     /* parse the incrementor */
2507     if (parser->tok != ')') {
2508         lex_ctx_t condctx = parser_ctx(parser);
2509         increment = parse_expression_leave(parser, false, false, false);
2510         if (!increment)
2511             goto onerr;
2512         if (!ast_side_effects(increment)) {
2513             if (compile_warning(condctx, WARN_EFFECTLESS_STATEMENT, "statement has no effect"))
2514                 goto onerr;
2515         }
2516     }
2517
2518     /* closing paren */
2519     if (parser->tok != ')') {
2520         parseerror(parser, "expected closing paren after 'for-loop' incrementor");
2521         goto onerr;
2522     }
2523     /* parse into the 'then' branch */
2524     if (!parser_next(parser)) {
2525         parseerror(parser, "expected for-loop body");
2526         goto onerr;
2527     }
2528     if (!parse_statement_or_block(parser, &ontrue))
2529         goto onerr;
2530
2531     if (cond) {
2532         cond = process_condition(parser, cond, &ifnot);
2533         if (!cond)
2534             goto onerr;
2535     }
2536     aloop = ast_loop_new(ctx, initexpr, cond, ifnot, NULL, false, increment, ontrue);
2537     *out = (ast_expression*)aloop;
2538
2539     if (!parser_leaveblock(parser)) {
2540         ast_delete(aloop);
2541         return false;
2542     }
2543     return true;
2544 onerr:
2545     if (initexpr)  ast_unref(initexpr);
2546     if (cond)      ast_unref(cond);
2547     if (increment) ast_unref(increment);
2548     (void)!parser_leaveblock(parser);
2549     return false;
2550 }
2551
2552 static bool parse_return(parser_t *parser, ast_block *block, ast_expression **out)
2553 {
2554     ast_expression *exp      = NULL;
2555     ast_expression *var      = NULL;
2556     ast_return     *ret      = NULL;
2557     ast_value      *retval   = parser->function->return_value;
2558     ast_value      *expected = parser->function->vtype;
2559
2560     lex_ctx_t ctx = parser_ctx(parser);
2561
2562     (void)block; /* not touching */
2563
2564     if (!parser_next(parser)) {
2565         parseerror(parser, "expected return expression");
2566         return false;
2567     }
2568
2569     /* return assignments */
2570     if (parser->tok == '=') {
2571         if (!OPTS_FLAG(RETURN_ASSIGNMENTS)) {
2572             parseerror(parser, "return assignments not activated, try using -freturn-assigments");
2573             return false;
2574         }
2575
2576         if (type_store_instr[expected->expression.next->vtype] == VINSTR_END) {
2577             char ty1[1024];
2578             ast_type_to_string(expected->expression.next, ty1, sizeof(ty1));
2579             parseerror(parser, "invalid return type: `%s'", ty1);
2580             return false;
2581         }
2582
2583         if (!parser_next(parser)) {
2584             parseerror(parser, "expected return assignment expression");
2585             return false;
2586         }
2587
2588         if (!(exp = parse_expression_leave(parser, false, false, false)))
2589             return false;
2590
2591         /* prepare the return value */
2592         if (!retval) {
2593             retval = ast_value_new(ctx, "#LOCAL_RETURN", TYPE_VOID);
2594             ast_type_adopt(retval, expected->expression.next);
2595             parser->function->return_value = retval;
2596         }
2597
2598         if (!ast_compare_type(exp, (ast_expression*)retval)) {
2599             char ty1[1024], ty2[1024];
2600             ast_type_to_string(exp, ty1, sizeof(ty1));
2601             ast_type_to_string(&retval->expression, ty2, sizeof(ty2));
2602             parseerror(parser, "invalid type for return value: `%s', expected `%s'", ty1, ty2);
2603         }
2604
2605         /* store to 'return' local variable */
2606         var = (ast_expression*)ast_store_new(
2607             ctx,
2608             type_store_instr[expected->expression.next->vtype],
2609             (ast_expression*)retval, exp);
2610
2611         if (!var) {
2612             ast_unref(exp);
2613             return false;
2614         }
2615
2616         if (parser->tok != ';')
2617             parseerror(parser, "missing semicolon after return assignment");
2618         else if (!parser_next(parser))
2619             parseerror(parser, "parse error after return assignment");
2620
2621         *out = var;
2622         return true;
2623     }
2624
2625     if (parser->tok != ';') {
2626         exp = parse_expression(parser, false, false);
2627         if (!exp)
2628             return false;
2629
2630         if (exp->vtype != TYPE_NIL &&
2631             exp->vtype != ((ast_expression*)expected)->next->vtype)
2632         {
2633             parseerror(parser, "return with invalid expression");
2634         }
2635
2636         ret = ast_return_new(ctx, exp);
2637         if (!ret) {
2638             ast_unref(exp);
2639             return false;
2640         }
2641     } else {
2642         if (!parser_next(parser))
2643             parseerror(parser, "parse error");
2644
2645         if (!retval && expected->expression.next->vtype != TYPE_VOID)
2646         {
2647             (void)!parsewarning(parser, WARN_MISSING_RETURN_VALUES, "return without value");
2648         }
2649         ret = ast_return_new(ctx, (ast_expression*)retval);
2650     }
2651     *out = (ast_expression*)ret;
2652     return true;
2653 }
2654
2655 static bool parse_break_continue(parser_t *parser, ast_block *block, ast_expression **out, bool is_continue)
2656 {
2657     size_t       i;
2658     unsigned int levels = 0;
2659     lex_ctx_t      ctx = parser_ctx(parser);
2660     const char **loops = (is_continue ? parser->continues : parser->breaks);
2661
2662     (void)block; /* not touching */
2663     if (!parser_next(parser)) {
2664         parseerror(parser, "expected semicolon or loop label");
2665         return false;
2666     }
2667
2668     if (!vec_size(loops)) {
2669         if (is_continue)
2670             parseerror(parser, "`continue` can only be used inside loops");
2671         else
2672             parseerror(parser, "`break` can only be used inside loops or switches");
2673     }
2674
2675     if (parser->tok == TOKEN_IDENT) {
2676         if (!OPTS_FLAG(LOOP_LABELS))
2677             parseerror(parser, "labeled loops not activated, try using -floop-labels");
2678         i = vec_size(loops);
2679         while (i--) {
2680             if (loops[i] && !strcmp(loops[i], parser_tokval(parser)))
2681                 break;
2682             if (!i) {
2683                 parseerror(parser, "no such loop to %s: `%s`",
2684                            (is_continue ? "continue" : "break out of"),
2685                            parser_tokval(parser));
2686                 return false;
2687             }
2688             ++levels;
2689         }
2690         if (!parser_next(parser)) {
2691             parseerror(parser, "expected semicolon");
2692             return false;
2693         }
2694     }
2695
2696     if (parser->tok != ';') {
2697         parseerror(parser, "expected semicolon");
2698         return false;
2699     }
2700
2701     if (!parser_next(parser))
2702         parseerror(parser, "parse error");
2703
2704     *out = (ast_expression*)ast_breakcont_new(ctx, is_continue, levels);
2705     return true;
2706 }
2707
2708 /* returns true when it was a variable qualifier, false otherwise!
2709  * on error, cvq is set to CV_WRONG
2710  */
2711 static bool parse_qualifiers(parser_t *parser, bool with_local, int *cvq, bool *noref, bool *is_static, uint32_t *_flags, char **message)
2712 {
2713     bool had_const    = false;
2714     bool had_var      = false;
2715     bool had_noref    = false;
2716     bool had_attrib   = false;
2717     bool had_static   = false;
2718     uint32_t flags    = 0;
2719
2720     *cvq = CV_NONE;
2721     for (;;) {
2722         if (parser->tok == TOKEN_ATTRIBUTE_OPEN) {
2723             had_attrib = true;
2724             /* parse an attribute */
2725             if (!parser_next(parser)) {
2726                 parseerror(parser, "expected attribute after `[[`");
2727                 *cvq = CV_WRONG;
2728                 return false;
2729             }
2730             if (!strcmp(parser_tokval(parser), "noreturn")) {
2731                 flags |= AST_FLAG_NORETURN;
2732                 if (!parser_next(parser) || parser->tok != TOKEN_ATTRIBUTE_CLOSE) {
2733                     parseerror(parser, "`noreturn` attribute has no parameters, expected `]]`");
2734                     *cvq = CV_WRONG;
2735                     return false;
2736                 }
2737             }
2738             else if (!strcmp(parser_tokval(parser), "noref")) {
2739                 had_noref = true;
2740                 if (!parser_next(parser) || parser->tok != TOKEN_ATTRIBUTE_CLOSE) {
2741                     parseerror(parser, "`noref` attribute has no parameters, expected `]]`");
2742                     *cvq = CV_WRONG;
2743                     return false;
2744                 }
2745             }
2746             else if (!strcmp(parser_tokval(parser), "inline")) {
2747                 flags |= AST_FLAG_INLINE;
2748                 if (!parser_next(parser) || parser->tok != TOKEN_ATTRIBUTE_CLOSE) {
2749                     parseerror(parser, "`noref` attribute has no parameters, expected `]]`");
2750                     *cvq = CV_WRONG;
2751                     return false;
2752                 }
2753             }
2754             else if (!strcmp(parser_tokval(parser), "alias") && !(flags & AST_FLAG_ALIAS)) {
2755                 flags   |= AST_FLAG_ALIAS;
2756                 *message = NULL;
2757
2758                 if (!parser_next(parser)) {
2759                     parseerror(parser, "parse error in attribute");
2760                     goto argerr;
2761                 }
2762
2763                 if (parser->tok == '(') {
2764                     if (!parser_next(parser) || parser->tok != TOKEN_STRINGCONST) {
2765                         parseerror(parser, "`alias` attribute missing parameter");
2766                         goto argerr;
2767                     }
2768
2769                     *message = util_strdup(parser_tokval(parser));
2770
2771                     if (!parser_next(parser)) {
2772                         parseerror(parser, "parse error in attribute");
2773                         goto argerr;
2774                     }
2775
2776                     if (parser->tok != ')') {
2777                         parseerror(parser, "`alias` attribute expected `)` after parameter");
2778                         goto argerr;
2779                     }
2780
2781                     if (!parser_next(parser)) {
2782                         parseerror(parser, "parse error in attribute");
2783                         goto argerr;
2784                     }
2785                 }
2786
2787                 if (parser->tok != TOKEN_ATTRIBUTE_CLOSE) {
2788                     parseerror(parser, "`alias` attribute expected `]]`");
2789                     goto argerr;
2790                 }
2791             }
2792             else if (!strcmp(parser_tokval(parser), "deprecated") && !(flags & AST_FLAG_DEPRECATED)) {
2793                 flags   |= AST_FLAG_DEPRECATED;
2794                 *message = NULL;
2795
2796                 if (!parser_next(parser)) {
2797                     parseerror(parser, "parse error in attribute");
2798                     goto argerr;
2799                 }
2800
2801                 if (parser->tok == '(') {
2802                     if (!parser_next(parser) || parser->tok != TOKEN_STRINGCONST) {
2803                         parseerror(parser, "`deprecated` attribute missing parameter");
2804                         goto argerr;
2805                     }
2806
2807                     *message = util_strdup(parser_tokval(parser));
2808
2809                     if (!parser_next(parser)) {
2810                         parseerror(parser, "parse error in attribute");
2811                         goto argerr;
2812                     }
2813
2814                     if(parser->tok != ')') {
2815                         parseerror(parser, "`deprecated` attribute expected `)` after parameter");
2816                         goto argerr;
2817                     }
2818
2819                     if (!parser_next(parser)) {
2820                         parseerror(parser, "parse error in attribute");
2821                         goto argerr;
2822                     }
2823                 }
2824                 /* no message */
2825                 if (parser->tok != TOKEN_ATTRIBUTE_CLOSE) {
2826                     parseerror(parser, "`deprecated` attribute expected `]]`");
2827
2828                     argerr: /* ugly */
2829                     if (*message) mem_d(*message);
2830                     *message = NULL;
2831                     *cvq     = CV_WRONG;
2832                     return false;
2833                 }
2834             }
2835             else
2836             {
2837                 /* Skip tokens until we hit a ]] */
2838                 (void)!parsewarning(parser, WARN_UNKNOWN_ATTRIBUTE, "unknown attribute starting with `%s`", parser_tokval(parser));
2839                 while (parser->tok != TOKEN_ATTRIBUTE_CLOSE) {
2840                     if (!parser_next(parser)) {
2841                         parseerror(parser, "error inside attribute");
2842                         *cvq = CV_WRONG;
2843                         return false;
2844                     }
2845                 }
2846             }
2847         }
2848         else if (with_local && !strcmp(parser_tokval(parser), "static"))
2849             had_static = true;
2850         else if (!strcmp(parser_tokval(parser), "const"))
2851             had_const = true;
2852         else if (!strcmp(parser_tokval(parser), "var"))
2853             had_var = true;
2854         else if (with_local && !strcmp(parser_tokval(parser), "local"))
2855             had_var = true;
2856         else if (!strcmp(parser_tokval(parser), "noref"))
2857             had_noref = true;
2858         else if (!had_const && !had_var && !had_noref && !had_attrib && !had_static && !flags) {
2859             return false;
2860         }
2861         else
2862             break;
2863         if (!parser_next(parser))
2864             goto onerr;
2865     }
2866     if (had_const)
2867         *cvq = CV_CONST;
2868     else if (had_var)
2869         *cvq = CV_VAR;
2870     else
2871         *cvq = CV_NONE;
2872     *noref     = had_noref;
2873     *is_static = had_static;
2874     *_flags    = flags;
2875     return true;
2876 onerr:
2877     parseerror(parser, "parse error after variable qualifier");
2878     *cvq = CV_WRONG;
2879     return true;
2880 }
2881
2882 static bool parse_switch_go(parser_t *parser, ast_block *block, ast_expression **out);
2883 static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **out)
2884 {
2885     bool rv;
2886     char *label = NULL;
2887
2888     /* skip the 'while' and get the body */
2889     if (!parser_next(parser)) {
2890         if (OPTS_FLAG(LOOP_LABELS))
2891             parseerror(parser, "expected loop label or 'switch' operand in parenthesis");
2892         else
2893             parseerror(parser, "expected 'switch' operand in parenthesis");
2894         return false;
2895     }
2896
2897     if (parser->tok == ':') {
2898         if (!OPTS_FLAG(LOOP_LABELS))
2899             parseerror(parser, "labeled loops not activated, try using -floop-labels");
2900         if (!parser_next(parser) || parser->tok != TOKEN_IDENT) {
2901             parseerror(parser, "expected loop label");
2902             return false;
2903         }
2904         label = util_strdup(parser_tokval(parser));
2905         if (!parser_next(parser)) {
2906             mem_d(label);
2907             parseerror(parser, "expected 'switch' operand in parenthesis");
2908             return false;
2909         }
2910     }
2911
2912     if (parser->tok != '(') {
2913         parseerror(parser, "expected 'switch' operand in parenthesis");
2914         return false;
2915     }
2916
2917     vec_push(parser->breaks, label);
2918
2919     rv = parse_switch_go(parser, block, out);
2920     if (label)
2921         mem_d(label);
2922     if (vec_last(parser->breaks) != label) {
2923         parseerror(parser, "internal error: label stack corrupted");
2924         rv = false;
2925         ast_delete(*out);
2926         *out = NULL;
2927     }
2928     else {
2929         vec_pop(parser->breaks);
2930     }
2931     return rv;
2932 }
2933
2934 static bool parse_switch_go(parser_t *parser, ast_block *block, ast_expression **out)
2935 {
2936     ast_expression *operand;
2937     ast_value      *opval;
2938     ast_value      *typevar;
2939     ast_switch     *switchnode;
2940     ast_switch_case swcase;
2941
2942     int  cvq;
2943     bool noref, is_static;
2944     uint32_t qflags = 0;
2945
2946     lex_ctx_t ctx = parser_ctx(parser);
2947
2948     (void)block; /* not touching */
2949     (void)opval;
2950
2951     /* parse into the expression */
2952     if (!parser_next(parser)) {
2953         parseerror(parser, "expected switch operand");
2954         return false;
2955     }
2956     /* parse the operand */
2957     operand = parse_expression_leave(parser, false, false, false);
2958     if (!operand)
2959         return false;
2960
2961     switchnode = ast_switch_new(ctx, operand);
2962
2963     /* closing paren */
2964     if (parser->tok != ')') {
2965         ast_delete(switchnode);
2966         parseerror(parser, "expected closing paren after 'switch' operand");
2967         return false;
2968     }
2969
2970     /* parse over the opening paren */
2971     if (!parser_next(parser) || parser->tok != '{') {
2972         ast_delete(switchnode);
2973         parseerror(parser, "expected list of cases");
2974         return false;
2975     }
2976
2977     if (!parser_next(parser)) {
2978         ast_delete(switchnode);
2979         parseerror(parser, "expected 'case' or 'default'");
2980         return false;
2981     }
2982
2983     /* new block; allow some variables to be declared here */
2984     parser_enterblock(parser);
2985     while (true) {
2986         typevar = NULL;
2987         if (parser->tok == TOKEN_IDENT)
2988             typevar = parser_find_typedef(parser, parser_tokval(parser), 0);
2989         if (typevar || parser->tok == TOKEN_TYPENAME) {
2990             if (!parse_variable(parser, block, false, CV_NONE, typevar, false, false, 0, NULL)) {
2991                 ast_delete(switchnode);
2992                 return false;
2993             }
2994             continue;
2995         }
2996         if (parse_qualifiers(parser, true, &cvq, &noref, &is_static, &qflags, NULL))
2997         {
2998             if (cvq == CV_WRONG) {
2999                 ast_delete(switchnode);
3000                 return false;
3001             }
3002             if (!parse_variable(parser, block, false, cvq, NULL, noref, is_static, qflags, NULL)) {
3003                 ast_delete(switchnode);
3004                 return false;
3005             }
3006             continue;
3007         }
3008         break;
3009     }
3010
3011     /* case list! */
3012     while (parser->tok != '}') {
3013         ast_block *caseblock;
3014
3015         if (!strcmp(parser_tokval(parser), "case")) {
3016             if (!parser_next(parser)) {
3017                 ast_delete(switchnode);
3018                 parseerror(parser, "expected expression for case");
3019                 return false;
3020             }
3021             swcase.value = parse_expression_leave(parser, false, false, false);
3022             if (!swcase.value) {
3023                 ast_delete(switchnode);
3024                 parseerror(parser, "expected expression for case");
3025                 return false;
3026             }
3027             if (!OPTS_FLAG(RELAXED_SWITCH)) {
3028                 if (!ast_istype(swcase.value, ast_value)) { /* || ((ast_value*)swcase.value)->cvq != CV_CONST) { */
3029                     parseerror(parser, "case on non-constant values need to be explicitly enabled via -frelaxed-switch");
3030                     ast_unref(operand);
3031                     return false;
3032                 }
3033             }
3034         }
3035         else if (!strcmp(parser_tokval(parser), "default")) {
3036             swcase.value = NULL;
3037             if (!parser_next(parser)) {
3038                 ast_delete(switchnode);
3039                 parseerror(parser, "expected colon");
3040                 return false;
3041             }
3042         }
3043         else {
3044             ast_delete(switchnode);
3045             parseerror(parser, "expected 'case' or 'default'");
3046             return false;
3047         }
3048
3049         /* Now the colon and body */
3050         if (parser->tok != ':') {
3051             if (swcase.value) ast_unref(swcase.value);
3052             ast_delete(switchnode);
3053             parseerror(parser, "expected colon");
3054             return false;
3055         }
3056
3057         if (!parser_next(parser)) {
3058             if (swcase.value) ast_unref(swcase.value);
3059             ast_delete(switchnode);
3060             parseerror(parser, "expected statements or case");
3061             return false;
3062         }
3063         caseblock = ast_block_new(parser_ctx(parser));
3064         if (!caseblock) {
3065             if (swcase.value) ast_unref(swcase.value);
3066             ast_delete(switchnode);
3067             return false;
3068         }
3069         swcase.code = (ast_expression*)caseblock;
3070         vec_push(switchnode->cases, swcase);
3071         while (true) {
3072             ast_expression *expr;
3073             if (parser->tok == '}')
3074                 break;
3075             if (parser->tok == TOKEN_KEYWORD) {
3076                 if (!strcmp(parser_tokval(parser), "case") ||
3077                     !strcmp(parser_tokval(parser), "default"))
3078                 {
3079                     break;
3080                 }
3081             }
3082             if (!parse_statement(parser, caseblock, &expr, true)) {
3083                 ast_delete(switchnode);
3084                 return false;
3085             }
3086             if (!expr)
3087                 continue;
3088             if (!ast_block_add_expr(caseblock, expr)) {
3089                 ast_delete(switchnode);
3090                 return false;
3091             }
3092         }
3093     }
3094
3095     parser_leaveblock(parser);
3096
3097     /* closing paren */
3098     if (parser->tok != '}') {
3099         ast_delete(switchnode);
3100         parseerror(parser, "expected closing paren of case list");
3101         return false;
3102     }
3103     if (!parser_next(parser)) {
3104         ast_delete(switchnode);
3105         parseerror(parser, "parse error after switch");
3106         return false;
3107     }
3108     *out = (ast_expression*)switchnode;
3109     return true;
3110 }
3111
3112 /* parse computed goto sides */
3113 static ast_expression *parse_goto_computed(parser_t *parser, ast_expression **side) {
3114     ast_expression *on_true;
3115     ast_expression *on_false;
3116     ast_expression *cond;
3117
3118     if (!*side)
3119         return NULL;
3120
3121     if (ast_istype(*side, ast_ternary)) {
3122         ast_ternary *tern = (ast_ternary*)*side;
3123         on_true  = parse_goto_computed(parser, &tern->on_true);
3124         on_false = parse_goto_computed(parser, &tern->on_false);
3125
3126         if (!on_true || !on_false) {
3127             parseerror(parser, "expected label or expression in ternary");
3128             if (on_true) ast_unref(on_true);
3129             if (on_false) ast_unref(on_false);
3130             return NULL;
3131         }
3132
3133         cond = tern->cond;
3134         tern->cond = NULL;
3135         ast_delete(tern);
3136         *side = NULL;
3137         return (ast_expression*)ast_ifthen_new(parser_ctx(parser), cond, on_true, on_false);
3138     } else if (ast_istype(*side, ast_label)) {
3139         ast_goto *gt = ast_goto_new(parser_ctx(parser), ((ast_label*)*side)->name);
3140         ast_goto_set_label(gt, ((ast_label*)*side));
3141         *side = NULL;
3142         return (ast_expression*)gt;
3143     }
3144     return NULL;
3145 }
3146
3147 static bool parse_goto(parser_t *parser, ast_expression **out)
3148 {
3149     ast_goto       *gt = NULL;
3150     ast_expression *lbl;
3151
3152     if (!parser_next(parser))
3153         return false;
3154
3155     if (parser->tok != TOKEN_IDENT) {
3156         ast_expression *expression;
3157
3158         /* could be an expression i.e computed goto :-) */
3159         if (parser->tok != '(') {
3160             parseerror(parser, "expected label name after `goto`");
3161             return false;
3162         }
3163
3164         /* failed to parse expression for goto */
3165         if (!(expression = parse_expression(parser, false, true)) ||
3166             !(*out = parse_goto_computed(parser, &expression))) {
3167             parseerror(parser, "invalid goto expression");
3168             if(expression)
3169                 ast_unref(expression);
3170             return false;
3171         }
3172
3173         return true;
3174     }
3175
3176     /* not computed goto */
3177     gt = ast_goto_new(parser_ctx(parser), parser_tokval(parser));
3178     lbl = parser_find_label(parser, gt->name);
3179     if (lbl) {
3180         if (!ast_istype(lbl, ast_label)) {
3181             parseerror(parser, "internal error: label is not an ast_label");
3182             ast_delete(gt);
3183             return false;
3184         }
3185         ast_goto_set_label(gt, (ast_label*)lbl);
3186     }
3187     else
3188         vec_push(parser->gotos, gt);
3189
3190     if (!parser_next(parser) || parser->tok != ';') {
3191         parseerror(parser, "semicolon expected after goto label");
3192         return false;
3193     }
3194     if (!parser_next(parser)) {
3195         parseerror(parser, "parse error after goto");
3196         return false;
3197     }
3198
3199     *out = (ast_expression*)gt;
3200     return true;
3201 }
3202
3203 static bool parse_skipwhite(parser_t *parser)
3204 {
3205     do {
3206         if (!parser_next(parser))
3207             return false;
3208     } while (parser->tok == TOKEN_WHITE && parser->tok < TOKEN_ERROR);
3209     return parser->tok < TOKEN_ERROR;
3210 }
3211
3212 static bool parse_eol(parser_t *parser)
3213 {
3214     if (!parse_skipwhite(parser))
3215         return false;
3216     return parser->tok == TOKEN_EOL;
3217 }
3218
3219 static bool parse_pragma_do(parser_t *parser)
3220 {
3221     if (!parser_next(parser) ||
3222         parser->tok != TOKEN_IDENT ||
3223         strcmp(parser_tokval(parser), "pragma"))
3224     {
3225         parseerror(parser, "expected `pragma` keyword after `#`, got `%s`", parser_tokval(parser));
3226         return false;
3227     }
3228     if (!parse_skipwhite(parser) || parser->tok != TOKEN_IDENT) {
3229         parseerror(parser, "expected pragma, got `%s`", parser_tokval(parser));
3230         return false;
3231     }
3232
3233     if (!strcmp(parser_tokval(parser), "noref")) {
3234         if (!parse_skipwhite(parser) || parser->tok != TOKEN_INTCONST) {
3235             parseerror(parser, "`noref` pragma requires an argument: 0 or 1");
3236             return false;
3237         }
3238         parser->noref = !!parser_token(parser)->constval.i;
3239         if (!parse_eol(parser)) {
3240             parseerror(parser, "parse error after `noref` pragma");
3241             return false;
3242         }
3243     }
3244     else
3245     {
3246         (void)!parsewarning(parser, WARN_UNKNOWN_PRAGMAS, "ignoring #pragma %s", parser_tokval(parser));
3247         return false;
3248     }
3249
3250     return true;
3251 }
3252
3253 static bool parse_pragma(parser_t *parser)
3254 {
3255     bool rv;
3256     parser->lex->flags.preprocessing = true;
3257     parser->lex->flags.mergelines = true;
3258     rv = parse_pragma_do(parser);
3259     if (parser->tok != TOKEN_EOL) {
3260         parseerror(parser, "junk after pragma");
3261         rv = false;
3262     }
3263     parser->lex->flags.preprocessing = false;
3264     parser->lex->flags.mergelines = false;
3265     if (!parser_next(parser)) {
3266         parseerror(parser, "parse error after pragma");
3267         rv = false;
3268     }
3269     return rv;
3270 }
3271
3272 static bool parse_statement(parser_t *parser, ast_block *block, ast_expression **out, bool allow_cases)
3273 {
3274     bool       noref, is_static;
3275     int        cvq     = CV_NONE;
3276     uint32_t   qflags  = 0;
3277     ast_value *typevar = NULL;
3278     char      *vstring = NULL;
3279
3280     *out = NULL;
3281
3282     if (parser->tok == TOKEN_IDENT)
3283         typevar = parser_find_typedef(parser, parser_tokval(parser), 0);
3284
3285     if (typevar || parser->tok == TOKEN_TYPENAME || parser->tok == '.')
3286     {
3287         /* local variable */
3288         if (!block) {
3289             parseerror(parser, "cannot declare a variable from here");
3290             return false;
3291         }
3292         if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) {
3293             if (parsewarning(parser, WARN_EXTENSIONS, "missing 'local' keyword when declaring a local variable"))
3294                 return false;
3295         }
3296         if (!parse_variable(parser, block, false, CV_NONE, typevar, false, false, 0, NULL))
3297             return false;
3298         return true;
3299     }
3300     else if (parse_qualifiers(parser, !!block, &cvq, &noref, &is_static, &qflags, &vstring))
3301     {
3302         if (cvq == CV_WRONG)
3303             return false;
3304         return parse_variable(parser, block, true, cvq, NULL, noref, is_static, qflags, vstring);
3305     }
3306     else if (parser->tok == TOKEN_KEYWORD)
3307     {
3308         if (!strcmp(parser_tokval(parser), "__builtin_debug_printtype"))
3309         {
3310             char ty[1024];
3311             ast_value *tdef;
3312
3313             if (!parser_next(parser)) {
3314                 parseerror(parser, "parse error after __builtin_debug_printtype");
3315                 return false;
3316             }
3317
3318             if (parser->tok == TOKEN_IDENT && (tdef = parser_find_typedef(parser, parser_tokval(parser), 0)))
3319             {
3320                 ast_type_to_string((ast_expression*)tdef, ty, sizeof(ty));
3321                 con_out("__builtin_debug_printtype: `%s`=`%s`\n", tdef->name, ty);
3322                 if (!parser_next(parser)) {
3323                     parseerror(parser, "parse error after __builtin_debug_printtype typename argument");
3324                     return false;
3325                 }
3326             }
3327             else
3328             {
3329                 if (!parse_statement(parser, block, out, allow_cases))
3330                     return false;
3331                 if (!*out)
3332                     con_out("__builtin_debug_printtype: got no output node\n");
3333                 else
3334                 {
3335                     ast_type_to_string(*out, ty, sizeof(ty));
3336                     con_out("__builtin_debug_printtype: `%s`\n", ty);
3337                 }
3338             }
3339             return true;
3340         }
3341         else if (!strcmp(parser_tokval(parser), "return"))
3342         {
3343             return parse_return(parser, block, out);
3344         }
3345         else if (!strcmp(parser_tokval(parser), "if"))
3346         {
3347             return parse_if(parser, block, out);
3348         }
3349         else if (!strcmp(parser_tokval(parser), "while"))
3350         {
3351             return parse_while(parser, block, out);
3352         }
3353         else if (!strcmp(parser_tokval(parser), "do"))
3354         {
3355             return parse_dowhile(parser, block, out);
3356         }
3357         else if (!strcmp(parser_tokval(parser), "for"))
3358         {
3359             if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) {
3360                 if (parsewarning(parser, WARN_EXTENSIONS, "for loops are not recognized in the original Quake C standard, to enable try an alternate standard --std=?"))
3361                     return false;
3362             }
3363             return parse_for(parser, block, out);
3364         }
3365         else if (!strcmp(parser_tokval(parser), "break"))
3366         {
3367             return parse_break_continue(parser, block, out, false);
3368         }
3369         else if (!strcmp(parser_tokval(parser), "continue"))
3370         {
3371             return parse_break_continue(parser, block, out, true);
3372         }
3373         else if (!strcmp(parser_tokval(parser), "switch"))
3374         {
3375             return parse_switch(parser, block, out);
3376         }
3377         else if (!strcmp(parser_tokval(parser), "case") ||
3378                  !strcmp(parser_tokval(parser), "default"))
3379         {
3380             if (!allow_cases) {
3381                 parseerror(parser, "unexpected 'case' label");
3382                 return false;
3383             }
3384             return true;
3385         }
3386         else if (!strcmp(parser_tokval(parser), "goto"))
3387         {
3388             return parse_goto(parser, out);
3389         }
3390         else if (!strcmp(parser_tokval(parser), "typedef"))
3391         {
3392             if (!parser_next(parser)) {
3393                 parseerror(parser, "expected type definition after 'typedef'");
3394                 return false;
3395             }
3396             return parse_typedef(parser);
3397         }
3398         parseerror(parser, "Unexpected keyword: `%s'", parser_tokval(parser));
3399         return false;
3400     }
3401     else if (parser->tok == '{')
3402     {
3403         ast_block *inner;
3404         inner = parse_block(parser);
3405         if (!inner)
3406             return false;
3407         *out = (ast_expression*)inner;
3408         return true;
3409     }
3410     else if (parser->tok == ':')
3411     {
3412         size_t i;
3413         ast_label *label;
3414         if (!parser_next(parser)) {
3415             parseerror(parser, "expected label name");
3416             return false;
3417         }
3418         if (parser->tok != TOKEN_IDENT) {
3419             parseerror(parser, "label must be an identifier");
3420             return false;
3421         }
3422         label = (ast_label*)parser_find_label(parser, parser_tokval(parser));
3423         if (label) {
3424             if (!label->undefined) {
3425                 parseerror(parser, "label `%s` already defined", label->name);
3426                 return false;
3427             }
3428             label->undefined = false;
3429         }
3430         else {
3431             label = ast_label_new(parser_ctx(parser), parser_tokval(parser), false);
3432             vec_push(parser->labels, label);
3433         }
3434         *out = (ast_expression*)label;
3435         if (!parser_next(parser)) {
3436             parseerror(parser, "parse error after label");
3437             return false;
3438         }
3439         for (i = 0; i < vec_size(parser->gotos); ++i) {
3440             if (!strcmp(parser->gotos[i]->name, label->name)) {
3441                 ast_goto_set_label(parser->gotos[i], label);
3442                 vec_remove(parser->gotos, i, 1);
3443                 --i;
3444             }
3445         }
3446         return true;
3447     }
3448     else if (parser->tok == ';')
3449     {
3450         if (!parser_next(parser)) {
3451             parseerror(parser, "parse error after empty statement");
3452             return false;
3453         }
3454         return true;
3455     }
3456     else
3457     {
3458         lex_ctx_t ctx = parser_ctx(parser);
3459         ast_expression *exp = parse_expression(parser, false, false);
3460         if (!exp)
3461             return false;
3462         *out = exp;
3463         if (!ast_side_effects(exp)) {
3464             if (compile_warning(ctx, WARN_EFFECTLESS_STATEMENT, "statement has no effect"))
3465                 return false;
3466         }
3467         return true;
3468     }
3469 }
3470
3471 static bool parse_enum(parser_t *parser)
3472 {
3473     bool        flag = false;
3474     bool        reverse = false;
3475     qcfloat_t     num = 0;
3476     ast_value **values = NULL;
3477     ast_value  *var = NULL;
3478     ast_value  *asvalue;
3479
3480     ast_expression *old;
3481
3482     if (!parser_next(parser) || (parser->tok != '{' && parser->tok != ':')) {
3483         parseerror(parser, "expected `{` or `:` after `enum` keyword");
3