gcc/cpplib.h

   1 /* Definitions for CPP library.
   2    Copyright (C) 1995, 96-99, 2000 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
  27 #ifdef __cplusplus
  28 extern "C" {
  29 #endif
  30
  31 typedef unsigned char U_CHAR;
  32
  33 typedef struct cpp_reader cpp_reader;
  34 typedef struct cpp_buffer cpp_buffer;
  35 typedef struct cpp_options cpp_options;
  36
  37 enum cpp_token
  38 {
  39   CPP_EOF = -1,
  40   CPP_OTHER = 0,
  41   CPP_COMMENT = 1,
  42   CPP_HSPACE,
  43   CPP_VSPACE, /* newlines and #line directives */
  44   CPP_NAME,
  45   CPP_NUMBER,
  46   CPP_CHAR,
  47   CPP_WCHAR,
  48   CPP_STRING,
  49   CPP_WSTRING,
  50   CPP_DIRECTIVE,
  51   CPP_ASSERTION,        /* #machine(a29k) */
  52   CPP_STRINGIZE,        /* stringize macro argument */
  53   CPP_TOKPASTE,         /* paste macro arg with next/prev token */
  54   CPP_LPAREN,           /* "(" */
  55   CPP_RPAREN,           /* ")" */
  56   CPP_LBRACE,           /* "{" */
  57   CPP_RBRACE,           /* "}" */
  58   CPP_COMMA,            /* "," */
  59   CPP_SEMICOLON,        /* ";" */
  60   CPP_3DOTS,            /* "..." */
  61   CPP_POP               /* We're about to pop the buffer stack.  */
  62 };
  63
  64 typedef enum cpp_token (*parse_underflow_t) PARAMS((cpp_reader *));
  65 typedef int (*parse_cleanup_t) PARAMS((cpp_buffer *, cpp_reader *));
  66
  67 extern int cpp_handle_option PARAMS ((cpp_reader *, int, char **));
  68 extern int cpp_handle_options PARAMS ((cpp_reader *, int, char **));
  69 extern enum cpp_token cpp_get_token PARAMS ((cpp_reader *));
  70 extern enum cpp_token cpp_get_non_space_token PARAMS ((cpp_reader *));
  71 extern enum cpp_token get_directive_token PARAMS ((cpp_reader *));
  72
  73 /* This frees resources used by PFILE. */
  74 extern void cpp_cleanup PARAMS ((cpp_reader *PFILE));
  75
  76 struct cpp_buffer
  77 {
  78   unsigned char *cur;    /* current position */
  79   unsigned char *rlimit; /* end of valid data */
  80   unsigned char *buf;    /* entire buffer */
  81   unsigned char *alimit; /* end of allocated buffer */
  82   unsigned char *line_base; /* start of current line */
  83
  84   struct cpp_buffer *prev;
  85
  86   /* Real filename.  (Alias to ->ihash->fname, obsolete). */
  87   const char *fname;
  88   /* Filename specified with #line command.  */
  89   const char *nominal_fname;
  90   /* Last filename specified with #line command.  */
  91   const char *last_nominal_fname;
  92   /* Actual directory of this file, used only for "" includes */
  93   struct file_name_list *actual_dir;
  94
  95   /* Pointer into the include hash table.  Used for include_next and
  96      to record control macros. */
  97   struct include_hash *ihash;
  98
  99   long lineno; /* Line number at CPP_LINE_BASE. */
 100   long colno; /* Column number at CPP_LINE_BASE. */
 101   long mark;  /* Saved position for lengthy backtrack. */
 102   parse_underflow_t underflow;
 103   parse_cleanup_t cleanup;
 104   void *data;
 105
 106   /* Value of if_stack at start of this file.
 107      Used to prohibit unmatched #endif (etc) in an include file.  */
 108   struct if_stack *if_stack;
 109
 110   /* True if this is a header file included using <FILENAME>.  */
 111   char system_header_p;
 112   char seen_eof;
 113
 114   /* True if buffer contains escape sequences.
 115      Currently there are two kinds:
 116      "\r-" means following identifier should not be macro-expanded.
 117      "\r " means a token-separator.  This turns into " " in final output
 118           if not stringizing and needed to separate tokens; otherwise nothing.
 119      Any other two-character sequence beginning with \r is an error.
 120
 121      If this is NOT set, then \r is a one-character escape meaning backslash
 122      newline.  This is guaranteed not to occur in the middle of a token.
 123      The two interpretations of \r do not conflict, because the two-character
 124      escapes are used only in macro buffers, and backslash-newline is removed
 125      from macro expansion text in collect_expansion and/or macarg.  */
 126   char has_escapes;
 127
 128   /* Used by the C++ frontend to implement redirected input (such as for
 129      default argument and/or template parsing).  */
 130   char manual_pop;
 131
 132   /* True if we have already warned about C++ comments in this file.
 133      The warning happens only for C89 extended mode with -pedantic on,
 134      and only once per file (otherwise it would be far too noisy).  */
 135   char warned_cplusplus_comments;
 136 };
 137
 138 struct file_name_map_list;
 139
 140 /* Maximum nesting of cpp_buffers.  We use a static limit, partly for
 141    efficiency, and partly to limit runaway recursion.  */
 142 #define CPP_STACK_MAX 200
 143
 144 /* A cpp_reader encapsulates the "state" of a pre-processor run.
 145    Applying cpp_get_token repeatedly yields a stream of pre-processor
 146    tokens.  Usually, there is only one cpp_reader object active. */
 147
 148 struct cpp_reader
 149 {
 150   parse_underflow_t get_token;
 151   cpp_buffer *buffer;
 152   cpp_options *opts;
 153
 154   /* A buffer used for both for cpp_get_token's output, and also internally. */
 155   unsigned char *token_buffer;
 156   /* Allocated size of token_buffer.  CPP_RESERVE allocates space.  */
 157   unsigned int token_buffer_size;
 158   /* End of the written part of token_buffer. */
 159   unsigned char *limit;
 160
 161   /* Error counter for exit code */
 162   int errors;
 163
 164   /* Line where a newline was first seen in a string constant.  */
 165   int multiline_string_line;
 166
 167   /* Current depth in #include directives that use <...>.  */
 168   int system_include_depth;
 169
 170   /* Current depth of buffer stack. */
 171   int buffer_stack_depth;
 172
 173   /* Hash table of macros and assertions.  See cpphash.c */
 174 #define HASHSIZE 1403
 175   struct hashnode **hashtab;
 176
 177   /* Hash table of other included files.  See cppfiles.c */
 178 #define ALL_INCLUDE_HASHSIZE 71
 179   struct include_hash *all_include_files[ALL_INCLUDE_HASHSIZE];
 180
 181   /* Chain of `actual directory' file_name_list entries,
 182      for "" inclusion. */
 183   struct file_name_list *actual_dirs;
 184
 185   /* Current maximum length of directory names in the search path
 186      for include files.  (Altered as we get more of them.)  */
 187   unsigned int max_include_len;
 188
 189   struct if_stack *if_stack;
 190
 191   /* Nonzero means we have printed (while error reporting) a list of
 192      containing files that matches the current status.  */
 193   char input_stack_listing_current;
 194
 195   /* If non-zero, macros are not expanded.  */
 196   char no_macro_expand;
 197
 198   /* If non-zero, directives cause a hard error.  Used when parsing
 199      macro arguments.  */
 200   char no_directives;
 201
 202   /* Print column number in error messages.  */
 203   char show_column;
 204
 205   /* We're printed a warning recommending against using #import.  */
 206   char import_warning;
 207
 208   /* If true, character between '<' and '>' are a single (string) token.  */
 209   char parsing_include_directive;
 210
 211   /* If true, # introduces an assertion (see do_assert) */
 212   char parsing_if_directive;
 213
 214   /* If true, # and ## are the STRINGIZE and TOKPASTE operators */
 215   char parsing_define_directive;
 216
 217   /* True if escape sequences (as described for has_escapes in
 218      parse_buffer) should be emitted.  */
 219   char output_escapes;
 220
 221   /* 0: Have seen non-white-space on this line.
 222      1: Only seen white space so far on this line.
 223      2: Only seen white space so far in this file.  */
 224   char only_seen_white;
 225
 226   long lineno;
 227
 228   struct tm *timebuf;
 229
 230   /* Buffer of -M output.  */
 231   char *deps_buffer;
 232
 233   /* Number of bytes allocated in above.  */
 234   int deps_allocated_size;
 235
 236   /* Number of bytes used.  */
 237   int deps_size;
 238
 239   /* Number of bytes since the last newline.  */
 240   int deps_column;
 241
 242   /* A buffer and a table, used only by read_and_prescan (in cppfiles.c)
 243      which are allocated once per cpp_reader object to keep them off the
 244      stack and avoid setup costs.  */
 245   U_CHAR *input_buffer;
 246   U_CHAR *input_speccase;
 247   size_t input_buffer_len;
 248 };
 249
 250 #define CPP_FATAL_LIMIT 1000
 251 /* True if we have seen a "fatal" error. */
 252 #define CPP_FATAL_ERRORS(READER) ((READER)->errors >= CPP_FATAL_LIMIT)
 253
 254 #define CPP_BUF_PEEK(BUFFER) \
 255   ((BUFFER)->cur < (BUFFER)->rlimit ? *(BUFFER)->cur : EOF)
 256 #define CPP_BUF_GET(BUFFER) \
 257   ((BUFFER)->cur < (BUFFER)->rlimit ? *(BUFFER)->cur++ : EOF)
 258 #define CPP_FORWARD(BUFFER, N) ((BUFFER)->cur += (N))
 259
 260 /* Macros for manipulating the token_buffer. */
 261
 262 #define CPP_OUT_BUFFER(PFILE) ((PFILE)->token_buffer)
 263
 264 /* Number of characters currently in PFILE's output buffer. */
 265 #define CPP_WRITTEN(PFILE) ((size_t)((PFILE)->limit - (PFILE)->token_buffer))
 266 #define CPP_PWRITTEN(PFILE) ((PFILE)->limit)
 267
 268 /* Make sure PFILE->token_buffer has space for at least N more characters. */
 269 #define CPP_RESERVE(PFILE, N) \
 270   (CPP_WRITTEN (PFILE) + (size_t)(N) > (PFILE)->token_buffer_size \
 271    && (cpp_grow_buffer (PFILE, N), 0))
 272
 273 /* Append string STR (of length N) to PFILE's output buffer.
 274    Assume there is enough space. */
 275 #define CPP_PUTS_Q(PFILE, STR, N) \
 276   (memcpy ((PFILE)->limit, STR, (N)), (PFILE)->limit += (N))
 277 /* Append string STR (of length N) to PFILE's output buffer.  Make space. */
 278 #define CPP_PUTS(PFILE, STR, N) CPP_RESERVE(PFILE, N), CPP_PUTS_Q(PFILE, STR,N)
 279 /* Append character CH to PFILE's output buffer.  Assume sufficient space. */
 280 #define CPP_PUTC_Q(PFILE, CH) (*(PFILE)->limit++ = (CH))
 281 /* Append character CH to PFILE's output buffer.  Make space if need be. */
 282 #define CPP_PUTC(PFILE, CH) (CPP_RESERVE (PFILE, 1), CPP_PUTC_Q (PFILE, CH))
 283 /* Make sure PFILE->limit is followed by '\0'. */
 284 #define CPP_NUL_TERMINATE_Q(PFILE) (*(PFILE)->limit = 0)
 285 #define CPP_NUL_TERMINATE(PFILE) (CPP_RESERVE(PFILE, 1), *(PFILE)->limit = 0)
 286 #define CPP_ADJUST_WRITTEN(PFILE,DELTA) ((PFILE)->limit += (DELTA))
 287 #define CPP_SET_WRITTEN(PFILE,N) ((PFILE)->limit = (PFILE)->token_buffer + (N))
 288
 289 /* Advance the current line by one. */
 290 #define CPP_BUMP_BUFFER_LINE(PBUF) ((PBUF)->lineno++,\
 291                                     (PBUF)->line_base = (PBUF)->cur)
 292 #define CPP_BUMP_LINE(PFILE) CPP_BUMP_BUFFER_LINE(CPP_BUFFER(PFILE))
 293
 294 #define CPP_OPTIONS(PFILE) ((PFILE)->opts)
 295 #define CPP_BUFFER(PFILE) ((PFILE)->buffer)
 296 #define CPP_PREV_BUFFER(BUFFER) ((BUFFER)->prev)
 297 /* The bottom of the buffer stack. */
 298 #define CPP_NULL_BUFFER(PFILE) NULL
 299
 300 /* The `pending' structure accumulates all the options that are not
 301    actually processed until we hit cpp_start_read.  It consists of
 302    several lists, one for each type of option.  We keep both head and
 303    tail pointers for quick insertion. */
 304 struct cpp_pending
 305 {
 306   struct pending_option *define_head, *define_tail;
 307   struct pending_option *assert_head, *assert_tail;
 308
 309   struct file_name_list *quote_head, *quote_tail;
 310   struct file_name_list *brack_head, *brack_tail;
 311   struct file_name_list *systm_head, *systm_tail;
 312   struct file_name_list *after_head, *after_tail;
 313
 314   struct pending_option *imacros_head, *imacros_tail;
 315   struct pending_option *include_head, *include_tail;
 316 };
 317
 318 /* Pointed to by cpp_reader.opts. */
 319 struct cpp_options {
 320   char *in_fname;
 321
 322   /* Name of output file, for error messages.  */
 323   const char *out_fname;
 324
 325   struct file_name_map_list *map_list;
 326
 327   /* Non-0 means -v, so print the full set of include dirs.  */
 328   char verbose;
 329
 330   /* Nonzero means use extra default include directories for C++.  */
 331
 332   char cplusplus;
 333
 334   /* Nonzero means handle cplusplus style comments */
 335
 336   char cplusplus_comments;
 337
 338   /* Nonzero means handle #import, for objective C.  */
 339
 340   char objc;
 341
 342   /* Nonzero means this is an assembly file, so ignore unrecognized
 343      directives and the "# 33" form of #line, both of which are
 344      probably comments.  Also, permit unbalanced ' strings (again,
 345      likely to be in comments).  */
 346
 347   char lang_asm;
 348
 349   /* Nonzero means this is Fortran, and we don't know where the
 350      comments are, so permit unbalanced ' strings.  Unlike lang_asm,
 351      this does not ignore unrecognized directives.  */
 352
 353   char lang_fortran;
 354
 355   /* Nonzero means handle CHILL comment syntax
 356      and output CHILL string delimiter for __DATE___ etc. */
 357
 358   char chill;
 359
 360   /* Nonzero means don't copy comments into the output file.  */
 361
 362   char discard_comments;
 363
 364   /* Nonzero means process the ANSI trigraph sequences.  */
 365
 366   char trigraphs;
 367
 368   /* Nonzero means print the names of included files rather than
 369      the preprocessed output.  1 means just the #include "...",
 370      2 means #include <...> as well.  */
 371
 372   char print_deps;
 373
 374   /* Nonzero if missing .h files in -M output are assumed to be generated
 375      files and not errors.  */
 376
 377   char print_deps_missing_files;
 378
 379   /* If true, fopen (deps_file, "a") else fopen (deps_file, "w"). */
 380   char print_deps_append;
 381
 382   /* Nonzero means print names of header files (-H).  */
 383
 384   char print_include_names;
 385
 386   /* Nonzero means try to make failure to fit ANSI C an error.  */
 387
 388   char pedantic_errors;
 389
 390   /* Nonzero means don't print warning messages.  */
 391
 392   char inhibit_warnings;
 393
 394   /* Nonzero means don't print error messages.  Has no option to select it,
 395      but can be set by a user of cpplib (e.g. fix-header).  */
 396
 397   char inhibit_errors;
 398
 399   /* Nonzero means warn if slash-star appears in a comment.  */
 400
 401   char warn_comments;
 402
 403   /* Nonzero means warn if there are any trigraphs.  */
 404
 405   char warn_trigraphs;
 406
 407   /* Nonzero means warn if #import is used.  */
 408
 409   char warn_import;
 410
 411   /* Nonzero means warn if a macro argument is (or would be)
 412      stringified with -traditional.  */
 413
 414   char warn_stringify;
 415
 416   /* Nonzero means turn warnings into errors.  */
 417
 418   char warnings_are_errors;
 419
 420   /* Nonzero causes output not to be done,
 421      but directives such as #define that have side effects
 422      are still obeyed.  */
 423
 424   char no_output;
 425
 426   /* Nonzero means we should look for header.gcc files that remap file
 427      names.  */
 428   char remap;
 429
 430   /* Nonzero means don't output line number information.  */
 431   char no_line_commands;
 432
 433   /* Nonzero means -I- has been seen,
 434      so don't look for #include "foo" the source-file directory.  */
 435   char ignore_srcdir;
 436
 437   /* Zero means dollar signs are punctuation.
 438      This used to be needed for conformance to the C Standard,
 439      before the C Standard was corrected.  */
 440   char dollars_in_ident;
 441
 442   /* Nonzero means try to imitate old fashioned non-ANSI preprocessor.  */
 443   char traditional;
 444
 445   /* Nonzero means warn if undefined identifiers are evaluated in an #if.  */
 446   char warn_undef;
 447
 448   /* Nonzero for the 1989 C Standard, including corrigenda and amendments.  */
 449   char c89;
 450
 451   /* Nonzero for the 1999 C Standard, including corrigenda and amendments.  */
 452   char c99;
 453
 454   /* Nonzero means give all the error messages the ANSI standard requires.  */
 455   char pedantic;
 456
 457   /* Nonzero means we're looking at already preprocessed code, so don't
 458      bother trying to do macro expansion and whatnot.  */
 459   char preprocessed;
 460
 461   char done_initializing;
 462
 463   /* Search paths for include files.  */
 464   struct file_name_list *quote_include;  /* First dir to search for "file" */
 465   struct file_name_list *bracket_include;/* First dir to search for <file> */
 466
 467   /* Directory prefix that should replace `/usr/lib/gcc-lib/TARGET/VERSION'
 468      in the standard include file directories.  */
 469   char *include_prefix;
 470   int include_prefix_len;
 471
 472   char no_standard_includes;
 473   char no_standard_cplusplus_includes;
 474
 475 /* dump_only means inhibit output of the preprocessed text
 476              and instead output the definitions of all user-defined
 477              macros in a form suitable for use as input to cccp.
 478    dump_names means pass #define and the macro name through to output.
 479    dump_definitions means pass the whole definition (plus #define) through
 480 */
 481
 482   enum {dump_none = 0, dump_only, dump_names, dump_definitions}
 483      dump_macros;
 484
 485 /* Nonzero means pass all #define and #undef directives which we actually
 486    process through to the output stream.  This feature is used primarily
 487    to allow cc1 to record the #defines and #undefs for the sake of
 488    debuggers which understand about preprocessor macros, but it may
 489    also be useful with -E to figure out how symbols are defined, and
 490    where they are defined.  */
 491   int debug_output;
 492
 493   /* Nonzero means pass #include lines through to the output,
 494      even if they are ifdefed out.  */
 495   int dump_includes;
 496
 497   /* Pending options - -D, -U, -A, -I, -ixxx. */
 498   struct cpp_pending *pending;
 499
 500   /* File name which deps are being written to.
 501      This is 0 if deps are being written to stdout.  */
 502   char *deps_file;
 503
 504   /* Target-name to write with the dependency information.  */
 505   char *deps_target;
 506 };
 507
 508 #define CPP_TRADITIONAL(PFILE) (CPP_OPTIONS(PFILE)-> traditional)
 509 #define CPP_WARN_UNDEF(PFILE) (CPP_OPTIONS(PFILE)->warn_undef)
 510 #define CPP_C89(PFILE) (CPP_OPTIONS(PFILE)->c89)
 511 #define CPP_PREPROCESSED(PFILE) (CPP_OPTIONS (PFILE)->preprocessed)
 512 #define CPP_PRINT_DEPS(PFILE) (CPP_OPTIONS (PFILE)->print_deps)
 513
 514 #define CPP_PEDANTIC(PFILE) \
 515   (CPP_OPTIONS (PFILE)->pedantic && !CPP_BUFFER (pfile)->system_header_p)
 516
 517 /* List of directories to look for include files in. */
 518 struct file_name_list
 519 {
 520   struct file_name_list *next;
 521   struct file_name_list *alloc; /* for the cache of
 522                                    current directory entries */
 523   char *name;
 524   unsigned int nlen;
 525   /* We use these to tell if the directory mentioned here is a duplicate
 526      of an earlier directory on the search path. */
 527   ino_t ino;
 528   dev_t dev;
 529   /* If the following is nonzero, it is a C-language system include
 530      directory.  */
 531   int sysp;
 532   /* Mapping of file names for this directory.
 533      Only used on MS-DOS and related platforms. */
 534   struct file_name_map *name_map;
 535 };
 536 #define ABSOLUTE_PATH ((struct file_name_list *)-1)
 537
 538 /* This structure is used for the table of all includes.  It is
 539    indexed by the `short name' (the name as it appeared in the
 540    #include statement) which is stored in *nshort.  */
 541 struct include_hash
 542 {
 543   struct include_hash *next;
 544   /* Next file with the same short name but a
 545      different (partial) pathname). */
 546   struct include_hash *next_this_file;
 547
 548   /* Location of the file in the include search path.
 549      Used for include_next */
 550   struct file_name_list *foundhere;
 551   const char *name;             /* (partial) pathname of file */
 552   const char *nshort;           /* name of file as referenced in #include */
 553   const char *control_macro;    /* macro, if any, preventing reinclusion -
 554                                    see redundant_include_p */
 555   char *buf, *limit;            /* for file content cache,
 556                                    not yet implemented */
 557 };
 558
 559 /* Name under which this program was invoked.  */
 560
 561 extern const char *progname;
 562
 563 /* The structure of a node in the hash table.  The hash table
 564    has entries for all tokens defined by #define commands (type T_MACRO),
 565    plus some special tokens like __LINE__ (these each have their own
 566    type, and the appropriate code is run when that type of node is seen.
 567    It does not contain control words like "#define", which are recognized
 568    by a separate piece of code. */
 569
 570 /* different flavors of hash nodes --- also used in keyword table */
 571 enum node_type {
 572  T_DEFINE = 1,  /* the `#define' keyword */
 573  T_INCLUDE,     /* the `#include' keyword */
 574  T_INCLUDE_NEXT, /* the `#include_next' keyword */
 575  T_IMPORT,      /* the `#import' keyword */
 576  T_IFDEF,       /* the `#ifdef' keyword */
 577  T_IFNDEF,      /* the `#ifndef' keyword */
 578  T_IF,          /* the `#if' keyword */
 579  T_ELSE,        /* `#else' */
 580  T_PRAGMA,      /* `#pragma' */
 581  T_ELIF,        /* `#elif' */
 582  T_UNDEF,       /* `#undef' */
 583  T_LINE,        /* `#line' */
 584  T_ERROR,       /* `#error' */
 585  T_WARNING,     /* `#warning' */
 586  T_ENDIF,       /* `#endif' */
 587  T_SCCS,        /* `#sccs', used on system V.  */
 588  T_IDENT,       /* `#ident', used on system V.  */
 589  T_ASSERT,      /* `#assert', taken from system V.  */
 590  T_UNASSERT,    /* `#unassert', taken from system V.  */
 591  T_SPECLINE,    /* special symbol `__LINE__' */
 592  T_DATE,        /* `__DATE__' */
 593  T_FILE,        /* `__FILE__' */
 594  T_BASE_FILE,   /* `__BASE_FILE__' */
 595  T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
 596  T_VERSION,     /* `__VERSION__' */
 597  T_TIME,        /* `__TIME__' */
 598  T_STDC,        /* `__STDC__' */
 599  T_CONST,       /* Constant string, used by `__SIZE_TYPE__' etc */
 600  T_MACRO,       /* macro defined by `#define' */
 601  T_DISABLED,    /* macro temporarily turned off for rescan */
 602  T_POISON,      /* defined with `#pragma poison' */
 603  T_UNUSED       /* Used for something not defined.  */
 604  };
 605
 606 /* Character classes.
 607    If the definition of `numchar' looks odd to you, please look up the
 608    definition of a pp-number in the C standard [section 6.4.8 of C99] */
 609 #define ISidnum         0x01    /* a-zA-Z0-9_ */
 610 #define ISidstart       0x02    /* _a-zA-Z */
 611 #define ISnumstart      0x04    /* 0-9 */
 612 #define IShspace        0x08    /* ' ' \t \f \v */
 613 #define ISspace         0x10    /* ' ' \t \f \v \n */
 614
 615 #define is_idchar(x)    (IStable[x] & ISidnum)
 616 #define is_numchar(x)   (IStable[x] & ISidnum)
 617 #define is_idstart(x)   (IStable[x] & ISidstart)
 618 #define is_numstart(x)  (IStable[x] & ISnumstart)
 619 #define is_hspace(x)    (IStable[x] & IShspace)
 620 #define is_space(x)     (IStable[x] & ISspace)
 621
 622 /* This table is not really `const', but it is only modified at
 623    initialization time, in a separate translation unit from the rest
 624    of the library.  We let the rest of the library think it is `const'
 625    to get better code and some additional compile-time checks.  */
 626 #ifndef FAKE_CONST
 627 #define FAKE_CONST const
 628 #endif
 629 extern FAKE_CONST unsigned char IStable[256];
 630 #undef FAKE_CONST
 631
 632 /* Stack of conditionals currently in progress
 633    (including both successful and failing conditionals).  */
 634
 635 struct if_stack {
 636   struct if_stack *next;        /* for chaining to the next stack frame */
 637   const char *fname;            /* copied from input when frame is made */
 638   int lineno;                   /* similarly */
 639   int if_succeeded;             /* true if a leg of this if-group
 640                                     has been passed through rescan */
 641   unsigned char *control_macro; /* For #ifndef at start of file,
 642                                    this is the macro name tested.  */
 643   enum node_type type;          /* type of last directive seen in this group */
 644 };
 645 typedef struct if_stack IF_STACK_FRAME;
 646
 647 extern void cpp_buf_line_and_col PARAMS((cpp_buffer *, long *, long *));
 648 extern cpp_buffer* cpp_file_buffer PARAMS((cpp_reader *));
 649 extern void cpp_define PARAMS ((cpp_reader *, unsigned char *));
 650 extern void cpp_assert PARAMS ((cpp_reader *, unsigned char *));
 651 extern void cpp_undef  PARAMS ((cpp_reader *, unsigned char *));
 652 extern void cpp_unassert PARAMS ((cpp_reader *, unsigned char *));
 653
 654 /* N.B. The error-message-printer prototypes have not been nicely
 655    formatted because exgettext needs to see 'msgid' on the same line
 656    as the name of the function in order to work properly.  Only the
 657    string argument gets a name in an effort to keep the lines from
 658    getting ridiculously oversized.  */
 659
 660 extern void cpp_ice PARAMS ((cpp_reader *, const char *msgid, ...))
 661   ATTRIBUTE_PRINTF_2;
 662 extern void cpp_fatal PARAMS ((cpp_reader *, const char *msgid, ...))
 663   ATTRIBUTE_PRINTF_2;
 664 extern void cpp_error PARAMS ((cpp_reader *, const char *msgid, ...))
 665   ATTRIBUTE_PRINTF_2;
 666 extern void cpp_warning PARAMS ((cpp_reader *, const char *msgid, ...))
 667   ATTRIBUTE_PRINTF_2;
 668 extern void cpp_pedwarn PARAMS ((cpp_reader *, const char *msgid, ...))
 669   ATTRIBUTE_PRINTF_2;
 670 extern void cpp_notice PARAMS ((cpp_reader *, const char *msgid, ...))
 671   ATTRIBUTE_PRINTF_2;
 672 extern void cpp_error_with_line PARAMS ((cpp_reader *, int, int, const char *msgid, ...))
 673   ATTRIBUTE_PRINTF_4;
 674 extern void cpp_warning_with_line PARAMS ((cpp_reader *, int, int, const char *msgid, ...))
 675   ATTRIBUTE_PRINTF_4;
 676 extern void cpp_pedwarn_with_line PARAMS ((cpp_reader *, int, int, const char *msgid, ...))
 677   ATTRIBUTE_PRINTF_4;
 678 extern void cpp_pedwarn_with_file_and_line PARAMS ((cpp_reader *, const char *, int, int, const char *msgid, ...))
 679   ATTRIBUTE_PRINTF_5;
 680 extern void cpp_error_from_errno PARAMS ((cpp_reader *, const char *));
 681 extern void cpp_notice_from_errno PARAMS ((cpp_reader *, const char *));
 682
 683 extern void cpp_grow_buffer PARAMS ((cpp_reader *, long));
 684 extern cpp_buffer *cpp_push_buffer PARAMS ((cpp_reader *,
 685                                             unsigned char *, long));
 686 extern cpp_buffer *cpp_pop_buffer PARAMS ((cpp_reader *));
 687 extern int cpp_defined PARAMS ((cpp_reader *, const U_CHAR *, int));
 688
 689 extern void cpp_reader_init PARAMS ((cpp_reader *));
 690 extern void cpp_options_init PARAMS ((cpp_options *));
 691 extern int cpp_start_read PARAMS ((cpp_reader *, char *));
 692 extern void cpp_finish PARAMS ((cpp_reader *));
 693
 694 extern void quote_string                PARAMS ((cpp_reader *, const char *));
 695 extern void cpp_expand_to_buffer        PARAMS ((cpp_reader *, const U_CHAR *,
 696                                                  int));
 697 extern void cpp_scan_buffer             PARAMS ((cpp_reader *));
 698
 699 /* Last arg to output_line_command.  */
 700 enum file_change_code {same_file, rename_file, enter_file, leave_file};
 701 extern void output_line_command         PARAMS ((cpp_reader *,
 702                                                  enum file_change_code));
 703
 704 /* In cppfiles.c */
 705 extern void simplify_pathname           PARAMS ((char *));
 706 extern void merge_include_chains        PARAMS ((struct cpp_options *));
 707 extern int find_include_file            PARAMS ((cpp_reader *, const char *,
 708                                                 struct file_name_list *,
 709                                                 struct include_hash **,
 710                                                 int *));
 711 extern int finclude                     PARAMS ((cpp_reader *, int,
 712                                                 struct include_hash *));
 713 extern int cpp_read_file                PARAMS ((cpp_reader *, const char *));
 714 extern void deps_output                 PARAMS ((cpp_reader *,
 715                                                 const char *, int));
 716 extern struct include_hash *include_hash PARAMS ((cpp_reader *, const char *, int));
 717
 718 #ifdef __cplusplus
 719 }
 720 #endif
 721 #endif /* __GCC_CPPLIB__ */