ftepp.c

   1 /*
   2  * Copyright (C) 2012
   3  *     Wolfgang Bumiller
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy of
   6  * this software and associated documentation files (the "Software"), to deal in
   7  * the Software without restriction, including without limitation the rights to
   8  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
   9  * of the Software, and to permit persons to whom the Software is furnished to do
  10  * so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in all
  13  * copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21  * SOFTWARE.
  22  */
  23 #include "gmqcc.h"
  24 #include "lexer.h"
  25
  26 typedef struct {
  27         bool on;
  28         bool was_on;
  29         bool had_else;
  30 } ppcondition;
  31
  32 typedef struct {
  33         int   token;
  34         char *value;
  35         /* a copy from the lexer */
  36         union {
  37                 vector v;
  38                 int    i;
  39                 double f;
  40                 int    t; /* type */
  41         } constval;
  42 } pptoken;
  43
  44 typedef struct {
  45         lex_ctx ctx;
  46
  47         char   *name;
  48         char  **params;
  49         /* yes we need an extra flag since `#define FOO x` is not the same as `#define FOO() x` */
  50         bool    has_params;
  51
  52         pptoken **output;
  53 } ppmacro;
  54
  55 typedef struct {
  56         lex_file    *lex;
  57         int          token;
  58         bool         newline;
  59         unsigned int errors;
  60
  61         ppcondition *conditions;
  62         ppmacro    **macros;
  63 } ftepp_t;
  64
  65 #define ftepp_tokval(f) ((f)->lex->tok.value)
  66 #define ftepp_ctx(f)    ((f)->lex->tok.ctx)
  67
  68 static void ftepp_errorat(ftepp_t *ftepp, lex_ctx ctx, const char *fmt, ...)
  69 {
  70         va_list ap;
  71
  72         ftepp->errors++;
  73
  74         va_start(ap, fmt);
  75     con_vprintmsg(LVL_ERROR, ctx.file, ctx.line, "error", fmt, ap);
  76         va_end(ap);
  77 }
  78
  79 static void ftepp_error(ftepp_t *ftepp, const char *fmt, ...)
  80 {
  81         va_list ap;
  82
  83         ftepp->errors++;
  84
  85         va_start(ap, fmt);
  86     con_vprintmsg(LVL_ERROR, ftepp->lex->tok.ctx.file, ftepp->lex->tok.ctx.line, "error", fmt, ap);
  87         va_end(ap);
  88 }
  89
  90 ppmacro *ppmacro_new(lex_ctx ctx, const char *name)
  91 {
  92         ppmacro *macro = (ppmacro*)mem_a(sizeof(ppmacro));
  93         memset(macro, 0, sizeof(*macro));
  94         macro->name = util_strdup(name);
  95         return macro;
  96 }
  97
  98 void ppmacro_delete(ppmacro *self)
  99 {
 100         vec_free(self->params);
 101         vec_free(self->output);
 102         mem_d(self->name);
 103         mem_d(self);
 104 }
 105
 106 ftepp_t* ftepp_init()
 107 {
 108         ftepp_t *ftepp;
 109
 110         ftepp = (ftepp_t*)mem_a(sizeof(*ftepp));
 111         memset(ftepp, 0, sizeof(*ftepp));
 112
 113         return ftepp;
 114 }
 115
 116 void ftepp_delete(ftepp_t *self)
 117 {
 118         vec_free(self->macros);
 119         vec_free(self->conditions);
 120         mem_d(self);
 121 }
 122
 123 ppmacro* ftepp_macro_find(ftepp_t *ftepp, const char *name)
 124 {
 125         size_t i;
 126         for (i = 0; i < vec_size(ftepp->macros); ++i) {
 127                 if (!strcmp(name, ftepp->macros[i]->name))
 128                         return ftepp->macros[i];
 129         }
 130         return NULL;
 131 }
 132
 133 static inline int ftepp_next(ftepp_t *ftepp)
 134 {
 135         return (ftepp->token = lex_do(ftepp->lex));
 136 }
 137
 138 /* Important: this does not skip newlines! */
 139 static bool ftepp_skipspace(ftepp_t *ftepp)
 140 {
 141         if (ftepp->token != TOKEN_WHITE)
 142                 return true;
 143         while (ftepp_next(ftepp) == TOKEN_WHITE) {}
 144         if (ftepp->token >= TOKEN_EOF) {
 145                 ftepp_error(ftepp, "unexpected end of preprocessor directive");
 146                 return false;
 147         }
 148         return true;
 149 }
 150
 151 /**
 152  * The huge macro parsing code...
 153  */
 154 static bool ftepp_define(ftepp_t *ftepp)
 155 {
 156         ppmacro *macro;
 157         (void)ftepp_next(ftepp);
 158         if (!ftepp_skipspace(ftepp))
 159                 return false;
 160
 161         switch (ftepp->token) {
 162                 case TOKEN_IDENT:
 163                 case TOKEN_TYPENAME:
 164                 case TOKEN_KEYWORD:
 165                         macro = ppmacro_new(ftepp_ctx(ftepp), ftepp_tokval(ftepp));
 166                         break;
 167                 default:
 168                         ftepp_error(ftepp, "expected macro name");
 169                         return false;
 170         }
 171
 172         (void)ftepp_next(ftepp);
 173         if (!ftepp_skipspace(ftepp))
 174                 return false;
 175         if (ftepp->token != TOKEN_EOL) {
 176                 ftepp_error(ftepp, "stray tokens after macro");
 177                 return false;
 178         }
 179         vec_push(ftepp->macros, macro);
 180         return true;
 181 }
 182
 183 /**
 184  * #if - the FTEQCC way:
 185  *    defined(FOO) => true if FOO was #defined regardless of parameters or contents
 186  *    <numbers>    => True if the number is not 0
 187  *    !<factor>    => True if the factor yields false
 188  *    <macro>      => becomes the macro's FIRST token regardless of parameters
 189  *    <e> && <e>   => True if both expressions are true
 190  *    <e> || <e>   => True if either expression is true
 191  *    <string>     => False
 192  *    <ident>      => False (remember for macros the <macro> rule applies instead)
 193  * Unary + and - are skipped
 194  * parenthesis in expressions are allowed
 195  * parameter lists on macros are errors
 196  * No mathematical calculations are executed
 197  */
 198 static bool ftepp_if_expr(ftepp_t *ftepp, bool *out)
 199 {
 200         ppmacro *macro;
 201         while (ftepp->token != TOKEN_EOL) {
 202                 switch (ftepp->token) {
 203                         case TOKEN_IDENT:
 204                         case TOKEN_TYPENAME:
 205                         case TOKEN_KEYWORD:
 206                                 macro = ftepp_macro_find(ftepp, ftepp_tokval(ftepp));
 207                                 if (!macro || !vec_size(macro->output)) {
 208                                         *out = false;
 209                                 } else {
 210                                         /* This does not expand recursively! */
 211                                         switch (macro->output[0]->token) {
 212                                                 case TOKEN_INTCONST:
 213                                                         *out = !!(macro->output[0]->constval.f);
 214                                                         break;
 215                                                 case TOKEN_FLOATCONST:
 216                                                         *out = !!(macro->output[0]->constval.f);
 217                                                         break;
 218                                                 default:
 219                                                         *out = false;
 220                                                         break;
 221                                         }
 222                                 }
 223                                 break;
 224                         case TOKEN_STRINGCONST:
 225                                 *out = false;
 226                                 break;
 227                         case TOKEN_INTCONST:
 228                                 *out = !!(ftepp->lex->tok.constval.i);
 229                                 break;
 230                         case TOKEN_FLOATCONST:
 231                                 *out = !!(ftepp->lex->tok.constval.f);
 232                                 break;
 233
 234                         default:
 235                                 ftepp_error(ftepp, "junk in #if");
 236                                 return false;
 237                 }
 238         }
 239         (void)ftepp_next(ftepp);
 240         return true;
 241 }
 242
 243 static bool ftepp_if(ftepp_t *ftepp, ppcondition *cond)
 244 {
 245         bool result = false;
 246
 247         memset(cond, 0, sizeof(*cond));
 248         (void)ftepp_next(ftepp);
 249
 250         if (!ftepp_skipspace(ftepp))
 251                 return false;
 252         if (ftepp->token == TOKEN_EOL) {
 253                 ftepp_error(ftepp, "expected expression for #if-directive");
 254                 return false;
 255         }
 256
 257         if (!ftepp_if_expr(ftepp, &result))
 258                 return false;
 259
 260         cond->on = result;
 261         return true;
 262 }
 263
 264 /**
 265  * ifdef is rather simple
 266  */
 267 static bool ftepp_ifdef(ftepp_t *ftepp, ppcondition *cond)
 268 {
 269         ppmacro *macro;
 270         memset(cond, 0, sizeof(*cond));
 271         (void)ftepp_next(ftepp);
 272         if (!ftepp_skipspace(ftepp))
 273                 return false;
 274
 275         switch (ftepp->token) {
 276                 case TOKEN_IDENT:
 277                 case TOKEN_TYPENAME:
 278                 case TOKEN_KEYWORD:
 279                         macro = ftepp_macro_find(ftepp, ftepp_tokval(ftepp));
 280                         break;
 281                 default:
 282                         ftepp_error(ftepp, "expected macro name");
 283                         return false;
 284         }
 285
 286         (void)ftepp_next(ftepp);
 287         if (!ftepp_skipspace(ftepp))
 288                 return false;
 289         if (ftepp->token != TOKEN_EOL) {
 290                 ftepp_error(ftepp, "stray tokens after #ifdef");
 291                 return false;
 292         }
 293         cond->on = !!macro;
 294         return true;
 295 }
 296
 297 /* Basic structure handlers */
 298 static bool ftepp_else_allowed(ftepp_t *ftepp)
 299 {
 300         if (!vec_size(ftepp->conditions)) {
 301                 ftepp_error(ftepp, "#else without #if");
 302                 return false;
 303         }
 304         if (vec_last(ftepp->conditions).had_else) {
 305                 ftepp_error(ftepp, "multiple #else for a single #if");
 306                 return false;
 307         }
 308         return true;
 309 }
 310
 311 static bool ftepp_hash(ftepp_t *ftepp)
 312 {
 313         ppcondition cond;
 314         ppcondition *pc;
 315
 316         lex_ctx ctx = ftepp_ctx(ftepp);
 317
 318         if (!ftepp_skipspace(ftepp))
 319                 return false;
 320
 321         switch (ftepp->token) {
 322                 case TOKEN_KEYWORD:
 323                 case TOKEN_IDENT:
 324                 case TOKEN_TYPENAME:
 325                         if (!strcmp(ftepp_tokval(ftepp), "define")) {
 326                                 return ftepp_define(ftepp);
 327                         }
 328                         else if (!strcmp(ftepp_tokval(ftepp), "ifdef")) {
 329                                 if (!ftepp_ifdef(ftepp, &cond))
 330                                         return false;
 331                                 vec_push(ftepp->conditions, cond);
 332                                 return true;
 333                         }
 334                         else if (!strcmp(ftepp_tokval(ftepp), "ifndef")) {
 335                                 if (!ftepp_ifdef(ftepp, &cond))
 336                                         return false;
 337                                 cond.on = !cond.on;
 338                                 vec_push(ftepp->conditions, cond);
 339                                 return true;
 340                         }
 341                         else if (!strcmp(ftepp_tokval(ftepp), "elifdef")) {
 342                                 if (!ftepp_else_allowed(ftepp))
 343                                         return false;
 344                                 if (!ftepp_ifdef(ftepp, &cond))
 345                                         return false;
 346                                 pc = &vec_last(ftepp->conditions);
 347                                 pc->on     = !pc->was_on && cond.on;
 348                                 pc->was_on = pc->was_on || pc->on;
 349                                 return true;
 350                         }
 351                         else if (!strcmp(ftepp_tokval(ftepp), "elifndef")) {
 352                                 if (!ftepp_else_allowed(ftepp))
 353                                         return false;
 354                                 if (!ftepp_ifdef(ftepp, &cond))
 355                                         return false;
 356                                 cond.on = !cond.on;
 357                                 pc = &vec_last(ftepp->conditions);
 358                                 pc->on     = !pc->was_on && cond.on;
 359                                 pc->was_on = pc->was_on || pc->on;
 360                                 return true;
 361                         }
 362                         else if (!strcmp(ftepp_tokval(ftepp), "elif")) {
 363                                 if (!ftepp_else_allowed(ftepp))
 364                                         return false;
 365                                 if (!ftepp_if(ftepp, &cond))
 366                                         return false;
 367                                 pc = &vec_last(ftepp->conditions);
 368                                 pc->on     = !pc->was_on && cond.on;
 369                                 pc->was_on = pc->was_on  || pc->on;
 370                                 return true;
 371                         }
 372                         else if (!strcmp(ftepp_tokval(ftepp), "if")) {
 373                                 if (!ftepp_if(ftepp, &cond))
 374                                         return false;
 375                                 vec_push(ftepp->conditions, cond);
 376                                 return true;
 377                         }
 378                         else if (!strcmp(ftepp_tokval(ftepp), "else")) {
 379                                 if (!ftepp_else_allowed(ftepp))
 380                                         return false;
 381                                 pc = &vec_last(ftepp->conditions);
 382                                 pc->on = !pc->was_on;
 383                                 pc->had_else = true;
 384                                 return true;
 385                         }
 386                         else if (!strcmp(ftepp_tokval(ftepp), "endif")) {
 387                                 if (!vec_size(ftepp->conditions)) {
 388                                         ftepp_error(ftepp, "#endif without #if");
 389                                         return false;
 390                                 }
 391                                 vec_pop(ftepp->conditions);
 392                                 break;
 393                         }
 394                         else {
 395                                 ftepp_error(ftepp, "unrecognized preprocessor directive: `%s`", ftepp_tokval(ftepp));
 396                                 return false;
 397                         }
 398                         break;
 399                 default:
 400                         ftepp_error(ftepp, "unexpected preprocessor token: `%s`", ftepp_tokval(ftepp));
 401                         return false;
 402                 case TOKEN_EOL:
 403                         ftepp_errorat(ftepp, ctx, "empty preprocessor directive");
 404                         return false;
 405                 case TOKEN_EOF:
 406                         ftepp_error(ftepp, "missing newline at end of file", ftepp_tokval(ftepp));
 407                         return false;
 408         }
 409         return true;
 410 }
 411
 412 static void ftepp_out(ftepp_t *ftepp, const char *str)
 413 {
 414         if (!vec_size(ftepp->conditions) ||
 415                 vec_last(ftepp->conditions).on)
 416         {
 417                 printf("%s", str);
 418         }
 419 }
 420
 421 static bool ftepp_preprocess(ftepp_t *ftepp)
 422 {
 423         bool newline = true;
 424
 425         ftepp->lex->flags.preprocessing = true;
 426
 427         ftepp_next(ftepp);
 428         do
 429         {
 430                 if (ftepp->token >= TOKEN_EOF)
 431                         break;
 432
 433                 ftepp->newline = newline;
 434                 newline = false;
 435
 436                 switch (ftepp->token) {
 437                         case '#':
 438                                 if (!ftepp->newline) {
 439                                         ftepp_out(ftepp, ftepp_tokval(ftepp));
 440                                         ftepp_next(ftepp);
 441                                         break;
 442                                 }
 443                                 if (ftepp_next(ftepp) >= TOKEN_EOF) {
 444                                         ftepp_error(ftepp, "error in preprocessor directive");
 445                                         ftepp->token = TOKEN_ERROR;
 446                                         break;
 447                                 }
 448                                 if (!ftepp_hash(ftepp))
 449                                         ftepp->token = TOKEN_ERROR;
 450                                 break;
 451                         case TOKEN_EOL:
 452                                 newline = true;
 453                                 ftepp_out(ftepp, "\n");
 454                                 ftepp_next(ftepp);
 455                                 break;
 456                         default:
 457                                 ftepp_out(ftepp, ftepp_tokval(ftepp));
 458                                 ftepp_next(ftepp);
 459                                 break;
 460                 }
 461         } while (!ftepp->errors && ftepp->token < TOKEN_EOF);
 462
 463         ftepp_delete(ftepp);
 464         return (ftepp->token == TOKEN_EOF);
 465 }
 466
 467 bool ftepp_preprocess_file(const char *filename)
 468 {
 469         ftepp_t *ftepp = ftepp_init();
 470     ftepp->lex = lex_open(filename);
 471     if (!ftepp->lex) {
 472         con_out("failed to open file \"%s\"\n", filename);
 473         return false;
 474     }
 475     return ftepp_preprocess(ftepp);
 476 }
 477
 478 bool ftepp_preprocess_string(const char *name, const char *str)
 479 {
 480         ftepp_t *ftepp = ftepp_init();
 481     ftepp->lex = lex_open_string(str, strlen(str), name);
 482     if (!ftepp->lex) {
 483         con_out("failed to create lexer for string \"%s\"\n", name);
 484         return false;
 485     }
 486     return ftepp_preprocess(ftepp);
 487 }