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