1/* Definitions for CPP library. 2 Copyright (C) 1995, 1996, 1997, 1998, 1999 Free Software Foundation, Inc. 3 Written by Per Bothner, 1994-95. 4 5This program is free software; you can redistribute it and/or modify it 6under the terms of the GNU General Public License as published by the 7Free Software Foundation; either version 2, or (at your option) any 8later version. 9 10This program is distributed in the hope that it will be useful, 11but WITHOUT ANY WARRANTY; without even the implied warranty of 12MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13GNU General Public License for more details. 14 15You should have received a copy of the GNU General Public License 16along with this program; if not, write to the Free Software 17Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 18 19 In other words, you are welcome to use, share and improve this program. 20 You are forbidden to forbid anyone else to use, share and improve 21 what you give them. Help stamp out software-hoarding! */ 22#ifndef __GCC_CPPLIB__ 23#define __GCC_CPPLIB__ 24 25#include <sys/types.h> 26 27#ifdef __cplusplus 28extern "C" { 29#endif 30 31typedef unsigned char U_CHAR; 32 33typedef struct cpp_reader cpp_reader; 34typedef struct cpp_buffer cpp_buffer; 35typedef struct cpp_options cpp_options; 36typedef struct hashnode cpp_hashnode; 37 38enum cpp_token { 39 CPP_EOF = -1, 40 CPP_OTHER = 0, 41 CPP_COMMENT = 1, 42 CPP_HSPACE, 43 CPP_VSPACE, /* newlines and #line directives */ 44 CPP_NAME, 45 CPP_NUMBER, 46 CPP_CHAR, 47 CPP_STRING, 48 CPP_DIRECTIVE, 49 CPP_LPAREN, /* "(" */ 50 CPP_RPAREN, /* ")" */ 51 CPP_LBRACE, /* "{" */ 52 CPP_RBRACE, /* "}" */ 53 CPP_COMMA, /* "," */ 54 CPP_SEMICOLON,/* ";" */ 55 CPP_3DOTS, /* "..." */ 56#if 0 57 CPP_ANDAND, /* "&&" */ 58 CPP_OROR, /* "||" */ 59 CPP_LSH, /* "<<" */ 60 CPP_RSH, /* ">>" */ 61 CPP_EQL, /* "==" */ 62 CPP_NEQ, /* "!=" */ 63 CPP_LEQ, /* "<=" */ 64 CPP_GEQ, /* ">=" */ 65 CPP_PLPL, /* "++" */ 66 CPP_MINMIN, /* "--" */ 67#endif 68 /* POP_TOKEN is returned when we've popped a cpp_buffer. */ 69 CPP_POP 70}; 71 72typedef enum cpp_token (*parse_underflow_t) PARAMS((cpp_reader *)); 73typedef int (*parse_cleanup_t) PARAMS((cpp_buffer *, cpp_reader *)); 74 75extern void parse_set_mark PARAMS ((cpp_reader *)); 76extern void parse_clear_mark PARAMS ((cpp_reader *)); 77extern void parse_goto_mark PARAMS ((cpp_reader *)); 78 79extern int cpp_handle_option PARAMS ((cpp_reader *, int, char **)); 80extern int cpp_handle_options PARAMS ((cpp_reader *, int, char **)); 81extern enum cpp_token cpp_get_token PARAMS ((cpp_reader *)); 82extern void cpp_skip_hspace PARAMS((cpp_reader *)); 83extern enum cpp_token cpp_get_non_space_token PARAMS ((cpp_reader *)); 84 85/* This frees resources used by PFILE. */ 86extern void cpp_cleanup PARAMS ((cpp_reader *PFILE)); 87 88struct cpp_buffer 89{ 90 unsigned char *cur; /* current position */ 91 unsigned char *rlimit; /* end of valid data */ 92 unsigned char *buf; /* entire buffer */ 93 unsigned char *alimit; /* end of allocated buffer */ 94 unsigned char *line_base; /* start of current line */ 95 96 struct cpp_buffer *prev; 97 98 /* Real filename. (Alias to ->ihash->fname, obsolete). */ 99 char *fname; 100 /* Filename specified with #line command. */ 101 char *nominal_fname; 102 /* Last filename specified with #line command. */ 103 char *last_nominal_fname; 104 /* Actual directory of this file, used only for "" includes */ 105 struct file_name_list *actual_dir; 106 107 /* Pointer into the include hash table. Used for include_next and 108 to record control macros. */ 109 struct include_hash *ihash; 110 111 long lineno; /* Line number at CPP_LINE_BASE. */ 112 long colno; /* Column number at CPP_LINE_BASE. */ 113 long mark; /* Saved position for lengthy backtrack. */ 114 parse_underflow_t underflow; 115 parse_cleanup_t cleanup; 116 void *data; 117 118 /* Value of if_stack at start of this file. 119 Used to prohibit unmatched #endif (etc) in an include file. */ 120 struct if_stack *if_stack; 121 122 /* True if this is a header file included using <FILENAME>. */ 123 char system_header_p; 124 char seen_eof; 125 126 /* True if buffer contains escape sequences. 127 Currently there are two kinds: 128 "\r-" means following identifier should not be macro-expanded. 129 "\r " means a token-separator. This turns into " " in final output 130 if not stringizing and needed to separate tokens; otherwise nothing. 131 Any other two-character sequence beginning with \r is an error. 132 133 If this is NOT set, then \r is a one-character escape meaning backslash 134 newline. This is guaranteed not to occur in the middle of a token. 135 The two interpretations of \r do not conflict, because the two-character 136 escapes are used only in macro buffers, and backslash-newline is removed 137 from macro expansion text in collect_expansion and/or macarg. */ 138 char has_escapes; 139}; 140 141struct file_name_map_list; 142 143/* Maximum nesting of cpp_buffers. We use a static limit, partly for 144 efficiency, and partly to limit runaway recursion. */ 145#define CPP_STACK_MAX 200 146 147/* A cpp_reader encapsulates the "state" of a pre-processor run. 148 Applying cpp_get_token repeatedly yields a stream of pre-processor 149 tokens. Usually, there is only one cpp_reader object active. */ 150 151struct cpp_reader 152{ 153 parse_underflow_t get_token; 154 cpp_buffer *buffer; 155 cpp_options *opts; 156 157 /* A buffer used for both for cpp_get_token's output, and also internally. */ 158 unsigned char *token_buffer; 159 /* Allocated size of token_buffer. CPP_RESERVE allocates space. */ 160 unsigned int token_buffer_size; 161 /* End of the written part of token_buffer. */ 162 unsigned char *limit; 163 164 /* Error counter for exit code */ 165 int errors; 166 167 /* Line where a newline was first seen in a string constant. */ 168 int multiline_string_line; 169 170 /* Current depth in #include directives that use <...>. */ 171 int system_include_depth; 172 173 /* Current depth of buffer stack. */ 174 int buffer_stack_depth; 175 176 /* Hash table of macros and assertions. See cpphash.c */ 177#define HASHSIZE 1403 178 struct hashnode **hashtab; 179 180 /* Hash table of other included files. See cppfiles.c */ 181#define ALL_INCLUDE_HASHSIZE 71 182 struct include_hash *all_include_files[ALL_INCLUDE_HASHSIZE]; 183 184 /* Chain of `actual directory' file_name_list entries, 185 for "" inclusion. */ 186 struct file_name_list *actual_dirs; 187 188 /* Current maximum length of directory names in the search path 189 for include files. (Altered as we get more of them.) */ 190 unsigned int max_include_len; 191 192 struct if_stack *if_stack; 193 194 /* Nonzero means we are inside an IF during a -pcp run. In this mode 195 macro expansion is done, and preconditions are output for all macro 196 uses requiring them. */ 197 char pcp_inside_if; 198 199 /* Nonzero means we have printed (while error reporting) a list of 200 containing files that matches the current status. */ 201 char input_stack_listing_current; 202 203 /* If non-zero, macros are not expanded. */ 204 char no_macro_expand; 205 206 /* Print column number in error messages. */ 207 char show_column; 208 209 /* We're printed a warning recommending against using #import. */ 210 char import_warning; 211 212 /* If true, character between '<' and '>' are a single (string) token. */ 213 char parsing_include_directive; 214 215 /* True if escape sequences (as described for has_escapes in 216 parse_buffer) should be emitted. */ 217 char output_escapes; 218 219 /* 0: Have seen non-white-space on this line. 220 1: Only seen white space so far on this line. 221 2: Only seen white space so far in this file. */ 222 char only_seen_white; 223 224 /* Nonzero means this file was included with a -imacros or -include 225 command line and should not be recorded as an include file. */ 226 227 int no_record_file; 228 229 long lineno; 230 231 struct tm *timebuf; 232 233 /* Buffer of -M output. */ 234 char *deps_buffer; 235 236 /* Number of bytes allocated in above. */ 237 int deps_allocated_size; 238 239 /* Number of bytes used. */ 240 int deps_size; 241 242 /* Number of bytes since the last newline. */ 243 int deps_column; 244 245 /* A buffer and a table, used only by read_and_prescan (in cppfiles.c) 246 which are allocated once per cpp_reader object to keep them off the 247 stack and avoid setup costs. */ 248 U_CHAR *input_buffer; 249 U_CHAR *input_speccase; 250 size_t input_buffer_len; 251}; 252 253#define CPP_FATAL_LIMIT 1000 254/* True if we have seen a "fatal" error. */ 255#define CPP_FATAL_ERRORS(READER) ((READER)->errors >= CPP_FATAL_LIMIT) 256 257#define CPP_BUF_PEEK(BUFFER) \ 258 ((BUFFER)->cur < (BUFFER)->rlimit ? *(BUFFER)->cur : EOF) 259#define CPP_BUF_GET(BUFFER) \ 260 ((BUFFER)->cur < (BUFFER)->rlimit ? *(BUFFER)->cur++ : EOF) 261#define CPP_FORWARD(BUFFER, N) ((BUFFER)->cur += (N)) 262 263/* Macros for manipulating the token_buffer. */ 264 265#define CPP_OUT_BUFFER(PFILE) ((PFILE)->token_buffer) 266 267/* Number of characters currently in PFILE's output buffer. */ 268#define CPP_WRITTEN(PFILE) ((size_t)((PFILE)->limit - (PFILE)->token_buffer)) 269#define CPP_PWRITTEN(PFILE) ((PFILE)->limit) 270 271/* Make sure PFILE->token_buffer has space for at least N more characters. */ 272#define CPP_RESERVE(PFILE, N) \ 273 (CPP_WRITTEN (PFILE) + (size_t)(N) > (PFILE)->token_buffer_size \ 274 && (cpp_grow_buffer (PFILE, N), 0)) 275 276/* Append string STR (of length N) to PFILE's output buffer. 277 Assume there is enough space. */ 278#define CPP_PUTS_Q(PFILE, STR, N) \ 279 (memcpy ((PFILE)->limit, STR, (N)), (PFILE)->limit += (N)) 280/* Append string STR (of length N) to PFILE's output buffer. Make space. */ 281#define CPP_PUTS(PFILE, STR, N) CPP_RESERVE(PFILE, N), CPP_PUTS_Q(PFILE, STR,N) 282/* Append character CH to PFILE's output buffer. Assume sufficient space. */ 283#define CPP_PUTC_Q(PFILE, CH) (*(PFILE)->limit++ = (CH)) 284/* Append character CH to PFILE's output buffer. Make space if need be. */ 285#define CPP_PUTC(PFILE, CH) (CPP_RESERVE (PFILE, 1), CPP_PUTC_Q (PFILE, CH)) 286/* Make sure PFILE->limit is followed by '\0'. */ 287#define CPP_NUL_TERMINATE_Q(PFILE) (*(PFILE)->limit = 0) 288#define CPP_NUL_TERMINATE(PFILE) (CPP_RESERVE(PFILE, 1), *(PFILE)->limit = 0) 289#define CPP_ADJUST_WRITTEN(PFILE,DELTA) ((PFILE)->limit += (DELTA)) 290#define CPP_SET_WRITTEN(PFILE,N) ((PFILE)->limit = (PFILE)->token_buffer + (N)) 291 292/* Advance the current line by one. */ 293#define CPP_BUMP_BUFFER_LINE(PBUF) ((PBUF)->lineno++,\ 294 (PBUF)->line_base = (PBUF)->cur) 295#define CPP_BUMP_LINE(PFILE) CPP_BUMP_BUFFER_LINE(CPP_BUFFER(PFILE)) 296 297#define CPP_OPTIONS(PFILE) ((PFILE)->opts) 298#define CPP_BUFFER(PFILE) ((PFILE)->buffer) 299#define CPP_PREV_BUFFER(BUFFER) ((BUFFER)->prev) 300/* The bottom of the buffer stack. */ 301#define CPP_NULL_BUFFER(PFILE) NULL 302 303/* The `pending' structure accumulates all the options that are not 304 actually processed until we hit cpp_start_read. It consists of 305 several lists, one for each type of option. We keep both head and 306 tail pointers for quick insertion. */ 307struct cpp_pending 308{ 309 struct pending_option *define_head, *define_tail; 310 struct pending_option *assert_head, *assert_tail; 311 312 struct file_name_list *quote_head, *quote_tail; 313 struct file_name_list *brack_head, *brack_tail; 314 struct file_name_list *systm_head, *systm_tail; 315 struct file_name_list *after_head, *after_tail; 316 317 struct pending_option *imacros_head, *imacros_tail; 318 struct pending_option *include_head, *include_tail; 319}; 320 321/* Pointed to by cpp_reader.opts. */ 322struct cpp_options { 323 char *in_fname; 324 325 /* Name of output file, for error messages. */ 326 char *out_fname; 327 328 struct file_name_map_list *map_list; 329 330 /* Non-0 means -v, so print the full set of include dirs. */ 331 char verbose; 332 333 /* Nonzero means use extra default include directories for C++. */ 334 335 char cplusplus; 336 337 /* Nonzero means handle cplusplus style comments */ 338 339 char cplusplus_comments; 340 341 /* Nonzero means handle #import, for objective C. */ 342 343 char objc; 344 345 /* Nonzero means this is an assembly file, and allow 346 unknown directives, which could be comments. */ 347 348 int lang_asm; 349 350 /* Nonzero means turn NOTREACHED into #pragma NOTREACHED etc */ 351 352 char for_lint; 353 354 /* Nonzero means handle CHILL comment syntax 355 and output CHILL string delimiter for __DATE___ etc. */ 356 357 char chill; 358 359 /* Nonzero means copy comments into the output file. */ 360 361 char put_out_comments; 362 363 /* Nonzero means process the ANSI trigraph sequences. */ 364 365 char trigraphs; 366 367 /* Nonzero means print the names of included files rather than 368 the preprocessed output. 1 means just the #include "...", 369 2 means #include <...> as well. */ 370 371 char print_deps; 372 373 /* Nonzero if missing .h files in -M output are assumed to be generated 374 files and not errors. */ 375 376 char print_deps_missing_files; 377 378 /* If true, fopen (deps_file, "a") else fopen (deps_file, "w"). */ 379 char print_deps_append; 380 381 /* Nonzero means print names of header files (-H). */ 382 383 char print_include_names; 384 385 /* Nonzero means try to make failure to fit ANSI C an error. */ 386 387 char pedantic_errors; 388 389 /* Nonzero means don't print warning messages. -w. */ 390 391 char inhibit_warnings; 392 393 /* Nonzero means warn if slash-star appears in a comment. */ 394 395 char warn_comments; 396 397 /* Nonzero means warn if there are any trigraphs. */ 398 399 char warn_trigraphs; 400 401 /* Nonzero means warn if #import is used. */ 402 403 char warn_import; 404 405 /* Nonzero means warn if a macro argument is (or would be) 406 stringified with -traditional. */ 407 408 char warn_stringify; 409 410 /* Nonzero means turn warnings into errors. */ 411 412 char warnings_are_errors; 413 414 /* Nonzero causes output not to be done, 415 but directives such as #define that have side effects 416 are still obeyed. */ 417 418 char no_output; 419 420 /* Nonzero means we should look for header.gcc files that remap file 421 names. */ 422 char remap; 423 424 /* Nonzero means don't output line number information. */ 425 426 char no_line_commands; 427 428/* Nonzero means output the text in failing conditionals, 429 inside #failed ... #endfailed. */ 430 431 char output_conditionals; 432 433 /* Nonzero means -I- has been seen, 434 so don't look for #include "foo" the source-file directory. */ 435 char ignore_srcdir; 436 437 /* Zero means dollar signs are punctuation. 438 This used to be needed for conformance to the C Standard, 439 before the C Standard was corrected. */ 440 char dollars_in_ident; 441 442 /* Nonzero means try to imitate old fashioned non-ANSI preprocessor. */ 443 char traditional; 444 445 /* Nonzero means warn if undefined identifiers are evaluated in an #if. */ 446 char warn_undef; 447 448 /* Nonzero for the 1989 C Standard, including corrigenda and amendments. */ 449 char c89; 450 451 /* Nonzero for the 199x C Standard, including corrigenda and amendments. */ 452 char c9x; 453 454 /* Nonzero means give all the error messages the ANSI standard requires. */ 455 char pedantic; 456 457 char done_initializing; 458 459 /* Search paths for include files. */ 460 struct file_name_list *quote_include; /* First dir to search for "file" */ 461 struct file_name_list *bracket_include;/* First dir to search for <file> */ 462 463 /* Directory prefix that should replace `/usr/lib/gcc-lib/TARGET/VERSION' 464 in the standard include file directories. */ 465 char *include_prefix; 466 int include_prefix_len; 467 468 char no_standard_includes; 469 char no_standard_cplusplus_includes; 470 471/* dump_only means inhibit output of the preprocessed text 472 and instead output the definitions of all user-defined 473 macros in a form suitable for use as input to cccp. 474 dump_names means pass #define and the macro name through to output. 475 dump_definitions means pass the whole definition (plus #define) through 476*/ 477 478 enum {dump_none = 0, dump_only, dump_names, dump_definitions} 479 dump_macros; 480 481/* Nonzero means pass all #define and #undef directives which we actually 482 process through to the output stream. This feature is used primarily 483 to allow cc1 to record the #defines and #undefs for the sake of 484 debuggers which understand about preprocessor macros, but it may 485 also be useful with -E to figure out how symbols are defined, and 486 where they are defined. */ 487 int debug_output; 488 489 /* Nonzero means pass #include lines through to the output, 490 even if they are ifdefed out. */ 491 int dump_includes; 492 493 /* Pending options - -D, -U, -A, -I, -ixxx. */ 494 struct cpp_pending *pending; 495 496 /* File name which deps are being written to. 497 This is 0 if deps are being written to stdout. */ 498 char *deps_file; 499 500 /* Target-name to write with the dependency information. */ 501 char *deps_target; 502}; 503 504#define CPP_TRADITIONAL(PFILE) (CPP_OPTIONS(PFILE)-> traditional) 505#define CPP_WARN_UNDEF(PFILE) (CPP_OPTIONS(PFILE)->warn_undef) 506#define CPP_C89(PFILE) (CPP_OPTIONS(PFILE)->c89) 507#define CPP_PEDANTIC(PFILE) (CPP_OPTIONS (PFILE)->pedantic) 508#define CPP_PRINT_DEPS(PFILE) (CPP_OPTIONS (PFILE)->print_deps) 509 510/* List of directories to look for include files in. */ 511struct file_name_list 512{ 513 struct file_name_list *next; 514 struct file_name_list *alloc; /* for the cache of 515 current directory entries */ 516 char *name; 517 unsigned int nlen; 518 /* We use these to tell if the directory mentioned here is a duplicate 519 of an earlier directory on the search path. */ 520 ino_t ino; 521 dev_t dev; 522 /* If the following is nonzero, it is a C-language system include 523 directory. */ 524 int sysp; 525 /* Mapping of file names for this directory. 526 Only used on MS-DOS and related platforms. */ 527 struct file_name_map *name_map; 528}; 529#define ABSOLUTE_PATH ((struct file_name_list *)-1) 530 531/* This structure is used for the table of all includes. It is 532 indexed by the `short name' (the name as it appeared in the 533 #include statement) which is stored in *nshort. */ 534struct include_hash 535{ 536 struct include_hash *next; 537 /* Next file with the same short name but a 538 different (partial) pathname). */ 539 struct include_hash *next_this_file; 540 541 /* Location of the file in the include search path. 542 Used for include_next */ 543 struct file_name_list *foundhere; 544 char *name; /* (partial) pathname of file */ 545 char *nshort; /* name of file as referenced in #include */ 546 char *control_macro; /* macro, if any, preventing reinclusion - see 547 redundant_include_p */ 548 char *buf, *limit; /* for file content cache, not yet implemented */ 549}; 550 551/* Name under which this program was invoked. */ 552 553extern char *progname; 554 555/* The structure of a node in the hash table. The hash table 556 has entries for all tokens defined by #define commands (type T_MACRO), 557 plus some special tokens like __LINE__ (these each have their own 558 type, and the appropriate code is run when that type of node is seen. 559 It does not contain control words like "#define", which are recognized 560 by a separate piece of code. */ 561 562/* different flavors of hash nodes --- also used in keyword table */ 563enum node_type { 564 T_DEFINE = 1, /* the `#define' keyword */ 565 T_INCLUDE, /* the `#include' keyword */ 566 T_INCLUDE_NEXT, /* the `#include_next' keyword */ 567 T_IMPORT, /* the `#import' keyword */ 568 T_IFDEF, /* the `#ifdef' keyword */ 569 T_IFNDEF, /* the `#ifndef' keyword */ 570 T_IF, /* the `#if' keyword */ 571 T_ELSE, /* `#else' */ 572 T_PRAGMA, /* `#pragma' */ 573 T_ELIF, /* `#elif' */ 574 T_UNDEF, /* `#undef' */ 575 T_LINE, /* `#line' */ 576 T_ERROR, /* `#error' */ 577 T_WARNING, /* `#warning' */ 578 T_ENDIF, /* `#endif' */ 579 T_SCCS, /* `#sccs', used on system V. */ 580 T_IDENT, /* `#ident', used on system V. */ 581 T_ASSERT, /* `#assert', taken from system V. */ 582 T_UNASSERT, /* `#unassert', taken from system V. */ 583 T_SPECLINE, /* special symbol `__LINE__' */ 584 T_DATE, /* `__DATE__' */ 585 T_FILE, /* `__FILE__' */ 586 T_BASE_FILE, /* `__BASE_FILE__' */ 587 T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */ 588 T_VERSION, /* `__VERSION__' */ 589 T_TIME, /* `__TIME__' */ 590 T_STDC, /* `__STDC__' */ 591 T_CONST, /* Constant string, used by `__SIZE_TYPE__' etc */ 592 T_MACRO, /* macro defined by `#define' */ 593 T_DISABLED, /* macro temporarily turned off for rescan */ 594 T_PCSTRING, /* precompiled string (hashval is KEYDEF *) */ 595 T_UNUSED /* Used for something not defined. */ 596 }; 597 598/* Structure returned by create_definition */ 599typedef struct macrodef MACRODEF; 600struct macrodef 601{ 602 struct definition *defn; 603 unsigned char *symnam; 604 int symlen; 605}; 606 607/* Structure allocated for every #define. For a simple replacement 608 such as 609 #define foo bar , 610 nargs = -1, the `pattern' list is null, and the expansion is just 611 the replacement text. Nargs = 0 means a functionlike macro with no args, 612 e.g., 613 #define getchar() getc (stdin) . 614 When there are args, the expansion is the replacement text with the 615 args squashed out, and the reflist is a list describing how to 616 build the output from the input: e.g., "3 chars, then the 1st arg, 617 then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg". 618 The chars here come from the expansion. Whatever is left of the 619 expansion after the last arg-occurrence is copied after that arg. 620 Note that the reflist can be arbitrarily long--- 621 its length depends on the number of times the arguments appear in 622 the replacement text, not how many args there are. Example: 623 #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and 624 pattern list 625 { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL } 626 where (x, y) means (nchars, argno). */ 627 628typedef struct definition DEFINITION; 629struct definition { 630 int nargs; 631 int length; /* length of expansion string */ 632 int predefined; /* True if the macro was builtin or */ 633 /* came from the command line */ 634 unsigned char *expansion; 635 int line; /* Line number of definition */ 636 char *file; /* File of definition */ 637 char rest_args; /* Nonzero if last arg. absorbs the rest */ 638 struct reflist { 639 struct reflist *next; 640 char stringify; /* nonzero if this arg was preceded by a 641 # operator. */ 642 char raw_before; /* Nonzero if a ## operator before arg. */ 643 char raw_after; /* Nonzero if a ## operator after arg. */ 644 char rest_args; /* Nonzero if this arg. absorbs the rest */ 645 int nchars; /* Number of literal chars to copy before 646 this arg occurrence. */ 647 int argno; /* Number of arg to substitute (origin-0) */ 648 } *pattern; 649 union { 650 /* Names of macro args, concatenated in reverse order 651 with comma-space between them. 652 The only use of this is that we warn on redefinition 653 if this differs between the old and new definitions. */ 654 unsigned char *argnames; 655 } args; 656}; 657 658/* These tables are not really `const', but they are only modified at 659 initialization time, in a separate translation unit from the rest 660 of the library. We let the rest of the library think they are `const' 661 to get better code and some additional sanity checks. */ 662#ifndef FAKE_CONST 663#define FAKE_CONST const 664#endif 665extern FAKE_CONST unsigned char is_idstart[256]; 666extern FAKE_CONST unsigned char is_idchar[256]; 667extern FAKE_CONST unsigned char is_hor_space[256]; 668extern FAKE_CONST unsigned char is_space[256]; 669extern FAKE_CONST unsigned char trigraph_table[256]; 670#undef FAKE_CONST 671 672/* Stack of conditionals currently in progress 673 (including both successful and failing conditionals). */ 674 675struct if_stack { 676 struct if_stack *next; /* for chaining to the next stack frame */ 677 char *fname; /* copied from input when frame is made */ 678 int lineno; /* similarly */ 679 int if_succeeded; /* true if a leg of this if-group 680 has been passed through rescan */ 681 unsigned char *control_macro; /* For #ifndef at start of file, 682 this is the macro name tested. */ 683 enum node_type type; /* type of last directive seen in this group */ 684}; 685typedef struct if_stack IF_STACK_FRAME; 686 687extern void cpp_buf_line_and_col PARAMS((cpp_buffer *, long *, long *)); 688extern cpp_buffer* cpp_file_buffer PARAMS((cpp_reader *)); 689extern void cpp_define PARAMS ((cpp_reader *, unsigned char *)); 690extern void cpp_assert PARAMS ((cpp_reader *, unsigned char *)); 691extern void cpp_undef PARAMS ((cpp_reader *, unsigned char *)); 692extern void cpp_unassert PARAMS ((cpp_reader *, unsigned char *)); 693 694extern void cpp_error PVPROTO ((cpp_reader *, const char *, ...)) 695 ATTRIBUTE_PRINTF_2; 696extern void cpp_warning PVPROTO ((cpp_reader *, const char *, ...)) 697 ATTRIBUTE_PRINTF_2; 698extern void cpp_pedwarn PVPROTO ((cpp_reader *, const char *, ...)) 699 ATTRIBUTE_PRINTF_2; 700extern void cpp_error_with_line PVPROTO ((cpp_reader *, int, int, const char *, ...)) 701 ATTRIBUTE_PRINTF_4; 702extern void cpp_warning_with_line PVPROTO ((cpp_reader *, int, int, const char *, ...)) 703 ATTRIBUTE_PRINTF_4; 704extern void cpp_pedwarn_with_line PVPROTO ((cpp_reader *, int, int, const char *, ...)) 705 ATTRIBUTE_PRINTF_4; 706extern void cpp_pedwarn_with_file_and_line PVPROTO ((cpp_reader *, char *, int, const char *, ...)) 707 ATTRIBUTE_PRINTF_4; 708extern void cpp_message_from_errno PROTO ((cpp_reader *, int, const char *)); 709extern void cpp_error_from_errno PROTO ((cpp_reader *, const char *)); 710extern void cpp_perror_with_name PROTO ((cpp_reader *, const char *)); 711extern void v_cpp_message PROTO ((cpp_reader *, int, const char *, va_list)); 712 713extern void cpp_grow_buffer PARAMS ((cpp_reader *, long)); 714extern HOST_WIDEST_INT cpp_parse_escape PARAMS ((cpp_reader *, char **, HOST_WIDEST_INT)); 715extern cpp_buffer *cpp_push_buffer PARAMS ((cpp_reader *, 716 unsigned char *, long)); 717extern cpp_buffer *cpp_pop_buffer PARAMS ((cpp_reader *)); 718 719extern cpp_hashnode *cpp_lookup PARAMS ((cpp_reader *, const unsigned char *, 720 int, int)); 721extern void cpp_reader_init PARAMS ((cpp_reader *)); 722extern void cpp_options_init PARAMS ((cpp_options *)); 723extern int cpp_start_read PARAMS ((cpp_reader *, char *)); 724extern int cpp_read_check_assertion PARAMS ((cpp_reader *)); 725extern int scan_decls PARAMS ((cpp_reader *, int, char **)); 726extern void skip_rest_of_line PARAMS ((cpp_reader *)); 727extern void cpp_finish PARAMS ((cpp_reader *)); 728 729extern void quote_string PARAMS ((cpp_reader *, const char *)); 730extern void cpp_expand_to_buffer PARAMS ((cpp_reader *, U_CHAR *, int)); 731extern void cpp_scan_buffer PARAMS ((cpp_reader *)); 732extern int check_macro_name PARAMS ((cpp_reader *, U_CHAR *, int)); 733 734/* Last arg to output_line_command. */ 735enum file_change_code {same_file, enter_file, leave_file}; 736extern void output_line_command PARAMS ((cpp_reader *, 737 enum file_change_code)); 738 739/* From cpperror.c */ 740extern void cpp_fatal PVPROTO ((cpp_reader *, const char *, ...)) 741 ATTRIBUTE_PRINTF_2; 742extern void cpp_message PVPROTO ((cpp_reader *, int, const char *, ...)) 743 ATTRIBUTE_PRINTF_3; 744extern void cpp_pfatal_with_name PROTO ((cpp_reader *, const char *)); 745extern void cpp_file_line_for_message PROTO ((cpp_reader *, char *, int, int)); 746extern void cpp_print_containing_files PROTO ((cpp_reader *)); 747extern void cpp_notice PVPROTO ((const char *msgid, ...)) ATTRIBUTE_PRINTF_1; 748 749/* In cppfiles.c */ 750extern void simplify_pathname PROTO ((char *)); 751extern void merge_include_chains PROTO ((struct cpp_options *)); 752extern int find_include_file PROTO ((cpp_reader *, char *, 753 struct file_name_list *, 754 struct include_hash **, 755 int *)); 756extern int finclude PROTO ((cpp_reader *, int, 757 struct include_hash *)); 758extern void deps_output PROTO ((cpp_reader *, char *, int)); 759extern struct include_hash *include_hash PROTO ((cpp_reader *, char *, int)); 760 761#ifndef INCLUDE_LEN_FUDGE 762#define INCLUDE_LEN_FUDGE 0 763#endif 764 765 766#ifdef __cplusplus 767} 768#endif 769#endif /* __GCC_CPPLIB__ */ 770 771