OSDN Git Service

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