OSDN Git Service

libcpp/
[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 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)
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 (_cpp_create_definition (pfile, node))
563         if (pfile->cb.define)
564           pfile->cb.define (pfile, pfile->directive_line, node);
565     }
566 }
567
568 /* Handle #undef.  Mark the identifier NT_VOID in the hash table.  */
569 static void
570 do_undef (cpp_reader *pfile)
571 {
572   cpp_hashnode *node = lex_macro_node (pfile, true);
573
574   if (node)
575     {
576       if (pfile->cb.undef)
577         pfile->cb.undef (pfile, pfile->directive_line, node);
578
579       /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified
580          identifier is not currently defined as a macro name.  */
581       if (node->type == NT_MACRO)
582         {
583           if (node->flags & NODE_WARN)
584             cpp_error (pfile, CPP_DL_WARNING,
585                        "undefining \"%s\"", NODE_NAME (node));
586
587           if (CPP_OPTION (pfile, warn_unused_macros))
588             _cpp_warn_if_unused_macro (pfile, node, NULL);
589
590           _cpp_free_definition (node);
591         }
592     }
593
594   check_eol (pfile);
595 }
596
597 /* Undefine a single macro/assertion/whatever.  */
598
599 static int
600 undefine_macros (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *h,
601                  void *data_p ATTRIBUTE_UNUSED)
602 {
603   /* Body of _cpp_free_definition inlined here for speed.
604      Macros and assertions no longer have anything to free.  */
605   h->type = NT_VOID;
606   h->flags &= ~(NODE_POISONED|NODE_BUILTIN|NODE_DISABLED);
607   return 1;
608 }
609
610 /* Undefine all macros and assertions.  */
611
612 void
613 cpp_undef_all (cpp_reader *pfile)
614 {
615   cpp_forall_identifiers (pfile, undefine_macros, NULL);
616 }
617
618
619 /* Helper routine used by parse_include.  Reinterpret the current line
620    as an h-char-sequence (< ... >); we are looking at the first token
621    after the <.  Returns a malloced filename.  */
622 static char *
623 glue_header_name (cpp_reader *pfile)
624 {
625   const cpp_token *token;
626   char *buffer;
627   size_t len, total_len = 0, capacity = 1024;
628
629   /* To avoid lexed tokens overwriting our glued name, we can only
630      allocate from the string pool once we've lexed everything.  */
631   buffer = XNEWVEC (char, capacity);
632   for (;;)
633     {
634       token = get_token_no_padding (pfile);
635
636       if (token->type == CPP_GREATER)
637         break;
638       if (token->type == CPP_EOF)
639         {
640           cpp_error (pfile, CPP_DL_ERROR, "missing terminating > character");
641           break;
642         }
643
644       len = cpp_token_len (token) + 2; /* Leading space, terminating \0.  */
645       if (total_len + len > capacity)
646         {
647           capacity = (capacity + len) * 2;
648           buffer = XRESIZEVEC (char, buffer, capacity);
649         }
650
651       if (token->flags & PREV_WHITE)
652         buffer[total_len++] = ' ';
653
654       total_len = (cpp_spell_token (pfile, token, (uchar *) &buffer[total_len],
655                                     true)
656                    - (uchar *) buffer);
657     }
658
659   buffer[total_len] = '\0';
660   return buffer;
661 }
662
663 /* Returns the file name of #include, #include_next, #import and
664    #pragma dependency.  The string is malloced and the caller should
665    free it.  Returns NULL on error.  */
666 static const char *
667 parse_include (cpp_reader *pfile, int *pangle_brackets,
668                const cpp_token ***buf)
669 {
670   char *fname;
671   const cpp_token *header;
672
673   /* Allow macro expansion.  */
674   header = get_token_no_padding (pfile);
675   if (header->type == CPP_STRING || header->type == CPP_HEADER_NAME)
676     {
677       fname = XNEWVEC (char, header->val.str.len - 1);
678       memcpy (fname, header->val.str.text + 1, header->val.str.len - 2);
679       fname[header->val.str.len - 2] = '\0';
680       *pangle_brackets = header->type == CPP_HEADER_NAME;
681     }
682   else if (header->type == CPP_LESS)
683     {
684       fname = glue_header_name (pfile);
685       *pangle_brackets = 1;
686     }
687   else
688     {
689       const unsigned char *dir;
690
691       if (pfile->directive == &dtable[T_PRAGMA])
692         dir = U"pragma dependency";
693       else
694         dir = pfile->directive->name;
695       cpp_error (pfile, CPP_DL_ERROR, "#%s expects \"FILENAME\" or <FILENAME>",
696                  dir);
697
698       return NULL;
699     }
700
701   if (buf == NULL || CPP_OPTION (pfile, discard_comments))
702     check_eol (pfile);
703   else
704     {
705       /* If we are not discarding comments, then gather them while
706          doing the eol check.  */
707       *buf = check_eol_return_comments (pfile);
708     }
709
710   return fname;
711 }
712
713 /* Handle #include, #include_next and #import.  */
714 static void
715 do_include_common (cpp_reader *pfile, enum include_type type)
716 {
717   const char *fname;
718   int angle_brackets;
719   const cpp_token **buf = NULL;
720
721   /* Re-enable saving of comments if requested, so that the include
722      callback can dump comments which follow #include.  */
723   pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
724
725   fname = parse_include (pfile, &angle_brackets, &buf);
726   if (!fname)
727     {
728       if (buf)
729         XDELETEVEC (buf);
730       return;
731     }
732
733   if (!*fname)
734   {
735     cpp_error (pfile, CPP_DL_ERROR, "empty filename in #%s",
736                pfile->directive->name);
737     XDELETEVEC (fname);
738     if (buf)
739       XDELETEVEC (buf);
740     return;
741   }
742
743   /* Prevent #include recursion.  */
744   if (pfile->line_table->depth >= CPP_STACK_MAX)
745     cpp_error (pfile, CPP_DL_ERROR, "#include nested too deeply");
746   else
747     {
748       /* Get out of macro context, if we are.  */
749       skip_rest_of_line (pfile);
750
751       if (pfile->cb.include)
752         pfile->cb.include (pfile, pfile->directive_line,
753                            pfile->directive->name, fname, angle_brackets,
754                            buf);
755
756       _cpp_stack_include (pfile, fname, angle_brackets, type);
757     }
758
759   XDELETEVEC (fname);
760   if (buf)
761     XDELETEVEC (buf);
762 }
763
764 static void
765 do_include (cpp_reader *pfile)
766 {
767   do_include_common (pfile, IT_INCLUDE);
768 }
769
770 static void
771 do_import (cpp_reader *pfile)
772 {
773   do_include_common (pfile, IT_IMPORT);
774 }
775
776 static void
777 do_include_next (cpp_reader *pfile)
778 {
779   enum include_type type = IT_INCLUDE_NEXT;
780
781   /* If this is the primary source file, warn and use the normal
782      search logic.  */
783   if (cpp_in_primary_file (pfile))
784     {
785       cpp_error (pfile, CPP_DL_WARNING,
786                  "#include_next in primary source file");
787       type = IT_INCLUDE;
788     }
789   do_include_common (pfile, type);
790 }
791
792 /* Subroutine of do_linemarker.  Read possible flags after file name.
793    LAST is the last flag seen; 0 if this is the first flag. Return the
794    flag if it is valid, 0 at the end of the directive. Otherwise
795    complain.  */
796 static unsigned int
797 read_flag (cpp_reader *pfile, unsigned int last)
798 {
799   const cpp_token *token = _cpp_lex_token (pfile);
800
801   if (token->type == CPP_NUMBER && token->val.str.len == 1)
802     {
803       unsigned int flag = token->val.str.text[0] - '0';
804
805       if (flag > last && flag <= 4
806           && (flag != 4 || last == 3)
807           && (flag != 2 || last == 0))
808         return flag;
809     }
810
811   if (token->type != CPP_EOF)
812     cpp_error (pfile, CPP_DL_ERROR, "invalid flag \"%s\" in line directive",
813                cpp_token_as_text (pfile, token));
814   return 0;
815 }
816
817 /* Subroutine of do_line and do_linemarker.  Convert a number in STR,
818    of length LEN, to binary; store it in NUMP, and return 0 if the
819    number was well-formed, 1 if not.  Temporary, hopefully.  */
820 static int
821 strtoul_for_line (const uchar *str, unsigned int len, long unsigned int *nump)
822 {
823   unsigned long reg = 0;
824   uchar c;
825   while (len--)
826     {
827       c = *str++;
828       if (!ISDIGIT (c))
829         return 1;
830       reg *= 10;
831       reg += c - '0';
832     }
833   *nump = reg;
834   return 0;
835 }
836
837 /* Interpret #line command.
838    Note that the filename string (if any) is a true string constant
839    (escapes are interpreted), unlike in #line.  */
840 static void
841 do_line (cpp_reader *pfile)
842 {
843   const struct line_maps *line_table = pfile->line_table;
844   const struct line_map *map = &line_table->maps[line_table->used - 1];
845
846   /* skip_rest_of_line() may cause line table to be realloc()ed so note down
847      sysp right now.  */
848
849   unsigned char map_sysp = map->sysp;
850   const cpp_token *token;
851   const char *new_file = map->to_file;
852   unsigned long new_lineno;
853
854   /* C99 raised the minimum limit on #line numbers.  */
855   unsigned int cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
856
857   /* #line commands expand macros.  */
858   token = cpp_get_token (pfile);
859   if (token->type != CPP_NUMBER
860       || strtoul_for_line (token->val.str.text, token->val.str.len,
861                            &new_lineno))
862     {
863       cpp_error (pfile, CPP_DL_ERROR,
864                  "\"%s\" after #line is not a positive integer",
865                  cpp_token_as_text (pfile, token));
866       return;
867     }
868
869   if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap))
870     cpp_error (pfile, CPP_DL_PEDWARN, "line number out of range");
871
872   token = cpp_get_token (pfile);
873   if (token->type == CPP_STRING)
874     {
875       cpp_string s = { 0, 0 };
876       if (cpp_interpret_string_notranslate (pfile, &token->val.str, 1,
877                                             &s, false))
878         new_file = (const char *)s.text;
879       check_eol (pfile);
880     }
881   else if (token->type != CPP_EOF)
882     {
883       cpp_error (pfile, CPP_DL_ERROR, "\"%s\" is not a valid filename",
884                  cpp_token_as_text (pfile, token));
885       return;
886     }
887
888   skip_rest_of_line (pfile);
889   _cpp_do_file_change (pfile, LC_RENAME, new_file, new_lineno,
890                        map_sysp);
891 }
892
893 /* Interpret the # 44 "file" [flags] notation, which has slightly
894    different syntax and semantics from #line:  Flags are allowed,
895    and we never complain about the line number being too big.  */
896 static void
897 do_linemarker (cpp_reader *pfile)
898 {
899   const struct line_maps *line_table = pfile->line_table;
900   const struct line_map *map = &line_table->maps[line_table->used - 1];
901   const cpp_token *token;
902   const char *new_file = map->to_file;
903   unsigned long new_lineno;
904   unsigned int new_sysp = map->sysp;
905   enum lc_reason reason = LC_RENAME;
906   int flag;
907
908   /* Back up so we can get the number again.  Putting this in
909      _cpp_handle_directive risks two calls to _cpp_backup_tokens in
910      some circumstances, which can segfault.  */
911   _cpp_backup_tokens (pfile, 1);
912
913   /* #line commands expand macros.  */
914   token = cpp_get_token (pfile);
915   if (token->type != CPP_NUMBER
916       || strtoul_for_line (token->val.str.text, token->val.str.len,
917                            &new_lineno))
918     {
919       cpp_error (pfile, CPP_DL_ERROR,
920                  "\"%s\" after # is not a positive integer",
921                  cpp_token_as_text (pfile, token));
922       return;
923     }
924
925   token = cpp_get_token (pfile);
926   if (token->type == CPP_STRING)
927     {
928       cpp_string s = { 0, 0 };
929       if (cpp_interpret_string_notranslate (pfile, &token->val.str,
930                                             1, &s, false))
931         new_file = (const char *)s.text;
932
933       new_sysp = 0;
934       flag = read_flag (pfile, 0);
935       if (flag == 1)
936         {
937           reason = LC_ENTER;
938           /* Fake an include for cpp_included ().  */
939           _cpp_fake_include (pfile, new_file);
940           flag = read_flag (pfile, flag);
941         }
942       else if (flag == 2)
943         {
944           reason = LC_LEAVE;
945           flag = read_flag (pfile, flag);
946         }
947       if (flag == 3)
948         {
949           new_sysp = 1;
950           flag = read_flag (pfile, flag);
951           if (flag == 4)
952             new_sysp = 2;
953         }
954       pfile->buffer->sysp = new_sysp;
955
956       check_eol (pfile);
957     }
958   else if (token->type != CPP_EOF)
959     {
960       cpp_error (pfile, CPP_DL_ERROR, "\"%s\" is not a valid filename",
961                  cpp_token_as_text (pfile, token));
962       return;
963     }
964
965   skip_rest_of_line (pfile);
966   _cpp_do_file_change (pfile, reason, new_file, new_lineno, new_sysp);
967 }
968
969 /* Arrange the file_change callback.  pfile->line has changed to
970    FILE_LINE of TO_FILE, for reason REASON.  SYSP is 1 for a system
971    header, 2 for a system header that needs to be extern "C" protected,
972    and zero otherwise.  */
973 void
974 _cpp_do_file_change (cpp_reader *pfile, enum lc_reason reason,
975                      const char *to_file, unsigned int file_line,
976                      unsigned int sysp)
977 {
978   const struct line_map *map = linemap_add (pfile->line_table, reason, sysp,
979                                             to_file, file_line);
980   if (map != NULL)
981     linemap_line_start (pfile->line_table, map->to_line, 127);
982
983   if (pfile->cb.file_change)
984     pfile->cb.file_change (pfile, map);
985 }
986
987 /* Report a warning or error detected by the program we are
988    processing.  Use the directive's tokens in the error message.  */
989 static void
990 do_diagnostic (cpp_reader *pfile, int code, int print_dir)
991 {
992   if (_cpp_begin_message (pfile, code, pfile->cur_token[-1].src_loc, 0))
993     {
994       if (print_dir)
995         fprintf (stderr, "#%s ", pfile->directive->name);
996       pfile->state.prevent_expansion++;
997       cpp_output_line (pfile, stderr);
998       pfile->state.prevent_expansion--;
999     }
1000 }
1001
1002 static void
1003 do_error (cpp_reader *pfile)
1004 {
1005   do_diagnostic (pfile, CPP_DL_ERROR, 1);
1006 }
1007
1008 static void
1009 do_warning (cpp_reader *pfile)
1010 {
1011   /* We want #warning diagnostics to be emitted in system headers too.  */
1012   do_diagnostic (pfile, CPP_DL_WARNING_SYSHDR, 1);
1013 }
1014
1015 /* Report program identification.  */
1016 static void
1017 do_ident (cpp_reader *pfile)
1018 {
1019   const cpp_token *str = cpp_get_token (pfile);
1020
1021   if (str->type != CPP_STRING)
1022     cpp_error (pfile, CPP_DL_ERROR, "invalid #%s directive",
1023                pfile->directive->name);
1024   else if (pfile->cb.ident)
1025     pfile->cb.ident (pfile, pfile->directive_line, &str->val.str);
1026
1027   check_eol (pfile);
1028 }
1029
1030 /* Lookup a PRAGMA name in a singly-linked CHAIN.  Returns the
1031    matching entry, or NULL if none is found.  The returned entry could
1032    be the start of a namespace chain, or a pragma.  */
1033 static struct pragma_entry *
1034 lookup_pragma_entry (struct pragma_entry *chain, const cpp_hashnode *pragma)
1035 {
1036   while (chain && chain->pragma != pragma)
1037     chain = chain->next;
1038
1039   return chain;
1040 }
1041
1042 /* Create and insert a blank pragma entry at the beginning of a
1043    singly-linked CHAIN.  */
1044 static struct pragma_entry *
1045 new_pragma_entry (cpp_reader *pfile, struct pragma_entry **chain)
1046 {
1047   struct pragma_entry *new_entry;
1048
1049   new_entry = (struct pragma_entry *)
1050     _cpp_aligned_alloc (pfile, sizeof (struct pragma_entry));
1051
1052   memset (new_entry, 0, sizeof (struct pragma_entry));
1053   new_entry->next = *chain;
1054
1055   *chain = new_entry;
1056   return new_entry;
1057 }
1058
1059 /* Register a pragma NAME in namespace SPACE.  If SPACE is null, it
1060    goes in the global namespace.  */
1061 static struct pragma_entry *
1062 register_pragma_1 (cpp_reader *pfile, const char *space, const char *name,
1063                    bool allow_name_expansion)
1064 {
1065   struct pragma_entry **chain = &pfile->pragmas;
1066   struct pragma_entry *entry;
1067   const cpp_hashnode *node;
1068
1069   if (space)
1070     {
1071       node = cpp_lookup (pfile, U space, strlen (space));
1072       entry = lookup_pragma_entry (*chain, node);
1073       if (!entry)
1074         {
1075           entry = new_pragma_entry (pfile, chain);
1076           entry->pragma = node;
1077           entry->is_nspace = true;
1078           entry->allow_expansion = allow_name_expansion;
1079         }
1080       else if (!entry->is_nspace)
1081         goto clash;
1082       else if (entry->allow_expansion != allow_name_expansion)
1083         {
1084           cpp_error (pfile, CPP_DL_ICE,
1085                      "registering pragmas in namespace \"%s\" with mismatched "
1086                      "name expansion", space);
1087           return NULL;
1088         }
1089       chain = &entry->u.space;
1090     }
1091   else if (allow_name_expansion)
1092     {
1093       cpp_error (pfile, CPP_DL_ICE,
1094                  "registering pragma \"%s\" with name expansion "
1095                  "and no namespace", name);
1096       return NULL;
1097     }
1098
1099   /* Check for duplicates.  */
1100   node = cpp_lookup (pfile, U name, strlen (name));
1101   entry = lookup_pragma_entry (*chain, node);
1102   if (entry == NULL)
1103     {
1104       entry = new_pragma_entry (pfile, chain);
1105       entry->pragma = node;
1106       return entry;
1107     }
1108
1109   if (entry->is_nspace)
1110     clash:
1111     cpp_error (pfile, CPP_DL_ICE,
1112                "registering \"%s\" as both a pragma and a pragma namespace",
1113                NODE_NAME (node));
1114   else if (space)
1115     cpp_error (pfile, CPP_DL_ICE, "#pragma %s %s is already registered",
1116                space, name);
1117   else
1118     cpp_error (pfile, CPP_DL_ICE, "#pragma %s is already registered", name);
1119
1120   return NULL;
1121 }
1122
1123 /* Register a cpplib internal pragma SPACE NAME with HANDLER.  */
1124 static void
1125 register_pragma_internal (cpp_reader *pfile, const char *space,
1126                           const char *name, pragma_cb handler)
1127 {
1128   struct pragma_entry *entry;
1129
1130   entry = register_pragma_1 (pfile, space, name, false);
1131   entry->is_internal = true;
1132   entry->u.handler = handler;
1133 }
1134
1135 /* Register a pragma NAME in namespace SPACE.  If SPACE is null, it
1136    goes in the global namespace.  HANDLER is the handler it will call,
1137    which must be non-NULL.  If ALLOW_EXPANSION is set, allow macro
1138    expansion while parsing pragma NAME.  This function is exported
1139    from libcpp. */
1140 void
1141 cpp_register_pragma (cpp_reader *pfile, const char *space, const char *name,
1142                      pragma_cb handler, bool allow_expansion)
1143 {
1144   struct pragma_entry *entry;
1145
1146   if (!handler)
1147     {
1148       cpp_error (pfile, CPP_DL_ICE, "registering pragma with NULL handler");
1149       return;
1150     }
1151
1152   entry = register_pragma_1 (pfile, space, name, false);
1153   if (entry)
1154     {
1155       entry->allow_expansion = allow_expansion;
1156       entry->u.handler = handler;
1157     }
1158 }
1159
1160 /* Similarly, but create mark the pragma for deferred processing.
1161    When found, a CPP_PRAGMA token will be insertted into the stream
1162    with IDENT in the token->u.pragma slot.  */
1163 void
1164 cpp_register_deferred_pragma (cpp_reader *pfile, const char *space,
1165                               const char *name, unsigned int ident,
1166                               bool allow_expansion, bool allow_name_expansion)
1167 {
1168   struct pragma_entry *entry;
1169
1170   entry = register_pragma_1 (pfile, space, name, allow_name_expansion);
1171   if (entry)
1172     {
1173       entry->is_deferred = true;
1174       entry->allow_expansion = allow_expansion;
1175       entry->u.ident = ident;
1176     }
1177 }  
1178
1179 /* Register the pragmas the preprocessor itself handles.  */
1180 void
1181 _cpp_init_internal_pragmas (cpp_reader *pfile)
1182 {
1183   /* Pragmas in the global namespace.  */
1184   register_pragma_internal (pfile, 0, "once", do_pragma_once);
1185
1186   /* New GCC-specific pragmas should be put in the GCC namespace.  */
1187   register_pragma_internal (pfile, "GCC", "poison", do_pragma_poison);
1188   register_pragma_internal (pfile, "GCC", "system_header",
1189                             do_pragma_system_header);
1190   register_pragma_internal (pfile, "GCC", "dependency", do_pragma_dependency);
1191 }
1192
1193 /* Return the number of registered pragmas in PE.  */
1194
1195 static int
1196 count_registered_pragmas (struct pragma_entry *pe)
1197 {
1198   int ct = 0;
1199   for (; pe != NULL; pe = pe->next)
1200     {
1201       if (pe->is_nspace)
1202         ct += count_registered_pragmas (pe->u.space);
1203       ct++;
1204     }
1205   return ct;
1206 }
1207
1208 /* Save into SD the names of the registered pragmas referenced by PE,
1209    and return a pointer to the next free space in SD.  */
1210
1211 static char **
1212 save_registered_pragmas (struct pragma_entry *pe, char **sd)
1213 {
1214   for (; pe != NULL; pe = pe->next)
1215     {
1216       if (pe->is_nspace)
1217         sd = save_registered_pragmas (pe->u.space, sd);
1218       *sd++ = (char *) xmemdup (HT_STR (&pe->pragma->ident),
1219                                 HT_LEN (&pe->pragma->ident),
1220                                 HT_LEN (&pe->pragma->ident) + 1);
1221     }
1222   return sd;
1223 }
1224
1225 /* Return a newly-allocated array which saves the names of the
1226    registered pragmas.  */
1227
1228 char **
1229 _cpp_save_pragma_names (cpp_reader *pfile)
1230 {
1231   int ct = count_registered_pragmas (pfile->pragmas);
1232   char **result = XNEWVEC (char *, ct);
1233   (void) save_registered_pragmas (pfile->pragmas, result);
1234   return result;
1235 }
1236
1237 /* Restore from SD the names of the registered pragmas referenced by PE,
1238    and return a pointer to the next unused name in SD.  */
1239
1240 static char **
1241 restore_registered_pragmas (cpp_reader *pfile, struct pragma_entry *pe,
1242                             char **sd)
1243 {
1244   for (; pe != NULL; pe = pe->next)
1245     {
1246       if (pe->is_nspace)
1247         sd = restore_registered_pragmas (pfile, pe->u.space, sd);
1248       pe->pragma = cpp_lookup (pfile, U *sd, strlen (*sd));
1249       free (*sd);
1250       sd++;
1251     }
1252   return sd;
1253 }
1254
1255 /* Restore the names of the registered pragmas from SAVED.  */
1256
1257 void
1258 _cpp_restore_pragma_names (cpp_reader *pfile, char **saved)
1259 {
1260   (void) restore_registered_pragmas (pfile, pfile->pragmas, saved);
1261   free (saved);
1262 }
1263
1264 /* Pragmata handling.  We handle some, and pass the rest on to the
1265    front end.  C99 defines three pragmas and says that no macro
1266    expansion is to be performed on them; whether or not macro
1267    expansion happens for other pragmas is implementation defined.
1268    This implementation allows for a mix of both, since GCC did not
1269    traditionally macro expand its (few) pragmas, whereas OpenMP
1270    specifies that macro expansion should happen.  */
1271 static void
1272 do_pragma (cpp_reader *pfile)
1273 {
1274   const struct pragma_entry *p = NULL;
1275   const cpp_token *token, *pragma_token = pfile->cur_token;
1276   cpp_token ns_token;
1277   unsigned int count = 1;
1278
1279   pfile->state.prevent_expansion++;
1280
1281   token = cpp_get_token (pfile);
1282   ns_token = *token;
1283   if (token->type == CPP_NAME)
1284     {
1285       p = lookup_pragma_entry (pfile->pragmas, token->val.node);
1286       if (p && p->is_nspace)
1287         {
1288           bool allow_name_expansion = p->allow_expansion;
1289           if (allow_name_expansion)
1290             pfile->state.prevent_expansion--;
1291           token = cpp_get_token (pfile);
1292           if (token->type == CPP_NAME)
1293             p = lookup_pragma_entry (p->u.space, token->val.node);
1294           else
1295             p = NULL;
1296           if (allow_name_expansion)
1297             pfile->state.prevent_expansion++;
1298           count = 2;
1299         }
1300     }
1301
1302   if (p)
1303     {
1304       if (p->is_deferred)
1305         {
1306           pfile->directive_result.src_loc = pragma_token->src_loc;
1307           pfile->directive_result.type = CPP_PRAGMA;
1308           pfile->directive_result.flags = pragma_token->flags;
1309           pfile->directive_result.val.pragma = p->u.ident;
1310           pfile->state.in_deferred_pragma = true;
1311           pfile->state.pragma_allow_expansion = p->allow_expansion;
1312           if (!p->allow_expansion)
1313             pfile->state.prevent_expansion++;
1314         }
1315       else
1316         {
1317           /* Since the handler below doesn't get the line number, that
1318              it might need for diagnostics, make sure it has the right
1319              numbers in place.  */
1320           if (pfile->cb.line_change)
1321             (*pfile->cb.line_change) (pfile, pragma_token, false);
1322           if (p->allow_expansion)
1323             pfile->state.prevent_expansion--;
1324           (*p->u.handler) (pfile);
1325           if (p->allow_expansion)
1326             pfile->state.prevent_expansion++;
1327         }
1328     }
1329   else if (pfile->cb.def_pragma)
1330     {
1331       if (count == 1 || pfile->context->prev == NULL)
1332         _cpp_backup_tokens (pfile, count);
1333       else
1334         {
1335           /* Invalid name comes from macro expansion, _cpp_backup_tokens
1336              won't allow backing 2 tokens.  */
1337           /* ??? The token buffer is leaked.  Perhaps if def_pragma hook
1338              reads both tokens, we could perhaps free it, but if it doesn't,
1339              we don't know the exact lifespan.  */
1340           cpp_token *toks = XNEWVEC (cpp_token, 2);
1341           toks[0] = ns_token;
1342           toks[0].flags |= NO_EXPAND;
1343           toks[1] = *token;
1344           toks[1].flags |= NO_EXPAND;
1345           _cpp_push_token_context (pfile, NULL, toks, 2);
1346         }
1347       pfile->cb.def_pragma (pfile, pfile->directive_line);
1348     }
1349
1350   pfile->state.prevent_expansion--;
1351 }
1352
1353 /* Handle #pragma once.  */
1354 static void
1355 do_pragma_once (cpp_reader *pfile)
1356 {
1357   if (cpp_in_primary_file (pfile))
1358     cpp_error (pfile, CPP_DL_WARNING, "#pragma once in main file");
1359
1360   check_eol (pfile);
1361   _cpp_mark_file_once_only (pfile, pfile->buffer->file);
1362 }
1363
1364 /* Handle #pragma GCC poison, to poison one or more identifiers so
1365    that the lexer produces a hard error for each subsequent usage.  */
1366 static void
1367 do_pragma_poison (cpp_reader *pfile)
1368 {
1369   const cpp_token *tok;
1370   cpp_hashnode *hp;
1371
1372   pfile->state.poisoned_ok = 1;
1373   for (;;)
1374     {
1375       tok = _cpp_lex_token (pfile);
1376       if (tok->type == CPP_EOF)
1377         break;
1378       if (tok->type != CPP_NAME)
1379         {
1380           cpp_error (pfile, CPP_DL_ERROR,
1381                      "invalid #pragma GCC poison directive");
1382           break;
1383         }
1384
1385       hp = tok->val.node;
1386       if (hp->flags & NODE_POISONED)
1387         continue;
1388
1389       if (hp->type == NT_MACRO)
1390         cpp_error (pfile, CPP_DL_WARNING, "poisoning existing macro \"%s\"",
1391                    NODE_NAME (hp));
1392       _cpp_free_definition (hp);
1393       hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1394     }
1395   pfile->state.poisoned_ok = 0;
1396 }
1397
1398 /* Mark the current header as a system header.  This will suppress
1399    some categories of warnings (notably those from -pedantic).  It is
1400    intended for use in system libraries that cannot be implemented in
1401    conforming C, but cannot be certain that their headers appear in a
1402    system include directory.  To prevent abuse, it is rejected in the
1403    primary source file.  */
1404 static void
1405 do_pragma_system_header (cpp_reader *pfile)
1406 {
1407   if (cpp_in_primary_file (pfile))
1408     cpp_error (pfile, CPP_DL_WARNING,
1409                "#pragma system_header ignored outside include file");
1410   else
1411     {
1412       check_eol (pfile);
1413       skip_rest_of_line (pfile);
1414       cpp_make_system_header (pfile, 1, 0);
1415     }
1416 }
1417
1418 /* Check the modified date of the current include file against a specified
1419    file. Issue a diagnostic, if the specified file is newer. We use this to
1420    determine if a fixed header should be refixed.  */
1421 static void
1422 do_pragma_dependency (cpp_reader *pfile)
1423 {
1424   const char *fname;
1425   int angle_brackets, ordering;
1426
1427   fname = parse_include (pfile, &angle_brackets, NULL);
1428   if (!fname)
1429     return;
1430
1431   ordering = _cpp_compare_file_date (pfile, fname, angle_brackets);
1432   if (ordering < 0)
1433     cpp_error (pfile, CPP_DL_WARNING, "cannot find source file %s", fname);
1434   else if (ordering > 0)
1435     {
1436       cpp_error (pfile, CPP_DL_WARNING,
1437                  "current file is older than %s", fname);
1438       if (cpp_get_token (pfile)->type != CPP_EOF)
1439         {
1440           _cpp_backup_tokens (pfile, 1);
1441           do_diagnostic (pfile, CPP_DL_WARNING, 0);
1442         }
1443     }
1444
1445   free ((void *) fname);
1446 }
1447
1448 /* Get a token but skip padding.  */
1449 static const cpp_token *
1450 get_token_no_padding (cpp_reader *pfile)
1451 {
1452   for (;;)
1453     {
1454       const cpp_token *result = cpp_get_token (pfile);
1455       if (result->type != CPP_PADDING)
1456         return result;
1457     }
1458 }
1459
1460 /* Check syntax is "(string-literal)".  Returns the string on success,
1461    or NULL on failure.  */
1462 static const cpp_token *
1463 get__Pragma_string (cpp_reader *pfile)
1464 {
1465   const cpp_token *string;
1466
1467   if (get_token_no_padding (pfile)->type != CPP_OPEN_PAREN)
1468     return NULL;
1469
1470   string = get_token_no_padding (pfile);
1471   if (string->type != CPP_STRING && string->type != CPP_WSTRING)
1472     return NULL;
1473
1474   if (get_token_no_padding (pfile)->type != CPP_CLOSE_PAREN)
1475     return NULL;
1476
1477   return string;
1478 }
1479
1480 /* Destringize IN into a temporary buffer, by removing the first \ of
1481    \" and \\ sequences, and process the result as a #pragma directive.  */
1482 static void
1483 destringize_and_run (cpp_reader *pfile, const cpp_string *in)
1484 {
1485   const unsigned char *src, *limit;
1486   char *dest, *result;
1487   cpp_context *saved_context;
1488   cpp_token *saved_cur_token;
1489   tokenrun *saved_cur_run;
1490   cpp_token *toks;
1491   int count;
1492
1493   dest = result = (char *) alloca (in->len - 1);
1494   src = in->text + 1 + (in->text[0] == 'L');
1495   limit = in->text + in->len - 1;
1496   while (src < limit)
1497     {
1498       /* We know there is a character following the backslash.  */
1499       if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1500         src++;
1501       *dest++ = *src++;
1502     }
1503   *dest = '\n';
1504
1505   /* Ugh; an awful kludge.  We are really not set up to be lexing
1506      tokens when in the middle of a macro expansion.  Use a new
1507      context to force cpp_get_token to lex, and so skip_rest_of_line
1508      doesn't go beyond the end of the text.  Also, remember the
1509      current lexing position so we can return to it later.
1510
1511      Something like line-at-a-time lexing should remove the need for
1512      this.  */
1513   saved_context = pfile->context;
1514   saved_cur_token = pfile->cur_token;
1515   saved_cur_run = pfile->cur_run;
1516
1517   pfile->context = XNEW (cpp_context);
1518   pfile->context->macro = 0;
1519   pfile->context->prev = 0;
1520   pfile->context->next = 0;
1521
1522   /* Inline run_directive, since we need to delay the _cpp_pop_buffer
1523      until we've read all of the tokens that we want.  */
1524   cpp_push_buffer (pfile, (const uchar *) result, dest - result,
1525                    /* from_stage3 */ true);
1526   /* ??? Antique Disgusting Hack.  What does this do?  */
1527   if (pfile->buffer->prev)
1528     pfile->buffer->file = pfile->buffer->prev->file;
1529
1530   start_directive (pfile);
1531   _cpp_clean_line (pfile);
1532   do_pragma (pfile);
1533   end_directive (pfile, 1);
1534
1535   /* We always insert at least one token, the directive result.  It'll
1536      either be a CPP_PADDING or a CPP_PRAGMA.  In the later case, we 
1537      need to insert *all* of the tokens, including the CPP_PRAGMA_EOL.  */
1538
1539   /* If we're not handling the pragma internally, read all of the tokens from
1540      the string buffer now, while the string buffer is still installed.  */
1541   /* ??? Note that the token buffer allocated here is leaked.  It's not clear
1542      to me what the true lifespan of the tokens are.  It would appear that
1543      the lifespan is the entire parse of the main input stream, in which case
1544      this may not be wrong.  */
1545   if (pfile->directive_result.type == CPP_PRAGMA)
1546     {
1547       int maxcount;
1548
1549       count = 1;
1550       maxcount = 50;
1551       toks = XNEWVEC (cpp_token, maxcount);
1552       toks[0] = pfile->directive_result;
1553
1554       do
1555         {
1556           if (count == maxcount)
1557             {
1558               maxcount = maxcount * 3 / 2;
1559               toks = XRESIZEVEC (cpp_token, toks, maxcount);
1560             }
1561           toks[count] = *cpp_get_token (pfile);
1562           /* Macros have been already expanded by cpp_get_token
1563              if the pragma allowed expansion.  */
1564           toks[count++].flags |= NO_EXPAND;
1565         }
1566       while (toks[count-1].type != CPP_PRAGMA_EOL);
1567     }
1568   else
1569     {
1570       count = 1;
1571       toks = XNEW (cpp_token);
1572       toks[0] = pfile->directive_result;
1573
1574       /* If we handled the entire pragma internally, make sure we get the
1575          line number correct for the next token.  */
1576       if (pfile->cb.line_change)
1577         pfile->cb.line_change (pfile, pfile->cur_token, false);
1578     }
1579
1580   /* Finish inlining run_directive.  */
1581   pfile->buffer->file = NULL;
1582   _cpp_pop_buffer (pfile);
1583
1584   /* Reset the old macro state before ...  */
1585   XDELETE (pfile->context);
1586   pfile->context = saved_context;
1587   pfile->cur_token = saved_cur_token;
1588   pfile->cur_run = saved_cur_run;
1589
1590   /* ... inserting the new tokens we collected.  */
1591   _cpp_push_token_context (pfile, NULL, toks, count);
1592 }
1593
1594 /* Handle the _Pragma operator.  */
1595 void
1596 _cpp_do__Pragma (cpp_reader *pfile)
1597 {
1598   const cpp_token *string = get__Pragma_string (pfile);
1599   pfile->directive_result.type = CPP_PADDING;
1600
1601   if (string)
1602     destringize_and_run (pfile, &string->val.str);
1603   else
1604     cpp_error (pfile, CPP_DL_ERROR,
1605                "_Pragma takes a parenthesized string literal");
1606 }
1607
1608 /* Handle #ifdef.  */
1609 static void
1610 do_ifdef (cpp_reader *pfile)
1611 {
1612   int skip = 1;
1613
1614   if (! pfile->state.skipping)
1615     {
1616       const cpp_hashnode *node = lex_macro_node (pfile, false);
1617
1618       if (node)
1619         {
1620           skip = node->type != NT_MACRO;
1621           _cpp_mark_macro_used (node);
1622           check_eol (pfile);
1623         }
1624     }
1625
1626   push_conditional (pfile, skip, T_IFDEF, 0);
1627 }
1628
1629 /* Handle #ifndef.  */
1630 static void
1631 do_ifndef (cpp_reader *pfile)
1632 {
1633   int skip = 1;
1634   const cpp_hashnode *node = 0;
1635
1636   if (! pfile->state.skipping)
1637     {
1638       node = lex_macro_node (pfile, false);
1639
1640       if (node)
1641         {
1642           skip = node->type == NT_MACRO;
1643           _cpp_mark_macro_used (node);
1644           check_eol (pfile);
1645         }
1646     }
1647
1648   push_conditional (pfile, skip, T_IFNDEF, node);
1649 }
1650
1651 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1652    pfile->mi_ind_cmacro so we can handle multiple-include
1653    optimizations.  If macro expansion occurs in the expression, we
1654    cannot treat it as a controlling conditional, since the expansion
1655    could change in the future.  That is handled by cpp_get_token.  */
1656 static void
1657 do_if (cpp_reader *pfile)
1658 {
1659   int skip = 1;
1660
1661   if (! pfile->state.skipping)
1662     skip = _cpp_parse_expr (pfile) == false;
1663
1664   push_conditional (pfile, skip, T_IF, pfile->mi_ind_cmacro);
1665 }
1666
1667 /* Flip skipping state if appropriate and continue without changing
1668    if_stack; this is so that the error message for missing #endif's
1669    etc. will point to the original #if.  */
1670 static void
1671 do_else (cpp_reader *pfile)
1672 {
1673   cpp_buffer *buffer = pfile->buffer;
1674   struct if_stack *ifs = buffer->if_stack;
1675
1676   if (ifs == NULL)
1677     cpp_error (pfile, CPP_DL_ERROR, "#else without #if");
1678   else
1679     {
1680       if (ifs->type == T_ELSE)
1681         {
1682           cpp_error (pfile, CPP_DL_ERROR, "#else after #else");
1683           cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
1684                                "the conditional began here");
1685         }
1686       ifs->type = T_ELSE;
1687
1688       /* Skip any future (erroneous) #elses or #elifs.  */
1689       pfile->state.skipping = ifs->skip_elses;
1690       ifs->skip_elses = true;
1691
1692       /* Invalidate any controlling macro.  */
1693       ifs->mi_cmacro = 0;
1694
1695       /* Only check EOL if was not originally skipping.  */
1696       if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
1697         check_eol (pfile);
1698     }
1699 }
1700
1701 /* Handle a #elif directive by not changing if_stack either.  See the
1702    comment above do_else.  */
1703 static void
1704 do_elif (cpp_reader *pfile)
1705 {
1706   cpp_buffer *buffer = pfile->buffer;
1707   struct if_stack *ifs = buffer->if_stack;
1708
1709   if (ifs == NULL)
1710     cpp_error (pfile, CPP_DL_ERROR, "#elif without #if");
1711   else
1712     {
1713       if (ifs->type == T_ELSE)
1714         {
1715           cpp_error (pfile, CPP_DL_ERROR, "#elif after #else");
1716           cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
1717                                "the conditional began here");
1718         }
1719       ifs->type = T_ELIF;
1720
1721       /* Only evaluate this if we aren't skipping elses.  During
1722          evaluation, set skipping to false to get lexer warnings.  */
1723       if (ifs->skip_elses)
1724         pfile->state.skipping = 1;
1725       else
1726         {
1727           pfile->state.skipping = 0;
1728           pfile->state.skipping = ! _cpp_parse_expr (pfile);
1729           ifs->skip_elses = ! pfile->state.skipping;
1730         }
1731
1732       /* Invalidate any controlling macro.  */
1733       ifs->mi_cmacro = 0;
1734     }
1735 }
1736
1737 /* #endif pops the if stack and resets pfile->state.skipping.  */
1738 static void
1739 do_endif (cpp_reader *pfile)
1740 {
1741   cpp_buffer *buffer = pfile->buffer;
1742   struct if_stack *ifs = buffer->if_stack;
1743
1744   if (ifs == NULL)
1745     cpp_error (pfile, CPP_DL_ERROR, "#endif without #if");
1746   else
1747     {
1748       /* Only check EOL if was not originally skipping.  */
1749       if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
1750         check_eol (pfile);
1751
1752       /* If potential control macro, we go back outside again.  */
1753       if (ifs->next == 0 && ifs->mi_cmacro)
1754         {
1755           pfile->mi_valid = true;
1756           pfile->mi_cmacro = ifs->mi_cmacro;
1757         }
1758
1759       buffer->if_stack = ifs->next;
1760       pfile->state.skipping = ifs->was_skipping;
1761       obstack_free (&pfile->buffer_ob, ifs);
1762     }
1763 }
1764
1765 /* Push an if_stack entry for a preprocessor conditional, and set
1766    pfile->state.skipping to SKIP.  If TYPE indicates the conditional
1767    is #if or #ifndef, CMACRO is a potentially controlling macro, and
1768    we need to check here that we are at the top of the file.  */
1769 static void
1770 push_conditional (cpp_reader *pfile, int skip, int type,
1771                   const cpp_hashnode *cmacro)
1772 {
1773   struct if_stack *ifs;
1774   cpp_buffer *buffer = pfile->buffer;
1775
1776   ifs = XOBNEW (&pfile->buffer_ob, struct if_stack);
1777   ifs->line = pfile->directive_line;
1778   ifs->next = buffer->if_stack;
1779   ifs->skip_elses = pfile->state.skipping || !skip;
1780   ifs->was_skipping = pfile->state.skipping;
1781   ifs->type = type;
1782   /* This condition is effectively a test for top-of-file.  */
1783   if (pfile->mi_valid && pfile->mi_cmacro == 0)
1784     ifs->mi_cmacro = cmacro;
1785   else
1786     ifs->mi_cmacro = 0;
1787
1788   pfile->state.skipping = skip;
1789   buffer->if_stack = ifs;
1790 }
1791
1792 /* Read the tokens of the answer into the macro pool, in a directive
1793    of type TYPE.  Only commit the memory if we intend it as permanent
1794    storage, i.e. the #assert case.  Returns 0 on success, and sets
1795    ANSWERP to point to the answer.  */
1796 static int
1797 parse_answer (cpp_reader *pfile, struct answer **answerp, int type)
1798 {
1799   const cpp_token *paren;
1800   struct answer *answer;
1801   unsigned int acount;
1802
1803   /* In a conditional, it is legal to not have an open paren.  We
1804      should save the following token in this case.  */
1805   paren = cpp_get_token (pfile);
1806
1807   /* If not a paren, see if we're OK.  */
1808   if (paren->type != CPP_OPEN_PAREN)
1809     {
1810       /* In a conditional no answer is a test for any answer.  It
1811          could be followed by any token.  */
1812       if (type == T_IF)
1813         {
1814           _cpp_backup_tokens (pfile, 1);
1815           return 0;
1816         }
1817
1818       /* #unassert with no answer is valid - it removes all answers.  */
1819       if (type == T_UNASSERT && paren->type == CPP_EOF)
1820         return 0;
1821
1822       cpp_error (pfile, CPP_DL_ERROR, "missing '(' after predicate");
1823       return 1;
1824     }
1825
1826   for (acount = 0;; acount++)
1827     {
1828       size_t room_needed;
1829       const cpp_token *token = cpp_get_token (pfile);
1830       cpp_token *dest;
1831
1832       if (token->type == CPP_CLOSE_PAREN)
1833         break;
1834
1835       if (token->type == CPP_EOF)
1836         {
1837           cpp_error (pfile, CPP_DL_ERROR, "missing ')' to complete answer");
1838           return 1;
1839         }
1840
1841       /* struct answer includes the space for one token.  */
1842       room_needed = (sizeof (struct answer) + acount * sizeof (cpp_token));
1843
1844       if (BUFF_ROOM (pfile->a_buff) < room_needed)
1845         _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (struct answer));
1846
1847       dest = &((struct answer *) BUFF_FRONT (pfile->a_buff))->first[acount];
1848       *dest = *token;
1849
1850       /* Drop whitespace at start, for answer equivalence purposes.  */
1851       if (acount == 0)
1852         dest->flags &= ~PREV_WHITE;
1853     }
1854
1855   if (acount == 0)
1856     {
1857       cpp_error (pfile, CPP_DL_ERROR, "predicate's answer is empty");
1858       return 1;
1859     }
1860
1861   answer = (struct answer *) BUFF_FRONT (pfile->a_buff);
1862   answer->count = acount;
1863   answer->next = NULL;
1864   *answerp = answer;
1865
1866   return 0;
1867 }
1868
1869 /* Parses an assertion directive of type TYPE, returning a pointer to
1870    the hash node of the predicate, or 0 on error.  If an answer was
1871    supplied, it is placed in ANSWERP, otherwise it is set to 0.  */
1872 static cpp_hashnode *
1873 parse_assertion (cpp_reader *pfile, struct answer **answerp, int type)
1874 {
1875   cpp_hashnode *result = 0;
1876   const cpp_token *predicate;
1877
1878   /* We don't expand predicates or answers.  */
1879   pfile->state.prevent_expansion++;
1880
1881   *answerp = 0;
1882   predicate = cpp_get_token (pfile);
1883   if (predicate->type == CPP_EOF)
1884     cpp_error (pfile, CPP_DL_ERROR, "assertion without predicate");
1885   else if (predicate->type != CPP_NAME)
1886     cpp_error (pfile, CPP_DL_ERROR, "predicate must be an identifier");
1887   else if (parse_answer (pfile, answerp, type) == 0)
1888     {
1889       unsigned int len = NODE_LEN (predicate->val.node);
1890       unsigned char *sym = (unsigned char *) alloca (len + 1);
1891
1892       /* Prefix '#' to get it out of macro namespace.  */
1893       sym[0] = '#';
1894       memcpy (sym + 1, NODE_NAME (predicate->val.node), len);
1895       result = cpp_lookup (pfile, sym, len + 1);
1896     }
1897
1898   pfile->state.prevent_expansion--;
1899   return result;
1900 }
1901
1902 /* Returns a pointer to the pointer to CANDIDATE in the answer chain,
1903    or a pointer to NULL if the answer is not in the chain.  */
1904 static struct answer **
1905 find_answer (cpp_hashnode *node, const struct answer *candidate)
1906 {
1907   unsigned int i;
1908   struct answer **result;
1909
1910   for (result = &node->value.answers; *result; result = &(*result)->next)
1911     {
1912       struct answer *answer = *result;
1913
1914       if (answer->count == candidate->count)
1915         {
1916           for (i = 0; i < answer->count; i++)
1917             if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
1918               break;
1919
1920           if (i == answer->count)
1921             break;
1922         }
1923     }
1924
1925   return result;
1926 }
1927
1928 /* Test an assertion within a preprocessor conditional.  Returns
1929    nonzero on failure, zero on success.  On success, the result of
1930    the test is written into VALUE, otherwise the value 0.  */
1931 int
1932 _cpp_test_assertion (cpp_reader *pfile, unsigned int *value)
1933 {
1934   struct answer *answer;
1935   cpp_hashnode *node;
1936
1937   node = parse_assertion (pfile, &answer, T_IF);
1938
1939   /* For recovery, an erroneous assertion expression is handled as a
1940      failing assertion.  */
1941   *value = 0;
1942
1943   if (node)
1944     *value = (node->type == NT_ASSERTION &&
1945               (answer == 0 || *find_answer (node, answer) != 0));
1946   else if (pfile->cur_token[-1].type == CPP_EOF)
1947     _cpp_backup_tokens (pfile, 1);
1948
1949   /* We don't commit the memory for the answer - it's temporary only.  */
1950   return node == 0;
1951 }
1952
1953 /* Handle #assert.  */
1954 static void
1955 do_assert (cpp_reader *pfile)
1956 {
1957   struct answer *new_answer;
1958   cpp_hashnode *node;
1959
1960   node = parse_assertion (pfile, &new_answer, T_ASSERT);
1961   if (node)
1962     {
1963       size_t answer_size;
1964
1965       /* Place the new answer in the answer list.  First check there
1966          is not a duplicate.  */
1967       new_answer->next = 0;
1968       if (node->type == NT_ASSERTION)
1969         {
1970           if (*find_answer (node, new_answer))
1971             {
1972               cpp_error (pfile, CPP_DL_WARNING, "\"%s\" re-asserted",
1973                          NODE_NAME (node) + 1);
1974               return;
1975             }
1976           new_answer->next = node->value.answers;
1977         }
1978
1979       answer_size = sizeof (struct answer) + ((new_answer->count - 1)
1980                                               * sizeof (cpp_token));
1981       /* Commit or allocate storage for the object.  */
1982       if (pfile->hash_table->alloc_subobject)
1983         {
1984           struct answer *temp_answer = new_answer;
1985           new_answer = (struct answer *) pfile->hash_table->alloc_subobject
1986             (answer_size);
1987           memcpy (new_answer, temp_answer, answer_size);
1988         }
1989       else
1990         BUFF_FRONT (pfile->a_buff) += answer_size;
1991
1992       node->type = NT_ASSERTION;
1993       node->value.answers = new_answer;
1994       check_eol (pfile);
1995     }
1996 }
1997
1998 /* Handle #unassert.  */
1999 static void
2000 do_unassert (cpp_reader *pfile)
2001 {
2002   cpp_hashnode *node;
2003   struct answer *answer;
2004
2005   node = parse_assertion (pfile, &answer, T_UNASSERT);
2006   /* It isn't an error to #unassert something that isn't asserted.  */
2007   if (node && node->type == NT_ASSERTION)
2008     {
2009       if (answer)
2010         {
2011           struct answer **p = find_answer (node, answer), *temp;
2012
2013           /* Remove the answer from the list.  */
2014           temp = *p;
2015           if (temp)
2016             *p = temp->next;
2017
2018           /* Did we free the last answer?  */
2019           if (node->value.answers == 0)
2020             node->type = NT_VOID;
2021
2022           check_eol (pfile);
2023         }
2024       else
2025         _cpp_free_definition (node);
2026     }
2027
2028   /* We don't commit the memory for the answer - it's temporary only.  */
2029 }
2030
2031 /* These are for -D, -U, -A.  */
2032
2033 /* Process the string STR as if it appeared as the body of a #define.
2034    If STR is just an identifier, define it with value 1.
2035    If STR has anything after the identifier, then it should
2036    be identifier=definition.  */
2037 void
2038 cpp_define (cpp_reader *pfile, const char *str)
2039 {
2040   char *buf, *p;
2041   size_t count;
2042
2043   /* Copy the entire option so we can modify it.
2044      Change the first "=" in the string to a space.  If there is none,
2045      tack " 1" on the end.  */
2046
2047   count = strlen (str);
2048   buf = (char *) alloca (count + 3);
2049   memcpy (buf, str, count);
2050
2051   p = strchr (str, '=');
2052   if (p)
2053     buf[p - str] = ' ';
2054   else
2055     {
2056       buf[count++] = ' ';
2057       buf[count++] = '1';
2058     }
2059   buf[count] = '\n';
2060
2061   run_directive (pfile, T_DEFINE, buf, count);
2062 }
2063
2064 /* Slight variant of the above for use by initialize_builtins.  */
2065 void
2066 _cpp_define_builtin (cpp_reader *pfile, const char *str)
2067 {
2068   size_t len = strlen (str);
2069   char *buf = (char *) alloca (len + 1);
2070   memcpy (buf, str, len);
2071   buf[len] = '\n';
2072   run_directive (pfile, T_DEFINE, buf, len);
2073 }
2074
2075 /* Process MACRO as if it appeared as the body of an #undef.  */
2076 void
2077 cpp_undef (cpp_reader *pfile, const char *macro)
2078 {
2079   size_t len = strlen (macro);
2080   char *buf = (char *) alloca (len + 1);
2081   memcpy (buf, macro, len);
2082   buf[len] = '\n';
2083   run_directive (pfile, T_UNDEF, buf, len);
2084 }
2085
2086 /* Like lex_macro_node, but read the input from STR.  */
2087 static cpp_hashnode *
2088 lex_macro_node_from_str (cpp_reader *pfile, const char *str)
2089 {
2090   size_t len = strlen (str);
2091   uchar *buf = (uchar *) alloca (len + 1);
2092   cpp_hashnode *node;
2093
2094   memcpy (buf, str, len);
2095   buf[len] = '\n';
2096   cpp_push_buffer (pfile, buf, len, true);
2097   node = lex_macro_node (pfile, true);
2098   _cpp_pop_buffer (pfile);
2099
2100   return node;
2101 }
2102
2103 /* If STR is a defined macro, return its definition node, else return NULL.  */
2104 cpp_macro *
2105 cpp_push_definition (cpp_reader *pfile, const char *str)
2106 {
2107   cpp_hashnode *node = lex_macro_node_from_str (pfile, str);
2108   if (node && node->type == NT_MACRO)
2109     return node->value.macro;
2110   else
2111     return NULL;
2112 }
2113
2114 /* Replace a previous definition DFN of the macro STR.  If DFN is NULL,
2115    then the macro should be undefined.  */
2116 void
2117 cpp_pop_definition (cpp_reader *pfile, const char *str, cpp_macro *dfn)
2118 {
2119   cpp_hashnode *node = lex_macro_node_from_str (pfile, str);
2120   if (node == NULL)
2121     return;
2122
2123   if (node->type == NT_MACRO)
2124     {
2125       if (pfile->cb.undef)
2126         pfile->cb.undef (pfile, pfile->directive_line, node);
2127       if (CPP_OPTION (pfile, warn_unused_macros))
2128         _cpp_warn_if_unused_macro (pfile, node, NULL);
2129     }
2130   if (node->type != NT_VOID)
2131     _cpp_free_definition (node);
2132
2133   if (dfn)
2134     {
2135       node->type = NT_MACRO;
2136       node->value.macro = dfn;
2137       if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_")))
2138         node->flags |= NODE_WARN;
2139
2140       if (pfile->cb.define)
2141         pfile->cb.define (pfile, pfile->directive_line, node);
2142     }
2143 }
2144
2145 /* Process the string STR as if it appeared as the body of a #assert.  */
2146 void
2147 cpp_assert (cpp_reader *pfile, const char *str)
2148 {
2149   handle_assertion (pfile, str, T_ASSERT);
2150 }
2151
2152 /* Process STR as if it appeared as the body of an #unassert.  */
2153 void
2154 cpp_unassert (cpp_reader *pfile, const char *str)
2155 {
2156   handle_assertion (pfile, str, T_UNASSERT);
2157 }
2158
2159 /* Common code for cpp_assert (-A) and cpp_unassert (-A-).  */
2160 static void
2161 handle_assertion (cpp_reader *pfile, const char *str, int type)
2162 {
2163   size_t count = strlen (str);
2164   const char *p = strchr (str, '=');
2165
2166   /* Copy the entire option so we can modify it.  Change the first
2167      "=" in the string to a '(', and tack a ')' on the end.  */
2168   char *buf = (char *) alloca (count + 2);
2169
2170   memcpy (buf, str, count);
2171   if (p)
2172     {
2173       buf[p - str] = '(';
2174       buf[count++] = ')';
2175     }
2176   buf[count] = '\n';
2177   str = buf;
2178
2179   run_directive (pfile, type, str, count);
2180 }
2181
2182 /* The number of errors for a given reader.  */
2183 unsigned int
2184 cpp_errors (cpp_reader *pfile)
2185 {
2186   return pfile->errors;
2187 }
2188
2189 /* The options structure.  */
2190 cpp_options *
2191 cpp_get_options (cpp_reader *pfile)
2192 {
2193   return &pfile->opts;
2194 }
2195
2196 /* The callbacks structure.  */
2197 cpp_callbacks *
2198 cpp_get_callbacks (cpp_reader *pfile)
2199 {
2200   return &pfile->cb;
2201 }
2202
2203 /* Copy the given callbacks structure to our own.  */
2204 void
2205 cpp_set_callbacks (cpp_reader *pfile, cpp_callbacks *cb)
2206 {
2207   pfile->cb = *cb;
2208 }
2209
2210 /* The dependencies structure.  (Creates one if it hasn't already been.)  */
2211 struct deps *
2212 cpp_get_deps (cpp_reader *pfile)
2213 {
2214   if (!pfile->deps)
2215     pfile->deps = deps_init ();
2216   return pfile->deps;
2217 }
2218
2219 /* Push a new buffer on the buffer stack.  Returns the new buffer; it
2220    doesn't fail.  It does not generate a file change call back; that
2221    is the responsibility of the caller.  */
2222 cpp_buffer *
2223 cpp_push_buffer (cpp_reader *pfile, const uchar *buffer, size_t len,
2224                  int from_stage3)
2225 {
2226   cpp_buffer *new_buffer = XOBNEW (&pfile->buffer_ob, cpp_buffer);
2227
2228   /* Clears, amongst other things, if_stack and mi_cmacro.  */
2229   memset (new_buffer, 0, sizeof (cpp_buffer));
2230
2231   new_buffer->next_line = new_buffer->buf = buffer;
2232   new_buffer->rlimit = buffer + len;
2233   new_buffer->from_stage3 = from_stage3;
2234   new_buffer->prev = pfile->buffer;
2235   new_buffer->need_line = true;
2236
2237   pfile->buffer = new_buffer;
2238
2239   return new_buffer;
2240 }
2241
2242 /* Pops a single buffer, with a file change call-back if appropriate.
2243    Then pushes the next -include file, if any remain.  */
2244 void
2245 _cpp_pop_buffer (cpp_reader *pfile)
2246 {
2247   cpp_buffer *buffer = pfile->buffer;
2248   struct _cpp_file *inc = buffer->file;
2249   struct if_stack *ifs;
2250
2251   /* Walk back up the conditional stack till we reach its level at
2252      entry to this file, issuing error messages.  */
2253   for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
2254     cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
2255                          "unterminated #%s", dtable[ifs->type].name);
2256
2257   /* In case of a missing #endif.  */
2258   pfile->state.skipping = 0;
2259
2260   /* _cpp_do_file_change expects pfile->buffer to be the new one.  */
2261   pfile->buffer = buffer->prev;
2262
2263   free (buffer->notes);
2264
2265   /* Free the buffer object now; we may want to push a new buffer
2266      in _cpp_push_next_include_file.  */
2267   obstack_free (&pfile->buffer_ob, buffer);
2268
2269   if (inc)
2270     {
2271       _cpp_pop_file_buffer (pfile, inc);
2272
2273       _cpp_do_file_change (pfile, LC_LEAVE, 0, 0, 0);
2274     }
2275 }
2276
2277 /* Enter all recognized directives in the hash table.  */
2278 void
2279 _cpp_init_directives (cpp_reader *pfile)
2280 {
2281   unsigned int i;
2282   cpp_hashnode *node;
2283
2284   for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
2285     {
2286       node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
2287       node->is_directive = 1;
2288       node->directive_index = i;
2289     }
2290 }