1 /* CPP Library. 2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 4 2009, 2010, 2011 Free Software Foundation, Inc. 5 Contributed by Per Bothner, 1994-95. 6 Based on CCCP program by Paul Rubin, June 1986 7 Adapted to ANSI C, Richard Stallman, Jan 1987 8 9 This program is free software; you can redistribute it and/or modify it 10 under the terms of the GNU General Public License as published by the 11 Free Software Foundation; either version 3, or (at your option) any 12 later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; see the file COPYING3. If not see 21 <http://www.gnu.org/licenses/>. */ 22 23 #include "config.h" 24 #include "system.h" 25 #include "cpplib.h" 26 #include "internal.h" 27 #include "mkdeps.h" 28 #include "localedir.h" 29 #include "filenames.h" 30 31 static void init_library (void); 32 static void mark_named_operators (cpp_reader *, int); 33 static void read_original_filename (cpp_reader *); 34 static void read_original_directory (cpp_reader *); 35 static void post_options (cpp_reader *); 36 37 /* If we have designated initializers (GCC >2.7) these tables can be 38 initialized, constant data. Otherwise, they have to be filled in at 39 runtime. */ 40 #if HAVE_DESIGNATED_INITIALIZERS 41 42 #define init_trigraph_map() /* Nothing. */ 43 #define TRIGRAPH_MAP \ 44 __extension__ const uchar _cpp_trigraph_map[UCHAR_MAX + 1] = { 45 46 #define END }; 47 #define s(p, v) [p] = v, 48 49 #else 50 51 #define TRIGRAPH_MAP uchar _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \ 52 static void init_trigraph_map (void) { \ 53 unsigned char *x = _cpp_trigraph_map; 54 55 #define END } 56 #define s(p, v) x[p] = v; 57 58 #endif 59 60 TRIGRAPH_MAP 61 s('=', '#') s(')', ']') s('!', '|') 62 s('(', '[') s('\'', '^') s('>', '}') 63 s('/', '\\') s('<', '{') s('-', '~') 64 END 65 66 #undef s 67 #undef END 68 #undef TRIGRAPH_MAP 69 70 /* A set of booleans indicating what CPP features each source language 71 requires. */ 72 struct lang_flags 73 { 74 char c99; 75 char cplusplus; 76 char extended_numbers; 77 char extended_identifiers; 78 char std; 79 char cplusplus_comments; 80 char digraphs; 81 char uliterals; 82 char rliterals; 83 char user_literals; 84 }; 85 86 static const struct lang_flags lang_defaults[] = 87 { /* c99 c++ xnum xid std // digr ulit rlit user_literals */ 88 /* GNUC89 */ { 0, 0, 1, 0, 0, 1, 1, 0, 0, 0 }, 89 /* GNUC99 */ { 1, 0, 1, 0, 0, 1, 1, 1, 1, 0 }, 90 /* GNUC11 */ { 1, 0, 1, 0, 0, 1, 1, 1, 1, 0 }, 91 /* STDC89 */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 }, 92 /* STDC94 */ { 0, 0, 0, 0, 1, 0, 1, 0, 0, 0 }, 93 /* STDC99 */ { 1, 0, 1, 0, 1, 1, 1, 0, 0, 0 }, 94 /* STDC11 */ { 1, 0, 1, 0, 1, 1, 1, 1, 0, 0 }, 95 /* GNUCXX */ { 0, 1, 1, 0, 0, 1, 1, 0, 0, 0 }, 96 /* CXX98 */ { 0, 1, 1, 0, 1, 1, 1, 0, 0, 0 }, 97 /* GNUCXX11 */ { 1, 1, 1, 0, 0, 1, 1, 1, 1, 1 }, 98 /* CXX11 */ { 1, 1, 1, 0, 1, 1, 1, 1, 1, 1 }, 99 /* ASM */ { 0, 0, 1, 0, 0, 1, 0, 0, 0, 0 } 100 /* xid should be 1 for GNUC99, STDC99, GNUCXX, CXX98, GNUCXX11, and 101 CXX11 when no longer experimental (when all uses of identifiers 102 in the compiler have been audited for correct handling of 103 extended identifiers). */ 104 }; 105 106 /* Sets internal flags correctly for a given language. */ 107 void 108 cpp_set_lang (cpp_reader *pfile, enum c_lang lang) 109 { 110 const struct lang_flags *l = &lang_defaults[(int) lang]; 111 112 CPP_OPTION (pfile, lang) = lang; 113 114 CPP_OPTION (pfile, c99) = l->c99; 115 CPP_OPTION (pfile, cplusplus) = l->cplusplus; 116 CPP_OPTION (pfile, extended_numbers) = l->extended_numbers; 117 CPP_OPTION (pfile, extended_identifiers) = l->extended_identifiers; 118 CPP_OPTION (pfile, std) = l->std; 119 CPP_OPTION (pfile, trigraphs) = l->std; 120 CPP_OPTION (pfile, cplusplus_comments) = l->cplusplus_comments; 121 CPP_OPTION (pfile, digraphs) = l->digraphs; 122 CPP_OPTION (pfile, uliterals) = l->uliterals; 123 CPP_OPTION (pfile, rliterals) = l->rliterals; 124 CPP_OPTION (pfile, user_literals) = l->user_literals; 125 } 126 127 /* Initialize library global state. */ 128 static void 129 init_library (void) 130 { 131 static int initialized = 0; 132 133 if (! initialized) 134 { 135 initialized = 1; 136 137 _cpp_init_lexer (); 138 139 /* Set up the trigraph map. This doesn't need to do anything if 140 we were compiled with a compiler that supports C99 designated 141 initializers. */ 142 init_trigraph_map (); 143 144 #ifdef ENABLE_NLS 145 (void) bindtextdomain (PACKAGE, LOCALEDIR); 146 #endif 147 } 148 } 149 150 /* Initialize a cpp_reader structure. */ 151 cpp_reader * 152 cpp_create_reader (enum c_lang lang, hash_table *table, 153 struct line_maps *line_table) 154 { 155 cpp_reader *pfile; 156 157 /* Initialize this instance of the library if it hasn't been already. */ 158 init_library (); 159 160 pfile = XCNEW (cpp_reader); 161 memset (&pfile->base_context, 0, sizeof (pfile->base_context)); 162 163 cpp_set_lang (pfile, lang); 164 CPP_OPTION (pfile, warn_multichar) = 1; 165 CPP_OPTION (pfile, discard_comments) = 1; 166 CPP_OPTION (pfile, discard_comments_in_macro_exp) = 1; 167 CPP_OPTION (pfile, tabstop) = 8; 168 CPP_OPTION (pfile, operator_names) = 1; 169 CPP_OPTION (pfile, warn_trigraphs) = 2; 170 CPP_OPTION (pfile, warn_endif_labels) = 1; 171 CPP_OPTION (pfile, cpp_warn_deprecated) = 1; 172 CPP_OPTION (pfile, cpp_warn_long_long) = 0; 173 CPP_OPTION (pfile, dollars_in_ident) = 1; 174 CPP_OPTION (pfile, warn_dollars) = 1; 175 CPP_OPTION (pfile, warn_variadic_macros) = 1; 176 CPP_OPTION (pfile, warn_builtin_macro_redefined) = 1; 177 CPP_OPTION (pfile, warn_normalize) = normalized_C; 178 179 /* Default CPP arithmetic to something sensible for the host for the 180 benefit of dumb users like fix-header. */ 181 CPP_OPTION (pfile, precision) = CHAR_BIT * sizeof (long); 182 CPP_OPTION (pfile, char_precision) = CHAR_BIT; 183 CPP_OPTION (pfile, wchar_precision) = CHAR_BIT * sizeof (int); 184 CPP_OPTION (pfile, int_precision) = CHAR_BIT * sizeof (int); 185 CPP_OPTION (pfile, unsigned_char) = 0; 186 CPP_OPTION (pfile, unsigned_wchar) = 1; 187 CPP_OPTION (pfile, bytes_big_endian) = 1; /* does not matter */ 188 189 /* Default to no charset conversion. */ 190 CPP_OPTION (pfile, narrow_charset) = _cpp_default_encoding (); 191 CPP_OPTION (pfile, wide_charset) = 0; 192 193 /* Default the input character set to UTF-8. */ 194 CPP_OPTION (pfile, input_charset) = _cpp_default_encoding (); 195 196 /* A fake empty "directory" used as the starting point for files 197 looked up without a search path. Name cannot be '/' because we 198 don't want to prepend anything at all to filenames using it. All 199 other entries are correct zero-initialized. */ 200 pfile->no_search_path.name = (char *) ""; 201 202 /* Initialize the line map. */ 203 pfile->line_table = line_table; 204 205 /* Initialize lexer state. */ 206 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments); 207 208 /* Set up static tokens. */ 209 pfile->avoid_paste.type = CPP_PADDING; 210 pfile->avoid_paste.val.source = NULL; 211 pfile->eof.type = CPP_EOF; 212 pfile->eof.flags = 0; 213 214 /* Create a token buffer for the lexer. */ 215 _cpp_init_tokenrun (&pfile->base_run, 250); 216 pfile->cur_run = &pfile->base_run; 217 pfile->cur_token = pfile->base_run.base; 218 219 /* Initialize the base context. */ 220 pfile->context = &pfile->base_context; 221 pfile->base_context.c.macro = 0; 222 pfile->base_context.prev = pfile->base_context.next = 0; 223 224 /* Aligned and unaligned storage. */ 225 pfile->a_buff = _cpp_get_buff (pfile, 0); 226 pfile->u_buff = _cpp_get_buff (pfile, 0); 227 228 /* Initialize table for push_macro/pop_macro. */ 229 pfile->pushed_macros = 0; 230 231 /* Do not force token locations by default. */ 232 pfile->forced_token_location_p = NULL; 233 234 /* The expression parser stack. */ 235 _cpp_expand_op_stack (pfile); 236 237 /* Initialize the buffer obstack. */ 238 _obstack_begin (&pfile->buffer_ob, 0, 0, 239 (void *(*) (long)) xmalloc, 240 (void (*) (void *)) free); 241 242 _cpp_init_files (pfile); 243 244 _cpp_init_hashtable (pfile, table); 245 246 return pfile; 247 } 248 249 /* Set the line_table entry in PFILE. This is called after reading a 250 PCH file, as the old line_table will be incorrect. */ 251 void 252 cpp_set_line_map (cpp_reader *pfile, struct line_maps *line_table) 253 { 254 pfile->line_table = line_table; 255 } 256 257 /* Free resources used by PFILE. Accessing PFILE after this function 258 returns leads to undefined behavior. Returns the error count. */ 259 void 260 cpp_destroy (cpp_reader *pfile) 261 { 262 cpp_context *context, *contextn; 263 struct def_pragma_macro *pmacro; 264 tokenrun *run, *runn; 265 int i; 266 267 free (pfile->op_stack); 268 269 while (CPP_BUFFER (pfile) != NULL) 270 _cpp_pop_buffer (pfile); 271 272 free (pfile->out.base); 273 274 if (pfile->macro_buffer) 275 { 276 free (pfile->macro_buffer); 277 pfile->macro_buffer = NULL; 278 pfile->macro_buffer_len = 0; 279 } 280 281 if (pfile->deps) 282 deps_free (pfile->deps); 283 obstack_free (&pfile->buffer_ob, 0); 284 285 _cpp_destroy_hashtable (pfile); 286 _cpp_cleanup_files (pfile); 287 _cpp_destroy_iconv (pfile); 288 289 _cpp_free_buff (pfile->a_buff); 290 _cpp_free_buff (pfile->u_buff); 291 _cpp_free_buff (pfile->free_buffs); 292 293 for (run = &pfile->base_run; run; run = runn) 294 { 295 runn = run->next; 296 free (run->base); 297 if (run != &pfile->base_run) 298 free (run); 299 } 300 301 for (context = pfile->base_context.next; context; context = contextn) 302 { 303 contextn = context->next; 304 free (context); 305 } 306 307 if (pfile->comments.entries) 308 { 309 for (i = 0; i < pfile->comments.count; i++) 310 free (pfile->comments.entries[i].comment); 311 312 free (pfile->comments.entries); 313 } 314 if (pfile->pushed_macros) 315 { 316 do 317 { 318 pmacro = pfile->pushed_macros; 319 pfile->pushed_macros = pmacro->next; 320 free (pmacro->name); 321 free (pmacro); 322 } 323 while (pfile->pushed_macros); 324 } 325 326 free (pfile); 327 } 328 329 /* This structure defines one built-in identifier. A node will be 330 entered in the hash table under the name NAME, with value VALUE. 331 332 There are two tables of these. builtin_array holds all the 333 "builtin" macros: these are handled by builtin_macro() in 334 macro.c. Builtin is somewhat of a misnomer -- the property of 335 interest is that these macros require special code to compute their 336 expansions. The value is a "cpp_builtin_type" enumerator. 337 338 operator_array holds the C++ named operators. These are keywords 339 which act as aliases for punctuators. In C++, they cannot be 340 altered through #define, and #if recognizes them as operators. In 341 C, these are not entered into the hash table at all (but see 342 <iso646.h>). The value is a token-type enumerator. */ 343 struct builtin_macro 344 { 345 const uchar *const name; 346 const unsigned short len; 347 const unsigned short value; 348 const bool always_warn_if_redefined; 349 }; 350 351 #define B(n, t, f) { DSC(n), t, f } 352 static const struct builtin_macro builtin_array[] = 353 { 354 B("__TIMESTAMP__", BT_TIMESTAMP, false), 355 B("__TIME__", BT_TIME, false), 356 B("__DATE__", BT_DATE, false), 357 B("__FILE__", BT_FILE, false), 358 B("__BASE_FILE__", BT_BASE_FILE, false), 359 B("__LINE__", BT_SPECLINE, true), 360 B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL, true), 361 B("__COUNTER__", BT_COUNTER, true), 362 /* Keep builtins not used for -traditional-cpp at the end, and 363 update init_builtins() if any more are added. */ 364 B("_Pragma", BT_PRAGMA, true), 365 B("__STDC__", BT_STDC, true), 366 }; 367 #undef B 368 369 struct builtin_operator 370 { 371 const uchar *const name; 372 const unsigned short len; 373 const unsigned short value; 374 }; 375 376 #define B(n, t) { DSC(n), t } 377 static const struct builtin_operator operator_array[] = 378 { 379 B("and", CPP_AND_AND), 380 B("and_eq", CPP_AND_EQ), 381 B("bitand", CPP_AND), 382 B("bitor", CPP_OR), 383 B("compl", CPP_COMPL), 384 B("not", CPP_NOT), 385 B("not_eq", CPP_NOT_EQ), 386 B("or", CPP_OR_OR), 387 B("or_eq", CPP_OR_EQ), 388 B("xor", CPP_XOR), 389 B("xor_eq", CPP_XOR_EQ) 390 }; 391 #undef B 392 393 /* Mark the C++ named operators in the hash table. */ 394 static void 395 mark_named_operators (cpp_reader *pfile, int flags) 396 { 397 const struct builtin_operator *b; 398 399 for (b = operator_array; 400 b < (operator_array + ARRAY_SIZE (operator_array)); 401 b++) 402 { 403 cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len); 404 hp->flags |= flags; 405 hp->is_directive = 0; 406 hp->directive_index = b->value; 407 } 408 } 409 410 /* Helper function of cpp_type2name. Return the string associated with 411 named operator TYPE. */ 412 const char * 413 cpp_named_operator2name (enum cpp_ttype type) 414 { 415 const struct builtin_operator *b; 416 417 for (b = operator_array; 418 b < (operator_array + ARRAY_SIZE (operator_array)); 419 b++) 420 { 421 if (type == b->value) 422 return (const char *) b->name; 423 } 424 425 return NULL; 426 } 427 428 void 429 cpp_init_special_builtins (cpp_reader *pfile) 430 { 431 const struct builtin_macro *b; 432 size_t n = ARRAY_SIZE (builtin_array); 433 434 if (CPP_OPTION (pfile, traditional)) 435 n -= 2; 436 else if (! CPP_OPTION (pfile, stdc_0_in_system_headers) 437 || CPP_OPTION (pfile, std)) 438 n--; 439 440 for (b = builtin_array; b < builtin_array + n; b++) 441 { 442 cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len); 443 hp->type = NT_MACRO; 444 hp->flags |= NODE_BUILTIN; 445 if (b->always_warn_if_redefined 446 || CPP_OPTION (pfile, warn_builtin_macro_redefined)) 447 hp->flags |= NODE_WARN; 448 hp->value.builtin = (enum cpp_builtin_type) b->value; 449 } 450 } 451 452 /* Read the builtins table above and enter them, and language-specific 453 macros, into the hash table. HOSTED is true if this is a hosted 454 environment. */ 455 void 456 cpp_init_builtins (cpp_reader *pfile, int hosted) 457 { 458 cpp_init_special_builtins (pfile); 459 460 if (!CPP_OPTION (pfile, traditional) 461 && (! CPP_OPTION (pfile, stdc_0_in_system_headers) 462 || CPP_OPTION (pfile, std))) 463 _cpp_define_builtin (pfile, "__STDC__ 1"); 464 465 if (CPP_OPTION (pfile, cplusplus)) 466 { 467 if (CPP_OPTION (pfile, lang) == CLK_CXX11 468 || CPP_OPTION (pfile, lang) == CLK_GNUCXX11) 469 _cpp_define_builtin (pfile, "__cplusplus 201103L"); 470 else 471 _cpp_define_builtin (pfile, "__cplusplus 199711L"); 472 } 473 else if (CPP_OPTION (pfile, lang) == CLK_ASM) 474 _cpp_define_builtin (pfile, "__ASSEMBLER__ 1"); 475 else if (CPP_OPTION (pfile, lang) == CLK_STDC94) 476 _cpp_define_builtin (pfile, "__STDC_VERSION__ 199409L"); 477 else if (CPP_OPTION (pfile, lang) == CLK_STDC11 478 || CPP_OPTION (pfile, lang) == CLK_GNUC11) 479 _cpp_define_builtin (pfile, "__STDC_VERSION__ 201112L"); 480 else if (CPP_OPTION (pfile, c99)) 481 _cpp_define_builtin (pfile, "__STDC_VERSION__ 199901L"); 482 483 if (CPP_OPTION (pfile, uliterals) 484 && !CPP_OPTION (pfile, cplusplus)) 485 { 486 _cpp_define_builtin (pfile, "__STDC_UTF_16__ 1"); 487 _cpp_define_builtin (pfile, "__STDC_UTF_32__ 1"); 488 } 489 490 if (hosted) 491 _cpp_define_builtin (pfile, "__STDC_HOSTED__ 1"); 492 else 493 _cpp_define_builtin (pfile, "__STDC_HOSTED__ 0"); 494 495 if (CPP_OPTION (pfile, objc)) 496 _cpp_define_builtin (pfile, "__OBJC__ 1"); 497 } 498 499 /* Sanity-checks are dependent on command-line options, so it is 500 called as a subroutine of cpp_read_main_file (). */ 501 #if ENABLE_CHECKING 502 static void sanity_checks (cpp_reader *); 503 static void sanity_checks (cpp_reader *pfile) 504 { 505 cppchar_t test = 0; 506 size_t max_precision = 2 * CHAR_BIT * sizeof (cpp_num_part); 507 508 /* Sanity checks for assumptions about CPP arithmetic and target 509 type precisions made by cpplib. */ 510 test--; 511 if (test < 1) 512 cpp_error (pfile, CPP_DL_ICE, "cppchar_t must be an unsigned type"); 513 514 if (CPP_OPTION (pfile, precision) > max_precision) 515 cpp_error (pfile, CPP_DL_ICE, 516 "preprocessor arithmetic has maximum precision of %lu bits;" 517 " target requires %lu bits", 518 (unsigned long) max_precision, 519 (unsigned long) CPP_OPTION (pfile, precision)); 520 521 if (CPP_OPTION (pfile, precision) < CPP_OPTION (pfile, int_precision)) 522 cpp_error (pfile, CPP_DL_ICE, 523 "CPP arithmetic must be at least as precise as a target int"); 524 525 if (CPP_OPTION (pfile, char_precision) < 8) 526 cpp_error (pfile, CPP_DL_ICE, "target char is less than 8 bits wide"); 527 528 if (CPP_OPTION (pfile, wchar_precision) < CPP_OPTION (pfile, char_precision)) 529 cpp_error (pfile, CPP_DL_ICE, 530 "target wchar_t is narrower than target char"); 531 532 if (CPP_OPTION (pfile, int_precision) < CPP_OPTION (pfile, char_precision)) 533 cpp_error (pfile, CPP_DL_ICE, 534 "target int is narrower than target char"); 535 536 /* This is assumed in eval_token() and could be fixed if necessary. */ 537 if (sizeof (cppchar_t) > sizeof (cpp_num_part)) 538 cpp_error (pfile, CPP_DL_ICE, 539 "CPP half-integer narrower than CPP character"); 540 541 if (CPP_OPTION (pfile, wchar_precision) > BITS_PER_CPPCHAR_T) 542 cpp_error (pfile, CPP_DL_ICE, 543 "CPP on this host cannot handle wide character constants over" 544 " %lu bits, but the target requires %lu bits", 545 (unsigned long) BITS_PER_CPPCHAR_T, 546 (unsigned long) CPP_OPTION (pfile, wchar_precision)); 547 } 548 #else 549 # define sanity_checks(PFILE) 550 #endif 551 552 /* This is called after options have been parsed, and partially 553 processed. */ 554 void 555 cpp_post_options (cpp_reader *pfile) 556 { 557 int flags; 558 559 sanity_checks (pfile); 560 561 post_options (pfile); 562 563 /* Mark named operators before handling command line macros. */ 564 flags = 0; 565 if (CPP_OPTION (pfile, cplusplus) && CPP_OPTION (pfile, operator_names)) 566 flags |= NODE_OPERATOR; 567 if (CPP_OPTION (pfile, warn_cxx_operator_names)) 568 flags |= NODE_DIAGNOSTIC | NODE_WARN_OPERATOR; 569 if (flags != 0) 570 mark_named_operators (pfile, flags); 571 } 572 573 /* Setup for processing input from the file named FNAME, or stdin if 574 it is the empty string. Return the original filename 575 on success (e.g. foo.i->foo.c), or NULL on failure. */ 576 const char * 577 cpp_read_main_file (cpp_reader *pfile, const char *fname) 578 { 579 if (CPP_OPTION (pfile, deps.style) != DEPS_NONE) 580 { 581 if (!pfile->deps) 582 pfile->deps = deps_init (); 583 584 /* Set the default target (if there is none already). */ 585 deps_add_default_target (pfile->deps, fname); 586 } 587 588 pfile->main_file 589 = _cpp_find_file (pfile, fname, &pfile->no_search_path, false, 0); 590 if (_cpp_find_failed (pfile->main_file)) 591 return NULL; 592 593 _cpp_stack_file (pfile, pfile->main_file, false); 594 595 /* For foo.i, read the original filename foo.c now, for the benefit 596 of the front ends. */ 597 if (CPP_OPTION (pfile, preprocessed)) 598 { 599 read_original_filename (pfile); 600 fname = 601 ORDINARY_MAP_FILE_NAME 602 ((LINEMAPS_LAST_ORDINARY_MAP (pfile->line_table))); 603 } 604 return fname; 605 } 606 607 /* For preprocessed files, if the first tokens are of the form # NUM. 608 handle the directive so we know the original file name. This will 609 generate file_change callbacks, which the front ends must handle 610 appropriately given their state of initialization. */ 611 static void 612 read_original_filename (cpp_reader *pfile) 613 { 614 const cpp_token *token, *token1; 615 616 /* Lex ahead; if the first tokens are of the form # NUM, then 617 process the directive, otherwise back up. */ 618 token = _cpp_lex_direct (pfile); 619 if (token->type == CPP_HASH) 620 { 621 pfile->state.in_directive = 1; 622 token1 = _cpp_lex_direct (pfile); 623 _cpp_backup_tokens (pfile, 1); 624 pfile->state.in_directive = 0; 625 626 /* If it's a #line directive, handle it. */ 627 if (token1->type == CPP_NUMBER 628 && _cpp_handle_directive (pfile, token->flags & PREV_WHITE)) 629 { 630 read_original_directory (pfile); 631 return; 632 } 633 } 634 635 /* Backup as if nothing happened. */ 636 _cpp_backup_tokens (pfile, 1); 637 } 638 639 /* For preprocessed files, if the tokens following the first filename 640 line is of the form # <line> "/path/name//", handle the 641 directive so we know the original current directory. */ 642 static void 643 read_original_directory (cpp_reader *pfile) 644 { 645 const cpp_token *hash, *token; 646 647 /* Lex ahead; if the first tokens are of the form # NUM, then 648 process the directive, otherwise back up. */ 649 hash = _cpp_lex_direct (pfile); 650 if (hash->type != CPP_HASH) 651 { 652 _cpp_backup_tokens (pfile, 1); 653 return; 654 } 655 656 token = _cpp_lex_direct (pfile); 657 658 if (token->type != CPP_NUMBER) 659 { 660 _cpp_backup_tokens (pfile, 2); 661 return; 662 } 663 664 token = _cpp_lex_direct (pfile); 665 666 if (token->type != CPP_STRING 667 || ! (token->val.str.len >= 5 668 && IS_DIR_SEPARATOR (token->val.str.text[token->val.str.len-2]) 669 && IS_DIR_SEPARATOR (token->val.str.text[token->val.str.len-3]))) 670 { 671 _cpp_backup_tokens (pfile, 3); 672 return; 673 } 674 675 if (pfile->cb.dir_change) 676 { 677 char *debugdir = (char *) alloca (token->val.str.len - 3); 678 679 memcpy (debugdir, (const char *) token->val.str.text + 1, 680 token->val.str.len - 4); 681 debugdir[token->val.str.len - 4] = '\0'; 682 683 pfile->cb.dir_change (pfile, debugdir); 684 } 685 } 686 687 /* This is called at the end of preprocessing. It pops the last 688 buffer and writes dependency output. 689 690 Maybe it should also reset state, such that you could call 691 cpp_start_read with a new filename to restart processing. */ 692 void 693 cpp_finish (cpp_reader *pfile, FILE *deps_stream) 694 { 695 /* Warn about unused macros before popping the final buffer. */ 696 if (CPP_OPTION (pfile, warn_unused_macros)) 697 cpp_forall_identifiers (pfile, _cpp_warn_if_unused_macro, NULL); 698 699 /* lex.c leaves the final buffer on the stack. This it so that 700 it returns an unending stream of CPP_EOFs to the client. If we 701 popped the buffer, we'd dereference a NULL buffer pointer and 702 segfault. It's nice to allow the client to do worry-free excess 703 cpp_get_token calls. */ 704 while (pfile->buffer) 705 _cpp_pop_buffer (pfile); 706 707 if (CPP_OPTION (pfile, deps.style) != DEPS_NONE 708 && deps_stream) 709 { 710 deps_write (pfile->deps, deps_stream, 72); 711 712 if (CPP_OPTION (pfile, deps.phony_targets)) 713 deps_phony_targets (pfile->deps, deps_stream); 714 } 715 716 /* Report on headers that could use multiple include guards. */ 717 if (CPP_OPTION (pfile, print_include_names)) 718 _cpp_report_missing_guards (pfile); 719 } 720 721 static void 722 post_options (cpp_reader *pfile) 723 { 724 /* -Wtraditional is not useful in C++ mode. */ 725 if (CPP_OPTION (pfile, cplusplus)) 726 CPP_OPTION (pfile, cpp_warn_traditional) = 0; 727 728 /* Permanently disable macro expansion if we are rescanning 729 preprocessed text. Read preprocesed source in ISO mode. */ 730 if (CPP_OPTION (pfile, preprocessed)) 731 { 732 if (!CPP_OPTION (pfile, directives_only)) 733 pfile->state.prevent_expansion = 1; 734 CPP_OPTION (pfile, traditional) = 0; 735 } 736 737 if (CPP_OPTION (pfile, warn_trigraphs) == 2) 738 CPP_OPTION (pfile, warn_trigraphs) = !CPP_OPTION (pfile, trigraphs); 739 740 if (CPP_OPTION (pfile, traditional)) 741 { 742 CPP_OPTION (pfile, cplusplus_comments) = 0; 743 744 CPP_OPTION (pfile, trigraphs) = 0; 745 CPP_OPTION (pfile, warn_trigraphs) = 0; 746 } 747 } 748