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_token cpp_token;
  38 typedef struct cpp_string cpp_string;
  39 typedef struct cpp_hashnode cpp_hashnode;
  40 typedef struct cpp_pool cpp_pool;
  41 typedef struct cpp_macro cpp_macro;
  42 typedef struct cpp_lexer_pos cpp_lexer_pos;
  43 typedef struct cpp_lookahead cpp_lookahead;
  44
  45 struct directive;               /* These are deliberately incomplete.  */
  46 struct answer;
  47 struct cpp_macro;
  48 struct macro_args;
  49 struct cpp_chunk;
  50 struct file_name_map_list;
  51 struct htab;
  52
  53 /* The first two groups, apart from '=', can appear in preprocessor
  54    expressions.  This allows a lookup table to be implemented in
  55    _cpp_parse_expr.
  56
  57    The first group, to CPP_LAST_EQ, can be immediately followed by an
  58    '='.  The lexer needs operators ending in '=', like ">>=", to be in
  59    the same order as their counterparts without the '=', like ">>".  */
  60
  61 /* Positions in the table.  */
  62 #define CPP_LAST_EQ CPP_MAX
  63 #define CPP_FIRST_DIGRAPH CPP_HASH
  64 #define CPP_LAST_PUNCTUATOR CPP_DOT_STAR
  65
  66 #define TTYPE_TABLE                             \
  67   OP(CPP_EQ = 0,        "=")                    \
  68   OP(CPP_NOT,           "!")                    \
  69   OP(CPP_GREATER,       ">")    /* compare */   \
  70   OP(CPP_LESS,          "<")                    \
  71   OP(CPP_PLUS,          "+")    /* math */      \
  72   OP(CPP_MINUS,         "-")                    \
  73   OP(CPP_MULT,          "*")                    \
  74   OP(CPP_DIV,           "/")                    \
  75   OP(CPP_MOD,           "%")                    \
  76   OP(CPP_AND,           "&")    /* bit ops */   \
  77   OP(CPP_OR,            "|")                    \
  78   OP(CPP_XOR,           "^")                    \
  79   OP(CPP_RSHIFT,        ">>")                   \
  80   OP(CPP_LSHIFT,        "<<")                   \
  81   OP(CPP_MIN,           "<?")   /* extension */ \
  82   OP(CPP_MAX,           ">?")                   \
  83 \
  84   OP(CPP_COMPL,         "~")                    \
  85   OP(CPP_AND_AND,       "&&")   /* logical */   \
  86   OP(CPP_OR_OR,         "||")                   \
  87   OP(CPP_QUERY,         "?")                    \
  88   OP(CPP_COLON,         ":")                    \
  89   OP(CPP_COMMA,         ",")    /* grouping */  \
  90   OP(CPP_OPEN_PAREN,    "(")                    \
  91   OP(CPP_CLOSE_PAREN,   ")")                    \
  92   OP(CPP_EQ_EQ,         "==")   /* compare */   \
  93   OP(CPP_NOT_EQ,        "!=")                   \
  94   OP(CPP_GREATER_EQ,    ">=")                   \
  95   OP(CPP_LESS_EQ,       "<=")                   \
  96 \
  97   OP(CPP_PLUS_EQ,       "+=")   /* math */      \
  98   OP(CPP_MINUS_EQ,      "-=")                   \
  99   OP(CPP_MULT_EQ,       "*=")                   \
 100   OP(CPP_DIV_EQ,        "/=")                   \
 101   OP(CPP_MOD_EQ,        "%=")                   \
 102   OP(CPP_AND_EQ,        "&=")   /* bit ops */   \
 103   OP(CPP_OR_EQ,         "|=")                   \
 104   OP(CPP_XOR_EQ,        "^=")                   \
 105   OP(CPP_RSHIFT_EQ,     ">>=")                  \
 106   OP(CPP_LSHIFT_EQ,     "<<=")                  \
 107   OP(CPP_MIN_EQ,        "<?=")  /* extension */ \
 108   OP(CPP_MAX_EQ,        ">?=")                  \
 109   /* Digraphs together, beginning with CPP_FIRST_DIGRAPH.  */   \
 110   OP(CPP_HASH,          "#")    /* digraphs */  \
 111   OP(CPP_PASTE,         "##")                   \
 112   OP(CPP_OPEN_SQUARE,   "[")                    \
 113   OP(CPP_CLOSE_SQUARE,  "]")                    \
 114   OP(CPP_OPEN_BRACE,    "{")                    \
 115   OP(CPP_CLOSE_BRACE,   "}")                    \
 116   /* The remainder of the punctuation.  Order is not significant.  */   \
 117   OP(CPP_SEMICOLON,     ";")    /* structure */ \
 118   OP(CPP_ELLIPSIS,      "...")                  \
 119   OP(CPP_PLUS_PLUS,     "++")   /* increment */ \
 120   OP(CPP_MINUS_MINUS,   "--")                   \
 121   OP(CPP_DEREF,         "->")   /* accessors */ \
 122   OP(CPP_DOT,           ".")                    \
 123   OP(CPP_SCOPE,         "::")                   \
 124   OP(CPP_DEREF_STAR,    "->*")                  \
 125   OP(CPP_DOT_STAR,      ".*")                   \
 126 \
 127   TK(CPP_NAME,          SPELL_IDENT)    /* word */                      \
 128   TK(CPP_INT,           SPELL_STRING)   /* 23 */                        \
 129   TK(CPP_FLOAT,         SPELL_STRING)   /* 3.14159 */                   \
 130   TK(CPP_NUMBER,        SPELL_STRING)   /* 34_be+ta  */                 \
 131 \
 132   TK(CPP_CHAR,          SPELL_STRING)   /* 'char' */                    \
 133   TK(CPP_WCHAR,         SPELL_STRING)   /* L'char' */                   \
 134   TK(CPP_OTHER,         SPELL_CHAR)     /* stray punctuation */         \
 135 \
 136   TK(CPP_STRING,        SPELL_STRING)   /* "string" */                  \
 137   TK(CPP_WSTRING,       SPELL_STRING)   /* L"string" */                 \
 138   TK(CPP_OSTRING,       SPELL_STRING)   /* @"string" - Objective C */   \
 139   TK(CPP_HEADER_NAME,   SPELL_STRING)   /* <stdio.h> in #include */     \
 140 \
 141   TK(CPP_COMMENT,       SPELL_STRING)   /* Only if output comments.  */ \
 142   TK(CPP_MACRO_ARG,     SPELL_NONE)     /* Macro argument.  */          \
 143   OP(CPP_EOF,           "EOL")          /* End of line or file.  */
 144
 145 #define OP(e, s) e,
 146 #define TK(e, s) e,
 147 enum cpp_ttype
 148 {
 149   TTYPE_TABLE
 150   N_TTYPES
 151 };
 152 #undef OP
 153 #undef TK
 154
 155 /* Multiple-include optimisation.  */
 156 enum mi_state {MI_FAILED = 0, MI_OUTSIDE};
 157 enum mi_ind {MI_IND_NONE = 0, MI_IND_NOT};
 158
 159 /* Payload of a NUMBER, FLOAT, STRING, or COMMENT token.  */
 160 struct cpp_string
 161 {
 162   unsigned int len;
 163   const unsigned char *text;
 164 };
 165
 166 /* Flags for the cpp_token structure.  */
 167 #define PREV_WHITE      (1 << 0) /* If whitespace before this token.  */
 168 #define DIGRAPH         (1 << 1) /* If it was a digraph.  */
 169 #define STRINGIFY_ARG   (1 << 2) /* If macro argument to be stringified.  */
 170 #define PASTE_LEFT      (1 << 3) /* If on LHS of a ## operator.  */
 171 #define NAMED_OP        (1 << 4) /* C++ named operators, also "defined".  */
 172 #define NO_EXPAND       (1 << 5) /* Do not macro-expand this token.  */
 173 #define VARARGS_FIRST   STRINGIFY_ARG /* First token of varargs expansion.  */
 174
 175 /* A preprocessing token.  This has been carefully packed and should
 176    occupy 12 bytes on 32-bit hosts and 16 bytes on 64-bit hosts.  */
 177 struct cpp_token
 178 {
 179   ENUM_BITFIELD(cpp_ttype) type : CHAR_BIT;  /* token type */
 180   unsigned char flags;          /* flags - see above */
 181
 182   union
 183   {
 184     HOST_WIDEST_INT integer;    /* An integer.  */
 185     struct cpp_hashnode *node;  /* An identifier.  */
 186     struct cpp_string str;      /* A string, or number.  */
 187     unsigned int arg_no;        /* Argument no. for a CPP_MACRO_ARG.  */
 188     unsigned char c;            /* Character represented by CPP_OTHER.  */
 189   } val;
 190 };
 191
 192 /* The position of a token in the current file.  */
 193 struct cpp_lexer_pos
 194 {
 195   unsigned int line;
 196   unsigned int output_line;
 197   unsigned short col;
 198 };
 199
 200 typedef struct cpp_token_with_pos cpp_token_with_pos;
 201 struct cpp_token_with_pos
 202 {
 203   cpp_token token;
 204   cpp_lexer_pos pos;
 205 };
 206
 207 /* Token lookahead.  */
 208 struct cpp_lookahead
 209 {
 210   struct cpp_lookahead *next;
 211   cpp_token_with_pos *tokens;
 212   cpp_lexer_pos pos;
 213   unsigned int cur, count, cap;
 214 };
 215
 216 /* Memory pools.  */
 217 struct cpp_pool
 218 {
 219   struct cpp_chunk *cur, *locked;
 220   unsigned char *pos;           /* Current position.  */
 221   unsigned int align;
 222   unsigned int locks;
 223 };
 224
 225 typedef struct toklist toklist;
 226 struct toklist
 227 {
 228   cpp_token *first;
 229   cpp_token *limit;
 230 };
 231
 232 typedef struct cpp_context cpp_context;
 233 struct cpp_context
 234 {
 235   /* Doubly-linked list.  */
 236   cpp_context *next, *prev;
 237
 238   /* Contexts other than the base context are contiguous tokens.
 239      e.g. macro expansions, expanded argument tokens.  */
 240   struct toklist list;
 241
 242   /* For a macro context, these are the macro and its arguments.  */
 243   cpp_macro *macro;
 244 };
 245
 246 /* A standalone character.  We may want to make it unsigned for the
 247    same reason we use unsigned char - to avoid signedness issues.  */
 248 typedef int cppchar_t;
 249
 250 struct cpp_buffer
 251 {
 252   const unsigned char *cur;      /* current position */
 253   const unsigned char *rlimit; /* end of valid data */
 254   const unsigned char *line_base; /* start of current line */
 255   cppchar_t read_ahead;         /* read ahead character */
 256   cppchar_t extra_char;         /* extra read-ahead for long tokens.  */
 257
 258   struct cpp_reader *pfile;     /* Owns this buffer.  */
 259   struct cpp_buffer *prev;
 260
 261   const unsigned char *buf;      /* entire buffer */
 262
 263   /* Filename specified with #line command.  */
 264   const char *nominal_fname;
 265
 266   /* Actual directory of this file, used only for "" includes */
 267   struct file_name_list *actual_dir;
 268
 269   /* Pointer into the include table.  Used for include_next and
 270      to record control macros. */
 271   struct include_file *inc;
 272
 273   /* Value of if_stack at start of this file.
 274      Used to prohibit unmatched #endif (etc) in an include file.  */
 275   struct if_stack *if_stack;
 276
 277   /* Token column position adjustment owing to tabs in whitespace.  */
 278   unsigned int col_adjust;
 279
 280   /* Line number at line_base (above). */
 281   unsigned int lineno;
 282
 283   /* True if we have already warned about C++ comments in this file.
 284      The warning happens only for C89 extended mode with -pedantic on,
 285      or for -Wtraditional, and only once per file (otherwise it would
 286      be far too noisy).  */
 287   unsigned char warned_cplusplus_comments;
 288
 289   /* True if we don't process trigraphs and escaped newlines.  True
 290      for preprocessed input, command line directives, and _Pragma
 291      buffers.  */
 292   unsigned char from_stage3;
 293 };
 294
 295 /* Maximum nesting of cpp_buffers.  We use a static limit, partly for
 296    efficiency, and partly to limit runaway recursion.  */
 297 #define CPP_STACK_MAX 200
 298
 299 /* Values for opts.dump_macros.
 300   dump_only means inhibit output of the preprocessed text
 301              and instead output the definitions of all user-defined
 302              macros in a form suitable for use as input to cpp.
 303    dump_names means pass #define and the macro name through to output.
 304    dump_definitions means pass the whole definition (plus #define) through
 305 */
 306 enum { dump_none = 0, dump_only, dump_names, dump_definitions };
 307
 308 /* This structure is nested inside struct cpp_reader, and
 309    carries all the options visible to the command line.  */
 310 struct cpp_options
 311 {
 312   /* Name of input and output files.  */
 313   const char *in_fname;
 314   const char *out_fname;
 315
 316   /* Characters between tab stops.  */
 317   unsigned int tabstop;
 318
 319   /* Pending options - -D, -U, -A, -I, -ixxx. */
 320   struct cpp_pending *pending;
 321
 322   /* File name which deps are being written to.  This is 0 if deps are
 323      being written to stdout.  */
 324   const char *deps_file;
 325
 326   /* Target-name to write with the dependency information.  */
 327   char *deps_target;
 328
 329   /* Search paths for include files.  */
 330   struct file_name_list *quote_include;  /* First dir to search for "file" */
 331   struct file_name_list *bracket_include;/* First dir to search for <file> */
 332
 333   /* Map between header names and file names, used only on DOS where
 334      file names are limited in length.  */
 335   struct file_name_map_list *map_list;
 336
 337   /* Directory prefix that should replace `/usr/lib/gcc-lib/TARGET/VERSION'
 338      in the standard include file directories.  */
 339   const char *include_prefix;
 340   unsigned int include_prefix_len;
 341
 342   /* -fleading_underscore sets this to "_".  */
 343   const char *user_label_prefix;
 344
 345   /* Non-0 means -v, so print the full set of include dirs.  */
 346   unsigned char verbose;
 347
 348   /* Nonzero means use extra default include directories for C++.  */
 349   unsigned char cplusplus;
 350
 351   /* Nonzero means handle cplusplus style comments */
 352   unsigned char cplusplus_comments;
 353
 354   /* Nonzero means handle #import, for objective C.  */
 355   unsigned char objc;
 356
 357   /* Nonzero means this is an assembly file, so ignore unrecognized
 358      directives and the "# 33" form of #line, both of which are
 359      probably comments.  Also, permit unbalanced ' strings (again,
 360      likely to be in comments).  */
 361   unsigned char lang_asm;
 362
 363   /* Nonzero means don't copy comments into the output file.  */
 364   unsigned char discard_comments;
 365
 366   /* Nonzero means process the ISO trigraph sequences.  */
 367   unsigned char trigraphs;
 368
 369   /* Nonzero means process the ISO digraph sequences.  */
 370   unsigned char digraphs;
 371
 372   /* Nonzero means print the names of included files rather than the
 373      preprocessed output.  1 means just the #include "...", 2 means
 374      #include <...> as well.  */
 375   unsigned char print_deps;
 376
 377   /* Nonzero if missing .h files in -M output are assumed to be
 378      generated files and not errors.  */
 379   unsigned char print_deps_missing_files;
 380
 381   /* If true, fopen (deps_file, "a") else fopen (deps_file, "w"). */
 382   unsigned char print_deps_append;
 383
 384   /* Nonzero means print names of header files (-H).  */
 385   unsigned char print_include_names;
 386
 387   /* Nonzero means cpp_pedwarn causes a hard error.  */
 388   unsigned char pedantic_errors;
 389
 390   /* Nonzero means don't print warning messages.  */
 391   unsigned char inhibit_warnings;
 392
 393   /* Nonzero means don't suppress warnings from system headers.  */
 394   unsigned char warn_system_headers;
 395
 396   /* Nonzero means don't print error messages.  Has no option to
 397      select it, but can be set by a user of cpplib (e.g. fix-header).  */
 398   unsigned char inhibit_errors;
 399
 400   /* Nonzero means warn if slash-star appears in a comment.  */
 401   unsigned char warn_comments;
 402
 403   /* Nonzero means warn if there are any trigraphs.  */
 404   unsigned char warn_trigraphs;
 405
 406   /* Nonzero means warn if #import is used.  */
 407   unsigned char warn_import;
 408
 409   /* Nonzero means warn about various incompatibilities with
 410      traditional C.  */
 411   unsigned char warn_traditional;
 412
 413   /* Nonzero means warn if ## is applied to two tokens that cannot be
 414      pasted together.  */
 415   unsigned char warn_paste;
 416
 417   /* Nonzero means turn warnings into errors.  */
 418   unsigned char warnings_are_errors;
 419
 420   /* Nonzero causes output not to be done, but directives such as
 421      #define that have side effects are still obeyed.  */
 422   unsigned char no_output;
 423
 424   /* Nonzero means we should look for header.gcc files that remap file
 425      names.  */
 426   unsigned char remap;
 427
 428   /* Nonzero means don't output line number information.  */
 429   unsigned char no_line_commands;
 430
 431   /* Nonzero means -I- has been seen, so don't look for #include "foo"
 432      the source-file directory.  */
 433   unsigned char ignore_srcdir;
 434
 435   /* Zero means dollar signs are punctuation. */
 436   unsigned char dollars_in_ident;
 437
 438   /* Nonzero means warn if undefined identifiers are evaluated in an #if.  */
 439   unsigned char warn_undef;
 440
 441   /* Nonzero for the 1989 C Standard, including corrigenda and amendments.  */
 442   unsigned char c89;
 443
 444   /* Nonzero for the 1999 C Standard, including corrigenda and amendments.  */
 445   unsigned char c99;
 446
 447   /* Nonzero means give all the error messages the ANSI standard requires.  */
 448   unsigned char pedantic;
 449
 450   /* Nonzero means we're looking at already preprocessed code, so don't
 451      bother trying to do macro expansion and whatnot.  */
 452   unsigned char preprocessed;
 453
 454   /* Nonzero disables all the standard directories for headers.  */
 455   unsigned char no_standard_includes;
 456
 457   /* Nonzero disables the C++-specific standard directories for headers.  */
 458   unsigned char no_standard_cplusplus_includes;
 459
 460   /* Nonzero means dump macros in some fashion - see above.  */
 461   unsigned char dump_macros;
 462
 463   /* Nonzero means pass all #define and #undef directives which we
 464      actually process through to the output stream.  This feature is
 465      used primarily to allow cc1 to record the #defines and #undefs
 466      for the sake of debuggers which understand about preprocessor
 467      macros, but it may also be useful with -E to figure out how
 468      symbols are defined, and where they are defined.  */
 469   unsigned char debug_output;
 470
 471   /* Nonzero means pass #include lines through to the output.  */
 472   unsigned char dump_includes;
 473
 474   /* Print column number in error messages.  */
 475   unsigned char show_column;
 476 };
 477
 478 struct lexer_state
 479 {
 480   /* Nonzero if first token on line is CPP_HASH.  */
 481   unsigned char in_directive;
 482
 483   /* Nonzero if in a directive that takes angle-bracketed headers.  */
 484   unsigned char angled_headers;
 485
 486   /* Nonzero to save comments.  Turned off if discard_comments, and in
 487      all directives apart from #define.  */
 488   unsigned char save_comments;
 489
 490   /* If nonzero the next token is at the beginning of the line.  */
 491   unsigned char next_bol;
 492
 493   /* Nonzero if we're mid-comment.  */
 494   unsigned char lexing_comment;
 495
 496   /* Nonzero if lexing __VA_ARGS__ is valid.  */
 497   unsigned char va_args_ok;
 498
 499   /* Nonzero if lexing poisoned identifiers is valid.  */
 500   unsigned char poisoned_ok;
 501
 502   /* Nonzero to prevent macro expansion.  */
 503   unsigned char prevent_expansion;
 504
 505   /* Nonzero when parsing arguments to a function-like macro.  */
 506   unsigned char parsing_args;
 507 };
 508
 509 /* Special nodes - identifiers with predefined significance.  */
 510 struct spec_nodes
 511 {
 512   cpp_hashnode *n_L;                    /* L"str" */
 513   cpp_hashnode *n_defined;              /* defined operator */
 514   cpp_hashnode *n__Pragma;              /* _Pragma operator */
 515   cpp_hashnode *n__STRICT_ANSI__;       /* STDC_0_IN_SYSTEM_HEADERS */
 516   cpp_hashnode *n__CHAR_UNSIGNED__;     /* plain char is unsigned */
 517   cpp_hashnode *n__VA_ARGS__;           /* C99 vararg macros */
 518 };
 519
 520 /* a cpp_reader encapsulates the "state" of a pre-processor run.
 521    Applying cpp_get_token repeatedly yields a stream of pre-processor
 522    tokens.  Usually, there is only one cpp_reader object active.  */
 523
 524 struct cpp_reader
 525 {
 526   /* Top of buffer stack.  */
 527   cpp_buffer *buffer;
 528
 529   /* Lexer state.  */
 530   struct lexer_state state;
 531
 532   /* The position of the last lexed token, last lexed directive, and
 533      last macro invocation.  */
 534   cpp_lexer_pos lexer_pos;
 535   cpp_lexer_pos macro_pos;
 536   cpp_lexer_pos directive_pos;
 537
 538   /* Memory pools.  */
 539   cpp_pool ident_pool;          /* For all identifiers, and permanent
 540                                    numbers and strings.  */
 541   cpp_pool temp_string_pool;    /* For temporary numbers and strings.   */
 542   cpp_pool macro_pool;          /* For macro definitions.  Permanent.  */
 543   cpp_pool argument_pool;       /* For macro arguments.  Temporary.   */
 544   cpp_pool* string_pool;        /* Either temp_string_pool or ident_pool.   */
 545
 546   /* Context stack.  */
 547   struct cpp_context base_context;
 548   struct cpp_context *context;
 549
 550   /* If in_directive, the directive if known.  */
 551   const struct directive *directive;
 552
 553   /* Multiple inlcude optimisation.  */
 554   enum mi_state mi_state;
 555   enum mi_ind mi_if_not_defined;
 556   unsigned int mi_lexed;
 557   const cpp_hashnode *mi_cmacro;
 558   const cpp_hashnode *mi_ind_cmacro;
 559
 560   /* Token lookahead.  */
 561   struct cpp_lookahead *la_read;        /* Read from this lookahead.  */
 562   struct cpp_lookahead *la_write;       /* Write to this lookahead.  */
 563   struct cpp_lookahead *la_unused;      /* Free store.  */
 564
 565   /* Error counter for exit code.  */
 566   unsigned int errors;
 567
 568   /* Line and column where a newline was first seen in a string
 569      constant (multi-line strings).  */
 570   cpp_lexer_pos mlstring_pos;
 571
 572   /* Buffer to hold macro definition string.  */
 573   unsigned char *macro_buffer;
 574   unsigned int macro_buffer_len;
 575
 576   /* Current depth in #include directives that use <...>.  */
 577   unsigned int system_include_depth;
 578
 579   /* Current depth of buffer stack.  */
 580   unsigned int buffer_stack_depth;
 581
 582   /* Current depth in #include directives.  */
 583   unsigned int include_depth;
 584
 585   /* Hash table of macros and assertions.  See cpphash.c.  */
 586   struct htab *hashtab;
 587
 588   /* Tree of other included files.  See cppfiles.c.  */
 589   struct splay_tree_s *all_include_files;
 590
 591   /* Chain of `actual directory' file_name_list entries, for ""
 592      inclusion.  */
 593   struct file_name_list *actual_dirs;
 594
 595   /* Current maximum length of directory names in the search path
 596      for include files.  (Altered as we get more of them.)  */
 597   unsigned int max_include_len;
 598
 599   /* Date and time tokens.  Calculated together if either is requested.  */
 600   cpp_token date;
 601   cpp_token time;
 602
 603   /* Buffer of -M output.  */
 604   struct deps *deps;
 605
 606   /* Obstack holding all macro hash nodes.  This never shrinks.
 607      See cpphash.c */
 608   struct obstack *hash_ob;
 609
 610   /* Obstack holding buffer and conditional structures.  This is a
 611      real stack.  See cpplib.c */
 612   struct obstack *buffer_ob;
 613
 614   /* Pragma table - dynamic, because a library user can add to the
 615      list of recognized pragmas.  */
 616   struct pragma_entry *pragmas;
 617
 618   /* Call backs.  */
 619   struct {
 620     void (*enter_file) PARAMS ((cpp_reader *));
 621     void (*leave_file) PARAMS ((cpp_reader *));
 622     void (*rename_file) PARAMS ((cpp_reader *));
 623     void (*include) PARAMS ((cpp_reader *, const unsigned char *,
 624                              const cpp_token *));
 625     void (*define) PARAMS ((cpp_reader *, cpp_hashnode *));
 626     void (*undef) PARAMS ((cpp_reader *, cpp_hashnode *));
 627     void (*poison) PARAMS ((cpp_reader *));
 628     void (*ident) PARAMS ((cpp_reader *, const cpp_string *));
 629     void (*def_pragma) PARAMS ((cpp_reader *));
 630   } cb;
 631
 632   /* User visible options.  */
 633   struct cpp_options opts;
 634
 635   /* Special nodes - identifiers with predefined significance to the
 636      preprocessor.  */
 637   struct spec_nodes spec_nodes;
 638
 639   /* Nonzero means we have printed (while error reporting) a list of
 640      containing files that matches the current status.  */
 641   unsigned char input_stack_listing_current;
 642
 643   /* We're printed a warning recommending against using #import.  */
 644   unsigned char import_warning;
 645
 646   /* True after cpp_start_read completes.  Used to inhibit some
 647      warnings while parsing the command line.  */
 648   unsigned char done_initializing;
 649
 650   /* True if we are skipping a failed conditional group.  */
 651   unsigned char skipping;
 652 };
 653
 654 #define CPP_FATAL_LIMIT 1000
 655 /* True if we have seen a "fatal" error. */
 656 #define CPP_FATAL_ERRORS(READER) ((READER)->errors >= CPP_FATAL_LIMIT)
 657
 658 #define CPP_OPTION(PFILE, OPTION) ((PFILE)->opts.OPTION)
 659 #define CPP_BUFFER(PFILE) ((PFILE)->buffer)
 660 #define CPP_BUF_LINE(BUF) ((BUF)->lineno)
 661 #define CPP_BUF_COLUMN(BUF, CUR) ((CUR) - (BUF)->line_base + (BUF)->col_adjust)
 662 #define CPP_BUF_COL(BUF) CPP_BUF_COLUMN(BUF, (BUF)->cur)
 663
 664 /* Name under which this program was invoked.  */
 665 extern const char *progname;
 666
 667 /* The structure of a node in the hash table.  The hash table has
 668    entries for all identifiers: either macros defined by #define
 669    commands (type NT_MACRO), assertions created with #assert
 670    (NT_ASSERTION), or neither of the above (NT_VOID).  Builtin macros
 671    like __LINE__ are flagged NODE_BUILTIN.  Poisioned identifiers are
 672    flagged NODE_POISONED.  NODE_OPERATOR (C++ only) indicates an
 673    identifier that behaves like an operator such as "xor".
 674    NODE_DIAGNOSTIC is for speed in lex_token: it indicates a
 675    diagnostic may be required for this node.  Currently this only
 676    applies to __VA_ARGS__ and poisoned identifiers.  */
 677
 678 /* Hash node flags.  */
 679 #define NODE_OPERATOR   (1 << 0)        /* C++ named operator.  */
 680 #define NODE_POISONED   (1 << 1)        /* Poisoned identifier.  */
 681 #define NODE_BUILTIN    (1 << 2)        /* Builtin macro.  */
 682 #define NODE_DIAGNOSTIC (1 << 3)        /* Possible diagnostic when lexed.  */
 683
 684 /* Different flavors of hash node.  */
 685 enum node_type
 686 {
 687   NT_VOID = 0,     /* No definition yet.  */
 688   NT_MACRO,        /* A macro of some form.  */
 689   NT_ASSERTION     /* Predicate for #assert.  */
 690 };
 691
 692 /* Different flavors of builtin macro.  */
 693 enum builtin_type
 694 {
 695   BT_SPECLINE = 0,              /* `__LINE__' */
 696   BT_DATE,                      /* `__DATE__' */
 697   BT_FILE,                      /* `__FILE__' */
 698   BT_BASE_FILE,                 /* `__BASE_FILE__' */
 699   BT_INCLUDE_LEVEL,             /* `__INCLUDE_LEVEL__' */
 700   BT_TIME,                      /* `__TIME__' */
 701   BT_STDC                       /* `__STDC__' */
 702 };
 703
 704 /* There is a slot in the hashnode for use by front ends when integrated
 705    with cpplib.  It holds a tree (see tree.h) but we mustn't drag that
 706    header into every user of cpplib.h.  cpplib does not do anything with
 707    this slot except clear it when a new node is created.  */
 708 union tree_node;
 709
 710 struct cpp_hashnode
 711 {
 712   const unsigned char *name;            /* null-terminated name */
 713   unsigned int hash;                    /* cached hash value */
 714   unsigned short length;                /* length of name excluding null */
 715   unsigned short arg_index;             /* macro argument index */
 716   unsigned char directive_index;        /* index into directive table.  */
 717   ENUM_BITFIELD(node_type) type : 8;    /* node type.  */
 718   unsigned char flags;                  /* node flags.  */
 719
 720   union
 721   {
 722     cpp_macro *macro;                   /* a macro.  */
 723     struct answer *answers;             /* answers to an assertion.  */
 724     enum cpp_ttype operator;            /* code for a named operator.  */
 725     enum builtin_type builtin;          /* code for a builtin macro.  */
 726   } value;
 727
 728   union tree_node *fe_value;            /* front end value */
 729 };
 730
 731 extern unsigned int cpp_token_len PARAMS ((const cpp_token *));
 732 extern unsigned char *cpp_token_as_text PARAMS ((cpp_reader *, const cpp_token *));
 733 extern unsigned char *cpp_spell_token PARAMS ((cpp_reader *, const cpp_token *,
 734                                                unsigned char *));
 735 extern void cpp_init PARAMS ((void));
 736 extern int cpp_handle_options PARAMS ((cpp_reader *, int, char **));
 737 extern int cpp_handle_option PARAMS ((cpp_reader *, int, char **));
 738 extern void cpp_reader_init PARAMS ((cpp_reader *));
 739
 740 extern void cpp_register_pragma PARAMS ((cpp_reader *,
 741                                          const char *, const char *,
 742                                          void (*) PARAMS ((cpp_reader *))));
 743 extern void cpp_register_pragma_space PARAMS ((cpp_reader *, const char *));
 744
 745 extern int cpp_start_read PARAMS ((cpp_reader *, const char *));
 746 extern void cpp_finish PARAMS ((cpp_reader *));
 747 extern void cpp_cleanup PARAMS ((cpp_reader *));
 748 extern int cpp_avoid_paste PARAMS ((cpp_reader *, const cpp_token *,
 749                                     const cpp_token *));
 750 extern enum cpp_ttype cpp_can_paste PARAMS ((cpp_reader *, const cpp_token *,
 751                                              const cpp_token *, int *));
 752 extern void cpp_get_token PARAMS ((cpp_reader *, cpp_token *));
 753 extern const cpp_lexer_pos *cpp_get_line PARAMS ((cpp_reader *));
 754 extern const unsigned char *cpp_macro_definition PARAMS ((cpp_reader *,
 755                                                   const cpp_hashnode *));
 756
 757 extern void cpp_define PARAMS ((cpp_reader *, const char *));
 758 extern void cpp_assert PARAMS ((cpp_reader *, const char *));
 759 extern void cpp_undef  PARAMS ((cpp_reader *, const char *));
 760 extern void cpp_unassert PARAMS ((cpp_reader *, const char *));
 761
 762 extern cpp_buffer *cpp_push_buffer PARAMS ((cpp_reader *,
 763                                             const unsigned char *, long));
 764 extern cpp_buffer *cpp_pop_buffer PARAMS ((cpp_reader *));
 765 extern int cpp_defined PARAMS ((cpp_reader *, const unsigned char *, int));
 766
 767 /* N.B. The error-message-printer prototypes have not been nicely
 768    formatted because exgettext needs to see 'msgid' on the same line
 769    as the name of the function in order to work properly.  Only the
 770    string argument gets a name in an effort to keep the lines from
 771    getting ridiculously oversized.  */
 772
 773 extern void cpp_ice PARAMS ((cpp_reader *, const char *msgid, ...))
 774   ATTRIBUTE_PRINTF_2;
 775 extern void cpp_fatal PARAMS ((cpp_reader *, const char *msgid, ...))
 776   ATTRIBUTE_PRINTF_2;
 777 extern void cpp_error PARAMS ((cpp_reader *, const char *msgid, ...))
 778   ATTRIBUTE_PRINTF_2;
 779 extern void cpp_warning PARAMS ((cpp_reader *, const char *msgid, ...))
 780   ATTRIBUTE_PRINTF_2;
 781 extern void cpp_pedwarn PARAMS ((cpp_reader *, const char *msgid, ...))
 782   ATTRIBUTE_PRINTF_2;
 783 extern void cpp_notice PARAMS ((cpp_reader *, const char *msgid, ...))
 784   ATTRIBUTE_PRINTF_2;
 785 extern void cpp_error_with_line PARAMS ((cpp_reader *, int, int, const char *msgid, ...))
 786   ATTRIBUTE_PRINTF_4;
 787 extern void cpp_warning_with_line PARAMS ((cpp_reader *, int, int, const char *msgid, ...))
 788   ATTRIBUTE_PRINTF_4;
 789 extern void cpp_pedwarn_with_line PARAMS ((cpp_reader *, int, int, const char *msgid, ...))
 790   ATTRIBUTE_PRINTF_4;
 791 extern void cpp_pedwarn_with_file_and_line PARAMS ((cpp_reader *, const char *, int, int, const char *msgid, ...))
 792   ATTRIBUTE_PRINTF_5;
 793 extern void cpp_error_from_errno PARAMS ((cpp_reader *, const char *));
 794 extern void cpp_notice_from_errno PARAMS ((cpp_reader *, const char *));
 795
 796 /* In cpplex.c */
 797 extern int cpp_ideq                     PARAMS ((const cpp_token *,
 798                                                  const char *));
 799 extern void cpp_output_line             PARAMS ((cpp_reader *, FILE *));
 800 extern void cpp_output_token            PARAMS ((const cpp_token *, FILE *));
 801 extern const char *cpp_type2name        PARAMS ((enum cpp_ttype));
 802
 803 /* In cpphash.c */
 804 extern cpp_hashnode *cpp_lookup         PARAMS ((cpp_reader *,
 805                                                  const unsigned char *, size_t));
 806 extern void cpp_forall_identifiers      PARAMS ((cpp_reader *,
 807                                                  int (*) PARAMS ((cpp_reader *,
 808                                                                   cpp_hashnode *,
 809                                                                   void *)),
 810                                                  void *));
 811
 812 /* In cppmacro.c */
 813 extern void cpp_scan_buffer_nooutput    PARAMS ((cpp_reader *));
 814 extern void cpp_start_lookahead         PARAMS ((cpp_reader *));
 815 extern void cpp_stop_lookahead          PARAMS ((cpp_reader *, int));
 816
 817 /* In cppfiles.c */
 818 extern int cpp_included PARAMS ((cpp_reader *, const char *));
 819 extern int cpp_read_file PARAMS ((cpp_reader *, const char *));
 820 extern void cpp_make_system_header PARAMS ((cpp_reader *, cpp_buffer *, int));
 821 extern const char *cpp_syshdr_flags PARAMS ((cpp_reader *, cpp_buffer *));
 822
 823 /* These are inline functions instead of macros so we can get type
 824    checking.  */
 825 typedef unsigned char U_CHAR;
 826 #define U (const U_CHAR *)  /* Intended use: U"string" */
 827
 828 static inline int ustrcmp       PARAMS ((const U_CHAR *, const U_CHAR *));
 829 static inline int ustrncmp      PARAMS ((const U_CHAR *, const U_CHAR *,
 830                                          size_t));
 831 static inline size_t ustrlen    PARAMS ((const U_CHAR *));
 832 static inline U_CHAR *uxstrdup  PARAMS ((const U_CHAR *));
 833 static inline U_CHAR *ustrchr   PARAMS ((const U_CHAR *, int));
 834 static inline int ufputs        PARAMS ((const U_CHAR *, FILE *));
 835
 836 static inline int
 837 ustrcmp (s1, s2)
 838      const U_CHAR *s1, *s2;
 839 {
 840   return strcmp ((const char *)s1, (const char *)s2);
 841 }
 842
 843 static inline int
 844 ustrncmp (s1, s2, n)
 845      const U_CHAR *s1, *s2;
 846      size_t n;
 847 {
 848   return strncmp ((const char *)s1, (const char *)s2, n);
 849 }
 850
 851 static inline size_t
 852 ustrlen (s1)
 853      const U_CHAR *s1;
 854 {
 855   return strlen ((const char *)s1);
 856 }
 857
 858 static inline U_CHAR *
 859 uxstrdup (s1)
 860      const U_CHAR *s1;
 861 {
 862   return (U_CHAR *) xstrdup ((const char *)s1);
 863 }
 864
 865 static inline U_CHAR *
 866 ustrchr (s1, c)
 867      const U_CHAR *s1;
 868      int c;
 869 {
 870   return (U_CHAR *) strchr ((const char *)s1, c);
 871 }
 872
 873 static inline int
 874 ufputs (s, f)
 875      const U_CHAR *s;
 876      FILE *f;
 877 {
 878   return fputs ((const char *)s, f);
 879 }
 880
 881 #ifdef __cplusplus
 882 }
 883 #endif
 884 #endif /* __GCC_CPPLIB__ */