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