|
0
|
1 /* CPP Library.
|
|
|
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
|
|
|
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2009
|
|
|
4 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 "localedir.h"
|
|
|
29
|
|
|
30 static void init_library (void);
|
|
|
31 static void mark_named_operators (cpp_reader *);
|
|
|
32 static void read_original_filename (cpp_reader *);
|
|
|
33 static void read_original_directory (cpp_reader *);
|
|
|
34 static void post_options (cpp_reader *);
|
|
|
35
|
|
|
36 /* If we have designated initializers (GCC >2.7) these tables can be
|
|
|
37 initialized, constant data. Otherwise, they have to be filled in at
|
|
|
38 runtime. */
|
|
|
39 #if HAVE_DESIGNATED_INITIALIZERS
|
|
|
40
|
|
|
41 #define init_trigraph_map() /* Nothing. */
|
|
|
42 #define TRIGRAPH_MAP \
|
|
|
43 __extension__ const uchar _cpp_trigraph_map[UCHAR_MAX + 1] = {
|
|
|
44
|
|
|
45 #define END };
|
|
|
46 #define s(p, v) [p] = v,
|
|
|
47
|
|
|
48 #else
|
|
|
49
|
|
|
50 #define TRIGRAPH_MAP uchar _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \
|
|
|
51 static void init_trigraph_map (void) { \
|
|
|
52 unsigned char *x = _cpp_trigraph_map;
|
|
|
53
|
|
|
54 #define END }
|
|
|
55 #define s(p, v) x[p] = v;
|
|
|
56
|
|
|
57 #endif
|
|
|
58
|
|
|
59 TRIGRAPH_MAP
|
|
|
60 s('=', '#') s(')', ']') s('!', '|')
|
|
|
61 s('(', '[') s('\'', '^') s('>', '}')
|
|
|
62 s('/', '\\') s('<', '{') s('-', '~')
|
|
|
63 END
|
|
|
64
|
|
|
65 #undef s
|
|
|
66 #undef END
|
|
|
67 #undef TRIGRAPH_MAP
|
|
|
68
|
|
|
69 /* A set of booleans indicating what CPP features each source language
|
|
|
70 requires. */
|
|
|
71 struct lang_flags
|
|
|
72 {
|
|
|
73 char c99;
|
|
|
74 char cplusplus;
|
|
|
75 char extended_numbers;
|
|
|
76 char extended_identifiers;
|
|
|
77 char std;
|
|
|
78 char cplusplus_comments;
|
|
|
79 char digraphs;
|
|
|
80 char uliterals;
|
|
|
81 };
|
|
|
82
|
|
|
83 static const struct lang_flags lang_defaults[] =
|
|
|
84 { /* c99 c++ xnum xid std // digr ulit */
|
|
|
85 /* GNUC89 */ { 0, 0, 1, 0, 0, 1, 1, 0 },
|
|
|
86 /* GNUC99 */ { 1, 0, 1, 0, 0, 1, 1, 1 },
|
|
|
87 /* STDC89 */ { 0, 0, 0, 0, 1, 0, 0, 0 },
|
|
|
88 /* STDC94 */ { 0, 0, 0, 0, 1, 0, 1, 0 },
|
|
|
89 /* STDC99 */ { 1, 0, 1, 0, 1, 1, 1, 0 },
|
|
|
90 /* GNUCXX */ { 0, 1, 1, 0, 0, 1, 1, 0 },
|
|
|
91 /* CXX98 */ { 0, 1, 1, 0, 1, 1, 1, 0 },
|
|
|
92 /* GNUCXX0X */ { 1, 1, 1, 0, 0, 1, 1, 1 },
|
|
|
93 /* CXX0X */ { 1, 1, 1, 0, 1, 1, 1, 1 },
|
|
|
94 /* ASM */ { 0, 0, 1, 0, 0, 1, 0, 0 }
|
|
|
95 /* xid should be 1 for GNUC99, STDC99, GNUCXX, CXX98, GNUCXX0X, and
|
|
|
96 CXX0X when no longer experimental (when all uses of identifiers
|
|
|
97 in the compiler have been audited for correct handling of
|
|
|
98 extended identifiers). */
|
|
|
99 };
|
|
|
100
|
|
|
101 /* Sets internal flags correctly for a given language. */
|
|
|
102 void
|
|
|
103 cpp_set_lang (cpp_reader *pfile, enum c_lang lang)
|
|
|
104 {
|
|
|
105 const struct lang_flags *l = &lang_defaults[(int) lang];
|
|
|
106
|
|
|
107 CPP_OPTION (pfile, lang) = lang;
|
|
|
108
|
|
|
109 CPP_OPTION (pfile, c99) = l->c99;
|
|
|
110 CPP_OPTION (pfile, cplusplus) = l->cplusplus;
|
|
|
111 CPP_OPTION (pfile, extended_numbers) = l->extended_numbers;
|
|
|
112 CPP_OPTION (pfile, extended_identifiers) = l->extended_identifiers;
|
|
|
113 CPP_OPTION (pfile, std) = l->std;
|
|
|
114 CPP_OPTION (pfile, trigraphs) = l->std;
|
|
|
115 CPP_OPTION (pfile, cplusplus_comments) = l->cplusplus_comments;
|
|
|
116 CPP_OPTION (pfile, digraphs) = l->digraphs;
|
|
|
117 CPP_OPTION (pfile, uliterals) = l->uliterals;
|
|
|
118 }
|
|
|
119
|
|
|
120 /* Initialize library global state. */
|
|
|
121 static void
|
|
|
122 init_library (void)
|
|
|
123 {
|
|
|
124 static int initialized = 0;
|
|
|
125
|
|
|
126 if (! initialized)
|
|
|
127 {
|
|
|
128 initialized = 1;
|
|
|
129
|
|
|
130 /* Set up the trigraph map. This doesn't need to do anything if
|
|
|
131 we were compiled with a compiler that supports C99 designated
|
|
|
132 initializers. */
|
|
|
133 init_trigraph_map ();
|
|
|
134
|
|
|
135 #ifdef ENABLE_NLS
|
|
|
136 (void) bindtextdomain (PACKAGE, LOCALEDIR);
|
|
|
137 #endif
|
|
|
138 }
|
|
|
139 }
|
|
|
140
|
|
|
141 /* Initialize a cpp_reader structure. */
|
|
|
142 cpp_reader *
|
|
|
143 cpp_create_reader (enum c_lang lang, hash_table *table,
|
|
|
144 struct line_maps *line_table)
|
|
|
145 {
|
|
|
146 cpp_reader *pfile;
|
|
|
147
|
|
|
148 /* Initialize this instance of the library if it hasn't been already. */
|
|
|
149 init_library ();
|
|
|
150
|
|
|
151 pfile = XCNEW (cpp_reader);
|
|
|
152
|
|
|
153 cpp_set_lang (pfile, lang);
|
|
|
154 CPP_OPTION (pfile, warn_multichar) = 1;
|
|
|
155 CPP_OPTION (pfile, discard_comments) = 1;
|
|
|
156 CPP_OPTION (pfile, discard_comments_in_macro_exp) = 1;
|
|
|
157 CPP_OPTION (pfile, show_column) = 1;
|
|
|
158 CPP_OPTION (pfile, tabstop) = 8;
|
|
|
159 CPP_OPTION (pfile, operator_names) = 1;
|
|
|
160 CPP_OPTION (pfile, warn_trigraphs) = 2;
|
|
|
161 CPP_OPTION (pfile, warn_endif_labels) = 1;
|
|
|
162 CPP_OPTION (pfile, warn_deprecated) = 1;
|
|
|
163 CPP_OPTION (pfile, warn_long_long) = !CPP_OPTION (pfile, c99);
|
|
|
164 CPP_OPTION (pfile, dollars_in_ident) = 1;
|
|
|
165 CPP_OPTION (pfile, warn_dollars) = 1;
|
|
|
166 CPP_OPTION (pfile, warn_variadic_macros) = 1;
|
|
|
167 CPP_OPTION (pfile, warn_builtin_macro_redefined) = 1;
|
|
|
168 CPP_OPTION (pfile, warn_normalize) = normalized_C;
|
|
|
169
|
|
|
170 /* Default CPP arithmetic to something sensible for the host for the
|
|
|
171 benefit of dumb users like fix-header. */
|
|
|
172 CPP_OPTION (pfile, precision) = CHAR_BIT * sizeof (long);
|
|
|
173 CPP_OPTION (pfile, char_precision) = CHAR_BIT;
|
|
|
174 CPP_OPTION (pfile, wchar_precision) = CHAR_BIT * sizeof (int);
|
|
|
175 CPP_OPTION (pfile, int_precision) = CHAR_BIT * sizeof (int);
|
|
|
176 CPP_OPTION (pfile, unsigned_char) = 0;
|
|
|
177 CPP_OPTION (pfile, unsigned_wchar) = 1;
|
|
|
178 CPP_OPTION (pfile, bytes_big_endian) = 1; /* does not matter */
|
|
|
179
|
|
|
180 /* Default to no charset conversion. */
|
|
|
181 CPP_OPTION (pfile, narrow_charset) = _cpp_default_encoding ();
|
|
|
182 CPP_OPTION (pfile, wide_charset) = 0;
|
|
|
183
|
|
|
184 /* Default the input character set to UTF-8. */
|
|
|
185 CPP_OPTION (pfile, input_charset) = _cpp_default_encoding ();
|
|
|
186
|
|
|
187 /* A fake empty "directory" used as the starting point for files
|
|
|
188 looked up without a search path. Name cannot be '/' because we
|
|
|
189 don't want to prepend anything at all to filenames using it. All
|
|
|
190 other entries are correct zero-initialized. */
|
|
|
191 pfile->no_search_path.name = (char *) "";
|
|
|
192
|
|
|
193 /* Initialize the line map. */
|
|
|
194 pfile->line_table = line_table;
|
|
|
195
|
|
|
196 /* Initialize lexer state. */
|
|
|
197 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
|
|
|
198
|
|
|
199 /* Set up static tokens. */
|
|
|
200 pfile->avoid_paste.type = CPP_PADDING;
|
|
|
201 pfile->avoid_paste.val.source = NULL;
|
|
|
202 pfile->eof.type = CPP_EOF;
|
|
|
203 pfile->eof.flags = 0;
|
|
|
204
|
|
|
205 /* Create a token buffer for the lexer. */
|
|
|
206 _cpp_init_tokenrun (&pfile->base_run, 250);
|
|
|
207 pfile->cur_run = &pfile->base_run;
|
|
|
208 pfile->cur_token = pfile->base_run.base;
|
|
|
209
|
|
|
210 /* Initialize the base context. */
|
|
|
211 pfile->context = &pfile->base_context;
|
|
|
212 pfile->base_context.macro = 0;
|
|
|
213 pfile->base_context.prev = pfile->base_context.next = 0;
|
|
|
214
|
|
|
215 /* Aligned and unaligned storage. */
|
|
|
216 pfile->a_buff = _cpp_get_buff (pfile, 0);
|
|
|
217 pfile->u_buff = _cpp_get_buff (pfile, 0);
|
|
|
218
|
|
|
219 /* The expression parser stack. */
|
|
|
220 _cpp_expand_op_stack (pfile);
|
|
|
221
|
|
|
222 /* Initialize the buffer obstack. */
|
|
|
223 _obstack_begin (&pfile->buffer_ob, 0, 0,
|
|
|
224 (void *(*) (long)) xmalloc,
|
|
|
225 (void (*) (void *)) free);
|
|
|
226
|
|
|
227 _cpp_init_files (pfile);
|
|
|
228
|
|
|
229 _cpp_init_hashtable (pfile, table);
|
|
|
230
|
|
|
231 return pfile;
|
|
|
232 }
|
|
|
233
|
|
|
234 /* Set the line_table entry in PFILE. This is called after reading a
|
|
|
235 PCH file, as the old line_table will be incorrect. */
|
|
|
236 void
|
|
|
237 cpp_set_line_map (cpp_reader *pfile, struct line_maps *line_table)
|
|
|
238 {
|
|
|
239 pfile->line_table = line_table;
|
|
|
240 }
|
|
|
241
|
|
|
242 /* Free resources used by PFILE. Accessing PFILE after this function
|
|
|
243 returns leads to undefined behavior. Returns the error count. */
|
|
|
244 void
|
|
|
245 cpp_destroy (cpp_reader *pfile)
|
|
|
246 {
|
|
|
247 cpp_context *context, *contextn;
|
|
|
248 tokenrun *run, *runn;
|
|
|
249 int i;
|
|
|
250
|
|
|
251 free (pfile->op_stack);
|
|
|
252
|
|
|
253 while (CPP_BUFFER (pfile) != NULL)
|
|
|
254 _cpp_pop_buffer (pfile);
|
|
|
255
|
|
|
256 if (pfile->out.base)
|
|
|
257 free (pfile->out.base);
|
|
|
258
|
|
|
259 if (pfile->macro_buffer)
|
|
|
260 {
|
|
|
261 free (pfile->macro_buffer);
|
|
|
262 pfile->macro_buffer = NULL;
|
|
|
263 pfile->macro_buffer_len = 0;
|
|
|
264 }
|
|
|
265
|
|
|
266 if (pfile->deps)
|
|
|
267 deps_free (pfile->deps);
|
|
|
268 obstack_free (&pfile->buffer_ob, 0);
|
|
|
269
|
|
|
270 _cpp_destroy_hashtable (pfile);
|
|
|
271 _cpp_cleanup_files (pfile);
|
|
|
272 _cpp_destroy_iconv (pfile);
|
|
|
273
|
|
|
274 _cpp_free_buff (pfile->a_buff);
|
|
|
275 _cpp_free_buff (pfile->u_buff);
|
|
|
276 _cpp_free_buff (pfile->free_buffs);
|
|
|
277
|
|
|
278 for (run = &pfile->base_run; run; run = runn)
|
|
|
279 {
|
|
|
280 runn = run->next;
|
|
|
281 free (run->base);
|
|
|
282 if (run != &pfile->base_run)
|
|
|
283 free (run);
|
|
|
284 }
|
|
|
285
|
|
|
286 for (context = pfile->base_context.next; context; context = contextn)
|
|
|
287 {
|
|
|
288 contextn = context->next;
|
|
|
289 free (context);
|
|
|
290 }
|
|
|
291
|
|
|
292 if (pfile->comments.entries)
|
|
|
293 {
|
|
|
294 for (i = 0; i < pfile->comments.count; i++)
|
|
|
295 free (pfile->comments.entries[i].comment);
|
|
|
296
|
|
|
297 free (pfile->comments.entries);
|
|
|
298 }
|
|
|
299
|
|
|
300 free (pfile);
|
|
|
301 }
|
|
|
302
|
|
|
303 /* This structure defines one built-in identifier. A node will be
|
|
|
304 entered in the hash table under the name NAME, with value VALUE.
|
|
|
305
|
|
|
306 There are two tables of these. builtin_array holds all the
|
|
|
307 "builtin" macros: these are handled by builtin_macro() in
|
|
|
308 macro.c. Builtin is somewhat of a misnomer -- the property of
|
|
|
309 interest is that these macros require special code to compute their
|
|
|
310 expansions. The value is a "builtin_type" enumerator.
|
|
|
311
|
|
|
312 operator_array holds the C++ named operators. These are keywords
|
|
|
313 which act as aliases for punctuators. In C++, they cannot be
|
|
|
314 altered through #define, and #if recognizes them as operators. In
|
|
|
315 C, these are not entered into the hash table at all (but see
|
|
|
316 <iso646.h>). The value is a token-type enumerator. */
|
|
|
317 struct builtin_macro
|
|
|
318 {
|
|
|
319 const uchar *const name;
|
|
|
320 const unsigned short len;
|
|
|
321 const unsigned short value;
|
|
|
322 const bool always_warn_if_redefined;
|
|
|
323 };
|
|
|
324
|
|
|
325 #define B(n, t, f) { DSC(n), t, f }
|
|
|
326 static const struct builtin_macro builtin_array[] =
|
|
|
327 {
|
|
|
328 B("__TIMESTAMP__", BT_TIMESTAMP, false),
|
|
|
329 B("__TIME__", BT_TIME, false),
|
|
|
330 B("__DATE__", BT_DATE, false),
|
|
|
331 B("__FILE__", BT_FILE, false),
|
|
|
332 B("__BASE_FILE__", BT_BASE_FILE, false),
|
|
|
333 B("__LINE__", BT_SPECLINE, true),
|
|
|
334 B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL, true),
|
|
|
335 B("__COUNTER__", BT_COUNTER, true),
|
|
|
336 /* Keep builtins not used for -traditional-cpp at the end, and
|
|
|
337 update init_builtins() if any more are added. */
|
|
|
338 B("_Pragma", BT_PRAGMA, true),
|
|
|
339 B("__STDC__", BT_STDC, true),
|
|
|
340 };
|
|
|
341 #undef B
|
|
|
342
|
|
|
343 struct builtin_operator
|
|
|
344 {
|
|
|
345 const uchar *const name;
|
|
|
346 const unsigned short len;
|
|
|
347 const unsigned short value;
|
|
|
348 };
|
|
|
349
|
|
|
350 #define B(n, t) { DSC(n), t }
|
|
|
351 static const struct builtin_operator operator_array[] =
|
|
|
352 {
|
|
|
353 B("and", CPP_AND_AND),
|
|
|
354 B("and_eq", CPP_AND_EQ),
|
|
|
355 B("bitand", CPP_AND),
|
|
|
356 B("bitor", CPP_OR),
|
|
|
357 B("compl", CPP_COMPL),
|
|
|
358 B("not", CPP_NOT),
|
|
|
359 B("not_eq", CPP_NOT_EQ),
|
|
|
360 B("or", CPP_OR_OR),
|
|
|
361 B("or_eq", CPP_OR_EQ),
|
|
|
362 B("xor", CPP_XOR),
|
|
|
363 B("xor_eq", CPP_XOR_EQ)
|
|
|
364 };
|
|
|
365 #undef B
|
|
|
366
|
|
|
367 /* Mark the C++ named operators in the hash table. */
|
|
|
368 static void
|
|
|
369 mark_named_operators (cpp_reader *pfile)
|
|
|
370 {
|
|
|
371 const struct builtin_operator *b;
|
|
|
372
|
|
|
373 for (b = operator_array;
|
|
|
374 b < (operator_array + ARRAY_SIZE (operator_array));
|
|
|
375 b++)
|
|
|
376 {
|
|
|
377 cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
|
|
|
378 hp->flags |= NODE_OPERATOR;
|
|
|
379 hp->is_directive = 0;
|
|
|
380 hp->directive_index = b->value;
|
|
|
381 }
|
|
|
382 }
|
|
|
383
|
|
|
384 void
|
|
|
385 cpp_init_special_builtins (cpp_reader *pfile)
|
|
|
386 {
|
|
|
387 const struct builtin_macro *b;
|
|
|
388 size_t n = ARRAY_SIZE (builtin_array);
|
|
|
389
|
|
|
390 if (CPP_OPTION (pfile, traditional))
|
|
|
391 n -= 2;
|
|
|
392 else if (! CPP_OPTION (pfile, stdc_0_in_system_headers)
|
|
|
393 || CPP_OPTION (pfile, std))
|
|
|
394 n--;
|
|
|
395
|
|
|
396 for (b = builtin_array; b < builtin_array + n; b++)
|
|
|
397 {
|
|
|
398 cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
|
|
|
399 hp->type = NT_MACRO;
|
|
|
400 hp->flags |= NODE_BUILTIN;
|
|
|
401 if (b->always_warn_if_redefined
|
|
|
402 || CPP_OPTION (pfile, warn_builtin_macro_redefined))
|
|
|
403 hp->flags |= NODE_WARN;
|
|
|
404 hp->value.builtin = (enum builtin_type) b->value;
|
|
|
405 }
|
|
|
406 }
|
|
|
407
|
|
|
408 /* Read the builtins table above and enter them, and language-specific
|
|
|
409 macros, into the hash table. HOSTED is true if this is a hosted
|
|
|
410 environment. */
|
|
|
411 void
|
|
|
412 cpp_init_builtins (cpp_reader *pfile, int hosted)
|
|
|
413 {
|
|
|
414 cpp_init_special_builtins (pfile);
|
|
|
415
|
|
|
416 if (!CPP_OPTION (pfile, traditional)
|
|
|
417 && (! CPP_OPTION (pfile, stdc_0_in_system_headers)
|
|
|
418 || CPP_OPTION (pfile, std)))
|
|
|
419 _cpp_define_builtin (pfile, "__STDC__ 1");
|
|
|
420
|
|
|
421 if (CPP_OPTION (pfile, cplusplus))
|
|
|
422 _cpp_define_builtin (pfile, "__cplusplus 1");
|
|
|
423 else if (CPP_OPTION (pfile, lang) == CLK_ASM)
|
|
|
424 _cpp_define_builtin (pfile, "__ASSEMBLER__ 1");
|
|
|
425 else if (CPP_OPTION (pfile, lang) == CLK_STDC94)
|
|
|
426 _cpp_define_builtin (pfile, "__STDC_VERSION__ 199409L");
|
|
|
427 else if (CPP_OPTION (pfile, c99))
|
|
|
428 _cpp_define_builtin (pfile, "__STDC_VERSION__ 199901L");
|
|
|
429
|
|
|
430 if (hosted)
|
|
|
431 _cpp_define_builtin (pfile, "__STDC_HOSTED__ 1");
|
|
|
432 else
|
|
|
433 _cpp_define_builtin (pfile, "__STDC_HOSTED__ 0");
|
|
|
434
|
|
|
435 if (CPP_OPTION (pfile, objc))
|
|
|
436 _cpp_define_builtin (pfile, "__OBJC__ 1");
|
|
|
437 }
|
|
|
438
|
|
|
439 /* Sanity-checks are dependent on command-line options, so it is
|
|
|
440 called as a subroutine of cpp_read_main_file (). */
|
|
|
441 #if ENABLE_CHECKING
|
|
|
442 static void sanity_checks (cpp_reader *);
|
|
|
443 static void sanity_checks (cpp_reader *pfile)
|
|
|
444 {
|
|
|
445 cppchar_t test = 0;
|
|
|
446 size_t max_precision = 2 * CHAR_BIT * sizeof (cpp_num_part);
|
|
|
447
|
|
|
448 /* Sanity checks for assumptions about CPP arithmetic and target
|
|
|
449 type precisions made by cpplib. */
|
|
|
450 test--;
|
|
|
451 if (test < 1)
|
|
|
452 cpp_error (pfile, CPP_DL_ICE, "cppchar_t must be an unsigned type");
|
|
|
453
|
|
|
454 if (CPP_OPTION (pfile, precision) > max_precision)
|
|
|
455 cpp_error (pfile, CPP_DL_ICE,
|
|
|
456 "preprocessor arithmetic has maximum precision of %lu bits;"
|
|
|
457 " target requires %lu bits",
|
|
|
458 (unsigned long) max_precision,
|
|
|
459 (unsigned long) CPP_OPTION (pfile, precision));
|
|
|
460
|
|
|
461 if (CPP_OPTION (pfile, precision) < CPP_OPTION (pfile, int_precision))
|
|
|
462 cpp_error (pfile, CPP_DL_ICE,
|
|
|
463 "CPP arithmetic must be at least as precise as a target int");
|
|
|
464
|
|
|
465 if (CPP_OPTION (pfile, char_precision) < 8)
|
|
|
466 cpp_error (pfile, CPP_DL_ICE, "target char is less than 8 bits wide");
|
|
|
467
|
|
|
468 if (CPP_OPTION (pfile, wchar_precision) < CPP_OPTION (pfile, char_precision))
|
|
|
469 cpp_error (pfile, CPP_DL_ICE,
|
|
|
470 "target wchar_t is narrower than target char");
|
|
|
471
|
|
|
472 if (CPP_OPTION (pfile, int_precision) < CPP_OPTION (pfile, char_precision))
|
|
|
473 cpp_error (pfile, CPP_DL_ICE,
|
|
|
474 "target int is narrower than target char");
|
|
|
475
|
|
|
476 /* This is assumed in eval_token() and could be fixed if necessary. */
|
|
|
477 if (sizeof (cppchar_t) > sizeof (cpp_num_part))
|
|
|
478 cpp_error (pfile, CPP_DL_ICE,
|
|
|
479 "CPP half-integer narrower than CPP character");
|
|
|
480
|
|
|
481 if (CPP_OPTION (pfile, wchar_precision) > BITS_PER_CPPCHAR_T)
|
|
|
482 cpp_error (pfile, CPP_DL_ICE,
|
|
|
483 "CPP on this host cannot handle wide character constants over"
|
|
|
484 " %lu bits, but the target requires %lu bits",
|
|
|
485 (unsigned long) BITS_PER_CPPCHAR_T,
|
|
|
486 (unsigned long) CPP_OPTION (pfile, wchar_precision));
|
|
|
487 }
|
|
|
488 #else
|
|
|
489 # define sanity_checks(PFILE)
|
|
|
490 #endif
|
|
|
491
|
|
|
492 /* This is called after options have been parsed, and partially
|
|
|
493 processed. */
|
|
|
494 void
|
|
|
495 cpp_post_options (cpp_reader *pfile)
|
|
|
496 {
|
|
|
497 sanity_checks (pfile);
|
|
|
498
|
|
|
499 post_options (pfile);
|
|
|
500
|
|
|
501 /* Mark named operators before handling command line macros. */
|
|
|
502 if (CPP_OPTION (pfile, cplusplus) && CPP_OPTION (pfile, operator_names))
|
|
|
503 mark_named_operators (pfile);
|
|
|
504 }
|
|
|
505
|
|
|
506 /* Setup for processing input from the file named FNAME, or stdin if
|
|
|
507 it is the empty string. Return the original filename
|
|
|
508 on success (e.g. foo.i->foo.c), or NULL on failure. */
|
|
|
509 const char *
|
|
|
510 cpp_read_main_file (cpp_reader *pfile, const char *fname)
|
|
|
511 {
|
|
|
512 if (CPP_OPTION (pfile, deps.style) != DEPS_NONE)
|
|
|
513 {
|
|
|
514 if (!pfile->deps)
|
|
|
515 pfile->deps = deps_init ();
|
|
|
516
|
|
|
517 /* Set the default target (if there is none already). */
|
|
|
518 deps_add_default_target (pfile->deps, fname);
|
|
|
519 }
|
|
|
520
|
|
|
521 pfile->main_file
|
|
|
522 = _cpp_find_file (pfile, fname, &pfile->no_search_path, false, 0);
|
|
|
523 if (_cpp_find_failed (pfile->main_file))
|
|
|
524 return NULL;
|
|
|
525
|
|
|
526 _cpp_stack_file (pfile, pfile->main_file, false);
|
|
|
527
|
|
|
528 /* For foo.i, read the original filename foo.c now, for the benefit
|
|
|
529 of the front ends. */
|
|
|
530 if (CPP_OPTION (pfile, preprocessed))
|
|
|
531 {
|
|
|
532 read_original_filename (pfile);
|
|
|
533 fname = pfile->line_table->maps[pfile->line_table->used-1].to_file;
|
|
|
534 }
|
|
|
535 return fname;
|
|
|
536 }
|
|
|
537
|
|
|
538 /* For preprocessed files, if the first tokens are of the form # NUM.
|
|
|
539 handle the directive so we know the original file name. This will
|
|
|
540 generate file_change callbacks, which the front ends must handle
|
|
|
541 appropriately given their state of initialization. */
|
|
|
542 static void
|
|
|
543 read_original_filename (cpp_reader *pfile)
|
|
|
544 {
|
|
|
545 const cpp_token *token, *token1;
|
|
|
546
|
|
|
547 /* Lex ahead; if the first tokens are of the form # NUM, then
|
|
|
548 process the directive, otherwise back up. */
|
|
|
549 token = _cpp_lex_direct (pfile);
|
|
|
550 if (token->type == CPP_HASH)
|
|
|
551 {
|
|
|
552 pfile->state.in_directive = 1;
|
|
|
553 token1 = _cpp_lex_direct (pfile);
|
|
|
554 _cpp_backup_tokens (pfile, 1);
|
|
|
555 pfile->state.in_directive = 0;
|
|
|
556
|
|
|
557 /* If it's a #line directive, handle it. */
|
|
|
558 if (token1->type == CPP_NUMBER)
|
|
|
559 {
|
|
|
560 _cpp_handle_directive (pfile, token->flags & PREV_WHITE);
|
|
|
561 read_original_directory (pfile);
|
|
|
562 return;
|
|
|
563 }
|
|
|
564 }
|
|
|
565
|
|
|
566 /* Backup as if nothing happened. */
|
|
|
567 _cpp_backup_tokens (pfile, 1);
|
|
|
568 }
|
|
|
569
|
|
|
570 /* For preprocessed files, if the tokens following the first filename
|
|
|
571 line is of the form # <line> "/path/name//", handle the
|
|
|
572 directive so we know the original current directory. */
|
|
|
573 static void
|
|
|
574 read_original_directory (cpp_reader *pfile)
|
|
|
575 {
|
|
|
576 const cpp_token *hash, *token;
|
|
|
577
|
|
|
578 /* Lex ahead; if the first tokens are of the form # NUM, then
|
|
|
579 process the directive, otherwise back up. */
|
|
|
580 hash = _cpp_lex_direct (pfile);
|
|
|
581 if (hash->type != CPP_HASH)
|
|
|
582 {
|
|
|
583 _cpp_backup_tokens (pfile, 1);
|
|
|
584 return;
|
|
|
585 }
|
|
|
586
|
|
|
587 token = _cpp_lex_direct (pfile);
|
|
|
588
|
|
|
589 if (token->type != CPP_NUMBER)
|
|
|
590 {
|
|
|
591 _cpp_backup_tokens (pfile, 2);
|
|
|
592 return;
|
|
|
593 }
|
|
|
594
|
|
|
595 token = _cpp_lex_direct (pfile);
|
|
|
596
|
|
|
597 if (token->type != CPP_STRING
|
|
|
598 || ! (token->val.str.len >= 5
|
|
|
599 && token->val.str.text[token->val.str.len-2] == '/'
|
|
|
600 && token->val.str.text[token->val.str.len-3] == '/'))
|
|
|
601 {
|
|
|
602 _cpp_backup_tokens (pfile, 3);
|
|
|
603 return;
|
|
|
604 }
|
|
|
605
|
|
|
606 if (pfile->cb.dir_change)
|
|
|
607 {
|
|
|
608 char *debugdir = (char *) alloca (token->val.str.len - 3);
|
|
|
609
|
|
|
610 memcpy (debugdir, (const char *) token->val.str.text + 1,
|
|
|
611 token->val.str.len - 4);
|
|
|
612 debugdir[token->val.str.len - 4] = '\0';
|
|
|
613
|
|
|
614 pfile->cb.dir_change (pfile, debugdir);
|
|
|
615 }
|
|
|
616 }
|
|
|
617
|
|
|
618 /* This is called at the end of preprocessing. It pops the last
|
|
|
619 buffer and writes dependency output, and returns the number of
|
|
|
620 errors.
|
|
|
621
|
|
|
622 Maybe it should also reset state, such that you could call
|
|
|
623 cpp_start_read with a new filename to restart processing. */
|
|
|
624 int
|
|
|
625 cpp_finish (cpp_reader *pfile, FILE *deps_stream)
|
|
|
626 {
|
|
|
627 /* Warn about unused macros before popping the final buffer. */
|
|
|
628 if (CPP_OPTION (pfile, warn_unused_macros))
|
|
|
629 cpp_forall_identifiers (pfile, _cpp_warn_if_unused_macro, NULL);
|
|
|
630
|
|
|
631 /* lex.c leaves the final buffer on the stack. This it so that
|
|
|
632 it returns an unending stream of CPP_EOFs to the client. If we
|
|
|
633 popped the buffer, we'd dereference a NULL buffer pointer and
|
|
|
634 segfault. It's nice to allow the client to do worry-free excess
|
|
|
635 cpp_get_token calls. */
|
|
|
636 while (pfile->buffer)
|
|
|
637 _cpp_pop_buffer (pfile);
|
|
|
638
|
|
|
639 /* Don't write the deps file if there are errors. */
|
|
|
640 if (CPP_OPTION (pfile, deps.style) != DEPS_NONE
|
|
|
641 && deps_stream && pfile->errors == 0)
|
|
|
642 {
|
|
|
643 deps_write (pfile->deps, deps_stream, 72);
|
|
|
644
|
|
|
645 if (CPP_OPTION (pfile, deps.phony_targets))
|
|
|
646 deps_phony_targets (pfile->deps, deps_stream);
|
|
|
647 }
|
|
|
648
|
|
|
649 /* Report on headers that could use multiple include guards. */
|
|
|
650 if (CPP_OPTION (pfile, print_include_names))
|
|
|
651 _cpp_report_missing_guards (pfile);
|
|
|
652
|
|
|
653 return pfile->errors;
|
|
|
654 }
|
|
|
655
|
|
|
656 static void
|
|
|
657 post_options (cpp_reader *pfile)
|
|
|
658 {
|
|
|
659 /* -Wtraditional is not useful in C++ mode. */
|
|
|
660 if (CPP_OPTION (pfile, cplusplus))
|
|
|
661 CPP_OPTION (pfile, warn_traditional) = 0;
|
|
|
662
|
|
|
663 /* Permanently disable macro expansion if we are rescanning
|
|
|
664 preprocessed text. Read preprocesed source in ISO mode. */
|
|
|
665 if (CPP_OPTION (pfile, preprocessed))
|
|
|
666 {
|
|
|
667 if (!CPP_OPTION (pfile, directives_only))
|
|
|
668 pfile->state.prevent_expansion = 1;
|
|
|
669 CPP_OPTION (pfile, traditional) = 0;
|
|
|
670 }
|
|
|
671
|
|
|
672 if (CPP_OPTION (pfile, warn_trigraphs) == 2)
|
|
|
673 CPP_OPTION (pfile, warn_trigraphs) = !CPP_OPTION (pfile, trigraphs);
|
|
|
674
|
|
|
675 if (CPP_OPTION (pfile, traditional))
|
|
|
676 {
|
|
|
677 CPP_OPTION (pfile, cplusplus_comments) = 0;
|
|
|
678
|
|
|
679 /* Traditional CPP does not accurately track column information. */
|
|
|
680 CPP_OPTION (pfile, show_column) = 0;
|
|
|
681 CPP_OPTION (pfile, trigraphs) = 0;
|
|
|
682 CPP_OPTION (pfile, warn_trigraphs) = 0;
|
|
|
683 }
|
|
|
684 }
|
