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