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