libcpp/directives.c

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