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, 2011 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 precede 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 = LINEMAPS_LAST_ORDINARY_MAP (line_table);
 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 = ORDINARY_MAP_IN_SYSTEM_HEADER_P (map);
 893   const cpp_token *token;
 894   const char *new_file = ORDINARY_MAP_FILE_NAME (map);
 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 = LINEMAPS_LAST_ORDINARY_MAP (line_table);
 950   const cpp_token *token;
 951   const char *new_file = ORDINARY_MAP_FILE_NAME (map);
 952   linenum_type new_lineno;
 953   unsigned int new_sysp = ORDINARY_MAP_IN_SYSTEM_HEADER_P (map);
 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,
1042                         ORDINARY_MAP_STARTING_LINE_NUMBER (map),
1043                         127);
1044
1045   if (pfile->cb.file_change)
1046     pfile->cb.file_change (pfile, map);
1047 }
1048
1049 /* Report a warning or error detected by the program we are
1050    processing.  Use the directive's tokens in the error message.  */
1051 static void
1052 do_diagnostic (cpp_reader *pfile, int code, int reason, int print_dir)
1053 {
1054   const unsigned char *dir_name;
1055   unsigned char *line;
1056   source_location src_loc = pfile->cur_token[-1].src_loc;
1057
1058   if (print_dir)
1059     dir_name = pfile->directive->name;
1060   else
1061     dir_name = NULL;
1062   pfile->state.prevent_expansion++;
1063   line = cpp_output_line_to_string (pfile, dir_name);
1064   pfile->state.prevent_expansion--;
1065
1066   if (code == CPP_DL_WARNING_SYSHDR && reason)
1067     cpp_warning_with_line_syshdr (pfile, reason, src_loc, 0, "%s", line);
1068   else if (code == CPP_DL_WARNING && reason)
1069     cpp_warning_with_line (pfile, reason, src_loc, 0, "%s", line);
1070   else
1071     cpp_error_with_line (pfile, code, src_loc, 0, "%s", line);
1072   free (line);
1073 }
1074
1075 static void
1076 do_error (cpp_reader *pfile)
1077 {
1078   do_diagnostic (pfile, CPP_DL_ERROR, 0, 1);
1079 }
1080
1081 static void
1082 do_warning (cpp_reader *pfile)
1083 {
1084   /* We want #warning diagnostics to be emitted in system headers too.  */
1085   do_diagnostic (pfile, CPP_DL_WARNING_SYSHDR, CPP_W_WARNING_DIRECTIVE, 1);
1086 }
1087
1088 /* Report program identification.  */
1089 static void
1090 do_ident (cpp_reader *pfile)
1091 {
1092   const cpp_token *str = cpp_get_token (pfile);
1093
1094   if (str->type != CPP_STRING)
1095     cpp_error (pfile, CPP_DL_ERROR, "invalid #%s directive",
1096                pfile->directive->name);
1097   else if (pfile->cb.ident)
1098     pfile->cb.ident (pfile, pfile->directive_line, &str->val.str);
1099
1100   check_eol (pfile, false);
1101 }
1102
1103 /* Lookup a PRAGMA name in a singly-linked CHAIN.  Returns the
1104    matching entry, or NULL if none is found.  The returned entry could
1105    be the start of a namespace chain, or a pragma.  */
1106 static struct pragma_entry *
1107 lookup_pragma_entry (struct pragma_entry *chain, const cpp_hashnode *pragma)
1108 {
1109   while (chain && chain->pragma != pragma)
1110     chain = chain->next;
1111
1112   return chain;
1113 }
1114
1115 /* Create and insert a blank pragma entry at the beginning of a
1116    singly-linked CHAIN.  */
1117 static struct pragma_entry *
1118 new_pragma_entry (cpp_reader *pfile, struct pragma_entry **chain)
1119 {
1120   struct pragma_entry *new_entry;
1121
1122   new_entry = (struct pragma_entry *)
1123     _cpp_aligned_alloc (pfile, sizeof (struct pragma_entry));
1124
1125   memset (new_entry, 0, sizeof (struct pragma_entry));
1126   new_entry->next = *chain;
1127
1128   *chain = new_entry;
1129   return new_entry;
1130 }
1131
1132 /* Register a pragma NAME in namespace SPACE.  If SPACE is null, it
1133    goes in the global namespace.  */
1134 static struct pragma_entry *
1135 register_pragma_1 (cpp_reader *pfile, const char *space, const char *name,
1136                    bool allow_name_expansion)
1137 {
1138   struct pragma_entry **chain = &pfile->pragmas;
1139   struct pragma_entry *entry;
1140   const cpp_hashnode *node;
1141
1142   if (space)
1143     {
1144       node = cpp_lookup (pfile, UC space, strlen (space));
1145       entry = lookup_pragma_entry (*chain, node);
1146       if (!entry)
1147         {
1148           entry = new_pragma_entry (pfile, chain);
1149           entry->pragma = node;
1150           entry->is_nspace = true;
1151           entry->allow_expansion = allow_name_expansion;
1152         }
1153       else if (!entry->is_nspace)
1154         goto clash;
1155       else if (entry->allow_expansion != allow_name_expansion)
1156         {
1157           cpp_error (pfile, CPP_DL_ICE,
1158                      "registering pragmas in namespace \"%s\" with mismatched "
1159                      "name expansion", space);
1160           return NULL;
1161         }
1162       chain = &entry->u.space;
1163     }
1164   else if (allow_name_expansion)
1165     {
1166       cpp_error (pfile, CPP_DL_ICE,
1167                  "registering pragma \"%s\" with name expansion "
1168                  "and no namespace", name);
1169       return NULL;
1170     }
1171
1172   /* Check for duplicates.  */
1173   node = cpp_lookup (pfile, UC name, strlen (name));
1174   entry = lookup_pragma_entry (*chain, node);
1175   if (entry == NULL)
1176     {
1177       entry = new_pragma_entry (pfile, chain);
1178       entry->pragma = node;
1179       return entry;
1180     }
1181
1182   if (entry->is_nspace)
1183     clash:
1184     cpp_error (pfile, CPP_DL_ICE,
1185                "registering \"%s\" as both a pragma and a pragma namespace",
1186                NODE_NAME (node));
1187   else if (space)
1188     cpp_error (pfile, CPP_DL_ICE, "#pragma %s %s is already registered",
1189                space, name);
1190   else
1191     cpp_error (pfile, CPP_DL_ICE, "#pragma %s is already registered", name);
1192
1193   return NULL;
1194 }
1195
1196 /* Register a cpplib internal pragma SPACE NAME with HANDLER.  */
1197 static void
1198 register_pragma_internal (cpp_reader *pfile, const char *space,
1199                           const char *name, pragma_cb handler)
1200 {
1201   struct pragma_entry *entry;
1202
1203   entry = register_pragma_1 (pfile, space, name, false);
1204   entry->is_internal = true;
1205   entry->u.handler = handler;
1206 }
1207
1208 /* Register a pragma NAME in namespace SPACE.  If SPACE is null, it
1209    goes in the global namespace.  HANDLER is the handler it will call,
1210    which must be non-NULL.  If ALLOW_EXPANSION is set, allow macro
1211    expansion while parsing pragma NAME.  This function is exported
1212    from libcpp. */
1213 void
1214 cpp_register_pragma (cpp_reader *pfile, const char *space, const char *name,
1215                      pragma_cb handler, bool allow_expansion)
1216 {
1217   struct pragma_entry *entry;
1218
1219   if (!handler)
1220     {
1221       cpp_error (pfile, CPP_DL_ICE, "registering pragma with NULL handler");
1222       return;
1223     }
1224
1225   entry = register_pragma_1 (pfile, space, name, false);
1226   if (entry)
1227     {
1228       entry->allow_expansion = allow_expansion;
1229       entry->u.handler = handler;
1230     }
1231 }
1232
1233 /* Similarly, but create mark the pragma for deferred processing.
1234    When found, a CPP_PRAGMA token will be insertted into the stream
1235    with IDENT in the token->u.pragma slot.  */
1236 void
1237 cpp_register_deferred_pragma (cpp_reader *pfile, const char *space,
1238                               const char *name, unsigned int ident,
1239                               bool allow_expansion, bool allow_name_expansion)
1240 {
1241   struct pragma_entry *entry;
1242
1243   entry = register_pragma_1 (pfile, space, name, allow_name_expansion);
1244   if (entry)
1245     {
1246       entry->is_deferred = true;
1247       entry->allow_expansion = allow_expansion;
1248       entry->u.ident = ident;
1249     }
1250 }
1251
1252 /* Register the pragmas the preprocessor itself handles.  */
1253 void
1254 _cpp_init_internal_pragmas (cpp_reader *pfile)
1255 {
1256   /* Pragmas in the global namespace.  */
1257   register_pragma_internal (pfile, 0, "once", do_pragma_once);
1258   register_pragma_internal (pfile, 0, "push_macro", do_pragma_push_macro);
1259   register_pragma_internal (pfile, 0, "pop_macro", do_pragma_pop_macro);
1260
1261   /* New GCC-specific pragmas should be put in the GCC namespace.  */
1262   register_pragma_internal (pfile, "GCC", "poison", do_pragma_poison);
1263   register_pragma_internal (pfile, "GCC", "system_header",
1264                             do_pragma_system_header);
1265   register_pragma_internal (pfile, "GCC", "dependency", do_pragma_dependency);
1266 }
1267
1268 /* Return the number of registered pragmas in PE.  */
1269
1270 static int
1271 count_registered_pragmas (struct pragma_entry *pe)
1272 {
1273   int ct = 0;
1274   for (; pe != NULL; pe = pe->next)
1275     {
1276       if (pe->is_nspace)
1277         ct += count_registered_pragmas (pe->u.space);
1278       ct++;
1279     }
1280   return ct;
1281 }
1282
1283 /* Save into SD the names of the registered pragmas referenced by PE,
1284    and return a pointer to the next free space in SD.  */
1285
1286 static char **
1287 save_registered_pragmas (struct pragma_entry *pe, char **sd)
1288 {
1289   for (; pe != NULL; pe = pe->next)
1290     {
1291       if (pe->is_nspace)
1292         sd = save_registered_pragmas (pe->u.space, sd);
1293       *sd++ = (char *) xmemdup (HT_STR (&pe->pragma->ident),
1294                                 HT_LEN (&pe->pragma->ident),
1295                                 HT_LEN (&pe->pragma->ident) + 1);
1296     }
1297   return sd;
1298 }
1299
1300 /* Return a newly-allocated array which saves the names of the
1301    registered pragmas.  */
1302
1303 char **
1304 _cpp_save_pragma_names (cpp_reader *pfile)
1305 {
1306   int ct = count_registered_pragmas (pfile->pragmas);
1307   char **result = XNEWVEC (char *, ct);
1308   (void) save_registered_pragmas (pfile->pragmas, result);
1309   return result;
1310 }
1311
1312 /* Restore from SD the names of the registered pragmas referenced by PE,
1313    and return a pointer to the next unused name in SD.  */
1314
1315 static char **
1316 restore_registered_pragmas (cpp_reader *pfile, struct pragma_entry *pe,
1317                             char **sd)
1318 {
1319   for (; pe != NULL; pe = pe->next)
1320     {
1321       if (pe->is_nspace)
1322         sd = restore_registered_pragmas (pfile, pe->u.space, sd);
1323       pe->pragma = cpp_lookup (pfile, UC *sd, strlen (*sd));
1324       free (*sd);
1325       sd++;
1326     }
1327   return sd;
1328 }
1329
1330 /* Restore the names of the registered pragmas from SAVED.  */
1331
1332 void
1333 _cpp_restore_pragma_names (cpp_reader *pfile, char **saved)
1334 {
1335   (void) restore_registered_pragmas (pfile, pfile->pragmas, saved);
1336   free (saved);
1337 }
1338
1339 /* Pragmata handling.  We handle some, and pass the rest on to the
1340    front end.  C99 defines three pragmas and says that no macro
1341    expansion is to be performed on them; whether or not macro
1342    expansion happens for other pragmas is implementation defined.
1343    This implementation allows for a mix of both, since GCC did not
1344    traditionally macro expand its (few) pragmas, whereas OpenMP
1345    specifies that macro expansion should happen.  */
1346 static void
1347 do_pragma (cpp_reader *pfile)
1348 {
1349   const struct pragma_entry *p = NULL;
1350   const cpp_token *token, *pragma_token;
1351   source_location pragma_token_virt_loc = 0;
1352   cpp_token ns_token;
1353   unsigned int count = 1;
1354
1355   pfile->state.prevent_expansion++;
1356
1357   pragma_token = token = cpp_get_token_with_location (pfile,
1358                                                       &pragma_token_virt_loc);
1359   ns_token = *token;
1360   if (token->type == CPP_NAME)
1361     {
1362       p = lookup_pragma_entry (pfile->pragmas, token->val.node.node);
1363       if (p && p->is_nspace)
1364         {
1365           bool allow_name_expansion = p->allow_expansion;
1366           if (allow_name_expansion)
1367             pfile->state.prevent_expansion--;
1368
1369           token = cpp_get_token (pfile);
1370           if (token->type == CPP_NAME)
1371             p = lookup_pragma_entry (p->u.space, token->val.node.node);
1372           else
1373             p = NULL;
1374           if (allow_name_expansion)
1375             pfile->state.prevent_expansion++;
1376           count = 2;
1377         }
1378     }
1379
1380   if (p)
1381     {
1382       if (p->is_deferred)
1383         {
1384           pfile->directive_result.src_loc = pragma_token_virt_loc;
1385           pfile->directive_result.type = CPP_PRAGMA;
1386           pfile->directive_result.flags = pragma_token->flags;
1387           pfile->directive_result.val.pragma = p->u.ident;
1388           pfile->state.in_deferred_pragma = true;
1389           pfile->state.pragma_allow_expansion = p->allow_expansion;
1390           if (!p->allow_expansion)
1391             pfile->state.prevent_expansion++;
1392         }
1393       else
1394         {
1395           /* Since the handler below doesn't get the line number, that
1396              it might need for diagnostics, make sure it has the right
1397              numbers in place.  */
1398           if (pfile->cb.line_change)
1399             (*pfile->cb.line_change) (pfile, pragma_token, false);
1400           if (p->allow_expansion)
1401             pfile->state.prevent_expansion--;
1402           (*p->u.handler) (pfile);
1403           if (p->allow_expansion)
1404             pfile->state.prevent_expansion++;
1405         }
1406     }
1407   else if (pfile->cb.def_pragma)
1408     {
1409       if (count == 1 || pfile->context->prev == NULL)
1410         _cpp_backup_tokens (pfile, count);
1411       else
1412         {
1413           /* Invalid name comes from macro expansion, _cpp_backup_tokens
1414              won't allow backing 2 tokens.  */
1415           /* ??? The token buffer is leaked.  Perhaps if def_pragma hook
1416              reads both tokens, we could perhaps free it, but if it doesn't,
1417              we don't know the exact lifespan.  */
1418           cpp_token *toks = XNEWVEC (cpp_token, 2);
1419           toks[0] = ns_token;
1420           toks[0].flags |= NO_EXPAND;
1421           toks[1] = *token;
1422           toks[1].flags |= NO_EXPAND;
1423           _cpp_push_token_context (pfile, NULL, toks, 2);
1424         }
1425       pfile->cb.def_pragma (pfile, pfile->directive_line);
1426     }
1427
1428   pfile->state.prevent_expansion--;
1429 }
1430
1431 /* Handle #pragma once.  */
1432 static void
1433 do_pragma_once (cpp_reader *pfile)
1434 {
1435   if (cpp_in_primary_file (pfile))
1436     cpp_error (pfile, CPP_DL_WARNING, "#pragma once in main file");
1437
1438   check_eol (pfile, false);
1439   _cpp_mark_file_once_only (pfile, pfile->buffer->file);
1440 }
1441
1442 /* Handle #pragma push_macro(STRING).  */
1443 static void
1444 do_pragma_push_macro (cpp_reader *pfile)
1445 {
1446   cpp_hashnode *node;
1447   size_t defnlen;
1448   const uchar *defn = NULL;
1449   char *macroname, *dest;
1450   const char *limit, *src;
1451   const cpp_token *txt;
1452   struct def_pragma_macro *c;
1453
1454   txt = get__Pragma_string (pfile);
1455   if (!txt)
1456     {
1457       source_location src_loc = pfile->cur_token[-1].src_loc;
1458       cpp_error_with_line (pfile, CPP_DL_ERROR, src_loc, 0,
1459                  "invalid #pragma push_macro directive");
1460       check_eol (pfile, false);
1461       skip_rest_of_line (pfile);
1462       return;
1463     }
1464   dest = macroname = (char *) alloca (txt->val.str.len + 2);
1465   src = (const char *) (txt->val.str.text + 1 + (txt->val.str.text[0] == 'L'));
1466   limit = (const char *) (txt->val.str.text + txt->val.str.len - 1);
1467   while (src < limit)
1468     {
1469       /* We know there is a character following the backslash.  */
1470       if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1471         src++;
1472       *dest++ = *src++;
1473     }
1474   *dest = 0;
1475   check_eol (pfile, false);
1476   skip_rest_of_line (pfile);
1477   c = XNEW (struct def_pragma_macro);
1478   memset (c, 0, sizeof (struct def_pragma_macro));
1479   c->name = XNEWVAR (char, strlen (macroname) + 1);
1480   strcpy (c->name, macroname);
1481   c->next = pfile->pushed_macros;
1482   node = _cpp_lex_identifier (pfile, c->name);
1483   if (node->type == NT_VOID)
1484     c->is_undef = 1;
1485   else
1486     {
1487       defn = cpp_macro_definition (pfile, node);
1488       defnlen = ustrlen (defn);
1489       c->definition = XNEWVEC (uchar, defnlen + 2);
1490       c->definition[defnlen] = '\n';
1491       c->definition[defnlen + 1] = 0;
1492       c->line = node->value.macro->line;
1493       c->syshdr = node->value.macro->syshdr;
1494       c->used = node->value.macro->used;
1495       memcpy (c->definition, defn, defnlen);
1496     }
1497
1498   pfile->pushed_macros = c;
1499 }
1500
1501 /* Handle #pragma pop_macro(STRING).  */
1502 static void
1503 do_pragma_pop_macro (cpp_reader *pfile)
1504 {
1505   char *macroname, *dest;
1506   const char *limit, *src;
1507   const cpp_token *txt;
1508   struct def_pragma_macro *l = NULL, *c = pfile->pushed_macros;
1509   txt = get__Pragma_string (pfile);
1510   if (!txt)
1511     {
1512       source_location src_loc = pfile->cur_token[-1].src_loc;
1513       cpp_error_with_line (pfile, CPP_DL_ERROR, src_loc, 0,
1514                  "invalid #pragma pop_macro directive");
1515       check_eol (pfile, false);
1516       skip_rest_of_line (pfile);
1517       return;
1518     }
1519   dest = macroname = (char *) alloca (txt->val.str.len + 2);
1520   src = (const char *) (txt->val.str.text + 1 + (txt->val.str.text[0] == 'L'));
1521   limit = (const char *) (txt->val.str.text + txt->val.str.len - 1);
1522   while (src < limit)
1523     {
1524       /* We know there is a character following the backslash.  */
1525       if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1526         src++;
1527       *dest++ = *src++;
1528     }
1529   *dest = 0;
1530   check_eol (pfile, false);
1531   skip_rest_of_line (pfile);
1532
1533   while (c != NULL)
1534     {
1535       if (!strcmp (c->name, macroname))
1536         {
1537           if (!l)
1538             pfile->pushed_macros = c->next;
1539           else
1540             l->next = c->next;
1541           cpp_pop_definition (pfile, c);
1542           free (c->definition);
1543           free (c->name);
1544           free (c);
1545           break;
1546         }
1547       l = c;
1548       c = c->next;
1549     }
1550 }
1551
1552 /* Handle #pragma GCC poison, to poison one or more identifiers so
1553    that the lexer produces a hard error for each subsequent usage.  */
1554 static void
1555 do_pragma_poison (cpp_reader *pfile)
1556 {
1557   const cpp_token *tok;
1558   cpp_hashnode *hp;
1559
1560   pfile->state.poisoned_ok = 1;
1561   for (;;)
1562     {
1563       tok = _cpp_lex_token (pfile);
1564       if (tok->type == CPP_EOF)
1565         break;
1566       if (tok->type != CPP_NAME)
1567         {
1568           cpp_error (pfile, CPP_DL_ERROR,
1569                      "invalid #pragma GCC poison directive");
1570           break;
1571         }
1572
1573       hp = tok->val.node.node;
1574       if (hp->flags & NODE_POISONED)
1575         continue;
1576
1577       if (hp->type == NT_MACRO)
1578         cpp_error (pfile, CPP_DL_WARNING, "poisoning existing macro \"%s\"",
1579                    NODE_NAME (hp));
1580       _cpp_free_definition (hp);
1581       hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1582     }
1583   pfile->state.poisoned_ok = 0;
1584 }
1585
1586 /* Mark the current header as a system header.  This will suppress
1587    some categories of warnings (notably those from -pedantic).  It is
1588    intended for use in system libraries that cannot be implemented in
1589    conforming C, but cannot be certain that their headers appear in a
1590    system include directory.  To prevent abuse, it is rejected in the
1591    primary source file.  */
1592 static void
1593 do_pragma_system_header (cpp_reader *pfile)
1594 {
1595   if (cpp_in_primary_file (pfile))
1596     cpp_error (pfile, CPP_DL_WARNING,
1597                "#pragma system_header ignored outside include file");
1598   else
1599     {
1600       check_eol (pfile, false);
1601       skip_rest_of_line (pfile);
1602       cpp_make_system_header (pfile, 1, 0);
1603     }
1604 }
1605
1606 /* Check the modified date of the current include file against a specified
1607    file. Issue a diagnostic, if the specified file is newer. We use this to
1608    determine if a fixed header should be refixed.  */
1609 static void
1610 do_pragma_dependency (cpp_reader *pfile)
1611 {
1612   const char *fname;
1613   int angle_brackets, ordering;
1614   source_location location;
1615
1616   fname = parse_include (pfile, &angle_brackets, NULL, &location);
1617   if (!fname)
1618     return;
1619
1620   ordering = _cpp_compare_file_date (pfile, fname, angle_brackets);
1621   if (ordering < 0)
1622     cpp_error (pfile, CPP_DL_WARNING, "cannot find source file %s", fname);
1623   else if (ordering > 0)
1624     {
1625       cpp_error (pfile, CPP_DL_WARNING,
1626                  "current file is older than %s", fname);
1627       if (cpp_get_token (pfile)->type != CPP_EOF)
1628         {
1629           _cpp_backup_tokens (pfile, 1);
1630           do_diagnostic (pfile, CPP_DL_WARNING, 0, 0);
1631         }
1632     }
1633
1634   free ((void *) fname);
1635 }
1636
1637 /* Get a token but skip padding.  */
1638 static const cpp_token *
1639 get_token_no_padding (cpp_reader *pfile)
1640 {
1641   for (;;)
1642     {
1643       const cpp_token *result = cpp_get_token (pfile);
1644       if (result->type != CPP_PADDING)
1645         return result;
1646     }
1647 }
1648
1649 /* Check syntax is "(string-literal)".  Returns the string on success,
1650    or NULL on failure.  */
1651 static const cpp_token *
1652 get__Pragma_string (cpp_reader *pfile)
1653 {
1654   const cpp_token *string;
1655   const cpp_token *paren;
1656
1657   paren = get_token_no_padding (pfile);
1658   if (paren->type == CPP_EOF)
1659     _cpp_backup_tokens (pfile, 1);
1660   if (paren->type != CPP_OPEN_PAREN)
1661     return NULL;
1662
1663   string = get_token_no_padding (pfile);
1664   if (string->type == CPP_EOF)
1665     _cpp_backup_tokens (pfile, 1);
1666   if (string->type != CPP_STRING && string->type != CPP_WSTRING
1667       && string->type != CPP_STRING32 && string->type != CPP_STRING16
1668       && string->type != CPP_UTF8STRING)
1669     return NULL;
1670
1671   paren = get_token_no_padding (pfile);
1672   if (paren->type == CPP_EOF)
1673     _cpp_backup_tokens (pfile, 1);
1674   if (paren->type != CPP_CLOSE_PAREN)
1675     return NULL;
1676
1677   return string;
1678 }
1679
1680 /* Destringize IN into a temporary buffer, by removing the first \ of
1681    \" and \\ sequences, and process the result as a #pragma directive.  */
1682 static void
1683 destringize_and_run (cpp_reader *pfile, const cpp_string *in)
1684 {
1685   const unsigned char *src, *limit;
1686   char *dest, *result;
1687   cpp_context *saved_context;
1688   cpp_token *saved_cur_token;
1689   tokenrun *saved_cur_run;
1690   cpp_token *toks;
1691   int count;
1692   const struct directive *save_directive;
1693
1694   dest = result = (char *) alloca (in->len - 1);
1695   src = in->text + 1 + (in->text[0] == 'L');
1696   limit = in->text + in->len - 1;
1697   while (src < limit)
1698     {
1699       /* We know there is a character following the backslash.  */
1700       if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1701         src++;
1702       *dest++ = *src++;
1703     }
1704   *dest = '\n';
1705
1706   /* Ugh; an awful kludge.  We are really not set up to be lexing
1707      tokens when in the middle of a macro expansion.  Use a new
1708      context to force cpp_get_token to lex, and so skip_rest_of_line
1709      doesn't go beyond the end of the text.  Also, remember the
1710      current lexing position so we can return to it later.
1711
1712      Something like line-at-a-time lexing should remove the need for
1713      this.  */
1714   saved_context = pfile->context;
1715   saved_cur_token = pfile->cur_token;
1716   saved_cur_run = pfile->cur_run;
1717
1718   pfile->context = XCNEW (cpp_context);
1719
1720   /* Inline run_directive, since we need to delay the _cpp_pop_buffer
1721      until we've read all of the tokens that we want.  */
1722   cpp_push_buffer (pfile, (const uchar *) result, dest - result,
1723                    /* from_stage3 */ true);
1724   /* ??? Antique Disgusting Hack.  What does this do?  */
1725   if (pfile->buffer->prev)
1726     pfile->buffer->file = pfile->buffer->prev->file;
1727
1728   start_directive (pfile);
1729   _cpp_clean_line (pfile);
1730   save_directive = pfile->directive;
1731   pfile->directive = &dtable[T_PRAGMA];
1732   do_pragma (pfile);
1733   end_directive (pfile, 1);
1734   pfile->directive = save_directive;
1735
1736   /* We always insert at least one token, the directive result.  It'll
1737      either be a CPP_PADDING or a CPP_PRAGMA.  In the later case, we
1738      need to insert *all* of the tokens, including the CPP_PRAGMA_EOL.  */
1739
1740   /* If we're not handling the pragma internally, read all of the tokens from
1741      the string buffer now, while the string buffer is still installed.  */
1742   /* ??? Note that the token buffer allocated here is leaked.  It's not clear
1743      to me what the true lifespan of the tokens are.  It would appear that
1744      the lifespan is the entire parse of the main input stream, in which case
1745      this may not be wrong.  */
1746   if (pfile->directive_result.type == CPP_PRAGMA)
1747     {
1748       int maxcount;
1749
1750       count = 1;
1751       maxcount = 50;
1752       toks = XNEWVEC (cpp_token, maxcount);
1753       toks[0] = pfile->directive_result;
1754
1755       do
1756         {
1757           if (count == maxcount)
1758             {
1759               maxcount = maxcount * 3 / 2;
1760               toks = XRESIZEVEC (cpp_token, toks, maxcount);
1761             }
1762           toks[count] = *cpp_get_token (pfile);
1763           /* Macros have been already expanded by cpp_get_token
1764              if the pragma allowed expansion.  */
1765           toks[count++].flags |= NO_EXPAND;
1766         }
1767       while (toks[count-1].type != CPP_PRAGMA_EOL);
1768     }
1769   else
1770     {
1771       count = 1;
1772       toks = XNEW (cpp_token);
1773       toks[0] = pfile->directive_result;
1774
1775       /* If we handled the entire pragma internally, make sure we get the
1776          line number correct for the next token.  */
1777       if (pfile->cb.line_change)
1778         pfile->cb.line_change (pfile, pfile->cur_token, false);
1779     }
1780
1781   /* Finish inlining run_directive.  */
1782   pfile->buffer->file = NULL;
1783   _cpp_pop_buffer (pfile);
1784
1785   /* Reset the old macro state before ...  */
1786   XDELETE (pfile->context);
1787   pfile->context = saved_context;
1788   pfile->cur_token = saved_cur_token;
1789   pfile->cur_run = saved_cur_run;
1790
1791   /* ... inserting the new tokens we collected.  */
1792   _cpp_push_token_context (pfile, NULL, toks, count);
1793 }
1794
1795 /* Handle the _Pragma operator.  Return 0 on error, 1 if ok.  */
1796 int
1797 _cpp_do__Pragma (cpp_reader *pfile)
1798 {
1799   const cpp_token *string = get__Pragma_string (pfile);
1800   pfile->directive_result.type = CPP_PADDING;
1801
1802   if (string)
1803     {
1804       destringize_and_run (pfile, &string->val.str);
1805       return 1;
1806     }
1807   cpp_error (pfile, CPP_DL_ERROR,
1808              "_Pragma takes a parenthesized string literal");
1809   return 0;
1810 }
1811
1812 /* Handle #ifdef.  */
1813 static void
1814 do_ifdef (cpp_reader *pfile)
1815 {
1816   int skip = 1;
1817
1818   if (! pfile->state.skipping)
1819     {
1820       cpp_hashnode *node = lex_macro_node (pfile, false);
1821
1822       if (node)
1823         {
1824           /* Do not treat conditional macros as being defined.  This is due to
1825              the powerpc and spu ports using conditional macros for 'vector',
1826              'bool', and 'pixel' to act as conditional keywords.  This messes
1827              up tests like #ifndef bool.  */
1828           skip = (node->type != NT_MACRO
1829                   || ((node->flags & NODE_CONDITIONAL) != 0));
1830           _cpp_mark_macro_used (node);
1831           if (!(node->flags & NODE_USED))
1832             {
1833               node->flags |= NODE_USED;
1834               if (node->type == NT_MACRO)
1835                 {
1836                   if ((node->flags & NODE_BUILTIN)
1837                       && pfile->cb.user_builtin_macro)
1838                     pfile->cb.user_builtin_macro (pfile, node);
1839                   if (pfile->cb.used_define)
1840                     pfile->cb.used_define (pfile, pfile->directive_line, node);
1841                 }
1842               else
1843                 {
1844                   if (pfile->cb.used_undef)
1845                     pfile->cb.used_undef (pfile, pfile->directive_line, node);
1846                 }
1847             }
1848           if (pfile->cb.used)
1849             pfile->cb.used (pfile, pfile->directive_line, node);
1850           check_eol (pfile, false);
1851         }
1852     }
1853
1854   push_conditional (pfile, skip, T_IFDEF, 0);
1855 }
1856
1857 /* Handle #ifndef.  */
1858 static void
1859 do_ifndef (cpp_reader *pfile)
1860 {
1861   int skip = 1;
1862   cpp_hashnode *node = 0;
1863
1864   if (! pfile->state.skipping)
1865     {
1866       node = lex_macro_node (pfile, false);
1867
1868       if (node)
1869         {
1870           /* Do not treat conditional macros as being defined.  This is due to
1871              the powerpc and spu ports using conditional macros for 'vector',
1872              'bool', and 'pixel' to act as conditional keywords.  This messes
1873              up tests like #ifndef bool.  */
1874           skip = (node->type == NT_MACRO
1875                   && ((node->flags & NODE_CONDITIONAL) == 0));
1876           _cpp_mark_macro_used (node);
1877           if (!(node->flags & NODE_USED))
1878             {
1879               node->flags |= NODE_USED;
1880               if (node->type == NT_MACRO)
1881                 {
1882                   if ((node->flags & NODE_BUILTIN)
1883                       && pfile->cb.user_builtin_macro)
1884                     pfile->cb.user_builtin_macro (pfile, node);
1885                   if (pfile->cb.used_define)
1886                     pfile->cb.used_define (pfile, pfile->directive_line, node);
1887                 }
1888               else
1889                 {
1890                   if (pfile->cb.used_undef)
1891                     pfile->cb.used_undef (pfile, pfile->directive_line, node);
1892                 }
1893             }
1894           if (pfile->cb.used)
1895             pfile->cb.used (pfile, pfile->directive_line, node);
1896           check_eol (pfile, false);
1897         }
1898     }
1899
1900   push_conditional (pfile, skip, T_IFNDEF, node);
1901 }
1902
1903 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1904    pfile->mi_ind_cmacro so we can handle multiple-include
1905    optimizations.  If macro expansion occurs in the expression, we
1906    cannot treat it as a controlling conditional, since the expansion
1907    could change in the future.  That is handled by cpp_get_token.  */
1908 static void
1909 do_if (cpp_reader *pfile)
1910 {
1911   int skip = 1;
1912
1913   if (! pfile->state.skipping)
1914     skip = _cpp_parse_expr (pfile, true) == false;
1915
1916   push_conditional (pfile, skip, T_IF, pfile->mi_ind_cmacro);
1917 }
1918
1919 /* Flip skipping state if appropriate and continue without changing
1920    if_stack; this is so that the error message for missing #endif's
1921    etc. will point to the original #if.  */
1922 static void
1923 do_else (cpp_reader *pfile)
1924 {
1925   cpp_buffer *buffer = pfile->buffer;
1926   struct if_stack *ifs = buffer->if_stack;
1927
1928   if (ifs == NULL)
1929     cpp_error (pfile, CPP_DL_ERROR, "#else without #if");
1930   else
1931     {
1932       if (ifs->type == T_ELSE)
1933         {
1934           cpp_error (pfile, CPP_DL_ERROR, "#else after #else");
1935           cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
1936                                "the conditional began here");
1937         }
1938       ifs->type = T_ELSE;
1939
1940       /* Skip any future (erroneous) #elses or #elifs.  */
1941       pfile->state.skipping = ifs->skip_elses;
1942       ifs->skip_elses = true;
1943
1944       /* Invalidate any controlling macro.  */
1945       ifs->mi_cmacro = 0;
1946
1947       /* Only check EOL if was not originally skipping.  */
1948       if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
1949         check_eol (pfile, false);
1950     }
1951 }
1952
1953 /* Handle a #elif directive by not changing if_stack either.  See the
1954    comment above do_else.  */
1955 static void
1956 do_elif (cpp_reader *pfile)
1957 {
1958   cpp_buffer *buffer = pfile->buffer;
1959   struct if_stack *ifs = buffer->if_stack;
1960
1961   if (ifs == NULL)
1962     cpp_error (pfile, CPP_DL_ERROR, "#elif without #if");
1963   else
1964     {
1965       if (ifs->type == T_ELSE)
1966         {
1967           cpp_error (pfile, CPP_DL_ERROR, "#elif after #else");
1968           cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
1969                                "the conditional began here");
1970         }
1971       ifs->type = T_ELIF;
1972
1973       if (! ifs->was_skipping)
1974         {
1975           bool value;
1976           /* The standard mandates that the expression be parsed even
1977              if we are skipping elses at this point -- the lexical
1978              restrictions on #elif only apply to skipped groups, but
1979              this group is not being skipped.  Temporarily set
1980              skipping to false to get lexer warnings.  */
1981           pfile->state.skipping = 0;
1982           value = _cpp_parse_expr (pfile, false);
1983           if (ifs->skip_elses)
1984             pfile->state.skipping = 1;
1985           else
1986             {
1987               pfile->state.skipping = ! value;
1988               ifs->skip_elses = value;
1989             }
1990         }
1991
1992       /* Invalidate any controlling macro.  */
1993       ifs->mi_cmacro = 0;
1994     }
1995 }
1996
1997 /* #endif pops the if stack and resets pfile->state.skipping.  */
1998 static void
1999 do_endif (cpp_reader *pfile)
2000 {
2001   cpp_buffer *buffer = pfile->buffer;
2002   struct if_stack *ifs = buffer->if_stack;
2003
2004   if (ifs == NULL)
2005     cpp_error (pfile, CPP_DL_ERROR, "#endif without #if");
2006   else
2007     {
2008       /* Only check EOL if was not originally skipping.  */
2009       if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
2010         check_eol (pfile, false);
2011
2012       /* If potential control macro, we go back outside again.  */
2013       if (ifs->next == 0 && ifs->mi_cmacro)
2014         {
2015           pfile->mi_valid = true;
2016           pfile->mi_cmacro = ifs->mi_cmacro;
2017         }
2018
2019       buffer->if_stack = ifs->next;
2020       pfile->state.skipping = ifs->was_skipping;
2021       obstack_free (&pfile->buffer_ob, ifs);
2022     }
2023 }
2024
2025 /* Push an if_stack entry for a preprocessor conditional, and set
2026    pfile->state.skipping to SKIP.  If TYPE indicates the conditional
2027    is #if or #ifndef, CMACRO is a potentially controlling macro, and
2028    we need to check here that we are at the top of the file.  */
2029 static void
2030 push_conditional (cpp_reader *pfile, int skip, int type,
2031                   const cpp_hashnode *cmacro)
2032 {
2033   struct if_stack *ifs;
2034   cpp_buffer *buffer = pfile->buffer;
2035
2036   ifs = XOBNEW (&pfile->buffer_ob, struct if_stack);
2037   ifs->line = pfile->directive_line;
2038   ifs->next = buffer->if_stack;
2039   ifs->skip_elses = pfile->state.skipping || !skip;
2040   ifs->was_skipping = pfile->state.skipping;
2041   ifs->type = type;
2042   /* This condition is effectively a test for top-of-file.  */
2043   if (pfile->mi_valid && pfile->mi_cmacro == 0)
2044     ifs->mi_cmacro = cmacro;
2045   else
2046     ifs->mi_cmacro = 0;
2047
2048   pfile->state.skipping = skip;
2049   buffer->if_stack = ifs;
2050 }
2051
2052 /* Read the tokens of the answer into the macro pool, in a directive
2053    of type TYPE.  Only commit the memory if we intend it as permanent
2054    storage, i.e. the #assert case.  Returns 0 on success, and sets
2055    ANSWERP to point to the answer.  PRED_LOC is the location of the
2056    predicate.  */
2057 static int
2058 parse_answer (cpp_reader *pfile, struct answer **answerp, int type,
2059               source_location pred_loc)
2060 {
2061   const cpp_token *paren;
2062   struct answer *answer;
2063   unsigned int acount;
2064
2065   /* In a conditional, it is legal to not have an open paren.  We
2066      should save the following token in this case.  */
2067   paren = cpp_get_token (pfile);
2068
2069   /* If not a paren, see if we're OK.  */
2070   if (paren->type != CPP_OPEN_PAREN)
2071     {
2072       /* In a conditional no answer is a test for any answer.  It
2073          could be followed by any token.  */
2074       if (type == T_IF)
2075         {
2076           _cpp_backup_tokens (pfile, 1);
2077           return 0;
2078         }
2079
2080       /* #unassert with no answer is valid - it removes all answers.  */
2081       if (type == T_UNASSERT && paren->type == CPP_EOF)
2082         return 0;
2083
2084       cpp_error_with_line (pfile, CPP_DL_ERROR, pred_loc, 0,
2085                            "missing '(' after predicate");
2086       return 1;
2087     }
2088
2089   for (acount = 0;; acount++)
2090     {
2091       size_t room_needed;
2092       const cpp_token *token = cpp_get_token (pfile);
2093       cpp_token *dest;
2094
2095       if (token->type == CPP_CLOSE_PAREN)
2096         break;
2097
2098       if (token->type == CPP_EOF)
2099         {
2100           cpp_error (pfile, CPP_DL_ERROR, "missing ')' to complete answer");
2101           return 1;
2102         }
2103
2104       /* struct answer includes the space for one token.  */
2105       room_needed = (sizeof (struct answer) + acount * sizeof (cpp_token));
2106
2107       if (BUFF_ROOM (pfile->a_buff) < room_needed)
2108         _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (struct answer));
2109
2110       dest = &((struct answer *) BUFF_FRONT (pfile->a_buff))->first[acount];
2111       *dest = *token;
2112
2113       /* Drop whitespace at start, for answer equivalence purposes.  */
2114       if (acount == 0)
2115         dest->flags &= ~PREV_WHITE;
2116     }
2117
2118   if (acount == 0)
2119     {
2120       cpp_error (pfile, CPP_DL_ERROR, "predicate's answer is empty");
2121       return 1;
2122     }
2123
2124   answer = (struct answer *) BUFF_FRONT (pfile->a_buff);
2125   answer->count = acount;
2126   answer->next = NULL;
2127   *answerp = answer;
2128
2129   return 0;
2130 }
2131
2132 /* Parses an assertion directive of type TYPE, returning a pointer to
2133    the hash node of the predicate, or 0 on error.  If an answer was
2134    supplied, it is placed in ANSWERP, otherwise it is set to 0.  */
2135 static cpp_hashnode *
2136 parse_assertion (cpp_reader *pfile, struct answer **answerp, int type)
2137 {
2138   cpp_hashnode *result = 0;
2139   const cpp_token *predicate;
2140
2141   /* We don't expand predicates or answers.  */
2142   pfile->state.prevent_expansion++;
2143
2144   *answerp = 0;
2145   predicate = cpp_get_token (pfile);
2146   if (predicate->type == CPP_EOF)
2147     cpp_error (pfile, CPP_DL_ERROR, "assertion without predicate");
2148   else if (predicate->type != CPP_NAME)
2149     cpp_error_with_line (pfile, CPP_DL_ERROR, predicate->src_loc, 0,
2150                          "predicate must be an identifier");
2151   else if (parse_answer (pfile, answerp, type, predicate->src_loc) == 0)
2152     {
2153       unsigned int len = NODE_LEN (predicate->val.node.node);
2154       unsigned char *sym = (unsigned char *) alloca (len + 1);
2155
2156       /* Prefix '#' to get it out of macro namespace.  */
2157       sym[0] = '#';
2158       memcpy (sym + 1, NODE_NAME (predicate->val.node.node), len);
2159       result = cpp_lookup (pfile, sym, len + 1);
2160     }
2161
2162   pfile->state.prevent_expansion--;
2163   return result;
2164 }
2165
2166 /* Returns a pointer to the pointer to CANDIDATE in the answer chain,
2167    or a pointer to NULL if the answer is not in the chain.  */
2168 static struct answer **
2169 find_answer (cpp_hashnode *node, const struct answer *candidate)
2170 {
2171   unsigned int i;
2172   struct answer **result;
2173
2174   for (result = &node->value.answers; *result; result = &(*result)->next)
2175     {
2176       struct answer *answer = *result;
2177
2178       if (answer->count == candidate->count)
2179         {
2180           for (i = 0; i < answer->count; i++)
2181             if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
2182               break;
2183
2184           if (i == answer->count)
2185             break;
2186         }
2187     }
2188
2189   return result;
2190 }
2191
2192 /* Test an assertion within a preprocessor conditional.  Returns
2193    nonzero on failure, zero on success.  On success, the result of
2194    the test is written into VALUE, otherwise the value 0.  */
2195 int
2196 _cpp_test_assertion (cpp_reader *pfile, unsigned int *value)
2197 {
2198   struct answer *answer;
2199   cpp_hashnode *node;
2200
2201   node = parse_assertion (pfile, &answer, T_IF);
2202
2203   /* For recovery, an erroneous assertion expression is handled as a
2204      failing assertion.  */
2205   *value = 0;
2206
2207   if (node)
2208     *value = (node->type == NT_ASSERTION &&
2209               (answer == 0 || *find_answer (node, answer) != 0));
2210   else if (pfile->cur_token[-1].type == CPP_EOF)
2211     _cpp_backup_tokens (pfile, 1);
2212
2213   /* We don't commit the memory for the answer - it's temporary only.  */
2214   return node == 0;
2215 }
2216
2217 /* Handle #assert.  */
2218 static void
2219 do_assert (cpp_reader *pfile)
2220 {
2221   struct answer *new_answer;
2222   cpp_hashnode *node;
2223
2224   node = parse_assertion (pfile, &new_answer, T_ASSERT);
2225   if (node)
2226     {
2227       size_t answer_size;
2228
2229       /* Place the new answer in the answer list.  First check there
2230          is not a duplicate.  */
2231       new_answer->next = 0;
2232       if (node->type == NT_ASSERTION)
2233         {
2234           if (*find_answer (node, new_answer))
2235             {
2236               cpp_error (pfile, CPP_DL_WARNING, "\"%s\" re-asserted",
2237                          NODE_NAME (node) + 1);
2238               return;
2239             }
2240           new_answer->next = node->value.answers;
2241         }
2242
2243       answer_size = sizeof (struct answer) + ((new_answer->count - 1)
2244                                               * sizeof (cpp_token));
2245       /* Commit or allocate storage for the object.  */
2246       if (pfile->hash_table->alloc_subobject)
2247         {
2248           struct answer *temp_answer = new_answer;
2249           new_answer = (struct answer *) pfile->hash_table->alloc_subobject
2250             (answer_size);
2251           memcpy (new_answer, temp_answer, answer_size);
2252         }
2253       else
2254         BUFF_FRONT (pfile->a_buff) += answer_size;
2255
2256       node->type = NT_ASSERTION;
2257       node->value.answers = new_answer;
2258       check_eol (pfile, false);
2259     }
2260 }
2261
2262 /* Handle #unassert.  */
2263 static void
2264 do_unassert (cpp_reader *pfile)
2265 {
2266   cpp_hashnode *node;
2267   struct answer *answer;
2268
2269   node = parse_assertion (pfile, &answer, T_UNASSERT);
2270   /* It isn't an error to #unassert something that isn't asserted.  */
2271   if (node && node->type == NT_ASSERTION)
2272     {
2273       if (answer)
2274         {
2275           struct answer **p = find_answer (node, answer), *temp;
2276
2277           /* Remove the answer from the list.  */
2278           temp = *p;
2279           if (temp)
2280             *p = temp->next;
2281
2282           /* Did we free the last answer?  */
2283           if (node->value.answers == 0)
2284             node->type = NT_VOID;
2285
2286           check_eol (pfile, false);
2287         }
2288       else
2289         _cpp_free_definition (node);
2290     }
2291
2292   /* We don't commit the memory for the answer - it's temporary only.  */
2293 }
2294
2295 /* These are for -D, -U, -A.  */
2296
2297 /* Process the string STR as if it appeared as the body of a #define.
2298    If STR is just an identifier, define it with value 1.
2299    If STR has anything after the identifier, then it should
2300    be identifier=definition.  */
2301 void
2302 cpp_define (cpp_reader *pfile, const char *str)
2303 {
2304   char *buf;
2305   const char *p;
2306   size_t count;
2307
2308   /* Copy the entire option so we can modify it.
2309      Change the first "=" in the string to a space.  If there is none,
2310      tack " 1" on the end.  */
2311
2312   count = strlen (str);
2313   buf = (char *) alloca (count + 3);
2314   memcpy (buf, str, count);
2315
2316   p = strchr (str, '=');
2317   if (p)
2318     buf[p - str] = ' ';
2319   else
2320     {
2321       buf[count++] = ' ';
2322       buf[count++] = '1';
2323     }
2324   buf[count] = '\n';
2325
2326   run_directive (pfile, T_DEFINE, buf, count);
2327 }
2328
2329
2330 /* Use to build macros to be run through cpp_define() as
2331    described above.
2332    Example: cpp_define_formatted (pfile, "MACRO=%d", value);  */
2333
2334 void
2335 cpp_define_formatted (cpp_reader *pfile, const char *fmt, ...)
2336 {
2337   char *ptr = NULL;
2338
2339   va_list ap;
2340   va_start (ap, fmt);
2341   vasprintf (&ptr, fmt, ap);
2342   va_end (ap);
2343
2344   cpp_define (pfile, ptr);
2345   free (ptr);
2346 }
2347
2348
2349 /* Slight variant of the above for use by initialize_builtins.  */
2350 void
2351 _cpp_define_builtin (cpp_reader *pfile, const char *str)
2352 {
2353   size_t len = strlen (str);
2354   char *buf = (char *) alloca (len + 1);
2355   memcpy (buf, str, len);
2356   buf[len] = '\n';
2357   run_directive (pfile, T_DEFINE, buf, len);
2358 }
2359
2360 /* Process MACRO as if it appeared as the body of an #undef.  */
2361 void
2362 cpp_undef (cpp_reader *pfile, const char *macro)
2363 {
2364   size_t len = strlen (macro);
2365   char *buf = (char *) alloca (len + 1);
2366   memcpy (buf, macro, len);
2367   buf[len] = '\n';
2368   run_directive (pfile, T_UNDEF, buf, len);
2369 }
2370
2371 /* Replace a previous definition DEF of the macro STR.  If DEF is NULL,
2372    or first element is zero, then the macro should be undefined.  */
2373 static void
2374 cpp_pop_definition (cpp_reader *pfile, struct def_pragma_macro *c)
2375 {
2376   cpp_hashnode *node = _cpp_lex_identifier (pfile, c->name);
2377   if (node == NULL)
2378     return;
2379
2380   if (pfile->cb.before_define)
2381     pfile->cb.before_define (pfile);
2382
2383   if (node->type == NT_MACRO)
2384     {
2385       if (pfile->cb.undef)
2386         pfile->cb.undef (pfile, pfile->directive_line, node);
2387       if (CPP_OPTION (pfile, warn_unused_macros))
2388         _cpp_warn_if_unused_macro (pfile, node, NULL);
2389     }
2390   if (node->type != NT_VOID)
2391     _cpp_free_definition (node);
2392
2393   if (c->is_undef)
2394     return;
2395   {
2396     size_t namelen;
2397     const uchar *dn;
2398     cpp_hashnode *h = NULL;
2399     cpp_buffer *nbuf;
2400
2401     namelen = ustrcspn (c->definition, "( \n");
2402     h = cpp_lookup (pfile, c->definition, namelen);
2403     dn = c->definition + namelen;
2404
2405     h->type = NT_VOID;
2406     h->flags &= ~(NODE_POISONED|NODE_BUILTIN|NODE_DISABLED|NODE_USED);
2407     nbuf = cpp_push_buffer (pfile, dn, ustrchr (dn, '\n') - dn, true);
2408     if (nbuf != NULL)
2409       {
2410         _cpp_clean_line (pfile);
2411         nbuf->sysp = 1;
2412         if (!_cpp_create_definition (pfile, h))
2413           abort ();
2414         _cpp_pop_buffer (pfile);
2415       }
2416     else
2417       abort ();
2418     h->value.macro->line = c->line;
2419     h->value.macro->syshdr = c->syshdr;
2420     h->value.macro->used = c->used;
2421   }
2422 }
2423
2424 /* Process the string STR as if it appeared as the body of a #assert.  */
2425 void
2426 cpp_assert (cpp_reader *pfile, const char *str)
2427 {
2428   handle_assertion (pfile, str, T_ASSERT);
2429 }
2430
2431 /* Process STR as if it appeared as the body of an #unassert.  */
2432 void
2433 cpp_unassert (cpp_reader *pfile, const char *str)
2434 {
2435   handle_assertion (pfile, str, T_UNASSERT);
2436 }
2437
2438 /* Common code for cpp_assert (-A) and cpp_unassert (-A-).  */
2439 static void
2440 handle_assertion (cpp_reader *pfile, const char *str, int type)
2441 {
2442   size_t count = strlen (str);
2443   const char *p = strchr (str, '=');
2444
2445   /* Copy the entire option so we can modify it.  Change the first
2446      "=" in the string to a '(', and tack a ')' on the end.  */
2447   char *buf = (char *) alloca (count + 2);
2448
2449   memcpy (buf, str, count);
2450   if (p)
2451     {
2452       buf[p - str] = '(';
2453       buf[count++] = ')';
2454     }
2455   buf[count] = '\n';
2456   str = buf;
2457
2458   run_directive (pfile, type, str, count);
2459 }
2460
2461 /* The options structure.  */
2462 cpp_options *
2463 cpp_get_options (cpp_reader *pfile)
2464 {
2465   return &pfile->opts;
2466 }
2467
2468 /* The callbacks structure.  */
2469 cpp_callbacks *
2470 cpp_get_callbacks (cpp_reader *pfile)
2471 {
2472   return &pfile->cb;
2473 }
2474
2475 /* Copy the given callbacks structure to our own.  */
2476 void
2477 cpp_set_callbacks (cpp_reader *pfile, cpp_callbacks *cb)
2478 {
2479   pfile->cb = *cb;
2480 }
2481
2482 /* The dependencies structure.  (Creates one if it hasn't already been.)  */
2483 struct deps *
2484 cpp_get_deps (cpp_reader *pfile)
2485 {
2486   if (!pfile->deps)
2487     pfile->deps = deps_init ();
2488   return pfile->deps;
2489 }
2490
2491 /* Push a new buffer on the buffer stack.  Returns the new buffer; it
2492    doesn't fail.  It does not generate a file change call back; that
2493    is the responsibility of the caller.  */
2494 cpp_buffer *
2495 cpp_push_buffer (cpp_reader *pfile, const uchar *buffer, size_t len,
2496                  int from_stage3)
2497 {
2498   cpp_buffer *new_buffer = XOBNEW (&pfile->buffer_ob, cpp_buffer);
2499
2500   /* Clears, amongst other things, if_stack and mi_cmacro.  */
2501   memset (new_buffer, 0, sizeof (cpp_buffer));
2502
2503   new_buffer->next_line = new_buffer->buf = buffer;
2504   new_buffer->rlimit = buffer + len;
2505   new_buffer->from_stage3 = from_stage3;
2506   new_buffer->prev = pfile->buffer;
2507   new_buffer->need_line = true;
2508
2509   pfile->buffer = new_buffer;
2510
2511   return new_buffer;
2512 }
2513
2514 /* Pops a single buffer, with a file change call-back if appropriate.
2515    Then pushes the next -include file, if any remain.  */
2516 void
2517 _cpp_pop_buffer (cpp_reader *pfile)
2518 {
2519   cpp_buffer *buffer = pfile->buffer;
2520   struct _cpp_file *inc = buffer->file;
2521   struct if_stack *ifs;
2522
2523   /* Walk back up the conditional stack till we reach its level at
2524      entry to this file, issuing error messages.  */
2525   for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
2526     cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
2527                          "unterminated #%s", dtable[ifs->type].name);
2528
2529   /* In case of a missing #endif.  */
2530   pfile->state.skipping = 0;
2531
2532   /* _cpp_do_file_change expects pfile->buffer to be the new one.  */
2533   pfile->buffer = buffer->prev;
2534
2535   free (buffer->notes);
2536
2537   /* Free the buffer object now; we may want to push a new buffer
2538      in _cpp_push_next_include_file.  */
2539   obstack_free (&pfile->buffer_ob, buffer);
2540
2541   if (inc)
2542     {
2543       _cpp_pop_file_buffer (pfile, inc);
2544
2545       _cpp_do_file_change (pfile, LC_LEAVE, 0, 0, 0);
2546     }
2547 }
2548
2549 /* Enter all recognized directives in the hash table.  */
2550 void
2551 _cpp_init_directives (cpp_reader *pfile)
2552 {
2553   unsigned int i;
2554   cpp_hashnode *node;
2555
2556   for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
2557     {
2558       node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
2559       node->is_directive = 1;
2560       node->directive_index = i;
2561     }
2562 }