1/* Part of CPP library. 2 Copyright (C) 1997-2015 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 "cpp-id-data.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 struct line_maps *line_table = PFILE->line_table; \ 71 const struct line_map *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. */ 82struct 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. */ 101typedef struct _cpp_buff _cpp_buff; 102struct _cpp_buff 103{ 104 struct _cpp_buff *next; 105 unsigned char *base, *cur, *limit; 106}; 107 108extern _cpp_buff *_cpp_get_buff (cpp_reader *, size_t); 109extern void _cpp_release_buff (cpp_reader *, _cpp_buff *); 110extern void _cpp_extend_buff (cpp_reader *, _cpp_buff **, size_t); 111extern _cpp_buff *_cpp_append_extend_buff (cpp_reader *, _cpp_buff *, size_t); 112extern void _cpp_free_buff (_cpp_buff *); 113extern unsigned char *_cpp_aligned_alloc (cpp_reader *, size_t); 114extern 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. */ 121enum include_type {IT_INCLUDE, IT_INCLUDE_NEXT, IT_IMPORT, IT_CMDLINE, IT_DEFAULT}; 122 123union 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. */ 130typedef struct tokenrun tokenrun; 131struct 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. */ 146typedef 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. */ 162enum 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 177typedef struct cpp_context cpp_context; 178struct 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 226struct 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__ is 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. */ 279struct 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__has_include__; /* __has_include__ operator */ 286 cpp_hashnode *n__has_include_next__; /* __has_include_next__ operator */ 287}; 288 289typedef struct _cpp_line_note _cpp_line_note; 290struct _cpp_line_note 291{ 292 /* Location in the clean line the note refers to. */ 293 const unsigned char *pos; 294 295 /* Type of note. The 9 'from' trigraph characters represent those 296 trigraphs, '\\' an escaped newline, ' ' an escaped newline with 297 intervening space, 0 represents a note that has already been handled, 298 and anything else is invalid. */ 299 unsigned int type; 300}; 301 302/* Represents the contents of a file cpplib has read in. */ 303struct cpp_buffer 304{ 305 const unsigned char *cur; /* Current location. */ 306 const unsigned char *line_base; /* Start of current physical line. */ 307 const unsigned char *next_line; /* Start of to-be-cleaned logical line. */ 308 309 const unsigned char *buf; /* Entire character buffer. */ 310 const unsigned char *rlimit; /* Writable byte at end of file. */ 311 const unsigned char *to_free; /* Pointer that should be freed when 312 popping the buffer. */ 313 314 _cpp_line_note *notes; /* Array of notes. */ 315 unsigned int cur_note; /* Next note to process. */ 316 unsigned int notes_used; /* Number of notes. */ 317 unsigned int notes_cap; /* Size of allocated array. */ 318 319 struct cpp_buffer *prev; 320 321 /* Pointer into the file table; non-NULL if this is a file buffer. 322 Used for include_next and to record control macros. */ 323 struct _cpp_file *file; 324 325 /* Saved value of __TIMESTAMP__ macro - date and time of last modification 326 of the assotiated file. */ 327 const unsigned char *timestamp; 328 329 /* Value of if_stack at start of this file. 330 Used to prohibit unmatched #endif (etc) in an include file. */ 331 struct if_stack *if_stack; 332 333 /* True if we need to get the next clean line. */ 334 bool need_line; 335 336 /* True if we have already warned about C++ comments in this file. 337 The warning happens only for C89 extended mode with -pedantic on, 338 or for -Wtraditional, and only once per file (otherwise it would 339 be far too noisy). */ 340 unsigned int warned_cplusplus_comments : 1; 341 342 /* True if we don't process trigraphs and escaped newlines. True 343 for preprocessed input, command line directives, and _Pragma 344 buffers. */ 345 unsigned int from_stage3 : 1; 346 347 /* At EOF, a buffer is automatically popped. If RETURN_AT_EOF is 348 true, a CPP_EOF token is then returned. Otherwise, the next 349 token from the enclosing buffer is returned. */ 350 unsigned int return_at_eof : 1; 351 352 /* One for a system header, two for a C system header file that therefore 353 needs to be extern "C" protected in C++, and zero otherwise. */ 354 unsigned char sysp; 355 356 /* The directory of the this buffer's file. Its NAME member is not 357 allocated, so we don't need to worry about freeing it. */ 358 struct cpp_dir dir; 359 360 /* Descriptor for converting from the input character set to the 361 source character set. */ 362 struct cset_converter input_cset_desc; 363}; 364 365/* The list of saved macros by push_macro pragma. */ 366struct def_pragma_macro { 367 /* Chain element to previous saved macro. */ 368 struct def_pragma_macro *next; 369 /* Name of the macro. */ 370 char *name; 371 /* The stored macro content. */ 372 unsigned char *definition; 373 374 /* Definition line number. */ 375 source_location line; 376 /* If macro defined in system header. */ 377 unsigned int syshdr : 1; 378 /* Nonzero if it has been expanded or had its existence tested. */ 379 unsigned int used : 1; 380 381 /* Mark if we save an undefined macro. */ 382 unsigned int is_undef : 1; 383}; 384 385/* A cpp_reader encapsulates the "state" of a pre-processor run. 386 Applying cpp_get_token repeatedly yields a stream of pre-processor 387 tokens. Usually, there is only one cpp_reader object active. */ 388struct cpp_reader 389{ 390 /* Top of buffer stack. */ 391 cpp_buffer *buffer; 392 393 /* Overlaid buffer (can be different after processing #include). */ 394 cpp_buffer *overlaid_buffer; 395 396 /* Lexer state. */ 397 struct lexer_state state; 398 399 /* Source line tracking. */ 400 struct line_maps *line_table; 401 402 /* The line of the '#' of the current directive. */ 403 source_location directive_line; 404 405 /* Memory buffers. */ 406 _cpp_buff *a_buff; /* Aligned permanent storage. */ 407 _cpp_buff *u_buff; /* Unaligned permanent storage. */ 408 _cpp_buff *free_buffs; /* Free buffer chain. */ 409 410 /* Context stack. */ 411 struct cpp_context base_context; 412 struct cpp_context *context; 413 414 /* If in_directive, the directive if known. */ 415 const struct directive *directive; 416 417 /* Token generated while handling a directive, if any. */ 418 cpp_token directive_result; 419 420 /* When expanding a macro at top-level, this is the location of the 421 macro invocation. */ 422 source_location invocation_location; 423 424 /* This is the node representing the macro being expanded at 425 top-level. The value of this data member is valid iff 426 in_macro_expansion_p() returns TRUE. */ 427 cpp_hashnode *top_most_macro_node; 428 429 /* Nonzero if we are about to expand a macro. Note that if we are 430 really expanding a macro, the function macro_of_context returns 431 the macro being expanded and this flag is set to false. Client 432 code should use the function in_macro_expansion_p to know if we 433 are either about to expand a macro, or are actually expanding 434 one. */ 435 bool about_to_expand_macro_p; 436 437 /* Search paths for include files. */ 438 struct cpp_dir *quote_include; /* "" */ 439 struct cpp_dir *bracket_include; /* <> */ 440 struct cpp_dir no_search_path; /* No path. */ 441 442 /* Chain of all hashed _cpp_file instances. */ 443 struct _cpp_file *all_files; 444 445 struct _cpp_file *main_file; 446 447 /* File and directory hash table. */ 448 struct htab *file_hash; 449 struct htab *dir_hash; 450 struct file_hash_entry_pool *file_hash_entries; 451 452 /* Negative path lookup hash table. */ 453 struct htab *nonexistent_file_hash; 454 struct obstack nonexistent_file_ob; 455 456 /* Nonzero means don't look for #include "foo" the source-file 457 directory. */ 458 bool quote_ignores_source_dir; 459 460 /* Nonzero if any file has contained #pragma once or #import has 461 been used. */ 462 bool seen_once_only; 463 464 /* Multiple include optimization. */ 465 const cpp_hashnode *mi_cmacro; 466 const cpp_hashnode *mi_ind_cmacro; 467 bool mi_valid; 468 469 /* Lexing. */ 470 cpp_token *cur_token; 471 tokenrun base_run, *cur_run; 472 unsigned int lookaheads; 473 474 /* Nonzero prevents the lexer from re-using the token runs. */ 475 unsigned int keep_tokens; 476 477 /* Buffer to hold macro definition string. */ 478 unsigned char *macro_buffer; 479 unsigned int macro_buffer_len; 480 481 /* Descriptor for converting from the source character set to the 482 execution character set. */ 483 struct cset_converter narrow_cset_desc; 484 485 /* Descriptor for converting from the source character set to the 486 UTF-8 execution character set. */ 487 struct cset_converter utf8_cset_desc; 488 489 /* Descriptor for converting from the source character set to the 490 UTF-16 execution character set. */ 491 struct cset_converter char16_cset_desc; 492 493 /* Descriptor for converting from the source character set to the 494 UTF-32 execution character set. */ 495 struct cset_converter char32_cset_desc; 496 497 /* Descriptor for converting from the source character set to the 498 wide execution character set. */ 499 struct cset_converter wide_cset_desc; 500 501 /* Date and time text. Calculated together if either is requested. */ 502 const unsigned char *date; 503 const unsigned char *time; 504 505 /* EOF token, and a token forcing paste avoidance. */ 506 cpp_token avoid_paste; 507 cpp_token eof; 508 509 /* Opaque handle to the dependencies of mkdeps.c. */ 510 struct deps *deps; 511 512 /* Obstack holding all macro hash nodes. This never shrinks. 513 See identifiers.c */ 514 struct obstack hash_ob; 515 516 /* Obstack holding buffer and conditional structures. This is a 517 real stack. See directives.c. */ 518 struct obstack buffer_ob; 519 520 /* Pragma table - dynamic, because a library user can add to the 521 list of recognized pragmas. */ 522 struct pragma_entry *pragmas; 523 524 /* Call backs to cpplib client. */ 525 struct cpp_callbacks cb; 526 527 /* Identifier hash table. */ 528 struct ht *hash_table; 529 530 /* Expression parser stack. */ 531 struct op *op_stack, *op_limit; 532 533 /* User visible options. */ 534 struct cpp_options opts; 535 536 /* Special nodes - identifiers with predefined significance to the 537 preprocessor. */ 538 struct spec_nodes spec_nodes; 539 540 /* Whether cpplib owns the hashtable. */ 541 bool our_hashtable; 542 543 /* Traditional preprocessing output buffer (a logical line). */ 544 struct 545 { 546 unsigned char *base; 547 unsigned char *limit; 548 unsigned char *cur; 549 source_location first_line; 550 } out; 551 552 /* Used for buffer overlays by traditional.c. */ 553 const unsigned char *saved_cur, *saved_rlimit, *saved_line_base; 554 555 /* A saved list of the defined macros, for dependency checking 556 of precompiled headers. */ 557 struct cpp_savedstate *savedstate; 558 559 /* Next value of __COUNTER__ macro. */ 560 unsigned int counter; 561 562 /* Table of comments, when state.save_comments is true. */ 563 cpp_comment_table comments; 564 565 /* List of saved macros by push_macro. */ 566 struct def_pragma_macro *pushed_macros; 567 568 /* If non-null, the lexer will use this location for the next token 569 instead of getting a location from the linemap. */ 570 source_location *forced_token_location_p; 571}; 572 573/* Character classes. Based on the more primitive macros in safe-ctype.h. 574 If the definition of `numchar' looks odd to you, please look up the 575 definition of a pp-number in the C standard [section 6.4.8 of C99]. 576 577 In the unlikely event that characters other than \r and \n enter 578 the set is_vspace, the macro handle_newline() in lex.c must be 579 updated. */ 580#define _dollar_ok(x) ((x) == '$' && CPP_OPTION (pfile, dollars_in_ident)) 581 582#define is_idchar(x) (ISIDNUM(x) || _dollar_ok(x)) 583#define is_numchar(x) ISIDNUM(x) 584#define is_idstart(x) (ISIDST(x) || _dollar_ok(x)) 585#define is_numstart(x) ISDIGIT(x) 586#define is_hspace(x) ISBLANK(x) 587#define is_vspace(x) IS_VSPACE(x) 588#define is_nvspace(x) IS_NVSPACE(x) 589#define is_space(x) IS_SPACE_OR_NUL(x) 590 591/* This table is constant if it can be initialized at compile time, 592 which is the case if cpp was compiled with GCC >=2.7, or another 593 compiler that supports C99. */ 594#if HAVE_DESIGNATED_INITIALIZERS 595extern const unsigned char _cpp_trigraph_map[UCHAR_MAX + 1]; 596#else 597extern unsigned char _cpp_trigraph_map[UCHAR_MAX + 1]; 598#endif 599 600/* Macros. */ 601 602static inline int cpp_in_system_header (cpp_reader *); 603static inline int 604cpp_in_system_header (cpp_reader *pfile) 605{ 606 return pfile->buffer ? pfile->buffer->sysp : 0; 607} 608#define CPP_PEDANTIC(PF) CPP_OPTION (PF, cpp_pedantic) 609#define CPP_WTRADITIONAL(PF) CPP_OPTION (PF, cpp_warn_traditional) 610 611static inline int cpp_in_primary_file (cpp_reader *); 612static inline int 613cpp_in_primary_file (cpp_reader *pfile) 614{ 615 return pfile->line_table->depth == 1; 616} 617 618/* In macro.c */ 619extern void _cpp_free_definition (cpp_hashnode *); 620extern bool _cpp_create_definition (cpp_reader *, cpp_hashnode *); 621extern void _cpp_pop_context (cpp_reader *); 622extern void _cpp_push_text_context (cpp_reader *, cpp_hashnode *, 623 const unsigned char *, size_t); 624extern bool _cpp_save_parameter (cpp_reader *, cpp_macro *, cpp_hashnode *, 625 cpp_hashnode *); 626extern bool _cpp_arguments_ok (cpp_reader *, cpp_macro *, const cpp_hashnode *, 627 unsigned int); 628extern const unsigned char *_cpp_builtin_macro_text (cpp_reader *, 629 cpp_hashnode *); 630extern int _cpp_warn_if_unused_macro (cpp_reader *, cpp_hashnode *, void *); 631extern void _cpp_push_token_context (cpp_reader *, cpp_hashnode *, 632 const cpp_token *, unsigned int); 633extern void _cpp_backup_tokens_direct (cpp_reader *, unsigned int); 634 635/* In identifiers.c */ 636extern void _cpp_init_hashtable (cpp_reader *, cpp_hash_table *); 637extern void _cpp_destroy_hashtable (cpp_reader *); 638 639/* In files.c */ 640typedef struct _cpp_file _cpp_file; 641extern _cpp_file *_cpp_find_file (cpp_reader *, const char *, cpp_dir *, 642 bool, int, bool); 643extern bool _cpp_find_failed (_cpp_file *); 644extern void _cpp_mark_file_once_only (cpp_reader *, struct _cpp_file *); 645extern void _cpp_fake_include (cpp_reader *, const char *); 646extern bool _cpp_stack_file (cpp_reader *, _cpp_file*, bool); 647extern bool _cpp_stack_include (cpp_reader *, const char *, int, 648 enum include_type); 649extern int _cpp_compare_file_date (cpp_reader *, const char *, int); 650extern void _cpp_report_missing_guards (cpp_reader *); 651extern void _cpp_init_files (cpp_reader *); 652extern void _cpp_cleanup_files (cpp_reader *); 653extern void _cpp_pop_file_buffer (cpp_reader *, struct _cpp_file *, 654 const unsigned char *); 655extern bool _cpp_save_file_entries (cpp_reader *pfile, FILE *f); 656extern bool _cpp_read_file_entries (cpp_reader *, FILE *); 657extern const char *_cpp_get_file_name (_cpp_file *); 658extern struct stat *_cpp_get_file_stat (_cpp_file *); 659extern bool _cpp_has_header (cpp_reader *, const char *, int, 660 enum include_type); 661 662/* In expr.c */ 663extern bool _cpp_parse_expr (cpp_reader *, bool); 664extern struct op *_cpp_expand_op_stack (cpp_reader *); 665 666/* In lex.c */ 667extern void _cpp_process_line_notes (cpp_reader *, int); 668extern void _cpp_clean_line (cpp_reader *); 669extern bool _cpp_get_fresh_line (cpp_reader *); 670extern bool _cpp_skip_block_comment (cpp_reader *); 671extern cpp_token *_cpp_temp_token (cpp_reader *); 672extern const cpp_token *_cpp_lex_token (cpp_reader *); 673extern cpp_token *_cpp_lex_direct (cpp_reader *); 674extern unsigned char *_cpp_spell_ident_ucns (unsigned char *, cpp_hashnode *); 675extern int _cpp_equiv_tokens (const cpp_token *, const cpp_token *); 676extern void _cpp_init_tokenrun (tokenrun *, unsigned int); 677extern cpp_hashnode *_cpp_lex_identifier (cpp_reader *, const char *); 678extern int _cpp_remaining_tokens_num_in_context (cpp_context *); 679extern void _cpp_init_lexer (void); 680 681/* In init.c. */ 682extern void _cpp_maybe_push_include_file (cpp_reader *); 683extern const char *cpp_named_operator2name (enum cpp_ttype type); 684 685/* In directives.c */ 686extern int _cpp_test_assertion (cpp_reader *, unsigned int *); 687extern int _cpp_handle_directive (cpp_reader *, int); 688extern void _cpp_define_builtin (cpp_reader *, const char *); 689extern char ** _cpp_save_pragma_names (cpp_reader *); 690extern void _cpp_restore_pragma_names (cpp_reader *, char **); 691extern int _cpp_do__Pragma (cpp_reader *); 692extern void _cpp_init_directives (cpp_reader *); 693extern void _cpp_init_internal_pragmas (cpp_reader *); 694extern void _cpp_do_file_change (cpp_reader *, enum lc_reason, const char *, 695 linenum_type, unsigned int); 696extern void _cpp_pop_buffer (cpp_reader *); 697extern char *_cpp_bracket_include (cpp_reader *); 698 699/* In directives.c */ 700struct _cpp_dir_only_callbacks 701{ 702 /* Called to print a block of lines. */ 703 void (*print_lines) (int, const void *, size_t); 704 void (*maybe_print_line) (source_location); 705}; 706 707extern void _cpp_preprocess_dir_only (cpp_reader *, 708 const struct _cpp_dir_only_callbacks *); 709 710/* In traditional.c. */ 711extern bool _cpp_scan_out_logical_line (cpp_reader *, cpp_macro *, bool); 712extern bool _cpp_read_logical_line_trad (cpp_reader *); 713extern void _cpp_overlay_buffer (cpp_reader *pfile, const unsigned char *, 714 size_t); 715extern void _cpp_remove_overlay (cpp_reader *); 716extern bool _cpp_create_trad_definition (cpp_reader *, cpp_macro *); 717extern bool _cpp_expansions_different_trad (const cpp_macro *, 718 const cpp_macro *); 719extern unsigned char *_cpp_copy_replacement_text (const cpp_macro *, 720 unsigned char *); 721extern size_t _cpp_replacement_text_len (const cpp_macro *); 722 723/* In charset.c. */ 724 725/* The normalization state at this point in the sequence. 726 It starts initialized to all zeros, and at the end 727 'level' is the normalization level of the sequence. */ 728 729struct normalize_state 730{ 731 /* The previous starter character. */ 732 cppchar_t previous; 733 /* The combining class of the previous character (whether or not a 734 starter). */ 735 unsigned char prev_class; 736 /* The lowest normalization level so far. */ 737 enum cpp_normalize_level level; 738}; 739#define INITIAL_NORMALIZE_STATE { 0, 0, normalized_KC } 740#define NORMALIZE_STATE_RESULT(st) ((st)->level) 741 742/* We saw a character C that matches ISIDNUM(), update a 743 normalize_state appropriately. */ 744#define NORMALIZE_STATE_UPDATE_IDNUM(st, c) \ 745 ((st)->previous = (c), (st)->prev_class = 0) 746 747extern cppchar_t _cpp_valid_ucn (cpp_reader *, const unsigned char **, 748 const unsigned char *, int, 749 struct normalize_state *state); 750extern void _cpp_destroy_iconv (cpp_reader *); 751extern unsigned char *_cpp_convert_input (cpp_reader *, const char *, 752 unsigned char *, size_t, size_t, 753 const unsigned char **, off_t *); 754extern const char *_cpp_default_encoding (void); 755extern cpp_hashnode * _cpp_interpret_identifier (cpp_reader *pfile, 756 const unsigned char *id, 757 size_t len); 758 759/* Utility routines and macros. */ 760#define DSC(str) (const unsigned char *)str, sizeof str - 1 761 762/* These are inline functions instead of macros so we can get type 763 checking. */ 764static inline int ustrcmp (const unsigned char *, const unsigned char *); 765static inline int ustrncmp (const unsigned char *, const unsigned char *, 766 size_t); 767static inline size_t ustrlen (const unsigned char *); 768static inline const unsigned char *uxstrdup (const unsigned char *); 769static inline const unsigned char *ustrchr (const unsigned char *, int); 770static inline int ufputs (const unsigned char *, FILE *); 771 772/* Use a const char for the second parameter since it is usually a literal. */ 773static inline int ustrcspn (const unsigned char *, const char *); 774 775static inline int 776ustrcmp (const unsigned char *s1, const unsigned char *s2) 777{ 778 return strcmp ((const char *)s1, (const char *)s2); 779} 780 781static inline int 782ustrncmp (const unsigned char *s1, const unsigned char *s2, size_t n) 783{ 784 return strncmp ((const char *)s1, (const char *)s2, n); 785} 786 787static inline int 788ustrcspn (const unsigned char *s1, const char *s2) 789{ 790 return strcspn ((const char *)s1, s2); 791} 792 793static inline size_t 794ustrlen (const unsigned char *s1) 795{ 796 return strlen ((const char *)s1); 797} 798 799static inline const unsigned char * 800uxstrdup (const unsigned char *s1) 801{ 802 return (const unsigned char *) xstrdup ((const char *)s1); 803} 804 805static inline const unsigned char * 806ustrchr (const unsigned char *s1, int c) 807{ 808 return (const unsigned char *) strchr ((const char *)s1, c); 809} 810 811static inline int 812ufputs (const unsigned char *s, FILE *f) 813{ 814 return fputs ((const char *)s, f); 815} 816 817 /* In line-map.c. */ 818 819/* Create a macro map. A macro map encodes source locations of tokens 820 that are part of a macro replacement-list, at a macro expansion 821 point. See the extensive comments of struct line_map and struct 822 line_map_macro, in line-map.h. 823 824 This map shall be created when the macro is expanded. The map 825 encodes the source location of the expansion point of the macro as 826 well as the "original" source location of each token that is part 827 of the macro replacement-list. If a macro is defined but never 828 expanded, it has no macro map. SET is the set of maps the macro 829 map should be part of. MACRO_NODE is the macro which the new macro 830 map should encode source locations for. EXPANSION is the location 831 of the expansion point of MACRO. For function-like macros 832 invocations, it's best to make it point to the closing parenthesis 833 of the macro, rather than the the location of the first character 834 of the macro. NUM_TOKENS is the number of tokens that are part of 835 the replacement-list of MACRO. */ 836const struct line_map *linemap_enter_macro (struct line_maps *, 837 struct cpp_hashnode*, 838 source_location, 839 unsigned int); 840 841/* Create and return a virtual location for a token that is part of a 842 macro expansion-list at a macro expansion point. See the comment 843 inside struct line_map_macro to see what an expansion-list exactly 844 is. 845 846 A call to this function must come after a call to 847 linemap_enter_macro. 848 849 MAP is the map into which the source location is created. TOKEN_NO 850 is the index of the token in the macro replacement-list, starting 851 at number 0. 852 853 ORIG_LOC is the location of the token outside of this macro 854 expansion. If the token comes originally from the macro 855 definition, it is the locus in the macro definition; otherwise it 856 is a location in the context of the caller of this macro expansion 857 (which is a virtual location or a source location if the caller is 858 itself a macro expansion or not). 859 860 MACRO_DEFINITION_LOC is the location in the macro definition, 861 either of the token itself or of a macro parameter that it 862 replaces. */ 863source_location linemap_add_macro_token (const struct line_map *, 864 unsigned int, 865 source_location, 866 source_location); 867 868/* Return the source line number corresponding to source location 869 LOCATION. SET is the line map set LOCATION comes from. If 870 LOCATION is the location of token that is part of the 871 expansion-list of a macro expansion return the line number of the 872 macro expansion point. */ 873int linemap_get_expansion_line (struct line_maps *, 874 source_location); 875 876/* Return the path of the file corresponding to source code location 877 LOCATION. 878 879 If LOCATION is the location of a token that is part of the 880 replacement-list of a macro expansion return the file path of the 881 macro expansion point. 882 883 SET is the line map set LOCATION comes from. */ 884const char* linemap_get_expansion_filename (struct line_maps *, 885 source_location); 886 887#ifdef __cplusplus 888} 889#endif 890 891#endif /* ! LIBCPP_INTERNAL_H */ 892