libcpp/directives.c

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