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