5aa980d5ef0c315e1d3bb6b039ebc159821c5a6f
[xonotic/gmqcc.git] / parser.c
1 /*
2  * Copyright (C) 2012
3  *     Wolfgang Bumiller
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining a copy of
6  * this software and associated documentation files (the "Software"), to deal in
7  * the Software without restriction, including without limitation the rights to
8  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
9  * of the Software, and to permit persons to whom the Software is furnished to do
10  * so, subject to the following conditions:
11  *
12  * The above copyright notice and this permission notice shall be included in all
13  * copies or substantial portions of the Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21  * SOFTWARE.
22  */
23 #include <stdio.h>
24 #include <stdarg.h>
25
26 #include "gmqcc.h"
27 #include "lexer.h"
28
29 /* beginning of locals */
30 #define PARSER_HT_LOCALS  2
31
32 #define PARSER_HT_SIZE    1024
33 #define TYPEDEF_HT_SIZE   16
34
35 enum parser_pot { POT_PAREN, POT_TERNARY1, POT_TERNARY2 };
36 typedef struct {
37     lex_file *lex;
38     int      tok;
39
40     ast_expression **globals;
41     ast_expression **fields;
42     ast_function **functions;
43     ast_value    **imm_float;
44     ast_value    **imm_string;
45     ast_value    **imm_vector;
46     size_t         translated;
47
48     /* must be deleted first, they reference immediates and values */
49     ast_value    **accessors;
50
51     ast_value *imm_float_zero;
52     ast_value *imm_float_one;
53     ast_value *imm_vector_zero;
54     ast_value *nil;
55
56     size_t crc_globals;
57     size_t crc_fields;
58
59     ast_function *function;
60
61     /* All the labels the function defined...
62      * Should they be in ast_function instead?
63      */
64     ast_label  **labels;
65     ast_goto   **gotos;
66     const char **breaks;
67     const char **continues;
68
69     /* A list of hashtables for each scope */
70     ht *variables;
71     ht htfields;
72     ht htglobals;
73     ht *typedefs;
74
75     /* not to be used directly, we use the hash table */
76     ast_expression **_locals;
77     size_t          *_blocklocals;
78     ast_value      **_typedefs;
79     size_t          *_blocktypedefs;
80     lex_ctx         *_block_ctx;
81
82     /* we store the '=' operator info */
83     const oper_info *assign_op;
84
85     /* TYPE_FIELD -> parser_find_fields is used instead of find_var
86      * TODO: TYPE_VECTOR -> x, y and z are accepted in the gmqcc standard
87      * anything else: type error
88      */
89     qcint  memberof;
90
91     /* Keep track of our ternary vs parenthesis nesting state.
92      * If we reach a 'comma' operator in a ternary without a paren,
93      * we shall trigger -Wternary-precedence.
94      */
95     enum parser_pot *pot;
96
97     /* pragma flags */
98     bool noref;
99 } parser_t;
100
101 static const ast_expression *intrinsic_debug_typestring = (ast_expression*)0x10;
102
103 static void parser_enterblock(parser_t *parser);
104 static bool parser_leaveblock(parser_t *parser);
105 static void parser_addlocal(parser_t *parser, const char *name, ast_expression *e);
106 static bool parse_typedef(parser_t *parser);
107 static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, int qualifier, ast_value *cached_typedef, bool noref, bool is_static, uint32_t qflags);
108 static ast_block* parse_block(parser_t *parser);
109 static bool parse_block_into(parser_t *parser, ast_block *block);
110 static bool parse_statement_or_block(parser_t *parser, ast_expression **out);
111 static bool parse_statement(parser_t *parser, ast_block *block, ast_expression **out, bool allow_cases);
112 static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma);
113 static ast_expression* parse_expression(parser_t *parser, bool stopatcomma);
114
115 static void parseerror(parser_t *parser, const char *fmt, ...)
116 {
117     va_list ap;
118     va_start(ap, fmt);
119     vcompile_error(parser->lex->tok.ctx, fmt, ap);
120     va_end(ap);
121 }
122
123 /* returns true if it counts as an error */
124 static bool GMQCC_WARN parsewarning(parser_t *parser, int warntype, const char *fmt, ...)
125 {
126     bool    r;
127     va_list ap;
128     va_start(ap, fmt);
129     r = vcompile_warning(parser->lex->tok.ctx, warntype, fmt, ap);
130     va_end(ap);
131     return r;
132 }
133
134 static bool GMQCC_WARN genwarning(lex_ctx ctx, int warntype, const char *fmt, ...)
135 {
136     bool    r;
137     va_list ap;
138     va_start(ap, fmt);
139     r = vcompile_warning(ctx, warntype, fmt, ap);
140     va_end(ap);
141     return r;
142 }
143
144 /**********************************************************************
145  * some maths used for constant folding
146  */
147
148 vector vec3_add(vector a, vector b)
149 {
150     vector out;
151     out.x = a.x + b.x;
152     out.y = a.y + b.y;
153     out.z = a.z + b.z;
154     return out;
155 }
156
157 vector vec3_sub(vector a, vector b)
158 {
159     vector out;
160     out.x = a.x - b.x;
161     out.y = a.y - b.y;
162     out.z = a.z - b.z;
163     return out;
164 }
165
166 qcfloat vec3_mulvv(vector a, vector b)
167 {
168     return (a.x * b.x + a.y * b.y + a.z * b.z);
169 }
170
171 vector vec3_mulvf(vector a, float b)
172 {
173     vector out;
174     out.x = a.x * b;
175     out.y = a.y * b;
176     out.z = a.z * b;
177     return out;
178 }
179
180 /**********************************************************************
181  * parsing
182  */
183
184 bool parser_next(parser_t *parser)
185 {
186     /* lex_do kills the previous token */
187     parser->tok = lex_do(parser->lex);
188     if (parser->tok == TOKEN_EOF)
189         return true;
190     if (parser->tok >= TOKEN_ERROR) {
191         parseerror(parser, "lex error");
192         return false;
193     }
194     return true;
195 }
196
197 #define parser_tokval(p) ((p)->lex->tok.value)
198 #define parser_token(p)  (&((p)->lex->tok))
199 #define parser_ctx(p)    ((p)->lex->tok.ctx)
200
201 static ast_value* parser_const_float(parser_t *parser, double d)
202 {
203     size_t i;
204     ast_value *out;
205     for (i = 0; i < vec_size(parser->imm_float); ++i) {
206         const double compare = parser->imm_float[i]->constval.vfloat;
207         if (memcmp((const void*)&compare, (const void *)&d, sizeof(double)) == 0)
208             return parser->imm_float[i];
209     }
210     out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_FLOAT);
211     out->cvq      = CV_CONST;
212     out->hasvalue = true;
213     out->constval.vfloat = d;
214     vec_push(parser->imm_float, out);
215     return out;
216 }
217
218 static ast_value* parser_const_float_0(parser_t *parser)
219 {
220     if (!parser->imm_float_zero)
221         parser->imm_float_zero = parser_const_float(parser, 0);
222     return parser->imm_float_zero;
223 }
224
225 static ast_value* parser_const_float_1(parser_t *parser)
226 {
227     if (!parser->imm_float_one)
228         parser->imm_float_one = parser_const_float(parser, 1);
229     return parser->imm_float_one;
230 }
231
232 static char *parser_strdup(const char *str)
233 {
234     if (str && !*str) {
235         /* actually dup empty strings */
236         char *out = (char*)mem_a(1);
237         *out = 0;
238         return out;
239     }
240     return util_strdup(str);
241 }
242
243 static ast_value* parser_const_string(parser_t *parser, const char *str, bool dotranslate)
244 {
245     size_t i;
246     ast_value *out;
247     for (i = 0; i < vec_size(parser->imm_string); ++i) {
248         if (!strcmp(parser->imm_string[i]->constval.vstring, str))
249             return parser->imm_string[i];
250     }
251     if (dotranslate) {
252         char name[32];
253         snprintf(name, sizeof(name), "dotranslate_%lu", (unsigned long)(parser->translated++));
254         out = ast_value_new(parser_ctx(parser), name, TYPE_STRING);
255     } else
256         out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_STRING);
257     out->cvq      = CV_CONST;
258     out->hasvalue = true;
259     out->constval.vstring = parser_strdup(str);
260     vec_push(parser->imm_string, out);
261     return out;
262 }
263
264 static ast_value* parser_const_vector(parser_t *parser, vector v)
265 {
266     size_t i;
267     ast_value *out;
268     for (i = 0; i < vec_size(parser->imm_vector); ++i) {
269         if (!memcmp(&parser->imm_vector[i]->constval.vvec, &v, sizeof(v)))
270             return parser->imm_vector[i];
271     }
272     out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_VECTOR);
273     out->cvq      = CV_CONST;
274     out->hasvalue = true;
275     out->constval.vvec = v;
276     vec_push(parser->imm_vector, out);
277     return out;
278 }
279
280 static ast_value* parser_const_vector_f(parser_t *parser, float x, float y, float z)
281 {
282     vector v;
283     v.x = x;
284     v.y = y;
285     v.z = z;
286     return parser_const_vector(parser, v);
287 }
288
289 static ast_value* parser_const_vector_0(parser_t *parser)
290 {
291     if (!parser->imm_vector_zero)
292         parser->imm_vector_zero = parser_const_vector_f(parser, 0, 0, 0);
293     return parser->imm_vector_zero;
294 }
295
296 static ast_expression* parser_find_field(parser_t *parser, const char *name)
297 {
298     return ( ast_expression*)util_htget(parser->htfields, name);
299 }
300
301 static ast_expression* parser_find_global(parser_t *parser, const char *name)
302 {
303     return (ast_expression*)util_htget(parser->htglobals, name);
304 }
305
306 static ast_expression* parser_find_param(parser_t *parser, const char *name)
307 {
308     size_t i;
309     ast_value *fun;
310     if (!parser->function)
311         return NULL;
312     fun = parser->function->vtype;
313     for (i = 0; i < vec_size(fun->expression.params); ++i) {
314         if (!strcmp(fun->expression.params[i]->name, name))
315             return (ast_expression*)(fun->expression.params[i]);
316     }
317     return NULL;
318 }
319
320 static ast_expression* parser_find_local(parser_t *parser, const char *name, size_t upto, bool *isparam)
321 {
322     size_t          i, hash;
323     ast_expression *e;
324
325     hash = util_hthash(parser->htglobals, name);
326
327     *isparam = false;
328     for (i = vec_size(parser->variables); i > upto;) {
329         --i;
330         if ( (e = (ast_expression*)util_htgeth(parser->variables[i], name, hash)) )
331             return e;
332     }
333     *isparam = true;
334     return parser_find_param(parser, name);
335 }
336
337 static ast_expression* parser_find_var(parser_t *parser, const char *name)
338 {
339     bool dummy;
340     ast_expression *v;
341     v         = parser_find_local(parser, name, 0, &dummy);
342     if (!v) v = parser_find_global(parser, name);
343     return v;
344 }
345
346 static ast_value* parser_find_typedef(parser_t *parser, const char *name, size_t upto)
347 {
348     size_t     i, hash;
349     ast_value *e;
350     hash = util_hthash(parser->typedefs[0], name);
351
352     for (i = vec_size(parser->typedefs); i > upto;) {
353         --i;
354         if ( (e = (ast_value*)util_htgeth(parser->typedefs[i], name, hash)) )
355             return e;
356     }
357     return NULL;
358 }
359
360 typedef struct
361 {
362     size_t etype; /* 0 = expression, others are operators */
363     int             paren;
364     size_t          off;
365     ast_expression *out;
366     ast_block      *block; /* for commas and function calls */
367     lex_ctx ctx;
368 } sy_elem;
369 typedef struct
370 {
371     sy_elem *out;
372     sy_elem *ops;
373 } shunt;
374
375 #define SY_PAREN_EXPR '('
376 #define SY_PAREN_FUNC 'f'
377 #define SY_PAREN_INDEX '['
378 #define SY_PAREN_TERNARY '?'
379
380 static sy_elem syexp(lex_ctx ctx, ast_expression *v) {
381     sy_elem e;
382     e.etype = 0;
383     e.off   = 0;
384     e.out   = v;
385     e.block = NULL;
386     e.ctx   = ctx;
387     e.paren = 0;
388     return e;
389 }
390
391 static sy_elem syblock(lex_ctx ctx, ast_block *v) {
392     sy_elem e;
393     e.etype = 0;
394     e.off   = 0;
395     e.out   = (ast_expression*)v;
396     e.block = v;
397     e.ctx   = ctx;
398     e.paren = 0;
399     return e;
400 }
401
402 static sy_elem syop(lex_ctx ctx, const oper_info *op) {
403     sy_elem e;
404     e.etype = 1 + (op - operators);
405     e.off   = 0;
406     e.out   = NULL;
407     e.block = NULL;
408     e.ctx   = ctx;
409     e.paren = 0;
410     return e;
411 }
412
413 static sy_elem syparen(lex_ctx ctx, int p, size_t off) {
414     sy_elem e;
415     e.etype = 0;
416     e.off   = off;
417     e.out   = NULL;
418     e.block = NULL;
419     e.ctx   = ctx;
420     e.paren = p;
421     return e;
422 }
423
424 #ifdef DEBUGSHUNT
425 # define DEBUGSHUNTDO(x) x
426 #else
427 # define DEBUGSHUNTDO(x)
428 #endif
429
430 /* With regular precedence rules, ent.foo[n] is the same as (ent.foo)[n],
431  * so we need to rotate it to become ent.(foo[n]).
432  */
433 static bool rotate_entfield_array_index_nodes(ast_expression **out)
434 {
435     ast_array_index *index;
436     ast_entfield    *entfield;
437
438     ast_value       *field;
439     ast_expression  *sub;
440     ast_expression  *entity;
441
442     lex_ctx ctx = ast_ctx(*out);
443
444     if (!ast_istype(*out, ast_array_index))
445         return false;
446     index = (ast_array_index*)*out;
447
448     if (!ast_istype(index->array, ast_entfield))
449         return false;
450     entfield = (ast_entfield*)index->array;
451
452     if (!ast_istype(entfield->field, ast_value))
453         return false;
454     field = (ast_value*)entfield->field;
455
456     sub    = index->index;
457     entity = entfield->entity;
458
459     ast_delete(index);
460
461     index = ast_array_index_new(ctx, (ast_expression*)field, sub);
462     entfield = ast_entfield_new(ctx, entity, (ast_expression*)index);
463     *out = (ast_expression*)entfield;
464
465     return true;
466 }
467
468 static bool immediate_is_true(lex_ctx ctx, ast_value *v)
469 {
470     switch (v->expression.vtype) {
471         case TYPE_FLOAT:
472             return !!v->constval.vfloat;
473         case TYPE_INTEGER:
474             return !!v->constval.vint;
475         case TYPE_VECTOR:
476             if (OPTS_FLAG(CORRECT_LOGIC))
477                 return v->constval.vvec.x &&
478                        v->constval.vvec.y &&
479                        v->constval.vvec.z;
480             else
481                 return !!(v->constval.vvec.x);
482         case TYPE_STRING:
483             if (!v->constval.vstring)
484                 return false;
485             if (v->constval.vstring && OPTS_FLAG(TRUE_EMPTY_STRINGS))
486                 return true;
487             return !!v->constval.vstring[0];
488         default:
489             compile_error(ctx, "internal error: immediate_is_true on invalid type");
490             return !!v->constval.vfunc;
491     }
492 }
493
494 static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
495 {
496     const oper_info *op;
497     lex_ctx ctx;
498     ast_expression *out = NULL;
499     ast_expression *exprs[3];
500     ast_block      *blocks[3];
501     ast_value      *asvalue[3];
502     ast_binstore   *asbinstore;
503     size_t i, assignop, addop, subop;
504     qcint  generated_op = 0;
505
506     char ty1[1024];
507     char ty2[1024];
508
509     if (!vec_size(sy->ops)) {
510         parseerror(parser, "internal error: missing operator");
511         return false;
512     }
513
514     if (vec_last(sy->ops).paren) {
515         parseerror(parser, "unmatched parenthesis");
516         return false;
517     }
518
519     op = &operators[vec_last(sy->ops).etype - 1];
520     ctx = vec_last(sy->ops).ctx;
521
522     DEBUGSHUNTDO(con_out("apply %s\n", op->op));
523
524     if (vec_size(sy->out) < op->operands) {
525         parseerror(parser, "internal error: not enough operands: %i (operator %s (%i))", vec_size(sy->out),
526                    op->op, (int)op->id);
527         return false;
528     }
529
530     vec_shrinkby(sy->ops, 1);
531
532     /* op(:?) has no input and no output */
533     if (!op->operands)
534         return true;
535
536     vec_shrinkby(sy->out, op->operands);
537     for (i = 0; i < op->operands; ++i) {
538         exprs[i]  = sy->out[vec_size(sy->out)+i].out;
539         blocks[i] = sy->out[vec_size(sy->out)+i].block;
540         asvalue[i] = (ast_value*)exprs[i];
541     }
542
543     if (blocks[0] && !vec_size(blocks[0]->exprs) && op->id != opid1(',')) {
544         parseerror(parser, "internal error: operator cannot be applied on empty blocks");
545         return false;
546     }
547
548 #define NotSameType(T) \
549              (exprs[0]->expression.vtype != exprs[1]->expression.vtype || \
550               exprs[0]->expression.vtype != T)
551 #define CanConstFold1(A) \
552              (ast_istype((A), ast_value) && ((ast_value*)(A))->hasvalue && (((ast_value*)(A))->cvq == CV_CONST) &&\
553               (A)->expression.vtype != TYPE_FUNCTION)
554 #define CanConstFold(A, B) \
555              (CanConstFold1(A) && CanConstFold1(B))
556 #define ConstV(i) (asvalue[(i)]->constval.vvec)
557 #define ConstF(i) (asvalue[(i)]->constval.vfloat)
558 #define ConstS(i) (asvalue[(i)]->constval.vstring)
559     switch (op->id)
560     {
561         default:
562             parseerror(parser, "internal error: unhandled operator: %s (%i)", op->op, (int)op->id);
563             return false;
564
565         case opid1('.'):
566             if (exprs[0]->expression.vtype == TYPE_ENTITY) {
567                 if (exprs[1]->expression.vtype != TYPE_FIELD) {
568                     parseerror(parser, "type error: right hand of member-operand should be an entity-field");
569                     return false;
570                 }
571                 out = (ast_expression*)ast_entfield_new(ctx, exprs[0], exprs[1]);
572             }
573             else if (exprs[0]->expression.vtype == TYPE_VECTOR) {
574                 parseerror(parser, "internal error: vector access is not supposed to be handled at this point");
575                 return false;
576             }
577             else {
578                 parseerror(parser, "type error: member-of operator on something that is not an entity or vector");
579                 return false;
580             }
581             break;
582
583         case opid1('['):
584             if (exprs[0]->expression.vtype != TYPE_ARRAY &&
585                 !(exprs[0]->expression.vtype == TYPE_FIELD &&
586                   exprs[0]->expression.next->expression.vtype == TYPE_ARRAY))
587             {
588                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
589                 parseerror(parser, "cannot index value of type %s", ty1);
590                 return false;
591             }
592             if (exprs[1]->expression.vtype != TYPE_FLOAT) {
593                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
594                 parseerror(parser, "index must be of type float, not %s", ty1);
595                 return false;
596             }
597             out = (ast_expression*)ast_array_index_new(ctx, exprs[0], exprs[1]);
598             if (rotate_entfield_array_index_nodes(&out))
599             {
600 #if 0
601                 /* This is not broken in fteqcc anymore */
602                 if (opts.standard != COMPILER_GMQCC) {
603                     /* this error doesn't need to make us bail out */
604                     (void)!parsewarning(parser, WARN_EXTENSIONS,
605                                         "accessing array-field members of an entity without parenthesis\n"
606                                         " -> this is an extension from -std=gmqcc");
607                 }
608 #endif
609             }
610             break;
611
612         case opid1(','):
613             if (blocks[0]) {
614                 if (!ast_block_add_expr(blocks[0], exprs[1]))
615                     return false;
616             } else {
617                 blocks[0] = ast_block_new(ctx);
618                 if (!ast_block_add_expr(blocks[0], exprs[0]) ||
619                     !ast_block_add_expr(blocks[0], exprs[1]))
620                 {
621                     return false;
622                 }
623             }
624             if (!ast_block_set_type(blocks[0], exprs[1]))
625                 return false;
626
627             vec_push(sy->out, syblock(ctx, blocks[0]));
628             return true;
629
630         case opid2('+','P'):
631             out = exprs[0];
632             break;
633         case opid2('-','P'):
634             switch (exprs[0]->expression.vtype) {
635                 case TYPE_FLOAT:
636                     if (CanConstFold1(exprs[0]))
637                         out = (ast_expression*)parser_const_float(parser, -ConstF(0));
638                     else
639                         out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F,
640                                                               (ast_expression*)parser_const_float_0(parser),
641                                                               exprs[0]);
642                     break;
643                 case TYPE_VECTOR:
644                     if (CanConstFold1(exprs[0]))
645                         out = (ast_expression*)parser_const_vector_f(parser,
646                             -ConstV(0).x, -ConstV(0).y, -ConstV(0).z);
647                     else
648                         out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V,
649                                                               (ast_expression*)parser_const_vector_0(parser),
650                                                               exprs[0]);
651                     break;
652                 default:
653                 parseerror(parser, "invalid types used in expression: cannot negate type %s",
654                            type_name[exprs[0]->expression.vtype]);
655                 return false;
656             }
657             break;
658
659         case opid2('!','P'):
660             switch (exprs[0]->expression.vtype) {
661                 case TYPE_FLOAT:
662                     if (CanConstFold1(exprs[0]))
663                         out = (ast_expression*)parser_const_float(parser, !ConstF(0));
664                     else
665                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, exprs[0]);
666                     break;
667                 case TYPE_VECTOR:
668                     if (CanConstFold1(exprs[0]))
669                         out = (ast_expression*)parser_const_float(parser,
670                             (!ConstV(0).x && !ConstV(0).y && !ConstV(0).z));
671                     else
672                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_V, exprs[0]);
673                     break;
674                 case TYPE_STRING:
675                     if (CanConstFold1(exprs[0])) {
676                         if (OPTS_FLAG(TRUE_EMPTY_STRINGS))
677                             out = (ast_expression*)parser_const_float(parser, !ConstS(0));
678                         else
679                             out = (ast_expression*)parser_const_float(parser, !ConstS(0) || !*ConstS(0));
680                     } else {
681                         if (OPTS_FLAG(TRUE_EMPTY_STRINGS))
682                             out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, exprs[0]);
683                         else
684                             out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_S, exprs[0]);
685                     }
686                     break;
687                 /* we don't constant-fold NOT for these types */
688                 case TYPE_ENTITY:
689                     out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_ENT, exprs[0]);
690                     break;
691                 case TYPE_FUNCTION:
692                     out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_FNC, exprs[0]);
693                     break;
694                 default:
695                 parseerror(parser, "invalid types used in expression: cannot logically negate type %s",
696                            type_name[exprs[0]->expression.vtype]);
697                 return false;
698             }
699             break;
700
701         case opid1('+'):
702             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
703                 (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) )
704             {
705                 parseerror(parser, "invalid types used in expression: cannot add type %s and %s",
706                            type_name[exprs[0]->expression.vtype],
707                            type_name[exprs[1]->expression.vtype]);
708                 return false;
709             }
710             switch (exprs[0]->expression.vtype) {
711                 case TYPE_FLOAT:
712                     if (CanConstFold(exprs[0], exprs[1]))
713                     {
714                         out = (ast_expression*)parser_const_float(parser, ConstF(0) + ConstF(1));
715                     }
716                     else
717                         out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_F, exprs[0], exprs[1]);
718                     break;
719                 case TYPE_VECTOR:
720                     if (CanConstFold(exprs[0], exprs[1]))
721                         out = (ast_expression*)parser_const_vector(parser, vec3_add(ConstV(0), ConstV(1)));
722                     else
723                         out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_V, exprs[0], exprs[1]);
724                     break;
725                 default:
726                     parseerror(parser, "invalid types used in expression: cannot add type %s and %s",
727                                type_name[exprs[0]->expression.vtype],
728                                type_name[exprs[1]->expression.vtype]);
729                     return false;
730             };
731             break;
732         case opid1('-'):
733             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
734                 (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) )
735             {
736                 parseerror(parser, "invalid types used in expression: cannot subtract type %s from %s",
737                            type_name[exprs[1]->expression.vtype],
738                            type_name[exprs[0]->expression.vtype]);
739                 return false;
740             }
741             switch (exprs[0]->expression.vtype) {
742                 case TYPE_FLOAT:
743                     if (CanConstFold(exprs[0], exprs[1]))
744                         out = (ast_expression*)parser_const_float(parser, ConstF(0) - ConstF(1));
745                     else
746                         out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F, exprs[0], exprs[1]);
747                     break;
748                 case TYPE_VECTOR:
749                     if (CanConstFold(exprs[0], exprs[1]))
750                         out = (ast_expression*)parser_const_vector(parser, vec3_sub(ConstV(0), ConstV(1)));
751                     else
752                         out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V, exprs[0], exprs[1]);
753                     break;
754                 default:
755                     parseerror(parser, "invalid types used in expression: cannot subtract type %s from %s",
756                                type_name[exprs[1]->expression.vtype],
757                                type_name[exprs[0]->expression.vtype]);
758                     return false;
759             };
760             break;
761         case opid1('*'):
762             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype &&
763                 !(exprs[0]->expression.vtype == TYPE_VECTOR &&
764                   exprs[1]->expression.vtype == TYPE_FLOAT) &&
765                 !(exprs[1]->expression.vtype == TYPE_VECTOR &&
766                   exprs[0]->expression.vtype == TYPE_FLOAT)
767                 )
768             {
769                 parseerror(parser, "invalid types used in expression: cannot multiply types %s and %s",
770                            type_name[exprs[1]->expression.vtype],
771                            type_name[exprs[0]->expression.vtype]);
772                 return false;
773             }
774             switch (exprs[0]->expression.vtype) {
775                 case TYPE_FLOAT:
776                     if (exprs[1]->expression.vtype == TYPE_VECTOR)
777                     {
778                         if (CanConstFold(exprs[0], exprs[1]))
779                             out = (ast_expression*)parser_const_vector(parser, vec3_mulvf(ConstV(1), ConstF(0)));
780                         else
781                             out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_FV, exprs[0], exprs[1]);
782                     }
783                     else
784                     {
785                         if (CanConstFold(exprs[0], exprs[1]))
786                             out = (ast_expression*)parser_const_float(parser, ConstF(0) * ConstF(1));
787                         else
788                             out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, exprs[0], exprs[1]);
789                     }
790                     break;
791                 case TYPE_VECTOR:
792                     if (exprs[1]->expression.vtype == TYPE_FLOAT)
793                     {
794                         if (CanConstFold(exprs[0], exprs[1]))
795                             out = (ast_expression*)parser_const_vector(parser, vec3_mulvf(ConstV(0), ConstF(1)));
796                         else
797                             out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_VF, exprs[0], exprs[1]);
798                     }
799                     else
800                     {
801                         if (CanConstFold(exprs[0], exprs[1]))
802                             out = (ast_expression*)parser_const_float(parser, vec3_mulvv(ConstV(0), ConstV(1)));
803                         else if (OPTS_OPTIMIZATION(OPTIM_VECTOR_COMPONENTS) && CanConstFold1(exprs[0])) {
804                             vector vec = ConstV(0);
805                             if (!vec.y && !vec.z) { /* 'n 0 0' * v */
806                                 ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS];
807                                 out = (ast_expression*)ast_member_new(ctx, exprs[1], 0, NULL);
808                                 out->expression.node.keep = false;
809                                 ((ast_member*)out)->rvalue = true;
810                                 if (vec.x != 1)
811                                     out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, (ast_expression*)parser_const_float(parser, vec.x), out);
812                             }
813                             else if (!vec.x && !vec.z) { /* '0 n 0' * v */
814                                 ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS];
815                                 out = (ast_expression*)ast_member_new(ctx, exprs[1], 1, NULL);
816                                 out->expression.node.keep = false;
817                                 ((ast_member*)out)->rvalue = true;
818                                 if (vec.y != 1)
819                                     out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, (ast_expression*)parser_const_float(parser, vec.y), out);
820                             }
821                             else if (!vec.x && !vec.y) { /* '0 n 0' * v */
822                                 ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS];
823                                 out = (ast_expression*)ast_member_new(ctx, exprs[1], 2, NULL);
824                                 out->expression.node.keep = false;
825                                 ((ast_member*)out)->rvalue = true;
826                                 if (vec.z != 1)
827                                     out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, (ast_expression*)parser_const_float(parser, vec.z), out);
828                             }
829                             else
830                                 out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_V, exprs[0], exprs[1]);
831                         }
832                         else if (OPTS_OPTIMIZATION(OPTIM_VECTOR_COMPONENTS) && CanConstFold1(exprs[1])) {
833                             vector vec = ConstV(1);
834                             if (!vec.y && !vec.z) { /* v * 'n 0 0' */
835                                 ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS];
836                                 out = (ast_expression*)ast_member_new(ctx, exprs[0], 0, NULL);
837                                 out->expression.node.keep = false;
838                                 ((ast_member*)out)->rvalue = true;
839                                 if (vec.x != 1)
840                                     out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, out, (ast_expression*)parser_const_float(parser, vec.x));
841                             }
842                             else if (!vec.x && !vec.z) { /* v * '0 n 0' */
843                                 ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS];
844                                 out = (ast_expression*)ast_member_new(ctx, exprs[0], 1, NULL);
845                                 out->expression.node.keep = false;
846                                 ((ast_member*)out)->rvalue = true;
847                                 if (vec.y != 1)
848                                     out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, out, (ast_expression*)parser_const_float(parser, vec.y));
849                             }
850                             else if (!vec.x && !vec.y) { /* v * '0 n 0' */
851                                 ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS];
852                                 out = (ast_expression*)ast_member_new(ctx, exprs[0], 2, NULL);
853                                 out->expression.node.keep = false;
854                                 ((ast_member*)out)->rvalue = true;
855                                 if (vec.z != 1)
856                                     out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, out, (ast_expression*)parser_const_float(parser, vec.z));
857                             }
858                             else
859                                 out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_V, exprs[0], exprs[1]);
860                         }
861                         else
862                             out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_V, exprs[0], exprs[1]);
863                     }
864                     break;
865                 default:
866                     parseerror(parser, "invalid types used in expression: cannot multiply types %s and %s",
867                                type_name[exprs[1]->expression.vtype],
868                                type_name[exprs[0]->expression.vtype]);
869                     return false;
870             };
871             break;
872         case opid1('/'):
873             if (NotSameType(TYPE_FLOAT)) {
874                 parseerror(parser, "invalid types used in expression: cannot divide types %s and %s",
875                            type_name[exprs[0]->expression.vtype],
876                            type_name[exprs[1]->expression.vtype]);
877                 return false;
878             }
879             if (CanConstFold(exprs[0], exprs[1]))
880                 out = (ast_expression*)parser_const_float(parser, ConstF(0) / ConstF(1));
881             else
882                 out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F, exprs[0], exprs[1]);
883             break;
884         case opid1('%'):
885         case opid2('%','='):
886             parseerror(parser, "qc does not have a modulo operator");
887             return false;
888         case opid1('|'):
889         case opid1('&'):
890             if (NotSameType(TYPE_FLOAT)) {
891                 parseerror(parser, "invalid types used in expression: cannot perform bit operations between types %s and %s",
892                            type_name[exprs[0]->expression.vtype],
893                            type_name[exprs[1]->expression.vtype]);
894                 return false;
895             }
896             if (CanConstFold(exprs[0], exprs[1]))
897                 out = (ast_expression*)parser_const_float(parser,
898                     (op->id == opid1('|') ? (float)( ((qcint)ConstF(0)) | ((qcint)ConstF(1)) ) :
899                                             (float)( ((qcint)ConstF(0)) & ((qcint)ConstF(1)) ) ));
900             else
901                 out = (ast_expression*)ast_binary_new(ctx,
902                     (op->id == opid1('|') ? INSTR_BITOR : INSTR_BITAND),
903                     exprs[0], exprs[1]);
904             break;
905         case opid1('^'):
906             parseerror(parser, "TODO: bitxor");
907             return false;
908
909         case opid2('<','<'):
910         case opid2('>','>'):
911         case opid3('<','<','='):
912         case opid3('>','>','='):
913             parseerror(parser, "TODO: shifts");
914             return false;
915
916         case opid2('|','|'):
917             generated_op += 1; /* INSTR_OR */
918         case opid2('&','&'):
919             generated_op += INSTR_AND;
920 #if 0
921             if (NotSameType(TYPE_FLOAT)) {
922                 parseerror(parser, "invalid types used in expression: cannot perform logical operations between types %s and %s",
923                            type_name[exprs[0]->expression.vtype],
924                            type_name[exprs[1]->expression.vtype]);
925                 parseerror(parser, "TODO: logical ops for arbitrary types using INSTR_NOT");
926                 parseerror(parser, "TODO: optional early out");
927                 return false;
928             }
929 #endif
930             if (CanConstFold(exprs[0], exprs[1]))
931             {
932                 if (OPTS_FLAG(PERL_LOGIC)) {
933                     if (immediate_is_true(ctx, asvalue[0]))
934                         out = exprs[1];
935                 }
936                 else
937                     out = (ast_expression*)parser_const_float(parser,
938                           ( (generated_op == INSTR_OR)
939                             ? (immediate_is_true(ctx, asvalue[0]) || immediate_is_true(ctx, asvalue[1]))
940                             : (immediate_is_true(ctx, asvalue[0]) && immediate_is_true(ctx, asvalue[1])) )
941                           ? 0 : 1);
942             }
943             else
944             {
945                 if (OPTS_FLAG(PERL_LOGIC) && !ast_compare_type(exprs[0], exprs[1])) {
946                     ast_type_to_string(exprs[0], ty1, sizeof(ty1));
947                     ast_type_to_string(exprs[1], ty2, sizeof(ty2));
948                     parseerror(parser, "invalid types for logical operation with -fperl-logic: %s and %s", ty1, ty2);
949                     return false;
950                 }
951                 for (i = 0; i < 2; ++i) {
952                     if (OPTS_FLAG(CORRECT_LOGIC) && exprs[i]->expression.vtype == TYPE_VECTOR) {
953                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_V, exprs[i]);
954                         if (!out) break;
955                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, out);
956                         if (!out) break;
957                         exprs[i] = out; out = NULL;
958                         if (OPTS_FLAG(PERL_LOGIC)) {
959                             /* here we want to keep the right expressions' type */
960                             break;
961                         }
962                     }
963                     else if (OPTS_FLAG(FALSE_EMPTY_STRINGS) && exprs[i]->expression.vtype == TYPE_STRING) {
964                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_S, exprs[i]);
965                         if (!out) break;
966                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, out);
967                         if (!out) break;
968                         exprs[i] = out; out = NULL;
969                         if (OPTS_FLAG(PERL_LOGIC)) {
970                             /* here we want to keep the right expressions' type */
971                             break;
972                         }
973                     }
974                 }
975                 out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
976             }
977             break;
978
979         case opid2('?',':'):
980             if (vec_last(parser->pot) != POT_TERNARY2) {
981                 parseerror(parser, "mismatched parenthesis/ternary");
982                 return false;
983             }
984             vec_pop(parser->pot);
985             if (exprs[1]->expression.vtype != exprs[2]->expression.vtype) {
986                 ast_type_to_string(exprs[1], ty1, sizeof(ty1));
987                 ast_type_to_string(exprs[2], ty2, sizeof(ty2));
988                 parseerror(parser, "operands of ternary expression must have the same type, got %s and %s", ty1, ty2);
989                 return false;
990             }
991             if (CanConstFold1(exprs[0]))
992                 out = (ConstF(0) ? exprs[1] : exprs[2]);
993             else
994                 out = (ast_expression*)ast_ternary_new(ctx, exprs[0], exprs[1], exprs[2]);
995             break;
996
997         case opid1('>'):
998             generated_op += 1; /* INSTR_GT */
999         case opid1('<'):
1000             generated_op += 1; /* INSTR_LT */
1001         case opid2('>', '='):
1002             generated_op += 1; /* INSTR_GE */
1003         case opid2('<', '='):
1004             generated_op += INSTR_LE;
1005             if (NotSameType(TYPE_FLOAT)) {
1006                 parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s",
1007                            type_name[exprs[0]->expression.vtype],
1008                            type_name[exprs[1]->expression.vtype]);
1009                 return false;
1010             }
1011             out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
1012             break;
1013         case opid2('!', '='):
1014             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) {
1015                 parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s",
1016                            type_name[exprs[0]->expression.vtype],
1017                            type_name[exprs[1]->expression.vtype]);
1018                 return false;
1019             }
1020             out = (ast_expression*)ast_binary_new(ctx, type_ne_instr[exprs[0]->expression.vtype], exprs[0], exprs[1]);
1021             break;
1022         case opid2('=', '='):
1023             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) {
1024                 parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s",
1025                            type_name[exprs[0]->expression.vtype],
1026                            type_name[exprs[1]->expression.vtype]);
1027                 return false;
1028             }
1029             out = (ast_expression*)ast_binary_new(ctx, type_eq_instr[exprs[0]->expression.vtype], exprs[0], exprs[1]);
1030             break;
1031
1032         case opid1('='):
1033             if (ast_istype(exprs[0], ast_entfield)) {
1034                 ast_expression *field = ((ast_entfield*)exprs[0])->field;
1035                 if (OPTS_FLAG(ADJUST_VECTOR_FIELDS) &&
1036                     exprs[0]->expression.vtype == TYPE_FIELD &&
1037                     exprs[0]->expression.next->expression.vtype == TYPE_VECTOR)
1038                 {
1039                     assignop = type_storep_instr[TYPE_VECTOR];
1040                 }
1041                 else
1042                     assignop = type_storep_instr[exprs[0]->expression.vtype];
1043                 if (assignop == AINSTR_END ||
1044                     !ast_compare_type(field->expression.next, exprs[1]))
1045                 {
1046                     ast_type_to_string(field->expression.next, ty1, sizeof(ty1));
1047                     ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1048                     if (OPTS_FLAG(ASSIGN_FUNCTION_TYPES) &&
1049                         field->expression.next->expression.vtype == TYPE_FUNCTION &&
1050                         exprs[1]->expression.vtype == TYPE_FUNCTION)
1051                     {
1052                         (void)!parsewarning(parser, WARN_ASSIGN_FUNCTION_TYPES,
1053                                             "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
1054                     }
1055                     else
1056                         parseerror(parser, "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
1057                 }
1058             }
1059             else
1060             {
1061                 if (OPTS_FLAG(ADJUST_VECTOR_FIELDS) &&
1062                     exprs[0]->expression.vtype == TYPE_FIELD &&
1063                     exprs[0]->expression.next->expression.vtype == TYPE_VECTOR)
1064                 {
1065                     assignop = type_store_instr[TYPE_VECTOR];
1066                 }
1067                 else {
1068                     assignop = type_store_instr[exprs[0]->expression.vtype];
1069                 }
1070
1071                 if (assignop == AINSTR_END) {
1072                     ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1073                     ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1074                     parseerror(parser, "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
1075                 }
1076                 else if (exprs[1]->expression.vtype != TYPE_NIL &&
1077                          !ast_compare_type(exprs[0], exprs[1]))
1078                 {
1079                     ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1080                     ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1081                     if (OPTS_FLAG(ASSIGN_FUNCTION_TYPES) &&
1082                         exprs[0]->expression.vtype == TYPE_FUNCTION &&
1083                         exprs[1]->expression.vtype == TYPE_FUNCTION)
1084                     {
1085                         (void)!parsewarning(parser, WARN_ASSIGN_FUNCTION_TYPES,
1086                                             "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
1087                     }
1088                     else
1089                         parseerror(parser, "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
1090                 }
1091             }
1092             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1093                 parseerror(parser, "assignment to constant `%s`", asvalue[0]->name);
1094             }
1095             out = (ast_expression*)ast_store_new(ctx, assignop, exprs[0], exprs[1]);
1096             break;
1097         case opid3('+','+','P'):
1098         case opid3('-','-','P'):
1099             /* prefix ++ */
1100             if (exprs[0]->expression.vtype != TYPE_FLOAT) {
1101                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1102                 parseerror(parser, "invalid type for prefix increment: %s", ty1);
1103                 return false;
1104             }
1105             if (op->id == opid3('+','+','P'))
1106                 addop = INSTR_ADD_F;
1107             else
1108                 addop = INSTR_SUB_F;
1109             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1110                 parseerror(parser, "assignment to constant `%s`", asvalue[0]->name);
1111             }
1112             if (ast_istype(exprs[0], ast_entfield)) {
1113                 out = (ast_expression*)ast_binstore_new(ctx, INSTR_STOREP_F, addop,
1114                                                         exprs[0],
1115                                                         (ast_expression*)parser_const_float_1(parser));
1116             } else {
1117                 out = (ast_expression*)ast_binstore_new(ctx, INSTR_STORE_F, addop,
1118                                                         exprs[0],
1119                                                         (ast_expression*)parser_const_float_1(parser));
1120             }
1121             break;
1122         case opid3('S','+','+'):
1123         case opid3('S','-','-'):
1124             /* prefix ++ */
1125             if (exprs[0]->expression.vtype != TYPE_FLOAT) {
1126                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1127                 parseerror(parser, "invalid type for suffix increment: %s", ty1);
1128                 return false;
1129             }
1130             if (op->id == opid3('S','+','+')) {
1131                 addop = INSTR_ADD_F;
1132                 subop = INSTR_SUB_F;
1133             } else {
1134                 addop = INSTR_SUB_F;
1135                 subop = INSTR_ADD_F;
1136             }
1137             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1138                 parseerror(parser, "assignment to constant `%s`", asvalue[0]->name);
1139             }
1140             if (ast_istype(exprs[0], ast_entfield)) {
1141                 out = (ast_expression*)ast_binstore_new(ctx, INSTR_STOREP_F, addop,
1142                                                         exprs[0],
1143                                                         (ast_expression*)parser_const_float_1(parser));
1144             } else {
1145                 out = (ast_expression*)ast_binstore_new(ctx, INSTR_STORE_F, addop,
1146                                                         exprs[0],
1147                                                         (ast_expression*)parser_const_float_1(parser));
1148             }
1149             if (!out)
1150                 return false;
1151             out = (ast_expression*)ast_binary_new(ctx, subop,
1152                                                   out,
1153                                                   (ast_expression*)parser_const_float_1(parser));
1154             break;
1155         case opid2('+','='):
1156         case opid2('-','='):
1157             if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
1158                 (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) )
1159             {
1160                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1161                 ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1162                 parseerror(parser, "invalid types used in expression: cannot add or subtract type %s and %s",
1163                            ty1, ty2);
1164                 return false;
1165             }
1166             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1167                 parseerror(parser, "assignment to constant `%s`", asvalue[0]->name);
1168             }
1169             if (ast_istype(exprs[0], ast_entfield))
1170                 assignop = type_storep_instr[exprs[0]->expression.vtype];
1171             else
1172                 assignop = type_store_instr[exprs[0]->expression.vtype];
1173             switch (exprs[0]->expression.vtype) {
1174                 case TYPE_FLOAT:
1175                     out = (ast_expression*)ast_binstore_new(ctx, assignop,
1176                                                             (op->id == opid2('+','=') ? INSTR_ADD_F : INSTR_SUB_F),
1177                                                             exprs[0], exprs[1]);
1178                     break;
1179                 case TYPE_VECTOR:
1180                     out = (ast_expression*)ast_binstore_new(ctx, assignop,
1181                                                             (op->id == opid2('+','=') ? INSTR_ADD_V : INSTR_SUB_V),
1182                                                             exprs[0], exprs[1]);
1183                     break;
1184                 default:
1185                     parseerror(parser, "invalid types used in expression: cannot add or subtract type %s and %s",
1186                                type_name[exprs[0]->expression.vtype],
1187                                type_name[exprs[1]->expression.vtype]);
1188                     return false;
1189             };
1190             break;
1191         case opid2('*','='):
1192         case opid2('/','='):
1193             if (exprs[1]->expression.vtype != TYPE_FLOAT ||
1194                 !(exprs[0]->expression.vtype == TYPE_FLOAT ||
1195                   exprs[0]->expression.vtype == TYPE_VECTOR))
1196             {
1197                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1198                 ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1199                 parseerror(parser, "invalid types used in expression: %s and %s",
1200                            ty1, ty2);
1201                 return false;
1202             }
1203             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1204                 parseerror(parser, "assignment to constant `%s`", asvalue[0]->name);
1205             }
1206             if (ast_istype(exprs[0], ast_entfield))
1207                 assignop = type_storep_instr[exprs[0]->expression.vtype];
1208             else
1209                 assignop = type_store_instr[exprs[0]->expression.vtype];
1210             switch (exprs[0]->expression.vtype) {
1211                 case TYPE_FLOAT:
1212                     out = (ast_expression*)ast_binstore_new(ctx, assignop,
1213                                                             (op->id == opid2('*','=') ? INSTR_MUL_F : INSTR_DIV_F),
1214                                                             exprs[0], exprs[1]);
1215                     break;
1216                 case TYPE_VECTOR:
1217                     if (op->id == opid2('*','=')) {
1218                         out = (ast_expression*)ast_binstore_new(ctx, assignop, INSTR_MUL_VF,
1219                                                                 exprs[0], exprs[1]);
1220                     } else {
1221                         /* there's no DIV_VF */
1222                         out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F,
1223                                                               (ast_expression*)parser_const_float_1(parser),
1224                                                               exprs[1]);
1225                         if (!out)
1226                             return false;
1227                         out = (ast_expression*)ast_binstore_new(ctx, assignop, INSTR_MUL_VF,
1228                                                                 exprs[0], out);
1229                     }
1230                     break;
1231                 default:
1232                     parseerror(parser, "invalid types used in expression: cannot add or subtract type %s and %s",
1233                                type_name[exprs[0]->expression.vtype],
1234                                type_name[exprs[1]->expression.vtype]);
1235                     return false;
1236             };
1237             break;
1238         case opid2('&','='):
1239         case opid2('|','='):
1240             if (NotSameType(TYPE_FLOAT)) {
1241                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1242                 ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1243                 parseerror(parser, "invalid types used in expression: %s and %s",
1244                            ty1, ty2);
1245                 return false;
1246             }
1247             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1248                 parseerror(parser, "assignment to constant `%s`", asvalue[0]->name);
1249             }
1250             if (ast_istype(exprs[0], ast_entfield))
1251                 assignop = type_storep_instr[exprs[0]->expression.vtype];
1252             else
1253                 assignop = type_store_instr[exprs[0]->expression.vtype];
1254             out = (ast_expression*)ast_binstore_new(ctx, assignop,
1255                                                     (op->id == opid2('&','=') ? INSTR_BITAND : INSTR_BITOR),
1256                                                     exprs[0], exprs[1]);
1257             break;
1258         case opid3('&','~','='):
1259             /* This is like: a &= ~(b);
1260              * But QC has no bitwise-not, so we implement it as
1261              * a -= a & (b);
1262              */
1263             if (NotSameType(TYPE_FLOAT)) {
1264                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1265                 ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1266                 parseerror(parser, "invalid types used in expression: %s and %s",
1267                            ty1, ty2);
1268                 return false;
1269             }
1270             if (ast_istype(exprs[0], ast_entfield))
1271                 assignop = type_storep_instr[exprs[0]->expression.vtype];
1272             else
1273                 assignop = type_store_instr[exprs[0]->expression.vtype];
1274             out = (ast_expression*)ast_binary_new(ctx, INSTR_BITAND, exprs[0], exprs[1]);
1275             if (!out)
1276                 return false;
1277             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1278                 parseerror(parser, "assignment to constant `%s`", asvalue[0]->name);
1279             }
1280             asbinstore = ast_binstore_new(ctx, assignop, INSTR_SUB_F, exprs[0], out);
1281             asbinstore->keep_dest = true;
1282             out = (ast_expression*)asbinstore;
1283             break;
1284     }
1285 #undef NotSameType
1286
1287     if (!out) {
1288         parseerror(parser, "failed to apply operand %s", op->op);
1289         return false;
1290     }
1291
1292     DEBUGSHUNTDO(con_out("applied %s\n", op->op));
1293     vec_push(sy->out, syexp(ctx, out));
1294     return true;
1295 }
1296
1297 static bool parser_close_call(parser_t *parser, shunt *sy)
1298 {
1299     /* was a function call */
1300     ast_expression *fun;
1301     ast_call       *call;
1302
1303     size_t          fid;
1304     size_t          paramcount;
1305
1306     vec_shrinkby(sy->ops, 1);
1307     fid = sy->ops[vec_size(sy->ops)].off;
1308
1309     /* out[fid] is the function
1310      * everything above is parameters...
1311      * 0 params = nothing
1312      * 1 params = ast_expression
1313      * more = ast_block
1314      */
1315
1316     if (vec_size(sy->out) < 1 || vec_size(sy->out) <= fid) {
1317         parseerror(parser, "internal error: function call needs function and parameter list...");
1318         return false;
1319     }
1320
1321     fun = sy->out[fid].out;
1322
1323     if (fun == intrinsic_debug_typestring) {
1324         char ty[1024];
1325         if (fid+2 != vec_size(sy->out) ||
1326             vec_last(sy->out).block)
1327         {
1328             parseerror(parser, "intrinsic __builtin_debug_typestring requires exactly 1 parameter");
1329             return false;
1330         }
1331         ast_type_to_string(vec_last(sy->out).out, ty, sizeof(ty));
1332         ast_unref(vec_last(sy->out).out);
1333         sy->out[fid] = syexp(ast_ctx(vec_last(sy->out).out),
1334                              (ast_expression*)parser_const_string(parser, ty, false));
1335         vec_shrinkby(sy->out, 1);
1336         return true;
1337     }
1338
1339     call = ast_call_new(sy->ops[vec_size(sy->ops)].ctx, fun);
1340     if (!call) {
1341         parseerror(parser, "internal error: failed to create ast_call node");
1342         return false;
1343     }
1344
1345     if (fid+1 == vec_size(sy->out)) {
1346         /* no arguments */
1347         paramcount = 0;
1348     } else if (fid+2 == vec_size(sy->out)) {
1349         ast_block *params;
1350         vec_shrinkby(sy->out, 1);
1351         params = sy->out[vec_size(sy->out)].block;
1352         if (!params) {
1353             /* 1 param */
1354             paramcount = 1;
1355             vec_push(call->params, sy->out[vec_size(sy->out)].out);
1356         } else {
1357             paramcount = vec_size(params->exprs);
1358             call->params = params->exprs;
1359             params->exprs = NULL;
1360             ast_delete(params);
1361         }
1362         (void)!ast_call_check_types(call);
1363     } else {
1364         parseerror(parser, "invalid function call");
1365         return false;
1366     }
1367
1368     /* overwrite fid, the function, with a call */
1369     sy->out[fid] = syexp(call->expression.node.context, (ast_expression*)call);
1370
1371     if (fun->expression.vtype != TYPE_FUNCTION) {
1372         parseerror(parser, "not a function (%s)", type_name[fun->expression.vtype]);
1373         return false;
1374     }
1375
1376     if (!fun->expression.next) {
1377         parseerror(parser, "could not determine function return type");
1378         return false;
1379     } else {
1380         if (vec_size(fun->expression.params) != paramcount &&
1381             !((fun->expression.flags & AST_FLAG_VARIADIC) &&
1382               vec_size(fun->expression.params) < paramcount))
1383         {
1384             ast_value *fval;
1385             const char *fewmany = (vec_size(fun->expression.params) > paramcount) ? "few" : "many";
1386
1387             fval = (ast_istype(fun, ast_value) ? ((ast_value*)fun) : NULL);
1388             if (opts.standard == COMPILER_GMQCC)
1389             {
1390                 if (fval)
1391                     parseerror(parser, "too %s parameters for call to %s: expected %i, got %i\n"
1392                                " -> `%s` has been declared here: %s:%i",
1393                                fewmany, fval->name, (int)vec_size(fun->expression.params), (int)paramcount,
1394                                fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line);
1395                 else
1396                     parseerror(parser, "too %s parameters for function call: expected %i, got %i\n"
1397                                " -> it has been declared here: %s:%i",
1398                                fewmany, (int)vec_size(fun->expression.params), (int)paramcount,
1399                                ast_ctx(fun).file, (int)ast_ctx(fun).line);
1400                 return false;
1401             }
1402             else
1403             {
1404                 if (fval)
1405                     return !parsewarning(parser, WARN_TOO_FEW_PARAMETERS,
1406                                          "too %s parameters for call to %s: expected %i, got %i\n"
1407                                          " -> `%s` has been declared here: %s:%i",
1408                                          fewmany, fval->name, (int)vec_size(fun->expression.params), (int)paramcount,
1409                                          fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line);
1410                 else
1411                     return !parsewarning(parser, WARN_TOO_FEW_PARAMETERS,
1412                                          "too %s parameters for function call: expected %i, got %i\n"
1413                                          " -> it has been declared here: %s:%i",
1414                                          fewmany, (int)vec_size(fun->expression.params), (int)paramcount,
1415                                          ast_ctx(fun).file, (int)ast_ctx(fun).line);
1416             }
1417         }
1418     }
1419
1420     return true;
1421 }
1422
1423 static bool parser_close_paren(parser_t *parser, shunt *sy, bool functions_only)
1424 {
1425     if (!vec_size(sy->ops)) {
1426         parseerror(parser, "unmatched closing paren");
1427         return false;
1428     }
1429     /* this would for bit a + (x) because there are no operators inside (x)
1430     if (sy->ops[vec_size(sy->ops)-1].paren == 1) {
1431         parseerror(parser, "empty parenthesis expression");
1432         return false;
1433     }
1434     */
1435     while (vec_size(sy->ops)) {
1436         if (sy->ops[vec_size(sy->ops)-1].paren == SY_PAREN_FUNC) {
1437             if (!parser_close_call(parser, sy))
1438                 return false;
1439             break;
1440         }
1441         if (sy->ops[vec_size(sy->ops)-1].paren == SY_PAREN_EXPR) {
1442             vec_shrinkby(sy->ops, 1);
1443             return !functions_only;
1444         }
1445         if (sy->ops[vec_size(sy->ops)-1].paren == SY_PAREN_INDEX) {
1446             if (functions_only)
1447                 return false;
1448             /* pop off the parenthesis */
1449             vec_shrinkby(sy->ops, 1);
1450             /* then apply the index operator */
1451             if (!parser_sy_apply_operator(parser, sy))
1452                 return false;
1453             return true;
1454         }
1455         if (sy->ops[vec_size(sy->ops)-1].paren == SY_PAREN_TERNARY) {
1456             if (functions_only)
1457                 return false;
1458             if (vec_last(parser->pot) != POT_TERNARY1) {
1459                 parseerror(parser, "mismatched colon in ternary expression (missing closing paren?)");
1460                 return false;
1461             }
1462             vec_last(parser->pot) = POT_TERNARY2;
1463             /* pop off the parenthesis */
1464             vec_shrinkby(sy->ops, 1);
1465             return true;
1466         }
1467         if (!parser_sy_apply_operator(parser, sy))
1468             return false;
1469     }
1470     return true;
1471 }
1472
1473 static void parser_reclassify_token(parser_t *parser)
1474 {
1475     size_t i;
1476     for (i = 0; i < operator_count; ++i) {
1477         if (!strcmp(parser_tokval(parser), operators[i].op)) {
1478             parser->tok = TOKEN_OPERATOR;
1479             return;
1480         }
1481     }
1482 }
1483
1484 static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma)
1485 {
1486     ast_expression *expr = NULL;
1487     shunt sy;
1488     bool wantop = false;
1489     bool gotmemberof = false;
1490
1491     /* count the parens because an if starts with one, so the
1492      * end of a condition is an unmatched closing paren
1493      */
1494     int parens = 0;
1495     int ternaries = 0;
1496
1497     sy.out = NULL;
1498     sy.ops = NULL;
1499
1500     parser->lex->flags.noops = false;
1501
1502     parser_reclassify_token(parser);
1503
1504     while (true)
1505     {
1506         if (gotmemberof)
1507             gotmemberof = false;
1508         else
1509             parser->memberof = 0;
1510
1511         if (OPTS_FLAG(TRANSLATABLE_STRINGS) &&
1512             parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "_"))
1513         {
1514             /* a translatable string */
1515             ast_value *val;
1516
1517             if (wantop) {
1518                 parseerror(parser, "expected operator or end of statement, got constant");
1519                 goto onerr;
1520             }
1521
1522             parser->lex->flags.noops = true;
1523             if (!parser_next(parser) || parser->tok != '(') {
1524                 parseerror(parser, "use _(\"string\") to create a translatable string constant");
1525                 goto onerr;
1526             }
1527             parser->lex->flags.noops = false;
1528             if (!parser_next(parser) || parser->tok != TOKEN_STRINGCONST) {
1529                 parseerror(parser, "expected a constant string in translatable-string extension");
1530                 goto onerr;
1531             }
1532             val = parser_const_string(parser, parser_tokval(parser), true);
1533             wantop = true;
1534             if (!val)
1535                 return NULL;
1536             vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val));
1537             DEBUGSHUNTDO(con_out("push string\n"));
1538
1539             if (!parser_next(parser) || parser->tok != ')') {
1540                 parseerror(parser, "expected closing paren after translatable string");
1541                 goto onerr;
1542             }
1543         }
1544         else if (parser->tok == TOKEN_IDENT)
1545         {
1546             ast_expression *var;
1547             if (wantop) {
1548                 parseerror(parser, "expected operator or end of statement");
1549                 goto onerr;
1550             }
1551             wantop = true;
1552             /* variable */
1553             if (opts.standard == COMPILER_GMQCC)
1554             {
1555                 if (parser->memberof == TYPE_ENTITY) {
1556                     /* still get vars first since there could be a fieldpointer */
1557                     var = parser_find_var(parser, parser_tokval(parser));
1558                     if (!var)
1559                         var = parser_find_field(parser, parser_tokval(parser));
1560                 }
1561                 else if (parser->memberof == TYPE_VECTOR)
1562                 {
1563                     parseerror(parser, "TODO: implement effective vector member access");
1564                     goto onerr;
1565                 }
1566                 else if (parser->memberof) {
1567                     parseerror(parser, "namespace for member not found");
1568                     goto onerr;
1569                 }
1570                 else
1571                     var = parser_find_var(parser, parser_tokval(parser));
1572             } else {
1573                 var = parser_find_var(parser, parser_tokval(parser));
1574                 if (!var)
1575                     var = parser_find_field(parser, parser_tokval(parser));
1576             }
1577             if (!var) {
1578                 /* intrinsics */
1579                 if (!strcmp(parser_tokval(parser), "__builtin_debug_typestring")) {
1580                     var = (ast_expression*)intrinsic_debug_typestring;
1581
1582                 }
1583                 else
1584                 {
1585                     parseerror(parser, "unexpected ident: %s", parser_tokval(parser));
1586                     goto onerr;
1587                 }
1588             }
1589             else
1590             {
1591                 if (ast_istype(var, ast_value)) {
1592                     ((ast_value*)var)->uses++;
1593                 }
1594                 else if (ast_istype(var, ast_member)) {
1595                     ast_member *mem = (ast_member*)var;
1596                     if (ast_istype(mem->owner, ast_value))
1597                         ((ast_value*)(mem->owner))->uses++;
1598                 }
1599             }
1600             vec_push(sy.out, syexp(parser_ctx(parser), var));
1601             DEBUGSHUNTDO(con_out("push %s\n", parser_tokval(parser)));
1602         }
1603         else if (parser->tok == TOKEN_FLOATCONST) {
1604             ast_value *val;
1605             if (wantop) {
1606                 parseerror(parser, "expected operator or end of statement, got constant");
1607                 goto onerr;
1608             }
1609             wantop = true;
1610             val = parser_const_float(parser, (parser_token(parser)->constval.f));
1611             if (!val)
1612                 return NULL;
1613             vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val));
1614             DEBUGSHUNTDO(con_out("push %g\n", parser_token(parser)->constval.f));
1615         }
1616         else if (parser->tok == TOKEN_INTCONST || parser->tok == TOKEN_CHARCONST) {
1617             ast_value *val;
1618             if (wantop) {
1619                 parseerror(parser, "expected operator or end of statement, got constant");
1620                 goto onerr;
1621             }
1622             wantop = true;
1623             val = parser_const_float(parser, (double)(parser_token(parser)->constval.i));
1624             if (!val)
1625                 return NULL;
1626             vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val));
1627             DEBUGSHUNTDO(con_out("push %i\n", parser_token(parser)->constval.i));
1628         }
1629         else if (parser->tok == TOKEN_STRINGCONST) {
1630             ast_value *val;
1631             if (wantop) {
1632                 parseerror(parser, "expected operator or end of statement, got constant");
1633                 goto onerr;
1634             }
1635             wantop = true;
1636             val = parser_const_string(parser, parser_tokval(parser), false);
1637             if (!val)
1638                 return NULL;
1639             vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val));
1640             DEBUGSHUNTDO(con_out("push string\n"));
1641         }
1642         else if (parser->tok == TOKEN_VECTORCONST) {
1643             ast_value *val;
1644             if (wantop) {
1645                 parseerror(parser, "expected operator or end of statement, got constant");
1646                 goto onerr;
1647             }
1648             wantop = true;
1649             val = parser_const_vector(parser, parser_token(parser)->constval.v);
1650             if (!val)
1651                 return NULL;
1652             vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val));
1653             DEBUGSHUNTDO(con_out("push '%g %g %g'\n",
1654                                 parser_token(parser)->constval.v.x,
1655                                 parser_token(parser)->constval.v.y,
1656                                 parser_token(parser)->constval.v.z));
1657         }
1658         else if (parser->tok == '(') {
1659             parseerror(parser, "internal error: '(' should be classified as operator");
1660             goto onerr;
1661         }
1662         else if (parser->tok == '[') {
1663             parseerror(parser, "internal error: '[' should be classified as operator");
1664             goto onerr;
1665         }
1666         else if (parser->tok == ')') {
1667             if (wantop) {
1668                 DEBUGSHUNTDO(con_out("do[op] )\n"));
1669                 --parens;
1670                 if (parens < 0)
1671                     break;
1672                 /* we do expect an operator next */
1673                 /* closing an opening paren */
1674                 if (!parser_close_paren(parser, &sy, false))
1675                     goto onerr;
1676                 if (vec_last(parser->pot) != POT_PAREN) {
1677                     parseerror(parser, "mismatched parentheses (closing paren during ternary expression?)");
1678                     goto onerr;
1679                 }
1680                 vec_pop(parser->pot);
1681             } else {
1682                 DEBUGSHUNTDO(con_out("do[nop] )\n"));
1683                 --parens;
1684                 if (parens < 0)
1685                     break;
1686                 /* allowed for function calls */
1687                 if (!parser_close_paren(parser, &sy, true))
1688                     goto onerr;
1689                 if (vec_last(parser->pot) != POT_PAREN) {
1690                     parseerror(parser, "mismatched parentheses (closing paren during ternary expression?)");
1691                     goto onerr;
1692                 }
1693                 vec_pop(parser->pot);
1694             }
1695             wantop = true;
1696         }
1697         else if (parser->tok == ']') {
1698             if (!wantop)
1699                 parseerror(parser, "operand expected");
1700             --parens;
1701             if (parens < 0)
1702                 break;
1703             if (!parser_close_paren(parser, &sy, false))
1704                 goto onerr;
1705             if (vec_last(parser->pot) != POT_PAREN) {
1706                 parseerror(parser, "mismatched parentheses (closing paren during ternary expression?)");
1707                 goto onerr;
1708             }
1709             vec_pop(parser->pot);
1710             wantop = true;
1711         }
1712         else if (parser->tok == TOKEN_TYPENAME) {
1713             parseerror(parser, "unexpected typename");
1714             goto onerr;
1715         }
1716         else if (parser->tok != TOKEN_OPERATOR) {
1717             if (wantop) {
1718                 parseerror(parser, "expected operator or end of statement");
1719                 goto onerr;
1720             }
1721             break;
1722         }
1723         else
1724         {
1725             /* classify the operator */
1726             const oper_info *op;
1727             const oper_info *olast = NULL;
1728             size_t o;
1729             for (o = 0; o < operator_count; ++o) {
1730                 if (((!(operators[o].flags & OP_PREFIX) == !!wantop)) &&
1731                     /* !(operators[o].flags & OP_SUFFIX) && / * remove this */
1732                     !strcmp(parser_tokval(parser), operators[o].op))
1733                 {
1734                     break;
1735                 }
1736             }
1737             if (o == operator_count) {
1738                 /* no operator found... must be the end of the statement */
1739                 break;
1740             }
1741             /* found an operator */
1742             op = &operators[o];
1743
1744             /* when declaring variables, a comma starts a new variable */
1745             if (op->id == opid1(',') && !parens && stopatcomma) {
1746                 /* fixup the token */
1747                 parser->tok = ',';
1748                 break;
1749             }
1750
1751             /* a colon without a pervious question mark cannot be a ternary */
1752             if (!ternaries && op->id == opid2(':','?')) {
1753                 parser->tok = ':';
1754                 break;
1755             }
1756
1757             if (op->id == opid1(',')) {
1758                 if (vec_size(parser->pot) && vec_last(parser->pot) == POT_TERNARY2) {
1759                     (void)!parsewarning(parser, WARN_TERNARY_PRECEDENCE, "suggesting parenthesis around ternary expression");
1760                 }
1761             }
1762
1763             if (vec_size(sy.ops) && !vec_last(sy.ops).paren)
1764                 olast = &operators[vec_last(sy.ops).etype-1];
1765
1766             while (olast && (
1767                     (op->prec < olast->prec) ||
1768                     (op->assoc == ASSOC_LEFT && op->prec <= olast->prec) ) )
1769             {
1770                 if (!parser_sy_apply_operator(parser, &sy))
1771                     goto onerr;
1772                 if (vec_size(sy.ops) && !vec_last(sy.ops).paren)
1773                     olast = &operators[vec_last(sy.ops).etype-1];
1774                 else
1775                     olast = NULL;
1776             }
1777
1778             if (op->id == opid1('.') && opts.standard == COMPILER_GMQCC) {
1779                 /* for gmqcc standard: open up the namespace of the previous type */
1780                 ast_expression *prevex = vec_last(sy.out).out;
1781                 if (!prevex) {
1782                     parseerror(parser, "unexpected member operator");
1783                     goto onerr;
1784                 }
1785                 if (prevex->expression.vtype == TYPE_ENTITY)
1786                     parser->memberof = TYPE_ENTITY;
1787                 else if (prevex->expression.vtype == TYPE_VECTOR)
1788                     parser->memberof = TYPE_VECTOR;
1789                 else {
1790                     parseerror(parser, "type error: type has no members");
1791                     goto onerr;
1792                 }
1793                 gotmemberof = true;
1794             }
1795
1796             if (op->id == opid1('(')) {
1797                 if (wantop) {
1798                     size_t sycount = vec_size(sy.out);
1799                     DEBUGSHUNTDO(con_out("push [op] (\n"));
1800                     ++parens; vec_push(parser->pot, POT_PAREN);
1801                     /* we expected an operator, this is the function-call operator */
1802                     vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_FUNC, sycount-1));
1803                 } else {
1804                     ++parens; vec_push(parser->pot, POT_PAREN);
1805                     vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_EXPR, 0));
1806                     DEBUGSHUNTDO(con_out("push [nop] (\n"));
1807                 }
1808                 wantop = false;
1809             } else if (op->id == opid1('[')) {
1810                 if (!wantop) {
1811                     parseerror(parser, "unexpected array subscript");
1812                     goto onerr;
1813                 }
1814                 ++parens; vec_push(parser->pot, POT_PAREN);
1815                 /* push both the operator and the paren, this makes life easier */
1816                 vec_push(sy.ops, syop(parser_ctx(parser), op));
1817                 vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_INDEX, 0));
1818                 wantop = false;
1819             } else if (op->id == opid2('?',':')) {
1820                 vec_push(sy.ops, syop(parser_ctx(parser), op));
1821                 vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_TERNARY, 0));
1822                 wantop = false;
1823                 ++ternaries;
1824                 vec_push(parser->pot, POT_TERNARY1);
1825             } else if (op->id == opid2(':','?')) {
1826                 if (!vec_size(parser->pot)) {
1827                     parseerror(parser, "unexpected colon outside ternary expression (missing parenthesis?)");
1828                     goto onerr;
1829                 }
1830                 if (vec_last(parser->pot) != POT_TERNARY1) {
1831                     parseerror(parser, "unexpected colon outside ternary expression (missing parenthesis?)");
1832                     goto onerr;
1833                 }
1834                 if (!parser_close_paren(parser, &sy, false))
1835                     goto onerr;
1836                 vec_push(sy.ops, syop(parser_ctx(parser), op));
1837                 wantop = false;
1838                 --ternaries;
1839             } else {
1840                 DEBUGSHUNTDO(con_out("push operator %s\n", op->op));
1841                 vec_push(sy.ops, syop(parser_ctx(parser), op));
1842                 wantop = !!(op->flags & OP_SUFFIX);
1843             }
1844         }
1845         if (!parser_next(parser)) {
1846             goto onerr;
1847         }
1848         if (parser->tok == ';' ||
1849             (!parens && parser->tok == ']'))
1850         {
1851             break;
1852         }
1853     }
1854
1855     while (vec_size(sy.ops)) {
1856         if (!parser_sy_apply_operator(parser, &sy))
1857             goto onerr;
1858     }
1859
1860     parser->lex->flags.noops = true;
1861     if (!vec_size(sy.out)) {
1862         parseerror(parser, "empty expression");
1863         expr = NULL;
1864     } else
1865         expr = sy.out[0].out;
1866     vec_free(sy.out);
1867     vec_free(sy.ops);
1868     DEBUGSHUNTDO(con_out("shunt done\n"));
1869     if (vec_size(parser->pot)) {
1870         parseerror(parser, "internal error: vec_size(parser->pot) = %lu", (unsigned long)vec_size(parser->pot));
1871         return NULL;
1872     }
1873     vec_free(parser->pot);
1874     return expr;
1875
1876 onerr:
1877     parser->lex->flags.noops = true;
1878     vec_free(sy.out);
1879     vec_free(sy.ops);
1880     return NULL;
1881 }
1882
1883 static ast_expression* parse_expression(parser_t *parser, bool stopatcomma)
1884 {
1885     ast_expression *e = parse_expression_leave(parser, stopatcomma);
1886     if (!e)
1887         return NULL;
1888     if (!parser_next(parser)) {
1889         ast_delete(e);
1890         return NULL;
1891     }
1892     return e;
1893 }
1894
1895 static void parser_enterblock(parser_t *parser)
1896 {
1897     vec_push(parser->variables, util_htnew(PARSER_HT_SIZE));
1898     vec_push(parser->_blocklocals, vec_size(parser->_locals));
1899     vec_push(parser->typedefs, util_htnew(TYPEDEF_HT_SIZE));
1900     vec_push(parser->_blocktypedefs, vec_size(parser->_typedefs));
1901     vec_push(parser->_block_ctx, parser_ctx(parser));
1902 }
1903
1904 static bool parser_leaveblock(parser_t *parser)
1905 {
1906     bool   rv = true;
1907     size_t locals, typedefs;
1908
1909     if (vec_size(parser->variables) <= PARSER_HT_LOCALS) {
1910         parseerror(parser, "internal error: parser_leaveblock with no block");
1911         return false;
1912     }
1913
1914     util_htdel(vec_last(parser->variables));
1915     vec_pop(parser->variables);
1916     if (!vec_size(parser->_blocklocals)) {
1917         parseerror(parser, "internal error: parser_leaveblock with no block (2)");
1918         return false;
1919     }
1920
1921     locals = vec_last(parser->_blocklocals);
1922     vec_pop(parser->_blocklocals);
1923     while (vec_size(parser->_locals) != locals) {
1924         ast_expression *e = vec_last(parser->_locals);
1925         ast_value      *v = (ast_value*)e;
1926         vec_pop(parser->_locals);
1927         if (ast_istype(e, ast_value) && !v->uses) {
1928             if (compile_warning(ast_ctx(v), WARN_UNUSED_VARIABLE, "unused variable: `%s`", v->name))
1929                 rv = false;
1930         }
1931     }
1932
1933     typedefs = vec_last(parser->_blocktypedefs);
1934     while (vec_size(parser->_typedefs) != typedefs) {
1935         ast_delete(vec_last(parser->_typedefs));
1936         vec_pop(parser->_typedefs);
1937     }
1938     util_htdel(vec_last(parser->typedefs));
1939     vec_pop(parser->typedefs);
1940
1941     vec_pop(parser->_block_ctx);
1942     return rv;
1943 }
1944
1945 static void parser_addlocal(parser_t *parser, const char *name, ast_expression *e)
1946 {
1947     vec_push(parser->_locals, e);
1948     util_htset(vec_last(parser->variables), name, (void*)e);
1949 }
1950
1951 static ast_expression* process_condition(parser_t *parser, ast_expression *cond, bool *_ifnot)
1952 {
1953     bool       ifnot = false;
1954     ast_unary *unary;
1955     ast_expression *prev;
1956
1957     if (OPTS_FLAG(FALSE_EMPTY_STRINGS) && cond->expression.vtype == TYPE_STRING)
1958     {
1959         prev = cond;
1960         cond = (ast_expression*)ast_unary_new(ast_ctx(cond), INSTR_NOT_S, cond);
1961         if (!cond) {
1962             ast_unref(prev);
1963             parseerror(parser, "internal error: failed to process condition");
1964             return NULL;
1965         }
1966         ifnot = !ifnot;
1967     }
1968     else if (OPTS_FLAG(CORRECT_LOGIC) && cond->expression.vtype == TYPE_VECTOR)
1969     {
1970         /* vector types need to be cast to true booleans */
1971         ast_binary *bin = (ast_binary*)cond;
1972         if (!OPTS_FLAG(PERL_LOGIC) || !ast_istype(cond, ast_binary) || !(bin->op == INSTR_AND || bin->op == INSTR_OR))
1973         {
1974             /* in perl-logic, AND and OR take care of the -fcorrect-logic */
1975             prev = cond;
1976             cond = (ast_expression*)ast_unary_new(ast_ctx(cond), INSTR_NOT_V, cond);
1977             if (!cond) {
1978                 ast_unref(prev);
1979                 parseerror(parser, "internal error: failed to process condition");
1980                 return NULL;
1981             }
1982             ifnot = !ifnot;
1983         }
1984     }
1985
1986     unary = (ast_unary*)cond;
1987     while (ast_istype(cond, ast_unary) && unary->op == INSTR_NOT_F)
1988     {
1989         cond = unary->operand;
1990         unary->operand = NULL;
1991         ast_delete(unary);
1992         ifnot = !ifnot;
1993         unary = (ast_unary*)cond;
1994     }
1995
1996     if (!cond)
1997         parseerror(parser, "internal error: failed to process condition");
1998
1999     if (ifnot) *_ifnot = !*_ifnot;
2000     return cond;
2001 }
2002
2003 static bool parse_if(parser_t *parser, ast_block *block, ast_expression **out)
2004 {
2005     ast_ifthen *ifthen;
2006     ast_expression *cond, *ontrue = NULL, *onfalse = NULL;
2007     bool ifnot = false;
2008
2009     lex_ctx ctx = parser_ctx(parser);
2010
2011     (void)block; /* not touching */
2012
2013     /* skip the 'if', parse an optional 'not' and check for an opening paren */
2014     if (!parser_next(parser)) {
2015         parseerror(parser, "expected condition or 'not'");
2016         return false;
2017     }
2018     if (parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "not")) {
2019         ifnot = true;
2020         if (!parser_next(parser)) {
2021             parseerror(parser, "expected condition in parenthesis");
2022             return false;
2023         }
2024     }
2025     if (parser->tok != '(') {
2026         parseerror(parser, "expected 'if' condition in parenthesis");
2027         return false;
2028     }
2029     /* parse into the expression */
2030     if (!parser_next(parser)) {
2031         parseerror(parser, "expected 'if' condition after opening paren");
2032         return false;
2033     }
2034     /* parse the condition */
2035     cond = parse_expression_leave(parser, false);
2036     if (!cond)
2037         return false;
2038     /* closing paren */
2039     if (parser->tok != ')') {
2040         parseerror(parser, "expected closing paren after 'if' condition");
2041         ast_delete(cond);
2042         return false;
2043     }
2044     /* parse into the 'then' branch */
2045     if (!parser_next(parser)) {
2046         parseerror(parser, "expected statement for on-true branch of 'if'");
2047         ast_delete(cond);
2048         return false;
2049     }
2050     if (!parse_statement_or_block(parser, &ontrue)) {
2051         ast_delete(cond);
2052         return false;
2053     }
2054     /* check for an else */
2055     if (!strcmp(parser_tokval(parser), "else")) {
2056         /* parse into the 'else' branch */
2057         if (!parser_next(parser)) {
2058             parseerror(parser, "expected on-false branch after 'else'");
2059             ast_delete(ontrue);
2060             ast_delete(cond);
2061             return false;
2062         }
2063         if (!parse_statement_or_block(parser, &onfalse)) {
2064             ast_delete(ontrue);
2065             ast_delete(cond);
2066             return false;
2067         }
2068     }
2069
2070     cond = process_condition(parser, cond, &ifnot);
2071     if (!cond) {
2072         if (ontrue)  ast_delete(ontrue);
2073         if (onfalse) ast_delete(onfalse);
2074         return false;
2075     }
2076
2077     if (ifnot)
2078         ifthen = ast_ifthen_new(ctx, cond, onfalse, ontrue);
2079     else
2080         ifthen = ast_ifthen_new(ctx, cond, ontrue, onfalse);
2081     *out = (ast_expression*)ifthen;
2082     return true;
2083 }
2084
2085 static bool parse_while_go(parser_t *parser, ast_block *block, ast_expression **out);
2086 static bool parse_while(parser_t *parser, ast_block *block, ast_expression **out)
2087 {
2088     bool rv;
2089     char *label = NULL;
2090
2091     /* skip the 'while' and get the body */
2092     if (!parser_next(parser)) {
2093         if (OPTS_FLAG(LOOP_LABELS))
2094             parseerror(parser, "expected loop label or 'while' condition in parenthesis");
2095         else
2096             parseerror(parser, "expected 'while' condition in parenthesis");
2097         return false;
2098     }
2099
2100     if (parser->tok == ':') {
2101         if (!OPTS_FLAG(LOOP_LABELS))
2102             parseerror(parser, "labeled loops not activated, try using -floop-labels");
2103         if (!parser_next(parser) || parser->tok != TOKEN_IDENT) {
2104             parseerror(parser, "expected loop label");
2105             return false;
2106         }
2107         label = util_strdup(parser_tokval(parser));
2108         if (!parser_next(parser)) {
2109             mem_d(label);
2110             parseerror(parser, "expected 'while' condition in parenthesis");
2111             return false;
2112         }
2113     }
2114
2115     if (parser->tok != '(') {
2116         parseerror(parser, "expected 'while' condition in parenthesis");
2117         return false;
2118     }
2119
2120     vec_push(parser->breaks, label);
2121     vec_push(parser->continues, label);
2122
2123     rv = parse_while_go(parser, block, out);
2124     if (label)
2125         mem_d(label);
2126     if (vec_last(parser->breaks) != label || vec_last(parser->continues) != label) {
2127         parseerror(parser, "internal error: label stack corrupted");
2128         rv = false;
2129         ast_delete(*out);
2130         *out = NULL;
2131     }
2132     else {
2133         vec_pop(parser->breaks);
2134         vec_pop(parser->continues);
2135     }
2136     return rv;
2137 }
2138
2139 static bool parse_while_go(parser_t *parser, ast_block *block, ast_expression **out)
2140 {
2141     ast_loop *aloop;
2142     ast_expression *cond, *ontrue;
2143
2144     bool ifnot = false;
2145
2146     lex_ctx ctx = parser_ctx(parser);
2147
2148     (void)block; /* not touching */
2149
2150     /* parse into the expression */
2151     if (!parser_next(parser)) {
2152         parseerror(parser, "expected 'while' condition after opening paren");
2153         return false;
2154     }
2155     /* parse the condition */
2156     cond = parse_expression_leave(parser, false);
2157     if (!cond)
2158         return false;
2159     /* closing paren */
2160     if (parser->tok != ')') {
2161         parseerror(parser, "expected closing paren after 'while' condition");
2162         ast_delete(cond);
2163         return false;
2164     }
2165     /* parse into the 'then' branch */
2166     if (!parser_next(parser)) {
2167         parseerror(parser, "expected while-loop body");
2168         ast_delete(cond);
2169         return false;
2170     }
2171     if (!parse_statement_or_block(parser, &ontrue)) {
2172         ast_delete(cond);
2173         return false;
2174     }
2175
2176     cond = process_condition(parser, cond, &ifnot);
2177     if (!cond) {
2178         ast_delete(ontrue);
2179         return false;
2180     }
2181     aloop = ast_loop_new(ctx, NULL, cond, ifnot, NULL, false, NULL, ontrue);
2182     *out = (ast_expression*)aloop;
2183     return true;
2184 }
2185
2186 static bool parse_dowhile_go(parser_t *parser, ast_block *block, ast_expression **out);
2187 static bool parse_dowhile(parser_t *parser, ast_block *block, ast_expression **out)
2188 {
2189     bool rv;
2190     char *label = NULL;
2191
2192     /* skip the 'do' and get the body */
2193     if (!parser_next(parser)) {
2194         if (OPTS_FLAG(LOOP_LABELS))
2195             parseerror(parser, "expected loop label or body");
2196         else
2197             parseerror(parser, "expected loop body");
2198         return false;
2199     }
2200
2201     if (parser->tok == ':') {
2202         if (!OPTS_FLAG(LOOP_LABELS))
2203             parseerror(parser, "labeled loops not activated, try using -floop-labels");
2204         if (!parser_next(parser) || parser->tok != TOKEN_IDENT) {
2205             parseerror(parser, "expected loop label");
2206             return false;
2207         }
2208         label = util_strdup(parser_tokval(parser));
2209         if (!parser_next(parser)) {
2210             mem_d(label);
2211             parseerror(parser, "expected loop body");
2212             return false;
2213         }
2214     }
2215
2216     vec_push(parser->breaks, label);
2217     vec_push(parser->continues, label);
2218
2219     rv = parse_dowhile_go(parser, block, out);
2220     if (label)
2221         mem_d(label);
2222     if (vec_last(parser->breaks) != label || vec_last(parser->continues) != label) {
2223         parseerror(parser, "internal error: label stack corrupted");
2224         rv = false;
2225         ast_delete(*out);
2226         *out = NULL;
2227     }
2228     else {
2229         vec_pop(parser->breaks);
2230         vec_pop(parser->continues);
2231     }
2232     return rv;
2233 }
2234
2235 static bool parse_dowhile_go(parser_t *parser, ast_block *block, ast_expression **out)
2236 {
2237     ast_loop *aloop;
2238     ast_expression *cond, *ontrue;
2239
2240     bool ifnot = false;
2241
2242     lex_ctx ctx = parser_ctx(parser);
2243
2244     (void)block; /* not touching */
2245
2246     if (!parse_statement_or_block(parser, &ontrue))
2247         return false;
2248
2249     /* expect the "while" */
2250     if (parser->tok != TOKEN_KEYWORD ||
2251         strcmp(parser_tokval(parser), "while"))
2252     {
2253         parseerror(parser, "expected 'while' and condition");
2254         ast_delete(ontrue);
2255         return false;
2256     }
2257
2258     /* skip the 'while' and check for opening paren */
2259     if (!parser_next(parser) || parser->tok != '(') {
2260         parseerror(parser, "expected 'while' condition in parenthesis");
2261         ast_delete(ontrue);
2262         return false;
2263     }
2264     /* parse into the expression */
2265     if (!parser_next(parser)) {
2266         parseerror(parser, "expected 'while' condition after opening paren");
2267         ast_delete(ontrue);
2268         return false;
2269     }
2270     /* parse the condition */
2271     cond = parse_expression_leave(parser, false);
2272     if (!cond)
2273         return false;
2274     /* closing paren */
2275     if (parser->tok != ')') {
2276         parseerror(parser, "expected closing paren after 'while' condition");
2277         ast_delete(ontrue);
2278         ast_delete(cond);
2279         return false;
2280     }
2281     /* parse on */
2282     if (!parser_next(parser) || parser->tok != ';') {
2283         parseerror(parser, "expected semicolon after condition");
2284         ast_delete(ontrue);
2285         ast_delete(cond);
2286         return false;
2287     }
2288
2289     if (!parser_next(parser)) {
2290         parseerror(parser, "parse error");
2291         ast_delete(ontrue);
2292         ast_delete(cond);
2293         return false;
2294     }
2295
2296     cond = process_condition(parser, cond, &ifnot);
2297     if (!cond) {
2298         ast_delete(ontrue);
2299         return false;
2300     }
2301     aloop = ast_loop_new(ctx, NULL, NULL, false, cond, ifnot, NULL, ontrue);
2302     *out = (ast_expression*)aloop;
2303     return true;
2304 }
2305
2306 static bool parse_for_go(parser_t *parser, ast_block *block, ast_expression **out);
2307 static bool parse_for(parser_t *parser, ast_block *block, ast_expression **out)
2308 {
2309     bool rv;
2310     char *label = NULL;
2311
2312     /* skip the 'for' and check for opening paren */
2313     if (!parser_next(parser)) {
2314         if (OPTS_FLAG(LOOP_LABELS))
2315             parseerror(parser, "expected loop label or 'for' expressions in parenthesis");
2316         else
2317             parseerror(parser, "expected 'for' expressions in parenthesis");
2318         return false;
2319     }
2320
2321     if (parser->tok == ':') {
2322         if (!OPTS_FLAG(LOOP_LABELS))
2323             parseerror(parser, "labeled loops not activated, try using -floop-labels");
2324         if (!parser_next(parser) || parser->tok != TOKEN_IDENT) {
2325             parseerror(parser, "expected loop label");
2326             return false;
2327         }
2328         label = util_strdup(parser_tokval(parser));
2329         if (!parser_next(parser)) {
2330             mem_d(label);
2331             parseerror(parser, "expected 'for' expressions in parenthesis");
2332             return false;
2333         }
2334     }
2335
2336     if (parser->tok != '(') {
2337         parseerror(parser, "expected 'for' expressions in parenthesis");
2338         return false;
2339     }
2340
2341     vec_push(parser->breaks, label);
2342     vec_push(parser->continues, label);
2343
2344     rv = parse_for_go(parser, block, out);
2345     if (label)
2346         mem_d(label);
2347     if (vec_last(parser->breaks) != label || vec_last(parser->continues) != label) {
2348         parseerror(parser, "internal error: label stack corrupted");
2349         rv = false;
2350         ast_delete(*out);
2351         *out = NULL;
2352     }
2353     else {
2354         vec_pop(parser->breaks);
2355         vec_pop(parser->continues);
2356     }
2357     return rv;
2358 }
2359 static bool parse_for_go(parser_t *parser, ast_block *block, ast_expression **out)
2360 {
2361     ast_loop       *aloop;
2362     ast_expression *initexpr, *cond, *increment, *ontrue;
2363     ast_value      *typevar;
2364
2365     bool retval = true;
2366     bool ifnot  = false;
2367
2368     lex_ctx ctx = parser_ctx(parser);
2369
2370     parser_enterblock(parser);
2371
2372     initexpr  = NULL;
2373     cond      = NULL;
2374     increment = NULL;
2375     ontrue    = NULL;
2376
2377     /* parse into the expression */
2378     if (!parser_next(parser)) {
2379         parseerror(parser, "expected 'for' initializer after opening paren");
2380         goto onerr;
2381     }
2382
2383     typevar = NULL;
2384     if (parser->tok == TOKEN_IDENT)
2385         typevar = parser_find_typedef(parser, parser_tokval(parser), 0);
2386
2387     if (typevar || parser->tok == TOKEN_TYPENAME) {
2388         if (opts.standard != COMPILER_GMQCC) {
2389             if (parsewarning(parser, WARN_EXTENSIONS,
2390                              "current standard does not allow variable declarations in for-loop initializers"))
2391                 goto onerr;
2392         }
2393         if (!parse_variable(parser, block, true, CV_VAR, typevar, false, false, 0))
2394             goto onerr;
2395     }
2396     else if (parser->tok != ';')
2397     {
2398         initexpr = parse_expression_leave(parser, false);
2399         if (!initexpr)
2400             goto onerr;
2401     }
2402
2403     /* move on to condition */
2404     if (parser->tok != ';') {
2405         parseerror(parser, "expected semicolon after for-loop initializer");
2406         goto onerr;
2407     }
2408     if (!parser_next(parser)) {
2409         parseerror(parser, "expected for-loop condition");
2410         goto onerr;
2411     }
2412
2413     /* parse the condition */
2414     if (parser->tok != ';') {
2415         cond = parse_expression_leave(parser, false);
2416         if (!cond)
2417             goto onerr;
2418     }
2419
2420     /* move on to incrementor */
2421     if (parser->tok != ';') {
2422         parseerror(parser, "expected semicolon after for-loop initializer");
2423         goto onerr;
2424     }
2425     if (!parser_next(parser)) {
2426         parseerror(parser, "expected for-loop condition");
2427         goto onerr;
2428     }
2429
2430     /* parse the incrementor */
2431     if (parser->tok != ')') {
2432         increment = parse_expression_leave(parser, false);
2433         if (!increment)
2434             goto onerr;
2435         if (!ast_side_effects(increment)) {
2436             if (genwarning(ast_ctx(increment), WARN_EFFECTLESS_STATEMENT, "statement has no effect"))
2437                 goto onerr;
2438         }
2439     }
2440
2441     /* closing paren */
2442     if (parser->tok != ')') {
2443         parseerror(parser, "expected closing paren after 'for-loop' incrementor");
2444         goto onerr;
2445     }
2446     /* parse into the 'then' branch */
2447     if (!parser_next(parser)) {
2448         parseerror(parser, "expected for-loop body");
2449         goto onerr;
2450     }
2451     if (!parse_statement_or_block(parser, &ontrue))
2452         goto onerr;
2453
2454     if (cond) {
2455         cond = process_condition(parser, cond, &ifnot);
2456         if (!cond)
2457             goto onerr;
2458     }
2459     aloop = ast_loop_new(ctx, initexpr, cond, ifnot, NULL, false, increment, ontrue);
2460     *out = (ast_expression*)aloop;
2461
2462     if (!parser_leaveblock(parser))
2463         retval = false;
2464     return retval;
2465 onerr:
2466     if (initexpr)  ast_delete(initexpr);
2467     if (cond)      ast_delete(cond);
2468     if (increment) ast_delete(increment);
2469     (void)!parser_leaveblock(parser);
2470     return false;
2471 }
2472
2473 static bool parse_return(parser_t *parser, ast_block *block, ast_expression **out)
2474 {
2475     ast_expression *exp = NULL;
2476     ast_return     *ret = NULL;
2477     ast_value      *expected = parser->function->vtype;
2478
2479     lex_ctx ctx = parser_ctx(parser);
2480
2481     (void)block; /* not touching */
2482
2483     if (!parser_next(parser)) {
2484         parseerror(parser, "expected return expression");
2485         return false;
2486     }
2487
2488     if (parser->tok != ';') {
2489         exp = parse_expression(parser, false);
2490         if (!exp)
2491             return false;
2492
2493         if (exp->expression.vtype != expected->expression.next->expression.vtype) {
2494             parseerror(parser, "return with invalid expression");
2495         }
2496
2497         ret = ast_return_new(ctx, exp);
2498         if (!ret) {
2499             ast_delete(exp);
2500             return false;
2501         }
2502     } else {
2503         if (!parser_next(parser))
2504             parseerror(parser, "parse error");
2505         if (expected->expression.next->expression.vtype != TYPE_VOID) {
2506             if (opts.standard != COMPILER_GMQCC)
2507                 (void)!parsewarning(parser, WARN_MISSING_RETURN_VALUES, "return without value");
2508             else
2509                 parseerror(parser, "return without value");
2510         }
2511         ret = ast_return_new(ctx, NULL);
2512     }
2513     *out = (ast_expression*)ret;
2514     return true;
2515 }
2516
2517 static bool parse_break_continue(parser_t *parser, ast_block *block, ast_expression **out, bool is_continue)
2518 {
2519     size_t       i;
2520     unsigned int levels = 0;
2521     lex_ctx      ctx = parser_ctx(parser);
2522     const char **loops = (is_continue ? parser->continues : parser->breaks);
2523
2524     (void)block; /* not touching */
2525     if (!parser_next(parser)) {
2526         parseerror(parser, "expected semicolon or loop label");
2527         return false;
2528     }
2529
2530     if (parser->tok == TOKEN_IDENT) {
2531         if (!OPTS_FLAG(LOOP_LABELS))
2532             parseerror(parser, "labeled loops not activated, try using -floop-labels");
2533         i = vec_size(loops);
2534         while (i--) {
2535             if (loops[i] && !strcmp(loops[i], parser_tokval(parser)))
2536                 break;
2537             if (!i) {
2538                 parseerror(parser, "no such loop to %s: `%s`",
2539                            (is_continue ? "continue" : "break out of"),
2540                            parser_tokval(parser));
2541                 return false;
2542             }
2543             ++levels;
2544         }
2545         if (!parser_next(parser)) {
2546             parseerror(parser, "expected semicolon");
2547             return false;
2548         }
2549     }
2550
2551     if (parser->tok != ';') {
2552         parseerror(parser, "expected semicolon");
2553         return false;
2554     }
2555
2556     if (!parser_next(parser))
2557         parseerror(parser, "parse error");
2558
2559     *out = (ast_expression*)ast_breakcont_new(ctx, is_continue, levels);
2560     return true;
2561 }
2562
2563 /* returns true when it was a variable qualifier, false otherwise!
2564  * on error, cvq is set to CV_WRONG
2565  */
2566 static bool parse_qualifiers(parser_t *parser, bool with_local, int *cvq, bool *noref, bool *is_static, uint32_t *_flags)
2567 {
2568     bool had_const    = false;
2569     bool had_var      = false;
2570     bool had_noref    = false;
2571     bool had_attrib   = false;
2572     bool had_static   = false;
2573     uint32_t flags    = 0;
2574
2575     *cvq = CV_NONE;
2576     for (;;) {
2577         if (parser->tok == TOKEN_ATTRIBUTE_OPEN) {
2578             had_attrib = true;
2579             /* parse an attribute */
2580             if (!parser_next(parser)) {
2581                 parseerror(parser, "expected attribute after `[[`");
2582                 *cvq = CV_WRONG;
2583                 return false;
2584             }
2585             if (!strcmp(parser_tokval(parser), "noreturn")) {
2586                 flags |= AST_FLAG_NORETURN;
2587                 if (!parser_next(parser) || parser->tok != TOKEN_ATTRIBUTE_CLOSE) {
2588                     parseerror(parser, "`noreturn` attribute has no parameters, expected `]]`");
2589                     *cvq = CV_WRONG;
2590                     return false;
2591                 }
2592             }
2593             else if (!strcmp(parser_tokval(parser), "noref")) {
2594                 had_noref = true;
2595                 if (!parser_next(parser) || parser->tok != TOKEN_ATTRIBUTE_CLOSE) {
2596                     parseerror(parser, "`noref` attribute has no parameters, expected `]]`");
2597                     *cvq = CV_WRONG;
2598                     return false;
2599                 }
2600             }
2601             else if (!strcmp(parser_tokval(parser), "inline")) {
2602                 flags |= AST_FLAG_INLINE;
2603                 if (!parser_next(parser) || parser->tok != TOKEN_ATTRIBUTE_CLOSE) {
2604                     parseerror(parser, "`noref` attribute has no parameters, expected `]]`");
2605                     *cvq = CV_WRONG;
2606                     return false;
2607                 }
2608             }
2609             else
2610             {
2611                 /* Skip tokens until we hit a ]] */
2612                 (void)!parsewarning(parser, WARN_UNKNOWN_ATTRIBUTE, "unknown attribute starting with `%s`", parser_tokval(parser));
2613                 while (parser->tok != TOKEN_ATTRIBUTE_CLOSE) {
2614                     if (!parser_next(parser)) {
2615                         parseerror(parser, "error inside attribute");
2616                         *cvq = CV_WRONG;
2617                         return false;
2618                     }
2619                 }
2620             }
2621         }
2622         else if (!strcmp(parser_tokval(parser), "static"))
2623             had_static = true;
2624         else if (!strcmp(parser_tokval(parser), "const"))
2625             had_const = true;
2626         else if (!strcmp(parser_tokval(parser), "var"))
2627             had_var = true;
2628         else if (with_local && !strcmp(parser_tokval(parser), "local"))
2629             had_var = true;
2630         else if (!strcmp(parser_tokval(parser), "noref"))
2631             had_noref = true;
2632         else if (!had_const && !had_var && !had_noref && !had_attrib && !had_static && !flags) {
2633             return false;
2634         }
2635         else
2636             break;
2637         if (!parser_next(parser))
2638             goto onerr;
2639     }
2640     if (had_const)
2641         *cvq = CV_CONST;
2642     else if (had_var)
2643         *cvq = CV_VAR;
2644     else
2645         *cvq = CV_NONE;
2646     *noref     = had_noref;
2647     *is_static = had_static;
2648     *_flags    = flags;
2649     return true;
2650 onerr:
2651     parseerror(parser, "parse error after variable qualifier");
2652     *cvq = CV_WRONG;
2653     return true;
2654 }
2655
2656 static bool parse_switch_go(parser_t *parser, ast_block *block, ast_expression **out);
2657 static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **out)
2658 {
2659     bool rv;
2660     char *label = NULL;
2661
2662     /* skip the 'while' and get the body */
2663     if (!parser_next(parser)) {
2664         if (OPTS_FLAG(LOOP_LABELS))
2665             parseerror(parser, "expected loop label or 'switch' operand in parenthesis");
2666         else
2667             parseerror(parser, "expected 'switch' operand in parenthesis");
2668         return false;
2669     }
2670
2671     if (parser->tok == ':') {
2672         if (!OPTS_FLAG(LOOP_LABELS))
2673             parseerror(parser, "labeled loops not activated, try using -floop-labels");
2674         if (!parser_next(parser) || parser->tok != TOKEN_IDENT) {
2675             parseerror(parser, "expected loop label");
2676             return false;
2677         }
2678         label = util_strdup(parser_tokval(parser));
2679         if (!parser_next(parser)) {
2680             mem_d(label);
2681             parseerror(parser, "expected 'switch' operand in parenthesis");
2682             return false;
2683         }
2684     }
2685
2686     if (parser->tok != '(') {
2687         parseerror(parser, "expected 'switch' operand in parenthesis");
2688         return false;
2689     }
2690
2691     vec_push(parser->breaks, label);
2692
2693     rv = parse_switch_go(parser, block, out);
2694     if (label)
2695         mem_d(label);
2696     if (vec_last(parser->breaks) != label) {
2697         parseerror(parser, "internal error: label stack corrupted");
2698         rv = false;
2699         ast_delete(*out);
2700         *out = NULL;
2701     }
2702     else {
2703         vec_pop(parser->breaks);
2704     }
2705     return rv;
2706 }
2707
2708 static bool parse_switch_go(parser_t *parser, ast_block *block, ast_expression **out)
2709 {
2710     ast_expression *operand;
2711     ast_value      *opval;
2712     ast_value      *typevar;
2713     ast_switch     *switchnode;
2714     ast_switch_case swcase;
2715
2716     int  cvq;
2717     bool noref, is_static;
2718     uint32_t qflags = 0;
2719
2720     lex_ctx ctx = parser_ctx(parser);
2721
2722     (void)block; /* not touching */
2723     (void)opval;
2724
2725     /* parse into the expression */
2726     if (!parser_next(parser)) {
2727         parseerror(parser, "expected switch operand");
2728         return false;
2729     }
2730     /* parse the operand */
2731     operand = parse_expression_leave(parser, false);
2732     if (!operand)
2733         return false;
2734
2735     switchnode = ast_switch_new(ctx, operand);
2736
2737     /* closing paren */
2738     if (parser->tok != ')') {
2739         ast_delete(switchnode);
2740         parseerror(parser, "expected closing paren after 'switch' operand");
2741         return false;
2742     }
2743
2744     /* parse over the opening paren */
2745     if (!parser_next(parser) || parser->tok != '{') {
2746         ast_delete(switchnode);
2747         parseerror(parser, "expected list of cases");
2748         return false;
2749     }
2750
2751     if (!parser_next(parser)) {
2752         ast_delete(switchnode);
2753         parseerror(parser, "expected 'case' or 'default'");
2754         return false;
2755     }
2756
2757     /* new block; allow some variables to be declared here */
2758     parser_enterblock(parser);
2759     while (true) {
2760         typevar = NULL;
2761         if (parser->tok == TOKEN_IDENT)
2762             typevar = parser_find_typedef(parser, parser_tokval(parser), 0);
2763         if (typevar || parser->tok == TOKEN_TYPENAME) {
2764             if (!parse_variable(parser, block, false, CV_NONE, typevar, false, false, 0)) {
2765                 ast_delete(switchnode);
2766                 return false;
2767             }
2768             continue;
2769         }
2770         if (parse_qualifiers(parser, true, &cvq, &noref, &is_static, &qflags))
2771         {
2772             if (cvq == CV_WRONG) {
2773                 ast_delete(switchnode);
2774                 return false;
2775             }
2776             if (!parse_variable(parser, block, false, cvq, NULL, noref, is_static, qflags)) {
2777                 ast_delete(switchnode);
2778                 return false;
2779             }
2780             continue;
2781         }
2782         break;
2783     }
2784
2785     /* case list! */
2786     while (parser->tok != '}') {
2787         ast_block *caseblock;
2788
2789         if (!strcmp(parser_tokval(parser), "case")) {
2790             if (!parser_next(parser)) {
2791                 ast_delete(switchnode);
2792                 parseerror(parser, "expected expression for case");
2793                 return false;
2794             }
2795             swcase.value = parse_expression_leave(parser, false);
2796             if (!swcase.value) {
2797                 ast_delete(switchnode);
2798                 parseerror(parser, "expected expression for case");
2799                 return false;
2800             }
2801             if (!OPTS_FLAG(RELAXED_SWITCH)) {
2802                 if (!ast_istype(swcase.value, ast_value)) { /* || ((ast_value*)swcase.value)->cvq != CV_CONST) { */
2803                     parseerror(parser, "case on non-constant values need to be explicitly enabled via -frelaxed-switch");
2804                     ast_unref(operand);
2805                     return false;
2806                 }
2807             }
2808         }
2809         else if (!strcmp(parser_tokval(parser), "default")) {
2810             swcase.value = NULL;
2811             if (!parser_next(parser)) {
2812                 ast_delete(switchnode);
2813                 parseerror(parser, "expected colon");
2814                 return false;
2815             }
2816         }
2817         else {
2818             ast_delete(switchnode);
2819             parseerror(parser, "expected 'case' or 'default'");
2820             return false;
2821         }
2822
2823         /* Now the colon and body */
2824         if (parser->tok != ':') {
2825             if (swcase.value) ast_unref(swcase.value);
2826             ast_delete(switchnode);
2827             parseerror(parser, "expected colon");
2828             return false;
2829         }
2830
2831         if (!parser_next(parser)) {
2832             if (swcase.value) ast_unref(swcase.value);
2833             ast_delete(switchnode);
2834             parseerror(parser, "expected statements or case");
2835             return false;
2836         }
2837         caseblock = ast_block_new(parser_ctx(parser));
2838         if (!caseblock) {
2839             if (swcase.value) ast_unref(swcase.value);
2840             ast_delete(switchnode);
2841             return false;
2842         }
2843         swcase.code = (ast_expression*)caseblock;
2844         vec_push(switchnode->cases, swcase);
2845         while (true) {
2846             ast_expression *expr;
2847             if (parser->tok == '}')
2848                 break;
2849             if (parser->tok == TOKEN_KEYWORD) {
2850                 if (!strcmp(parser_tokval(parser), "case") ||
2851                     !strcmp(parser_tokval(parser), "default"))
2852                 {
2853                     break;
2854                 }
2855             }
2856             if (!parse_statement(parser, caseblock, &expr, true)) {
2857                 ast_delete(switchnode);
2858                 return false;
2859             }
2860             if (!expr)
2861                 continue;
2862             if (!ast_block_add_expr(caseblock, expr)) {
2863                 ast_delete(switchnode);
2864                 return false;
2865             }
2866         }
2867     }
2868
2869     parser_leaveblock(parser);
2870
2871     /* closing paren */
2872     if (parser->tok != '}') {
2873         ast_delete(switchnode);
2874         parseerror(parser, "expected closing paren of case list");
2875         return false;
2876     }
2877     if (!parser_next(parser)) {
2878         ast_delete(switchnode);
2879         parseerror(parser, "parse error after switch");
2880         return false;
2881     }
2882     *out = (ast_expression*)switchnode;
2883     return true;
2884 }
2885
2886 static bool parse_goto(parser_t *parser, ast_expression **out)
2887 {
2888     size_t    i;
2889     ast_goto *gt;
2890
2891     if (!parser_next(parser) || parser->tok != TOKEN_IDENT) {
2892         parseerror(parser, "expected label name after `goto`");
2893         return false;
2894     }
2895
2896     gt = ast_goto_new(parser_ctx(parser), parser_tokval(parser));
2897
2898     for (i = 0; i < vec_size(parser->labels); ++i) {
2899         if (!strcmp(parser->labels[i]->name, parser_tokval(parser))) {
2900             ast_goto_set_label(gt, parser->labels[i]);
2901             break;
2902         }
2903     }
2904     if (i == vec_size(parser->labels))
2905         vec_push(parser->gotos, gt);
2906
2907     if (!parser_next(parser) || parser->tok != ';') {
2908         parseerror(parser, "semicolon expected after goto label");
2909         return false;
2910     }
2911     if (!parser_next(parser)) {
2912         parseerror(parser, "parse error after goto");
2913         return false;
2914     }
2915
2916     *out = (ast_expression*)gt;
2917     return true;
2918 }
2919
2920 static bool parse_skipwhite(parser_t *parser)
2921 {
2922     do {
2923         if (!parser_next(parser))
2924             return false;
2925     } while (parser->tok == TOKEN_WHITE && parser->tok < TOKEN_ERROR);
2926     return parser->tok < TOKEN_ERROR;
2927 }
2928
2929 static bool parse_eol(parser_t *parser)
2930 {
2931     if (!parse_skipwhite(parser))
2932         return false;
2933     return parser->tok == TOKEN_EOL;
2934 }
2935
2936 static bool parse_pragma_do(parser_t *parser)
2937 {
2938     if (!parser_next(parser) ||
2939         parser->tok != TOKEN_IDENT ||
2940         strcmp(parser_tokval(parser), "pragma"))
2941     {
2942         parseerror(parser, "expected `pragma` keyword after `#`, got `%s`", parser_tokval(parser));
2943         return false;
2944     }
2945     if (!parse_skipwhite(parser) || parser->tok != TOKEN_IDENT) {
2946         parseerror(parser, "expected pragma, got `%s`", parser_tokval(parser));
2947         return false;
2948     }
2949
2950     if (!strcmp(parser_tokval(parser), "noref")) {
2951         if (!parse_skipwhite(parser) || parser->tok != TOKEN_INTCONST) {
2952             parseerror(parser, "`noref` pragma requires an argument: 0 or 1");
2953             return false;
2954         }
2955         parser->noref = !!parser_token(parser)->constval.i;
2956         if (!parse_eol(parser)) {
2957             parseerror(parser, "parse error after `noref` pragma");
2958             return false;
2959         }
2960     }
2961     else
2962     {
2963         (void)!parsewarning(parser, WARN_UNKNOWN_PRAGMAS, "ignoring #pragma %s", parser_tokval(parser));
2964         return false;
2965     }
2966
2967     return true;
2968 }
2969
2970 static bool parse_pragma(parser_t *parser)
2971 {
2972     bool rv;
2973     parser->lex->flags.preprocessing = true;
2974     parser->lex->flags.mergelines = true;
2975     rv = parse_pragma_do(parser);
2976     if (parser->tok != TOKEN_EOL) {
2977         parseerror(parser, "junk after pragma");
2978         rv = false;
2979     }
2980     parser->lex->flags.preprocessing = false;
2981     parser->lex->flags.mergelines = false;
2982     if (!parser_next(parser)) {
2983         parseerror(parser, "parse error after pragma");
2984         rv = false;
2985     }
2986     return rv;
2987 }
2988
2989 static bool parse_statement(parser_t *parser, ast_block *block, ast_expression **out, bool allow_cases)
2990 {
2991     bool       noref, is_static;
2992     int        cvq = CV_NONE;
2993     uint32_t   qflags = 0;
2994     ast_value *typevar = NULL;
2995
2996     *out = NULL;
2997
2998     if (parser->tok == TOKEN_IDENT)
2999         typevar = parser_find_typedef(parser, parser_tokval(parser), 0);
3000
3001     if (typevar || parser->tok == TOKEN_TYPENAME || parser->tok == '.')
3002     {
3003         /* local variable */
3004         if (!block) {
3005             parseerror(parser, "cannot declare a variable from here");
3006             return false;
3007         }
3008         if (opts.standard == COMPILER_QCC) {
3009             if (parsewarning(parser, WARN_EXTENSIONS, "missing 'local' keyword when declaring a local variable"))
3010                 return false;
3011         }
3012         if (!parse_variable(parser, block, false, CV_NONE, typevar, false, false, 0))
3013             return false;
3014         return true;
3015     }
3016     else if (parse_qualifiers(parser, !!block, &cvq, &noref, &is_static, &qflags))
3017     {
3018         if (cvq == CV_WRONG)
3019             return false;
3020         return parse_variable(parser, block, true, cvq, NULL, noref, is_static, qflags);
3021     }
3022     else if (parser->tok == TOKEN_KEYWORD)
3023     {
3024         if (!strcmp(parser_tokval(parser), "__builtin_debug_printtype"))
3025         {
3026             char ty[1024];
3027             ast_value *tdef;
3028
3029             if (!parser_next(parser)) {
3030                 parseerror(parser, "parse error after __builtin_debug_printtype");
3031                 return false;
3032             }
3033
3034             if (parser->tok == TOKEN_IDENT && (tdef = parser_find_typedef(parser, parser_tokval(parser), 0)))
3035             {
3036                 ast_type_to_string((ast_expression*)tdef, ty, sizeof(ty));
3037                 con_out("__builtin_debug_printtype: `%s`=`%s`\n", tdef->name, ty);
3038                 if (!parser_next(parser)) {
3039                     parseerror(parser, "parse error after __builtin_debug_printtype typename argument");
3040                     return false;
3041                 }
3042             }
3043             else
3044             {
3045                 if (!parse_statement(parser, block, out, allow_cases))
3046                     return false;
3047                 if (!*out)
3048                     con_out("__builtin_debug_printtype: got no output node\n");
3049                 else
3050                 {
3051                     ast_type_to_string(*out, ty, sizeof(ty));
3052                     con_out("__builtin_debug_printtype: `%s`\n", ty);
3053                 }
3054             }
3055             return true;
3056         }
3057         else if (!strcmp(parser_tokval(parser), "return"))
3058         {
3059             return parse_return(parser, block, out);
3060         }
3061         else if (!strcmp(parser_tokval(parser), "if"))
3062         {
3063             return parse_if(parser, block, out);
3064         }
3065         else if (!strcmp(parser_tokval(parser), "while"))
3066         {
3067             return parse_while(parser, block, out);
3068         }
3069         else if (!strcmp(parser_tokval(parser), "do"))
3070         {
3071             return parse_dowhile(parser, block, out);
3072         }
3073         else if (!strcmp(parser_tokval(parser), "for"))
3074         {
3075             if (opts.standard == COMPILER_QCC) {
3076                 if (parsewarning(parser, WARN_EXTENSIONS, "for loops are not recognized in the original Quake C standard, to enable try an alternate standard --std=?"))
3077                     return false;
3078             }
3079             return parse_for(parser, block, out);
3080         }
3081         else if (!strcmp(parser_tokval(parser), "break"))
3082         {
3083             return parse_break_continue(parser, block, out, false);
3084         }
3085         else if (!strcmp(parser_tokval(parser), "continue"))
3086         {
3087             return parse_break_continue(parser, block, out, true);
3088         }
3089         else if (!strcmp(parser_tokval(parser), "switch"))
3090         {
3091             return parse_switch(parser, block, out);
3092         }
3093         else if (!strcmp(parser_tokval(parser), "case") ||
3094                  !strcmp(parser_tokval(parser), "default"))
3095         {
3096             if (!allow_cases) {
3097                 parseerror(parser, "unexpected 'case' label");
3098                 return false;
3099             }
3100             return true;
3101         }
3102         else if (!strcmp(parser_tokval(parser), "goto"))
3103         {
3104             return parse_goto(parser, out);
3105         }
3106         else if (!strcmp(parser_tokval(parser), "typedef"))
3107         {
3108             if (!parser_next(parser)) {
3109                 parseerror(parser, "expected type definition after 'typedef'");
3110                 return false;
3111             }
3112             return parse_typedef(parser);
3113         }
3114         parseerror(parser, "Unexpected keyword");
3115         return false;
3116     }
3117     else if (parser->tok == '{')
3118     {
3119         ast_block *inner;
3120         inner = parse_block(parser);
3121         if (!inner)
3122             return false;
3123         *out = (ast_expression*)inner;
3124         return true;
3125     }
3126     else if (parser->tok == ':')
3127     {
3128         size_t i;
3129         ast_label *label;
3130         if (!parser_next(parser)) {
3131             parseerror(parser, "expected label name");
3132             return false;
3133         }
3134         if (parser->tok != TOKEN_IDENT) {
3135             parseerror(parser, "label must be an identifier");
3136             return false;
3137         }
3138         label = ast_label_new(parser_ctx(parser), parser_tokval(parser));
3139         if (!label)
3140             return false;
3141         vec_push(parser->labels, label);
3142         *out = (ast_expression*)label;
3143         if (!parser_next(parser)) {
3144             parseerror(parser, "parse error after label");
3145             return false;
3146         }
3147         for (i = 0; i < vec_size(parser->gotos); ++i) {
3148             if (!strcmp(parser->gotos[i]->name, label->name)) {
3149                 ast_goto_set_label(parser->gotos[i], label);
3150                 vec_remove(parser->gotos, i, 1);
3151                 --i;
3152             }
3153         }
3154         return true;
3155     }
3156     else if (parser->tok == ';')
3157     {
3158         if (!parser_next(parser)) {
3159             parseerror(parser, "parse error after empty statement");
3160             return false;
3161         }
3162         return true;
3163     }
3164     else
3165     {
3166         ast_expression *exp = parse_expression(parser, false);
3167         if (!exp)
3168             return false;
3169         *out = exp;
3170         if (!ast_side_effects(exp)) {
3171             if (genwarning(ast_ctx(exp), WARN_EFFECTLESS_STATEMENT, "statement has no effect"))
3172                 return false;
3173         }
3174         return true;
3175     }
3176 }
3177
3178 static bool parse_block_into(parser_t *parser, ast_block *block)
3179 {
3180     bool   retval = true;
3181
3182     parser_enterblock(parser);
3183
3184     if (!parser_next(parser)) { /* skip the '{' */
3185         parseerror(parser, "expected function body");
3186         goto cleanup;
3187     }
3188
3189     while (parser->tok != TOKEN_EOF && parser->tok < TOKEN_ERROR)
3190     {
3191         ast_expression *expr = NULL;
3192         if (parser->tok == '}')
3193             break;
3194
3195         if (!parse_statement(parser, block, &expr, false)) {
3196             /* parseerror(parser, "parse error"); */
3197             block = NULL;
3198             goto cleanup;
3199         }
3200         if (!expr)
3201             continue;
3202         if (!ast_block_add_expr(block, expr)) {
3203             ast_delete(block);
3204             block = NULL;
3205             goto cleanup;
3206         }
3207     }
3208
3209     if (parser->tok != '}') {
3210         block = NULL;
3211     } else {
3212         (void)parser_next(parser);
3213     }
3214
3215 cleanup:
3216     if (!parser_leaveblock(parser))
3217         retval = false;
3218     return retval && !!block;
3219 }
3220
3221 static ast_block* parse_block(parser_t *parser)
3222 {
3223     ast_block *block;
3224     block = ast_block_new(parser_ctx(parser));
3225     if (!block)
3226         return NULL;
3227     if (!parse_block_into(parser, block)) {
3228         ast_block_delete(block);
3229         return NULL;
3230     }
3231     return block;
3232 }
3233
3234 static bool parse_statement_or_block(parser_t *parser, ast_expression **out)
3235 {
3236     if (parser->tok == '{') {
3237         *out = (ast_expression*)parse_block(parser);
3238         return !!*out;
3239     }
3240     return parse_statement(parser, NULL, out, false);
3241 }
3242
3243 static bool create_vector_members(ast_value *var, ast_member **me)
3244 {
3245     size_t i;
3246     size_t len = strlen(var->name);
3247
3248     for (i = 0; i < 3; ++i) {
3249         char *name = (char*)mem_a(len+3);
3250         memcpy(name, var->name, len);
3251         name[len+0] = '_';
3252         name[len+1] = 'x'+i;
3253         name[len+2] = 0;
3254         me[i] = ast_member_new(ast_ctx(var), (ast_expression*)var, i, name);
3255         mem_d(name);
3256         if (!me[i])
3257             break;
3258     }
3259     if (i == 3)
3260         return true;
3261
3262     /* unroll */
3263     do { ast_member_delete(me[--i]); } while(i);
3264     return false;
3265 }
3266
3267 static bool parse_function_body(parser_t *parser, ast_value *var)
3268 {
3269     ast_block      *block = NULL;
3270     ast_function   *func;
3271     ast_function   *old;
3272     size_t          parami;
3273
3274     ast_expression *framenum  = NULL;
3275     ast_expression *nextthink = NULL;
3276     /* None of the following have to be deleted */
3277     ast_expression *fld_think = NULL, *fld_nextthink = NULL, *fld_frame = NULL;
3278     ast_expression *gbl_time = NULL, *gbl_self = NULL;
3279     bool            has_frame_think;
3280
3281     bool retval = true;
3282
3283     has_frame_think = false;
3284     old = parser->function;
3285
3286     if (vec_size(parser->gotos) || vec_size(parser->labels)) {
3287         parseerror(parser, "gotos/labels leaking");
3288         return false;
3289     }
3290
3291     if (var->expression.flags & AST_FLAG_VARIADIC) {
3292         if (parsewarning(parser, WARN_VARIADIC_FUNCTION,
3293                          "variadic function with implementation will not be able to access additional parameters"))
3294         {
3295             return false;
3296         }
3297     }
3298
3299     if (parser->tok == '[') {
3300         /* got a frame definition: [ framenum, nextthink ]
3301          * this translates to:
3302          * self.frame = framenum;
3303          * self.nextthink = time + 0.1;
3304          * self.think = nextthink;
3305          */
3306         nextthink = NULL;
3307
3308         fld_think     = parser_find_field(parser, "think");
3309         fld_nextthink = parser_find_field(parser, "nextthink");
3310         fld_frame     = parser_find_field(parser, "frame");
3311         if (!fld_think || !fld_nextthink || !fld_frame) {
3312             parseerror(parser, "cannot use [frame,think] notation without the required fields");
3313             parseerror(parser, "please declare the following entityfields: `frame`, `think`, `nextthink`");
3314             return false;
3315         }
3316         gbl_time      = parser_find_global(parser, "time");
3317         gbl_self      = parser_find_global(parser, "self");
3318         if (!gbl_time || !gbl_self) {
3319             parseerror(parser, "cannot use [frame,think] notation without the required globals");
3320             parseerror(parser, "please declare the following globals: `time`, `self`");
3321             return false;
3322         }
3323
3324         if (!parser_next(parser))
3325             return false;
3326
3327         framenum = parse_expression_leave(parser, true);
3328         if (!framenum) {
3329             parseerror(parser, "expected a framenumber constant in[frame,think] notation");
3330             return false;
3331         }
3332         if (!ast_istype(framenum, ast_value) || !( (ast_value*)framenum )->hasvalue) {
3333             ast_unref(framenum);
3334             parseerror(parser, "framenumber in [frame,think] notation must be a constant");
3335             return false;
3336         }
3337
3338         if (parser->tok != ',') {
3339             ast_unref(framenum);
3340             parseerror(parser, "expected comma after frame number in [frame,think] notation");
3341             parseerror(parser, "Got a %i\n", parser->tok);
3342             return false;
3343         }
3344
3345         if (!parser_next(parser)) {
3346             ast_unref(framenum);
3347             return false;
3348         }
3349
3350         if (parser->tok == TOKEN_IDENT && !parser_find_var(parser, parser_tokval(parser)))
3351         {
3352             /* qc allows the use of not-yet-declared functions here
3353              * - this automatically creates a prototype */
3354             ast_value      *thinkfunc;
3355             ast_expression *functype = fld_think->expression.next;
3356
3357             thinkfunc = ast_value_new(parser_ctx(parser), parser_tokval(parser), functype->expression.vtype);
3358             if (!thinkfunc || !ast_type_adopt(thinkfunc, functype)) {
3359                 ast_unref(framenum);
3360                 parseerror(parser, "failed to create implicit prototype for `%s`", parser_tokval(parser));
3361                 return false;
3362             }
3363
3364             if (!parser_next(parser)) {
3365                 ast_unref(framenum);
3366                 ast_delete(thinkfunc);
3367                 return false;
3368             }
3369
3370             vec_push(parser->globals, (ast_expression*)thinkfunc);
3371             util_htset(parser->htglobals, thinkfunc->name, thinkfunc);
3372             nextthink = (ast_expression*)thinkfunc;
3373
3374         } else {
3375             nextthink = parse_expression_leave(parser, true);
3376             if (!nextthink) {
3377                 ast_unref(framenum);
3378                 parseerror(parser, "expected a think-function in [frame,think] notation");
3379                 return false;
3380             }
3381         }
3382
3383         if (!ast_istype(nextthink, ast_value)) {
3384             parseerror(parser, "think-function in [frame,think] notation must be a constant");
3385             retval = false;
3386         }
3387
3388         if (retval && parser->tok != ']') {
3389             parseerror(parser, "expected closing `]` for [frame,think] notation");
3390             retval = false;
3391         }
3392
3393         if (retval && !parser_next(parser)) {
3394             retval = false;
3395         }
3396
3397         if (retval && parser->tok != '{') {
3398             parseerror(parser, "a function body has to be declared after a [frame,think] declaration");
3399             retval = false;
3400         }
3401
3402         if (!retval) {
3403             ast_unref(nextthink);
3404             ast_unref(framenum);
3405             return false;
3406         }
3407
3408         has_frame_think = true;
3409     }
3410
3411     block = ast_block_new(parser_ctx(parser));
3412     if (!block) {
3413         parseerror(parser, "failed to allocate block");
3414         if (has_frame_think) {
3415             ast_unref(nextthink);
3416             ast_unref(framenum);
3417         }
3418         return false;
3419     }
3420
3421     if (has_frame_think) {
3422         lex_ctx ctx;
3423         ast_expression *self_frame;
3424         ast_expression *self_nextthink;
3425         ast_expression *self_think;
3426         ast_expression *time_plus_1;
3427         ast_store *store_frame;
3428         ast_store *store_nextthink;
3429         ast_store *store_think;
3430
3431         ctx = parser_ctx(parser);
3432         self_frame     = (ast_expression*)ast_entfield_new(ctx, gbl_self, fld_frame);
3433         self_nextthink = (ast_expression*)ast_entfield_new(ctx, gbl_self, fld_nextthink);
3434         self_think     = (ast_expression*)ast_entfield_new(ctx, gbl_self, fld_think);
3435
3436         time_plus_1    = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_F,
3437                          gbl_time, (ast_expression*)parser_const_float(parser, 0.1));
3438
3439         if (!self_frame || !self_nextthink || !self_think || !time_plus_1) {
3440             if (self_frame)     ast_delete(self_frame);
3441             if (self_nextthink) ast_delete(self_nextthink);
3442             if (self_think)     ast_delete(self_think);
3443             if (time_plus_1)    ast_delete(time_plus_1);
3444             retval = false;
3445         }
3446
3447         if (retval)
3448         {
3449             store_frame     = ast_store_new(ctx, INSTR_STOREP_F,   self_frame,     framenum);
3450             store_nextthink = ast_store_new(ctx, INSTR_STOREP_F,   self_nextthink, time_plus_1);
3451             store_think     = ast_store_new(ctx, INSTR_STOREP_FNC, self_think,     nextthink);
3452
3453             if (!store_frame) {
3454                 ast_delete(self_frame);
3455                 retval = false;
3456             }
3457             if (!store_nextthink) {
3458                 ast_delete(self_nextthink);
3459                 retval = false;
3460             }
3461             if (!store_think) {
3462                 ast_delete(self_think);
3463                 retval = false;
3464             }
3465             if (!retval) {
3466                 if (store_frame)     ast_delete(store_frame);
3467                 if (store_nextthink) ast_delete(store_nextthink);
3468                 if (store_think)     ast_delete(store_think);
3469                 retval = false;
3470             }
3471             if (!ast_block_add_expr(block, (ast_expression*)store_frame) ||
3472                 !ast_block_add_expr(block, (ast_expression*)store_nextthink) ||
3473                 !ast_block_add_expr(block, (ast_expression*)store_think))
3474             {
3475                 retval = false;
3476             }
3477         }
3478
3479         if (!retval) {
3480             parseerror(parser, "failed to generate code for [frame,think]");
3481             ast_unref(nextthink);
3482             ast_unref(framenum);
3483             ast_delete(block);
3484             return false;
3485         }
3486     }
3487
3488     parser_enterblock(parser);
3489
3490     for (parami = 0; parami < vec_size(var->expression.params); ++parami) {
3491         size_t     e;
3492         ast_value *param = var->expression.params[parami];
3493         ast_member *me[3];
3494
3495         if (param->expression.vtype != TYPE_VECTOR &&
3496             (param->expression.vtype != TYPE_FIELD ||
3497              param->expression.next->expression.vtype != TYPE_VECTOR))
3498         {
3499             continue;
3500         }
3501
3502         if (!create_vector_members(param, me)) {
3503             ast_block_delete(block);
3504             return false;
3505         }
3506
3507         for (e = 0; e < 3; ++e) {
3508             parser_addlocal(parser, me[e]->name, (ast_expression*)me[e]);
3509             ast_block_collect(block, (ast_expression*)me[e]);
3510         }
3511     }
3512
3513     func = ast_function_new(ast_ctx(var), var->name, var);
3514     if (!func) {
3515         parseerror(parser, "failed to allocate function for `%s`", var->name);
3516         ast_block_delete(block);
3517         goto enderr;
3518     }
3519     vec_push(parser->functions, func);
3520
3521     parser->function = func;
3522     if (!parse_block_into(parser, block)) {
3523         ast_block_delete(block);
3524         goto enderrfn;
3525     }
3526
3527     vec_push(func->blocks, block);
3528
3529     parser->function = old;
3530     if (!parser_leaveblock(parser))
3531         retval = false;
3532     if (vec_size(parser->variables) != PARSER_HT_LOCALS) {
3533         parseerror(parser, "internal error: local scopes left");
3534         retval = false;
3535     }
3536
3537     if (parser->tok == ';')
3538         return parser_next(parser);
3539     else if (opts.standard == COMPILER_QCC)
3540         parseerror(parser, "missing semicolon after function body (mandatory with -std=qcc)");
3541     return retval;
3542
3543 enderrfn:
3544     vec_pop(parser->functions);
3545     ast_function_delete(func);
3546     var->constval.vfunc = NULL;
3547
3548 enderr:
3549     (void)!parser_leaveblock(parser);
3550     parser->function = old;
3551     return false;
3552 }
3553
3554 static ast_expression *array_accessor_split(
3555     parser_t  *parser,
3556     ast_value *array,
3557     ast_value *index,
3558     size_t     middle,
3559     ast_expression *left,
3560     ast_expression *right
3561     )
3562 {
3563     ast_ifthen *ifthen;
3564     ast_binary *cmp;
3565
3566     lex_ctx ctx = ast_ctx(array);
3567
3568     if (!left || !right) {
3569         if (left)  ast_delete(left);
3570         if (right) ast_delete(right);
3571         return NULL;
3572     }
3573
3574     cmp = ast_binary_new(ctx, INSTR_LT,
3575                          (ast_expression*)index,
3576                          (ast_expression*)parser_const_float(parser, middle));
3577     if (!cmp) {
3578         ast_delete(left);
3579         ast_delete(right);
3580         parseerror(parser, "internal error: failed to create comparison for array setter");
3581         return NULL;
3582     }
3583
3584     ifthen = ast_ifthen_new(ctx, (ast_expression*)cmp, left, right);
3585     if (!ifthen) {
3586         ast_delete(cmp); /* will delete left and right */
3587         parseerror(parser, "internal error: failed to create conditional jump for array setter");
3588         return NULL;
3589     }
3590
3591     return (ast_expression*)ifthen;
3592 }
3593
3594 static ast_expression *array_setter_node(parser_t *parser, ast_value *array, ast_value *index, ast_value *value, size_t from, size_t afterend)
3595 {
3596     lex_ctx ctx = ast_ctx(array);
3597
3598     if (from+1 == afterend) {
3599         /* set this value */
3600         ast_block       *block;
3601         ast_return      *ret;
3602         ast_array_index *subscript;
3603         ast_store       *st;
3604         int assignop = type_store_instr[value->expression.vtype];
3605
3606         if (value->expression.vtype == TYPE_FIELD && value->expression.next->expression.vtype == TYPE_VECTOR)
3607             assignop = INSTR_STORE_V;
3608
3609         subscript = ast_array_index_new(ctx, (ast_expression*)array, (ast_expression*)parser_const_float(parser, from));
3610         if (!subscript)
3611             return NULL;
3612
3613         st = ast_store_new(ctx, assignop, (ast_expression*)subscript, (ast_expression*)value);
3614         if (!st) {
3615             ast_delete(subscript);
3616             return NULL;
3617         }
3618
3619         block = ast_block_new(ctx);
3620         if (!block) {
3621             ast_delete(st);
3622             return NULL;
3623         }
3624
3625         if (!ast_block_add_expr(block, (ast_expression*)st)) {
3626             ast_delete(block);
3627             return NULL;
3628         }
3629
3630         ret = ast_return_new(ctx, NULL);
3631         if (!ret) {
3632             ast_delete(block);
3633             return NULL;
3634         }
3635
3636         if (!ast_block_add_expr(block, (ast_expression*)ret)) {
3637             ast_delete(block);
3638             return NULL;
3639         }
3640
3641         return (ast_expression*)block;
3642     } else {
3643         ast_expression *left, *right;
3644         size_t diff = afterend - from;
3645         size_t middle = from + diff/2;
3646         left  = array_setter_node(parser, array, index, value, from, middle);
3647         right = array_setter_node(parser, array, index, value, middle, afterend);
3648         return array_accessor_split(parser, array, index, middle, left, right);
3649     }
3650 }
3651
3652 static ast_expression *array_field_setter_node(
3653     parser_t  *parser,
3654     ast_value *array,
3655     ast_value *entity,
3656     ast_value *index,
3657     ast_value *value,
3658     size_t     from,
3659     size_t     afterend)
3660 {
3661     lex_ctx ctx = ast_ctx(array);
3662
3663     if (from+1 == afterend) {
3664         /* set this value */
3665         ast_block       *block;
3666         ast_return      *ret;
3667         ast_entfield    *entfield;
3668         ast_array_index *subscript;
3669         ast_store       *st;
3670         int assignop = type_storep_instr[value->expression.vtype];
3671
3672         if (value->expression.vtype == TYPE_FIELD && value->expression.next->expression.vtype == TYPE_VECTOR)
3673             assignop = INSTR_STOREP_V;
3674
3675         subscript = ast_array_index_new(ctx, (ast_expression*)array, (ast_expression*)parser_const_float(parser, from));
3676         if (!subscript)
3677             return NULL;
3678
3679         entfield = ast_entfield_new_force(ctx,
3680                                           (ast_expression*)entity,
3681                                           (ast_expression*)subscript,
3682                                           (ast_expression*)subscript);
3683         if (!entfield) {
3684             ast_delete(subscript);
3685             return NULL;
3686         }
3687
3688         st = ast_store_new(ctx, assignop, (ast_expression*)entfield, (ast_expression*)value);
3689         if (!st) {
3690             ast_delete(entfield);
3691             return NULL;
3692         }
3693
3694         block = ast_block_new(ctx);
3695         if (!block) {
3696             ast_delete(st);
3697             return NULL;
3698         }
3699
3700         if (!ast_block_add_expr(block, (ast_expression*)st)) {
3701             ast_delete(block);
3702             return NULL;
3703         }
3704
3705         ret = ast_return_new(ctx, NULL);
3706         if (!ret) {
3707             ast_delete(block);
3708             return NULL;
3709         }
3710
3711         if (!ast_block_add_expr(block, (ast_expression*)ret)) {
3712             ast_delete(block);
3713             return NULL;
3714         }
3715
3716         return (ast_expression*)block;
3717     } else {
3718         ast_expression *left, *right;
3719         size_t diff = afterend - from;
3720         size_t middle = from + diff/2;
3721         left  = array_field_setter_node(parser, array, entity, index, value, from, middle);
3722         right = array_field_setter_node(parser, array, entity, index, value, middle, afterend);
3723         return array_accessor_split(parser, array, index, middle, left, right);
3724     }
3725 }
3726
3727 static ast_expression *array_getter_node(parser_t *parser, ast_value *array, ast_value *index, size_t from, size_t afterend)
3728 {
3729     lex_ctx ctx = ast_ctx(array);
3730
3731     if (from+1 == afterend) {
3732         ast_return      *ret;
3733         ast_array_index *subscript;
3734
3735         subscript = ast_array_index_new(ctx, (ast_expression*)array, (ast_expression*)parser_const_float(parser, from));
3736         if (!subscript)
3737             return NULL;
3738
3739         ret = ast_return_new(ctx, (ast_expression*)subscript);
3740         if (!ret) {
3741             ast_delete(subscript);
3742             return NULL;
3743         }
3744
3745         return (ast_expression*)ret;
3746     } else {
3747         ast_expression *left, *right;
3748         size_t diff = afterend - from;
3749         size_t middle = from + diff/2;
3750         left  = array_getter_node(parser, array, index, from, middle);
3751         right = array_getter_node(parser, array, index, middle, afterend);
3752         return array_accessor_split(parser, array, index, middle, left, right);
3753     }
3754 }
3755
3756 static bool parser_create_array_accessor(parser_t *parser, ast_value *array, const char *funcname, ast_value **out)
3757 {
3758     ast_function   *func = NULL;
3759     ast_value      *fval = NULL;
3760     ast_block      *body = NULL;
3761
3762     fval = ast_value_new(ast_ctx(array), funcname, TYPE_FUNCTION);
3763     if (!fval) {
3764         parseerror(parser, "failed to create accessor function value");
3765         return false;
3766     }
3767
3768     func = ast_function_new(ast_ctx(array), funcname, fval);
3769     if (!func) {
3770         ast_delete(fval);
3771         parseerror(parser, "failed to create accessor function node");
3772         return false;
3773     }
3774
3775     body = ast_block_new(ast_ctx(array));
3776     if (!body) {
3777         parseerror(parser, "failed to create block for array accessor");
3778         ast_delete(fval);
3779         ast_delete(func);
3780         return false;
3781     }
3782
3783     vec_push(func->blocks, body);
3784     *out = fval;
3785
3786     vec_push(parser->accessors, fval);
3787
3788     return true;
3789 }
3790
3791 static bool parser_create_array_setter(parser_t *parser, ast_value *array, const char *funcname)
3792 {
3793     ast_expression *root = NULL;
3794     ast_value      *index = NULL;
3795     ast_value      *value = NULL;
3796     ast_function   *func;
3797     ast_value      *fval;
3798
3799     if (!ast_istype(array->expression.next, ast_value)) {
3800         parseerror(parser, "internal error: array accessor needs to build an ast_value with a copy of the element type");
3801         return false;
3802     }
3803
3804     if (!parser_create_array_accessor(parser, array, funcname, &fval))
3805         return false;
3806     func = fval->constval.vfunc;
3807     fval->expression.next = (ast_expression*)ast_value_new(ast_ctx(array), "<void>", TYPE_VOID);
3808
3809     index = ast_value_new(ast_ctx(array), "index", TYPE_FLOAT);
3810     value = ast_value_copy((ast_value*)array->expression.next);
3811
3812     if (!index || !value) {
3813         parseerror(parser, "failed to create locals for array accessor");
3814         goto cleanup;
3815     }
3816     (void)!ast_value_set_name(value, "value"); /* not important */
3817     vec_push(fval->expression.params, index);
3818     vec_push(fval->expression.params, value);
3819
3820     root = array_setter_node(parser, array, index, value, 0, array->expression.count);
3821     if (!root) {
3822         parseerror(parser, "failed to build accessor search tree");
3823         goto cleanup;
3824     }
3825
3826     array->setter = fval;
3827     return ast_block_add_expr(func->blocks[0], root);
3828 cleanup:
3829     if (index) ast_delete(index);
3830     if (value) ast_delete(value);
3831     if (root)  ast_delete(root);
3832     ast_delete(func);
3833     ast_delete(fval);
3834     return false;
3835 }
3836
3837 static bool parser_create_array_field_setter(parser_t *parser, ast_value *array, const char *funcname)
3838 {
3839     ast_expression *root = NULL;
3840     ast_value      *entity = NULL;
3841     ast_value      *index = NULL;
3842     ast_value      *value = NULL;
3843     ast_function   *func;
3844     ast_value      *fval;
3845
3846     if (!ast_istype(array->expression.next, ast_value)) {
3847         parseerror(parser, "internal error: array accessor needs to build an ast_value with a copy of the element type");
3848         return false;
3849     }
3850
3851     if (!parser_create_array_accessor(parser, array, funcname, &fval))
3852         return false;
3853     func = fval->constval.vfunc;
3854     fval->expression.next = (ast_expression*)ast_value_new(ast_ctx(array), "<void>", TYPE_VOID);
3855
3856     entity = ast_value_new(ast_ctx(array), "entity", TYPE_ENTITY);
3857     index  = ast_value_new(ast_ctx(array), "index",  TYPE_FLOAT);
3858     value  = ast_value_copy((ast_value*)array->expression.next);
3859     if (!entity || !index || !value) {
3860         parseerror(parser, "failed to create locals for array accessor");
3861         goto cleanup;
3862     }
3863     (void)!ast_value_set_name(value, "value"); /* not important */
3864     vec_push(fval->expression.params, entity);
3865     vec_push(fval->expression.params, index);
3866     vec_push(fval->expression.params, value);
3867
3868     root = array_field_setter_node(parser, array, entity, index, value, 0, array->expression.count);
3869     if (!root) {
3870         parseerror(parser, "failed to build accessor search tree");
3871         goto cleanup;
3872     }
3873
3874     array->setter = fval;
3875     return ast_block_add_expr(func->blocks[0], root);
3876 cleanup:
3877     if (entity) ast_delete(entity);
3878     if (index)  ast_delete(index);
3879     if (value)  ast_delete(value);
3880     if (root)   ast_delete(root);
3881     ast_delete(func);
3882     ast_delete(fval);
3883     return false;
3884 }
3885
3886 static bool parser_create_array_getter(parser_t *parser, ast_value *array, const ast_expression *elemtype, const char *funcname)
3887 {
3888     ast_expression *root = NULL;
3889     ast_value      *index = NULL;
3890     ast_value      *fval;
3891     ast_function   *func;
3892
3893     /* NOTE: checking array->expression.next rather than elemtype since
3894      * for fields elemtype is a temporary fieldtype.
3895      */
3896     if (!ast_istype(array->expression.next, ast_value)) {
3897         parseerror(parser, "internal error: array accessor needs to build an ast_value with a copy of the element type");
3898         return false;
3899     }
3900
3901     if (!parser_create_array_accessor(parser, array, funcname, &fval))
3902         return false;
3903     func = fval->constval.vfunc;
3904     fval->expression.next = ast_type_copy(ast_ctx(array), elemtype);
3905
3906     index = ast_value_new(ast_ctx(array), "index", TYPE_FLOAT);
3907
3908     if (!index) {
3909         parseerror(parser, "failed to create locals for array accessor");
3910         goto cleanup;
3911     }
3912     vec_push(fval->expression.params, index);
3913
3914     root = array_getter_node(parser, array, index, 0, array->expression.count);
3915     if (!root) {
3916         parseerror(parser, "failed to build accessor search tree");
3917         goto cleanup;
3918     }
3919
3920     array->getter = fval;
3921     return ast_block_add_expr(func->blocks[0], root);
3922 cleanup:
3923     if (index) ast_delete(index);
3924     if (root)  ast_delete(root);
3925     ast_delete(func);
3926     ast_delete(fval);
3927     return false;
3928 }
3929
3930 static ast_value *parse_typename(parser_t *parser, ast_value **storebase, ast_value *cached_typedef);
3931 static ast_value *parse_parameter_list(parser_t *parser, ast_value *var)
3932 {
3933     lex_ctx     ctx;
3934     size_t      i;
3935     ast_value **params;
3936     ast_value  *param;
3937     ast_value  *fval;
3938     bool        first = true;
3939     bool        variadic = false;
3940
3941     ctx = parser_ctx(parser);
3942
3943     /* for the sake of less code we parse-in in this function */
3944     if (!parser_next(parser)) {
3945         parseerror(parser, "expected parameter list");
3946         return NULL;
3947     }
3948
3949     params = NULL;
3950
3951     /* parse variables until we hit a closing paren */
3952     while (parser->tok != ')') {
3953         if (!first) {
3954             /* there must be commas between them */
3955             if (parser->tok != ',') {
3956                 parseerror(parser, "expected comma or end of parameter list");
3957                 goto on_error;
3958             }
3959             if (!parser_next(parser)) {
3960                 parseerror(parser, "expected parameter");
3961                 goto on_error;
3962             }
3963         }
3964         first = false;
3965
3966         if (parser->tok == TOKEN_DOTS) {
3967             /* '...' indicates a varargs function */
3968             variadic = true;
3969             if (!parser_next(parser)) {
3970                 parseerror(parser, "expected parameter");
3971                 return NULL;
3972             }
3973             if (parser->tok != ')') {
3974                 parseerror(parser, "`...` must be the last parameter of a variadic function declaration");
3975                 goto on_error;
3976             }
3977         }
3978         else
3979         {
3980             /* for anything else just parse a typename */
3981             param = parse_typename(parser, NULL, NULL);
3982             if (!param)
3983                 goto on_error;
3984             vec_push(params, param);
3985             if (param->expression.vtype >= TYPE_VARIANT) {
3986                 char tname[1024]; /* typename is reserved in C++ */
3987                 ast_type_to_string((ast_expression*)param, tname, sizeof(tname));
3988                 parseerror(parser, "type not supported as part of a parameter list: %s", tname);
3989                 goto on_error;
3990             }
3991         }
3992     }
3993
3994     if (vec_size(params) == 1 && params[0]->expression.vtype == TYPE_VOID)
3995         vec_free(params);
3996
3997     /* sanity check */
3998     if (vec_size(params) > 8 && opts.standard == COMPILER_QCC)
3999         (void)!parsewarning(parser, WARN_EXTENSIONS, "more than 8 parameters are not supported by this standard");
4000
4001     /* parse-out */
4002     if (!parser_next(parser)) {
4003         parseerror(parser, "parse error after typename");
4004         goto on_error;
4005     }
4006
4007     /* now turn 'var' into a function type */
4008     fval = ast_value_new(ctx, "<type()>", TYPE_FUNCTION);
4009     fval->expression.next     = (ast_expression*)var;
4010     if (variadic)
4011         fval->expression.flags |= AST_FLAG_VARIADIC;
4012     var = fval;
4013
4014     var->expression.params = params;
4015     params = NULL;
4016
4017     return var;
4018
4019 on_error:
4020     ast_delete(var);
4021     for (i = 0; i < vec_size(params); ++i)
4022         ast_delete(params[i]);
4023     vec_free(params);
4024     return NULL;
4025 }
4026
4027 static ast_value *parse_arraysize(parser_t *parser, ast_value *var)
4028 {
4029     ast_expression *cexp;
4030     ast_value      *cval, *tmp;
4031     lex_ctx ctx;
4032
4033     ctx = parser_ctx(parser);
4034
4035     if (!parser_next(parser)) {
4036         ast_delete(var);
4037         parseerror(parser, "expected array-size");
4038         return NULL;
4039     }
4040
4041     cexp = parse_expression_leave(parser, true);
4042
4043     if (!cexp || !ast_istype(cexp, ast_value)) {
4044         if (cexp)
4045             ast_unref(cexp);
4046         ast_delete(var);
4047         parseerror(parser, "expected array-size as constant positive integer");
4048         return NULL;
4049     }
4050     cval = (ast_value*)cexp;
4051
4052     tmp = ast_value_new(ctx, "<type[]>", TYPE_ARRAY);
4053     tmp->expression.next = (ast_expression*)var;
4054     var = tmp;
4055
4056     if (cval->expression.vtype == TYPE_INTEGER)
4057         tmp->expression.count = cval->constval.vint;
4058     else if (cval->expression.vtype == TYPE_FLOAT)
4059         tmp->expression.count = cval->constval.vfloat;
4060     else {
4061         ast_unref(cexp);
4062         ast_delete(var);
4063         parseerror(parser, "array-size must be a positive integer constant");
4064         return NULL;
4065     }
4066     ast_unref(cexp);
4067
4068     if (parser->tok != ']') {
4069         ast_delete(var);
4070         parseerror(parser, "expected ']' after array-size");
4071         return NULL;
4072     }
4073     if (!parser_next(parser)) {
4074         ast_delete(var);
4075         parseerror(parser, "error after parsing array size");
4076         return NULL;
4077     }
4078     return var;
4079 }
4080
4081 /* Parse a complete typename.
4082  * for single-variables (ie. function parameters or typedefs) storebase should be NULL
4083  * but when parsing variables separated by comma
4084  * 'storebase' should point to where the base-type should be kept.
4085  * The base type makes up every bit of type information which comes *before* the
4086  * variable name.
4087  *
4088  * The following will be parsed in its entirety:
4089  *     void() foo()
4090  * The 'basetype' in this case is 'void()'
4091  * and if there's a comma after it, say:
4092  *     void() foo(), bar
4093  * then the type-information 'void()' can be stored in 'storebase'
4094  */
4095 static ast_value *parse_typename(parser_t *parser, ast_value **storebase, ast_value *cached_typedef)
4096 {
4097     ast_value *var, *tmp;
4098     lex_ctx    ctx;
4099
4100     const char *name = NULL;
4101     bool        isfield  = false;
4102     bool        wasarray = false;
4103     size_t      morefields = 0;
4104
4105     ctx = parser_ctx(parser);
4106
4107     /* types may start with a dot */
4108     if (parser->tok == '.') {
4109         isfield = true;
4110         /* if we parsed a dot we need a typename now */
4111         if (!parser_next(parser)) {
4112             parseerror(parser, "expected typename for field definition");
4113             return NULL;
4114         }
4115
4116         /* Further dots are handled seperately because they won't be part of the
4117          * basetype
4118          */
4119         while (parser->tok == '.') {
4120             ++morefields;
4121             if (!parser_next(parser)) {
4122                 parseerror(parser, "expected typename for field definition");
4123                 return NULL;
4124             }
4125         }
4126     }
4127     if (parser->tok == TOKEN_IDENT)
4128         cached_typedef = parser_find_typedef(parser, parser_tokval(parser), 0);
4129     if (!cached_typedef && parser->tok != TOKEN_TYPENAME) {
4130         parseerror(parser, "expected typename");
4131         return NULL;
4132     }
4133
4134     /* generate the basic type value */
4135     if (cached_typedef) {
4136         var = ast_value_copy(cached_typedef);
4137         ast_value_set_name(var, "<type(from_def)>");
4138     } else
4139         var = ast_value_new(ctx, "<type>", parser_token(parser)->constval.t);
4140
4141     for (; morefields; --morefields) {
4142         tmp = ast_value_new(ctx, "<.type>", TYPE_FIELD);
4143         tmp->expression.next = (ast_expression*)var;
4144         var = tmp;
4145     }
4146
4147     /* do not yet turn into a field - remember:
4148      * .void() foo; is a field too
4149      * .void()() foo; is a function
4150      */
4151
4152     /* parse on */
4153     if (!parser_next(parser)) {
4154         ast_delete(var);
4155         parseerror(parser, "parse error after typename");
4156         return NULL;
4157     }
4158
4159     /* an opening paren now starts the parameter-list of a function
4160      * this is where original-QC has parameter lists.
4161      * We allow a single parameter list here.
4162      * Much like fteqcc we don't allow `float()() x`
4163      */
4164     if (parser->tok == '(') {
4165         var = parse_parameter_list(parser, var);
4166         if (!var)
4167             return NULL;
4168     }
4169
4170     /* store the base if requested */
4171     if (storebase) {
4172         *storebase = ast_value_copy(var);
4173         if (isfield) {
4174             tmp = ast_value_new(ctx, "<type:f>", TYPE_FIELD);
4175             tmp->expression.next = (ast_expression*)*storebase;
4176             *storebase = tmp;
4177         }
4178     }
4179
4180     /* there may be a name now */
4181     if (parser->tok == TOKEN_IDENT) {
4182         name = util_strdup(parser_tokval(parser));
4183         /* parse on */
4184