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