contrib/gcc/cpplib.h

   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
   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   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
 141 struct 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
 151 struct 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. */
 307 struct 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. */
 322 struct 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. */
 511 struct 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.  */
 534 struct 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
 553 extern 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 */
 563 enum 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 */
 599 typedef struct macrodef MACRODEF;
 600 struct 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
 628 typedef struct definition DEFINITION;
 629 struct 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
 665 extern FAKE_CONST unsigned char is_idstart[256];
 666 extern FAKE_CONST unsigned char is_idchar[256];
 667 extern FAKE_CONST unsigned char is_hor_space[256];
 668 extern FAKE_CONST unsigned char is_space[256];
 669 extern 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
 675 struct 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 };
 685 typedef struct if_stack IF_STACK_FRAME;
 686
 687 extern void cpp_buf_line_and_col PARAMS((cpp_buffer *, long *, long *));
 688 extern cpp_buffer* cpp_file_buffer PARAMS((cpp_reader *));
 689 extern void cpp_define PARAMS ((cpp_reader *, unsigned char *));
 690 extern void cpp_assert PARAMS ((cpp_reader *, unsigned char *));
 691 extern void cpp_undef  PARAMS ((cpp_reader *, unsigned char *));
 692 extern void cpp_unassert PARAMS ((cpp_reader *, unsigned char *));
 693
 694 extern void cpp_error PVPROTO ((cpp_reader *, const char *, ...))
 695   ATTRIBUTE_PRINTF_2;
 696 extern void cpp_warning PVPROTO ((cpp_reader *, const char *, ...))
 697   ATTRIBUTE_PRINTF_2;
 698 extern void cpp_pedwarn PVPROTO ((cpp_reader *, const char *, ...))
 699   ATTRIBUTE_PRINTF_2;
 700 extern void cpp_error_with_line PVPROTO ((cpp_reader *, int, int, const char *, ...))
 701   ATTRIBUTE_PRINTF_4;
 702 extern void cpp_warning_with_line PVPROTO ((cpp_reader *, int, int, const char *, ...))
 703   ATTRIBUTE_PRINTF_4;
 704 extern void cpp_pedwarn_with_line PVPROTO ((cpp_reader *, int, int, const char *, ...))
 705   ATTRIBUTE_PRINTF_4;
 706 extern void cpp_pedwarn_with_file_and_line PVPROTO ((cpp_reader *, char *, int, const char *, ...))
 707   ATTRIBUTE_PRINTF_4;
 708 extern void cpp_message_from_errno PROTO ((cpp_reader *, int, const char *));
 709 extern void cpp_error_from_errno PROTO ((cpp_reader *, const char *));
 710 extern void cpp_perror_with_name PROTO ((cpp_reader *, const char *));
 711 extern void v_cpp_message PROTO ((cpp_reader *, int, const char *, va_list));
 712
 713 extern void cpp_grow_buffer PARAMS ((cpp_reader *, long));
 714 extern HOST_WIDEST_INT cpp_parse_escape PARAMS ((cpp_reader *, char **, HOST_WIDEST_INT));
 715 extern cpp_buffer *cpp_push_buffer PARAMS ((cpp_reader *,
 716                                             unsigned char *, long));
 717 extern cpp_buffer *cpp_pop_buffer PARAMS ((cpp_reader *));
 718
 719 extern cpp_hashnode *cpp_lookup PARAMS ((cpp_reader *, const unsigned char *,
 720                                          int, int));
 721 extern void cpp_reader_init PARAMS ((cpp_reader *));
 722 extern void cpp_options_init PARAMS ((cpp_options *));
 723 extern int cpp_start_read PARAMS ((cpp_reader *, char *));
 724 extern int cpp_read_check_assertion PARAMS ((cpp_reader *));
 725 extern int scan_decls PARAMS ((cpp_reader *, int, char **));
 726 extern void skip_rest_of_line PARAMS ((cpp_reader *));
 727 extern void cpp_finish PARAMS ((cpp_reader *));
 728
 729 extern void quote_string                PARAMS ((cpp_reader *, const char *));
 730 extern void cpp_expand_to_buffer        PARAMS ((cpp_reader *, U_CHAR *, int));
 731 extern void cpp_scan_buffer             PARAMS ((cpp_reader *));
 732 extern int check_macro_name             PARAMS ((cpp_reader *, U_CHAR *, int));
 733
 734 /* Last arg to output_line_command.  */
 735 enum file_change_code {same_file, enter_file, leave_file};
 736 extern void output_line_command         PARAMS ((cpp_reader *,
 737                                                  enum file_change_code));
 738
 739 /* From cpperror.c */
 740 extern void cpp_fatal PVPROTO ((cpp_reader *, const char *, ...))
 741   ATTRIBUTE_PRINTF_2;
 742 extern void cpp_message PVPROTO ((cpp_reader *, int, const char *, ...))
 743   ATTRIBUTE_PRINTF_3;
 744 extern void cpp_pfatal_with_name PROTO ((cpp_reader *, const char *));
 745 extern void cpp_file_line_for_message PROTO ((cpp_reader *, char *, int, int));
 746 extern void cpp_print_containing_files PROTO ((cpp_reader *));
 747 extern void cpp_notice PVPROTO ((const char *msgid, ...)) ATTRIBUTE_PRINTF_1;
 748
 749 /* In cppfiles.c */
 750 extern void simplify_pathname           PROTO ((char *));
 751 extern void merge_include_chains        PROTO ((struct cpp_options *));
 752 extern int find_include_file            PROTO ((cpp_reader *, char *,
 753                                                 struct file_name_list *,
 754                                                 struct include_hash **,
 755                                                 int *));
 756 extern int finclude                     PROTO ((cpp_reader *, int,
 757                                                 struct include_hash *));
 758 extern void deps_output                 PROTO ((cpp_reader *, char *, int));
 759 extern 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