gcc/cpplib.h

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