parser.c

   1 #include <stdio.h>
   2 #include <stdarg.h>
   3
   4 #include "gmqcc.h"
   5 #include "lexer.h"
   6
   7 typedef struct {
   8     char *name;
   9     ast_expression *var;
  10 } varentry_t;
  11
  12 typedef struct {
  13     lex_file *lex;
  14     int      tok;
  15
  16     MEM_VECTOR_MAKE(varentry_t, globals);
  17     MEM_VECTOR_MAKE(varentry_t, fields);
  18     MEM_VECTOR_MAKE(ast_function*, functions);
  19     MEM_VECTOR_MAKE(ast_value*, imm_float);
  20     MEM_VECTOR_MAKE(ast_value*, imm_string);
  21     MEM_VECTOR_MAKE(ast_value*, imm_vector);
  22
  23     ast_function *function;
  24     MEM_VECTOR_MAKE(varentry_t, locals);
  25     size_t blocklocal;
  26
  27     size_t errors;
  28
  29     /* TYPE_FIELD -> parser_find_fields is used instead of find_var
  30      * TODO: TYPE_VECTOR -> x, y and z are accepted in the gmqcc standard
  31      * anything else: type error
  32      */
  33     qcint  memberof;
  34 } parser_t;
  35
  36 MEM_VEC_FUNCTIONS(parser_t, varentry_t, globals)
  37 MEM_VEC_FUNCTIONS(parser_t, varentry_t, fields)
  38 MEM_VEC_FUNCTIONS(parser_t, ast_value*, imm_float)
  39 MEM_VEC_FUNCTIONS(parser_t, ast_value*, imm_string)
  40 MEM_VEC_FUNCTIONS(parser_t, ast_value*, imm_vector)
  41 MEM_VEC_FUNCTIONS(parser_t, varentry_t, locals)
  42 MEM_VEC_FUNCTIONS(parser_t, ast_function*, functions)
  43
  44 static void parser_pop_local(parser_t *parser);
  45 static bool parser_variable(parser_t *parser, ast_block *localblock);
  46 static ast_block* parser_parse_block(parser_t *parser);
  47 static ast_expression* parser_parse_statement_or_block(parser_t *parser);
  48 static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomma);
  49 static ast_expression* parser_expression(parser_t *parser, bool stopatcomma);
  50
  51 void parseerror(parser_t *parser, const char *fmt, ...)
  52 {
  53         va_list ap;
  54
  55         parser->errors++;
  56
  57         va_start(ap, fmt);
  58     vprintmsg(LVL_ERROR, parser->lex->tok->ctx.file, parser->lex->tok->ctx.line, "parse error", fmt, ap);
  59         va_end(ap);
  60
  61         printf("\n");
  62 }
  63
  64 /* returns true if it counts as an error */
  65 bool GMQCC_WARN parsewarning(parser_t *parser, int warntype, const char *fmt, ...)
  66 {
  67         va_list ap;
  68         int lvl = LVL_WARNING;
  69
  70     if (!OPTS_WARN(warntype))
  71         return false;
  72
  73     if (OPTS_WARN(WARN_ERROR)) {
  74             parser->errors++;
  75             lvl = LVL_ERROR;
  76         }
  77
  78         va_start(ap, fmt);
  79     vprintmsg(lvl, parser->lex->tok->ctx.file, parser->lex->tok->ctx.line, "warning", fmt, ap);
  80         va_end(ap);
  81
  82         return OPTS_WARN(WARN_ERROR);
  83 }
  84
  85 /**********************************************************************
  86  * some maths used for constant folding
  87  */
  88
  89 vector vec3_add(vector a, vector b)
  90 {
  91     vector out;
  92     out.x = a.x + b.x;
  93     out.y = a.y + b.y;
  94     out.z = a.z + b.z;
  95     return out;
  96 }
  97
  98 vector vec3_sub(vector a, vector b)
  99 {
 100     vector out;
 101     out.x = a.x - b.x;
 102     out.y = a.y - b.y;
 103     out.z = a.z - b.z;
 104     return out;
 105 }
 106
 107 qcfloat vec3_mulvv(vector a, vector b)
 108 {
 109     return (a.x * b.x + a.y * b.y + a.z * b.z);
 110 }
 111
 112 vector vec3_mulvf(vector a, float b)
 113 {
 114     vector out;
 115     out.x = a.x * b;
 116     out.y = a.y * b;
 117     out.z = a.z * b;
 118     return out;
 119 }
 120
 121 /**********************************************************************
 122  * parsing
 123  */
 124
 125 bool parser_next(parser_t *parser)
 126 {
 127     /* lex_do kills the previous token */
 128     parser->tok = lex_do(parser->lex);
 129     if (parser->tok == TOKEN_EOF || parser->tok >= TOKEN_ERROR)
 130         return false;
 131     return true;
 132 }
 133
 134 /* lift a token out of the parser so it's not destroyed by parser_next */
 135 token *parser_lift(parser_t *parser)
 136 {
 137     token *tok = parser->lex->tok;
 138     parser->lex->tok = NULL;
 139     return tok;
 140 }
 141
 142 #define parser_tokval(p) (p->lex->tok->value)
 143 #define parser_token(p)  (p->lex->tok)
 144 #define parser_ctx(p)    (p->lex->tok->ctx)
 145
 146 ast_value* parser_const_float(parser_t *parser, double d)
 147 {
 148     size_t i;
 149     ast_value *out;
 150     for (i = 0; i < parser->imm_float_count; ++i) {
 151         if (parser->imm_float[i]->constval.vfloat == d)
 152             return parser->imm_float[i];
 153     }
 154     out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_FLOAT);
 155     out->isconst = true;
 156     out->constval.vfloat = d;
 157     if (!parser_t_imm_float_add(parser, out)) {
 158         ast_value_delete(out);
 159         return NULL;
 160     }
 161     return out;
 162 }
 163
 164 ast_value* parser_const_string(parser_t *parser, const char *str)
 165 {
 166     size_t i;
 167     ast_value *out;
 168     for (i = 0; i < parser->imm_string_count; ++i) {
 169         if (!strcmp(parser->imm_string[i]->constval.vstring, str))
 170             return parser->imm_string[i];
 171     }
 172     out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_STRING);
 173     out->isconst = true;
 174     out->constval.vstring = util_strdup(str);
 175     if (!parser_t_imm_string_add(parser, out)) {
 176         ast_value_delete(out);
 177         return NULL;
 178     }
 179     return out;
 180 }
 181
 182 ast_value* parser_const_vector(parser_t *parser, vector v)
 183 {
 184     size_t i;
 185     ast_value *out;
 186     for (i = 0; i < parser->imm_vector_count; ++i) {
 187         if (!memcmp(&parser->imm_vector[i]->constval.vvec, &v, sizeof(v)))
 188             return parser->imm_vector[i];
 189     }
 190     out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_VECTOR);
 191     out->isconst = true;
 192     out->constval.vvec = v;
 193     if (!parser_t_imm_vector_add(parser, out)) {
 194         ast_value_delete(out);
 195         return NULL;
 196     }
 197     return out;
 198 }
 199
 200 ast_expression* parser_find_field(parser_t *parser, const char *name)
 201 {
 202     size_t i;
 203     for (i = 0; i < parser->fields_count; ++i) {
 204         if (!strcmp(parser->fields[i].name, name))
 205             return parser->fields[i].var;
 206     }
 207     return NULL;
 208 }
 209
 210 ast_expression* parser_find_global(parser_t *parser, const char *name)
 211 {
 212     size_t i;
 213     for (i = 0; i < parser->globals_count; ++i) {
 214         if (!strcmp(parser->globals[i].name, name))
 215             return parser->globals[i].var;
 216     }
 217     return NULL;
 218 }
 219
 220 ast_expression* parser_find_local(parser_t *parser, const char *name, size_t upto)
 221 {
 222     size_t i;
 223     ast_value *fun;
 224     for (i = parser->locals_count; i > upto;) {
 225         --i;
 226         if (!strcmp(parser->locals[i].name, name))
 227             return parser->locals[i].var;
 228     }
 229     fun = parser->function->vtype;
 230     for (i = 0; i < fun->expression.params_count; ++i) {
 231         if (!strcmp(fun->expression.params[i]->name, name))
 232             return (ast_expression*)(fun->expression.params[i]);
 233     }
 234     return NULL;
 235 }
 236
 237 ast_expression* parser_find_var(parser_t *parser, const char *name)
 238 {
 239     ast_expression *v;
 240     v         = parser_find_local(parser, name, 0);
 241     if (!v) v = parser_find_global(parser, name);
 242     return v;
 243 }
 244
 245 typedef struct {
 246     MEM_VECTOR_MAKE(ast_value*, p);
 247 } paramlist_t;
 248 MEM_VEC_FUNCTIONS(paramlist_t, ast_value*, p)
 249
 250 static ast_value *parser_parse_type(parser_t *parser, int basetype, bool *isfunc)
 251 {
 252     paramlist_t params;
 253     ast_value *var;
 254     lex_ctx   ctx = parser_ctx(parser);
 255     int vtype = basetype;
 256     int temptype;
 257     size_t i;
 258
 259     MEM_VECTOR_INIT(&params, p);
 260
 261     *isfunc = false;
 262
 263     if (parser->tok == '(') {
 264         *isfunc = true;
 265         while (true) {
 266             ast_value *param;
 267             bool dummy;
 268
 269             if (!parser_next(parser))
 270                 goto on_error;
 271
 272             if (parser->tok == ')')
 273                 break;
 274
 275             temptype = parser_token(parser)->constval.t;
 276             if (!parser_next(parser))
 277                 goto on_error;
 278
 279             param = parser_parse_type(parser, temptype, &dummy);
 280             (void)dummy;
 281
 282             if (!param)
 283                 goto on_error;
 284
 285             if (parser->tok == TOKEN_IDENT) {
 286                 /* named parameter */
 287                 if (!ast_value_set_name(param, parser_tokval(parser)))
 288                     goto on_error;
 289                 if (!parser_next(parser))
 290                     goto on_error;
 291             }
 292
 293             if (!paramlist_t_p_add(&params, param)) {
 294                 parseerror(parser, "Out of memory while parsing typename");
 295                 goto on_error;
 296             }
 297
 298             if (parser->tok == ',')
 299                 continue;
 300             if (parser->tok == ')')
 301                 break;
 302             parseerror(parser, "Unexpected token");
 303             goto on_error;
 304         }
 305         if (!parser_next(parser))
 306             goto on_error;
 307     }
 308
 309     var = ast_value_new(ctx, "<unnamed>", vtype);
 310     if (!var)
 311         goto on_error;
 312     MEM_VECTOR_MOVE(&params, p, &var->expression, params);
 313     return var;
 314 on_error:
 315     for (i = 0; i < params.p_count; ++i)
 316         ast_value_delete(params.p[i]);
 317     MEM_VECTOR_CLEAR(&params, p);
 318     return NULL;
 319 }
 320
 321 typedef struct
 322 {
 323     size_t etype; /* 0 = expression, others are operators */
 324     int             paren;
 325     size_t          off;
 326     ast_expression *out;
 327     ast_block      *block; /* for commas and function calls */
 328     lex_ctx ctx;
 329 } sy_elem;
 330 typedef struct
 331 {
 332     MEM_VECTOR_MAKE(sy_elem, out);
 333     MEM_VECTOR_MAKE(sy_elem, ops);
 334 } shunt;
 335 MEM_VEC_FUNCTIONS(shunt, sy_elem, out)
 336 MEM_VEC_FUNCTIONS(shunt, sy_elem, ops)
 337
 338 static sy_elem syexp(lex_ctx ctx, ast_expression *v) {
 339     sy_elem e;
 340     e.etype = 0;
 341     e.out   = v;
 342     e.block = NULL;
 343     e.ctx   = ctx;
 344     e.paren = 0;
 345     return e;
 346 }
 347
 348 static sy_elem syblock(lex_ctx ctx, ast_block *v) {
 349     sy_elem e;
 350     e.etype = 0;
 351     e.out   = (ast_expression*)v;
 352     e.block = v;
 353     e.ctx   = ctx;
 354     e.paren = 0;
 355     return e;
 356 }
 357
 358 static sy_elem syop(lex_ctx ctx, const oper_info *op) {
 359     sy_elem e;
 360     e.etype = 1 + (op - operators);
 361     e.out   = NULL;
 362     e.block = NULL;
 363     e.ctx   = ctx;
 364     e.paren = 0;
 365     return e;
 366 }
 367
 368 static sy_elem syparen(lex_ctx ctx, int p, size_t off) {
 369     sy_elem e;
 370     e.etype = 0;
 371     e.off   = off;
 372     e.out   = NULL;
 373     e.block = NULL;
 374     e.ctx   = ctx;
 375     e.paren = p;
 376     return e;
 377 }
 378
 379 #ifdef DEBUGSHUNT
 380 # define DEBUGSHUNTDO(x) x
 381 #else
 382 # define DEBUGSHUNTDO(x)
 383 #endif
 384
 385 static bool parser_sy_pop(parser_t *parser, shunt *sy)
 386 {
 387     const oper_info *op;
 388     lex_ctx ctx;
 389     ast_expression *out = NULL;
 390     ast_expression *exprs[3];
 391     ast_block      *blocks[3];
 392     ast_value      *asvalue[3];
 393     size_t i, assignop;
 394     qcint  generated_op = 0;
 395
 396     if (!sy->ops_count) {
 397         parseerror(parser, "internal error: missing operator");
 398         return false;
 399     }
 400
 401     if (sy->ops[sy->ops_count-1].paren) {
 402         parseerror(parser, "unmatched parenthesis");
 403         return false;
 404     }
 405
 406     op = &operators[sy->ops[sy->ops_count-1].etype - 1];
 407     ctx = sy->ops[sy->ops_count-1].ctx;
 408
 409     DEBUGSHUNTDO(printf("apply %s\n", op->op));
 410
 411     if (sy->out_count < op->operands) {
 412         parseerror(parser, "internal error: not enough operands: %i", sy->out_count);
 413         return false;
 414     }
 415
 416     sy->ops_count--;
 417
 418     sy->out_count -= op->operands;
 419     for (i = 0; i < op->operands; ++i) {
 420         exprs[i]  = sy->out[sy->out_count+i].out;
 421         blocks[i] = sy->out[sy->out_count+i].block;
 422         asvalue[i] = (ast_value*)exprs[i];
 423     }
 424
 425     if (blocks[0] && !blocks[0]->exprs_count && op->id != opid1(',')) {
 426         parseerror(parser, "internal error: operator cannot be applied on empty blocks");
 427         return false;
 428     }
 429
 430 #define NotSameType(T) \
 431              (exprs[0]->expression.vtype != exprs[1]->expression.vtype || \
 432               exprs[0]->expression.vtype != T)
 433 #define CanConstFold(A, B)                                                \
 434              (ast_istype((A), ast_value) && ast_istype((B), ast_value) && \
 435               ((ast_value*)(A))->isconst && ((ast_value*)(B))->isconst)
 436 #define ConstV(i) (asvalue[(i)]->constval.vvec)
 437 #define ConstF(i) (asvalue[(i)]->constval.vfloat)
 438     switch (op->id)
 439     {
 440         default:
 441             parseerror(parser, "internal error: unhandled operand");
 442             return false;
 443
 444         case opid1('.'):
 445             if (exprs[0]->expression.vtype == TYPE_ENTITY) {
 446                 if (exprs[1]->expression.vtype != TYPE_FIELD) {
 447                     parseerror(parser, "type error: right hand of member-operand should be an entity-field");
 448                     return false;
 449                 }
 450                 out = (ast_expression*)ast_entfield_new(ctx, exprs[0], exprs[1]);
 451             }
 452             else if (exprs[0]->expression.vtype == TYPE_VECTOR) {
 453                 parseerror(parser, "internal error: vector access is not supposed to be handled at this point");
 454                 return false;
 455             }
 456             else {
 457                 parseerror(parser, "type error: member-of operator on something that is not an entity or vector");
 458                 return false;
 459             }
 460             break;
 461
 462         case opid1(','):
 463             if (blocks[0]) {
 464                 if (!ast_block_exprs_add(blocks[0], exprs[1]))
 465                     return false;
 466             } else {
 467                 blocks[0] = ast_block_new(ctx);
 468                 if (!ast_block_exprs_add(blocks[0], exprs[0]) ||
 469                     !ast_block_exprs_add(blocks[0], exprs[1]))
 470                 {
 471                     return false;
 472                 }
 473             }
 474             if (!ast_block_set_type(blocks[0], exprs[1]))
 475                 return false;
 476
 477             sy->out[sy->out_count++] = syblock(ctx, blocks[0]);
 478             return true;
 479
 480         case opid1('+'):
 481             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
 482                 (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) )
 483             {
 484                 parseerror(parser, "invalid types used in expression: cannot add type %s and %s",
 485                            type_name[exprs[0]->expression.vtype],
 486                            type_name[exprs[1]->expression.vtype]);
 487                 return false;
 488             }
 489             switch (exprs[0]->expression.vtype) {
 490                 case TYPE_FLOAT:
 491                     if (CanConstFold(exprs[0], exprs[1]))
 492                     {
 493                         out = (ast_expression*)parser_const_float(parser, ConstF(0) + ConstF(1));
 494                     }
 495                     else
 496                         out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_F, exprs[0], exprs[1]);
 497                     break;
 498                 case TYPE_VECTOR:
 499                     if (CanConstFold(exprs[0], exprs[1]))
 500                         out = (ast_expression*)parser_const_vector(parser, vec3_add(ConstV(0), ConstV(1)));
 501                     else
 502                         out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_V, exprs[0], exprs[1]);
 503                     break;
 504                 default:
 505                     parseerror(parser, "invalid types used in expression: cannot add type %s and %s",
 506                                type_name[exprs[0]->expression.vtype],
 507                                type_name[exprs[1]->expression.vtype]);
 508                     return false;
 509             };
 510             break;
 511         case opid1('-'):
 512             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
 513                 (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) )
 514             {
 515                 parseerror(parser, "invalid types used in expression: cannot subtract type %s from %s",
 516                            type_name[exprs[1]->expression.vtype],
 517                            type_name[exprs[0]->expression.vtype]);
 518                 return false;
 519             }
 520             switch (exprs[0]->expression.vtype) {
 521                 case TYPE_FLOAT:
 522                     if (CanConstFold(exprs[0], exprs[1]))
 523                         out = (ast_expression*)parser_const_float(parser, ConstF(0) - ConstF(1));
 524                     else
 525                         out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F, exprs[0], exprs[1]);
 526                     break;
 527                 case TYPE_VECTOR:
 528                     if (CanConstFold(exprs[0], exprs[1]))
 529                         out = (ast_expression*)parser_const_vector(parser, vec3_sub(ConstV(0), ConstV(1)));
 530                     else
 531                         out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V, exprs[0], exprs[1]);
 532                     break;
 533                 default:
 534                     parseerror(parser, "invalid types used in expression: cannot subtract type %s from %s",
 535                                type_name[exprs[1]->expression.vtype],
 536                                type_name[exprs[0]->expression.vtype]);
 537                     return false;
 538             };
 539             break;
 540         case opid1('*'):
 541             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype &&
 542                 exprs[0]->expression.vtype != TYPE_VECTOR &&
 543                 exprs[0]->expression.vtype != TYPE_FLOAT &&
 544                 exprs[1]->expression.vtype != TYPE_VECTOR &&
 545                 exprs[1]->expression.vtype != TYPE_FLOAT)
 546             {
 547                 parseerror(parser, "invalid types used in expression: cannot multiply types %s and %s",
 548                            type_name[exprs[1]->expression.vtype],
 549                            type_name[exprs[0]->expression.vtype]);
 550                 return false;
 551             }
 552             switch (exprs[0]->expression.vtype) {
 553                 case TYPE_FLOAT:
 554                     if (exprs[1]->expression.vtype == TYPE_VECTOR)
 555                     {
 556                         if (CanConstFold(exprs[0], exprs[1]))
 557                             out = (ast_expression*)parser_const_vector(parser, vec3_mulvf(ConstV(1), ConstF(0)));
 558                         else
 559                             out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_FV, exprs[0], exprs[1]);
 560                     }
 561                     else
 562                     {
 563                         if (CanConstFold(exprs[0], exprs[1]))
 564                             out = (ast_expression*)parser_const_float(parser, ConstF(0) * ConstF(1));
 565                         else
 566                             out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, exprs[0], exprs[1]);
 567                     }
 568                     break;
 569                 case TYPE_VECTOR:
 570                     if (exprs[1]->expression.vtype == TYPE_FLOAT)
 571                     {
 572                         if (CanConstFold(exprs[0], exprs[1]))
 573                             out = (ast_expression*)parser_const_vector(parser, vec3_mulvf(ConstV(0), ConstF(1)));
 574                         else
 575                             out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_VF, exprs[0], exprs[1]);
 576                     }
 577                     else
 578                     {
 579                         if (CanConstFold(exprs[0], exprs[1]))
 580                             out = (ast_expression*)parser_const_float(parser, vec3_mulvv(ConstV(0), ConstV(1)));
 581                         else
 582                             out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_V, exprs[0], exprs[1]);
 583                     }
 584                     break;
 585                 default:
 586                     parseerror(parser, "invalid types used in expression: cannot multiply types %s and %s",
 587                                type_name[exprs[1]->expression.vtype],
 588                                type_name[exprs[0]->expression.vtype]);
 589                     return false;
 590             };
 591             break;
 592         case opid1('/'):
 593             if (NotSameType(TYPE_FLOAT)) {
 594                 parseerror(parser, "invalid types used in expression: cannot divide types %s and %s",
 595                            type_name[exprs[0]->expression.vtype],
 596                            type_name[exprs[1]->expression.vtype]);
 597                 return false;
 598             }
 599             if (CanConstFold(exprs[0], exprs[1]))
 600                 out = (ast_expression*)parser_const_float(parser, ConstF(0) / ConstF(1));
 601             else
 602                 out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F, exprs[0], exprs[1]);
 603             break;
 604         case opid1('%'):
 605         case opid2('%','='):
 606             parseerror(parser, "qc does not have a modulo operator");
 607             return false;
 608         case opid1('|'):
 609         case opid1('&'):
 610             if (NotSameType(TYPE_FLOAT)) {
 611                 parseerror(parser, "invalid types used in expression: cannot perform bit operations between types %s and %s",
 612                            type_name[exprs[0]->expression.vtype],
 613                            type_name[exprs[1]->expression.vtype]);
 614                 return false;
 615             }
 616             if (CanConstFold(exprs[0], exprs[1]))
 617                 out = (ast_expression*)parser_const_float(parser,
 618                     (op->id == opid1('|') ? (float)( ((qcint)ConstF(0)) | ((qcint)ConstF(1)) ) :
 619                                             (float)( ((qcint)ConstF(0)) & ((qcint)ConstF(1)) ) ));
 620             else
 621                 out = (ast_expression*)ast_binary_new(ctx,
 622                     (op->id == opid1('|') ? INSTR_BITOR : INSTR_BITAND),
 623                     exprs[0], exprs[1]);
 624             break;
 625         case opid1('^'):
 626             parseerror(parser, "TODO: bitxor");
 627             return false;
 628
 629         case opid2('<','<'):
 630         case opid2('>','>'):
 631         case opid3('<','<','='):
 632         case opid3('>','>','='):
 633             parseerror(parser, "TODO: shifts");
 634             return false;
 635
 636         case opid2('|','|'):
 637             generated_op += 1; /* INSTR_OR */
 638         case opid2('&','&'):
 639             generated_op += INSTR_AND;
 640             if (NotSameType(TYPE_FLOAT)) {
 641                 parseerror(parser, "invalid types used in expression: cannot perform logical operations between types %s and %s",
 642                            type_name[exprs[0]->expression.vtype],
 643                            type_name[exprs[1]->expression.vtype]);
 644                 parseerror(parser, "TODO: logical ops for arbitrary types using INSTR_NOT");
 645                 parseerror(parser, "TODO: optional early out");
 646                 return false;
 647             }
 648             if (opts_standard == COMPILER_GMQCC)
 649                 printf("TODO: early out logic\n");
 650             if (CanConstFold(exprs[0], exprs[1]))
 651                 out = (ast_expression*)parser_const_float(parser,
 652                     (generated_op == INSTR_OR ? (ConstF(0) || ConstF(1)) : (ConstF(0) && ConstF(1))));
 653             else
 654                 out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
 655             break;
 656
 657         case opid1('>'):
 658             generated_op += 1; /* INSTR_GT */
 659         case opid1('<'):
 660             generated_op += 1; /* INSTR_LT */
 661         case opid2('>', '='):
 662             generated_op += 1; /* INSTR_GE */
 663         case opid2('<', '='):
 664             generated_op += INSTR_LE;
 665             if (NotSameType(TYPE_FLOAT)) {
 666                 parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s",
 667                            type_name[exprs[0]->expression.vtype],
 668                            type_name[exprs[1]->expression.vtype]);
 669                 return false;
 670             }
 671             out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
 672             break;
 673         case opid2('!', '='):
 674             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) {
 675                 parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s",
 676                            type_name[exprs[0]->expression.vtype],
 677                            type_name[exprs[1]->expression.vtype]);
 678                 return false;
 679             }
 680             out = (ast_expression*)ast_binary_new(ctx, type_ne_instr[exprs[0]->expression.vtype], exprs[0], exprs[1]);
 681             break;
 682         case opid2('=', '='):
 683             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) {
 684                 parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s",
 685                            type_name[exprs[0]->expression.vtype],
 686                            type_name[exprs[1]->expression.vtype]);
 687                 return false;
 688             }
 689             out = (ast_expression*)ast_binary_new(ctx, type_eq_instr[exprs[0]->expression.vtype], exprs[0], exprs[1]);
 690             break;
 691
 692         case opid1('='):
 693             if (ast_istype(exprs[0], ast_entfield))
 694                 assignop = type_storep_instr[exprs[0]->expression.vtype];
 695             else
 696                 assignop = type_store_instr[exprs[0]->expression.vtype];
 697             out = (ast_expression*)ast_store_new(ctx, assignop, exprs[0], exprs[1]);
 698             break;
 699         case opid2('+','='):
 700         case opid2('-','='):
 701             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
 702                 (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) )
 703             {
 704                 parseerror(parser, "invalid types used in expression: cannot add or subtract type %s and %s",
 705                            type_name[exprs[0]->expression.vtype],
 706                            type_name[exprs[1]->expression.vtype]);
 707                 return false;
 708             }
 709             if (ast_istype(exprs[0], ast_entfield))
 710                 assignop = type_storep_instr[exprs[0]->expression.vtype];
 711             else
 712                 assignop = type_store_instr[exprs[0]->expression.vtype];
 713             switch (exprs[0]->expression.vtype) {
 714                 case TYPE_FLOAT:
 715                     out = (ast_expression*)ast_binstore_new(ctx, assignop,
 716                                                             (op->id == opid2('+','=') ? INSTR_ADD_F : INSTR_SUB_F),
 717                                                             exprs[0], exprs[1]);
 718                     break;
 719                 case TYPE_VECTOR:
 720                     out = (ast_expression*)ast_binstore_new(ctx, assignop,
 721                                                             (op->id == opid2('+','=') ? INSTR_ADD_V : INSTR_SUB_V),
 722                                                             exprs[0], exprs[1]);
 723                     break;
 724                 default:
 725                     parseerror(parser, "invalid types used in expression: cannot add or subtract type %s and %s",
 726                                type_name[exprs[0]->expression.vtype],
 727                                type_name[exprs[1]->expression.vtype]);
 728                     return false;
 729             };
 730             break;
 731     }
 732 #undef NotSameType
 733
 734     if (!out) {
 735         parseerror(parser, "failed to apply operand %s", op->op);
 736         return false;
 737     }
 738
 739     DEBUGSHUNTDO(printf("applied %s\n", op->op));
 740     sy->out[sy->out_count++] = syexp(ctx, out);
 741     return true;
 742 }
 743
 744 static bool parser_close_call(parser_t *parser, shunt *sy)
 745 {
 746     /* was a function call */
 747     ast_expression *fun;
 748     ast_call       *call;
 749
 750     size_t          fid;
 751     size_t          paramcount;
 752
 753     sy->ops_count--;
 754     fid = sy->ops[sy->ops_count].off;
 755
 756     /* out[fid] is the function
 757      * everything above is parameters...
 758      * 0 params = nothing
 759      * 1 params = ast_expression
 760      * more = ast_block
 761      */
 762
 763     if (sy->out_count < 1 || sy->out_count <= fid) {
 764         parseerror(parser, "internal error: function call needs function and parameter list...");
 765         return false;
 766     }
 767
 768     fun = sy->out[fid].out;
 769
 770     call = ast_call_new(sy->ops[sy->ops_count].ctx, fun);
 771     if (!call) {
 772         parseerror(parser, "out of memory");
 773         return false;
 774     }
 775
 776     if (fid+1 == sy->out_count) {
 777         /* no arguments */
 778         paramcount = 0;
 779     } else if (fid+2 == sy->out_count) {
 780         ast_block *params;
 781         sy->out_count--;
 782         params = sy->out[sy->out_count].block;
 783         if (!params) {
 784             /* 1 param */
 785             paramcount = 1;
 786             if (!ast_call_params_add(call, sy->out[sy->out_count].out)) {
 787                 ast_delete(sy->out[sy->out_count].out);
 788                 parseerror(parser, "out of memory");
 789                 return false;
 790             }
 791         } else {
 792             paramcount = params->exprs_count;
 793             MEM_VECTOR_MOVE(params, exprs, call, params);
 794             ast_delete(params);
 795         }
 796     } else {
 797         parseerror(parser, "invalid function call");
 798         return false;
 799     }
 800
 801     /* overwrite fid, the function, with a call */
 802     sy->out[fid] = syexp(call->expression.node.context, (ast_expression*)call);
 803
 804     if (fun->expression.vtype != TYPE_FUNCTION) {
 805         parseerror(parser, "not a function");
 806         return false;
 807     }
 808
 809     if (!fun->expression.next) {
 810         parseerror(parser, "could not determine function return type");
 811         return false;
 812     } else {
 813         if (fun->expression.params_count != paramcount) {
 814             parseerror(parser, "expected %i parameters, got %i", (int)fun->expression.params_count, paramcount);
 815             return false;
 816         }
 817     }
 818
 819     return true;
 820 }
 821
 822 static bool parser_close_paren(parser_t *parser, shunt *sy, bool functions_only)
 823 {
 824     if (!sy->ops_count) {
 825         parseerror(parser, "unmatched closing paren");
 826         return false;
 827     }
 828     if (sy->ops[sy->ops_count-1].paren == 1) {
 829         parseerror(parser, "empty parenthesis expression");
 830         return false;
 831     }
 832     while (sy->ops_count) {
 833         if (sy->ops[sy->ops_count-1].paren == 'f') {
 834             if (!parser_close_call(parser, sy))
 835                 return false;
 836             break;
 837         }
 838         if (sy->ops[sy->ops_count-1].paren == 1) {
 839             sy->ops_count--;
 840             return !functions_only;
 841         }
 842         if (!parser_sy_pop(parser, sy))
 843             return false;
 844     }
 845     return true;
 846 }
 847
 848 static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomma)
 849 {
 850     ast_expression *expr = NULL;
 851     shunt sy;
 852     bool wantop = false;
 853     bool gotmemberof = false;
 854
 855     /* count the parens because an if starts with one, so the
 856      * end of a condition is an unmatched closing paren
 857      */
 858     int parens = 0;
 859
 860     MEM_VECTOR_INIT(&sy, out);
 861     MEM_VECTOR_INIT(&sy, ops);
 862
 863     while (true)
 864     {
 865         if (gotmemberof)
 866             gotmemberof = false;
 867         else
 868             parser->memberof = 0;
 869         if (!wantop)
 870         {
 871             bool nextwant = true;
 872             if (parser->tok == TOKEN_IDENT)
 873             {
 874                 /* variable */
 875                 ast_expression *var;
 876                 if (opts_standard == COMPILER_GMQCC)
 877                 {
 878                     if (parser->memberof == TYPE_ENTITY)
 879                         var = parser_find_field(parser, parser_tokval(parser));
 880                     else if (parser->memberof == TYPE_VECTOR)
 881                     {
 882                         parseerror(parser, "TODO: implement effective vector member access");
 883                         goto onerr;
 884                     }
 885                     else if (parser->memberof) {
 886                         parseerror(parser, "namespace for member not found");
 887                         goto onerr;
 888                     }
 889                     else
 890                         var = parser_find_var(parser, parser_tokval(parser));
 891                 } else {
 892                     var = parser_find_var(parser, parser_tokval(parser));
 893                     if (!var)
 894                         var = parser_find_field(parser, parser_tokval(parser));
 895                 }
 896                 if (!var) {
 897                     parseerror(parser, "unexpected ident: %s", parser_tokval(parser));
 898                     goto onerr;
 899                 }
 900                 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), var))) {
 901                     parseerror(parser, "out of memory");
 902                     goto onerr;
 903                 }
 904                 DEBUGSHUNTDO(printf("push %s\n", parser_tokval(parser)));
 905             }
 906             else if (parser->tok == TOKEN_FLOATCONST) {
 907                 ast_value *val = parser_const_float(parser, (parser_token(parser)->constval.f));
 908                 if (!val)
 909                     return false;
 910                 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) {
 911                     parseerror(parser, "out of memory");
 912                     goto onerr;
 913                 }
 914                 DEBUGSHUNTDO(printf("push %g\n", parser_token(parser)->constval.f));
 915             }
 916             else if (parser->tok == TOKEN_INTCONST) {
 917                 ast_value *val = parser_const_float(parser, (double)(parser_token(parser)->constval.i));
 918                 if (!val)
 919                     return false;
 920                 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) {
 921                     parseerror(parser, "out of memory");
 922                     goto onerr;
 923                 }
 924                 DEBUGSHUNTDO(printf("push %i\n", parser_token(parser)->constval.i));
 925             }
 926             else if (parser->tok == TOKEN_STRINGCONST) {
 927                 ast_value *val = parser_const_string(parser, parser_tokval(parser));
 928                 if (!val)
 929                     return false;
 930                 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) {
 931                     parseerror(parser, "out of memory");
 932                     goto onerr;
 933                 }
 934                 DEBUGSHUNTDO(printf("push string\n"));
 935             }
 936             else if (parser->tok == TOKEN_VECTORCONST) {
 937                 ast_value *val = parser_const_vector(parser, parser_token(parser)->constval.v);
 938                 if (!val)
 939                     return false;
 940                 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) {
 941                     parseerror(parser, "out of memory");
 942                     goto onerr;
 943                 }
 944                 DEBUGSHUNTDO(printf("push '%g %g %g'\n",
 945                                     parser_token(parser)->constval.v.x,
 946                                     parser_token(parser)->constval.v.y,
 947                                     parser_token(parser)->constval.v.z));
 948             }
 949             else if (parser->tok == '(') {
 950                 ++parens;
 951                 nextwant = false; /* not expecting an operator next */
 952                 if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 1, 0))) {
 953                     parseerror(parser, "out of memory");
 954                     goto onerr;
 955                 }
 956                 DEBUGSHUNTDO(printf("push (\n"));
 957             }
 958             else if (parser->tok == ')') {
 959                 DEBUGSHUNTDO(printf("do[nop] )\n"));
 960                 --parens;
 961                 if (parens < 0)
 962                     break;
 963                 /* allowed for function calls */
 964                 if (!parser_close_paren(parser, &sy, true))
 965                     goto onerr;
 966             }
 967             else {
 968                 /* TODO: prefix operators */
 969                 parseerror(parser, "expected statement");
 970                 goto onerr;
 971             }
 972             wantop = nextwant;
 973             parser->lex->flags.noops = !wantop;
 974         } else {
 975             bool nextwant = false;
 976             if (parser->tok == '(') {
 977                 DEBUGSHUNTDO(printf("push (\n"));
 978                 ++parens;
 979                 /* we expected an operator, this is the function-call operator */
 980                 if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 'f', sy.out_count-1))) {
 981                     parseerror(parser, "out of memory");
 982                     goto onerr;
 983                 }
 984             }
 985             else if (parser->tok == ')') {
 986                 DEBUGSHUNTDO(printf("do[op] )\n"));
 987                 --parens;
 988                 if (parens < 0)
 989                     break;
 990                 /* we do expect an operator next */
 991                 /* closing an opening paren */
 992                 if (!parser_close_paren(parser, &sy, false))
 993                     goto onerr;
 994                 nextwant = true;
 995             }
 996             else if (parser->tok != TOKEN_OPERATOR) {
 997                 parseerror(parser, "expected operator or end of statement");
 998                 goto onerr;
 999             }
1000             else {
1001                 /* classify the operator */
1002                 /* TODO: suffix operators */
1003                 const oper_info *op;
1004                 const oper_info *olast = NULL;
1005                 size_t o;
1006                 for (o = 0; o < operator_count; ++o) {
1007                     if (!(operators[o].flags & OP_PREFIX) &&
1008                         !(operators[o].flags & OP_SUFFIX) && /* remove this */
1009                         !strcmp(parser_tokval(parser), operators[o].op))
1010                     {
1011                         break;
1012                     }
1013                 }
1014                 if (o == operator_count) {
1015                     /* no operator found... must be the end of the statement */
1016                     break;
1017                 }
1018                 /* found an operator */
1019                 op = &operators[o];
1020
1021                 /* when declaring variables, a comma starts a new variable */
1022                 if (op->id == opid1(',') && !parens && stopatcomma)
1023                     break;
1024
1025                 if (op->id == opid1('.')) {
1026                     /* for gmqcc standard: open up the namespace of the previous type */
1027                     ast_expression *prevex = sy.out[sy.out_count-1].out;
1028                     if (!prevex) {
1029                         parseerror(parser, "unexpected member operator");
1030                         goto onerr;
1031                     }
1032                     if (prevex->expression.vtype == TYPE_ENTITY)
1033                         parser->memberof = TYPE_ENTITY;
1034                     else if (prevex->expression.vtype == TYPE_VECTOR)
1035                         parser->memberof = TYPE_VECTOR;
1036                     else {
1037                         parseerror(parser, "type error: type has no members");
1038                         goto onerr;
1039                     }
1040                     gotmemberof = true;
1041                 }
1042
1043                 if (sy.ops_count && !sy.ops[sy.ops_count-1].paren)
1044                     olast = &operators[sy.ops[sy.ops_count-1].etype-1];
1045
1046                 while (olast && (
1047                         (op->prec < olast->prec) ||
1048                         (op->assoc == ASSOC_LEFT && op->prec <= olast->prec) ) )
1049                 {
1050                     if (!parser_sy_pop(parser, &sy))
1051                         goto onerr;
1052                     if (sy.ops_count && !sy.ops[sy.ops_count-1].paren)
1053                         olast = &operators[sy.ops[sy.ops_count-1].etype-1];
1054                     else
1055                         olast = NULL;
1056                 }
1057
1058                 DEBUGSHUNTDO(printf("push operator %s\n", op->op));
1059                 if (!shunt_ops_add(&sy, syop(parser_ctx(parser), op)))
1060                     goto onerr;
1061             }
1062             wantop = nextwant;
1063             parser->lex->flags.noops = !wantop;
1064         }
1065         if (!parser_next(parser)) {
1066             goto onerr;
1067         }
1068         if (parser->tok == ';') {
1069             break;
1070         }
1071     }
1072
1073     while (sy.ops_count) {
1074         if (!parser_sy_pop(parser, &sy))
1075             goto onerr;
1076     }
1077
1078     parser->lex->flags.noops = true;
1079     if (!sy.out_count) {
1080         parseerror(parser, "empty expression");
1081         expr = NULL;
1082     } else
1083         expr = sy.out[0].out;
1084     MEM_VECTOR_CLEAR(&sy, out);
1085     MEM_VECTOR_CLEAR(&sy, ops);
1086     DEBUGSHUNTDO(printf("shut done\n"));
1087     return expr;
1088
1089 onerr:
1090     parser->lex->flags.noops = true;
1091     MEM_VECTOR_CLEAR(&sy, out);
1092     MEM_VECTOR_CLEAR(&sy, ops);
1093     return NULL;
1094 }
1095
1096 static ast_expression* parser_expression(parser_t *parser, bool stopatcomma)
1097 {
1098     ast_expression *e = parser_expression_leave(parser, stopatcomma);
1099     if (!e)
1100         return NULL;
1101     if (!parser_next(parser)) {
1102         ast_delete(e);
1103         return NULL;
1104     }
1105     return e;
1106 }
1107
1108 static bool parser_parse_if(parser_t *parser, ast_block *block, ast_expression **out)
1109 {
1110     ast_ifthen *ifthen;
1111     ast_expression *cond, *ontrue, *onfalse = NULL;
1112
1113     lex_ctx ctx = parser_ctx(parser);
1114
1115     /* skip the 'if' and check for opening paren */
1116     if (!parser_next(parser) || parser->tok != '(') {
1117         parseerror(parser, "expected 'if' condition in parenthesis");
1118         return false;
1119     }
1120     /* parse into the expression */
1121     if (!parser_next(parser)) {
1122         parseerror(parser, "expected 'if' condition after opening paren");
1123         return false;
1124     }
1125     /* parse the condition */
1126     cond = parser_expression_leave(parser, false);
1127     if (!cond)
1128         return false;
1129     /* closing paren */
1130     if (parser->tok != ')') {
1131         parseerror(parser, "expected closing paren after 'if' condition");
1132         ast_delete(cond);
1133         return false;
1134     }
1135     /* parse into the 'then' branch */
1136     if (!parser_next(parser)) {
1137         parseerror(parser, "expected statement for on-true branch of 'if'");
1138         ast_delete(cond);
1139         return false;
1140     }
1141     ontrue = parser_parse_statement_or_block(parser);
1142     if (!ontrue) {
1143         ast_delete(cond);
1144         return false;
1145     }
1146     /* check for an else */
1147     if (!strcmp(parser_tokval(parser), "else")) {
1148         /* parse into the 'else' branch */
1149         if (!parser_next(parser)) {
1150             parseerror(parser, "expected on-false branch after 'else'");
1151             ast_delete(ontrue);
1152             ast_delete(cond);
1153             return false;
1154         }
1155         onfalse = parser_parse_statement_or_block(parser);
1156         if (!onfalse) {
1157             ast_delete(ontrue);
1158             ast_delete(cond);
1159             return false;
1160         }
1161     }
1162
1163     ifthen = ast_ifthen_new(ctx, cond, ontrue, onfalse);
1164     *out = (ast_expression*)ifthen;
1165     return true;
1166 }
1167
1168 static bool parser_parse_while(parser_t *parser, ast_block *block, ast_expression **out)
1169 {
1170     ast_loop *aloop;
1171     ast_expression *cond, *ontrue;
1172
1173     lex_ctx ctx = parser_ctx(parser);
1174
1175     /* skip the 'while' and check for opening paren */
1176     if (!parser_next(parser) || parser->tok != '(') {
1177         parseerror(parser, "expected 'while' condition in parenthesis");
1178         return false;
1179     }
1180     /* parse into the expression */
1181     if (!parser_next(parser)) {
1182         parseerror(parser, "expected 'while' condition after opening paren");
1183         return false;
1184     }
1185     /* parse the condition */
1186     cond = parser_expression_leave(parser, false);
1187     if (!cond)
1188         return false;
1189     /* closing paren */
1190     if (parser->tok != ')') {
1191         parseerror(parser, "expected closing paren after 'while' condition");
1192         ast_delete(cond);
1193         return false;
1194     }
1195     /* parse into the 'then' branch */
1196     if (!parser_next(parser)) {
1197         parseerror(parser, "expected while-loop body");
1198         ast_delete(cond);
1199         return false;
1200     }
1201     ontrue = parser_parse_statement_or_block(parser);
1202     if (!ontrue) {
1203         ast_delete(cond);
1204         return false;
1205     }
1206
1207     aloop = ast_loop_new(ctx, NULL, cond, NULL, NULL, ontrue);
1208     *out = (ast_expression*)aloop;
1209     return true;
1210 }
1211
1212 static bool parser_parse_dowhile(parser_t *parser, ast_block *block, ast_expression **out)
1213 {
1214     ast_loop *aloop;
1215     ast_expression *cond, *ontrue;
1216
1217     lex_ctx ctx = parser_ctx(parser);
1218
1219     /* skip the 'do' and get the body */
1220     if (!parser_next(parser)) {
1221         parseerror(parser, "expected loop body");
1222         return false;
1223     }
1224     ontrue = parser_parse_statement_or_block(parser);
1225     if (!ontrue)
1226         return false;
1227
1228     /* expect the "while" */
1229     if (parser->tok != TOKEN_KEYWORD ||
1230         strcmp(parser_tokval(parser), "while"))
1231     {
1232         parseerror(parser, "expected 'while' and condition");
1233         ast_delete(ontrue);
1234         return false;
1235     }
1236
1237     /* skip the 'while' and check for opening paren */
1238     if (!parser_next(parser) || parser->tok != '(') {
1239         parseerror(parser, "expected 'while' condition in parenthesis");
1240         ast_delete(ontrue);
1241         return false;
1242     }
1243     /* parse into the expression */
1244     if (!parser_next(parser)) {
1245         parseerror(parser, "expected 'while' condition after opening paren");
1246         ast_delete(ontrue);
1247         return false;
1248     }
1249     /* parse the condition */
1250     cond = parser_expression_leave(parser, false);
1251     if (!cond)
1252         return false;
1253     /* closing paren */
1254     if (parser->tok != ')') {
1255         parseerror(parser, "expected closing paren after 'while' condition");
1256         ast_delete(ontrue);
1257         ast_delete(cond);
1258         return false;
1259     }
1260     /* parse on */
1261     if (!parser_next(parser) || parser->tok != ';') {
1262         parseerror(parser, "expected semicolon after condition");
1263         ast_delete(ontrue);
1264         ast_delete(cond);
1265         return false;
1266     }
1267
1268     if (!parser_next(parser)) {
1269         parseerror(parser, "parse error");
1270         ast_delete(ontrue);
1271         ast_delete(cond);
1272         return false;
1273     }
1274
1275     aloop = ast_loop_new(ctx, NULL, NULL, cond, NULL, ontrue);
1276     *out = (ast_expression*)aloop;
1277     return true;
1278 }
1279
1280 static bool parser_parse_for(parser_t *parser, ast_block *block, ast_expression **out)
1281 {
1282     ast_loop *aloop;
1283     ast_expression *initexpr, *cond, *increment, *ontrue;
1284     size_t oldblocklocal;
1285
1286     lex_ctx ctx = parser_ctx(parser);
1287
1288     oldblocklocal = parser->blocklocal;
1289     parser->blocklocal = parser->locals_count;
1290
1291     initexpr  = NULL;
1292     cond      = NULL;
1293     increment = NULL;
1294     ontrue    = NULL;
1295
1296     /* skip the 'while' and check for opening paren */
1297     if (!parser_next(parser) || parser->tok != '(') {
1298         parseerror(parser, "expected 'for' expressions in parenthesis");
1299         goto onerr;
1300     }
1301     /* parse into the expression */
1302     if (!parser_next(parser)) {
1303         parseerror(parser, "expected 'for' initializer after opening paren");
1304         goto onerr;
1305     }
1306
1307     if (parser->tok == TOKEN_TYPENAME) {
1308         if (opts_standard != COMPILER_GMQCC) {
1309             if (parsewarning(parser, WARN_EXTENSIONS,
1310                              "current standard does not allow variable declarations in for-loop initializers"))
1311                 goto onerr;
1312         }
1313
1314         parseerror(parser, "TODO: assignment of new variables to be non-const");
1315         goto onerr;
1316         if (!parser_variable(parser, block))
1317             goto onerr;
1318     }
1319     else if (parser->tok != ';')
1320     {
1321         initexpr = parser_expression_leave(parser, false);
1322         if (!initexpr)
1323             goto onerr;
1324     }
1325
1326     /* move on to condition */
1327     if (parser->tok != ';') {
1328         parseerror(parser, "expected semicolon after for-loop initializer");
1329         goto onerr;
1330     }
1331     if (!parser_next(parser)) {
1332         parseerror(parser, "expected for-loop condition");
1333         goto onerr;
1334     }
1335
1336     /* parse the condition */
1337     if (parser->tok != ';') {
1338         cond = parser_expression_leave(parser, false);
1339         if (!cond)
1340             goto onerr;
1341     }
1342
1343     /* move on to incrementor */
1344     if (parser->tok != ';') {
1345         parseerror(parser, "expected semicolon after for-loop initializer");
1346         goto onerr;
1347     }
1348     if (!parser_next(parser)) {
1349         parseerror(parser, "expected for-loop condition");
1350         goto onerr;
1351     }
1352
1353     /* parse the incrementor */
1354     if (parser->tok != ')') {
1355         increment = parser_expression_leave(parser, false);
1356         if (!increment)
1357             goto onerr;
1358     }
1359
1360     /* closing paren */
1361     if (parser->tok != ')') {
1362         parseerror(parser, "expected closing paren after 'for-loop' incrementor");
1363         goto onerr;
1364     }
1365     /* parse into the 'then' branch */
1366     if (!parser_next(parser)) {
1367         parseerror(parser, "expected for-loop body");
1368         goto onerr;
1369     }
1370     ontrue = parser_parse_statement_or_block(parser);
1371     if (!ontrue) {
1372         goto onerr;
1373     }
1374
1375     aloop = ast_loop_new(ctx, initexpr, cond, NULL, increment, ontrue);
1376     *out = (ast_expression*)aloop;
1377
1378     while (parser->locals_count > parser->blocklocal)
1379         parser_pop_local(parser);
1380     parser->blocklocal = oldblocklocal;
1381     return true;
1382 onerr:
1383     if (initexpr)  ast_delete(initexpr);
1384     if (cond)      ast_delete(cond);
1385     if (increment) ast_delete(increment);
1386     while (parser->locals_count > parser->blocklocal)
1387         parser_pop_local(parser);
1388     parser->blocklocal = oldblocklocal;
1389     return false;
1390 }
1391
1392 static bool parser_parse_statement(parser_t *parser, ast_block *block, ast_expression **out)
1393 {
1394     if (parser->tok == TOKEN_TYPENAME)
1395     {
1396         /* local variable */
1397         if (!block) {
1398             parseerror(parser, "cannot declare a variable from here");
1399             return false;
1400         }
1401         if (opts_standard == COMPILER_QCC) {
1402             if (parsewarning(parser, WARN_EXTENSIONS, "missing 'local' keyword when declaring a local variable"))
1403                 return false;
1404         }
1405         if (!parser_variable(parser, block))
1406             return false;
1407         *out = NULL;
1408         return true;
1409     }
1410     else if (parser->tok == TOKEN_KEYWORD)
1411     {
1412         if (!strcmp(parser_tokval(parser), "local"))
1413         {
1414             if (!block) {
1415                 parseerror(parser, "cannot declare a local variable here");
1416                 return false;
1417             }
1418             if (!parser_next(parser)) {
1419                 parseerror(parser, "expected variable declaration");
1420                 return false;
1421             }
1422             if (!parser_variable(parser, block))
1423                 return false;
1424             *out = NULL;
1425             return true;
1426         }
1427         else if (!strcmp(parser_tokval(parser), "return"))
1428         {
1429             ast_expression *exp = NULL;
1430             ast_return     *ret = NULL;
1431             ast_value      *expected = parser->function->vtype;
1432
1433             if (!parser_next(parser)) {
1434                 parseerror(parser, "expected return expression");
1435                 return false;
1436             }
1437
1438             if (parser->tok != ';') {
1439                 exp = parser_expression(parser, false);
1440                 if (!exp)
1441                     return false;
1442
1443                 if (exp->expression.vtype != expected->expression.next->expression.vtype) {
1444                     parseerror(parser, "return with invalid expression");
1445                 }
1446
1447                 ret = ast_return_new(exp->expression.node.context, exp);
1448                 if (!ret) {
1449                     ast_delete(exp);
1450                     return false;
1451                 }
1452
1453                 *out = (ast_expression*)ret;
1454             } else if (!parser_next(parser)) {
1455                 parseerror(parser, "expected semicolon");
1456                 if (expected->expression.next->expression.vtype != TYPE_VOID) {
1457                     parseerror(parser, "return without value");
1458                 }
1459             }
1460             return true;
1461         }
1462         else if (!strcmp(parser_tokval(parser), "if"))
1463         {
1464             return parser_parse_if(parser, block, out);
1465         }
1466         else if (!strcmp(parser_tokval(parser), "while"))
1467         {
1468             return parser_parse_while(parser, block, out);
1469         }
1470         else if (!strcmp(parser_tokval(parser), "do"))
1471         {
1472             return parser_parse_dowhile(parser, block, out);
1473         }
1474         else if (!strcmp(parser_tokval(parser), "for"))
1475         {
1476             if (opts_standard == COMPILER_QCC) {
1477                 if (parsewarning(parser, WARN_EXTENSIONS, "for loops are not recognized in the original Quake C standard, to enable try an alternate standard --std=?"))
1478                     return false;
1479             }
1480             return parser_parse_for(parser, block, out);
1481         }
1482         parseerror(parser, "Unexpected keyword");
1483         return false;
1484     }
1485     else if (parser->tok == '{')
1486     {
1487         ast_block *inner;
1488         inner = parser_parse_block(parser);
1489         if (!inner)
1490             return false;
1491         *out = (ast_expression*)inner;
1492         return true;
1493     }
1494     else
1495     {
1496         ast_expression *exp = parser_expression(parser, false);
1497         if (!exp)
1498             return false;
1499         *out = exp;
1500         return true;
1501     }
1502 }
1503
1504 static void parser_pop_local(parser_t *parser)
1505 {
1506     parser->locals_count--;
1507     mem_d(parser->locals[parser->locals_count].name);
1508 }
1509
1510 static ast_block* parser_parse_block(parser_t *parser)
1511 {
1512     size_t oldblocklocal;
1513     ast_block *block = NULL;
1514
1515     oldblocklocal = parser->blocklocal;
1516     parser->blocklocal = parser->locals_count;
1517
1518     if (!parser_next(parser)) { /* skip the '{' */
1519         parseerror(parser, "expected function body");
1520         goto cleanup;
1521     }
1522
1523     block = ast_block_new(parser_ctx(parser));
1524
1525     while (parser->tok != TOKEN_EOF && parser->tok < TOKEN_ERROR)
1526     {
1527         ast_expression *expr;
1528         if (parser->tok == '}')
1529             break;
1530
1531         if (!parser_parse_statement(parser, block, &expr)) {
1532             ast_block_delete(block);
1533             block = NULL;
1534             goto cleanup;
1535         }
1536         if (!expr)
1537             continue;
1538         if (!ast_block_exprs_add(block, expr)) {
1539             ast_delete(expr);
1540             ast_block_delete(block);
1541             block = NULL;
1542             goto cleanup;
1543         }
1544     }
1545
1546     if (parser->tok != '}') {
1547         ast_block_delete(block);
1548         block = NULL;
1549     } else {
1550         (void)parser_next(parser);
1551     }
1552
1553 cleanup:
1554     while (parser->locals_count > parser->blocklocal)
1555         parser_pop_local(parser);
1556     parser->blocklocal = oldblocklocal;
1557     /* unroll the local vector */
1558     return block;
1559 }
1560
1561 static ast_expression* parser_parse_statement_or_block(parser_t *parser)
1562 {
1563     ast_expression *expr;
1564     if (parser->tok == '{')
1565         return (ast_expression*)parser_parse_block(parser);
1566     if (!parser_parse_statement(parser, NULL, &expr))
1567         return NULL;
1568     return expr;
1569 }
1570
1571 static bool parser_variable(parser_t *parser, ast_block *localblock)
1572 {
1573     bool          isfunc = false;
1574     ast_function *func = NULL;
1575     lex_ctx       ctx;
1576     ast_value    *var;
1577     varentry_t    varent;
1578     ast_expression *olddecl;
1579
1580     int basetype = parser_token(parser)->constval.t;
1581
1582     while (true)
1583     {
1584         if (!parser_next(parser)) { /* skip basetype or comma */
1585             parseerror(parser, "expected variable declaration");
1586             return false;
1587         }
1588
1589         olddecl = NULL;
1590         isfunc  = false;
1591         func    = NULL;
1592         ctx = parser_ctx(parser);
1593         var = parser_parse_type(parser, basetype, &isfunc);
1594
1595         if (!var)
1596             return false;
1597
1598         if (parser->tok != TOKEN_IDENT) {
1599             parseerror(parser, "expected variable name\n");
1600             return false;
1601         }
1602
1603         if (!isfunc) {
1604             if (!localblock && (olddecl = parser_find_global(parser, parser_tokval(parser)))) {
1605                 ast_value_delete(var);
1606                 parseerror(parser, "global %s already declared here: %s:%i\n",
1607                            parser_tokval(parser), ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line);
1608                 return false;
1609             }
1610
1611             if (localblock && parser_find_local(parser, parser_tokval(parser), parser->blocklocal)) {
1612                 ast_value_delete(var);
1613                 parseerror(parser, "local %s already declared here: %s:%i\n",
1614                            parser_tokval(parser), ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line);
1615                 return false;
1616             }
1617         }
1618
1619         if (!ast_value_set_name(var, parser_tokval(parser))) {
1620             parseerror(parser, "failed to set variable name\n");
1621             ast_value_delete(var);
1622             return false;
1623         }
1624
1625         if (isfunc) {
1626             /* a function was defined */
1627             ast_value *fval;
1628             ast_value *proto = NULL;
1629
1630             if (!localblock)
1631                 olddecl = parser_find_global(parser, parser_tokval(parser));
1632             else
1633                 olddecl = parser_find_local(parser, parser_tokval(parser), parser->blocklocal);
1634
1635             if (olddecl) {
1636                 /* we had a prototype */
1637                 if (!ast_istype(olddecl, ast_value)) {
1638                     /* theoretically not possible you think?
1639                      * well:
1640                      * vector v;
1641                      * void() v_x = {}
1642                      * got it?
1643                      */
1644                     parseerror(parser, "cannot declare a function with the same name as a vector's member: %s",
1645                                parser_tokval(parser));
1646                     ast_value_delete(var);
1647                     return false;
1648                 }
1649
1650                 proto = (ast_value*)olddecl;
1651             }
1652
1653             /* turn var into a value of TYPE_FUNCTION, with the old var
1654              * as return type
1655              */
1656             fval = ast_value_new(ctx, var->name, TYPE_FUNCTION);
1657             func = ast_function_new(ctx, var->name, fval);
1658             if (!fval || !func) {
1659                 ast_value_delete(var);
1660                 if (fval) ast_value_delete(fval);
1661                 if (func) ast_function_delete(func);
1662                 return false;
1663             }
1664
1665             fval->expression.next = (ast_expression*)var;
1666             MEM_VECTOR_MOVE(&var->expression, params, &fval->expression, params);
1667
1668             /* we compare the type late here, but it's easier than
1669              * messing with the parameter-vector etc. earlier
1670              */
1671             if (proto) {
1672                 if (!ast_compare_type((ast_expression*)proto, (ast_expression*)fval)) {
1673                     parseerror(parser, "conflicting types for `%s`, previous declaration was here: %s:%i",
1674                                proto->name,
1675                                ast_ctx(proto).file, ast_ctx(proto).line);
1676                     ast_function_delete(func);
1677                     ast_value_delete(fval);
1678                     return false;
1679                 }
1680                 ast_function_delete(func);
1681                 ast_value_delete(fval);
1682                 var = proto;
1683                 func = var->constval.vfunc;
1684             }
1685             else
1686             {
1687                 if (!parser_t_functions_add(parser, func)) {
1688                     ast_function_delete(func);
1689                     ast_value_delete(fval);
1690                     return false;
1691                 }
1692             }
1693
1694             var = fval;
1695         }
1696
1697         varent.name = util_strdup(var->name);
1698         varent.var = (ast_expression*)var;
1699         if (var->expression.vtype == TYPE_VECTOR)
1700         {
1701             size_t len = strlen(varent.name);
1702             varentry_t vx, vy, vz;
1703             vx.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 0);
1704             vy.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 1);
1705             vz.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 2);
1706             vx.name = mem_a(len+3);
1707             vy.name = mem_a(len+3);
1708             vz.name = mem_a(len+3);
1709             memcpy(vx.name, varent.name, len);
1710             memcpy(vy.name, varent.name, len);
1711             memcpy(vz.name, varent.name, len);
1712             vx.name[len] = vy.name[len] = vz.name[len] = '_';
1713             vx.name[len+1] = 'x';
1714             vy.name[len+1] = 'y';
1715             vz.name[len+1] = 'z';
1716             vx.name[len+2] = vy.name[len+2] = vz.name[len+2] = 0;
1717
1718             if (!localblock) {
1719                 (void)!parser_t_globals_add(parser, varent);
1720                 (void)!parser_t_globals_add(parser, vx);
1721                 (void)!parser_t_globals_add(parser, vy);
1722                 (void)!parser_t_globals_add(parser, vz);
1723             } else {
1724                 (void)!parser_t_locals_add(parser, varent);
1725                 (void)!parser_t_locals_add(parser, vx);
1726                 (void)!parser_t_locals_add(parser, vy);
1727                 (void)!parser_t_locals_add(parser, vz);
1728             }
1729         }
1730         else
1731         {
1732             if ( (!localblock && !parser_t_globals_add(parser, varent)) ||
1733                  ( localblock && !parser_t_locals_add(parser, varent)) )
1734             {
1735                 ast_value_delete(var);
1736                 return false;
1737             }
1738         }
1739         if (localblock && !ast_block_locals_add(localblock, var))
1740         {
1741             parser_pop_local(parser);
1742             ast_value_delete(var);
1743             return false;
1744         }
1745
1746         if (!parser_next(parser)) {
1747             ast_value_delete(var);
1748             return false;
1749         }
1750
1751         if (parser->tok == ';') {
1752             if (!parser_next(parser))
1753                 return parser->tok == TOKEN_EOF;
1754             return true;
1755         }
1756
1757         if (parser->tok == ',') {
1758             /* another var */
1759             continue;
1760         }
1761
1762         if (parser->tok != '=') {
1763             parseerror(parser, "expected '=' or ';'");
1764             return false;
1765         }
1766
1767         if (!parser_next(parser))
1768             return false;
1769
1770         if (parser->tok == '#') {
1771             if (localblock) {
1772                 parseerror(parser, "cannot declare builtins within functions");
1773                 return false;
1774             }
1775             if (!isfunc || !func) {
1776                 parseerror(parser, "unexpected builtin number, '%s' is not a function", var->name);
1777                 return false;
1778             }
1779             if (!parser_next(parser)) {
1780                 parseerror(parser, "expected builtin number");
1781                 return false;
1782             }
1783             if (parser->tok != TOKEN_INTCONST) {
1784                 parseerror(parser, "builtin number must be an integer constant");
1785                 return false;
1786             }
1787             if (parser_token(parser)->constval.i <= 0) {
1788                 parseerror(parser, "builtin number must be positive integer greater than zero");
1789                 return false;
1790             }
1791
1792             func->builtin = -parser_token(parser)->constval.i;
1793
1794             if (!parser_next(parser))
1795                 return false;
1796         } else if (parser->tok == '{') {
1797             /* function body */
1798             ast_block *block;
1799             ast_function *old = parser->function;
1800
1801             if (localblock) {
1802                 parseerror(parser, "cannot declare functions within functions");
1803                 return false;
1804             }
1805
1806             parser->function = func;
1807             block = parser_parse_block(parser);
1808             parser->function = old;
1809
1810             if (!block)
1811                 return false;
1812
1813             if (!ast_function_blocks_add(func, block)) {
1814                 ast_block_delete(block);
1815                 return false;
1816             }
1817
1818             if (parser->tok == ';')
1819                 return parser_next(parser) || parser->tok == TOKEN_EOF;
1820             else if (opts_standard == COMPILER_QCC)
1821                 parseerror(parser, "missing semicolon after function body (mandatory with -std=qcc)");
1822             return true;
1823         } else {
1824             ast_expression *cexp;
1825             ast_value      *cval;
1826
1827             cexp = parser_expression_leave(parser, true);
1828             cval = (ast_value*)cexp;
1829             if (!ast_istype(cval, ast_value) || !cval->isconst)
1830                 parseerror(parser, "cannot initialize a global constant variable with a non-constant expression");
1831             else
1832             {
1833                 var->isconst = true;
1834                 memcpy(&var->constval, &cval->constval, sizeof(var->constval));
1835                 memset(&cval->constval, 0, sizeof(cval->constval));
1836                 ast_unref(cval);
1837             }
1838         }
1839
1840         if (parser->tok == ',') {
1841             /* another */
1842             continue;
1843         }
1844
1845         if (parser->tok != ';') {
1846             parseerror(parser, "missing semicolon");
1847             return false;
1848         }
1849
1850         (void)parser_next(parser);
1851
1852         return true;
1853     }
1854 }
1855
1856 static bool parser_do(parser_t *parser)
1857 {
1858     if (parser->tok == TOKEN_TYPENAME)
1859     {
1860         return parser_variable(parser, NULL);
1861     }
1862     else if (parser->tok == TOKEN_KEYWORD)
1863     {
1864         /* handle 'var' and 'const' */
1865         return false;
1866     }
1867     else if (parser->tok == '.')
1868     {
1869         ast_value *var;
1870         ast_value *fld;
1871         bool       isfunc = false;
1872         int        basetype;
1873         lex_ctx    ctx = parser_ctx(parser);
1874         varentry_t varent;
1875
1876         /* entity-member declaration */
1877         if (!parser_next(parser) || parser->tok != TOKEN_TYPENAME) {
1878             parseerror(parser, "expected member variable definition");
1879             return false;
1880         }
1881
1882         /* remember the base/return type */
1883         basetype = parser_token(parser)->constval.t;
1884
1885         /* parse into the declaration */
1886         if (!parser_next(parser)) {
1887             parseerror(parser, "expected field def");
1888             return false;
1889         }
1890
1891         /* parse the field type fully */
1892         var = parser_parse_type(parser, basetype, &isfunc);
1893         if (!var)
1894             return false;
1895
1896         while (true) {
1897             /* now the field name */
1898             if (parser->tok != TOKEN_IDENT) {
1899                 parseerror(parser, "expected field name");
1900                 ast_delete(var);
1901                 return false;
1902             }
1903
1904             /* check for an existing field
1905              * in original qc we also have to check for an existing
1906              * global named like the field
1907              */
1908             if (opts_standard == COMPILER_QCC) {
1909                 if (parser_find_global(parser, parser_tokval(parser))) {
1910                     parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc");
1911                     ast_delete(var);
1912                     return false;
1913                 }
1914             }
1915             if (parser_find_field(parser, parser_tokval(parser))) {
1916                 parseerror(parser, "field %s already exists", parser_tokval(parser));
1917                 ast_delete(var);
1918                 return false;
1919             }
1920
1921             /* if it was a function, turn it into a function */
1922             if (isfunc) {
1923                 ast_value *fval;
1924                 /* turn var into a value of TYPE_FUNCTION, with the old var
1925                  * as return type
1926                  */
1927                 fval = ast_value_new(ctx, var->name, TYPE_FUNCTION);
1928                 if (!fval) {
1929                     ast_value_delete(var);
1930                     ast_value_delete(fval);
1931                     return false;
1932                 }
1933
1934                 fval->expression.next = (ast_expression*)var;
1935                 MEM_VECTOR_MOVE(&var->expression, params, &fval->expression, params);
1936
1937                 var = fval;
1938             }
1939
1940             /* turn it into a field */
1941             fld = ast_value_new(ctx, parser_tokval(parser), TYPE_FIELD);
1942             fld->expression.next = (ast_expression*)var;
1943
1944             varent.var = (ast_expression*)fld;
1945             varent.name = util_strdup(fld->name);
1946             (void)!parser_t_fields_add(parser, varent);
1947
1948             if (var->expression.vtype == TYPE_VECTOR)
1949             {
1950                 /* create _x, _y and _z fields as well */
1951                 size_t len;
1952                 varentry_t vx, vy, vz;
1953
1954                 len = strlen(varent.name);
1955                 vx.var = (ast_expression*)ast_member_new(ast_ctx(fld), (ast_expression*)fld, 0);
1956                 vy.var = (ast_expression*)ast_member_new(ast_ctx(fld), (ast_expression*)fld, 1);
1957                 vz.var = (ast_expression*)ast_member_new(ast_ctx(fld), (ast_expression*)fld, 2);
1958                 vx.name = mem_a(len+3);
1959                 vy.name = mem_a(len+3);
1960                 vz.name = mem_a(len+3);
1961                 memcpy(vx.name, varent.name, len);
1962                 memcpy(vy.name, varent.name, len);
1963                 memcpy(vz.name, varent.name, len);
1964                 vx.name[len] = vy.name[len] = vz.name[len] = '_';
1965                 vx.name[len+1] = 'x';
1966                 vy.name[len+1] = 'y';
1967                 vz.name[len+1] = 'z';
1968                 vx.name[len+2] = vy.name[len+2] = vz.name[len+2] = 0;
1969                 (void)!parser_t_fields_add(parser, vx);
1970                 (void)!parser_t_fields_add(parser, vy);
1971                 (void)!parser_t_fields_add(parser, vz);
1972             }
1973
1974             if (!parser_next(parser)) {
1975                 parseerror(parser, "expected semicolon or another field name");
1976                 return false;
1977             }
1978             if (parser->tok == ';')
1979                 break;
1980             if (parser->tok != ',' || !parser_next(parser)) {
1981                 parseerror(parser, "expected semicolon or another field name");
1982                 return false;
1983             }
1984         }
1985
1986         /* skip the semicolon */
1987         if (!parser_next(parser))
1988             return parser->tok == TOKEN_EOF;
1989
1990         return true;
1991     }
1992     else
1993     {
1994         parseerror(parser, "unexpected token: %s", parser->lex->tok->value);
1995         return false;
1996     }
1997     return true;
1998 }
1999
2000 static parser_t *parser;
2001
2002 bool parser_init()
2003 {
2004     parser = (parser_t*)mem_a(sizeof(parser_t));
2005     if (!parser)
2006         return false;
2007
2008     memset(parser, 0, sizeof(*parser));
2009     return true;
2010 }
2011
2012 bool parser_compile(const char *filename)
2013 {
2014     parser->lex = lex_open(filename);
2015     if (!parser->lex) {
2016         printf("failed to open file \"%s\"\n", filename);
2017         return false;
2018     }
2019
2020     /* initial lexer/parser state */
2021     parser->lex->flags.noops = true;
2022
2023     if (parser_next(parser))
2024     {
2025         while (parser->tok != TOKEN_EOF && parser->tok < TOKEN_ERROR)
2026         {
2027             if (!parser_do(parser)) {
2028                 if (parser->tok == TOKEN_EOF)
2029                     parseerror(parser, "unexpected eof");
2030                 else if (!parser->errors)
2031                     parseerror(parser, "parse error\n");
2032                 lex_close(parser->lex);
2033                 mem_d(parser);
2034                 return false;
2035             }
2036         }
2037     }
2038
2039     lex_close(parser->lex);
2040
2041     return !parser->errors;
2042 }
2043
2044 void parser_cleanup()
2045 {
2046     size_t i;
2047     for (i = 0; i < parser->functions_count; ++i) {
2048         ast_delete(parser->functions[i]);
2049     }
2050     for (i = 0; i < parser->imm_vector_count; ++i) {
2051         ast_delete(parser->imm_vector[i]);
2052     }
2053     for (i = 0; i < parser->imm_string_count; ++i) {
2054         ast_delete(parser->imm_string[i]);
2055     }
2056     for (i = 0; i < parser->imm_float_count; ++i) {
2057         ast_delete(parser->imm_float[i]);
2058     }
2059     for (i = 0; i < parser->globals_count; ++i) {
2060         ast_delete(parser->globals[i].var);
2061         mem_d(parser->globals[i].name);
2062     }
2063     MEM_VECTOR_CLEAR(parser, globals);
2064
2065     mem_d(parser);
2066 }
2067
2068 bool parser_finish(const char *output)
2069 {
2070     size_t i;
2071     ir_builder *ir;
2072
2073     if (!parser->errors)
2074     {
2075         ir = ir_builder_new("gmqcc_out");
2076         if (!ir) {
2077             printf("failed to allocate builder\n");
2078             return false;
2079         }
2080
2081         for (i = 0; i < parser->imm_float_count; ++i) {
2082             if (!ast_global_codegen(parser->imm_float[i], ir)) {
2083                 printf("failed to generate global %s\n", parser->imm_float[i]->name);
2084                 ir_builder_delete(ir);
2085                 return false;
2086             }
2087         }
2088         for (i = 0; i < parser->imm_string_count; ++i) {
2089             if (!ast_global_codegen(parser->imm_string[i], ir)) {
2090                 printf("failed to generate global %s\n", parser->imm_string[i]->name);
2091                 ir_builder_delete(ir);
2092                 return false;
2093             }
2094         }
2095         for (i = 0; i < parser->imm_vector_count; ++i) {
2096             if (!ast_global_codegen(parser->imm_vector[i], ir)) {
2097                 printf("failed to generate global %s\n", parser->imm_vector[i]->name);
2098                 ir_builder_delete(ir);
2099                 return false;
2100             }
2101         }
2102         for (i = 0; i < parser->fields_count; ++i) {
2103             ast_value *field;
2104             bool isconst;
2105             if (!ast_istype(parser->fields[i].var, ast_value))
2106                 continue;
2107             field = (ast_value*)parser->fields[i].var;
2108             isconst = field->isconst;
2109             field->isconst = false;
2110             if (!ast_global_codegen((ast_value*)field, ir)) {
2111                 printf("failed to generate field %s\n", field->name);
2112                 ir_builder_delete(ir);
2113                 return false;
2114             }
2115             if (isconst) {
2116                 ir_value *ifld;
2117                 ast_expression *subtype;
2118                 field->isconst = true;
2119                 subtype = field->expression.next;
2120                 ifld = ir_builder_create_field(ir, field->name, subtype->expression.vtype);
2121                 if (subtype->expression.vtype == TYPE_FIELD)
2122                     ifld->fieldtype = subtype->expression.next->expression.vtype;
2123                 else if (subtype->expression.vtype == TYPE_FUNCTION)
2124                     ifld->outtype = subtype->expression.next->expression.vtype;
2125                 (void)!ir_value_set_field(field->ir_v, ifld);
2126             }
2127         }
2128         for (i = 0; i < parser->globals_count; ++i) {
2129             if (!ast_istype(parser->globals[i].var, ast_value))
2130                 continue;
2131             if (!ast_global_codegen((ast_value*)(parser->globals[i].var), ir)) {
2132                 printf("failed to generate global %s\n", parser->globals[i].name);
2133                 ir_builder_delete(ir);
2134                 return false;
2135             }
2136         }
2137         for (i = 0; i < parser->functions_count; ++i) {
2138             if (!ast_function_codegen(parser->functions[i], ir)) {
2139                 printf("failed to generate function %s\n", parser->functions[i]->name);
2140                 ir_builder_delete(ir);
2141                 return false;
2142             }
2143             if (!ir_function_finalize(parser->functions[i]->ir_func)) {
2144                 printf("failed to finalize function %s\n", parser->functions[i]->name);
2145                 ir_builder_delete(ir);
2146                 return false;
2147             }
2148         }
2149
2150         if (opts_dump)
2151             ir_builder_dump(ir, printf);
2152
2153         if (!ir_builder_generate(ir, output)) {
2154             printf("*** failed to generate output file\n");
2155             ir_builder_delete(ir);
2156             return false;
2157         }
2158
2159         ir_builder_delete(ir);
2160         return true;
2161     }
2162
2163     printf("*** there were compile errors\n");
2164     return false;
2165 }