nsz Git - cparser/blob - preprocessor.c

   1 #include <config.h>
   2
   3 #include <assert.h>
   4 #include <errno.h>
   5 #include <string.h>
   6 #include <stdbool.h>
   7 #include <ctype.h>
   8
   9 #include "token_t.h"
  10 #include "symbol_t.h"
  11 #include "adt/util.h"
  12 #include "adt/error.h"
  13 #include "adt/strutil.h"
  14 #include "adt/strset.h"
  15 #include "lang_features.h"
  16 #include "diagnostic.h"
  17 #include "string_rep.h"
  18 #include "input.h"
  19
  20 #define MAX_PUTBACK 3
  21 #define INCLUDE_LIMIT 199  /* 199 is for gcc "compatibility" */
  22
  23 struct pp_argument_t {
  24         size_t   list_len;
  25         token_t *token_list;
  26 };
  27
  28 struct pp_definition_t {
  29         symbol_t          *symbol;
  30         source_position_t  source_position;
  31         pp_definition_t   *parent_expansion;
  32         size_t             expand_pos;
  33         bool               is_variadic    : 1;
  34         bool               is_expanding   : 1;
  35         bool               has_parameters : 1;
  36         size_t             n_parameters;
  37         symbol_t          *parameters;
  38
  39         /* replacement */
  40         size_t             list_len;
  41         token_t           *token_list;
  42
  43 };
  44
  45 typedef struct pp_conditional_t pp_conditional_t;
  46 struct pp_conditional_t {
  47         source_position_t  source_position;
  48         bool               condition;
  49         bool               in_else;
  50         bool               skip; /**< conditional in skip mode (then+else gets skipped) */
  51         pp_conditional_t  *parent;
  52 };
  53
  54 typedef struct pp_input_t pp_input_t;
  55 struct pp_input_t {
  56         FILE              *file;
  57         input_t           *input;
  58         utf32              c;
  59         utf32              buf[1024+MAX_PUTBACK];
  60         const utf32       *bufend;
  61         const utf32       *bufpos;
  62         source_position_t  position;
  63         pp_input_t        *parent;
  64         unsigned           output_line;
  65 };
  66
  67 /** additional info about the current token */
  68 typedef struct add_token_info_t {
  69         /** whitespace from beginning of line to the token */
  70         unsigned whitespace;
  71         /** there has been any whitespace before the token */
  72         bool     had_whitespace;
  73         /** the token is at the beginning of the line */
  74         bool     at_line_begin;
  75 } add_token_info_t;
  76
  77 typedef struct searchpath_entry_t searchpath_entry_t;
  78 struct searchpath_entry_t {
  79         const char         *path;
  80         searchpath_entry_t *next;
  81 };
  82
  83 static pp_input_t      input;
  84
  85 static pp_input_t     *input_stack;
  86 static unsigned        n_inputs;
  87 static struct obstack  input_obstack;
  88
  89 static pp_conditional_t *conditional_stack;
  90
  91 static token_t           pp_token;
  92 static bool              resolve_escape_sequences = false;
  93 static bool              ignore_unknown_chars     = true;
  94 static bool              in_pp_directive;
  95 static bool              skip_mode;
  96 static FILE             *out;
  97 static struct obstack    pp_obstack;
  98 static struct obstack    config_obstack;
  99 static const char       *printed_input_name = NULL;
 100 static source_position_t expansion_pos;
 101 static pp_definition_t  *current_expansion  = NULL;
 102 static strset_t          stringset;
 103 static preprocessor_token_type_t last_token = TP_ERROR;
 104
 105 static searchpath_entry_t *searchpath;
 106
 107 static add_token_info_t  info;
 108
 109 static inline void next_char(void);
 110 static void next_preprocessing_token(void);
 111 static void print_line_directive(const source_position_t *pos, const char *add);
 112
 113 static void switch_input(FILE *file, const char *filename)
 114 {
 115         input.file                = file;
 116         input.input               = input_from_stream(file, NULL);
 117         input.bufend              = NULL;
 118         input.bufpos              = NULL;
 119         input.output_line         = 0;
 120         input.position.input_name = filename;
 121         input.position.lineno     = 1;
 122
 123         /* indicate that we're at a new input */
 124         print_line_directive(&input.position, input_stack != NULL ? "1" : NULL);
 125
 126         /* place a virtual '\n' so we realize we're at line begin */
 127         input.position.lineno = 0;
 128         input.c               = '\n';
 129         next_preprocessing_token();
 130 }
 131
 132 static void close_input(void)
 133 {
 134         input_free(input.input);
 135         assert(input.file != NULL);
 136
 137         fclose(input.file);
 138         input.input  = NULL;
 139         input.file   = NULL;
 140         input.bufend = NULL;
 141         input.bufpos = NULL;
 142         input.c      = EOF;
 143 }
 144
 145 static void push_input(void)
 146 {
 147         pp_input_t *saved_input
 148                 = obstack_alloc(&input_obstack, sizeof(*saved_input));
 149
 150         memcpy(saved_input, &input, sizeof(*saved_input));
 151
 152         /* adjust buffer positions */
 153         if (input.bufpos != NULL)
 154                 saved_input->bufpos = saved_input->buf + (input.bufpos - input.buf);
 155         if (input.bufend != NULL)
 156                 saved_input->bufend = saved_input->buf + (input.bufend - input.buf);
 157
 158         saved_input->parent = input_stack;
 159         input_stack         = saved_input;
 160         ++n_inputs;
 161 }
 162
 163 static void pop_restore_input(void)
 164 {
 165         assert(n_inputs > 0);
 166         assert(input_stack != NULL);
 167
 168         pp_input_t *saved_input = input_stack;
 169
 170         memcpy(&input, saved_input, sizeof(input));
 171         input.parent = NULL;
 172
 173         /* adjust buffer positions */
 174         if (saved_input->bufpos != NULL)
 175                 input.bufpos = input.buf + (saved_input->bufpos - saved_input->buf);
 176         if (saved_input->bufend != NULL)
 177                 input.bufend = input.buf + (saved_input->bufend - saved_input->buf);
 178
 179         input_stack = saved_input->parent;
 180         obstack_free(&input_obstack, saved_input);
 181         --n_inputs;
 182 }
 183
 184 /**
 185  * Prints a parse error message at the current token.
 186  *
 187  * @param msg   the error message
 188  */
 189 static void parse_error(const char *msg)
 190 {
 191         errorf(&pp_token.source_position,  "%s", msg);
 192 }
 193
 194 static inline void next_real_char(void)
 195 {
 196         assert(input.bufpos <= input.bufend);
 197         if (input.bufpos >= input.bufend) {
 198                 size_t n = decode(input.input, input.buf + MAX_PUTBACK,
 199                                   sizeof(input.buf)/sizeof(input.buf[0]) - MAX_PUTBACK);
 200                 if (n == 0) {
 201                         input.c = EOF;
 202                         return;
 203                 }
 204                 input.bufpos = input.buf + MAX_PUTBACK;
 205                 input.bufend = input.bufpos + n;
 206         }
 207         input.c = *input.bufpos++;
 208         ++input.position.colno;
 209 }
 210
 211 /**
 212  * Put a character back into the buffer.
 213  *
 214  * @param pc  the character to put back
 215  */
 216 static inline void put_back(utf32 const pc)
 217 {
 218         assert(input.bufpos > input.buf);
 219         *(--input.bufpos - input.buf + input.buf) = (char) pc;
 220         --input.position.colno;
 221 }
 222
 223 #define MATCH_NEWLINE(code)                   \
 224         case '\r':                                \
 225                 next_char();                          \
 226                 if (input.c == '\n') {                \
 227         case '\n':                                \
 228                         next_char();                      \
 229                 }                                     \
 230                 info.whitespace = 0;                  \
 231                 ++input.position.lineno;              \
 232                 input.position.colno = 1;             \
 233                 code
 234
 235 #define eat(c_type) (assert(input.c == c_type), next_char())
 236
 237 static void maybe_concat_lines(void)
 238 {
 239         eat('\\');
 240
 241         switch (input.c) {
 242         MATCH_NEWLINE(
 243                 return;
 244         )
 245
 246         default:
 247                 break;
 248         }
 249
 250         put_back(input.c);
 251         input.c = '\\';
 252 }
 253
 254 /**
 255  * Set c to the next input character, ie.
 256  * after expanding trigraphs.
 257  */
 258 static inline void next_char(void)
 259 {
 260         next_real_char();
 261
 262         /* filter trigraphs and concatenated lines */
 263         if (UNLIKELY(input.c == '\\')) {
 264                 maybe_concat_lines();
 265                 goto end_of_next_char;
 266         }
 267
 268         if (LIKELY(input.c != '?'))
 269                 goto end_of_next_char;
 270
 271         next_real_char();
 272         if (LIKELY(input.c != '?')) {
 273                 put_back(input.c);
 274                 input.c = '?';
 275                 goto end_of_next_char;
 276         }
 277
 278         next_real_char();
 279         switch (input.c) {
 280         case '=': input.c = '#'; break;
 281         case '(': input.c = '['; break;
 282         case '/': input.c = '\\'; maybe_concat_lines(); break;
 283         case ')': input.c = ']'; break;
 284         case '\'': input.c = '^'; break;
 285         case '<': input.c = '{'; break;
 286         case '!': input.c = '|'; break;
 287         case '>': input.c = '}'; break;
 288         case '-': input.c = '~'; break;
 289         default:
 290                 put_back(input.c);
 291                 put_back('?');
 292                 input.c = '?';
 293                 break;
 294         }
 295
 296 end_of_next_char:;
 297 #ifdef DEBUG_CHARS
 298         printf("nchar '%c'\n", input.c);
 299 #endif
 300 }
 301
 302
 303
 304 /**
 305  * Returns true if the given char is a octal digit.
 306  *
 307  * @param char  the character to check
 308  */
 309 static inline bool is_octal_digit(int chr)
 310 {
 311         switch (chr) {
 312         case '0':
 313         case '1':
 314         case '2':
 315         case '3':
 316         case '4':
 317         case '5':
 318         case '6':
 319         case '7':
 320                 return true;
 321         default:
 322                 return false;
 323         }
 324 }
 325
 326 /**
 327  * Returns the value of a digit.
 328  * The only portable way to do it ...
 329  */
 330 static int digit_value(int digit)
 331 {
 332         switch (digit) {
 333         case '0': return 0;
 334         case '1': return 1;
 335         case '2': return 2;
 336         case '3': return 3;
 337         case '4': return 4;
 338         case '5': return 5;
 339         case '6': return 6;
 340         case '7': return 7;
 341         case '8': return 8;
 342         case '9': return 9;
 343         case 'a':
 344         case 'A': return 10;
 345         case 'b':
 346         case 'B': return 11;
 347         case 'c':
 348         case 'C': return 12;
 349         case 'd':
 350         case 'D': return 13;
 351         case 'e':
 352         case 'E': return 14;
 353         case 'f':
 354         case 'F': return 15;
 355         default:
 356                 panic("wrong character given");
 357         }
 358 }
 359
 360 /**
 361  * Parses an octal character sequence.
 362  *
 363  * @param first_digit  the already read first digit
 364  */
 365 static int parse_octal_sequence(const int first_digit)
 366 {
 367         assert(is_octal_digit(first_digit));
 368         int value = digit_value(first_digit);
 369         if (!is_octal_digit(input.c)) return value;
 370         value = 8 * value + digit_value(input.c);
 371         next_char();
 372         if (!is_octal_digit(input.c)) return value;
 373         value = 8 * value + digit_value(input.c);
 374         next_char();
 375
 376         if (char_is_signed) {
 377                 return (signed char) value;
 378         } else {
 379                 return (unsigned char) value;
 380         }
 381 }
 382
 383 /**
 384  * Parses a hex character sequence.
 385  */
 386 static int parse_hex_sequence(void)
 387 {
 388         int value = 0;
 389         while (isxdigit(input.c)) {
 390                 value = 16 * value + digit_value(input.c);
 391                 next_char();
 392         }
 393
 394         if (char_is_signed) {
 395                 return (signed char) value;
 396         } else {
 397                 return (unsigned char) value;
 398         }
 399 }
 400
 401 /**
 402  * Parse an escape sequence.
 403  */
 404 static int parse_escape_sequence(void)
 405 {
 406         eat('\\');
 407
 408         int ec = input.c;
 409         next_char();
 410
 411         switch (ec) {
 412         case '"':  return '"';
 413         case '\'': return '\'';
 414         case '\\': return '\\';
 415         case '?': return '\?';
 416         case 'a': return '\a';
 417         case 'b': return '\b';
 418         case 'f': return '\f';
 419         case 'n': return '\n';
 420         case 'r': return '\r';
 421         case 't': return '\t';
 422         case 'v': return '\v';
 423         case 'x':
 424                 return parse_hex_sequence();
 425         case '0':
 426         case '1':
 427         case '2':
 428         case '3':
 429         case '4':
 430         case '5':
 431         case '6':
 432         case '7':
 433                 return parse_octal_sequence(ec);
 434         case EOF:
 435                 parse_error("reached end of file while parsing escape sequence");
 436                 return EOF;
 437         default:
 438                 parse_error("unknown escape sequence");
 439                 return EOF;
 440         }
 441 }
 442
 443 static void grow_symbol(utf32 const tc)
 444 {
 445         struct obstack *const o  = &symbol_obstack;
 446         if (tc < 0x80U) {
 447                 obstack_1grow(o, tc);
 448         } else if (tc < 0x800) {
 449                 obstack_1grow(o, 0xC0 | (tc >> 6));
 450                 obstack_1grow(o, 0x80 | (tc & 0x3F));
 451         } else if (tc < 0x10000) {
 452                 obstack_1grow(o, 0xE0 | ( tc >> 12));
 453                 obstack_1grow(o, 0x80 | ((tc >>  6) & 0x3F));
 454                 obstack_1grow(o, 0x80 | ( tc        & 0x3F));
 455         } else {
 456                 obstack_1grow(o, 0xF0 | ( tc >> 18));
 457                 obstack_1grow(o, 0x80 | ((tc >> 12) & 0x3F));
 458                 obstack_1grow(o, 0x80 | ((tc >>  6) & 0x3F));
 459                 obstack_1grow(o, 0x80 | ( tc        & 0x3F));
 460         }
 461 }
 462
 463 static const char *identify_string(char *string)
 464 {
 465         const char *result = strset_insert(&stringset, string);
 466         if (result != string) {
 467                 obstack_free(&symbol_obstack, string);
 468         }
 469         return result;
 470 }
 471
 472 static string_t make_string(char *string, size_t len)
 473 {
 474         const char *result = identify_string(string);
 475         return (string_t) {result, len};
 476 }
 477
 478 static void parse_string_literal(void)
 479 {
 480         const unsigned start_linenr = input.position.lineno;
 481
 482         eat('"');
 483
 484         while (true) {
 485                 switch (input.c) {
 486                 case '\\': {
 487                         utf32 tc;
 488                         if (resolve_escape_sequences) {
 489                                 tc = parse_escape_sequence();
 490                                 obstack_1grow(&symbol_obstack, (char) tc);
 491                         } else {
 492                                 obstack_1grow(&symbol_obstack, (char) input.c);
 493                                 next_char();
 494                                 obstack_1grow(&symbol_obstack, (char) input.c);
 495                                 next_char();
 496                         }
 497                         break;
 498                 }
 499
 500                 case EOF: {
 501                         source_position_t source_position;
 502                         source_position.input_name = pp_token.source_position.input_name;
 503                         source_position.lineno     = start_linenr;
 504                         errorf(&source_position, "string has no end");
 505                         pp_token.type = TP_ERROR;
 506                         return;
 507                 }
 508
 509                 case '"':
 510                         next_char();
 511                         goto end_of_string;
 512
 513                 default:
 514                         grow_symbol(input.c);
 515                         next_char();
 516                         break;
 517                 }
 518         }
 519
 520 end_of_string:
 521         /* add finishing 0 to the string */
 522         obstack_1grow(&symbol_obstack, '\0');
 523         const size_t size   = (size_t)obstack_object_size(&symbol_obstack);
 524         char *const  string = obstack_finish(&symbol_obstack);
 525
 526         pp_token.type    = TP_STRING_LITERAL;
 527         pp_token.literal = make_string(string, size);
 528 }
 529
 530 /**
 531  * Parse a wide string literal and set lexer_token.
 532  */
 533 static void parse_wide_string_literal(void)
 534 {
 535         parse_string_literal();
 536         if (pp_token.type == TP_STRING_LITERAL)
 537                 pp_token.type = TP_WIDE_STRING_LITERAL;
 538 }
 539
 540 static void parse_wide_character_constant(void)
 541 {
 542         eat('\'');
 543
 544         while (true) {
 545                 switch (input.c) {
 546                 case '\\': {
 547                         const utf32 tc = parse_escape_sequence();
 548                         grow_symbol(tc);
 549                         break;
 550                 }
 551
 552                 MATCH_NEWLINE(
 553                         parse_error("newline while parsing character constant");
 554                         break;
 555                 )
 556
 557                 case '\'':
 558                         next_char();
 559                         goto end_of_wide_char_constant;
 560
 561                 case EOF:
 562                         parse_error("EOF while parsing character constant");
 563                         pp_token.type = TP_ERROR;
 564                         return;
 565
 566                 default:
 567                         grow_symbol(input.c);
 568                         next_char();
 569                         break;
 570                 }
 571         }
 572
 573 end_of_wide_char_constant:
 574         obstack_1grow(&symbol_obstack, '\0');
 575         size_t  size = (size_t) obstack_object_size(&symbol_obstack)-1;
 576         char   *string = obstack_finish(&symbol_obstack);
 577         pp_token.type    = TP_WIDE_CHARACTER_CONSTANT;
 578         pp_token.literal = make_string(string, size);
 579
 580         if (size == 0) {
 581                 parse_error("empty character constant");
 582         }
 583 }
 584
 585 static void parse_character_constant(void)
 586 {
 587         const unsigned start_linenr = input.position.lineno;
 588
 589         eat('\'');
 590
 591         int tc;
 592         while (true) {
 593                 switch (input.c) {
 594                 case '\\':
 595                         tc = parse_escape_sequence();
 596                         obstack_1grow(&symbol_obstack, (char) tc);
 597                         break;
 598
 599                 MATCH_NEWLINE(
 600                         parse_error("newline while parsing character constant");
 601                         break;
 602                 )
 603
 604                 case EOF: {
 605                         source_position_t source_position;
 606                         source_position.input_name = pp_token.source_position.input_name;
 607                         source_position.lineno     = start_linenr;
 608                         errorf(&source_position, "EOF while parsing character constant");
 609                         pp_token.type = TP_ERROR;
 610                         return;
 611                 }
 612
 613                 case '\'':
 614                         next_char();
 615                         goto end_of_char_constant;
 616
 617                 default:
 618                         obstack_1grow(&symbol_obstack, (char) input.c);
 619                         next_char();
 620                         break;
 621
 622                 }
 623         }
 624
 625 end_of_char_constant:;
 626         const size_t      size   = (size_t)obstack_object_size(&symbol_obstack);
 627         const char *const string = obstack_finish(&symbol_obstack);
 628
 629         pp_token.type          = TP_CHARACTER_CONSTANT;
 630         pp_token.literal.begin = string;
 631         pp_token.literal.size  = size;
 632 }
 633
 634 #define SYMBOL_CHARS_WITHOUT_E_P \
 635         case 'a': \
 636         case 'b': \
 637         case 'c': \
 638         case 'd': \
 639         case 'f': \
 640         case 'g': \
 641         case 'h': \
 642         case 'i': \
 643         case 'j': \
 644         case 'k': \
 645         case 'l': \
 646         case 'm': \
 647         case 'n': \
 648         case 'o': \
 649         case 'q': \
 650         case 'r': \
 651         case 's': \
 652         case 't': \
 653         case 'u': \
 654         case 'v': \
 655         case 'w': \
 656         case 'x': \
 657         case 'y': \
 658         case 'z': \
 659         case 'A': \
 660         case 'B': \
 661         case 'C': \
 662         case 'D': \
 663         case 'F': \
 664         case 'G': \
 665         case 'H': \
 666         case 'I': \
 667         case 'J': \
 668         case 'K': \
 669         case 'L': \
 670         case 'M': \
 671         case 'N': \
 672         case 'O': \
 673         case 'Q': \
 674         case 'R': \
 675         case 'S': \
 676         case 'T': \
 677         case 'U': \
 678         case 'V': \
 679         case 'W': \
 680         case 'X': \
 681         case 'Y': \
 682         case 'Z': \
 683         case '_':
 684
 685 #define SYMBOL_CHARS \
 686         SYMBOL_CHARS_WITHOUT_E_P \
 687         case 'e': \
 688         case 'p': \
 689         case 'E': \
 690         case 'P':
 691
 692 #define DIGITS \
 693         case '0':  \
 694         case '1':  \
 695         case '2':  \
 696         case '3':  \
 697         case '4':  \
 698         case '5':  \
 699         case '6':  \
 700         case '7':  \
 701         case '8':  \
 702         case '9':
 703
 704 /**
 705  * returns next final token from a preprocessor macro expansion
 706  */
 707 static void expand_next(void)
 708 {
 709         assert(current_expansion != NULL);
 710
 711         pp_definition_t *definition = current_expansion;
 712
 713 restart:
 714         if (definition->list_len == 0
 715                         || definition->expand_pos >= definition->list_len) {
 716                 /* we're finished with the current macro, move up 1 level in the
 717                  * expansion stack */
 718                 pp_definition_t *parent = definition->parent_expansion;
 719                 definition->parent_expansion = NULL;
 720                 definition->is_expanding     = false;
 721
 722                 /* it was the outermost expansion, parse normal pptoken */
 723                 if (parent == NULL) {
 724                         current_expansion = NULL;
 725                         next_preprocessing_token();
 726                         return;
 727                 }
 728                 definition        = parent;
 729                 current_expansion = definition;
 730                 goto restart;
 731         }
 732         pp_token = definition->token_list[definition->expand_pos];
 733         pp_token.source_position = expansion_pos;
 734         ++definition->expand_pos;
 735
 736         if (pp_token.type != TP_IDENTIFIER)
 737                 return;
 738
 739         /* if it was an identifier then we might need to expand again */
 740         pp_definition_t *symbol_definition = pp_token.symbol->pp_definition;
 741         if (symbol_definition != NULL && !symbol_definition->is_expanding) {
 742                 symbol_definition->parent_expansion = definition;
 743                 symbol_definition->expand_pos       = 0;
 744                 symbol_definition->is_expanding     = true;
 745                 definition                          = symbol_definition;
 746                 current_expansion                   = definition;
 747                 goto restart;
 748         }
 749 }
 750
 751 static void skip_line_comment(void)
 752 {
 753         while (true) {
 754                 switch (input.c) {
 755                 case EOF:
 756                         return;
 757
 758                 case '\r':
 759                 case '\n':
 760                         return;
 761
 762                 default:
 763                         next_char();
 764                         break;
 765                 }
 766         }
 767 }
 768
 769 static void skip_multiline_comment(void)
 770 {
 771         unsigned start_linenr = input.position.lineno;
 772         while (true) {
 773                 switch (input.c) {
 774                 case '/':
 775                         next_char();
 776                         if (input.c == '*') {
 777                                 /* TODO: nested comment, warn here */
 778                         }
 779                         break;
 780                 case '*':
 781                         next_char();
 782                         if (input.c == '/') {
 783                                 next_char();
 784                                 info.whitespace += input.position.colno-1;
 785                                 return;
 786                         }
 787                         break;
 788
 789                 MATCH_NEWLINE(
 790                         info.at_line_begin |= !in_pp_directive;
 791                         break;
 792                 )
 793
 794                 case EOF: {
 795                         source_position_t source_position;
 796                         source_position.input_name = pp_token.source_position.input_name;
 797                         source_position.lineno     = start_linenr;
 798                         errorf(&source_position, "at end of file while looking for comment end");
 799                         return;
 800                 }
 801
 802                 default:
 803                         next_char();
 804                         break;
 805                 }
 806         }
 807 }
 808
 809 static void skip_whitespace(void)
 810 {
 811         while (true) {
 812                 switch (input.c) {
 813                 case ' ':
 814                 case '\t':
 815                         next_char();
 816                         continue;
 817
 818                 MATCH_NEWLINE(
 819                         info.at_line_begin = true;
 820                         return;
 821                 )
 822
 823                 case '/':
 824                         next_char();
 825                         if (input.c == '/') {
 826                                 next_char();
 827                                 skip_line_comment();
 828                                 continue;
 829                         } else if (input.c == '*') {
 830                                 next_char();
 831                                 skip_multiline_comment();
 832                                 continue;
 833                         } else {
 834                                 put_back(input.c);
 835                                 input.c = '/';
 836                         }
 837                         return;
 838                 default:
 839                         return;
 840                 }
 841         }
 842 }
 843
 844 static void eat_pp(int type)
 845 {
 846         (void) type;
 847         assert(pp_token.type == type);
 848         next_preprocessing_token();
 849 }
 850
 851 static void parse_symbol(void)
 852 {
 853         obstack_1grow(&symbol_obstack, (char) input.c);
 854         next_char();
 855
 856         while (true) {
 857                 switch (input.c) {
 858                 DIGITS
 859                 SYMBOL_CHARS
 860                         obstack_1grow(&symbol_obstack, (char) input.c);
 861                         next_char();
 862                         break;
 863
 864                 default:
 865                         goto end_symbol;
 866                 }
 867         }
 868
 869 end_symbol:
 870         obstack_1grow(&symbol_obstack, '\0');
 871         char *string = obstack_finish(&symbol_obstack);
 872
 873         /* might be a wide string or character constant ( L"string"/L'c' ) */
 874         if (input.c == '"' && string[0] == 'L' && string[1] == '\0') {
 875                 obstack_free(&symbol_obstack, string);
 876                 parse_wide_string_literal();
 877                 return;
 878         } else if (input.c == '\'' && string[0] == 'L' && string[1] == '\0') {
 879                 obstack_free(&symbol_obstack, string);
 880                 parse_wide_character_constant();
 881                 return;
 882         }
 883
 884         symbol_t *symbol = symbol_table_insert(string);
 885
 886         pp_token.type   = symbol->pp_ID;
 887         pp_token.symbol = symbol;
 888
 889         /* we can free the memory from symbol obstack if we already had an entry in
 890          * the symbol table */
 891         if (symbol->string != string) {
 892                 obstack_free(&symbol_obstack, string);
 893         }
 894 }
 895
 896 static void parse_number(void)
 897 {
 898         obstack_1grow(&symbol_obstack, (char) input.c);
 899         next_char();
 900
 901         while (true) {
 902                 switch (input.c) {
 903                 case '.':
 904                 DIGITS
 905                 SYMBOL_CHARS_WITHOUT_E_P
 906                         obstack_1grow(&symbol_obstack, (char) input.c);
 907                         next_char();
 908                         break;
 909
 910                 case 'e':
 911                 case 'p':
 912                 case 'E':
 913                 case 'P':
 914                         obstack_1grow(&symbol_obstack, (char) input.c);
 915                         next_char();
 916                         if (input.c == '+' || input.c == '-') {
 917                                 obstack_1grow(&symbol_obstack, (char) input.c);
 918                                 next_char();
 919                         }
 920                         break;
 921
 922                 default:
 923                         goto end_number;
 924                 }
 925         }
 926
 927 end_number:
 928         obstack_1grow(&symbol_obstack, '\0');
 929         size_t  size   = obstack_object_size(&symbol_obstack);
 930         char   *string = obstack_finish(&symbol_obstack);
 931
 932         pp_token.type          = TP_NUMBER;
 933         pp_token.literal.begin = string;
 934         pp_token.literal.size  = size;
 935 }
 936
 937
 938 #define MAYBE_PROLOG                                       \
 939                         next_char();                                   \
 940                         while (true) {                                 \
 941                                 switch (input.c) {
 942
 943 #define MAYBE(ch, set_type)                                \
 944                                 case ch:                                   \
 945                                         next_char();                           \
 946                                         pp_token.type = set_type;              \
 947                                         return;
 948
 949 #define ELSE_CODE(code)                                    \
 950                                 default:                                   \
 951                                         code                                   \
 952                                         return;                                \
 953                                 }                                          \
 954                         }
 955
 956 #define ELSE(set_type)                                     \
 957                 ELSE_CODE(                                         \
 958                         pp_token.type = set_type;                      \
 959                 )
 960
 961 static void next_preprocessing_token(void)
 962 {
 963         if (current_expansion != NULL) {
 964                 expand_next();
 965                 return;
 966         }
 967
 968         info.at_line_begin  = false;
 969         info.had_whitespace = false;
 970 restart:
 971         pp_token.source_position = input.position;
 972         switch (input.c) {
 973         case ' ':
 974         case '\t':
 975                 ++info.whitespace;
 976                 info.had_whitespace = true;
 977                 next_char();
 978                 goto restart;
 979
 980         MATCH_NEWLINE(
 981                 info.at_line_begin = true;
 982                 info.had_whitespace = true;
 983                 goto restart;
 984         )
 985
 986         SYMBOL_CHARS
 987                 parse_symbol();
 988                 return;
 989
 990         DIGITS
 991                 parse_number();
 992                 return;
 993
 994         case '"':
 995                 parse_string_literal();
 996                 return;
 997
 998         case '\'':
 999                 parse_character_constant();
1000                 return;
1001
1002         case '.':
1003                 MAYBE_PROLOG
1004                         case '0':
1005                         case '1':
1006                         case '2':
1007                         case '3':
1008                         case '4':
1009                         case '5':
1010                         case '6':
1011                         case '7':
1012                         case '8':
1013                         case '9':
1014                                 put_back(input.c);
1015                                 input.c = '.';
1016                                 parse_number();
1017                                 return;
1018
1019                         case '.':
1020                                 MAYBE_PROLOG
1021                                 MAYBE('.', TP_DOTDOTDOT)
1022                                 ELSE_CODE(
1023                                         put_back(input.c);
1024                                         input.c = '.';
1025                                         pp_token.type = '.';
1026                                 )
1027                 ELSE('.')
1028         case '&':
1029                 MAYBE_PROLOG
1030                 MAYBE('&', TP_ANDAND)
1031                 MAYBE('=', TP_ANDEQUAL)
1032                 ELSE('&')
1033         case '*':
1034                 MAYBE_PROLOG
1035                 MAYBE('=', TP_ASTERISKEQUAL)
1036                 ELSE('*')
1037         case '+':
1038                 MAYBE_PROLOG
1039                 MAYBE('+', TP_PLUSPLUS)
1040                 MAYBE('=', TP_PLUSEQUAL)
1041                 ELSE('+')
1042         case '-':
1043                 MAYBE_PROLOG
1044                 MAYBE('>', TP_MINUSGREATER)
1045                 MAYBE('-', TP_MINUSMINUS)
1046                 MAYBE('=', TP_MINUSEQUAL)
1047                 ELSE('-')
1048         case '!':
1049                 MAYBE_PROLOG
1050                 MAYBE('=', TP_EXCLAMATIONMARKEQUAL)
1051                 ELSE('!')
1052         case '/':
1053                 MAYBE_PROLOG
1054                 MAYBE('=', TP_SLASHEQUAL)
1055                         case '*':
1056                                 next_char();
1057                                 info.had_whitespace = true;
1058                                 skip_multiline_comment();
1059                                 goto restart;
1060                         case '/':
1061                                 next_char();
1062                                 info.had_whitespace = true;
1063                                 skip_line_comment();
1064                                 goto restart;
1065                 ELSE('/')
1066         case '%':
1067                 MAYBE_PROLOG
1068                 MAYBE('>', '}')
1069                 MAYBE('=', TP_PERCENTEQUAL)
1070                         case ':':
1071                                 MAYBE_PROLOG
1072                                         case '%':
1073                                                 MAYBE_PROLOG
1074                                                 MAYBE(':', TP_HASHHASH)
1075                                                 ELSE_CODE(
1076                                                         put_back(input.c);
1077                                                         input.c = '%';
1078                                                         pp_token.type = '#';
1079                                                 )
1080                                 ELSE('#')
1081                 ELSE('%')
1082         case '<':
1083                 MAYBE_PROLOG
1084                 MAYBE(':', '[')
1085                 MAYBE('%', '{')
1086                 MAYBE('=', TP_LESSEQUAL)
1087                         case '<':
1088                                 MAYBE_PROLOG
1089                                 MAYBE('=', TP_LESSLESSEQUAL)
1090                                 ELSE(TP_LESSLESS)
1091                 ELSE('<')
1092         case '>':
1093                 MAYBE_PROLOG
1094                 MAYBE('=', TP_GREATEREQUAL)
1095                         case '>':
1096                                 MAYBE_PROLOG
1097                                 MAYBE('=', TP_GREATERGREATEREQUAL)
1098                                 ELSE(TP_GREATERGREATER)
1099                 ELSE('>')
1100         case '^':
1101                 MAYBE_PROLOG
1102                 MAYBE('=', TP_CARETEQUAL)
1103                 ELSE('^')
1104         case '|':
1105                 MAYBE_PROLOG
1106                 MAYBE('=', TP_PIPEEQUAL)
1107                 MAYBE('|', TP_PIPEPIPE)
1108                 ELSE('|')
1109         case ':':
1110                 MAYBE_PROLOG
1111                 MAYBE('>', ']')
1112                 ELSE(':')
1113         case '=':
1114                 MAYBE_PROLOG
1115                 MAYBE('=', TP_EQUALEQUAL)
1116                 ELSE('=')
1117         case '#':
1118                 MAYBE_PROLOG
1119                 MAYBE('#', TP_HASHHASH)
1120                 ELSE_CODE(
1121                         pp_token.type = '#';
1122                 )
1123
1124         case '?':
1125         case '[':
1126         case ']':
1127         case '(':
1128         case ')':
1129         case '{':
1130         case '}':
1131         case '~':
1132         case ';':
1133         case ',':
1134         case '\\':
1135                 pp_token.type = input.c;
1136                 next_char();
1137                 return;
1138
1139         case EOF:
1140                 if (input_stack != NULL) {
1141                         close_input();
1142                         pop_restore_input();
1143                         fputc('\n', out);
1144                         print_line_directive(&input.position, "2");
1145                         goto restart;
1146                 } else {
1147                         pp_token.source_position.lineno++;
1148                         info.at_line_begin = true;
1149                         pp_token.type = TP_EOF;
1150                 }
1151                 return;
1152
1153         default:
1154                 next_char();
1155                 if (!ignore_unknown_chars) {
1156                         errorf(&pp_token.source_position, "unknown character '%c' found\n",
1157                                input.c);
1158                         pp_token.type = TP_ERROR;
1159                 } else {
1160                         pp_token.type = input.c;
1161                 }
1162                 return;
1163         }
1164 }
1165
1166 static void print_quoted_string(const char *const string)
1167 {
1168         fputc('"', out);
1169         for (const char *c = string; *c != 0; ++c) {
1170                 switch (*c) {
1171                 case '"': fputs("\\\"", out); break;
1172                 case '\\':  fputs("\\\\", out); break;
1173                 case '\a':  fputs("\\a", out); break;
1174                 case '\b':  fputs("\\b", out); break;
1175                 case '\f':  fputs("\\f", out); break;
1176                 case '\n':  fputs("\\n", out); break;
1177                 case '\r':  fputs("\\r", out); break;
1178                 case '\t':  fputs("\\t", out); break;
1179                 case '\v':  fputs("\\v", out); break;
1180                 case '\?':  fputs("\\?", out); break;
1181                 default:
1182                         if (!isprint(*c)) {
1183                                 fprintf(out, "\\%03o", (unsigned)*c);
1184                                 break;
1185                         }
1186                         fputc(*c, out);
1187                         break;
1188                 }
1189         }
1190         fputc('"', out);
1191 }
1192
1193 static void print_line_directive(const source_position_t *pos, const char *add)
1194 {
1195         fprintf(out, "# %u ", pos->lineno);
1196         print_quoted_string(pos->input_name);
1197         if (add != NULL) {
1198                 fputc(' ', out);
1199                 fputs(add, out);
1200         }
1201
1202         printed_input_name = pos->input_name;
1203         input.output_line  = pos->lineno-1;
1204 }
1205
1206 static void emit_newlines(void)
1207 {
1208         unsigned delta = pp_token.source_position.lineno - input.output_line;
1209
1210         if (delta >= 9) {
1211                 fputc('\n', out);
1212                 print_line_directive(&pp_token.source_position, NULL);
1213                 fputc('\n', out);
1214         } else {
1215                 for (unsigned i = 0; i < delta; ++i) {
1216                         fputc('\n', out);
1217                 }
1218         }
1219         input.output_line = pp_token.source_position.lineno;
1220 }
1221
1222 static void emit_pp_token(void)
1223 {
1224         if (skip_mode)
1225                 return;
1226
1227         if (info.at_line_begin) {
1228                 emit_newlines();
1229
1230                 for (unsigned i = 0; i < info.whitespace; ++i)
1231                         fputc(' ', out);
1232
1233         } else if (info.had_whitespace ||
1234                            tokens_would_paste(last_token, pp_token.type)) {
1235                 fputc(' ', out);
1236         }
1237
1238         switch (pp_token.type) {
1239         case TP_IDENTIFIER:
1240                 fputs(pp_token.symbol->string, out);
1241                 break;
1242         case TP_NUMBER:
1243                 fputs(pp_token.literal.begin, out);
1244                 break;
1245         case TP_WIDE_STRING_LITERAL:
1246                 fputc('L', out);
1247         case TP_STRING_LITERAL:
1248                 fputc('"', out);
1249                 fputs(pp_token.literal.begin, out);
1250                 fputc('"', out);
1251                 break;
1252         case TP_WIDE_CHARACTER_CONSTANT:
1253                 fputc('L', out);
1254         case TP_CHARACTER_CONSTANT:
1255                 fputc('\'', out);
1256                 fputs(pp_token.literal.begin, out);
1257                 fputc('\'', out);
1258                 break;
1259         default:
1260                 print_pp_token_type(out, pp_token.type);
1261                 break;
1262         }
1263         last_token = pp_token.type;
1264 }
1265
1266 static void eat_pp_directive(void)
1267 {
1268         while (!info.at_line_begin) {
1269                 next_preprocessing_token();
1270         }
1271 }
1272
1273 static bool strings_equal(const string_t *string1, const string_t *string2)
1274 {
1275         size_t size = string1->size;
1276         if (size != string2->size)
1277                 return false;
1278
1279         const char *c1 = string1->begin;
1280         const char *c2 = string2->begin;
1281         for (size_t i = 0; i < size; ++i, ++c1, ++c2) {
1282                 if (*c1 != *c2)
1283                         return false;
1284         }
1285         return true;
1286 }
1287
1288 static bool pp_tokens_equal(const token_t *token1, const token_t *token2)
1289 {
1290         if (token1->type != token2->type)
1291                 return false;
1292
1293         switch (token1->type) {
1294         case TP_HEADERNAME:
1295                 /* TODO */
1296                 return false;
1297         case TP_IDENTIFIER:
1298                 return token1->symbol == token2->symbol;
1299         case TP_NUMBER:
1300         case TP_CHARACTER_CONSTANT:
1301         case TP_STRING_LITERAL:
1302                 return strings_equal(&token1->literal, &token2->literal);
1303
1304         default:
1305                 return true;
1306         }
1307 }
1308
1309 static bool pp_definitions_equal(const pp_definition_t *definition1,
1310                                  const pp_definition_t *definition2)
1311 {
1312         if (definition1->list_len != definition2->list_len)
1313                 return false;
1314
1315         size_t         len = definition1->list_len;
1316         const token_t *t1  = definition1->token_list;
1317         const token_t *t2  = definition2->token_list;
1318         for (size_t i = 0; i < len; ++i, ++t1, ++t2) {
1319                 if (!pp_tokens_equal(t1, t2))
1320                         return false;
1321         }
1322         return true;
1323 }
1324
1325 static void parse_define_directive(void)
1326 {
1327         eat_pp(TP_define);
1328         assert(obstack_object_size(&pp_obstack) == 0);
1329
1330         if (pp_token.type != TP_IDENTIFIER || info.at_line_begin) {
1331                 errorf(&pp_token.source_position,
1332                        "expected identifier after #define, got '%t'", &pp_token);
1333                 goto error_out;
1334         }
1335         symbol_t *symbol = pp_token.symbol;
1336
1337         pp_definition_t *new_definition
1338                 = obstack_alloc(&pp_obstack, sizeof(new_definition[0]));
1339         memset(new_definition, 0, sizeof(new_definition[0]));
1340         new_definition->source_position = input.position;
1341
1342         /* this is probably the only place where spaces are significant in the
1343          * lexer (except for the fact that they separate tokens). #define b(x)
1344          * is something else than #define b (x) */
1345         if (input.c == '(') {
1346                 /* eat the '(' */
1347                 next_preprocessing_token();
1348                 /* get next token after '(' */
1349                 next_preprocessing_token();
1350
1351                 while (true) {
1352                         switch (pp_token.type) {
1353                         case TP_DOTDOTDOT:
1354                                 new_definition->is_variadic = true;
1355                                 next_preprocessing_token();
1356                                 if (pp_token.type != ')') {
1357                                         errorf(&input.position,
1358                                                         "'...' not at end of macro argument list");
1359                                         goto error_out;
1360                                 }
1361                                 break;
1362                         case TP_IDENTIFIER:
1363                                 obstack_ptr_grow(&pp_obstack, pp_token.symbol);
1364                                 next_preprocessing_token();
1365
1366                                 if (pp_token.type == ',') {
1367                                         next_preprocessing_token();
1368                                         break;
1369                                 }
1370
1371                                 if (pp_token.type != ')') {
1372                                         errorf(&pp_token.source_position,
1373                                                "expected ',' or ')' after identifier, got '%t'",
1374                                                &pp_token);
1375                                         goto error_out;
1376                                 }
1377                                 break;
1378                         case ')':
1379                                 next_preprocessing_token();
1380                                 goto finish_argument_list;
1381                         default:
1382                                 errorf(&pp_token.source_position,
1383                                        "expected identifier, '...' or ')' in #define argument list, got '%t'",
1384                                        &pp_token);
1385                                 goto error_out;
1386                         }
1387                 }
1388
1389         finish_argument_list:
1390                 new_definition->has_parameters = true;
1391                 new_definition->n_parameters
1392                         = obstack_object_size(&pp_obstack) / sizeof(new_definition->parameters[0]);
1393                 new_definition->parameters = obstack_finish(&pp_obstack);
1394         } else {
1395                 next_preprocessing_token();
1396         }
1397
1398         /* construct a new pp_definition on the obstack */
1399         assert(obstack_object_size(&pp_obstack) == 0);
1400         size_t list_len = 0;
1401         while (!info.at_line_begin) {
1402                 obstack_grow(&pp_obstack, &pp_token, sizeof(pp_token));
1403                 ++list_len;
1404                 next_preprocessing_token();
1405         }
1406
1407         new_definition->list_len   = list_len;
1408         new_definition->token_list = obstack_finish(&pp_obstack);
1409
1410         pp_definition_t *old_definition = symbol->pp_definition;
1411         if (old_definition != NULL) {
1412                 if (!pp_definitions_equal(old_definition, new_definition)) {
1413                         warningf(WARN_OTHER, &input.position, "multiple definition of macro '%Y' (first defined %P)", symbol, &old_definition->source_position);
1414                 } else {
1415                         /* reuse the old definition */
1416                         obstack_free(&pp_obstack, new_definition);
1417                         new_definition = old_definition;
1418                 }
1419         }
1420
1421         symbol->pp_definition = new_definition;
1422         return;
1423
1424 error_out:
1425         if (obstack_object_size(&pp_obstack) > 0) {
1426                 char *ptr = obstack_finish(&pp_obstack);
1427                 obstack_free(&pp_obstack, ptr);
1428         }
1429         eat_pp_directive();
1430 }
1431
1432 static void parse_undef_directive(void)
1433 {
1434         eat_pp(TP_undef);
1435
1436         if (pp_token.type != TP_IDENTIFIER) {
1437                 errorf(&input.position,
1438                        "expected identifier after #undef, got '%t'", &pp_token);
1439                 eat_pp_directive();
1440                 return;
1441         }
1442
1443         symbol_t *symbol = pp_token.symbol;
1444         symbol->pp_definition = NULL;
1445         next_preprocessing_token();
1446
1447         if (!info.at_line_begin) {
1448                 warningf(WARN_OTHER, &input.position, "extra tokens at end of #undef directive");
1449         }
1450         eat_pp_directive();
1451 }
1452
1453 static const char *parse_headername(void)
1454 {
1455         /* behind an #include we can have the special headername lexems.
1456          * They're only allowed behind an #include so they're not recognized
1457          * by the normal next_preprocessing_token. We handle them as a special
1458          * exception here */
1459         if (info.at_line_begin) {
1460                 parse_error("expected headername after #include");
1461                 return NULL;
1462         }
1463
1464         assert(obstack_object_size(&symbol_obstack) == 0);
1465
1466         /* check wether we have a "... or <... headername */
1467         switch (input.c) {
1468         case '<':
1469                 next_char();
1470                 while (true) {
1471                         switch (input.c) {
1472                         case EOF:
1473                                 /* fallthrough */
1474                         MATCH_NEWLINE(
1475                                 parse_error("header name without closing '>'");
1476                                 return NULL;
1477                         )
1478                         case '>':
1479                                 next_char();
1480                                 goto finished_headername;
1481                         }
1482                         obstack_1grow(&symbol_obstack, (char) input.c);
1483                         next_char();
1484                 }
1485                 /* we should never be here */
1486
1487         case '"':
1488                 next_char();
1489                 while (true) {
1490                         switch (input.c) {
1491                         case EOF:
1492                                 /* fallthrough */
1493                         MATCH_NEWLINE(
1494                                 parse_error("header name without closing '>'");
1495                                 return NULL;
1496                         )
1497                         case '"':
1498                                 next_char();
1499                                 goto finished_headername;
1500                         }
1501                         obstack_1grow(&symbol_obstack, (char) input.c);
1502                         next_char();
1503                 }
1504                 /* we should never be here */
1505
1506         default:
1507                 /* TODO: do normal pp_token parsing and concatenate results */
1508                 panic("pp_token concat include not implemented yet");
1509         }
1510
1511 finished_headername:
1512         obstack_1grow(&symbol_obstack, '\0');
1513         char *headername = obstack_finish(&symbol_obstack);
1514
1515         /* TODO: iterate search-path to find the file */
1516
1517         skip_whitespace();
1518
1519         return identify_string(headername);
1520 }
1521
1522 static bool do_include(bool system_include, const char *headername)
1523 {
1524         if (!system_include) {
1525                 /* for "bla" includes first try current dir
1526                  * TODO: this isn't correct, should be the directory of the source file
1527                  */
1528                 FILE *file = fopen(headername, "r");
1529                 if (file != NULL) {
1530                         switch_input(file, headername);
1531                         return true;
1532                 }
1533         }
1534
1535         size_t headername_len = strlen(headername);
1536         assert(obstack_object_size(&pp_obstack) == 0);
1537         /* check searchpath */
1538         for (searchpath_entry_t *entry = searchpath; entry != NULL;
1539              entry = entry->next) {
1540             const char *path = entry->path;
1541             size_t      len  = strlen(path);
1542                 obstack_grow(&pp_obstack, path, len);
1543                 if (path[len-1] != '/')
1544                         obstack_1grow(&pp_obstack, '/');
1545                 obstack_grow(&pp_obstack, headername, headername_len+1);
1546
1547                 char *complete_path = obstack_finish(&pp_obstack);
1548                 FILE *file          = fopen(complete_path, "r");
1549                 if (file != NULL) {
1550                         const char *filename = identify_string(complete_path);
1551                         switch_input(file, filename);
1552                         return true;
1553                 }
1554                 obstack_free(&pp_obstack, complete_path);
1555         }
1556
1557         return false;
1558 }
1559
1560 static bool parse_include_directive(void)
1561 {
1562         /* don't eat the TP_include here!
1563          * we need an alternative parsing for the next token */
1564         skip_whitespace();
1565         bool system_include = input.c == '<';
1566         const char *headername = parse_headername();
1567         if (headername == NULL) {
1568                 eat_pp_directive();
1569                 return false;
1570         }
1571
1572         if (!info.at_line_begin) {
1573                 warningf(WARN_OTHER, &pp_token.source_position, "extra tokens at end of #include directive");
1574                 eat_pp_directive();
1575         }
1576
1577         if (n_inputs > INCLUDE_LIMIT) {
1578                 errorf(&pp_token.source_position, "#include nested too deeply");
1579                 /* eat \n or EOF */
1580                 next_preprocessing_token();
1581                 return false;
1582         }
1583
1584         /* we have to reenable space counting and macro expansion here,
1585          * because it is still disabled in directive parsing,
1586          * but we will trigger a preprocessing token reading of the new file
1587          * now and need expansions/space counting */
1588         in_pp_directive = false;
1589
1590         /* switch inputs */
1591         emit_newlines();
1592         push_input();
1593         bool res = do_include(system_include, headername);
1594         if (!res) {
1595                 errorf(&pp_token.source_position,
1596                        "failed including '%s': %s", headername, strerror(errno));
1597                 pop_restore_input();
1598                 return false;
1599         }
1600
1601         return true;
1602 }
1603
1604 static pp_conditional_t *push_conditional(void)
1605 {
1606         pp_conditional_t *conditional
1607                 = obstack_alloc(&pp_obstack, sizeof(*conditional));
1608         memset(conditional, 0, sizeof(*conditional));
1609
1610         conditional->parent = conditional_stack;
1611         conditional_stack   = conditional;
1612
1613         return conditional;
1614 }
1615
1616 static void pop_conditional(void)
1617 {
1618         assert(conditional_stack != NULL);
1619         conditional_stack = conditional_stack->parent;
1620 }
1621
1622 static void check_unclosed_conditionals(void)
1623 {
1624         while (conditional_stack != NULL) {
1625                 pp_conditional_t *conditional = conditional_stack;
1626
1627                 if (conditional->in_else) {
1628                         errorf(&conditional->source_position, "unterminated #else");
1629                 } else {
1630                         errorf(&conditional->source_position, "unterminated condition");
1631                 }
1632                 pop_conditional();
1633         }
1634 }
1635
1636 static void parse_ifdef_ifndef_directive(void)
1637 {
1638         bool is_ifndef = (pp_token.type == TP_ifndef);
1639         bool condition;
1640         next_preprocessing_token();
1641
1642         if (skip_mode) {
1643                 eat_pp_directive();
1644                 pp_conditional_t *conditional = push_conditional();
1645                 conditional->source_position  = pp_token.source_position;
1646                 conditional->skip             = true;
1647                 return;
1648         }
1649
1650         if (pp_token.type != TP_IDENTIFIER || info.at_line_begin) {
1651                 errorf(&pp_token.source_position,
1652                        "expected identifier after #%s, got '%t'",
1653                        is_ifndef ? "ifndef" : "ifdef", &pp_token);
1654                 eat_pp_directive();
1655
1656                 /* just take the true case in the hope to avoid further errors */
1657                 condition = true;
1658         } else {
1659                 symbol_t        *symbol        = pp_token.symbol;
1660                 pp_definition_t *pp_definition = symbol->pp_definition;
1661                 next_preprocessing_token();
1662
1663                 if (!info.at_line_begin) {
1664                         errorf(&pp_token.source_position,
1665                                "extra tokens at end of #%s",
1666                                is_ifndef ? "ifndef" : "ifdef");
1667                         eat_pp_directive();
1668                 }
1669
1670                 /* evaluate wether we are in true or false case */
1671                 condition = is_ifndef ? pp_definition == NULL : pp_definition != NULL;
1672         }
1673
1674         pp_conditional_t *conditional = push_conditional();
1675         conditional->source_position  = pp_token.source_position;
1676         conditional->condition        = condition;
1677
1678         if (!condition) {
1679                 skip_mode = true;
1680         }
1681 }
1682
1683 static void parse_else_directive(void)
1684 {
1685         eat_pp(TP_else);
1686
1687         if (!info.at_line_begin) {
1688                 if (!skip_mode) {
1689                         warningf(WARN_OTHER, &pp_token.source_position, "extra tokens at end of #else");
1690                 }
1691                 eat_pp_directive();
1692         }
1693
1694         pp_conditional_t *conditional = conditional_stack;
1695         if (conditional == NULL) {
1696                 errorf(&pp_token.source_position, "#else without prior #if");
1697                 return;
1698         }
1699
1700         if (conditional->in_else) {
1701                 errorf(&pp_token.source_position,
1702                        "#else after #else (condition started %P)",
1703                        conditional->source_position);
1704                 skip_mode = true;
1705                 return;
1706         }
1707
1708         conditional->in_else = true;
1709         if (!conditional->skip) {
1710                 skip_mode = conditional->condition;
1711         }
1712         conditional->source_position = pp_token.source_position;
1713 }
1714
1715 static void parse_endif_directive(void)
1716 {
1717         eat_pp(TP_endif);
1718
1719         if (!info.at_line_begin) {
1720                 if (!skip_mode) {
1721                         warningf(WARN_OTHER, &pp_token.source_position, "extra tokens at end of #endif");
1722                 }
1723                 eat_pp_directive();
1724         }
1725
1726         pp_conditional_t *conditional = conditional_stack;
1727         if (conditional == NULL) {
1728                 errorf(&pp_token.source_position, "#endif without prior #if");
1729                 return;
1730         }
1731
1732         if (!conditional->skip) {
1733                 skip_mode = false;
1734         }
1735         pop_conditional();
1736 }
1737
1738 static void parse_preprocessing_directive(void)
1739 {
1740         in_pp_directive = true;
1741         eat_pp('#');
1742
1743         if (skip_mode) {
1744                 switch (pp_token.type) {
1745                 case TP_ifdef:
1746                 case TP_ifndef:
1747                         parse_ifdef_ifndef_directive();
1748                         break;
1749                 case TP_else:
1750                         parse_else_directive();
1751                         break;
1752                 case TP_endif:
1753                         parse_endif_directive();
1754                         break;
1755                 default:
1756                         eat_pp_directive();
1757                         break;
1758                 }
1759         } else {
1760                 switch (pp_token.type) {
1761                 case TP_define:
1762                         parse_define_directive();
1763                         break;
1764                 case TP_undef:
1765                         parse_undef_directive();
1766                         break;
1767                 case TP_ifdef:
1768                 case TP_ifndef:
1769                         parse_ifdef_ifndef_directive();
1770                         break;
1771                 case TP_else:
1772                         parse_else_directive();
1773                         break;
1774                 case TP_endif:
1775                         parse_endif_directive();
1776                         break;
1777                 case TP_include:
1778                         parse_include_directive();
1779                         break;
1780                 default:
1781                         if (info.at_line_begin) {
1782                                 /* the nop directive "#" */
1783                                 break;
1784                         }
1785                         errorf(&pp_token.source_position,
1786                                    "invalid preprocessing directive #%t", &pp_token);
1787                         eat_pp_directive();
1788                         break;
1789                 }
1790         }
1791
1792         in_pp_directive = false;
1793         assert(info.at_line_begin);
1794 }
1795
1796 static void prepend_include_path(const char *path)
1797 {
1798         searchpath_entry_t *entry = OALLOCZ(&config_obstack, searchpath_entry_t);
1799         entry->path = path;
1800         entry->next = searchpath;
1801         searchpath  = entry;
1802 }
1803
1804 static void setup_include_path(void)
1805 {
1806         /* built-in paths */
1807         prepend_include_path("/usr/include");
1808
1809         /* parse environment variable */
1810         const char *cpath = getenv("CPATH");
1811         if (cpath != NULL && *cpath != '\0') {
1812                 const char *begin = cpath;
1813                 const char *c;
1814                 do {
1815                         c = begin;
1816                         while (*c != '\0' && *c != ':')
1817                                 ++c;
1818
1819                         size_t len = c-begin;
1820                         if (len == 0) {
1821                                 /* for gcc compatibility (Matze: I would expect that
1822                                  * nothing happens for an empty entry...) */
1823                                 prepend_include_path(".");
1824                         } else {
1825                                 char *string = obstack_alloc(&config_obstack, len+1);
1826                                 memcpy(string, begin, len);
1827                                 string[len] = '\0';
1828
1829                                 prepend_include_path(string);
1830                         }
1831
1832                         begin = c+1;
1833                         /* skip : */
1834                         if (*begin == ':')
1835                                 ++begin;
1836                 } while(*c != '\0');
1837         }
1838 }
1839
1840 int pptest_main(int argc, char **argv);
1841 int pptest_main(int argc, char **argv)
1842 {
1843         init_symbol_table();
1844         init_tokens();
1845
1846         obstack_init(&config_obstack);
1847         obstack_init(&pp_obstack);
1848         obstack_init(&input_obstack);
1849         strset_init(&stringset);
1850
1851         setup_include_path();
1852
1853         /* simplistic commandline parser */
1854         const char *filename = NULL;
1855         for (int i = 1; i < argc; ++i) {
1856                 const char *opt = argv[i];
1857                 if (streq(opt, "-I")) {
1858                         prepend_include_path(argv[++i]);
1859                         continue;
1860                 } else if (streq(opt, "-E")) {
1861                         /* ignore */
1862                 } else if (opt[0] == '-') {
1863                         fprintf(stderr, "Unknown option '%s'\n", opt);
1864                 } else {
1865                         if (filename != NULL)
1866                                 fprintf(stderr, "Multiple inputs not supported\n");
1867                         filename = argv[i];
1868                 }
1869         }
1870         if (filename == NULL) {
1871                 fprintf(stderr, "No input specified\n");
1872                 return 1;
1873         }
1874
1875         out = stdout;
1876
1877         /* just here for gcc compatibility */
1878         fprintf(out, "# 1 \"%s\"\n", filename);
1879         fprintf(out, "# 1 \"<built-in>\"\n");
1880         fprintf(out, "# 1 \"<command-line>\"\n");
1881
1882         FILE *file = fopen(filename, "r");
1883         if (file == NULL) {
1884                 fprintf(stderr, "Couldn't open input '%s'\n", filename);
1885                 return 1;
1886         }
1887         switch_input(file, filename);
1888
1889         while (true) {
1890                 if (pp_token.type == '#' && info.at_line_begin) {
1891                         parse_preprocessing_directive();
1892                         continue;
1893                 } else if (pp_token.type == TP_EOF) {
1894                         goto end_of_main_loop;
1895                 } else if (pp_token.type == TP_IDENTIFIER && !in_pp_directive) {
1896                         symbol_t *symbol = pp_token.symbol;
1897                         pp_definition_t *pp_definition = symbol->pp_definition;
1898                         if (pp_definition != NULL && !pp_definition->is_expanding) {
1899                                 expansion_pos = pp_token.source_position;
1900                                 if (pp_definition->has_parameters) {
1901                                         source_position_t position = pp_token.source_position;
1902                                         add_token_info_t old_info = info;
1903                                         next_preprocessing_token();
1904                                         add_token_info_t new_info = info;
1905
1906                                         /* no opening brace -> no expansion */
1907                                         if (pp_token.type == '(') {
1908                                                 eat_pp('(');
1909
1910                                                 /* parse arguments (TODO) */
1911                                                 while (pp_token.type != TP_EOF && pp_token.type != ')')
1912                                                         next_preprocessing_token();
1913                                         } else {
1914                                                 token_t next_token = pp_token;
1915                                                 /* restore identifier token */
1916                                                 pp_token.type            = TP_IDENTIFIER;
1917                                                 pp_token.symbol          = symbol;
1918                                                 pp_token.source_position = position;
1919                                                 info = old_info;
1920                                                 emit_pp_token();
1921
1922                                                 info = new_info;
1923                                                 pp_token = next_token;
1924                                                 continue;
1925                                         }
1926                                         info = old_info;
1927                                 }
1928                                 pp_definition->expand_pos   = 0;
1929                                 pp_definition->is_expanding = true;
1930                                 current_expansion           = pp_definition;
1931                                 expand_next();
1932                                 continue;
1933                         }
1934                 }
1935
1936                 emit_pp_token();
1937                 next_preprocessing_token();
1938         }
1939 end_of_main_loop:
1940
1941         fputc('\n', out);
1942         check_unclosed_conditionals();
1943         close_input();
1944
1945         obstack_free(&input_obstack, NULL);
1946         obstack_free(&pp_obstack, NULL);
1947         obstack_free(&config_obstack, NULL);
1948
1949         strset_destroy(&stringset);
1950
1951         exit_tokens();
1952         exit_symbol_table();
1953
1954         return 0;
1955 }