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.
6 This file is part of GCC.
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
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
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/>. */
24 #include "coretypes.h"
35 #include "splay-tree.h"
39 /* We may keep statistics about how long which files took to compile. */
40 static int header_time
, body_time
;
41 static splay_tree file_info_tree
;
43 int pending_lang_change
; /* If we need to switch languages - C++ only */
44 int c_header_level
; /* depth in C headers - C++ and UPC only */
46 static tree
interpret_integer (const cpp_token
*, unsigned int,
47 enum overflow_type
*);
48 static tree
interpret_float (const cpp_token
*, unsigned int, const char *,
49 enum overflow_type
*);
50 static tree
interpret_fixed (const cpp_token
*, unsigned int);
51 static enum integer_type_kind narrowest_unsigned_type
52 (unsigned HOST_WIDE_INT
, unsigned HOST_WIDE_INT
, unsigned int);
53 static enum integer_type_kind narrowest_signed_type
54 (unsigned HOST_WIDE_INT
, unsigned HOST_WIDE_INT
, unsigned int);
55 static enum cpp_ttype
lex_string (const cpp_token
*, tree
*, bool, bool);
56 static tree
lex_charconst (const cpp_token
*);
57 static void update_header_times (const char *);
58 static int dump_one_header (splay_tree_node
, void *);
59 static void cb_line_change (cpp_reader
*, const cpp_token
*, int);
60 static void cb_ident (cpp_reader
*, unsigned int, const cpp_string
*);
61 static void cb_def_pragma (cpp_reader
*, unsigned int);
62 static void cb_define (cpp_reader
*, unsigned int, cpp_hashnode
*);
63 static void cb_undef (cpp_reader
*, unsigned int, cpp_hashnode
*);
68 struct cpp_callbacks
*cb
;
69 struct c_fileinfo
*toplevel
;
71 /* The get_fileinfo data structure must be initialized before
72 cpp_read_main_file is called. */
73 toplevel
= get_fileinfo ("<top level>");
74 if (flag_detailed_statistics
)
77 body_time
= get_run_time ();
78 toplevel
->time
= body_time
;
81 cb
= cpp_get_callbacks (parse_in
);
83 cb
->line_change
= cb_line_change
;
85 cb
->def_pragma
= cb_def_pragma
;
86 cb
->valid_pch
= c_common_valid_pch
;
87 cb
->read_pch
= c_common_read_pch
;
89 /* Set the debug callbacks if we can use them. */
90 if ((debug_info_level
== DINFO_LEVEL_VERBOSE
91 && (write_symbols
== DWARF2_DEBUG
92 || write_symbols
== VMS_AND_DWARF2_DEBUG
))
93 || flag_dump_go_spec
!= NULL
)
95 cb
->define
= cb_define
;
101 get_fileinfo (const char *name
)
104 struct c_fileinfo
*fi
;
107 file_info_tree
= splay_tree_new ((splay_tree_compare_fn
) strcmp
,
109 (splay_tree_delete_value_fn
) free
);
111 n
= splay_tree_lookup (file_info_tree
, (splay_tree_key
) name
);
113 return (struct c_fileinfo
*) n
->value
;
115 fi
= XNEW (struct c_fileinfo
);
117 fi
->interface_only
= 0;
118 fi
->interface_unknown
= 1;
119 splay_tree_insert (file_info_tree
, (splay_tree_key
) name
,
120 (splay_tree_value
) fi
);
125 update_header_times (const char *name
)
127 /* Changing files again. This means currently collected time
128 is charged against header time, and body time starts back at 0. */
129 if (flag_detailed_statistics
)
131 int this_time
= get_run_time ();
132 struct c_fileinfo
*file
= get_fileinfo (name
);
133 header_time
+= this_time
- body_time
;
134 file
->time
+= this_time
- body_time
;
135 body_time
= this_time
;
140 dump_one_header (splay_tree_node n
, void * ARG_UNUSED (dummy
))
142 print_time ((const char *) n
->key
,
143 ((struct c_fileinfo
*) n
->value
)->time
);
148 dump_time_statistics (void)
150 struct c_fileinfo
*file
= get_fileinfo (input_filename
);
151 int this_time
= get_run_time ();
152 file
->time
+= this_time
- body_time
;
154 fprintf (stderr
, "\n******\n");
155 print_time ("header files (total)", header_time
);
156 print_time ("main file (total)", this_time
- body_time
);
157 fprintf (stderr
, "ratio = %g : 1\n",
158 (double) header_time
/ (double) (this_time
- body_time
));
159 fprintf (stderr
, "\n******\n");
161 splay_tree_foreach (file_info_tree
, dump_one_header
, 0);
165 cb_ident (cpp_reader
* ARG_UNUSED (pfile
),
166 unsigned int ARG_UNUSED (line
),
167 const cpp_string
* ARG_UNUSED (str
))
171 /* Convert escapes in the string. */
172 cpp_string cstr
= { 0, 0 };
173 if (cpp_interpret_string (pfile
, str
, 1, &cstr
, CPP_STRING
))
175 targetm
.asm_out
.output_ident ((const char *) cstr
.text
);
176 free (CONST_CAST (unsigned char *, cstr
.text
));
181 /* Called at the start of every non-empty line. TOKEN is the first
182 lexed token on the line. Used for diagnostic line numbers. */
184 cb_line_change (cpp_reader
* ARG_UNUSED (pfile
), const cpp_token
*token
,
187 if (token
->type
!= CPP_EOF
&& !parsing_args
)
188 input_location
= token
->src_loc
;
192 fe_file_change (const struct line_map
*new_map
)
197 if (new_map
->reason
== LC_ENTER
)
199 /* Don't stack the main buffer on the input stack;
200 we already did in compile_file. */
201 if (!MAIN_FILE_P (new_map
))
203 unsigned int included_at
= LAST_SOURCE_LINE_LOCATION (new_map
- 1);
205 if (included_at
> BUILTINS_LOCATION
)
206 line
= SOURCE_LINE (new_map
- 1, included_at
);
208 input_location
= new_map
->start_location
;
209 (*debug_hooks
->start_source_file
) (line
, LINEMAP_FILE (new_map
));
212 else if (LINEMAP_SYSP (new_map
) == 2)
215 #ifndef NO_IMPLICIT_EXTERN_C
216 ++pending_lang_change
;
221 else if (new_map
->reason
== LC_LEAVE
)
223 if (c_header_level
&& --c_header_level
== 0)
225 if (LINEMAP_SYSP (new_map
) == 2)
226 warning (0, "badly nested C headers from preprocessor");
227 #ifndef NO_IMPLICIT_EXTERN_C
228 --pending_lang_change
;
231 input_location
= new_map
->start_location
;
233 (*debug_hooks
->end_source_file
) (LINEMAP_LINE (new_map
));
236 update_header_times (LINEMAP_FILE (new_map
));
237 input_location
= new_map
->start_location
;
241 cb_def_pragma (cpp_reader
*pfile
, source_location loc
)
243 /* Issue a warning message if we have been asked to do so. Ignore
244 unknown pragmas in system headers unless an explicit
245 -Wunknown-pragmas has been given. */
246 if (warn_unknown_pragmas
> in_system_header
)
248 const unsigned char *space
, *name
;
250 location_t fe_loc
= loc
;
252 space
= name
= (const unsigned char *) "";
253 s
= cpp_get_token (pfile
);
254 if (s
->type
!= CPP_EOF
)
256 space
= cpp_token_as_text (pfile
, s
);
257 s
= cpp_get_token (pfile
);
258 if (s
->type
== CPP_NAME
)
259 name
= cpp_token_as_text (pfile
, s
);
262 warning_at (fe_loc
, OPT_Wunknown_pragmas
, "ignoring #pragma %s %s",
267 /* #define callback for DWARF and DWARF2 debug info. */
269 cb_define (cpp_reader
*pfile
, source_location loc
, cpp_hashnode
*node
)
271 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
272 (*debug_hooks
->define
) (SOURCE_LINE (map
, loc
),
273 (const char *) cpp_macro_definition (pfile
, node
));
276 /* #undef callback for DWARF and DWARF2 debug info. */
278 cb_undef (cpp_reader
* ARG_UNUSED (pfile
), source_location loc
,
281 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
282 (*debug_hooks
->undef
) (SOURCE_LINE (map
, loc
),
283 (const char *) NODE_NAME (node
));
286 /* Read a token and return its type. Fill *VALUE with its value, if
287 applicable. Fill *CPP_FLAGS with the token's flags, if it is
291 c_lex_with_flags (tree
*value
, location_t
*loc
, unsigned char *cpp_flags
,
294 static bool no_more_pch
;
295 const cpp_token
*tok
;
297 unsigned char add_flags
= 0;
298 enum overflow_type overflow
= OT_NONE
;
300 timevar_push (TV_CPP
);
302 tok
= cpp_get_token_with_location (parse_in
, loc
);
312 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
.node
));
317 const char *suffix
= NULL
;
318 unsigned int flags
= cpp_classify_number (parse_in
, tok
, &suffix
, *loc
);
320 switch (flags
& CPP_N_CATEGORY
)
323 /* cpplib has issued an error. */
324 *value
= error_mark_node
;
328 /* C++ uses '0' to mark virtual functions as pure.
329 Set PURE_ZERO to pass this information to the C++ parser. */
330 if (tok
->val
.str
.len
== 1 && *tok
->val
.str
.text
== '0')
331 add_flags
= PURE_ZERO
;
332 *value
= interpret_integer (tok
, flags
, &overflow
);
336 *value
= interpret_float (tok
, flags
, suffix
, &overflow
);
343 if (flags
& CPP_N_USERDEF
)
347 tree suffix_id
= get_identifier (suffix
);
348 int len
= tok
->val
.str
.len
- strlen (suffix
);
349 /* If this is going to be used as a C string to pass to a
350 raw literal operator, we need to add a trailing NUL. */
351 tree num_string
= build_string (len
+ 1,
352 (const char *) tok
->val
.str
.text
);
353 TREE_TYPE (num_string
) = char_array_type_node
;
354 num_string
= fix_string_type (num_string
);
355 str
= CONST_CAST (char *, TREE_STRING_POINTER (num_string
));
357 literal
= build_userdef_literal (suffix_id
, *value
, overflow
,
365 /* An @ may give the next token special significance in Objective-C. */
366 if (c_dialect_objc ())
368 location_t atloc
= *loc
;
372 tok
= cpp_get_token_with_location (parse_in
, &newloc
);
384 type
= lex_string (tok
, value
, true, true);
388 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
.node
));
389 if (OBJC_IS_AT_KEYWORD (C_RID_CODE (*value
))
390 || OBJC_IS_CXX_KEYWORD (C_RID_CODE (*value
)))
393 /* Note the complication: if we found an OBJC_CXX
394 keyword, for example, 'class', we will be
395 returning a token of type CPP_AT_NAME and rid
396 code RID_CLASS (not RID_AT_CLASS). The language
397 parser needs to convert that to RID_AT_CLASS.
405 error_at (atloc
, "stray %<@%> in program");
416 unsigned char name
[8];
418 *cpp_spell_token (parse_in
, tok
, name
, true) = 0;
420 error_at (*loc
, "stray %qs in program", name
);
427 cppchar_t c
= tok
->val
.str
.text
[0];
429 if (c
== '"' || c
== '\'')
430 error ("missing terminating %c character", (int) c
);
431 else if (ISGRAPH (c
))
432 error ("stray %qc in program", (int) c
);
434 error ("stray %<\\%o%> in program", (int) c
);
438 case CPP_CHAR_USERDEF
:
439 case CPP_WCHAR_USERDEF
:
440 case CPP_CHAR16_USERDEF
:
441 case CPP_CHAR32_USERDEF
:
444 cpp_token temp_tok
= *tok
;
445 const char *suffix
= cpp_get_userdef_suffix (tok
);
446 temp_tok
.val
.str
.len
-= strlen (suffix
);
447 temp_tok
.type
= cpp_userdef_char_remove_type (type
);
448 literal
= build_userdef_literal (get_identifier (suffix
),
449 lex_charconst (&temp_tok
),
459 *value
= lex_charconst (tok
);
462 case CPP_STRING_USERDEF
:
463 case CPP_WSTRING_USERDEF
:
464 case CPP_STRING16_USERDEF
:
465 case CPP_STRING32_USERDEF
:
466 case CPP_UTF8STRING_USERDEF
:
468 tree literal
, string
;
469 const char *suffix
= cpp_get_userdef_suffix (tok
);
470 string
= build_string (tok
->val
.str
.len
- strlen (suffix
),
471 (const char *) tok
->val
.str
.text
);
472 literal
= build_userdef_literal (get_identifier (suffix
),
473 string
, OT_NONE
, NULL_TREE
);
483 if ((lex_flags
& C_LEX_STRING_NO_JOIN
) == 0)
485 type
= lex_string (tok
, value
, false,
486 (lex_flags
& C_LEX_STRING_NO_TRANSLATE
) == 0);
489 *value
= build_string (tok
->val
.str
.len
, (const char *) tok
->val
.str
.text
);
493 *value
= build_int_cst (integer_type_node
, tok
->val
.pragma
);
496 /* These tokens should not be visible outside cpplib. */
497 case CPP_HEADER_NAME
:
501 /* CPP_COMMENT will appear when compiling with -C and should be
512 *cpp_flags
= tok
->flags
| add_flags
;
517 c_common_no_more_pch ();
520 timevar_pop (TV_CPP
);
525 /* Returns the narrowest C-visible unsigned type, starting with the
526 minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
529 static enum integer_type_kind
530 narrowest_unsigned_type (unsigned HOST_WIDE_INT low
,
531 unsigned HOST_WIDE_INT high
,
536 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
537 itk
= itk_unsigned_int
;
538 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
539 itk
= itk_unsigned_long
;
541 itk
= itk_unsigned_long_long
;
543 for (; itk
< itk_none
; itk
+= 2 /* skip unsigned types */)
547 if (integer_types
[itk
] == NULL_TREE
)
549 upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
551 if ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) > high
552 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) == high
553 && TREE_INT_CST_LOW (upper
) >= low
))
554 return (enum integer_type_kind
) itk
;
560 /* Ditto, but narrowest signed type. */
561 static enum integer_type_kind
562 narrowest_signed_type (unsigned HOST_WIDE_INT low
,
563 unsigned HOST_WIDE_INT high
, unsigned int flags
)
567 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
569 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
575 for (; itk
< itk_none
; itk
+= 2 /* skip signed types */)
579 if (integer_types
[itk
] == NULL_TREE
)
581 upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
583 if ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) > high
584 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) == high
585 && TREE_INT_CST_LOW (upper
) >= low
))
586 return (enum integer_type_kind
) itk
;
592 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
594 interpret_integer (const cpp_token
*token
, unsigned int flags
,
595 enum overflow_type
*overflow
)
598 enum integer_type_kind itk
;
600 cpp_options
*options
= cpp_get_options (parse_in
);
604 integer
= cpp_interpret_integer (parse_in
, token
, flags
);
605 integer
= cpp_num_sign_extend (integer
, options
->precision
);
606 if (integer
.overflow
)
607 *overflow
= OT_OVERFLOW
;
609 /* The type of a constant with a U suffix is straightforward. */
610 if (flags
& CPP_N_UNSIGNED
)
611 itk
= narrowest_unsigned_type (integer
.low
, integer
.high
, flags
);
614 /* The type of a potentially-signed integer constant varies
615 depending on the base it's in, the standard in use, and the
617 enum integer_type_kind itk_u
618 = narrowest_unsigned_type (integer
.low
, integer
.high
, flags
);
619 enum integer_type_kind itk_s
620 = narrowest_signed_type (integer
.low
, integer
.high
, flags
);
622 /* In both C89 and C99, octal and hex constants may be signed or
623 unsigned, whichever fits tighter. We do not warn about this
624 choice differing from the traditional choice, as the constant
625 is probably a bit pattern and either way will work. */
626 if ((flags
& CPP_N_RADIX
) != CPP_N_DECIMAL
)
627 itk
= MIN (itk_u
, itk_s
);
630 /* In C99, decimal constants are always signed.
631 In C89, decimal constants that don't fit in long have
632 undefined behavior; we try to make them unsigned long.
633 In GCC's extended C89, that last is true of decimal
634 constants that don't fit in long long, too. */
637 if (itk_s
> itk_u
&& itk_s
> itk_long
)
641 if (itk_u
< itk_unsigned_long
)
642 itk_u
= itk_unsigned_long
;
644 warning (0, "this decimal constant is unsigned only in ISO C90");
647 warning (OPT_Wtraditional
,
648 "this decimal constant would be unsigned in ISO C90");
654 /* cpplib has already issued a warning for overflow. */
655 type
= ((flags
& CPP_N_UNSIGNED
)
656 ? widest_unsigned_literal_type_node
657 : widest_integer_literal_type_node
);
660 type
= integer_types
[itk
];
661 if (itk
> itk_unsigned_long
662 && (flags
& CPP_N_WIDTH
) != CPP_N_LARGE
)
664 ((c_dialect_cxx () ? cxx_dialect
== cxx98
: !flag_isoc99
)
665 ? DK_PEDWARN
: DK_WARNING
,
666 input_location
, OPT_Wlong_long
,
667 (flags
& CPP_N_UNSIGNED
)
668 ? "integer constant is too large for %<unsigned long%> type"
669 : "integer constant is too large for %<long%> type");
672 value
= build_int_cst_wide (type
, integer
.low
, integer
.high
);
674 /* Convert imaginary to a complex type. */
675 if (flags
& CPP_N_IMAGINARY
)
676 value
= build_complex (NULL_TREE
, build_int_cst (type
, 0), value
);
681 /* Interpret TOKEN, a floating point number with FLAGS as classified
682 by cpplib. For C++0X SUFFIX may contain a user-defined literal suffix. */
684 interpret_float (const cpp_token
*token
, unsigned int flags
,
685 const char *suffix
, enum overflow_type
*overflow
)
690 REAL_VALUE_TYPE real
;
691 REAL_VALUE_TYPE real_trunc
;
697 /* Default (no suffix) depends on whether the FLOAT_CONST_DECIMAL64
698 pragma has been used and is either double or _Decimal64. Types
699 that are not allowed with decimal float default to double. */
700 if (flags
& CPP_N_DEFAULT
)
702 flags
^= CPP_N_DEFAULT
;
703 flags
|= CPP_N_MEDIUM
;
705 if (((flags
& CPP_N_HEX
) == 0) && ((flags
& CPP_N_IMAGINARY
) == 0))
707 warning (OPT_Wunsuffixed_float_constants
,
708 "unsuffixed float constant");
709 if (float_const_decimal64_p ())
710 flags
|= CPP_N_DFLOAT
;
714 /* Decode _Fract and _Accum. */
715 if (flags
& CPP_N_FRACT
|| flags
& CPP_N_ACCUM
)
716 return interpret_fixed (token
, flags
);
718 /* Decode type based on width and properties. */
719 if (flags
& CPP_N_DFLOAT
)
720 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
721 type
= dfloat128_type_node
;
722 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
723 type
= dfloat32_type_node
;
725 type
= dfloat64_type_node
;
727 if (flags
& CPP_N_WIDTH_MD
)
730 enum machine_mode mode
;
732 if ((flags
& CPP_N_WIDTH_MD
) == CPP_N_MD_W
)
737 mode
= targetm
.c
.mode_for_suffix (suffix
);
738 if (mode
== VOIDmode
)
740 error ("unsupported non-standard suffix on floating constant");
742 return error_mark_node
;
745 pedwarn (input_location
, OPT_Wpedantic
, "non-standard suffix on floating constant");
747 type
= c_common_type_for_mode (mode
, 0);
750 else if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
751 type
= long_double_type_node
;
752 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
753 || flag_single_precision_constant
)
754 type
= float_type_node
;
756 type
= double_type_node
;
758 const_type
= excess_precision_type (type
);
762 /* Copy the constant to a nul-terminated buffer. If the constant
763 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
764 can't handle them. */
765 copylen
= token
->val
.str
.len
;
766 if (flags
& CPP_N_USERDEF
)
767 copylen
-= strlen (suffix
);
768 else if (flags
& CPP_N_DFLOAT
)
772 if ((flags
& CPP_N_WIDTH
) != CPP_N_MEDIUM
)
773 /* Must be an F or L or machine defined suffix. */
775 if (flags
& CPP_N_IMAGINARY
)
780 copy
= (char *) alloca (copylen
+ 1);
781 memcpy (copy
, token
->val
.str
.text
, copylen
);
782 copy
[copylen
] = '\0';
784 real_from_string3 (&real
, copy
, TYPE_MODE (const_type
));
785 if (const_type
!= type
)
786 /* Diagnosing if the result of converting the value with excess
787 precision to the semantic type would overflow (with associated
788 double rounding) is more appropriate than diagnosing if the
789 result of converting the string directly to the semantic type
791 real_convert (&real_trunc
, TYPE_MODE (type
), &real
);
793 /* Both C and C++ require a diagnostic for a floating constant
794 outside the range of representable values of its type. Since we
795 have __builtin_inf* to produce an infinity, this is now a
796 mandatory pedwarn if the target does not support infinities. */
797 if (REAL_VALUE_ISINF (real
)
798 || (const_type
!= type
&& REAL_VALUE_ISINF (real_trunc
)))
800 *overflow
= OT_OVERFLOW
;
801 if (!(flags
& CPP_N_USERDEF
))
803 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)))
804 pedwarn (input_location
, 0,
805 "floating constant exceeds range of %qT", type
);
807 warning (OPT_Woverflow
,
808 "floating constant exceeds range of %qT", type
);
811 /* We also give a warning if the value underflows. */
812 else if (REAL_VALUES_EQUAL (real
, dconst0
)
813 || (const_type
!= type
814 && REAL_VALUES_EQUAL (real_trunc
, dconst0
)))
816 REAL_VALUE_TYPE realvoidmode
;
817 int oflow
= real_from_string (&realvoidmode
, copy
);
818 *overflow
= (oflow
== 0 ? OT_NONE
819 : (oflow
< 0 ? OT_UNDERFLOW
: OT_OVERFLOW
));
820 if (!(flags
& CPP_N_USERDEF
))
822 if (oflow
< 0 || !REAL_VALUES_EQUAL (realvoidmode
, dconst0
))
823 warning (OPT_Woverflow
, "floating constant truncated to zero");
827 /* Create a node with determined type and value. */
828 value
= build_real (const_type
, real
);
829 if (flags
& CPP_N_IMAGINARY
)
831 value
= build_complex (NULL_TREE
, convert (const_type
,
832 integer_zero_node
), value
);
833 if (type
!= const_type
)
835 const_type
= TREE_TYPE (value
);
836 type
= build_complex_type (type
);
840 if (type
!= const_type
)
841 value
= build1 (EXCESS_PRECISION_EXPR
, type
, value
);
846 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
850 interpret_fixed (const cpp_token
*token
, unsigned int flags
)
854 FIXED_VALUE_TYPE fixed
;
858 copylen
= token
->val
.str
.len
;
860 if (flags
& CPP_N_FRACT
) /* _Fract. */
862 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Fract. */
864 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
866 type
= unsigned_long_long_fract_type_node
;
869 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
871 type
= unsigned_long_fract_type_node
;
874 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
876 type
= unsigned_short_fract_type_node
;
881 type
= unsigned_fract_type_node
;
885 else /* Signed _Fract. */
887 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
889 type
= long_long_fract_type_node
;
892 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
894 type
= long_fract_type_node
;
897 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
899 type
= short_fract_type_node
;
904 type
= fract_type_node
;
911 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Accum. */
913 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
915 type
= unsigned_long_long_accum_type_node
;
918 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
920 type
= unsigned_long_accum_type_node
;
923 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
925 type
= unsigned_short_accum_type_node
;
930 type
= unsigned_accum_type_node
;
934 else /* Signed _Accum. */
936 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
938 type
= long_long_accum_type_node
;
941 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
943 type
= long_accum_type_node
;
946 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
948 type
= short_accum_type_node
;
953 type
= accum_type_node
;
959 copy
= (char *) alloca (copylen
+ 1);
960 memcpy (copy
, token
->val
.str
.text
, copylen
);
961 copy
[copylen
] = '\0';
963 fixed_from_string (&fixed
, copy
, TYPE_MODE (type
));
965 /* Create a node with determined type and value. */
966 value
= build_fixed (type
, fixed
);
971 /* Convert a series of STRING, WSTRING, STRING16, STRING32 and/or
972 UTF8STRING tokens into a tree, performing string constant
973 concatenation. TOK is the first of these. VALP is the location to
974 write the string into. OBJC_STRING indicates whether an '@' token
975 preceded the incoming token (in that case, the strings can either
976 be ObjC strings, preceded by a single '@', or normal strings, not
977 preceded by '@'. The result will be a CPP_OBJC_STRING). Returns
978 the CPP token type of the result (CPP_STRING, CPP_WSTRING,
979 CPP_STRING32, CPP_STRING16, CPP_UTF8STRING, or CPP_OBJC_STRING).
981 This is unfortunately more work than it should be. If any of the
982 strings in the series has an L prefix, the result is a wide string
983 (6.4.5p4). Whether or not the result is a wide string affects the
984 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
985 sequences do not continue across the boundary between two strings in
986 a series (6.4.5p7), so we must not lose the boundaries. Therefore
987 cpp_interpret_string takes a vector of cpp_string structures, which
988 we must arrange to provide. */
990 static enum cpp_ttype
991 lex_string (const cpp_token
*tok
, tree
*valp
, bool objc_string
, bool translate
)
995 struct obstack str_ob
;
997 enum cpp_ttype type
= tok
->type
;
999 /* Try to avoid the overhead of creating and destroying an obstack
1000 for the common case of just one string. */
1001 cpp_string str
= tok
->val
.str
;
1002 cpp_string
*strs
= &str
;
1004 /* objc_at_sign_was_seen is only used when doing Objective-C string
1005 concatenation. It is 'true' if we have seen an '@' before the
1006 current string, and 'false' if not. We must see exactly one or
1007 zero '@' before each string. */
1008 bool objc_at_sign_was_seen
= false;
1011 tok
= cpp_get_token (parse_in
);
1019 if (objc_at_sign_was_seen
)
1020 error ("repeated %<@%> before Objective-C string");
1022 objc_at_sign_was_seen
= true;
1033 case CPP_UTF8STRING
:
1034 if (type
!= tok
->type
)
1036 if (type
== CPP_STRING
)
1039 error ("unsupported non-standard concatenation of string literals");
1045 gcc_obstack_init (&str_ob
);
1046 obstack_grow (&str_ob
, &str
, sizeof (cpp_string
));
1050 obstack_grow (&str_ob
, &tok
->val
.str
, sizeof (cpp_string
));
1052 objc_at_sign_was_seen
= false;
1056 /* It is an error if we saw a '@' with no following string. */
1057 if (objc_at_sign_was_seen
)
1058 error ("stray %<@%> in program");
1060 /* We have read one more token than we want. */
1061 _cpp_backup_tokens (parse_in
, 1);
1063 strs
= XOBFINISH (&str_ob
, cpp_string
*);
1065 if (concats
&& !objc_string
&& !in_system_header
)
1066 warning (OPT_Wtraditional
,
1067 "traditional C rejects string constant concatenation");
1070 ? cpp_interpret_string
: cpp_interpret_string_notranslate
)
1071 (parse_in
, strs
, concats
+ 1, &istr
, type
))
1073 value
= build_string (istr
.len
, (const char *) istr
.text
);
1074 free (CONST_CAST (unsigned char *, istr
.text
));
1078 /* Callers cannot generally handle error_mark_node in this context,
1079 so return the empty string instead. cpp_interpret_string has
1085 case CPP_UTF8STRING
:
1086 value
= build_string (1, "");
1089 value
= build_string (TYPE_PRECISION (char16_type_node
)
1090 / TYPE_PRECISION (char_type_node
),
1091 "\0"); /* char16_t is 16 bits */
1094 value
= build_string (TYPE_PRECISION (char32_type_node
)
1095 / TYPE_PRECISION (char_type_node
),
1096 "\0\0\0"); /* char32_t is 32 bits */
1099 value
= build_string (TYPE_PRECISION (wchar_type_node
)
1100 / TYPE_PRECISION (char_type_node
),
1101 "\0\0\0"); /* widest supported wchar_t
1111 case CPP_UTF8STRING
:
1112 TREE_TYPE (value
) = char_array_type_node
;
1115 TREE_TYPE (value
) = char16_array_type_node
;
1118 TREE_TYPE (value
) = char32_array_type_node
;
1121 TREE_TYPE (value
) = wchar_array_type_node
;
1123 *valp
= fix_string_type (value
);
1126 obstack_free (&str_ob
, 0);
1128 return objc_string
? CPP_OBJC_STRING
: type
;
1131 /* Converts a (possibly wide) character constant token into a tree. */
1133 lex_charconst (const cpp_token
*token
)
1137 unsigned int chars_seen
;
1140 result
= cpp_interpret_charconst (parse_in
, token
,
1141 &chars_seen
, &unsignedp
);
1143 if (token
->type
== CPP_WCHAR
)
1144 type
= wchar_type_node
;
1145 else if (token
->type
== CPP_CHAR32
)
1146 type
= char32_type_node
;
1147 else if (token
->type
== CPP_CHAR16
)
1148 type
= char16_type_node
;
1149 /* In C, a character constant has type 'int'.
1150 In C++ 'char', but multi-char charconsts have type 'int'. */
1151 else if (!c_dialect_cxx () || chars_seen
> 1)
1152 type
= integer_type_node
;
1154 type
= char_type_node
;
1156 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1157 before possibly widening to HOST_WIDE_INT for build_int_cst. */
1158 if (unsignedp
|| (cppchar_signed_t
) result
>= 0)
1159 value
= build_int_cst_wide (type
, result
, 0);
1161 value
= build_int_cst_wide (type
, (cppchar_signed_t
) result
, -1);