Uhh forgot to save file
[xonotic/gmqcc.git] / parser.c
1 /*
2  * Copyright (C) 2012, 2013
3  *     Wolfgang Bumiller
4  *     Dale Weiler
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy of
7  * this software and associated documentation files (the "Software"), to deal in
8  * the Software without restriction, including without limitation the rights to
9  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
10  * of the Software, and to permit persons to whom the Software is furnished to do
11  * so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in all
14  * copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22  * SOFTWARE.
23  */
24 #include <string.h>
25 #include <math.h>
26
27 #include "gmqcc.h"
28 #include "lexer.h"
29 #include "ast.h"
30
31 /* beginning of locals */
32 #define PARSER_HT_LOCALS  2
33
34 #define PARSER_HT_SIZE    128
35 #define TYPEDEF_HT_SIZE   16
36
37 typedef struct parser_s {
38     lex_file *lex;
39     int      tok;
40
41     bool     ast_cleaned;
42
43     ast_expression **globals;
44     ast_expression **fields;
45     ast_function **functions;
46     ast_value    **imm_float;
47     ast_value    **imm_string;
48     ast_value    **imm_vector;
49     size_t         translated;
50
51     ht ht_imm_string;
52
53     /* must be deleted first, they reference immediates and values */
54     ast_value    **accessors;
55
56     ast_value *imm_float_zero;
57     ast_value *imm_float_one;
58     ast_value *imm_float_neg_one;
59
60     ast_value *imm_vector_zero;
61
62     ast_value *nil;
63     ast_value *reserved_version;
64
65     size_t crc_globals;
66     size_t crc_fields;
67
68     ast_function *function;
69     ht            aliases;
70
71     /* All the labels the function defined...
72      * Should they be in ast_function instead?
73      */
74     ast_label  **labels;
75     ast_goto   **gotos;
76     const char **breaks;
77     const char **continues;
78
79     /* A list of hashtables for each scope */
80     ht *variables;
81     ht htfields;
82     ht htglobals;
83     ht *typedefs;
84
85     /* same as above but for the spelling corrector */
86     correct_trie_t  **correct_variables;
87     size_t         ***correct_variables_score;  /* vector of vector of size_t* */
88
89     /* not to be used directly, we use the hash table */
90     ast_expression **_locals;
91     size_t          *_blocklocals;
92     ast_value      **_typedefs;
93     size_t          *_blocktypedefs;
94     lex_ctx         *_block_ctx;
95
96     /* we store the '=' operator info */
97     const oper_info *assign_op;
98
99     /* magic values */
100     ast_value *const_vec[3];
101
102     /* pragma flags */
103     bool noref;
104
105     /* collected information */
106     size_t     max_param_count;
107
108     /* code generator */
109     code_t     *code;
110 } parser_t;
111
112 static ast_expression * const intrinsic_debug_typestring = (ast_expression*)0x1;
113
114 static void parser_enterblock(parser_t *parser);
115 static bool parser_leaveblock(parser_t *parser);
116 static void parser_addlocal(parser_t *parser, const char *name, ast_expression *e);
117 static void parser_addglobal(parser_t *parser, const char *name, ast_expression *e);
118 static bool parse_typedef(parser_t *parser);
119 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, char *vstring);
120 static ast_block* parse_block(parser_t *parser);
121 static bool parse_block_into(parser_t *parser, ast_block *block);
122 static bool parse_statement_or_block(parser_t *parser, ast_expression **out);
123 static bool parse_statement(parser_t *parser, ast_block *block, ast_expression **out, bool allow_cases);
124 static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma, bool truthvalue, bool with_labels);
125 static ast_expression* parse_expression(parser_t *parser, bool stopatcomma, bool with_labels);
126 static ast_value* parser_create_array_setter_proto(parser_t *parser, ast_value *array, const char *funcname);
127 static ast_value* parser_create_array_getter_proto(parser_t *parser, ast_value *array, const ast_expression *elemtype, const char *funcname);
128 static ast_value *parse_typename(parser_t *parser, ast_value **storebase, ast_value *cached_typedef);
129
130 static void parseerror(parser_t *parser, const char *fmt, ...)
131 {
132     va_list ap;
133     va_start(ap, fmt);
134     vcompile_error(parser->lex->tok.ctx, fmt, ap);
135     va_end(ap);
136 }
137
138 /* returns true if it counts as an error */
139 static bool GMQCC_WARN parsewarning(parser_t *parser, int warntype, const char *fmt, ...)
140 {
141     bool    r;
142     va_list ap;
143     va_start(ap, fmt);
144     r = vcompile_warning(parser->lex->tok.ctx, warntype, fmt, ap);
145     va_end(ap);
146     return r;
147 }
148
149 /**********************************************************************
150  * some maths used for constant folding
151  */
152
153 vector vec3_add(vector a, vector b)
154 {
155     vector out;
156     out.x = a.x + b.x;
157     out.y = a.y + b.y;
158     out.z = a.z + b.z;
159     return out;
160 }
161
162 vector vec3_sub(vector a, vector b)
163 {
164     vector out;
165     out.x = a.x - b.x;
166     out.y = a.y - b.y;
167     out.z = a.z - b.z;
168     return out;
169 }
170
171 qcfloat vec3_mulvv(vector a, vector b)
172 {
173     return (a.x * b.x + a.y * b.y + a.z * b.z);
174 }
175
176 vector vec3_mulvf(vector a, float b)
177 {
178     vector out;
179     out.x = a.x * b;
180     out.y = a.y * b;
181     out.z = a.z * b;
182     return out;
183 }
184
185 /**********************************************************************
186  * parsing
187  */
188
189 static bool parser_next(parser_t *parser)
190 {
191     /* lex_do kills the previous token */
192     parser->tok = lex_do(parser->lex);
193     if (parser->tok == TOKEN_EOF)
194         return true;
195     if (parser->tok >= TOKEN_ERROR) {
196         parseerror(parser, "lex error");
197         return false;
198     }
199     return true;
200 }
201
202 #define parser_tokval(p) ((p)->lex->tok.value)
203 #define parser_token(p)  (&((p)->lex->tok))
204 #define parser_ctx(p)    ((p)->lex->tok.ctx)
205
206 static ast_value* parser_const_float(parser_t *parser, double d)
207 {
208     size_t i;
209     ast_value *out;
210     lex_ctx ctx;
211     for (i = 0; i < vec_size(parser->imm_float); ++i) {
212         const double compare = parser->imm_float[i]->constval.vfloat;
213         if (memcmp((const void*)&compare, (const void *)&d, sizeof(double)) == 0)
214             return parser->imm_float[i];
215     }
216     if (parser->lex)
217         ctx = parser_ctx(parser);
218     else {
219         memset(&ctx, 0, sizeof(ctx));
220     }
221     out = ast_value_new(ctx, "#IMMEDIATE", TYPE_FLOAT);
222     out->cvq      = CV_CONST;
223     out->hasvalue = true;
224     out->isimm    = true;
225     out->constval.vfloat = d;
226     vec_push(parser->imm_float, out);
227     return out;
228 }
229
230 static ast_value* parser_const_float_0(parser_t *parser)
231 {
232     if (!parser->imm_float_zero)
233         parser->imm_float_zero = parser_const_float(parser, 0);
234     return parser->imm_float_zero;
235 }
236
237 static ast_value* parser_const_float_neg1(parser_t *parser) {
238     if (!parser->imm_float_neg_one)
239         parser->imm_float_neg_one = parser_const_float(parser, -1);
240     return parser->imm_float_neg_one;
241 }
242
243 static ast_value* parser_const_float_1(parser_t *parser)
244 {
245     if (!parser->imm_float_one)
246         parser->imm_float_one = parser_const_float(parser, 1);
247     return parser->imm_float_one;
248 }
249
250 static char *parser_strdup(const char *str)
251 {
252     if (str && !*str) {
253         /* actually dup empty strings */
254         char *out = (char*)mem_a(1);
255         *out = 0;
256         return out;
257     }
258     return util_strdup(str);
259 }
260
261 static ast_value* parser_const_string(parser_t *parser, const char *str, bool dotranslate)
262 {
263     size_t hash = util_hthash(parser->ht_imm_string, str);
264     ast_value *out;
265     if ( (out = (ast_value*)util_htgeth(parser->ht_imm_string, str, hash)) ) {
266         if (dotranslate && out->name[0] == '#') {
267             char name[32];
268             util_snprintf(name, sizeof(name), "dotranslate_%lu", (unsigned long)(parser->translated++));
269             ast_value_set_name(out, name);
270             out->expression.flags |= AST_FLAG_INCLUDE_DEF;
271         }
272         return out;
273     }
274     /*
275     for (i = 0; i < vec_size(parser->imm_string); ++i) {
276         if (!strcmp(parser->imm_string[i]->constval.vstring, str))
277             return parser->imm_string[i];
278     }
279     */
280     if (dotranslate) {
281         char name[32];
282         util_snprintf(name, sizeof(name), "dotranslate_%lu", (unsigned long)(parser->translated++));
283         out = ast_value_new(parser_ctx(parser), name, TYPE_STRING);
284         out->expression.flags |= AST_FLAG_INCLUDE_DEF;
285     } else
286         out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_STRING);
287     out->cvq      = CV_CONST;
288     out->hasvalue = true;
289     out->isimm    = true;
290     out->constval.vstring = parser_strdup(str);
291     vec_push(parser->imm_string, out);
292     util_htseth(parser->ht_imm_string, str, hash, out);
293     return out;
294 }
295
296 static ast_value* parser_const_vector(parser_t *parser, vector v)
297 {
298     size_t i;
299     ast_value *out;
300     for (i = 0; i < vec_size(parser->imm_vector); ++i) {
301         if (!memcmp(&parser->imm_vector[i]->constval.vvec, &v, sizeof(v)))
302             return parser->imm_vector[i];
303     }
304     out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_VECTOR);
305     out->cvq      = CV_CONST;
306     out->hasvalue = true;
307     out->isimm    = true;
308     out->constval.vvec = v;
309     vec_push(parser->imm_vector, out);
310     return out;
311 }
312
313 static ast_value* parser_const_vector_f(parser_t *parser, float x, float y, float z)
314 {
315     vector v;
316     v.x = x;
317     v.y = y;
318     v.z = z;
319     return parser_const_vector(parser, v);
320 }
321
322 static ast_value* parser_const_vector_0(parser_t *parser)
323 {
324     if (!parser->imm_vector_zero)
325         parser->imm_vector_zero = parser_const_vector_f(parser, 0, 0, 0);
326     return parser->imm_vector_zero;
327 }
328
329 static ast_expression* parser_find_field(parser_t *parser, const char *name)
330 {
331     return ( ast_expression*)util_htget(parser->htfields, name);
332 }
333
334 static ast_expression* parser_find_label(parser_t *parser, const char *name)
335 {
336     size_t i;
337     for(i = 0; i < vec_size(parser->labels); i++)
338         if (!strcmp(parser->labels[i]->name, name))
339             return (ast_expression*)parser->labels[i];
340     return NULL;
341 }
342
343 static ast_expression* parser_find_global(parser_t *parser, const char *name)
344 {
345     ast_expression *var = (ast_expression*)util_htget(parser->aliases, parser_tokval(parser));
346     if (var)
347         return var;
348     return (ast_expression*)util_htget(parser->htglobals, name);
349 }
350
351 static ast_expression* parser_find_param(parser_t *parser, const char *name)
352 {
353     size_t i;
354     ast_value *fun;
355     if (!parser->function)
356         return NULL;
357     fun = parser->function->vtype;
358     for (i = 0; i < vec_size(fun->expression.params); ++i) {
359         if (!strcmp(fun->expression.params[i]->name, name))
360             return (ast_expression*)(fun->expression.params[i]);
361     }
362     return NULL;
363 }
364
365 static ast_expression* parser_find_local(parser_t *parser, const char *name, size_t upto, bool *isparam)
366 {
367     size_t          i, hash;
368     ast_expression *e;
369
370     hash = util_hthash(parser->htglobals, name);
371
372     *isparam = false;
373     for (i = vec_size(parser->variables); i > upto;) {
374         --i;
375         if ( (e = (ast_expression*)util_htgeth(parser->variables[i], name, hash)) )
376             return e;
377     }
378     *isparam = true;
379     return parser_find_param(parser, name);
380 }
381
382 static ast_expression* parser_find_var(parser_t *parser, const char *name)
383 {
384     bool dummy;
385     ast_expression *v;
386     v         = parser_find_local(parser, name, 0, &dummy);
387     if (!v) v = parser_find_global(parser, name);
388     return v;
389 }
390
391 static ast_value* parser_find_typedef(parser_t *parser, const char *name, size_t upto)
392 {
393     size_t     i, hash;
394     ast_value *e;
395     hash = util_hthash(parser->typedefs[0], name);
396
397     for (i = vec_size(parser->typedefs); i > upto;) {
398         --i;
399         if ( (e = (ast_value*)util_htgeth(parser->typedefs[i], name, hash)) )
400             return e;
401     }
402     return NULL;
403 }
404
405 /* include intrinsics */
406 #include "intrin.h"
407
408 typedef struct
409 {
410     size_t etype; /* 0 = expression, others are operators */
411     bool            isparen;
412     size_t          off;
413     ast_expression *out;
414     ast_block      *block; /* for commas and function calls */
415     lex_ctx ctx;
416 } sy_elem;
417
418 enum {
419     PAREN_EXPR,
420     PAREN_FUNC,
421     PAREN_INDEX,
422     PAREN_TERNARY1,
423     PAREN_TERNARY2
424 };
425 typedef struct
426 {
427     sy_elem        *out;
428     sy_elem        *ops;
429     size_t         *argc;
430     unsigned int   *paren;
431 } shunt;
432
433 static sy_elem syexp(lex_ctx ctx, ast_expression *v) {
434     sy_elem e;
435     e.etype = 0;
436     e.off   = 0;
437     e.out   = v;
438     e.block = NULL;
439     e.ctx   = ctx;
440     e.isparen = false;
441     return e;
442 }
443
444 static sy_elem syblock(lex_ctx ctx, ast_block *v) {
445     sy_elem e;
446     e.etype = 0;
447     e.off   = 0;
448     e.out   = (ast_expression*)v;
449     e.block = v;
450     e.ctx   = ctx;
451     e.isparen = false;
452     return e;
453 }
454
455 static sy_elem syop(lex_ctx ctx, const oper_info *op) {
456     sy_elem e;
457     e.etype = 1 + (op - operators);
458     e.off   = 0;
459     e.out   = NULL;
460     e.block = NULL;
461     e.ctx   = ctx;
462     e.isparen = false;
463     return e;
464 }
465
466 static sy_elem syparen(lex_ctx ctx, size_t off) {
467     sy_elem e;
468     e.etype = 0;
469     e.off   = off;
470     e.out   = NULL;
471     e.block = NULL;
472     e.ctx   = ctx;
473     e.isparen = true;
474     return e;
475 }
476
477 /* With regular precedence rules, ent.foo[n] is the same as (ent.foo)[n],
478  * so we need to rotate it to become ent.(foo[n]).
479  */
480 static bool rotate_entfield_array_index_nodes(ast_expression **out)
481 {
482     ast_array_index *index, *oldindex;
483     ast_entfield    *entfield;
484
485     ast_value       *field;
486     ast_expression  *sub;
487     ast_expression  *entity;
488
489     lex_ctx ctx = ast_ctx(*out);
490
491     if (!ast_istype(*out, ast_array_index))
492         return false;
493     index = (ast_array_index*)*out;
494
495     if (!ast_istype(index->array, ast_entfield))
496         return false;
497     entfield = (ast_entfield*)index->array;
498
499     if (!ast_istype(entfield->field, ast_value))
500         return false;
501     field = (ast_value*)entfield->field;
502
503     sub    = index->index;
504     entity = entfield->entity;
505
506     oldindex = index;
507
508     index = ast_array_index_new(ctx, (ast_expression*)field, sub);
509     entfield = ast_entfield_new(ctx, entity, (ast_expression*)index);
510     *out = (ast_expression*)entfield;
511
512     oldindex->array = NULL;
513     oldindex->index = NULL;
514     ast_delete(oldindex);
515
516     return true;
517 }
518
519 static bool immediate_is_true(lex_ctx ctx, ast_value *v)
520 {
521     switch (v->expression.vtype) {
522         case TYPE_FLOAT:
523             return !!v->constval.vfloat;
524         case TYPE_INTEGER:
525             return !!v->constval.vint;
526         case TYPE_VECTOR:
527             if (OPTS_FLAG(CORRECT_LOGIC))
528                 return v->constval.vvec.x &&
529                        v->constval.vvec.y &&
530                        v->constval.vvec.z;
531             else
532                 return !!(v->constval.vvec.x);
533         case TYPE_STRING:
534             if (!v->constval.vstring)
535                 return false;
536             if (v->constval.vstring && OPTS_FLAG(TRUE_EMPTY_STRINGS))
537                 return true;
538             return !!v->constval.vstring[0];
539         default:
540             compile_error(ctx, "internal error: immediate_is_true on invalid type");
541             return !!v->constval.vfunc;
542     }
543 }
544
545 static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
546 {
547     const oper_info *op;
548     lex_ctx ctx;
549     ast_expression *out = NULL;
550     ast_expression *exprs[3];
551     ast_block      *blocks[3];
552     ast_value      *asvalue[3];
553     ast_binstore   *asbinstore;
554     size_t i, assignop, addop, subop;
555     qcint  generated_op = 0;
556
557     char ty1[1024];
558     char ty2[1024];
559
560     if (!vec_size(sy->ops)) {
561         parseerror(parser, "internal error: missing operator");
562         return false;
563     }
564
565     if (vec_last(sy->ops).isparen) {
566         parseerror(parser, "unmatched parenthesis");
567         return false;
568     }
569
570     op = &operators[vec_last(sy->ops).etype - 1];
571     ctx = vec_last(sy->ops).ctx;
572
573     if (vec_size(sy->out) < op->operands) {
574         compile_error(ctx, "internal error: not enough operands: %i (operator %s (%i))", vec_size(sy->out),
575                       op->op, (int)op->id);
576         return false;
577     }
578
579     vec_shrinkby(sy->ops, 1);
580
581     /* op(:?) has no input and no output */
582     if (!op->operands)
583         return true;
584
585     vec_shrinkby(sy->out, op->operands);
586     for (i = 0; i < op->operands; ++i) {
587         exprs[i]  = sy->out[vec_size(sy->out)+i].out;
588         blocks[i] = sy->out[vec_size(sy->out)+i].block;
589         asvalue[i] = (ast_value*)exprs[i];
590
591         if (exprs[i]->vtype == TYPE_NOEXPR &&
592             !(i != 0 && op->id == opid2('?',':')) &&
593             !(i == 1 && op->id == opid1('.')))
594         {
595             if (ast_istype(exprs[i], ast_label))
596                 compile_error(ast_ctx(exprs[i]), "expected expression, got an unknown identifier");
597             else
598                 compile_error(ast_ctx(exprs[i]), "not an expression");
599             (void)!compile_warning(ast_ctx(exprs[i]), WARN_DEBUG, "expression %u\n", (unsigned int)i);
600         }
601     }
602
603     if (blocks[0] && !vec_size(blocks[0]->exprs) && op->id != opid1(',')) {
604         compile_error(ctx, "internal error: operator cannot be applied on empty blocks");
605         return false;
606     }
607
608 #define NotSameType(T) \
609              (exprs[0]->vtype != exprs[1]->vtype || \
610               exprs[0]->vtype != T)
611 #define CanConstFold1(A) \
612              (ast_istype((A), ast_value) && ((ast_value*)(A))->hasvalue && (((ast_value*)(A))->cvq == CV_CONST) &&\
613               (A)->vtype != TYPE_FUNCTION)
614 #define CanConstFold(A, B) \
615              (CanConstFold1(A) && CanConstFold1(B))
616 #define ConstV(i) (asvalue[(i)]->constval.vvec)
617 #define ConstF(i) (asvalue[(i)]->constval.vfloat)
618 #define ConstS(i) (asvalue[(i)]->constval.vstring)
619     switch (op->id)
620     {
621         default:
622             compile_error(ctx, "internal error: unhandled operator: %s (%i)", op->op, (int)op->id);
623             return false;
624
625         case opid1('.'):
626             if (exprs[0]->vtype == TYPE_VECTOR &&
627                 exprs[1]->vtype == TYPE_NOEXPR)
628             {
629                 if      (exprs[1] == (ast_expression*)parser->const_vec[0])
630                     out = (ast_expression*)ast_member_new(ctx, exprs[0], 0, NULL);
631                 else if (exprs[1] == (ast_expression*)parser->const_vec[1])
632                     out = (ast_expression*)ast_member_new(ctx, exprs[0], 1, NULL);
633                 else if (exprs[1] == (ast_expression*)parser->const_vec[2])
634                     out = (ast_expression*)ast_member_new(ctx, exprs[0], 2, NULL);
635                 else {
636                     compile_error(ctx, "access to invalid vector component");
637                     return false;
638                 }
639             }
640             else if (exprs[0]->vtype == TYPE_ENTITY) {
641                 if (exprs[1]->vtype != TYPE_FIELD) {
642                     compile_error(ast_ctx(exprs[1]), "type error: right hand of member-operand should be an entity-field");
643                     return false;
644                 }
645                 out = (ast_expression*)ast_entfield_new(ctx, exprs[0], exprs[1]);
646             }
647             else if (exprs[0]->vtype == TYPE_VECTOR) {
648                 compile_error(ast_ctx(exprs[1]), "vectors cannot be accessed this way");
649                 return false;
650             }
651             else {
652                 compile_error(ast_ctx(exprs[1]), "type error: member-of operator on something that is not an entity or vector");
653                 return false;
654             }
655             break;
656
657         case opid1('['):
658             if (exprs[0]->vtype != TYPE_ARRAY &&
659                 !(exprs[0]->vtype == TYPE_FIELD &&
660                   exprs[0]->next->vtype == TYPE_ARRAY))
661             {
662                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
663                 compile_error(ast_ctx(exprs[0]), "cannot index value of type %s", ty1);
664                 return false;
665             }
666             if (exprs[1]->vtype != TYPE_FLOAT) {
667                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
668                 compile_error(ast_ctx(exprs[1]), "index must be of type float, not %s", ty1);
669                 return false;
670             }
671             out = (ast_expression*)ast_array_index_new(ctx, exprs[0], exprs[1]);
672             if (rotate_entfield_array_index_nodes(&out))
673             {
674 #if 0
675                 /* This is not broken in fteqcc anymore */
676                 if (OPTS_OPTION_U32(OPTION_STANDARD) != COMPILER_GMQCC) {
677                     /* this error doesn't need to make us bail out */
678                     (void)!parsewarning(parser, WARN_EXTENSIONS,
679                                         "accessing array-field members of an entity without parenthesis\n"
680                                         " -> this is an extension from -std=gmqcc");
681                 }
682 #endif
683             }
684             break;
685
686         case opid1(','):
687             if (vec_size(sy->paren) && vec_last(sy->paren) == PAREN_FUNC) {
688                 vec_push(sy->out, syexp(ctx, exprs[0]));
689                 vec_push(sy->out, syexp(ctx, exprs[1]));
690                 vec_last(sy->argc)++;
691                 return true;
692             }
693             if (blocks[0]) {
694                 if (!ast_block_add_expr(blocks[0], exprs[1]))
695                     return false;
696             } else {
697                 blocks[0] = ast_block_new(ctx);
698                 if (!ast_block_add_expr(blocks[0], exprs[0]) ||
699                     !ast_block_add_expr(blocks[0], exprs[1]))
700                 {
701                     return false;
702                 }
703             }
704             ast_block_set_type(blocks[0], exprs[1]);
705
706             vec_push(sy->out, syblock(ctx, blocks[0]));
707             return true;
708
709         case opid2('+','P'):
710             out = exprs[0];
711             break;
712         case opid2('-','P'):
713             switch (exprs[0]->vtype) {
714                 case TYPE_FLOAT:
715                     if (CanConstFold1(exprs[0]))
716                         out = (ast_expression*)parser_const_float(parser, -ConstF(0));
717                     else
718                         out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F,
719                                                               (ast_expression*)parser_const_float_0(parser),
720                                                               exprs[0]);
721                     break;
722                 case TYPE_VECTOR:
723                     if (CanConstFold1(exprs[0]))
724                         out = (ast_expression*)parser_const_vector_f(parser,
725                             -ConstV(0).x, -ConstV(0).y, -ConstV(0).z);
726                     else
727                         out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V,
728                                                               (ast_expression*)parser_const_vector_0(parser),
729                                                               exprs[0]);
730                     break;
731                 default:
732                 compile_error(ctx, "invalid types used in expression: cannot negate type %s",
733                               type_name[exprs[0]->vtype]);
734                 return false;
735             }
736             break;
737
738         case opid2('!','P'):
739             switch (exprs[0]->vtype) {
740                 case TYPE_FLOAT:
741                     if (CanConstFold1(exprs[0]))
742                         out = (ast_expression*)parser_const_float(parser, !ConstF(0));
743                     else
744                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, exprs[0]);
745                     break;
746                 case TYPE_VECTOR:
747                     if (CanConstFold1(exprs[0]))
748                         out = (ast_expression*)parser_const_float(parser,
749                             (!ConstV(0).x && !ConstV(0).y && !ConstV(0).z));
750                     else
751                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_V, exprs[0]);
752                     break;
753                 case TYPE_STRING:
754                     if (CanConstFold1(exprs[0])) {
755                         if (OPTS_FLAG(TRUE_EMPTY_STRINGS))
756                             out = (ast_expression*)parser_const_float(parser, !ConstS(0));
757                         else
758                             out = (ast_expression*)parser_const_float(parser, !ConstS(0) || !*ConstS(0));
759                     } else {
760                         if (OPTS_FLAG(TRUE_EMPTY_STRINGS))
761                             out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, exprs[0]);
762                         else
763                             out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_S, exprs[0]);
764                     }
765                     break;
766                 /* we don't constant-fold NOT for these types */
767                 case TYPE_ENTITY:
768                     out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_ENT, exprs[0]);
769                     break;
770                 case TYPE_FUNCTION:
771                     out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_FNC, exprs[0]);
772                     break;
773                 default:
774                 compile_error(ctx, "invalid types used in expression: cannot logically negate type %s",
775                               type_name[exprs[0]->vtype]);
776                 return false;
777             }
778             break;
779
780         case opid1('+'):
781             if (exprs[0]->vtype != exprs[1]->vtype ||
782                 (exprs[0]->vtype != TYPE_VECTOR && exprs[0]->vtype != TYPE_FLOAT) )
783             {
784                 compile_error(ctx, "invalid types used in expression: cannot add type %s and %s",
785                               type_name[exprs[0]->vtype],
786                               type_name[exprs[1]->vtype]);
787                 return false;
788             }
789             switch (exprs[0]->vtype) {
790                 case TYPE_FLOAT:
791                     if (CanConstFold(exprs[0], exprs[1]))
792                     {
793                         out = (ast_expression*)parser_const_float(parser, ConstF(0) + ConstF(1));
794                     }
795                     else
796                         out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_F, exprs[0], exprs[1]);
797                     break;
798                 case TYPE_VECTOR:
799                     if (CanConstFold(exprs[0], exprs[1]))
800                         out = (ast_expression*)parser_const_vector(parser, vec3_add(ConstV(0), ConstV(1)));
801                     else
802                         out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_V, exprs[0], exprs[1]);
803                     break;
804                 default:
805                     compile_error(ctx, "invalid types used in expression: cannot add type %s and %s",
806                                   type_name[exprs[0]->vtype],
807                                   type_name[exprs[1]->vtype]);
808                     return false;
809             };
810             break;
811         case opid1('-'):
812             if (exprs[0]->vtype != exprs[1]->vtype ||
813                 (exprs[0]->vtype != TYPE_VECTOR && exprs[0]->vtype != TYPE_FLOAT) )
814             {
815                 compile_error(ctx, "invalid types used in expression: cannot subtract type %s from %s",
816                               type_name[exprs[1]->vtype],
817                               type_name[exprs[0]->vtype]);
818                 return false;
819             }
820             switch (exprs[0]->vtype) {
821                 case TYPE_FLOAT:
822                     if (CanConstFold(exprs[0], exprs[1]))
823                         out = (ast_expression*)parser_const_float(parser, ConstF(0) - ConstF(1));
824                     else
825                         out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F, exprs[0], exprs[1]);
826                     break;
827                 case TYPE_VECTOR:
828                     if (CanConstFold(exprs[0], exprs[1]))
829                         out = (ast_expression*)parser_const_vector(parser, vec3_sub(ConstV(0), ConstV(1)));
830                     else
831                         out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V, exprs[0], exprs[1]);
832                     break;
833                 default:
834                     compile_error(ctx, "invalid types used in expression: cannot subtract type %s from %s",
835                                   type_name[exprs[1]->vtype],
836                                   type_name[exprs[0]->vtype]);
837                     return false;
838             };
839             break;
840         case opid1('*'):
841             if (exprs[0]->vtype != exprs[1]->vtype &&
842                 !(exprs[0]->vtype == TYPE_VECTOR &&
843                   exprs[1]->vtype == TYPE_FLOAT) &&
844                 !(exprs[1]->vtype == TYPE_VECTOR &&
845                   exprs[0]->vtype == TYPE_FLOAT)
846                 )
847             {
848                 compile_error(ctx, "invalid types used in expression: cannot multiply types %s and %s",
849                               type_name[exprs[1]->vtype],
850                               type_name[exprs[0]->vtype]);
851                 return false;
852             }
853             switch (exprs[0]->vtype) {
854                 case TYPE_FLOAT:
855                     if (exprs[1]->vtype == TYPE_VECTOR)
856                     {
857                         if (CanConstFold(exprs[0], exprs[1]))
858                             out = (ast_expression*)parser_const_vector(parser, vec3_mulvf(ConstV(1), ConstF(0)));
859                         else
860                             out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_FV, exprs[0], exprs[1]);
861                     }
862                     else
863                     {
864                         if (CanConstFold(exprs[0], exprs[1]))
865                             out = (ast_expression*)parser_const_float(parser, ConstF(0) * ConstF(1));
866                         else
867                             out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, exprs[0], exprs[1]);
868                     }
869                     break;
870                 case TYPE_VECTOR:
871                     if (exprs[1]->vtype == TYPE_FLOAT)
872                     {
873                         if (CanConstFold(exprs[0], exprs[1]))
874                             out = (ast_expression*)parser_const_vector(parser, vec3_mulvf(ConstV(0), ConstF(1)));
875                         else
876                             out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_VF, exprs[0], exprs[1]);
877                     }
878                     else
879                     {
880                         if (CanConstFold(exprs[0], exprs[1]))
881                             out = (ast_expression*)parser_const_float(parser, vec3_mulvv(ConstV(0), ConstV(1)));
882                         else if (OPTS_OPTIMIZATION(OPTIM_VECTOR_COMPONENTS) && CanConstFold1(exprs[0])) {
883                             vector vec = ConstV(0);
884                             if (!vec.y && !vec.z) { /* 'n 0 0' * v */
885                                 ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS];
886                                 out = (ast_expression*)ast_member_new(ctx, exprs[1], 0, NULL);
887                                 out->node.keep = false;
888                                 ((ast_member*)out)->rvalue = true;
889                                 if (vec.x != 1)
890                                     out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, (ast_expression*)parser_const_float(parser, vec.x), out);
891                             }
892                             else if (!vec.x && !vec.z) { /* '0 n 0' * v */
893                                 ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS];
894                                 out = (ast_expression*)ast_member_new(ctx, exprs[1], 1, NULL);
895                                 out->node.keep = false;
896                                 ((ast_member*)out)->rvalue = true;
897                                 if (vec.y != 1)
898                                     out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, (ast_expression*)parser_const_float(parser, vec.y), out);
899                             }
900                             else if (!vec.x && !vec.y) { /* '0 n 0' * v */
901                                 ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS];
902                                 out = (ast_expression*)ast_member_new(ctx, exprs[1], 2, NULL);
903                                 out->node.keep = false;
904                                 ((ast_member*)out)->rvalue = true;
905                                 if (vec.z != 1)
906                                     out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, (ast_expression*)parser_const_float(parser, vec.z), out);
907                             }
908                             else
909                                 out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_V, exprs[0], exprs[1]);
910                         }
911                         else if (OPTS_OPTIMIZATION(OPTIM_VECTOR_COMPONENTS) && CanConstFold1(exprs[1])) {
912                             vector vec = ConstV(1);
913                             if (!vec.y && !vec.z) { /* v * 'n 0 0' */
914                                 ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS];
915                                 out = (ast_expression*)ast_member_new(ctx, exprs[0], 0, NULL);
916                                 out->node.keep = false;
917                                 ((ast_member*)out)->rvalue = true;
918                                 if (vec.x != 1)
919                                     out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, out, (ast_expression*)parser_const_float(parser, vec.x));
920                             }
921                             else if (!vec.x && !vec.z) { /* v * '0 n 0' */
922                                 ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS];
923                                 out = (ast_expression*)ast_member_new(ctx, exprs[0], 1, NULL);
924                                 out->node.keep = false;
925                                 ((ast_member*)out)->rvalue = true;
926                                 if (vec.y != 1)
927                                     out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, out, (ast_expression*)parser_const_float(parser, vec.y));
928                             }
929                             else if (!vec.x && !vec.y) { /* v * '0 n 0' */
930                                 ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS];
931                                 out = (ast_expression*)ast_member_new(ctx, exprs[0], 2, NULL);
932                                 out->node.keep = false;
933                                 ((ast_member*)out)->rvalue = true;
934                                 if (vec.z != 1)
935                                     out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, out, (ast_expression*)parser_const_float(parser, vec.z));
936                             }
937                             else
938                                 out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_V, exprs[0], exprs[1]);
939                         }
940                         else
941                             out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_V, exprs[0], exprs[1]);
942                     }
943                     break;
944                 default:
945                     compile_error(ctx, "invalid types used in expression: cannot multiply types %s and %s",
946                                   type_name[exprs[1]->vtype],
947                                   type_name[exprs[0]->vtype]);
948                     return false;
949             };
950             break;
951         case opid1('/'):
952             if (exprs[1]->vtype != TYPE_FLOAT) {
953                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
954                 ast_type_to_string(exprs[1], ty2, sizeof(ty2));
955                 compile_error(ctx, "invalid types used in expression: cannot divide tyeps %s and %s", ty1, ty2);
956                 return false;
957             }
958             if (exprs[0]->vtype == TYPE_FLOAT) {
959                 if (CanConstFold(exprs[0], exprs[1]))
960                     out = (ast_expression*)parser_const_float(parser, ConstF(0) / ConstF(1));
961                 else
962                     out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F, exprs[0], exprs[1]);
963             }
964             else if (exprs[0]->vtype == TYPE_VECTOR) {
965                 if (CanConstFold(exprs[0], exprs[1]))
966                     out = (ast_expression*)parser_const_vector(parser, vec3_mulvf(ConstV(0), 1.0/ConstF(1)));
967                 else {
968                     if (CanConstFold1(exprs[1])) {
969                         out = (ast_expression*)parser_const_float(parser, 1.0 / ConstF(1));
970                     } else {
971                         out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F,
972                                                               (ast_expression*)parser_const_float_1(parser),
973                                                               exprs[1]);
974                     }
975                     if (!out) {
976                         compile_error(ctx, "internal error: failed to generate division");
977                         return false;
978                     }
979                     out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_VF, exprs[0], out);
980                 }
981             }
982             else
983             {
984                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
985                 ast_type_to_string(exprs[1], ty2, sizeof(ty2));
986                 compile_error(ctx, "invalid types used in expression: cannot divide tyeps %s and %s", ty1, ty2);
987                 return false;
988             }
989             break;
990
991         case opid1('%'):
992             if (NotSameType(TYPE_FLOAT)) {
993                 compile_error(ctx, "invalid types used in expression: cannot perform modulo operation between types %s and %s",
994                     type_name[exprs[0]->vtype],
995                     type_name[exprs[1]->vtype]);
996                 return false;
997             }
998             if (CanConstFold(exprs[0], exprs[1])) {
999                 out = (ast_expression*)parser_const_float(parser,
1000                             (float)(((qcint)ConstF(0)) % ((qcint)ConstF(1))));
1001             } else {
1002                 /* generate a call to __builtin_mod */
1003                 ast_expression *mod  = intrin_func(parser, "mod");
1004                 ast_call       *call = NULL;
1005                 if (!mod) return false; /* can return null for missing floor */
1006
1007                 call = ast_call_new(parser_ctx(parser), mod);
1008                 vec_push(call->params, exprs[0]);
1009                 vec_push(call->params, exprs[1]);
1010
1011                 out = (ast_expression*)call;
1012             }
1013             break;
1014
1015         case opid2('%','='):
1016             compile_error(ctx, "%= is unimplemented");
1017             return false;
1018
1019         case opid1('|'):
1020         case opid1('&'):
1021             if (NotSameType(TYPE_FLOAT)) {
1022                 compile_error(ctx, "invalid types used in expression: cannot perform bit operations between types %s and %s",
1023                               type_name[exprs[0]->vtype],
1024                               type_name[exprs[1]->vtype]);
1025                 return false;
1026             }
1027             if (CanConstFold(exprs[0], exprs[1]))
1028                 out = (ast_expression*)parser_const_float(parser,
1029                     (op->id == opid1('|') ? (float)( ((qcint)ConstF(0)) | ((qcint)ConstF(1)) ) :
1030                                             (float)( ((qcint)ConstF(0)) & ((qcint)ConstF(1)) ) ));
1031             else
1032                 out = (ast_expression*)ast_binary_new(ctx,
1033                     (op->id == opid1('|') ? INSTR_BITOR : INSTR_BITAND),
1034                     exprs[0], exprs[1]);
1035             break;
1036         case opid1('^'):
1037             /*
1038              * Okay lets designate what the hell is an acceptable use
1039              * of the ^ operator. In many vector processing units, XOR
1040              * is allowed to be used on vectors, but only if the first
1041              * operand is a vector, the second operand can be a float
1042              * or vector. It's never legal for the first operand to be
1043              * a float, and then the following operand to be a vector.
1044              * Further more, the only time it is legal to do XOR otherwise
1045              * is when both operand are floats. This nicely crafted if
1046              * statement catches them all.
1047              * 
1048              * In the event that the first operand is a vector, two
1049              * possible situations can arise, thus, each element of
1050              * vector A (operand A) is exclusive-ORed with the corresponding
1051              * element of vector B (operand B), If B is scalar, the
1052              * scalar value is first replicated for each element.
1053              * 
1054              * The QCVM itself lacks a BITXOR instruction. Thus emulating
1055              * the mathematics of it is required. The following equation
1056              * is used: (LHS | RHS) & ~(LHS & RHS). However, due to the
1057              * QCVM also lacking a BITNEG instruction, we need to emulate
1058              * ~FOO with -1 - FOO, the whole process becoming this nicely
1059              * crafted expression: (LHS | RHS) & (-1 - (LHS & RHS)).
1060              * 
1061              * When A is not scalar, this process is repeated for all
1062              * components of vector A with the value in operand B,
1063              * only if operand B is scalar. When A is not scalar, and B
1064              * is also not scalar, this process is repeated for all
1065              * components of the vector A with the components of vector B.
1066              * Finally when A is scalar and B is scalar, this process is
1067              * simply used once for A and B being LHS and RHS respectfully.
1068              * 
1069              * Yes the semantics are a bit strange (no pun intended).
1070              * But then again BITXOR is strange itself, consdering it's
1071              * commutative, assocative, and elements of the BITXOR operation
1072              * are their own inverse.
1073              */
1074             if ( !(exprs[0]->vtype == TYPE_FLOAT  && exprs[1]->vtype == TYPE_FLOAT) &&
1075                  !(exprs[0]->vtype == TYPE_VECTOR && exprs[1]->vtype == TYPE_FLOAT) &&
1076                  !(exprs[0]->vtype == TYPE_VECTOR && exprs[1]->vtype == TYPE_VECTOR))
1077             {
1078                 compile_error(ctx, "invalid types used in expression: cannot perform bit operations between types %s and %s",
1079                               type_name[exprs[0]->vtype],
1080                               type_name[exprs[1]->vtype]);
1081                 return false;
1082             }
1083
1084             /*
1085              * IF the first expression is float, the following will be too
1086              * since scalar ^ vector is not allowed.
1087              */
1088             if (exprs[0]->vtype == TYPE_FLOAT) {
1089                 if(CanConstFold(exprs[0], exprs[1])) {
1090                     out = (ast_expression*)parser_const_float(parser, (float)((qcint)(ConstF(0)) ^ ((qcint)(ConstF(1)))));
1091                 } else {
1092                     ast_binary *expr = ast_binary_new(
1093                         ctx,
1094                         INSTR_SUB_F,
1095                         (ast_expression*)parser_const_float_neg1(parser),
1096                         (ast_expression*)ast_binary_new(
1097                             ctx,
1098                             INSTR_BITAND,
1099                             exprs[0],
1100                             exprs[1]
1101                         )
1102                     );
1103                     expr->refs = AST_REF_NONE;
1104                     
1105                     out = (ast_expression*)
1106                         ast_binary_new(
1107                             ctx,
1108                             INSTR_BITAND,
1109                             (ast_expression*)ast_binary_new(
1110                                 ctx,
1111                                 INSTR_BITOR,
1112                                 exprs[0],
1113                                 exprs[1]
1114                             ),
1115                             (ast_expression*)expr
1116                         );
1117                 }
1118             } else {
1119                 /*
1120                  * The first is a vector: vector is allowed to xor with vector and
1121                  * with scalar, branch here for the second operand.
1122                  */
1123                 if (exprs[1]->vtype == TYPE_VECTOR) {
1124                     /*
1125                      * Xor all the values of the vector components against the
1126                      * vectors components in question.
1127                      */
1128                     if (CanConstFold(exprs[0], exprs[1])) {
1129                         out = (ast_expression*)parser_const_vector_f(
1130                             parser,
1131                             (float)(((qcint)(ConstV(0).x)) ^ ((qcint)(ConstV(1).x))),
1132                             (float)(((qcint)(ConstV(0).y)) ^ ((qcint)(ConstV(1).y))),
1133                             (float)(((qcint)(ConstV(0).z)) ^ ((qcint)(ConstV(1).z)))
1134                         );
1135                     } else {
1136                         compile_error(ast_ctx(exprs[0]), "Not Yet Implemented: bit-xor for vector against vector");
1137                         return false;
1138                     }
1139                 } else {
1140                     /*
1141                      * Xor all the values of the vector components against the
1142                      * scalar in question.
1143                      */
1144                     if (CanConstFold(exprs[0], exprs[1])) {
1145                         out = (ast_expression*)parser_const_vector_f(
1146                             parser,
1147                             (float)(((qcint)(ConstV(0).x)) ^ ((qcint)(ConstF(1)))),
1148                             (float)(((qcint)(ConstV(0).y)) ^ ((qcint)(ConstF(1)))),
1149                             (float)(((qcint)(ConstV(0).z)) ^ ((qcint)(ConstF(1))))
1150                         );
1151                     } else {
1152                         compile_error(ast_ctx(exprs[0]), "Not Yet Implemented: bit-xor for vector against float");
1153                         return false;
1154                     }
1155                 }
1156             }
1157                 
1158             break;
1159
1160         case opid2('<','<'):
1161         case opid2('>','>'):
1162             if (CanConstFold(exprs[0], exprs[1]) && ! NotSameType(TYPE_FLOAT)) {
1163                 if (op->id == opid2('<','<'))
1164                     out = (ast_expression*)parser_const_float(parser, (double)((unsigned int)(ConstF(0)) << (unsigned int)(ConstF(1))));
1165                 else
1166                     out = (ast_expression*)parser_const_float(parser, (double)((unsigned int)(ConstF(0)) >> (unsigned int)(ConstF(1))));
1167                 break;
1168             }
1169         case opid3('<','<','='):
1170         case opid3('>','>','='):
1171             compile_error(ast_ctx(exprs[0]), "Not Yet Implemented: bit-shifts");
1172             return false;
1173
1174         case opid2('|','|'):
1175             generated_op += 1; /* INSTR_OR */
1176         case opid2('&','&'):
1177             generated_op += INSTR_AND;
1178             if (CanConstFold(exprs[0], exprs[1]))
1179             {
1180                 if (OPTS_FLAG(PERL_LOGIC)) {
1181                     if (immediate_is_true(ctx, asvalue[0]))
1182                         out = exprs[1];
1183                 }
1184                 else
1185                     out = (ast_expression*)parser_const_float(parser,
1186                           ( (generated_op == INSTR_OR)
1187                             ? (immediate_is_true(ctx, asvalue[0]) || immediate_is_true(ctx, asvalue[1]))
1188                             : (immediate_is_true(ctx, asvalue[0]) && immediate_is_true(ctx, asvalue[1])) )
1189                           ? 1 : 0);
1190             }
1191             else
1192             {
1193                 if (OPTS_FLAG(PERL_LOGIC) && !ast_compare_type(exprs[0], exprs[1])) {
1194                     ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1195                     ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1196                     compile_error(ctx, "invalid types for logical operation with -fperl-logic: %s and %s", ty1, ty2);
1197                     return false;
1198                 }
1199                 for (i = 0; i < 2; ++i) {
1200                     if (OPTS_FLAG(CORRECT_LOGIC) && exprs[i]->vtype == TYPE_VECTOR) {
1201                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_V, exprs[i]);
1202                         if (!out) break;
1203                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, out);
1204                         if (!out) break;
1205                         exprs[i] = out; out = NULL;
1206                         if (OPTS_FLAG(PERL_LOGIC)) {
1207                             /* here we want to keep the right expressions' type */
1208                             break;
1209                         }
1210                     }
1211                     else if (OPTS_FLAG(FALSE_EMPTY_STRINGS) && exprs[i]->vtype == TYPE_STRING) {
1212                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_S, exprs[i]);
1213                         if (!out) break;
1214                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, out);
1215                         if (!out) break;
1216                         exprs[i] = out; out = NULL;
1217                         if (OPTS_FLAG(PERL_LOGIC)) {
1218                             /* here we want to keep the right expressions' type */
1219                             break;
1220                         }
1221                     }
1222                 }
1223                 out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
1224             }
1225             break;
1226
1227         case opid2('?',':'):
1228             if (vec_last(sy->paren) != PAREN_TERNARY2) {
1229                 compile_error(ctx, "mismatched parenthesis/ternary");
1230                 return false;
1231             }
1232             vec_pop(sy->paren);
1233             if (!ast_compare_type(exprs[1], exprs[2])) {
1234                 ast_type_to_string(exprs[1], ty1, sizeof(ty1));
1235                 ast_type_to_string(exprs[2], ty2, sizeof(ty2));
1236                 compile_error(ctx, "operands of ternary expression must have the same type, got %s and %s", ty1, ty2);
1237                 return false;
1238             }
1239             if (CanConstFold1(exprs[0]))
1240                 out = (immediate_is_true(ctx, asvalue[0]) ? exprs[1] : exprs[2]);
1241             else
1242                 out = (ast_expression*)ast_ternary_new(ctx, exprs[0], exprs[1], exprs[2]);
1243             break;
1244
1245         case opid2('*', '*'):
1246             if (NotSameType(TYPE_FLOAT)) {
1247                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1248                 ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1249                 compile_error(ctx, "invalid types used in exponentiation: %s and %s",
1250                     ty1, ty2);
1251
1252                 return false;
1253             }
1254
1255             if (CanConstFold(exprs[0], exprs[1])) {
1256                 out = (ast_expression*)parser_const_float(parser, powf(ConstF(0), ConstF(1)));
1257             } else {
1258                 ast_call *gencall = ast_call_new(parser_ctx(parser), intrin_func(parser, "pow"));
1259                 vec_push(gencall->params, exprs[0]);
1260                 vec_push(gencall->params, exprs[1]);
1261                 out = (ast_expression*)gencall;
1262             }
1263             break;
1264
1265         case opid3('<','=','>'): /* -1, 0, or 1 */
1266             if (NotSameType(TYPE_FLOAT)) {
1267                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1268                 ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1269                 compile_error(ctx, "invalid types used in comparision: %s and %s",
1270                     ty1, ty2);
1271
1272                 return false;
1273             }
1274
1275             if (CanConstFold(exprs[0], exprs[1])) {
1276                 if (ConstF(0) < ConstF(1))
1277                     out = (ast_expression*)parser_const_float_neg1(parser);
1278                 else if (ConstF(0) == ConstF(1))
1279                     out = (ast_expression*)parser_const_float_0(parser);
1280                 else if (ConstF(0) > ConstF(1))
1281                     out = (ast_expression*)parser_const_float_1(parser);
1282             } else {
1283                 ast_binary *eq = ast_binary_new(ctx, INSTR_EQ_F, exprs[0], exprs[1]);
1284
1285                 eq->refs = AST_REF_NONE;
1286
1287                     /* if (lt) { */
1288                 out = (ast_expression*)ast_ternary_new(ctx,
1289                         (ast_expression*)ast_binary_new(ctx, INSTR_LT, exprs[0], exprs[1]),
1290                         /* out = -1 */
1291                         (ast_expression*)parser_const_float_neg1(parser),
1292                     /* } else { */
1293                         /* if (eq) { */
1294                         (ast_expression*)ast_ternary_new(ctx, (ast_expression*)eq,
1295                             /* out = 0 */
1296                             (ast_expression*)parser_const_float_0(parser),
1297                         /* } else { */
1298                             /* out = 1 */
1299                             (ast_expression*)parser_const_float_1(parser)
1300                         /* } */
1301                         )
1302                     /* } */
1303                     );
1304
1305             }
1306             break;
1307
1308         case opid1('>'):
1309             generated_op += 1; /* INSTR_GT */
1310         case opid1('<'):
1311             generated_op += 1; /* INSTR_LT */
1312         case opid2('>', '='):
1313             generated_op += 1; /* INSTR_GE */
1314         case opid2('<', '='):
1315             generated_op += INSTR_LE;
1316             if (NotSameType(TYPE_FLOAT)) {
1317                 compile_error(ctx, "invalid types used in expression: cannot perform comparison between types %s and %s",
1318                               type_name[exprs[0]->vtype],
1319                               type_name[exprs[1]->vtype]);
1320                 return false;
1321             }
1322             out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
1323             break;
1324         case opid2('!', '='):
1325             if (exprs[0]->vtype != exprs[1]->vtype) {
1326                 compile_error(ctx, "invalid types used in expression: cannot perform comparison between types %s and %s",
1327                               type_name[exprs[0]->vtype],
1328                               type_name[exprs[1]->vtype]);
1329                 return false;
1330             }
1331             out = (ast_expression*)ast_binary_new(ctx, type_ne_instr[exprs[0]->vtype], exprs[0], exprs[1]);
1332             break;
1333         case opid2('=', '='):
1334             if (exprs[0]->vtype != exprs[1]->vtype) {
1335                 compile_error(ctx, "invalid types used in expression: cannot perform comparison between types %s and %s",
1336                               type_name[exprs[0]->vtype],
1337                               type_name[exprs[1]->vtype]);
1338                 return false;
1339             }
1340             out = (ast_expression*)ast_binary_new(ctx, type_eq_instr[exprs[0]->vtype], exprs[0], exprs[1]);
1341             break;
1342
1343         case opid1('='):
1344             if (ast_istype(exprs[0], ast_entfield)) {
1345                 ast_expression *field = ((ast_entfield*)exprs[0])->field;
1346                 if (OPTS_FLAG(ADJUST_VECTOR_FIELDS) &&
1347                     exprs[0]->vtype == TYPE_FIELD &&
1348                     exprs[0]->next->vtype == TYPE_VECTOR)
1349                 {
1350                     assignop = type_storep_instr[TYPE_VECTOR];
1351                 }
1352                 else
1353                     assignop = type_storep_instr[exprs[0]->vtype];
1354                 if (assignop == VINSTR_END || !ast_compare_type(field->next, exprs[1]))
1355                 {
1356                     ast_type_to_string(field->next, ty1, sizeof(ty1));
1357                     ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1358                     if (OPTS_FLAG(ASSIGN_FUNCTION_TYPES) &&
1359                         field->next->vtype == TYPE_FUNCTION &&
1360                         exprs[1]->vtype == TYPE_FUNCTION)
1361                     {
1362                         (void)!compile_warning(ctx, WARN_ASSIGN_FUNCTION_TYPES,
1363                                                "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
1364                     }
1365                     else
1366                         compile_error(ctx, "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
1367                 }
1368             }
1369             else
1370             {
1371                 if (OPTS_FLAG(ADJUST_VECTOR_FIELDS) &&
1372                     exprs[0]->vtype == TYPE_FIELD &&
1373                     exprs[0]->next->vtype == TYPE_VECTOR)
1374                 {
1375                     assignop = type_store_instr[TYPE_VECTOR];
1376                 }
1377                 else {
1378                     assignop = type_store_instr[exprs[0]->vtype];
1379                 }
1380
1381                 if (assignop == VINSTR_END) {
1382                     ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1383                     ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1384                     compile_error(ctx, "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
1385                 }
1386                 else if (!ast_compare_type(exprs[0], exprs[1]))
1387                 {
1388                     ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1389                     ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1390                     if (OPTS_FLAG(ASSIGN_FUNCTION_TYPES) &&
1391                         exprs[0]->vtype == TYPE_FUNCTION &&
1392                         exprs[1]->vtype == TYPE_FUNCTION)
1393                     {
1394                         (void)!compile_warning(ctx, WARN_ASSIGN_FUNCTION_TYPES,
1395                                                "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
1396                     }
1397                     else
1398                         compile_error(ctx, "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
1399                 }
1400             }
1401             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1402                 compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name);
1403             }
1404             out = (ast_expression*)ast_store_new(ctx, assignop, exprs[0], exprs[1]);
1405             break;
1406         case opid3('+','+','P'):
1407         case opid3('-','-','P'):
1408             /* prefix ++ */
1409             if (exprs[0]->vtype != TYPE_FLOAT) {
1410                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1411                 compile_error(ast_ctx(exprs[0]), "invalid type for prefix increment: %s", ty1);
1412                 return false;
1413             }
1414             if (op->id == opid3('+','+','P'))
1415                 addop = INSTR_ADD_F;
1416             else
1417                 addop = INSTR_SUB_F;
1418             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1419                 compile_error(ast_ctx(exprs[0]), "assignment to constant `%s`", asvalue[0]->name);
1420             }
1421             if (ast_istype(exprs[0], ast_entfield)) {
1422                 out = (ast_expression*)ast_binstore_new(ctx, INSTR_STOREP_F, addop,
1423                                                         exprs[0],
1424                                                         (ast_expression*)parser_const_float_1(parser));
1425             } else {
1426                 out = (ast_expression*)ast_binstore_new(ctx, INSTR_STORE_F, addop,
1427                                                         exprs[0],
1428                                                         (ast_expression*)parser_const_float_1(parser));
1429             }
1430             break;
1431         case opid3('S','+','+'):
1432         case opid3('S','-','-'):
1433             /* prefix ++ */
1434             if (exprs[0]->vtype != TYPE_FLOAT) {
1435                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1436                 compile_error(ast_ctx(exprs[0]), "invalid type for suffix increment: %s", ty1);
1437                 return false;
1438             }
1439             if (op->id == opid3('S','+','+')) {
1440                 addop = INSTR_ADD_F;
1441                 subop = INSTR_SUB_F;
1442             } else {
1443                 addop = INSTR_SUB_F;
1444                 subop = INSTR_ADD_F;
1445             }
1446             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1447                 compile_error(ast_ctx(exprs[0]), "assignment to constant `%s`", asvalue[0]->name);
1448             }
1449             if (ast_istype(exprs[0], ast_entfield)) {
1450                 out = (ast_expression*)ast_binstore_new(ctx, INSTR_STOREP_F, addop,
1451                                                         exprs[0],
1452                                                         (ast_expression*)parser_const_float_1(parser));
1453             } else {
1454                 out = (ast_expression*)ast_binstore_new(ctx, INSTR_STORE_F, addop,
1455                                                         exprs[0],
1456                                                         (ast_expression*)parser_const_float_1(parser));
1457             }
1458             if (!out)
1459                 return false;
1460             out = (ast_expression*)ast_binary_new(ctx, subop,
1461                                                   out,
1462                                                   (ast_expression*)parser_const_float_1(parser));
1463             break;
1464         case opid2('+','='):
1465         case opid2('-','='):
1466             if (exprs[0]->vtype != exprs[1]->vtype ||
1467                 (exprs[0]->vtype != TYPE_VECTOR && exprs[0]->vtype != TYPE_FLOAT) )
1468             {
1469                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1470                 ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1471                 compile_error(ctx, "invalid types used in expression: cannot add or subtract type %s and %s",
1472                               ty1, ty2);
1473                 return false;
1474             }
1475             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1476                 compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name);
1477             }
1478             if (ast_istype(exprs[0], ast_entfield))
1479                 assignop = type_storep_instr[exprs[0]->vtype];
1480             else
1481                 assignop = type_store_instr[exprs[0]->vtype];
1482             switch (exprs[0]->vtype) {
1483                 case TYPE_FLOAT:
1484                     out = (ast_expression*)ast_binstore_new(ctx, assignop,
1485                                                             (op->id == opid2('+','=') ? INSTR_ADD_F : INSTR_SUB_F),
1486                                                             exprs[0], exprs[1]);
1487                     break;
1488                 case TYPE_VECTOR:
1489                     out = (ast_expression*)ast_binstore_new(ctx, assignop,
1490                                                             (op->id == opid2('+','=') ? INSTR_ADD_V : INSTR_SUB_V),
1491                                                             exprs[0], exprs[1]);
1492                     break;
1493                 default:
1494                     compile_error(ctx, "invalid types used in expression: cannot add or subtract type %s and %s",
1495                                   type_name[exprs[0]->vtype],
1496                                   type_name[exprs[1]->vtype]);
1497                     return false;
1498             };
1499             break;
1500         case opid2('*','='):
1501         case opid2('/','='):
1502             if (exprs[1]->vtype != TYPE_FLOAT ||
1503                 !(exprs[0]->vtype == TYPE_FLOAT ||
1504                   exprs[0]->vtype == TYPE_VECTOR))
1505             {
1506                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1507                 ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1508                 compile_error(ctx, "invalid types used in expression: %s and %s",
1509                               ty1, ty2);
1510                 return false;
1511             }
1512             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1513                 compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name);
1514             }
1515             if (ast_istype(exprs[0], ast_entfield))
1516                 assignop = type_storep_instr[exprs[0]->vtype];
1517             else
1518                 assignop = type_store_instr[exprs[0]->vtype];
1519             switch (exprs[0]->vtype) {
1520                 case TYPE_FLOAT:
1521                     out = (ast_expression*)ast_binstore_new(ctx, assignop,
1522                                                             (op->id == opid2('*','=') ? INSTR_MUL_F : INSTR_DIV_F),
1523                                                             exprs[0], exprs[1]);
1524                     break;
1525                 case TYPE_VECTOR:
1526                     if (op->id == opid2('*','=')) {
1527                         out = (ast_expression*)ast_binstore_new(ctx, assignop, INSTR_MUL_VF,
1528                                                                 exprs[0], exprs[1]);
1529                     } else {
1530                         /* there's no DIV_VF */
1531                         if (CanConstFold1(exprs[1])) {
1532                             out = (ast_expression*)parser_const_float(parser, 1.0 / ConstF(1));
1533                         } else {
1534                             out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F,
1535                                                                   (ast_expression*)parser_const_float_1(parser),
1536                                                                   exprs[1]);
1537                         }
1538                         if (!out) {
1539                             compile_error(ctx, "internal error: failed to generate division");
1540                             return false;
1541                         }
1542                         out = (ast_expression*)ast_binstore_new(ctx, assignop, INSTR_MUL_VF,
1543                                                                 exprs[0], out);
1544                     }
1545                     break;
1546                 default:
1547                     compile_error(ctx, "invalid types used in expression: cannot add or subtract type %s and %s",
1548                                   type_name[exprs[0]->vtype],
1549                                   type_name[exprs[1]->vtype]);
1550                     return false;
1551             };
1552             break;
1553         case opid2('&','='):
1554         case opid2('|','='):
1555             if (NotSameType(TYPE_FLOAT)) {
1556                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1557                 ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1558                 compile_error(ctx, "invalid types used in expression: %s and %s",
1559                               ty1, ty2);
1560                 return false;
1561             }
1562             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1563                 compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name);
1564             }
1565             if (ast_istype(exprs[0], ast_entfield))
1566                 assignop = type_storep_instr[exprs[0]->vtype];
1567             else
1568                 assignop = type_store_instr[exprs[0]->vtype];
1569             out = (ast_expression*)ast_binstore_new(ctx, assignop,
1570                                                     (op->id == opid2('&','=') ? INSTR_BITAND : INSTR_BITOR),
1571                                                     exprs[0], exprs[1]);
1572             break;
1573         case opid3('&','~','='):
1574             /* This is like: a &= ~(b);
1575              * But QC has no bitwise-not, so we implement it as
1576              * a -= a & (b);
1577              */
1578             if (NotSameType(TYPE_FLOAT)) {
1579                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1580                 ast_type_to_string(exprs[1], ty2, sizeof(ty2));
1581                 compile_error(ctx, "invalid types used in expression: %s and %s",
1582                               ty1, ty2);
1583                 return false;
1584             }
1585             if (ast_istype(exprs[0], ast_entfield))
1586                 assignop = type_storep_instr[exprs[0]->vtype];
1587             else
1588                 assignop = type_store_instr[exprs[0]->vtype];
1589             out = (ast_expression*)ast_binary_new(ctx, INSTR_BITAND, exprs[0], exprs[1]);
1590             if (!out)
1591                 return false;
1592             if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
1593                 compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name);
1594             }
1595             asbinstore = ast_binstore_new(ctx, assignop, INSTR_SUB_F, exprs[0], out);
1596             asbinstore->keep_dest = true;
1597             out = (ast_expression*)asbinstore;
1598             break;
1599
1600         case opid2('~', 'P'):
1601             if (exprs[0]->vtype != TYPE_FLOAT) {
1602                 ast_type_to_string(exprs[0], ty1, sizeof(ty1));
1603                 compile_error(ast_ctx(exprs[0]), "invalid type for bit not: %s", ty1);
1604                 return false;
1605             }
1606
1607             if(CanConstFold1(exprs[0]))
1608                 out = (ast_expression*)parser_const_float(parser, ~(qcint)ConstF(0));
1609             else
1610                 out = (ast_expression*)
1611                     ast_binary_new(ctx, INSTR_SUB_F, (ast_expression*)parser_const_float_neg1(parser), exprs[0]);
1612             break;
1613     }
1614 #undef NotSameType
1615
1616     if (!out) {
1617         compile_error(ctx, "failed to apply operator %s", op->op);
1618         return false;
1619     }
1620
1621     vec_push(sy->out, syexp(ctx, out));
1622     return true;
1623 }
1624
1625 static bool parser_close_call(parser_t *parser, shunt *sy)
1626 {
1627     /* was a function call */
1628     ast_expression *fun;
1629     ast_value      *funval = NULL;
1630     ast_call       *call;
1631
1632     size_t          fid;
1633     size_t          paramcount, i;
1634
1635     fid = vec_last(sy->ops).off;
1636     vec_shrinkby(sy->ops, 1);
1637
1638     /* out[fid] is the function
1639      * everything above is parameters...
1640      */
1641     if (!vec_size(sy->argc)) {
1642         parseerror(parser, "internal error: no argument counter available");
1643         return false;
1644     }
1645
1646     paramcount = vec_last(sy->argc);
1647     vec_pop(sy->argc);
1648
1649     if (vec_size(sy->out) < fid) {
1650         parseerror(parser, "internal error: broken function call%lu < %lu+%lu\n",
1651                    (unsigned long)vec_size(sy->out),
1652                    (unsigned long)fid,
1653                    (unsigned long)paramcount);
1654         return false;
1655     }
1656
1657     fun = sy->out[fid].out;
1658
1659     if (fun == intrinsic_debug_typestring) {
1660         char ty[1024];
1661         if (fid+2 != vec_size(sy->out) ||
1662             vec_last(sy->out).block)
1663         {
1664             parseerror(parser, "intrinsic __builtin_debug_typestring requires exactly 1 parameter");
1665             return false;
1666         }
1667         ast_type_to_string(vec_last(sy->out).out, ty, sizeof(ty));
1668         ast_unref(vec_last(sy->out).out);
1669         sy->out[fid] = syexp(ast_ctx(vec_last(sy->out).out),
1670                              (ast_expression*)parser_const_string(parser, ty, false));
1671         vec_shrinkby(sy->out, 1);
1672         return true;
1673     }
1674
1675     call = ast_call_new(sy->ops[vec_size(sy->ops)].ctx, fun);
1676     if (!call)
1677         return false;
1678
1679     if (fid+1 < vec_size(sy->out))
1680         ++paramcount;
1681
1682     if (fid+1 + paramcount != vec_size(sy->out)) {
1683         parseerror(parser, "internal error: parameter count mismatch: (%lu+1+%lu), %lu",
1684                    (unsigned long)fid, (unsigned long)paramcount, (unsigned long)vec_size(sy->out));
1685         return false;
1686     }
1687
1688     for (i = 0; i < paramcount; ++i)
1689         vec_push(call->params, sy->out[fid+1 + i].out);
1690     vec_shrinkby(sy->out, paramcount);
1691     (void)!ast_call_check_types(call, parser->function->vtype->expression.varparam);
1692     if (parser->max_param_count < paramcount)
1693         parser->max_param_count = paramcount;
1694
1695     if (ast_istype(fun, ast_value)) {
1696         funval = (ast_value*)fun;
1697         if ((fun->flags & AST_FLAG_VARIADIC) &&
1698             !(/*funval->cvq == CV_CONST && */ funval->hasvalue && funval->constval.vfunc->builtin))
1699         {
1700             call->va_count = (ast_expression*)parser_const_float(parser, (double)paramcount);
1701         }
1702     }
1703
1704     /* overwrite fid, the function, with a call */
1705     sy->out[fid] = syexp(call->expression.node.context, (ast_expression*)call);
1706
1707     if (fun->vtype != TYPE_FUNCTION) {
1708         parseerror(parser, "not a function (%s)", type_name[fun->vtype]);
1709         return false;
1710     }
1711
1712     if (!fun->next) {
1713         parseerror(parser, "could not determine function return type");
1714         return false;
1715     } else {
1716         ast_value *fval = (ast_istype(fun, ast_value) ? ((ast_value*)fun) : NULL);
1717
1718         if (fun->flags & AST_FLAG_DEPRECATED) {
1719             if (!fval) {
1720                 return !parsewarning(parser, WARN_DEPRECATED,
1721                         "call to function (which is marked deprecated)\n",
1722                         "-> it has been declared here: %s:%i",
1723                         ast_ctx(fun).file, ast_ctx(fun).line);
1724             }
1725             if (!fval->desc) {
1726                 return !parsewarning(parser, WARN_DEPRECATED,
1727                         "call to `%s` (which is marked deprecated)\n"
1728                         "-> `%s` declared here: %s:%i",
1729                         fval->name, fval->name, ast_ctx(fun).file, ast_ctx(fun).line);
1730             }
1731             return !parsewarning(parser, WARN_DEPRECATED,
1732                     "call to `%s` (deprecated: %s)\n"
1733                     "-> `%s` declared here: %s:%i",
1734                     fval->name, fval->desc, fval->name, ast_ctx(fun).file,
1735                     ast_ctx(fun).line);
1736         }
1737
1738         if (vec_size(fun->params) != paramcount &&
1739             !((fun->flags & AST_FLAG_VARIADIC) &&
1740               vec_size(fun->params) < paramcount))
1741         {
1742             const char *fewmany = (vec_size(fun->params) > paramcount) ? "few" : "many";
1743             if (fval)
1744                 return !parsewarning(parser, WARN_INVALID_PARAMETER_COUNT,
1745                                      "too %s parameters for call to %s: expected %i, got %i\n"
1746                                      " -> `%s` has been declared here: %s:%i",
1747                                      fewmany, fval->name, (int)vec_size(fun->params), (int)paramcount,
1748                                      fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line);
1749             else
1750                 return !parsewarning(parser, WARN_INVALID_PARAMETER_COUNT,
1751                                      "too %s parameters for function call: expected %i, got %i\n"
1752                                      " -> it has been declared here: %s:%i",
1753                                      fewmany, (int)vec_size(fun->params), (int)paramcount,
1754                                      ast_ctx(fun).file, (int)ast_ctx(fun).line);
1755         }
1756     }
1757
1758     return true;
1759 }
1760
1761 static bool parser_close_paren(parser_t *parser, shunt *sy)
1762 {
1763     if (!vec_size(sy->ops)) {
1764         parseerror(parser, "unmatched closing paren");
1765         return false;
1766     }
1767
1768     while (vec_size(sy->ops)) {
1769         if (vec_last(sy->ops).isparen) {
1770             if (vec_last(sy->paren) == PAREN_FUNC) {
1771                 vec_pop(sy->paren);
1772                 if (!parser_close_call(parser, sy))
1773                     return false;
1774                 break;
1775             }
1776             if (vec_last(sy->paren) == PAREN_EXPR) {
1777                 vec_pop(sy->paren);
1778                 if (!vec_size(sy->out)) {
1779                     compile_error(vec_last(sy->ops).ctx, "empty paren expression");
1780                     vec_shrinkby(sy->ops, 1);
1781                     return false;
1782                 }
1783                 vec_shrinkby(sy->ops, 1);
1784                 break;
1785             }
1786             if (vec_last(sy->paren) == PAREN_INDEX) {
1787                 vec_pop(sy->paren);
1788                 /* pop off the parenthesis */
1789                 vec_shrinkby(sy->ops, 1);
1790                 /* then apply the index operator */
1791                 if (!parser_sy_apply_operator(parser, sy))
1792                     return false;
1793                 break;
1794             }
1795             if (vec_last(sy->paren) == PAREN_TERNARY1) {
1796                 vec_last(sy->paren) = PAREN_TERNARY2;
1797                 /* pop off the parenthesis */
1798                 vec_shrinkby(sy->ops, 1);
1799                 break;
1800             }
1801             compile_error(vec_last(sy->ops).ctx, "invalid parenthesis");
1802             return false;
1803         }
1804         if (!parser_sy_apply_operator(parser, sy))
1805             return false;
1806     }
1807     return true;
1808 }
1809
1810 static void parser_reclassify_token(parser_t *parser)
1811 {
1812     size_t i;
1813     for (i = 0; i < operator_count; ++i) {
1814         if (!strcmp(parser_tokval(parser), operators[i].op)) {
1815             parser->tok = TOKEN_OPERATOR;
1816             return;
1817         }
1818     }
1819 }
1820
1821 static ast_expression* parse_vararg_do(parser_t *parser)
1822 {
1823     ast_expression *idx, *out;
1824     ast_value      *typevar;
1825     ast_value      *funtype = parser->function->vtype;
1826     lex_ctx         ctx     = parser_ctx(parser);
1827
1828     if (!parser->function->varargs) {
1829         parseerror(parser, "function has no variable argument list");
1830         return NULL;
1831     }
1832
1833     if (!parser_next(parser) || parser->tok != '(') {
1834         parseerror(parser, "expected parameter index and type in parenthesis");
1835         return NULL;
1836     }
1837     if (!parser_next(parser)) {
1838         parseerror(parser, "error parsing parameter index");
1839         return NULL;
1840     }
1841
1842     idx = parse_expression_leave(parser, true, false, false);
1843     if (!idx)
1844         return NULL;
1845
1846     if (parser->tok != ',') {
1847         if (parser->tok != ')') {
1848             ast_unref(idx);
1849             parseerror(parser, "expected comma after parameter index");
1850             return NULL;
1851         }
1852         /* vararg piping: ...(start) */
1853         out = (ast_expression*)ast_argpipe_new(ctx, idx);
1854         return out;
1855     }
1856
1857     if (!parser_next(parser) || (parser->tok != TOKEN_IDENT && parser->tok != TOKEN_TYPENAME)) {
1858         ast_unref(idx);
1859         parseerror(parser, "expected typename for vararg");
1860         return NULL;
1861     }
1862
1863     typevar = parse_typename(parser, NULL, NULL);
1864     if (!typevar) {
1865         ast_unref(idx);
1866         return NULL;
1867     }
1868
1869     if (parser->tok != ')') {
1870         ast_unref(idx);
1871         ast_delete(typevar);
1872         parseerror(parser, "expected closing paren");
1873         return NULL;
1874     }
1875
1876     if (funtype->expression.varparam &&
1877         !ast_compare_type((ast_expression*)typevar, (ast_expression*)funtype->expression.varparam))
1878     {
1879         char ty1[1024];
1880         char ty2[1024];
1881         ast_type_to_string((ast_expression*)typevar, ty1, sizeof(ty1));
1882         ast_type_to_string((ast_expression*)funtype->expression.varparam, ty2, sizeof(ty2));
1883         compile_error(ast_ctx(typevar),
1884                       "function was declared to take varargs of type `%s`, requested type is: %s",
1885                       ty2, ty1);
1886     }
1887
1888     out = (ast_expression*)ast_array_index_new(ctx, (ast_expression*)(parser->function->varargs), idx);
1889     ast_type_adopt(out, typevar);
1890     ast_delete(typevar);
1891     return out;
1892 }
1893
1894 static ast_expression* parse_vararg(parser_t *parser)
1895 {
1896     bool           old_noops = parser->lex->flags.noops;
1897
1898     ast_expression *out;
1899
1900     parser->lex->flags.noops = true;
1901     out = parse_vararg_do(parser);
1902
1903     parser->lex->flags.noops = old_noops;
1904     return out;
1905 }
1906
1907 /* not to be exposed */
1908 extern bool ftepp_predef_exists(const char *name);
1909
1910 static bool parse_sya_operand(parser_t *parser, shunt *sy, bool with_labels)
1911 {
1912     if (OPTS_FLAG(TRANSLATABLE_STRINGS) &&
1913         parser->tok == TOKEN_IDENT &&
1914         !strcmp(parser_tokval(parser), "_"))
1915     {
1916         /* a translatable string */
1917         ast_value *val;
1918
1919         parser->lex->flags.noops = true;
1920         if (!parser_next(parser) || parser->tok != '(') {
1921             parseerror(parser, "use _(\"string\") to create a translatable string constant");
1922             return false;
1923         }
1924         parser->lex->flags.noops = false;
1925         if (!parser_next(parser) || parser->tok != TOKEN_STRINGCONST) {
1926             parseerror(parser, "expected a constant string in translatable-string extension");
1927             return false;
1928         }
1929         val = parser_const_string(parser, parser_tokval(parser), true);
1930         if (!val)
1931             return false;
1932         vec_push(sy->out, syexp(parser_ctx(parser), (ast_expression*)val));
1933
1934         if (!parser_next(parser) || parser->tok != ')') {
1935             parseerror(parser, "expected closing paren after translatable string");
1936             return false;
1937         }
1938         return true;
1939     }
1940     else if (parser->tok == TOKEN_DOTS)
1941     {
1942         ast_expression *va;
1943         if (!OPTS_FLAG(VARIADIC_ARGS)) {
1944             parseerror(parser, "cannot access varargs (try -fvariadic-args)");
1945             return false;
1946         }
1947         va = parse_vararg(parser);
1948         if (!va)
1949             return false;
1950         vec_push(sy->out, syexp(parser_ctx(parser), va));
1951         return true;
1952     }
1953     else if (parser->tok == TOKEN_FLOATCONST) {
1954         ast_value *val;
1955         val = parser_const_float(parser, (parser_token(parser)->constval.f));
1956         if (!val)
1957             return false;
1958         vec_push(sy->out, syexp(parser_ctx(parser), (ast_expression*)val));
1959         return true;
1960     }
1961     else if (parser->tok == TOKEN_INTCONST || parser->tok == TOKEN_CHARCONST) {
1962         ast_value *val;
1963         val = parser_const_float(parser, (double)(parser_token(parser)->constval.i));
1964         if (!val)
1965             return false;
1966         vec_push(sy->out, syexp(parser_ctx(parser), (ast_expression*)val));
1967         return true;
1968     }
1969     else if (parser->tok == TOKEN_STRINGCONST) {
1970         ast_value *val;
1971         val = parser_const_string(parser, parser_tokval(parser), false);
1972         if (!val)
1973             return false;
1974         vec_push(sy->out, syexp(parser_ctx(parser), (ast_expression*)val));
1975         return true;
1976     }
1977     else if (parser->tok == TOKEN_VECTORCONST) {
1978         ast_value *val;
1979         val = parser_const_vector(parser, parser_token(parser)->constval.v);
1980         if (!val)
1981             return false;
1982         vec_push(sy->out, syexp(parser_ctx(parser), (ast_expression*)val));
1983         return true;
1984     }
1985     else if (parser->tok == TOKEN_IDENT)
1986     {
1987         const char     *ctoken = parser_tokval(parser);
1988         ast_expression *prev = vec_size(sy->out) ? vec_last(sy->out).out : NULL;
1989         ast_expression *var;
1990         /* a_vector.{x,y,z} */
1991         if (!vec_size(sy->ops) ||
1992             !vec_last(sy->ops).etype ||
1993             operators[vec_last(sy->ops).etype-1].id != opid1('.') ||
1994             (prev >= intrinsic_debug_typestring &&
1995              prev <= intrinsic_debug_typestring))
1996         {
1997             /* When adding more intrinsics, fix the above condition */
1998             prev = NULL;
1999         }
2000         if (prev && prev->vtype == TYPE_VECTOR && ctoken[0] >= 'x' && ctoken[0] <= 'z' && !ctoken[1])
2001         {
2002             var = (ast_expression*)parser->const_vec[ctoken[0]-'x'];
2003         } else {
2004             var = parser_find_var(parser, parser_tokval(parser));
2005             if (!var)
2006                 var = parser_find_field(parser, parser_tokval(parser));
2007         }
2008         if (!var && with_labels) {
2009             var = (ast_expression*)parser_find_label(parser, parser_tokval(parser));
2010             if (!with_labels) {
2011                 ast_label *lbl = ast_label_new(parser_ctx(parser), parser_tokval(parser), true);
2012                 var = (ast_expression*)lbl;
2013                 vec_push(parser->labels, lbl);
2014             }
2015         }
2016         if (!var && !strcmp(parser_tokval(parser), "__FUNC__"))
2017             var = (ast_expression*)parser_const_string(parser, parser->function->name, false);
2018         if (!var) {
2019             /* intrinsics */
2020             if (!strcmp(parser_tokval(parser), "__builtin_debug_typestring")) {
2021                 var = (ast_expression*)intrinsic_debug_typestring;
2022             }
2023             /* now we try for the real intrinsic hashtable. If the string
2024              * begins with __builtin, we simply skip past it, otherwise we
2025              * use the identifier as is.
2026              */
2027             else if (!strncmp(parser_tokval(parser), "__builtin_", 10)) {
2028                 var = intrin_func(parser, parser_tokval(parser) + 10 /* skip __builtin */);
2029             }
2030
2031             if (!var) {
2032                 char *correct = NULL;
2033                 size_t i;
2034
2035                 /*
2036                  * sometimes people use preprocessing predefs without enabling them
2037                  * i've done this thousands of times already myself.  Lets check for
2038                  * it in the predef table.  And diagnose it better :)
2039                  */
2040                 if (!OPTS_FLAG(FTEPP_PREDEFS) && ftepp_predef_exists(parser_tokval(parser))) {
2041                     parseerror(parser, "unexpected identifier: %s (use -fftepp-predef to enable pre-defined macros)", parser_tokval(parser));
2042                     return false;
2043                 }
2044
2045                 /*
2046                  * TODO: determine the best score for the identifier: be it
2047                  * a variable, a field.
2048                  *
2049                  * We should also consider adding correction tables for
2050                  * other things as well.
2051                  */
2052                 if (OPTS_OPTION_BOOL(OPTION_CORRECTION) && strlen(parser_tokval(parser)) <= 16) {
2053                     correction_t corr;
2054                     correct_init(&corr);
2055
2056                     for (i = 0; i < vec_size(parser->correct_variables); i++) {
2057                         correct = correct_str(&corr, parser->correct_variables[i], parser_tokval(parser));
2058                         if (strcmp(correct, parser_tokval(parser))) {
2059                             break;
2060                         } else if (correct) {
2061                             mem_d(correct);
2062                             correct = NULL;
2063                         }
2064                     }
2065                     correct_free(&corr);
2066
2067                     if (correct) {
2068                         parseerror(parser, "unexpected identifier: %s (did you mean %s?)", parser_tokval(parser), correct);
2069                         mem_d(correct);
2070                         return false;
2071                     }
2072                 }
2073                 parseerror(parser, "unexpected identifier: %s", parser_tokval(parser));
2074                 return false;
2075             }
2076         }
2077         else
2078         {
2079             if (ast_istype(var, ast_value)) {
2080                 ((ast_value*)var)->uses++;
2081             }
2082             else if (ast_istype(var, ast_member)) {
2083                 ast_member *mem = (ast_member*)var;
2084                 if (ast_istype(mem->owner, ast_value))
2085                     ((ast_value*)(mem->owner))->uses++;
2086             }
2087         }
2088         vec_push(sy->out, syexp(parser_ctx(parser), var));
2089         return true;
2090     }
2091     parseerror(parser, "unexpected token `%s`", parser_tokval(parser));
2092     return false;
2093 }
2094
2095 static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma, bool truthvalue, bool with_labels)
2096 {
2097     ast_expression *expr = NULL;
2098     shunt sy;
2099     size_t i;
2100     bool wantop = false;
2101     /* only warn once about an assignment in a truth value because the current code
2102      * would trigger twice on: if(a = b && ...), once for the if-truth-value, once for the && part
2103      */
2104     bool warn_truthvalue = true;
2105
2106     /* count the parens because an if starts with one, so the
2107      * end of a condition is an unmatched closing paren
2108      */
2109     int ternaries = 0;
2110
2111     memset(&sy, 0, sizeof(sy));
2112
2113     parser->lex->flags.noops = false;
2114
2115     parser_reclassify_token(parser);
2116
2117     while (true)
2118     {
2119         if (parser->tok == TOKEN_TYPENAME) {
2120             parseerror(parser, "unexpected typename `%s`", parser_tokval(parser));
2121             goto onerr;
2122         }
2123
2124         if (parser->tok == TOKEN_OPERATOR)
2125         {
2126             /* classify the operator */
2127             const oper_info *op;
2128             const oper_info *olast = NULL;
2129             size_t o;
2130             for (o = 0; o < operator_count; ++o) {
2131                 if (((!(operators[o].flags & OP_PREFIX) == !!wantop)) &&
2132                     /* !(operators[o].flags & OP_SUFFIX) && / * remove this */
2133                     !strcmp(parser_tokval(parser), operators[o].op))
2134                 {
2135                     break;
2136                 }
2137             }
2138             if (o == operator_count) {
2139                 compile_error(parser_ctx(parser), "unknown operator: %s", parser_tokval(parser));
2140                 goto onerr;
2141             }
2142             /* found an operator */
2143             op = &operators[o];
2144
2145             /* when declaring variables, a comma starts a new variable */
2146             if (op->id == opid1(',') && !vec_size(sy.paren) && stopatcomma) {
2147                 /* fixup the token */
2148                 parser->tok = ',';
2149                 break;
2150             }
2151
2152             /* a colon without a pervious question mark cannot be a ternary */
2153             if (!ternaries && op->id == opid2(':','?')) {
2154                 parser->tok = ':';
2155                 break;
2156             }
2157
2158             if (op->id == opid1(',')) {
2159                 if (vec_size(sy.paren) && vec_last(sy.paren) == PAREN_TERNARY2) {
2160                     (void)!parsewarning(parser, WARN_TERNARY_PRECEDENCE, "suggesting parenthesis around ternary expression");
2161                 }
2162             }
2163
2164             if (vec_size(sy.ops) && !vec_last(sy.ops).isparen)
2165                 olast = &operators[vec_last(sy.ops).etype-1];
2166
2167 #define IsAssignOp(x) (\
2168                 (x) == opid1('=') || \
2169                 (x) == opid2('+','=') || \
2170                 (x) == opid2('-','=') || \
2171                 (x) == opid2('*','=') || \
2172                 (x) == opid2('/','=') || \
2173                 (x) == opid2('%','=') || \
2174                 (x) == opid2('&','=') || \
2175                 (x) == opid2('|','=') || \
2176                 (x) == opid3('&','~','=') \
2177                 )
2178             if (warn_truthvalue) {
2179                 if ( (olast && IsAssignOp(olast->id) && (op->id == opid2('&','&') || op->id == opid2('|','|'))) ||
2180                      (olast && IsAssignOp(op->id) && (olast->id == opid2('&','&') || olast->id == opid2('|','|'))) ||
2181                      (truthvalue && !vec_size(sy.paren) && IsAssignOp(op->id))
2182                    )
2183                 {
2184                     (void)!parsewarning(parser, WARN_PARENTHESIS, "suggesting parenthesis around assignment used as truth value");
2185                     warn_truthvalue = false;
2186                 }
2187             }
2188
2189             while (olast && (
2190                     (op->prec < olast->prec) ||
2191                     (op->assoc == ASSOC_LEFT && op->prec <= olast->prec) ) )
2192             {
2193                 if (!parser_sy_apply_operator(parser, &sy))
2194                     goto onerr;
2195                 if (vec_size(sy.ops) && !vec_last(sy.ops).isparen)
2196                     olast = &operators[vec_last(sy.ops).etype-1];
2197                 else
2198                     olast = NULL;
2199             }
2200
2201             if (op->id == opid1('(')) {
2202                 if (wantop) {
2203                     size_t sycount = vec_size(sy.out);
2204                     /* we expected an operator, this is the function-call operator */
2205                     vec_push(sy.paren, PAREN_FUNC);
2206                     vec_push(sy.ops, syparen(parser_ctx(parser), sycount-1));
2207                     vec_push(sy.argc, 0);
2208                 } else {
2209                     vec_push(sy.paren, PAREN_EXPR);
2210                     vec_push(sy.ops, syparen(parser_ctx(parser), 0));
2211                 }
2212                 wantop = false;
2213             } else if (op->id == opid1('[')) {
2214                 if (!wantop) {
2215                     parseerror(parser, "unexpected array subscript");
2216                     goto onerr;
2217                 }
2218                 vec_push(sy.paren, PAREN_INDEX);
2219                 /* push both the operator and the paren, this makes life easier */
2220                 vec_push(sy.ops, syop(parser_ctx(parser), op));
2221                 vec_push(sy.ops, syparen(parser_ctx(parser), 0));
2222                 wantop = false;
2223             } else if (op->id == opid2('?',':')) {
2224                 vec_push(sy.ops, syop(parser_ctx(parser), op));
2225                 vec_push(sy.ops, syparen(parser_ctx(parser), 0));
2226                 wantop = false;
2227                 ++ternaries;
2228                 vec_push(sy.paren, PAREN_TERNARY1);
2229             } else if (op->id == opid2(':','?')) {
2230                 if (!vec_size(sy.paren)) {
2231                     parseerror(parser, "unexpected colon outside ternary expression (missing parenthesis?)");
2232                     goto onerr;
2233                 }
2234                 if (vec_last(sy.paren) != PAREN_TERNARY1) {
2235                     parseerror(parser, "unexpected colon outside ternary expression (missing parenthesis?)");
2236                     goto onerr;
2237                 }
2238                 if (!parser_close_paren(parser, &sy))
2239                     goto onerr;
2240                 vec_push(sy.ops, syop(parser_ctx(parser), op));
2241                 wantop = false;
2242                 --ternaries;
2243             } else {
2244                 vec_push(sy.ops, syop(parser_ctx(parser), op));
2245                 wantop = !!(op->flags & OP_SUFFIX);
2246             }
2247         }
2248         else if (parser->tok == ')') {
2249             while (vec_size(sy.paren) && vec_last(sy.paren) == PAREN_TERNARY2) {
2250                 if (!parser_sy_apply_operator(parser, &sy))
2251                     goto onerr;
2252             }
2253             if (!vec_size(sy.paren))
2254                 break;
2255             if (wantop) {
2256                 if (vec_last(sy.paren) == PAREN_TERNARY1) {
2257                     parseerror(parser, "mismatched parentheses (closing paren in ternary expression?)");
2258                     goto onerr;
2259                 }
2260                 if (!parser_close_paren(parser, &sy))
2261                     goto onerr;
2262             } else {
2263                 /* must be a function call without parameters */
2264                 if (vec_last(sy.paren) != PAREN_FUNC) {
2265                     parseerror(parser, "closing paren in invalid position");
2266                     goto onerr;
2267                 }
2268                 if (!parser_close_paren(parser, &sy))
2269                     goto onerr;
2270             }
2271             wantop = true;
2272         }
2273         else if (parser->tok == '(') {
2274             parseerror(parser, "internal error: '(' should be classified as operator");
2275             goto onerr;
2276         }
2277         else if (parser->tok == '[') {
2278             parseerror(parser, "internal error: '[' should be classified as operator");
2279             goto onerr;
2280         }
2281         else if (parser->tok == ']') {
2282             while (vec_size(sy.paren) && vec_last(sy.paren) == PAREN_TERNARY2) {
2283                 if (!parser_sy_apply_operator(parser, &sy))
2284                     goto onerr;
2285             }
2286             if (!vec_size(sy.paren))
2287                 break;
2288             if (vec_last(sy.paren) != PAREN_INDEX) {
2289                 parseerror(parser, "mismatched parentheses, unexpected ']'");
2290                 goto onerr;
2291             }
2292             if (!parser_close_paren(parser, &sy))
2293                 goto onerr;
2294             wantop = true;
2295         }
2296         else if (!wantop) {
2297             if (!parse_sya_operand(parser, &sy, with_labels))
2298                 goto onerr;
2299 #if 0
2300             if (vec_size(sy.paren) && vec_last(sy.ops).isparen && vec_last(sy.paren) == PAREN_FUNC)
2301                 vec_last(sy.argc)++;
2302 #endif
2303             wantop = true;
2304         }
2305         else {
2306             /* in this case we might want to allow constant string concatenation */
2307             bool concatenated = false;
2308             if (parser->tok == TOKEN_STRINGCONST && vec_size(sy.out)) {
2309                 ast_expression *lexpr = vec_last(sy.out).out;
2310                 if (ast_istype(lexpr, ast_value)) {
2311                     ast_value *last = (ast_value*)lexpr;
2312                     if (last->isimm == true && last->cvq == CV_CONST &&
2313                         last->hasvalue && last->expression.vtype == TYPE_STRING)
2314                     {
2315                         char *newstr = NULL;
2316                         util_asprintf(&newstr, "%s%s", last->constval.vstring, parser_tokval(parser));
2317                         vec_last(sy.out).out = (ast_expression*)parser_const_string(parser, newstr, false);
2318                         mem_d(newstr);
2319                         concatenated = true;
2320                     }
2321                 }
2322             }
2323             if (!concatenated) {
2324                 parseerror(parser, "expected operator or end of statement");
2325                 goto onerr;
2326             }
2327         }
2328
2329         if (!parser_next(parser)) {
2330             goto onerr;
2331         }
2332         if (parser->tok == ';' ||
2333             ((!vec_size(sy.paren) || (vec_size(sy.paren) == 1 && vec_last(sy.paren) == PAREN_TERNARY2)) &&
2334             (parser->tok == ']' || parser->tok == ')' || parser->tok == '}')))
2335         {
2336             break;
2337         }
2338     }
2339
2340     while (vec_size(sy.ops)) {
2341         if (!parser_sy_apply_operator(parser, &sy))
2342             goto onerr;
2343     }
2344
2345     parser->lex->flags.noops = true;
2346     if (vec_size(sy.out) != 1) {
2347         parseerror(parser, "expression with not 1 but %lu output values...", (unsigned long) vec_size(sy.out));
2348         expr = NULL;
2349     } else
2350         expr = sy.out[0].out;
2351     vec_free(sy.out);
2352     vec_free(sy.ops);
2353     if (vec_size(sy.paren)) {
2354         parseerror(parser, "internal error: vec_size(sy.paren) = %lu", (unsigned long)vec_size(sy.paren));
2355         return NULL;
2356     }
2357     vec_free(sy.paren);
2358     vec_free(sy.argc);
2359     return expr;
2360
2361 onerr:
2362     parser->lex->flags.noops = true;
2363     for (i = 0; i < vec_size(sy.out); ++i) {
2364         if (sy.out[i].out)
2365             ast_unref(sy.out[i].out);
2366     }
2367     vec_free(sy.out);
2368     vec_free(sy.ops);
2369     vec_free(sy.paren);
2370     vec_free(sy.argc);
2371     return NULL;
2372 }
2373
2374 static ast_expression* parse_expression(parser_t *parser, bool stopatcomma, bool with_labels)
2375 {
2376     ast_expression *e = parse_expression_leave(parser, stopatcomma, false, with_labels);
2377     if (!e)
2378         return NULL;
2379     if (parser->tok != ';') {
2380         parseerror(parser, "semicolon expected after expression");
2381         ast_unref(e);
2382         return NULL;
2383     }
2384     if (!parser_next(parser)) {
2385         ast_unref(e);
2386         return NULL;
2387     }
2388     return e;
2389 }
2390
2391 static void parser_enterblock(parser_t *parser)
2392 {
2393     vec_push(parser->variables, util_htnew(PARSER_HT_SIZE));
2394     vec_push(parser->_blocklocals, vec_size(parser->_locals));
2395     vec_push(parser->typedefs, util_htnew(TYPEDEF_HT_SIZE));
2396     vec_push(parser->_blocktypedefs, vec_size(parser->_typedefs));
2397     vec_push(parser->_block_ctx, parser_ctx(parser));
2398
2399     /* corrector */
2400     vec_push(parser->correct_variables, correct_trie_new());
2401     vec_push(parser->correct_variables_score, NULL);
2402 }
2403
2404 static bool parser_leaveblock(parser_t *parser)
2405 {
2406     bool   rv = true;
2407     size_t locals, typedefs;
2408
2409     if (vec_size(parser->variables) <= PARSER_HT_LOCALS) {
2410         parseerror(parser, "internal error: parser_leaveblock with no block");
2411         return false;
2412     }
2413
2414     util_htdel(vec_last(parser->variables));
2415     correct_del(vec_last(parser->correct_variables), vec_last(parser->correct_variables_score));
2416
2417     vec_pop(parser->variables);
2418     vec_pop(parser->correct_variables);
2419     vec_pop(parser->correct_variables_score);
2420     if (!vec_size(parser->_blocklocals)) {
2421         parseerror(parser, "internal error: parser_leaveblock with no block (2)");
2422         return false;
2423     }
2424
2425     locals = vec_last(parser->_blocklocals);
2426     vec_pop(parser->_blocklocals);
2427     while (vec_size(parser->_locals) != locals) {
2428         ast_expression *e = vec_last(parser->_locals);
2429         ast_value      *v = (ast_value*)e;
2430         vec_pop(parser->_locals);
2431         if (ast_istype(e, ast_value) && !v->uses) {
2432             if (compile_warning(ast_ctx(v), WARN_UNUSED_VARIABLE, "unused variable: `%s`", v->name))
2433                 rv = false;
2434         }
2435     }
2436
2437     typedefs = vec_last(parser->_blocktypedefs);
2438     while (vec_size(parser->_typedefs) != typedefs) {
2439         ast_delete(vec_last(parser->_typedefs));
2440         vec_pop(parser->_typedefs);
2441     }
2442     util_htdel(vec_last(parser->typedefs));
2443     vec_pop(parser->typedefs);
2444
2445     vec_pop(parser->_block_ctx);
2446
2447     return rv;
2448 }
2449
2450 static void parser_addlocal(parser_t *parser, const char *name, ast_expression *e)
2451 {
2452     vec_push(parser->_locals, e);
2453     util_htset(vec_last(parser->variables), name, (void*)e);
2454
2455     /* corrector */
2456     correct_add (
2457          vec_last(parser->correct_variables),
2458         &vec_last(parser->correct_variables_score),
2459         name
2460     );
2461 }
2462
2463 static void parser_addglobal(parser_t *parser, const char *name, ast_expression *e)
2464 {
2465     vec_push(parser->globals, e);
2466     util_htset(parser->htglobals, name, e);
2467
2468     /* corrector */
2469     correct_add (
2470          parser->correct_variables[0],
2471         &parser->correct_variables_score[0],
2472         name
2473     );
2474 }
2475
2476 static ast_expression* process_condition(parser_t *parser, ast_expression *cond, bool *_ifnot)
2477 {
2478     bool       ifnot = false;
2479     ast_unary *unary;
2480     ast_expression *prev;
2481
2482     if (cond->vtype == TYPE_VOID || cond->vtype >= TYPE_VARIANT) {
2483         char ty[1024];
2484         ast_type_to_string(cond, ty, sizeof(ty));
2485         compile_error(ast_ctx(cond), "invalid type for if() condition: %s", ty);
2486     }
2487
2488     if (OPTS_FLAG(FALSE_EMPTY_STRINGS) && cond->vtype == TYPE_STRING)
2489     {
2490         prev = cond;
2491         cond = (ast_expression*)ast_unary_new(ast_ctx(cond), INSTR_NOT_S, cond);
2492         if (!cond) {
2493             ast_unref(prev);
2494             parseerror(parser, "internal error: failed to process condition");
2495             return NULL;
2496         }
2497         ifnot = !ifnot;
2498     }
2499     else if (OPTS_FLAG(CORRECT_LOGIC) && cond->vtype == TYPE_VECTOR)
2500     {
2501         /* vector types need to be cast to true booleans */
2502         ast_binary *bin = (ast_binary*)cond;
2503         if (!OPTS_FLAG(PERL_LOGIC) || !ast_istype(cond, ast_binary) || !(bin->op == INSTR_AND || bin->op == INSTR_OR))
2504         {
2505             /* in perl-logic, AND and OR take care of the -fcorrect-logic */
2506             prev = cond;
2507             cond = (ast_expression*)ast_unary_new(ast_ctx(cond), INSTR_NOT_V, cond);
2508             if (!cond) {
2509                 ast_unref(prev);
2510                 parseerror(parser, "internal error: failed to process condition");
2511                 return NULL;
2512             }
2513             ifnot = !ifnot;
2514         }
2515     }
2516
2517     unary = (ast_unary*)cond;
2518     while (ast_istype(cond, ast_unary) && unary->op == INSTR_NOT_F)
2519     {
2520         cond = unary->operand;
2521         unary->operand = NULL;
2522         ast_delete(unary);
2523         ifnot = !ifnot;
2524         unary = (ast_unary*)cond;
2525     }
2526
2527     if (!cond)
2528         parseerror(parser, "internal error: failed to process condition");
2529
2530     if (ifnot) *_ifnot = !*_ifnot;
2531     return cond;
2532 }
2533
2534 static bool parse_if(parser_t *parser, ast_block *block, ast_expression **out)
2535 {
2536     ast_ifthen *ifthen;
2537     ast_expression *cond, *ontrue = NULL, *onfalse = NULL;
2538     bool ifnot = false;
2539
2540     lex_ctx ctx = parser_ctx(parser);
2541
2542     (void)block; /* not touching */
2543
2544     /* skip the 'if', parse an optional 'not' and check for an opening paren */
2545     if (!parser_next(parser)) {
2546         parseerror(parser, "expected condition or 'not'");
2547         return false;
2548     }
2549     if (parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "not")) {
2550         ifnot = true;
2551         if (!parser_next(parser)) {
2552             parseerror(parser, "expected condition in parenthesis");
2553             return false;
2554         }
2555     }
2556     if (parser->tok != '(') {
2557         parseerror(parser, "expected 'if' condition in parenthesis");
2558         return false;
2559     }
2560     /* parse into the expression */
2561     if (!parser_next(parser)) {
2562         parseerror(parser, "expected 'if' condition after opening paren");
2563         return false;
2564     }
2565     /* parse the condition */
2566     cond = parse_expression_leave(parser, false, true, false);
2567     if (!cond)
2568         return false;
2569     /* closing paren */
2570     if (parser->tok != ')') {
2571         parseerror(parser, "expected closing paren after 'if' condition");
2572         ast_unref(cond);
2573         return false;
2574     }
2575     /* parse into the 'then' branch */
2576     if (!parser_next(parser)) {
2577         parseerror(parser, "expected statement for on-true branch of 'if'");
2578         ast_unref(cond);
2579         return false;
2580     }
2581     if (!parse_statement_or_block(parser, &ontrue)) {
2582         ast_unref(cond);
2583         return false;
2584     }
2585     if (!ontrue)
2586         ontrue = (ast_expression*)ast_block_new(parser_ctx(parser));
2587     /* check for an else */
2588     if (!strcmp(parser_tokval(parser), "else")) {
2589         /* parse into the 'else' branch */
2590         if (!parser_next(parser)) {
2591             parseerror(parser, "expected on-false branch after 'else'");
2592             ast_delete(ontrue);
2593             ast_unref(cond);
2594             return false;
2595         }
2596         if (!parse_statement_or_block(parser, &onfalse)) {
2597             ast_delete(ontrue);
2598             ast_unref(cond);
2599             return false;
2600         }
2601     }
2602
2603     cond = process_condition(parser, cond, &ifnot);
2604     if (!cond) {
2605         if (ontrue)  ast_delete(ontrue);
2606         if (onfalse) ast_delete(onfalse);
2607         return false;
2608     }
2609
2610     if (ifnot)
2611         ifthen = ast_ifthen_new(ctx, cond, onfalse, ontrue);
2612     else
2613         ifthen = ast_ifthen_new(ctx, cond, ontrue, onfalse);
2614     *out = (ast_expression*)ifthen;
2615     return true;
2616 }
2617
2618 static bool parse_while_go(parser_t *parser, ast_block *block, ast_expression **out);
2619 static bool parse_while(parser_t *parser, ast_block *block, ast_expression **out)
2620 {
2621     bool rv;
2622     char *label = NULL;
2623
2624     /* skip the 'while' and get the body */
2625     if (!parser_next(parser)) {
2626         if (OPTS_FLAG(LOOP_LABELS))
2627             parseerror(parser, "expected loop label or 'while' condition in parenthesis");
2628         else
2629             parseerror(parser, "expected 'while' condition in parenthesis");
2630         return false;
2631     }
2632
2633     if (parser->tok == ':') {
2634         if (!OPTS_FLAG(LOOP_LABELS))
2635             parseerror(parser, "labeled loops not activated, try using -floop-labels");
2636         if (!parser_next(parser) || parser->tok != TOKEN_IDENT) {
2637             parseerror(parser, "expected loop label");
2638             return false;
2639         }
2640         label = util_strdup(parser_tokval(parser));
2641         if (!parser_next(parser)) {
2642             mem_d(label);
2643             parseerror(parser, "expected 'while' condition in parenthesis");
2644             return false;
2645         }
2646     }
2647
2648     if (parser->tok != '(') {
2649         parseerror(parser, "expected 'while' condition in parenthesis");
2650         return false;
2651     }
2652
2653     vec_push(parser->breaks, label);
2654     vec_push(parser->continues, label);
2655
2656     rv = parse_while_go(parser, block, out);
2657     if (label)
2658         mem_d(label);
2659     if (vec_last(parser->breaks) != label || vec_last(parser->continues) != label) {
2660         parseerror(parser, "internal error: label stack corrupted");
2661         rv = false;
2662         ast_delete(*out);
2663         *out = NULL;
2664     }
2665     else {
2666         vec_pop(parser->breaks);
2667         vec_pop(parser->continues);
2668     }
2669     return rv;
2670 }
2671
2672 static bool parse_while_go(parser_t *parser, ast_block *block, ast_expression **out)
2673 {
2674     ast_loop *aloop;
2675     ast_expression *cond, *ontrue;
2676
2677     bool ifnot = false;
2678
2679     lex_ctx ctx = parser_ctx(parser);
2680
2681     (void)block; /* not touching */
2682
2683     /* parse into the expression */
2684     if (!parser_next(parser)) {
2685         parseerror(parser, "expected 'while' condition after opening paren");
2686         return false;
2687     }
2688     /* parse the condition */
2689     cond = parse_expression_leave(parser, false, true, false);
2690     if (!cond)
2691         return false;
2692     /* closing paren */
2693     if (parser->tok != ')') {
2694         parseerror(parser, "expected closing paren after 'while' condition");
2695         ast_unref(cond);
2696         return false;
2697     }
2698     /* parse into the 'then' branch */
2699     if (!parser_next(parser)) {
2700         parseerror(parser, "expected while-loop body");
2701         ast_unref(cond);
2702         return false;
2703     }
2704     if (!parse_statement_or_block(parser, &ontrue)) {
2705         ast_unref(cond);
2706         return false;
2707     }
2708
2709     cond = process_condition(parser, cond, &ifnot);
2710     if (!cond) {
2711         ast_unref(ontrue);
2712         return false;
2713     }
2714     aloop = ast_loop_new(ctx, NULL, cond, ifnot, NULL, false, NULL, ontrue);
2715     *out = (ast_expression*)aloop;
2716     return true;
2717 }
2718
2719 static bool parse_dowhile_go(parser_t *parser, ast_block *block, ast_expression **out);
2720 static bool parse_dowhile(parser_t *parser, ast_block *block, ast_expression **out)
2721 {
2722     bool rv;
2723     char *label = NULL;
2724
2725     /* skip the 'do' and get the body */
2726     if (!parser_next(parser)) {
2727         if (OPTS_FLAG(LOOP_LABELS))
2728             parseerror(parser, "expected loop label or body");
2729         else
2730             parseerror(parser, "expected loop body");
2731         return false;
2732     }
2733
2734     if (parser->tok == ':') {
2735         if (!OPTS_FLAG(LOOP_LABELS))
2736             parseerror(parser, "labeled loops not activated, try using -floop-labels");
2737         if (!parser_next(parser) || parser->tok != TOKEN_IDENT) {
2738             parseerror(parser, "expected loop label");
2739             return false;
2740         }
2741         label = util_strdup(parser_tokval(parser));
2742         if (!parser_next(parser)) {
2743             mem_d(label);
2744             parseerror(parser, "expected loop body");
2745             return false;
2746         }
2747     }
2748
2749     vec_push(parser->breaks, label);
2750     vec_push(parser->continues, label);
2751
2752     rv = parse_dowhile_go(parser, block, out);
2753     if (label)
2754         mem_d(label);
2755     if (vec_last(parser->breaks) != label || vec_last(parser->continues) != label) {
2756         parseerror(parser, "internal error: label stack corrupted");
2757         rv = false;
2758         ast_delete(*out);
2759         *out = NULL;
2760     }
2761     else {
2762         vec_pop(parser->breaks);
2763         vec_pop(parser->continues);
2764     }
2765     return rv;
2766 }
2767
2768 static bool parse_dowhile_go(parser_t *parser, ast_block *block, ast_expression **out)
2769 {
2770     ast_loop *aloop;
2771     ast_expression *cond, *ontrue;
2772
2773     bool ifnot = false;
2774
2775     lex_ctx ctx = parser_ctx(parser);
2776
2777     (void)block; /* not touching */
2778
2779     if (!parse_statement_or_block(parser, &ontrue))
2780         return false;
2781
2782     /* expect the "while" */
2783     if (parser->tok != TOKEN_KEYWORD ||
2784         strcmp(parser_tokval(parser), "while"))
2785     {
2786         parseerror(parser, "expected 'while' and condition");
2787         ast_delete(ontrue);
2788         return false;
2789     }
2790
2791     /* skip the 'while' and check for opening paren */
2792     if (!parser_next(parser) || parser->tok != '(') {
2793         parseerror(parser, "expected 'while' condition in parenthesis");
2794         ast_delete(ontrue);
2795         return false;
2796     }
2797     /* parse into the expression */
2798     if (!parser_next(parser)) {
2799         parseerror(parser, "expected 'while' condition after opening paren");
2800         ast_delete(ontrue);
2801         return false;
2802     }
2803     /* parse the condition */
2804     cond = parse_expression_leave(parser, false, true, false);
2805     if (!cond)
2806         return false;
2807     /* closing paren */
2808     if (parser->tok != ')') {
2809         parseerror(parser, "expected closing paren after 'while' condition");
2810         ast_delete(ontrue);
2811         ast_unref(cond);
2812         return false;
2813     }
2814     /* parse on */
2815     if (!parser_next(parser) || parser->tok != ';') {
2816         parseerror(parser, "expected semicolon after condition");
2817         ast_delete(ontrue);
2818         ast_unref(cond);
2819         return false;
2820     }
2821
2822     if (!parser_next(parser)) {
2823         parseerror(parser, "parse error");
2824         ast_delete(ontrue);
2825         ast_unref(cond);
2826         return false;
2827     }
2828
2829     cond = process_condition(parser, cond, &ifnot);
2830     if (!cond) {
2831         ast_delete(ontrue);
2832         return false;
2833     }
2834     aloop = ast_loop_new(ctx, NULL, NULL, false, cond, ifnot, NULL, ontrue);
2835     *out = (ast_expression*)aloop;
2836     return true;
2837 }
2838
2839 static bool parse_for_go(parser_t *parser, ast_block *block, ast_expression **out);
2840 static bool parse_for(parser_t *parser, ast_block *block, ast_expression **out)
2841 {
2842     bool rv;
2843     char *label = NULL;
2844
2845     /* skip the 'for' and check for opening paren */
2846     if (!parser_next(parser)) {
2847         if (OPTS_FLAG(LOOP_LABELS))
2848             parseerror(parser, "expected loop label or 'for' expressions in parenthesis");
2849         else
2850             parseerror(parser, "expected 'for' expressions in parenthesis");
2851         return false;
2852     }
2853
2854     if (parser->tok == ':') {
2855         if (!OPTS_FLAG(LOOP_LABELS))
2856             parseerror(parser, "labeled loops not activated, try using -floop-labels");
2857         if (!parser_next(parser) || parser->tok != TOKEN_IDENT) {
2858             parseerror(parser, "expected loop label");
2859             return false;
2860         }
2861         label = util_strdup(parser_tokval(parser));
2862         if (!parser_next(parser)) {
2863             mem_d(label);
2864             parseerror(parser, "expected 'for' expressions in parenthesis");
2865             return false;
2866         }
2867     }
2868
2869     if (parser->tok != '(') {
2870         parseerror(parser, "expected 'for' expressions in parenthesis");
2871         return false;
2872     }
2873
2874     vec_push(parser->breaks, label);
2875     vec_push(parser->continues, label);
2876
2877     rv = parse_for_go(parser, block, out);
2878     if (label)
2879         mem_d(label);
2880     if (vec_last(parser->breaks) != label || vec_last(parser->continues) != label) {
2881         parseerror(parser, "internal error: label stack corrupted");
2882         rv = false;
2883         ast_delete(*out);
2884         *out = NULL;
2885     }
2886     else {
2887         vec_pop(parser->breaks);
2888         vec_pop(parser->continues);
2889     }
2890     return rv;
2891 }
2892 static bool parse_for_go(parser_t *parser, ast_block *block, ast_expression **out)
2893 {
2894     ast_loop       *aloop;
2895     ast_expression *initexpr, *cond, *increment, *ontrue;
2896     ast_value      *typevar;
2897
2898     bool ifnot  = false;
2899
2900     lex_ctx ctx = parser_ctx(parser);
2901
2902     parser_enterblock(parser);
2903
2904     initexpr  = NULL;
2905     cond      = NULL;
2906     increment = NULL;
2907     ontrue    = NULL;
2908
2909     /* parse into the expression */
2910     if (!parser_next(parser)) {
2911         parseerror(parser, "expected 'for' initializer after opening paren");
2912         goto onerr;
2913     }
2914
2915     typevar = NULL;
2916     if (parser->tok == TOKEN_IDENT)
2917         typevar = parser_find_typedef(parser, parser_tokval(parser), 0);
2918
2919     if (typevar || parser->tok == TOKEN_TYPENAME) {
2920 #if 0
2921         if (OPTS_OPTION_U32(OPTION_STANDARD) != COMPILER_GMQCC) {
2922             if (parsewarning(parser, WARN_EXTENSIONS,
2923                              "current standard does not allow variable declarations in for-loop initializers"))
2924                 goto onerr;
2925         }
2926 #endif
2927         if (!parse_variable(parser, block, true, CV_VAR, typevar, false, false, 0, NULL))
2928             goto onerr;
2929     }
2930     else if (parser->tok != ';')
2931     {
2932         initexpr = parse_expression_leave(parser, false, false, false);
2933         if (!initexpr)
2934             goto onerr;
2935     }
2936
2937     /* move on to condition */
2938     if (parser->tok != ';') {
2939         parseerror(parser, "expected semicolon after for-loop initializer");
2940         goto onerr;
2941     }
2942     if (!parser_next(parser)) {
2943         parseerror(parser, "expected for-loop condition");
2944         goto onerr;
2945     }
2946
2947     /* parse the condition */
2948     if (parser->tok != ';') {
2949         cond = parse_expression_leave(parser, false, true, false);
2950         if (!cond)
2951             goto onerr;
2952     }
2953
2954     /* move on to incrementor */
2955     if (parser->tok != ';') {
2956         parseerror(parser, "expected semicolon after for-loop initializer");
2957         goto onerr;
2958     }
2959     if (!parser_next(parser)) {
2960         parseerror(parser, "expected for-loop condition");
2961         goto onerr;
2962     }
2963
2964     /* parse the incrementor */
2965     if (parser->tok != ')') {
2966         lex_ctx condctx = parser_ctx(parser);
2967         increment = parse_expression_leave(parser, false, false, false);
2968         if (!increment)
2969             goto onerr;
2970         if (!ast_side_effects(increment)) {
2971             if (compile_warning(condctx, WARN_EFFECTLESS_STATEMENT, "statement has no effect"))
2972                 goto onerr;
2973         }
2974     }
2975
2976     /* closing paren */
2977     if (parser->tok != ')') {
2978         parseerror(parser, "expected closing paren after 'for-loop' incrementor");
2979         goto onerr;
2980     }
2981     /* parse into the 'then' branch */
2982     if (!parser_next(parser)) {
2983         parseerror(parser, "expected for-loop body");
2984         goto onerr;
2985     }
2986     if (!parse_statement_or_block(parser, &ontrue))
2987         goto onerr;
2988
2989     if (cond) {
2990         cond = process_condition(parser, cond, &ifnot);
2991         if (!cond)
2992             goto onerr;
2993     }
2994     aloop = ast_loop_new(ctx, initexpr, cond, ifnot, NULL, false, increment, ontrue);
2995     *out = (ast_expression*)aloop;
2996
2997     if (!parser_leaveblock(parser)) {
2998         ast_delete(aloop);
2999         return false;
3000     }
3001     return true;
3002 onerr:
3003     if (initexpr)  ast_unref(initexpr);
3004     if (cond)      ast_unref(cond);
3005     if (increment) ast_unref(increment);
3006     (void)!parser_leaveblock(parser);
3007     return false;
3008 }
3009
3010 static bool parse_return(parser_t *parser, ast_block *block, ast_expression **out)
3011 {
3012     ast_expression *exp      = NULL;
3013     ast_expression *var      = NULL;
3014     ast_return     *ret      = NULL;
3015     ast_value      *retval   = parser->function->return_value;
3016     ast_value      *expected = parser->function->vtype;
3017
3018     lex_ctx ctx = parser_ctx(parser);
3019
3020     (void)block; /* not touching */
3021
3022     if (!parser_next(parser)) {
3023         parseerror(parser, "expected return expression");
3024         return false;
3025     }
3026
3027     /* return assignments */
3028     if (parser->tok == '=') {
3029         if (!OPTS_FLAG(RETURN_ASSIGNMENTS)) {
3030             parseerror(parser, "return assignments not activated, try using -freturn-assigments");
3031             return false;
3032         }
3033
3034         if (type_store_instr[expected->expression.next->vtype] == VINSTR_END) {
3035             char ty1[1024];
3036             ast_type_to_string(expected->expression.next, ty1, sizeof(ty1));
3037             parseerror(parser, "invalid return type: `%s'", ty1);
3038             return false;
3039         }
3040
3041         if (!parser_next(parser)) {
3042             parseerror(parser, "expected return assignment expression");
3043             return false;
3044         }
3045
3046         if (!(exp = parse_expression_leave(parser, false, false, false)))
3047             return false;
3048
3049         /* prepare the return value */
3050         if (!retval) {
3051             retval = ast_value_new(ctx, "#LOCAL_RETURN", TYPE_VOID);
3052             ast_type_adopt(retval, expected->expression.next);
3053             parser->function->return_value = retval;
3054         }
3055
3056         if (!ast_compare_type(exp, (ast_expression*)retval)) {
3057             char ty1[1024], ty2[1024];
3058             ast_type_to_string(exp, ty1, sizeof(ty1));
3059             ast_type_to_string(&retval->expression, ty2, sizeof(ty2));
3060             parseerror(parser, "invalid type for return value: `%s', expected `%s'", ty1, ty2);
3061         }
3062
3063         /* store to 'return' local variable */
3064         var = (ast_expression*)ast_store_new(
3065             ctx,
3066             type_store_instr[expected->expression.next->vtype],
3067             (ast_expression*)retval, exp);
3068
3069         if (!var) {
3070             ast_unref(exp);
3071             return false;
3072         }
3073
3074         if (parser->tok != ';')
3075             parseerror(parser, "missing semicolon after return assignment");
3076         else if (!parser_next(parser))
3077             parseerror(parser, "parse error after return assignment");
3078
3079         *out = var;
3080         return true;
3081     }
3082
3083     if (parser->tok != ';') {
3084         exp = parse_expression(parser, false, false);
3085         if (!exp)
3086             return false;
3087
3088         if (exp->vtype != TYPE_NIL &&
3089             exp->vtype != ((ast_expression*)expected)->next->vtype)
3090         {
3091             parseerror(parser, "return with invalid expression");
3092         }
3093
3094         ret = ast_return_new(ctx, exp);
3095         if (!ret) {
3096             ast_unref(exp);
3097             return false;
3098         }
3099     } else {
3100         if (!parser_next(parser))
3101             parseerror(parser, "parse error");
3102
3103         if (!retval && expected->expression.next->vtype != TYPE_VOID)
3104         {
3105             (void)!parsewarning(parser, WARN_MISSING_RETURN_VALUES, "return without value");
3106         }
3107         ret = ast_return_new(ctx, (ast_expression*)retval);
3108     }
3109     *out = (ast_expression*)ret;
3110     return true;
3111 }
3112
3113 static bool parse_break_continue(parser_t *parser, ast_block *block, ast_expression **out, bool is_continue)
3114 {
3115     size_t       i;
3116     unsigned int levels = 0;
3117     lex_ctx      ctx = parser_ctx(parser);
3118     const char **loops = (is_continue ? parser->continues : parser->breaks);
3119
3120     (void)block; /* not touching */
3121     if (!parser_next(parser)) {
3122         parseerror(parser, "expected semicolon or loop label");
3123         return false;
3124     }
3125
3126     if (!vec_size(loops)) {
3127         if (is_continue)
3128             parseerror(parser, "`continue` can only be used inside loops");
3129         else
3130             parseerror(parser, "`break` can only be used inside loops or switches");
3131     }
3132
3133     if (parser->tok == TOKEN_IDENT) {
3134         if (!OPTS_FLAG(LOOP_LABELS))
3135             parseerror(parser, "labeled loops not activated, try using -floop-labels");
3136         i = vec_size(loops);
3137         while (i--) {
3138             if (loops[i] && !strcmp(loops[i], parser_tokval(parser)))
3139                 break;
3140             if (!i) {
3141                 parseerror(parser, "no such loop to %s: `%s`",
3142                            (is_continue ? "continue" : "break out of"),
3143                            parser_tokval(parser));
3144                 return false;
3145             }
3146             ++levels;
3147         }
3148         if (!parser_next(parser)) {
3149             parseerror(parser, "expected semicolon");
3150             return false;
3151         }
3152     }
3153
3154     if (parser->tok != ';') {
3155         parseerror(parser, "expected semicolon");
3156         return false;
3157     }
3158
3159     if (!parser_next(parser))
3160         parseerror(parser, "parse error");
3161
3162     *out = (ast_expression*)ast_breakcont_new(ctx, is_continue, levels);
3163     return true;
3164 }
3165
3166 /* returns true when it was a variable qualifier, false otherwise!
3167  * on error, cvq is set to CV_WRONG
3168  */
3169 static bool parse_qualifiers(parser_t *parser, bool with_local, int *cvq, bool *noref, bool *is_static, uint32_t *_flags, char **message)
3170 {
3171     bool had_const    = false;
3172     bool had_var      = false;
3173     bool had_noref    = false;
3174     bool had_attrib   = false;
3175     bool had_static   = false;
3176     uint32_t flags    = 0;
3177
3178     *cvq = CV_NONE;
3179     for (;;) {
3180         if (parser->tok == TOKEN_ATTRIBUTE_OPEN) {
3181             had_attrib = true;
3182             /* parse an attribute */
3183             if (!parser_next(parser)) {
3184                 parseerror(parser, "expected attribute after `[[`");
3185                 *cvq = CV_WRONG;
3186                 return false;
3187             }
3188             if (!strcmp(parser_tokval(parser), "noreturn")) {
3189                 flags |= AST_FLAG_NORETURN;
3190                 if (!parser_next(parser) || parser->tok != TOKEN_ATTRIBUTE_CLOSE) {
3191                     parseerror(parser, "`noreturn` attribute has no parameters, expected `]]`");
3192                     *cvq = CV_WRONG;
3193                     return false;
3194                 }
3195             }
3196             else if (!strcmp(parser_tokval(parser), "noref")) {
3197                 had_noref = true;
3198                 if (!parser_next(parser) || parser->tok != TOKEN_ATTRIBUTE_CLOSE) {
3199                     parseerror(parser, "`noref` attribute has no parameters, expected `]]`");
3200                     *cvq = CV_WRONG;
3201                     return false;
3202                 }
3203             }
3204             else if (!strcmp(parser_tokval(parser), "inline")) {
3205                 flags |= AST_FLAG_INLINE;
3206                 if (!parser_next(parser) || parser->tok != TOKEN_ATTRIBUTE_CLOSE) {
3207                     parseerror(parser, "`noref` attribute has no parameters, expected `]]`");
3208                     *cvq = CV_WRONG;
3209                     return false;
3210                 }
3211             }
3212             else if (!strcmp(parser_tokval(parser), "alias") && !(flags & AST_FLAG_ALIAS)) {
3213                 flags   |= AST_FLAG_ALIAS;
3214                 *message = NULL;
3215
3216                 if (!parser_next(parser)) {
3217                     parseerror(parser, "parse error in attribute");
3218                     goto argerr;
3219                 }
3220
3221                 if (parser->tok == '(') {
3222                     if (!parser_next(parser) || parser->tok != TOKEN_STRINGCONST) {
3223                         parseerror(parser, "`alias` attribute missing parameter");
3224                         goto argerr;
3225                     }
3226
3227                     *message = util_strdup(parser_tokval(parser));
3228
3229                     if (!parser_next(parser)) {
3230                         parseerror(parser, "parse error in attribute");
3231                         goto argerr;
3232                     }
3233
3234                     if (parser->tok != ')') {
3235                         parseerror(parser, "`alias` attribute expected `)` after parameter");
3236                         goto argerr;
3237                     }
3238
3239                     if (!parser_next(parser)) {
3240                         parseerror(parser, "parse error in attribute");
3241                         goto argerr;
3242                     }
3243                 }
3244
3245                 if (parser->tok != TOKEN_ATTRIBUTE_CLOSE) {
3246                     parseerror(parser, "`alias` attribute expected `]]`");
3247                     goto argerr;
3248                 }
3249             }
3250             else if (!strcmp(parser_tokval(parser), "deprecated") && !(flags & AST_FLAG_DEPRECATED)) {
3251                 flags   |= AST_FLAG_DEPRECATED;
3252                 *message = NULL;
3253
3254                 if (!parser_next(parser)) {
3255                     parseerror(parser, "parse error in attribute");
3256                     goto argerr;
3257                 }
3258
3259                 if (parser->tok == '(') {
3260                     if (!parser_next(parser) || parser->tok != TOKEN_STRINGCONST) {
3261                         parseerror(parser, "`deprecated` attribute missing parameter");
3262                         goto argerr;
3263                     }
3264
3265                     *message = util_strdup(parser_tokval(parser));
3266
3267                     if (!parser_next(parser)) {
3268                         parseerror(parser, "parse error in attribute");
3269                         goto argerr;
3270                     }
3271
3272                     if(parser->tok != ')') {
3273                         parseerror(parser, "`deprecated` attribute expected `)` after parameter");
3274                         goto argerr;
3275                     }
3276
3277                     if (!parser_next(parser)) {
3278                         parseerror(parser, "parse error in attribute");
3279                         goto argerr;
3280                     }
3281                 }
3282                 /* no message */
3283                 if (parser->tok != TOKEN_ATTRIBUTE_CLOSE) {
3284                     parseerror(parser, "`deprecated` attribute expected `]]`");
3285
3286                     argerr: /* ugly */
3287                     if (*message) mem_d(*message);
3288                     *message = NULL;
3289                     *cvq     = CV_WRONG;
3290                     return false;
3291                 }
3292             }
3293             else
3294             {
3295                 /* Skip tokens until we hit a ]] */
3296                 (void)!parsewarning(parser, WARN_UNKNOWN_ATTRIBUTE, "unknown attribute starting with `%s`", parser_tokval(parser));
3297                 while (parser->tok != TOKEN_ATTRIBUTE_CLOSE) {
3298                     if (!parser_next(parser)) {
3299                         parseerror(parser, "error inside attribute");
3300                         *cvq = CV_WRONG;
3301                         return false;
3302                     }
3303                 }
3304             }
3305         }
3306         else if (with_local && !strcmp(parser_tokval(parser), "static"))
3307             had_static = true;
3308         else if (!strcmp(parser_tokval(parser), "const"))
3309             had_const = true;
3310         else if (!strcmp(parser_tokval(parser), "var"))
3311             had_var = true;
3312         else if (with_local && !strcmp(parser_tokval(parser), "local"))
3313             had_var = true;
3314         else if (!strcmp(parser_tokval(parser), "noref"))
3315             had_noref = true;
3316         else if (!had_const && !had_var && !had_noref && !had_attrib && !had_static && !flags) {
3317             return false;
3318         }
3319         else
3320             break;
3321         if (!parser_next(parser))
3322             goto onerr;
3323     }
3324     if (had_const)
3325         *cvq = CV_CONST;
3326     else if (had_var)
3327         *cvq = CV_VAR;
3328     else
3329         *cvq = CV_NONE;
3330     *noref     = had_noref;
3331     *is_static = had_static;
3332     *_flags    = flags;
3333     return true;
3334 onerr:
3335     parseerror(parser, "parse error after variable qualifier");
3336     *cvq = CV_WRONG;
3337     return true;
3338 }
3339
3340 static bool parse_switch_go(parser_t *parser, ast_block *block, ast_expression **out);
3341 static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **out)
3342 {
3343     bool rv;
3344     char *label = NULL;
3345
3346     /* skip the 'while' and get the body */
3347     if (!parser_next(parser)) {
3348         if (OPTS_FLAG(LOOP_LABELS))
3349             parseerror(parser, "expected loop label or 'switch' operand in parenthesis");
3350         else
3351             parseerror(parser, "expected 'switch' operand in parenthesis");
3352         return false;
3353     }
3354
3355     if (parser->tok == ':') {
3356         if (!OPTS_FLAG(LOOP_LABELS))
3357             parseerror(parser, "labeled loops not activated, try using -floop-labels");
3358         if (!parser_next(parser) || parser->tok != TOKEN_IDENT) {
3359             parseerror(parser, "expected loop label");
3360             return false;
3361         }
3362         label = util_strdup(parser_tokval(parser));
3363         if (!parser_next(parser)) {
3364             mem_d(label);
3365             parseerror(parser, "expected 'switch' operand in parenthesis");
3366             return false;
3367         }
3368     }
3369
3370     if (parser->tok != '(') {
3371         parseerror(parser, "expected 'switch' operand in parenthesis");
3372         return false;
3373     }
3374
3375     vec_push(parser->breaks, label);
3376
3377     rv = parse_switch_go(parser, block, out);
3378     if (label)
3379         mem_d(label);
3380     if (vec_last(parser->breaks) != label) {
3381         parseerror(parser, "internal error: label stack corrupted");
3382         rv = false;
3383         ast_delete(*out);
3384         *out = NULL;
3385     }
3386     else {
3387         vec_pop(parser->breaks);
3388     }
3389     return rv;
3390 }
3391
3392 static bool parse_switch_go(parser_t *parser, ast_block *block, ast_expression **out)
3393 {
3394     ast_expression *operand;
3395     ast_value      *opval;
3396     ast_value      *typevar;
3397     ast_switch     *switchnode;
3398     ast_switch_case swcase;
3399
3400     int  cvq;
3401     bool noref, is_static;
3402     uint32_t qflags = 0;
3403
3404     lex_ctx ctx = parser_ctx(parser);
3405
3406     (void)block; /* not touching */
3407     (void)opval;
3408
3409     /* parse into the expression */
3410     if (!parser_next(parser)) {
3411         parseerror(parser, "expected switch operand");
3412         return false;
3413     }
3414     /* parse the operand */
3415     operand = parse_expression_leave(parser, false, false, false);
3416     if (!operand)
3417         return false;
3418
3419     switchnode = ast_switch_new(ctx, operand);
3420
3421     /* closing paren */
3422     if (parser->tok != ')') {
3423         ast_delete(switchnode);
3424         parseerror(parser, "expected closing paren after 'switch' operand");
3425         return false;
3426     }
3427
3428     /* parse over the opening paren */
3429     if (!parser_next(parser) || parser->tok != '{') {
3430         ast_delete(switchnode);
3431         parseerror(parser, "expected list of cases");
3432         return false;
3433     }
3434
3435     if (!parser_next(parser)) {
3436         ast_delete(switchnode);
3437         parseerror(parser, "expected 'case' or 'default'");