gcc/cpplib.h

   1 /* Definitions for CPP library.
   2    Copyright (C) 1995 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, 675 Mass Ave, Cambridge, MA 02139, 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 #define STATIC_BUFFERS
  31
  32 typedef unsigned char U_CHAR;
  33
  34 #ifndef FAILURE_EXIT_CODE
  35 #define FAILURE_EXIT_CODE 33    /* gnu cc command understands this */
  36 #endif
  37
  38 #ifndef SUCCESS_EXIT_CODE
  39 #define SUCCESS_EXIT_CODE 0     /* 0 means success on Unix.  */
  40 #endif
  41
  42 struct parse_file;
  43 typedef struct cpp_reader cpp_reader;
  44 typedef struct cpp_buffer cpp_buffer;
  45 typedef struct cpp_options cpp_options;
  46 typedef struct hashnode cpp_hashnode;
  47
  48 enum cpp_token {
  49   CPP_EOF = -1,
  50   CPP_OTHER = 0,
  51   CPP_COMMENT = 1,
  52   CPP_HSPACE,
  53   CPP_VSPACE, /* newlines and #line directives */
  54   CPP_NAME,
  55   CPP_NUMBER,
  56   CPP_CHAR,
  57   CPP_STRING,
  58   CPP_DIRECTIVE,
  59   CPP_LPAREN,   /* "(" */
  60   CPP_RPAREN,   /* ")" */
  61   CPP_LBRACE,   /* "{" */
  62   CPP_RBRACE,   /* "}" */
  63   CPP_COMMA,    /* "," */
  64   CPP_SEMICOLON,/* ";" */
  65   CPP_3DOTS,    /* "..." */
  66 #if 0
  67   CPP_ANDAND, /* "&&" */
  68   CPP_OROR,   /* "||" */
  69   CPP_LSH,    /* "<<" */
  70   CPP_RSH,    /* ">>" */
  71   CPP_EQL,    /* "==" */
  72   CPP_NEQ,    /* "!=" */
  73   CPP_LEQ,    /* "<=" */
  74   CPP_GEQ,    /* ">=" */
  75   CPP_PLPL,   /* "++" */
  76   CPP_MINMIN, /* "--" */
  77 #endif
  78   /* POP_TOKEN is returned when we've popped a cpp_buffer. */
  79   CPP_POP
  80 };
  81
  82 #ifndef PARAMS
  83 #ifdef __STDC
  84 #define PARAMS(P) P
  85 #else
  86 #define PARAMS(P) ()
  87 #endif
  88 #endif /* !PARAMS */
  89
  90 typedef enum cpp_token (*parse_underflow_t) PARAMS((cpp_reader*));
  91 typedef int (*parse_cleanup_t) PARAMS((cpp_buffer *, cpp_reader*));
  92
  93 /* A parse_marker indicates a previous position,
  94    which we can backtrack to. */
  95
  96 struct parse_marker {
  97   cpp_buffer *buf;
  98   struct parse_marker *next;
  99   int position;
 100 };
 101
 102 extern void parse_set_mark PARAMS ((struct parse_marker*, cpp_reader*));
 103 extern void parse_clear_mark PARAMS ((struct parse_marker*));
 104 extern void parse_goto_mark PARAMS((struct parse_marker*, cpp_reader*));
 105 extern void parse_move_mark PARAMS((struct parse_marker*, cpp_reader*));
 106
 107 extern int cpp_handle_options PARAMS ((cpp_reader*, int, char**));
 108 extern enum cpp_token cpp_get_token PARAMS ((struct parse_marker*));
 109 extern void cpp_skip_hspace PARAMS((cpp_reader*));
 110 extern enum cpp_token cpp_get_non_space_token PARAMS ((cpp_reader *));
 111
 112
 113 /* Maintain and search list of included files, for #import.  */
 114
 115 #define IMPORT_HASH_SIZE 31
 116
 117 struct import_file {
 118   char *name;
 119   ino_t inode;
 120   dev_t dev;
 121   struct import_file *next;
 122 };
 123
 124 /* If we have a huge buffer, may need to cache more recent counts */
 125 #define CPP_LINE_BASE(BUF) ((BUF)->buf + (BUF)->line_base)
 126
 127 struct cpp_buffer {
 128   unsigned char *buf;
 129   unsigned char *cur;
 130   unsigned char *rlimit; /* end of valid data */
 131   unsigned char *alimit; /* end of allocated buffer */
 132   unsigned char *prev;  /* start of current token */
 133
 134   char *fname;
 135   /* Filename specified with #line command.  */
 136   char *nominal_fname;
 137
 138   /* Record where in the search path this file was found.
 139      For #include_next.  */
 140   struct file_name_list *dir;
 141
 142   long line_base;
 143   long lineno; /* Line number at CPP_LINE_BASE. */
 144   long colno; /* Column number at CPP_LINE_BASE. */
 145 #ifndef STATIC_BUFFERS
 146   cpp_buffer *chain;
 147 #endif
 148   parse_underflow_t underflow;
 149   parse_cleanup_t cleanup;
 150   void *data;
 151   struct parse_marker *marks;
 152   /* Value of if_stack at start of this file.
 153      Used to prohibit unmatched #endif (etc) in an include file.  */
 154   struct if_stack *if_stack;
 155
 156   /* True if this is a header file included using <FILENAME>.  */
 157   char system_header_p;
 158   char seen_eof;
 159
 160   /* True if buffer contains escape sequences.
 161      Currently there are are only two kind:
 162      "@-" means following identifier should not be macro-expanded.
 163      "@ " means a token-separator.  This turns into " " in final output
 164           if not stringizing and needed to separate tokens; otherwise nothing.
 165      "@@" means a normal '@'. */
 166   char has_escapes;
 167 };
 168
 169 struct cpp_pending;  /* Forward declaration - for C++. */
 170 struct file_name_map_list;
 171
 172 typedef struct assertion_hashnode ASSERTION_HASHNODE;
 173 #define ASSERTION_HASHSIZE 37
 174
 175 #ifdef STATIC_BUFFERS
 176 /* Maximum nesting of cpp_buffers.  We use a static limit, partly for
 177    efficiency, and partly to limit runaway recursion.  */
 178 #define CPP_STACK_MAX 200
 179 #endif
 180
 181 struct cpp_reader {
 182   unsigned char *limit;
 183   parse_underflow_t get_token;
 184   cpp_buffer *buffer;
 185 #ifdef STATIC_BUFFERS
 186   cpp_buffer buffer_stack[CPP_STACK_MAX];
 187 #endif
 188
 189   int errors;                   /* Error counter for exit code */
 190   /* While scanning a comment or a string constant,
 191      this records the line it started on, for error messages.  */
 192   int start_line;
 193   void *data;
 194
 195   U_CHAR *token_buffer;
 196   int token_buffer_size;
 197
 198   /* Current depth in #include directives that use <...>.  */
 199   int system_include_depth;
 200
 201   /* List of included files that contained #pragma once.  */
 202   struct file_name_list *dont_repeat_files;
 203
 204   /* List of other included files.
 205      If ->control_macro if nonzero, the file had a #ifndef
 206      around the entire contents, and ->control_macro gives the macro name.  */
 207   struct file_name_list *all_include_files;
 208
 209   /* Current maximum length of directory names in the search path
 210      for include files.  (Altered as we get more of them.)  */
 211   int max_include_len;
 212
 213   /* Hash table of files already included with #include or #import.  */
 214   struct import_file *import_hash_table[IMPORT_HASH_SIZE];
 215
 216   struct if_stack *if_stack;
 217
 218   /* Nonzero means we are inside an IF during a -pcp run.  In this mode
 219      macro expansion is done, and preconditions are output for all macro
 220      uses requiring them. */
 221   char pcp_inside_if;
 222
 223   /* Nonzero means we have printed (while error reporting) a list of
 224      containing files that matches the current status. */
 225   char input_stack_listing_current;
 226
 227   /* If non-zero, macros are not expanded. */
 228   char no_macro_expand;
 229
 230   /* Print column number in error messages. */
 231   char show_column;
 232
 233   /* We're printed a warning recommending against using #import. */
 234   char import_warning;
 235
 236   /* If true, character between '<' and '>' are a single (string) token. */
 237   char parsing_include_directive;
 238
 239   /* True if escape sequences (as described for has_escapes in
 240      parse_buffer) should be emitted. */
 241   char output_escapes;
 242
 243   /* 0: Have seen non-white-space on this line.
 244      1: Only seen white space so far on this line.
 245      2: Only seen white space so far in this file. */
 246    char only_seen_white;
 247
 248   /* Nonzero means this file was included with a -imacros or -include
 249      command line and should not be recorded as an include file.  */
 250
 251   int no_record_file;
 252
 253   long lineno;
 254
 255   struct tm *timebuf;
 256
 257   ASSERTION_HASHNODE *assertion_hashtab[ASSERTION_HASHSIZE];
 258
 259   /* Buffer of -M output.  */
 260   char *deps_buffer;
 261
 262   /* Number of bytes allocated in above.  */
 263   int deps_allocated_size;
 264
 265   /* Number of bytes used.  */
 266   int deps_size;
 267
 268   /* Number of bytes since the last newline.  */
 269   int deps_column;
 270 };
 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 /* 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 #define CPP_BUFFER(PFILE) ((PFILE)->buffer)
 305 #ifdef STATIC_BUFFERS
 306 #define CPP_PREV_BUFFER(BUFFER) ((BUFFER)+1)
 307 #define CPP_NULL_BUFFER(PFILE) (&(PFILE)->buffer_stack[CPP_STACK_MAX])
 308 #else
 309 #define CPP_PREV_BUFFER(BUFFER) ((BUFFER)->chain)
 310 #define CPP_NULL_BUFFER(PFILE) ((cpp_buffer*)0)
 311 #endif
 312
 313 /* Pointed to by parse_file::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 delimeter 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 don't output line number information.  */
 413
 414   char no_line_commands;
 415
 416 /* Nonzero means output the text in failing conditionals,
 417    inside #failed ... #endfailed.  */
 418
 419   char output_conditionals;
 420
 421   /* Nonzero means -I- has been seen,
 422      so don't look for #include "foo" the source-file directory.  */
 423   char ignore_srcdir;
 424
 425 /* Zero means dollar signs are punctuation.
 426    -$ stores 0; -traditional may store 1.  Default is 1 for VMS, 0 otherwise.
 427    This must be 0 for correct processing of this ANSI C program:
 428         #define foo(a) #a
 429         #define lose(b) foo (b)
 430         #define test$
 431         lose (test)     */
 432   char dollars_in_ident;
 433 #ifndef DOLLARS_IN_IDENTIFIERS
 434 #define DOLLARS_IN_IDENTIFIERS 1
 435 #endif
 436
 437   /* Nonzero means try to imitate old fashioned non-ANSI preprocessor.  */
 438   char traditional;
 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   /* Pending -D, -U and -A options, in reverse order. */
 490   struct cpp_pending *pending;
 491
 492   /* File name which deps are being written to.
 493      This is 0 if deps are being written to stdout.  */
 494   char *deps_file;
 495
 496   /* Target-name to write with the dependency information.  */
 497   char *deps_target;
 498 };
 499
 500 #define CPP_TRADITIONAL(PFILE) (CPP_OPTIONS(PFILE)-> traditional)
 501 #define CPP_PEDANTIC(PFILE) (CPP_OPTIONS (PFILE)->pedantic)
 502 #define CPP_PRINT_DEPS(PFILE) (CPP_OPTIONS (PFILE)->print_deps)
 503
 504 /* Name under which this program was invoked.  */
 505
 506 extern char *progname;
 507
 508 /* The structure of a node in the hash table.  The hash table
 509    has entries for all tokens defined by #define commands (type T_MACRO),
 510    plus some special tokens like __LINE__ (these each have their own
 511    type, and the appropriate code is run when that type of node is seen.
 512    It does not contain control words like "#define", which are recognized
 513    by a separate piece of code. */
 514
 515 /* different flavors of hash nodes --- also used in keyword table */
 516 enum node_type {
 517  T_DEFINE = 1,  /* the `#define' keyword */
 518  T_INCLUDE,     /* the `#include' keyword */
 519  T_INCLUDE_NEXT, /* the `#include_next' keyword */
 520  T_IMPORT,      /* the `#import' keyword */
 521  T_IFDEF,       /* the `#ifdef' keyword */
 522  T_IFNDEF,      /* the `#ifndef' keyword */
 523  T_IF,          /* the `#if' keyword */
 524  T_ELSE,        /* `#else' */
 525  T_PRAGMA,      /* `#pragma' */
 526  T_ELIF,        /* `#elif' */
 527  T_UNDEF,       /* `#undef' */
 528  T_LINE,        /* `#line' */
 529  T_ERROR,       /* `#error' */
 530  T_WARNING,     /* `#warning' */
 531  T_ENDIF,       /* `#endif' */
 532  T_SCCS,        /* `#sccs', used on system V.  */
 533  T_IDENT,       /* `#ident', used on system V.  */
 534  T_ASSERT,      /* `#assert', taken from system V.  */
 535  T_UNASSERT,    /* `#unassert', taken from system V.  */
 536  T_SPECLINE,    /* special symbol `__LINE__' */
 537  T_DATE,        /* `__DATE__' */
 538  T_FILE,        /* `__FILE__' */
 539  T_BASE_FILE,   /* `__BASE_FILE__' */
 540  T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
 541  T_VERSION,     /* `__VERSION__' */
 542  T_SIZE_TYPE,   /* `__SIZE_TYPE__' */
 543  T_PTRDIFF_TYPE,   /* `__PTRDIFF_TYPE__' */
 544  T_WCHAR_TYPE,   /* `__WCHAR_TYPE__' */
 545  T_USER_LABEL_PREFIX_TYPE, /* `__USER_LABEL_PREFIX__' */
 546  T_REGISTER_PREFIX_TYPE,   /* `__REGISTER_PREFIX__' */
 547  T_TIME,        /* `__TIME__' */
 548  T_CONST,       /* Constant value, used by `__STDC__' */
 549  T_MACRO,       /* macro defined by `#define' */
 550  T_DISABLED,    /* macro temporarily turned off for rescan */
 551  T_SPEC_DEFINED, /* special `defined' macro for use in #if statements */
 552  T_PCSTRING,    /* precompiled string (hashval is KEYDEF *) */
 553  T_UNUSED       /* Used for something not defined.  */
 554  };
 555
 556 /* Structure returned by create_definition */
 557 typedef struct macrodef MACRODEF;
 558 struct macrodef
 559 {
 560   struct definition *defn;
 561   U_CHAR *symnam;
 562   int symlen;
 563 };
 564
 565 /* Structure allocated for every #define.  For a simple replacement
 566    such as
 567         #define foo bar ,
 568    nargs = -1, the `pattern' list is null, and the expansion is just
 569    the replacement text.  Nargs = 0 means a functionlike macro with no args,
 570    e.g.,
 571        #define getchar() getc (stdin) .
 572    When there are args, the expansion is the replacement text with the
 573    args squashed out, and the reflist is a list describing how to
 574    build the output from the input: e.g., "3 chars, then the 1st arg,
 575    then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
 576    The chars here come from the expansion.  Whatever is left of the
 577    expansion after the last arg-occurrence is copied after that arg.
 578    Note that the reflist can be arbitrarily long---
 579    its length depends on the number of times the arguments appear in
 580    the replacement text, not how many args there are.  Example:
 581    #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
 582    pattern list
 583      { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
 584    where (x, y) means (nchars, argno). */
 585
 586 typedef struct definition DEFINITION;
 587 struct definition {
 588   int nargs;
 589   int length;                   /* length of expansion string */
 590   int predefined;               /* True if the macro was builtin or */
 591                                 /* came from the command line */
 592   U_CHAR *expansion;
 593   int line;                     /* Line number of definition */
 594   char *file;                   /* File of definition */
 595   char rest_args;               /* Nonzero if last arg. absorbs the rest */
 596   struct reflist {
 597     struct reflist *next;
 598     char stringify;             /* nonzero if this arg was preceded by a
 599                                    # operator. */
 600     char raw_before;            /* Nonzero if a ## operator before arg. */
 601     char raw_after;             /* Nonzero if a ## operator after arg. */
 602     char rest_args;             /* Nonzero if this arg. absorbs the rest */
 603     int nchars;                 /* Number of literal chars to copy before
 604                                    this arg occurrence.  */
 605     int argno;                  /* Number of arg to substitute (origin-0) */
 606   } *pattern;
 607   union {
 608     /* Names of macro args, concatenated in reverse order
 609        with comma-space between them.
 610        The only use of this is that we warn on redefinition
 611        if this differs between the old and new definitions.  */
 612     U_CHAR *argnames;
 613   } args;
 614 };
 615
 616 extern U_CHAR is_idchar[256];
 617
 618 /* Stack of conditionals currently in progress
 619    (including both successful and failing conditionals).  */
 620
 621 struct if_stack {
 622   struct if_stack *next;        /* for chaining to the next stack frame */
 623   char *fname;          /* copied from input when frame is made */
 624   int lineno;                   /* similarly */
 625   int if_succeeded;             /* true if a leg of this if-group
 626                                     has been passed through rescan */
 627   U_CHAR *control_macro;        /* For #ifndef at start of file,
 628                                    this is the macro name tested.  */
 629   enum node_type type;          /* type of last directive seen in this group */
 630 };
 631 typedef struct if_stack IF_STACK_FRAME;
 632
 633 extern void cpp_buf_line_and_col PARAMS((cpp_buffer*, long*, long*));
 634 extern cpp_buffer* cpp_file_buffer PARAMS((cpp_reader*));
 635 extern void cpp_define PARAMS ((cpp_reader*, U_CHAR*));
 636
 637 extern void cpp_error ();
 638 extern void cpp_warning ();
 639 extern void cpp_pedwarn ();
 640 extern void cpp_error_with_line ();
 641 extern void cpp_warning_with_line ();
 642 extern void cpp_pedwarn_with_line ();
 643 extern void cpp_pedwarn_with_file_and_line ();
 644 extern void fatal ();
 645 extern void cpp_error_from_errno ();
 646 extern void cpp_perror_with_name ();
 647 extern void cpp_pfatal_with_name ();
 648
 649 extern void cpp_grow_buffer PARAMS ((cpp_reader*, long));
 650 extern int cpp_parse_escape PARAMS ((cpp_reader*, char**));
 651 extern cpp_buffer* cpp_push_buffer PARAMS ((cpp_reader *, U_CHAR*, long));
 652 extern cpp_buffer* cpp_pop_buffer PARAMS ((cpp_reader *));
 653
 654 extern cpp_hashnode* cpp_lookup PARAMS ((cpp_reader*, const U_CHAR*,
 655                                          int, int));
 656
 657 #ifdef __cplusplus
 658 }
 659 #endif