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);
  49 static ast_expression* parser_expression(parser_t *parser);
  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)
 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                 if (op->id == opid1('.')) {
1021                     /* for gmqcc standard: open up the namespace of the previous type */
1022                     ast_expression *prevex = sy.out[sy.out_count-1].out;
1023                     if (!prevex) {
1024                         parseerror(parser, "unexpected member operator");
1025                         goto onerr;
1026                     }
1027                     if (prevex->expression.vtype == TYPE_ENTITY)
1028                         parser->memberof = TYPE_ENTITY;
1029                     else if (prevex->expression.vtype == TYPE_VECTOR)
1030                         parser->memberof = TYPE_VECTOR;
1031                     else {
1032                         parseerror(parser, "type error: type has no members");
1033                         goto onerr;
1034                     }
1035                     gotmemberof = true;
1036                 }
1037
1038                 if (sy.ops_count && !sy.ops[sy.ops_count-1].paren)
1039                     olast = &operators[sy.ops[sy.ops_count-1].etype-1];
1040
1041                 while (olast && (
1042                         (op->prec < olast->prec) ||
1043                         (op->assoc == ASSOC_LEFT && op->prec <= olast->prec) ) )
1044                 {
1045                     if (!parser_sy_pop(parser, &sy))
1046                         goto onerr;
1047                     if (sy.ops_count && !sy.ops[sy.ops_count-1].paren)
1048                         olast = &operators[sy.ops[sy.ops_count-1].etype-1];
1049                     else
1050                         olast = NULL;
1051                 }
1052
1053                 DEBUGSHUNTDO(printf("push operator %s\n", op->op));
1054                 if (!shunt_ops_add(&sy, syop(parser_ctx(parser), op)))
1055                     goto onerr;
1056             }
1057             wantop = nextwant;
1058             parser->lex->flags.noops = !wantop;
1059         }
1060         if (!parser_next(parser)) {
1061             goto onerr;
1062         }
1063         if (parser->tok == ';') {
1064             break;
1065         }
1066     }
1067
1068     while (sy.ops_count) {
1069         if (!parser_sy_pop(parser, &sy))
1070             goto onerr;
1071     }
1072
1073     parser->lex->flags.noops = true;
1074     if (!sy.out_count) {
1075         parseerror(parser, "empty expression");
1076         expr = NULL;
1077     } else
1078         expr = sy.out[0].out;
1079     MEM_VECTOR_CLEAR(&sy, out);
1080     MEM_VECTOR_CLEAR(&sy, ops);
1081     DEBUGSHUNTDO(printf("shut done\n"));
1082     return expr;
1083
1084 onerr:
1085     parser->lex->flags.noops = true;
1086     MEM_VECTOR_CLEAR(&sy, out);
1087     MEM_VECTOR_CLEAR(&sy, ops);
1088     return NULL;
1089 }
1090
1091 static ast_expression* parser_expression(parser_t *parser)
1092 {
1093     ast_expression *e = parser_expression_leave(parser);
1094     if (!e)
1095         return NULL;
1096     if (!parser_next(parser)) {
1097         ast_delete(e);
1098         return NULL;
1099     }
1100     return e;
1101 }
1102
1103 static bool parser_parse_if(parser_t *parser, ast_block *block, ast_expression **out)
1104 {
1105     ast_ifthen *ifthen;
1106     ast_expression *cond, *ontrue, *onfalse = NULL;
1107
1108     lex_ctx ctx = parser_ctx(parser);
1109
1110     /* skip the 'if' and check for opening paren */
1111     if (!parser_next(parser) || parser->tok != '(') {
1112         parseerror(parser, "expected 'if' condition in parenthesis");
1113         return false;
1114     }
1115     /* parse into the expression */
1116     if (!parser_next(parser)) {
1117         parseerror(parser, "expected 'if' condition after opening paren");
1118         return false;
1119     }
1120     /* parse the condition */
1121     cond = parser_expression_leave(parser);
1122     if (!cond)
1123         return false;
1124     /* closing paren */
1125     if (parser->tok != ')') {
1126         parseerror(parser, "expected closing paren after 'if' condition");
1127         ast_delete(cond);
1128         return false;
1129     }
1130     /* parse into the 'then' branch */
1131     if (!parser_next(parser)) {
1132         parseerror(parser, "expected statement for on-true branch of 'if'");
1133         ast_delete(cond);
1134         return false;
1135     }
1136     ontrue = parser_parse_statement_or_block(parser);
1137     if (!ontrue) {
1138         ast_delete(cond);
1139         return false;
1140     }
1141     /* check for an else */
1142     if (!strcmp(parser_tokval(parser), "else")) {
1143         /* parse into the 'else' branch */
1144         if (!parser_next(parser)) {
1145             parseerror(parser, "expected on-false branch after 'else'");
1146             ast_delete(ontrue);
1147             ast_delete(cond);
1148             return false;
1149         }
1150         onfalse = parser_parse_statement_or_block(parser);
1151         if (!onfalse) {
1152             ast_delete(ontrue);
1153             ast_delete(cond);
1154             return false;
1155         }
1156     }
1157
1158     ifthen = ast_ifthen_new(ctx, cond, ontrue, onfalse);
1159     *out = (ast_expression*)ifthen;
1160     return true;
1161 }
1162
1163 static bool parser_parse_while(parser_t *parser, ast_block *block, ast_expression **out)
1164 {
1165     ast_loop *aloop;
1166     ast_expression *cond, *ontrue;
1167
1168     lex_ctx ctx = parser_ctx(parser);
1169
1170     /* skip the 'while' and check for opening paren */
1171     if (!parser_next(parser) || parser->tok != '(') {
1172         parseerror(parser, "expected 'while' condition in parenthesis");
1173         return false;
1174     }
1175     /* parse into the expression */
1176     if (!parser_next(parser)) {
1177         parseerror(parser, "expected 'while' condition after opening paren");
1178         return false;
1179     }
1180     /* parse the condition */
1181     cond = parser_expression_leave(parser);
1182     if (!cond)
1183         return false;
1184     /* closing paren */
1185     if (parser->tok != ')') {
1186         parseerror(parser, "expected closing paren after 'while' condition");
1187         ast_delete(cond);
1188         return false;
1189     }
1190     /* parse into the 'then' branch */
1191     if (!parser_next(parser)) {
1192         parseerror(parser, "expected while-loop body");
1193         ast_delete(cond);
1194         return false;
1195     }
1196     ontrue = parser_parse_statement_or_block(parser);
1197     if (!ontrue) {
1198         ast_delete(cond);
1199         return false;
1200     }
1201
1202     aloop = ast_loop_new(ctx, NULL, cond, NULL, NULL, ontrue);
1203     *out = (ast_expression*)aloop;
1204     return true;
1205 }
1206
1207 static bool parser_parse_dowhile(parser_t *parser, ast_block *block, ast_expression **out)
1208 {
1209     ast_loop *aloop;
1210     ast_expression *cond, *ontrue;
1211
1212     lex_ctx ctx = parser_ctx(parser);
1213
1214     /* skip the 'do' and get the body */
1215     if (!parser_next(parser)) {
1216         parseerror(parser, "expected loop body");
1217         return false;
1218     }
1219     ontrue = parser_parse_statement_or_block(parser);
1220     if (!ontrue)
1221         return false;
1222
1223     /* expect the "while" */
1224     if (parser->tok != TOKEN_KEYWORD ||
1225         strcmp(parser_tokval(parser), "while"))
1226     {
1227         parseerror(parser, "expected 'while' and condition");
1228         ast_delete(ontrue);
1229         return false;
1230     }
1231
1232     /* skip the 'while' and check for opening paren */
1233     if (!parser_next(parser) || parser->tok != '(') {
1234         parseerror(parser, "expected 'while' condition in parenthesis");
1235         ast_delete(ontrue);
1236         return false;
1237     }
1238     /* parse into the expression */
1239     if (!parser_next(parser)) {
1240         parseerror(parser, "expected 'while' condition after opening paren");
1241         ast_delete(ontrue);
1242         return false;
1243     }
1244     /* parse the condition */
1245     cond = parser_expression_leave(parser);
1246     if (!cond)
1247         return false;
1248     /* closing paren */
1249     if (parser->tok != ')') {
1250         parseerror(parser, "expected closing paren after 'while' condition");
1251         ast_delete(ontrue);
1252         ast_delete(cond);
1253         return false;
1254     }
1255     /* parse on */
1256     if (!parser_next(parser) || parser->tok != ';') {
1257         parseerror(parser, "expected semicolon after condition");
1258         ast_delete(ontrue);
1259         ast_delete(cond);
1260         return false;
1261     }
1262
1263     if (!parser_next(parser)) {
1264         parseerror(parser, "parse error");
1265         ast_delete(ontrue);
1266         ast_delete(cond);
1267         return false;
1268     }
1269
1270     aloop = ast_loop_new(ctx, NULL, NULL, cond, NULL, ontrue);
1271     *out = (ast_expression*)aloop;
1272     return true;
1273 }
1274
1275 static bool parser_parse_for(parser_t *parser, ast_block *block, ast_expression **out)
1276 {
1277     ast_loop *aloop;
1278     ast_expression *initexpr, *cond, *increment, *ontrue;
1279     size_t oldblocklocal;
1280
1281     lex_ctx ctx = parser_ctx(parser);
1282
1283     oldblocklocal = parser->blocklocal;
1284     parser->blocklocal = parser->locals_count;
1285
1286     initexpr  = NULL;
1287     cond      = NULL;
1288     increment = NULL;
1289     ontrue    = NULL;
1290
1291     /* skip the 'while' and check for opening paren */
1292     if (!parser_next(parser) || parser->tok != '(') {
1293         parseerror(parser, "expected 'for' expressions in parenthesis");
1294         goto onerr;
1295     }
1296     /* parse into the expression */
1297     if (!parser_next(parser)) {
1298         parseerror(parser, "expected 'for' initializer after opening paren");
1299         goto onerr;
1300     }
1301
1302     if (parser->tok == TOKEN_TYPENAME) {
1303         if (opts_standard != COMPILER_GMQCC) {
1304             if (parsewarning(parser, WARN_EXTENSIONS,
1305                              "current standard does not allow variable declarations in for-loop initializers"))
1306                 goto onerr;
1307         }
1308
1309         parseerror(parser, "TODO: assignment of new variables to be non-const");
1310         goto onerr;
1311         if (!parser_variable(parser, block))
1312             goto onerr;
1313     }
1314     else if (parser->tok != ';')
1315     {
1316         initexpr = parser_expression_leave(parser);
1317         if (!initexpr)
1318             goto onerr;
1319     }
1320
1321     /* move on to condition */
1322     if (parser->tok != ';') {
1323         parseerror(parser, "expected semicolon after for-loop initializer");
1324         goto onerr;
1325     }
1326     if (!parser_next(parser)) {
1327         parseerror(parser, "expected for-loop condition");
1328         goto onerr;
1329     }
1330
1331     /* parse the condition */
1332     if (parser->tok != ';') {
1333         cond = parser_expression_leave(parser);
1334         if (!cond)
1335             goto onerr;
1336     }
1337
1338     /* move on to incrementor */
1339     if (parser->tok != ';') {
1340         parseerror(parser, "expected semicolon after for-loop initializer");
1341         goto onerr;
1342     }
1343     if (!parser_next(parser)) {
1344         parseerror(parser, "expected for-loop condition");
1345         goto onerr;
1346     }
1347
1348     /* parse the incrementor */
1349     if (parser->tok != ')') {
1350         increment = parser_expression_leave(parser);
1351         if (!increment)
1352             goto onerr;
1353     }
1354
1355     /* closing paren */
1356     if (parser->tok != ')') {
1357         parseerror(parser, "expected closing paren after 'for-loop' incrementor");
1358         goto onerr;
1359     }
1360     /* parse into the 'then' branch */
1361     if (!parser_next(parser)) {
1362         parseerror(parser, "expected for-loop body");
1363         goto onerr;
1364     }
1365     ontrue = parser_parse_statement_or_block(parser);
1366     if (!ontrue) {
1367         goto onerr;
1368     }
1369
1370     aloop = ast_loop_new(ctx, initexpr, cond, NULL, increment, ontrue);
1371     *out = (ast_expression*)aloop;
1372
1373     while (parser->locals_count > parser->blocklocal)
1374         parser_pop_local(parser);
1375     parser->blocklocal = oldblocklocal;
1376     return true;
1377 onerr:
1378     if (initexpr)  ast_delete(initexpr);
1379     if (cond)      ast_delete(cond);
1380     if (increment) ast_delete(increment);
1381     while (parser->locals_count > parser->blocklocal)
1382         parser_pop_local(parser);
1383     parser->blocklocal = oldblocklocal;
1384     return false;
1385 }
1386
1387 static bool parser_parse_statement(parser_t *parser, ast_block *block, ast_expression **out)
1388 {
1389     if (parser->tok == TOKEN_TYPENAME)
1390     {
1391         /* local variable */
1392         if (!block) {
1393             parseerror(parser, "cannot declare a variable from here");
1394             return false;
1395         }
1396         if (opts_standard == COMPILER_QCC) {
1397             if (parsewarning(parser, WARN_EXTENSIONS, "missing 'local' keyword when declaring a local variable"))
1398                 return false;
1399         }
1400         if (!parser_variable(parser, block))
1401             return false;
1402         *out = NULL;
1403         return true;
1404     }
1405     else if (parser->tok == TOKEN_KEYWORD)
1406     {
1407         if (!strcmp(parser_tokval(parser), "local"))
1408         {
1409             if (!block) {
1410                 parseerror(parser, "cannot declare a local variable here");
1411                 return false;
1412             }
1413             if (!parser_next(parser)) {
1414                 parseerror(parser, "expected variable declaration");
1415                 return false;
1416             }
1417             if (!parser_variable(parser, block))
1418                 return false;
1419             *out = NULL;
1420             return true;
1421         }
1422         else if (!strcmp(parser_tokval(parser), "return"))
1423         {
1424             ast_expression *exp = NULL;
1425             ast_return     *ret = NULL;
1426             ast_value      *expected = parser->function->vtype;
1427
1428             if (!parser_next(parser)) {
1429                 parseerror(parser, "expected return expression");
1430                 return false;
1431             }
1432
1433             if (parser->tok != ';') {
1434                 exp = parser_expression(parser);
1435                 if (!exp)
1436                     return false;
1437
1438                 if (exp->expression.vtype != expected->expression.next->expression.vtype) {
1439                     parseerror(parser, "return with invalid expression");
1440                 }
1441
1442                 ret = ast_return_new(exp->expression.node.context, exp);
1443                 if (!ret) {
1444                     ast_delete(exp);
1445                     return false;
1446                 }
1447
1448                 *out = (ast_expression*)ret;
1449             } else if (!parser_next(parser)) {
1450                 parseerror(parser, "expected semicolon");
1451                 if (expected->expression.next->expression.vtype != TYPE_VOID) {
1452                     parseerror(parser, "return without value");
1453                 }
1454             }
1455             return true;
1456         }
1457         else if (!strcmp(parser_tokval(parser), "if"))
1458         {
1459             return parser_parse_if(parser, block, out);
1460         }
1461         else if (!strcmp(parser_tokval(parser), "while"))
1462         {
1463             return parser_parse_while(parser, block, out);
1464         }
1465         else if (!strcmp(parser_tokval(parser), "do"))
1466         {
1467             return parser_parse_dowhile(parser, block, out);
1468         }
1469         else if (!strcmp(parser_tokval(parser), "for"))
1470         {
1471             if (opts_standard == COMPILER_QCC) {
1472                 if (parsewarning(parser, WARN_EXTENSIONS, "for loops are not recognized in the original Quake C standard, to enable try an alternate standard --std=?"))
1473                     return false;
1474             }
1475             return parser_parse_for(parser, block, out);
1476         }
1477         parseerror(parser, "Unexpected keyword");
1478         return false;
1479     }
1480     else if (parser->tok == '{')
1481     {
1482         ast_block *inner;
1483         inner = parser_parse_block(parser);
1484         if (!inner)
1485             return false;
1486         *out = (ast_expression*)inner;
1487         return true;
1488     }
1489     else
1490     {
1491         ast_expression *exp = parser_expression(parser);
1492         if (!exp)
1493             return false;
1494         *out = exp;
1495         return true;
1496     }
1497 }
1498
1499 static void parser_pop_local(parser_t *parser)
1500 {
1501     parser->locals_count--;
1502     mem_d(parser->locals[parser->locals_count].name);
1503 }
1504
1505 static ast_block* parser_parse_block(parser_t *parser)
1506 {
1507     size_t oldblocklocal;
1508     ast_block *block = NULL;
1509
1510     oldblocklocal = parser->blocklocal;
1511     parser->blocklocal = parser->locals_count;
1512
1513     if (!parser_next(parser)) { /* skip the '{' */
1514         parseerror(parser, "expected function body");
1515         goto cleanup;
1516     }
1517
1518     block = ast_block_new(parser_ctx(parser));
1519
1520     while (parser->tok != TOKEN_EOF && parser->tok < TOKEN_ERROR)
1521     {
1522         ast_expression *expr;
1523         if (parser->tok == '}')
1524             break;
1525
1526         if (!parser_parse_statement(parser, block, &expr)) {
1527             ast_block_delete(block);
1528             block = NULL;
1529             goto cleanup;
1530         }
1531         if (!expr)
1532             continue;
1533         if (!ast_block_exprs_add(block, expr)) {
1534             ast_delete(expr);
1535             ast_block_delete(block);
1536             block = NULL;
1537             goto cleanup;
1538         }
1539     }
1540
1541     if (parser->tok != '}') {
1542         ast_block_delete(block);
1543         block = NULL;
1544     } else {
1545         (void)parser_next(parser);
1546     }
1547
1548 cleanup:
1549     while (parser->locals_count > parser->blocklocal)
1550         parser_pop_local(parser);
1551     parser->blocklocal = oldblocklocal;
1552     /* unroll the local vector */
1553     return block;
1554 }
1555
1556 static ast_expression* parser_parse_statement_or_block(parser_t *parser)
1557 {
1558     ast_expression *expr;
1559     if (parser->tok == '{')
1560         return (ast_expression*)parser_parse_block(parser);
1561     if (!parser_parse_statement(parser, NULL, &expr))
1562         return NULL;
1563     return expr;
1564 }
1565
1566 static bool parser_variable(parser_t *parser, ast_block *localblock)
1567 {
1568     bool          isfunc = false;
1569     ast_function *func = NULL;
1570     lex_ctx       ctx;
1571     ast_value    *var;
1572     varentry_t    varent;
1573     ast_expression *olddecl;
1574
1575     int basetype = parser_token(parser)->constval.t;
1576
1577     while (true)
1578     {
1579         if (!parser_next(parser)) { /* skip basetype or comma */
1580             parseerror(parser, "expected variable declaration");
1581             return false;
1582         }
1583
1584         olddecl = NULL;
1585         isfunc  = false;
1586         func    = NULL;
1587         ctx = parser_ctx(parser);
1588         var = parser_parse_type(parser, basetype, &isfunc);
1589
1590         if (!var)
1591             return false;
1592
1593         if (parser->tok != TOKEN_IDENT) {
1594             parseerror(parser, "expected variable name\n");
1595             return false;
1596         }
1597
1598         if (!isfunc) {
1599             if (!localblock && (olddecl = parser_find_global(parser, parser_tokval(parser)))) {
1600                 ast_value_delete(var);
1601                 parseerror(parser, "global %s already declared here: %s:%i\n",
1602                            parser_tokval(parser), ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line);
1603                 return false;
1604             }
1605
1606             if (localblock && parser_find_local(parser, parser_tokval(parser), parser->blocklocal)) {
1607                 ast_value_delete(var);
1608                 parseerror(parser, "local %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
1614         if (!ast_value_set_name(var, parser_tokval(parser))) {
1615             parseerror(parser, "failed to set variable name\n");
1616             ast_value_delete(var);
1617             return false;
1618         }
1619
1620         if (isfunc) {
1621             /* a function was defined */
1622             ast_value *fval;
1623             ast_value *proto = NULL;
1624
1625             if (!localblock)
1626                 olddecl = parser_find_global(parser, parser_tokval(parser));
1627             else
1628                 olddecl = parser_find_local(parser, parser_tokval(parser), parser->blocklocal);
1629
1630             if (olddecl) {
1631                 /* we had a prototype */
1632                 if (!ast_istype(olddecl, ast_value)) {
1633                     /* theoretically not possible you think?
1634                      * well:
1635                      * vector v;
1636                      * void() v_x = {}
1637                      * got it?
1638                      */
1639                     parseerror(parser, "cannot declare a function with the same name as a vector's member: %s",
1640                                parser_tokval(parser));
1641                     ast_value_delete(var);
1642                     return false;
1643                 }
1644
1645                 proto = (ast_value*)olddecl;
1646             }
1647
1648             /* turn var into a value of TYPE_FUNCTION, with the old var
1649              * as return type
1650              */
1651             fval = ast_value_new(ctx, var->name, TYPE_FUNCTION);
1652             func = ast_function_new(ctx, var->name, fval);
1653             if (!fval || !func) {
1654                 ast_value_delete(var);
1655                 if (fval) ast_value_delete(fval);
1656                 if (func) ast_function_delete(func);
1657                 return false;
1658             }
1659
1660             fval->expression.next = (ast_expression*)var;
1661             MEM_VECTOR_MOVE(&var->expression, params, &fval->expression, params);
1662
1663             /* we compare the type late here, but it's easier than
1664              * messing with the parameter-vector etc. earlier
1665              */
1666             if (proto) {
1667                 if (!ast_compare_type((ast_expression*)proto, (ast_expression*)fval)) {
1668                     parseerror(parser, "conflicting types for `%s`, previous declaration was here: %s:%i",
1669                                proto->name,
1670                                ast_ctx(proto).file, ast_ctx(proto).line);
1671                     ast_function_delete(func);
1672                     ast_value_delete(fval);
1673                     return false;
1674                 }
1675                 ast_function_delete(func);
1676                 ast_value_delete(fval);
1677                 var = proto;
1678                 func = var->constval.vfunc;
1679             }
1680             else
1681             {
1682                 if (!parser_t_functions_add(parser, func)) {
1683                     ast_function_delete(func);
1684                     ast_value_delete(fval);
1685                     return false;
1686                 }
1687             }
1688
1689             var = fval;
1690         }
1691
1692         varent.name = util_strdup(var->name);
1693         varent.var = (ast_expression*)var;
1694         if (var->expression.vtype == TYPE_VECTOR)
1695         {
1696             size_t len = strlen(varent.name);
1697             varentry_t vx, vy, vz;
1698             vx.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 0);
1699             vy.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 1);
1700             vz.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 2);
1701             vx.name = mem_a(len+3);
1702             vy.name = mem_a(len+3);
1703             vz.name = mem_a(len+3);
1704             memcpy(vx.name, varent.name, len);
1705             memcpy(vy.name, varent.name, len);
1706             memcpy(vz.name, varent.name, len);
1707             vx.name[len] = vy.name[len] = vz.name[len] = '_';
1708             vx.name[len+1] = 'x';
1709             vy.name[len+1] = 'y';
1710             vz.name[len+1] = 'z';
1711             vx.name[len+2] = vy.name[len+2] = vz.name[len+2] = 0;
1712
1713             if (!localblock) {
1714                 (void)!parser_t_globals_add(parser, varent);
1715                 (void)!parser_t_globals_add(parser, vx);
1716                 (void)!parser_t_globals_add(parser, vy);
1717                 (void)!parser_t_globals_add(parser, vz);
1718             } else {
1719                 (void)!parser_t_locals_add(parser, varent);
1720                 (void)!parser_t_locals_add(parser, vx);
1721                 (void)!parser_t_locals_add(parser, vy);
1722                 (void)!parser_t_locals_add(parser, vz);
1723             }
1724         }
1725         else
1726         {
1727             if ( (!localblock && !parser_t_globals_add(parser, varent)) ||
1728                  ( localblock && !parser_t_locals_add(parser, varent)) )
1729             {
1730                 ast_value_delete(var);
1731                 return false;
1732             }
1733         }
1734         if (localblock && !ast_block_locals_add(localblock, var))
1735         {
1736             parser_pop_local(parser);
1737             ast_value_delete(var);
1738             return false;
1739         }
1740
1741         if (!parser_next(parser)) {
1742             ast_value_delete(var);
1743             return false;
1744         }
1745
1746         if (parser->tok == ';') {
1747             if (!parser_next(parser))
1748                 return parser->tok == TOKEN_EOF;
1749             return true;
1750         }
1751
1752         if (parser->tok == ',') {
1753             /* another var */
1754             continue;
1755         }
1756
1757         if (parser->tok != '=') {
1758             parseerror(parser, "expected '=' or ';'");
1759             return false;
1760         }
1761
1762         if (!parser_next(parser))
1763             return false;
1764
1765         if (parser->tok == '#') {
1766             if (localblock) {
1767                 parseerror(parser, "cannot declare builtins within functions");
1768                 return false;
1769             }
1770             if (!isfunc || !func) {
1771                 parseerror(parser, "unexpected builtin number, '%s' is not a function", var->name);
1772                 return false;
1773             }
1774             if (!parser_next(parser)) {
1775                 parseerror(parser, "expected builtin number");
1776                 return false;
1777             }
1778             if (parser->tok != TOKEN_INTCONST) {
1779                 parseerror(parser, "builtin number must be an integer constant");
1780                 return false;
1781             }
1782             if (parser_token(parser)->constval.i <= 0) {
1783                 parseerror(parser, "builtin number must be positive integer greater than zero");
1784                 return false;
1785             }
1786
1787             func->builtin = -parser_token(parser)->constval.i;
1788         } else if (parser->tok == '{') {
1789             /* function body */
1790             ast_block *block;
1791             ast_function *old = parser->function;
1792
1793             if (localblock) {
1794                 parseerror(parser, "cannot declare functions within functions");
1795                 return false;
1796             }
1797
1798             parser->function = func;
1799             block = parser_parse_block(parser);
1800             parser->function = old;
1801
1802             if (!block)
1803                 return false;
1804
1805             if (!ast_function_blocks_add(func, block)) {
1806                 ast_block_delete(block);
1807                 return false;
1808             }
1809
1810             if (parser->tok == ';')
1811                 return parser_next(parser) || parser->tok == TOKEN_EOF;
1812             else if (opts_standard == COMPILER_QCC)
1813                 parseerror(parser, "missing semicolon after function body (mandatory with -std=qcc)");
1814             return true;
1815         } else {
1816             parseerror(parser, "TODO, const assignment");
1817         }
1818
1819         if (!parser_next(parser))
1820             return false;
1821
1822         if (parser->tok == ',') {
1823             /* another */
1824             continue;
1825         }
1826
1827         if (parser->tok != ';') {
1828             parseerror(parser, "expected semicolon");
1829             return false;
1830         }
1831
1832         (void)parser_next(parser);
1833
1834         return true;
1835     }
1836 }
1837
1838 static bool parser_do(parser_t *parser)
1839 {
1840     if (parser->tok == TOKEN_TYPENAME)
1841     {
1842         return parser_variable(parser, NULL);
1843     }
1844     else if (parser->tok == TOKEN_KEYWORD)
1845     {
1846         /* handle 'var' and 'const' */
1847         return false;
1848     }
1849     else if (parser->tok == '.')
1850     {
1851         ast_value *var;
1852         ast_value *fld;
1853         bool       isfunc = false;
1854         int        basetype;
1855         lex_ctx    ctx = parser_ctx(parser);
1856         varentry_t varent;
1857
1858         /* entity-member declaration */
1859         if (!parser_next(parser) || parser->tok != TOKEN_TYPENAME) {
1860             parseerror(parser, "expected member variable definition");
1861             return false;
1862         }
1863
1864         /* remember the base/return type */
1865         basetype = parser_token(parser)->constval.t;
1866
1867         /* parse into the declaration */
1868         if (!parser_next(parser)) {
1869             parseerror(parser, "expected field def");
1870             return false;
1871         }
1872
1873         /* parse the field type fully */
1874         var = parser_parse_type(parser, basetype, &isfunc);
1875         if (!var)
1876             return false;
1877
1878         while (true) {
1879             /* now the field name */
1880             if (parser->tok != TOKEN_IDENT) {
1881                 parseerror(parser, "expected field name");
1882                 ast_delete(var);
1883                 return false;
1884             }
1885
1886             /* check for an existing field
1887              * in original qc we also have to check for an existing
1888              * global named like the field
1889              */
1890             if (opts_standard == COMPILER_QCC) {
1891                 if (parser_find_global(parser, parser_tokval(parser))) {
1892                     parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc");
1893                     ast_delete(var);
1894                     return false;
1895                 }
1896             }
1897             if (parser_find_field(parser, parser_tokval(parser))) {
1898                 parseerror(parser, "field %s already exists", parser_tokval(parser));
1899                 ast_delete(var);
1900                 return false;
1901             }
1902
1903             /* if it was a function, turn it into a function */
1904             if (isfunc) {
1905                 ast_value *fval;
1906                 /* turn var into a value of TYPE_FUNCTION, with the old var
1907                  * as return type
1908                  */
1909                 fval = ast_value_new(ctx, var->name, TYPE_FUNCTION);
1910                 if (!fval) {
1911                     ast_value_delete(var);
1912                     ast_value_delete(fval);
1913                     return false;
1914                 }
1915
1916                 fval->expression.next = (ast_expression*)var;
1917                 MEM_VECTOR_MOVE(&var->expression, params, &fval->expression, params);
1918
1919                 var = fval;
1920             }
1921
1922             /* turn it into a field */
1923             fld = ast_value_new(ctx, parser_tokval(parser), TYPE_FIELD);
1924             fld->expression.next = (ast_expression*)var;
1925
1926             varent.var = (ast_expression*)fld;
1927             varent.name = util_strdup(fld->name);
1928             (void)!parser_t_fields_add(parser, varent);
1929
1930             if (var->expression.vtype == TYPE_VECTOR)
1931             {
1932                 /* create _x, _y and _z fields as well */
1933                 size_t len;
1934                 varentry_t vx, vy, vz;
1935
1936                 len = strlen(varent.name);
1937                 vx.var = (ast_expression*)ast_member_new(ast_ctx(fld), (ast_expression*)fld, 0);
1938                 vy.var = (ast_expression*)ast_member_new(ast_ctx(fld), (ast_expression*)fld, 1);
1939                 vz.var = (ast_expression*)ast_member_new(ast_ctx(fld), (ast_expression*)fld, 2);
1940                 vx.name = mem_a(len+3);
1941                 vy.name = mem_a(len+3);
1942                 vz.name = mem_a(len+3);
1943                 memcpy(vx.name, varent.name, len);
1944                 memcpy(vy.name, varent.name, len);
1945                 memcpy(vz.name, varent.name, len);
1946                 vx.name[len] = vy.name[len] = vz.name[len] = '_';
1947                 vx.name[len+1] = 'x';
1948                 vy.name[len+1] = 'y';
1949                 vz.name[len+1] = 'z';
1950                 vx.name[len+2] = vy.name[len+2] = vz.name[len+2] = 0;
1951                 (void)!parser_t_fields_add(parser, vx);
1952                 (void)!parser_t_fields_add(parser, vy);
1953                 (void)!parser_t_fields_add(parser, vz);
1954             }
1955
1956             if (!parser_next(parser)) {
1957                 parseerror(parser, "expected semicolon or another field name");
1958                 return false;
1959             }
1960             if (parser->tok == ';')
1961                 break;
1962             if (parser->tok != ',' || !parser_next(parser)) {
1963                 parseerror(parser, "expected semicolon or another field name");
1964                 return false;
1965             }
1966         }
1967
1968         /* skip the semicolon */
1969         if (!parser_next(parser))
1970             return parser->tok == TOKEN_EOF;
1971
1972         return true;
1973     }
1974     else
1975     {
1976         parseerror(parser, "unexpected token: %s", parser->lex->tok->value);
1977         return false;
1978     }
1979     return true;
1980 }
1981
1982 static parser_t *parser;
1983
1984 bool parser_init()
1985 {
1986     parser = (parser_t*)mem_a(sizeof(parser_t));
1987     if (!parser)
1988         return false;
1989
1990     memset(parser, 0, sizeof(*parser));
1991     return true;
1992 }
1993
1994 bool parser_compile(const char *filename)
1995 {
1996     parser->lex = lex_open(filename);
1997     if (!parser->lex) {
1998         printf("failed to open file \"%s\"\n", filename);
1999         return false;
2000     }
2001
2002     /* initial lexer/parser state */
2003     parser->lex->flags.noops = true;
2004
2005     if (parser_next(parser))
2006     {
2007         while (parser->tok != TOKEN_EOF && parser->tok < TOKEN_ERROR)
2008         {
2009             if (!parser_do(parser)) {
2010                 if (parser->tok == TOKEN_EOF)
2011                     parseerror(parser, "unexpected eof");
2012                 else if (!parser->errors)
2013                     parseerror(parser, "parse error\n");
2014                 lex_close(parser->lex);
2015                 mem_d(parser);
2016                 return false;
2017             }
2018         }
2019     }
2020
2021     lex_close(parser->lex);
2022
2023     return !parser->errors;
2024 }
2025
2026 void parser_cleanup()
2027 {
2028     size_t i;
2029     for (i = 0; i < parser->functions_count; ++i) {
2030         ast_delete(parser->functions[i]);
2031     }
2032     for (i = 0; i < parser->imm_vector_count; ++i) {
2033         ast_delete(parser->imm_vector[i]);
2034     }
2035     for (i = 0; i < parser->imm_string_count; ++i) {
2036         ast_delete(parser->imm_string[i]);
2037     }
2038     for (i = 0; i < parser->imm_float_count; ++i) {
2039         ast_delete(parser->imm_float[i]);
2040     }
2041     for (i = 0; i < parser->globals_count; ++i) {
2042         ast_delete(parser->globals[i].var);
2043         mem_d(parser->globals[i].name);
2044     }
2045     MEM_VECTOR_CLEAR(parser, globals);
2046
2047     mem_d(parser);
2048 }
2049
2050 bool parser_finish(const char *output)
2051 {
2052     size_t i;
2053     ir_builder *ir;
2054
2055     if (!parser->errors)
2056     {
2057         ir = ir_builder_new("gmqcc_out");
2058         if (!ir) {
2059             printf("failed to allocate builder\n");
2060             return false;
2061         }
2062
2063         for (i = 0; i < parser->imm_float_count; ++i) {
2064             if (!ast_global_codegen(parser->imm_float[i], ir)) {
2065                 printf("failed to generate global %s\n", parser->imm_float[i]->name);
2066                 ir_builder_delete(ir);
2067                 return false;
2068             }
2069         }
2070         for (i = 0; i < parser->imm_string_count; ++i) {
2071             if (!ast_global_codegen(parser->imm_string[i], ir)) {
2072                 printf("failed to generate global %s\n", parser->imm_string[i]->name);
2073                 ir_builder_delete(ir);
2074                 return false;
2075             }
2076         }
2077         for (i = 0; i < parser->imm_vector_count; ++i) {
2078             if (!ast_global_codegen(parser->imm_vector[i], ir)) {
2079                 printf("failed to generate global %s\n", parser->imm_vector[i]->name);
2080                 ir_builder_delete(ir);
2081                 return false;
2082             }
2083         }
2084         for (i = 0; i < parser->fields_count; ++i) {
2085             ast_value *field;
2086             bool isconst;
2087             if (!ast_istype(parser->fields[i].var, ast_value))
2088                 continue;
2089             field = (ast_value*)parser->fields[i].var;
2090             isconst = field->isconst;
2091             field->isconst = false;
2092             if (!ast_global_codegen((ast_value*)field, ir)) {
2093                 printf("failed to generate field %s\n", field->name);
2094                 ir_builder_delete(ir);
2095                 return false;
2096             }
2097             if (isconst) {
2098                 ir_value *ifld;
2099                 ast_expression *subtype;
2100                 field->isconst = true;
2101                 subtype = field->expression.next;
2102                 ifld = ir_builder_create_field(ir, field->name, subtype->expression.vtype);
2103                 if (subtype->expression.vtype == TYPE_FIELD)
2104                     ifld->fieldtype = subtype->expression.next->expression.vtype;
2105                 else if (subtype->expression.vtype == TYPE_FUNCTION)
2106                     ifld->outtype = subtype->expression.next->expression.vtype;
2107                 (void)!ir_value_set_field(field->ir_v, ifld);
2108             }
2109         }
2110         for (i = 0; i < parser->globals_count; ++i) {
2111             if (!ast_istype(parser->globals[i].var, ast_value))
2112                 continue;
2113             if (!ast_global_codegen((ast_value*)(parser->globals[i].var), ir)) {
2114                 printf("failed to generate global %s\n", parser->globals[i].name);
2115                 ir_builder_delete(ir);
2116                 return false;
2117             }
2118         }
2119         for (i = 0; i < parser->functions_count; ++i) {
2120             if (!ast_function_codegen(parser->functions[i], ir)) {
2121                 printf("failed to generate function %s\n", parser->functions[i]->name);
2122                 ir_builder_delete(ir);
2123                 return false;
2124             }
2125             if (!ir_function_finalize(parser->functions[i]->ir_func)) {
2126                 printf("failed to finalize function %s\n", parser->functions[i]->name);
2127                 ir_builder_delete(ir);
2128                 return false;
2129             }
2130         }
2131
2132         if (opts_dump)
2133             ir_builder_dump(ir, printf);
2134
2135         if (!ir_builder_generate(ir, output)) {
2136             printf("*** failed to generate output file\n");
2137             ir_builder_delete(ir);
2138             return false;
2139         }
2140
2141         ir_builder_delete(ir);
2142         return true;
2143     }
2144
2145     printf("*** there were compile errors\n");
2146     return false;
2147 }