OSDN Git Service

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