gcc/cpplib.h

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