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 inhibit_predefs;
 457   char no_standard_includes;
 458   char no_standard_cplusplus_includes;
 459
 460 /* dump_only means inhibit output of the preprocessed text
 461              and instead output the definitions of all user-defined
 462              macros in a form suitable for use as input to cccp.
 463    dump_names means pass #define and the macro name through to output.
 464    dump_definitions means pass the whole definition (plus #define) through
 465 */
 466
 467   enum {dump_none = 0, dump_only, dump_names, dump_definitions}
 468      dump_macros;
 469
 470 /* Nonzero means pass all #define and #undef directives which we actually
 471    process through to the output stream.  This feature is used primarily
 472    to allow cc1 to record the #defines and #undefs for the sake of
 473    debuggers which understand about preprocessor macros, but it may
 474    also be useful with -E to figure out how symbols are defined, and
 475    where they are defined.  */
 476   int debug_output;
 477
 478   /* Nonzero means pass #include lines through to the output,
 479      even if they are ifdefed out.  */
 480   int dump_includes;
 481
 482   /* Pending options - -D, -U, -A, -I, -ixxx. */
 483   struct cpp_pending *pending;
 484
 485   /* File name which deps are being written to.
 486      This is 0 if deps are being written to stdout.  */
 487   char *deps_file;
 488
 489   /* Target-name to write with the dependency information.  */
 490   char *deps_target;
 491 };
 492
 493 #define CPP_TRADITIONAL(PFILE) (CPP_OPTIONS(PFILE)-> traditional)
 494 #define CPP_WARN_UNDEF(PFILE) (CPP_OPTIONS(PFILE)->warn_undef)
 495 #define CPP_C89(PFILE) (CPP_OPTIONS(PFILE)->c89)
 496 #define CPP_PEDANTIC(PFILE) (CPP_OPTIONS (PFILE)->pedantic)
 497 #define CPP_PRINT_DEPS(PFILE) (CPP_OPTIONS (PFILE)->print_deps)
 498
 499 /* List of directories to look for include files in. */
 500 struct file_name_list
 501 {
 502   struct file_name_list *next;
 503   struct file_name_list *alloc; /* for the cache of
 504                                    current directory entries */
 505   char *name;
 506   unsigned int nlen;
 507   /* We use these to tell if the directory mentioned here is a duplicate
 508      of an earlier directory on the search path. */
 509   ino_t ino;
 510   dev_t dev;
 511   /* If the following is nonzero, it is a C-language system include
 512      directory.  */
 513   int sysp;
 514   /* Mapping of file names for this directory.
 515      Only used on MS-DOS and related platforms. */
 516   struct file_name_map *name_map;
 517 };
 518 #define ABSOLUTE_PATH ((struct file_name_list *)-1)
 519
 520 /* This structure is used for the table of all includes.  It is
 521    indexed by the `short name' (the name as it appeared in the
 522    #include statement) which is stored in *nshort.  */
 523 struct include_hash
 524 {
 525   struct include_hash *next;
 526   /* Next file with the same short name but a
 527      different (partial) pathname). */
 528   struct include_hash *next_this_file;
 529
 530   /* Location of the file in the include search path.
 531      Used for include_next */
 532   struct file_name_list *foundhere;
 533   char *name;           /* (partial) pathname of file */
 534   char *nshort;         /* name of file as referenced in #include */
 535   char *control_macro;  /* macro, if any, preventing reinclusion - see
 536                            redundant_include_p */
 537   char *buf, *limit;    /* for file content cache, not yet implemented */
 538 };
 539
 540 /* Name under which this program was invoked.  */
 541
 542 extern char *progname;
 543
 544 /* The structure of a node in the hash table.  The hash table
 545    has entries for all tokens defined by #define commands (type T_MACRO),
 546    plus some special tokens like __LINE__ (these each have their own
 547    type, and the appropriate code is run when that type of node is seen.
 548    It does not contain control words like "#define", which are recognized
 549    by a separate piece of code. */
 550
 551 /* different flavors of hash nodes --- also used in keyword table */
 552 enum node_type {
 553  T_DEFINE = 1,  /* the `#define' keyword */
 554  T_INCLUDE,     /* the `#include' keyword */
 555  T_INCLUDE_NEXT, /* the `#include_next' keyword */
 556  T_IMPORT,      /* the `#import' keyword */
 557  T_IFDEF,       /* the `#ifdef' keyword */
 558  T_IFNDEF,      /* the `#ifndef' keyword */
 559  T_IF,          /* the `#if' keyword */
 560  T_ELSE,        /* `#else' */
 561  T_PRAGMA,      /* `#pragma' */
 562  T_ELIF,        /* `#elif' */
 563  T_UNDEF,       /* `#undef' */
 564  T_LINE,        /* `#line' */
 565  T_ERROR,       /* `#error' */
 566  T_WARNING,     /* `#warning' */
 567  T_ENDIF,       /* `#endif' */
 568  T_SCCS,        /* `#sccs', used on system V.  */
 569  T_IDENT,       /* `#ident', used on system V.  */
 570  T_ASSERT,      /* `#assert', taken from system V.  */
 571  T_UNASSERT,    /* `#unassert', taken from system V.  */
 572  T_SPECLINE,    /* special symbol `__LINE__' */
 573  T_DATE,        /* `__DATE__' */
 574  T_FILE,        /* `__FILE__' */
 575  T_BASE_FILE,   /* `__BASE_FILE__' */
 576  T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
 577  T_VERSION,     /* `__VERSION__' */
 578  T_TIME,        /* `__TIME__' */
 579  T_STDC,        /* `__STDC__' */
 580  T_CONST,       /* Constant string, used by `__SIZE_TYPE__' etc */
 581  T_MACRO,       /* macro defined by `#define' */
 582  T_DISABLED,    /* macro temporarily turned off for rescan */
 583  T_PCSTRING,    /* precompiled string (hashval is KEYDEF *) */
 584  T_UNUSED       /* Used for something not defined.  */
 585  };
 586
 587 /* Structure returned by create_definition */
 588 typedef struct macrodef MACRODEF;
 589 struct macrodef
 590 {
 591   struct definition *defn;
 592   unsigned char *symnam;
 593   int symlen;
 594 };
 595
 596 /* Structure allocated for every #define.  For a simple replacement
 597    such as
 598         #define foo bar ,
 599    nargs = -1, the `pattern' list is null, and the expansion is just
 600    the replacement text.  Nargs = 0 means a functionlike macro with no args,
 601    e.g.,
 602        #define getchar() getc (stdin) .
 603    When there are args, the expansion is the replacement text with the
 604    args squashed out, and the reflist is a list describing how to
 605    build the output from the input: e.g., "3 chars, then the 1st arg,
 606    then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
 607    The chars here come from the expansion.  Whatever is left of the
 608    expansion after the last arg-occurrence is copied after that arg.
 609    Note that the reflist can be arbitrarily long---
 610    its length depends on the number of times the arguments appear in
 611    the replacement text, not how many args there are.  Example:
 612    #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
 613    pattern list
 614      { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
 615    where (x, y) means (nchars, argno). */
 616
 617 typedef struct definition DEFINITION;
 618 struct definition {
 619   int nargs;
 620   int length;                   /* length of expansion string */
 621   int predefined;               /* True if the macro was builtin or */
 622                                 /* came from the command line */
 623   unsigned char *expansion;
 624   int line;                     /* Line number of definition */
 625   char *file;                   /* File of definition */
 626   char rest_args;               /* Nonzero if last arg. absorbs the rest */
 627   struct reflist {
 628     struct reflist *next;
 629     char stringify;             /* nonzero if this arg was preceded by a
 630                                    # operator. */
 631     char raw_before;            /* Nonzero if a ## operator before arg. */
 632     char raw_after;             /* Nonzero if a ## operator after arg. */
 633     char rest_args;             /* Nonzero if this arg. absorbs the rest */
 634     int nchars;                 /* Number of literal chars to copy before
 635                                    this arg occurrence.  */
 636     int argno;                  /* Number of arg to substitute (origin-0) */
 637   } *pattern;
 638   union {
 639     /* Names of macro args, concatenated in reverse order
 640        with comma-space between them.
 641        The only use of this is that we warn on redefinition
 642        if this differs between the old and new definitions.  */
 643     unsigned char *argnames;
 644   } args;
 645 };
 646
 647 /* These tables are not really `const', but they are only modified at
 648    initialization time, in a separate translation unit from the rest
 649    of the library.  We let the rest of the library think they are `const'
 650    to get better code and some additional sanity checks.  */
 651 #ifndef FAKE_CONST
 652 #define FAKE_CONST const
 653 #endif
 654 extern FAKE_CONST unsigned char is_idstart[256];
 655 extern FAKE_CONST unsigned char is_idchar[256];
 656 extern FAKE_CONST unsigned char is_hor_space[256];
 657 extern FAKE_CONST unsigned char is_space[256];
 658 extern FAKE_CONST unsigned char trigraph_table[256];
 659 #undef FAKE_CONST
 660
 661 /* Stack of conditionals currently in progress
 662    (including both successful and failing conditionals).  */
 663
 664 struct if_stack {
 665   struct if_stack *next;        /* for chaining to the next stack frame */
 666   char *fname;          /* copied from input when frame is made */
 667   int lineno;                   /* similarly */
 668   int if_succeeded;             /* true if a leg of this if-group
 669                                     has been passed through rescan */
 670   unsigned char *control_macro; /* For #ifndef at start of file,
 671                                    this is the macro name tested.  */
 672   enum node_type type;          /* type of last directive seen in this group */
 673 };
 674 typedef struct if_stack IF_STACK_FRAME;
 675
 676 extern void cpp_buf_line_and_col PARAMS((cpp_buffer *, long *, long *));
 677 extern cpp_buffer* cpp_file_buffer PARAMS((cpp_reader *));
 678 extern void cpp_define PARAMS ((cpp_reader *, unsigned char *));
 679 extern void cpp_assert PARAMS ((cpp_reader *, unsigned char *));
 680 extern void cpp_undef  PARAMS ((cpp_reader *, unsigned char *));
 681 extern void cpp_unassert PARAMS ((cpp_reader *, unsigned char *));
 682
 683 extern void cpp_error PVPROTO ((cpp_reader *, const char *, ...))
 684   ATTRIBUTE_PRINTF_2;
 685 extern void cpp_warning PVPROTO ((cpp_reader *, const char *, ...))
 686   ATTRIBUTE_PRINTF_2;
 687 extern void cpp_pedwarn PVPROTO ((cpp_reader *, const char *, ...))
 688   ATTRIBUTE_PRINTF_2;
 689 extern void cpp_error_with_line PVPROTO ((cpp_reader *, int, int, const char *, ...))
 690   ATTRIBUTE_PRINTF_4;
 691 extern void cpp_warning_with_line PVPROTO ((cpp_reader *, int, int, const char *, ...))
 692   ATTRIBUTE_PRINTF_4;
 693 extern void cpp_pedwarn_with_line PVPROTO ((cpp_reader *, int, int, const char *, ...))
 694   ATTRIBUTE_PRINTF_4;
 695 extern void cpp_pedwarn_with_file_and_line PVPROTO ((cpp_reader *, char *, int, const char *, ...))
 696   ATTRIBUTE_PRINTF_4;
 697 extern void cpp_message_from_errno PROTO ((cpp_reader *, int, const char *));
 698 extern void cpp_error_from_errno PROTO ((cpp_reader *, const char *));
 699 extern void cpp_perror_with_name PROTO ((cpp_reader *, const char *));
 700 extern void v_cpp_message PROTO ((cpp_reader *, int, const char *, va_list));
 701
 702 extern void cpp_grow_buffer PARAMS ((cpp_reader *, long));
 703 extern HOST_WIDEST_INT cpp_parse_escape PARAMS ((cpp_reader *, char **, HOST_WIDEST_INT));
 704 extern cpp_buffer *cpp_push_buffer PARAMS ((cpp_reader *,
 705                                             unsigned char *, long));
 706 extern cpp_buffer *cpp_pop_buffer PARAMS ((cpp_reader *));
 707
 708 extern cpp_hashnode *cpp_lookup PARAMS ((cpp_reader *, const unsigned char *,
 709                                          int, int));
 710 extern void cpp_reader_init PARAMS ((cpp_reader *));
 711 extern void cpp_options_init PARAMS ((cpp_options *));
 712 extern int cpp_start_read PARAMS ((cpp_reader *, char *));
 713 extern int cpp_read_check_assertion PARAMS ((cpp_reader *));
 714 extern int scan_decls PARAMS ((cpp_reader *, int, char **));
 715 extern void skip_rest_of_line PARAMS ((cpp_reader *));
 716 extern void cpp_finish PARAMS ((cpp_reader *));
 717
 718 extern void quote_string                PARAMS ((cpp_reader *, const char *));
 719 extern void cpp_expand_to_buffer        PARAMS ((cpp_reader *, U_CHAR *, int));
 720 extern void cpp_scan_buffer             PARAMS ((cpp_reader *));
 721 extern int check_macro_name             PARAMS ((cpp_reader *, U_CHAR *, int));
 722
 723 /* Last arg to output_line_command.  */
 724 enum file_change_code {same_file, enter_file, leave_file};
 725 extern void output_line_command         PARAMS ((cpp_reader *, int,
 726                                                  enum file_change_code));
 727
 728 /* From cpperror.c */
 729 extern void cpp_fatal PVPROTO ((cpp_reader *, const char *, ...))
 730   ATTRIBUTE_PRINTF_2;
 731 extern void cpp_message PVPROTO ((cpp_reader *, int, const char *, ...))
 732   ATTRIBUTE_PRINTF_3;
 733 extern void cpp_pfatal_with_name PROTO ((cpp_reader *, const char *));
 734 extern void cpp_file_line_for_message PROTO ((cpp_reader *, char *, int, int));
 735 extern void cpp_print_containing_files PROTO ((cpp_reader *));
 736 extern void cpp_notice PVPROTO ((const char *msgid, ...)) ATTRIBUTE_PRINTF_1;
 737
 738 /* In cppfiles.c */
 739 extern void simplify_pathname           PROTO ((char *));
 740 extern void merge_include_chains        PROTO ((struct cpp_options *));
 741 extern int find_include_file            PROTO ((cpp_reader *, char *,
 742                                                 struct file_name_list *,
 743                                                 struct include_hash **,
 744                                                 int *));
 745 extern int finclude                     PROTO ((cpp_reader *, int,
 746                                                 struct include_hash *));
 747 extern void deps_output                 PROTO ((cpp_reader *, char *, int));
 748 extern struct include_hash *include_hash PROTO ((cpp_reader *, char *, int));
 749
 750 #ifndef INCLUDE_LEN_FUDGE
 751 #define INCLUDE_LEN_FUDGE 0
 752 #endif
 753
 754
 755 #ifdef __cplusplus
 756 }
 757 #endif
 758 #endif /* __GCC_CPPLIB__ */
 759