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