OSDN Git Service

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