OSDN Git Service

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