LCOV - code coverage report
Current view: top level - libcpp/include - cpplib.h (source / functions) Hit Total Coverage
Test: gcc.info Lines: 14 14 100.0 %
Date: 2020-07-04 13:15:35 Functions: 1 1 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Definitions for CPP library.
       2                 :            :    Copyright (C) 1995-2020 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 _cpp_file;
      40                 :            : 
      41                 :            : /* The first three groups, apart from '=', can appear in preprocessor
      42                 :            :    expressions (+= and -= are used to indicate unary + and - resp.).
      43                 :            :    This allows a lookup table to be implemented in _cpp_parse_expr.
      44                 :            : 
      45                 :            :    The first group, to CPP_LAST_EQ, can be immediately followed by an
      46                 :            :    '='.  The lexer needs operators ending in '=', like ">>=", to be in
      47                 :            :    the same order as their counterparts without the '=', like ">>".
      48                 :            : 
      49                 :            :    See the cpp_operator table optab in expr.c if you change the order or
      50                 :            :    add or remove anything in the first group.  */
      51                 :            : 
      52                 :            : #define TTYPE_TABLE                                                     \
      53                 :            :   OP(EQ,                "=")                                          \
      54                 :            :   OP(NOT,               "!")                                          \
      55                 :            :   OP(GREATER,           ">")       /* compare */                           \
      56                 :            :   OP(LESS,              "<")                                               \
      57                 :            :   OP(PLUS,              "+")  /* math */                              \
      58                 :            :   OP(MINUS,             "-")                                          \
      59                 :            :   OP(MULT,              "*")                                          \
      60                 :            :   OP(DIV,               "/")                                          \
      61                 :            :   OP(MOD,               "%")                                          \
      62                 :            :   OP(AND,               "&")      /* bit ops */                           \
      63                 :            :   OP(OR,                "|")                                          \
      64                 :            :   OP(XOR,               "^")                                          \
      65                 :            :   OP(RSHIFT,            ">>")                                           \
      66                 :            :   OP(LSHIFT,            "<<")                                           \
      67                 :            :                                                                         \
      68                 :            :   OP(COMPL,             "~")                                          \
      69                 :            :   OP(AND_AND,           "&&") /* logical */                           \
      70                 :            :   OP(OR_OR,             "||")                                         \
      71                 :            :   OP(QUERY,             "?")                                          \
      72                 :            :   OP(COLON,             ":")                                          \
      73                 :            :   OP(COMMA,             ",")  /* grouping */                          \
      74                 :            :   OP(OPEN_PAREN,        "(")                                          \
      75                 :            :   OP(CLOSE_PAREN,       ")")                                          \
      76                 :            :   TK(EOF,               NONE)                                           \
      77                 :            :   OP(EQ_EQ,             "==") /* compare */                           \
      78                 :            :   OP(NOT_EQ,            "!=")                                         \
      79                 :            :   OP(GREATER_EQ,        ">=")                                              \
      80                 :            :   OP(LESS_EQ,           "<=")                                              \
      81                 :            :   OP(SPACESHIP,         "<=>")                                          \
      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(UTF8CHAR,          LITERAL) /* u8'char' */                         \
     123                 :            :   TK(OTHER,             LITERAL) /* stray punctuation */                \
     124                 :            :                                                                         \
     125                 :            :   TK(STRING,            LITERAL) /* "string" */                               \
     126                 :            :   TK(WSTRING,           LITERAL) /* L"string" */                      \
     127                 :            :   TK(STRING16,          LITERAL) /* u"string" */                      \
     128                 :            :   TK(STRING32,          LITERAL) /* U"string" */                      \
     129                 :            :   TK(UTF8STRING,        LITERAL) /* u8"string" */                     \
     130                 :            :   TK(OBJC_STRING,       LITERAL) /* @"string" - Objective-C */                \
     131                 :            :   TK(HEADER_NAME,       LITERAL) /* <stdio.h> in #include */              \
     132                 :            :                                                                         \
     133                 :            :   TK(CHAR_USERDEF,      LITERAL) /* 'char'_suffix - C++-0x */           \
     134                 :            :   TK(WCHAR_USERDEF,     LITERAL) /* L'char'_suffix - C++-0x */          \
     135                 :            :   TK(CHAR16_USERDEF,    LITERAL) /* u'char'_suffix - C++-0x */          \
     136                 :            :   TK(CHAR32_USERDEF,    LITERAL) /* U'char'_suffix - C++-0x */          \
     137                 :            :   TK(UTF8CHAR_USERDEF,  LITERAL) /* u8'char'_suffix - C++-0x */         \
     138                 :            :   TK(STRING_USERDEF,    LITERAL) /* "string"_suffix - C++-0x */               \
     139                 :            :   TK(WSTRING_USERDEF,   LITERAL) /* L"string"_suffix - C++-0x */      \
     140                 :            :   TK(STRING16_USERDEF,  LITERAL) /* u"string"_suffix - C++-0x */      \
     141                 :            :   TK(STRING32_USERDEF,  LITERAL) /* U"string"_suffix - C++-0x */      \
     142                 :            :   TK(UTF8STRING_USERDEF,LITERAL) /* u8"string"_suffix - C++-0x */     \
     143                 :            :                                                                         \
     144                 :            :   TK(COMMENT,           LITERAL) /* Only if output comments.  */        \
     145                 :            :                                  /* SPELL_LITERAL happens to DTRT.  */  \
     146                 :            :   TK(MACRO_ARG,         NONE)    /* Macro argument.  */                 \
     147                 :            :   TK(PRAGMA,            NONE)    /* Only for deferred pragmas.  */      \
     148                 :            :   TK(PRAGMA_EOL,        NONE)    /* End-of-line for deferred pragmas.  */ \
     149                 :            :   TK(PADDING,           NONE)    /* Whitespace for -E.  */
     150                 :            : 
     151                 :            : #define OP(e, s) CPP_ ## e,
     152                 :            : #define TK(e, s) CPP_ ## e,
     153                 :            : enum cpp_ttype
     154                 :            : {
     155                 :            :   TTYPE_TABLE
     156                 :            :   N_TTYPES,
     157                 :            : 
     158                 :            :   /* A token type for keywords, as opposed to ordinary identifiers.  */
     159                 :            :   CPP_KEYWORD,
     160                 :            : 
     161                 :            :   /* Positions in the table.  */
     162                 :            :   CPP_LAST_EQ        = CPP_LSHIFT,
     163                 :            :   CPP_FIRST_DIGRAPH  = CPP_HASH,
     164                 :            :   CPP_LAST_PUNCTUATOR= CPP_ATSIGN,
     165                 :            :   CPP_LAST_CPP_OP    = CPP_LESS_EQ
     166                 :            : };
     167                 :            : #undef OP
     168                 :            : #undef TK
     169                 :            : 
     170                 :            : /* C language kind, used when calling cpp_create_reader.  */
     171                 :            : enum c_lang {CLK_GNUC89 = 0, CLK_GNUC99, CLK_GNUC11, CLK_GNUC17, CLK_GNUC2X,
     172                 :            :              CLK_STDC89, CLK_STDC94, CLK_STDC99, CLK_STDC11, CLK_STDC17,
     173                 :            :              CLK_STDC2X,
     174                 :            :              CLK_GNUCXX, CLK_CXX98, CLK_GNUCXX11, CLK_CXX11,
     175                 :            :              CLK_GNUCXX14, CLK_CXX14, CLK_GNUCXX17, CLK_CXX17,
     176                 :            :              CLK_GNUCXX20, CLK_CXX20, CLK_ASM};
     177                 :            : 
     178                 :            : /* Payload of a NUMBER, STRING, CHAR or COMMENT token.  */
     179                 :            : struct GTY(()) cpp_string {
     180                 :            :   unsigned int len;
     181                 :            :   const unsigned char *text;
     182                 :            : };
     183                 :            : 
     184                 :            : /* Flags for the cpp_token structure.  */
     185                 :            : #define PREV_WHITE      (1 << 0) /* If whitespace before this token.  */
     186                 :            : #define DIGRAPH         (1 << 1) /* If it was a digraph.  */
     187                 :            : #define STRINGIFY_ARG   (1 << 2) /* If macro argument to be stringified.  */
     188                 :            : #define PASTE_LEFT      (1 << 3) /* If on LHS of a ## operator.  */
     189                 :            : #define NAMED_OP        (1 << 4) /* C++ named operators.  */
     190                 :            : #define PREV_FALLTHROUGH (1 << 5) /* On a token preceeded by FALLTHROUGH
     191                 :            :                                      comment.  */
     192                 :            : #define BOL             (1 << 6) /* Token at beginning of line.  */
     193                 :            : #define PURE_ZERO       (1 << 7) /* Single 0 digit, used by the C++ frontend,
     194                 :            :                                     set in c-lex.c.  */
     195                 :            : #define SP_DIGRAPH      (1 << 8) /* # or ## token was a digraph.  */
     196                 :            : #define SP_PREV_WHITE   (1 << 9) /* If whitespace before a ##
     197                 :            :                                     operator, or before this token
     198                 :            :                                     after a # operator.  */
     199                 :            : #define NO_EXPAND       (1 << 10) /* Do not macro-expand this token.  */
     200                 :            : 
     201                 :            : /* Specify which field, if any, of the cpp_token union is used.  */
     202                 :            : 
     203                 :            : enum cpp_token_fld_kind {
     204                 :            :   CPP_TOKEN_FLD_NODE,
     205                 :            :   CPP_TOKEN_FLD_SOURCE,
     206                 :            :   CPP_TOKEN_FLD_STR,
     207                 :            :   CPP_TOKEN_FLD_ARG_NO,
     208                 :            :   CPP_TOKEN_FLD_TOKEN_NO,
     209                 :            :   CPP_TOKEN_FLD_PRAGMA,
     210                 :            :   CPP_TOKEN_FLD_NONE
     211                 :            : };
     212                 :            : 
     213                 :            : /* A macro argument in the cpp_token union.  */
     214                 :            : struct GTY(()) cpp_macro_arg {
     215                 :            :   /* Argument number.  */
     216                 :            :   unsigned int arg_no;
     217                 :            :   /* The original spelling of the macro argument token.  */
     218                 :            :   cpp_hashnode *
     219                 :            :     GTY ((nested_ptr (union tree_node,
     220                 :            :                 "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
     221                 :            :                         "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL")))
     222                 :            :        spelling;
     223                 :            : };
     224                 :            : 
     225                 :            : /* An identifier in the cpp_token union.  */
     226                 :            : struct GTY(()) cpp_identifier {
     227                 :            :   /* The canonical (UTF-8) spelling of the identifier.  */
     228                 :            :   cpp_hashnode *
     229                 :            :     GTY ((nested_ptr (union tree_node,
     230                 :            :                 "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
     231                 :            :                         "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL")))
     232                 :            :        node;
     233                 :            :   /* The original spelling of the identifier.  */
     234                 :            :   cpp_hashnode *
     235                 :            :     GTY ((nested_ptr (union tree_node,
     236                 :            :                 "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
     237                 :            :                         "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL")))
     238                 :            :        spelling;
     239                 :            : };
     240                 :            : 
     241                 :            : /* A preprocessing token.  This has been carefully packed and should
     242                 :            :    occupy 16 bytes on 32-bit hosts and 24 bytes on 64-bit hosts.  */
     243                 :            : struct GTY(()) cpp_token {
     244                 :            : 
     245                 :            :   /* Location of first char of token, together with range of full token.  */
     246                 :            :   location_t src_loc;
     247                 :            : 
     248                 :            :   ENUM_BITFIELD(cpp_ttype) type : CHAR_BIT;  /* token type */
     249                 :            :   unsigned short flags;         /* flags - see above */
     250                 :            : 
     251                 :            :   union cpp_token_u
     252                 :            :   {
     253                 :            :     /* An identifier.  */
     254                 :            :     struct cpp_identifier GTY ((tag ("CPP_TOKEN_FLD_NODE"))) node;
     255                 :            :          
     256                 :            :     /* Inherit padding from this token.  */
     257                 :            :     cpp_token * GTY ((tag ("CPP_TOKEN_FLD_SOURCE"))) source;
     258                 :            : 
     259                 :            :     /* A string, or number.  */
     260                 :            :     struct cpp_string GTY ((tag ("CPP_TOKEN_FLD_STR"))) str;
     261                 :            : 
     262                 :            :     /* Argument no. (and original spelling) for a CPP_MACRO_ARG.  */
     263                 :            :     struct cpp_macro_arg GTY ((tag ("CPP_TOKEN_FLD_ARG_NO"))) macro_arg;
     264                 :            : 
     265                 :            :     /* Original token no. for a CPP_PASTE (from a sequence of
     266                 :            :        consecutive paste tokens in a macro expansion).  */
     267                 :            :     unsigned int GTY ((tag ("CPP_TOKEN_FLD_TOKEN_NO"))) token_no;
     268                 :            : 
     269                 :            :     /* Caller-supplied identifier for a CPP_PRAGMA.  */
     270                 :            :     unsigned int GTY ((tag ("CPP_TOKEN_FLD_PRAGMA"))) pragma;
     271                 :            :   } GTY ((desc ("cpp_token_val_index (&%1)"))) val;
     272                 :            : };
     273                 :            : 
     274                 :            : /* Say which field is in use.  */
     275                 :            : extern enum cpp_token_fld_kind cpp_token_val_index (const cpp_token *tok);
     276                 :            : 
     277                 :            : /* A type wide enough to hold any multibyte source character.
     278                 :            :    cpplib's character constant interpreter requires an unsigned type.
     279                 :            :    Also, a typedef for the signed equivalent.
     280                 :            :    The width of this type is capped at 32 bits; there do exist targets
     281                 :            :    where wchar_t is 64 bits, but only in a non-default mode, and there
     282                 :            :    would be no meaningful interpretation for a wchar_t value greater
     283                 :            :    than 2^32 anyway -- the widest wide-character encoding around is
     284                 :            :    ISO 10646, which stops at 2^31.  */
     285                 :            : #if CHAR_BIT * SIZEOF_INT >= 32
     286                 :            : # define CPPCHAR_SIGNED_T int
     287                 :            : #elif CHAR_BIT * SIZEOF_LONG >= 32
     288                 :            : # define CPPCHAR_SIGNED_T long
     289                 :            : #else
     290                 :            : # error "Cannot find a least-32-bit signed integer type"
     291                 :            : #endif
     292                 :            : typedef unsigned CPPCHAR_SIGNED_T cppchar_t;
     293                 :            : typedef CPPCHAR_SIGNED_T cppchar_signed_t;
     294                 :            : 
     295                 :            : /* Style of header dependencies to generate.  */
     296                 :            : enum cpp_deps_style { DEPS_NONE = 0, DEPS_USER, DEPS_SYSTEM };
     297                 :            : 
     298                 :            : /* The possible normalization levels, from most restrictive to least.  */
     299                 :            : enum cpp_normalize_level {
     300                 :            :   /* In NFKC.  */
     301                 :            :   normalized_KC = 0,
     302                 :            :   /* In NFC.  */
     303                 :            :   normalized_C,
     304                 :            :   /* In NFC, except for subsequences where being in NFC would make
     305                 :            :      the identifier invalid.  */
     306                 :            :   normalized_identifier_C,
     307                 :            :   /* Not normalized at all.  */
     308                 :            :   normalized_none
     309                 :            : };
     310                 :            : 
     311                 :            : /* This structure is nested inside struct cpp_reader, and
     312                 :            :    carries all the options visible to the command line.  */
     313                 :            : struct cpp_options
     314                 :            : {
     315                 :            :   /* Characters between tab stops.  */
     316                 :            :   unsigned int tabstop;
     317                 :            : 
     318                 :            :   /* The language we're preprocessing.  */
     319                 :            :   enum c_lang lang;
     320                 :            : 
     321                 :            :   /* Nonzero means use extra default include directories for C++.  */
     322                 :            :   unsigned char cplusplus;
     323                 :            : 
     324                 :            :   /* Nonzero means handle cplusplus style comments.  */
     325                 :            :   unsigned char cplusplus_comments;
     326                 :            : 
     327                 :            :   /* Nonzero means define __OBJC__, treat @ as a special token, use
     328                 :            :      the OBJC[PLUS]_INCLUDE_PATH environment variable, and allow
     329                 :            :      "#import".  */
     330                 :            :   unsigned char objc;
     331                 :            : 
     332                 :            :   /* Nonzero means don't copy comments into the output file.  */
     333                 :            :   unsigned char discard_comments;
     334                 :            : 
     335                 :            :   /* Nonzero means don't copy comments into the output file during
     336                 :            :      macro expansion.  */
     337                 :            :   unsigned char discard_comments_in_macro_exp;
     338                 :            : 
     339                 :            :   /* Nonzero means process the ISO trigraph sequences.  */
     340                 :            :   unsigned char trigraphs;
     341                 :            : 
     342                 :            :   /* Nonzero means process the ISO digraph sequences.  */
     343                 :            :   unsigned char digraphs;
     344                 :            : 
     345                 :            :   /* Nonzero means to allow hexadecimal floats and LL suffixes.  */
     346                 :            :   unsigned char extended_numbers;
     347                 :            : 
     348                 :            :   /* Nonzero means process u/U prefix literals (UTF-16/32).  */
     349                 :            :   unsigned char uliterals;
     350                 :            : 
     351                 :            :   /* Nonzero means process u8 prefixed character literals (UTF-8).  */
     352                 :            :   unsigned char utf8_char_literals;
     353                 :            : 
     354                 :            :   /* Nonzero means process r/R raw strings.  If this is set, uliterals
     355                 :            :      must be set as well.  */
     356                 :            :   unsigned char rliterals;
     357                 :            : 
     358                 :            :   /* Nonzero means print names of header files (-H).  */
     359                 :            :   unsigned char print_include_names;
     360                 :            : 
     361                 :            :   /* Nonzero means complain about deprecated features.  */
     362                 :            :   unsigned char cpp_warn_deprecated;
     363                 :            : 
     364                 :            :   /* Nonzero means warn if slash-star appears in a comment.  */
     365                 :            :   unsigned char warn_comments;
     366                 :            : 
     367                 :            :   /* Nonzero means to warn about __DATA__, __TIME__ and __TIMESTAMP__ usage.   */
     368                 :            :   unsigned char warn_date_time;
     369                 :            : 
     370                 :            :   /* Nonzero means warn if a user-supplied include directory does not
     371                 :            :      exist.  */
     372                 :            :   unsigned char warn_missing_include_dirs;
     373                 :            : 
     374                 :            :   /* Nonzero means warn if there are any trigraphs.  */
     375                 :            :   unsigned char warn_trigraphs;
     376                 :            : 
     377                 :            :   /* Nonzero means warn about multicharacter charconsts.  */
     378                 :            :   unsigned char warn_multichar;
     379                 :            : 
     380                 :            :   /* Nonzero means warn about various incompatibilities with
     381                 :            :      traditional C.  */
     382                 :            :   unsigned char cpp_warn_traditional;
     383                 :            : 
     384                 :            :   /* Nonzero means warn about long long numeric constants.  */
     385                 :            :   unsigned char cpp_warn_long_long;
     386                 :            : 
     387                 :            :   /* Nonzero means warn about text after an #endif (or #else).  */
     388                 :            :   unsigned char warn_endif_labels;
     389                 :            : 
     390                 :            :   /* Nonzero means warn about implicit sign changes owing to integer
     391                 :            :      promotions.  */
     392                 :            :   unsigned char warn_num_sign_change;
     393                 :            : 
     394                 :            :   /* Zero means don't warn about __VA_ARGS__ usage in c89 pedantic mode.
     395                 :            :      Presumably the usage is protected by the appropriate #ifdef.  */
     396                 :            :   unsigned char warn_variadic_macros;
     397                 :            : 
     398                 :            :   /* Nonzero means warn about builtin macros that are redefined or
     399                 :            :      explicitly undefined.  */
     400                 :            :   unsigned char warn_builtin_macro_redefined;
     401                 :            : 
     402                 :            :   /* Different -Wimplicit-fallthrough= levels.  */
     403                 :            :   unsigned char cpp_warn_implicit_fallthrough;
     404                 :            : 
     405                 :            :   /* Nonzero means we should look for header.gcc files that remap file
     406                 :            :      names.  */
     407                 :            :   unsigned char remap;
     408                 :            : 
     409                 :            :   /* Zero means dollar signs are punctuation.  */
     410                 :            :   unsigned char dollars_in_ident;
     411                 :            : 
     412                 :            :   /* Nonzero means UCNs are accepted in identifiers.  */
     413                 :            :   unsigned char extended_identifiers;
     414                 :            : 
     415                 :            :   /* True if we should warn about dollars in identifiers or numbers
     416                 :            :      for this translation unit.  */
     417                 :            :   unsigned char warn_dollars;
     418                 :            : 
     419                 :            :   /* Nonzero means warn if undefined identifiers are evaluated in an #if.  */
     420                 :            :   unsigned char warn_undef;
     421                 :            : 
     422                 :            :   /* Nonzero means warn if "defined" is encountered in a place other than
     423                 :            :      an #if.  */
     424                 :            :   unsigned char warn_expansion_to_defined;
     425                 :            : 
     426                 :            :   /* Nonzero means warn of unused macros from the main file.  */
     427                 :            :   unsigned char warn_unused_macros;
     428                 :            : 
     429                 :            :   /* Nonzero for the 1999 C Standard, including corrigenda and amendments.  */
     430                 :            :   unsigned char c99;
     431                 :            : 
     432                 :            :   /* Nonzero if we are conforming to a specific C or C++ standard.  */
     433                 :            :   unsigned char std;
     434                 :            : 
     435                 :            :   /* Nonzero means give all the error messages the ANSI standard requires.  */
     436                 :            :   unsigned char cpp_pedantic;
     437                 :            : 
     438                 :            :   /* Nonzero means we're looking at already preprocessed code, so don't
     439                 :            :      bother trying to do macro expansion and whatnot.  */
     440                 :            :   unsigned char preprocessed;
     441                 :            :   
     442                 :            :   /* Nonzero means we are going to emit debugging logs during
     443                 :            :      preprocessing.  */
     444                 :            :   unsigned char debug;
     445                 :            : 
     446                 :            :   /* Nonzero means we are tracking locations of tokens involved in
     447                 :            :      macro expansion. 1 Means we track the location in degraded mode
     448                 :            :      where we do not track locations of tokens resulting from the
     449                 :            :      expansion of arguments of function-like macro.  2 Means we do
     450                 :            :      track all macro expansions. This last option is the one that
     451                 :            :      consumes the highest amount of memory.  */
     452                 :            :   unsigned char track_macro_expansion;
     453                 :            : 
     454                 :            :   /* Nonzero means handle C++ alternate operator names.  */
     455                 :            :   unsigned char operator_names;
     456                 :            : 
     457                 :            :   /* Nonzero means warn about use of C++ alternate operator names.  */
     458                 :            :   unsigned char warn_cxx_operator_names;
     459                 :            : 
     460                 :            :   /* True for traditional preprocessing.  */
     461                 :            :   unsigned char traditional;
     462                 :            : 
     463                 :            :   /* Nonzero for C++ 2011 Standard user-defined literals.  */
     464                 :            :   unsigned char user_literals;
     465                 :            : 
     466                 :            :   /* Nonzero means warn when a string or character literal is followed by a
     467                 :            :      ud-suffix which does not beging with an underscore.  */
     468                 :            :   unsigned char warn_literal_suffix;
     469                 :            : 
     470                 :            :   /* Nonzero means interpret imaginary, fixed-point, or other gnu extension
     471                 :            :      literal number suffixes as user-defined literal number suffixes.  */
     472                 :            :   unsigned char ext_numeric_literals;
     473                 :            : 
     474                 :            :   /* Nonzero means extended identifiers allow the characters specified
     475                 :            :      in C11 and C++11.  */
     476                 :            :   unsigned char c11_identifiers;
     477                 :            : 
     478                 :            :   /* Nonzero for C++ 2014 Standard binary constants.  */
     479                 :            :   unsigned char binary_constants;
     480                 :            : 
     481                 :            :   /* Nonzero for C++ 2014 Standard digit separators.  */
     482                 :            :   unsigned char digit_separators;
     483                 :            : 
     484                 :            :   /* Nonzero for C2X decimal floating-point constants.  */
     485                 :            :   unsigned char dfp_constants;
     486                 :            : 
     487                 :            :   /* Nonzero for C++20 __VA_OPT__ feature.  */
     488                 :            :   unsigned char va_opt;
     489                 :            : 
     490                 :            :   /* Nonzero for the '::' token.  */
     491                 :            :   unsigned char scope;
     492                 :            : 
     493                 :            :   /* Holds the name of the target (execution) character set.  */
     494                 :            :   const char *narrow_charset;
     495                 :            : 
     496                 :            :   /* Holds the name of the target wide character set.  */
     497                 :            :   const char *wide_charset;
     498                 :            : 
     499                 :            :   /* Holds the name of the input character set.  */
     500                 :            :   const char *input_charset;
     501                 :            : 
     502                 :            :   /* The minimum permitted level of normalization before a warning
     503                 :            :      is generated.  See enum cpp_normalize_level.  */
     504                 :            :   int warn_normalize;
     505                 :            : 
     506                 :            :   /* True to warn about precompiled header files we couldn't use.  */
     507                 :            :   bool warn_invalid_pch;
     508                 :            : 
     509                 :            :   /* True if dependencies should be restored from a precompiled header.  */
     510                 :            :   bool restore_pch_deps;
     511                 :            : 
     512                 :            :   /* True if warn about differences between C90 and C99.  */
     513                 :            :   signed char cpp_warn_c90_c99_compat;
     514                 :            : 
     515                 :            :   /* True if warn about differences between C11 and C2X.  */
     516                 :            :   signed char cpp_warn_c11_c2x_compat;
     517                 :            : 
     518                 :            :   /* True if warn about differences between C++98 and C++11.  */
     519                 :            :   bool cpp_warn_cxx11_compat;
     520                 :            : 
     521                 :            :   /* Dependency generation.  */
     522                 :            :   struct
     523                 :            :   {
     524                 :            :     /* Style of header dependencies to generate.  */
     525                 :            :     enum cpp_deps_style style;
     526                 :            : 
     527                 :            :     /* Assume missing files are generated files.  */
     528                 :            :     bool missing_files;
     529                 :            : 
     530                 :            :     /* Generate phony targets for each dependency apart from the first
     531                 :            :        one.  */
     532                 :            :     bool phony_targets;
     533                 :            : 
     534                 :            :     /* If true, no dependency is generated on the main file.  */
     535                 :            :     bool ignore_main_file;
     536                 :            : 
     537                 :            :     /* If true, intend to use the preprocessor output (e.g., for compilation)
     538                 :            :        in addition to the dependency info.  */
     539                 :            :     bool need_preprocessor_output;
     540                 :            :   } deps;
     541                 :            : 
     542                 :            :   /* Target-specific features set by the front end or client.  */
     543                 :            : 
     544                 :            :   /* Precision for target CPP arithmetic, target characters, target
     545                 :            :      ints and target wide characters, respectively.  */
     546                 :            :   size_t precision, char_precision, int_precision, wchar_precision;
     547                 :            : 
     548                 :            :   /* True means chars (wide chars) are unsigned.  */
     549                 :            :   bool unsigned_char, unsigned_wchar;
     550                 :            : 
     551                 :            :   /* True if the most significant byte in a word has the lowest
     552                 :            :      address in memory.  */
     553                 :            :   bool bytes_big_endian;
     554                 :            : 
     555                 :            :   /* Nonzero means __STDC__ should have the value 0 in system headers.  */
     556                 :            :   unsigned char stdc_0_in_system_headers;
     557                 :            : 
     558                 :            :   /* True disables tokenization outside of preprocessing directives. */
     559                 :            :   bool directives_only;
     560                 :            : 
     561                 :            :   /* True enables canonicalization of system header file paths. */
     562                 :            :   bool canonical_system_headers;
     563                 :            : 
     564                 :            :   /* The maximum depth of the nested #include.  */
     565                 :            :   unsigned int max_include_depth;
     566                 :            : };
     567                 :            : 
     568                 :            : /* Diagnostic levels.  To get a diagnostic without associating a
     569                 :            :    position in the translation unit with it, use cpp_error_with_line
     570                 :            :    with a line number of zero.  */
     571                 :            : 
     572                 :            : enum cpp_diagnostic_level {
     573                 :            :   /* Warning, an error with -Werror.  */
     574                 :            :   CPP_DL_WARNING = 0,
     575                 :            :   /* Same as CPP_DL_WARNING, except it is not suppressed in system headers.  */
     576                 :            :   CPP_DL_WARNING_SYSHDR,
     577                 :            :   /* Warning, an error with -pedantic-errors or -Werror.  */
     578                 :            :   CPP_DL_PEDWARN,
     579                 :            :   /* An error.  */
     580                 :            :   CPP_DL_ERROR,
     581                 :            :   /* An internal consistency check failed.  Prints "internal error: ",
     582                 :            :      otherwise the same as CPP_DL_ERROR.  */
     583                 :            :   CPP_DL_ICE,
     584                 :            :   /* An informative note following a warning.  */
     585                 :            :   CPP_DL_NOTE,
     586                 :            :   /* A fatal error.  */
     587                 :            :   CPP_DL_FATAL
     588                 :            : };
     589                 :            : 
     590                 :            : /* Warning reason codes. Use a reason code of CPP_W_NONE for unclassified
     591                 :            :    warnings and diagnostics that are not warnings.  */
     592                 :            : 
     593                 :            : enum cpp_warning_reason {
     594                 :            :   CPP_W_NONE = 0,
     595                 :            :   CPP_W_DEPRECATED,
     596                 :            :   CPP_W_COMMENTS,
     597                 :            :   CPP_W_MISSING_INCLUDE_DIRS,
     598                 :            :   CPP_W_TRIGRAPHS,
     599                 :            :   CPP_W_MULTICHAR,
     600                 :            :   CPP_W_TRADITIONAL,
     601                 :            :   CPP_W_LONG_LONG,
     602                 :            :   CPP_W_ENDIF_LABELS,
     603                 :            :   CPP_W_NUM_SIGN_CHANGE,
     604                 :            :   CPP_W_VARIADIC_MACROS,
     605                 :            :   CPP_W_BUILTIN_MACRO_REDEFINED,
     606                 :            :   CPP_W_DOLLARS,
     607                 :            :   CPP_W_UNDEF,
     608                 :            :   CPP_W_UNUSED_MACROS,
     609                 :            :   CPP_W_CXX_OPERATOR_NAMES,
     610                 :            :   CPP_W_NORMALIZE,
     611                 :            :   CPP_W_INVALID_PCH,
     612                 :            :   CPP_W_WARNING_DIRECTIVE,
     613                 :            :   CPP_W_LITERAL_SUFFIX,
     614                 :            :   CPP_W_DATE_TIME,
     615                 :            :   CPP_W_PEDANTIC,
     616                 :            :   CPP_W_C90_C99_COMPAT,
     617                 :            :   CPP_W_C11_C2X_COMPAT,
     618                 :            :   CPP_W_CXX11_COMPAT,
     619                 :            :   CPP_W_EXPANSION_TO_DEFINED
     620                 :            : };
     621                 :            : 
     622                 :            : /* Callback for header lookup for HEADER, which is the name of a
     623                 :            :    source file.  It is used as a method of last resort to find headers
     624                 :            :    that are not otherwise found during the normal include processing.
     625                 :            :    The return value is the malloced name of a header to try and open,
     626                 :            :    if any, or NULL otherwise.  This callback is called only if the
     627                 :            :    header is otherwise unfound.  */
     628                 :            : typedef const char *(*missing_header_cb)(cpp_reader *, const char *header, cpp_dir **);
     629                 :            : 
     630                 :            : /* Call backs to cpplib client.  */
     631                 :            : struct cpp_callbacks
     632                 :            : {
     633                 :            :   /* Called when a new line of preprocessed output is started.  */
     634                 :            :   void (*line_change) (cpp_reader *, const cpp_token *, int);
     635                 :            : 
     636                 :            :   /* Called when switching to/from a new file.
     637                 :            :      The line_map is for the new file.  It is NULL if there is no new file.
     638                 :            :      (In C this happens when done with <built-in>+<command line> and also
     639                 :            :      when done with a main file.)  This can be used for resource cleanup.  */
     640                 :            :   void (*file_change) (cpp_reader *, const line_map_ordinary *);
     641                 :            : 
     642                 :            :   void (*dir_change) (cpp_reader *, const char *);
     643                 :            :   void (*include) (cpp_reader *, location_t, const unsigned char *,
     644                 :            :                    const char *, int, const cpp_token **);
     645                 :            :   void (*define) (cpp_reader *, location_t, cpp_hashnode *);
     646                 :            :   void (*undef) (cpp_reader *, location_t, cpp_hashnode *);
     647                 :            :   void (*ident) (cpp_reader *, location_t, const cpp_string *);
     648                 :            :   void (*def_pragma) (cpp_reader *, location_t);
     649                 :            :   int (*valid_pch) (cpp_reader *, const char *, int);
     650                 :            :   void (*read_pch) (cpp_reader *, const char *, int, const char *);
     651                 :            :   missing_header_cb missing_header;
     652                 :            : 
     653                 :            :   /* Context-sensitive macro support.  Returns macro (if any) that should
     654                 :            :      be expanded.  */
     655                 :            :   cpp_hashnode * (*macro_to_expand) (cpp_reader *, const cpp_token *);
     656                 :            : 
     657                 :            :   /* Called to emit a diagnostic.  This callback receives the
     658                 :            :      translated message.  */
     659                 :            :   bool (*diagnostic) (cpp_reader *,
     660                 :            :                       enum cpp_diagnostic_level,
     661                 :            :                       enum cpp_warning_reason,
     662                 :            :                       rich_location *,
     663                 :            :                       const char *, va_list *)
     664                 :            :        ATTRIBUTE_FPTR_PRINTF(5,0);
     665                 :            : 
     666                 :            :   /* Callbacks for when a macro is expanded, or tested (whether
     667                 :            :      defined or not at the time) in #ifdef, #ifndef or "defined".  */
     668                 :            :   void (*used_define) (cpp_reader *, location_t, cpp_hashnode *);
     669                 :            :   void (*used_undef) (cpp_reader *, location_t, cpp_hashnode *);
     670                 :            :   /* Called before #define and #undef or other macro definition
     671                 :            :      changes are processed.  */
     672                 :            :   void (*before_define) (cpp_reader *);
     673                 :            :   /* Called whenever a macro is expanded or tested.
     674                 :            :      Second argument is the location of the start of the current expansion.  */
     675                 :            :   void (*used) (cpp_reader *, location_t, cpp_hashnode *);
     676                 :            : 
     677                 :            :   /* Callback to identify whether an attribute exists.  */
     678                 :            :   int (*has_attribute) (cpp_reader *);
     679                 :            : 
     680                 :            :   /* Callback to determine whether a built-in function is recognized.  */
     681                 :            :   int (*has_builtin) (cpp_reader *);
     682                 :            : 
     683                 :            :   /* Callback that can change a user lazy into normal macro.  */
     684                 :            :   void (*user_lazy_macro) (cpp_reader *, cpp_macro *, unsigned);
     685                 :            : 
     686                 :            :   /* Callback to parse SOURCE_DATE_EPOCH from environment.  */
     687                 :            :   time_t (*get_source_date_epoch) (cpp_reader *);
     688                 :            : 
     689                 :            :   /* Callback for providing suggestions for misspelled directives.  */
     690                 :            :   const char *(*get_suggestion) (cpp_reader *, const char *, const char *const *);
     691                 :            : 
     692                 :            :   /* Callback for when a comment is encountered, giving the location
     693                 :            :      of the opening slash, a pointer to the content (which is not
     694                 :            :      necessarily 0-terminated), and the length of the content.
     695                 :            :      The content contains the opening slash-star (or slash-slash),
     696                 :            :      and for C-style comments contains the closing star-slash.  For
     697                 :            :      C++-style comments it does not include the terminating newline.  */
     698                 :            :   void (*comment) (cpp_reader *, location_t, const unsigned char *,
     699                 :            :                    size_t);
     700                 :            : 
     701                 :            :   /* Callback for filename remapping in __FILE__ and __BASE_FILE__ macro
     702                 :            :      expansions.  */
     703                 :            :   const char *(*remap_filename) (const char*);
     704                 :            : };
     705                 :            : 
     706                 :            : #ifdef VMS
     707                 :            : #define INO_T_CPP ino_t ino[3]
     708                 :            : #else
     709                 :            : #define INO_T_CPP ino_t ino
     710                 :            : #endif
     711                 :            : 
     712                 :            : /* Chain of directories to look for include files in.  */
     713                 :            : struct cpp_dir
     714                 :            : {
     715                 :            :   /* NULL-terminated singly-linked list.  */
     716                 :            :   struct cpp_dir *next;
     717                 :            : 
     718                 :            :   /* NAME of the directory, NUL-terminated.  */
     719                 :            :   char *name;
     720                 :            :   unsigned int len;
     721                 :            : 
     722                 :            :   /* One if a system header, two if a system header that has extern
     723                 :            :      "C" guards for C++.  */
     724                 :            :   unsigned char sysp;
     725                 :            : 
     726                 :            :   /* Is this a user-supplied directory? */
     727                 :            :   bool user_supplied_p;
     728                 :            : 
     729                 :            :   /* The canonicalized NAME as determined by lrealpath.  This field 
     730                 :            :      is only used by hosts that lack reliable inode numbers.  */
     731                 :            :   char *canonical_name;
     732                 :            : 
     733                 :            :   /* Mapping of file names for this directory for MS-DOS and related
     734                 :            :      platforms.  A NULL-terminated array of (from, to) pairs.  */
     735                 :            :   const char **name_map;
     736                 :            : 
     737                 :            :   /* Routine to construct pathname, given the search path name and the
     738                 :            :      HEADER we are trying to find, return a constructed pathname to
     739                 :            :      try and open.  If this is NULL, the constructed pathname is as
     740                 :            :      constructed by append_file_to_dir.  */
     741                 :            :   char *(*construct) (const char *header, cpp_dir *dir);
     742                 :            : 
     743                 :            :   /* The C front end uses these to recognize duplicated
     744                 :            :      directories in the search path.  */
     745                 :            :   INO_T_CPP;
     746                 :            :   dev_t dev;
     747                 :            : };
     748                 :            : 
     749                 :            : /* The kind of the cpp_macro.  */
     750                 :            : enum cpp_macro_kind {
     751                 :            :   cmk_macro,    /* An ISO macro (token expansion).  */
     752                 :            :   cmk_assert,   /* An assertion.  */
     753                 :            :   cmk_traditional       /* A traditional macro (text expansion).  */
     754                 :            : };
     755                 :            : 
     756                 :            : /* Each macro definition is recorded in a cpp_macro structure.
     757                 :            :    Variadic macros cannot occur with traditional cpp.  */
     758                 :            : struct GTY(()) cpp_macro {
     759                 :            :   union cpp_parm_u 
     760                 :            :   {
     761                 :            :     /* Parameters, if any.  If parameter names use extended identifiers,
     762                 :            :        the original spelling of those identifiers, not the canonical
     763                 :            :        UTF-8 spelling, goes here.  */
     764                 :            :     cpp_hashnode ** GTY ((tag ("false"),
     765                 :            :                           nested_ptr (union tree_node,
     766                 :            :         "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
     767                 :            :         "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL"),
     768                 :            :                           length ("%1.paramc"))) params;
     769                 :            : 
     770                 :            :     /* If this is an assertion, the next one in the chain.  */
     771                 :            :     cpp_macro *GTY ((tag ("true"))) next;
     772                 :            :   } GTY ((desc ("%1.kind == cmk_assert"))) parm;
     773                 :            : 
     774                 :            :   /* Definition line number.  */
     775                 :            :   location_t line;
     776                 :            : 
     777                 :            :   /* Number of tokens in body, or bytes for traditional macros.  */
     778                 :            :   /* Do we really need 2^32-1 range here?  */
     779                 :            :   unsigned int count;
     780                 :            : 
     781                 :            :   /* Number of parameters.  */
     782                 :            :   unsigned short paramc;
     783                 :            : 
     784                 :            :   /* Non-zero if this is a user-lazy macro, value provided by user.  */
     785                 :            :   unsigned char lazy;
     786                 :            : 
     787                 :            :   /* The kind of this macro (ISO, trad or assert) */
     788                 :            :   unsigned kind : 2;
     789                 :            : 
     790                 :            :   /* If a function-like macro.  */
     791                 :            :   unsigned int fun_like : 1;
     792                 :            : 
     793                 :            :   /* If a variadic macro.  */
     794                 :            :   unsigned int variadic : 1;
     795                 :            : 
     796                 :            :   /* If macro defined in system header.  */
     797                 :            :   unsigned int syshdr   : 1;
     798                 :            : 
     799                 :            :   /* Nonzero if it has been expanded or had its existence tested.  */
     800                 :            :   unsigned int used     : 1;
     801                 :            : 
     802                 :            :   /* Indicate whether the tokens include extra CPP_PASTE tokens at the
     803                 :            :      end to track invalid redefinitions with consecutive CPP_PASTE
     804                 :            :      tokens.  */
     805                 :            :   unsigned int extra_tokens : 1;
     806                 :            : 
     807                 :            :   /* 1 bits spare (32-bit). 33 on 64-bit target.  */
     808                 :            : 
     809                 :            :   union cpp_exp_u
     810                 :            :   {
     811                 :            :     /* Trailing array of replacement tokens (ISO), or assertion body value.  */
     812                 :            :     cpp_token GTY ((tag ("false"), length ("%1.count"))) tokens[1];
     813                 :            : 
     814                 :            :     /* Pointer to replacement text (traditional).  See comment at top
     815                 :            :        of cpptrad.c for how traditional function-like macros are
     816                 :            :        encoded.  */
     817                 :            :     const unsigned char *GTY ((tag ("true"))) text;
     818                 :            :   } GTY ((desc ("%1.kind == cmk_traditional"))) exp;
     819                 :            : };
     820                 :            : 
     821                 :            : /* Poisoned identifiers are flagged NODE_POISONED.  NODE_OPERATOR (C++
     822                 :            :    only) indicates an identifier that behaves like an operator such as
     823                 :            :    "xor".  NODE_DIAGNOSTIC is for speed in lex_token: it indicates a
     824                 :            :    diagnostic may be required for this node.  Currently this only
     825                 :            :    applies to __VA_ARGS__, poisoned identifiers, and -Wc++-compat
     826                 :            :    warnings about NODE_OPERATOR.  */
     827                 :            : 
     828                 :            : /* Hash node flags.  */
     829                 :            : #define NODE_OPERATOR   (1 << 0)  /* C++ named operator.  */
     830                 :            : #define NODE_POISONED   (1 << 1)  /* Poisoned identifier.  */
     831                 :            : #define NODE_DIAGNOSTIC (1 << 2)  /* Possible diagnostic when lexed.  */
     832                 :            : #define NODE_WARN       (1 << 3)  /* Warn if redefined or undefined.  */
     833                 :            : #define NODE_DISABLED   (1 << 4)  /* A disabled macro.  */
     834                 :            : #define NODE_USED       (1 << 5)  /* Dumped with -dU.  */
     835                 :            : #define NODE_CONDITIONAL (1 << 6) /* Conditional macro */
     836                 :            : #define NODE_WARN_OPERATOR (1 << 7)       /* Warn about C++ named operator.  */
     837                 :            : 
     838                 :            : /* Different flavors of hash node.  */
     839                 :            : enum node_type
     840                 :            : {
     841                 :            :   NT_VOID = 0,     /* Maybe an assert?  */
     842                 :            :   NT_MACRO_ARG,    /* A macro arg.  */
     843                 :            :   NT_USER_MACRO,   /* A user macro.  */
     844                 :            :   NT_BUILTIN_MACRO, /* A builtin macro.  */
     845                 :            :   NT_MACRO_MASK = NT_USER_MACRO  /* Mask for either macro kind.  */
     846                 :            : };
     847                 :            : 
     848                 :            : /* Different flavors of builtin macro.  _Pragma is an operator, but we
     849                 :            :    handle it with the builtin code for efficiency reasons.  */
     850                 :            : enum cpp_builtin_type
     851                 :            : {
     852                 :            :   BT_SPECLINE = 0,              /* `__LINE__' */
     853                 :            :   BT_DATE,                      /* `__DATE__' */
     854                 :            :   BT_FILE,                      /* `__FILE__' */
     855                 :            :   BT_BASE_FILE,                 /* `__BASE_FILE__' */
     856                 :            :   BT_INCLUDE_LEVEL,             /* `__INCLUDE_LEVEL__' */
     857                 :            :   BT_TIME,                      /* `__TIME__' */
     858                 :            :   BT_STDC,                      /* `__STDC__' */
     859                 :            :   BT_PRAGMA,                    /* `_Pragma' operator */
     860                 :            :   BT_TIMESTAMP,                 /* `__TIMESTAMP__' */
     861                 :            :   BT_COUNTER,                   /* `__COUNTER__' */
     862                 :            :   BT_HAS_ATTRIBUTE,             /* `__has_attribute(x)' */
     863                 :            :   BT_HAS_BUILTIN,               /* `__has_builtin(x)' */
     864                 :            :   BT_HAS_INCLUDE,               /* `__has_include(x)' */
     865                 :            :   BT_HAS_INCLUDE_NEXT           /* `__has_include_next(x)' */
     866                 :            : };
     867                 :            : 
     868                 :            : #define CPP_HASHNODE(HNODE)     ((cpp_hashnode *) (HNODE))
     869                 :            : #define HT_NODE(NODE)           (&(NODE)->ident)
     870                 :            : #define NODE_LEN(NODE)          HT_LEN (HT_NODE (NODE))
     871                 :            : #define NODE_NAME(NODE)         HT_STR (HT_NODE (NODE))
     872                 :            : 
     873                 :            : /* The common part of an identifier node shared amongst all 3 C front
     874                 :            :    ends.  Also used to store CPP identifiers, which are a superset of
     875                 :            :    identifiers in the grammatical sense.  */
     876                 :            : 
     877                 :            : union GTY(()) _cpp_hashnode_value {
     878                 :            :   /* Assert (maybe NULL) */
     879                 :            :   cpp_macro * GTY((tag ("NT_VOID"))) answers;
     880                 :            :   /* Macro (never NULL) */
     881                 :            :   cpp_macro * GTY((tag ("NT_USER_MACRO"))) macro;
     882                 :            :   /* Code for a builtin macro.  */
     883                 :            :   enum cpp_builtin_type GTY ((tag ("NT_BUILTIN_MACRO"))) builtin;
     884                 :            :   /* Macro argument index.  */
     885                 :            :   unsigned short GTY ((tag ("NT_MACRO_ARG"))) arg_index;
     886                 :            : };
     887                 :            : 
     888                 :            : struct GTY(()) cpp_hashnode {
     889                 :            :   struct ht_identifier ident;
     890                 :            :   unsigned int is_directive : 1;
     891                 :            :   unsigned int directive_index : 7;     /* If is_directive,
     892                 :            :                                            then index into directive table.
     893                 :            :                                            Otherwise, a NODE_OPERATOR.  */
     894                 :            :   unsigned char rid_code;               /* Rid code - for front ends.  */
     895                 :            :   ENUM_BITFIELD(node_type) type : 2;    /* CPP node type.  */
     896                 :            :   unsigned int flags : 8;               /* CPP flags.  */
     897                 :            : 
     898                 :            :   /* 6 bits spare (plus another 32 on 64-bit hosts).  */
     899                 :            : 
     900                 :            :   union _cpp_hashnode_value GTY ((desc ("%1.type"))) value;
     901                 :            : };
     902                 :            : 
     903                 :            : /* A class for iterating through the source locations within a
     904                 :            :    string token (before escapes are interpreted, and before
     905                 :            :    concatenation).  */
     906                 :            : 
     907                 :            : class cpp_string_location_reader {
     908                 :            :  public:
     909                 :            :   cpp_string_location_reader (location_t src_loc,
     910                 :            :                               line_maps *line_table);
     911                 :            : 
     912                 :            :   source_range get_next ();
     913                 :            : 
     914                 :            :  private:
     915                 :            :   location_t m_loc;
     916                 :            :   int m_offset_per_column;
     917                 :            : };
     918                 :            : 
     919                 :            : /* A class for storing the source ranges of all of the characters within
     920                 :            :    a string literal, after escapes are interpreted, and after
     921                 :            :    concatenation.
     922                 :            : 
     923                 :            :    This is not GTY-marked, as instances are intended to be temporary.  */
     924                 :            : 
     925                 :            : class cpp_substring_ranges
     926                 :            : {
     927                 :            :  public:
     928                 :            :   cpp_substring_ranges ();
     929                 :            :   ~cpp_substring_ranges ();
     930                 :            : 
     931                 :      16393 :   int get_num_ranges () const { return m_num_ranges; }
     932                 :      29731 :   source_range get_range (int idx) const
     933                 :            :   {
     934                 :      29731 :     linemap_assert (idx < m_num_ranges);
     935                 :      29731 :     return m_ranges[idx];
     936                 :            :   }
     937                 :            : 
     938                 :            :   void add_range (source_range range);
     939                 :            :   void add_n_ranges (int num, cpp_string_location_reader &loc_reader);
     940                 :            : 
     941                 :            :  private:
     942                 :            :   source_range *m_ranges;
     943                 :            :   int m_num_ranges;
     944                 :            :   int m_alloc_ranges;
     945                 :            : };
     946                 :            : 
     947                 :            : /* Call this first to get a handle to pass to other functions.
     948                 :            : 
     949                 :            :    If you want cpplib to manage its own hashtable, pass in a NULL
     950                 :            :    pointer.  Otherwise you should pass in an initialized hash table
     951                 :            :    that cpplib will share; this technique is used by the C front
     952                 :            :    ends.  */
     953                 :            : extern cpp_reader *cpp_create_reader (enum c_lang, struct ht *,
     954                 :            :                                       class line_maps *);
     955                 :            : 
     956                 :            : /* Reset the cpp_reader's line_map.  This is only used after reading a
     957                 :            :    PCH file.  */
     958                 :            : extern void cpp_set_line_map (cpp_reader *, class line_maps *);
     959                 :            : 
     960                 :            : /* Call this to change the selected language standard (e.g. because of
     961                 :            :    command line options).  */
     962                 :            : extern void cpp_set_lang (cpp_reader *, enum c_lang);
     963                 :            : 
     964                 :            : /* Set the include paths.  */
     965                 :            : extern void cpp_set_include_chains (cpp_reader *, cpp_dir *, cpp_dir *, int);
     966                 :            : 
     967                 :            : /* Call these to get pointers to the options, callback, and deps
     968                 :            :    structures for a given reader.  These pointers are good until you
     969                 :            :    call cpp_finish on that reader.  You can either edit the callbacks
     970                 :            :    through the pointer returned from cpp_get_callbacks, or set them
     971                 :            :    with cpp_set_callbacks.  */
     972                 :            : extern cpp_options *cpp_get_options (cpp_reader *) ATTRIBUTE_PURE;
     973                 :            : extern cpp_callbacks *cpp_get_callbacks (cpp_reader *) ATTRIBUTE_PURE;
     974                 :            : extern void cpp_set_callbacks (cpp_reader *, cpp_callbacks *);
     975                 :            : extern class mkdeps *cpp_get_deps (cpp_reader *) ATTRIBUTE_PURE;
     976                 :            : 
     977                 :            : /* This function reads the file, but does not start preprocessing.  It
     978                 :            :    returns the name of the original file; this is the same as the
     979                 :            :    input file, except for preprocessed input.  This will generate at
     980                 :            :    least one file change callback, and possibly a line change callback
     981                 :            :    too.  If there was an error opening the file, it returns NULL.  */
     982                 :            : extern const char *cpp_read_main_file (cpp_reader *, const char *);
     983                 :            : 
     984                 :            : /* Set up built-ins with special behavior.  Use cpp_init_builtins()
     985                 :            :    instead unless your know what you are doing.  */
     986                 :            : extern void cpp_init_special_builtins (cpp_reader *);
     987                 :            : 
     988                 :            : /* Set up built-ins like __FILE__.  */
     989                 :            : extern void cpp_init_builtins (cpp_reader *, int);
     990                 :            : 
     991                 :            : /* This is called after options have been parsed, and partially
     992                 :            :    processed.  */
     993                 :            : extern void cpp_post_options (cpp_reader *);
     994                 :            : 
     995                 :            : /* Set up translation to the target character set.  */
     996                 :            : extern void cpp_init_iconv (cpp_reader *);
     997                 :            : 
     998                 :            : /* Call this to finish preprocessing.  If you requested dependency
     999                 :            :    generation, pass an open stream to write the information to,
    1000                 :            :    otherwise NULL.  It is your responsibility to close the stream.  */
    1001                 :            : extern void cpp_finish (cpp_reader *, FILE *deps_stream);
    1002                 :            : 
    1003                 :            : /* Call this to release the handle at the end of preprocessing.  Any
    1004                 :            :    use of the handle after this function returns is invalid.  */
    1005                 :            : extern void cpp_destroy (cpp_reader *);
    1006                 :            : 
    1007                 :            : extern unsigned int cpp_token_len (const cpp_token *);
    1008                 :            : extern unsigned char *cpp_token_as_text (cpp_reader *, const cpp_token *);
    1009                 :            : extern unsigned char *cpp_spell_token (cpp_reader *, const cpp_token *,
    1010                 :            :                                        unsigned char *, bool);
    1011                 :            : extern void cpp_register_pragma (cpp_reader *, const char *, const char *,
    1012                 :            :                                  void (*) (cpp_reader *), bool);
    1013                 :            : extern void cpp_register_deferred_pragma (cpp_reader *, const char *,
    1014                 :            :                                           const char *, unsigned, bool, bool);
    1015                 :            : extern int cpp_avoid_paste (cpp_reader *, const cpp_token *,
    1016                 :            :                             const cpp_token *);
    1017                 :            : extern const cpp_token *cpp_get_token (cpp_reader *);
    1018                 :            : extern const cpp_token *cpp_get_token_with_location (cpp_reader *,
    1019                 :            :                                                      location_t *);
    1020                 :    3484925 : inline bool cpp_user_macro_p (const cpp_hashnode *node)
    1021                 :            : {
    1022                 :    3484925 :   return node->type == NT_USER_MACRO;
    1023                 :            : }
    1024                 :            : inline bool cpp_builtin_macro_p (const cpp_hashnode *node)
    1025                 :            : {
    1026                 :            :   return node->type == NT_BUILTIN_MACRO;
    1027                 :            : }
    1028                 :   15582204 : inline bool cpp_macro_p (const cpp_hashnode *node)
    1029                 :            : {
    1030                 :   15582204 :   return node->type & NT_MACRO_MASK;
    1031                 :            : }
    1032                 :            : 
    1033                 :            : /* Returns true if NODE is a function-like user macro.  */
    1034                 :         64 : inline bool cpp_fun_like_macro_p (cpp_hashnode *node)
    1035                 :            : {
    1036                 :         64 :   return cpp_user_macro_p (node) && node->value.macro->fun_like;
    1037                 :            : }
    1038                 :            : 
    1039                 :            : extern const unsigned char *cpp_macro_definition (cpp_reader *,
    1040                 :            :                                                   cpp_hashnode *);
    1041                 :         82 : inline location_t cpp_macro_definition_location (cpp_hashnode *node)
    1042                 :            : {
    1043                 :         82 :   return node->value.macro->line;
    1044                 :            : }
    1045                 :            : extern void _cpp_backup_tokens (cpp_reader *, unsigned int);
    1046                 :            : extern const cpp_token *cpp_peek_token (cpp_reader *, int);
    1047                 :            : 
    1048                 :            : /* Evaluate a CPP_*CHAR* token.  */
    1049                 :            : extern cppchar_t cpp_interpret_charconst (cpp_reader *, const cpp_token *,
    1050                 :            :                                           unsigned int *, int *);
    1051                 :            : /* Evaluate a vector of CPP_*STRING* tokens.  */
    1052                 :            : extern bool cpp_interpret_string (cpp_reader *,
    1053                 :            :                                   const cpp_string *, size_t,
    1054                 :            :                                   cpp_string *, enum cpp_ttype);
    1055                 :            : extern const char *cpp_interpret_string_ranges (cpp_reader *pfile,
    1056                 :            :                                                 const cpp_string *from,
    1057                 :            :                                                 cpp_string_location_reader *,
    1058                 :            :                                                 size_t count,
    1059                 :            :                                                 cpp_substring_ranges *out,
    1060                 :            :                                                 enum cpp_ttype type);
    1061                 :            : extern bool cpp_interpret_string_notranslate (cpp_reader *,
    1062                 :            :                                               const cpp_string *, size_t,
    1063                 :            :                                               cpp_string *, enum cpp_ttype);
    1064                 :            : 
    1065                 :            : /* Convert a host character constant to the execution character set.  */
    1066                 :            : extern cppchar_t cpp_host_to_exec_charset (cpp_reader *, cppchar_t);
    1067                 :            : 
    1068                 :            : /* Used to register macros and assertions, perhaps from the command line.
    1069                 :            :    The text is the same as the command line argument.  */
    1070                 :            : extern void cpp_define (cpp_reader *, const char *);
    1071                 :            : extern void cpp_define_formatted (cpp_reader *pfile, 
    1072                 :            :                                   const char *fmt, ...) ATTRIBUTE_PRINTF_2;
    1073                 :            : extern void cpp_assert (cpp_reader *, const char *);
    1074                 :            : extern void cpp_undef (cpp_reader *, const char *);
    1075                 :            : extern void cpp_unassert (cpp_reader *, const char *);
    1076                 :            : 
    1077                 :            : /* Mark a node as a lazily defined macro.  */
    1078                 :            : extern void cpp_define_lazily (cpp_reader *, cpp_hashnode *node, unsigned N);
    1079                 :            : 
    1080                 :            : /* Undefine all macros and assertions.  */
    1081                 :            : extern void cpp_undef_all (cpp_reader *);
    1082                 :            : 
    1083                 :            : extern cpp_buffer *cpp_push_buffer (cpp_reader *, const unsigned char *,
    1084                 :            :                                     size_t, int);
    1085                 :            : extern int cpp_defined (cpp_reader *, const unsigned char *, int);
    1086                 :            : 
    1087                 :            : /* A preprocessing number.  Code assumes that any unused high bits of
    1088                 :            :    the double integer are set to zero.  */
    1089                 :            : 
    1090                 :            : /* This type has to be equal to unsigned HOST_WIDE_INT, see
    1091                 :            :    gcc/c-family/c-lex.c.  */
    1092                 :            : typedef uint64_t cpp_num_part;
    1093                 :            : typedef struct cpp_num cpp_num;
    1094                 :            : struct cpp_num
    1095                 :            : {
    1096                 :            :   cpp_num_part high;
    1097                 :            :   cpp_num_part low;
    1098                 :            :   bool unsignedp;  /* True if value should be treated as unsigned.  */
    1099                 :            :   bool overflow;   /* True if the most recent calculation overflowed.  */
    1100                 :            : };
    1101                 :            : 
    1102                 :            : /* cpplib provides two interfaces for interpretation of preprocessing
    1103                 :            :    numbers.
    1104                 :            : 
    1105                 :            :    cpp_classify_number categorizes numeric constants according to
    1106                 :            :    their field (integer, floating point, or invalid), radix (decimal,
    1107                 :            :    octal, hexadecimal), and type suffixes.  */
    1108                 :            : 
    1109                 :            : #define CPP_N_CATEGORY  0x000F
    1110                 :            : #define CPP_N_INVALID   0x0000
    1111                 :            : #define CPP_N_INTEGER   0x0001
    1112                 :            : #define CPP_N_FLOATING  0x0002
    1113                 :            : 
    1114                 :            : #define CPP_N_WIDTH     0x00F0
    1115                 :            : #define CPP_N_SMALL     0x0010  /* int, float, short _Fract/Accum  */
    1116                 :            : #define CPP_N_MEDIUM    0x0020  /* long, double, long _Fract/_Accum.  */
    1117                 :            : #define CPP_N_LARGE     0x0040  /* long long, long double,
    1118                 :            :                                    long long _Fract/Accum.  */
    1119                 :            : 
    1120                 :            : #define CPP_N_WIDTH_MD  0xF0000 /* machine defined.  */
    1121                 :            : #define CPP_N_MD_W      0x10000
    1122                 :            : #define CPP_N_MD_Q      0x20000
    1123                 :            : 
    1124                 :            : #define CPP_N_RADIX     0x0F00
    1125                 :            : #define CPP_N_DECIMAL   0x0100
    1126                 :            : #define CPP_N_HEX       0x0200
    1127                 :            : #define CPP_N_OCTAL     0x0400
    1128                 :            : #define CPP_N_BINARY    0x0800
    1129                 :            : 
    1130                 :            : #define CPP_N_UNSIGNED  0x1000  /* Properties.  */
    1131                 :            : #define CPP_N_IMAGINARY 0x2000
    1132                 :            : #define CPP_N_DFLOAT    0x4000
    1133                 :            : #define CPP_N_DEFAULT   0x8000
    1134                 :            : 
    1135                 :            : #define CPP_N_FRACT     0x100000 /* Fract types.  */
    1136                 :            : #define CPP_N_ACCUM     0x200000 /* Accum types.  */
    1137                 :            : #define CPP_N_FLOATN    0x400000 /* _FloatN types.  */
    1138                 :            : #define CPP_N_FLOATNX   0x800000 /* _FloatNx types.  */
    1139                 :            : 
    1140                 :            : #define CPP_N_USERDEF   0x1000000 /* C++0x user-defined literal.  */
    1141                 :            : 
    1142                 :            : #define CPP_N_WIDTH_FLOATN_NX   0xF0000000 /* _FloatN / _FloatNx value
    1143                 :            :                                               of N, divided by 16.  */
    1144                 :            : #define CPP_FLOATN_SHIFT        24
    1145                 :            : #define CPP_FLOATN_MAX  0xF0
    1146                 :            : 
    1147                 :            : /* Classify a CPP_NUMBER token.  The return value is a combination of
    1148                 :            :    the flags from the above sets.  */
    1149                 :            : extern unsigned cpp_classify_number (cpp_reader *, const cpp_token *,
    1150                 :            :                                      const char **, location_t);
    1151                 :            : 
    1152                 :            : /* Return the classification flags for a float suffix.  */
    1153                 :            : extern unsigned int cpp_interpret_float_suffix (cpp_reader *, const char *,
    1154                 :            :                                                 size_t);
    1155                 :            : 
    1156                 :            : /* Return the classification flags for an int suffix.  */
    1157                 :            : extern unsigned int cpp_interpret_int_suffix (cpp_reader *, const char *,
    1158                 :            :                                               size_t);
    1159                 :            : 
    1160                 :            : /* Evaluate a token classified as category CPP_N_INTEGER.  */
    1161                 :            : extern cpp_num cpp_interpret_integer (cpp_reader *, const cpp_token *,
    1162                 :            :                                       unsigned int);
    1163                 :            : 
    1164                 :            : /* Sign extend a number, with PRECISION significant bits and all
    1165                 :            :    others assumed clear, to fill out a cpp_num structure.  */
    1166                 :            : cpp_num cpp_num_sign_extend (cpp_num, size_t);
    1167                 :            : 
    1168                 :            : /* Output a diagnostic of some kind.  */
    1169                 :            : extern bool cpp_error (cpp_reader *, enum cpp_diagnostic_level,
    1170                 :            :                        const char *msgid, ...)
    1171                 :            :   ATTRIBUTE_PRINTF_3;
    1172                 :            : extern bool cpp_warning (cpp_reader *, enum cpp_warning_reason,
    1173                 :            :                          const char *msgid, ...)
    1174                 :            :   ATTRIBUTE_PRINTF_3;
    1175                 :            : extern bool cpp_pedwarning (cpp_reader *, enum cpp_warning_reason,
    1176                 :            :                             const char *msgid, ...)
    1177                 :            :   ATTRIBUTE_PRINTF_3;
    1178                 :            : extern bool cpp_warning_syshdr (cpp_reader *, enum cpp_warning_reason reason,
    1179                 :            :                                 const char *msgid, ...)
    1180                 :            :   ATTRIBUTE_PRINTF_3;
    1181                 :            : 
    1182                 :            : /* Output a diagnostic with "MSGID: " preceding the
    1183                 :            :    error string of errno.  No location is printed.  */
    1184                 :            : extern bool cpp_errno (cpp_reader *, enum cpp_diagnostic_level,
    1185                 :            :                        const char *msgid);
    1186                 :            : /* Similarly, but with "FILENAME: " instead of "MSGID: ", where
    1187                 :            :    the filename is not localized.  */
    1188                 :            : extern bool cpp_errno_filename (cpp_reader *, enum cpp_diagnostic_level,
    1189                 :            :                                 const char *filename, location_t loc);
    1190                 :            : 
    1191                 :            : /* Same as cpp_error, except additionally specifies a position as a
    1192                 :            :    (translation unit) physical line and physical column.  If the line is
    1193                 :            :    zero, then no location is printed.  */
    1194                 :            : extern bool cpp_error_with_line (cpp_reader *, enum cpp_diagnostic_level,
    1195                 :            :                                  location_t, unsigned,
    1196                 :            :                                  const char *msgid, ...)
    1197                 :            :   ATTRIBUTE_PRINTF_5;
    1198                 :            : extern bool cpp_warning_with_line (cpp_reader *, enum cpp_warning_reason,
    1199                 :            :                                    location_t, unsigned,
    1200                 :            :                                    const char *msgid, ...)
    1201                 :            :   ATTRIBUTE_PRINTF_5;
    1202                 :            : extern bool cpp_pedwarning_with_line (cpp_reader *, enum cpp_warning_reason,
    1203                 :            :                                       location_t, unsigned,
    1204                 :            :                                       const char *msgid, ...)
    1205                 :            :   ATTRIBUTE_PRINTF_5;
    1206                 :            : extern bool cpp_warning_with_line_syshdr (cpp_reader *, enum cpp_warning_reason,
    1207                 :            :                                           location_t, unsigned,
    1208                 :            :                                           const char *msgid, ...)
    1209                 :            :   ATTRIBUTE_PRINTF_5;
    1210                 :            : 
    1211                 :            : extern bool cpp_error_at (cpp_reader * pfile, enum cpp_diagnostic_level,
    1212                 :            :                           location_t src_loc, const char *msgid, ...)
    1213                 :            :   ATTRIBUTE_PRINTF_4;
    1214                 :            : 
    1215                 :            : extern bool cpp_error_at (cpp_reader * pfile, enum cpp_diagnostic_level,
    1216                 :            :                           rich_location *richloc, const char *msgid, ...)
    1217                 :            :   ATTRIBUTE_PRINTF_4;
    1218                 :            : 
    1219                 :            : /* In lex.c */
    1220                 :            : extern int cpp_ideq (const cpp_token *, const char *);
    1221                 :            : extern void cpp_output_line (cpp_reader *, FILE *);
    1222                 :            : extern unsigned char *cpp_output_line_to_string (cpp_reader *,
    1223                 :            :                                                  const unsigned char *);
    1224                 :            : extern void cpp_output_token (const cpp_token *, FILE *);
    1225                 :            : extern const char *cpp_type2name (enum cpp_ttype, unsigned char flags);
    1226                 :            : /* Returns the value of an escape sequence, truncated to the correct
    1227                 :            :    target precision.  PSTR points to the input pointer, which is just
    1228                 :            :    after the backslash.  LIMIT is how much text we have.  WIDE is true
    1229                 :            :    if the escape sequence is part of a wide character constant or
    1230                 :            :    string literal.  Handles all relevant diagnostics.  */
    1231                 :            : extern cppchar_t cpp_parse_escape (cpp_reader *, const unsigned char ** pstr,
    1232                 :            :                                    const unsigned char *limit, int wide);
    1233                 :            : 
    1234                 :            : /* Structure used to hold a comment block at a given location in the
    1235                 :            :    source code.  */
    1236                 :            : 
    1237                 :            : typedef struct
    1238                 :            : {
    1239                 :            :   /* Text of the comment including the terminators.  */
    1240                 :            :   char *comment;
    1241                 :            : 
    1242                 :            :   /* source location for the given comment.  */
    1243                 :            :   location_t sloc;
    1244                 :            : } cpp_comment;
    1245                 :            : 
    1246                 :            : /* Structure holding all comments for a given cpp_reader.  */
    1247                 :            : 
    1248                 :            : typedef struct
    1249                 :            : {
    1250                 :            :   /* table of comment entries.  */
    1251                 :            :   cpp_comment *entries;
    1252                 :            : 
    1253                 :            :   /* number of actual entries entered in the table.  */
    1254                 :            :   int count;
    1255                 :            : 
    1256                 :            :   /* number of entries allocated currently.  */
    1257                 :            :   int allocated;
    1258                 :            : } cpp_comment_table;
    1259                 :            : 
    1260                 :            : /* Returns the table of comments encountered by the preprocessor. This
    1261                 :            :    table is only populated when pfile->state.save_comments is true. */
    1262                 :            : extern cpp_comment_table *cpp_get_comments (cpp_reader *);
    1263                 :            : 
    1264                 :            : /* In hash.c */
    1265                 :            : 
    1266                 :            : /* Lookup an identifier in the hashtable.  Puts the identifier in the
    1267                 :            :    table if it is not already there.  */
    1268                 :            : extern cpp_hashnode *cpp_lookup (cpp_reader *, const unsigned char *,
    1269                 :            :                                  unsigned int);
    1270                 :            : 
    1271                 :            : typedef int (*cpp_cb) (cpp_reader *, cpp_hashnode *, void *);
    1272                 :            : extern void cpp_forall_identifiers (cpp_reader *, cpp_cb, void *);
    1273                 :            : 
    1274                 :            : /* In macro.c */
    1275                 :            : extern void cpp_scan_nooutput (cpp_reader *);
    1276                 :            : extern int  cpp_sys_macro_p (cpp_reader *);
    1277                 :            : extern unsigned char *cpp_quote_string (unsigned char *, const unsigned char *,
    1278                 :            :                                         unsigned int);
    1279                 :            : 
    1280                 :            : /* In files.c */
    1281                 :            : extern bool cpp_included (cpp_reader *, const char *);
    1282                 :            : extern bool cpp_included_before (cpp_reader *, const char *, location_t);
    1283                 :            : extern void cpp_make_system_header (cpp_reader *, int, int);
    1284                 :            : extern bool cpp_push_include (cpp_reader *, const char *);
    1285                 :            : extern bool cpp_push_default_include (cpp_reader *, const char *);
    1286                 :            : extern void cpp_change_file (cpp_reader *, enum lc_reason, const char *);
    1287                 :            : extern const char *cpp_get_path (struct _cpp_file *);
    1288                 :            : extern cpp_dir *cpp_get_dir (struct _cpp_file *);
    1289                 :            : extern cpp_buffer *cpp_get_buffer (cpp_reader *);
    1290                 :            : extern struct _cpp_file *cpp_get_file (cpp_buffer *);
    1291                 :            : extern cpp_buffer *cpp_get_prev (cpp_buffer *);
    1292                 :            : extern void cpp_clear_file_cache (cpp_reader *);
    1293                 :            : 
    1294                 :            : /* In pch.c */
    1295                 :            : struct save_macro_data;
    1296                 :            : extern int cpp_save_state (cpp_reader *, FILE *);
    1297                 :            : extern int cpp_write_pch_deps (cpp_reader *, FILE *);
    1298                 :            : extern int cpp_write_pch_state (cpp_reader *, FILE *);
    1299                 :            : extern int cpp_valid_state (cpp_reader *, const char *, int);
    1300                 :            : extern void cpp_prepare_state (cpp_reader *, struct save_macro_data **);
    1301                 :            : extern int cpp_read_state (cpp_reader *, const char *, FILE *,
    1302                 :            :                            struct save_macro_data *);
    1303                 :            : 
    1304                 :            : /* In lex.c */
    1305                 :            : extern void cpp_force_token_locations (cpp_reader *, location_t);
    1306                 :            : extern void cpp_stop_forcing_token_locations (cpp_reader *);
    1307                 :            : enum CPP_DO_task
    1308                 :            : {
    1309                 :            :   CPP_DO_print,
    1310                 :            :   CPP_DO_location,
    1311                 :            :   CPP_DO_token
    1312                 :            : };
    1313                 :            : 
    1314                 :            : extern void cpp_directive_only_process (cpp_reader *pfile,
    1315                 :            :                                         void *data,
    1316                 :            :                                         void (*cb) (cpp_reader *,
    1317                 :            :                                                     CPP_DO_task,
    1318                 :            :                                                     void *data, ...));
    1319                 :            : 
    1320                 :            : /* In expr.c */
    1321                 :            : extern enum cpp_ttype cpp_userdef_string_remove_type
    1322                 :            :   (enum cpp_ttype type);
    1323                 :            : extern enum cpp_ttype cpp_userdef_string_add_type
    1324                 :            :   (enum cpp_ttype type);
    1325                 :            : extern enum cpp_ttype cpp_userdef_char_remove_type
    1326                 :            :   (enum cpp_ttype type);
    1327                 :            : extern enum cpp_ttype cpp_userdef_char_add_type
    1328                 :            :   (enum cpp_ttype type);
    1329                 :            : extern bool cpp_userdef_string_p
    1330                 :            :   (enum cpp_ttype type);
    1331                 :            : extern bool cpp_userdef_char_p
    1332                 :            :   (enum cpp_ttype type);
    1333                 :            : extern const char * cpp_get_userdef_suffix
    1334                 :            :   (const cpp_token *);
    1335                 :            : 
    1336                 :            : /* In charset.c */
    1337                 :            : int cpp_byte_column_to_display_column (const char *data, int data_length,
    1338                 :            :                                        int column);
    1339                 :     130952 : inline int cpp_display_width (const char *data, int data_length)
    1340                 :            : {
    1341                 :     130952 :     return cpp_byte_column_to_display_column (data, data_length, data_length);
    1342                 :            : }
    1343                 :            : int cpp_display_column_to_byte_column (const char *data, int data_length,
    1344                 :            :                                        int display_col);
    1345                 :            : int cpp_wcwidth (cppchar_t c);
    1346                 :            : 
    1347                 :            : #endif /* ! LIBCPP_CPPLIB_H */

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.