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 void parseerror(parser_t *parser, const char *fmt, ...)
  45 {
  46         va_list ap;
  47
  48         parser->errors++;
  49
  50     if (parser)
  51             printf("error %s:%lu: ", parser->lex->tok->ctx.file, (unsigned long)parser->lex->tok->ctx.line);
  52         else
  53             printf("error: ");
  54
  55         va_start(ap, fmt);
  56         vprintf(fmt, ap);
  57         va_end(ap);
  58
  59         printf("\n");
  60 }
  61
  62 bool parser_next(parser_t *parser)
  63 {
  64     /* lex_do kills the previous token */
  65     parser->tok = lex_do(parser->lex);
  66     if (parser->tok == TOKEN_EOF || parser->tok >= TOKEN_ERROR)
  67         return false;
  68     return true;
  69 }
  70
  71 /* lift a token out of the parser so it's not destroyed by parser_next */
  72 token *parser_lift(parser_t *parser)
  73 {
  74     token *tok = parser->lex->tok;
  75     parser->lex->tok = NULL;
  76     return tok;
  77 }
  78
  79 #define parser_tokval(p) (p->lex->tok->value)
  80 #define parser_token(p)  (p->lex->tok)
  81 #define parser_ctx(p)    (p->lex->tok->ctx)
  82
  83 ast_value* parser_const_float(parser_t *parser, double d)
  84 {
  85     size_t i;
  86     ast_value *out;
  87     for (i = 0; i < parser->imm_float_count; ++i) {
  88         if (parser->imm_float[i]->constval.vfloat == d)
  89             return parser->imm_float[i];
  90     }
  91     out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_FLOAT);
  92     out->isconst = true;
  93     out->constval.vfloat = d;
  94     if (!parser_t_imm_float_add(parser, out)) {
  95         ast_value_delete(out);
  96         return NULL;
  97     }
  98     return out;
  99 }
 100
 101 ast_value* parser_const_string(parser_t *parser, const char *str)
 102 {
 103     size_t i;
 104     ast_value *out;
 105     for (i = 0; i < parser->imm_string_count; ++i) {
 106         if (!strcmp(parser->imm_string[i]->constval.vstring, str))
 107             return parser->imm_string[i];
 108     }
 109     out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_STRING);
 110     out->isconst = true;
 111     out->constval.vstring = util_strdup(str);
 112     if (!parser_t_imm_string_add(parser, out)) {
 113         ast_value_delete(out);
 114         return NULL;
 115     }
 116     return out;
 117 }
 118
 119 ast_value* parser_const_vector(parser_t *parser, vector v)
 120 {
 121     size_t i;
 122     ast_value *out;
 123     for (i = 0; i < parser->imm_vector_count; ++i) {
 124         if (!memcmp(&parser->imm_vector[i]->constval.vvec, &v, sizeof(v)))
 125             return parser->imm_vector[i];
 126     }
 127     out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_VECTOR);
 128     out->isconst = true;
 129     out->constval.vvec = v;
 130     if (!parser_t_imm_vector_add(parser, out)) {
 131         ast_value_delete(out);
 132         return NULL;
 133     }
 134     return out;
 135 }
 136
 137 ast_expression* parser_find_field(parser_t *parser, const char *name)
 138 {
 139     size_t i;
 140     for (i = 0; i < parser->fields_count; ++i) {
 141         if (!strcmp(parser->fields[i].name, name))
 142             return parser->fields[i].var;
 143     }
 144     return NULL;
 145 }
 146
 147 ast_expression* parser_find_global(parser_t *parser, const char *name)
 148 {
 149     size_t i;
 150     for (i = 0; i < parser->globals_count; ++i) {
 151         if (!strcmp(parser->globals[i].name, name))
 152             return parser->globals[i].var;
 153     }
 154     return NULL;
 155 }
 156
 157 ast_expression* parser_find_local(parser_t *parser, const char *name, size_t upto)
 158 {
 159     size_t i;
 160     ast_value *fun;
 161     for (i = parser->locals_count; i > upto;) {
 162         --i;
 163         if (!strcmp(parser->locals[i].name, name))
 164             return parser->locals[i].var;
 165     }
 166     fun = parser->function->vtype;
 167     for (i = 0; i < fun->expression.params_count; ++i) {
 168         if (!strcmp(fun->expression.params[i]->name, name))
 169             return (ast_expression*)(fun->expression.params[i]);
 170     }
 171     return NULL;
 172 }
 173
 174 ast_expression* parser_find_var(parser_t *parser, const char *name)
 175 {
 176     ast_expression *v;
 177     v         = parser_find_local(parser, name, 0);
 178     if (!v) v = parser_find_global(parser, name);
 179     return v;
 180 }
 181
 182 typedef struct {
 183     MEM_VECTOR_MAKE(ast_value*, p);
 184 } paramlist_t;
 185 MEM_VEC_FUNCTIONS(paramlist_t, ast_value*, p)
 186
 187 static ast_value *parser_parse_type(parser_t *parser, int basetype, bool *isfunc)
 188 {
 189     paramlist_t params;
 190     ast_value *var;
 191     lex_ctx   ctx = parser_ctx(parser);
 192     int vtype = basetype;
 193     int temptype;
 194     size_t i;
 195
 196     MEM_VECTOR_INIT(&params, p);
 197
 198     *isfunc = false;
 199
 200     if (parser->tok == '(') {
 201         *isfunc = true;
 202         while (true) {
 203             ast_value *param;
 204             bool dummy;
 205
 206             if (!parser_next(parser))
 207                 goto on_error;
 208
 209             if (parser->tok == ')')
 210                 break;
 211
 212             temptype = parser_token(parser)->constval.t;
 213             if (!parser_next(parser))
 214                 goto on_error;
 215
 216             param = parser_parse_type(parser, temptype, &dummy);
 217             (void)dummy;
 218
 219             if (!param)
 220                 goto on_error;
 221
 222             if (parser->tok == TOKEN_IDENT) {
 223                 /* named parameter */
 224                 if (!ast_value_set_name(param, parser_tokval(parser)))
 225                     goto on_error;
 226                 if (!parser_next(parser))
 227                     goto on_error;
 228             }
 229
 230             if (!paramlist_t_p_add(&params, param)) {
 231                 parseerror(parser, "Out of memory while parsing typename");
 232                 goto on_error;
 233             }
 234
 235             if (parser->tok == ',')
 236                 continue;
 237             if (parser->tok == ')')
 238                 break;
 239             parseerror(parser, "Unexpected token");
 240             goto on_error;
 241         }
 242         if (!parser_next(parser))
 243             goto on_error;
 244     }
 245
 246     var = ast_value_new(ctx, "<unnamed>", vtype);
 247     if (!var)
 248         goto on_error;
 249     MEM_VECTOR_MOVE(&params, p, &var->expression, params);
 250     return var;
 251 on_error:
 252     for (i = 0; i < params.p_count; ++i)
 253         ast_value_delete(params.p[i]);
 254     MEM_VECTOR_CLEAR(&params, p);
 255     return NULL;
 256 }
 257
 258 typedef struct
 259 {
 260     size_t etype; /* 0 = expression, others are operators */
 261     int             paren;
 262     size_t          off;
 263     ast_expression *out;
 264     ast_block      *block; /* for commas and function calls */
 265     lex_ctx ctx;
 266 } sy_elem;
 267 typedef struct
 268 {
 269     MEM_VECTOR_MAKE(sy_elem, out);
 270     MEM_VECTOR_MAKE(sy_elem, ops);
 271 } shunt;
 272 MEM_VEC_FUNCTIONS(shunt, sy_elem, out)
 273 MEM_VEC_FUNCTIONS(shunt, sy_elem, ops)
 274
 275 static sy_elem syexp(lex_ctx ctx, ast_expression *v) {
 276     sy_elem e;
 277     e.etype = 0;
 278     e.out   = v;
 279     e.block = NULL;
 280     e.ctx   = ctx;
 281     e.paren = 0;
 282     return e;
 283 }
 284
 285 static sy_elem syblock(lex_ctx ctx, ast_block *v) {
 286     sy_elem e;
 287     e.etype = 0;
 288     e.out   = (ast_expression*)v;
 289     e.block = v;
 290     e.ctx   = ctx;
 291     e.paren = 0;
 292     return e;
 293 }
 294
 295 static sy_elem syop(lex_ctx ctx, const oper_info *op) {
 296     sy_elem e;
 297     e.etype = 1 + (op - operators);
 298     e.out   = NULL;
 299     e.block = NULL;
 300     e.ctx   = ctx;
 301     e.paren = 0;
 302     return e;
 303 }
 304
 305 static sy_elem syparen(lex_ctx ctx, int p, size_t off) {
 306     sy_elem e;
 307     e.etype = 0;
 308     e.off   = off;
 309     e.out   = NULL;
 310     e.block = NULL;
 311     e.ctx   = ctx;
 312     e.paren = p;
 313     return e;
 314 }
 315
 316 #ifdef DEBUGSHUNT
 317 # define DEBUGSHUNTDO(x) x
 318 #else
 319 # define DEBUGSHUNTDO(x)
 320 #endif
 321
 322 static bool parser_sy_pop(parser_t *parser, shunt *sy)
 323 {
 324     const oper_info *op;
 325     lex_ctx ctx;
 326     ast_expression *out = NULL;
 327     ast_expression *exprs[3];
 328     ast_block      *blocks[3];
 329     size_t i, assignop;
 330
 331     if (!sy->ops_count) {
 332         parseerror(parser, "internal error: missing operator");
 333         return false;
 334     }
 335
 336     if (sy->ops[sy->ops_count-1].paren) {
 337         parseerror(parser, "unmatched parenthesis");
 338         return false;
 339     }
 340
 341     op = &operators[sy->ops[sy->ops_count-1].etype - 1];
 342     ctx = sy->ops[sy->ops_count-1].ctx;
 343
 344     DEBUGSHUNTDO(printf("apply %s\n", op->op));
 345
 346     if (sy->out_count < op->operands) {
 347         parseerror(parser, "internal error: not enough operands: %i", sy->out_count);
 348         return false;
 349     }
 350
 351     sy->ops_count--;
 352
 353     sy->out_count -= op->operands;
 354     for (i = 0; i < op->operands; ++i) {
 355         exprs[i]  = sy->out[sy->out_count+i].out;
 356         blocks[i] = sy->out[sy->out_count+i].block;
 357     }
 358
 359     if (blocks[0] && !blocks[0]->exprs_count && op->id != opid1(',')) {
 360         parseerror(parser, "internal error: operator cannot be applied on empty blocks");
 361         return false;
 362     }
 363
 364     switch (op->id)
 365     {
 366         default:
 367             parseerror(parser, "internal error: unhandled operand");
 368             return false;
 369
 370         case opid1('.'):
 371             if (exprs[0]->expression.vtype == TYPE_ENTITY) {
 372                 if (exprs[1]->expression.vtype != TYPE_FIELD) {
 373                     parseerror(parser, "type error: right hand of member-operand should be an entity-field");
 374                     return false;
 375                 }
 376                 out = (ast_expression*)ast_entfield_new(ctx, exprs[0], exprs[1]);
 377             }
 378             else if (exprs[0]->expression.vtype == TYPE_VECTOR) {
 379                 parseerror(parser, "internal error: vector access is not supposed to be handled at this point");
 380                 return false;
 381             }
 382             else {
 383                 parseerror(parser, "type error: member-of operator on something that is not an entity or vector");
 384                 return false;
 385             }
 386             break;
 387
 388         case opid1(','):
 389             if (blocks[0]) {
 390                 if (!ast_block_exprs_add(blocks[0], exprs[1]))
 391                     return false;
 392             } else {
 393                 blocks[0] = ast_block_new(ctx);
 394                 if (!ast_block_exprs_add(blocks[0], exprs[0]) ||
 395                     !ast_block_exprs_add(blocks[0], exprs[1]))
 396                 {
 397                     return false;
 398                 }
 399             }
 400             if (!ast_block_set_type(blocks[0], exprs[1]))
 401                 return false;
 402
 403             sy->out[sy->out_count++] = syblock(ctx, blocks[0]);
 404             return true;
 405
 406         case opid1('+'):
 407             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) {
 408                 parseerror(parser, "Cannot add type %s and %s",
 409                            type_name[exprs[0]->expression.vtype],
 410                            type_name[exprs[1]->expression.vtype]);
 411                 return false;
 412             }
 413             if (exprs[0]->expression.vteyp != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) {
 414                 parseerror(parser, "type error: %s - %s not defined",
 415                            type_name[exprs[0]->expression.vtype],
 416                            type_name[exprs[1]->expression.vtype]);
 417                 return false;
 418             }
 419             switch (exprs[0]->expression.vtype) {
 420                 case TYPE_FLOAT:
 421                     out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_F, exprs[0], exprs[1]);
 422                     break;
 423                 case TYPE_VECTOR:
 424                     out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_V, exprs[0], exprs[1]);
 425                     break;
 426                 default:
 427                     parseerror(parser, "Cannot add type %s and %s",
 428                                type_name[exprs[0]->expression.vtype],
 429                                type_name[exprs[1]->expression.vtype]);
 430                     return false;
 431             };
 432             break;
 433         case opid1('-'):
 434             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) {
 435                 parseerror(parser, "Cannot subtract type %s from %s",
 436                            type_name[exprs[1]->expression.vtype],
 437                            type_name[exprs[0]->expression.vtype]);
 438                 return false;
 439             }
 440             if (exprs[0]->expression.vteyp != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) {
 441                 parseerror(parser, "type error: %s - %s not defined",
 442                            type_name[exprs[0]->expression.vtype],
 443                            type_name[exprs[1]->expression.vtype]);
 444                 return false;
 445             }
 446             switch (exprs[0]->expression.vtype) {
 447                 case TYPE_FLOAT:
 448                     out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F, exprs[0], exprs[1]);
 449                     break;
 450                 case TYPE_VECTOR:
 451                     out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V, exprs[0], exprs[1]);
 452                     break;
 453                 default:
 454                     parseerror(parser, "Cannot add type %s from %s",
 455                                type_name[exprs[1]->expression.vtype],
 456                                type_name[exprs[0]->expression.vtype]);
 457                     return false;
 458             };
 459             break;
 460         case opid1('*'):
 461             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype &&
 462                 exprs[0]->expression.vtype != TYPE_VECTOR &&
 463                 exprs[0]->expression.vtype != TYPE_FLOAT &&
 464                 exprs[1]->expression.vtype != TYPE_VECTOR &&
 465                 exprs[1]->expression.vtype != TYPE_FLOAT)
 466             {
 467                 parseerror(parser, "Cannot multiply type %s from %s",
 468                            type_name[exprs[1]->expression.vtype],
 469                            type_name[exprs[0]->expression.vtype]);
 470                 return false;
 471             }
 472             switch (exprs[0]->expression.vtype) {
 473                 case TYPE_FLOAT:
 474                     if (exprs[1]->expression.vtype == TYPE_VECTOR)
 475                         out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_FV, exprs[0], exprs[1]);
 476                     else
 477                         out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, exprs[0], exprs[1]);
 478                     break;
 479                 case TYPE_VECTOR:
 480                     if (exprs[1]->expression.vtype == TYPE_FLOAT)
 481                         out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_VF, exprs[0], exprs[1]);
 482                     else
 483                         out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_V, exprs[0], exprs[1]);
 484                     break;
 485                 default:
 486                     parseerror(parser, "Cannot add type %s from %s",
 487                                type_name[exprs[1]->expression.vtype],
 488                                type_name[exprs[0]->expression.vtype]);
 489                     return false;
 490             };
 491             break;
 492         case opid1('/'):
 493             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
 494                 exprs[0]->expression.vtype != TYPE_FLOAT)
 495             {
 496                 parseerror(parser, "Cannot divide types %s and %s",
 497                            type_name[exprs[0]->expression.vtype],
 498                            type_name[exprs[1]->expression.vtype]);
 499                 return false;
 500             }
 501             out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F, exprs[0], exprs[1]);
 502             break;
 503
 504
 505         case opid1('='):
 506             if (ast_istype(exprs[0], ast_entfield))
 507                 assignop = type_storep_instr[exprs[0]->expression.vtype];
 508             else
 509                 assignop = type_store_instr[exprs[0]->expression.vtype];
 510             out = (ast_expression*)ast_store_new(ctx, assignop, exprs[0], exprs[1]);
 511             break;
 512     }
 513
 514     if (!out) {
 515         parseerror(parser, "failed to apply operand %s", op->op);
 516         return false;
 517     }
 518
 519     DEBUGSHUNTDO(printf("applied %s\n", op->op));
 520     sy->out[sy->out_count++] = syexp(ctx, out);
 521     return true;
 522 }
 523
 524 static bool parser_close_call(parser_t *parser, shunt *sy)
 525 {
 526     /* was a function call */
 527     ast_expression *fun;
 528     ast_call       *call;
 529
 530     size_t          fid;
 531     size_t          paramcount;
 532
 533     sy->ops_count--;
 534     fid = sy->ops[sy->ops_count].off;
 535
 536     /* out[fid] is the function
 537      * everything above is parameters...
 538      * 0 params = nothing
 539      * 1 params = ast_expression
 540      * more = ast_block
 541      */
 542
 543     if (sy->out_count < 1 || sy->out_count <= fid) {
 544         parseerror(parser, "internal error: function call needs function and parameter list...");
 545         return false;
 546     }
 547
 548     fun = sy->out[fid].out;
 549
 550     call = ast_call_new(sy->ops[sy->ops_count].ctx, fun);
 551     if (!call) {
 552         parseerror(parser, "out of memory");
 553         return false;
 554     }
 555
 556     if (fid+1 == sy->out_count) {
 557         /* no arguments */
 558         paramcount = 0;
 559     } else if (fid+2 == sy->out_count) {
 560         ast_block *params;
 561         sy->out_count--;
 562         params = sy->out[sy->out_count].block;
 563         if (!params) {
 564             /* 1 param */
 565             paramcount = 1;
 566             if (!ast_call_params_add(call, sy->out[sy->out_count].out)) {
 567                 ast_delete(sy->out[sy->out_count].out);
 568                 parseerror(parser, "out of memory");
 569                 return false;
 570             }
 571         } else {
 572             paramcount = params->exprs_count;
 573             MEM_VECTOR_MOVE(params, exprs, call, params);
 574             ast_delete(params);
 575         }
 576     } else {
 577         parseerror(parser, "invalid function call");
 578         return false;
 579     }
 580
 581     /* overwrite fid, the function, with a call */
 582     sy->out[fid] = syexp(call->expression.node.context, (ast_expression*)call);
 583
 584     if (fun->expression.vtype != TYPE_FUNCTION) {
 585         parseerror(parser, "not a function");
 586         return false;
 587     }
 588
 589     if (!fun->expression.next) {
 590         parseerror(parser, "could not determine function return type");
 591         return false;
 592     } else {
 593         if (fun->expression.params_count != paramcount) {
 594             parseerror(parser, "expected %i parameters, got %i", (int)fun->expression.params_count, paramcount);
 595             return false;
 596         }
 597     }
 598
 599     return true;
 600 }
 601
 602 static bool parser_close_paren(parser_t *parser, shunt *sy, bool functions_only)
 603 {
 604     if (!sy->ops_count) {
 605         parseerror(parser, "unmatched closing paren");
 606         return false;
 607     }
 608     if (sy->ops[sy->ops_count-1].paren == 1) {
 609         parseerror(parser, "empty parenthesis expression");
 610         return false;
 611     }
 612     while (sy->ops_count) {
 613         if (sy->ops[sy->ops_count-1].paren == 'f') {
 614             if (!parser_close_call(parser, sy))
 615                 return false;
 616             break;
 617         }
 618         if (sy->ops[sy->ops_count-1].paren == 1) {
 619             sy->ops_count--;
 620             return !functions_only;
 621         }
 622         if (!parser_sy_pop(parser, sy))
 623             return false;
 624     }
 625     return true;
 626 }
 627
 628 static ast_expression* parser_expression(parser_t *parser)
 629 {
 630     ast_expression *expr = NULL;
 631     shunt sy;
 632     bool wantop = false;
 633     bool gotmemberof = false;
 634
 635     /* count the parens because an if starts with one, so the
 636      * end of a condition is an unmatched closing paren
 637      */
 638     int parens = 0;
 639
 640     MEM_VECTOR_INIT(&sy, out);
 641     MEM_VECTOR_INIT(&sy, ops);
 642
 643     while (true)
 644     {
 645         if (gotmemberof)
 646             gotmemberof = false;
 647         else
 648             parser->memberof = 0;
 649         if (!wantop)
 650         {
 651             bool nextwant = true;
 652             if (parser->tok == TOKEN_IDENT)
 653             {
 654                 /* variable */
 655                 ast_expression *var;
 656                 if (opts_standard == COMPILER_GMQCC)
 657                 {
 658                     if (parser->memberof == TYPE_ENTITY)
 659                         var = parser_find_field(parser, parser_tokval(parser));
 660                     else if (parser->memberof == TYPE_VECTOR)
 661                     {
 662                         parseerror(parser, "TODO: implement effective vector member access");
 663                         goto onerr;
 664                     }
 665                     else if (parser->memberof) {
 666                         parseerror(parser, "namespace for member not found");
 667                         goto onerr;
 668                     }
 669                     else
 670                         var = parser_find_var(parser, parser_tokval(parser));
 671                 } else {
 672                     var = parser_find_var(parser, parser_tokval(parser));
 673                     if (!var)
 674                         var = parser_find_field(parser, parser_tokval(parser));
 675                 }
 676                 if (!var) {
 677                     parseerror(parser, "unexpected ident: %s", parser_tokval(parser));
 678                     goto onerr;
 679                 }
 680                 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), var))) {
 681                     parseerror(parser, "out of memory");
 682                     goto onerr;
 683                 }
 684                 DEBUGSHUNTDO(printf("push %s\n", parser_tokval(parser)));
 685             }
 686             else if (parser->tok == TOKEN_FLOATCONST) {
 687                 ast_value *val = parser_const_float(parser, (parser_token(parser)->constval.f));
 688                 if (!val)
 689                     return false;
 690                 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) {
 691                     parseerror(parser, "out of memory");
 692                     goto onerr;
 693                 }
 694                 DEBUGSHUNTDO(printf("push %g\n", parser_token(parser)->constval.f));
 695             }
 696             else if (parser->tok == TOKEN_INTCONST) {
 697                 ast_value *val = parser_const_float(parser, (double)(parser_token(parser)->constval.i));
 698                 if (!val)
 699                     return false;
 700                 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) {
 701                     parseerror(parser, "out of memory");
 702                     goto onerr;
 703                 }
 704                 DEBUGSHUNTDO(printf("push %i\n", parser_token(parser)->constval.i));
 705             }
 706             else if (parser->tok == TOKEN_STRINGCONST) {
 707                 ast_value *val = parser_const_string(parser, parser_tokval(parser));
 708                 if (!val)
 709                     return false;
 710                 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) {
 711                     parseerror(parser, "out of memory");
 712                     goto onerr;
 713                 }
 714                 DEBUGSHUNTDO(printf("push string\n"));
 715             }
 716             else if (parser->tok == TOKEN_VECTORCONST) {
 717                 ast_value *val = parser_const_vector(parser, parser_token(parser)->constval.v);
 718                 if (!val)
 719                     return false;
 720                 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) {
 721                     parseerror(parser, "out of memory");
 722                     goto onerr;
 723                 }
 724                 DEBUGSHUNTDO(printf("push '%g %g %g'\n",
 725                                     parser_token(parser)->constval.v.x,
 726                                     parser_token(parser)->constval.v.y,
 727                                     parser_token(parser)->constval.v.z));
 728             }
 729             else if (parser->tok == '(') {
 730                 ++parens;
 731                 nextwant = false; /* not expecting an operator next */
 732                 if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 1, 0))) {
 733                     parseerror(parser, "out of memory");
 734                     goto onerr;
 735                 }
 736                 DEBUGSHUNTDO(printf("push (\n"));
 737             }
 738             else if (parser->tok == ')') {
 739                 DEBUGSHUNTDO(printf("do[nop] )\n"));
 740                 --parens;
 741                 if (parens < 0)
 742                     break;
 743                 /* allowed for function calls */
 744                 if (!parser_close_paren(parser, &sy, true))
 745                     goto onerr;
 746             }
 747             else {
 748                 /* TODO: prefix operators */
 749                 parseerror(parser, "expected statement");
 750                 goto onerr;
 751             }
 752             wantop = nextwant;
 753             parser->lex->flags.noops = !wantop;
 754         } else {
 755             bool nextwant = false;
 756             if (parser->tok == '(') {
 757                 DEBUGSHUNTDO(printf("push (\n"));
 758                 ++parens;
 759                 /* we expected an operator, this is the function-call operator */
 760                 if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 'f', sy.out_count-1))) {
 761                     parseerror(parser, "out of memory");
 762                     goto onerr;
 763                 }
 764             }
 765             else if (parser->tok == ')') {
 766                 DEBUGSHUNTDO(printf("do[op] )\n"));
 767                 --parens;
 768                 if (parens < 0)
 769                     break;
 770                 /* we do expect an operator next */
 771                 /* closing an opening paren */
 772                 if (!parser_close_paren(parser, &sy, false))
 773                     goto onerr;
 774                 nextwant = true;
 775             }
 776             else if (parser->tok != TOKEN_OPERATOR) {
 777                 parseerror(parser, "expected operator or end of statement");
 778                 goto onerr;
 779             }
 780             else {
 781                 /* classify the operator */
 782                 /* TODO: suffix operators */
 783                 const oper_info *op;
 784                 const oper_info *olast = NULL;
 785                 size_t o;
 786                 for (o = 0; o < operator_count; ++o) {
 787                     if (!(operators[o].flags & OP_PREFIX) &&
 788                         !(operators[o].flags & OP_SUFFIX) && /* remove this */
 789                         !strcmp(parser_tokval(parser), operators[o].op))
 790                     {
 791                         break;
 792                     }
 793                 }
 794                 if (o == operator_count) {
 795                     /* no operator found... must be the end of the statement */
 796                     break;
 797                 }
 798                 /* found an operator */
 799                 op = &operators[o];
 800                 if (op->id == opid1('.')) {
 801                     /* for gmqcc standard: open up the namespace of the previous type */
 802                     ast_expression *prevex = sy.out[sy.out_count-1].out;
 803                     if (!prevex) {
 804                         parseerror(parser, "unexpected member operator");
 805                         goto onerr;
 806                     }
 807                     if (prevex->expression.vtype == TYPE_ENTITY)
 808                         parser->memberof = TYPE_ENTITY;
 809                     else if (prevex->expression.vtype == TYPE_VECTOR)
 810                         parser->memberof = TYPE_VECTOR;
 811                     else {
 812                         parseerror(parser, "type error: type has no members");
 813                         goto onerr;
 814                     }
 815                     gotmemberof = true;
 816                 }
 817
 818                 if (sy.ops_count && !sy.ops[sy.ops_count-1].paren)
 819                     olast = &operators[sy.ops[sy.ops_count-1].etype-1];
 820
 821                 while (olast && (
 822                         (op->prec < olast->prec) ||
 823                         (op->assoc == ASSOC_LEFT && op->prec <= olast->prec) ) )
 824                 {
 825                     if (!parser_sy_pop(parser, &sy))
 826                         goto onerr;
 827                     if (sy.ops_count && !sy.ops[sy.ops_count-1].paren)
 828                         olast = &operators[sy.ops[sy.ops_count-1].etype-1];
 829                     else
 830                         olast = NULL;
 831                 }
 832
 833                 DEBUGSHUNTDO(printf("push operator %s\n", op->op));
 834                 if (!shunt_ops_add(&sy, syop(parser_ctx(parser), op)))
 835                     goto onerr;
 836             }
 837             wantop = nextwant;
 838             parser->lex->flags.noops = !wantop;
 839         }
 840         if (!parser_next(parser)) {
 841             goto onerr;
 842         }
 843         if (parser->tok == ';') {
 844             break;
 845         }
 846     }
 847     if (parens >= 0 && !parser_next(parser)) {
 848         parseerror(parser, "Unexpected end of file");
 849         goto onerr;
 850     }
 851
 852     while (sy.ops_count) {
 853         if (!parser_sy_pop(parser, &sy))
 854             goto onerr;
 855     }
 856
 857     parser->lex->flags.noops = true;
 858     if (!sy.out_count) {
 859         parseerror(parser, "empty expression");
 860         expr = NULL;
 861     } else
 862         expr = sy.out[0].out;
 863     MEM_VECTOR_CLEAR(&sy, out);
 864     MEM_VECTOR_CLEAR(&sy, ops);
 865     DEBUGSHUNTDO(printf("shut done\n"));
 866     return expr;
 867
 868 onerr:
 869     parser->lex->flags.noops = true;
 870     MEM_VECTOR_CLEAR(&sy, out);
 871     MEM_VECTOR_CLEAR(&sy, ops);
 872     return NULL;
 873 }
 874
 875 static bool parser_variable(parser_t *parser, ast_block *localblock);
 876 static ast_block* parser_parse_block(parser_t *parser);
 877 static ast_expression* parser_parse_statement_or_block(parser_t *parser);
 878 static bool parser_parse_statement(parser_t *parser, ast_block *block, ast_expression **out)
 879 {
 880     if (parser->tok == TOKEN_TYPENAME)
 881     {
 882         /* local variable */
 883         if (!block) {
 884             parseerror(parser, "cannot declare a variable from here");
 885             return false;
 886         }
 887         if (!parser_variable(parser, block))
 888             return false;
 889         *out = NULL;
 890         return true;
 891     }
 892     else if (parser->tok == TOKEN_KEYWORD)
 893     {
 894         if (!strcmp(parser_tokval(parser), "return"))
 895         {
 896             ast_expression *exp = NULL;
 897             ast_return     *ret = NULL;
 898             ast_value      *expected = parser->function->vtype;
 899
 900             if (!parser_next(parser)) {
 901                 parseerror(parser, "expected return expression");
 902                 return false;
 903             }
 904
 905             if (parser->tok != ';') {
 906                 exp = parser_expression(parser);
 907                 if (!exp)
 908                     return false;
 909
 910                 if (exp->expression.vtype != expected->expression.next->expression.vtype) {
 911                     parseerror(parser, "return with invalid expression");
 912                 }
 913
 914                 ret = ast_return_new(exp->expression.node.context, exp);
 915                 if (!ret) {
 916                     ast_delete(exp);
 917                     return false;
 918                 }
 919
 920                 *out = (ast_expression*)ret;
 921             } else if (!parser_next(parser)) {
 922                 parseerror(parser, "expected semicolon");
 923                 if (expected->expression.next->expression.vtype != TYPE_VOID) {
 924                     parseerror(parser, "return without value");
 925                 }
 926             }
 927             return true;
 928         }
 929         else if (!strcmp(parser_tokval(parser), "if"))
 930         {
 931             ast_ifthen *ifthen;
 932             ast_expression *cond, *ontrue, *onfalse = NULL;
 933
 934             lex_ctx ctx = parser_ctx(parser);
 935
 936             /* skip the 'if' and check for opening paren */
 937             if (!parser_next(parser) || parser->tok != '(') {
 938                 parseerror(parser, "expected 'if' condition in parenthesis");
 939                 return false;
 940             }
 941             /* parse into the expression */
 942             if (!parser_next(parser)) {
 943                 parseerror(parser, "expected 'if' condition after opening paren");
 944                 return false;
 945             }
 946             /* parse the condition */
 947             cond = parser_expression(parser);
 948             if (!cond)
 949                 return false;
 950             /* closing paren */
 951             if (parser->tok != ')') {
 952                 parseerror(parser, "expected closing paren after 'if' condition");
 953                 ast_delete(cond);
 954                 return false;
 955             }
 956             /* parse into the 'then' branch */
 957             if (!parser_next(parser)) {
 958                 parseerror(parser, "expected statement for on-true branch of 'if'");
 959                 ast_delete(cond);
 960                 return false;
 961             }
 962             ontrue = parser_parse_statement_or_block(parser);
 963             if (!ontrue) {
 964                 ast_delete(cond);
 965                 return false;
 966             }
 967             /* check for an else */
 968             if (!strcmp(parser_tokval(parser), "else")) {
 969                 /* parse into the 'else' branch */
 970                 if (!parser_next(parser)) {
 971                     parseerror(parser, "expected on-false branch after 'else'");
 972                     ast_delete(ontrue);
 973                     ast_delete(cond);
 974                     return false;
 975                 }
 976                 onfalse = parser_parse_statement_or_block(parser);
 977                 if (!onfalse) {
 978                     ast_delete(ontrue);
 979                     ast_delete(cond);
 980                     return false;
 981                 }
 982             }
 983
 984             ifthen = ast_ifthen_new(ctx, cond, ontrue, onfalse);
 985             *out = (ast_expression*)ifthen;
 986             return true;
 987         }
 988         parseerror(parser, "Unexpected keyword");
 989         return false;
 990     }
 991     else if (parser->tok == '{')
 992     {
 993         ast_block *inner;
 994         inner = parser_parse_block(parser);
 995         if (!inner)
 996             return false;
 997         *out = (ast_expression*)inner;
 998         return true;
 999     }
1000     else
1001     {
1002         ast_expression *exp = parser_expression(parser);
1003         if (!exp)
1004             return false;
1005         *out = exp;
1006         return true;
1007     }
1008 }
1009
1010 static void parser_pop_local(parser_t *parser)
1011 {
1012     parser->locals_count--;
1013     mem_d(parser->locals[parser->locals_count].name);
1014 }
1015
1016 static ast_block* parser_parse_block(parser_t *parser)
1017 {
1018     size_t oldblocklocal;
1019     ast_block *block = NULL;
1020
1021     oldblocklocal = parser->blocklocal;
1022     parser->blocklocal = parser->locals_count;
1023
1024     if (!parser_next(parser)) { /* skip the '{' */
1025         parseerror(parser, "expected function body");
1026         goto cleanup;
1027     }
1028
1029     block = ast_block_new(parser_ctx(parser));
1030
1031     while (parser->tok != TOKEN_EOF && parser->tok < TOKEN_ERROR)
1032     {
1033         ast_expression *expr;
1034         if (parser->tok == '}')
1035             break;
1036
1037         if (!parser_parse_statement(parser, block, &expr)) {
1038             ast_block_delete(block);
1039             block = NULL;
1040             goto cleanup;
1041         }
1042         if (!expr)
1043             continue;
1044         if (!ast_block_exprs_add(block, expr)) {
1045             ast_delete(expr);
1046             ast_block_delete(block);
1047             block = NULL;
1048             goto cleanup;
1049         }
1050     }
1051
1052     if (parser->tok != '}') {
1053         ast_block_delete(block);
1054         block = NULL;
1055     } else {
1056         (void)parser_next(parser);
1057     }
1058
1059 cleanup:
1060     while (parser->locals_count > parser->blocklocal)
1061         parser_pop_local(parser);
1062     parser->blocklocal = oldblocklocal;
1063     /* unroll the local vector */
1064     return block;
1065 }
1066
1067 static ast_expression* parser_parse_statement_or_block(parser_t *parser)
1068 {
1069     ast_expression *expr;
1070     if (parser->tok == '{')
1071         return (ast_expression*)parser_parse_block(parser);
1072     if (!parser_parse_statement(parser, NULL, &expr))
1073         return NULL;
1074     return expr;
1075 }
1076
1077 static bool parser_variable(parser_t *parser, ast_block *localblock)
1078 {
1079     bool          isfunc = false;
1080     ast_function *func = NULL;
1081     lex_ctx       ctx;
1082     ast_value    *var;
1083     varentry_t    varent;
1084
1085     int basetype = parser_token(parser)->constval.t;
1086
1087     while (true)
1088     {
1089         if (!parser_next(parser)) { /* skip basetype or comma */
1090             parseerror(parser, "expected variable declaration");
1091             return false;
1092         }
1093
1094         isfunc = false;
1095         func = NULL;
1096         ctx = parser_ctx(parser);
1097         var = parser_parse_type(parser, basetype, &isfunc);
1098
1099         if (!var)
1100             return false;
1101
1102         if (parser->tok != TOKEN_IDENT) {
1103             parseerror(parser, "expected variable name\n");
1104             return false;
1105         }
1106
1107         if (!localblock && parser_find_global(parser, parser_tokval(parser))) {
1108             ast_value_delete(var);
1109             parseerror(parser, "global already exists: %s\n", parser_tokval(parser));
1110             return false;
1111         }
1112
1113         if (localblock && parser_find_local(parser, parser_tokval(parser), parser->blocklocal)) {
1114             ast_value_delete(var);
1115             parseerror(parser, "local variable already exists: %s\n", parser_tokval(parser));
1116             return false;
1117         }
1118
1119         if (!ast_value_set_name(var, parser_tokval(parser))) {
1120             parseerror(parser, "failed to set variable name\n");
1121             ast_value_delete(var);
1122             return false;
1123         }
1124
1125         if (isfunc) {
1126             /* a function was defined */
1127             ast_value *fval;
1128
1129             /* turn var into a value of TYPE_FUNCTION, with the old var
1130              * as return type
1131              */
1132             fval = ast_value_new(ctx, var->name, TYPE_FUNCTION);
1133             func = ast_function_new(ctx, var->name, fval);
1134             if (!fval || !func) {
1135                 ast_value_delete(var);
1136                 if (fval) ast_value_delete(fval);
1137                 if (func) ast_function_delete(func);
1138                 return false;
1139             }
1140
1141             fval->expression.next = (ast_expression*)var;
1142             MEM_VECTOR_MOVE(&var->expression, params, &fval->expression, params);
1143
1144             if (!parser_t_functions_add(parser, func)) {
1145                 ast_value_delete(var);
1146                 if (fval) ast_value_delete(fval);
1147                 if (func) ast_function_delete(func);
1148                 return false;
1149             }
1150
1151             var = fval;
1152         }
1153
1154         varent.name = util_strdup(var->name);
1155         varent.var = (ast_expression*)var;
1156         if (var->expression.vtype == TYPE_VECTOR)
1157         {
1158             size_t len = strlen(varent.name);
1159             varentry_t vx, vy, vz;
1160             vx.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 0);
1161             vy.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 1);
1162             vz.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 2);
1163             vx.name = mem_a(len+3);
1164             vy.name = mem_a(len+3);
1165             vz.name = mem_a(len+3);
1166             strcpy(vx.name, varent.name);
1167             strcpy(vy.name, varent.name);
1168             strcpy(vz.name, varent.name);
1169             vx.name[len] = vy.name[len] = vz.name[len] = '_';
1170             vx.name[len+1] = 'x';
1171             vy.name[len+1] = 'y';
1172             vz.name[len+1] = 'z';
1173             vx.name[len+2] = vy.name[len+2] = vz.name[len+2] = 0;
1174
1175             if (!localblock) {
1176                 (void)!parser_t_globals_add(parser, varent);
1177                 (void)!parser_t_globals_add(parser, vx);
1178                 (void)!parser_t_globals_add(parser, vy);
1179                 (void)!parser_t_globals_add(parser, vz);
1180             } else {
1181                 (void)!parser_t_locals_add(parser, varent);
1182                 (void)!parser_t_locals_add(parser, vx);
1183                 (void)!parser_t_locals_add(parser, vy);
1184                 (void)!parser_t_locals_add(parser, vz);
1185             }
1186         }
1187         else
1188         {
1189             if ( (!localblock && !parser_t_globals_add(parser, varent)) ||
1190                  ( localblock && !parser_t_locals_add(parser, varent)) )
1191             {
1192                 ast_value_delete(var);
1193                 return false;
1194             }
1195         }
1196         if (localblock && !ast_block_locals_add(localblock, var))
1197         {
1198             parser_pop_local(parser);
1199             ast_value_delete(var);
1200             return false;
1201         }
1202
1203         if (!parser_next(parser)) {
1204             ast_value_delete(var);
1205             return false;
1206         }
1207
1208         if (parser->tok == ';') {
1209             if (!parser_next(parser))
1210                 return parser->tok == TOKEN_EOF;
1211             return true;
1212         }
1213
1214         if (parser->tok == ',') {
1215             /* another var */
1216             continue;
1217         }
1218
1219         if (parser->tok != '=') {
1220             parseerror(parser, "expected '=' or ';'");
1221             return false;
1222         }
1223
1224         if (!parser_next(parser))
1225             return false;
1226
1227         if (parser->tok == '#') {
1228             if (localblock) {
1229                 parseerror(parser, "cannot declare builtins within functions");
1230                 return false;
1231             }
1232             if (!isfunc || !func) {
1233                 parseerror(parser, "unexpected builtin number, '%s' is not a function", var->name);
1234                 return false;
1235             }
1236             if (!parser_next(parser)) {
1237                 parseerror(parser, "expected builtin number");
1238                 return false;
1239             }
1240             if (parser->tok != TOKEN_INTCONST) {
1241                 parseerror(parser, "builtin number must be an integer constant");
1242                 return false;
1243             }
1244             if (parser_token(parser)->constval.i <= 0) {
1245                 parseerror(parser, "builtin number must be positive integer greater than zero");
1246                 return false;
1247             }
1248
1249             func->builtin = -parser_token(parser)->constval.i;
1250         } else if (parser->tok == '{') {
1251             /* function body */
1252             ast_block *block;
1253             ast_function *old = parser->function;
1254
1255             if (localblock) {
1256                 parseerror(parser, "cannot declare functions within functions");
1257                 return false;
1258             }
1259
1260             parser->function = func;
1261             block = parser_parse_block(parser);
1262             parser->function = old;
1263
1264             if (!block)
1265                 return false;
1266
1267             if (!ast_function_blocks_add(func, block)) {
1268                 ast_block_delete(block);
1269                 return false;
1270             }
1271             return true;
1272         } else {
1273             parseerror(parser, "TODO, const assignment");
1274         }
1275
1276         if (!parser_next(parser))
1277             return false;
1278
1279         if (parser->tok == ',') {
1280             /* another */
1281             continue;
1282         }
1283
1284         if (parser->tok != ';') {
1285             parseerror(parser, "expected semicolon");
1286             return false;
1287         }
1288
1289         (void)parser_next(parser);
1290
1291         return true;
1292     }
1293 }
1294
1295 static bool parser_do(parser_t *parser)
1296 {
1297     if (parser->tok == TOKEN_TYPENAME)
1298     {
1299         return parser_variable(parser, NULL);
1300     }
1301     else if (parser->tok == TOKEN_KEYWORD)
1302     {
1303         /* handle 'var' and 'const' */
1304         return false;
1305     }
1306     else if (parser->tok == '.')
1307     {
1308         ast_value *var;
1309         ast_value *fld;
1310         bool       isfunc = false;
1311         int        basetype;
1312         lex_ctx    ctx = parser_ctx(parser);
1313         varentry_t varent;
1314
1315         /* entity-member declaration */
1316         if (!parser_next(parser) || parser->tok != TOKEN_TYPENAME) {
1317             parseerror(parser, "expected member variable definition");
1318             return false;
1319         }
1320
1321         /* remember the base/return type */
1322         basetype = parser_token(parser)->constval.t;
1323
1324         /* parse into the declaration */
1325         if (!parser_next(parser)) {
1326             parseerror(parser, "expected field def");
1327             return false;
1328         }
1329
1330         /* parse the field type fully */
1331         var = parser_parse_type(parser, basetype, &isfunc);
1332         if (!var)
1333             return false;
1334
1335         /* now the field name */
1336         if (parser->tok != TOKEN_IDENT) {
1337             parseerror(parser, "expected field name");
1338             ast_delete(var);
1339             return false;
1340         }
1341
1342         /* check for an existing field
1343          * in original qc we also have to check for an existing
1344          * global named like the field
1345          */
1346         if (opts_standard == COMPILER_QCC) {
1347             if (parser_find_global(parser, parser_tokval(parser))) {
1348                 parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc");
1349                 ast_delete(var);
1350                 return false;
1351             }
1352         }
1353         if (parser_find_field(parser, parser_tokval(parser))) {
1354             parseerror(parser, "field %s already exists", parser_tokval(parser));
1355             ast_delete(var);
1356             return false;
1357         }
1358
1359         /* if it was a function, turn it into a function */
1360         if (isfunc) {
1361             ast_value *fval;
1362             /* turn var into a value of TYPE_FUNCTION, with the old var
1363              * as return type
1364              */
1365             fval = ast_value_new(ctx, var->name, TYPE_FUNCTION);
1366             if (!fval) {
1367                 ast_value_delete(var);
1368                 ast_value_delete(fval);
1369                 return false;
1370             }
1371
1372             fval->expression.next = (ast_expression*)var;
1373             MEM_VECTOR_MOVE(&var->expression, params, &fval->expression, params);
1374
1375             var = fval;
1376         }
1377
1378         /* turn it into a field */
1379         fld = ast_value_new(ctx, parser_tokval(parser), TYPE_FIELD);
1380         fld->expression.next = (ast_expression*)var;
1381
1382         varent.var = (ast_expression*)fld;
1383         if (var->expression.vtype == TYPE_VECTOR)
1384         {
1385             /* create _x, _y and _z fields as well */
1386             parseerror(parser, "TODO: vector field members (_x,_y,_z)");
1387             ast_delete(fld);
1388             return false;
1389         }
1390
1391         varent.name = util_strdup(fld->name);
1392         (void)!parser_t_fields_add(parser, varent);
1393
1394         /* end with a semicolon */
1395         if (!parser_next(parser) || parser->tok != ';') {
1396             parseerror(parser, "semicolon expected");
1397             return false;
1398         }
1399
1400         /* skip the semicolon */
1401         if (!parser_next(parser))
1402             return parser->tok == TOKEN_EOF;
1403
1404         return true;
1405     }
1406     else
1407     {
1408         parseerror(parser, "unexpected token: %s", parser->lex->tok->value);
1409         return false;
1410     }
1411     return true;
1412 }
1413
1414 static parser_t *parser;
1415
1416 bool parser_init()
1417 {
1418     parser = (parser_t*)mem_a(sizeof(parser_t));
1419     if (!parser)
1420         return false;
1421
1422     memset(parser, 0, sizeof(parser));
1423
1424     MEM_VECTOR_INIT(parser, globals);
1425     MEM_VECTOR_INIT(parser, locals);
1426     return true;
1427 }
1428
1429 bool parser_compile(const char *filename)
1430 {
1431     parser->lex = lex_open(filename);
1432     if (!parser->lex) {
1433         printf("failed to open file \"%s\"\n", filename);
1434         return false;
1435     }
1436
1437     /* initial lexer/parser state */
1438     parser->lex->flags.noops = true;
1439
1440     if (parser_next(parser))
1441     {
1442         while (parser->tok != TOKEN_EOF && parser->tok < TOKEN_ERROR)
1443         {
1444             if (!parser_do(parser)) {
1445                 if (parser->tok == TOKEN_EOF)
1446                     parseerror(parser, "unexpected eof");
1447                 else
1448                     parseerror(parser, "parse error\n");
1449                 lex_close(parser->lex);
1450                 mem_d(parser);
1451                 return false;
1452             }
1453         }
1454     }
1455
1456     lex_close(parser->lex);
1457
1458     return !parser->errors;
1459 }
1460
1461 void parser_cleanup()
1462 {
1463     size_t i;
1464     for (i = 0; i < parser->functions_count; ++i) {
1465         ast_delete(parser->functions[i]);
1466     }
1467     for (i = 0; i < parser->imm_vector_count; ++i) {
1468         ast_delete(parser->imm_vector[i]);
1469     }
1470     for (i = 0; i < parser->imm_string_count; ++i) {
1471         ast_delete(parser->imm_string[i]);
1472     }
1473     for (i = 0; i < parser->imm_float_count; ++i) {
1474         ast_delete(parser->imm_float[i]);
1475     }
1476     for (i = 0; i < parser->globals_count; ++i) {
1477         ast_delete(parser->globals[i].var);
1478         mem_d(parser->globals[i].name);
1479     }
1480     MEM_VECTOR_CLEAR(parser, globals);
1481
1482     mem_d(parser);
1483 }
1484
1485 bool parser_finish(const char *output)
1486 {
1487     size_t i;
1488     ir_builder *ir;
1489
1490     if (!parser->errors)
1491     {
1492         ir = ir_builder_new("gmqcc_out");
1493         if (!ir) {
1494             printf("failed to allocate builder\n");
1495             return false;
1496         }
1497
1498         for (i = 0; i < parser->imm_float_count; ++i) {
1499             if (!ast_global_codegen(parser->imm_float[i], ir)) {
1500                 printf("failed to generate global %s\n", parser->imm_float[i]->name);
1501                 ir_builder_delete(ir);
1502                 return false;
1503             }
1504         }
1505         for (i = 0; i < parser->imm_string_count; ++i) {
1506             if (!ast_global_codegen(parser->imm_string[i], ir)) {
1507                 printf("failed to generate global %s\n", parser->imm_string[i]->name);
1508                 ir_builder_delete(ir);
1509                 return false;
1510             }
1511         }
1512         for (i = 0; i < parser->imm_vector_count; ++i) {
1513             if (!ast_global_codegen(parser->imm_vector[i], ir)) {
1514                 printf("failed to generate global %s\n", parser->imm_vector[i]->name);
1515                 ir_builder_delete(ir);
1516                 return false;
1517             }
1518         }
1519         for (i = 0; i < parser->fields_count; ++i) {
1520             ast_value *field;
1521             bool isconst;
1522             if (!ast_istype(parser->fields[i].var, ast_value))
1523                 continue;
1524             field = (ast_value*)parser->fields[i].var;
1525             isconst = field->isconst;
1526             field->isconst = false;
1527             if (!ast_global_codegen((ast_value*)field, ir)) {
1528                 printf("failed to generate field %s\n", field->name);
1529                 ir_builder_delete(ir);
1530                 return false;
1531             }
1532             if (isconst) {
1533                 ir_value *ifld;
1534                 ast_expression *subtype;
1535                 field->isconst = true;
1536                 subtype = field->expression.next;
1537                 ifld = ir_builder_create_field(ir, field->name, subtype->expression.vtype);
1538                 if (subtype->expression.vtype == TYPE_FIELD)
1539                     ifld->fieldtype = subtype->expression.next->expression.vtype;
1540                 else if (subtype->expression.vtype == TYPE_FUNCTION)
1541                     ifld->outtype = subtype->expression.next->expression.vtype;
1542                 (void)!ir_value_set_field(field->ir_v, ifld);
1543             }
1544         }
1545         for (i = 0; i < parser->globals_count; ++i) {
1546             if (!ast_istype(parser->globals[i].var, ast_value))
1547                 continue;
1548             if (!ast_global_codegen((ast_value*)(parser->globals[i].var), ir)) {
1549                 printf("failed to generate global %s\n", parser->globals[i].name);
1550                 ir_builder_delete(ir);
1551                 return false;
1552             }
1553         }
1554         for (i = 0; i < parser->functions_count; ++i) {
1555             if (!ast_function_codegen(parser->functions[i], ir)) {
1556                 printf("failed to generate function %s\n", parser->functions[i]->name);
1557                 ir_builder_delete(ir);
1558                 return false;
1559             }
1560             if (!ir_function_finalize(parser->functions[i]->ir_func)) {
1561                 printf("failed to finalize function %s\n", parser->functions[i]->name);
1562                 ir_builder_delete(ir);
1563                 return false;
1564             }
1565         }
1566
1567         ir_builder_dump(ir, printf);
1568
1569         if (!ir_builder_generate(ir, output)) {
1570             printf("*** failed to generate output file\n");
1571             ir_builder_delete(ir);
1572             return false;
1573         }
1574
1575         ir_builder_delete(ir);
1576         return true;
1577     }
1578
1579     printf("*** there were compile errors\n");
1580     return false;
1581 }