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 /* For complex reasons, cpp_reader is also typedefed in c-pragma.h.  */
  32 #ifndef _C_PRAGMA_H
  33 typedef struct cpp_reader cpp_reader;
  34 #endif
  35 typedef struct cpp_buffer cpp_buffer;
  36 typedef struct cpp_options cpp_options;
  37 typedef struct cpp_printer cpp_printer;
  38 typedef struct cpp_token cpp_token;
  39 typedef struct cpp_toklist cpp_toklist;
  40 typedef struct cpp_string cpp_string;
  41 typedef struct cpp_hashnode cpp_hashnode;
  42
  43 /* The first two groups, apart from '=', can appear in preprocessor
  44    expressions.  This allows a lookup table to be implemented in
  45    _cpp_parse_expr.
  46
  47    The first group, to CPP_LAST_EQ, can be immediately followed by an
  48    '='.  The lexer needs operators ending in '=', like ">>=", to be in
  49    the same order as their counterparts without the '=', like ">>".  */
  50
  51 /* Positions in the table.  */
  52 #define CPP_LAST_EQ CPP_MAX
  53 #define CPP_FIRST_DIGRAPH CPP_HASH
  54 #define CPP_LAST_PUNCTUATOR CPP_DOT_STAR
  55
  56 #define TTYPE_TABLE                             \
  57   OP(CPP_EQ = 0,        "=")                    \
  58   OP(CPP_NOT,           "!")                    \
  59   OP(CPP_GREATER,       ">")    /* compare */   \
  60   OP(CPP_LESS,          "<")                    \
  61   OP(CPP_PLUS,          "+")    /* math */      \
  62   OP(CPP_MINUS,         "-")                    \
  63   OP(CPP_MULT,          "*")                    \
  64   OP(CPP_DIV,           "/")                    \
  65   OP(CPP_MOD,           "%")                    \
  66   OP(CPP_AND,           "&")    /* bit ops */   \
  67   OP(CPP_OR,            "|")                    \
  68   OP(CPP_XOR,           "^")                    \
  69   OP(CPP_RSHIFT,        ">>")                   \
  70   OP(CPP_LSHIFT,        "<<")                   \
  71   OP(CPP_MIN,           "<?")   /* extension */ \
  72   OP(CPP_MAX,           ">?")                   \
  73 \
  74   OP(CPP_COMPL,         "~")                    \
  75   OP(CPP_AND_AND,       "&&")   /* logical */   \
  76   OP(CPP_OR_OR,         "||")                   \
  77   OP(CPP_QUERY,         "?")                    \
  78   OP(CPP_COLON,         ":")                    \
  79   OP(CPP_COMMA,         ",")    /* grouping */  \
  80   OP(CPP_OPEN_PAREN,    "(")                    \
  81   OP(CPP_CLOSE_PAREN,   ")")                    \
  82   OP(CPP_EQ_EQ,         "==")   /* compare */   \
  83   OP(CPP_NOT_EQ,        "!=")                   \
  84   OP(CPP_GREATER_EQ,    ">=")                   \
  85   OP(CPP_LESS_EQ,       "<=")                   \
  86 \
  87   OP(CPP_PLUS_EQ,       "+=")   /* math */      \
  88   OP(CPP_MINUS_EQ,      "-=")                   \
  89   OP(CPP_MULT_EQ,       "*=")                   \
  90   OP(CPP_DIV_EQ,        "/=")                   \
  91   OP(CPP_MOD_EQ,        "%=")                   \
  92   OP(CPP_AND_EQ,        "&=")   /* bit ops */   \
  93   OP(CPP_OR_EQ,         "|=")                   \
  94   OP(CPP_XOR_EQ,        "^=")                   \
  95   OP(CPP_RSHIFT_EQ,     ">>=")                  \
  96   OP(CPP_LSHIFT_EQ,     "<<=")                  \
  97   OP(CPP_MIN_EQ,        "<?=")  /* extension */ \
  98   OP(CPP_MAX_EQ,        ">?=")                  \
  99   /* Digraphs together, beginning with CPP_FIRST_DIGRAPH.  */   \
 100   OP(CPP_HASH,          "#")    /* digraphs */  \
 101   OP(CPP_PASTE,         "##")                   \
 102   OP(CPP_OPEN_SQUARE,   "[")                    \
 103   OP(CPP_CLOSE_SQUARE,  "]")                    \
 104   OP(CPP_OPEN_BRACE,    "{")                    \
 105   OP(CPP_CLOSE_BRACE,   "}")                    \
 106   /* The remainder of the punctuation.  Order is not significant.  */   \
 107   OP(CPP_SEMICOLON,     ";")    /* structure */ \
 108   OP(CPP_ELLIPSIS,      "...")                  \
 109   OP(CPP_BACKSLASH,     "\\")                   \
 110   OP(CPP_PLUS_PLUS,     "++")   /* increment */ \
 111   OP(CPP_MINUS_MINUS,   "--")                   \
 112   OP(CPP_DEREF,         "->")   /* accessors */ \
 113   OP(CPP_DOT,           ".")                    \
 114   OP(CPP_SCOPE,         "::")                   \
 115   OP(CPP_DEREF_STAR,    "->*")                  \
 116   OP(CPP_DOT_STAR,      ".*")                   \
 117   OP(CPP_DEFINED,       "defined") /* #if */    \
 118 \
 119   TK(CPP_NAME,          SPELL_IDENT)    /* word */                      \
 120   TK(CPP_INT,           SPELL_STRING)   /* 23 */                        \
 121   TK(CPP_FLOAT,         SPELL_STRING)   /* 3.14159 */                   \
 122   TK(CPP_NUMBER,        SPELL_STRING)   /* 34_be+ta  */                 \
 123 \
 124   TK(CPP_CHAR,          SPELL_STRING)   /* 'char' */                    \
 125   TK(CPP_WCHAR,         SPELL_STRING)   /* L'char' */                   \
 126   TK(CPP_OTHER,         SPELL_CHAR)     /* stray punctuation */         \
 127 \
 128   TK(CPP_STRING,        SPELL_STRING)   /* "string" */                  \
 129   TK(CPP_WSTRING,       SPELL_STRING)   /* L"string" */                 \
 130   TK(CPP_OSTRING,       SPELL_STRING)   /* @"string" - Objective C */   \
 131   TK(CPP_HEADER_NAME,   SPELL_STRING)   /* <stdio.h> in #include */     \
 132 \
 133   TK(CPP_COMMENT,       SPELL_STRING)   /* Only if output comments.  */ \
 134   TK(CPP_MACRO_ARG,     SPELL_NONE)     /* Macro argument.  */          \
 135   TK(CPP_PLACEMARKER,   SPELL_NONE)     /* Placemarker token.  */       \
 136   TK(CPP_EOF,           SPELL_NONE)     /* End of file.  */
 137
 138 #define OP(e, s) e,
 139 #define TK(e, s) e,
 140 enum cpp_ttype
 141 {
 142   TTYPE_TABLE
 143   N_TTYPES
 144 };
 145 #undef OP
 146 #undef TK
 147
 148 /* Payload of a NUMBER, FLOAT, STRING, or COMMENT token.  */
 149 struct cpp_string
 150 {
 151   unsigned int len;
 152   const unsigned char *text;
 153 };
 154
 155 /* Flags for the cpp_token structure.  */
 156 #define PREV_WHITE      (1 << 0) /* If whitespace before this token.  */
 157 #define BOL             (1 << 1) /* Beginning of logical line.  */
 158 #define DIGRAPH         (1 << 2) /* If it was a digraph.  */
 159 #define STRINGIFY_ARG   (1 << 3) /* If macro argument to be stringified.  */
 160 #define PASTE_LEFT      (1 << 4) /* If on LHS of a ## operator.  */
 161 #define PASTED          (1 << 5) /* The result of a ## operator.  */
 162 #define NAMED_OP        (1 << 6) /* C++ named operators, also "defined".  */
 163 #define VOID_REST       (1 << 7) /* When a rest arg gets zero actual args.  */
 164
 165 /* A preprocessing token.  This has been carefully packed and should
 166    occupy 16 bytes on 32-bit hosts and 24 bytes on 64-bit hosts.  */
 167 struct cpp_token
 168 {
 169   unsigned int line;            /* starting line number of this token */
 170   unsigned short col;           /* starting column of this token */
 171   ENUM_BITFIELD(cpp_ttype) type : CHAR_BIT;  /* token type */
 172   unsigned char flags;          /* flags - see above */
 173
 174   union
 175   {
 176     HOST_WIDEST_INT integer;    /* an integer */
 177     struct cpp_hashnode *node;  /* an identifier */
 178     struct cpp_string str;      /* a string, or number */
 179     unsigned int aux;           /* argument no. for a CPP_MACRO_ARG, or
 180                                    character represented by CPP_OTHER.  */
 181   } val;
 182 };
 183
 184 /* cpp_toklist flags.  */
 185 #define VAR_ARGS        (1 << 0)
 186 #define BEG_OF_FILE     (1 << 1)
 187
 188 struct directive;               /* These are deliberately incomplete.  */
 189 struct answer;
 190 struct macro_args;
 191 struct cpp_context;
 192
 193 struct cpp_toklist
 194 {
 195   cpp_token *tokens;            /* actual tokens as an array */
 196   unsigned int tokens_used;     /* tokens used */
 197   unsigned int tokens_cap;      /* tokens allocated */
 198
 199   unsigned char *namebuf;       /* names buffer */
 200   unsigned int name_used;       /* _bytes_ used */
 201   unsigned int name_cap;        /* _bytes_ allocated */
 202
 203   /* If the list represents a directive, this points to it.  */
 204   const struct directive *directive;
 205
 206   const char *file;             /* in file name */
 207   unsigned int line;            /* starting line number */
 208
 209   unsigned short params_len;    /* length of macro parameter names.  */
 210
 211   short int paramc;             /* no. of macro params (-1 = obj-like).  */
 212
 213   /* Per-list flags, see above */
 214   unsigned short flags;
 215 };
 216
 217 /* A standalone character.  We may want to make it unsigned for the
 218    same reason we use unsigned char - to avoid signedness issues.  */
 219 typedef int cppchar_t;
 220
 221 struct cpp_buffer
 222 {
 223   const unsigned char *cur;      /* current position */
 224   const unsigned char *rlimit; /* end of valid data */
 225   const unsigned char *line_base; /* start of current line */
 226   cppchar_t read_ahead;         /* read ahead character */
 227   cppchar_t extra_char;         /* extra read-ahead for long tokens.  */
 228
 229   struct cpp_reader *pfile;     /* Owns this buffer.  */
 230   struct cpp_buffer *prev;
 231
 232   const unsigned char *buf;      /* entire buffer */
 233
 234   /* Filename specified with #line command.  */
 235   const char *nominal_fname;
 236
 237   /* Actual directory of this file, used only for "" includes */
 238   struct file_name_list *actual_dir;
 239
 240   /* Pointer into the include table.  Used for include_next and
 241      to record control macros. */
 242   struct include_file *inc;
 243
 244   /* Value of if_stack at start of this file.
 245      Used to prohibit unmatched #endif (etc) in an include file.  */
 246   struct if_stack *if_stack;
 247
 248   /* Token column position adjustment owing to tabs in whitespace.  */
 249   unsigned int col_adjust;
 250
 251   /* Line number at line_base (above). */
 252   unsigned int lineno;
 253
 254   /* True if we have already warned about C++ comments in this file.
 255      The warning happens only for C89 extended mode with -pedantic on,
 256      or for -Wtraditional, and only once per file (otherwise it would
 257      be far too noisy).  */
 258   char warned_cplusplus_comments;
 259 };
 260
 261 struct file_name_map_list;
 262 struct htab;
 263
 264 /* Maximum nesting of cpp_buffers.  We use a static limit, partly for
 265    efficiency, and partly to limit runaway recursion.  */
 266 #define CPP_STACK_MAX 200
 267
 268 /* Values for opts.dump_macros.
 269   dump_only means inhibit output of the preprocessed text
 270              and instead output the definitions of all user-defined
 271              macros in a form suitable for use as input to cpp.
 272    dump_names means pass #define and the macro name through to output.
 273    dump_definitions means pass the whole definition (plus #define) through
 274 */
 275 enum { dump_none = 0, dump_only, dump_names, dump_definitions };
 276
 277 /* This structure is nested inside struct cpp_reader, and
 278    carries all the options visible to the command line.  */
 279 struct cpp_options
 280 {
 281   /* Name of input and output files.  */
 282   const char *in_fname;
 283   const char *out_fname;
 284
 285   /* Characters between tab stops.  */
 286   unsigned int tabstop;
 287
 288   /* Pending options - -D, -U, -A, -I, -ixxx. */
 289   struct cpp_pending *pending;
 290
 291   /* File name which deps are being written to.  This is 0 if deps are
 292      being written to stdout.  */
 293   const char *deps_file;
 294
 295   /* Target-name to write with the dependency information.  */
 296   char *deps_target;
 297
 298   /* Search paths for include files.  */
 299   struct file_name_list *quote_include;  /* First dir to search for "file" */
 300   struct file_name_list *bracket_include;/* First dir to search for <file> */
 301
 302   /* Map between header names and file names, used only on DOS where
 303      file names are limited in length.  */
 304   struct file_name_map_list *map_list;
 305
 306   /* Directory prefix that should replace `/usr/lib/gcc-lib/TARGET/VERSION'
 307      in the standard include file directories.  */
 308   const char *include_prefix;
 309   unsigned int include_prefix_len;
 310
 311   /* -fleading_underscore sets this to "_".  */
 312   const char *user_label_prefix;
 313
 314   /* Non-0 means -v, so print the full set of include dirs.  */
 315   unsigned char verbose;
 316
 317   /* Nonzero means use extra default include directories for C++.  */
 318   unsigned char cplusplus;
 319
 320   /* Nonzero means handle cplusplus style comments */
 321   unsigned char cplusplus_comments;
 322
 323   /* Nonzero means handle #import, for objective C.  */
 324   unsigned char objc;
 325
 326   /* Nonzero means this is an assembly file, so ignore unrecognized
 327      directives and the "# 33" form of #line, both of which are
 328      probably comments.  Also, permit unbalanced ' strings (again,
 329      likely to be in comments).  */
 330   unsigned char lang_asm;
 331
 332   /* Nonzero means don't copy comments into the output file.  */
 333   unsigned char discard_comments;
 334
 335   /* Nonzero means process the ISO trigraph sequences.  */
 336   unsigned char trigraphs;
 337
 338   /* Nonzero means process the ISO digraph sequences.  */
 339   unsigned char digraphs;
 340
 341   /* Nonzero means print the names of included files rather than the
 342      preprocessed output.  1 means just the #include "...", 2 means
 343      #include <...> as well.  */
 344   unsigned char print_deps;
 345
 346   /* Nonzero if missing .h files in -M output are assumed to be
 347      generated files and not errors.  */
 348   unsigned char print_deps_missing_files;
 349
 350   /* If true, fopen (deps_file, "a") else fopen (deps_file, "w"). */
 351   unsigned char print_deps_append;
 352
 353   /* Nonzero means print names of header files (-H).  */
 354   unsigned char print_include_names;
 355
 356   /* Nonzero means cpp_pedwarn causes a hard error.  */
 357   unsigned char pedantic_errors;
 358
 359   /* Nonzero means don't print warning messages.  */
 360   unsigned char inhibit_warnings;
 361
 362   /* Nonzero means don't print error messages.  Has no option to
 363      select it, but can be set by a user of cpplib (e.g. fix-header).  */
 364   unsigned char inhibit_errors;
 365
 366   /* Nonzero means warn if slash-star appears in a comment.  */
 367   unsigned char warn_comments;
 368
 369   /* Nonzero means warn if there are any trigraphs.  */
 370   unsigned char warn_trigraphs;
 371
 372   /* Nonzero means warn if #import is used.  */
 373   unsigned char warn_import;
 374
 375   /* Nonzero means warn about various incompatibilities with
 376      traditional C.  */
 377   unsigned char warn_traditional;
 378
 379   /* Nonzero means warn if ## is applied to two tokens that cannot be
 380      pasted together.  */
 381   unsigned char warn_paste;
 382
 383   /* Nonzero means turn warnings into errors.  */
 384   unsigned char warnings_are_errors;
 385
 386   /* Nonzero causes output not to be done, but directives such as
 387      #define that have side effects are still obeyed.  */
 388   unsigned char no_output;
 389
 390   /* Nonzero means we should look for header.gcc files that remap file
 391      names.  */
 392   unsigned char remap;
 393
 394   /* Nonzero means don't output line number information.  */
 395   unsigned char no_line_commands;
 396
 397   /* Nonzero means -I- has been seen, so don't look for #include "foo"
 398      the source-file directory.  */
 399   unsigned char ignore_srcdir;
 400
 401   /* Zero means dollar signs are punctuation. */
 402   unsigned char dollars_in_ident;
 403
 404   /* Nonzero means warn if undefined identifiers are evaluated in an #if.  */
 405   unsigned char warn_undef;
 406
 407   /* Nonzero for the 1989 C Standard, including corrigenda and amendments.  */
 408   unsigned char c89;
 409
 410   /* Nonzero for the 1999 C Standard, including corrigenda and amendments.  */
 411   unsigned char c99;
 412
 413   /* Nonzero means give all the error messages the ANSI standard requires.  */
 414   unsigned char pedantic;
 415
 416   /* Nonzero means we're looking at already preprocessed code, so don't
 417      bother trying to do macro expansion and whatnot.  */
 418   unsigned char preprocessed;
 419
 420   /* Nonzero disables all the standard directories for headers.  */
 421   unsigned char no_standard_includes;
 422
 423   /* Nonzero disables the C++-specific standard directories for headers.  */
 424   unsigned char no_standard_cplusplus_includes;
 425
 426   /* Nonzero means dump macros in some fashion - see above.  */
 427   unsigned char dump_macros;
 428
 429   /* Nonzero means pass all #define and #undef directives which we
 430      actually process through to the output stream.  This feature is
 431      used primarily to allow cc1 to record the #defines and #undefs
 432      for the sake of debuggers which understand about preprocessor
 433      macros, but it may also be useful with -E to figure out how
 434      symbols are defined, and where they are defined.  */
 435   unsigned char debug_output;
 436
 437   /* Nonzero means pass #include lines through to the output.  */
 438   unsigned char dump_includes;
 439
 440   /* Print column number in error messages.  */
 441   unsigned char show_column;
 442 };
 443
 444 struct lexer_state
 445 {
 446   /* Nonzero if first token on line is CPP_HASH.  */
 447   unsigned char in_directive;
 448
 449   /* Nonzero if the directive's # was not in the first column.  Used
 450      by -Wtraditional.  */
 451   unsigned char indented;
 452
 453   /* Nonzero if in a directive that takes angle-bracketed headers.  */
 454   unsigned char angled_headers;
 455
 456   /* Nonzero to save comments.  Turned off if discard_comments, and in
 457      all directives apart from #define.  */
 458   unsigned char save_comments;
 459
 460   /* Nonzero to get force the lexer to skip newlines.  */
 461   unsigned char skip_newlines;
 462
 463   /* Nonzero if we're in the subroutine lex_line.  */
 464   unsigned char in_lex_line;
 465
 466   /* Nonzero if we're mid-comment.  */
 467   unsigned char lexing_comment;
 468
 469   /* Tells parse_number we saw a leading period.  */
 470   unsigned char seen_dot;
 471 };
 472 #define IN_DIRECTIVE(pfile) (pfile->state.in_directive)
 473 #define KNOWN_DIRECTIVE(list) (list->directive != 0)
 474
 475 /* A cpp_reader encapsulates the "state" of a pre-processor run.
 476    Applying cpp_get_token repeatedly yields a stream of pre-processor
 477    tokens.  Usually, there is only one cpp_reader object active. */
 478
 479 struct cpp_reader
 480 {
 481   /* Top of buffer stack.  */
 482   cpp_buffer *buffer;
 483
 484   /* Lexer state.  */
 485   struct lexer_state state;
 486
 487   /* Error counter for exit code */
 488   unsigned int errors;
 489
 490   /* Line and column where a newline was first seen in a string
 491      constant (multi-line strings).  */
 492   unsigned int mls_line;
 493   unsigned int mls_column;
 494
 495   /* Current depth in #include directives that use <...>.  */
 496   unsigned int system_include_depth;
 497
 498   /* Current depth of buffer stack. */
 499   unsigned int buffer_stack_depth;
 500
 501   /* Current depth in #include directives.  */
 502   unsigned int include_depth;
 503
 504   /* Hash table of macros and assertions.  See cpphash.c */
 505   struct htab *hashtab;
 506
 507   /* Tree of other included files.  See cppfiles.c */
 508   struct splay_tree_s *all_include_files;
 509
 510   /* Chain of `actual directory' file_name_list entries,
 511      for "" inclusion. */
 512   struct file_name_list *actual_dirs;
 513
 514   /* Current maximum length of directory names in the search path
 515      for include files.  (Altered as we get more of them.)  */
 516   unsigned int max_include_len;
 517
 518   /* Potential controlling macro for the current buffer.  This is only
 519      live between the #endif and the end of file, and there can only
 520      be one at a time, so it is per-reader not per-buffer.  */
 521   const cpp_hashnode *potential_control_macro;
 522
 523   /* Token list used to store logical lines with new lexer.  */
 524   cpp_toklist token_list;
 525
 526   /* Temporary token store.  */
 527   cpp_token **temp_tokens;
 528   unsigned int temp_cap;
 529   unsigned int temp_alloced;
 530   unsigned int temp_used;
 531
 532   /* Date and time tokens.  Calculated together if either is requested.  */
 533   cpp_token *date;
 534   cpp_token *time;
 535
 536   /* The # of a the current directive. It may not be first in line if
 537      we append, and finding it is tedious.  */
 538   const cpp_token *first_directive_token;
 539
 540   /* Context stack.  Used for macro expansion and for determining
 541      which macros are disabled.  */
 542   unsigned int context_cap;
 543   unsigned int cur_context;
 544   unsigned int no_expand_level;
 545   unsigned int paste_level;
 546   struct cpp_context *contexts;
 547
 548   /* Current arguments when scanning arguments. Used for pointer
 549      fix-up.  */
 550   struct macro_args *args;
 551
 552   /* Buffer of -M output.  */
 553   struct deps *deps;
 554
 555   /* Obstack holding all macro hash nodes.  This never shrinks.
 556      See cpphash.c */
 557   struct obstack *hash_ob;
 558
 559   /* Obstack holding buffer and conditional structures.  This is a
 560      real stack.  See cpplib.c */
 561   struct obstack *buffer_ob;
 562
 563   /* Pragma table - dynamic, because a library user can add to the
 564      list of recognized pragmas.  */
 565   struct pragma_entry *pragmas;
 566
 567   /* Call backs.  */
 568   struct {
 569     void (*enter_file) PARAMS ((cpp_reader *));
 570     void (*leave_file) PARAMS ((cpp_reader *));
 571     void (*rename_file) PARAMS ((cpp_reader *));
 572     void (*include) PARAMS ((cpp_reader *, const unsigned char *,
 573                              const unsigned char *, unsigned int, int));
 574     void (*define) PARAMS ((cpp_reader *, cpp_hashnode *));
 575     void (*undef) PARAMS ((cpp_reader *, cpp_hashnode *));
 576     void (*poison) PARAMS ((cpp_reader *));
 577     void (*ident) PARAMS ((cpp_reader *, const unsigned char *, unsigned int));
 578     void (*def_pragma) PARAMS ((cpp_reader *));
 579   } cb;
 580
 581   /* User visible options.  */
 582   struct cpp_options opts;
 583
 584   /* Nonzero means we have printed (while error reporting) a list of
 585      containing files that matches the current status.  */
 586   unsigned char input_stack_listing_current;
 587
 588   /* We're printed a warning recommending against using #import.  */
 589   unsigned char import_warning;
 590
 591   /* True after cpp_start_read completes.  Used to inhibit some
 592      warnings while parsing the command line.  */
 593   unsigned char done_initializing;
 594
 595   /* True if we are skipping a failed conditional group.  */
 596   unsigned char skipping;
 597
 598   /* True if we need to save parameter spellings - only if -pedantic,
 599      or we might need to write out definitions.  */
 600   unsigned char save_parameter_spellings;
 601
 602   /* True if output_line_command needs to output a newline.  */
 603   unsigned char need_newline;
 604
 605   /* Special nodes - identifiers with predefined significance to the
 606      preprocessor.  */
 607   struct spec_nodes *spec_nodes;
 608 };
 609
 610 /* struct cpp_printer encapsulates state used to convert the stream of
 611    tokens coming from cpp_get_token back into a text file.  Not
 612    everyone wants to do that, hence we separate the function.  */
 613
 614 struct cpp_printer
 615 {
 616   FILE *outf;                   /* stream to write to */
 617   const char *last_fname;       /* previous file name */
 618   unsigned int lineno;          /* line currently being written */
 619 };
 620
 621 #define CPP_FATAL_LIMIT 1000
 622 /* True if we have seen a "fatal" error. */
 623 #define CPP_FATAL_ERRORS(READER) ((READER)->errors >= CPP_FATAL_LIMIT)
 624
 625 #define CPP_OPTION(PFILE, OPTION) ((PFILE)->opts.OPTION)
 626 #define CPP_BUFFER(PFILE) ((PFILE)->buffer)
 627 #define CPP_BUF_LINE(BUF) ((BUF)->lineno)
 628 #define CPP_BUF_COLUMN(BUF, CUR) ((CUR) - (BUF)->line_base + (BUF)->col_adjust)
 629 #define CPP_BUF_COL(BUF) CPP_BUF_COLUMN(BUF, (BUF)->cur)
 630
 631 /* Name under which this program was invoked.  */
 632 extern const char *progname;
 633
 634 /* The structure of a node in the hash table.  The hash table
 635    has entries for all tokens defined by #define commands (type T_MACRO),
 636    plus some special tokens like __LINE__ (these each have their own
 637    type, and the appropriate code is run when that type of node is seen.
 638    It does not contain control words like "#define", which are recognized
 639    by a separate piece of code. */
 640
 641 /* different flavors of hash nodes */
 642 enum node_type
 643 {
 644   T_VOID = 0,      /* no definition yet */
 645   T_SPECLINE,      /* `__LINE__' */
 646   T_DATE,          /* `__DATE__' */
 647   T_FILE,          /* `__FILE__' */
 648   T_BASE_FILE,     /* `__BASE_FILE__' */
 649   T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
 650   T_TIME,          /* `__TIME__' */
 651   T_STDC,          /* `__STDC__' */
 652   T_OPERATOR,      /* operator with a name; val.code is token type */
 653   T_POISON,        /* poisoned identifier */
 654   T_MACRO,         /* a macro, either object-like or function-like */
 655   T_ASSERTION      /* predicate for #assert */
 656 };
 657
 658 /* There is a slot in the hashnode for use by front ends when integrated
 659    with cpplib.  It holds a tree (see tree.h) but we mustn't drag that
 660    header into every user of cpplib.h.  cpplib does not do anything with
 661    this slot except clear it when a new node is created.  */
 662 union tree_node;
 663
 664 struct cpp_hashnode
 665 {
 666   unsigned int hash;                    /* cached hash value */
 667   unsigned short length;                /* length of name */
 668   ENUM_BITFIELD(node_type) type : 8;    /* node type */
 669
 670   union
 671   {
 672     const cpp_toklist *expansion;       /* a macro's replacement list.  */
 673     struct answer *answers;             /* answers to an assertion.  */
 674     enum cpp_ttype code;                /* code for a named operator.  */
 675   } value;
 676
 677   union tree_node *fe_value;            /* front end value */
 678
 679   const unsigned char name[1];          /* name[length] */
 680 };
 681
 682 extern void cpp_init PARAMS ((void));
 683 extern int cpp_handle_options PARAMS ((cpp_reader *, int, char **));
 684 extern int cpp_handle_option PARAMS ((cpp_reader *, int, char **));
 685 extern void cpp_reader_init PARAMS ((cpp_reader *));
 686 extern cpp_printer *cpp_printer_init PARAMS ((cpp_reader *, cpp_printer *));
 687
 688 extern void cpp_register_pragma PARAMS ((cpp_reader *,
 689                                          const char *, const char *,
 690                                          void (*) PARAMS ((cpp_reader *))));
 691 extern void cpp_register_pragma_space PARAMS ((cpp_reader *, const char *));
 692
 693 extern int cpp_start_read PARAMS ((cpp_reader *, cpp_printer *, const char *));
 694 extern void cpp_output_tokens PARAMS ((cpp_reader *, cpp_printer *,
 695                                        unsigned int));
 696 extern void cpp_finish PARAMS ((cpp_reader *, cpp_printer *));
 697 extern void cpp_cleanup PARAMS ((cpp_reader *));
 698
 699 extern const cpp_token *cpp_get_token PARAMS ((cpp_reader *));
 700
 701 extern void cpp_define PARAMS ((cpp_reader *, const char *));
 702 extern void cpp_assert PARAMS ((cpp_reader *, const char *));
 703 extern void cpp_undef  PARAMS ((cpp_reader *, const char *));
 704 extern void cpp_unassert PARAMS ((cpp_reader *, const char *));
 705
 706 extern void cpp_free_token_list PARAMS ((cpp_toklist *));
 707 extern cpp_buffer *cpp_push_buffer PARAMS ((cpp_reader *,
 708                                             const unsigned char *, long));
 709 extern cpp_buffer *cpp_pop_buffer PARAMS ((cpp_reader *));
 710 extern int cpp_defined PARAMS ((cpp_reader *, const unsigned char *, int));
 711
 712 /* N.B. The error-message-printer prototypes have not been nicely
 713    formatted because exgettext needs to see 'msgid' on the same line
 714    as the name of the function in order to work properly.  Only the
 715    string argument gets a name in an effort to keep the lines from
 716    getting ridiculously oversized.  */
 717
 718 extern void cpp_ice PARAMS ((cpp_reader *, const char *msgid, ...))
 719   ATTRIBUTE_PRINTF_2;
 720 extern void cpp_fatal PARAMS ((cpp_reader *, const char *msgid, ...))
 721   ATTRIBUTE_PRINTF_2;
 722 extern void cpp_error PARAMS ((cpp_reader *, const char *msgid, ...))
 723   ATTRIBUTE_PRINTF_2;
 724 extern void cpp_warning PARAMS ((cpp_reader *, const char *msgid, ...))
 725   ATTRIBUTE_PRINTF_2;
 726 extern void cpp_pedwarn PARAMS ((cpp_reader *, const char *msgid, ...))
 727   ATTRIBUTE_PRINTF_2;
 728 extern void cpp_notice PARAMS ((cpp_reader *, const char *msgid, ...))
 729   ATTRIBUTE_PRINTF_2;
 730 extern void cpp_error_with_line PARAMS ((cpp_reader *, int, int, const char *msgid, ...))
 731   ATTRIBUTE_PRINTF_4;
 732 extern void cpp_warning_with_line PARAMS ((cpp_reader *, int, int, const char *msgid, ...))
 733   ATTRIBUTE_PRINTF_4;
 734 extern void cpp_pedwarn_with_line PARAMS ((cpp_reader *, int, int, const char *msgid, ...))
 735   ATTRIBUTE_PRINTF_4;
 736 extern void cpp_pedwarn_with_file_and_line PARAMS ((cpp_reader *, const char *, int, int, const char *msgid, ...))
 737   ATTRIBUTE_PRINTF_5;
 738 extern void cpp_error_from_errno PARAMS ((cpp_reader *, const char *));
 739 extern void cpp_notice_from_errno PARAMS ((cpp_reader *, const char *));
 740
 741 extern const char *cpp_type2name PARAMS ((enum cpp_ttype));
 742
 743 /* In cpplex.c */
 744 extern cpp_buffer *cpp_push_buffer      PARAMS ((cpp_reader *,
 745                                                  const unsigned char *, long));
 746 extern cpp_buffer *cpp_pop_buffer       PARAMS ((cpp_reader *));
 747 extern void cpp_scan_buffer             PARAMS ((cpp_reader *, cpp_printer *));
 748 extern void cpp_scan_buffer_nooutput    PARAMS ((cpp_reader *));
 749 extern int cpp_ideq                     PARAMS ((const cpp_token *,
 750                                                  const char *));
 751 extern void cpp_printf                  PARAMS ((cpp_reader *, cpp_printer *,
 752                                                  const char *, ...));
 753
 754 extern void cpp_output_list             PARAMS ((cpp_reader *, FILE *,
 755                                                  const cpp_toklist *,
 756                                                  const cpp_token *));
 757
 758 /* In cpphash.c */
 759 extern cpp_hashnode *cpp_lookup PARAMS ((cpp_reader *,
 760                                          const unsigned char *, size_t));
 761 extern void cpp_forall_identifiers PARAMS ((cpp_reader *,
 762                                             int (*) PARAMS ((cpp_reader *,
 763                                                              cpp_hashnode *))));
 764 /* In cppmacro.c */
 765 extern void cpp_dump_definition PARAMS ((cpp_reader *, FILE *,
 766                                          const cpp_hashnode *));
 767
 768 /* In cppfiles.c */
 769 extern int cpp_included PARAMS ((cpp_reader *, const char *));
 770 extern int cpp_read_file PARAMS ((cpp_reader *, const char *));
 771 extern void cpp_make_system_header PARAMS ((cpp_reader *, cpp_buffer *, int));
 772 extern const char *cpp_syshdr_flags PARAMS ((cpp_reader *, cpp_buffer *));
 773
 774 #ifdef __cplusplus
 775 }
 776 #endif
 777 #endif /* __GCC_CPPLIB__ */