OSDN Git Service

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