libcpp/include/cpplib.h

   1 /* Definitions for CPP library.
   2    Copyright (C) 1995-2014 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 3, 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; see the file COPYING3.  If not see
  17 <http://www.gnu.org/licenses/>.
  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 LIBCPP_CPPLIB_H
  23 #define LIBCPP_CPPLIB_H
  24
  25 #include <sys/types.h>
  26 #include "symtab.h"
  27 #include "line-map.h"
  28
  29 typedef struct cpp_reader cpp_reader;
  30 typedef struct cpp_buffer cpp_buffer;
  31 typedef struct cpp_options cpp_options;
  32 typedef struct cpp_token cpp_token;
  33 typedef struct cpp_string cpp_string;
  34 typedef struct cpp_hashnode cpp_hashnode;
  35 typedef struct cpp_macro cpp_macro;
  36 typedef struct cpp_callbacks cpp_callbacks;
  37 typedef struct cpp_dir cpp_dir;
  38
  39 struct answer;
  40 struct _cpp_file;
  41
  42 /* The first three groups, apart from '=', can appear in preprocessor
  43    expressions (+= and -= are used to indicate unary + and - resp.).
  44    This allows a lookup table to be implemented in _cpp_parse_expr.
  45
  46    The first group, to CPP_LAST_EQ, can be immediately followed by an
  47    '='.  The lexer needs operators ending in '=', like ">>=", to be in
  48    the same order as their counterparts without the '=', like ">>".
  49
  50    See the cpp_operator table optab in expr.c if you change the order or
  51    add or remove anything in the first group.  */
  52
  53 #define TTYPE_TABLE                                                     \
  54   OP(EQ,                "=")                                            \
  55   OP(NOT,               "!")                                            \
  56   OP(GREATER,           ">")    /* compare */                           \
  57   OP(LESS,              "<")                                            \
  58   OP(PLUS,              "+")    /* math */                              \
  59   OP(MINUS,             "-")                                            \
  60   OP(MULT,              "*")                                            \
  61   OP(DIV,               "/")                                            \
  62   OP(MOD,               "%")                                            \
  63   OP(AND,               "&")    /* bit ops */                           \
  64   OP(OR,                "|")                                            \
  65   OP(XOR,               "^")                                            \
  66   OP(RSHIFT,            ">>")                                           \
  67   OP(LSHIFT,            "<<")                                           \
  68                                                                         \
  69   OP(COMPL,             "~")                                            \
  70   OP(AND_AND,           "&&")   /* logical */                           \
  71   OP(OR_OR,             "||")                                           \
  72   OP(QUERY,             "?")                                            \
  73   OP(COLON,             ":")                                            \
  74   OP(COMMA,             ",")    /* grouping */                          \
  75   OP(OPEN_PAREN,        "(")                                            \
  76   OP(CLOSE_PAREN,       ")")                                            \
  77   TK(EOF,               NONE)                                           \
  78   OP(EQ_EQ,             "==")   /* compare */                           \
  79   OP(NOT_EQ,            "!=")                                           \
  80   OP(GREATER_EQ,        ">=")                                           \
  81   OP(LESS_EQ,           "<=")                                           \
  82                                                                         \
  83   /* These two are unary + / - in preprocessor expressions.  */         \
  84   OP(PLUS_EQ,           "+=")   /* math */                              \
  85   OP(MINUS_EQ,          "-=")                                           \
  86                                                                         \
  87   OP(MULT_EQ,           "*=")                                           \
  88   OP(DIV_EQ,            "/=")                                           \
  89   OP(MOD_EQ,            "%=")                                           \
  90   OP(AND_EQ,            "&=")   /* bit ops */                           \
  91   OP(OR_EQ,             "|=")                                           \
  92   OP(XOR_EQ,            "^=")                                           \
  93   OP(RSHIFT_EQ,         ">>=")                                          \
  94   OP(LSHIFT_EQ,         "<<=")                                          \
  95   /* Digraphs together, beginning with CPP_FIRST_DIGRAPH.  */           \
  96   OP(HASH,              "#")    /* digraphs */                          \
  97   OP(PASTE,             "##")                                           \
  98   OP(OPEN_SQUARE,       "[")                                            \
  99   OP(CLOSE_SQUARE,      "]")                                            \
 100   OP(OPEN_BRACE,        "{")                                            \
 101   OP(CLOSE_BRACE,       "}")                                            \
 102   /* The remainder of the punctuation.  Order is not significant.  */   \
 103   OP(SEMICOLON,         ";")    /* structure */                         \
 104   OP(ELLIPSIS,          "...")                                          \
 105   OP(PLUS_PLUS,         "++")   /* increment */                         \
 106   OP(MINUS_MINUS,       "--")                                           \
 107   OP(DEREF,             "->")   /* accessors */                         \
 108   OP(DOT,               ".")                                            \
 109   OP(SCOPE,             "::")                                           \
 110   OP(DEREF_STAR,        "->*")                                          \
 111   OP(DOT_STAR,          ".*")                                           \
 112   OP(ATSIGN,            "@")  /* used in Objective-C */                 \
 113                                                                         \
 114   TK(NAME,              IDENT)   /* word */                             \
 115   TK(AT_NAME,           IDENT)   /* @word - Objective-C */              \
 116   TK(NUMBER,            LITERAL) /* 34_be+ta  */                        \
 117                                                                         \
 118   TK(CHAR,              LITERAL) /* 'char' */                           \
 119   TK(WCHAR,             LITERAL) /* L'char' */                          \
 120   TK(CHAR16,            LITERAL) /* u'char' */                          \
 121   TK(CHAR32,            LITERAL) /* U'char' */                          \
 122   TK(OTHER,             LITERAL) /* stray punctuation */                \
 123                                                                         \
 124   TK(STRING,            LITERAL) /* "string" */                         \
 125   TK(WSTRING,           LITERAL) /* L"string" */                        \
 126   TK(STRING16,          LITERAL) /* u"string" */                        \
 127   TK(STRING32,          LITERAL) /* U"string" */                        \
 128   TK(UTF8STRING,        LITERAL) /* u8"string" */                       \
 129   TK(OBJC_STRING,       LITERAL) /* @"string" - Objective-C */          \
 130   TK(HEADER_NAME,       LITERAL) /* <stdio.h> in #include */            \
 131                                                                         \
 132   TK(CHAR_USERDEF,      LITERAL) /* 'char'_suffix - C++-0x */           \
 133   TK(WCHAR_USERDEF,     LITERAL) /* L'char'_suffix - C++-0x */          \
 134   TK(CHAR16_USERDEF,    LITERAL) /* u'char'_suffix - C++-0x */          \
 135   TK(CHAR32_USERDEF,    LITERAL) /* U'char'_suffix - C++-0x */          \
 136   TK(STRING_USERDEF,    LITERAL) /* "string"_suffix - C++-0x */         \
 137   TK(WSTRING_USERDEF,   LITERAL) /* L"string"_suffix - C++-0x */        \
 138   TK(STRING16_USERDEF,  LITERAL) /* u"string"_suffix - C++-0x */        \
 139   TK(STRING32_USERDEF,  LITERAL) /* U"string"_suffix - C++-0x */        \
 140   TK(UTF8STRING_USERDEF,LITERAL) /* u8"string"_suffix - C++-0x */       \
 141                                                                         \
 142   TK(COMMENT,           LITERAL) /* Only if output comments.  */        \
 143                                  /* SPELL_LITERAL happens to DTRT.  */  \
 144   TK(MACRO_ARG,         NONE)    /* Macro argument.  */                 \
 145   TK(PRAGMA,            NONE)    /* Only for deferred pragmas.  */      \
 146   TK(PRAGMA_EOL,        NONE)    /* End-of-line for deferred pragmas.  */ \
 147   TK(PADDING,           NONE)    /* Whitespace for -E.  */
 148
 149 #define OP(e, s) CPP_ ## e,
 150 #define TK(e, s) CPP_ ## e,
 151 enum cpp_ttype
 152 {
 153   TTYPE_TABLE
 154   N_TTYPES,
 155
 156   /* Positions in the table.  */
 157   CPP_LAST_EQ        = CPP_LSHIFT,
 158   CPP_FIRST_DIGRAPH  = CPP_HASH,
 159   CPP_LAST_PUNCTUATOR= CPP_ATSIGN,
 160   CPP_LAST_CPP_OP    = CPP_LESS_EQ
 161 };
 162 #undef OP
 163 #undef TK
 164
 165 /* C language kind, used when calling cpp_create_reader.  */
 166 enum c_lang {CLK_GNUC89 = 0, CLK_GNUC99, CLK_GNUC11,
 167              CLK_STDC89, CLK_STDC94, CLK_STDC99, CLK_STDC11,
 168              CLK_GNUCXX, CLK_CXX98, CLK_GNUCXX11, CLK_CXX11,
 169              CLK_GNUCXX1Y, CLK_CXX1Y, CLK_ASM};
 170
 171 /* Payload of a NUMBER, STRING, CHAR or COMMENT token.  */
 172 struct GTY(()) cpp_string {
 173   unsigned int len;
 174   const unsigned char *text;
 175 };
 176
 177 /* Flags for the cpp_token structure.  */
 178 #define PREV_WHITE      (1 << 0) /* If whitespace before this token.  */
 179 #define DIGRAPH         (1 << 1) /* If it was a digraph.  */
 180 #define STRINGIFY_ARG   (1 << 2) /* If macro argument to be stringified.  */
 181 #define PASTE_LEFT      (1 << 3) /* If on LHS of a ## operator.  */
 182 #define NAMED_OP        (1 << 4) /* C++ named operators.  */
 183 #define NO_EXPAND       (1 << 5) /* Do not macro-expand this token.  */
 184 #define BOL             (1 << 6) /* Token at beginning of line.  */
 185 #define PURE_ZERO       (1 << 7) /* Single 0 digit, used by the C++ frontend,
 186                                     set in c-lex.c.  */
 187 #define SP_DIGRAPH      (1 << 8) /* # or ## token was a digraph.  */
 188 #define SP_PREV_WHITE   (1 << 9) /* If whitespace before a ##
 189                                     operator, or before this token
 190                                     after a # operator.  */
 191
 192 /* Specify which field, if any, of the cpp_token union is used.  */
 193
 194 enum cpp_token_fld_kind {
 195   CPP_TOKEN_FLD_NODE,
 196   CPP_TOKEN_FLD_SOURCE,
 197   CPP_TOKEN_FLD_STR,
 198   CPP_TOKEN_FLD_ARG_NO,
 199   CPP_TOKEN_FLD_TOKEN_NO,
 200   CPP_TOKEN_FLD_PRAGMA,
 201   CPP_TOKEN_FLD_NONE
 202 };
 203
 204 /* A macro argument in the cpp_token union.  */
 205 struct GTY(()) cpp_macro_arg {
 206   /* Argument number.  */
 207   unsigned int arg_no;
 208 };
 209
 210 /* An identifier in the cpp_token union.  */
 211 struct GTY(()) cpp_identifier {
 212   /* The canonical (UTF-8) spelling of the identifier.  */
 213   cpp_hashnode *
 214     GTY ((nested_ptr (union tree_node,
 215                 "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
 216                         "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL")))
 217        node;
 218 };
 219
 220 /* A preprocessing token.  This has been carefully packed and should
 221    occupy 16 bytes on 32-bit hosts and 24 bytes on 64-bit hosts.  */
 222 struct GTY(()) cpp_token {
 223   source_location src_loc;      /* Location of first char of token.  */
 224   ENUM_BITFIELD(cpp_ttype) type : CHAR_BIT;  /* token type */
 225   unsigned short flags;         /* flags - see above */
 226
 227   union cpp_token_u
 228   {
 229     /* An identifier.  */
 230     struct cpp_identifier GTY ((tag ("CPP_TOKEN_FLD_NODE"))) node;
 231
 232     /* Inherit padding from this token.  */
 233     cpp_token * GTY ((tag ("CPP_TOKEN_FLD_SOURCE"))) source;
 234
 235     /* A string, or number.  */
 236     struct cpp_string GTY ((tag ("CPP_TOKEN_FLD_STR"))) str;
 237
 238     /* Argument no. for a CPP_MACRO_ARG.  */
 239     struct cpp_macro_arg GTY ((tag ("CPP_TOKEN_FLD_ARG_NO"))) macro_arg;
 240
 241     /* Original token no. for a CPP_PASTE (from a sequence of
 242        consecutive paste tokens in a macro expansion).  */
 243     unsigned int GTY ((tag ("CPP_TOKEN_FLD_TOKEN_NO"))) token_no;
 244
 245     /* Caller-supplied identifier for a CPP_PRAGMA.  */
 246     unsigned int GTY ((tag ("CPP_TOKEN_FLD_PRAGMA"))) pragma;
 247   } GTY ((desc ("cpp_token_val_index (&%1)"))) val;
 248 };
 249
 250 /* Say which field is in use.  */
 251 extern enum cpp_token_fld_kind cpp_token_val_index (const cpp_token *tok);
 252
 253 /* A type wide enough to hold any multibyte source character.
 254    cpplib's character constant interpreter requires an unsigned type.
 255    Also, a typedef for the signed equivalent.
 256    The width of this type is capped at 32 bits; there do exist targets
 257    where wchar_t is 64 bits, but only in a non-default mode, and there
 258    would be no meaningful interpretation for a wchar_t value greater
 259    than 2^32 anyway -- the widest wide-character encoding around is
 260    ISO 10646, which stops at 2^31.  */
 261 #if CHAR_BIT * SIZEOF_INT >= 32
 262 # define CPPCHAR_SIGNED_T int
 263 #elif CHAR_BIT * SIZEOF_LONG >= 32
 264 # define CPPCHAR_SIGNED_T long
 265 #else
 266 # error "Cannot find a least-32-bit signed integer type"
 267 #endif
 268 typedef unsigned CPPCHAR_SIGNED_T cppchar_t;
 269 typedef CPPCHAR_SIGNED_T cppchar_signed_t;
 270
 271 /* Style of header dependencies to generate.  */
 272 enum cpp_deps_style { DEPS_NONE = 0, DEPS_USER, DEPS_SYSTEM };
 273
 274 /* The possible normalization levels, from most restrictive to least.  */
 275 enum cpp_normalize_level {
 276   /* In NFKC.  */
 277   normalized_KC = 0,
 278   /* In NFC.  */
 279   normalized_C,
 280   /* In NFC, except for subsequences where being in NFC would make
 281      the identifier invalid.  */
 282   normalized_identifier_C,
 283   /* Not normalized at all.  */
 284   normalized_none
 285 };
 286
 287 /* This structure is nested inside struct cpp_reader, and
 288    carries all the options visible to the command line.  */
 289 struct cpp_options
 290 {
 291   /* Characters between tab stops.  */
 292   unsigned int tabstop;
 293
 294   /* The language we're preprocessing.  */
 295   enum c_lang lang;
 296
 297   /* Nonzero means use extra default include directories for C++.  */
 298   unsigned char cplusplus;
 299
 300   /* Nonzero means handle cplusplus style comments.  */
 301   unsigned char cplusplus_comments;
 302
 303   /* Nonzero means define __OBJC__, treat @ as a special token, use
 304      the OBJC[PLUS]_INCLUDE_PATH environment variable, and allow
 305      "#import".  */
 306   unsigned char objc;
 307
 308   /* Nonzero means don't copy comments into the output file.  */
 309   unsigned char discard_comments;
 310
 311   /* Nonzero means don't copy comments into the output file during
 312      macro expansion.  */
 313   unsigned char discard_comments_in_macro_exp;
 314
 315   /* Nonzero means process the ISO trigraph sequences.  */
 316   unsigned char trigraphs;
 317
 318   /* Nonzero means process the ISO digraph sequences.  */
 319   unsigned char digraphs;
 320
 321   /* Nonzero means to allow hexadecimal floats and LL suffixes.  */
 322   unsigned char extended_numbers;
 323
 324   /* Nonzero means process u/U prefix literals (UTF-16/32).  */
 325   unsigned char uliterals;
 326
 327   /* Nonzero means process r/R raw strings.  If this is set, uliterals
 328      must be set as well.  */
 329   unsigned char rliterals;
 330
 331   /* Nonzero means print names of header files (-H).  */
 332   unsigned char print_include_names;
 333
 334   /* Nonzero means complain about deprecated features.  */
 335   unsigned char cpp_warn_deprecated;
 336
 337   /* Nonzero means warn if slash-star appears in a comment.  */
 338   unsigned char warn_comments;
 339
 340   /* Nonzero means to warn about __DATA__, __TIME__ and __TIMESTAMP__ usage.   */
 341   unsigned char warn_date_time;
 342
 343   /* Nonzero means warn if a user-supplied include directory does not
 344      exist.  */
 345   unsigned char warn_missing_include_dirs;
 346
 347   /* Nonzero means warn if there are any trigraphs.  */
 348   unsigned char warn_trigraphs;
 349
 350   /* Nonzero means warn about multicharacter charconsts.  */
 351   unsigned char warn_multichar;
 352
 353   /* Nonzero means warn about various incompatibilities with
 354      traditional C.  */
 355   unsigned char cpp_warn_traditional;
 356
 357   /* Nonzero means warn about long long numeric constants.  */
 358   unsigned char cpp_warn_long_long;
 359
 360   /* Nonzero means warn about text after an #endif (or #else).  */
 361   unsigned char warn_endif_labels;
 362
 363   /* Nonzero means warn about implicit sign changes owing to integer
 364      promotions.  */
 365   unsigned char warn_num_sign_change;
 366
 367   /* Zero means don't warn about __VA_ARGS__ usage in c89 pedantic mode.
 368      Presumably the usage is protected by the appropriate #ifdef.  */
 369   unsigned char warn_variadic_macros;
 370
 371   /* Nonzero means warn about builtin macros that are redefined or
 372      explicitly undefined.  */
 373   unsigned char warn_builtin_macro_redefined;
 374
 375   /* Nonzero means we should look for header.gcc files that remap file
 376      names.  */
 377   unsigned char remap;
 378
 379   /* Zero means dollar signs are punctuation.  */
 380   unsigned char dollars_in_ident;
 381
 382   /* Nonzero means UCNs are accepted in identifiers.  */
 383   unsigned char extended_identifiers;
 384
 385   /* True if we should warn about dollars in identifiers or numbers
 386      for this translation unit.  */
 387   unsigned char warn_dollars;
 388
 389   /* Nonzero means warn if undefined identifiers are evaluated in an #if.  */
 390   unsigned char warn_undef;
 391
 392   /* Nonzero means warn of unused macros from the main file.  */
 393   unsigned char warn_unused_macros;
 394
 395   /* Nonzero for the 1999 C Standard, including corrigenda and amendments.  */
 396   unsigned char c99;
 397
 398   /* Nonzero if we are conforming to a specific C or C++ standard.  */
 399   unsigned char std;
 400
 401   /* Nonzero means give all the error messages the ANSI standard requires.  */
 402   unsigned char cpp_pedantic;
 403
 404   /* Nonzero means we're looking at already preprocessed code, so don't
 405      bother trying to do macro expansion and whatnot.  */
 406   unsigned char preprocessed;
 407
 408   /* Nonzero means we are going to emit debugging logs during
 409      preprocessing.  */
 410   unsigned char debug;
 411
 412   /* Nonzero means we are tracking locations of tokens involved in
 413      macro expansion. 1 Means we track the location in degraded mode
 414      where we do not track locations of tokens resulting from the
 415      expansion of arguments of function-like macro.  2 Means we do
 416      track all macro expansions. This last option is the one that
 417      consumes the highest amount of memory.  */
 418   unsigned char track_macro_expansion;
 419
 420   /* Nonzero means handle C++ alternate operator names.  */
 421   unsigned char operator_names;
 422
 423   /* Nonzero means warn about use of C++ alternate operator names.  */
 424   unsigned char warn_cxx_operator_names;
 425
 426   /* True for traditional preprocessing.  */
 427   unsigned char traditional;
 428
 429   /* Nonzero for C++ 2011 Standard user-defined literals.  */
 430   unsigned char user_literals;
 431
 432   /* Nonzero means warn when a string or character literal is followed by a
 433      ud-suffix which does not beging with an underscore.  */
 434   unsigned char warn_literal_suffix;
 435
 436   /* Nonzero means interpret imaginary, fixed-point, or other gnu extension
 437      literal number suffixes as user-defined literal number suffixes.  */
 438   unsigned char ext_numeric_literals;
 439
 440   /* Nonzero means extended identifiers allow the characters specified
 441      in C11 and C++11.  */
 442   unsigned char c11_identifiers;
 443
 444   /* Nonzero for C++ 2014 Standard binary constants.  */
 445   unsigned char binary_constants;
 446
 447   /* Nonzero for C++ 2014 Standard digit separators.  */
 448   unsigned char digit_separators;
 449
 450   /* Holds the name of the target (execution) character set.  */
 451   const char *narrow_charset;
 452
 453   /* Holds the name of the target wide character set.  */
 454   const char *wide_charset;
 455
 456   /* Holds the name of the input character set.  */
 457   const char *input_charset;
 458
 459   /* The minimum permitted level of normalization before a warning
 460      is generated.  */
 461   enum cpp_normalize_level warn_normalize;
 462
 463   /* True to warn about precompiled header files we couldn't use.  */
 464   bool warn_invalid_pch;
 465
 466   /* True if dependencies should be restored from a precompiled header.  */
 467   bool restore_pch_deps;
 468
 469   /* True if warn about differences between C90 and C99.  */
 470   signed char cpp_warn_c90_c99_compat;
 471
 472   /* Dependency generation.  */
 473   struct
 474   {
 475     /* Style of header dependencies to generate.  */
 476     enum cpp_deps_style style;
 477
 478     /* Assume missing files are generated files.  */
 479     bool missing_files;
 480
 481     /* Generate phony targets for each dependency apart from the first
 482        one.  */
 483     bool phony_targets;
 484
 485     /* If true, no dependency is generated on the main file.  */
 486     bool ignore_main_file;
 487
 488     /* If true, intend to use the preprocessor output (e.g., for compilation)
 489        in addition to the dependency info.  */
 490     bool need_preprocessor_output;
 491   } deps;
 492
 493   /* Target-specific features set by the front end or client.  */
 494
 495   /* Precision for target CPP arithmetic, target characters, target
 496      ints and target wide characters, respectively.  */
 497   size_t precision, char_precision, int_precision, wchar_precision;
 498
 499   /* True means chars (wide chars) are unsigned.  */
 500   bool unsigned_char, unsigned_wchar;
 501
 502   /* True if the most significant byte in a word has the lowest
 503      address in memory.  */
 504   bool bytes_big_endian;
 505
 506   /* Nonzero means __STDC__ should have the value 0 in system headers.  */
 507   unsigned char stdc_0_in_system_headers;
 508
 509   /* True disables tokenization outside of preprocessing directives. */
 510   bool directives_only;
 511
 512   /* True enables canonicalization of system header file paths. */
 513   bool canonical_system_headers;
 514 };
 515
 516 /* Callback for header lookup for HEADER, which is the name of a
 517    source file.  It is used as a method of last resort to find headers
 518    that are not otherwise found during the normal include processing.
 519    The return value is the malloced name of a header to try and open,
 520    if any, or NULL otherwise.  This callback is called only if the
 521    header is otherwise unfound.  */
 522 typedef const char *(*missing_header_cb)(cpp_reader *, const char *header, cpp_dir **);
 523
 524 /* Call backs to cpplib client.  */
 525 struct cpp_callbacks
 526 {
 527   /* Called when a new line of preprocessed output is started.  */
 528   void (*line_change) (cpp_reader *, const cpp_token *, int);
 529
 530   /* Called when switching to/from a new file.
 531      The line_map is for the new file.  It is NULL if there is no new file.
 532      (In C this happens when done with <built-in>+<command line> and also
 533      when done with a main file.)  This can be used for resource cleanup.  */
 534   void (*file_change) (cpp_reader *, const struct line_map *);
 535
 536   void (*dir_change) (cpp_reader *, const char *);
 537   void (*include) (cpp_reader *, source_location, const unsigned char *,
 538                    const char *, int, const cpp_token **);
 539   void (*define) (cpp_reader *, source_location, cpp_hashnode *);
 540   void (*undef) (cpp_reader *, source_location, cpp_hashnode *);
 541   void (*ident) (cpp_reader *, source_location, const cpp_string *);
 542   void (*def_pragma) (cpp_reader *, source_location);
 543   int (*valid_pch) (cpp_reader *, const char *, int);
 544   void (*read_pch) (cpp_reader *, const char *, int, const char *);
 545   missing_header_cb missing_header;
 546
 547   /* Context-sensitive macro support.  Returns macro (if any) that should
 548      be expanded.  */
 549   cpp_hashnode * (*macro_to_expand) (cpp_reader *, const cpp_token *);
 550
 551   /* Called to emit a diagnostic.  This callback receives the
 552      translated message.  */
 553   bool (*error) (cpp_reader *, int, int, source_location, unsigned int,
 554                  const char *, va_list *)
 555        ATTRIBUTE_FPTR_PRINTF(6,0);
 556
 557   /* Callbacks for when a macro is expanded, or tested (whether
 558      defined or not at the time) in #ifdef, #ifndef or "defined".  */
 559   void (*used_define) (cpp_reader *, source_location, cpp_hashnode *);
 560   void (*used_undef) (cpp_reader *, source_location, cpp_hashnode *);
 561   /* Called before #define and #undef or other macro definition
 562      changes are processed.  */
 563   void (*before_define) (cpp_reader *);
 564   /* Called whenever a macro is expanded or tested.
 565      Second argument is the location of the start of the current expansion.  */
 566   void (*used) (cpp_reader *, source_location, cpp_hashnode *);
 567
 568   /* Callback that can change a user builtin into normal macro.  */
 569   bool (*user_builtin_macro) (cpp_reader *, cpp_hashnode *);
 570 };
 571
 572 #ifdef VMS
 573 #define INO_T_CPP ino_t ino[3]
 574 #else
 575 #define INO_T_CPP ino_t ino
 576 #endif
 577
 578 /* Chain of directories to look for include files in.  */
 579 struct cpp_dir
 580 {
 581   /* NULL-terminated singly-linked list.  */
 582   struct cpp_dir *next;
 583
 584   /* NAME of the directory, NUL-terminated.  */
 585   char *name;
 586   unsigned int len;
 587
 588   /* One if a system header, two if a system header that has extern
 589      "C" guards for C++.  */
 590   unsigned char sysp;
 591
 592   /* Is this a user-supplied directory? */
 593   bool user_supplied_p;
 594
 595   /* The canonicalized NAME as determined by lrealpath.  This field
 596      is only used by hosts that lack reliable inode numbers.  */
 597   char *canonical_name;
 598
 599   /* Mapping of file names for this directory for MS-DOS and related
 600      platforms.  A NULL-terminated array of (from, to) pairs.  */
 601   const char **name_map;
 602
 603   /* Routine to construct pathname, given the search path name and the
 604      HEADER we are trying to find, return a constructed pathname to
 605      try and open.  If this is NULL, the constructed pathname is as
 606      constructed by append_file_to_dir.  */
 607   char *(*construct) (const char *header, cpp_dir *dir);
 608
 609   /* The C front end uses these to recognize duplicated
 610      directories in the search path.  */
 611   INO_T_CPP;
 612   dev_t dev;
 613 };
 614
 615 /* The structure of a node in the hash table.  The hash table has
 616    entries for all identifiers: either macros defined by #define
 617    commands (type NT_MACRO), assertions created with #assert
 618    (NT_ASSERTION), or neither of the above (NT_VOID).  Builtin macros
 619    like __LINE__ are flagged NODE_BUILTIN.  Poisoned identifiers are
 620    flagged NODE_POISONED.  NODE_OPERATOR (C++ only) indicates an
 621    identifier that behaves like an operator such as "xor".
 622    NODE_DIAGNOSTIC is for speed in lex_token: it indicates a
 623    diagnostic may be required for this node.  Currently this only
 624    applies to __VA_ARGS__, poisoned identifiers, and -Wc++-compat
 625    warnings about NODE_OPERATOR.  */
 626
 627 /* Hash node flags.  */
 628 #define NODE_OPERATOR   (1 << 0)        /* C++ named operator.  */
 629 #define NODE_POISONED   (1 << 1)        /* Poisoned identifier.  */
 630 #define NODE_BUILTIN    (1 << 2)        /* Builtin macro.  */
 631 #define NODE_DIAGNOSTIC (1 << 3)        /* Possible diagnostic when lexed.  */
 632 #define NODE_WARN       (1 << 4)        /* Warn if redefined or undefined.  */
 633 #define NODE_DISABLED   (1 << 5)        /* A disabled macro.  */
 634 #define NODE_MACRO_ARG  (1 << 6)        /* Used during #define processing.  */
 635 #define NODE_USED       (1 << 7)        /* Dumped with -dU.  */
 636 #define NODE_CONDITIONAL (1 << 8)       /* Conditional macro */
 637 #define NODE_WARN_OPERATOR (1 << 9)     /* Warn about C++ named operator.  */
 638
 639 /* Different flavors of hash node.  */
 640 enum node_type
 641 {
 642   NT_VOID = 0,     /* No definition yet.  */
 643   NT_MACRO,        /* A macro of some form.  */
 644   NT_ASSERTION     /* Predicate for #assert.  */
 645 };
 646
 647 /* Different flavors of builtin macro.  _Pragma is an operator, but we
 648    handle it with the builtin code for efficiency reasons.  */
 649 enum cpp_builtin_type
 650 {
 651   BT_SPECLINE = 0,              /* `__LINE__' */
 652   BT_DATE,                      /* `__DATE__' */
 653   BT_FILE,                      /* `__FILE__' */
 654   BT_BASE_FILE,                 /* `__BASE_FILE__' */
 655   BT_INCLUDE_LEVEL,             /* `__INCLUDE_LEVEL__' */
 656   BT_TIME,                      /* `__TIME__' */
 657   BT_STDC,                      /* `__STDC__' */
 658   BT_PRAGMA,                    /* `_Pragma' operator */
 659   BT_TIMESTAMP,                 /* `__TIMESTAMP__' */
 660   BT_COUNTER,                   /* `__COUNTER__' */
 661   BT_FIRST_USER,                /* User defined builtin macros.  */
 662   BT_LAST_USER = BT_FIRST_USER + 31
 663 };
 664
 665 #define CPP_HASHNODE(HNODE)     ((cpp_hashnode *) (HNODE))
 666 #define HT_NODE(NODE)           ((ht_identifier *) (NODE))
 667 #define NODE_LEN(NODE)          HT_LEN (&(NODE)->ident)
 668 #define NODE_NAME(NODE)         HT_STR (&(NODE)->ident)
 669
 670 /* Specify which field, if any, of the union is used.  */
 671
 672 enum {
 673   NTV_MACRO,
 674   NTV_ANSWER,
 675   NTV_BUILTIN,
 676   NTV_ARGUMENT,
 677   NTV_NONE
 678 };
 679
 680 #define CPP_HASHNODE_VALUE_IDX(HNODE)                           \
 681   ((HNODE.flags & NODE_MACRO_ARG) ? NTV_ARGUMENT                \
 682    : HNODE.type == NT_MACRO ? ((HNODE.flags & NODE_BUILTIN)     \
 683                                ? NTV_BUILTIN : NTV_MACRO)       \
 684    : HNODE.type == NT_ASSERTION ? NTV_ANSWER                    \
 685    : NTV_NONE)
 686
 687 /* The common part of an identifier node shared amongst all 3 C front
 688    ends.  Also used to store CPP identifiers, which are a superset of
 689    identifiers in the grammatical sense.  */
 690
 691 union GTY(()) _cpp_hashnode_value {
 692   /* If a macro.  */
 693   cpp_macro * GTY((tag ("NTV_MACRO"))) macro;
 694   /* Answers to an assertion.  */
 695   struct answer * GTY ((tag ("NTV_ANSWER"))) answers;
 696   /* Code for a builtin macro.  */
 697   enum cpp_builtin_type GTY ((tag ("NTV_BUILTIN"))) builtin;
 698   /* Macro argument index.  */
 699   unsigned short GTY ((tag ("NTV_ARGUMENT"))) arg_index;
 700 };
 701
 702 struct GTY(()) cpp_hashnode {
 703   struct ht_identifier ident;
 704   unsigned int is_directive : 1;
 705   unsigned int directive_index : 7;     /* If is_directive,
 706                                            then index into directive table.
 707                                            Otherwise, a NODE_OPERATOR.  */
 708   unsigned char rid_code;               /* Rid code - for front ends.  */
 709   ENUM_BITFIELD(node_type) type : 6;    /* CPP node type.  */
 710   unsigned int flags : 10;              /* CPP flags.  */
 711
 712   union _cpp_hashnode_value GTY ((desc ("CPP_HASHNODE_VALUE_IDX (%1)"))) value;
 713 };
 714
 715 /* Call this first to get a handle to pass to other functions.
 716
 717    If you want cpplib to manage its own hashtable, pass in a NULL
 718    pointer.  Otherwise you should pass in an initialized hash table
 719    that cpplib will share; this technique is used by the C front
 720    ends.  */
 721 extern cpp_reader *cpp_create_reader (enum c_lang, struct ht *,
 722                                       struct line_maps *);
 723
 724 /* Reset the cpp_reader's line_map.  This is only used after reading a
 725    PCH file.  */
 726 extern void cpp_set_line_map (cpp_reader *, struct line_maps *);
 727
 728 /* Call this to change the selected language standard (e.g. because of
 729    command line options).  */
 730 extern void cpp_set_lang (cpp_reader *, enum c_lang);
 731
 732 /* Set the include paths.  */
 733 extern void cpp_set_include_chains (cpp_reader *, cpp_dir *, cpp_dir *, int);
 734
 735 /* Call these to get pointers to the options, callback, and deps
 736    structures for a given reader.  These pointers are good until you
 737    call cpp_finish on that reader.  You can either edit the callbacks
 738    through the pointer returned from cpp_get_callbacks, or set them
 739    with cpp_set_callbacks.  */
 740 extern cpp_options *cpp_get_options (cpp_reader *);
 741 extern cpp_callbacks *cpp_get_callbacks (cpp_reader *);
 742 extern void cpp_set_callbacks (cpp_reader *, cpp_callbacks *);
 743 extern struct deps *cpp_get_deps (cpp_reader *);
 744
 745 /* This function reads the file, but does not start preprocessing.  It
 746    returns the name of the original file; this is the same as the
 747    input file, except for preprocessed input.  This will generate at
 748    least one file change callback, and possibly a line change callback
 749    too.  If there was an error opening the file, it returns NULL.  */
 750 extern const char *cpp_read_main_file (cpp_reader *, const char *);
 751
 752 /* Set up built-ins with special behavior.  Use cpp_init_builtins()
 753    instead unless your know what you are doing.  */
 754 extern void cpp_init_special_builtins (cpp_reader *);
 755
 756 /* Set up built-ins like __FILE__.  */
 757 extern void cpp_init_builtins (cpp_reader *, int);
 758
 759 /* This is called after options have been parsed, and partially
 760    processed.  */
 761 extern void cpp_post_options (cpp_reader *);
 762
 763 /* Set up translation to the target character set.  */
 764 extern void cpp_init_iconv (cpp_reader *);
 765
 766 /* Call this to finish preprocessing.  If you requested dependency
 767    generation, pass an open stream to write the information to,
 768    otherwise NULL.  It is your responsibility to close the stream.  */
 769 extern void cpp_finish (cpp_reader *, FILE *deps_stream);
 770
 771 /* Call this to release the handle at the end of preprocessing.  Any
 772    use of the handle after this function returns is invalid.  */
 773 extern void cpp_destroy (cpp_reader *);
 774
 775 extern unsigned int cpp_token_len (const cpp_token *);
 776 extern unsigned char *cpp_token_as_text (cpp_reader *, const cpp_token *);
 777 extern unsigned char *cpp_spell_token (cpp_reader *, const cpp_token *,
 778                                        unsigned char *, bool);
 779 extern void cpp_register_pragma (cpp_reader *, const char *, const char *,
 780                                  void (*) (cpp_reader *), bool);
 781 extern void cpp_register_deferred_pragma (cpp_reader *, const char *,
 782                                           const char *, unsigned, bool, bool);
 783 extern int cpp_avoid_paste (cpp_reader *, const cpp_token *,
 784                             const cpp_token *);
 785 extern const cpp_token *cpp_get_token (cpp_reader *);
 786 extern const cpp_token *cpp_get_token_with_location (cpp_reader *,
 787                                                      source_location *);
 788 extern const unsigned char *cpp_macro_definition (cpp_reader *,
 789                                                   cpp_hashnode *);
 790 extern void _cpp_backup_tokens (cpp_reader *, unsigned int);
 791 extern const cpp_token *cpp_peek_token (cpp_reader *, int);
 792
 793 /* Evaluate a CPP_*CHAR* token.  */
 794 extern cppchar_t cpp_interpret_charconst (cpp_reader *, const cpp_token *,
 795                                           unsigned int *, int *);
 796 /* Evaluate a vector of CPP_*STRING* tokens.  */
 797 extern bool cpp_interpret_string (cpp_reader *,
 798                                   const cpp_string *, size_t,
 799                                   cpp_string *, enum cpp_ttype);
 800 extern bool cpp_interpret_string_notranslate (cpp_reader *,
 801                                               const cpp_string *, size_t,
 802                                               cpp_string *, enum cpp_ttype);
 803
 804 /* Convert a host character constant to the execution character set.  */
 805 extern cppchar_t cpp_host_to_exec_charset (cpp_reader *, cppchar_t);
 806
 807 /* Used to register macros and assertions, perhaps from the command line.
 808    The text is the same as the command line argument.  */
 809 extern void cpp_define (cpp_reader *, const char *);
 810 extern void cpp_define_formatted (cpp_reader *pfile,
 811                                   const char *fmt, ...) ATTRIBUTE_PRINTF_2;
 812 extern void cpp_assert (cpp_reader *, const char *);
 813 extern void cpp_undef (cpp_reader *, const char *);
 814 extern void cpp_unassert (cpp_reader *, const char *);
 815
 816 /* Undefine all macros and assertions.  */
 817 extern void cpp_undef_all (cpp_reader *);
 818
 819 extern cpp_buffer *cpp_push_buffer (cpp_reader *, const unsigned char *,
 820                                     size_t, int);
 821 extern int cpp_defined (cpp_reader *, const unsigned char *, int);
 822
 823 /* A preprocessing number.  Code assumes that any unused high bits of
 824    the double integer are set to zero.  */
 825
 826 /* This type has to be equal to unsigned HOST_WIDE_INT, see
 827    gcc/c-family/c-lex.c.  */
 828 typedef uint64_t cpp_num_part;
 829 typedef struct cpp_num cpp_num;
 830 struct cpp_num
 831 {
 832   cpp_num_part high;
 833   cpp_num_part low;
 834   bool unsignedp;  /* True if value should be treated as unsigned.  */
 835   bool overflow;   /* True if the most recent calculation overflowed.  */
 836 };
 837
 838 /* cpplib provides two interfaces for interpretation of preprocessing
 839    numbers.
 840
 841    cpp_classify_number categorizes numeric constants according to
 842    their field (integer, floating point, or invalid), radix (decimal,
 843    octal, hexadecimal), and type suffixes.  */
 844
 845 #define CPP_N_CATEGORY  0x000F
 846 #define CPP_N_INVALID   0x0000
 847 #define CPP_N_INTEGER   0x0001
 848 #define CPP_N_FLOATING  0x0002
 849
 850 #define CPP_N_WIDTH     0x00F0
 851 #define CPP_N_SMALL     0x0010  /* int, float, shrot _Fract/Accum  */
 852 #define CPP_N_MEDIUM    0x0020  /* long, double, long _Fract/_Accum.  */
 853 #define CPP_N_LARGE     0x0040  /* long long, long double,
 854                                    long long _Fract/Accum.  */
 855
 856 #define CPP_N_WIDTH_MD  0xF0000 /* machine defined.  */
 857 #define CPP_N_MD_W      0x10000
 858 #define CPP_N_MD_Q      0x20000
 859
 860 #define CPP_N_RADIX     0x0F00
 861 #define CPP_N_DECIMAL   0x0100
 862 #define CPP_N_HEX       0x0200
 863 #define CPP_N_OCTAL     0x0400
 864 #define CPP_N_BINARY    0x0800
 865
 866 #define CPP_N_UNSIGNED  0x1000  /* Properties.  */
 867 #define CPP_N_IMAGINARY 0x2000
 868 #define CPP_N_DFLOAT    0x4000
 869 #define CPP_N_DEFAULT   0x8000
 870
 871 #define CPP_N_FRACT     0x100000 /* Fract types.  */
 872 #define CPP_N_ACCUM     0x200000 /* Accum types.  */
 873
 874 #define CPP_N_USERDEF   0x1000000 /* C++0x user-defined literal.  */
 875
 876 /* Classify a CPP_NUMBER token.  The return value is a combination of
 877    the flags from the above sets.  */
 878 extern unsigned cpp_classify_number (cpp_reader *, const cpp_token *,
 879                                      const char **, source_location);
 880
 881 /* Return the classification flags for a float suffix.  */
 882 extern unsigned int cpp_interpret_float_suffix (cpp_reader *, const char *,
 883                                                 size_t);
 884
 885 /* Return the classification flags for an int suffix.  */
 886 extern unsigned int cpp_interpret_int_suffix (cpp_reader *, const char *,
 887                                               size_t);
 888
 889 /* Evaluate a token classified as category CPP_N_INTEGER.  */
 890 extern cpp_num cpp_interpret_integer (cpp_reader *, const cpp_token *,
 891                                       unsigned int);
 892
 893 /* Sign extend a number, with PRECISION significant bits and all
 894    others assumed clear, to fill out a cpp_num structure.  */
 895 cpp_num cpp_num_sign_extend (cpp_num, size_t);
 896
 897 /* Diagnostic levels.  To get a diagnostic without associating a
 898    position in the translation unit with it, use cpp_error_with_line
 899    with a line number of zero.  */
 900
 901 enum {
 902   /* Warning, an error with -Werror.  */
 903   CPP_DL_WARNING = 0,
 904   /* Same as CPP_DL_WARNING, except it is not suppressed in system headers.  */
 905   CPP_DL_WARNING_SYSHDR,
 906   /* Warning, an error with -pedantic-errors or -Werror.  */
 907   CPP_DL_PEDWARN,
 908   /* An error.  */
 909   CPP_DL_ERROR,
 910   /* An internal consistency check failed.  Prints "internal error: ",
 911      otherwise the same as CPP_DL_ERROR.  */
 912   CPP_DL_ICE,
 913   /* An informative note following a warning.  */
 914   CPP_DL_NOTE,
 915   /* A fatal error.  */
 916   CPP_DL_FATAL
 917 };
 918
 919 /* Warning reason codes. Use a reason code of zero for unclassified warnings
 920    and errors that are not warnings.  */
 921 enum {
 922   CPP_W_NONE = 0,
 923   CPP_W_DEPRECATED,
 924   CPP_W_COMMENTS,
 925   CPP_W_MISSING_INCLUDE_DIRS,
 926   CPP_W_TRIGRAPHS,
 927   CPP_W_MULTICHAR,
 928   CPP_W_TRADITIONAL,
 929   CPP_W_LONG_LONG,
 930   CPP_W_ENDIF_LABELS,
 931   CPP_W_NUM_SIGN_CHANGE,
 932   CPP_W_VARIADIC_MACROS,
 933   CPP_W_BUILTIN_MACRO_REDEFINED,
 934   CPP_W_DOLLARS,
 935   CPP_W_UNDEF,
 936   CPP_W_UNUSED_MACROS,
 937   CPP_W_CXX_OPERATOR_NAMES,
 938   CPP_W_NORMALIZE,
 939   CPP_W_INVALID_PCH,
 940   CPP_W_WARNING_DIRECTIVE,
 941   CPP_W_LITERAL_SUFFIX,
 942   CPP_W_DATE_TIME
 943 };
 944
 945 /* Output a diagnostic of some kind.  */
 946 extern bool cpp_error (cpp_reader *, int, const char *msgid, ...)
 947   ATTRIBUTE_PRINTF_3;
 948 extern bool cpp_warning (cpp_reader *, int, const char *msgid, ...)
 949   ATTRIBUTE_PRINTF_3;
 950 extern bool cpp_pedwarning (cpp_reader *, int, const char *msgid, ...)
 951   ATTRIBUTE_PRINTF_3;
 952 extern bool cpp_warning_syshdr (cpp_reader *, int, const char *msgid, ...)
 953   ATTRIBUTE_PRINTF_3;
 954
 955 /* Output a diagnostic with "MSGID: " preceding the
 956    error string of errno.  No location is printed.  */
 957 extern bool cpp_errno (cpp_reader *, int, const char *msgid);
 958
 959 /* Same as cpp_error, except additionally specifies a position as a
 960    (translation unit) physical line and physical column.  If the line is
 961    zero, then no location is printed.  */
 962 extern bool cpp_error_with_line (cpp_reader *, int, source_location,
 963                                  unsigned, const char *msgid, ...)
 964   ATTRIBUTE_PRINTF_5;
 965 extern bool cpp_warning_with_line (cpp_reader *, int, source_location,
 966                                    unsigned, const char *msgid, ...)
 967   ATTRIBUTE_PRINTF_5;
 968 extern bool cpp_pedwarning_with_line (cpp_reader *, int, source_location,
 969                                       unsigned, const char *msgid, ...)
 970   ATTRIBUTE_PRINTF_5;
 971 extern bool cpp_warning_with_line_syshdr (cpp_reader *, int, source_location,
 972                                           unsigned, const char *msgid, ...)
 973   ATTRIBUTE_PRINTF_5;
 974
 975 /* In lex.c */
 976 extern int cpp_ideq (const cpp_token *, const char *);
 977 extern void cpp_output_line (cpp_reader *, FILE *);
 978 extern unsigned char *cpp_output_line_to_string (cpp_reader *,
 979                                                  const unsigned char *);
 980 extern void cpp_output_token (const cpp_token *, FILE *);
 981 extern const char *cpp_type2name (enum cpp_ttype, unsigned char flags);
 982 /* Returns the value of an escape sequence, truncated to the correct
 983    target precision.  PSTR points to the input pointer, which is just
 984    after the backslash.  LIMIT is how much text we have.  WIDE is true
 985    if the escape sequence is part of a wide character constant or
 986    string literal.  Handles all relevant diagnostics.  */
 987 extern cppchar_t cpp_parse_escape (cpp_reader *, const unsigned char ** pstr,
 988                                    const unsigned char *limit, int wide);
 989
 990 /* Structure used to hold a comment block at a given location in the
 991    source code.  */
 992
 993 typedef struct
 994 {
 995   /* Text of the comment including the terminators.  */
 996   char *comment;
 997
 998   /* source location for the given comment.  */
 999   source_location sloc;
1000 } cpp_comment;
1001
1002 /* Structure holding all comments for a given cpp_reader.  */
1003
1004 typedef struct
1005 {
1006   /* table of comment entries.  */
1007   cpp_comment *entries;
1008
1009   /* number of actual entries entered in the table.  */
1010   int count;
1011
1012   /* number of entries allocated currently.  */
1013   int allocated;
1014 } cpp_comment_table;
1015
1016 /* Returns the table of comments encountered by the preprocessor. This
1017    table is only populated when pfile->state.save_comments is true. */
1018 extern cpp_comment_table *cpp_get_comments (cpp_reader *);
1019
1020 /* In hash.c */
1021
1022 /* Lookup an identifier in the hashtable.  Puts the identifier in the
1023    table if it is not already there.  */
1024 extern cpp_hashnode *cpp_lookup (cpp_reader *, const unsigned char *,
1025                                  unsigned int);
1026
1027 typedef int (*cpp_cb) (cpp_reader *, cpp_hashnode *, void *);
1028 extern void cpp_forall_identifiers (cpp_reader *, cpp_cb, void *);
1029
1030 /* In macro.c */
1031 extern void cpp_scan_nooutput (cpp_reader *);
1032 extern int  cpp_sys_macro_p (cpp_reader *);
1033 extern unsigned char *cpp_quote_string (unsigned char *, const unsigned char *,
1034                                         unsigned int);
1035
1036 /* In files.c */
1037 extern bool cpp_included (cpp_reader *, const char *);
1038 extern bool cpp_included_before (cpp_reader *, const char *, source_location);
1039 extern void cpp_make_system_header (cpp_reader *, int, int);
1040 extern bool cpp_push_include (cpp_reader *, const char *);
1041 extern bool cpp_push_default_include (cpp_reader *, const char *);
1042 extern void cpp_change_file (cpp_reader *, enum lc_reason, const char *);
1043 extern const char *cpp_get_path (struct _cpp_file *);
1044 extern cpp_dir *cpp_get_dir (struct _cpp_file *);
1045 extern cpp_buffer *cpp_get_buffer (cpp_reader *);
1046 extern struct _cpp_file *cpp_get_file (cpp_buffer *);
1047 extern cpp_buffer *cpp_get_prev (cpp_buffer *);
1048 extern void cpp_clear_file_cache (cpp_reader *);
1049
1050 /* In pch.c */
1051 struct save_macro_data;
1052 extern int cpp_save_state (cpp_reader *, FILE *);
1053 extern int cpp_write_pch_deps (cpp_reader *, FILE *);
1054 extern int cpp_write_pch_state (cpp_reader *, FILE *);
1055 extern int cpp_valid_state (cpp_reader *, const char *, int);
1056 extern void cpp_prepare_state (cpp_reader *, struct save_macro_data **);
1057 extern int cpp_read_state (cpp_reader *, const char *, FILE *,
1058                            struct save_macro_data *);
1059
1060 /* In lex.c */
1061 extern void cpp_force_token_locations (cpp_reader *, source_location *);
1062 extern void cpp_stop_forcing_token_locations (cpp_reader *);
1063
1064 /* In expr.c */
1065 extern enum cpp_ttype cpp_userdef_string_remove_type
1066   (enum cpp_ttype type);
1067 extern enum cpp_ttype cpp_userdef_string_add_type
1068   (enum cpp_ttype type);
1069 extern enum cpp_ttype cpp_userdef_char_remove_type
1070   (enum cpp_ttype type);
1071 extern enum cpp_ttype cpp_userdef_char_add_type
1072   (enum cpp_ttype type);
1073 extern bool cpp_userdef_string_p
1074   (enum cpp_ttype type);
1075 extern bool cpp_userdef_char_p
1076   (enum cpp_ttype type);
1077 extern const char * cpp_get_userdef_suffix
1078   (const cpp_token *);
1079
1080 #endif /* ! LIBCPP_CPPLIB_H */