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