|
0
|
1 /* Mainly the interface between cpplib and the C front ends.
|
|
|
2 Copyright (C) 1987, 1988, 1989, 1992, 1994, 1995, 1996, 1997
|
|
|
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
|
|
|
4 Free Software Foundation, Inc.
|
|
|
5
|
|
|
6 This file is part of GCC.
|
|
|
7
|
|
|
8 GCC is free software; you can redistribute it and/or modify it under
|
|
|
9 the terms of the GNU General Public License as published by the Free
|
|
|
10 Software Foundation; either version 3, or (at your option) any later
|
|
|
11 version.
|
|
|
12
|
|
|
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
16 for more details.
|
|
|
17
|
|
|
18 You should have received a copy of the GNU General Public License
|
|
|
19 along with GCC; see the file COPYING3. If not see
|
|
|
20 <http://www.gnu.org/licenses/>. */
|
|
|
21
|
|
|
22 #include "config.h"
|
|
|
23 #include "system.h"
|
|
|
24 #include "coretypes.h"
|
|
|
25 #include "tm.h"
|
|
|
26
|
|
|
27 #include "real.h"
|
|
|
28 #include "rtl.h"
|
|
|
29 #include "tree.h"
|
|
|
30 #include "input.h"
|
|
|
31 #include "output.h"
|
|
|
32 #include "c-tree.h"
|
|
|
33 #include "c-common.h"
|
|
|
34 #include "flags.h"
|
|
|
35 #include "timevar.h"
|
|
|
36 #include "cpplib.h"
|
|
|
37 #include "c-pragma.h"
|
|
|
38 #include "toplev.h"
|
|
|
39 #include "intl.h"
|
|
|
40 #include "tm_p.h"
|
|
|
41 #include "splay-tree.h"
|
|
|
42 #include "debug.h"
|
|
|
43 #include "target.h"
|
|
|
44
|
|
|
45 /* We may keep statistics about how long which files took to compile. */
|
|
|
46 static int header_time, body_time;
|
|
|
47 static splay_tree file_info_tree;
|
|
|
48
|
|
|
49 int pending_lang_change; /* If we need to switch languages - C++ only */
|
|
|
50 int c_header_level; /* depth in C headers - C++ only */
|
|
|
51
|
|
|
52 static tree interpret_integer (const cpp_token *, unsigned int);
|
|
|
53 static tree interpret_float (const cpp_token *, unsigned int);
|
|
|
54 static tree interpret_fixed (const cpp_token *, unsigned int);
|
|
|
55 static enum integer_type_kind narrowest_unsigned_type
|
|
|
56 (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
|
|
|
57 static enum integer_type_kind narrowest_signed_type
|
|
|
58 (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
|
|
|
59 static enum cpp_ttype lex_string (const cpp_token *, tree *, bool, bool);
|
|
|
60 static tree lex_charconst (const cpp_token *);
|
|
|
61 static void update_header_times (const char *);
|
|
|
62 static int dump_one_header (splay_tree_node, void *);
|
|
|
63 static void cb_line_change (cpp_reader *, const cpp_token *, int);
|
|
|
64 static void cb_ident (cpp_reader *, unsigned int, const cpp_string *);
|
|
|
65 static void cb_def_pragma (cpp_reader *, unsigned int);
|
|
|
66 static void cb_define (cpp_reader *, unsigned int, cpp_hashnode *);
|
|
|
67 static void cb_undef (cpp_reader *, unsigned int, cpp_hashnode *);
|
|
|
68
|
|
|
69 void
|
|
|
70 init_c_lex (void)
|
|
|
71 {
|
|
|
72 struct cpp_callbacks *cb;
|
|
|
73 struct c_fileinfo *toplevel;
|
|
|
74
|
|
|
75 /* The get_fileinfo data structure must be initialized before
|
|
|
76 cpp_read_main_file is called. */
|
|
|
77 toplevel = get_fileinfo ("<top level>");
|
|
|
78 if (flag_detailed_statistics)
|
|
|
79 {
|
|
|
80 header_time = 0;
|
|
|
81 body_time = get_run_time ();
|
|
|
82 toplevel->time = body_time;
|
|
|
83 }
|
|
|
84
|
|
|
85 cb = cpp_get_callbacks (parse_in);
|
|
|
86
|
|
|
87 cb->line_change = cb_line_change;
|
|
|
88 cb->ident = cb_ident;
|
|
|
89 cb->def_pragma = cb_def_pragma;
|
|
|
90 cb->valid_pch = c_common_valid_pch;
|
|
|
91 cb->read_pch = c_common_read_pch;
|
|
|
92
|
|
|
93 /* Set the debug callbacks if we can use them. */
|
|
|
94 if (debug_info_level == DINFO_LEVEL_VERBOSE
|
|
|
95 && (write_symbols == DWARF2_DEBUG
|
|
|
96 || write_symbols == VMS_AND_DWARF2_DEBUG))
|
|
|
97 {
|
|
|
98 cb->define = cb_define;
|
|
|
99 cb->undef = cb_undef;
|
|
|
100 }
|
|
|
101 }
|
|
|
102
|
|
|
103 struct c_fileinfo *
|
|
|
104 get_fileinfo (const char *name)
|
|
|
105 {
|
|
|
106 splay_tree_node n;
|
|
|
107 struct c_fileinfo *fi;
|
|
|
108
|
|
|
109 if (!file_info_tree)
|
|
|
110 file_info_tree = splay_tree_new ((splay_tree_compare_fn) strcmp,
|
|
|
111 0,
|
|
|
112 (splay_tree_delete_value_fn) free);
|
|
|
113
|
|
|
114 n = splay_tree_lookup (file_info_tree, (splay_tree_key) name);
|
|
|
115 if (n)
|
|
|
116 return (struct c_fileinfo *) n->value;
|
|
|
117
|
|
|
118 fi = XNEW (struct c_fileinfo);
|
|
|
119 fi->time = 0;
|
|
|
120 fi->interface_only = 0;
|
|
|
121 fi->interface_unknown = 1;
|
|
|
122 splay_tree_insert (file_info_tree, (splay_tree_key) name,
|
|
|
123 (splay_tree_value) fi);
|
|
|
124 return fi;
|
|
|
125 }
|
|
|
126
|
|
|
127 static void
|
|
|
128 update_header_times (const char *name)
|
|
|
129 {
|
|
|
130 /* Changing files again. This means currently collected time
|
|
|
131 is charged against header time, and body time starts back at 0. */
|
|
|
132 if (flag_detailed_statistics)
|
|
|
133 {
|
|
|
134 int this_time = get_run_time ();
|
|
|
135 struct c_fileinfo *file = get_fileinfo (name);
|
|
|
136 header_time += this_time - body_time;
|
|
|
137 file->time += this_time - body_time;
|
|
|
138 body_time = this_time;
|
|
|
139 }
|
|
|
140 }
|
|
|
141
|
|
|
142 static int
|
|
|
143 dump_one_header (splay_tree_node n, void * ARG_UNUSED (dummy))
|
|
|
144 {
|
|
|
145 print_time ((const char *) n->key,
|
|
|
146 ((struct c_fileinfo *) n->value)->time);
|
|
|
147 return 0;
|
|
|
148 }
|
|
|
149
|
|
|
150 void
|
|
|
151 dump_time_statistics (void)
|
|
|
152 {
|
|
|
153 struct c_fileinfo *file = get_fileinfo (input_filename);
|
|
|
154 int this_time = get_run_time ();
|
|
|
155 file->time += this_time - body_time;
|
|
|
156
|
|
|
157 fprintf (stderr, "\n******\n");
|
|
|
158 print_time ("header files (total)", header_time);
|
|
|
159 print_time ("main file (total)", this_time - body_time);
|
|
|
160 fprintf (stderr, "ratio = %g : 1\n",
|
|
|
161 (double) header_time / (double) (this_time - body_time));
|
|
|
162 fprintf (stderr, "\n******\n");
|
|
|
163
|
|
|
164 splay_tree_foreach (file_info_tree, dump_one_header, 0);
|
|
|
165 }
|
|
|
166
|
|
|
167 static void
|
|
|
168 cb_ident (cpp_reader * ARG_UNUSED (pfile),
|
|
|
169 unsigned int ARG_UNUSED (line),
|
|
|
170 const cpp_string * ARG_UNUSED (str))
|
|
|
171 {
|
|
|
172 #ifdef ASM_OUTPUT_IDENT
|
|
|
173 if (!flag_no_ident)
|
|
|
174 {
|
|
|
175 /* Convert escapes in the string. */
|
|
|
176 cpp_string cstr = { 0, 0 };
|
|
|
177 if (cpp_interpret_string (pfile, str, 1, &cstr, CPP_STRING))
|
|
|
178 {
|
|
|
179 ASM_OUTPUT_IDENT (asm_out_file, (const char *) cstr.text);
|
|
|
180 free (CONST_CAST (unsigned char *, cstr.text));
|
|
|
181 }
|
|
|
182 }
|
|
|
183 #endif
|
|
|
184 }
|
|
|
185
|
|
|
186 /* Called at the start of every non-empty line. TOKEN is the first
|
|
|
187 lexed token on the line. Used for diagnostic line numbers. */
|
|
|
188 static void
|
|
|
189 cb_line_change (cpp_reader * ARG_UNUSED (pfile), const cpp_token *token,
|
|
|
190 int parsing_args)
|
|
|
191 {
|
|
|
192 if (token->type != CPP_EOF && !parsing_args)
|
|
|
193 input_location = token->src_loc;
|
|
|
194 }
|
|
|
195
|
|
|
196 void
|
|
|
197 fe_file_change (const struct line_map *new_map)
|
|
|
198 {
|
|
|
199 if (new_map == NULL)
|
|
|
200 return;
|
|
|
201
|
|
|
202 if (new_map->reason == LC_ENTER)
|
|
|
203 {
|
|
|
204 /* Don't stack the main buffer on the input stack;
|
|
|
205 we already did in compile_file. */
|
|
|
206 if (!MAIN_FILE_P (new_map))
|
|
|
207 {
|
|
|
208 unsigned int included_at = LAST_SOURCE_LINE_LOCATION (new_map - 1);
|
|
|
209 int line = 0;
|
|
|
210 if (included_at > BUILTINS_LOCATION)
|
|
|
211 line = SOURCE_LINE (new_map - 1, included_at);
|
|
|
212
|
|
|
213 input_location = new_map->start_location;
|
|
|
214 (*debug_hooks->start_source_file) (line, new_map->to_file);
|
|
|
215 #ifndef NO_IMPLICIT_EXTERN_C
|
|
|
216 if (c_header_level)
|
|
|
217 ++c_header_level;
|
|
|
218 else if (new_map->sysp == 2)
|
|
|
219 {
|
|
|
220 c_header_level = 1;
|
|
|
221 ++pending_lang_change;
|
|
|
222 }
|
|
|
223 #endif
|
|
|
224 }
|
|
|
225 }
|
|
|
226 else if (new_map->reason == LC_LEAVE)
|
|
|
227 {
|
|
|
228 #ifndef NO_IMPLICIT_EXTERN_C
|
|
|
229 if (c_header_level && --c_header_level == 0)
|
|
|
230 {
|
|
|
231 if (new_map->sysp == 2)
|
|
|
232 warning (0, "badly nested C headers from preprocessor");
|
|
|
233 --pending_lang_change;
|
|
|
234 }
|
|
|
235 #endif
|
|
|
236 input_location = new_map->start_location;
|
|
|
237
|
|
|
238 (*debug_hooks->end_source_file) (new_map->to_line);
|
|
|
239 }
|
|
|
240
|
|
|
241 update_header_times (new_map->to_file);
|
|
|
242 input_location = new_map->start_location;
|
|
|
243 }
|
|
|
244
|
|
|
245 static void
|
|
|
246 cb_def_pragma (cpp_reader *pfile, source_location loc)
|
|
|
247 {
|
|
|
248 /* Issue a warning message if we have been asked to do so. Ignore
|
|
|
249 unknown pragmas in system headers unless an explicit
|
|
|
250 -Wunknown-pragmas has been given. */
|
|
|
251 if (warn_unknown_pragmas > in_system_header)
|
|
|
252 {
|
|
|
253 const unsigned char *space, *name;
|
|
|
254 const cpp_token *s;
|
|
|
255 location_t fe_loc = loc;
|
|
|
256
|
|
|
257 space = name = (const unsigned char *) "";
|
|
|
258 s = cpp_get_token (pfile);
|
|
|
259 if (s->type != CPP_EOF)
|
|
|
260 {
|
|
|
261 space = cpp_token_as_text (pfile, s);
|
|
|
262 s = cpp_get_token (pfile);
|
|
|
263 if (s->type == CPP_NAME)
|
|
|
264 name = cpp_token_as_text (pfile, s);
|
|
|
265 }
|
|
|
266
|
|
|
267 warning (OPT_Wunknown_pragmas, "%Hignoring #pragma %s %s",
|
|
|
268 &fe_loc, space, name);
|
|
|
269 }
|
|
|
270 }
|
|
|
271
|
|
|
272 /* #define callback for DWARF and DWARF2 debug info. */
|
|
|
273 static void
|
|
|
274 cb_define (cpp_reader *pfile, source_location loc, cpp_hashnode *node)
|
|
|
275 {
|
|
|
276 const struct line_map *map = linemap_lookup (line_table, loc);
|
|
|
277 (*debug_hooks->define) (SOURCE_LINE (map, loc),
|
|
|
278 (const char *) cpp_macro_definition (pfile, node));
|
|
|
279 }
|
|
|
280
|
|
|
281 /* #undef callback for DWARF and DWARF2 debug info. */
|
|
|
282 static void
|
|
|
283 cb_undef (cpp_reader * ARG_UNUSED (pfile), source_location loc,
|
|
|
284 cpp_hashnode *node)
|
|
|
285 {
|
|
|
286 const struct line_map *map = linemap_lookup (line_table, loc);
|
|
|
287 (*debug_hooks->undef) (SOURCE_LINE (map, loc),
|
|
|
288 (const char *) NODE_NAME (node));
|
|
|
289 }
|
|
|
290
|
|
|
291 /* Read a token and return its type. Fill *VALUE with its value, if
|
|
|
292 applicable. Fill *CPP_FLAGS with the token's flags, if it is
|
|
|
293 non-NULL. */
|
|
|
294
|
|
|
295 enum cpp_ttype
|
|
|
296 c_lex_with_flags (tree *value, location_t *loc, unsigned char *cpp_flags,
|
|
|
297 int lex_flags)
|
|
|
298 {
|
|
|
299 static bool no_more_pch;
|
|
|
300 const cpp_token *tok;
|
|
|
301 enum cpp_ttype type;
|
|
|
302 unsigned char add_flags = 0;
|
|
|
303
|
|
|
304 timevar_push (TV_CPP);
|
|
|
305 retry:
|
|
|
306 tok = cpp_get_token_with_location (parse_in, loc);
|
|
|
307 type = tok->type;
|
|
|
308
|
|
|
309 retry_after_at:
|
|
|
310 switch (type)
|
|
|
311 {
|
|
|
312 case CPP_PADDING:
|
|
|
313 goto retry;
|
|
|
314
|
|
|
315 case CPP_NAME:
|
|
|
316 *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
|
|
|
317 break;
|
|
|
318
|
|
|
319 case CPP_NUMBER:
|
|
|
320 {
|
|
|
321 unsigned int flags = cpp_classify_number (parse_in, tok);
|
|
|
322
|
|
|
323 switch (flags & CPP_N_CATEGORY)
|
|
|
324 {
|
|
|
325 case CPP_N_INVALID:
|
|
|
326 /* cpplib has issued an error. */
|
|
|
327 *value = error_mark_node;
|
|
|
328 errorcount++;
|
|
|
329 break;
|
|
|
330
|
|
|
331 case CPP_N_INTEGER:
|
|
|
332 /* C++ uses '0' to mark virtual functions as pure.
|
|
|
333 Set PURE_ZERO to pass this information to the C++ parser. */
|
|
|
334 if (tok->val.str.len == 1 && *tok->val.str.text == '0')
|
|
|
335 add_flags = PURE_ZERO;
|
|
|
336 *value = interpret_integer (tok, flags);
|
|
|
337 break;
|
|
|
338
|
|
|
339 case CPP_N_FLOATING:
|
|
|
340 *value = interpret_float (tok, flags);
|
|
|
341 break;
|
|
|
342
|
|
|
343 default:
|
|
|
344 gcc_unreachable ();
|
|
|
345 }
|
|
|
346 }
|
|
|
347 break;
|
|
|
348
|
|
|
349 case CPP_ATSIGN:
|
|
|
350 /* An @ may give the next token special significance in Objective-C. */
|
|
|
351 if (c_dialect_objc ())
|
|
|
352 {
|
|
|
353 location_t atloc = *loc;
|
|
|
354 location_t newloc;
|
|
|
355
|
|
|
356 retry_at:
|
|
|
357 tok = cpp_get_token_with_location (parse_in, &newloc);
|
|
|
358 type = tok->type;
|
|
|
359 switch (type)
|
|
|
360 {
|
|
|
361 case CPP_PADDING:
|
|
|
362 goto retry_at;
|
|
|
363
|
|
|
364 case CPP_STRING:
|
|
|
365 case CPP_WSTRING:
|
|
|
366 case CPP_STRING16:
|
|
|
367 case CPP_STRING32:
|
|
|
368 type = lex_string (tok, value, true, true);
|
|
|
369 break;
|
|
|
370
|
|
|
371 case CPP_NAME:
|
|
|
372 *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
|
|
|
373 if (objc_is_reserved_word (*value))
|
|
|
374 {
|
|
|
375 type = CPP_AT_NAME;
|
|
|
376 break;
|
|
|
377 }
|
|
|
378 /* FALLTHROUGH */
|
|
|
379
|
|
|
380 default:
|
|
|
381 /* ... or not. */
|
|
|
382 error ("%Hstray %<@%> in program", &atloc);
|
|
|
383 *loc = newloc;
|
|
|
384 goto retry_after_at;
|
|
|
385 }
|
|
|
386 break;
|
|
|
387 }
|
|
|
388
|
|
|
389 /* FALLTHROUGH */
|
|
|
390 case CPP_HASH:
|
|
|
391 case CPP_PASTE:
|
|
|
392 {
|
|
|
393 unsigned char name[4];
|
|
|
394
|
|
|
395 *cpp_spell_token (parse_in, tok, name, true) = 0;
|
|
|
396
|
|
|
397 error ("stray %qs in program", name);
|
|
|
398 }
|
|
|
399
|
|
|
400 goto retry;
|
|
|
401
|
|
|
402 case CPP_OTHER:
|
|
|
403 {
|
|
|
404 cppchar_t c = tok->val.str.text[0];
|
|
|
405
|
|
|
406 if (c == '"' || c == '\'')
|
|
|
407 error ("missing terminating %c character", (int) c);
|
|
|
408 else if (ISGRAPH (c))
|
|
|
409 error ("stray %qc in program", (int) c);
|
|
|
410 else
|
|
|
411 error ("stray %<\\%o%> in program", (int) c);
|
|
|
412 }
|
|
|
413 goto retry;
|
|
|
414
|
|
|
415 case CPP_CHAR:
|
|
|
416 case CPP_WCHAR:
|
|
|
417 case CPP_CHAR16:
|
|
|
418 case CPP_CHAR32:
|
|
|
419 *value = lex_charconst (tok);
|
|
|
420 break;
|
|
|
421
|
|
|
422 case CPP_STRING:
|
|
|
423 case CPP_WSTRING:
|
|
|
424 case CPP_STRING16:
|
|
|
425 case CPP_STRING32:
|
|
|
426 if ((lex_flags & C_LEX_RAW_STRINGS) == 0)
|
|
|
427 {
|
|
|
428 type = lex_string (tok, value, false,
|
|
|
429 (lex_flags & C_LEX_STRING_NO_TRANSLATE) == 0);
|
|
|
430 break;
|
|
|
431 }
|
|
|
432 *value = build_string (tok->val.str.len, (const char *) tok->val.str.text);
|
|
|
433 break;
|
|
|
434
|
|
|
435 case CPP_PRAGMA:
|
|
|
436 *value = build_int_cst (NULL, tok->val.pragma);
|
|
|
437 break;
|
|
|
438
|
|
|
439 /* These tokens should not be visible outside cpplib. */
|
|
|
440 case CPP_HEADER_NAME:
|
|
|
441 case CPP_COMMENT:
|
|
|
442 case CPP_MACRO_ARG:
|
|
|
443 gcc_unreachable ();
|
|
|
444
|
|
|
445 default:
|
|
|
446 *value = NULL_TREE;
|
|
|
447 break;
|
|
|
448 }
|
|
|
449
|
|
|
450 if (cpp_flags)
|
|
|
451 *cpp_flags = tok->flags | add_flags;
|
|
|
452
|
|
|
453 if (!no_more_pch)
|
|
|
454 {
|
|
|
455 no_more_pch = true;
|
|
|
456 c_common_no_more_pch ();
|
|
|
457 }
|
|
|
458
|
|
|
459 timevar_pop (TV_CPP);
|
|
|
460
|
|
|
461 return type;
|
|
|
462 }
|
|
|
463
|
|
|
464 /* Returns the narrowest C-visible unsigned type, starting with the
|
|
|
465 minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
|
|
|
466 there isn't one. */
|
|
|
467
|
|
|
468 static enum integer_type_kind
|
|
|
469 narrowest_unsigned_type (unsigned HOST_WIDE_INT low,
|
|
|
470 unsigned HOST_WIDE_INT high,
|
|
|
471 unsigned int flags)
|
|
|
472 {
|
|
|
473 int itk;
|
|
|
474
|
|
|
475 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
|
|
|
476 itk = itk_unsigned_int;
|
|
|
477 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
|
|
|
478 itk = itk_unsigned_long;
|
|
|
479 else
|
|
|
480 itk = itk_unsigned_long_long;
|
|
|
481
|
|
|
482 for (; itk < itk_none; itk += 2 /* skip unsigned types */)
|
|
|
483 {
|
|
|
484 tree upper = TYPE_MAX_VALUE (integer_types[itk]);
|
|
|
485
|
|
|
486 if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
|
|
|
487 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
|
|
|
488 && TREE_INT_CST_LOW (upper) >= low))
|
|
|
489 return (enum integer_type_kind) itk;
|
|
|
490 }
|
|
|
491
|
|
|
492 return itk_none;
|
|
|
493 }
|
|
|
494
|
|
|
495 /* Ditto, but narrowest signed type. */
|
|
|
496 static enum integer_type_kind
|
|
|
497 narrowest_signed_type (unsigned HOST_WIDE_INT low,
|
|
|
498 unsigned HOST_WIDE_INT high, unsigned int flags)
|
|
|
499 {
|
|
|
500 int itk;
|
|
|
501
|
|
|
502 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
|
|
|
503 itk = itk_int;
|
|
|
504 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
|
|
|
505 itk = itk_long;
|
|
|
506 else
|
|
|
507 itk = itk_long_long;
|
|
|
508
|
|
|
509
|
|
|
510 for (; itk < itk_none; itk += 2 /* skip signed types */)
|
|
|
511 {
|
|
|
512 tree upper = TYPE_MAX_VALUE (integer_types[itk]);
|
|
|
513
|
|
|
514 if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
|
|
|
515 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
|
|
|
516 && TREE_INT_CST_LOW (upper) >= low))
|
|
|
517 return (enum integer_type_kind) itk;
|
|
|
518 }
|
|
|
519
|
|
|
520 return itk_none;
|
|
|
521 }
|
|
|
522
|
|
|
523 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
|
|
|
524 static tree
|
|
|
525 interpret_integer (const cpp_token *token, unsigned int flags)
|
|
|
526 {
|
|
|
527 tree value, type;
|
|
|
528 enum integer_type_kind itk;
|
|
|
529 cpp_num integer;
|
|
|
530 cpp_options *options = cpp_get_options (parse_in);
|
|
|
531
|
|
|
532 integer = cpp_interpret_integer (parse_in, token, flags);
|
|
|
533 integer = cpp_num_sign_extend (integer, options->precision);
|
|
|
534
|
|
|
535 /* The type of a constant with a U suffix is straightforward. */
|
|
|
536 if (flags & CPP_N_UNSIGNED)
|
|
|
537 itk = narrowest_unsigned_type (integer.low, integer.high, flags);
|
|
|
538 else
|
|
|
539 {
|
|
|
540 /* The type of a potentially-signed integer constant varies
|
|
|
541 depending on the base it's in, the standard in use, and the
|
|
|
542 length suffixes. */
|
|
|
543 enum integer_type_kind itk_u
|
|
|
544 = narrowest_unsigned_type (integer.low, integer.high, flags);
|
|
|
545 enum integer_type_kind itk_s
|
|
|
546 = narrowest_signed_type (integer.low, integer.high, flags);
|
|
|
547
|
|
|
548 /* In both C89 and C99, octal and hex constants may be signed or
|
|
|
549 unsigned, whichever fits tighter. We do not warn about this
|
|
|
550 choice differing from the traditional choice, as the constant
|
|
|
551 is probably a bit pattern and either way will work. */
|
|
|
552 if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
|
|
|
553 itk = MIN (itk_u, itk_s);
|
|
|
554 else
|
|
|
555 {
|
|
|
556 /* In C99, decimal constants are always signed.
|
|
|
557 In C89, decimal constants that don't fit in long have
|
|
|
558 undefined behavior; we try to make them unsigned long.
|
|
|
559 In GCC's extended C89, that last is true of decimal
|
|
|
560 constants that don't fit in long long, too. */
|
|
|
561
|
|
|
562 itk = itk_s;
|
|
|
563 if (itk_s > itk_u && itk_s > itk_long)
|
|
|
564 {
|
|
|
565 if (!flag_isoc99)
|
|
|
566 {
|
|
|
567 if (itk_u < itk_unsigned_long)
|
|
|
568 itk_u = itk_unsigned_long;
|
|
|
569 itk = itk_u;
|
|
|
570 warning (0, "this decimal constant is unsigned only in ISO C90");
|
|
|
571 }
|
|
|
572 else
|
|
|
573 warning (OPT_Wtraditional,
|
|
|
574 "this decimal constant would be unsigned in ISO C90");
|
|
|
575 }
|
|
|
576 }
|
|
|
577 }
|
|
|
578
|
|
|
579 if (itk == itk_none)
|
|
|
580 /* cpplib has already issued a warning for overflow. */
|
|
|
581 type = ((flags & CPP_N_UNSIGNED)
|
|
|
582 ? widest_unsigned_literal_type_node
|
|
|
583 : widest_integer_literal_type_node);
|
|
|
584 else
|
|
|
585 type = integer_types[itk];
|
|
|
586
|
|
|
587 if (itk > itk_unsigned_long
|
|
|
588 && (flags & CPP_N_WIDTH) != CPP_N_LARGE
|
|
|
589 && !in_system_header && !flag_isoc99)
|
|
|
590 pedwarn (input_location, 0, "integer constant is too large for %qs type",
|
|
|
591 (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long");
|
|
|
592
|
|
|
593 value = build_int_cst_wide (type, integer.low, integer.high);
|
|
|
594
|
|
|
595 /* Convert imaginary to a complex type. */
|
|
|
596 if (flags & CPP_N_IMAGINARY)
|
|
|
597 value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
|
|
|
598
|
|
|
599 return value;
|
|
|
600 }
|
|
|
601
|
|
|
602 /* Interpret TOKEN, a floating point number with FLAGS as classified
|
|
|
603 by cpplib. */
|
|
|
604 static tree
|
|
|
605 interpret_float (const cpp_token *token, unsigned int flags)
|
|
|
606 {
|
|
|
607 tree type;
|
|
|
608 tree value;
|
|
|
609 REAL_VALUE_TYPE real;
|
|
|
610 char *copy;
|
|
|
611 size_t copylen;
|
|
|
612
|
|
|
613 /* Decode _Fract and _Accum. */
|
|
|
614 if (flags & CPP_N_FRACT || flags & CPP_N_ACCUM)
|
|
|
615 return interpret_fixed (token, flags);
|
|
|
616
|
|
|
617 /* Decode type based on width and properties. */
|
|
|
618 if (flags & CPP_N_DFLOAT)
|
|
|
619 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
|
|
|
620 type = dfloat128_type_node;
|
|
|
621 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
|
|
|
622 type = dfloat32_type_node;
|
|
|
623 else
|
|
|
624 type = dfloat64_type_node;
|
|
|
625 else
|
|
|
626 if (flags & CPP_N_WIDTH_MD)
|
|
|
627 {
|
|
|
628 char suffix;
|
|
|
629 enum machine_mode mode;
|
|
|
630
|
|
|
631 if ((flags & CPP_N_WIDTH_MD) == CPP_N_MD_W)
|
|
|
632 suffix = 'w';
|
|
|
633 else
|
|
|
634 suffix = 'q';
|
|
|
635
|
|
|
636 mode = targetm.c.mode_for_suffix (suffix);
|
|
|
637 if (mode == VOIDmode)
|
|
|
638 {
|
|
|
639 error ("unsupported non-standard suffix on floating constant");
|
|
|
640 errorcount++;
|
|
|
641
|
|
|
642 return error_mark_node;
|
|
|
643 }
|
|
|
644 else
|
|
|
645 pedwarn (input_location, OPT_pedantic, "non-standard suffix on floating constant");
|
|
|
646
|
|
|
647 type = c_common_type_for_mode (mode, 0);
|
|
|
648 gcc_assert (type);
|
|
|
649 }
|
|
|
650 else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
|
|
|
651 type = long_double_type_node;
|
|
|
652 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
|
|
|
653 || flag_single_precision_constant)
|
|
|
654 type = float_type_node;
|
|
|
655 else
|
|
|
656 type = double_type_node;
|
|
|
657
|
|
|
658 /* Copy the constant to a nul-terminated buffer. If the constant
|
|
|
659 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
|
|
|
660 can't handle them. */
|
|
|
661 copylen = token->val.str.len;
|
|
|
662 if (flags & CPP_N_DFLOAT)
|
|
|
663 copylen -= 2;
|
|
|
664 else
|
|
|
665 {
|
|
|
666 if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
|
|
|
667 /* Must be an F or L or machine defined suffix. */
|
|
|
668 copylen--;
|
|
|
669 if (flags & CPP_N_IMAGINARY)
|
|
|
670 /* I or J suffix. */
|
|
|
671 copylen--;
|
|
|
672 }
|
|
|
673
|
|
|
674 copy = (char *) alloca (copylen + 1);
|
|
|
675 memcpy (copy, token->val.str.text, copylen);
|
|
|
676 copy[copylen] = '\0';
|
|
|
677
|
|
|
678 real_from_string3 (&real, copy, TYPE_MODE (type));
|
|
|
679
|
|
|
680 /* Both C and C++ require a diagnostic for a floating constant
|
|
|
681 outside the range of representable values of its type. Since we
|
|
|
682 have __builtin_inf* to produce an infinity, this is now a
|
|
|
683 mandatory pedwarn if the target does not support infinities. */
|
|
|
684 if (REAL_VALUE_ISINF (real))
|
|
|
685 {
|
|
|
686 if (!MODE_HAS_INFINITIES (TYPE_MODE (type)))
|
|
|
687 pedwarn (input_location, 0, "floating constant exceeds range of %qT", type);
|
|
|
688 else
|
|
|
689 warning (OPT_Woverflow, "floating constant exceeds range of %qT", type);
|
|
|
690 }
|
|
|
691 /* We also give a warning if the value underflows. */
|
|
|
692 else if (REAL_VALUES_EQUAL (real, dconst0))
|
|
|
693 {
|
|
|
694 REAL_VALUE_TYPE realvoidmode;
|
|
|
695 int overflow = real_from_string (&realvoidmode, copy);
|
|
|
696 if (overflow < 0 || !REAL_VALUES_EQUAL (realvoidmode, dconst0))
|
|
|
697 warning (OPT_Woverflow, "floating constant truncated to zero");
|
|
|
698 }
|
|
|
699
|
|
|
700 /* Create a node with determined type and value. */
|
|
|
701 value = build_real (type, real);
|
|
|
702 if (flags & CPP_N_IMAGINARY)
|
|
|
703 value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
|
|
|
704
|
|
|
705 return value;
|
|
|
706 }
|
|
|
707
|
|
|
708 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
|
|
|
709 by cpplib. */
|
|
|
710
|
|
|
711 static tree
|
|
|
712 interpret_fixed (const cpp_token *token, unsigned int flags)
|
|
|
713 {
|
|
|
714 tree type;
|
|
|
715 tree value;
|
|
|
716 FIXED_VALUE_TYPE fixed;
|
|
|
717 char *copy;
|
|
|
718 size_t copylen;
|
|
|
719
|
|
|
720 copylen = token->val.str.len;
|
|
|
721
|
|
|
722 if (flags & CPP_N_FRACT) /* _Fract. */
|
|
|
723 {
|
|
|
724 if (flags & CPP_N_UNSIGNED) /* Unsigned _Fract. */
|
|
|
725 {
|
|
|
726 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
|
|
|
727 {
|
|
|
728 type = unsigned_long_long_fract_type_node;
|
|
|
729 copylen -= 4;
|
|
|
730 }
|
|
|
731 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
|
|
|
732 {
|
|
|
733 type = unsigned_long_fract_type_node;
|
|
|
734 copylen -= 3;
|
|
|
735 }
|
|
|
736 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
|
|
|
737 {
|
|
|
738 type = unsigned_short_fract_type_node;
|
|
|
739 copylen -= 3;
|
|
|
740 }
|
|
|
741 else
|
|
|
742 {
|
|
|
743 type = unsigned_fract_type_node;
|
|
|
744 copylen -= 2;
|
|
|
745 }
|
|
|
746 }
|
|
|
747 else /* Signed _Fract. */
|
|
|
748 {
|
|
|
749 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
|
|
|
750 {
|
|
|
751 type = long_long_fract_type_node;
|
|
|
752 copylen -= 3;
|
|
|
753 }
|
|
|
754 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
|
|
|
755 {
|
|
|
756 type = long_fract_type_node;
|
|
|
757 copylen -= 2;
|
|
|
758 }
|
|
|
759 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
|
|
|
760 {
|
|
|
761 type = short_fract_type_node;
|
|
|
762 copylen -= 2;
|
|
|
763 }
|
|
|
764 else
|
|
|
765 {
|
|
|
766 type = fract_type_node;
|
|
|
767 copylen --;
|
|
|
768 }
|
|
|
769 }
|
|
|
770 }
|
|
|
771 else /* _Accum. */
|
|
|
772 {
|
|
|
773 if (flags & CPP_N_UNSIGNED) /* Unsigned _Accum. */
|
|
|
774 {
|
|
|
775 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
|
|
|
776 {
|
|
|
777 type = unsigned_long_long_accum_type_node;
|
|
|
778 copylen -= 4;
|
|
|
779 }
|
|
|
780 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
|
|
|
781 {
|
|
|
782 type = unsigned_long_accum_type_node;
|
|
|
783 copylen -= 3;
|
|
|
784 }
|
|
|
785 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
|
|
|
786 {
|
|
|
787 type = unsigned_short_accum_type_node;
|
|
|
788 copylen -= 3;
|
|
|
789 }
|
|
|
790 else
|
|
|
791 {
|
|
|
792 type = unsigned_accum_type_node;
|
|
|
793 copylen -= 2;
|
|
|
794 }
|
|
|
795 }
|
|
|
796 else /* Signed _Accum. */
|
|
|
797 {
|
|
|
798 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
|
|
|
799 {
|
|
|
800 type = long_long_accum_type_node;
|
|
|
801 copylen -= 3;
|
|
|
802 }
|
|
|
803 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
|
|
|
804 {
|
|
|
805 type = long_accum_type_node;
|
|
|
806 copylen -= 2;
|
|
|
807 }
|
|
|
808 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
|
|
|
809 {
|
|
|
810 type = short_accum_type_node;
|
|
|
811 copylen -= 2;
|
|
|
812 }
|
|
|
813 else
|
|
|
814 {
|
|
|
815 type = accum_type_node;
|
|
|
816 copylen --;
|
|
|
817 }
|
|
|
818 }
|
|
|
819 }
|
|
|
820
|
|
|
821 copy = (char *) alloca (copylen + 1);
|
|
|
822 memcpy (copy, token->val.str.text, copylen);
|
|
|
823 copy[copylen] = '\0';
|
|
|
824
|
|
|
825 fixed_from_string (&fixed, copy, TYPE_MODE (type));
|
|
|
826
|
|
|
827 /* Create a node with determined type and value. */
|
|
|
828 value = build_fixed (type, fixed);
|
|
|
829
|
|
|
830 return value;
|
|
|
831 }
|
|
|
832
|
|
|
833 /* Convert a series of STRING, WSTRING, STRING16 and/or STRING32 tokens
|
|
|
834 into a tree, performing string constant concatenation. TOK is the
|
|
|
835 first of these. VALP is the location to write the string into.
|
|
|
836 OBJC_STRING indicates whether an '@' token preceded the incoming token.
|
|
|
837 Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
|
|
|
838 CPP_STRING32, CPP_STRING16, or CPP_OBJC_STRING).
|
|
|
839
|
|
|
840 This is unfortunately more work than it should be. If any of the
|
|
|
841 strings in the series has an L prefix, the result is a wide string
|
|
|
842 (6.4.5p4). Whether or not the result is a wide string affects the
|
|
|
843 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
|
|
|
844 sequences do not continue across the boundary between two strings in
|
|
|
845 a series (6.4.5p7), so we must not lose the boundaries. Therefore
|
|
|
846 cpp_interpret_string takes a vector of cpp_string structures, which
|
|
|
847 we must arrange to provide. */
|
|
|
848
|
|
|
849 static enum cpp_ttype
|
|
|
850 lex_string (const cpp_token *tok, tree *valp, bool objc_string, bool translate)
|
|
|
851 {
|
|
|
852 tree value;
|
|
|
853 size_t concats = 0;
|
|
|
854 struct obstack str_ob;
|
|
|
855 cpp_string istr;
|
|
|
856 enum cpp_ttype type = tok->type;
|
|
|
857
|
|
|
858 /* Try to avoid the overhead of creating and destroying an obstack
|
|
|
859 for the common case of just one string. */
|
|
|
860 cpp_string str = tok->val.str;
|
|
|
861 cpp_string *strs = &str;
|
|
|
862
|
|
|
863 retry:
|
|
|
864 tok = cpp_get_token (parse_in);
|
|
|
865 switch (tok->type)
|
|
|
866 {
|
|
|
867 case CPP_PADDING:
|
|
|
868 goto retry;
|
|
|
869 case CPP_ATSIGN:
|
|
|
870 if (c_dialect_objc ())
|
|
|
871 {
|
|
|
872 objc_string = true;
|
|
|
873 goto retry;
|
|
|
874 }
|
|
|
875 /* FALLTHROUGH */
|
|
|
876
|
|
|
877 default:
|
|
|
878 break;
|
|
|
879
|
|
|
880 case CPP_WSTRING:
|
|
|
881 case CPP_STRING16:
|
|
|
882 case CPP_STRING32:
|
|
|
883 if (type != tok->type)
|
|
|
884 {
|
|
|
885 if (type == CPP_STRING)
|
|
|
886 type = tok->type;
|
|
|
887 else
|
|
|
888 error ("unsupported non-standard concatenation of string literals");
|
|
|
889 }
|
|
|
890
|
|
|
891 case CPP_STRING:
|
|
|
892 if (!concats)
|
|
|
893 {
|
|
|
894 gcc_obstack_init (&str_ob);
|
|
|
895 obstack_grow (&str_ob, &str, sizeof (cpp_string));
|
|
|
896 }
|
|
|
897
|
|
|
898 concats++;
|
|
|
899 obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
|
|
|
900 goto retry;
|
|
|
901 }
|
|
|
902
|
|
|
903 /* We have read one more token than we want. */
|
|
|
904 _cpp_backup_tokens (parse_in, 1);
|
|
|
905 if (concats)
|
|
|
906 strs = XOBFINISH (&str_ob, cpp_string *);
|
|
|
907
|
|
|
908 if (concats && !objc_string && !in_system_header)
|
|
|
909 warning (OPT_Wtraditional,
|
|
|
910 "traditional C rejects string constant concatenation");
|
|
|
911
|
|
|
912 if ((translate
|
|
|
913 ? cpp_interpret_string : cpp_interpret_string_notranslate)
|
|
|
914 (parse_in, strs, concats + 1, &istr, type))
|
|
|
915 {
|
|
|
916 value = build_string (istr.len, (const char *) istr.text);
|
|
|
917 free (CONST_CAST (unsigned char *, istr.text));
|
|
|
918 }
|
|
|
919 else
|
|
|
920 {
|
|
|
921 /* Callers cannot generally handle error_mark_node in this context,
|
|
|
922 so return the empty string instead. cpp_interpret_string has
|
|
|
923 issued an error. */
|
|
|
924 switch (type)
|
|
|
925 {
|
|
|
926 default:
|
|
|
927 case CPP_STRING:
|
|
|
928 value = build_string (1, "");
|
|
|
929 break;
|
|
|
930 case CPP_STRING16:
|
|
|
931 value = build_string (TYPE_PRECISION (char16_type_node)
|
|
|
932 / TYPE_PRECISION (char_type_node),
|
|
|
933 "\0"); /* char16_t is 16 bits */
|
|
|
934 break;
|
|
|
935 case CPP_STRING32:
|
|
|
936 value = build_string (TYPE_PRECISION (char32_type_node)
|
|
|
937 / TYPE_PRECISION (char_type_node),
|
|
|
938 "\0\0\0"); /* char32_t is 32 bits */
|
|
|
939 break;
|
|
|
940 case CPP_WSTRING:
|
|
|
941 value = build_string (TYPE_PRECISION (wchar_type_node)
|
|
|
942 / TYPE_PRECISION (char_type_node),
|
|
|
943 "\0\0\0"); /* widest supported wchar_t
|
|
|
944 is 32 bits */
|
|
|
945 break;
|
|
|
946 }
|
|
|
947 }
|
|
|
948
|
|
|
949 switch (type)
|
|
|
950 {
|
|
|
951 default:
|
|
|
952 case CPP_STRING:
|
|
|
953 TREE_TYPE (value) = char_array_type_node;
|
|
|
954 break;
|
|
|
955 case CPP_STRING16:
|
|
|
956 TREE_TYPE (value) = char16_array_type_node;
|
|
|
957 break;
|
|
|
958 case CPP_STRING32:
|
|
|
959 TREE_TYPE (value) = char32_array_type_node;
|
|
|
960 break;
|
|
|
961 case CPP_WSTRING:
|
|
|
962 TREE_TYPE (value) = wchar_array_type_node;
|
|
|
963 }
|
|
|
964 *valp = fix_string_type (value);
|
|
|
965
|
|
|
966 if (concats)
|
|
|
967 obstack_free (&str_ob, 0);
|
|
|
968
|
|
|
969 return objc_string ? CPP_OBJC_STRING : type;
|
|
|
970 }
|
|
|
971
|
|
|
972 /* Converts a (possibly wide) character constant token into a tree. */
|
|
|
973 static tree
|
|
|
974 lex_charconst (const cpp_token *token)
|
|
|
975 {
|
|
|
976 cppchar_t result;
|
|
|
977 tree type, value;
|
|
|
978 unsigned int chars_seen;
|
|
|
979 int unsignedp = 0;
|
|
|
980
|
|
|
981 result = cpp_interpret_charconst (parse_in, token,
|
|
|
982 &chars_seen, &unsignedp);
|
|
|
983
|
|
|
984 if (token->type == CPP_WCHAR)
|
|
|
985 type = wchar_type_node;
|
|
|
986 else if (token->type == CPP_CHAR32)
|
|
|
987 type = char32_type_node;
|
|
|
988 else if (token->type == CPP_CHAR16)
|
|
|
989 type = char16_type_node;
|
|
|
990 /* In C, a character constant has type 'int'.
|
|
|
991 In C++ 'char', but multi-char charconsts have type 'int'. */
|
|
|
992 else if (!c_dialect_cxx () || chars_seen > 1)
|
|
|
993 type = integer_type_node;
|
|
|
994 else
|
|
|
995 type = char_type_node;
|
|
|
996
|
|
|
997 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
|
|
|
998 before possibly widening to HOST_WIDE_INT for build_int_cst. */
|
|
|
999 if (unsignedp || (cppchar_signed_t) result >= 0)
|
|
|
1000 value = build_int_cst_wide (type, result, 0);
|
|
|
1001 else
|
|
|
1002 value = build_int_cst_wide (type, (cppchar_signed_t) result, -1);
|
|
|
1003
|
|
|
1004 return value;
|
|
|
1005 }
|
