OSDN Git Service

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