ftepp.cpp

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