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
  23 #include <sys/types.h>
  24 #include <sys/stat.h>
  25
  26 #ifdef __cplusplus
  27 extern "C" {
  28 #endif
  29
  30 typedef unsigned char U_CHAR;
  31
  32 typedef struct cpp_reader cpp_reader;
  33 typedef struct cpp_buffer cpp_buffer;
  34 typedef struct cpp_options cpp_options;
  35 typedef struct hashnode cpp_hashnode;
  36
  37 enum cpp_token {
  38   CPP_EOF = -1,
  39   CPP_OTHER = 0,
  40   CPP_COMMENT = 1,
  41   CPP_HSPACE,
  42   CPP_VSPACE, /* newlines and #line directives */
  43   CPP_NAME,
  44   CPP_NUMBER,
  45   CPP_CHAR,
  46   CPP_STRING,
  47   CPP_DIRECTIVE,
  48   CPP_LPAREN,   /* "(" */
  49   CPP_RPAREN,   /* ")" */
  50   CPP_LBRACE,   /* "{" */
  51   CPP_RBRACE,   /* "}" */
  52   CPP_COMMA,    /* "," */
  53   CPP_SEMICOLON,/* ";" */
  54   CPP_3DOTS,    /* "..." */
  55 #if 0
  56   CPP_ANDAND, /* "&&" */
  57   CPP_OROR,   /* "||" */
  58   CPP_LSH,    /* "<<" */
  59   CPP_RSH,    /* ">>" */
  60   CPP_EQL,    /* "==" */
  61   CPP_NEQ,    /* "!=" */
  62   CPP_LEQ,    /* "<=" */
  63   CPP_GEQ,    /* ">=" */
  64   CPP_PLPL,   /* "++" */
  65   CPP_MINMIN, /* "--" */
  66 #endif
  67   /* POP_TOKEN is returned when we've popped a cpp_buffer. */
  68   CPP_POP
  69 };
  70
  71 #ifndef PARAMS
  72 #define PARAMS(P) PROTO(P)
  73 #endif /* !PARAMS */
  74
  75 typedef enum cpp_token (*parse_underflow_t) PARAMS((cpp_reader *));
  76 typedef int (*parse_cleanup_t) PARAMS((cpp_buffer *, cpp_reader *));
  77
  78 /* A parse_marker indicates a previous position,
  79    which we can backtrack to. */
  80
  81 struct parse_marker {
  82   cpp_buffer *buf;
  83   struct parse_marker *next;
  84   int position;
  85 };
  86
  87 extern void parse_set_mark PARAMS ((struct parse_marker *, cpp_reader *));
  88 extern void parse_clear_mark PARAMS ((struct parse_marker *));
  89 extern void parse_goto_mark PARAMS((struct parse_marker *, cpp_reader *));
  90 extern void parse_move_mark PARAMS((struct parse_marker *, cpp_reader *));
  91
  92 extern int cpp_handle_options PARAMS ((cpp_reader *, int, char **));
  93 extern enum cpp_token cpp_get_token PARAMS ((cpp_reader *));
  94 extern void cpp_skip_hspace PARAMS((cpp_reader *));
  95 extern enum cpp_token cpp_get_non_space_token PARAMS ((cpp_reader *));
  96
  97 /* This frees resources used by PFILE. */
  98 extern void cpp_cleanup PARAMS ((cpp_reader *PFILE));
  99
 100 /* Maintain and search list of included files, for #import.  */
 101
 102 #define IMPORT_HASH_SIZE 31
 103
 104 struct import_file {
 105   char *name;
 106   ino_t inode;
 107   dev_t dev;
 108   struct import_file *next;
 109 };
 110
 111 /* If we have a huge buffer, may need to cache more recent counts */
 112 #define CPP_LINE_BASE(BUF) ((BUF)->buf + (BUF)->line_base)
 113
 114 struct cpp_buffer {
 115   unsigned char *buf;
 116   unsigned char *cur;
 117   unsigned char *rlimit; /* end of valid data */
 118   unsigned char *alimit; /* end of allocated buffer */
 119   unsigned char *prev;  /* start of current token */
 120
 121   char *fname;
 122   /* Filename specified with #line command.  */
 123   char *nominal_fname;
 124
 125   /* Record where in the search path this file was found.
 126      For #include_next.  */
 127   struct file_name_list *dir;
 128
 129   long line_base;
 130   long lineno; /* Line number at CPP_LINE_BASE. */
 131   long colno; /* Column number at CPP_LINE_BASE. */
 132   parse_underflow_t underflow;
 133   parse_cleanup_t cleanup;
 134   void *data;
 135   struct parse_marker *marks;
 136   /* Value of if_stack at start of this file.
 137      Used to prohibit unmatched #endif (etc) in an include file.  */
 138   struct if_stack *if_stack;
 139
 140   /* True if this is a header file included using <FILENAME>.  */
 141   char system_header_p;
 142   char seen_eof;
 143
 144   /* True if buffer contains escape sequences.
 145      Currently there are three kinds:
 146      "@-" means following identifier should not be macro-expanded.
 147      "@ " means a token-separator.  This turns into " " in final output
 148           if not stringizing and needed to separate tokens; otherwise nothing.
 149      "@@" means a normal '@'.
 150      (An '@' inside a string stands for itself and is never an escape.) */
 151   char has_escapes;
 152 };
 153
 154 struct cpp_pending;  /* Forward declaration - for C++. */
 155 struct file_name_map_list;
 156
 157 typedef struct assertion_hashnode ASSERTION_HASHNODE;
 158 #define ASSERTION_HASHSIZE 37
 159
 160 /* Maximum nesting of cpp_buffers.  We use a static limit, partly for
 161    efficiency, and partly to limit runaway recursion.  */
 162 #define CPP_STACK_MAX 200
 163
 164 /* A cpp_reader encapsulates the "state" of a pre-processor run.
 165    Applying cpp_get_token repeatedly yields a stream of pre-processor
 166    tokens.  Usually, there is only one cpp_reader object active. */
 167
 168 struct cpp_reader {
 169   parse_underflow_t get_token;
 170   cpp_buffer *buffer;
 171   cpp_buffer buffer_stack[CPP_STACK_MAX];
 172
 173   int errors;                   /* Error counter for exit code */
 174   void *data;
 175
 176   /* A buffer used for both for cpp_get_token's output, and also internally. */
 177   unsigned char *token_buffer;
 178   /* Allocated size of token_buffer.  CPP_RESERVE allocates space.  */
 179   int token_buffer_size;
 180   /* End of the written part of token_buffer. */
 181   unsigned char *limit;
 182
 183   /* Line where a newline was first seen in a string constant.  */
 184   int multiline_string_line;
 185
 186   /* Current depth in #include directives that use <...>.  */
 187   int system_include_depth;
 188
 189   /* List of included files that contained #pragma once.  */
 190   struct file_name_list *dont_repeat_files;
 191
 192   /* List of other included files.
 193      If ->control_macro if nonzero, the file had a #ifndef
 194      around the entire contents, and ->control_macro gives the macro name.  */
 195   struct file_name_list *all_include_files;
 196
 197   /* Current maximum length of directory names in the search path
 198      for include files.  (Altered as we get more of them.)  */
 199   int max_include_len;
 200
 201   /* Hash table of files already included with #include or #import.  */
 202   struct import_file *import_hash_table[IMPORT_HASH_SIZE];
 203
 204   struct if_stack *if_stack;
 205
 206   /* Nonzero means we are inside an IF during a -pcp run.  In this mode
 207      macro expansion is done, and preconditions are output for all macro
 208      uses requiring them. */
 209   char pcp_inside_if;
 210
 211   /* Nonzero means we have printed (while error reporting) a list of
 212      containing files that matches the current status. */
 213   char input_stack_listing_current;
 214
 215   /* If non-zero, macros are not expanded. */
 216   char no_macro_expand;
 217
 218   /* Print column number in error messages. */
 219   char show_column;
 220
 221   /* We're printed a warning recommending against using #import. */
 222   char import_warning;
 223
 224   /* If true, character between '<' and '>' are a single (string) token. */
 225   char parsing_include_directive;
 226
 227   /* True if escape sequences (as described for has_escapes in
 228      parse_buffer) should be emitted. */
 229   char output_escapes;
 230
 231   /* 0: Have seen non-white-space on this line.
 232      1: Only seen white space so far on this line.
 233      2: Only seen white space so far in this file. */
 234    char only_seen_white;
 235
 236   /* Nonzero means this file was included with a -imacros or -include
 237      command line and should not be recorded as an include file.  */
 238
 239   int no_record_file;
 240
 241   long lineno;
 242
 243   struct tm *timebuf;
 244
 245   ASSERTION_HASHNODE *assertion_hashtab[ASSERTION_HASHSIZE];
 246
 247   /* Buffer of -M output.  */
 248   char *deps_buffer;
 249
 250   /* Number of bytes allocated in above.  */
 251   int deps_allocated_size;
 252
 253   /* Number of bytes used.  */
 254   int deps_size;
 255
 256   /* Number of bytes since the last newline.  */
 257   int deps_column;
 258
 259 #ifdef __cplusplus
 260   ~cpp_reader () { cpp_cleanup (this); }
 261 #endif
 262 };
 263
 264 #define CPP_FATAL_LIMIT 1000
 265 /* True if we have seen a "fatal" error. */
 266 #define CPP_FATAL_ERRORS(READER) ((READER)->errors >= CPP_FATAL_LIMIT)
 267
 268 #define CPP_BUF_PEEK(BUFFER) \
 269   ((BUFFER)->cur < (BUFFER)->rlimit ? *(BUFFER)->cur : EOF)
 270 #define CPP_BUF_GET(BUFFER) \
 271   ((BUFFER)->cur < (BUFFER)->rlimit ? *(BUFFER)->cur++ : EOF)
 272 #define CPP_FORWARD(BUFFER, N) ((BUFFER)->cur += (N))
 273
 274 /* Macros for manipulating the token_buffer. */
 275
 276 #define CPP_OUT_BUFFER(PFILE) ((PFILE)->token_buffer)
 277
 278 /* Number of characters currently in PFILE's output buffer. */
 279 #define CPP_WRITTEN(PFILE) ((PFILE)->limit - (PFILE)->token_buffer)
 280 #define CPP_PWRITTEN(PFILE) ((PFILE)->limit)
 281
 282 /* Make sure PFILE->token_buffer has space for at least N more characters. */
 283 #define CPP_RESERVE(PFILE, N) \
 284   (CPP_WRITTEN (PFILE) + N > (PFILE)->token_buffer_size \
 285    && (cpp_grow_buffer (PFILE, N), 0))
 286
 287 /* Append string STR (of length N) to PFILE's output buffer.
 288    Assume there is enough space. */
 289 #define CPP_PUTS_Q(PFILE, STR, N) \
 290   (bcopy (STR, (PFILE)->limit, (N)), (PFILE)->limit += (N))
 291 /* Append string STR (of length N) to PFILE's output buffer.  Make space. */
 292 #define CPP_PUTS(PFILE, STR, N) CPP_RESERVE(PFILE, N), CPP_PUTS_Q(PFILE, STR,N)
 293 /* Append character CH to PFILE's output buffer.  Assume sufficient space. */
 294 #define CPP_PUTC_Q(PFILE, CH) (*(PFILE)->limit++ = (CH))
 295 /* Append character CH to PFILE's output buffer.  Make space if need be. */
 296 #define CPP_PUTC(PFILE, CH) (CPP_RESERVE (PFILE, 1), CPP_PUTC_Q (PFILE, CH))
 297 /* Make sure PFILE->limit is followed by '\0'. */
 298 #define CPP_NUL_TERMINATE_Q(PFILE) (*(PFILE)->limit = 0)
 299 #define CPP_NUL_TERMINATE(PFILE) (CPP_RESERVE(PFILE, 1), *(PFILE)->limit = 0)
 300 #define CPP_ADJUST_WRITTEN(PFILE,DELTA) ((PFILE)->limit += (DELTA))
 301 #define CPP_SET_WRITTEN(PFILE,N) ((PFILE)->limit = (PFILE)->token_buffer + (N))
 302
 303 #define CPP_OPTIONS(PFILE) ((cpp_options *) (PFILE)->data)
 304
 305 #define CPP_BUFFER(PFILE) ((PFILE)->buffer)
 306 #define CPP_PREV_BUFFER(BUFFER) ((BUFFER)+1)
 307 /* The bottom of the buffer stack. */
 308 #define CPP_NULL_BUFFER(PFILE) (&(PFILE)->buffer_stack[CPP_STACK_MAX])
 309
 310 /* Pointed to by cpp_reader::data. */
 311 struct cpp_options {
 312   char *in_fname;
 313
 314   /* Name of output file, for error messages.  */
 315   char *out_fname;
 316
 317   struct file_name_map_list *map_list;
 318
 319   /* Non-0 means -v, so print the full set of include dirs.  */
 320   char verbose;
 321
 322   /* Nonzero means use extra default include directories for C++.  */
 323
 324   char cplusplus;
 325
 326   /* Nonzero means handle cplusplus style comments */
 327
 328   char cplusplus_comments;
 329
 330   /* Nonzero means handle #import, for objective C.  */
 331
 332   char objc;
 333
 334   /* Nonzero means this is an assembly file, and allow
 335      unknown directives, which could be comments.  */
 336
 337   int lang_asm;
 338
 339   /* Nonzero means turn NOTREACHED into #pragma NOTREACHED etc */
 340
 341   char for_lint;
 342
 343   /* Nonzero means handle CHILL comment syntax
 344      and output CHILL string delimiter for __DATE___ etc. */
 345
 346   char chill;
 347
 348   /* Nonzero means copy comments into the output file.  */
 349
 350   char put_out_comments;
 351
 352   /* Nonzero means don't process the ANSI trigraph sequences.  */
 353
 354   char no_trigraphs;
 355
 356   /* Nonzero means print the names of included files rather than
 357      the preprocessed output.  1 means just the #include "...",
 358      2 means #include <...> as well.  */
 359
 360   char print_deps;
 361
 362   /* Nonzero if missing .h files in -M output are assumed to be generated
 363      files and not errors.  */
 364
 365   char print_deps_missing_files;
 366
 367   /* If true, fopen (deps_file, "a") else fopen (deps_file, "w"). */
 368   char print_deps_append;
 369
 370   /* Nonzero means print names of header files (-H).  */
 371
 372   char print_include_names;
 373
 374   /* Nonzero means try to make failure to fit ANSI C an error.  */
 375
 376   char pedantic_errors;
 377
 378   /* Nonzero means don't print warning messages.  -w.  */
 379
 380   char inhibit_warnings;
 381
 382   /* Nonzero means warn if slash-star appears in a comment.  */
 383
 384   char warn_comments;
 385
 386   /* Nonzero means warn if there are any trigraphs.  */
 387
 388   char warn_trigraphs;
 389
 390   /* Nonzero means warn if #import is used.  */
 391
 392   char warn_import;
 393
 394   /* Nonzero means warn if a macro argument is (or would be)
 395      stringified with -traditional.  */
 396
 397   char warn_stringify;
 398
 399   /* Nonzero means turn warnings into errors.  */
 400
 401   char warnings_are_errors;
 402
 403   /* Nonzero causes output not to be done,
 404      but directives such as #define that have side effects
 405      are still obeyed.  */
 406
 407   char no_output;
 408
 409   /* Nonzero means we should look for header.gcc files that remap file
 410      names.  */
 411   char remap;
 412
 413   /* Nonzero means don't output line number information.  */
 414
 415   char no_line_commands;
 416
 417 /* Nonzero means output the text in failing conditionals,
 418    inside #failed ... #endfailed.  */
 419
 420   char output_conditionals;
 421
 422   /* Nonzero means -I- has been seen,
 423      so don't look for #include "foo" the source-file directory.  */
 424   char ignore_srcdir;
 425
 426   /* Zero means dollar signs are punctuation.
 427      This used to be needed for conformance to the C Standard,
 428      before the C Standard was corrected.  */
 429   char dollars_in_ident;
 430
 431   /* Nonzero means try to imitate old fashioned non-ANSI preprocessor.  */
 432   char traditional;
 433
 434   /* Nonzero means warn if undefined identifiers are evaluated in an #if.  */
 435   char warn_undef;
 436
 437   /* Nonzero for the 1989 C Standard, including corrigenda and amendments.  */
 438   char c89;
 439
 440   /* Nonzero means give all the error messages the ANSI standard requires.  */
 441   char pedantic;
 442
 443   char done_initializing;
 444
 445   struct file_name_list *include;       /* First dir to search */
 446   /* First dir to search for <file> */
 447   /* This is the first element to use for #include <...>.
 448      If it is 0, use the entire chain for such includes.  */
 449   struct file_name_list *first_bracket_include;
 450   /* This is the first element in the chain that corresponds to
 451      a directory of system header files.  */
 452   struct file_name_list *first_system_include;
 453   struct file_name_list *last_include;  /* Last in chain */
 454
 455   /* Chain of include directories to put at the end of the other chain.  */
 456   struct file_name_list *after_include;
 457   struct file_name_list *last_after_include;    /* Last in chain */
 458
 459   /* Chain to put at the start of the system include files.  */
 460   struct file_name_list *before_system;
 461   struct file_name_list *last_before_system;    /* Last in chain */
 462
 463   /* Directory prefix that should replace `/usr' in the standard
 464      include file directories.  */
 465   char *include_prefix;
 466
 467   char inhibit_predefs;
 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 -D, -U and -A options, in reverse order. */
 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 /* Name under which this program was invoked.  */
 511
 512 extern char *progname;
 513
 514 /* The structure of a node in the hash table.  The hash table
 515    has entries for all tokens defined by #define commands (type T_MACRO),
 516    plus some special tokens like __LINE__ (these each have their own
 517    type, and the appropriate code is run when that type of node is seen.
 518    It does not contain control words like "#define", which are recognized
 519    by a separate piece of code. */
 520
 521 /* different flavors of hash nodes --- also used in keyword table */
 522 enum node_type {
 523  T_DEFINE = 1,  /* the `#define' keyword */
 524  T_INCLUDE,     /* the `#include' keyword */
 525  T_INCLUDE_NEXT, /* the `#include_next' keyword */
 526  T_IMPORT,      /* the `#import' keyword */
 527  T_IFDEF,       /* the `#ifdef' keyword */
 528  T_IFNDEF,      /* the `#ifndef' keyword */
 529  T_IF,          /* the `#if' keyword */
 530  T_ELSE,        /* `#else' */
 531  T_PRAGMA,      /* `#pragma' */
 532  T_ELIF,        /* `#elif' */
 533  T_UNDEF,       /* `#undef' */
 534  T_LINE,        /* `#line' */
 535  T_ERROR,       /* `#error' */
 536  T_WARNING,     /* `#warning' */
 537  T_ENDIF,       /* `#endif' */
 538  T_SCCS,        /* `#sccs', used on system V.  */
 539  T_IDENT,       /* `#ident', used on system V.  */
 540  T_ASSERT,      /* `#assert', taken from system V.  */
 541  T_UNASSERT,    /* `#unassert', taken from system V.  */
 542  T_SPECLINE,    /* special symbol `__LINE__' */
 543  T_DATE,        /* `__DATE__' */
 544  T_FILE,        /* `__FILE__' */
 545  T_BASE_FILE,   /* `__BASE_FILE__' */
 546  T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
 547  T_VERSION,     /* `__VERSION__' */
 548  T_SIZE_TYPE,   /* `__SIZE_TYPE__' */
 549  T_PTRDIFF_TYPE,   /* `__PTRDIFF_TYPE__' */
 550  T_WCHAR_TYPE,   /* `__WCHAR_TYPE__' */
 551  T_USER_LABEL_PREFIX_TYPE, /* `__USER_LABEL_PREFIX__' */
 552  T_REGISTER_PREFIX_TYPE,   /* `__REGISTER_PREFIX__' */
 553  T_TIME,        /* `__TIME__' */
 554  T_CONST,       /* Constant value, used by `__STDC__' */
 555  T_MACRO,       /* macro defined by `#define' */
 556  T_DISABLED,    /* macro temporarily turned off for rescan */
 557  T_SPEC_DEFINED, /* special `defined' macro for use in #if statements */
 558  T_PCSTRING,    /* precompiled string (hashval is KEYDEF *) */
 559  T_UNUSED       /* Used for something not defined.  */
 560  };
 561
 562 /* Structure returned by create_definition */
 563 typedef struct macrodef MACRODEF;
 564 struct macrodef
 565 {
 566   struct definition *defn;
 567   unsigned char *symnam;
 568   int symlen;
 569 };
 570
 571 /* Structure allocated for every #define.  For a simple replacement
 572    such as
 573         #define foo bar ,
 574    nargs = -1, the `pattern' list is null, and the expansion is just
 575    the replacement text.  Nargs = 0 means a functionlike macro with no args,
 576    e.g.,
 577        #define getchar() getc (stdin) .
 578    When there are args, the expansion is the replacement text with the
 579    args squashed out, and the reflist is a list describing how to
 580    build the output from the input: e.g., "3 chars, then the 1st arg,
 581    then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
 582    The chars here come from the expansion.  Whatever is left of the
 583    expansion after the last arg-occurrence is copied after that arg.
 584    Note that the reflist can be arbitrarily long---
 585    its length depends on the number of times the arguments appear in
 586    the replacement text, not how many args there are.  Example:
 587    #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
 588    pattern list
 589      { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
 590    where (x, y) means (nchars, argno). */
 591
 592 typedef struct definition DEFINITION;
 593 struct definition {
 594   int nargs;
 595   int length;                   /* length of expansion string */
 596   int predefined;               /* True if the macro was builtin or */
 597                                 /* came from the command line */
 598   unsigned char *expansion;
 599   int line;                     /* Line number of definition */
 600   char *file;                   /* File of definition */
 601   char rest_args;               /* Nonzero if last arg. absorbs the rest */
 602   struct reflist {
 603     struct reflist *next;
 604     char stringify;             /* nonzero if this arg was preceded by a
 605                                    # operator. */
 606     char raw_before;            /* Nonzero if a ## operator before arg. */
 607     char raw_after;             /* Nonzero if a ## operator after arg. */
 608     char rest_args;             /* Nonzero if this arg. absorbs the rest */
 609     int nchars;                 /* Number of literal chars to copy before
 610                                    this arg occurrence.  */
 611     int argno;                  /* Number of arg to substitute (origin-0) */
 612   } *pattern;
 613   union {
 614     /* Names of macro args, concatenated in reverse order
 615        with comma-space between them.
 616        The only use of this is that we warn on redefinition
 617        if this differs between the old and new definitions.  */
 618     unsigned char *argnames;
 619   } args;
 620 };
 621
 622 extern unsigned char is_idchar[256];
 623
 624 /* Stack of conditionals currently in progress
 625    (including both successful and failing conditionals).  */
 626
 627 struct if_stack {
 628   struct if_stack *next;        /* for chaining to the next stack frame */
 629   char *fname;          /* copied from input when frame is made */
 630   int lineno;                   /* similarly */
 631   int if_succeeded;             /* true if a leg of this if-group
 632                                     has been passed through rescan */
 633   unsigned char *control_macro; /* For #ifndef at start of file,
 634                                    this is the macro name tested.  */
 635   enum node_type type;          /* type of last directive seen in this group */
 636 };
 637 typedef struct if_stack IF_STACK_FRAME;
 638
 639 extern void cpp_buf_line_and_col PARAMS((cpp_buffer *, long *, long *));
 640 extern cpp_buffer* cpp_file_buffer PARAMS((cpp_reader *));
 641 extern void cpp_define PARAMS ((cpp_reader*, unsigned char *));
 642
 643 extern void cpp_error PVPROTO ((cpp_reader *, const char *, ...))
 644   ATTRIBUTE_PRINTF_2;
 645 extern void cpp_warning PVPROTO ((cpp_reader *, const char *, ...))
 646   ATTRIBUTE_PRINTF_2;
 647 extern void cpp_pedwarn PVPROTO ((cpp_reader *, const char *, ...))
 648   ATTRIBUTE_PRINTF_2;
 649 extern void cpp_error_with_line PVPROTO ((cpp_reader *, int, int, const char *, ...))
 650   ATTRIBUTE_PRINTF_4;
 651 extern void cpp_pedwarn_with_line PVPROTO ((cpp_reader *, int, int, const char *, ...))
 652   ATTRIBUTE_PRINTF_4;
 653 extern void cpp_pedwarn_with_file_and_line PVPROTO ((cpp_reader *, char *, int, const char *, ...))
 654   ATTRIBUTE_PRINTF_4;
 655 extern void cpp_error_from_errno PROTO ((cpp_reader *, const char *));
 656 extern void cpp_perror_with_name PROTO ((cpp_reader *, const char *));
 657
 658 extern void cpp_grow_buffer PARAMS ((cpp_reader *, long));
 659 extern int cpp_parse_escape PARAMS ((cpp_reader *, char **));
 660 extern cpp_buffer *cpp_push_buffer PARAMS ((cpp_reader *,
 661                                             unsigned char *, long));
 662 extern cpp_buffer *cpp_pop_buffer PARAMS ((cpp_reader *));
 663
 664 extern cpp_hashnode *cpp_lookup PARAMS ((cpp_reader *, const unsigned char *,
 665                                          int, int));
 666 extern void cpp_reader_init PARAMS ((cpp_reader *));
 667 extern void cpp_options_init PARAMS ((cpp_options *));
 668 extern int cpp_start_read PARAMS ((cpp_reader *, char *));
 669 extern int cpp_read_check_assertion PARAMS ((cpp_reader *));
 670 extern int scan_decls PARAMS ((cpp_reader *, int, char **));
 671 extern void skip_rest_of_line PARAMS ((cpp_reader *));
 672 extern void cpp_finish PARAMS ((cpp_reader *));
 673
 674 /* From cpperror.c */
 675 extern void cpp_fatal PVPROTO ((cpp_reader *, const char *, ...))
 676   ATTRIBUTE_PRINTF_2;
 677 extern void cpp_message PVPROTO ((cpp_reader *, int, const char *, ...))
 678   ATTRIBUTE_PRINTF_3;
 679 extern void cpp_pfatal_with_name PROTO ((cpp_reader *, const char *));
 680 extern void cpp_file_line_for_message PROTO ((cpp_reader *, char *, int, int));
 681 extern void cpp_print_containing_files PROTO ((cpp_reader *));
 682
 683 #ifdef __cplusplus
 684 }
 685 #endif