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