libcpp/init.c

   1 /* CPP Library.
   2    Copyright (C) 1986-2021 Free Software Foundation, Inc.
   3    Contributed by Per Bothner, 1994-95.
   4    Based on CCCP program by Paul Rubin, June 1986
   5    Adapted to ANSI C, Richard Stallman, Jan 1987
   6
   7 This program is free software; you can redistribute it and/or modify it
   8 under the terms of the GNU General Public License as published by the
   9 Free Software Foundation; either version 3, or (at your option) any
  10 later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "cpplib.h"
  24 #include "internal.h"
  25 #include "mkdeps.h"
  26 #include "localedir.h"
  27 #include "filenames.h"
  28
  29 #ifndef ENABLE_CANONICAL_SYSTEM_HEADERS
  30 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
  31 #define ENABLE_CANONICAL_SYSTEM_HEADERS 1
  32 #else
  33 #define ENABLE_CANONICAL_SYSTEM_HEADERS 0
  34 #endif
  35 #endif
  36
  37 static void init_library (void);
  38 static void mark_named_operators (cpp_reader *, int);
  39 static bool read_original_filename (cpp_reader *);
  40 static void read_original_directory (cpp_reader *);
  41 static void post_options (cpp_reader *);
  42
  43 /* If we have designated initializers (GCC >2.7) these tables can be
  44    initialized, constant data.  Otherwise, they have to be filled in at
  45    runtime.  */
  46 #if HAVE_DESIGNATED_INITIALIZERS
  47
  48 #define init_trigraph_map()  /* Nothing.  */
  49 #define TRIGRAPH_MAP \
  50 __extension__ const uchar _cpp_trigraph_map[UCHAR_MAX + 1] = {
  51
  52 #define END };
  53 #define s(p, v) [p] = v,
  54
  55 #else
  56
  57 #define TRIGRAPH_MAP uchar _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \
  58  static void init_trigraph_map (void) { \
  59  unsigned char *x = _cpp_trigraph_map;
  60
  61 #define END }
  62 #define s(p, v) x[p] = v;
  63
  64 #endif
  65
  66 TRIGRAPH_MAP
  67   s('=', '#')   s(')', ']')     s('!', '|')
  68   s('(', '[')   s('\'', '^')    s('>', '}')
  69   s('/', '\\')  s('<', '{')     s('-', '~')
  70 END
  71
  72 #undef s
  73 #undef END
  74 #undef TRIGRAPH_MAP
  75
  76 /* A set of booleans indicating what CPP features each source language
  77    requires.  */
  78 struct lang_flags
  79 {
  80   char c99;
  81   char cplusplus;
  82   char extended_numbers;
  83   char extended_identifiers;
  84   char c11_identifiers;
  85   char std;
  86   char digraphs;
  87   char uliterals;
  88   char rliterals;
  89   char user_literals;
  90   char binary_constants;
  91   char digit_separators;
  92   char trigraphs;
  93   char utf8_char_literals;
  94   char va_opt;
  95   char scope;
  96   char dfp_constants;
  97   char size_t_literals;
  98   char elifdef;
  99 };
 100
 101 static const struct lang_flags lang_defaults[] =
 102 { /*              c99 c++ xnum xid c11 std digr ulit rlit udlit bincst digsep trig u8chlit vaopt scope dfp szlit elifdef */
 103   /* GNUC89   */  { 0,  0,  1,  0,  0,  0,  1,   0,   0,   0,    0,     0,     0,   0,      1,   1,     0,   0,   0 },
 104   /* GNUC99   */  { 1,  0,  1,  1,  0,  0,  1,   1,   1,   0,    0,     0,     0,   0,      1,   1,     0,   0,   0 },
 105   /* GNUC11   */  { 1,  0,  1,  1,  1,  0,  1,   1,   1,   0,    0,     0,     0,   0,      1,   1,     0,   0,   0 },
 106   /* GNUC17   */  { 1,  0,  1,  1,  1,  0,  1,   1,   1,   0,    0,     0,     0,   0,      1,   1,     0,   0,   0 },
 107   /* GNUC2X   */  { 1,  0,  1,  1,  1,  0,  1,   1,   1,   0,    1,     1,     0,   1,      1,   1,     1,   0,   1 },
 108   /* STDC89   */  { 0,  0,  0,  0,  0,  1,  0,   0,   0,   0,    0,     0,     1,   0,      0,   0,     0,   0,   0 },
 109   /* STDC94   */  { 0,  0,  0,  0,  0,  1,  1,   0,   0,   0,    0,     0,     1,   0,      0,   0,     0,   0,   0 },
 110   /* STDC99   */  { 1,  0,  1,  1,  0,  1,  1,   0,   0,   0,    0,     0,     1,   0,      0,   0,     0,   0,   0 },
 111   /* STDC11   */  { 1,  0,  1,  1,  1,  1,  1,   1,   0,   0,    0,     0,     1,   0,      0,   0,     0,   0,   0 },
 112   /* STDC17   */  { 1,  0,  1,  1,  1,  1,  1,   1,   0,   0,    0,     0,     1,   0,      0,   0,     0,   0,   0 },
 113   /* STDC2X   */  { 1,  0,  1,  1,  1,  1,  1,   1,   0,   0,    1,     1,     1,   1,      0,   1,     1,   0,   1 },
 114   /* GNUCXX   */  { 0,  1,  1,  1,  0,  0,  1,   0,   0,   0,    0,     0,     0,   0,      1,   1,     0,   0,   0 },
 115   /* CXX98    */  { 0,  1,  0,  1,  0,  1,  1,   0,   0,   0,    0,     0,     1,   0,      0,   1,     0,   0,   0 },
 116   /* GNUCXX11 */  { 1,  1,  1,  1,  1,  0,  1,   1,   1,   1,    0,     0,     0,   0,      1,   1,     0,   0,   0 },
 117   /* CXX11    */  { 1,  1,  0,  1,  1,  1,  1,   1,   1,   1,    0,     0,     1,   0,      0,   1,     0,   0,   0 },
 118   /* GNUCXX14 */  { 1,  1,  1,  1,  1,  0,  1,   1,   1,   1,    1,     1,     0,   0,      1,   1,     0,   0,   0 },
 119   /* CXX14    */  { 1,  1,  0,  1,  1,  1,  1,   1,   1,   1,    1,     1,     1,   0,      0,   1,     0,   0,   0 },
 120   /* GNUCXX17 */  { 1,  1,  1,  1,  1,  0,  1,   1,   1,   1,    1,     1,     0,   1,      1,   1,     0,   0,   0 },
 121   /* CXX17    */  { 1,  1,  1,  1,  1,  1,  1,   1,   1,   1,    1,     1,     0,   1,      0,   1,     0,   0,   0 },
 122   /* GNUCXX20 */  { 1,  1,  1,  1,  1,  0,  1,   1,   1,   1,    1,     1,     0,   1,      1,   1,     0,   0,   0 },
 123   /* CXX20    */  { 1,  1,  1,  1,  1,  1,  1,   1,   1,   1,    1,     1,     0,   1,      1,   1,     0,   0,   0 },
 124   /* GNUCXX23 */  { 1,  1,  1,  1,  1,  0,  1,   1,   1,   1,    1,     1,     0,   1,      1,   1,     0,   1,   0 },
 125   /* CXX23    */  { 1,  1,  1,  1,  1,  1,  1,   1,   1,   1,    1,     1,     0,   1,      1,   1,     0,   1,   0 },
 126   /* ASM      */  { 0,  0,  1,  0,  0,  0,  0,   0,   0,   0,    0,     0,     0,   0,      0,   0,     0,   0,   0 }
 127 };
 128
 129 /* Sets internal flags correctly for a given language.  */
 130 void
 131 cpp_set_lang (cpp_reader *pfile, enum c_lang lang)
 132 {
 133   const struct lang_flags *l = &lang_defaults[(int) lang];
 134
 135   CPP_OPTION (pfile, lang) = lang;
 136
 137   CPP_OPTION (pfile, c99)                        = l->c99;
 138   CPP_OPTION (pfile, cplusplus)                  = l->cplusplus;
 139   CPP_OPTION (pfile, extended_numbers)           = l->extended_numbers;
 140   CPP_OPTION (pfile, extended_identifiers)       = l->extended_identifiers;
 141   CPP_OPTION (pfile, c11_identifiers)            = l->c11_identifiers;
 142   CPP_OPTION (pfile, std)                        = l->std;
 143   CPP_OPTION (pfile, digraphs)                   = l->digraphs;
 144   CPP_OPTION (pfile, uliterals)                  = l->uliterals;
 145   CPP_OPTION (pfile, rliterals)                  = l->rliterals;
 146   CPP_OPTION (pfile, user_literals)              = l->user_literals;
 147   CPP_OPTION (pfile, binary_constants)           = l->binary_constants;
 148   CPP_OPTION (pfile, digit_separators)           = l->digit_separators;
 149   CPP_OPTION (pfile, trigraphs)                  = l->trigraphs;
 150   CPP_OPTION (pfile, utf8_char_literals)         = l->utf8_char_literals;
 151   CPP_OPTION (pfile, va_opt)                     = l->va_opt;
 152   CPP_OPTION (pfile, scope)                      = l->scope;
 153   CPP_OPTION (pfile, dfp_constants)              = l->dfp_constants;
 154   CPP_OPTION (pfile, size_t_literals)            = l->size_t_literals;
 155   CPP_OPTION (pfile, elifdef)                    = l->elifdef;
 156 }
 157
 158 /* Initialize library global state.  */
 159 static void
 160 init_library (void)
 161 {
 162   static int initialized = 0;
 163
 164   if (! initialized)
 165     {
 166       initialized = 1;
 167
 168       _cpp_init_lexer ();
 169
 170       /* Set up the trigraph map.  This doesn't need to do anything if
 171          we were compiled with a compiler that supports C99 designated
 172          initializers.  */
 173       init_trigraph_map ();
 174
 175 #ifdef ENABLE_NLS
 176        (void) bindtextdomain (PACKAGE, LOCALEDIR);
 177 #endif
 178     }
 179 }
 180
 181 /* Initialize a cpp_reader structure.  */
 182 cpp_reader *
 183 cpp_create_reader (enum c_lang lang, cpp_hash_table *table,
 184                    class line_maps *line_table)
 185 {
 186   cpp_reader *pfile;
 187
 188   /* Initialize this instance of the library if it hasn't been already.  */
 189   init_library ();
 190
 191   pfile = XCNEW (cpp_reader);
 192   memset (&pfile->base_context, 0, sizeof (pfile->base_context));
 193
 194   cpp_set_lang (pfile, lang);
 195   CPP_OPTION (pfile, warn_multichar) = 1;
 196   CPP_OPTION (pfile, discard_comments) = 1;
 197   CPP_OPTION (pfile, discard_comments_in_macro_exp) = 1;
 198   CPP_OPTION (pfile, max_include_depth) = 200;
 199   CPP_OPTION (pfile, operator_names) = 1;
 200   CPP_OPTION (pfile, warn_trigraphs) = 2;
 201   CPP_OPTION (pfile, warn_endif_labels) = 1;
 202   CPP_OPTION (pfile, cpp_warn_c90_c99_compat) = -1;
 203   CPP_OPTION (pfile, cpp_warn_c11_c2x_compat) = -1;
 204   CPP_OPTION (pfile, cpp_warn_cxx11_compat) = 0;
 205   CPP_OPTION (pfile, cpp_warn_deprecated) = 1;
 206   CPP_OPTION (pfile, cpp_warn_long_long) = 0;
 207   CPP_OPTION (pfile, dollars_in_ident) = 1;
 208   CPP_OPTION (pfile, warn_dollars) = 1;
 209   CPP_OPTION (pfile, warn_variadic_macros) = 1;
 210   CPP_OPTION (pfile, warn_builtin_macro_redefined) = 1;
 211   CPP_OPTION (pfile, cpp_warn_implicit_fallthrough) = 0;
 212   /* By default, track locations of tokens resulting from macro
 213      expansion.  The '2' means, track the locations with the highest
 214      accuracy.  Read the comments for struct
 215      cpp_options::track_macro_expansion to learn about the other
 216      values.  */
 217   CPP_OPTION (pfile, track_macro_expansion) = 2;
 218   CPP_OPTION (pfile, warn_normalize) = normalized_C;
 219   CPP_OPTION (pfile, warn_literal_suffix) = 1;
 220   CPP_OPTION (pfile, canonical_system_headers)
 221       = ENABLE_CANONICAL_SYSTEM_HEADERS;
 222   CPP_OPTION (pfile, ext_numeric_literals) = 1;
 223   CPP_OPTION (pfile, warn_date_time) = 0;
 224
 225   /* Default CPP arithmetic to something sensible for the host for the
 226      benefit of dumb users like fix-header.  */
 227   CPP_OPTION (pfile, precision) = CHAR_BIT * sizeof (long);
 228   CPP_OPTION (pfile, char_precision) = CHAR_BIT;
 229   CPP_OPTION (pfile, wchar_precision) = CHAR_BIT * sizeof (int);
 230   CPP_OPTION (pfile, int_precision) = CHAR_BIT * sizeof (int);
 231   CPP_OPTION (pfile, unsigned_char) = 0;
 232   CPP_OPTION (pfile, unsigned_wchar) = 1;
 233   CPP_OPTION (pfile, bytes_big_endian) = 1;  /* does not matter */
 234
 235   /* Default to no charset conversion.  */
 236   CPP_OPTION (pfile, narrow_charset) = _cpp_default_encoding ();
 237   CPP_OPTION (pfile, wide_charset) = 0;
 238
 239   /* Default the input character set to UTF-8.  */
 240   CPP_OPTION (pfile, input_charset) = _cpp_default_encoding ();
 241
 242   /* A fake empty "directory" used as the starting point for files
 243      looked up without a search path.  Name cannot be '/' because we
 244      don't want to prepend anything at all to filenames using it.  All
 245      other entries are correct zero-initialized.  */
 246   pfile->no_search_path.name = (char *) "";
 247
 248   /* Initialize the line map.  */
 249   pfile->line_table = line_table;
 250
 251   /* Initialize lexer state.  */
 252   pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
 253
 254   /* Set up static tokens.  */
 255   pfile->avoid_paste.type = CPP_PADDING;
 256   pfile->avoid_paste.val.source = NULL;
 257   pfile->avoid_paste.src_loc = 0;
 258   pfile->endarg.type = CPP_EOF;
 259   pfile->endarg.flags = 0;
 260   pfile->endarg.src_loc = 0;
 261
 262   /* Create a token buffer for the lexer.  */
 263   _cpp_init_tokenrun (&pfile->base_run, 250);
 264   pfile->cur_run = &pfile->base_run;
 265   pfile->cur_token = pfile->base_run.base;
 266
 267   /* Initialize the base context.  */
 268   pfile->context = &pfile->base_context;
 269   pfile->base_context.c.macro = 0;
 270   pfile->base_context.prev = pfile->base_context.next = 0;
 271
 272   /* Aligned and unaligned storage.  */
 273   pfile->a_buff = _cpp_get_buff (pfile, 0);
 274   pfile->u_buff = _cpp_get_buff (pfile, 0);
 275
 276   /* Initialize table for push_macro/pop_macro.  */
 277   pfile->pushed_macros = 0;
 278
 279   /* Do not force token locations by default.  */
 280   pfile->forced_token_location = 0;
 281
 282   /* Note the timestamp is unset.  */
 283   pfile->time_stamp = time_t (-1);
 284   pfile->time_stamp_kind = 0;
 285
 286   /* The expression parser stack.  */
 287   _cpp_expand_op_stack (pfile);
 288
 289   /* Initialize the buffer obstack.  */
 290   obstack_specify_allocation (&pfile->buffer_ob, 0, 0, xmalloc, free);
 291
 292   _cpp_init_files (pfile);
 293
 294   _cpp_init_hashtable (pfile, table);
 295
 296   return pfile;
 297 }
 298
 299 /* Set the line_table entry in PFILE.  This is called after reading a
 300    PCH file, as the old line_table will be incorrect.  */
 301 void
 302 cpp_set_line_map (cpp_reader *pfile, class line_maps *line_table)
 303 {
 304   pfile->line_table = line_table;
 305 }
 306
 307 /* Free resources used by PFILE.  Accessing PFILE after this function
 308    returns leads to undefined behavior.  Returns the error count.  */
 309 void
 310 cpp_destroy (cpp_reader *pfile)
 311 {
 312   cpp_context *context, *contextn;
 313   struct def_pragma_macro *pmacro;
 314   tokenrun *run, *runn;
 315   int i;
 316
 317   free (pfile->op_stack);
 318
 319   while (CPP_BUFFER (pfile) != NULL)
 320     _cpp_pop_buffer (pfile);
 321
 322   free (pfile->out.base);
 323
 324   if (pfile->macro_buffer)
 325     {
 326       free (pfile->macro_buffer);
 327       pfile->macro_buffer = NULL;
 328       pfile->macro_buffer_len = 0;
 329     }
 330
 331   if (pfile->deps)
 332     deps_free (pfile->deps);
 333   obstack_free (&pfile->buffer_ob, 0);
 334
 335   _cpp_destroy_hashtable (pfile);
 336   _cpp_cleanup_files (pfile);
 337   _cpp_destroy_iconv (pfile);
 338
 339   _cpp_free_buff (pfile->a_buff);
 340   _cpp_free_buff (pfile->u_buff);
 341   _cpp_free_buff (pfile->free_buffs);
 342
 343   for (run = &pfile->base_run; run; run = runn)
 344     {
 345       runn = run->next;
 346       free (run->base);
 347       if (run != &pfile->base_run)
 348         free (run);
 349     }
 350
 351   for (context = pfile->base_context.next; context; context = contextn)
 352     {
 353       contextn = context->next;
 354       free (context);
 355     }
 356
 357   if (pfile->comments.entries)
 358     {
 359       for (i = 0; i < pfile->comments.count; i++)
 360         free (pfile->comments.entries[i].comment);
 361
 362       free (pfile->comments.entries);
 363     }
 364   if (pfile->pushed_macros)
 365     {
 366       do
 367         {
 368           pmacro = pfile->pushed_macros;
 369           pfile->pushed_macros = pmacro->next;
 370           free (pmacro->name);
 371           free (pmacro);
 372         }
 373       while (pfile->pushed_macros);
 374     }
 375
 376   free (pfile);
 377 }
 378
 379 /* This structure defines one built-in identifier.  A node will be
 380    entered in the hash table under the name NAME, with value VALUE.
 381
 382    There are two tables of these.  builtin_array holds all the
 383    "builtin" macros: these are handled by builtin_macro() in
 384    macro.c.  Builtin is somewhat of a misnomer -- the property of
 385    interest is that these macros require special code to compute their
 386    expansions.  The value is a "cpp_builtin_type" enumerator.
 387
 388    operator_array holds the C++ named operators.  These are keywords
 389    which act as aliases for punctuators.  In C++, they cannot be
 390    altered through #define, and #if recognizes them as operators.  In
 391    C, these are not entered into the hash table at all (but see
 392    <iso646.h>).  The value is a token-type enumerator.  */
 393 struct builtin_macro
 394 {
 395   const uchar *const name;
 396   const unsigned short len;
 397   const unsigned short value;
 398   const bool always_warn_if_redefined;
 399 };
 400
 401 #define B(n, t, f)    { DSC(n), t, f }
 402 static const struct builtin_macro builtin_array[] =
 403 {
 404   B("__TIMESTAMP__",     BT_TIMESTAMP,     false),
 405   B("__TIME__",          BT_TIME,          false),
 406   B("__DATE__",          BT_DATE,          false),
 407   B("__FILE__",          BT_FILE,          false),
 408   B("__BASE_FILE__",     BT_BASE_FILE,     false),
 409   B("__LINE__",          BT_SPECLINE,      true),
 410   B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL, true),
 411   B("__COUNTER__",       BT_COUNTER,       true),
 412   /* Make sure to update the list of built-in
 413      function-like macros in traditional.c:
 414      fun_like_macro() when adding more following */
 415   B("__has_attribute",   BT_HAS_ATTRIBUTE, true),
 416   B("__has_c_attribute", BT_HAS_STD_ATTRIBUTE, true),
 417   B("__has_cpp_attribute", BT_HAS_ATTRIBUTE, true),
 418   B("__has_builtin",     BT_HAS_BUILTIN,   true),
 419   B("__has_include",     BT_HAS_INCLUDE,   true),
 420   B("__has_include_next",BT_HAS_INCLUDE_NEXT,   true),
 421   /* Keep builtins not used for -traditional-cpp at the end, and
 422      update init_builtins() if any more are added.  */
 423   B("_Pragma",           BT_PRAGMA,        true),
 424   B("__STDC__",          BT_STDC,          true),
 425 };
 426 #undef B
 427
 428 struct builtin_operator
 429 {
 430   const uchar *const name;
 431   const unsigned short len;
 432   const unsigned short value;
 433 };
 434
 435 #define B(n, t)    { DSC(n), t }
 436 static const struct builtin_operator operator_array[] =
 437 {
 438   B("and",      CPP_AND_AND),
 439   B("and_eq",   CPP_AND_EQ),
 440   B("bitand",   CPP_AND),
 441   B("bitor",    CPP_OR),
 442   B("compl",    CPP_COMPL),
 443   B("not",      CPP_NOT),
 444   B("not_eq",   CPP_NOT_EQ),
 445   B("or",       CPP_OR_OR),
 446   B("or_eq",    CPP_OR_EQ),
 447   B("xor",      CPP_XOR),
 448   B("xor_eq",   CPP_XOR_EQ)
 449 };
 450 #undef B
 451
 452 /* Mark the C++ named operators in the hash table.  */
 453 static void
 454 mark_named_operators (cpp_reader *pfile, int flags)
 455 {
 456   const struct builtin_operator *b;
 457
 458   for (b = operator_array;
 459        b < (operator_array + ARRAY_SIZE (operator_array));
 460        b++)
 461     {
 462       cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
 463       hp->flags |= flags;
 464       hp->is_directive = 0;
 465       hp->directive_index = b->value;
 466     }
 467 }
 468
 469 /* Helper function of cpp_type2name. Return the string associated with
 470    named operator TYPE.  */
 471 const char *
 472 cpp_named_operator2name (enum cpp_ttype type)
 473 {
 474   const struct builtin_operator *b;
 475
 476   for (b = operator_array;
 477        b < (operator_array + ARRAY_SIZE (operator_array));
 478        b++)
 479     {
 480       if (type == b->value)
 481         return (const char *) b->name;
 482     }
 483
 484   return NULL;
 485 }
 486
 487 void
 488 cpp_init_special_builtins (cpp_reader *pfile)
 489 {
 490   const struct builtin_macro *b;
 491   size_t n = ARRAY_SIZE (builtin_array);
 492
 493   if (CPP_OPTION (pfile, traditional))
 494     n -= 2;
 495   else if (! CPP_OPTION (pfile, stdc_0_in_system_headers)
 496            || CPP_OPTION (pfile, std))
 497     n--;
 498
 499   for (b = builtin_array; b < builtin_array + n; b++)
 500     {
 501       if ((b->value == BT_HAS_ATTRIBUTE
 502            || b->value == BT_HAS_STD_ATTRIBUTE
 503            || b->value == BT_HAS_BUILTIN)
 504           && (CPP_OPTION (pfile, lang) == CLK_ASM
 505               || pfile->cb.has_attribute == NULL))
 506         continue;
 507       cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
 508       hp->type = NT_BUILTIN_MACRO;
 509       if (b->always_warn_if_redefined)
 510         hp->flags |= NODE_WARN;
 511       hp->value.builtin = (enum cpp_builtin_type) b->value;
 512     }
 513 }
 514
 515 /* Restore macro C to builtin macro definition.  */
 516
 517 void
 518 _cpp_restore_special_builtin (cpp_reader *pfile, struct def_pragma_macro *c)
 519 {
 520   size_t len = strlen (c->name);
 521
 522   for (const struct builtin_macro *b = builtin_array;
 523        b < builtin_array + ARRAY_SIZE (builtin_array); b++)
 524     if (b->len == len && memcmp (c->name, b->name, len + 1) == 0)
 525       {
 526         cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
 527         hp->type = NT_BUILTIN_MACRO;
 528         if (b->always_warn_if_redefined)
 529           hp->flags |= NODE_WARN;
 530         hp->value.builtin = (enum cpp_builtin_type) b->value;
 531       }
 532 }
 533
 534 /* Read the builtins table above and enter them, and language-specific
 535    macros, into the hash table.  HOSTED is true if this is a hosted
 536    environment.  */
 537 void
 538 cpp_init_builtins (cpp_reader *pfile, int hosted)
 539 {
 540   cpp_init_special_builtins (pfile);
 541
 542   if (!CPP_OPTION (pfile, traditional)
 543       && (! CPP_OPTION (pfile, stdc_0_in_system_headers)
 544           || CPP_OPTION (pfile, std)))
 545     _cpp_define_builtin (pfile, "__STDC__ 1");
 546
 547   if (CPP_OPTION (pfile, cplusplus))
 548     {
 549       /* C++23 is not yet a standard.  For now, use an invalid
 550        * year/month, 202100L, which is larger than 202002L.  */
 551       if (CPP_OPTION (pfile, lang) == CLK_CXX23
 552           || CPP_OPTION (pfile, lang) == CLK_GNUCXX23)
 553         _cpp_define_builtin (pfile, "__cplusplus 202100L");
 554       else if (CPP_OPTION (pfile, lang) == CLK_CXX20
 555           || CPP_OPTION (pfile, lang) == CLK_GNUCXX20)
 556         _cpp_define_builtin (pfile, "__cplusplus 202002L");
 557       else if (CPP_OPTION (pfile, lang) == CLK_CXX17
 558           || CPP_OPTION (pfile, lang) == CLK_GNUCXX17)
 559         _cpp_define_builtin (pfile, "__cplusplus 201703L");
 560       else if (CPP_OPTION (pfile, lang) == CLK_CXX14
 561           || CPP_OPTION (pfile, lang) == CLK_GNUCXX14)
 562         _cpp_define_builtin (pfile, "__cplusplus 201402L");
 563       else if (CPP_OPTION (pfile, lang) == CLK_CXX11
 564                || CPP_OPTION (pfile, lang) == CLK_GNUCXX11)
 565         _cpp_define_builtin (pfile, "__cplusplus 201103L");
 566       else
 567         _cpp_define_builtin (pfile, "__cplusplus 199711L");
 568     }
 569   else if (CPP_OPTION (pfile, lang) == CLK_ASM)
 570     _cpp_define_builtin (pfile, "__ASSEMBLER__ 1");
 571   else if (CPP_OPTION (pfile, lang) == CLK_STDC94)
 572     _cpp_define_builtin (pfile, "__STDC_VERSION__ 199409L");
 573   else if (CPP_OPTION (pfile, lang) == CLK_STDC2X
 574            || CPP_OPTION (pfile, lang) == CLK_GNUC2X)
 575     _cpp_define_builtin (pfile, "__STDC_VERSION__ 202000L");
 576   else if (CPP_OPTION (pfile, lang) == CLK_STDC17
 577            || CPP_OPTION (pfile, lang) == CLK_GNUC17)
 578     _cpp_define_builtin (pfile, "__STDC_VERSION__ 201710L");
 579   else if (CPP_OPTION (pfile, lang) == CLK_STDC11
 580            || CPP_OPTION (pfile, lang) == CLK_GNUC11)
 581     _cpp_define_builtin (pfile, "__STDC_VERSION__ 201112L");
 582   else if (CPP_OPTION (pfile, c99))
 583     _cpp_define_builtin (pfile, "__STDC_VERSION__ 199901L");
 584
 585   if (CPP_OPTION (pfile, uliterals)
 586       && !(CPP_OPTION (pfile, cplusplus)
 587            && (CPP_OPTION (pfile, lang) == CLK_GNUCXX
 588             || CPP_OPTION (pfile, lang) == CLK_CXX98)))
 589     {
 590       _cpp_define_builtin (pfile, "__STDC_UTF_16__ 1");
 591       _cpp_define_builtin (pfile, "__STDC_UTF_32__ 1");
 592     }
 593
 594   if (hosted)
 595     _cpp_define_builtin (pfile, "__STDC_HOSTED__ 1");
 596   else
 597     _cpp_define_builtin (pfile, "__STDC_HOSTED__ 0");
 598
 599   if (CPP_OPTION (pfile, objc))
 600     _cpp_define_builtin (pfile, "__OBJC__ 1");
 601 }
 602
 603 /* Sanity-checks are dependent on command-line options, so it is
 604    called as a subroutine of cpp_read_main_file.  */
 605 #if CHECKING_P
 606 static void sanity_checks (cpp_reader *);
 607 static void sanity_checks (cpp_reader *pfile)
 608 {
 609   cppchar_t test = 0;
 610   size_t max_precision = 2 * CHAR_BIT * sizeof (cpp_num_part);
 611
 612   /* Sanity checks for assumptions about CPP arithmetic and target
 613      type precisions made by cpplib.  */
 614   test--;
 615   if (test < 1)
 616     cpp_error (pfile, CPP_DL_ICE, "cppchar_t must be an unsigned type");
 617
 618   if (CPP_OPTION (pfile, precision) > max_precision)
 619     cpp_error (pfile, CPP_DL_ICE,
 620                "preprocessor arithmetic has maximum precision of %lu bits;"
 621                " target requires %lu bits",
 622                (unsigned long) max_precision,
 623                (unsigned long) CPP_OPTION (pfile, precision));
 624
 625   if (CPP_OPTION (pfile, precision) < CPP_OPTION (pfile, int_precision))
 626     cpp_error (pfile, CPP_DL_ICE,
 627                "CPP arithmetic must be at least as precise as a target int");
 628
 629   if (CPP_OPTION (pfile, char_precision) < 8)
 630     cpp_error (pfile, CPP_DL_ICE, "target char is less than 8 bits wide");
 631
 632   if (CPP_OPTION (pfile, wchar_precision) < CPP_OPTION (pfile, char_precision))
 633     cpp_error (pfile, CPP_DL_ICE,
 634                "target wchar_t is narrower than target char");
 635
 636   if (CPP_OPTION (pfile, int_precision) < CPP_OPTION (pfile, char_precision))
 637     cpp_error (pfile, CPP_DL_ICE,
 638                "target int is narrower than target char");
 639
 640   /* This is assumed in eval_token() and could be fixed if necessary.  */
 641   if (sizeof (cppchar_t) > sizeof (cpp_num_part))
 642     cpp_error (pfile, CPP_DL_ICE,
 643                "CPP half-integer narrower than CPP character");
 644
 645   if (CPP_OPTION (pfile, wchar_precision) > BITS_PER_CPPCHAR_T)
 646     cpp_error (pfile, CPP_DL_ICE,
 647                "CPP on this host cannot handle wide character constants over"
 648                " %lu bits, but the target requires %lu bits",
 649                (unsigned long) BITS_PER_CPPCHAR_T,
 650                (unsigned long) CPP_OPTION (pfile, wchar_precision));
 651 }
 652 #else
 653 # define sanity_checks(PFILE)
 654 #endif
 655
 656 /* This is called after options have been parsed, and partially
 657    processed.  */
 658 void
 659 cpp_post_options (cpp_reader *pfile)
 660 {
 661   int flags;
 662
 663   sanity_checks (pfile);
 664
 665   post_options (pfile);
 666
 667   /* Mark named operators before handling command line macros.  */
 668   flags = 0;
 669   if (CPP_OPTION (pfile, cplusplus) && CPP_OPTION (pfile, operator_names))
 670     flags |= NODE_OPERATOR;
 671   if (CPP_OPTION (pfile, warn_cxx_operator_names))
 672     flags |= NODE_DIAGNOSTIC | NODE_WARN_OPERATOR;
 673   if (flags != 0)
 674     mark_named_operators (pfile, flags);
 675 }
 676
 677 /* Setup for processing input from the file named FNAME, or stdin if
 678    it is the empty string.  Return the original filename on success
 679    (e.g. foo.i->foo.c), or NULL on failure.  INJECTING is true if
 680    there may be injected headers before line 1 of the main file.  */
 681 const char *
 682 cpp_read_main_file (cpp_reader *pfile, const char *fname, bool injecting)
 683 {
 684   if (mkdeps *deps = cpp_get_deps (pfile))
 685     /* Set the default target (if there is none already).  */
 686     deps_add_default_target (deps, fname);
 687
 688   pfile->main_file
 689     = _cpp_find_file (pfile, fname,
 690                       CPP_OPTION (pfile, preprocessed) ? &pfile->no_search_path
 691                       : CPP_OPTION (pfile, main_search) == CMS_user
 692                       ? pfile->quote_include
 693                       : CPP_OPTION (pfile, main_search) == CMS_system
 694                       ? pfile->bracket_include : &pfile->no_search_path,
 695                       /*angle=*/0, _cpp_FFK_NORMAL, 0);
 696
 697   if (_cpp_find_failed (pfile->main_file))
 698     return NULL;
 699
 700   _cpp_stack_file (pfile, pfile->main_file,
 701                    injecting || CPP_OPTION (pfile, preprocessed)
 702                    ? IT_PRE_MAIN : IT_MAIN, 0);
 703
 704   /* For foo.i, read the original filename foo.c now, for the benefit
 705      of the front ends.  */
 706   if (CPP_OPTION (pfile, preprocessed))
 707     if (!read_original_filename (pfile))
 708       {
 709         /* We're on line 1 after all.  */
 710         auto *last = linemap_check_ordinary
 711           (LINEMAPS_LAST_MAP (pfile->line_table, false));
 712         last->to_line = 1;
 713         /* Inform of as-if a file change.  */
 714         _cpp_do_file_change (pfile, LC_RENAME_VERBATIM, LINEMAP_FILE (last),
 715                              LINEMAP_LINE (last), LINEMAP_SYSP (last));
 716       }
 717
 718   auto *map = LINEMAPS_LAST_ORDINARY_MAP (pfile->line_table);
 719   pfile->main_loc = MAP_START_LOCATION (map);
 720
 721   return ORDINARY_MAP_FILE_NAME (map);
 722 }
 723
 724 location_t
 725 cpp_main_loc (const cpp_reader *pfile)
 726 {
 727   return pfile->main_loc;
 728 }
 729
 730 /* For preprocessed files, if the very first characters are
 731    '#<SPACE>[01]<SPACE>', then handle a line directive so we know the
 732    original file name.  This will generate file_change callbacks,
 733    which the front ends must handle appropriately given their state of
 734    initialization.  We peek directly into the character buffer, so
 735    that we're not confused by otherwise-skipped white space &
 736    comments.  We can be very picky, because this should have been
 737    machine-generated text (by us, no less).  This way we do not
 738    interfere with the module directive state machine.  */
 739
 740 static bool
 741 read_original_filename (cpp_reader *pfile)
 742 {
 743   auto *buf = pfile->buffer->next_line;
 744
 745   if (pfile->buffer->rlimit - buf > 4
 746       && buf[0] == '#'
 747       && buf[1] == ' '
 748       // Also permit '1', as that's what used to be here
 749       && (buf[2] == '0' || buf[2] == '1')
 750       && buf[3] == ' ')
 751     {
 752       const cpp_token *token = _cpp_lex_direct (pfile);
 753       gcc_checking_assert (token->type == CPP_HASH);
 754       if (_cpp_handle_directive (pfile, token->flags & PREV_WHITE))
 755         {
 756           read_original_directory (pfile);
 757
 758           auto *penult = &linemap_check_ordinary
 759             (LINEMAPS_LAST_MAP (pfile->line_table, false))[-1];
 760           if (penult[1].reason == LC_RENAME_VERBATIM)
 761             {
 762               /* Expunge any evidence of the original linemap.  */
 763               pfile->line_table->highest_location
 764                 = pfile->line_table->highest_line
 765                 = penult[0].start_location;
 766
 767               penult[1].start_location = penult[0].start_location;
 768               penult[1].reason = penult[0].reason;
 769               penult[0] = penult[1];
 770               pfile->line_table->info_ordinary.used--;
 771               pfile->line_table->info_ordinary.cache = 0;
 772             }
 773
 774           return true;
 775         }
 776     }
 777
 778   return false;
 779 }
 780
 781 /* For preprocessed files, if the tokens following the first filename
 782    line is of the form # <line> "/path/name//", handle the
 783    directive so we know the original current directory.
 784
 785    As with the first line peeking, we can do this without lexing by
 786    being picky.  */
 787 static void
 788 read_original_directory (cpp_reader *pfile)
 789 {
 790   auto *buf = pfile->buffer->next_line;
 791
 792   if (pfile->buffer->rlimit - buf > 4
 793       && buf[0] == '#'
 794       && buf[1] == ' '
 795       // Also permit '1', as that's what used to be here
 796       && (buf[2] == '0' || buf[2] == '1')
 797       && buf[3] == ' ')
 798     {
 799       const cpp_token *hash = _cpp_lex_direct (pfile);
 800       gcc_checking_assert (hash->type == CPP_HASH);
 801       pfile->state.in_directive = 1;
 802       const cpp_token *number = _cpp_lex_direct (pfile);
 803       gcc_checking_assert (number->type == CPP_NUMBER);
 804       const cpp_token *string = _cpp_lex_direct (pfile);
 805       pfile->state.in_directive = 0;
 806
 807       const unsigned char *text = nullptr;
 808       size_t len = 0;
 809       if (string->type == CPP_STRING)
 810         {
 811           /* The string value includes the quotes.  */
 812           text = string->val.str.text;
 813           len = string->val.str.len;
 814         }
 815       if (len < 5
 816           || !IS_DIR_SEPARATOR (text[len - 2])
 817           || !IS_DIR_SEPARATOR (text[len - 3]))
 818         {
 819           /* That didn't work out, back out.   */
 820           _cpp_backup_tokens (pfile, 3);
 821           return;
 822         }
 823
 824       if (pfile->cb.dir_change)
 825         {
 826           /* Smash the string directly, it's dead at this point  */
 827           char *smashy = (char *)text;
 828           smashy[len - 3] = 0;
 829
 830           pfile->cb.dir_change (pfile, smashy + 1);
 831         }
 832
 833       /* We should be at EOL.  */
 834     }
 835 }
 836
 837 /* This is called at the end of preprocessing.  It pops the last
 838    buffer and writes dependency output.
 839
 840    Maybe it should also reset state, such that you could call
 841    cpp_start_read with a new filename to restart processing.  */
 842 void
 843 cpp_finish (cpp_reader *pfile, FILE *deps_stream)
 844 {
 845   /* Warn about unused macros before popping the final buffer.  */
 846   if (CPP_OPTION (pfile, warn_unused_macros))
 847     cpp_forall_identifiers (pfile, _cpp_warn_if_unused_macro, NULL);
 848
 849   /* lex.c leaves the final buffer on the stack.  This it so that
 850      it returns an unending stream of CPP_EOFs to the client.  If we
 851      popped the buffer, we'd dereference a NULL buffer pointer and
 852      segfault.  It's nice to allow the client to do worry-free excess
 853      cpp_get_token calls.  */
 854   while (pfile->buffer)
 855     _cpp_pop_buffer (pfile);
 856
 857   if (deps_stream)
 858     deps_write (pfile, deps_stream, 72);
 859
 860   /* Report on headers that could use multiple include guards.  */
 861   if (CPP_OPTION (pfile, print_include_names))
 862     _cpp_report_missing_guards (pfile);
 863 }
 864
 865 static void
 866 post_options (cpp_reader *pfile)
 867 {
 868   /* -Wtraditional is not useful in C++ mode.  */
 869   if (CPP_OPTION (pfile, cplusplus))
 870     CPP_OPTION (pfile, cpp_warn_traditional) = 0;
 871
 872   /* Permanently disable macro expansion if we are rescanning
 873      preprocessed text.  Read preprocesed source in ISO mode.  */
 874   if (CPP_OPTION (pfile, preprocessed))
 875     {
 876       if (!CPP_OPTION (pfile, directives_only))
 877         pfile->state.prevent_expansion = 1;
 878       CPP_OPTION (pfile, traditional) = 0;
 879     }
 880
 881   if (CPP_OPTION (pfile, warn_trigraphs) == 2)
 882     CPP_OPTION (pfile, warn_trigraphs) = !CPP_OPTION (pfile, trigraphs);
 883
 884   if (CPP_OPTION (pfile, traditional))
 885     {
 886       CPP_OPTION (pfile, trigraphs) = 0;
 887       CPP_OPTION (pfile, warn_trigraphs) = 0;
 888     }
 889
 890   if (CPP_OPTION (pfile, module_directives))
 891     {
 892       /* These unspellable tokens have a leading space.  */
 893       const char *const inits[spec_nodes::M_HWM]
 894         = {"export ", "module ", "import ", "__import"};
 895
 896       for (int ix = 0; ix != spec_nodes::M_HWM; ix++)
 897         {
 898           cpp_hashnode *node = cpp_lookup (pfile, UC (inits[ix]),
 899                                            strlen (inits[ix]));
 900
 901           /* Token we pass to the compiler.  */
 902           pfile->spec_nodes.n_modules[ix][1] = node;
 903
 904           if (ix != spec_nodes::M__IMPORT)
 905             /* Token we recognize when lexing, drop the trailing ' '.  */
 906             node = cpp_lookup (pfile, NODE_NAME (node), NODE_LEN (node) - 1);
 907
 908           node->flags |= NODE_MODULE;
 909           pfile->spec_nodes.n_modules[ix][0] = node;
 910         }
 911     }
 912 }