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