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