gcc/cpplib.h

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