Mercurial > hg > CbC > CbC_gcc

comparison gcc/c-family/c-lex.c @ 68:561a7518be6b

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