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) == 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       /* Only evaluate this if we aren't skipping elses.  During
1800          evaluation, set skipping to false to get lexer warnings.  */
1801       if (ifs->skip_elses)
1802         pfile->state.skipping = 1;
1803       else
1804         {
1805           pfile->state.skipping = 0;
1806           pfile->state.skipping = ! _cpp_parse_expr (pfile);
1807           ifs->skip_elses = ! pfile->state.skipping;
1808         }
1809
1810       /* Invalidate any controlling macro.  */
1811       ifs->mi_cmacro = 0;
1812     }
1813 }
1814
1815 /* #endif pops the if stack and resets pfile->state.skipping.  */
1816 static void
1817 do_endif (cpp_reader *pfile)
1818 {
1819   cpp_buffer *buffer = pfile->buffer;
1820   struct if_stack *ifs = buffer->if_stack;
1821
1822   if (ifs == NULL)
1823     cpp_error (pfile, CPP_DL_ERROR, "#endif without #if");
1824   else
1825     {
1826       /* Only check EOL if was not originally skipping.  */
1827       if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
1828         check_eol (pfile);
1829
1830       /* If potential control macro, we go back outside again.  */
1831       if (ifs->next == 0 && ifs->mi_cmacro)
1832         {
1833           pfile->mi_valid = true;
1834           pfile->mi_cmacro = ifs->mi_cmacro;
1835         }
1836
1837       buffer->if_stack = ifs->next;
1838       pfile->state.skipping = ifs->was_skipping;
1839       obstack_free (&pfile->buffer_ob, ifs);
1840     }
1841 }
1842
1843 /* Push an if_stack entry for a preprocessor conditional, and set
1844    pfile->state.skipping to SKIP.  If TYPE indicates the conditional
1845    is #if or #ifndef, CMACRO is a potentially controlling macro, and
1846    we need to check here that we are at the top of the file.  */
1847 static void
1848 push_conditional (cpp_reader *pfile, int skip, int type,
1849                   const cpp_hashnode *cmacro)
1850 {
1851   struct if_stack *ifs;
1852   cpp_buffer *buffer = pfile->buffer;
1853
1854   ifs = XOBNEW (&pfile->buffer_ob, struct if_stack);
1855   ifs->line = pfile->directive_line;
1856   ifs->next = buffer->if_stack;
1857   ifs->skip_elses = pfile->state.skipping || !skip;
1858   ifs->was_skipping = pfile->state.skipping;
1859   ifs->type = type;
1860   /* This condition is effectively a test for top-of-file.  */
1861   if (pfile->mi_valid && pfile->mi_cmacro == 0)
1862     ifs->mi_cmacro = cmacro;
1863   else
1864     ifs->mi_cmacro = 0;
1865
1866   pfile->state.skipping = skip;
1867   buffer->if_stack = ifs;
1868 }
1869
1870 /* Read the tokens of the answer into the macro pool, in a directive
1871    of type TYPE.  Only commit the memory if we intend it as permanent
1872    storage, i.e. the #assert case.  Returns 0 on success, and sets
1873    ANSWERP to point to the answer.  */
1874 static int
1875 parse_answer (cpp_reader *pfile, struct answer **answerp, int type)
1876 {
1877   const cpp_token *paren;
1878   struct answer *answer;
1879   unsigned int acount;
1880
1881   /* In a conditional, it is legal to not have an open paren.  We
1882      should save the following token in this case.  */
1883   paren = cpp_get_token (pfile);
1884
1885   /* If not a paren, see if we're OK.  */
1886   if (paren->type != CPP_OPEN_PAREN)
1887     {
1888       /* In a conditional no answer is a test for any answer.  It
1889          could be followed by any token.  */
1890       if (type == T_IF)
1891         {
1892           _cpp_backup_tokens (pfile, 1);
1893           return 0;
1894         }
1895
1896       /* #unassert with no answer is valid - it removes all answers.  */
1897       if (type == T_UNASSERT && paren->type == CPP_EOF)
1898         return 0;
1899
1900       cpp_error (pfile, CPP_DL_ERROR, "missing '(' after predicate");
1901       return 1;
1902     }
1903
1904   for (acount = 0;; acount++)
1905     {
1906       size_t room_needed;
1907       const cpp_token *token = cpp_get_token (pfile);
1908       cpp_token *dest;
1909
1910       if (token->type == CPP_CLOSE_PAREN)
1911         break;
1912
1913       if (token->type == CPP_EOF)
1914         {
1915           cpp_error (pfile, CPP_DL_ERROR, "missing ')' to complete answer");
1916           return 1;
1917         }
1918
1919       /* struct answer includes the space for one token.  */
1920       room_needed = (sizeof (struct answer) + acount * sizeof (cpp_token));
1921
1922       if (BUFF_ROOM (pfile->a_buff) < room_needed)
1923         _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (struct answer));
1924
1925       dest = &((struct answer *) BUFF_FRONT (pfile->a_buff))->first[acount];
1926       *dest = *token;
1927
1928       /* Drop whitespace at start, for answer equivalence purposes.  */
1929       if (acount == 0)
1930         dest->flags &= ~PREV_WHITE;
1931     }
1932
1933   if (acount == 0)
1934     {
1935       cpp_error (pfile, CPP_DL_ERROR, "predicate's answer is empty");
1936       return 1;
1937     }
1938
1939   answer = (struct answer *) BUFF_FRONT (pfile->a_buff);
1940   answer->count = acount;
1941   answer->next = NULL;
1942   *answerp = answer;
1943
1944   return 0;
1945 }
1946
1947 /* Parses an assertion directive of type TYPE, returning a pointer to
1948    the hash node of the predicate, or 0 on error.  If an answer was
1949    supplied, it is placed in ANSWERP, otherwise it is set to 0.  */
1950 static cpp_hashnode *
1951 parse_assertion (cpp_reader *pfile, struct answer **answerp, int type)
1952 {
1953   cpp_hashnode *result = 0;
1954   const cpp_token *predicate;
1955
1956   /* We don't expand predicates or answers.  */
1957   pfile->state.prevent_expansion++;
1958
1959   *answerp = 0;
1960   predicate = cpp_get_token (pfile);
1961   if (predicate->type == CPP_EOF)
1962     cpp_error (pfile, CPP_DL_ERROR, "assertion without predicate");
1963   else if (predicate->type != CPP_NAME)
1964     cpp_error (pfile, CPP_DL_ERROR, "predicate must be an identifier");
1965   else if (parse_answer (pfile, answerp, type) == 0)
1966     {
1967       unsigned int len = NODE_LEN (predicate->val.node);
1968       unsigned char *sym = (unsigned char *) alloca (len + 1);
1969
1970       /* Prefix '#' to get it out of macro namespace.  */
1971       sym[0] = '#';
1972       memcpy (sym + 1, NODE_NAME (predicate->val.node), len);
1973       result = cpp_lookup (pfile, sym, len + 1);
1974     }
1975
1976   pfile->state.prevent_expansion--;
1977   return result;
1978 }
1979
1980 /* Returns a pointer to the pointer to CANDIDATE in the answer chain,
1981    or a pointer to NULL if the answer is not in the chain.  */
1982 static struct answer **
1983 find_answer (cpp_hashnode *node, const struct answer *candidate)
1984 {
1985   unsigned int i;
1986   struct answer **result;
1987
1988   for (result = &node->value.answers; *result; result = &(*result)->next)
1989     {
1990       struct answer *answer = *result;
1991
1992       if (answer->count == candidate->count)
1993         {
1994           for (i = 0; i < answer->count; i++)
1995             if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
1996               break;
1997
1998           if (i == answer->count)
1999             break;
2000         }
2001     }
2002
2003   return result;
2004 }
2005
2006 /* Test an assertion within a preprocessor conditional.  Returns
2007    nonzero on failure, zero on success.  On success, the result of
2008    the test is written into VALUE, otherwise the value 0.  */
2009 int
2010 _cpp_test_assertion (cpp_reader *pfile, unsigned int *value)
2011 {
2012   struct answer *answer;
2013   cpp_hashnode *node;
2014
2015   node = parse_assertion (pfile, &answer, T_IF);
2016
2017   /* For recovery, an erroneous assertion expression is handled as a
2018      failing assertion.  */
2019   *value = 0;
2020
2021   if (node)
2022     *value = (node->type == NT_ASSERTION &&
2023               (answer == 0 || *find_answer (node, answer) != 0));
2024   else if (pfile->cur_token[-1].type == CPP_EOF)
2025     _cpp_backup_tokens (pfile, 1);
2026
2027   /* We don't commit the memory for the answer - it's temporary only.  */
2028   return node == 0;
2029 }
2030
2031 /* Handle #assert.  */
2032 static void
2033 do_assert (cpp_reader *pfile)
2034 {
2035   struct answer *new_answer;
2036   cpp_hashnode *node;
2037
2038   node = parse_assertion (pfile, &new_answer, T_ASSERT);
2039   if (node)
2040     {
2041       size_t answer_size;
2042
2043       /* Place the new answer in the answer list.  First check there
2044          is not a duplicate.  */
2045       new_answer->next = 0;
2046       if (node->type == NT_ASSERTION)
2047         {
2048           if (*find_answer (node, new_answer))
2049             {
2050               cpp_error (pfile, CPP_DL_WARNING, "\"%s\" re-asserted",
2051                          NODE_NAME (node) + 1);
2052               return;
2053             }
2054           new_answer->next = node->value.answers;
2055         }
2056
2057       answer_size = sizeof (struct answer) + ((new_answer->count - 1)
2058                                               * sizeof (cpp_token));
2059       /* Commit or allocate storage for the object.  */
2060       if (pfile->hash_table->alloc_subobject)
2061         {
2062           struct answer *temp_answer = new_answer;
2063           new_answer = (struct answer *) pfile->hash_table->alloc_subobject
2064             (answer_size);
2065           memcpy (new_answer, temp_answer, answer_size);
2066         }
2067       else
2068         BUFF_FRONT (pfile->a_buff) += answer_size;
2069
2070       node->type = NT_ASSERTION;
2071       node->value.answers = new_answer;
2072       check_eol (pfile);
2073     }
2074 }
2075
2076 /* Handle #unassert.  */
2077 static void
2078 do_unassert (cpp_reader *pfile)
2079 {
2080   cpp_hashnode *node;
2081   struct answer *answer;
2082
2083   node = parse_assertion (pfile, &answer, T_UNASSERT);
2084   /* It isn't an error to #unassert something that isn't asserted.  */
2085   if (node && node->type == NT_ASSERTION)
2086     {
2087       if (answer)
2088         {
2089           struct answer **p = find_answer (node, answer), *temp;
2090
2091           /* Remove the answer from the list.  */
2092           temp = *p;
2093           if (temp)
2094             *p = temp->next;
2095
2096           /* Did we free the last answer?  */
2097           if (node->value.answers == 0)
2098             node->type = NT_VOID;
2099
2100           check_eol (pfile);
2101         }
2102       else
2103         _cpp_free_definition (node);
2104     }
2105
2106   /* We don't commit the memory for the answer - it's temporary only.  */
2107 }
2108
2109 /* These are for -D, -U, -A.  */
2110
2111 /* Process the string STR as if it appeared as the body of a #define.
2112    If STR is just an identifier, define it with value 1.
2113    If STR has anything after the identifier, then it should
2114    be identifier=definition.  */
2115 void
2116 cpp_define (cpp_reader *pfile, const char *str)
2117 {
2118   char *buf, *p;
2119   size_t count;
2120
2121   /* Copy the entire option so we can modify it.
2122      Change the first "=" in the string to a space.  If there is none,
2123      tack " 1" on the end.  */
2124
2125   count = strlen (str);
2126   buf = (char *) alloca (count + 3);
2127   memcpy (buf, str, count);
2128
2129   p = strchr (str, '=');
2130   if (p)
2131     buf[p - str] = ' ';
2132   else
2133     {
2134       buf[count++] = ' ';
2135       buf[count++] = '1';
2136     }
2137   buf[count] = '\n';
2138
2139   run_directive (pfile, T_DEFINE, buf, count);
2140 }
2141
2142
2143 /* Use to build macros to be run through cpp_define() as
2144    described above.
2145    Example: cpp_define_formatted (pfile, "MACRO=%d", value);  */
2146
2147 void
2148 cpp_define_formatted (cpp_reader *pfile, const char *fmt, ...)
2149 {
2150   char *ptr = NULL;
2151
2152   va_list ap;
2153   va_start (ap, fmt);
2154   vasprintf (&ptr, fmt, ap);
2155   va_end (ap);
2156
2157   cpp_define (pfile, ptr);
2158   free (ptr);
2159 }
2160
2161
2162 /* Slight variant of the above for use by initialize_builtins.  */
2163 void
2164 _cpp_define_builtin (cpp_reader *pfile, const char *str)
2165 {
2166   size_t len = strlen (str);
2167   char *buf = (char *) alloca (len + 1);
2168   memcpy (buf, str, len);
2169   buf[len] = '\n';
2170   run_directive (pfile, T_DEFINE, buf, len);
2171 }
2172
2173 /* Process MACRO as if it appeared as the body of an #undef.  */
2174 void
2175 cpp_undef (cpp_reader *pfile, const char *macro)
2176 {
2177   size_t len = strlen (macro);
2178   char *buf = (char *) alloca (len + 1);
2179   memcpy (buf, macro, len);
2180   buf[len] = '\n';
2181   run_directive (pfile, T_UNDEF, buf, len);
2182 }
2183
2184 /* Like lex_macro_node, but read the input from STR.  */
2185 static cpp_hashnode *
2186 lex_macro_node_from_str (cpp_reader *pfile, const char *str)
2187 {
2188   size_t len = strlen (str);
2189   uchar *buf = (uchar *) alloca (len + 1);
2190   cpp_hashnode *node;
2191
2192   memcpy (buf, str, len);
2193   buf[len] = '\n';
2194   cpp_push_buffer (pfile, buf, len, true);
2195   node = lex_macro_node (pfile, true);
2196   _cpp_pop_buffer (pfile);
2197
2198   return node;
2199 }
2200
2201 /* If STR is a defined macro, return its definition node, else return NULL.  */
2202 cpp_macro *
2203 cpp_push_definition (cpp_reader *pfile, const char *str)
2204 {
2205   cpp_hashnode *node = lex_macro_node_from_str (pfile, str);
2206   if (node && node->type == NT_MACRO)
2207     return node->value.macro;
2208   else
2209     return NULL;
2210 }
2211
2212 /* Replace a previous definition DFN of the macro STR.  If DFN is NULL,
2213    then the macro should be undefined.  */
2214 void
2215 cpp_pop_definition (cpp_reader *pfile, const char *str, cpp_macro *dfn)
2216 {
2217   cpp_hashnode *node = lex_macro_node_from_str (pfile, str);
2218   if (node == NULL)
2219     return;
2220
2221   if (pfile->cb.before_define)
2222     pfile->cb.before_define (pfile);
2223
2224   if (node->type == NT_MACRO)
2225     {
2226       if (pfile->cb.undef)
2227         pfile->cb.undef (pfile, pfile->directive_line, node);
2228       if (CPP_OPTION (pfile, warn_unused_macros))
2229         _cpp_warn_if_unused_macro (pfile, node, NULL);
2230     }
2231   if (node->type != NT_VOID)
2232     _cpp_free_definition (node);
2233
2234   if (dfn)
2235     {
2236       node->type = NT_MACRO;
2237       node->value.macro = dfn;
2238       if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_")))
2239         node->flags |= NODE_WARN;
2240
2241       if (pfile->cb.define)
2242         pfile->cb.define (pfile, pfile->directive_line, node);
2243     }
2244 }
2245
2246 /* Process the string STR as if it appeared as the body of a #assert.  */
2247 void
2248 cpp_assert (cpp_reader *pfile, const char *str)
2249 {
2250   handle_assertion (pfile, str, T_ASSERT);
2251 }
2252
2253 /* Process STR as if it appeared as the body of an #unassert.  */
2254 void
2255 cpp_unassert (cpp_reader *pfile, const char *str)
2256 {
2257   handle_assertion (pfile, str, T_UNASSERT);
2258 }
2259
2260 /* Common code for cpp_assert (-A) and cpp_unassert (-A-).  */
2261 static void
2262 handle_assertion (cpp_reader *pfile, const char *str, int type)
2263 {
2264   size_t count = strlen (str);
2265   const char *p = strchr (str, '=');
2266
2267   /* Copy the entire option so we can modify it.  Change the first
2268      "=" in the string to a '(', and tack a ')' on the end.  */
2269   char *buf = (char *) alloca (count + 2);
2270
2271   memcpy (buf, str, count);
2272   if (p)
2273     {
2274       buf[p - str] = '(';
2275       buf[count++] = ')';
2276     }
2277   buf[count] = '\n';
2278   str = buf;
2279
2280   run_directive (pfile, type, str, count);
2281 }
2282
2283 /* The number of errors for a given reader.  */
2284 unsigned int
2285 cpp_errors (cpp_reader *pfile)
2286 {
2287   return pfile->errors;
2288 }
2289
2290 /* The options structure.  */
2291 cpp_options *
2292 cpp_get_options (cpp_reader *pfile)
2293 {
2294   return &pfile->opts;
2295 }
2296
2297 /* The callbacks structure.  */
2298 cpp_callbacks *
2299 cpp_get_callbacks (cpp_reader *pfile)
2300 {
2301   return &pfile->cb;
2302 }
2303
2304 /* Copy the given callbacks structure to our own.  */
2305 void
2306 cpp_set_callbacks (cpp_reader *pfile, cpp_callbacks *cb)
2307 {
2308   pfile->cb = *cb;
2309 }
2310
2311 /* The dependencies structure.  (Creates one if it hasn't already been.)  */
2312 struct deps *
2313 cpp_get_deps (cpp_reader *pfile)
2314 {
2315   if (!pfile->deps)
2316     pfile->deps = deps_init ();
2317   return pfile->deps;
2318 }
2319
2320 /* Push a new buffer on the buffer stack.  Returns the new buffer; it
2321    doesn't fail.  It does not generate a file change call back; that
2322    is the responsibility of the caller.  */
2323 cpp_buffer *
2324 cpp_push_buffer (cpp_reader *pfile, const uchar *buffer, size_t len,
2325                  int from_stage3)
2326 {
2327   cpp_buffer *new_buffer = XOBNEW (&pfile->buffer_ob, cpp_buffer);
2328
2329   /* Clears, amongst other things, if_stack and mi_cmacro.  */
2330   memset (new_buffer, 0, sizeof (cpp_buffer));
2331
2332   new_buffer->next_line = new_buffer->buf = buffer;
2333   new_buffer->rlimit = buffer + len;
2334   new_buffer->from_stage3 = from_stage3;
2335   new_buffer->prev = pfile->buffer;
2336   new_buffer->need_line = true;
2337
2338   pfile->buffer = new_buffer;
2339
2340   return new_buffer;
2341 }
2342
2343 /* Pops a single buffer, with a file change call-back if appropriate.
2344    Then pushes the next -include file, if any remain.  */
2345 void
2346 _cpp_pop_buffer (cpp_reader *pfile)
2347 {
2348   cpp_buffer *buffer = pfile->buffer;
2349   struct _cpp_file *inc = buffer->file;
2350   struct if_stack *ifs;
2351
2352   /* Walk back up the conditional stack till we reach its level at
2353      entry to this file, issuing error messages.  */
2354   for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
2355     cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
2356                          "unterminated #%s", dtable[ifs->type].name);
2357
2358   /* In case of a missing #endif.  */
2359   pfile->state.skipping = 0;
2360
2361   /* _cpp_do_file_change expects pfile->buffer to be the new one.  */
2362   pfile->buffer = buffer->prev;
2363
2364   free (buffer->notes);
2365
2366   /* Free the buffer object now; we may want to push a new buffer
2367      in _cpp_push_next_include_file.  */
2368   obstack_free (&pfile->buffer_ob, buffer);
2369
2370   if (inc)
2371     {
2372       _cpp_pop_file_buffer (pfile, inc);
2373
2374       _cpp_do_file_change (pfile, LC_LEAVE, 0, 0, 0);
2375     }
2376 }
2377
2378 /* Enter all recognized directives in the hash table.  */
2379 void
2380 _cpp_init_directives (cpp_reader *pfile)
2381 {
2382   unsigned int i;
2383   cpp_hashnode *node;
2384
2385   for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
2386     {
2387       node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
2388       node->is_directive = 1;
2389       node->directive_index = i;
2390     }
2391 }