Use hashtable for macro definitions in the preprocessor, this speeds up the search...
[xonotic/gmqcc.git] / ftepp.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 <time.h>
25 #include "gmqcc.h"
26 #include "lexer.h"
27
28 #define HT_MACROS 1024
29 typedef struct {
30     bool on;
31     bool was_on;
32     bool had_else;
33 } ppcondition;
34
35 typedef struct {
36     int   token;
37     char *value;
38     /* a copy from the lexer */
39     union {
40         vector v;
41         int    i;
42         double f;
43         int    t; /* type */
44     } constval;
45 } pptoken;
46
47 typedef struct {
48     lex_ctx ctx;
49
50     char   *name;
51     char  **params;
52     /* yes we need an extra flag since `#define FOO x` is not the same as `#define FOO() x` */
53     bool    has_params;
54     bool    variadic;
55
56     pptoken **output;
57 } ppmacro;
58
59 typedef struct ftepp_s {
60     lex_file    *lex;
61     int          token;
62     unsigned int errors;
63
64     bool         output_on;
65     ppcondition *conditions;
66     /*ppmacro    **macros;*/
67     ht           macros; /* hashtable<string, ppmacro*> */
68
69     char        *output_string;
70
71     char        *itemname;
72     char        *includename;
73     bool         in_macro;
74 } ftepp_t;
75
76 /*
77  * Implement the predef subsystem now.  We can do this safely with the
78  * help of lexer contexts.
79  */  
80 static uint32_t ftepp_predef_countval = 0;
81 static uint32_t ftepp_predef_randval  = 0;
82
83 /* __DATE__ */
84 char *ftepp_predef_date(lex_file *context) {
85     struct tm *itime;
86     time_t     rtime;
87     char      *value = (char*)mem_a(82);
88     /* 82 is enough for strftime but we also have " " in our string */
89
90     (void)context;
91
92     /* get time */
93     time (&rtime);
94     itime = localtime(&rtime);
95
96     strftime(value, 82, "\"%b %d %Y\"", itime);
97
98     return value;
99 }
100
101 /* __TIME__ */
102 char *ftepp_predef_time(lex_file *context) {
103     struct tm *itime;
104     time_t     rtime;
105     char      *value = (char*)mem_a(82);
106     /* 82 is enough for strftime but we also have " " in our string */
107
108     (void)context;
109
110     /* get time */
111     time (&rtime);
112     itime = localtime(&rtime);
113
114     strftime(value, 82, "\"%X\"", itime);
115
116     return value;
117 }
118
119 /* __LINE__ */
120 char *ftepp_predef_line(lex_file *context) {
121     char   *value;
122     util_asprintf(&value, "%d", (int)context->line);
123     return value;
124 }
125 /* __FILE__ */
126 char *ftepp_predef_file(lex_file *context) {
127     size_t  length = strlen(context->name) + 3; /* two quotes and a terminator */
128     char   *value  = (char*)mem_a(length);
129     snprintf(value, length, "\"%s\"", context->name);
130
131     return value;
132 }
133 /* __COUNTER_LAST__ */
134 char *ftepp_predef_counterlast(lex_file *context) {
135     char   *value;
136     util_asprintf(&value, "%u", ftepp_predef_countval);
137
138     (void)context;
139     return value;
140 }
141 /* __COUNTER__ */
142 char *ftepp_predef_counter(lex_file *context) {
143     char   *value;
144     ftepp_predef_countval ++;
145     util_asprintf(&value, "%u", ftepp_predef_countval);
146     (void)context;
147
148     return value;
149 }
150 /* __RANDOM__ */
151 char *ftepp_predef_random(lex_file *context) {
152     char  *value;
153     ftepp_predef_randval = (util_rand() % 0xFF) + 1;
154     util_asprintf(&value, "%u", ftepp_predef_randval);
155
156     (void)context;
157     return value;
158 }
159 /* __RANDOM_LAST__ */
160 char *ftepp_predef_randomlast(lex_file *context) {
161     char   *value;
162     util_asprintf(&value, "%u", ftepp_predef_randval);
163
164     (void)context;
165     return value;
166 }
167
168 const ftepp_predef_t ftepp_predefs[FTEPP_PREDEF_COUNT] = {
169     { "__LINE__",         &ftepp_predef_line        },
170     { "__FILE__",         &ftepp_predef_file        },
171     { "__COUNTER__",      &ftepp_predef_counter     },
172     { "__COUNTER_LAST__", &ftepp_predef_counterlast },
173     { "__RANDOM__",       &ftepp_predef_random      },
174     { "__RANDOM_LAST__",  &ftepp_predef_randomlast  },
175     { "__DATE__",         &ftepp_predef_date        },
176     { "__TIME__",         &ftepp_predef_time        }
177 };
178
179 #define ftepp_tokval(f) ((f)->lex->tok.value)
180 #define ftepp_ctx(f)    ((f)->lex->tok.ctx)
181
182 static void ftepp_errorat(ftepp_t *ftepp, lex_ctx ctx, const char *fmt, ...)
183 {
184     va_list ap;
185
186     ftepp->errors++;
187
188     va_start(ap, fmt);
189     con_cvprintmsg((void*)&ctx, LVL_ERROR, "error", fmt, ap);
190     va_end(ap);
191 }
192
193 static void ftepp_error(ftepp_t *ftepp, const char *fmt, ...)
194 {
195     va_list ap;
196
197     ftepp->errors++;
198
199     va_start(ap, fmt);
200     con_cvprintmsg((void*)&ftepp->lex->tok.ctx, LVL_ERROR, "error", fmt, ap);
201     va_end(ap);
202 }
203
204 static bool GMQCC_WARN ftepp_warn(ftepp_t *ftepp, int warntype, const char *fmt, ...)
205 {
206     bool    r;
207     va_list ap;
208
209     va_start(ap, fmt);
210     r = vcompile_warning(ftepp->lex->tok.ctx, warntype, fmt, ap);
211     va_end(ap);
212     return r;
213 }
214
215 static pptoken *pptoken_make(ftepp_t *ftepp)
216 {
217     pptoken *token = (pptoken*)mem_a(sizeof(pptoken));
218     token->token = ftepp->token;
219 #if 0
220     if (token->token == TOKEN_WHITE)
221         token->value = util_strdup(" ");
222     else
223 #else
224         token->value = util_strdup(ftepp_tokval(ftepp));
225 #endif
226     memcpy(&token->constval, &ftepp->lex->tok.constval, sizeof(token->constval));
227     return token;
228 }
229
230 static void pptoken_delete(pptoken *self)
231 {
232     mem_d(self->value);
233     mem_d(self);
234 }
235
236 static ppmacro *ppmacro_new(lex_ctx ctx, const char *name)
237 {
238     ppmacro *macro = (ppmacro*)mem_a(sizeof(ppmacro));
239
240     (void)ctx;
241     memset(macro, 0, sizeof(*macro));
242     macro->name = util_strdup(name);
243     return macro;
244 }
245
246 static void ppmacro_delete(ppmacro *self)
247 {
248     size_t i;
249     for (i = 0; i < vec_size(self->params); ++i)
250         mem_d(self->params[i]);
251     vec_free(self->params);
252     for (i = 0; i < vec_size(self->output); ++i)
253         pptoken_delete(self->output[i]);
254     vec_free(self->output);
255     mem_d(self->name);
256     mem_d(self);
257 }
258
259 static ftepp_t* ftepp_new()
260 {
261     ftepp_t *ftepp;
262
263     ftepp = (ftepp_t*)mem_a(sizeof(*ftepp));
264     memset(ftepp, 0, sizeof(*ftepp));
265
266     ftepp->macros    = util_htnew(HT_MACROS);
267     ftepp->output_on = true;
268
269     return ftepp;
270 }
271
272 static void ftepp_flush_do(ftepp_t *self)
273 {
274     vec_free(self->output_string);
275 }
276
277 static void ftepp_delete(ftepp_t *self)
278 {
279     ftepp_flush_do(self);
280     if (self->itemname)
281         mem_d(self->itemname);
282     if (self->includename)
283         vec_free(self->includename);
284
285     /*
286     for (i = 0; i < vec_size(self->macros); ++i)
287         ppmacro_delete(self->macros[i]);
288
289     vec_free(self->macros);
290 */
291
292     util_htrem(self->macros, (void (*)(void*))&ppmacro_delete);
293
294     vec_free(self->conditions);
295     if (self->lex)
296         lex_close(self->lex);
297     mem_d(self);
298 }
299
300 static void ftepp_out(ftepp_t *ftepp, const char *str, bool ignore_cond)
301 {
302     if (ignore_cond || ftepp->output_on)
303     {
304         size_t len;
305         char  *data;
306         len = strlen(str);
307         data = vec_add(ftepp->output_string, len);
308         memcpy(data, str, len);
309     }
310 }
311
312 static void ftepp_update_output_condition(ftepp_t *ftepp)
313 {
314     size_t i;
315     ftepp->output_on = true;
316     for (i = 0; i < vec_size(ftepp->conditions); ++i)
317         ftepp->output_on = ftepp->output_on && ftepp->conditions[i].on;
318 }
319
320 static ppmacro* ftepp_macro_find(ftepp_t *ftepp, const char *name)
321 {
322     return util_htget(ftepp->macros, name);
323 }
324
325 static void ftepp_macro_delete(ftepp_t *ftepp, const char *name)
326 {
327     util_htrm(ftepp->macros, name, NULL);
328 }
329
330 static GMQCC_INLINE int ftepp_next(ftepp_t *ftepp)
331 {
332     return (ftepp->token = lex_do(ftepp->lex));
333 }
334
335 /* Important: this does not skip newlines! */
336 static bool ftepp_skipspace(ftepp_t *ftepp)
337 {
338     if (ftepp->token != TOKEN_WHITE)
339         return true;
340     while (ftepp_next(ftepp) == TOKEN_WHITE) {}
341     if (ftepp->token >= TOKEN_EOF) {
342         ftepp_error(ftepp, "unexpected end of preprocessor directive");
343         return false;
344     }
345     return true;
346 }
347
348 /* this one skips EOLs as well */
349 static bool ftepp_skipallwhite(ftepp_t *ftepp)
350 {
351     if (ftepp->token != TOKEN_WHITE && ftepp->token != TOKEN_EOL)
352         return true;
353     do {
354         ftepp_next(ftepp);
355     } while (ftepp->token == TOKEN_WHITE || ftepp->token == TOKEN_EOL);
356     if (ftepp->token >= TOKEN_EOF) {
357         ftepp_error(ftepp, "unexpected end of preprocessor directive");
358         return false;
359     }
360     return true;
361 }
362
363 /**
364  * The huge macro parsing code...
365  */
366 static bool ftepp_define_params(ftepp_t *ftepp, ppmacro *macro)
367 {
368     do {
369         ftepp_next(ftepp);
370         if (!ftepp_skipspace(ftepp))
371             return false;
372         if (ftepp->token == ')')
373             break;
374         switch (ftepp->token) {
375             case TOKEN_IDENT:
376             case TOKEN_TYPENAME:
377             case TOKEN_KEYWORD:
378                 vec_push(macro->params, util_strdup(ftepp_tokval(ftepp)));
379                 break;
380             case TOKEN_DOTS:
381                 macro->variadic = true;
382                 break;
383             default:
384                 ftepp_error(ftepp, "unexpected token in parameter list");
385                 return false;
386         }
387         ftepp_next(ftepp);
388         if (!ftepp_skipspace(ftepp))
389             return false;
390         if (macro->variadic && ftepp->token != ')') {
391             ftepp_error(ftepp, "cannot have parameters after the variadic parameters");
392             return false;
393         }
394     } while (ftepp->token == ',');
395
396     if (ftepp->token != ')') {
397         ftepp_error(ftepp, "expected closing paren after macro parameter list");
398         return false;
399     }
400     ftepp_next(ftepp);
401     /* skipspace happens in ftepp_define */
402     return true;
403 }
404
405 static bool ftepp_define_body(ftepp_t *ftepp, ppmacro *macro)
406 {
407     pptoken *ptok;
408     while (ftepp->token != TOKEN_EOL && ftepp->token < TOKEN_EOF) {
409         bool   subscript = false;
410         size_t index     = 0;
411         if (macro->variadic && !strcmp(ftepp_tokval(ftepp), "__VA_ARGS__")) {
412             subscript = !!(ftepp_next(ftepp) == '#');
413
414             if (subscript && ftepp_next(ftepp) != '#') {
415                 ftepp_error(ftepp, "expected `##` in __VA_ARGS__ for subscripting");
416                 return false;
417             } else if (subscript) {
418                 if (ftepp_next(ftepp) == '[') {
419                     if (ftepp_next(ftepp) != TOKEN_INTCONST) {
420                         ftepp_error(ftepp, "expected index for __VA_ARGS__ subscript");
421                         return false;
422                     }
423
424                     index = (int)strtol(ftepp_tokval(ftepp), NULL, 10);
425
426                     if (ftepp_next(ftepp) != ']') {
427                         ftepp_error(ftepp, "expected `]` in __VA_ARGS__ subscript");
428                         return false;
429                     }
430
431                     /*
432                      * mark it as an array to be handled later as such and not
433                      * as traditional __VA_ARGS__
434                      */
435                     ftepp->token = TOKEN_VA_ARGS_ARRAY;
436                     ptok = pptoken_make(ftepp);
437                     ptok->constval.i = index;
438                     vec_push(macro->output, ptok);
439                     ftepp_next(ftepp);
440                 } else {
441                     ftepp_error(ftepp, "expected `[` for subscripting of __VA_ARGS__");
442                     return false;
443                 }
444             } else {
445                 int old = ftepp->token;
446                 ftepp->token = TOKEN_VA_ARGS;
447                 ptok = pptoken_make(ftepp);
448                 vec_push(macro->output, ptok);
449                 ftepp->token = old;
450             }
451         }
452         else if (macro->variadic && !strcmp(ftepp_tokval(ftepp), "__VA_COUNT__")) {
453             ftepp->token = TOKEN_VA_COUNT;
454             ptok         = pptoken_make(ftepp);
455             vec_push(macro->output, ptok);
456             ftepp_next(ftepp);
457         } else {
458             ptok = pptoken_make(ftepp);
459             vec_push(macro->output, ptok);
460             ftepp_next(ftepp);
461         }
462     }
463     /* recursive expansion can cause EOFs here */
464     if (ftepp->token != TOKEN_EOL && ftepp->token != TOKEN_EOF) {
465         ftepp_error(ftepp, "unexpected junk after macro or unexpected end of file");
466         return false;
467     }
468     return true;
469 }
470
471 static bool ftepp_define(ftepp_t *ftepp)
472 {
473     ppmacro *macro = NULL;
474     size_t l = ftepp_ctx(ftepp).line;
475
476     (void)ftepp_next(ftepp);
477     if (!ftepp_skipspace(ftepp))
478         return false;
479
480     switch (ftepp->token) {
481         case TOKEN_IDENT:
482         case TOKEN_TYPENAME:
483         case TOKEN_KEYWORD:
484             macro = ftepp_macro_find(ftepp, ftepp_tokval(ftepp));
485             if (macro && ftepp->output_on) {
486                 if (ftepp_warn(ftepp, WARN_CPP, "redefining `%s`", ftepp_tokval(ftepp)))
487                     return false;
488                 ftepp_macro_delete(ftepp, ftepp_tokval(ftepp));
489             }
490             macro = ppmacro_new(ftepp_ctx(ftepp), ftepp_tokval(ftepp));
491             break;
492         default:
493             ftepp_error(ftepp, "expected macro name");
494             return false;
495     }
496
497     (void)ftepp_next(ftepp);
498
499     if (ftepp->token == '(') {
500         macro->has_params = true;
501         if (!ftepp_define_params(ftepp, macro)) {
502             ppmacro_delete(macro);
503             return false;
504         }
505     }
506
507     if (!ftepp_skipspace(ftepp)) {
508         ppmacro_delete(macro);
509         return false;
510     }
511
512     if (!ftepp_define_body(ftepp, macro)) {
513         ppmacro_delete(macro);
514         return false;
515     }
516
517 #if 0
518     if (ftepp->output_on)
519         vec_push(ftepp->macros, macro);
520 #endif
521     if (ftepp->output_on)
522         util_htset(ftepp->macros, macro->name, (void*)macro);
523     else {
524         ppmacro_delete(macro);
525     }
526
527     for (; l < ftepp_ctx(ftepp).line; ++l)
528         ftepp_out(ftepp, "\n", true);
529     return true;
530 }
531
532 /**
533  * When a macro is used we have to handle parameters as well
534  * as special-concatenation via ## or stringification via #
535  *
536  * Note: parenthesis can nest, so FOO((a),b) is valid, but only
537  * this kind of parens. Curly braces or [] don't count towards the
538  * paren-level.
539  */
540 typedef struct {
541     pptoken **tokens;
542 } macroparam;
543
544 static void macroparam_clean(macroparam *self)
545 {
546     size_t i;
547     for (i = 0; i < vec_size(self->tokens); ++i)
548         pptoken_delete(self->tokens[i]);
549     vec_free(self->tokens);
550 }
551
552 /* need to leave the last token up */
553 static bool ftepp_macro_call_params(ftepp_t *ftepp, macroparam **out_params)
554 {
555     macroparam *params = NULL;
556     pptoken    *ptok;
557     macroparam  mp;
558     size_t      parens = 0;
559     size_t      i;
560
561     if (!ftepp_skipallwhite(ftepp))
562         return false;
563     while (ftepp->token != ')') {
564         mp.tokens = NULL;
565         if (!ftepp_skipallwhite(ftepp))
566             return false;
567         while (parens || ftepp->token != ',') {
568             if (ftepp->token == '(')
569                 ++parens;
570             else if (ftepp->token == ')') {
571                 if (!parens)
572                     break;
573                 --parens;
574             }
575             ptok = pptoken_make(ftepp);
576             vec_push(mp.tokens, ptok);
577             if (ftepp_next(ftepp) >= TOKEN_EOF) {
578                 ftepp_error(ftepp, "unexpected EOF in macro call");
579                 goto on_error;
580             }
581         }
582         vec_push(params, mp);
583         mp.tokens = NULL;
584         if (ftepp->token == ')')
585             break;
586         if (ftepp->token != ',') {
587             ftepp_error(ftepp, "expected closing paren or comma in macro call");
588             goto on_error;
589         }
590         if (ftepp_next(ftepp) >= TOKEN_EOF) {
591             ftepp_error(ftepp, "unexpected EOF in macro call");
592             goto on_error;
593         }
594     }
595     /* need to leave that up
596     if (ftepp_next(ftepp) >= TOKEN_EOF) {
597         ftepp_error(ftepp, "unexpected EOF in macro call");
598         goto on_error;
599     }
600     */
601     *out_params = params;
602     return true;
603
604 on_error:
605     if (mp.tokens)
606         macroparam_clean(&mp);
607     for (i = 0; i < vec_size(params); ++i)
608         macroparam_clean(&params[i]);
609     vec_free(params);
610     return false;
611 }
612
613 static bool macro_params_find(ppmacro *macro, const char *name, size_t *idx)
614 {
615     size_t i;
616     for (i = 0; i < vec_size(macro->params); ++i) {
617         if (!strcmp(macro->params[i], name)) {
618             *idx = i;
619             return true;
620         }
621     }
622     return false;
623 }
624
625 static void ftepp_stringify_token(ftepp_t *ftepp, pptoken *token)
626 {
627     char        chs[2];
628     const char *ch;
629     chs[1] = 0;
630     switch (token->token) {
631         case TOKEN_STRINGCONST:
632             ch = token->value;
633             while (*ch) {
634                 /* in preprocessor mode strings already are string,
635                  * so we don't get actual newline bytes here.
636                  * Still need to escape backslashes and quotes.
637                  */
638                 switch (*ch) {
639                     case '\\': ftepp_out(ftepp, "\\\\", false); break;
640                     case '"':  ftepp_out(ftepp, "\\\"", false); break;
641                     default:
642                         chs[0] = *ch;
643                         ftepp_out(ftepp, chs, false);
644                         break;
645                 }
646                 ++ch;
647             }
648             break;
649         case TOKEN_WHITE:
650             ftepp_out(ftepp, " ", false);
651             break;
652         case TOKEN_EOL:
653             ftepp_out(ftepp, "\\n", false);
654             break;
655         default:
656             ftepp_out(ftepp, token->value, false);
657             break;
658     }
659 }
660
661 static void ftepp_stringify(ftepp_t *ftepp, macroparam *param)
662 {
663     size_t i;
664     ftepp_out(ftepp, "\"", false);
665     for (i = 0; i < vec_size(param->tokens); ++i)
666         ftepp_stringify_token(ftepp, param->tokens[i]);
667     ftepp_out(ftepp, "\"", false);
668 }
669
670 static void ftepp_recursion_header(ftepp_t *ftepp)
671 {
672     ftepp_out(ftepp, "\n#pragma push(line)\n", false);
673 }
674
675 static void ftepp_recursion_footer(ftepp_t *ftepp)
676 {
677     ftepp_out(ftepp, "\n#pragma pop(line)\n", false);
678 }
679
680 static void ftepp_param_out(ftepp_t *ftepp, macroparam *param)
681 {
682     size_t   i;
683     pptoken *out;
684     for (i = 0; i < vec_size(param->tokens); ++i) {
685         out = param->tokens[i];
686         if (out->token == TOKEN_EOL)
687             ftepp_out(ftepp, "\n", false);
688         else
689             ftepp_out(ftepp, out->value, false);
690     }
691 }
692
693 static bool ftepp_preprocess(ftepp_t *ftepp);
694 static bool ftepp_macro_expand(ftepp_t *ftepp, ppmacro *macro, macroparam *params, bool resetline)
695 {
696     char     *buffer       = NULL;
697     char     *old_string   = ftepp->output_string;
698     char     *inner_string;
699     lex_file *old_lexer    = ftepp->lex;
700     size_t    vararg_start = vec_size(macro->params);
701     bool      retval       = true;
702     bool      has_newlines;
703     size_t    varargs;
704
705     size_t    o, pi;
706     lex_file *inlex;
707
708     bool      old_inmacro;
709
710     int nextok;
711
712     if (vararg_start < vec_size(params))
713         varargs = vec_size(params) - vararg_start;
714     else
715         varargs = 0;
716
717     /* really ... */
718     if (!vec_size(macro->output))
719         return true;
720
721     ftepp->output_string = NULL;
722     for (o = 0; o < vec_size(macro->output); ++o) {
723         pptoken *out = macro->output[o];
724         switch (out->token) {
725             case TOKEN_VA_ARGS:
726                 if (!macro->variadic) {
727                     ftepp_error(ftepp, "internal preprocessor error: TOKEN_VA_ARGS in non-variadic macro");
728                     vec_free(old_string);
729                     return false;
730                 }
731                 if (!varargs)
732                     break;
733
734                 pi = 0;
735                 ftepp_param_out(ftepp, &params[pi + vararg_start]);
736                 for (++pi; pi < varargs; ++pi) {
737                     ftepp_out(ftepp, ", ", false);
738                     ftepp_param_out(ftepp, &params[pi + vararg_start]);
739                 }
740                 break;
741
742             case TOKEN_VA_ARGS_ARRAY:
743                 if ((size_t)out->constval.i >= varargs) {
744                     ftepp_error(ftepp, "subscript of `[%u]` is out of bounds for `__VA_ARGS__`", out->constval.i);
745                     vec_free(old_string);
746                     return false;
747                 }
748
749                 ftepp_param_out(ftepp, &params[out->constval.i + vararg_start]);
750                 break;
751
752             case TOKEN_VA_COUNT:
753                 util_asprintf(&buffer, "%d", varargs);
754                 ftepp_out(ftepp, buffer, false);
755                 mem_d(buffer);
756                 break;
757
758             case TOKEN_IDENT:
759             case TOKEN_TYPENAME:
760             case TOKEN_KEYWORD:
761                 if (!macro_params_find(macro, out->value, &pi)) {
762                     ftepp_out(ftepp, out->value, false);
763                     break;
764                 } else
765                     ftepp_param_out(ftepp, &params[pi]);
766                 break;
767             case '#':
768                 if (o + 1 < vec_size(macro->output)) {
769                     nextok = macro->output[o+1]->token;
770                     if (nextok == '#') {
771                         /* raw concatenation */
772                         ++o;
773                         break;
774                     }
775                     if ( (nextok == TOKEN_IDENT    ||
776                           nextok == TOKEN_KEYWORD  ||
777                           nextok == TOKEN_TYPENAME) &&
778                         macro_params_find(macro, macro->output[o+1]->value, &pi))
779                     {
780                         ++o;
781                         ftepp_stringify(ftepp, &params[pi]);
782                         break;
783                     }
784                 }
785                 ftepp_out(ftepp, "#", false);
786                 break;
787             case TOKEN_EOL:
788                 ftepp_out(ftepp, "\n", false);
789                 break;
790             default:
791                 ftepp_out(ftepp, out->value, false);
792                 break;
793         }
794     }
795     vec_push(ftepp->output_string, 0);
796     /* Now run the preprocessor recursively on this string buffer */
797     /*
798     printf("__________\n%s\n=========\n", ftepp->output_string);
799     */
800     inlex = lex_open_string(ftepp->output_string, vec_size(ftepp->output_string)-1, ftepp->lex->name);
801     if (!inlex) {
802         ftepp_error(ftepp, "internal error: failed to instantiate lexer");
803         retval = false;
804         goto cleanup;
805     }
806
807     inlex->line  = ftepp->lex->line;
808     inlex->sline = ftepp->lex->sline;
809     ftepp->lex   = inlex;
810
811     old_inmacro     = ftepp->in_macro;
812     ftepp->in_macro = true;
813     ftepp->output_string = NULL;
814     if (!ftepp_preprocess(ftepp)) {
815         ftepp->in_macro = old_inmacro;
816         vec_free(ftepp->lex->open_string);
817         vec_free(ftepp->output_string);
818         lex_close(ftepp->lex);
819         retval = false;
820         goto cleanup;
821     }
822     ftepp->in_macro = old_inmacro;
823     vec_free(ftepp->lex->open_string);
824     lex_close(ftepp->lex);
825
826     inner_string = ftepp->output_string;
827     ftepp->output_string = old_string;
828
829     has_newlines = (strchr(inner_string, '\n') != NULL);
830
831     if (has_newlines && !old_inmacro)
832         ftepp_recursion_header(ftepp);
833
834     vec_append(ftepp->output_string, vec_size(inner_string), inner_string);
835     vec_free(inner_string);
836
837     if (has_newlines && !old_inmacro)
838         ftepp_recursion_footer(ftepp);
839
840     if (resetline && !ftepp->in_macro) {
841         char lineno[128];
842         snprintf(lineno, 128, "\n#pragma line(%lu)\n", (unsigned long)(old_lexer->sline));
843         ftepp_out(ftepp, lineno, false);
844     }
845
846     old_string = ftepp->output_string;
847 cleanup:
848     ftepp->lex           = old_lexer;
849     ftepp->output_string = old_string;
850     return retval;
851 }
852
853 static bool ftepp_macro_call(ftepp_t *ftepp, ppmacro *macro)
854 {
855     size_t     o;
856     macroparam *params = NULL;
857     bool        retval = true;
858     size_t      paramline;
859
860     if (!macro->has_params) {
861         if (!ftepp_macro_expand(ftepp, macro, NULL, false))
862             return false;
863         ftepp_next(ftepp);
864         return true;
865     }
866     ftepp_next(ftepp);
867
868     if (!ftepp_skipallwhite(ftepp))
869         return false;
870
871     if (ftepp->token != '(') {
872         ftepp_error(ftepp, "expected macro parameters in parenthesis");
873         return false;
874     }
875
876     ftepp_next(ftepp);
877     paramline = ftepp->lex->sline;
878     if (!ftepp_macro_call_params(ftepp, &params))
879         return false;
880
881     if ( vec_size(params) < vec_size(macro->params) ||
882         (vec_size(params) > vec_size(macro->params) && !macro->variadic) )
883     {
884         ftepp_error(ftepp, "macro %s expects%s %u paramteters, %u provided", macro->name,
885                     (macro->variadic ? " at least" : ""),
886                     (unsigned int)vec_size(macro->params),
887                     (unsigned int)vec_size(params));
888         retval = false;
889         goto cleanup;
890     }
891
892     if (!ftepp_macro_expand(ftepp, macro, params, (paramline != ftepp->lex->sline)))
893         retval = false;
894     ftepp_next(ftepp);
895
896 cleanup:
897     for (o = 0; o < vec_size(params); ++o)
898         macroparam_clean(&params[o]);
899     vec_free(params);
900     return retval;
901 }
902
903 /**
904  * #if - the FTEQCC way:
905  *    defined(FOO) => true if FOO was #defined regardless of parameters or contents
906  *    <numbers>    => True if the number is not 0
907  *    !<factor>    => True if the factor yields false
908  *    !!<factor>   => ERROR on 2 or more unary nots
909  *    <macro>      => becomes the macro's FIRST token regardless of parameters
910  *    <e> && <e>   => True if both expressions are true
911  *    <e> || <e>   => True if either expression is true
912  *    <string>     => False
913  *    <ident>      => False (remember for macros the <macro> rule applies instead)
914  * Unary + and - are weird and wrong in fteqcc so we don't allow them
915  * parenthesis in expressions are allowed
916  * parameter lists on macros are errors
917  * No mathematical calculations are executed
918  */
919 static bool ftepp_if_expr(ftepp_t *ftepp, bool *out, double *value_out);
920 static bool ftepp_if_op(ftepp_t *ftepp)
921 {
922     ftepp->lex->flags.noops = false;
923     ftepp_next(ftepp);
924     if (!ftepp_skipspace(ftepp))
925         return false;
926     ftepp->lex->flags.noops = true;
927     return true;
928 }
929 static bool ftepp_if_value(ftepp_t *ftepp, bool *out, double *value_out)
930 {
931     ppmacro *macro;
932     bool     wasnot = false;
933     bool     wasneg = false;
934
935     if (!ftepp_skipspace(ftepp))
936         return false;
937
938     while (ftepp->token == '!') {
939         wasnot = true;
940         ftepp_next(ftepp);
941         if (!ftepp_skipspace(ftepp))
942             return false;
943     }
944
945     if (ftepp->token == TOKEN_OPERATOR && !strcmp(ftepp_tokval(ftepp), "-"))
946     {
947         wasneg = true;
948         ftepp_next(ftepp);
949         if (!ftepp_skipspace(ftepp))
950             return false;
951     }
952
953     switch (ftepp->token) {
954         case TOKEN_IDENT:
955         case TOKEN_TYPENAME:
956         case TOKEN_KEYWORD:
957             if (!strcmp(ftepp_tokval(ftepp), "defined")) {
958                 ftepp_next(ftepp);
959                 if (!ftepp_skipspace(ftepp))
960                     return false;
961                 if (ftepp->token != '(') {
962                     ftepp_error(ftepp, "`defined` keyword in #if requires a macro name in parenthesis");
963                     return false;
964                 }
965                 ftepp_next(ftepp);
966                 if (!ftepp_skipspace(ftepp))
967                     return false;
968                 if (ftepp->token != TOKEN_IDENT &&
969                     ftepp->token != TOKEN_TYPENAME &&
970                     ftepp->token != TOKEN_KEYWORD)
971                 {
972                     ftepp_error(ftepp, "defined() used on an unexpected token type");
973                     return false;
974                 }
975                 macro = ftepp_macro_find(ftepp, ftepp_tokval(ftepp));
976                 *out = !!macro;
977                 ftepp_next(ftepp);
978                 if (!ftepp_skipspace(ftepp))
979                     return false;
980                 if (ftepp->token != ')') {
981                     ftepp_error(ftepp, "expected closing paren");
982                     return false;
983                 }
984                 break;
985             }
986
987             macro = ftepp_macro_find(ftepp, ftepp_tokval(ftepp));
988             if (!macro || !vec_size(macro->output)) {
989                 *out = false;
990                 *value_out = 0;
991             } else {
992                 /* This does not expand recursively! */
993                 switch (macro->output[0]->token) {
994                     case TOKEN_INTCONST:
995                         *value_out = macro->output[0]->constval.i;
996                         *out = !!(macro->output[0]->constval.i);
997                         break;
998                     case TOKEN_FLOATCONST:
999                         *value_out = macro->output[0]->constval.f;
1000                         *out = !!(macro->output[0]->constval.f);
1001                         break;
1002                     default:
1003                         *out = false;
1004                         break;
1005                 }
1006             }
1007             break;
1008         case TOKEN_STRINGCONST:
1009             *value_out = 0;
1010             *out = false;
1011             break;
1012         case TOKEN_INTCONST:
1013             *value_out = ftepp->lex->tok.constval.i;
1014             *out = !!(ftepp->lex->tok.constval.i);
1015             break;
1016         case TOKEN_FLOATCONST:
1017             *value_out = ftepp->lex->tok.constval.f;
1018             *out = !!(ftepp->lex->tok.constval.f);
1019             break;
1020
1021         case '(':
1022             ftepp_next(ftepp);
1023             if (!ftepp_if_expr(ftepp, out, value_out))
1024                 return false;
1025             if (ftepp->token != ')') {
1026                 ftepp_error(ftepp, "expected closing paren in #if expression");
1027                 return false;
1028             }
1029             break;
1030
1031         default:
1032             ftepp_error(ftepp, "junk in #if: `%s` ...", ftepp_tokval(ftepp));
1033             if (OPTS_OPTION_BOOL(OPTION_DEBUG))
1034                 ftepp_error(ftepp, "internal: token %i\n", ftepp->token);
1035             return false;
1036     }
1037     if (wasneg)
1038         *value_out = -*value_out;
1039     if (wasnot) {
1040         *out = !*out;
1041         *value_out = (*out ? 1 : 0);
1042     }
1043     return true;
1044 }
1045
1046 /*
1047 static bool ftepp_if_nextvalue(ftepp_t *ftepp, bool *out, double *value_out)
1048 {
1049     if (!ftepp_next(ftepp))
1050         return false;
1051     return ftepp_if_value(ftepp, out, value_out);
1052 }
1053 */
1054
1055 static bool ftepp_if_expr(ftepp_t *ftepp, bool *out, double *value_out)
1056 {
1057     if (!ftepp_if_value(ftepp, out, value_out))
1058         return false;
1059
1060     if (!ftepp_if_op(ftepp))
1061         return false;
1062
1063     if (ftepp->token == ')' || ftepp->token != TOKEN_OPERATOR)
1064         return true;
1065
1066     /* FTEQCC is all right-associative and no precedence here */
1067     if (!strcmp(ftepp_tokval(ftepp), "&&") ||
1068         !strcmp(ftepp_tokval(ftepp), "||"))
1069     {
1070         bool next = false;
1071         char opc  = ftepp_tokval(ftepp)[0];
1072         double nextvalue;
1073
1074         (void)nextvalue;
1075         if (!ftepp_next(ftepp))
1076             return false;
1077         if (!ftepp_if_expr(ftepp, &next, &nextvalue))
1078             return false;
1079
1080         if (opc == '&')
1081             *out = *out && next;
1082         else
1083             *out = *out || next;
1084
1085         *value_out = (*out ? 1 : 0);
1086         return true;
1087     }
1088     else if (!strcmp(ftepp_tokval(ftepp), "==") ||
1089              !strcmp(ftepp_tokval(ftepp), "!=") ||
1090              !strcmp(ftepp_tokval(ftepp), ">=") ||
1091              !strcmp(ftepp_tokval(ftepp), "<=") ||
1092              !strcmp(ftepp_tokval(ftepp), ">") ||
1093              !strcmp(ftepp_tokval(ftepp), "<"))
1094     {
1095         bool next = false;
1096         const char opc0 = ftepp_tokval(ftepp)[0];
1097         const char opc1 = ftepp_tokval(ftepp)[1];
1098         double other;
1099
1100         if (!ftepp_next(ftepp))
1101             return false;
1102         if (!ftepp_if_expr(ftepp, &next, &other))
1103             return false;
1104
1105         if (opc0 == '=')
1106             *out = (*value_out == other);
1107         else if (opc0 == '!')
1108             *out = (*value_out != other);
1109         else if (opc0 == '>') {
1110             if (opc1 == '=') *out = (*value_out >= other);
1111             else             *out = (*value_out > other);
1112         }
1113         else if (opc0 == '<') {
1114             if (opc1 == '=') *out = (*value_out <= other);
1115             else             *out = (*value_out < other);
1116         }
1117         *value_out = (*out ? 1 : 0);
1118
1119         return true;
1120     }
1121     else {
1122         ftepp_error(ftepp, "junk after #if");
1123         return false;
1124     }
1125 }
1126
1127 static bool ftepp_if(ftepp_t *ftepp, ppcondition *cond)
1128 {
1129     bool result = false;
1130     double dummy = 0;
1131
1132     memset(cond, 0, sizeof(*cond));
1133     (void)ftepp_next(ftepp);
1134
1135     if (!ftepp_skipspace(ftepp))
1136         return false;
1137     if (ftepp->token == TOKEN_EOL) {
1138         ftepp_error(ftepp, "expected expression for #if-directive");
1139         return false;
1140     }
1141
1142     if (!ftepp_if_expr(ftepp, &result, &dummy))
1143         return false;
1144
1145     cond->on = result;
1146     return true;
1147 }
1148
1149 /**
1150  * ifdef is rather simple
1151  */
1152 static bool ftepp_ifdef(ftepp_t *ftepp, ppcondition *cond)
1153 {
1154     ppmacro *macro;
1155     memset(cond, 0, sizeof(*cond));
1156     (void)ftepp_next(ftepp);
1157     if (!ftepp_skipspace(ftepp))
1158         return false;
1159
1160     switch (ftepp->token) {
1161         case TOKEN_IDENT:
1162         case TOKEN_TYPENAME:
1163         case TOKEN_KEYWORD:
1164             macro = ftepp_macro_find(ftepp, ftepp_tokval(ftepp));
1165             break;
1166         default:
1167             ftepp_error(ftepp, "expected macro name");
1168             return false;
1169     }
1170
1171     (void)ftepp_next(ftepp);
1172     if (!ftepp_skipspace(ftepp))
1173         return false;
1174     /* relaxing this condition
1175     if (ftepp->token != TOKEN_EOL && ftepp->token != TOKEN_EOF) {
1176         ftepp_error(ftepp, "stray tokens after #ifdef");
1177         return false;
1178     }
1179     */
1180     cond->on = !!macro;
1181     return true;
1182 }
1183
1184 /**
1185  * undef is also simple
1186  */
1187 static bool ftepp_undef(ftepp_t *ftepp)
1188 {
1189     (void)ftepp_next(ftepp);
1190     if (!ftepp_skipspace(ftepp))
1191         return false;
1192
1193     if (ftepp->output_on) {
1194         switch (ftepp->token) {
1195             case TOKEN_IDENT:
1196             case TOKEN_TYPENAME:
1197             case TOKEN_KEYWORD:
1198                 ftepp_macro_delete(ftepp, ftepp_tokval(ftepp));
1199                 break;
1200             default:
1201                 ftepp_error(ftepp, "expected macro name");
1202                 return false;
1203         }
1204     }
1205
1206     (void)ftepp_next(ftepp);
1207     if (!ftepp_skipspace(ftepp))
1208         return false;
1209     /* relaxing this condition
1210     if (ftepp->token != TOKEN_EOL && ftepp->token != TOKEN_EOF) {
1211         ftepp_error(ftepp, "stray tokens after #ifdef");
1212         return false;
1213     }
1214     */
1215     return true;
1216 }
1217
1218 /* Special unescape-string function which skips a leading quote
1219  * and stops at a quote, not just at \0
1220  */
1221 static void unescape(const char *str, char *out) {
1222     ++str;
1223     while (*str && *str != '"') {
1224         if (*str == '\\') {
1225             ++str;
1226             switch (*str) {
1227                 case '\\': *out++ = *str; break;
1228                 case '"':  *out++ = *str; break;
1229                 case 'a':  *out++ = '\a'; break;
1230                 case 'b':  *out++ = '\b'; break;
1231                 case 'r':  *out++ = '\r'; break;
1232                 case 'n':  *out++ = '\n'; break;
1233                 case 't':  *out++ = '\t'; break;
1234                 case 'f':  *out++ = '\f'; break;
1235                 case 'v':  *out++ = '\v'; break;
1236                 default:
1237                     *out++ = '\\';
1238                     *out++ = *str;
1239                     break;
1240             }
1241             ++str;
1242             continue;
1243         }
1244
1245         *out++ = *str++;
1246     }
1247     *out = 0;
1248 }
1249
1250 static char *ftepp_include_find_path(const char *file, const char *pathfile)
1251 {
1252     FILE       *fp;
1253     char       *filename = NULL;
1254     const char *last_slash;
1255     size_t      len;
1256
1257     if (!pathfile)
1258         return NULL;
1259
1260     last_slash = strrchr(pathfile, '/');
1261
1262     if (last_slash) {
1263         len = last_slash - pathfile;
1264         memcpy(vec_add(filename, len), pathfile, len);
1265         vec_push(filename, '/');
1266     }
1267
1268     len = strlen(file);
1269     memcpy(vec_add(filename, len+1), file, len);
1270     vec_last(filename) = 0;
1271
1272     fp = fs_file_open(filename, "rb");
1273     if (fp) {
1274         fs_file_close(fp);
1275         return filename;
1276     }
1277     vec_free(filename);
1278     return NULL;
1279 }
1280
1281 static char *ftepp_include_find(ftepp_t *ftepp, const char *file)
1282 {
1283     char *filename = NULL;
1284
1285     filename = ftepp_include_find_path(file, ftepp->includename);
1286     if (!filename)
1287         filename = ftepp_include_find_path(file, ftepp->itemname);
1288     return filename;
1289 }
1290
1291 static bool ftepp_directive_warning(ftepp_t *ftepp) {
1292     char *message = NULL;
1293
1294     if (!ftepp_skipspace(ftepp))
1295         return false;
1296
1297     /* handle the odd non string constant case so it works like C */
1298     if (ftepp->token != TOKEN_STRINGCONST) {
1299         bool  store   = false;
1300         vec_upload(message, "#warning", 8);
1301         ftepp_next(ftepp);
1302         while (ftepp->token != TOKEN_EOL) {
1303             vec_upload(message, ftepp_tokval(ftepp), strlen(ftepp_tokval(ftepp)));
1304             ftepp_next(ftepp);
1305         }
1306         vec_push(message, '\0');
1307         if (ftepp->output_on)
1308             store = ftepp_warn(ftepp, WARN_CPP, message);
1309         else
1310             store = false;
1311         vec_free(message);
1312         return store;
1313     }
1314
1315     if (!ftepp->output_on)
1316         return false;
1317
1318     unescape  (ftepp_tokval(ftepp), ftepp_tokval(ftepp));
1319     return ftepp_warn(ftepp, WARN_CPP, "#warning %s", ftepp_tokval(ftepp));
1320 }
1321
1322 static void ftepp_directive_error(ftepp_t *ftepp) {
1323     char *message = NULL;
1324
1325     if (!ftepp_skipspace(ftepp))
1326         return;
1327
1328     /* handle the odd non string constant case so it works like C */
1329     if (ftepp->token != TOKEN_STRINGCONST) {
1330         vec_upload(message, "#error", 6);
1331         ftepp_next(ftepp);
1332         while (ftepp->token != TOKEN_EOL) {
1333             vec_upload(message, ftepp_tokval(ftepp), strlen(ftepp_tokval(ftepp)));
1334             ftepp_next(ftepp);
1335         }
1336         vec_push(message, '\0');
1337         if (ftepp->output_on)
1338             ftepp_error(ftepp, message);
1339         vec_free(message);
1340         return;
1341     }
1342
1343     if (!ftepp->output_on)
1344         return;
1345
1346     unescape  (ftepp_tokval(ftepp), ftepp_tokval(ftepp));
1347     ftepp_error(ftepp, "#error %s", ftepp_tokval(ftepp));
1348 }
1349
1350 static void ftepp_directive_message(ftepp_t *ftepp) {
1351     char *message = NULL;
1352
1353     if (!ftepp_skipspace(ftepp))
1354         return;
1355
1356     /* handle the odd non string constant case so it works like C */
1357     if (ftepp->token != TOKEN_STRINGCONST) {
1358         vec_upload(message, "#message", 8);
1359         ftepp_next(ftepp);
1360         while (ftepp->token != TOKEN_EOL) {
1361             vec_upload(message, ftepp_tokval(ftepp), strlen(ftepp_tokval(ftepp)));
1362             ftepp_next(ftepp);
1363         }
1364         vec_push(message, '\0');
1365         if (ftepp->output_on)
1366             con_cprintmsg(&ftepp->lex->tok.ctx, LVL_MSG, "message", message);
1367         vec_free(message);
1368         return;
1369     }
1370
1371     if (!ftepp->output_on)
1372         return;
1373
1374     unescape     (ftepp_tokval(ftepp), ftepp_tokval(ftepp));
1375     con_cprintmsg(&ftepp->lex->tok.ctx, LVL_MSG, "message",  ftepp_tokval(ftepp));
1376 }
1377
1378 /**
1379  * Include a file.
1380  * FIXME: do we need/want a -I option?
1381  * FIXME: what about when dealing with files in subdirectories coming from a progs.src?
1382  */
1383 static bool ftepp_include(ftepp_t *ftepp)
1384 {
1385     lex_file *old_lexer = ftepp->lex;
1386     lex_file *inlex;
1387     lex_ctx  ctx;
1388     char     lineno[128];
1389     char     *filename;
1390     char     *old_includename;
1391
1392     (void)ftepp_next(ftepp);
1393     if (!ftepp_skipspace(ftepp))
1394         return false;
1395
1396     if (ftepp->token != TOKEN_STRINGCONST) {
1397         ftepp_error(ftepp, "expected filename to include");
1398         return false;
1399     }
1400
1401     if (!ftepp->output_on) {
1402         ftepp_next(ftepp);
1403         return true;
1404     }
1405
1406     ctx = ftepp_ctx(ftepp);
1407
1408     unescape(ftepp_tokval(ftepp), ftepp_tokval(ftepp));
1409
1410     ftepp_out(ftepp, "\n#pragma file(", false);
1411     ftepp_out(ftepp, ftepp_tokval(ftepp), false);
1412     ftepp_out(ftepp, ")\n#pragma line(1)\n", false);
1413
1414     filename = ftepp_include_find(ftepp, ftepp_tokval(ftepp));
1415     if (!filename) {
1416         ftepp_error(ftepp, "failed to open include file `%s`", ftepp_tokval(ftepp));
1417         return false;
1418     }
1419     inlex = lex_open(filename);
1420     if (!inlex) {
1421         ftepp_error(ftepp, "open failed on include file `%s`", filename);
1422         vec_free(filename);
1423         return false;
1424     }
1425     ftepp->lex = inlex;
1426     old_includename = ftepp->includename;
1427     ftepp->includename = filename;
1428     if (!ftepp_preprocess(ftepp)) {
1429         vec_free(ftepp->includename);
1430         ftepp->includename = old_includename;
1431         lex_close(ftepp->lex);
1432         ftepp->lex = old_lexer;
1433         return false;
1434     }
1435     vec_free(ftepp->includename);
1436     ftepp->includename = old_includename;
1437     lex_close(ftepp->lex);
1438     ftepp->lex = old_lexer;
1439
1440     ftepp_out(ftepp, "\n#pragma file(", false);
1441     ftepp_out(ftepp, ctx.file, false);
1442     snprintf(lineno, sizeof(lineno), ")\n#pragma line(%lu)\n", (unsigned long)(ctx.line+1));
1443     ftepp_out(ftepp, lineno, false);
1444
1445     /* skip the line */
1446     (void)ftepp_next(ftepp);
1447     if (!ftepp_skipspace(ftepp))
1448         return false;
1449     if (ftepp->token != TOKEN_EOL) {
1450         ftepp_error(ftepp, "stray tokens after #include");
1451         return false;
1452     }
1453     (void)ftepp_next(ftepp);
1454
1455     return true;
1456 }
1457
1458 /* Basic structure handlers */
1459 static bool ftepp_else_allowed(ftepp_t *ftepp)
1460 {
1461     if (!vec_size(ftepp->conditions)) {
1462         ftepp_error(ftepp, "#else without #if");
1463         return false;
1464     }
1465     if (vec_last(ftepp->conditions).had_else) {
1466         ftepp_error(ftepp, "multiple #else for a single #if");
1467         return false;
1468     }
1469     return true;
1470 }
1471
1472 static bool ftepp_hash(ftepp_t *ftepp)
1473 {
1474     ppcondition cond;
1475     ppcondition *pc;
1476
1477     lex_ctx ctx = ftepp_ctx(ftepp);
1478
1479     if (!ftepp_skipspace(ftepp))
1480         return false;
1481
1482     switch (ftepp->token) {
1483         case TOKEN_KEYWORD:
1484         case TOKEN_IDENT:
1485         case TOKEN_TYPENAME:
1486             if (!strcmp(ftepp_tokval(ftepp), "define")) {
1487                 return ftepp_define(ftepp);
1488             }
1489             else if (!strcmp(ftepp_tokval(ftepp), "undef")) {
1490                 return ftepp_undef(ftepp);
1491             }
1492             else if (!strcmp(ftepp_tokval(ftepp), "ifdef")) {
1493                 if (!ftepp_ifdef(ftepp, &cond))
1494                     return false;
1495                 cond.was_on = cond.on;
1496                 vec_push(ftepp->conditions, cond);
1497                 ftepp->output_on = ftepp->output_on && cond.on;
1498                 break;
1499             }
1500             else if (!strcmp(ftepp_tokval(ftepp), "ifndef")) {
1501                 if (!ftepp_ifdef(ftepp, &cond))
1502                     return false;
1503                 cond.on = !cond.on;
1504                 cond.was_on = cond.on;
1505                 vec_push(ftepp->conditions, cond);
1506                 ftepp->output_on = ftepp->output_on && cond.on;
1507                 break;
1508             }
1509             else if (!strcmp(ftepp_tokval(ftepp), "elifdef")) {
1510                 if (!ftepp_else_allowed(ftepp))
1511                     return false;
1512                 if (!ftepp_ifdef(ftepp, &cond))
1513                     return false;
1514                 pc = &vec_last(ftepp->conditions);
1515                 pc->on     = !pc->was_on && cond.on;
1516                 pc->was_on = pc->was_on || pc->on;
1517                 ftepp_update_output_condition(ftepp);
1518                 break;
1519             }
1520             else if (!strcmp(ftepp_tokval(ftepp), "elifndef")) {
1521                 if (!ftepp_else_allowed(ftepp))
1522                     return false;
1523                 if (!ftepp_ifdef(ftepp, &cond))
1524                     return false;
1525                 cond.on = !cond.on;
1526                 pc = &vec_last(ftepp->conditions);
1527                 pc->on     = !pc->was_on && cond.on;
1528                 pc->was_on = pc->was_on || pc->on;
1529                 ftepp_update_output_condition(ftepp);
1530                 break;
1531             }
1532             else if (!strcmp(ftepp_tokval(ftepp), "elif")) {
1533                 if (!ftepp_else_allowed(ftepp))
1534                     return false;
1535                 if (!ftepp_if(ftepp, &cond))
1536                     return false;
1537                 pc = &vec_last(ftepp->conditions);
1538                 pc->on     = !pc->was_on && cond.on;
1539                 pc->was_on = pc->was_on  || pc->on;
1540                 ftepp_update_output_condition(ftepp);
1541                 break;
1542             }
1543             else if (!strcmp(ftepp_tokval(ftepp), "if")) {
1544                 if (!ftepp_if(ftepp, &cond))
1545                     return false;
1546                 cond.was_on = cond.on;
1547                 vec_push(ftepp->conditions, cond);
1548                 ftepp->output_on = ftepp->output_on && cond.on;
1549                 break;
1550             }
1551             else if (!strcmp(ftepp_tokval(ftepp), "else")) {
1552                 if (!ftepp_else_allowed(ftepp))
1553                     return false;
1554                 pc = &vec_last(ftepp->conditions);
1555                 pc->on = !pc->was_on;
1556                 pc->had_else = true;
1557                 ftepp_next(ftepp);
1558                 ftepp_update_output_condition(ftepp);
1559                 break;
1560             }
1561             else if (!strcmp(ftepp_tokval(ftepp), "endif")) {
1562                 if (!vec_size(ftepp->conditions)) {
1563                     ftepp_error(ftepp, "#endif without #if");
1564                     return false;
1565                 }
1566                 vec_pop(ftepp->conditions);
1567                 ftepp_next(ftepp);
1568                 ftepp_update_output_condition(ftepp);
1569                 break;
1570             }
1571             else if (!strcmp(ftepp_tokval(ftepp), "include")) {
1572                 return ftepp_include(ftepp);
1573             }
1574             else if (!strcmp(ftepp_tokval(ftepp), "pragma")) {
1575                 ftepp_out(ftepp, "#", false);
1576                 break;
1577             }
1578             else if (!strcmp(ftepp_tokval(ftepp), "warning")) {
1579                 ftepp_directive_warning(ftepp);
1580                 break;
1581             }
1582             else if (!strcmp(ftepp_tokval(ftepp), "error")) {
1583                 ftepp_directive_error(ftepp);
1584                 break;
1585             }
1586             else if (!strcmp(ftepp_tokval(ftepp), "message")) {
1587                 ftepp_directive_message(ftepp);
1588                 break;
1589             }
1590             else {
1591                 if (ftepp->output_on) {
1592                     ftepp_error(ftepp, "unrecognized preprocessor directive: `%s`", ftepp_tokval(ftepp));
1593                     return false;
1594                 } else {
1595                     ftepp_next(ftepp);
1596                     break;
1597                 }
1598             }
1599             /* break; never reached */
1600         default:
1601             ftepp_error(ftepp, "unexpected preprocessor token: `%s`", ftepp_tokval(ftepp));
1602             return false;
1603         case TOKEN_EOL:
1604             ftepp_errorat(ftepp, ctx, "empty preprocessor directive");
1605             return false;
1606         case TOKEN_EOF:
1607             ftepp_error(ftepp, "missing newline at end of file", ftepp_tokval(ftepp));
1608             return false;
1609
1610         /* Builtins! Don't forget the builtins! */
1611         case TOKEN_INTCONST:
1612         case TOKEN_FLOATCONST:
1613             ftepp_out(ftepp, "#", false);
1614             return true;
1615     }
1616     if (!ftepp_skipspace(ftepp))
1617         return false;
1618     return true;
1619 }
1620
1621 static bool ftepp_preprocess(ftepp_t *ftepp)
1622 {
1623     ppmacro *macro;
1624     bool     newline = true;
1625
1626     /* predef stuff */
1627     char    *expand  = NULL;
1628     size_t   i;
1629
1630     ftepp->lex->flags.preprocessing = true;
1631     ftepp->lex->flags.mergelines    = false;
1632     ftepp->lex->flags.noops         = true;
1633
1634     ftepp_next(ftepp);
1635     do
1636     {
1637         if (ftepp->token >= TOKEN_EOF)
1638             break;
1639 #if 0
1640         newline = true;
1641 #endif
1642
1643         switch (ftepp->token) {
1644             case TOKEN_KEYWORD:
1645             case TOKEN_IDENT:
1646             case TOKEN_TYPENAME:
1647                 /* is it a predef? */
1648                 if (OPTS_FLAG(FTEPP_PREDEFS)) {
1649                     for (i = 0; i < sizeof(ftepp_predefs) / sizeof (*ftepp_predefs); i++) {
1650                         if (!strcmp(ftepp_predefs[i].name, ftepp_tokval(ftepp))) {
1651                             expand = ftepp_predefs[i].func(ftepp->lex);
1652                             ftepp_out(ftepp, expand, false);
1653                             ftepp_next(ftepp); /* skip */
1654
1655                             mem_d(expand); /* free memory */
1656                             break;
1657                         }
1658                     }
1659                 }
1660
1661                 if (ftepp->output_on)
1662                     macro = ftepp_macro_find(ftepp, ftepp_tokval(ftepp));
1663                 else
1664                     macro = NULL;
1665
1666                 if (!macro) {
1667                     ftepp_out(ftepp, ftepp_tokval(ftepp), false);
1668                     ftepp_next(ftepp);
1669                     break;
1670                 }
1671                 if (!ftepp_macro_call(ftepp, macro))
1672                     ftepp->token = TOKEN_ERROR;
1673                 break;
1674             case '#':
1675                 if (!newline) {
1676                     ftepp_out(ftepp, ftepp_tokval(ftepp), false);
1677                     ftepp_next(ftepp);
1678                     break;
1679                 }
1680                 ftepp->lex->flags.mergelines = true;
1681                 if (ftepp_next(ftepp) >= TOKEN_EOF) {
1682                     ftepp_error(ftepp, "error in preprocessor directive");
1683                     ftepp->token = TOKEN_ERROR;
1684                     break;
1685                 }
1686                 if (!ftepp_hash(ftepp))
1687                     ftepp->token = TOKEN_ERROR;
1688                 ftepp->lex->flags.mergelines = false;
1689                 break;
1690             case TOKEN_EOL:
1691                 newline = true;
1692                 ftepp_out(ftepp, "\n", true);
1693                 ftepp_next(ftepp);
1694                 break;
1695             case TOKEN_WHITE:
1696                 /* same as default but don't set newline=false */
1697                 ftepp_out(ftepp, ftepp_tokval(ftepp), true);
1698                 ftepp_next(ftepp);
1699                 break;
1700             default:
1701                 newline = false;
1702                 ftepp_out(ftepp, ftepp_tokval(ftepp), false);
1703                 ftepp_next(ftepp);
1704                 break;
1705         }
1706     } while (!ftepp->errors && ftepp->token < TOKEN_EOF);
1707
1708     /* force a 0 at the end but don't count it as added to the output */
1709     vec_push(ftepp->output_string, 0);
1710     vec_shrinkby(ftepp->output_string, 1);
1711
1712     return (ftepp->token == TOKEN_EOF);
1713 }
1714
1715 /* Like in parser.c - files keep the previous state so we have one global
1716  * preprocessor. Except here we will want to warn about dangling #ifs.
1717  */
1718 static bool ftepp_preprocess_done(ftepp_t *ftepp)
1719 {
1720     bool retval = true;
1721     if (vec_size(ftepp->conditions)) {
1722         if (ftepp_warn(ftepp, WARN_MULTIFILE_IF, "#if spanning multiple files, is this intended?"))
1723             retval = false;
1724     }
1725     lex_close(ftepp->lex);
1726     ftepp->lex = NULL;
1727     if (ftepp->itemname) {
1728         mem_d(ftepp->itemname);
1729         ftepp->itemname = NULL;
1730     }
1731     return retval;
1732 }
1733
1734 bool ftepp_preprocess_file(ftepp_t *ftepp, const char *filename)
1735 {
1736     ftepp->lex = lex_open(filename);
1737     ftepp->itemname = util_strdup(filename);
1738     if (!ftepp->lex) {
1739         con_out("failed to open file \"%s\"\n", filename);
1740         return false;
1741     }
1742     if (!ftepp_preprocess(ftepp))
1743         return false;
1744     return ftepp_preprocess_done(ftepp);
1745 }
1746
1747 bool ftepp_preprocess_string(ftepp_t *ftepp, const char *name, const char *str)
1748 {
1749     ftepp->lex = lex_open_string(str, strlen(str), name);
1750     ftepp->itemname = util_strdup(name);
1751     if (!ftepp->lex) {
1752         con_out("failed to create lexer for string \"%s\"\n", name);
1753         return false;
1754     }
1755     if (!ftepp_preprocess(ftepp))
1756         return false;
1757     return ftepp_preprocess_done(ftepp);
1758 }
1759
1760
1761 void ftepp_add_macro(ftepp_t *ftepp, const char *name, const char *value) {
1762     char *create = NULL;
1763
1764     /* use saner path for empty macros */
1765     if (!value) {
1766         ftepp_add_define(ftepp, "__builtin__", name);
1767         return;
1768     }
1769
1770     vec_upload(create, "#define ", 8);
1771     vec_upload(create, name,  strlen(name));
1772     vec_push  (create, ' ');
1773     vec_upload(create, value, strlen(value));
1774     vec_push  (create, 0);
1775
1776     ftepp_preprocess_string(ftepp, "__builtin__", create);
1777     vec_free  (create);
1778 }
1779
1780 ftepp_t *ftepp_create()
1781 {
1782     ftepp_t *ftepp;
1783     char minor[32];
1784     char major[32];
1785
1786     ftepp = ftepp_new();
1787     if (!ftepp)
1788         return NULL;
1789
1790     memset(minor, 0, sizeof(minor));
1791     memset(major, 0, sizeof(major));
1792
1793     /* set the right macro based on the selected standard */
1794     ftepp_add_define(ftepp, NULL, "GMQCC");
1795     if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_FTEQCC) {
1796         ftepp_add_define(ftepp, NULL, "__STD_FTEQCC__");
1797         /* 1.00 */
1798         major[0] = '"';
1799         major[1] = '1';
1800         major[2] = '"';
1801
1802         minor[0] = '"';
1803         minor[1] = '0';
1804         minor[2] = '"';
1805     } else if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_GMQCC) {
1806         ftepp_add_define(ftepp, NULL, "__STD_GMQCC__");
1807         snprintf(major, 32, "\"%d\"", GMQCC_VERSION_MAJOR);
1808         snprintf(minor, 32, "\"%d\"", GMQCC_VERSION_MINOR);
1809     } else if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCCX) {
1810         ftepp_add_define(ftepp, NULL, "__STD_QCCX__");
1811         snprintf(major, 32, "\"%d\"", GMQCC_VERSION_MAJOR);
1812         snprintf(minor, 32, "\"%d\"", GMQCC_VERSION_MINOR);
1813     } else if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) {
1814         ftepp_add_define(ftepp, NULL, "__STD_QCC__");
1815         /* 1.0 */
1816         major[0] = '"';
1817         major[1] = '1';
1818         major[2] = '"';
1819
1820         minor[0] = '"';
1821         minor[1] = '0';
1822         minor[2] = '"';
1823     }
1824
1825     ftepp_add_macro(ftepp, "__STD_VERSION_MINOR__", minor);
1826     ftepp_add_macro(ftepp, "__STD_VERSION_MAJOR__", major);
1827
1828     return ftepp;
1829 }
1830
1831 void ftepp_add_define(ftepp_t *ftepp, const char *source, const char *name)
1832 {
1833     ppmacro *macro;
1834     lex_ctx ctx = { "__builtin__", 0 };
1835     ctx.file = source;
1836     macro = ppmacro_new(ctx, name);
1837     /*vec_push(ftepp->macros, macro);*/
1838     util_htset(ftepp->macros, name, macro);
1839 }
1840
1841 const char *ftepp_get(ftepp_t *ftepp)
1842 {
1843     return ftepp->output_string;
1844 }
1845
1846 void ftepp_flush(ftepp_t *ftepp)
1847 {
1848     ftepp_flush_do(ftepp);
1849 }
1850
1851 void ftepp_finish(ftepp_t *ftepp)
1852 {
1853     if (!ftepp)
1854         return;
1855     ftepp_delete(ftepp);
1856 }