OSDN Git Service

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