OSDN Git Service

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