libcpp/directives.c

   1 /* CPP Library. (Directive handling.)
   2    Copyright (C) 1986-2019 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 "obstack.h"
  27
  28 /* Stack of conditionals currently in progress
  29    (including both successful and failing conditionals).  */
  30 struct if_stack
  31 {
  32   struct if_stack *next;
  33   location_t line;              /* Line where condition started.  */
  34   const cpp_hashnode *mi_cmacro;/* macro name for #ifndef around entire file */
  35   bool skip_elses;              /* Can future #else / #elif be skipped?  */
  36   bool was_skipping;            /* If were skipping on entry.  */
  37   int type;                     /* Most recent conditional for diagnostics.  */
  38 };
  39
  40 /* Contains a registered pragma or pragma namespace.  */
  41 typedef void (*pragma_cb) (cpp_reader *);
  42 struct pragma_entry
  43 {
  44   struct pragma_entry *next;
  45   const cpp_hashnode *pragma;   /* Name and length.  */
  46   bool is_nspace;
  47   bool is_internal;
  48   bool is_deferred;
  49   bool allow_expansion;
  50   union {
  51     pragma_cb handler;
  52     struct pragma_entry *space;
  53     unsigned int ident;
  54   } u;
  55 };
  56
  57 /* Values for the origin field of struct directive.  KANDR directives
  58    come from traditional (K&R) C.  STDC89 directives come from the
  59    1989 C standard.  EXTENSION directives are extensions.  */
  60 #define KANDR           0
  61 #define STDC89          1
  62 #define EXTENSION       2
  63
  64 /* Values for the flags field of struct directive.  COND indicates a
  65    conditional; IF_COND an opening conditional.  INCL means to treat
  66    "..." and <...> as q-char and h-char sequences respectively.  IN_I
  67    means this directive should be handled even if -fpreprocessed is in
  68    effect (these are the directives with callback hooks).
  69
  70    EXPAND is set on directives that are always macro-expanded.  */
  71 #define COND            (1 << 0)
  72 #define IF_COND         (1 << 1)
  73 #define INCL            (1 << 2)
  74 #define IN_I            (1 << 3)
  75 #define EXPAND          (1 << 4)
  76 #define DEPRECATED      (1 << 5)
  77
  78 /* Defines one #-directive, including how to handle it.  */
  79 typedef void (*directive_handler) (cpp_reader *);
  80 typedef struct directive directive;
  81 struct directive
  82 {
  83   directive_handler handler;    /* Function to handle directive.  */
  84   const uchar *name;            /* Name of directive.  */
  85   unsigned short length;        /* Length of name.  */
  86   unsigned char origin;         /* Origin of directive.  */
  87   unsigned char flags;          /* Flags describing this directive.  */
  88 };
  89
  90 /* Forward declarations.  */
  91
  92 static void skip_rest_of_line (cpp_reader *);
  93 static void check_eol (cpp_reader *, bool);
  94 static void start_directive (cpp_reader *);
  95 static void prepare_directive_trad (cpp_reader *);
  96 static void end_directive (cpp_reader *, int);
  97 static void directive_diagnostics (cpp_reader *, const directive *, int);
  98 static void run_directive (cpp_reader *, int, const char *, size_t);
  99 static char *glue_header_name (cpp_reader *);
 100 static const char *parse_include (cpp_reader *, int *, const cpp_token ***,
 101                                   location_t *);
 102 static void push_conditional (cpp_reader *, int, int, const cpp_hashnode *);
 103 static unsigned int read_flag (cpp_reader *, unsigned int);
 104 static bool strtolinenum (const uchar *, size_t, linenum_type *, bool *);
 105 static void do_diagnostic (cpp_reader *, enum cpp_diagnostic_level code,
 106                            enum cpp_warning_reason reason, int);
 107 static cpp_hashnode *lex_macro_node (cpp_reader *, bool);
 108 static int undefine_macros (cpp_reader *, cpp_hashnode *, void *);
 109 static void do_include_common (cpp_reader *, enum include_type);
 110 static struct pragma_entry *lookup_pragma_entry (struct pragma_entry *,
 111                                                  const cpp_hashnode *);
 112 static int count_registered_pragmas (struct pragma_entry *);
 113 static char ** save_registered_pragmas (struct pragma_entry *, char **);
 114 static char ** restore_registered_pragmas (cpp_reader *, struct pragma_entry *,
 115                                            char **);
 116 static void do_pragma_once (cpp_reader *);
 117 static void do_pragma_poison (cpp_reader *);
 118 static void do_pragma_system_header (cpp_reader *);
 119 static void do_pragma_dependency (cpp_reader *);
 120 static void do_pragma_warning_or_error (cpp_reader *, bool error);
 121 static void do_pragma_warning (cpp_reader *);
 122 static void do_pragma_error (cpp_reader *);
 123 static void do_linemarker (cpp_reader *);
 124 static const cpp_token *get_token_no_padding (cpp_reader *);
 125 static const cpp_token *get__Pragma_string (cpp_reader *);
 126 static void destringize_and_run (cpp_reader *, const cpp_string *,
 127                                  location_t);
 128 static bool parse_answer (cpp_reader *, int, location_t, cpp_macro **);
 129 static cpp_hashnode *parse_assertion (cpp_reader *, int, cpp_macro **);
 130 static cpp_macro **find_answer (cpp_hashnode *, const cpp_macro *);
 131 static void handle_assertion (cpp_reader *, const char *, int);
 132 static void do_pragma_push_macro (cpp_reader *);
 133 static void do_pragma_pop_macro (cpp_reader *);
 134 static void cpp_pop_definition (cpp_reader *, struct def_pragma_macro *);
 135
 136 /* This is the table of directive handlers.  All extensions other than
 137    #warning, #include_next, and #import are deprecated.  The name is
 138    where the extension appears to have come from.  */
 139
 140 #define DIRECTIVE_TABLE                                                 \
 141   D(define,     T_DEFINE = 0,   KANDR,     IN_I)                        \
 142   D(include,    T_INCLUDE,      KANDR,     INCL | EXPAND)               \
 143   D(endif,      T_ENDIF,        KANDR,     COND)                        \
 144   D(ifdef,      T_IFDEF,        KANDR,     COND | IF_COND)              \
 145   D(if,         T_IF,           KANDR,     COND | IF_COND | EXPAND)     \
 146   D(else,       T_ELSE,         KANDR,     COND)                        \
 147   D(ifndef,     T_IFNDEF,       KANDR,     COND | IF_COND)              \
 148   D(undef,      T_UNDEF,        KANDR,     IN_I)                        \
 149   D(line,       T_LINE,         KANDR,     EXPAND)                      \
 150   D(elif,       T_ELIF,         STDC89,    COND | EXPAND)               \
 151   D(error,      T_ERROR,        STDC89,    0)                           \
 152   D(pragma,     T_PRAGMA,       STDC89,    IN_I)                        \
 153   D(warning,    T_WARNING,      EXTENSION, 0)                           \
 154   D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL | EXPAND)             \
 155   D(ident,      T_IDENT,        EXTENSION, IN_I)                        \
 156   D(import,     T_IMPORT,       EXTENSION, INCL | EXPAND)  /* ObjC */   \
 157   D(assert,     T_ASSERT,       EXTENSION, DEPRECATED)     /* SVR4 */   \
 158   D(unassert,   T_UNASSERT,     EXTENSION, DEPRECATED)     /* SVR4 */   \
 159   D(sccs,       T_SCCS,         EXTENSION, IN_I)           /*  SVR4? */
 160
 161 /* #sccs is synonymous with #ident.  */
 162 #define do_sccs do_ident
 163
 164 /* Use the table to generate a series of prototypes, an enum for the
 165    directive names, and an array of directive handlers.  */
 166
 167 #define D(name, t, o, f) static void do_##name (cpp_reader *);
 168 DIRECTIVE_TABLE
 169 #undef D
 170
 171 #define D(n, tag, o, f) tag,
 172 enum
 173 {
 174   DIRECTIVE_TABLE
 175   N_DIRECTIVES
 176 };
 177 #undef D
 178
 179 #define D(name, t, origin, flags) \
 180 { do_##name, (const uchar *) #name, \
 181   sizeof #name - 1, origin, flags },
 182 static const directive dtable[] =
 183 {
 184 DIRECTIVE_TABLE
 185 };
 186 #undef D
 187
 188 /* A NULL-terminated array of directive names for use
 189    when suggesting corrections for misspelled directives.  */
 190 #define D(name, t, origin, flags) #name,
 191 static const char * const directive_names[] = {
 192 DIRECTIVE_TABLE
 193   NULL
 194 };
 195 #undef D
 196
 197 #undef DIRECTIVE_TABLE
 198
 199 /* Wrapper struct directive for linemarkers.
 200    The origin is more or less true - the original K+R cpp
 201    did use this notation in its preprocessed output.  */
 202 static const directive linemarker_dir =
 203 {
 204   do_linemarker, UC"#", 1, KANDR, IN_I
 205 };
 206
 207 /* Skip any remaining tokens in a directive.  */
 208 static void
 209 skip_rest_of_line (cpp_reader *pfile)
 210 {
 211   /* Discard all stacked contexts.  */
 212   while (pfile->context->prev)
 213     _cpp_pop_context (pfile);
 214
 215   /* Sweep up all tokens remaining on the line.  */
 216   if (! SEEN_EOL ())
 217     while (_cpp_lex_token (pfile)->type != CPP_EOF)
 218       ;
 219 }
 220
 221 /* Helper function for check_oel.  */
 222
 223 static void
 224 check_eol_1 (cpp_reader *pfile, bool expand, enum cpp_warning_reason reason)
 225 {
 226   if (! SEEN_EOL () && (expand
 227                         ? cpp_get_token (pfile)
 228                         : _cpp_lex_token (pfile))->type != CPP_EOF)
 229     cpp_pedwarning (pfile, reason, "extra tokens at end of #%s directive",
 230                     pfile->directive->name);
 231 }
 232
 233 /* Variant of check_eol used for Wendif-labels warnings.  */
 234
 235 static void
 236 check_eol_endif_labels (cpp_reader *pfile)
 237 {
 238   check_eol_1 (pfile, false, CPP_W_ENDIF_LABELS);
 239 }
 240
 241 /* Ensure there are no stray tokens at the end of a directive.  If
 242    EXPAND is true, tokens macro-expanding to nothing are allowed.  */
 243
 244 static void
 245 check_eol (cpp_reader *pfile, bool expand)
 246 {
 247   check_eol_1 (pfile, expand, CPP_W_NONE);
 248 }
 249
 250 /* Ensure there are no stray tokens other than comments at the end of
 251    a directive, and gather the comments.  */
 252 static const cpp_token **
 253 check_eol_return_comments (cpp_reader *pfile)
 254 {
 255   size_t c;
 256   size_t capacity = 8;
 257   const cpp_token **buf;
 258
 259   buf = XNEWVEC (const cpp_token *, capacity);
 260   c = 0;
 261   if (! SEEN_EOL ())
 262     {
 263       while (1)
 264         {
 265           const cpp_token *tok;
 266
 267           tok = _cpp_lex_token (pfile);
 268           if (tok->type == CPP_EOF)
 269             break;
 270           if (tok->type != CPP_COMMENT)
 271             cpp_error (pfile, CPP_DL_PEDWARN,
 272                        "extra tokens at end of #%s directive",
 273                        pfile->directive->name);
 274           else
 275             {
 276               if (c + 1 >= capacity)
 277                 {
 278                   capacity *= 2;
 279                   buf = XRESIZEVEC (const cpp_token *, buf, capacity);
 280                 }
 281               buf[c] = tok;
 282               ++c;
 283             }
 284         }
 285     }
 286   buf[c] = NULL;
 287   return buf;
 288 }
 289
 290 /* Called when entering a directive, _Pragma or command-line directive.  */
 291 static void
 292 start_directive (cpp_reader *pfile)
 293 {
 294   /* Setup in-directive state.  */
 295   pfile->state.in_directive = 1;
 296   pfile->state.save_comments = 0;
 297   pfile->directive_result.type = CPP_PADDING;
 298
 299   /* Some handlers need the position of the # for diagnostics.  */
 300   pfile->directive_line = pfile->line_table->highest_line;
 301 }
 302
 303 /* Called when leaving a directive, _Pragma or command-line directive.  */
 304 static void
 305 end_directive (cpp_reader *pfile, int skip_line)
 306 {
 307   if (CPP_OPTION (pfile, traditional))
 308     {
 309       /* Revert change of prepare_directive_trad.  */
 310       if (!pfile->state.in_deferred_pragma)
 311         pfile->state.prevent_expansion--;
 312
 313       if (pfile->directive != &dtable[T_DEFINE])
 314         _cpp_remove_overlay (pfile);
 315     }
 316   else if (pfile->state.in_deferred_pragma)
 317     ;
 318   /* We don't skip for an assembler #.  */
 319   else if (skip_line)
 320     {
 321       skip_rest_of_line (pfile);
 322       if (!pfile->keep_tokens)
 323         {
 324           pfile->cur_run = &pfile->base_run;
 325           pfile->cur_token = pfile->base_run.base;
 326         }
 327     }
 328
 329   /* Restore state.  */
 330   pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
 331   pfile->state.in_directive = 0;
 332   pfile->state.in_expression = 0;
 333   pfile->state.angled_headers = 0;
 334   pfile->directive = 0;
 335 }
 336
 337 /* Prepare to handle the directive in pfile->directive.  */
 338 static void
 339 prepare_directive_trad (cpp_reader *pfile)
 340 {
 341   if (pfile->directive != &dtable[T_DEFINE])
 342     {
 343       bool no_expand = (pfile->directive
 344                         && ! (pfile->directive->flags & EXPAND));
 345       bool was_skipping = pfile->state.skipping;
 346
 347       pfile->state.in_expression = (pfile->directive == &dtable[T_IF]
 348                                     || pfile->directive == &dtable[T_ELIF]);
 349       if (pfile->state.in_expression)
 350         pfile->state.skipping = false;
 351
 352       if (no_expand)
 353         pfile->state.prevent_expansion++;
 354       _cpp_scan_out_logical_line (pfile, NULL, false);
 355       if (no_expand)
 356         pfile->state.prevent_expansion--;
 357
 358       pfile->state.skipping = was_skipping;
 359       _cpp_overlay_buffer (pfile, pfile->out.base,
 360                            pfile->out.cur - pfile->out.base);
 361     }
 362
 363   /* Stop ISO C from expanding anything.  */
 364   pfile->state.prevent_expansion++;
 365 }
 366
 367 /* Output diagnostics for a directive DIR.  INDENTED is nonzero if
 368    the '#' was indented.  */
 369 static void
 370 directive_diagnostics (cpp_reader *pfile, const directive *dir, int indented)
 371 {
 372   /* Issue -pedantic or deprecated warnings for extensions.  We let
 373      -pedantic take precedence if both are applicable.  */
 374   if (! pfile->state.skipping)
 375     {
 376       if (dir->origin == EXTENSION
 377           && !(dir == &dtable[T_IMPORT] && CPP_OPTION (pfile, objc))
 378           && CPP_PEDANTIC (pfile))
 379         cpp_error (pfile, CPP_DL_PEDWARN, "#%s is a GCC extension", dir->name);
 380       else if (((dir->flags & DEPRECATED) != 0
 381                 || (dir == &dtable[T_IMPORT] && !CPP_OPTION (pfile, objc)))
 382                && CPP_OPTION (pfile, cpp_warn_deprecated))
 383         cpp_warning (pfile, CPP_W_DEPRECATED,
 384                      "#%s is a deprecated GCC extension", dir->name);
 385     }
 386
 387   /* Traditionally, a directive is ignored unless its # is in
 388      column 1.  Therefore in code intended to work with K+R
 389      compilers, directives added by C89 must have their #
 390      indented, and directives present in traditional C must not.
 391      This is true even of directives in skipped conditional
 392      blocks.  #elif cannot be used at all.  */
 393   if (CPP_WTRADITIONAL (pfile))
 394     {
 395       if (dir == &dtable[T_ELIF])
 396         cpp_warning (pfile, CPP_W_TRADITIONAL,
 397                      "suggest not using #elif in traditional C");
 398       else if (indented && dir->origin == KANDR)
 399         cpp_warning (pfile, CPP_W_TRADITIONAL,
 400                      "traditional C ignores #%s with the # indented",
 401                      dir->name);
 402       else if (!indented && dir->origin != KANDR)
 403         cpp_warning (pfile, CPP_W_TRADITIONAL,
 404                      "suggest hiding #%s from traditional C with an indented #",
 405                      dir->name);
 406     }
 407 }
 408
 409 /* Check if we have a known directive.  INDENTED is nonzero if the
 410    '#' of the directive was indented.  This function is in this file
 411    to save unnecessarily exporting dtable etc. to lex.c.  Returns
 412    nonzero if the line of tokens has been handled, zero if we should
 413    continue processing the line.  */
 414 int
 415 _cpp_handle_directive (cpp_reader *pfile, int indented)
 416 {
 417   const directive *dir = 0;
 418   const cpp_token *dname;
 419   bool was_parsing_args = pfile->state.parsing_args;
 420   bool was_discarding_output = pfile->state.discarding_output;
 421   int skip = 1;
 422
 423   if (was_discarding_output)
 424     pfile->state.prevent_expansion = 0;
 425
 426   if (was_parsing_args)
 427     {
 428       if (CPP_OPTION (pfile, cpp_pedantic))
 429         cpp_error (pfile, CPP_DL_PEDWARN,
 430              "embedding a directive within macro arguments is not portable");
 431       pfile->state.parsing_args = 0;
 432       pfile->state.prevent_expansion = 0;
 433     }
 434   start_directive (pfile);
 435   dname = _cpp_lex_token (pfile);
 436
 437   if (dname->type == CPP_NAME)
 438     {
 439       if (dname->val.node.node->is_directive)
 440         dir = &dtable[dname->val.node.node->directive_index];
 441     }
 442   /* We do not recognize the # followed by a number extension in
 443      assembler code.  */
 444   else if (dname->type == CPP_NUMBER && CPP_OPTION (pfile, lang) != CLK_ASM)
 445     {
 446       dir = &linemarker_dir;
 447       if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, preprocessed)
 448           && ! pfile->state.skipping)
 449         cpp_error (pfile, CPP_DL_PEDWARN,
 450                    "style of line directive is a GCC extension");
 451     }
 452
 453   if (dir)
 454     {
 455       /* If we have a directive that is not an opening conditional,
 456          invalidate any control macro.  */
 457       if (! (dir->flags & IF_COND))
 458         pfile->mi_valid = false;
 459
 460       /* Kluge alert.  In order to be sure that code like this
 461
 462          #define HASH #
 463          HASH define foo bar
 464
 465          does not cause '#define foo bar' to get executed when
 466          compiled with -save-temps, we recognize directives in
 467          -fpreprocessed mode only if the # is in column 1.  macro.c
 468          puts a space in front of any '#' at the start of a macro.
 469
 470          We exclude the -fdirectives-only case because macro expansion
 471          has not been performed yet, and block comments can cause spaces
 472          to precede the directive.  */
 473       if (CPP_OPTION (pfile, preprocessed)
 474           && !CPP_OPTION (pfile, directives_only)
 475           && (indented || !(dir->flags & IN_I)))
 476         {
 477           skip = 0;
 478           dir = 0;
 479         }
 480       else
 481         {
 482           /* In failed conditional groups, all non-conditional
 483              directives are ignored.  Before doing that, whether
 484              skipping or not, we should lex angle-bracketed headers
 485              correctly, and maybe output some diagnostics.  */
 486           pfile->state.angled_headers = dir->flags & INCL;
 487           pfile->state.directive_wants_padding = dir->flags & INCL;
 488           if (! CPP_OPTION (pfile, preprocessed))
 489             directive_diagnostics (pfile, dir, indented);
 490           if (pfile->state.skipping && !(dir->flags & COND))
 491             dir = 0;
 492         }
 493     }
 494   else if (dname->type == CPP_EOF)
 495     ;   /* CPP_EOF is the "null directive".  */
 496   else
 497     {
 498       /* An unknown directive.  Don't complain about it in assembly
 499          source: we don't know where the comments are, and # may
 500          introduce assembler pseudo-ops.  Don't complain about invalid
 501          directives in skipped conditional groups (6.10 p4).  */
 502       if (CPP_OPTION (pfile, lang) == CLK_ASM)
 503         skip = 0;
 504       else if (!pfile->state.skipping)
 505         {
 506           const char *unrecognized
 507             = (const char *)cpp_token_as_text (pfile, dname);
 508           const char *hint = NULL;
 509
 510           /* Call back into gcc to get a spelling suggestion.  Ideally
 511              we'd just use best_match from gcc/spellcheck.h (and filter
 512              out the uncommon directives), but that requires moving it
 513              to a support library.  */
 514           if (pfile->cb.get_suggestion)
 515             hint = pfile->cb.get_suggestion (pfile, unrecognized,
 516                                              directive_names);
 517
 518           if (hint)
 519             {
 520               rich_location richloc (pfile->line_table, dname->src_loc);
 521               source_range misspelled_token_range
 522                 = get_range_from_loc (pfile->line_table, dname->src_loc);
 523               richloc.add_fixit_replace (misspelled_token_range, hint);
 524               cpp_error_at (pfile, CPP_DL_ERROR, &richloc,
 525                             "invalid preprocessing directive #%s;"
 526                             " did you mean #%s?",
 527                             unrecognized, hint);
 528             }
 529           else
 530             cpp_error (pfile, CPP_DL_ERROR,
 531                        "invalid preprocessing directive #%s",
 532                        unrecognized);
 533         }
 534     }
 535
 536   pfile->directive = dir;
 537   if (CPP_OPTION (pfile, traditional))
 538     prepare_directive_trad (pfile);
 539
 540   if (dir)
 541     pfile->directive->handler (pfile);
 542   else if (skip == 0)
 543     _cpp_backup_tokens (pfile, 1);
 544
 545   end_directive (pfile, skip);
 546   if (was_parsing_args && !pfile->state.in_deferred_pragma)
 547     {
 548       /* Restore state when within macro args.  */
 549       pfile->state.parsing_args = 2;
 550       pfile->state.prevent_expansion = 1;
 551     }
 552   if (was_discarding_output)
 553     pfile->state.prevent_expansion = 1;
 554   return skip;
 555 }
 556
 557 /* Directive handler wrapper used by the command line option
 558    processor.  BUF is \n terminated.  */
 559 static void
 560 run_directive (cpp_reader *pfile, int dir_no, const char *buf, size_t count)
 561 {
 562   cpp_push_buffer (pfile, (const uchar *) buf, count,
 563                    /* from_stage3 */ true);
 564   start_directive (pfile);
 565
 566   /* This is a short-term fix to prevent a leading '#' being
 567      interpreted as a directive.  */
 568   _cpp_clean_line (pfile);
 569
 570   pfile->directive = &dtable[dir_no];
 571   if (CPP_OPTION (pfile, traditional))
 572     prepare_directive_trad (pfile);
 573   pfile->directive->handler (pfile);
 574   end_directive (pfile, 1);
 575   _cpp_pop_buffer (pfile);
 576 }
 577
 578 /* Checks for validity the macro name in #define, #undef, #ifdef and
 579    #ifndef directives.  IS_DEF_OR_UNDEF is true if this call is
 580    processing a #define or #undefine directive, and false
 581    otherwise.  */
 582 static cpp_hashnode *
 583 lex_macro_node (cpp_reader *pfile, bool is_def_or_undef)
 584 {
 585   const cpp_token *token = _cpp_lex_token (pfile);
 586
 587   /* The token immediately after #define must be an identifier.  That
 588      identifier may not be "defined", per C99 6.10.8p4.
 589      In C++, it may not be any of the "named operators" either,
 590      per C++98 [lex.digraph], [lex.key].
 591      Finally, the identifier may not have been poisoned.  (In that case
 592      the lexer has issued the error message for us.)  */
 593
 594   if (token->type == CPP_NAME)
 595     {
 596       cpp_hashnode *node = token->val.node.node;
 597
 598       if (is_def_or_undef && node == pfile->spec_nodes.n_defined)
 599         cpp_error (pfile, CPP_DL_ERROR,
 600                    "\"defined\" cannot be used as a macro name");
 601       else if (is_def_or_undef
 602             && (node == pfile->spec_nodes.n__has_include__
 603              || node == pfile->spec_nodes.n__has_include_next__))
 604         cpp_error (pfile, CPP_DL_ERROR,
 605                    "\"__has_include__\" cannot be used as a macro name");
 606       else if (! (node->flags & NODE_POISONED))
 607         return node;
 608     }
 609   else if (token->flags & NAMED_OP)
 610     cpp_error (pfile, CPP_DL_ERROR,
 611        "\"%s\" cannot be used as a macro name as it is an operator in C++",
 612                NODE_NAME (token->val.node.node));
 613   else if (token->type == CPP_EOF)
 614     cpp_error (pfile, CPP_DL_ERROR, "no macro name given in #%s directive",
 615                pfile->directive->name);
 616   else
 617     cpp_error (pfile, CPP_DL_ERROR, "macro names must be identifiers");
 618
 619   return NULL;
 620 }
 621
 622 /* Process a #define directive.  Most work is done in macro.c.  */
 623 static void
 624 do_define (cpp_reader *pfile)
 625 {
 626   cpp_hashnode *node = lex_macro_node (pfile, true);
 627
 628   if (node)
 629     {
 630       /* If we have been requested to expand comments into macros,
 631          then re-enable saving of comments.  */
 632       pfile->state.save_comments =
 633         ! CPP_OPTION (pfile, discard_comments_in_macro_exp);
 634
 635       if (pfile->cb.before_define)
 636         pfile->cb.before_define (pfile);
 637
 638       if (_cpp_create_definition (pfile, node))
 639         if (pfile->cb.define)
 640           pfile->cb.define (pfile, pfile->directive_line, node);
 641
 642       node->flags &= ~NODE_USED;
 643     }
 644 }
 645
 646 /* Handle #undef.  Mark the identifier NT_VOID in the hash table.  */
 647 static void
 648 do_undef (cpp_reader *pfile)
 649 {
 650   cpp_hashnode *node = lex_macro_node (pfile, true);
 651
 652   if (node)
 653     {
 654       if (pfile->cb.before_define)
 655         pfile->cb.before_define (pfile);
 656
 657       if (pfile->cb.undef)
 658         pfile->cb.undef (pfile, pfile->directive_line, node);
 659
 660       /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified
 661          identifier is not currently defined as a macro name.  */
 662       if (cpp_macro_p (node))
 663         {
 664           if (node->flags & NODE_WARN)
 665             cpp_error (pfile, CPP_DL_WARNING,
 666                        "undefining \"%s\"", NODE_NAME (node));
 667           else if (cpp_builtin_macro_p (node)
 668                    && CPP_OPTION (pfile, warn_builtin_macro_redefined))
 669             cpp_warning_with_line (pfile, CPP_W_BUILTIN_MACRO_REDEFINED,
 670                                    pfile->directive_line, 0,
 671                                    "undefining \"%s\"", NODE_NAME (node));
 672
 673           if (CPP_OPTION (pfile, warn_unused_macros))
 674             _cpp_warn_if_unused_macro (pfile, node, NULL);
 675
 676           _cpp_free_definition (node);
 677         }
 678     }
 679
 680   check_eol (pfile, false);
 681 }
 682
 683 /* Undefine a single macro/assertion/whatever.  */
 684
 685 static int
 686 undefine_macros (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *h,
 687                  void *data_p ATTRIBUTE_UNUSED)
 688 {
 689   /* Body of _cpp_free_definition inlined here for speed.
 690      Macros and assertions no longer have anything to free.  */
 691   h->type = NT_VOID;
 692   h->value.answers = NULL;
 693   h->flags &= ~(NODE_POISONED|NODE_DISABLED|NODE_USED);
 694   return 1;
 695 }
 696
 697 /* Undefine all macros and assertions.  */
 698
 699 void
 700 cpp_undef_all (cpp_reader *pfile)
 701 {
 702   cpp_forall_identifiers (pfile, undefine_macros, NULL);
 703 }
 704
 705
 706 /* Helper routine used by parse_include.  Reinterpret the current line
 707    as an h-char-sequence (< ... >); we are looking at the first token
 708    after the <.  Returns a malloced filename.  */
 709 static char *
 710 glue_header_name (cpp_reader *pfile)
 711 {
 712   const cpp_token *token;
 713   char *buffer;
 714   size_t len, total_len = 0, capacity = 1024;
 715
 716   /* To avoid lexed tokens overwriting our glued name, we can only
 717      allocate from the string pool once we've lexed everything.  */
 718   buffer = XNEWVEC (char, capacity);
 719   for (;;)
 720     {
 721       token = get_token_no_padding (pfile);
 722
 723       if (token->type == CPP_GREATER)
 724         break;
 725       if (token->type == CPP_EOF)
 726         {
 727           cpp_error (pfile, CPP_DL_ERROR, "missing terminating > character");
 728           break;
 729         }
 730
 731       len = cpp_token_len (token) + 2; /* Leading space, terminating \0.  */
 732       if (total_len + len > capacity)
 733         {
 734           capacity = (capacity + len) * 2;
 735           buffer = XRESIZEVEC (char, buffer, capacity);
 736         }
 737
 738       if (token->flags & PREV_WHITE)
 739         buffer[total_len++] = ' ';
 740
 741       total_len = (cpp_spell_token (pfile, token, (uchar *) &buffer[total_len],
 742                                     true)
 743                    - (uchar *) buffer);
 744     }
 745
 746   buffer[total_len] = '\0';
 747   return buffer;
 748 }
 749
 750 /* Returns the file name of #include, #include_next, #import and
 751    #pragma dependency.  The string is malloced and the caller should
 752    free it.  Returns NULL on error.  LOCATION is the source location
 753    of the file name.  */
 754
 755 static const char *
 756 parse_include (cpp_reader *pfile, int *pangle_brackets,
 757                const cpp_token ***buf, location_t *location)
 758 {
 759   char *fname;
 760   const cpp_token *header;
 761
 762   /* Allow macro expansion.  */
 763   header = get_token_no_padding (pfile);
 764   *location = header->src_loc;
 765   if ((header->type == CPP_STRING && header->val.str.text[0] != 'R')
 766       || header->type == CPP_HEADER_NAME)
 767     {
 768       fname = XNEWVEC (char, header->val.str.len - 1);
 769       memcpy (fname, header->val.str.text + 1, header->val.str.len - 2);
 770       fname[header->val.str.len - 2] = '\0';
 771       *pangle_brackets = header->type == CPP_HEADER_NAME;
 772     }
 773   else if (header->type == CPP_LESS)
 774     {
 775       fname = glue_header_name (pfile);
 776       *pangle_brackets = 1;
 777     }
 778   else
 779     {
 780       const unsigned char *dir;
 781
 782       if (pfile->directive == &dtable[T_PRAGMA])
 783         dir = UC"pragma dependency";
 784       else
 785         dir = pfile->directive->name;
 786       cpp_error (pfile, CPP_DL_ERROR, "#%s expects \"FILENAME\" or <FILENAME>",
 787                  dir);
 788
 789       return NULL;
 790     }
 791
 792   if (pfile->directive == &dtable[T_PRAGMA])
 793     {
 794       /* This pragma allows extra tokens after the file name.  */
 795     }
 796   else if (buf == NULL || CPP_OPTION (pfile, discard_comments))
 797     check_eol (pfile, true);
 798   else
 799     {
 800       /* If we are not discarding comments, then gather them while
 801          doing the eol check.  */
 802       *buf = check_eol_return_comments (pfile);
 803     }
 804
 805   return fname;
 806 }
 807
 808 /* Handle #include, #include_next and #import.  */
 809 static void
 810 do_include_common (cpp_reader *pfile, enum include_type type)
 811 {
 812   const char *fname;
 813   int angle_brackets;
 814   const cpp_token **buf = NULL;
 815   location_t location;
 816
 817   /* Re-enable saving of comments if requested, so that the include
 818      callback can dump comments which follow #include.  */
 819   pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
 820
 821   fname = parse_include (pfile, &angle_brackets, &buf, &location);
 822   if (!fname)
 823     goto done;
 824
 825   if (!*fname)
 826     {
 827       cpp_error_with_line (pfile, CPP_DL_ERROR, location, 0,
 828                            "empty filename in #%s",
 829                            pfile->directive->name);
 830       goto done;
 831     }
 832
 833   /* Prevent #include recursion.  */
 834   if (pfile->line_table->depth >= CPP_STACK_MAX)
 835     cpp_error (pfile, CPP_DL_ERROR, "#include nested too deeply");
 836   else
 837     {
 838       /* Get out of macro context, if we are.  */
 839       skip_rest_of_line (pfile);
 840
 841       if (pfile->cb.include)
 842         pfile->cb.include (pfile, pfile->directive_line,
 843                            pfile->directive->name, fname, angle_brackets,
 844                            buf);
 845
 846       _cpp_stack_include (pfile, fname, angle_brackets, type, location);
 847     }
 848
 849  done:
 850   XDELETEVEC (fname);
 851   if (buf)
 852     XDELETEVEC (buf);
 853 }
 854
 855 static void
 856 do_include (cpp_reader *pfile)
 857 {
 858   do_include_common (pfile, IT_INCLUDE);
 859 }
 860
 861 static void
 862 do_import (cpp_reader *pfile)
 863 {
 864   do_include_common (pfile, IT_IMPORT);
 865 }
 866
 867 static void
 868 do_include_next (cpp_reader *pfile)
 869 {
 870   enum include_type type = IT_INCLUDE_NEXT;
 871
 872   /* If this is the primary source file, warn and use the normal
 873      search logic.  */
 874   if (cpp_in_primary_file (pfile))
 875     {
 876       cpp_error (pfile, CPP_DL_WARNING,
 877                  "#include_next in primary source file");
 878       type = IT_INCLUDE;
 879     }
 880   do_include_common (pfile, type);
 881 }
 882
 883 /* Subroutine of do_linemarker.  Read possible flags after file name.
 884    LAST is the last flag seen; 0 if this is the first flag. Return the
 885    flag if it is valid, 0 at the end of the directive. Otherwise
 886    complain.  */
 887 static unsigned int
 888 read_flag (cpp_reader *pfile, unsigned int last)
 889 {
 890   const cpp_token *token = _cpp_lex_token (pfile);
 891
 892   if (token->type == CPP_NUMBER && token->val.str.len == 1)
 893     {
 894       unsigned int flag = token->val.str.text[0] - '0';
 895
 896       if (flag > last && flag <= 4
 897           && (flag != 4 || last == 3)
 898           && (flag != 2 || last == 0))
 899         return flag;
 900     }
 901
 902   if (token->type != CPP_EOF)
 903     cpp_error (pfile, CPP_DL_ERROR, "invalid flag \"%s\" in line directive",
 904                cpp_token_as_text (pfile, token));
 905   return 0;
 906 }
 907
 908 /* Subroutine of do_line and do_linemarker.  Convert a number in STR,
 909    of length LEN, to binary; store it in NUMP, and return false if the
 910    number was well-formed, true if not. WRAPPED is set to true if the
 911    number did not fit into 'unsigned long'.  */
 912 static bool
 913 strtolinenum (const uchar *str, size_t len, linenum_type *nump, bool *wrapped)
 914 {
 915   linenum_type reg = 0;
 916   linenum_type reg_prev = 0;
 917
 918   uchar c;
 919   *wrapped = false;
 920   while (len--)
 921     {
 922       c = *str++;
 923       if (!ISDIGIT (c))
 924         return true;
 925       reg *= 10;
 926       reg += c - '0';
 927       if (reg < reg_prev)
 928         *wrapped = true;
 929       reg_prev = reg;
 930     }
 931   *nump = reg;
 932   return false;
 933 }
 934
 935 /* Interpret #line command.
 936    Note that the filename string (if any) is a true string constant
 937    (escapes are interpreted), unlike in #line.  */
 938 static void
 939 do_line (cpp_reader *pfile)
 940 {
 941   struct line_maps *line_table = pfile->line_table;
 942   const line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
 943
 944   /* skip_rest_of_line() may cause line table to be realloc()ed so note down
 945      sysp right now.  */
 946
 947   unsigned char map_sysp = ORDINARY_MAP_IN_SYSTEM_HEADER_P (map);
 948   const cpp_token *token;
 949   const char *new_file = ORDINARY_MAP_FILE_NAME (map);
 950   linenum_type new_lineno;
 951
 952   /* C99 raised the minimum limit on #line numbers.  */
 953   linenum_type cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
 954   bool wrapped;
 955
 956   /* #line commands expand macros.  */
 957   token = cpp_get_token (pfile);
 958   if (token->type != CPP_NUMBER
 959       || strtolinenum (token->val.str.text, token->val.str.len,
 960                        &new_lineno, &wrapped))
 961     {
 962       if (token->type == CPP_EOF)
 963         cpp_error (pfile, CPP_DL_ERROR, "unexpected end of file after #line");
 964       else
 965         cpp_error (pfile, CPP_DL_ERROR,
 966                    "\"%s\" after #line is not a positive integer",
 967                    cpp_token_as_text (pfile, token));
 968       return;
 969     }
 970
 971   if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap || wrapped))
 972     cpp_error (pfile, CPP_DL_PEDWARN, "line number out of range");
 973   else if (wrapped)
 974     cpp_error (pfile, CPP_DL_WARNING, "line number out of range");
 975
 976   token = cpp_get_token (pfile);
 977   if (token->type == CPP_STRING)
 978     {
 979       cpp_string s = { 0, 0 };
 980       if (cpp_interpret_string_notranslate (pfile, &token->val.str, 1,
 981                                             &s, CPP_STRING))
 982         new_file = (const char *)s.text;
 983       check_eol (pfile, true);
 984     }
 985   else if (token->type != CPP_EOF)
 986     {
 987       cpp_error (pfile, CPP_DL_ERROR, "\"%s\" is not a valid filename",
 988                  cpp_token_as_text (pfile, token));
 989       return;
 990     }
 991
 992   skip_rest_of_line (pfile);
 993   _cpp_do_file_change (pfile, LC_RENAME_VERBATIM, new_file, new_lineno,
 994                        map_sysp);
 995   line_table->seen_line_directive = true;
 996 }
 997
 998 /* Interpret the # 44 "file" [flags] notation, which has slightly
 999    different syntax and semantics from #line:  Flags are allowed,
1000    and we never complain about the line number being too big.  */
1001 static void
1002 do_linemarker (cpp_reader *pfile)
1003 {
1004   struct line_maps *line_table = pfile->line_table;
1005   const line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
1006   const cpp_token *token;
1007   const char *new_file = ORDINARY_MAP_FILE_NAME (map);
1008   linenum_type new_lineno;
1009   unsigned int new_sysp = ORDINARY_MAP_IN_SYSTEM_HEADER_P (map);
1010   enum lc_reason reason = LC_RENAME_VERBATIM;
1011   int flag;
1012   bool wrapped;
1013
1014   /* Back up so we can get the number again.  Putting this in
1015      _cpp_handle_directive risks two calls to _cpp_backup_tokens in
1016      some circumstances, which can segfault.  */
1017   _cpp_backup_tokens (pfile, 1);
1018
1019   /* #line commands expand macros.  */
1020   token = cpp_get_token (pfile);
1021   if (token->type != CPP_NUMBER
1022       || strtolinenum (token->val.str.text, token->val.str.len,
1023                        &new_lineno, &wrapped))
1024     {
1025       /* Unlike #line, there does not seem to be a way to get an EOF
1026          here.  So, it should be safe to always spell the token.  */
1027       cpp_error (pfile, CPP_DL_ERROR,
1028                  "\"%s\" after # is not a positive integer",
1029                  cpp_token_as_text (pfile, token));
1030       return;
1031     }
1032
1033   token = cpp_get_token (pfile);
1034   if (token->type == CPP_STRING)
1035     {
1036       cpp_string s = { 0, 0 };
1037       if (cpp_interpret_string_notranslate (pfile, &token->val.str,
1038                                             1, &s, CPP_STRING))
1039         new_file = (const char *)s.text;
1040
1041       new_sysp = 0;
1042       flag = read_flag (pfile, 0);
1043       if (flag == 1)
1044         {
1045           reason = LC_ENTER;
1046           /* Fake an include for cpp_included ().  */
1047           _cpp_fake_include (pfile, new_file);
1048           flag = read_flag (pfile, flag);
1049         }
1050       else if (flag == 2)
1051         {
1052           reason = LC_LEAVE;
1053           flag = read_flag (pfile, flag);
1054         }
1055       if (flag == 3)
1056         {
1057           new_sysp = 1;
1058           flag = read_flag (pfile, flag);
1059           if (flag == 4)
1060             new_sysp = 2;
1061         }
1062       pfile->buffer->sysp = new_sysp;
1063
1064       check_eol (pfile, false);
1065     }
1066   else if (token->type != CPP_EOF)
1067     {
1068       cpp_error (pfile, CPP_DL_ERROR, "\"%s\" is not a valid filename",
1069                  cpp_token_as_text (pfile, token));
1070       return;
1071     }
1072
1073   skip_rest_of_line (pfile);
1074
1075   if (reason == LC_LEAVE)
1076     {
1077       /* Reread map since cpp_get_token can invalidate it with a
1078          reallocation.  */
1079       map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
1080       const line_map_ordinary *from
1081         = linemap_included_from_linemap (line_table, map);
1082       if (MAIN_FILE_P (map)
1083           || (from
1084               && filename_cmp (ORDINARY_MAP_FILE_NAME (from), new_file) != 0))
1085         {
1086           cpp_warning (pfile, CPP_W_NONE,
1087                        "file \"%s\" linemarker ignored due to "
1088                        "incorrect nesting", new_file);
1089           return;
1090         }
1091     }
1092   /* Compensate for the increment in linemap_add that occurs in
1093      _cpp_do_file_change.  We're currently at the start of the line
1094      *following* the #line directive.  A separate location_t for this
1095      location makes no sense (until we do the LC_LEAVE), and
1096      complicates LAST_SOURCE_LINE_LOCATION.  */
1097   pfile->line_table->highest_location--;
1098
1099   _cpp_do_file_change (pfile, reason, new_file, new_lineno, new_sysp);
1100   line_table->seen_line_directive = true;
1101 }
1102
1103 /* Arrange the file_change callback.  pfile->line has changed to
1104    FILE_LINE of TO_FILE, for reason REASON.  SYSP is 1 for a system
1105    header, 2 for a system header that needs to be extern "C" protected,
1106    and zero otherwise.  */
1107 void
1108 _cpp_do_file_change (cpp_reader *pfile, enum lc_reason reason,
1109                      const char *to_file, linenum_type file_line,
1110                      unsigned int sysp)
1111 {
1112   linemap_assert (reason != LC_ENTER_MACRO);
1113   const struct line_map *map = linemap_add (pfile->line_table, reason, sysp,
1114                                             to_file, file_line);
1115   const line_map_ordinary *ord_map = NULL;
1116   if (map != NULL)
1117     {
1118       ord_map = linemap_check_ordinary (map);
1119       linemap_line_start (pfile->line_table,
1120                           ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map),
1121                           127);
1122     }
1123
1124   if (pfile->cb.file_change)
1125     pfile->cb.file_change (pfile, ord_map);
1126 }
1127
1128 /* Report a warning or error detected by the program we are
1129    processing.  Use the directive's tokens in the error message.  */
1130 static void
1131 do_diagnostic (cpp_reader *pfile, enum cpp_diagnostic_level code,
1132                enum cpp_warning_reason reason, int print_dir)
1133 {
1134   const unsigned char *dir_name;
1135   unsigned char *line;
1136   location_t src_loc = pfile->cur_token[-1].src_loc;
1137
1138   if (print_dir)
1139     dir_name = pfile->directive->name;
1140   else
1141     dir_name = NULL;
1142   pfile->state.prevent_expansion++;
1143   line = cpp_output_line_to_string (pfile, dir_name);
1144   pfile->state.prevent_expansion--;
1145
1146   if (code == CPP_DL_WARNING_SYSHDR && reason)
1147     cpp_warning_with_line_syshdr (pfile, reason, src_loc, 0, "%s", line);
1148   else if (code == CPP_DL_WARNING && reason)
1149     cpp_warning_with_line (pfile, reason, src_loc, 0, "%s", line);
1150   else
1151     cpp_error_with_line (pfile, code, src_loc, 0, "%s", line);
1152   free (line);
1153 }
1154
1155 static void
1156 do_error (cpp_reader *pfile)
1157 {
1158   do_diagnostic (pfile, CPP_DL_ERROR, CPP_W_NONE, 1);
1159 }
1160
1161 static void
1162 do_warning (cpp_reader *pfile)
1163 {
1164   /* We want #warning diagnostics to be emitted in system headers too.  */
1165   do_diagnostic (pfile, CPP_DL_WARNING_SYSHDR, CPP_W_WARNING_DIRECTIVE, 1);
1166 }
1167
1168 /* Report program identification.  */
1169 static void
1170 do_ident (cpp_reader *pfile)
1171 {
1172   const cpp_token *str = cpp_get_token (pfile);
1173
1174   if (str->type != CPP_STRING)
1175     cpp_error (pfile, CPP_DL_ERROR, "invalid #%s directive",
1176                pfile->directive->name);
1177   else if (pfile->cb.ident)
1178     pfile->cb.ident (pfile, pfile->directive_line, &str->val.str);
1179
1180   check_eol (pfile, false);
1181 }
1182
1183 /* Lookup a PRAGMA name in a singly-linked CHAIN.  Returns the
1184    matching entry, or NULL if none is found.  The returned entry could
1185    be the start of a namespace chain, or a pragma.  */
1186 static struct pragma_entry *
1187 lookup_pragma_entry (struct pragma_entry *chain, const cpp_hashnode *pragma)
1188 {
1189   while (chain && chain->pragma != pragma)
1190     chain = chain->next;
1191
1192   return chain;
1193 }
1194
1195 /* Create and insert a blank pragma entry at the beginning of a
1196    singly-linked CHAIN.  */
1197 static struct pragma_entry *
1198 new_pragma_entry (cpp_reader *pfile, struct pragma_entry **chain)
1199 {
1200   struct pragma_entry *new_entry;
1201
1202   new_entry = (struct pragma_entry *)
1203     _cpp_aligned_alloc (pfile, sizeof (struct pragma_entry));
1204
1205   memset (new_entry, 0, sizeof (struct pragma_entry));
1206   new_entry->next = *chain;
1207
1208   *chain = new_entry;
1209   return new_entry;
1210 }
1211
1212 /* Register a pragma NAME in namespace SPACE.  If SPACE is null, it
1213    goes in the global namespace.  */
1214 static struct pragma_entry *
1215 register_pragma_1 (cpp_reader *pfile, const char *space, const char *name,
1216                    bool allow_name_expansion)
1217 {
1218   struct pragma_entry **chain = &pfile->pragmas;
1219   struct pragma_entry *entry;
1220   const cpp_hashnode *node;
1221
1222   if (space)
1223     {
1224       node = cpp_lookup (pfile, UC space, strlen (space));
1225       entry = lookup_pragma_entry (*chain, node);
1226       if (!entry)
1227         {
1228           entry = new_pragma_entry (pfile, chain);
1229           entry->pragma = node;
1230           entry->is_nspace = true;
1231           entry->allow_expansion = allow_name_expansion;
1232         }
1233       else if (!entry->is_nspace)
1234         goto clash;
1235       else if (entry->allow_expansion != allow_name_expansion)
1236         {
1237           cpp_error (pfile, CPP_DL_ICE,
1238                      "registering pragmas in namespace \"%s\" with mismatched "
1239                      "name expansion", space);
1240           return NULL;
1241         }
1242       chain = &entry->u.space;
1243     }
1244   else if (allow_name_expansion)
1245     {
1246       cpp_error (pfile, CPP_DL_ICE,
1247                  "registering pragma \"%s\" with name expansion "
1248                  "and no namespace", name);
1249       return NULL;
1250     }
1251
1252   /* Check for duplicates.  */
1253   node = cpp_lookup (pfile, UC name, strlen (name));
1254   entry = lookup_pragma_entry (*chain, node);
1255   if (entry == NULL)
1256     {
1257       entry = new_pragma_entry (pfile, chain);
1258       entry->pragma = node;
1259       return entry;
1260     }
1261
1262   if (entry->is_nspace)
1263     clash:
1264     cpp_error (pfile, CPP_DL_ICE,
1265                "registering \"%s\" as both a pragma and a pragma namespace",
1266                NODE_NAME (node));
1267   else if (space)
1268     cpp_error (pfile, CPP_DL_ICE, "#pragma %s %s is already registered",
1269                space, name);
1270   else
1271     cpp_error (pfile, CPP_DL_ICE, "#pragma %s is already registered", name);
1272
1273   return NULL;
1274 }
1275
1276 /* Register a cpplib internal pragma SPACE NAME with HANDLER.  */
1277 static void
1278 register_pragma_internal (cpp_reader *pfile, const char *space,
1279                           const char *name, pragma_cb handler)
1280 {
1281   struct pragma_entry *entry;
1282
1283   entry = register_pragma_1 (pfile, space, name, false);
1284   entry->is_internal = true;
1285   entry->u.handler = handler;
1286 }
1287
1288 /* Register a pragma NAME in namespace SPACE.  If SPACE is null, it
1289    goes in the global namespace.  HANDLER is the handler it will call,
1290    which must be non-NULL.  If ALLOW_EXPANSION is set, allow macro
1291    expansion while parsing pragma NAME.  This function is exported
1292    from libcpp. */
1293 void
1294 cpp_register_pragma (cpp_reader *pfile, const char *space, const char *name,
1295                      pragma_cb handler, bool allow_expansion)
1296 {
1297   struct pragma_entry *entry;
1298
1299   if (!handler)
1300     {
1301       cpp_error (pfile, CPP_DL_ICE, "registering pragma with NULL handler");
1302       return;
1303     }
1304
1305   entry = register_pragma_1 (pfile, space, name, false);
1306   if (entry)
1307     {
1308       entry->allow_expansion = allow_expansion;
1309       entry->u.handler = handler;
1310     }
1311 }
1312
1313 /* Similarly, but create mark the pragma for deferred processing.
1314    When found, a CPP_PRAGMA token will be insertted into the stream
1315    with IDENT in the token->u.pragma slot.  */
1316 void
1317 cpp_register_deferred_pragma (cpp_reader *pfile, const char *space,
1318                               const char *name, unsigned int ident,
1319                               bool allow_expansion, bool allow_name_expansion)
1320 {
1321   struct pragma_entry *entry;
1322
1323   entry = register_pragma_1 (pfile, space, name, allow_name_expansion);
1324   if (entry)
1325     {
1326       entry->is_deferred = true;
1327       entry->allow_expansion = allow_expansion;
1328       entry->u.ident = ident;
1329     }
1330 }
1331
1332 /* Register the pragmas the preprocessor itself handles.  */
1333 void
1334 _cpp_init_internal_pragmas (cpp_reader *pfile)
1335 {
1336   /* Pragmas in the global namespace.  */
1337   register_pragma_internal (pfile, 0, "once", do_pragma_once);
1338   register_pragma_internal (pfile, 0, "push_macro", do_pragma_push_macro);
1339   register_pragma_internal (pfile, 0, "pop_macro", do_pragma_pop_macro);
1340
1341   /* New GCC-specific pragmas should be put in the GCC namespace.  */
1342   register_pragma_internal (pfile, "GCC", "poison", do_pragma_poison);
1343   register_pragma_internal (pfile, "GCC", "system_header",
1344                             do_pragma_system_header);
1345   register_pragma_internal (pfile, "GCC", "dependency", do_pragma_dependency);
1346   register_pragma_internal (pfile, "GCC", "warning", do_pragma_warning);
1347   register_pragma_internal (pfile, "GCC", "error", do_pragma_error);
1348 }
1349
1350 /* Return the number of registered pragmas in PE.  */
1351
1352 static int
1353 count_registered_pragmas (struct pragma_entry *pe)
1354 {
1355   int ct = 0;
1356   for (; pe != NULL; pe = pe->next)
1357     {
1358       if (pe->is_nspace)
1359         ct += count_registered_pragmas (pe->u.space);
1360       ct++;
1361     }
1362   return ct;
1363 }
1364
1365 /* Save into SD the names of the registered pragmas referenced by PE,
1366    and return a pointer to the next free space in SD.  */
1367
1368 static char **
1369 save_registered_pragmas (struct pragma_entry *pe, char **sd)
1370 {
1371   for (; pe != NULL; pe = pe->next)
1372     {
1373       if (pe->is_nspace)
1374         sd = save_registered_pragmas (pe->u.space, sd);
1375       *sd++ = (char *) xmemdup (HT_STR (&pe->pragma->ident),
1376                                 HT_LEN (&pe->pragma->ident),
1377                                 HT_LEN (&pe->pragma->ident) + 1);
1378     }
1379   return sd;
1380 }
1381
1382 /* Return a newly-allocated array which saves the names of the
1383    registered pragmas.  */
1384
1385 char **
1386 _cpp_save_pragma_names (cpp_reader *pfile)
1387 {
1388   int ct = count_registered_pragmas (pfile->pragmas);
1389   char **result = XNEWVEC (char *, ct);
1390   (void) save_registered_pragmas (pfile->pragmas, result);
1391   return result;
1392 }
1393
1394 /* Restore from SD the names of the registered pragmas referenced by PE,
1395    and return a pointer to the next unused name in SD.  */
1396
1397 static char **
1398 restore_registered_pragmas (cpp_reader *pfile, struct pragma_entry *pe,
1399                             char **sd)
1400 {
1401   for (; pe != NULL; pe = pe->next)
1402     {
1403       if (pe->is_nspace)
1404         sd = restore_registered_pragmas (pfile, pe->u.space, sd);
1405       pe->pragma = cpp_lookup (pfile, UC *sd, strlen (*sd));
1406       free (*sd);
1407       sd++;
1408     }
1409   return sd;
1410 }
1411
1412 /* Restore the names of the registered pragmas from SAVED.  */
1413
1414 void
1415 _cpp_restore_pragma_names (cpp_reader *pfile, char **saved)
1416 {
1417   (void) restore_registered_pragmas (pfile, pfile->pragmas, saved);
1418   free (saved);
1419 }
1420
1421 /* Pragmata handling.  We handle some, and pass the rest on to the
1422    front end.  C99 defines three pragmas and says that no macro
1423    expansion is to be performed on them; whether or not macro
1424    expansion happens for other pragmas is implementation defined.
1425    This implementation allows for a mix of both, since GCC did not
1426    traditionally macro expand its (few) pragmas, whereas OpenMP
1427    specifies that macro expansion should happen.  */
1428 static void
1429 do_pragma (cpp_reader *pfile)
1430 {
1431   const struct pragma_entry *p = NULL;
1432   const cpp_token *token, *pragma_token;
1433   location_t pragma_token_virt_loc = 0;
1434   cpp_token ns_token;
1435   unsigned int count = 1;
1436
1437   pfile->state.prevent_expansion++;
1438
1439   pragma_token = token = cpp_get_token_with_location (pfile,
1440                                                       &pragma_token_virt_loc);
1441   ns_token = *token;
1442   if (token->type == CPP_NAME)
1443     {
1444       p = lookup_pragma_entry (pfile->pragmas, token->val.node.node);
1445       if (p && p->is_nspace)
1446         {
1447           bool allow_name_expansion = p->allow_expansion;
1448           if (allow_name_expansion)
1449             pfile->state.prevent_expansion--;
1450
1451           token = cpp_get_token (pfile);
1452           if (token->type == CPP_NAME)
1453             p = lookup_pragma_entry (p->u.space, token->val.node.node);
1454           else
1455             p = NULL;
1456           if (allow_name_expansion)
1457             pfile->state.prevent_expansion++;
1458           count = 2;
1459         }
1460     }
1461
1462   if (p)
1463     {
1464       if (p->is_deferred)
1465         {
1466           pfile->directive_result.src_loc = pragma_token_virt_loc;
1467           pfile->directive_result.type = CPP_PRAGMA;
1468           pfile->directive_result.flags = pragma_token->flags;
1469           pfile->directive_result.val.pragma = p->u.ident;
1470           pfile->state.in_deferred_pragma = true;
1471           pfile->state.pragma_allow_expansion = p->allow_expansion;
1472           if (!p->allow_expansion)
1473             pfile->state.prevent_expansion++;
1474         }
1475       else
1476         {
1477           /* Since the handler below doesn't get the line number, that
1478              it might need for diagnostics, make sure it has the right
1479              numbers in place.  */
1480           if (pfile->cb.line_change)
1481             (*pfile->cb.line_change) (pfile, pragma_token, false);
1482           if (p->allow_expansion)
1483             pfile->state.prevent_expansion--;
1484           (*p->u.handler) (pfile);
1485           if (p->allow_expansion)
1486             pfile->state.prevent_expansion++;
1487         }
1488     }
1489   else if (pfile->cb.def_pragma)
1490     {
1491       if (count == 1 || pfile->context->prev == NULL)
1492         _cpp_backup_tokens (pfile, count);
1493       else
1494         {
1495           /* Invalid name comes from macro expansion, _cpp_backup_tokens
1496              won't allow backing 2 tokens.  */
1497           /* ??? The token buffer is leaked.  Perhaps if def_pragma hook
1498              reads both tokens, we could perhaps free it, but if it doesn't,
1499              we don't know the exact lifespan.  */
1500           cpp_token *toks = XNEWVEC (cpp_token, 2);
1501           toks[0] = ns_token;
1502           toks[0].flags |= NO_EXPAND;
1503           toks[1] = *token;
1504           toks[1].flags |= NO_EXPAND;
1505           _cpp_push_token_context (pfile, NULL, toks, 2);
1506         }
1507       pfile->cb.def_pragma (pfile, pfile->directive_line);
1508     }
1509
1510   pfile->state.prevent_expansion--;
1511 }
1512
1513 /* Handle #pragma once.  */
1514 static void
1515 do_pragma_once (cpp_reader *pfile)
1516 {
1517   if (cpp_in_primary_file (pfile))
1518     cpp_error (pfile, CPP_DL_WARNING, "#pragma once in main file");
1519
1520   check_eol (pfile, false);
1521   _cpp_mark_file_once_only (pfile, pfile->buffer->file);
1522 }
1523
1524 /* Handle #pragma push_macro(STRING).  */
1525 static void
1526 do_pragma_push_macro (cpp_reader *pfile)
1527 {
1528   cpp_hashnode *node;
1529   size_t defnlen;
1530   const uchar *defn = NULL;
1531   char *macroname, *dest;
1532   const char *limit, *src;
1533   const cpp_token *txt;
1534   struct def_pragma_macro *c;
1535
1536   txt = get__Pragma_string (pfile);
1537   if (!txt)
1538     {
1539       location_t src_loc = pfile->cur_token[-1].src_loc;
1540       cpp_error_with_line (pfile, CPP_DL_ERROR, src_loc, 0,
1541                  "invalid #pragma push_macro directive");
1542       check_eol (pfile, false);
1543       skip_rest_of_line (pfile);
1544       return;
1545     }
1546   dest = macroname = (char *) alloca (txt->val.str.len + 2);
1547   src = (const char *) (txt->val.str.text + 1 + (txt->val.str.text[0] == 'L'));
1548   limit = (const char *) (txt->val.str.text + txt->val.str.len - 1);
1549   while (src < limit)
1550     {
1551       /* We know there is a character following the backslash.  */
1552       if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1553         src++;
1554       *dest++ = *src++;
1555     }
1556   *dest = 0;
1557   check_eol (pfile, false);
1558   skip_rest_of_line (pfile);
1559   c = XNEW (struct def_pragma_macro);
1560   memset (c, 0, sizeof (struct def_pragma_macro));
1561   c->name = XNEWVAR (char, strlen (macroname) + 1);
1562   strcpy (c->name, macroname);
1563   c->next = pfile->pushed_macros;
1564   node = _cpp_lex_identifier (pfile, c->name);
1565   if (node->type == NT_VOID)
1566     c->is_undef = 1;
1567   else
1568     {
1569       defn = cpp_macro_definition (pfile, node);
1570       defnlen = ustrlen (defn);
1571       c->definition = XNEWVEC (uchar, defnlen + 2);
1572       c->definition[defnlen] = '\n';
1573       c->definition[defnlen + 1] = 0;
1574       c->line = node->value.macro->line;
1575       c->syshdr = node->value.macro->syshdr;
1576       c->used = node->value.macro->used;
1577       memcpy (c->definition, defn, defnlen);
1578     }
1579
1580   pfile->pushed_macros = c;
1581 }
1582
1583 /* Handle #pragma pop_macro(STRING).  */
1584 static void
1585 do_pragma_pop_macro (cpp_reader *pfile)
1586 {
1587   char *macroname, *dest;
1588   const char *limit, *src;
1589   const cpp_token *txt;
1590   struct def_pragma_macro *l = NULL, *c = pfile->pushed_macros;
1591   txt = get__Pragma_string (pfile);
1592   if (!txt)
1593     {
1594       location_t src_loc = pfile->cur_token[-1].src_loc;
1595       cpp_error_with_line (pfile, CPP_DL_ERROR, src_loc, 0,
1596                  "invalid #pragma pop_macro directive");
1597       check_eol (pfile, false);
1598       skip_rest_of_line (pfile);
1599       return;
1600     }
1601   dest = macroname = (char *) alloca (txt->val.str.len + 2);
1602   src = (const char *) (txt->val.str.text + 1 + (txt->val.str.text[0] == 'L'));
1603   limit = (const char *) (txt->val.str.text + txt->val.str.len - 1);
1604   while (src < limit)
1605     {
1606       /* We know there is a character following the backslash.  */
1607       if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1608         src++;
1609       *dest++ = *src++;
1610     }
1611   *dest = 0;
1612   check_eol (pfile, false);
1613   skip_rest_of_line (pfile);
1614
1615   while (c != NULL)
1616     {
1617       if (!strcmp (c->name, macroname))
1618         {
1619           if (!l)
1620             pfile->pushed_macros = c->next;
1621           else
1622             l->next = c->next;
1623           cpp_pop_definition (pfile, c);
1624           free (c->definition);
1625           free (c->name);
1626           free (c);
1627           break;
1628         }
1629       l = c;
1630       c = c->next;
1631     }
1632 }
1633
1634 /* Handle #pragma GCC poison, to poison one or more identifiers so
1635    that the lexer produces a hard error for each subsequent usage.  */
1636 static void
1637 do_pragma_poison (cpp_reader *pfile)
1638 {
1639   const cpp_token *tok;
1640   cpp_hashnode *hp;
1641
1642   pfile->state.poisoned_ok = 1;
1643   for (;;)
1644     {
1645       tok = _cpp_lex_token (pfile);
1646       if (tok->type == CPP_EOF)
1647         break;
1648       if (tok->type != CPP_NAME)
1649         {
1650           cpp_error (pfile, CPP_DL_ERROR,
1651                      "invalid #pragma GCC poison directive");
1652           break;
1653         }
1654
1655       hp = tok->val.node.node;
1656       if (hp->flags & NODE_POISONED)
1657         continue;
1658
1659       if (cpp_macro_p (hp))
1660         cpp_error (pfile, CPP_DL_WARNING, "poisoning existing macro \"%s\"",
1661                    NODE_NAME (hp));
1662       _cpp_free_definition (hp);
1663       hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1664     }
1665   pfile->state.poisoned_ok = 0;
1666 }
1667
1668 /* Mark the current header as a system header.  This will suppress
1669    some categories of warnings (notably those from -pedantic).  It is
1670    intended for use in system libraries that cannot be implemented in
1671    conforming C, but cannot be certain that their headers appear in a
1672    system include directory.  To prevent abuse, it is rejected in the
1673    primary source file.  */
1674 static void
1675 do_pragma_system_header (cpp_reader *pfile)
1676 {
1677   if (cpp_in_primary_file (pfile))
1678     cpp_error (pfile, CPP_DL_WARNING,
1679                "#pragma system_header ignored outside include file");
1680   else
1681     {
1682       check_eol (pfile, false);
1683       skip_rest_of_line (pfile);
1684       cpp_make_system_header (pfile, 1, 0);
1685     }
1686 }
1687
1688 /* Check the modified date of the current include file against a specified
1689    file. Issue a diagnostic, if the specified file is newer. We use this to
1690    determine if a fixed header should be refixed.  */
1691 static void
1692 do_pragma_dependency (cpp_reader *pfile)
1693 {
1694   const char *fname;
1695   int angle_brackets, ordering;
1696   location_t location;
1697
1698   fname = parse_include (pfile, &angle_brackets, NULL, &location);
1699   if (!fname)
1700     return;
1701
1702   ordering = _cpp_compare_file_date (pfile, fname, angle_brackets);
1703   if (ordering < 0)
1704     cpp_error (pfile, CPP_DL_WARNING, "cannot find source file %s", fname);
1705   else if (ordering > 0)
1706     {
1707       cpp_error (pfile, CPP_DL_WARNING,
1708                  "current file is older than %s", fname);
1709       if (cpp_get_token (pfile)->type != CPP_EOF)
1710         {
1711           _cpp_backup_tokens (pfile, 1);
1712           do_diagnostic (pfile, CPP_DL_WARNING, CPP_W_NONE, 0);
1713         }
1714     }
1715
1716   free ((void *) fname);
1717 }
1718
1719 /* Issue a diagnostic with the message taken from the pragma.  If
1720    ERROR is true, the diagnostic is a warning, otherwise, it is an
1721    error.  */
1722 static void
1723 do_pragma_warning_or_error (cpp_reader *pfile, bool error)
1724 {
1725   const cpp_token *tok = _cpp_lex_token (pfile);
1726   cpp_string str;
1727   if (tok->type != CPP_STRING
1728       || !cpp_interpret_string_notranslate (pfile, &tok->val.str, 1, &str,
1729                                             CPP_STRING)
1730       || str.len == 0)
1731     {
1732       cpp_error (pfile, CPP_DL_ERROR, "invalid \"#pragma GCC %s\" directive",
1733                  error ? "error" : "warning");
1734       return;
1735     }
1736   cpp_error (pfile, error ? CPP_DL_ERROR : CPP_DL_WARNING,
1737              "%s", str.text);
1738   free ((void *)str.text);
1739 }
1740
1741 /* Issue a warning diagnostic.  */
1742 static void
1743 do_pragma_warning (cpp_reader *pfile)
1744 {
1745   do_pragma_warning_or_error (pfile, false);
1746 }
1747
1748 /* Issue an error diagnostic.  */
1749 static void
1750 do_pragma_error (cpp_reader *pfile)
1751 {
1752   do_pragma_warning_or_error (pfile, true);
1753 }
1754
1755 /* Get a token but skip padding.  */
1756 static const cpp_token *
1757 get_token_no_padding (cpp_reader *pfile)
1758 {
1759   for (;;)
1760     {
1761       const cpp_token *result = cpp_get_token (pfile);
1762       if (result->type != CPP_PADDING)
1763         return result;
1764     }
1765 }
1766
1767 /* Check syntax is "(string-literal)".  Returns the string on success,
1768    or NULL on failure.  */
1769 static const cpp_token *
1770 get__Pragma_string (cpp_reader *pfile)
1771 {
1772   const cpp_token *string;
1773   const cpp_token *paren;
1774
1775   paren = get_token_no_padding (pfile);
1776   if (paren->type == CPP_EOF)
1777     _cpp_backup_tokens (pfile, 1);
1778   if (paren->type != CPP_OPEN_PAREN)
1779     return NULL;
1780
1781   string = get_token_no_padding (pfile);
1782   if (string->type == CPP_EOF)
1783     _cpp_backup_tokens (pfile, 1);
1784   if (string->type != CPP_STRING && string->type != CPP_WSTRING
1785       && string->type != CPP_STRING32 && string->type != CPP_STRING16
1786       && string->type != CPP_UTF8STRING)
1787     return NULL;
1788
1789   paren = get_token_no_padding (pfile);
1790   if (paren->type == CPP_EOF)
1791     _cpp_backup_tokens (pfile, 1);
1792   if (paren->type != CPP_CLOSE_PAREN)
1793     return NULL;
1794
1795   return string;
1796 }
1797
1798 /* Destringize IN into a temporary buffer, by removing the first \ of
1799    \" and \\ sequences, and process the result as a #pragma directive.  */
1800 static void
1801 destringize_and_run (cpp_reader *pfile, const cpp_string *in,
1802                      location_t expansion_loc)
1803 {
1804   const unsigned char *src, *limit;
1805   char *dest, *result;
1806   cpp_context *saved_context;
1807   cpp_token *saved_cur_token;
1808   tokenrun *saved_cur_run;
1809   cpp_token *toks;
1810   int count;
1811   const struct directive *save_directive;
1812
1813   dest = result = (char *) alloca (in->len - 1);
1814   src = in->text + 1 + (in->text[0] == 'L');
1815   limit = in->text + in->len - 1;
1816   while (src < limit)
1817     {
1818       /* We know there is a character following the backslash.  */
1819       if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1820         src++;
1821       *dest++ = *src++;
1822     }
1823   *dest = '\n';
1824
1825   /* Ugh; an awful kludge.  We are really not set up to be lexing
1826      tokens when in the middle of a macro expansion.  Use a new
1827      context to force cpp_get_token to lex, and so skip_rest_of_line
1828      doesn't go beyond the end of the text.  Also, remember the
1829      current lexing position so we can return to it later.
1830
1831      Something like line-at-a-time lexing should remove the need for
1832      this.  */
1833   saved_context = pfile->context;
1834   saved_cur_token = pfile->cur_token;
1835   saved_cur_run = pfile->cur_run;
1836
1837   pfile->context = XCNEW (cpp_context);
1838
1839   /* Inline run_directive, since we need to delay the _cpp_pop_buffer
1840      until we've read all of the tokens that we want.  */
1841   cpp_push_buffer (pfile, (const uchar *) result, dest - result,
1842                    /* from_stage3 */ true);
1843   /* ??? Antique Disgusting Hack.  What does this do?  */
1844   if (pfile->buffer->prev)
1845     pfile->buffer->file = pfile->buffer->prev->file;
1846
1847   start_directive (pfile);
1848   _cpp_clean_line (pfile);
1849   save_directive = pfile->directive;
1850   pfile->directive = &dtable[T_PRAGMA];
1851   do_pragma (pfile);
1852   end_directive (pfile, 1);
1853   pfile->directive = save_directive;
1854
1855   /* We always insert at least one token, the directive result.  It'll
1856      either be a CPP_PADDING or a CPP_PRAGMA.  In the later case, we
1857      need to insert *all* of the tokens, including the CPP_PRAGMA_EOL.  */
1858
1859   /* If we're not handling the pragma internally, read all of the tokens from
1860      the string buffer now, while the string buffer is still installed.  */
1861   /* ??? Note that the token buffer allocated here is leaked.  It's not clear
1862      to me what the true lifespan of the tokens are.  It would appear that
1863      the lifespan is the entire parse of the main input stream, in which case
1864      this may not be wrong.  */
1865   if (pfile->directive_result.type == CPP_PRAGMA)
1866     {
1867       int maxcount;
1868
1869       count = 1;
1870       maxcount = 50;
1871       toks = XNEWVEC (cpp_token, maxcount);
1872       toks[0] = pfile->directive_result;
1873
1874       do
1875         {
1876           if (count == maxcount)
1877             {
1878               maxcount = maxcount * 3 / 2;
1879               toks = XRESIZEVEC (cpp_token, toks, maxcount);
1880             }
1881           toks[count] = *cpp_get_token (pfile);
1882           /* _Pragma is a builtin, so we're not within a macro-map, and so
1883              the token locations are set to bogus ordinary locations
1884              near to, but after that of the "_Pragma".
1885              Paper over this by setting them equal to the location of the
1886              _Pragma itself (PR preprocessor/69126).  */
1887           toks[count].src_loc = expansion_loc;
1888           /* Macros have been already expanded by cpp_get_token
1889              if the pragma allowed expansion.  */
1890           toks[count++].flags |= NO_EXPAND;
1891         }
1892       while (toks[count-1].type != CPP_PRAGMA_EOL);
1893     }
1894   else
1895     {
1896       count = 1;
1897       toks = XNEW (cpp_token);
1898       toks[0] = pfile->directive_result;
1899
1900       /* If we handled the entire pragma internally, make sure we get the
1901          line number correct for the next token.  */
1902       if (pfile->cb.line_change)
1903         pfile->cb.line_change (pfile, pfile->cur_token, false);
1904     }
1905
1906   /* Finish inlining run_directive.  */
1907   pfile->buffer->file = NULL;
1908   _cpp_pop_buffer (pfile);
1909
1910   /* Reset the old macro state before ...  */
1911   XDELETE (pfile->context);
1912   pfile->context = saved_context;
1913   pfile->cur_token = saved_cur_token;
1914   pfile->cur_run = saved_cur_run;
1915
1916   /* ... inserting the new tokens we collected.  */
1917   _cpp_push_token_context (pfile, NULL, toks, count);
1918 }
1919
1920 /* Handle the _Pragma operator.  Return 0 on error, 1 if ok.  */
1921 int
1922 _cpp_do__Pragma (cpp_reader *pfile, location_t expansion_loc)
1923 {
1924   const cpp_token *string = get__Pragma_string (pfile);
1925   pfile->directive_result.type = CPP_PADDING;
1926
1927   if (string)
1928     {
1929       destringize_and_run (pfile, &string->val.str, expansion_loc);
1930       return 1;
1931     }
1932   cpp_error (pfile, CPP_DL_ERROR,
1933              "_Pragma takes a parenthesized string literal");
1934   return 0;
1935 }
1936
1937 /* Handle #ifdef.  */
1938 static void
1939 do_ifdef (cpp_reader *pfile)
1940 {
1941   int skip = 1;
1942
1943   if (! pfile->state.skipping)
1944     {
1945       cpp_hashnode *node = lex_macro_node (pfile, false);
1946
1947       if (node)
1948         {
1949           /* Do not treat conditional macros as being defined.  This is due to
1950              the powerpc and spu ports using conditional macros for 'vector',
1951              'bool', and 'pixel' to act as conditional keywords.  This messes
1952              up tests like #ifndef bool.  */
1953           skip = !cpp_macro_p (node) || (node->flags & NODE_CONDITIONAL);
1954           _cpp_mark_macro_used (node);
1955           _cpp_maybe_notify_macro_use (pfile, node);
1956           if (pfile->cb.used)
1957             pfile->cb.used (pfile, pfile->directive_line, node);
1958           check_eol (pfile, false);
1959         }
1960     }
1961
1962   push_conditional (pfile, skip, T_IFDEF, 0);
1963 }
1964
1965 /* Handle #ifndef.  */
1966 static void
1967 do_ifndef (cpp_reader *pfile)
1968 {
1969   int skip = 1;
1970   cpp_hashnode *node = 0;
1971
1972   if (! pfile->state.skipping)
1973     {
1974       node = lex_macro_node (pfile, false);
1975
1976       if (node)
1977         {
1978           /* Do not treat conditional macros as being defined.  This is due to
1979              the powerpc and spu ports using conditional macros for 'vector',
1980              'bool', and 'pixel' to act as conditional keywords.  This messes
1981              up tests like #ifndef bool.  */
1982           skip = (cpp_macro_p (node)
1983                   && !(node->flags & NODE_CONDITIONAL));
1984           _cpp_mark_macro_used (node);
1985           _cpp_maybe_notify_macro_use (pfile, node);
1986           if (pfile->cb.used)
1987             pfile->cb.used (pfile, pfile->directive_line, node);
1988           check_eol (pfile, false);
1989         }
1990     }
1991
1992   push_conditional (pfile, skip, T_IFNDEF, node);
1993 }
1994
1995 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1996    pfile->mi_ind_cmacro so we can handle multiple-include
1997    optimizations.  If macro expansion occurs in the expression, we
1998    cannot treat it as a controlling conditional, since the expansion
1999    could change in the future.  That is handled by cpp_get_token.  */
2000 static void
2001 do_if (cpp_reader *pfile)
2002 {
2003   int skip = 1;
2004
2005   if (! pfile->state.skipping)
2006     skip = _cpp_parse_expr (pfile, true) == false;
2007
2008   push_conditional (pfile, skip, T_IF, pfile->mi_ind_cmacro);
2009 }
2010
2011 /* Flip skipping state if appropriate and continue without changing
2012    if_stack; this is so that the error message for missing #endif's
2013    etc. will point to the original #if.  */
2014 static void
2015 do_else (cpp_reader *pfile)
2016 {
2017   cpp_buffer *buffer = pfile->buffer;
2018   struct if_stack *ifs = buffer->if_stack;
2019
2020   if (ifs == NULL)
2021     cpp_error (pfile, CPP_DL_ERROR, "#else without #if");
2022   else
2023     {
2024       if (ifs->type == T_ELSE)
2025         {
2026           cpp_error (pfile, CPP_DL_ERROR, "#else after #else");
2027           cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
2028                                "the conditional began here");
2029         }
2030       ifs->type = T_ELSE;
2031
2032       /* Skip any future (erroneous) #elses or #elifs.  */
2033       pfile->state.skipping = ifs->skip_elses;
2034       ifs->skip_elses = true;
2035
2036       /* Invalidate any controlling macro.  */
2037       ifs->mi_cmacro = 0;
2038
2039       /* Only check EOL if was not originally skipping.  */
2040       if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
2041         check_eol_endif_labels (pfile);
2042     }
2043 }
2044
2045 /* Handle a #elif directive by not changing if_stack either.  See the
2046    comment above do_else.  */
2047 static void
2048 do_elif (cpp_reader *pfile)
2049 {
2050   cpp_buffer *buffer = pfile->buffer;
2051   struct if_stack *ifs = buffer->if_stack;
2052
2053   if (ifs == NULL)
2054     cpp_error (pfile, CPP_DL_ERROR, "#elif without #if");
2055   else
2056     {
2057       if (ifs->type == T_ELSE)
2058         {
2059           cpp_error (pfile, CPP_DL_ERROR, "#elif after #else");
2060           cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
2061                                "the conditional began here");
2062         }
2063       ifs->type = T_ELIF;
2064
2065       /* See DR#412: "Only the first group whose control condition
2066          evaluates to true (nonzero) is processed; any following groups
2067          are skipped and their controlling directives are processed as
2068          if they were in a group that is skipped."  */
2069       if (ifs->skip_elses)
2070         pfile->state.skipping = 1;
2071       else
2072         {
2073           pfile->state.skipping = ! _cpp_parse_expr (pfile, false);
2074           ifs->skip_elses = ! pfile->state.skipping;
2075         }
2076
2077       /* Invalidate any controlling macro.  */
2078       ifs->mi_cmacro = 0;
2079     }
2080 }
2081
2082 /* #endif pops the if stack and resets pfile->state.skipping.  */
2083 static void
2084 do_endif (cpp_reader *pfile)
2085 {
2086   cpp_buffer *buffer = pfile->buffer;
2087   struct if_stack *ifs = buffer->if_stack;
2088
2089   if (ifs == NULL)
2090     cpp_error (pfile, CPP_DL_ERROR, "#endif without #if");
2091   else
2092     {
2093       /* Only check EOL if was not originally skipping.  */
2094       if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
2095         check_eol_endif_labels (pfile);
2096
2097       /* If potential control macro, we go back outside again.  */
2098       if (ifs->next == 0 && ifs->mi_cmacro)
2099         {
2100           pfile->mi_valid = true;
2101           pfile->mi_cmacro = ifs->mi_cmacro;
2102         }
2103
2104       buffer->if_stack = ifs->next;
2105       pfile->state.skipping = ifs->was_skipping;
2106       obstack_free (&pfile->buffer_ob, ifs);
2107     }
2108 }
2109
2110 /* Push an if_stack entry for a preprocessor conditional, and set
2111    pfile->state.skipping to SKIP.  If TYPE indicates the conditional
2112    is #if or #ifndef, CMACRO is a potentially controlling macro, and
2113    we need to check here that we are at the top of the file.  */
2114 static void
2115 push_conditional (cpp_reader *pfile, int skip, int type,
2116                   const cpp_hashnode *cmacro)
2117 {
2118   struct if_stack *ifs;
2119   cpp_buffer *buffer = pfile->buffer;
2120
2121   ifs = XOBNEW (&pfile->buffer_ob, struct if_stack);
2122   ifs->line = pfile->directive_line;
2123   ifs->next = buffer->if_stack;
2124   ifs->skip_elses = pfile->state.skipping || !skip;
2125   ifs->was_skipping = pfile->state.skipping;
2126   ifs->type = type;
2127   /* This condition is effectively a test for top-of-file.  */
2128   if (pfile->mi_valid && pfile->mi_cmacro == 0)
2129     ifs->mi_cmacro = cmacro;
2130   else
2131     ifs->mi_cmacro = 0;
2132
2133   pfile->state.skipping = skip;
2134   buffer->if_stack = ifs;
2135 }
2136
2137 /* Read the tokens of the answer into the macro pool, in a directive
2138    of type TYPE.  Only commit the memory if we intend it as permanent
2139    storage, i.e. the #assert case.  Returns 0 on success, and sets
2140    ANSWERP to point to the answer.  PRED_LOC is the location of the
2141    predicate.  */
2142 static bool
2143 parse_answer (cpp_reader *pfile, int type, location_t pred_loc,
2144               cpp_macro **answer_ptr)
2145 {
2146   /* In a conditional, it is legal to not have an open paren.  We
2147      should save the following token in this case.  */
2148   const cpp_token *paren = cpp_get_token (pfile);
2149
2150   /* If not a paren, see if we're OK.  */
2151   if (paren->type != CPP_OPEN_PAREN)
2152     {
2153       /* In a conditional no answer is a test for any answer.  It
2154          could be followed by any token.  */
2155       if (type == T_IF)
2156         {
2157           _cpp_backup_tokens (pfile, 1);
2158           return true;
2159         }
2160
2161       /* #unassert with no answer is valid - it removes all answers.  */
2162       if (type == T_UNASSERT && paren->type == CPP_EOF)
2163         return true;
2164
2165       cpp_error_with_line (pfile, CPP_DL_ERROR, pred_loc, 0,
2166                            "missing '(' after predicate");
2167       return false;
2168     }
2169
2170   cpp_macro *answer = _cpp_new_macro (pfile, cmk_assert,
2171                                       _cpp_reserve_room (pfile, 0,
2172                                                          sizeof (cpp_macro)));
2173   answer->parm.next = NULL;
2174   unsigned count = 0;
2175   for (;;)
2176     {
2177       const cpp_token *token = cpp_get_token (pfile);
2178
2179       if (token->type == CPP_CLOSE_PAREN)
2180         break;
2181
2182       if (token->type == CPP_EOF)
2183         {
2184           cpp_error (pfile, CPP_DL_ERROR, "missing ')' to complete answer");
2185           return false;
2186         }
2187
2188       answer = (cpp_macro *)_cpp_reserve_room
2189         (pfile, sizeof (cpp_macro) + count * sizeof (cpp_token),
2190          sizeof (cpp_token));
2191       answer->exp.tokens[count++] = *token;
2192     }
2193
2194   if (!count)
2195     {
2196       cpp_error (pfile, CPP_DL_ERROR, "predicate's answer is empty");
2197       return false;
2198     }
2199
2200   /* Drop whitespace at start, for answer equivalence purposes.  */
2201   answer->exp.tokens[0].flags &= ~PREV_WHITE;
2202
2203   answer->count = count;
2204   *answer_ptr = answer;
2205
2206   return true;
2207 }
2208
2209 /* Parses an assertion directive of type TYPE, returning a pointer to
2210    the hash node of the predicate, or 0 on error.  The node is
2211    guaranteed to be disjoint from the macro namespace, so can only
2212    have type 'NT_VOID'.  If an answer was supplied, it is placed in
2213    *ANSWER_PTR, which is otherwise set to 0.  */
2214 static cpp_hashnode *
2215 parse_assertion (cpp_reader *pfile, int type, cpp_macro **answer_ptr)
2216 {
2217   cpp_hashnode *result = 0;
2218
2219   /* We don't expand predicates or answers.  */
2220   pfile->state.prevent_expansion++;
2221
2222   *answer_ptr = NULL;
2223
2224   const cpp_token *predicate = cpp_get_token (pfile);
2225   if (predicate->type == CPP_EOF)
2226     cpp_error (pfile, CPP_DL_ERROR, "assertion without predicate");
2227   else if (predicate->type != CPP_NAME)
2228     cpp_error_with_line (pfile, CPP_DL_ERROR, predicate->src_loc, 0,
2229                          "predicate must be an identifier");
2230   else if (parse_answer (pfile, type, predicate->src_loc, answer_ptr))
2231     {
2232       unsigned int len = NODE_LEN (predicate->val.node.node);
2233       unsigned char *sym = (unsigned char *) alloca (len + 1);
2234
2235       /* Prefix '#' to get it out of macro namespace.  */
2236       sym[0] = '#';
2237       memcpy (sym + 1, NODE_NAME (predicate->val.node.node), len);
2238       result = cpp_lookup (pfile, sym, len + 1);
2239     }
2240
2241   pfile->state.prevent_expansion--;
2242
2243   return result;
2244 }
2245
2246 /* Returns a pointer to the pointer to CANDIDATE in the answer chain,
2247    or a pointer to NULL if the answer is not in the chain.  */
2248 static cpp_macro **
2249 find_answer (cpp_hashnode *node, const cpp_macro *candidate)
2250 {
2251   unsigned int i;
2252   cpp_macro **result = NULL;
2253
2254   for (result = &node->value.answers; *result; result = &(*result)->parm.next)
2255     {
2256       cpp_macro *answer = *result;
2257
2258       if (answer->count == candidate->count)
2259         {
2260           for (i = 0; i < answer->count; i++)
2261             if (!_cpp_equiv_tokens (&answer->exp.tokens[i],
2262                                     &candidate->exp.tokens[i]))
2263               break;
2264
2265           if (i == answer->count)
2266             break;
2267         }
2268     }
2269
2270   return result;
2271 }
2272
2273 /* Test an assertion within a preprocessor conditional.  Returns
2274    nonzero on failure, zero on success.  On success, the result of
2275    the test is written into VALUE, otherwise the value 0.  */
2276 int
2277 _cpp_test_assertion (cpp_reader *pfile, unsigned int *value)
2278 {
2279   cpp_macro *answer;
2280   cpp_hashnode *node = parse_assertion (pfile, T_IF, &answer);
2281
2282   /* For recovery, an erroneous assertion expression is handled as a
2283      failing assertion.  */
2284   *value = 0;
2285
2286   if (node)
2287     {
2288       if (node->value.answers)
2289         *value = !answer || *find_answer (node, answer);
2290     }
2291   else if (pfile->cur_token[-1].type == CPP_EOF)
2292     _cpp_backup_tokens (pfile, 1);
2293
2294   /* We don't commit the memory for the answer - it's temporary only.  */
2295   return node == 0;
2296 }
2297
2298 /* Handle #assert.  */
2299 static void
2300 do_assert (cpp_reader *pfile)
2301 {
2302   cpp_macro *answer;
2303   cpp_hashnode *node = parse_assertion (pfile, T_ASSERT, &answer);
2304
2305   if (node)
2306     {
2307       /* Place the new answer in the answer list.  First check there
2308          is not a duplicate.  */
2309       if (*find_answer (node, answer))
2310         {
2311           cpp_error (pfile, CPP_DL_WARNING, "\"%s\" re-asserted",
2312                      NODE_NAME (node) + 1);
2313           return;
2314         }
2315
2316       /* Commit or allocate storage for the answer.  */
2317       answer = (cpp_macro *)_cpp_commit_buff
2318         (pfile, sizeof (cpp_macro) - sizeof (cpp_token)
2319          + sizeof (cpp_token) * answer->count);
2320
2321       /* Chain into the list.  */
2322       answer->parm.next = node->value.answers;
2323       node->value.answers = answer;
2324
2325       check_eol (pfile, false);
2326     }
2327 }
2328
2329 /* Handle #unassert.  */
2330 static void
2331 do_unassert (cpp_reader *pfile)
2332 {
2333   cpp_macro *answer;
2334   cpp_hashnode *node = parse_assertion (pfile, T_UNASSERT, &answer);
2335
2336   /* It isn't an error to #unassert something that isn't asserted.  */
2337   if (node)
2338     {
2339       if (answer)
2340         {
2341           cpp_macro **p = find_answer (node, answer);
2342
2343           /* Remove the assert from the list.  */
2344           if (cpp_macro *temp = *p)
2345             *p = temp->parm.next;
2346
2347           check_eol (pfile, false);
2348         }
2349       else
2350         _cpp_free_definition (node);
2351     }
2352
2353   /* We don't commit the memory for the answer - it's temporary only.  */
2354 }
2355
2356 /* These are for -D, -U, -A.  */
2357
2358 /* Process the string STR as if it appeared as the body of a #define.
2359    If STR is just an identifier, define it with value 1.
2360    If STR has anything after the identifier, then it should
2361    be identifier=definition.  */
2362 void
2363 cpp_define (cpp_reader *pfile, const char *str)
2364 {
2365   char *buf;
2366   const char *p;
2367   size_t count;
2368
2369   /* Copy the entire option so we can modify it.
2370      Change the first "=" in the string to a space.  If there is none,
2371      tack " 1" on the end.  */
2372
2373   count = strlen (str);
2374   buf = (char *) alloca (count + 3);
2375   memcpy (buf, str, count);
2376
2377   p = strchr (str, '=');
2378   if (p)
2379     buf[p - str] = ' ';
2380   else
2381     {
2382       buf[count++] = ' ';
2383       buf[count++] = '1';
2384     }
2385   buf[count] = '\n';
2386
2387   run_directive (pfile, T_DEFINE, buf, count);
2388 }
2389
2390
2391 /* Use to build macros to be run through cpp_define() as
2392    described above.
2393    Example: cpp_define_formatted (pfile, "MACRO=%d", value);  */
2394
2395 void
2396 cpp_define_formatted (cpp_reader *pfile, const char *fmt, ...)
2397 {
2398   char *ptr;
2399
2400   va_list ap;
2401   va_start (ap, fmt);
2402   ptr = xvasprintf (fmt, ap);
2403   va_end (ap);
2404
2405   cpp_define (pfile, ptr);
2406   free (ptr);
2407 }
2408
2409
2410 /* Slight variant of the above for use by initialize_builtins.  */
2411 void
2412 _cpp_define_builtin (cpp_reader *pfile, const char *str)
2413 {
2414   size_t len = strlen (str);
2415   char *buf = (char *) alloca (len + 1);
2416   memcpy (buf, str, len);
2417   buf[len] = '\n';
2418   run_directive (pfile, T_DEFINE, buf, len);
2419 }
2420
2421 /* Process MACRO as if it appeared as the body of an #undef.  */
2422 void
2423 cpp_undef (cpp_reader *pfile, const char *macro)
2424 {
2425   size_t len = strlen (macro);
2426   char *buf = (char *) alloca (len + 1);
2427   memcpy (buf, macro, len);
2428   buf[len] = '\n';
2429   run_directive (pfile, T_UNDEF, buf, len);
2430 }
2431
2432 /* Replace a previous definition DEF of the macro STR.  If DEF is NULL,
2433    or first element is zero, then the macro should be undefined.  */
2434 static void
2435 cpp_pop_definition (cpp_reader *pfile, struct def_pragma_macro *c)
2436 {
2437   cpp_hashnode *node = _cpp_lex_identifier (pfile, c->name);
2438   if (node == NULL)
2439     return;
2440
2441   if (pfile->cb.before_define)
2442     pfile->cb.before_define (pfile);
2443
2444   if (cpp_macro_p (node))
2445     {
2446       if (pfile->cb.undef)
2447         pfile->cb.undef (pfile, pfile->directive_line, node);
2448       if (CPP_OPTION (pfile, warn_unused_macros))
2449         _cpp_warn_if_unused_macro (pfile, node, NULL);
2450       _cpp_free_definition (node);
2451     }
2452
2453   if (c->is_undef)
2454     return;
2455
2456   {
2457     size_t namelen;
2458     const uchar *dn;
2459     cpp_hashnode *h = NULL;
2460     cpp_buffer *nbuf;
2461
2462     namelen = ustrcspn (c->definition, "( \n");
2463     h = cpp_lookup (pfile, c->definition, namelen);
2464     dn = c->definition + namelen;
2465
2466     nbuf = cpp_push_buffer (pfile, dn, ustrchr (dn, '\n') - dn, true);
2467     if (nbuf != NULL)
2468       {
2469         _cpp_clean_line (pfile);
2470         nbuf->sysp = 1;
2471         if (!_cpp_create_definition (pfile, h))
2472           abort ();
2473         _cpp_pop_buffer (pfile);
2474       }
2475     else
2476       abort ();
2477     h->value.macro->line = c->line;
2478     h->value.macro->syshdr = c->syshdr;
2479     h->value.macro->used = c->used;
2480   }
2481 }
2482
2483 /* Process the string STR as if it appeared as the body of a #assert.  */
2484 void
2485 cpp_assert (cpp_reader *pfile, const char *str)
2486 {
2487   handle_assertion (pfile, str, T_ASSERT);
2488 }
2489
2490 /* Process STR as if it appeared as the body of an #unassert.  */
2491 void
2492 cpp_unassert (cpp_reader *pfile, const char *str)
2493 {
2494   handle_assertion (pfile, str, T_UNASSERT);
2495 }
2496
2497 /* Common code for cpp_assert (-A) and cpp_unassert (-A-).  */
2498 static void
2499 handle_assertion (cpp_reader *pfile, const char *str, int type)
2500 {
2501   size_t count = strlen (str);
2502   const char *p = strchr (str, '=');
2503
2504   /* Copy the entire option so we can modify it.  Change the first
2505      "=" in the string to a '(', and tack a ')' on the end.  */
2506   char *buf = (char *) alloca (count + 2);
2507
2508   memcpy (buf, str, count);
2509   if (p)
2510     {
2511       buf[p - str] = '(';
2512       buf[count++] = ')';
2513     }
2514   buf[count] = '\n';
2515   str = buf;
2516
2517   run_directive (pfile, type, str, count);
2518 }
2519
2520 /* The options structure.  */
2521 cpp_options *
2522 cpp_get_options (cpp_reader *pfile)
2523 {
2524   return &pfile->opts;
2525 }
2526
2527 /* The callbacks structure.  */
2528 cpp_callbacks *
2529 cpp_get_callbacks (cpp_reader *pfile)
2530 {
2531   return &pfile->cb;
2532 }
2533
2534 /* Copy the given callbacks structure to our own.  */
2535 void
2536 cpp_set_callbacks (cpp_reader *pfile, cpp_callbacks *cb)
2537 {
2538   pfile->cb = *cb;
2539 }
2540
2541 /* The dependencies structure.  (Creates one if it hasn't already been.)  */
2542 struct mkdeps *
2543 cpp_get_deps (cpp_reader *pfile)
2544 {
2545   if (!pfile->deps)
2546     pfile->deps = deps_init ();
2547   return pfile->deps;
2548 }
2549
2550 /* Push a new buffer on the buffer stack.  Returns the new buffer; it
2551    doesn't fail.  It does not generate a file change call back; that
2552    is the responsibility of the caller.  */
2553 cpp_buffer *
2554 cpp_push_buffer (cpp_reader *pfile, const uchar *buffer, size_t len,
2555                  int from_stage3)
2556 {
2557   cpp_buffer *new_buffer = XOBNEW (&pfile->buffer_ob, cpp_buffer);
2558
2559   /* Clears, amongst other things, if_stack and mi_cmacro.  */
2560   memset (new_buffer, 0, sizeof (cpp_buffer));
2561
2562   new_buffer->next_line = new_buffer->buf = buffer;
2563   new_buffer->rlimit = buffer + len;
2564   new_buffer->from_stage3 = from_stage3;
2565   new_buffer->prev = pfile->buffer;
2566   new_buffer->need_line = true;
2567
2568   pfile->buffer = new_buffer;
2569
2570   return new_buffer;
2571 }
2572
2573 /* Pops a single buffer, with a file change call-back if appropriate.
2574    Then pushes the next -include file, if any remain.  */
2575 void
2576 _cpp_pop_buffer (cpp_reader *pfile)
2577 {
2578   cpp_buffer *buffer = pfile->buffer;
2579   struct _cpp_file *inc = buffer->file;
2580   struct if_stack *ifs;
2581   const unsigned char *to_free;
2582
2583   /* Walk back up the conditional stack till we reach its level at
2584      entry to this file, issuing error messages.  */
2585   for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
2586     cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
2587                          "unterminated #%s", dtable[ifs->type].name);
2588
2589   /* In case of a missing #endif.  */
2590   pfile->state.skipping = 0;
2591
2592   /* _cpp_do_file_change expects pfile->buffer to be the new one.  */
2593   pfile->buffer = buffer->prev;
2594
2595   to_free = buffer->to_free;
2596   free (buffer->notes);
2597
2598   /* Free the buffer object now; we may want to push a new buffer
2599      in _cpp_push_next_include_file.  */
2600   obstack_free (&pfile->buffer_ob, buffer);
2601
2602   if (inc)
2603     {
2604       _cpp_pop_file_buffer (pfile, inc, to_free);
2605
2606       _cpp_do_file_change (pfile, LC_LEAVE, 0, 0, 0);
2607     }
2608   else if (to_free)
2609     free ((void *)to_free);
2610 }
2611
2612 /* Enter all recognized directives in the hash table.  */
2613 void
2614 _cpp_init_directives (cpp_reader *pfile)
2615 {
2616   unsigned int i;
2617   cpp_hashnode *node;
2618
2619   for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
2620     {
2621       node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
2622       node->is_directive = 1;
2623       node->directive_index = i;
2624     }
2625 }
2626
2627 /* Extract header file from a bracket include. Parsing starts after '<'.
2628    The string is malloced and must be freed by the caller.  */
2629 char *
2630 _cpp_bracket_include(cpp_reader *pfile)
2631 {
2632   return glue_header_name (pfile);
2633 }
2634