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