gcc/cpplib.h

   1 /* Definitions for CPP library.
   2    Copyright (C) 1995, 1996, 1997 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 #include <sys/stat.h>
  27
  28 #ifdef __cplusplus
  29 extern "C" {
  30 #endif
  31
  32 typedef unsigned char U_CHAR;
  33
  34 typedef struct cpp_reader cpp_reader;
  35 typedef struct cpp_buffer cpp_buffer;
  36 typedef struct cpp_options cpp_options;
  37 typedef struct hashnode cpp_hashnode;
  38
  39 enum cpp_token {
  40   CPP_EOF = -1,
  41   CPP_OTHER = 0,
  42   CPP_COMMENT = 1,
  43   CPP_HSPACE,
  44   CPP_VSPACE, /* newlines and #line directives */
  45   CPP_NAME,
  46   CPP_NUMBER,
  47   CPP_CHAR,
  48   CPP_STRING,
  49   CPP_DIRECTIVE,
  50   CPP_LPAREN,   /* "(" */
  51   CPP_RPAREN,   /* ")" */
  52   CPP_LBRACE,   /* "{" */
  53   CPP_RBRACE,   /* "}" */
  54   CPP_COMMA,    /* "," */
  55   CPP_SEMICOLON,/* ";" */
  56   CPP_3DOTS,    /* "..." */
  57 #if 0
  58   CPP_ANDAND, /* "&&" */
  59   CPP_OROR,   /* "||" */
  60   CPP_LSH,    /* "<<" */
  61   CPP_RSH,    /* ">>" */
  62   CPP_EQL,    /* "==" */
  63   CPP_NEQ,    /* "!=" */
  64   CPP_LEQ,    /* "<=" */
  65   CPP_GEQ,    /* ">=" */
  66   CPP_PLPL,   /* "++" */
  67   CPP_MINMIN, /* "--" */
  68 #endif
  69   /* POP_TOKEN is returned when we've popped a cpp_buffer. */
  70   CPP_POP
  71 };
  72
  73 #ifndef PARAMS
  74 #define PARAMS(P) PROTO(P)
  75 #endif /* !PARAMS */
  76
  77 typedef enum cpp_token (*parse_underflow_t) PARAMS((cpp_reader *));
  78 typedef int (*parse_cleanup_t) PARAMS((cpp_buffer *, cpp_reader *));
  79
  80 /* A parse_marker indicates a previous position,
  81    which we can backtrack to. */
  82
  83 struct parse_marker {
  84   cpp_buffer *buf;
  85   struct parse_marker *next;
  86   int position;
  87 };
  88
  89 extern void parse_set_mark PARAMS ((struct parse_marker *, cpp_reader *));
  90 extern void parse_clear_mark PARAMS ((struct parse_marker *));
  91 extern void parse_goto_mark PARAMS((struct parse_marker *, cpp_reader *));
  92 extern void parse_move_mark PARAMS((struct parse_marker *, cpp_reader *));
  93
  94 extern int cpp_handle_option PARAMS ((cpp_reader *, int, char **));
  95 extern int cpp_handle_options PARAMS ((cpp_reader *, int, char **));
  96 extern enum cpp_token cpp_get_token PARAMS ((cpp_reader *));
  97 extern void cpp_skip_hspace PARAMS((cpp_reader *));
  98 extern enum cpp_token cpp_get_non_space_token PARAMS ((cpp_reader *));
  99
 100 /* This frees resources used by PFILE. */
 101 extern void cpp_cleanup PARAMS ((cpp_reader *PFILE));
 102
 103 /* Maintain and search list of included files, for #import.  */
 104
 105 #define IMPORT_HASH_SIZE 31
 106
 107 struct import_file {
 108   char *name;
 109   ino_t inode;
 110   dev_t dev;
 111   struct import_file *next;
 112 };
 113
 114 /* If we have a huge buffer, may need to cache more recent counts */
 115 #define CPP_LINE_BASE(BUF) ((BUF)->buf + (BUF)->line_base)
 116
 117 struct cpp_buffer {
 118   unsigned char *buf;
 119   unsigned char *cur;
 120   unsigned char *rlimit; /* end of valid data */
 121   unsigned char *alimit; /* end of allocated buffer */
 122   unsigned char *prev;  /* start of current token */
 123
 124   char *fname;
 125   /* Filename specified with #line command.  */
 126   char *nominal_fname;
 127
 128   /* Record where in the search path this file was found.
 129      For #include_next.  */
 130   struct file_name_list *dir;
 131
 132   long line_base;
 133   long lineno; /* Line number at CPP_LINE_BASE. */
 134   long colno; /* Column number at CPP_LINE_BASE. */
 135   parse_underflow_t underflow;
 136   parse_cleanup_t cleanup;
 137   void *data;
 138   struct parse_marker *marks;
 139   /* Value of if_stack at start of this file.
 140      Used to prohibit unmatched #endif (etc) in an include file.  */
 141   struct if_stack *if_stack;
 142
 143   /* True if this is a header file included using <FILENAME>.  */
 144   char system_header_p;
 145   char seen_eof;
 146
 147   /* True if buffer contains escape sequences.
 148      Currently there are three kinds:
 149      "@-" means following identifier should not be macro-expanded.
 150      "@ " means a token-separator.  This turns into " " in final output
 151           if not stringizing and needed to separate tokens; otherwise nothing.
 152      "@@" means a normal '@'.
 153      (An '@' inside a string stands for itself and is never an escape.) */
 154   char has_escapes;
 155 };
 156
 157 struct cpp_pending;  /* Forward declaration - for C++. */
 158 struct file_name_map_list;
 159
 160 typedef struct assertion_hashnode ASSERTION_HASHNODE;
 161 #define ASSERTION_HASHSIZE 37
 162
 163 /* Maximum nesting of cpp_buffers.  We use a static limit, partly for
 164    efficiency, and partly to limit runaway recursion.  */
 165 #define CPP_STACK_MAX 200
 166
 167 /* A cpp_reader encapsulates the "state" of a pre-processor run.
 168    Applying cpp_get_token repeatedly yields a stream of pre-processor
 169    tokens.  Usually, there is only one cpp_reader object active. */
 170
 171 struct cpp_reader {
 172   parse_underflow_t get_token;
 173   cpp_buffer *buffer;
 174   cpp_buffer buffer_stack[CPP_STACK_MAX];
 175
 176   int errors;                   /* Error counter for exit code */
 177   void *data;
 178
 179   /* A buffer used for both for cpp_get_token's output, and also internally. */
 180   unsigned char *token_buffer;
 181   /* Allocated size of token_buffer.  CPP_RESERVE allocates space.  */
 182   unsigned int token_buffer_size;
 183   /* End of the written part of token_buffer. */
 184   unsigned char *limit;
 185
 186   /* Line where a newline was first seen in a string constant.  */
 187   int multiline_string_line;
 188
 189   /* Current depth in #include directives that use <...>.  */
 190   int system_include_depth;
 191
 192   /* List of included files that contained #pragma once.  */
 193   struct file_name_list *dont_repeat_files;
 194
 195   /* List of other included files.
 196      If ->control_macro if nonzero, the file had a #ifndef
 197      around the entire contents, and ->control_macro gives the macro name.  */
 198   struct file_name_list *all_include_files;
 199
 200   /* Current maximum length of directory names in the search path
 201      for include files.  (Altered as we get more of them.)  */
 202   int max_include_len;
 203
 204   /* Hash table of files already included with #include or #import.  */
 205   struct import_file *import_hash_table[IMPORT_HASH_SIZE];
 206
 207   struct if_stack *if_stack;
 208
 209   /* Nonzero means we are inside an IF during a -pcp run.  In this mode
 210      macro expansion is done, and preconditions are output for all macro
 211      uses requiring them. */
 212   char pcp_inside_if;
 213
 214   /* Nonzero means we have printed (while error reporting) a list of
 215      containing files that matches the current status. */
 216   char input_stack_listing_current;
 217
 218   /* If non-zero, macros are not expanded. */
 219   char no_macro_expand;
 220
 221   /* Print column number in error messages. */
 222   char show_column;
 223
 224   /* We're printed a warning recommending against using #import. */
 225   char import_warning;
 226
 227   /* If true, character between '<' and '>' are a single (string) token. */
 228   char parsing_include_directive;
 229
 230   /* True if escape sequences (as described for has_escapes in
 231      parse_buffer) should be emitted. */
 232   char output_escapes;
 233
 234   /* 0: Have seen non-white-space on this line.
 235      1: Only seen white space so far on this line.
 236      2: Only seen white space so far in this file. */
 237    char only_seen_white;
 238
 239   /* Nonzero means this file was included with a -imacros or -include
 240      command line and should not be recorded as an include file.  */
 241
 242   int no_record_file;
 243
 244   long lineno;
 245
 246   struct tm *timebuf;
 247
 248   ASSERTION_HASHNODE *assertion_hashtab[ASSERTION_HASHSIZE];
 249
 250   /* Buffer of -M output.  */
 251   char *deps_buffer;
 252
 253   /* Number of bytes allocated in above.  */
 254   int deps_allocated_size;
 255
 256   /* Number of bytes used.  */
 257   int deps_size;
 258
 259   /* Number of bytes since the last newline.  */
 260   int deps_column;
 261
 262 #ifdef __cplusplus
 263   ~cpp_reader () { cpp_cleanup (this); }
 264 #endif
 265 };
 266
 267 #define CPP_FATAL_LIMIT 1000
 268 /* True if we have seen a "fatal" error. */
 269 #define CPP_FATAL_ERRORS(READER) ((READER)->errors >= CPP_FATAL_LIMIT)
 270
 271 #define CPP_BUF_PEEK(BUFFER) \
 272   ((BUFFER)->cur < (BUFFER)->rlimit ? *(BUFFER)->cur : EOF)
 273 #define CPP_BUF_GET(BUFFER) \
 274   ((BUFFER)->cur < (BUFFER)->rlimit ? *(BUFFER)->cur++ : EOF)
 275 #define CPP_FORWARD(BUFFER, N) ((BUFFER)->cur += (N))
 276
 277 /* Macros for manipulating the token_buffer. */
 278
 279 #define CPP_OUT_BUFFER(PFILE) ((PFILE)->token_buffer)
 280
 281 /* Number of characters currently in PFILE's output buffer. */
 282 #define CPP_WRITTEN(PFILE) ((size_t)((PFILE)->limit - (PFILE)->token_buffer))
 283 #define CPP_PWRITTEN(PFILE) ((PFILE)->limit)
 284
 285 /* Make sure PFILE->token_buffer has space for at least N more characters. */
 286 #define CPP_RESERVE(PFILE, N) \
 287   (CPP_WRITTEN (PFILE) + (size_t)(N) > (PFILE)->token_buffer_size \
 288    && (cpp_grow_buffer (PFILE, N), 0))
 289
 290 /* Append string STR (of length N) to PFILE's output buffer.
 291    Assume there is enough space. */
 292 #define CPP_PUTS_Q(PFILE, STR, N) \
 293   (bcopy (STR, (PFILE)->limit, (N)), (PFILE)->limit += (N))
 294 /* Append string STR (of length N) to PFILE's output buffer.  Make space. */
 295 #define CPP_PUTS(PFILE, STR, N) CPP_RESERVE(PFILE, N), CPP_PUTS_Q(PFILE, STR,N)
 296 /* Append character CH to PFILE's output buffer.  Assume sufficient space. */
 297 #define CPP_PUTC_Q(PFILE, CH) (*(PFILE)->limit++ = (CH))
 298 /* Append character CH to PFILE's output buffer.  Make space if need be. */
 299 #define CPP_PUTC(PFILE, CH) (CPP_RESERVE (PFILE, 1), CPP_PUTC_Q (PFILE, CH))
 300 /* Make sure PFILE->limit is followed by '\0'. */
 301 #define CPP_NUL_TERMINATE_Q(PFILE) (*(PFILE)->limit = 0)
 302 #define CPP_NUL_TERMINATE(PFILE) (CPP_RESERVE(PFILE, 1), *(PFILE)->limit = 0)
 303 #define CPP_ADJUST_WRITTEN(PFILE,DELTA) ((PFILE)->limit += (DELTA))
 304 #define CPP_SET_WRITTEN(PFILE,N) ((PFILE)->limit = (PFILE)->token_buffer + (N))
 305
 306 #define CPP_OPTIONS(PFILE) ((cpp_options *) (PFILE)->data)
 307
 308 #define CPP_BUFFER(PFILE) ((PFILE)->buffer)
 309 #define CPP_PREV_BUFFER(BUFFER) ((BUFFER)+1)
 310 /* The bottom of the buffer stack. */
 311 #define CPP_NULL_BUFFER(PFILE) (&(PFILE)->buffer_stack[CPP_STACK_MAX])
 312
 313 /* Pointed to by cpp_reader::data. */
 314 struct cpp_options {
 315   char *in_fname;
 316
 317   /* Name of output file, for error messages.  */
 318   char *out_fname;
 319
 320   struct file_name_map_list *map_list;
 321
 322   /* Non-0 means -v, so print the full set of include dirs.  */
 323   char verbose;
 324
 325   /* Nonzero means use extra default include directories for C++.  */
 326
 327   char cplusplus;
 328
 329   /* Nonzero means handle cplusplus style comments */
 330
 331   char cplusplus_comments;
 332
 333   /* Nonzero means handle #import, for objective C.  */
 334
 335   char objc;
 336
 337   /* Nonzero means this is an assembly file, and allow
 338      unknown directives, which could be comments.  */
 339
 340   int lang_asm;
 341
 342   /* Nonzero means turn NOTREACHED into #pragma NOTREACHED etc */
 343
 344   char for_lint;
 345
 346   /* Nonzero means handle CHILL comment syntax
 347      and output CHILL string delimiter for __DATE___ etc. */
 348
 349   char chill;
 350
 351   /* Nonzero means copy comments into the output file.  */
 352
 353   char put_out_comments;
 354
 355   /* Nonzero means don't process the ANSI trigraph sequences.  */
 356
 357   char no_trigraphs;
 358
 359   /* Nonzero means print the names of included files rather than
 360      the preprocessed output.  1 means just the #include "...",
 361      2 means #include <...> as well.  */
 362
 363   char print_deps;
 364
 365   /* Nonzero if missing .h files in -M output are assumed to be generated
 366      files and not errors.  */
 367
 368   char print_deps_missing_files;
 369
 370   /* If true, fopen (deps_file, "a") else fopen (deps_file, "w"). */
 371   char print_deps_append;
 372
 373   /* Nonzero means print names of header files (-H).  */
 374
 375   char print_include_names;
 376
 377   /* Nonzero means try to make failure to fit ANSI C an error.  */
 378
 379   char pedantic_errors;
 380
 381   /* Nonzero means don't print warning messages.  -w.  */
 382
 383   char inhibit_warnings;
 384
 385   /* Nonzero means warn if slash-star appears in a comment.  */
 386
 387   char warn_comments;
 388
 389   /* Nonzero means warn if there are any trigraphs.  */
 390
 391   char warn_trigraphs;
 392
 393   /* Nonzero means warn if #import is used.  */
 394
 395   char warn_import;
 396
 397   /* Nonzero means warn if a macro argument is (or would be)
 398      stringified with -traditional.  */
 399
 400   char warn_stringify;
 401
 402   /* Nonzero means turn warnings into errors.  */
 403
 404   char warnings_are_errors;
 405
 406   /* Nonzero causes output not to be done,
 407      but directives such as #define that have side effects
 408      are still obeyed.  */
 409
 410   char no_output;
 411
 412   /* Nonzero means we should look for header.gcc files that remap file
 413      names.  */
 414   char remap;
 415
 416   /* Nonzero means don't output line number information.  */
 417
 418   char no_line_commands;
 419
 420 /* Nonzero means output the text in failing conditionals,
 421    inside #failed ... #endfailed.  */
 422
 423   char output_conditionals;
 424
 425   /* Nonzero means -I- has been seen,
 426      so don't look for #include "foo" the source-file directory.  */
 427   char ignore_srcdir;
 428
 429   /* Zero means dollar signs are punctuation.
 430      This used to be needed for conformance to the C Standard,
 431      before the C Standard was corrected.  */
 432   char dollars_in_ident;
 433
 434   /* Nonzero means try to imitate old fashioned non-ANSI preprocessor.  */
 435   char traditional;
 436
 437   /* Nonzero means warn if undefined identifiers are evaluated in an #if.  */
 438   char warn_undef;
 439
 440   /* Nonzero for the 1989 C Standard, including corrigenda and amendments.  */
 441   char c89;
 442
 443   /* Nonzero means give all the error messages the ANSI standard requires.  */
 444   char pedantic;
 445
 446   char done_initializing;
 447
 448   struct file_name_list *include;       /* First dir to search */
 449   /* First dir to search for <file> */
 450   /* This is the first element to use for #include <...>.
 451      If it is 0, use the entire chain for such includes.  */
 452   struct file_name_list *first_bracket_include;
 453   /* This is the first element in the chain that corresponds to
 454      a directory of system header files.  */
 455   struct file_name_list *first_system_include;
 456   struct file_name_list *last_include;  /* Last in chain */
 457
 458   /* Chain of include directories to put at the end of the other chain.  */
 459   struct file_name_list *after_include;
 460   struct file_name_list *last_after_include;    /* Last in chain */
 461
 462   /* Chain to put at the start of the system include files.  */
 463   struct file_name_list *before_system;
 464   struct file_name_list *last_before_system;    /* Last in chain */
 465
 466   /* Directory prefix that should replace `/usr' in the standard
 467      include file directories.  */
 468   char *include_prefix;
 469
 470   char inhibit_predefs;
 471   char no_standard_includes;
 472   char no_standard_cplusplus_includes;
 473
 474 /* dump_only means inhibit output of the preprocessed text
 475              and instead output the definitions of all user-defined
 476              macros in a form suitable for use as input to cccp.
 477    dump_names means pass #define and the macro name through to output.
 478    dump_definitions means pass the whole definition (plus #define) through
 479 */
 480
 481   enum {dump_none = 0, dump_only, dump_names, dump_definitions}
 482      dump_macros;
 483
 484 /* Nonzero means pass all #define and #undef directives which we actually
 485    process through to the output stream.  This feature is used primarily
 486    to allow cc1 to record the #defines and #undefs for the sake of
 487    debuggers which understand about preprocessor macros, but it may
 488    also be useful with -E to figure out how symbols are defined, and
 489    where they are defined.  */
 490   int debug_output;
 491
 492   /* Nonzero means pass #include lines through to the output,
 493      even if they are ifdefed out.  */
 494   int dump_includes;
 495
 496   /* Pending -D, -U and -A options, in reverse order. */
 497   struct cpp_pending *pending;
 498
 499   /* File name which deps are being written to.
 500      This is 0 if deps are being written to stdout.  */
 501   char *deps_file;
 502
 503   /* Target-name to write with the dependency information.  */
 504   char *deps_target;
 505 };
 506
 507 #define CPP_TRADITIONAL(PFILE) (CPP_OPTIONS(PFILE)-> traditional)
 508 #define CPP_WARN_UNDEF(PFILE) (CPP_OPTIONS(PFILE)->warn_undef)
 509 #define CPP_C89(PFILE) (CPP_OPTIONS(PFILE)->c89)
 510 #define CPP_PEDANTIC(PFILE) (CPP_OPTIONS (PFILE)->pedantic)
 511 #define CPP_PRINT_DEPS(PFILE) (CPP_OPTIONS (PFILE)->print_deps)
 512
 513 struct file_name_list
 514   {
 515     struct file_name_list *next;
 516     char *fname;
 517     /* If the following is nonzero, it is a macro name.
 518        Don't include the file again if that macro is defined.  */
 519     U_CHAR *control_macro;
 520     /* If the following is nonzero, it is a C-language system include
 521        directory.  */
 522     int c_system_include_path;
 523     /* Mapping of file names for this directory.  */
 524     struct file_name_map *name_map;
 525     /* Non-zero if name_map is valid.  */
 526     int got_name_map;
 527   };
 528
 529 /* If a buffer's dir field is SELF_DIR_DUMMY, it means the file was found
 530    via the same directory as the file that #included it.  */
 531 #define SELF_DIR_DUMMY ((struct file_name_list *) (~0))
 532
 533
 534 /* Name under which this program was invoked.  */
 535
 536 extern char *progname;
 537
 538 /* The structure of a node in the hash table.  The hash table
 539    has entries for all tokens defined by #define commands (type T_MACRO),
 540    plus some special tokens like __LINE__ (these each have their own
 541    type, and the appropriate code is run when that type of node is seen.
 542    It does not contain control words like "#define", which are recognized
 543    by a separate piece of code. */
 544
 545 /* different flavors of hash nodes --- also used in keyword table */
 546 enum node_type {
 547  T_DEFINE = 1,  /* the `#define' keyword */
 548  T_INCLUDE,     /* the `#include' keyword */
 549  T_INCLUDE_NEXT, /* the `#include_next' keyword */
 550  T_IMPORT,      /* the `#import' keyword */
 551  T_IFDEF,       /* the `#ifdef' keyword */
 552  T_IFNDEF,      /* the `#ifndef' keyword */
 553  T_IF,          /* the `#if' keyword */
 554  T_ELSE,        /* `#else' */
 555  T_PRAGMA,      /* `#pragma' */
 556  T_ELIF,        /* `#elif' */
 557  T_UNDEF,       /* `#undef' */
 558  T_LINE,        /* `#line' */
 559  T_ERROR,       /* `#error' */
 560  T_WARNING,     /* `#warning' */
 561  T_ENDIF,       /* `#endif' */
 562  T_SCCS,        /* `#sccs', used on system V.  */
 563  T_IDENT,       /* `#ident', used on system V.  */
 564  T_ASSERT,      /* `#assert', taken from system V.  */
 565  T_UNASSERT,    /* `#unassert', taken from system V.  */
 566  T_SPECLINE,    /* special symbol `__LINE__' */
 567  T_DATE,        /* `__DATE__' */
 568  T_FILE,        /* `__FILE__' */
 569  T_BASE_FILE,   /* `__BASE_FILE__' */
 570  T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
 571  T_VERSION,     /* `__VERSION__' */
 572  T_SIZE_TYPE,   /* `__SIZE_TYPE__' */
 573  T_PTRDIFF_TYPE,   /* `__PTRDIFF_TYPE__' */
 574  T_WCHAR_TYPE,   /* `__WCHAR_TYPE__' */
 575  T_USER_LABEL_PREFIX_TYPE, /* `__USER_LABEL_PREFIX__' */
 576  T_REGISTER_PREFIX_TYPE,   /* `__REGISTER_PREFIX__' */
 577  T_TIME,        /* `__TIME__' */
 578  T_CONST,       /* Constant value, used by `__STDC__' */
 579  T_MACRO,       /* macro defined by `#define' */
 580  T_DISABLED,    /* macro temporarily turned off for rescan */
 581  T_SPEC_DEFINED, /* special `defined' macro for use in #if statements */
 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 extern unsigned char is_idchar[256];
 647 extern unsigned char is_hor_space[256];
 648 extern unsigned char is_space[256];
 649
 650 /* Stack of conditionals currently in progress
 651    (including both successful and failing conditionals).  */
 652
 653 struct if_stack {
 654   struct if_stack *next;        /* for chaining to the next stack frame */
 655   char *fname;          /* copied from input when frame is made */
 656   int lineno;                   /* similarly */
 657   int if_succeeded;             /* true if a leg of this if-group
 658                                     has been passed through rescan */
 659   unsigned char *control_macro; /* For #ifndef at start of file,
 660                                    this is the macro name tested.  */
 661   enum node_type type;          /* type of last directive seen in this group */
 662 };
 663 typedef struct if_stack IF_STACK_FRAME;
 664
 665 extern void cpp_buf_line_and_col PARAMS((cpp_buffer *, long *, long *));
 666 extern cpp_buffer* cpp_file_buffer PARAMS((cpp_reader *));
 667 extern void cpp_define PARAMS ((cpp_reader*, unsigned char *));
 668
 669 extern void cpp_error PVPROTO ((cpp_reader *, const char *, ...))
 670   ATTRIBUTE_PRINTF_2;
 671 extern void cpp_warning PVPROTO ((cpp_reader *, const char *, ...))
 672   ATTRIBUTE_PRINTF_2;
 673 extern void cpp_pedwarn PVPROTO ((cpp_reader *, const char *, ...))
 674   ATTRIBUTE_PRINTF_2;
 675 extern void cpp_error_with_line PVPROTO ((cpp_reader *, int, int, const char *, ...))
 676   ATTRIBUTE_PRINTF_4;
 677 extern void cpp_pedwarn_with_line PVPROTO ((cpp_reader *, int, int, const char *, ...))
 678   ATTRIBUTE_PRINTF_4;
 679 extern void cpp_pedwarn_with_file_and_line PVPROTO ((cpp_reader *, char *, int, const char *, ...))
 680   ATTRIBUTE_PRINTF_4;
 681 extern void cpp_message_from_errno PROTO ((cpp_reader *, int, const char *));
 682 extern void cpp_error_from_errno PROTO ((cpp_reader *, const char *));
 683 extern void cpp_perror_with_name PROTO ((cpp_reader *, const char *));
 684 extern void v_cpp_message PROTO ((cpp_reader *, int, const char *, va_list));
 685
 686 extern void cpp_grow_buffer PARAMS ((cpp_reader *, long));
 687 extern int cpp_parse_escape PARAMS ((cpp_reader *, char **));
 688 extern cpp_buffer *cpp_push_buffer PARAMS ((cpp_reader *,
 689                                             unsigned char *, long));
 690 extern cpp_buffer *cpp_pop_buffer PARAMS ((cpp_reader *));
 691
 692 extern cpp_hashnode *cpp_lookup PARAMS ((cpp_reader *, const unsigned char *,
 693                                          int, int));
 694 extern void cpp_reader_init PARAMS ((cpp_reader *));
 695 extern void cpp_options_init PARAMS ((cpp_options *));
 696 extern int cpp_start_read PARAMS ((cpp_reader *, char *));
 697 extern int cpp_read_check_assertion PARAMS ((cpp_reader *));
 698 extern int scan_decls PARAMS ((cpp_reader *, int, char **));
 699 extern void skip_rest_of_line PARAMS ((cpp_reader *));
 700 extern void cpp_finish PARAMS ((cpp_reader *));
 701
 702 /* From cpperror.c */
 703 extern void cpp_fatal PVPROTO ((cpp_reader *, const char *, ...))
 704   ATTRIBUTE_PRINTF_2;
 705 extern void cpp_message PVPROTO ((cpp_reader *, int, const char *, ...))
 706   ATTRIBUTE_PRINTF_3;
 707 extern void cpp_pfatal_with_name PROTO ((cpp_reader *, const char *));
 708 extern void cpp_file_line_for_message PROTO ((cpp_reader *, char *, int, int));
 709 extern void cpp_print_containing_files PROTO ((cpp_reader *));
 710
 711 /* In cppfiles.c */
 712 extern void append_include_chain        PROTO ((cpp_reader *,
 713                                                 struct file_name_list *,
 714                                                 struct file_name_list *));
 715 extern int finclude                     PROTO ((cpp_reader *, int, char *,
 716                                                 int, struct file_name_list *));
 717 extern int find_include_file            PROTO ((cpp_reader *, char *,
 718                                                 unsigned long, char *, int,
 719                                                 struct file_name_list *,
 720                                                 struct file_name_list **));
 721 extern void deps_output                 PROTO ((cpp_reader *, char *, int));
 722
 723 /* Bleargh. */
 724 extern char *savestring                 PROTO ((char *));
 725 #ifndef INCLUDE_LEN_FUDGE
 726 #define INCLUDE_LEN_FUDGE 0
 727 #endif
 728
 729
 730 #ifdef __cplusplus
 731 }
 732 #endif
 733 #endif /* __GCC_CPPLIB__ */
 734