1 /* Mainly the interface between cpplib and the C front ends.
2 Copyright (C) 1987-2015 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
27 #include "stringpool.h"
28 #include "stor-layout.h"
35 #include "splay-tree.h"
41 /* We may keep statistics about how long which files took to compile. */
42 static int header_time
, body_time
;
43 static splay_tree file_info_tree
;
45 int pending_lang_change
; /* If we need to switch languages - C++ only */
46 int c_header_level
; /* depth in C headers - C++ only */
48 static tree
interpret_integer (const cpp_token
*, unsigned int,
49 enum overflow_type
*);
50 static tree
interpret_float (const cpp_token
*, unsigned int, const char *,
51 enum overflow_type
*);
52 static tree
interpret_fixed (const cpp_token
*, unsigned int);
53 static enum integer_type_kind narrowest_unsigned_type
54 (const widest_int
&, unsigned int);
55 static enum integer_type_kind narrowest_signed_type
56 (const widest_int
&, unsigned int);
57 static enum cpp_ttype
lex_string (const cpp_token
*, tree
*, bool, bool);
58 static tree
lex_charconst (const cpp_token
*);
59 static void update_header_times (const char *);
60 static int dump_one_header (splay_tree_node
, void *);
61 static void cb_line_change (cpp_reader
*, const cpp_token
*, int);
62 static void cb_ident (cpp_reader
*, unsigned int, const cpp_string
*);
63 static void cb_def_pragma (cpp_reader
*, unsigned int);
64 static void cb_define (cpp_reader
*, unsigned int, cpp_hashnode
*);
65 static void cb_undef (cpp_reader
*, unsigned int, cpp_hashnode
*);
70 struct cpp_callbacks
*cb
;
71 struct c_fileinfo
*toplevel
;
73 /* The get_fileinfo data structure must be initialized before
74 cpp_read_main_file is called. */
75 toplevel
= get_fileinfo ("<top level>");
76 if (flag_detailed_statistics
)
79 body_time
= get_run_time ();
80 toplevel
->time
= body_time
;
83 cb
= cpp_get_callbacks (parse_in
);
85 cb
->line_change
= cb_line_change
;
87 cb
->def_pragma
= cb_def_pragma
;
88 cb
->valid_pch
= c_common_valid_pch
;
89 cb
->read_pch
= c_common_read_pch
;
90 cb
->has_attribute
= c_common_has_attribute
;
92 /* Set the debug callbacks if we can use them. */
93 if ((debug_info_level
== DINFO_LEVEL_VERBOSE
94 && (write_symbols
== DWARF2_DEBUG
95 || write_symbols
== VMS_AND_DWARF2_DEBUG
))
96 || flag_dump_go_spec
!= NULL
)
98 cb
->define
= cb_define
;
104 get_fileinfo (const char *name
)
107 struct c_fileinfo
*fi
;
110 file_info_tree
= splay_tree_new ((splay_tree_compare_fn
) strcmp
,
112 (splay_tree_delete_value_fn
) free
);
114 n
= splay_tree_lookup (file_info_tree
, (splay_tree_key
) name
);
116 return (struct c_fileinfo
*) n
->value
;
118 fi
= XNEW (struct c_fileinfo
);
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
);
128 update_header_times (const char *name
)
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
)
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
;
143 dump_one_header (splay_tree_node n
, void * ARG_UNUSED (dummy
))
145 print_time ((const char *) n
->key
,
146 ((struct c_fileinfo
*) n
->value
)->time
);
151 dump_time_statistics (void)
153 struct c_fileinfo
*file
= get_fileinfo (LOCATION_FILE (input_location
));
154 int this_time
= get_run_time ();
155 file
->time
+= this_time
- body_time
;
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");
164 splay_tree_foreach (file_info_tree
, dump_one_header
, 0);
168 cb_ident (cpp_reader
* ARG_UNUSED (pfile
),
169 unsigned int ARG_UNUSED (line
),
170 const cpp_string
* ARG_UNUSED (str
))
174 /* Convert escapes in the string. */
175 cpp_string cstr
= { 0, 0 };
176 if (cpp_interpret_string (pfile
, str
, 1, &cstr
, CPP_STRING
))
178 targetm
.asm_out
.output_ident ((const char *) cstr
.text
);
179 free (CONST_CAST (unsigned char *, cstr
.text
));
184 /* Called at the start of every non-empty line. TOKEN is the first
185 lexed token on the line. Used for diagnostic line numbers. */
187 cb_line_change (cpp_reader
* ARG_UNUSED (pfile
), const cpp_token
*token
,
190 if (token
->type
!= CPP_EOF
&& !parsing_args
)
191 input_location
= token
->src_loc
;
195 fe_file_change (const line_map_ordinary
*new_map
)
200 if (new_map
->reason
== LC_ENTER
)
202 /* Don't stack the main buffer on the input stack;
203 we already did in compile_file. */
204 if (!MAIN_FILE_P (new_map
))
206 unsigned int included_at
= LAST_SOURCE_LINE_LOCATION (new_map
- 1);
208 if (included_at
> BUILTINS_LOCATION
)
209 line
= SOURCE_LINE (new_map
- 1, included_at
);
211 input_location
= new_map
->start_location
;
212 (*debug_hooks
->start_source_file
) (line
, LINEMAP_FILE (new_map
));
213 #ifndef NO_IMPLICIT_EXTERN_C
216 else if (LINEMAP_SYSP (new_map
) == 2)
219 ++pending_lang_change
;
224 else if (new_map
->reason
== LC_LEAVE
)
226 #ifndef NO_IMPLICIT_EXTERN_C
227 if (c_header_level
&& --c_header_level
== 0)
229 if (LINEMAP_SYSP (new_map
) == 2)
230 warning (0, "badly nested C headers from preprocessor");
231 --pending_lang_change
;
234 input_location
= new_map
->start_location
;
236 (*debug_hooks
->end_source_file
) (LINEMAP_LINE (new_map
));
239 update_header_times (LINEMAP_FILE (new_map
));
240 input_location
= new_map
->start_location
;
244 cb_def_pragma (cpp_reader
*pfile
, source_location loc
)
246 /* Issue a warning message if we have been asked to do so. Ignore
247 unknown pragmas in system headers unless an explicit
248 -Wunknown-pragmas has been given. */
249 if (warn_unknown_pragmas
> in_system_header_at (input_location
))
251 const unsigned char *space
, *name
;
253 location_t fe_loc
= loc
;
255 space
= name
= (const unsigned char *) "";
256 s
= cpp_get_token (pfile
);
257 if (s
->type
!= CPP_EOF
)
259 space
= cpp_token_as_text (pfile
, s
);
260 s
= cpp_get_token (pfile
);
261 if (s
->type
== CPP_NAME
)
262 name
= cpp_token_as_text (pfile
, s
);
265 warning_at (fe_loc
, OPT_Wunknown_pragmas
, "ignoring #pragma %s %s",
270 /* #define callback for DWARF and DWARF2 debug info. */
272 cb_define (cpp_reader
*pfile
, source_location loc
, cpp_hashnode
*node
)
274 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
275 (*debug_hooks
->define
) (SOURCE_LINE (linemap_check_ordinary (map
), loc
),
276 (const char *) cpp_macro_definition (pfile
, node
));
279 /* #undef callback for DWARF and DWARF2 debug info. */
281 cb_undef (cpp_reader
* ARG_UNUSED (pfile
), source_location loc
,
284 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
285 (*debug_hooks
->undef
) (SOURCE_LINE (linemap_check_ordinary (map
), loc
),
286 (const char *) NODE_NAME (node
));
289 /* Wrapper around cpp_get_token to skip CPP_PADDING tokens
290 and not consume CPP_EOF. */
291 static const cpp_token
*
292 get_token_no_padding (cpp_reader
*pfile
)
296 const cpp_token
*ret
= cpp_peek_token (pfile
, 0);
297 if (ret
->type
== CPP_EOF
)
299 ret
= cpp_get_token (pfile
);
300 if (ret
->type
!= CPP_PADDING
)
305 /* Callback for has_attribute. */
307 c_common_has_attribute (cpp_reader
*pfile
)
310 tree attr_name
= NULL_TREE
;
311 const cpp_token
*token
;
313 token
= get_token_no_padding (pfile
);
314 if (token
->type
!= CPP_OPEN_PAREN
)
316 cpp_error (pfile
, CPP_DL_ERROR
,
317 "missing '(' after \"__has_attribute\"");
320 token
= get_token_no_padding (pfile
);
321 if (token
->type
== CPP_NAME
)
323 attr_name
= get_identifier ((const char *)
324 cpp_token_as_text (pfile
, token
));
325 if (c_dialect_cxx ())
328 const cpp_token
*nxt_token
;
330 nxt_token
= cpp_peek_token (pfile
, idx
++);
331 while (nxt_token
->type
== CPP_PADDING
);
332 if (nxt_token
->type
== CPP_SCOPE
)
334 get_token_no_padding (pfile
); // Eat scope.
335 nxt_token
= get_token_no_padding (pfile
);
336 if (nxt_token
->type
== CPP_NAME
)
338 tree attr_ns
= attr_name
;
340 = get_identifier ((const char *)
341 cpp_token_as_text (pfile
, nxt_token
));
342 attr_name
= build_tree_list (attr_ns
, attr_id
);
346 cpp_error (pfile
, CPP_DL_ERROR
,
347 "attribute identifier required after scope");
348 attr_name
= NULL_TREE
;
355 const struct attribute_spec
*attr
= lookup_attribute_spec (attr_name
);
358 if (TREE_CODE (attr_name
) == TREE_LIST
)
359 attr_name
= TREE_VALUE (attr_name
);
360 if (is_attribute_p ("noreturn", attr_name
))
362 else if (is_attribute_p ("deprecated", attr_name
))
371 cpp_error (pfile
, CPP_DL_ERROR
,
372 "macro \"__has_attribute\" requires an identifier");
376 if (get_token_no_padding (pfile
)->type
!= CPP_CLOSE_PAREN
)
377 cpp_error (pfile
, CPP_DL_ERROR
,
378 "missing ')' after \"__has_attribute\"");
383 /* Read a token and return its type. Fill *VALUE with its value, if
384 applicable. Fill *CPP_FLAGS with the token's flags, if it is
388 c_lex_with_flags (tree
*value
, location_t
*loc
, unsigned char *cpp_flags
,
391 static bool no_more_pch
;
392 const cpp_token
*tok
;
394 unsigned char add_flags
= 0;
395 enum overflow_type overflow
= OT_NONE
;
397 timevar_push (TV_CPP
);
399 tok
= cpp_get_token_with_location (parse_in
, loc
);
409 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
.node
));
414 const char *suffix
= NULL
;
415 unsigned int flags
= cpp_classify_number (parse_in
, tok
, &suffix
, *loc
);
417 switch (flags
& CPP_N_CATEGORY
)
420 /* cpplib has issued an error. */
421 *value
= error_mark_node
;
425 /* C++ uses '0' to mark virtual functions as pure.
426 Set PURE_ZERO to pass this information to the C++ parser. */
427 if (tok
->val
.str
.len
== 1 && *tok
->val
.str
.text
== '0')
428 add_flags
= PURE_ZERO
;
429 *value
= interpret_integer (tok
, flags
, &overflow
);
433 *value
= interpret_float (tok
, flags
, suffix
, &overflow
);
440 if (flags
& CPP_N_USERDEF
)
444 tree suffix_id
= get_identifier (suffix
);
445 int len
= tok
->val
.str
.len
- strlen (suffix
);
446 /* If this is going to be used as a C string to pass to a
447 raw literal operator, we need to add a trailing NUL. */
448 tree num_string
= build_string (len
+ 1,
449 (const char *) tok
->val
.str
.text
);
450 TREE_TYPE (num_string
) = char_array_type_node
;
451 num_string
= fix_string_type (num_string
);
452 str
= CONST_CAST (char *, TREE_STRING_POINTER (num_string
));
454 literal
= build_userdef_literal (suffix_id
, *value
, overflow
,
462 /* An @ may give the next token special significance in Objective-C. */
463 if (c_dialect_objc ())
465 location_t atloc
= *loc
;
469 tok
= cpp_get_token_with_location (parse_in
, &newloc
);
481 type
= lex_string (tok
, value
, true, true);
485 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
.node
));
486 if (OBJC_IS_AT_KEYWORD (C_RID_CODE (*value
))
487 || OBJC_IS_CXX_KEYWORD (C_RID_CODE (*value
)))
490 /* Note the complication: if we found an OBJC_CXX
491 keyword, for example, 'class', we will be
492 returning a token of type CPP_AT_NAME and rid
493 code RID_CLASS (not RID_AT_CLASS). The language
494 parser needs to convert that to RID_AT_CLASS.
502 error_at (atloc
, "stray %<@%> in program");
513 unsigned char name
[8];
515 *cpp_spell_token (parse_in
, tok
, name
, true) = 0;
517 error_at (*loc
, "stray %qs in program", name
);
524 cppchar_t c
= tok
->val
.str
.text
[0];
526 if (c
== '"' || c
== '\'')
527 error ("missing terminating %c character", (int) c
);
528 else if (ISGRAPH (c
))
529 error ("stray %qc in program", (int) c
);
531 error ("stray %<\\%o%> in program", (int) c
);
535 case CPP_CHAR_USERDEF
:
536 case CPP_WCHAR_USERDEF
:
537 case CPP_CHAR16_USERDEF
:
538 case CPP_CHAR32_USERDEF
:
539 case CPP_UTF8CHAR_USERDEF
:
542 cpp_token temp_tok
= *tok
;
543 const char *suffix
= cpp_get_userdef_suffix (tok
);
544 temp_tok
.val
.str
.len
-= strlen (suffix
);
545 temp_tok
.type
= cpp_userdef_char_remove_type (type
);
546 literal
= build_userdef_literal (get_identifier (suffix
),
547 lex_charconst (&temp_tok
),
558 *value
= lex_charconst (tok
);
561 case CPP_STRING_USERDEF
:
562 case CPP_WSTRING_USERDEF
:
563 case CPP_STRING16_USERDEF
:
564 case CPP_STRING32_USERDEF
:
565 case CPP_UTF8STRING_USERDEF
:
567 tree literal
, string
;
568 const char *suffix
= cpp_get_userdef_suffix (tok
);
569 string
= build_string (tok
->val
.str
.len
- strlen (suffix
),
570 (const char *) tok
->val
.str
.text
);
571 literal
= build_userdef_literal (get_identifier (suffix
),
572 string
, OT_NONE
, NULL_TREE
);
582 if ((lex_flags
& C_LEX_STRING_NO_JOIN
) == 0)
584 type
= lex_string (tok
, value
, false,
585 (lex_flags
& C_LEX_STRING_NO_TRANSLATE
) == 0);
588 *value
= build_string (tok
->val
.str
.len
, (const char *) tok
->val
.str
.text
);
592 *value
= build_int_cst (integer_type_node
, tok
->val
.pragma
);
595 /* These tokens should not be visible outside cpplib. */
596 case CPP_HEADER_NAME
:
600 /* CPP_COMMENT will appear when compiling with -C and should be
611 *cpp_flags
= tok
->flags
| add_flags
;
616 c_common_no_more_pch ();
619 timevar_pop (TV_CPP
);
624 /* Returns the narrowest C-visible unsigned type, starting with the
625 minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
628 static enum integer_type_kind
629 narrowest_unsigned_type (const widest_int
&val
, unsigned int flags
)
633 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
634 itk
= itk_unsigned_int
;
635 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
636 itk
= itk_unsigned_long
;
638 itk
= itk_unsigned_long_long
;
640 for (; itk
< itk_none
; itk
+= 2 /* skip unsigned types */)
644 if (integer_types
[itk
] == NULL_TREE
)
646 upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
648 if (wi::geu_p (wi::to_widest (upper
), val
))
649 return (enum integer_type_kind
) itk
;
655 /* Ditto, but narrowest signed type. */
656 static enum integer_type_kind
657 narrowest_signed_type (const widest_int
&val
, unsigned int flags
)
661 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
663 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
668 for (; itk
< itk_none
; itk
+= 2 /* skip signed types */)
672 if (integer_types
[itk
] == NULL_TREE
)
674 upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
676 if (wi::geu_p (wi::to_widest (upper
), val
))
677 return (enum integer_type_kind
) itk
;
683 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
685 interpret_integer (const cpp_token
*token
, unsigned int flags
,
686 enum overflow_type
*overflow
)
689 enum integer_type_kind itk
;
691 HOST_WIDE_INT ival
[3];
695 integer
= cpp_interpret_integer (parse_in
, token
, flags
);
696 if (integer
.overflow
)
697 *overflow
= OT_OVERFLOW
;
699 ival
[0] = integer
.low
;
700 ival
[1] = integer
.high
;
702 widest_int wval
= widest_int::from_array (ival
, 3);
704 /* The type of a constant with a U suffix is straightforward. */
705 if (flags
& CPP_N_UNSIGNED
)
706 itk
= narrowest_unsigned_type (wval
, flags
);
709 /* The type of a potentially-signed integer constant varies
710 depending on the base it's in, the standard in use, and the
712 enum integer_type_kind itk_u
713 = narrowest_unsigned_type (wval
, flags
);
714 enum integer_type_kind itk_s
715 = narrowest_signed_type (wval
, flags
);
717 /* In both C89 and C99, octal and hex constants may be signed or
718 unsigned, whichever fits tighter. We do not warn about this
719 choice differing from the traditional choice, as the constant
720 is probably a bit pattern and either way will work. */
721 if ((flags
& CPP_N_RADIX
) != CPP_N_DECIMAL
)
722 itk
= MIN (itk_u
, itk_s
);
725 /* In C99, decimal constants are always signed.
726 In C89, decimal constants that don't fit in long have
727 undefined behavior; we try to make them unsigned long.
728 In GCC's extended C89, that last is true of decimal
729 constants that don't fit in long long, too. */
732 if (itk_s
> itk_u
&& itk_s
> itk_long
)
736 if (itk_u
< itk_unsigned_long
)
737 itk_u
= itk_unsigned_long
;
739 warning (0, "this decimal constant is unsigned only in ISO C90");
742 warning (OPT_Wtraditional
,
743 "this decimal constant would be unsigned in ISO C90");
749 /* cpplib has already issued a warning for overflow. */
750 type
= ((flags
& CPP_N_UNSIGNED
)
751 ? widest_unsigned_literal_type_node
752 : widest_integer_literal_type_node
);
755 type
= integer_types
[itk
];
756 if (itk
> itk_unsigned_long
757 && (flags
& CPP_N_WIDTH
) != CPP_N_LARGE
)
759 ((c_dialect_cxx () ? cxx_dialect
== cxx98
: !flag_isoc99
)
760 ? DK_PEDWARN
: DK_WARNING
,
761 input_location
, OPT_Wlong_long
,
762 (flags
& CPP_N_UNSIGNED
)
763 ? "integer constant is too large for %<unsigned long%> type"
764 : "integer constant is too large for %<long%> type");
767 value
= wide_int_to_tree (type
, wval
);
769 /* Convert imaginary to a complex type. */
770 if (flags
& CPP_N_IMAGINARY
)
771 value
= build_complex (NULL_TREE
, build_int_cst (type
, 0), value
);
776 /* Interpret TOKEN, a floating point number with FLAGS as classified
777 by cpplib. For C++0X SUFFIX may contain a user-defined literal suffix. */
779 interpret_float (const cpp_token
*token
, unsigned int flags
,
780 const char *suffix
, enum overflow_type
*overflow
)
785 REAL_VALUE_TYPE real
;
786 REAL_VALUE_TYPE real_trunc
;
792 /* Default (no suffix) depends on whether the FLOAT_CONST_DECIMAL64
793 pragma has been used and is either double or _Decimal64. Types
794 that are not allowed with decimal float default to double. */
795 if (flags
& CPP_N_DEFAULT
)
797 flags
^= CPP_N_DEFAULT
;
798 flags
|= CPP_N_MEDIUM
;
800 if (((flags
& CPP_N_HEX
) == 0) && ((flags
& CPP_N_IMAGINARY
) == 0))
802 warning (OPT_Wunsuffixed_float_constants
,
803 "unsuffixed float constant");
804 if (float_const_decimal64_p ())
805 flags
|= CPP_N_DFLOAT
;
809 /* Decode _Fract and _Accum. */
810 if (flags
& CPP_N_FRACT
|| flags
& CPP_N_ACCUM
)
811 return interpret_fixed (token
, flags
);
813 /* Decode type based on width and properties. */
814 if (flags
& CPP_N_DFLOAT
)
815 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
816 type
= dfloat128_type_node
;
817 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
818 type
= dfloat32_type_node
;
820 type
= dfloat64_type_node
;
822 if (flags
& CPP_N_WIDTH_MD
)
827 if ((flags
& CPP_N_WIDTH_MD
) == CPP_N_MD_W
)
832 mode
= targetm
.c
.mode_for_suffix (suffix
);
833 if (mode
== VOIDmode
)
835 error ("unsupported non-standard suffix on floating constant");
837 return error_mark_node
;
840 pedwarn (input_location
, OPT_Wpedantic
, "non-standard suffix on floating constant");
842 type
= c_common_type_for_mode (mode
, 0);
845 else if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
846 type
= long_double_type_node
;
847 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
848 || flag_single_precision_constant
)
849 type
= float_type_node
;
851 type
= double_type_node
;
853 const_type
= excess_precision_type (type
);
857 /* Copy the constant to a nul-terminated buffer. If the constant
858 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
859 can't handle them. */
860 copylen
= token
->val
.str
.len
;
861 if (flags
& CPP_N_USERDEF
)
862 copylen
-= strlen (suffix
);
863 else if (flags
& CPP_N_DFLOAT
)
867 if ((flags
& CPP_N_WIDTH
) != CPP_N_MEDIUM
)
868 /* Must be an F or L or machine defined suffix. */
870 if (flags
& CPP_N_IMAGINARY
)
875 copy
= (char *) alloca (copylen
+ 1);
876 if (cxx_dialect
> cxx11
)
879 for (size_t i
= 0; i
< copylen
; ++i
)
880 if (token
->val
.str
.text
[i
] != '\'')
881 copy
[maxlen
++] = token
->val
.str
.text
[i
];
886 memcpy (copy
, token
->val
.str
.text
, copylen
);
887 copy
[copylen
] = '\0';
890 real_from_string3 (&real
, copy
, TYPE_MODE (const_type
));
891 if (const_type
!= type
)
892 /* Diagnosing if the result of converting the value with excess
893 precision to the semantic type would overflow (with associated
894 double rounding) is more appropriate than diagnosing if the
895 result of converting the string directly to the semantic type
897 real_convert (&real_trunc
, TYPE_MODE (type
), &real
);
899 /* Both C and C++ require a diagnostic for a floating constant
900 outside the range of representable values of its type. Since we
901 have __builtin_inf* to produce an infinity, this is now a
902 mandatory pedwarn if the target does not support infinities. */
903 if (REAL_VALUE_ISINF (real
)
904 || (const_type
!= type
&& REAL_VALUE_ISINF (real_trunc
)))
906 *overflow
= OT_OVERFLOW
;
907 if (!(flags
& CPP_N_USERDEF
))
909 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)))
910 pedwarn (input_location
, 0,
911 "floating constant exceeds range of %qT", type
);
913 warning (OPT_Woverflow
,
914 "floating constant exceeds range of %qT", type
);
917 /* We also give a warning if the value underflows. */
918 else if (REAL_VALUES_EQUAL (real
, dconst0
)
919 || (const_type
!= type
920 && REAL_VALUES_EQUAL (real_trunc
, dconst0
)))
922 REAL_VALUE_TYPE realvoidmode
;
923 int oflow
= real_from_string (&realvoidmode
, copy
);
924 *overflow
= (oflow
== 0 ? OT_NONE
925 : (oflow
< 0 ? OT_UNDERFLOW
: OT_OVERFLOW
));
926 if (!(flags
& CPP_N_USERDEF
))
928 if (oflow
< 0 || !REAL_VALUES_EQUAL (realvoidmode
, dconst0
))
929 warning (OPT_Woverflow
, "floating constant truncated to zero");
933 /* Create a node with determined type and value. */
934 value
= build_real (const_type
, real
);
935 if (flags
& CPP_N_IMAGINARY
)
937 value
= build_complex (NULL_TREE
, convert (const_type
,
938 integer_zero_node
), value
);
939 if (type
!= const_type
)
941 const_type
= TREE_TYPE (value
);
942 type
= build_complex_type (type
);
946 if (type
!= const_type
)
947 value
= build1 (EXCESS_PRECISION_EXPR
, type
, value
);
952 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
956 interpret_fixed (const cpp_token
*token
, unsigned int flags
)
960 FIXED_VALUE_TYPE fixed
;
964 copylen
= token
->val
.str
.len
;
966 if (flags
& CPP_N_FRACT
) /* _Fract. */
968 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Fract. */
970 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
972 type
= unsigned_long_long_fract_type_node
;
975 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
977 type
= unsigned_long_fract_type_node
;
980 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
982 type
= unsigned_short_fract_type_node
;
987 type
= unsigned_fract_type_node
;
991 else /* Signed _Fract. */
993 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
995 type
= long_long_fract_type_node
;
998 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1000 type
= long_fract_type_node
;
1003 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1005 type
= short_fract_type_node
;
1010 type
= fract_type_node
;
1017 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Accum. */
1019 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1021 type
= unsigned_long_long_accum_type_node
;
1024 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1026 type
= unsigned_long_accum_type_node
;
1029 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1031 type
= unsigned_short_accum_type_node
;
1036 type
= unsigned_accum_type_node
;
1040 else /* Signed _Accum. */
1042 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1044 type
= long_long_accum_type_node
;
1047 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1049 type
= long_accum_type_node
;
1052 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1054 type
= short_accum_type_node
;
1059 type
= accum_type_node
;
1065 copy
= (char *) alloca (copylen
+ 1);
1066 memcpy (copy
, token
->val
.str
.text
, copylen
);
1067 copy
[copylen
] = '\0';
1069 fixed_from_string (&fixed
, copy
, TYPE_MODE (type
));
1071 /* Create a node with determined type and value. */
1072 value
= build_fixed (type
, fixed
);
1077 /* Convert a series of STRING, WSTRING, STRING16, STRING32 and/or
1078 UTF8STRING tokens into a tree, performing string constant
1079 concatenation. TOK is the first of these. VALP is the location to
1080 write the string into. OBJC_STRING indicates whether an '@' token
1081 preceded the incoming token (in that case, the strings can either
1082 be ObjC strings, preceded by a single '@', or normal strings, not
1083 preceded by '@'. The result will be a CPP_OBJC_STRING). Returns
1084 the CPP token type of the result (CPP_STRING, CPP_WSTRING,
1085 CPP_STRING32, CPP_STRING16, CPP_UTF8STRING, or CPP_OBJC_STRING).
1087 This is unfortunately more work than it should be. If any of the
1088 strings in the series has an L prefix, the result is a wide string
1089 (6.4.5p4). Whether or not the result is a wide string affects the
1090 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
1091 sequences do not continue across the boundary between two strings in
1092 a series (6.4.5p7), so we must not lose the boundaries. Therefore
1093 cpp_interpret_string takes a vector of cpp_string structures, which
1094 we must arrange to provide. */
1096 static enum cpp_ttype
1097 lex_string (const cpp_token
*tok
, tree
*valp
, bool objc_string
, bool translate
)
1101 struct obstack str_ob
;
1103 enum cpp_ttype type
= tok
->type
;
1105 /* Try to avoid the overhead of creating and destroying an obstack
1106 for the common case of just one string. */
1107 cpp_string str
= tok
->val
.str
;
1108 cpp_string
*strs
= &str
;
1110 /* objc_at_sign_was_seen is only used when doing Objective-C string
1111 concatenation. It is 'true' if we have seen an '@' before the
1112 current string, and 'false' if not. We must see exactly one or
1113 zero '@' before each string. */
1114 bool objc_at_sign_was_seen
= false;
1117 tok
= cpp_get_token (parse_in
);
1125 if (objc_at_sign_was_seen
)
1126 error ("repeated %<@%> before Objective-C string");
1128 objc_at_sign_was_seen
= true;
1139 case CPP_UTF8STRING
:
1140 if (type
!= tok
->type
)
1142 if (type
== CPP_STRING
)
1145 error ("unsupported non-standard concatenation of string literals");
1151 gcc_obstack_init (&str_ob
);
1152 obstack_grow (&str_ob
, &str
, sizeof (cpp_string
));
1156 obstack_grow (&str_ob
, &tok
->val
.str
, sizeof (cpp_string
));
1158 objc_at_sign_was_seen
= false;
1162 /* It is an error if we saw a '@' with no following string. */
1163 if (objc_at_sign_was_seen
)
1164 error ("stray %<@%> in program");
1166 /* We have read one more token than we want. */
1167 _cpp_backup_tokens (parse_in
, 1);
1169 strs
= XOBFINISH (&str_ob
, cpp_string
*);
1171 if (concats
&& !objc_string
&& !in_system_header_at (input_location
))
1172 warning (OPT_Wtraditional
,
1173 "traditional C rejects string constant concatenation");
1176 ? cpp_interpret_string
: cpp_interpret_string_notranslate
)
1177 (parse_in
, strs
, concats
+ 1, &istr
, type
))
1179 value
= build_string (istr
.len
, (const char *) istr
.text
);
1180 free (CONST_CAST (unsigned char *, istr
.text
));
1184 /* Callers cannot generally handle error_mark_node in this context,
1185 so return the empty string instead. cpp_interpret_string has
1191 case CPP_UTF8STRING
:
1192 value
= build_string (1, "");
1195 value
= build_string (TYPE_PRECISION (char16_type_node
)
1196 / TYPE_PRECISION (char_type_node
),
1197 "\0"); /* char16_t is 16 bits */
1200 value
= build_string (TYPE_PRECISION (char32_type_node
)
1201 / TYPE_PRECISION (char_type_node
),
1202 "\0\0\0"); /* char32_t is 32 bits */
1205 value
= build_string (TYPE_PRECISION (wchar_type_node
)
1206 / TYPE_PRECISION (char_type_node
),
1207 "\0\0\0"); /* widest supported wchar_t
1217 case CPP_UTF8STRING
:
1218 TREE_TYPE (value
) = char_array_type_node
;
1221 TREE_TYPE (value
) = char16_array_type_node
;
1224 TREE_TYPE (value
) = char32_array_type_node
;
1227 TREE_TYPE (value
) = wchar_array_type_node
;
1229 *valp
= fix_string_type (value
);
1232 obstack_free (&str_ob
, 0);
1234 return objc_string
? CPP_OBJC_STRING
: type
;
1237 /* Converts a (possibly wide) character constant token into a tree. */
1239 lex_charconst (const cpp_token
*token
)
1243 unsigned int chars_seen
;
1246 result
= cpp_interpret_charconst (parse_in
, token
,
1247 &chars_seen
, &unsignedp
);
1249 if (token
->type
== CPP_WCHAR
)
1250 type
= wchar_type_node
;
1251 else if (token
->type
== CPP_CHAR32
)
1252 type
= char32_type_node
;
1253 else if (token
->type
== CPP_CHAR16
)
1254 type
= char16_type_node
;
1255 else if (token
->type
== CPP_UTF8CHAR
)
1256 type
= char_type_node
;
1257 /* In C, a character constant has type 'int'.
1258 In C++ 'char', but multi-char charconsts have type 'int'. */
1259 else if (!c_dialect_cxx () || chars_seen
> 1)
1260 type
= integer_type_node
;
1262 type
= char_type_node
;
1264 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1265 before possibly widening to HOST_WIDE_INT for build_int_cst. */
1266 if (unsignedp
|| (cppchar_signed_t
) result
>= 0)
1267 value
= build_int_cst (type
, result
);
1269 value
= build_int_cst (type
, (cppchar_signed_t
) result
);