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