1 /* Part of CPP library. 2 Copyright (C) 1997-2018 Free Software Foundation, Inc. 3 4 This program is free software; you can redistribute it and/or modify it 5 under the terms of the GNU General Public License as published by the 6 Free Software Foundation; either version 3, or (at your option) any 7 later version. 8 9 This program is distributed in the hope that it will be useful, 10 but WITHOUT ANY WARRANTY; without even the implied warranty of 11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 GNU General Public License for more details. 13 14 You should have received a copy of the GNU General Public License 15 along with this program; see the file COPYING3. If not see 16 <http://www.gnu.org/licenses/>. */ 17 18 /* This header defines all the internal data structures and functions 19 that need to be visible across files. It should not be used outside 20 cpplib. */ 21 22 #ifndef LIBCPP_INTERNAL_H 23 #define LIBCPP_INTERNAL_H 24 25 #include "symtab.h" 26 #include "cpp-id-data.h" 27 28 #if HAVE_ICONV 29 #include <iconv.h> 30 #else 31 #define HAVE_ICONV 0 32 typedef int iconv_t; /* dummy */ 33 #endif 34 35 #ifdef __cplusplus 36 extern "C" { 37 #endif 38 39 struct directive; /* Deliberately incomplete. */ 40 struct pending_option; 41 struct op; 42 struct _cpp_strbuf; 43 44 typedef bool (*convert_f) (iconv_t, const unsigned char *, size_t, 45 struct _cpp_strbuf *); 46 struct cset_converter 47 { 48 convert_f func; 49 iconv_t cd; 50 int width; 51 }; 52 53 #define BITS_PER_CPPCHAR_T (CHAR_BIT * sizeof (cppchar_t)) 54 55 /* Test if a sign is valid within a preprocessing number. */ 56 #define VALID_SIGN(c, prevc) \ 57 (((c) == '+' || (c) == '-') && \ 58 ((prevc) == 'e' || (prevc) == 'E' \ 59 || (((prevc) == 'p' || (prevc) == 'P') \ 60 && CPP_OPTION (pfile, extended_numbers)))) 61 62 #define DIGIT_SEP(c) ((c) == '\'' && CPP_OPTION (pfile, digit_separators)) 63 64 #define CPP_OPTION(PFILE, OPTION) ((PFILE)->opts.OPTION) 65 #define CPP_BUFFER(PFILE) ((PFILE)->buffer) 66 #define CPP_BUF_COLUMN(BUF, CUR) ((CUR) - (BUF)->line_base) 67 #define CPP_BUF_COL(BUF) CPP_BUF_COLUMN(BUF, (BUF)->cur) 68 69 #define CPP_INCREMENT_LINE(PFILE, COLS_HINT) do { \ 70 const struct line_maps *line_table = PFILE->line_table; \ 71 const struct line_map_ordinary *map = \ 72 LINEMAPS_LAST_ORDINARY_MAP (line_table); \ 73 linenum_type line = SOURCE_LINE (map, line_table->highest_line); \ 74 linemap_line_start (PFILE->line_table, line + 1, COLS_HINT); \ 75 } while (0) 76 77 /* Maximum nesting of cpp_buffers. We use a static limit, partly for 78 efficiency, and partly to limit runaway recursion. */ 79 #define CPP_STACK_MAX 200 80 81 /* Host alignment handling. */ 82 struct dummy 83 { 84 char c; 85 union 86 { 87 double d; 88 int *p; 89 } u; 90 }; 91 92 #define DEFAULT_ALIGNMENT offsetof (struct dummy, u) 93 #define CPP_ALIGN2(size, align) (((size) + ((align) - 1)) & ~((align) - 1)) 94 #define CPP_ALIGN(size) CPP_ALIGN2 (size, DEFAULT_ALIGNMENT) 95 96 #define _cpp_mark_macro_used(NODE) do { \ 97 if ((NODE)->type == NT_MACRO && !((NODE)->flags & NODE_BUILTIN)) \ 98 (NODE)->value.macro->used = 1; } while (0) 99 100 /* A generic memory buffer, and operations on it. */ 101 typedef struct _cpp_buff _cpp_buff; 102 struct _cpp_buff 103 { 104 struct _cpp_buff *next; 105 unsigned char *base, *cur, *limit; 106 }; 107 108 extern _cpp_buff *_cpp_get_buff (cpp_reader *, size_t); 109 extern void _cpp_release_buff (cpp_reader *, _cpp_buff *); 110 extern void _cpp_extend_buff (cpp_reader *, _cpp_buff **, size_t); 111 extern _cpp_buff *_cpp_append_extend_buff (cpp_reader *, _cpp_buff *, size_t); 112 extern void _cpp_free_buff (_cpp_buff *); 113 extern unsigned char *_cpp_aligned_alloc (cpp_reader *, size_t); 114 extern unsigned char *_cpp_unaligned_alloc (cpp_reader *, size_t); 115 116 #define BUFF_ROOM(BUFF) (size_t) ((BUFF)->limit - (BUFF)->cur) 117 #define BUFF_FRONT(BUFF) ((BUFF)->cur) 118 #define BUFF_LIMIT(BUFF) ((BUFF)->limit) 119 120 /* #include types. */ 121 enum include_type {IT_INCLUDE, IT_INCLUDE_NEXT, IT_IMPORT, IT_CMDLINE, IT_DEFAULT}; 122 123 union utoken 124 { 125 const cpp_token *token; 126 const cpp_token **ptoken; 127 }; 128 129 /* A "run" of tokens; part of a chain of runs. */ 130 typedef struct tokenrun tokenrun; 131 struct tokenrun 132 { 133 tokenrun *next, *prev; 134 cpp_token *base, *limit; 135 }; 136 137 /* Accessor macros for struct cpp_context. */ 138 #define FIRST(c) ((c)->u.iso.first) 139 #define LAST(c) ((c)->u.iso.last) 140 #define CUR(c) ((c)->u.trad.cur) 141 #define RLIMIT(c) ((c)->u.trad.rlimit) 142 143 /* This describes some additional data that is added to the macro 144 token context of type cpp_context, when -ftrack-macro-expansion is 145 on. */ 146 typedef struct 147 { 148 /* The node of the macro we are referring to. */ 149 cpp_hashnode *macro_node; 150 /* This buffer contains an array of virtual locations. The virtual 151 location at index 0 is the virtual location of the token at index 152 0 in the current instance of cpp_context; similarly for all the 153 other virtual locations. */ 154 source_location *virt_locs; 155 /* This is a pointer to the current virtual location. This is used 156 to iterate over the virtual locations while we iterate over the 157 tokens they belong to. */ 158 source_location *cur_virt_loc; 159 } macro_context; 160 161 /* The kind of tokens carried by a cpp_context. */ 162 enum context_tokens_kind { 163 /* This is the value of cpp_context::tokens_kind if u.iso.first 164 contains an instance of cpp_token **. */ 165 TOKENS_KIND_INDIRECT, 166 /* This is the value of cpp_context::tokens_kind if u.iso.first 167 contains an instance of cpp_token *. */ 168 TOKENS_KIND_DIRECT, 169 /* This is the value of cpp_context::tokens_kind when the token 170 context contains tokens resulting from macro expansion. In that 171 case struct cpp_context::macro points to an instance of struct 172 macro_context. This is used only when the 173 -ftrack-macro-expansion flag is on. */ 174 TOKENS_KIND_EXTENDED 175 }; 176 177 typedef struct cpp_context cpp_context; 178 struct cpp_context 179 { 180 /* Doubly-linked list. */ 181 cpp_context *next, *prev; 182 183 union 184 { 185 /* For ISO macro expansion. Contexts other than the base context 186 are contiguous tokens. e.g. macro expansions, expanded 187 argument tokens. */ 188 struct 189 { 190 union utoken first; 191 union utoken last; 192 } iso; 193 194 /* For traditional macro expansion. */ 195 struct 196 { 197 const unsigned char *cur; 198 const unsigned char *rlimit; 199 } trad; 200 } u; 201 202 /* If non-NULL, a buffer used for storage related to this context. 203 When the context is popped, the buffer is released. */ 204 _cpp_buff *buff; 205 206 /* If tokens_kind is TOKEN_KIND_EXTENDED, then (as we thus are in a 207 macro context) this is a pointer to an instance of macro_context. 208 Otherwise if tokens_kind is *not* TOKEN_KIND_EXTENDED, then, if 209 we are in a macro context, this is a pointer to an instance of 210 cpp_hashnode, representing the name of the macro this context is 211 for. If we are not in a macro context, then this is just NULL. 212 Note that when tokens_kind is TOKEN_KIND_EXTENDED, the memory 213 used by the instance of macro_context pointed to by this member 214 is de-allocated upon de-allocation of the instance of struct 215 cpp_context. */ 216 union 217 { 218 macro_context *mc; 219 cpp_hashnode *macro; 220 } c; 221 222 /* This determines the type of tokens held by this context. */ 223 enum context_tokens_kind tokens_kind; 224 }; 225 226 struct lexer_state 227 { 228 /* Nonzero if first token on line is CPP_HASH. */ 229 unsigned char in_directive; 230 231 /* Nonzero if in a directive that will handle padding tokens itself. 232 #include needs this to avoid problems with computed include and 233 spacing between tokens. */ 234 unsigned char directive_wants_padding; 235 236 /* True if we are skipping a failed conditional group. */ 237 unsigned char skipping; 238 239 /* Nonzero if in a directive that takes angle-bracketed headers. */ 240 unsigned char angled_headers; 241 242 /* Nonzero if in a #if or #elif directive. */ 243 unsigned char in_expression; 244 245 /* Nonzero to save comments. Turned off if discard_comments, and in 246 all directives apart from #define. */ 247 unsigned char save_comments; 248 249 /* Nonzero if lexing __VA_ARGS__ and __VA_OPT__ are valid. */ 250 unsigned char va_args_ok; 251 252 /* Nonzero if lexing poisoned identifiers is valid. */ 253 unsigned char poisoned_ok; 254 255 /* Nonzero to prevent macro expansion. */ 256 unsigned char prevent_expansion; 257 258 /* Nonzero when parsing arguments to a function-like macro. */ 259 unsigned char parsing_args; 260 261 /* Nonzero if in a __has_include__ or __has_include_next__ statement. */ 262 unsigned char in__has_include__; 263 264 /* Nonzero if prevent_expansion is true only because output is 265 being discarded. */ 266 unsigned char discarding_output; 267 268 /* Nonzero to skip evaluating part of an expression. */ 269 unsigned int skip_eval; 270 271 /* Nonzero when handling a deferred pragma. */ 272 unsigned char in_deferred_pragma; 273 274 /* Nonzero if the deferred pragma being handled allows macro expansion. */ 275 unsigned char pragma_allow_expansion; 276 }; 277 278 /* Special nodes - identifiers with predefined significance. */ 279 struct spec_nodes 280 { 281 cpp_hashnode *n_defined; /* defined operator */ 282 cpp_hashnode *n_true; /* C++ keyword true */ 283 cpp_hashnode *n_false; /* C++ keyword false */ 284 cpp_hashnode *n__VA_ARGS__; /* C99 vararg macros */ 285 cpp_hashnode *n__VA_OPT__; /* C++ vararg macros */ 286 cpp_hashnode *n__has_include__; /* __has_include__ operator */ 287 cpp_hashnode *n__has_include_next__; /* __has_include_next__ operator */ 288 }; 289 290 typedef struct _cpp_line_note _cpp_line_note; 291 struct _cpp_line_note 292 { 293 /* Location in the clean line the note refers to. */ 294 const unsigned char *pos; 295 296 /* Type of note. The 9 'from' trigraph characters represent those 297 trigraphs, '\\' an escaped newline, ' ' an escaped newline with 298 intervening space, 0 represents a note that has already been handled, 299 and anything else is invalid. */ 300 unsigned int type; 301 }; 302 303 /* Represents the contents of a file cpplib has read in. */ 304 struct cpp_buffer 305 { 306 const unsigned char *cur; /* Current location. */ 307 const unsigned char *line_base; /* Start of current physical line. */ 308 const unsigned char *next_line; /* Start of to-be-cleaned logical line. */ 309 310 const unsigned char *buf; /* Entire character buffer. */ 311 const unsigned char *rlimit; /* Writable byte at end of file. */ 312 const unsigned char *to_free; /* Pointer that should be freed when 313 popping the buffer. */ 314 315 _cpp_line_note *notes; /* Array of notes. */ 316 unsigned int cur_note; /* Next note to process. */ 317 unsigned int notes_used; /* Number of notes. */ 318 unsigned int notes_cap; /* Size of allocated array. */ 319 320 struct cpp_buffer *prev; 321 322 /* Pointer into the file table; non-NULL if this is a file buffer. 323 Used for include_next and to record control macros. */ 324 struct _cpp_file *file; 325 326 /* Saved value of __TIMESTAMP__ macro - date and time of last modification 327 of the assotiated file. */ 328 const unsigned char *timestamp; 329 330 /* Value of if_stack at start of this file. 331 Used to prohibit unmatched #endif (etc) in an include file. */ 332 struct if_stack *if_stack; 333 334 /* True if we need to get the next clean line. */ 335 bool need_line; 336 337 /* True if we have already warned about C++ comments in this file. 338 The warning happens only for C89 extended mode with -pedantic on, 339 or for -Wtraditional, and only once per file (otherwise it would 340 be far too noisy). */ 341 unsigned int warned_cplusplus_comments : 1; 342 343 /* True if we don't process trigraphs and escaped newlines. True 344 for preprocessed input, command line directives, and _Pragma 345 buffers. */ 346 unsigned int from_stage3 : 1; 347 348 /* At EOF, a buffer is automatically popped. If RETURN_AT_EOF is 349 true, a CPP_EOF token is then returned. Otherwise, the next 350 token from the enclosing buffer is returned. */ 351 unsigned int return_at_eof : 1; 352 353 /* One for a system header, two for a C system header file that therefore 354 needs to be extern "C" protected in C++, and zero otherwise. */ 355 unsigned char sysp; 356 357 /* The directory of the this buffer's file. Its NAME member is not 358 allocated, so we don't need to worry about freeing it. */ 359 struct cpp_dir dir; 360 361 /* Descriptor for converting from the input character set to the 362 source character set. */ 363 struct cset_converter input_cset_desc; 364 }; 365 366 /* The list of saved macros by push_macro pragma. */ 367 struct def_pragma_macro { 368 /* Chain element to previous saved macro. */ 369 struct def_pragma_macro *next; 370 /* Name of the macro. */ 371 char *name; 372 /* The stored macro content. */ 373 unsigned char *definition; 374 375 /* Definition line number. */ 376 source_location line; 377 /* If macro defined in system header. */ 378 unsigned int syshdr : 1; 379 /* Nonzero if it has been expanded or had its existence tested. */ 380 unsigned int used : 1; 381 382 /* Mark if we save an undefined macro. */ 383 unsigned int is_undef : 1; 384 }; 385 386 /* A cpp_reader encapsulates the "state" of a pre-processor run. 387 Applying cpp_get_token repeatedly yields a stream of pre-processor 388 tokens. Usually, there is only one cpp_reader object active. */ 389 struct cpp_reader 390 { 391 /* Top of buffer stack. */ 392 cpp_buffer *buffer; 393 394 /* Overlaid buffer (can be different after processing #include). */ 395 cpp_buffer *overlaid_buffer; 396 397 /* Lexer state. */ 398 struct lexer_state state; 399 400 /* Source line tracking. */ 401 struct line_maps *line_table; 402 403 /* The line of the '#' of the current directive. */ 404 source_location directive_line; 405 406 /* Memory buffers. */ 407 _cpp_buff *a_buff; /* Aligned permanent storage. */ 408 _cpp_buff *u_buff; /* Unaligned permanent storage. */ 409 _cpp_buff *free_buffs; /* Free buffer chain. */ 410 411 /* Context stack. */ 412 struct cpp_context base_context; 413 struct cpp_context *context; 414 415 /* If in_directive, the directive if known. */ 416 const struct directive *directive; 417 418 /* Token generated while handling a directive, if any. */ 419 cpp_token directive_result; 420 421 /* When expanding a macro at top-level, this is the location of the 422 macro invocation. */ 423 source_location invocation_location; 424 425 /* This is the node representing the macro being expanded at 426 top-level. The value of this data member is valid iff 427 in_macro_expansion_p() returns TRUE. */ 428 cpp_hashnode *top_most_macro_node; 429 430 /* Nonzero if we are about to expand a macro. Note that if we are 431 really expanding a macro, the function macro_of_context returns 432 the macro being expanded and this flag is set to false. Client 433 code should use the function in_macro_expansion_p to know if we 434 are either about to expand a macro, or are actually expanding 435 one. */ 436 bool about_to_expand_macro_p; 437 438 /* Search paths for include files. */ 439 struct cpp_dir *quote_include; /* "" */ 440 struct cpp_dir *bracket_include; /* <> */ 441 struct cpp_dir no_search_path; /* No path. */ 442 443 /* Chain of all hashed _cpp_file instances. */ 444 struct _cpp_file *all_files; 445 446 struct _cpp_file *main_file; 447 448 /* File and directory hash table. */ 449 struct htab *file_hash; 450 struct htab *dir_hash; 451 struct file_hash_entry_pool *file_hash_entries; 452 453 /* Negative path lookup hash table. */ 454 struct htab *nonexistent_file_hash; 455 struct obstack nonexistent_file_ob; 456 457 /* Nonzero means don't look for #include "foo" the source-file 458 directory. */ 459 bool quote_ignores_source_dir; 460 461 /* Nonzero if any file has contained #pragma once or #import has 462 been used. */ 463 bool seen_once_only; 464 465 /* Multiple include optimization. */ 466 const cpp_hashnode *mi_cmacro; 467 const cpp_hashnode *mi_ind_cmacro; 468 bool mi_valid; 469 470 /* Lexing. */ 471 cpp_token *cur_token; 472 tokenrun base_run, *cur_run; 473 unsigned int lookaheads; 474 475 /* Nonzero prevents the lexer from re-using the token runs. */ 476 unsigned int keep_tokens; 477 478 /* Buffer to hold macro definition string. */ 479 unsigned char *macro_buffer; 480 unsigned int macro_buffer_len; 481 482 /* Descriptor for converting from the source character set to the 483 execution character set. */ 484 struct cset_converter narrow_cset_desc; 485 486 /* Descriptor for converting from the source character set to the 487 UTF-8 execution character set. */ 488 struct cset_converter utf8_cset_desc; 489 490 /* Descriptor for converting from the source character set to the 491 UTF-16 execution character set. */ 492 struct cset_converter char16_cset_desc; 493 494 /* Descriptor for converting from the source character set to the 495 UTF-32 execution character set. */ 496 struct cset_converter char32_cset_desc; 497 498 /* Descriptor for converting from the source character set to the 499 wide execution character set. */ 500 struct cset_converter wide_cset_desc; 501 502 /* Date and time text. Calculated together if either is requested. */ 503 const unsigned char *date; 504 const unsigned char *time; 505 506 /* Externally set timestamp to replace current date and time useful for 507 reproducibility. It should be initialized to -2 (not yet set) and 508 set to -1 to disable it or to a non-negative value to enable it. */ 509 time_t source_date_epoch; 510 511 /* EOF token, and a token forcing paste avoidance. */ 512 cpp_token avoid_paste; 513 cpp_token eof; 514 515 /* Opaque handle to the dependencies of mkdeps.c. */ 516 struct deps *deps; 517 518 /* Obstack holding all macro hash nodes. This never shrinks. 519 See identifiers.c */ 520 struct obstack hash_ob; 521 522 /* Obstack holding buffer and conditional structures. This is a 523 real stack. See directives.c. */ 524 struct obstack buffer_ob; 525 526 /* Pragma table - dynamic, because a library user can add to the 527 list of recognized pragmas. */ 528 struct pragma_entry *pragmas; 529 530 /* Call backs to cpplib client. */ 531 struct cpp_callbacks cb; 532 533 /* Identifier hash table. */ 534 struct ht *hash_table; 535 536 /* Expression parser stack. */ 537 struct op *op_stack, *op_limit; 538 539 /* User visible options. */ 540 struct cpp_options opts; 541 542 /* Special nodes - identifiers with predefined significance to the 543 preprocessor. */ 544 struct spec_nodes spec_nodes; 545 546 /* Whether cpplib owns the hashtable. */ 547 bool our_hashtable; 548 549 /* Traditional preprocessing output buffer (a logical line). */ 550 struct 551 { 552 unsigned char *base; 553 unsigned char *limit; 554 unsigned char *cur; 555 source_location first_line; 556 } out; 557 558 /* Used for buffer overlays by traditional.c. */ 559 const unsigned char *saved_cur, *saved_rlimit, *saved_line_base; 560 561 /* A saved list of the defined macros, for dependency checking 562 of precompiled headers. */ 563 struct cpp_savedstate *savedstate; 564 565 /* Next value of __COUNTER__ macro. */ 566 unsigned int counter; 567 568 /* Table of comments, when state.save_comments is true. */ 569 cpp_comment_table comments; 570 571 /* List of saved macros by push_macro. */ 572 struct def_pragma_macro *pushed_macros; 573 574 /* If non-null, the lexer will use this location for the next token 575 instead of getting a location from the linemap. */ 576 source_location *forced_token_location_p; 577 }; 578 579 /* Character classes. Based on the more primitive macros in safe-ctype.h. 580 If the definition of `numchar' looks odd to you, please look up the 581 definition of a pp-number in the C standard [section 6.4.8 of C99]. 582 583 In the unlikely event that characters other than \r and \n enter 584 the set is_vspace, the macro handle_newline() in lex.c must be 585 updated. */ 586 #define _dollar_ok(x) ((x) == '$' && CPP_OPTION (pfile, dollars_in_ident)) 587 588 #define is_idchar(x) (ISIDNUM(x) || _dollar_ok(x)) 589 #define is_numchar(x) ISIDNUM(x) 590 #define is_idstart(x) (ISIDST(x) || _dollar_ok(x)) 591 #define is_numstart(x) ISDIGIT(x) 592 #define is_hspace(x) ISBLANK(x) 593 #define is_vspace(x) IS_VSPACE(x) 594 #define is_nvspace(x) IS_NVSPACE(x) 595 #define is_space(x) IS_SPACE_OR_NUL(x) 596 597 /* This table is constant if it can be initialized at compile time, 598 which is the case if cpp was compiled with GCC >=2.7, or another 599 compiler that supports C99. */ 600 #if HAVE_DESIGNATED_INITIALIZERS 601 extern const unsigned char _cpp_trigraph_map[UCHAR_MAX + 1]; 602 #else 603 extern unsigned char _cpp_trigraph_map[UCHAR_MAX + 1]; 604 #endif 605 606 /* Macros. */ 607 608 static inline int cpp_in_system_header (cpp_reader *); 609 static inline int 610 cpp_in_system_header (cpp_reader *pfile) 611 { 612 return pfile->buffer ? pfile->buffer->sysp : 0; 613 } 614 #define CPP_PEDANTIC(PF) CPP_OPTION (PF, cpp_pedantic) 615 #define CPP_WTRADITIONAL(PF) CPP_OPTION (PF, cpp_warn_traditional) 616 617 static inline int cpp_in_primary_file (cpp_reader *); 618 static inline int 619 cpp_in_primary_file (cpp_reader *pfile) 620 { 621 return pfile->line_table->depth == 1; 622 } 623 624 /* In macro.c */ 625 extern void _cpp_free_definition (cpp_hashnode *); 626 extern bool _cpp_create_definition (cpp_reader *, cpp_hashnode *); 627 extern void _cpp_pop_context (cpp_reader *); 628 extern void _cpp_push_text_context (cpp_reader *, cpp_hashnode *, 629 const unsigned char *, size_t); 630 extern bool _cpp_save_parameter (cpp_reader *, cpp_macro *, cpp_hashnode *, 631 cpp_hashnode *); 632 extern bool _cpp_arguments_ok (cpp_reader *, cpp_macro *, const cpp_hashnode *, 633 unsigned int); 634 extern const unsigned char *_cpp_builtin_macro_text (cpp_reader *, 635 cpp_hashnode *, 636 source_location = 0); 637 extern int _cpp_warn_if_unused_macro (cpp_reader *, cpp_hashnode *, void *); 638 extern void _cpp_push_token_context (cpp_reader *, cpp_hashnode *, 639 const cpp_token *, unsigned int); 640 extern void _cpp_backup_tokens_direct (cpp_reader *, unsigned int); 641 642 /* In identifiers.c */ 643 extern void _cpp_init_hashtable (cpp_reader *, cpp_hash_table *); 644 extern void _cpp_destroy_hashtable (cpp_reader *); 645 646 /* In files.c */ 647 typedef struct _cpp_file _cpp_file; 648 extern _cpp_file *_cpp_find_file (cpp_reader *, const char *, cpp_dir *, 649 bool, int, bool, source_location); 650 extern bool _cpp_find_failed (_cpp_file *); 651 extern void _cpp_mark_file_once_only (cpp_reader *, struct _cpp_file *); 652 extern void _cpp_fake_include (cpp_reader *, const char *); 653 extern bool _cpp_stack_file (cpp_reader *, _cpp_file*, bool, 654 source_location); 655 extern bool _cpp_stack_include (cpp_reader *, const char *, int, 656 enum include_type, source_location); 657 extern int _cpp_compare_file_date (cpp_reader *, const char *, int); 658 extern void _cpp_report_missing_guards (cpp_reader *); 659 extern void _cpp_init_files (cpp_reader *); 660 extern void _cpp_cleanup_files (cpp_reader *); 661 extern void _cpp_pop_file_buffer (cpp_reader *, struct _cpp_file *, 662 const unsigned char *); 663 extern bool _cpp_save_file_entries (cpp_reader *pfile, FILE *f); 664 extern bool _cpp_read_file_entries (cpp_reader *, FILE *); 665 extern const char *_cpp_get_file_name (_cpp_file *); 666 extern struct stat *_cpp_get_file_stat (_cpp_file *); 667 extern bool _cpp_has_header (cpp_reader *, const char *, int, 668 enum include_type); 669 670 /* In expr.c */ 671 extern bool _cpp_parse_expr (cpp_reader *, bool); 672 extern struct op *_cpp_expand_op_stack (cpp_reader *); 673 674 /* In lex.c */ 675 extern void _cpp_process_line_notes (cpp_reader *, int); 676 extern void _cpp_clean_line (cpp_reader *); 677 extern bool _cpp_get_fresh_line (cpp_reader *); 678 extern bool _cpp_skip_block_comment (cpp_reader *); 679 extern cpp_token *_cpp_temp_token (cpp_reader *); 680 extern const cpp_token *_cpp_lex_token (cpp_reader *); 681 extern cpp_token *_cpp_lex_direct (cpp_reader *); 682 extern unsigned char *_cpp_spell_ident_ucns (unsigned char *, cpp_hashnode *); 683 extern int _cpp_equiv_tokens (const cpp_token *, const cpp_token *); 684 extern void _cpp_init_tokenrun (tokenrun *, unsigned int); 685 extern cpp_hashnode *_cpp_lex_identifier (cpp_reader *, const char *); 686 extern int _cpp_remaining_tokens_num_in_context (cpp_context *); 687 extern void _cpp_init_lexer (void); 688 689 /* In init.c. */ 690 extern void _cpp_maybe_push_include_file (cpp_reader *); 691 extern const char *cpp_named_operator2name (enum cpp_ttype type); 692 693 /* In directives.c */ 694 extern int _cpp_test_assertion (cpp_reader *, unsigned int *); 695 extern int _cpp_handle_directive (cpp_reader *, int); 696 extern void _cpp_define_builtin (cpp_reader *, const char *); 697 extern char ** _cpp_save_pragma_names (cpp_reader *); 698 extern void _cpp_restore_pragma_names (cpp_reader *, char **); 699 extern int _cpp_do__Pragma (cpp_reader *, source_location); 700 extern void _cpp_init_directives (cpp_reader *); 701 extern void _cpp_init_internal_pragmas (cpp_reader *); 702 extern void _cpp_do_file_change (cpp_reader *, enum lc_reason, const char *, 703 linenum_type, unsigned int); 704 extern void _cpp_pop_buffer (cpp_reader *); 705 extern char *_cpp_bracket_include (cpp_reader *); 706 707 /* In directives.c */ 708 struct _cpp_dir_only_callbacks 709 { 710 /* Called to print a block of lines. */ 711 void (*print_lines) (int, const void *, size_t); 712 bool (*maybe_print_line) (source_location); 713 }; 714 715 extern void _cpp_preprocess_dir_only (cpp_reader *, 716 const struct _cpp_dir_only_callbacks *); 717 718 /* In traditional.c. */ 719 extern bool _cpp_scan_out_logical_line (cpp_reader *, cpp_macro *, bool); 720 extern bool _cpp_read_logical_line_trad (cpp_reader *); 721 extern void _cpp_overlay_buffer (cpp_reader *pfile, const unsigned char *, 722 size_t); 723 extern void _cpp_remove_overlay (cpp_reader *); 724 extern bool _cpp_create_trad_definition (cpp_reader *, cpp_macro *); 725 extern bool _cpp_expansions_different_trad (const cpp_macro *, 726 const cpp_macro *); 727 extern unsigned char *_cpp_copy_replacement_text (const cpp_macro *, 728 unsigned char *); 729 extern size_t _cpp_replacement_text_len (const cpp_macro *); 730 731 /* In charset.c. */ 732 733 /* The normalization state at this point in the sequence. 734 It starts initialized to all zeros, and at the end 735 'level' is the normalization level of the sequence. */ 736 737 struct normalize_state 738 { 739 /* The previous starter character. */ 740 cppchar_t previous; 741 /* The combining class of the previous character (whether or not a 742 starter). */ 743 unsigned char prev_class; 744 /* The lowest normalization level so far. */ 745 enum cpp_normalize_level level; 746 }; 747 #define INITIAL_NORMALIZE_STATE { 0, 0, normalized_KC } 748 #define NORMALIZE_STATE_RESULT(st) ((st)->level) 749 750 /* We saw a character C that matches ISIDNUM(), update a 751 normalize_state appropriately. */ 752 #define NORMALIZE_STATE_UPDATE_IDNUM(st, c) \ 753 ((st)->previous = (c), (st)->prev_class = 0) 754 755 extern bool _cpp_valid_ucn (cpp_reader *, const unsigned char **, 756 const unsigned char *, int, 757 struct normalize_state *state, 758 cppchar_t *, 759 source_range *char_range, 760 cpp_string_location_reader *loc_reader); 761 extern void _cpp_destroy_iconv (cpp_reader *); 762 extern unsigned char *_cpp_convert_input (cpp_reader *, const char *, 763 unsigned char *, size_t, size_t, 764 const unsigned char **, off_t *); 765 extern const char *_cpp_default_encoding (void); 766 extern cpp_hashnode * _cpp_interpret_identifier (cpp_reader *pfile, 767 const unsigned char *id, 768 size_t len); 769 770 /* Utility routines and macros. */ 771 #define DSC(str) (const unsigned char *)str, sizeof str - 1 772 773 /* These are inline functions instead of macros so we can get type 774 checking. */ 775 static inline int ustrcmp (const unsigned char *, const unsigned char *); 776 static inline int ustrncmp (const unsigned char *, const unsigned char *, 777 size_t); 778 static inline size_t ustrlen (const unsigned char *); 779 static inline const unsigned char *uxstrdup (const unsigned char *); 780 static inline const unsigned char *ustrchr (const unsigned char *, int); 781 static inline int ufputs (const unsigned char *, FILE *); 782 783 /* Use a const char for the second parameter since it is usually a literal. */ 784 static inline int ustrcspn (const unsigned char *, const char *); 785 786 static inline int 787 ustrcmp (const unsigned char *s1, const unsigned char *s2) 788 { 789 return strcmp ((const char *)s1, (const char *)s2); 790 } 791 792 static inline int 793 ustrncmp (const unsigned char *s1, const unsigned char *s2, size_t n) 794 { 795 return strncmp ((const char *)s1, (const char *)s2, n); 796 } 797 798 static inline int 799 ustrcspn (const unsigned char *s1, const char *s2) 800 { 801 return strcspn ((const char *)s1, s2); 802 } 803 804 static inline size_t 805 ustrlen (const unsigned char *s1) 806 { 807 return strlen ((const char *)s1); 808 } 809 810 static inline const unsigned char * 811 uxstrdup (const unsigned char *s1) 812 { 813 return (const unsigned char *) xstrdup ((const char *)s1); 814 } 815 816 static inline const unsigned char * 817 ustrchr (const unsigned char *s1, int c) 818 { 819 return (const unsigned char *) strchr ((const char *)s1, c); 820 } 821 822 static inline int 823 ufputs (const unsigned char *s, FILE *f) 824 { 825 return fputs ((const char *)s, f); 826 } 827 828 /* In line-map.c. */ 829 830 /* Create a macro map. A macro map encodes source locations of tokens 831 that are part of a macro replacement-list, at a macro expansion 832 point. See the extensive comments of struct line_map and struct 833 line_map_macro, in line-map.h. 834 835 This map shall be created when the macro is expanded. The map 836 encodes the source location of the expansion point of the macro as 837 well as the "original" source location of each token that is part 838 of the macro replacement-list. If a macro is defined but never 839 expanded, it has no macro map. SET is the set of maps the macro 840 map should be part of. MACRO_NODE is the macro which the new macro 841 map should encode source locations for. EXPANSION is the location 842 of the expansion point of MACRO. For function-like macros 843 invocations, it's best to make it point to the closing parenthesis 844 of the macro, rather than the the location of the first character 845 of the macro. NUM_TOKENS is the number of tokens that are part of 846 the replacement-list of MACRO. */ 847 const line_map_macro *linemap_enter_macro (struct line_maps *, 848 struct cpp_hashnode*, 849 source_location, 850 unsigned int); 851 852 /* Create and return a virtual location for a token that is part of a 853 macro expansion-list at a macro expansion point. See the comment 854 inside struct line_map_macro to see what an expansion-list exactly 855 is. 856 857 A call to this function must come after a call to 858 linemap_enter_macro. 859 860 MAP is the map into which the source location is created. TOKEN_NO 861 is the index of the token in the macro replacement-list, starting 862 at number 0. 863 864 ORIG_LOC is the location of the token outside of this macro 865 expansion. If the token comes originally from the macro 866 definition, it is the locus in the macro definition; otherwise it 867 is a location in the context of the caller of this macro expansion 868 (which is a virtual location or a source location if the caller is 869 itself a macro expansion or not). 870 871 MACRO_DEFINITION_LOC is the location in the macro definition, 872 either of the token itself or of a macro parameter that it 873 replaces. */ 874 source_location linemap_add_macro_token (const line_map_macro *, 875 unsigned int, 876 source_location, 877 source_location); 878 879 /* Return the source line number corresponding to source location 880 LOCATION. SET is the line map set LOCATION comes from. If 881 LOCATION is the location of token that is part of the 882 expansion-list of a macro expansion return the line number of the 883 macro expansion point. */ 884 int linemap_get_expansion_line (struct line_maps *, 885 source_location); 886 887 /* Return the path of the file corresponding to source code location 888 LOCATION. 889 890 If LOCATION is the location of a token that is part of the 891 replacement-list of a macro expansion return the file path of the 892 macro expansion point. 893 894 SET is the line map set LOCATION comes from. */ 895 const char* linemap_get_expansion_filename (struct line_maps *, 896 source_location); 897 898 #ifdef __cplusplus 899 } 900 #endif 901 902 #endif /* ! LIBCPP_INTERNAL_H */ 903