1 /* Mainly the interface between cpplib and the C front ends.
2 Copyright (C) 1987-2017 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"
26 #include "stringpool.h"
27 #include "stor-layout.h"
33 /* We may keep statistics about how long which files took to compile. */
34 static int header_time
, body_time
;
35 static splay_tree file_info_tree
;
37 int pending_lang_change
; /* If we need to switch languages - C++ only */
38 int c_header_level
; /* depth in C headers - C++ only */
40 static tree
interpret_integer (const cpp_token
*, unsigned int,
41 enum overflow_type
*);
42 static tree
interpret_float (const cpp_token
*, unsigned int, const char *,
43 enum overflow_type
*);
44 static tree
interpret_fixed (const cpp_token
*, unsigned int);
45 static enum integer_type_kind narrowest_unsigned_type
46 (const widest_int
&, unsigned int);
47 static enum integer_type_kind narrowest_signed_type
48 (const widest_int
&, unsigned int);
49 static enum cpp_ttype
lex_string (const cpp_token
*, tree
*, bool, bool);
50 static tree
lex_charconst (const cpp_token
*);
51 static void update_header_times (const char *);
52 static int dump_one_header (splay_tree_node
, void *);
53 static void cb_line_change (cpp_reader
*, const cpp_token
*, int);
54 static void cb_ident (cpp_reader
*, unsigned int, const cpp_string
*);
55 static void cb_def_pragma (cpp_reader
*, unsigned int);
56 static void cb_define (cpp_reader
*, unsigned int, cpp_hashnode
*);
57 static void cb_undef (cpp_reader
*, unsigned int, cpp_hashnode
*);
62 struct cpp_callbacks
*cb
;
63 struct c_fileinfo
*toplevel
;
65 /* The get_fileinfo data structure must be initialized before
66 cpp_read_main_file is called. */
67 toplevel
= get_fileinfo ("<top level>");
68 if (flag_detailed_statistics
)
71 body_time
= get_run_time ();
72 toplevel
->time
= body_time
;
75 cb
= cpp_get_callbacks (parse_in
);
77 cb
->line_change
= cb_line_change
;
79 cb
->def_pragma
= cb_def_pragma
;
80 cb
->valid_pch
= c_common_valid_pch
;
81 cb
->read_pch
= c_common_read_pch
;
82 cb
->has_attribute
= c_common_has_attribute
;
83 cb
->get_source_date_epoch
= cb_get_source_date_epoch
;
84 cb
->get_suggestion
= cb_get_suggestion
;
86 /* Set the debug callbacks if we can use them. */
87 if ((debug_info_level
== DINFO_LEVEL_VERBOSE
88 && (write_symbols
== DWARF2_DEBUG
89 || write_symbols
== VMS_AND_DWARF2_DEBUG
))
90 || flag_dump_go_spec
!= NULL
)
92 cb
->define
= cb_define
;
98 get_fileinfo (const char *name
)
101 struct c_fileinfo
*fi
;
104 file_info_tree
= splay_tree_new ((splay_tree_compare_fn
) strcmp
,
106 (splay_tree_delete_value_fn
) free
);
108 n
= splay_tree_lookup (file_info_tree
, (splay_tree_key
) name
);
110 return (struct c_fileinfo
*) n
->value
;
112 fi
= XNEW (struct c_fileinfo
);
114 fi
->interface_only
= 0;
115 fi
->interface_unknown
= 1;
116 splay_tree_insert (file_info_tree
, (splay_tree_key
) name
,
117 (splay_tree_value
) fi
);
122 update_header_times (const char *name
)
124 /* Changing files again. This means currently collected time
125 is charged against header time, and body time starts back at 0. */
126 if (flag_detailed_statistics
)
128 int this_time
= get_run_time ();
129 struct c_fileinfo
*file
= get_fileinfo (name
);
130 header_time
+= this_time
- body_time
;
131 file
->time
+= this_time
- body_time
;
132 body_time
= this_time
;
137 dump_one_header (splay_tree_node n
, void * ARG_UNUSED (dummy
))
139 print_time ((const char *) n
->key
,
140 ((struct c_fileinfo
*) n
->value
)->time
);
145 dump_time_statistics (void)
147 struct c_fileinfo
*file
= get_fileinfo (LOCATION_FILE (input_location
));
148 int this_time
= get_run_time ();
149 file
->time
+= this_time
- body_time
;
151 fprintf (stderr
, "\n******\n");
152 print_time ("header files (total)", header_time
);
153 print_time ("main file (total)", this_time
- body_time
);
154 fprintf (stderr
, "ratio = %g : 1\n",
155 (double) header_time
/ (double) (this_time
- body_time
));
156 fprintf (stderr
, "\n******\n");
158 splay_tree_foreach (file_info_tree
, dump_one_header
, 0);
162 cb_ident (cpp_reader
* ARG_UNUSED (pfile
),
163 unsigned int ARG_UNUSED (line
),
164 const cpp_string
* ARG_UNUSED (str
))
168 /* Convert escapes in the string. */
169 cpp_string cstr
= { 0, 0 };
170 if (cpp_interpret_string (pfile
, str
, 1, &cstr
, CPP_STRING
))
172 targetm
.asm_out
.output_ident ((const char *) cstr
.text
);
173 free (CONST_CAST (unsigned char *, cstr
.text
));
178 /* Called at the start of every non-empty line. TOKEN is the first
179 lexed token on the line. Used for diagnostic line numbers. */
181 cb_line_change (cpp_reader
* ARG_UNUSED (pfile
), const cpp_token
*token
,
184 if (token
->type
!= CPP_EOF
&& !parsing_args
)
185 input_location
= token
->src_loc
;
189 fe_file_change (const line_map_ordinary
*new_map
)
194 if (new_map
->reason
== LC_ENTER
)
196 /* Don't stack the main buffer on the input stack;
197 we already did in compile_file. */
198 if (!MAIN_FILE_P (new_map
))
200 unsigned int included_at
= LAST_SOURCE_LINE_LOCATION (new_map
- 1);
202 if (included_at
> BUILTINS_LOCATION
)
203 line
= SOURCE_LINE (new_map
- 1, included_at
);
205 input_location
= new_map
->start_location
;
206 (*debug_hooks
->start_source_file
) (line
, LINEMAP_FILE (new_map
));
207 #ifndef NO_IMPLICIT_EXTERN_C
210 else if (LINEMAP_SYSP (new_map
) == 2)
213 ++pending_lang_change
;
218 else if (new_map
->reason
== LC_LEAVE
)
220 #ifndef NO_IMPLICIT_EXTERN_C
221 if (c_header_level
&& --c_header_level
== 0)
223 if (LINEMAP_SYSP (new_map
) == 2)
224 warning (0, "badly nested C headers from preprocessor");
225 --pending_lang_change
;
228 input_location
= new_map
->start_location
;
230 (*debug_hooks
->end_source_file
) (LINEMAP_LINE (new_map
));
233 update_header_times (LINEMAP_FILE (new_map
));
234 input_location
= new_map
->start_location
;
238 cb_def_pragma (cpp_reader
*pfile
, source_location loc
)
240 /* Issue a warning message if we have been asked to do so. Ignore
241 unknown pragmas in system headers unless an explicit
242 -Wunknown-pragmas has been given. */
243 if (warn_unknown_pragmas
> in_system_header_at (input_location
))
245 const unsigned char *space
, *name
;
247 location_t fe_loc
= loc
;
249 space
= name
= (const unsigned char *) "";
250 s
= cpp_get_token (pfile
);
251 if (s
->type
!= CPP_EOF
)
253 space
= cpp_token_as_text (pfile
, s
);
254 s
= cpp_get_token (pfile
);
255 if (s
->type
== CPP_NAME
)
256 name
= cpp_token_as_text (pfile
, s
);
259 warning_at (fe_loc
, OPT_Wunknown_pragmas
, "ignoring #pragma %s %s",
264 /* #define callback for DWARF and DWARF2 debug info. */
266 cb_define (cpp_reader
*pfile
, source_location loc
, cpp_hashnode
*node
)
268 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
269 (*debug_hooks
->define
) (SOURCE_LINE (linemap_check_ordinary (map
), loc
),
270 (const char *) cpp_macro_definition (pfile
, node
));
273 /* #undef callback for DWARF and DWARF2 debug info. */
275 cb_undef (cpp_reader
* ARG_UNUSED (pfile
), source_location loc
,
278 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
279 (*debug_hooks
->undef
) (SOURCE_LINE (linemap_check_ordinary (map
), loc
),
280 (const char *) NODE_NAME (node
));
283 /* Wrapper around cpp_get_token to skip CPP_PADDING tokens
284 and not consume CPP_EOF. */
285 static const cpp_token
*
286 get_token_no_padding (cpp_reader
*pfile
)
290 const cpp_token
*ret
= cpp_peek_token (pfile
, 0);
291 if (ret
->type
== CPP_EOF
)
293 ret
= cpp_get_token (pfile
);
294 if (ret
->type
!= CPP_PADDING
)
299 /* Callback for has_attribute. */
301 c_common_has_attribute (cpp_reader
*pfile
)
304 tree attr_name
= NULL_TREE
;
305 const cpp_token
*token
;
307 token
= get_token_no_padding (pfile
);
308 if (token
->type
!= CPP_OPEN_PAREN
)
310 cpp_error (pfile
, CPP_DL_ERROR
,
311 "missing '(' after \"__has_attribute\"");
314 token
= get_token_no_padding (pfile
);
315 if (token
->type
== CPP_NAME
)
317 attr_name
= get_identifier ((const char *)
318 cpp_token_as_text (pfile
, token
));
319 attr_name
= canonicalize_attr_name (attr_name
);
320 if (c_dialect_cxx ())
323 const cpp_token
*nxt_token
;
325 nxt_token
= cpp_peek_token (pfile
, idx
++);
326 while (nxt_token
->type
== CPP_PADDING
);
327 if (nxt_token
->type
== CPP_SCOPE
)
329 get_token_no_padding (pfile
); // Eat scope.
330 nxt_token
= get_token_no_padding (pfile
);
331 if (nxt_token
->type
== CPP_NAME
)
333 tree attr_ns
= attr_name
;
335 = get_identifier ((const char *)
336 cpp_token_as_text (pfile
, nxt_token
));
337 attr_name
= build_tree_list (attr_ns
, attr_id
);
341 cpp_error (pfile
, CPP_DL_ERROR
,
342 "attribute identifier required after scope");
343 attr_name
= NULL_TREE
;
348 /* Some standard attributes need special handling. */
349 if (is_attribute_p ("noreturn", attr_name
))
351 else if (is_attribute_p ("deprecated", attr_name
))
353 else if (is_attribute_p ("maybe_unused", attr_name
)
354 || is_attribute_p ("nodiscard", attr_name
)
355 || is_attribute_p ("fallthrough", attr_name
))
358 attr_name
= NULL_TREE
;
364 const struct attribute_spec
*attr
= lookup_attribute_spec (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_at (*loc
, "missing terminating %c character", (int) c
);
528 else if (ISGRAPH (c
))
529 error_at (*loc
, "stray %qc in program", (int) c
);
531 error_at (*loc
, "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. Ignore, except
601 when it is a FALLTHROUGH comment, in that case set
602 PREV_FALLTHROUGH flag on the next non-comment token. */
604 if (tok
->flags
& PREV_FALLTHROUGH
)
608 tok
= cpp_get_token_with_location (parse_in
, loc
);
611 while (type
== CPP_PADDING
|| type
== CPP_COMMENT
);
612 add_flags
|= PREV_FALLTHROUGH
;
623 *cpp_flags
= tok
->flags
| add_flags
;
628 c_common_no_more_pch ();
631 timevar_pop (TV_CPP
);
636 /* Returns the narrowest C-visible unsigned type, starting with the
637 minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
640 static enum integer_type_kind
641 narrowest_unsigned_type (const widest_int
&val
, unsigned int flags
)
645 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
646 itk
= itk_unsigned_int
;
647 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
648 itk
= itk_unsigned_long
;
650 itk
= itk_unsigned_long_long
;
652 for (; itk
< itk_none
; itk
+= 2 /* skip unsigned types */)
656 if (integer_types
[itk
] == NULL_TREE
)
658 upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
660 if (wi::geu_p (wi::to_widest (upper
), val
))
661 return (enum integer_type_kind
) itk
;
667 /* Ditto, but narrowest signed type. */
668 static enum integer_type_kind
669 narrowest_signed_type (const widest_int
&val
, unsigned int flags
)
673 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
675 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
680 for (; itk
< itk_none
; itk
+= 2 /* skip signed types */)
684 if (integer_types
[itk
] == NULL_TREE
)
686 upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
688 if (wi::geu_p (wi::to_widest (upper
), val
))
689 return (enum integer_type_kind
) itk
;
695 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
697 interpret_integer (const cpp_token
*token
, unsigned int flags
,
698 enum overflow_type
*overflow
)
701 enum integer_type_kind itk
;
703 HOST_WIDE_INT ival
[3];
707 integer
= cpp_interpret_integer (parse_in
, token
, flags
);
708 if (integer
.overflow
)
709 *overflow
= OT_OVERFLOW
;
711 ival
[0] = integer
.low
;
712 ival
[1] = integer
.high
;
714 widest_int wval
= widest_int::from_array (ival
, 3);
716 /* The type of a constant with a U suffix is straightforward. */
717 if (flags
& CPP_N_UNSIGNED
)
718 itk
= narrowest_unsigned_type (wval
, flags
);
721 /* The type of a potentially-signed integer constant varies
722 depending on the base it's in, the standard in use, and the
724 enum integer_type_kind itk_u
725 = narrowest_unsigned_type (wval
, flags
);
726 enum integer_type_kind itk_s
727 = narrowest_signed_type (wval
, flags
);
729 /* In both C89 and C99, octal and hex constants may be signed or
730 unsigned, whichever fits tighter. We do not warn about this
731 choice differing from the traditional choice, as the constant
732 is probably a bit pattern and either way will work. */
733 if ((flags
& CPP_N_RADIX
) != CPP_N_DECIMAL
)
734 itk
= MIN (itk_u
, itk_s
);
737 /* In C99, decimal constants are always signed.
738 In C89, decimal constants that don't fit in long have
739 undefined behavior; we try to make them unsigned long.
740 In GCC's extended C89, that last is true of decimal
741 constants that don't fit in long long, too. */
744 if (itk_s
> itk_u
&& itk_s
> itk_long
)
748 if (itk_u
< itk_unsigned_long
)
749 itk_u
= itk_unsigned_long
;
751 warning (0, "this decimal constant is unsigned only in ISO C90");
754 warning (OPT_Wtraditional
,
755 "this decimal constant would be unsigned in ISO C90");
761 /* cpplib has already issued a warning for overflow. */
762 type
= ((flags
& CPP_N_UNSIGNED
)
763 ? widest_unsigned_literal_type_node
764 : widest_integer_literal_type_node
);
767 type
= integer_types
[itk
];
768 if (itk
> itk_unsigned_long
769 && (flags
& CPP_N_WIDTH
) != CPP_N_LARGE
)
771 ((c_dialect_cxx () ? cxx_dialect
== cxx98
: !flag_isoc99
)
772 ? DK_PEDWARN
: DK_WARNING
,
773 input_location
, OPT_Wlong_long
,
774 (flags
& CPP_N_UNSIGNED
)
775 ? "integer constant is too large for %<unsigned long%> type"
776 : "integer constant is too large for %<long%> type");
779 value
= wide_int_to_tree (type
, wval
);
781 /* Convert imaginary to a complex type. */
782 if (flags
& CPP_N_IMAGINARY
)
783 value
= build_complex (NULL_TREE
, build_int_cst (type
, 0), value
);
788 /* Interpret TOKEN, a floating point number with FLAGS as classified
789 by cpplib. For C++11 SUFFIX may contain a user-defined literal suffix. */
791 interpret_float (const cpp_token
*token
, unsigned int flags
,
792 const char *suffix
, enum overflow_type
*overflow
)
797 REAL_VALUE_TYPE real
;
798 REAL_VALUE_TYPE real_trunc
;
804 /* Default (no suffix) depends on whether the FLOAT_CONST_DECIMAL64
805 pragma has been used and is either double or _Decimal64. Types
806 that are not allowed with decimal float default to double. */
807 if (flags
& CPP_N_DEFAULT
)
809 flags
^= CPP_N_DEFAULT
;
810 flags
|= CPP_N_MEDIUM
;
812 if (((flags
& CPP_N_HEX
) == 0) && ((flags
& CPP_N_IMAGINARY
) == 0))
814 warning (OPT_Wunsuffixed_float_constants
,
815 "unsuffixed float constant");
816 if (float_const_decimal64_p ())
817 flags
|= CPP_N_DFLOAT
;
821 /* Decode _Fract and _Accum. */
822 if (flags
& CPP_N_FRACT
|| flags
& CPP_N_ACCUM
)
823 return interpret_fixed (token
, flags
);
825 /* Decode type based on width and properties. */
826 if (flags
& CPP_N_DFLOAT
)
827 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
828 type
= dfloat128_type_node
;
829 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
830 type
= dfloat32_type_node
;
832 type
= dfloat64_type_node
;
834 if (flags
& CPP_N_WIDTH_MD
)
839 if ((flags
& CPP_N_WIDTH_MD
) == CPP_N_MD_W
)
844 mode
= targetm
.c
.mode_for_suffix (suffix
);
845 if (mode
== VOIDmode
)
847 error ("unsupported non-standard suffix on floating constant");
849 return error_mark_node
;
852 pedwarn (input_location
, OPT_Wpedantic
, "non-standard suffix on floating constant");
854 type
= c_common_type_for_mode (mode
, 0);
857 else if ((flags
& (CPP_N_FLOATN
| CPP_N_FLOATNX
)) != 0)
859 unsigned int n
= (flags
& CPP_N_WIDTH_FLOATN_NX
) >> CPP_FLOATN_SHIFT
;
860 bool extended
= (flags
& CPP_N_FLOATNX
) != 0;
862 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
863 if (floatn_nx_types
[i
].n
== (int) n
864 && floatn_nx_types
[i
].extended
== extended
)
866 type
= FLOATN_NX_TYPE_NODE (i
);
869 if (type
== NULL_TREE
)
871 error ("unsupported non-standard suffix on floating constant");
872 return error_mark_node
;
875 pedwarn (input_location
, OPT_Wpedantic
, "non-standard suffix on floating constant");
877 else if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
878 type
= long_double_type_node
;
879 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
880 || flag_single_precision_constant
)
881 type
= float_type_node
;
883 type
= double_type_node
;
885 const_type
= excess_precision_type (type
);
889 /* Copy the constant to a nul-terminated buffer. If the constant
890 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
891 can't handle them. */
892 copylen
= token
->val
.str
.len
;
893 if (flags
& CPP_N_USERDEF
)
894 copylen
-= strlen (suffix
);
895 else if (flags
& CPP_N_DFLOAT
)
899 if ((flags
& CPP_N_WIDTH
) != CPP_N_MEDIUM
)
900 /* Must be an F or L or machine defined suffix. */
902 if (flags
& CPP_N_IMAGINARY
)
905 if (flags
& CPP_N_FLOATNX
)
907 if (flags
& (CPP_N_FLOATN
| CPP_N_FLOATNX
))
909 unsigned int n
= (flags
& CPP_N_WIDTH_FLOATN_NX
) >> CPP_FLOATN_SHIFT
;
918 copy
= (char *) alloca (copylen
+ 1);
919 if (cxx_dialect
> cxx11
)
922 for (size_t i
= 0; i
< copylen
; ++i
)
923 if (token
->val
.str
.text
[i
] != '\'')
924 copy
[maxlen
++] = token
->val
.str
.text
[i
];
929 memcpy (copy
, token
->val
.str
.text
, copylen
);
930 copy
[copylen
] = '\0';
933 real_from_string3 (&real
, copy
, TYPE_MODE (const_type
));
934 if (const_type
!= type
)
935 /* Diagnosing if the result of converting the value with excess
936 precision to the semantic type would overflow (with associated
937 double rounding) is more appropriate than diagnosing if the
938 result of converting the string directly to the semantic type
940 real_convert (&real_trunc
, TYPE_MODE (type
), &real
);
942 /* Both C and C++ require a diagnostic for a floating constant
943 outside the range of representable values of its type. Since we
944 have __builtin_inf* to produce an infinity, this is now a
945 mandatory pedwarn if the target does not support infinities. */
946 if (REAL_VALUE_ISINF (real
)
947 || (const_type
!= type
&& REAL_VALUE_ISINF (real_trunc
)))
949 *overflow
= OT_OVERFLOW
;
950 if (!(flags
& CPP_N_USERDEF
))
952 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)))
953 pedwarn (input_location
, 0,
954 "floating constant exceeds range of %qT", type
);
956 warning (OPT_Woverflow
,
957 "floating constant exceeds range of %qT", type
);
960 /* We also give a warning if the value underflows. */
961 else if (real_equal (&real
, &dconst0
)
962 || (const_type
!= type
963 && real_equal (&real_trunc
, &dconst0
)))
965 REAL_VALUE_TYPE realvoidmode
;
966 int oflow
= real_from_string (&realvoidmode
, copy
);
967 *overflow
= (oflow
== 0 ? OT_NONE
968 : (oflow
< 0 ? OT_UNDERFLOW
: OT_OVERFLOW
));
969 if (!(flags
& CPP_N_USERDEF
))
971 if (oflow
< 0 || !real_equal (&realvoidmode
, &dconst0
))
972 warning (OPT_Woverflow
, "floating constant truncated to zero");
976 /* Create a node with determined type and value. */
977 value
= build_real (const_type
, real
);
978 if (flags
& CPP_N_IMAGINARY
)
980 value
= build_complex (NULL_TREE
,
981 fold_convert (const_type
,
982 integer_zero_node
), value
);
983 if (type
!= const_type
)
985 const_type
= TREE_TYPE (value
);
986 type
= build_complex_type (type
);
990 if (type
!= const_type
)
991 value
= build1_loc (token
->src_loc
, EXCESS_PRECISION_EXPR
, type
, value
);
996 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
1000 interpret_fixed (const cpp_token
*token
, unsigned int flags
)
1004 FIXED_VALUE_TYPE fixed
;
1008 copylen
= token
->val
.str
.len
;
1010 if (flags
& CPP_N_FRACT
) /* _Fract. */
1012 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Fract. */
1014 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1016 type
= unsigned_long_long_fract_type_node
;
1019 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1021 type
= unsigned_long_fract_type_node
;
1024 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1026 type
= unsigned_short_fract_type_node
;
1031 type
= unsigned_fract_type_node
;
1035 else /* Signed _Fract. */
1037 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1039 type
= long_long_fract_type_node
;
1042 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1044 type
= long_fract_type_node
;
1047 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1049 type
= short_fract_type_node
;
1054 type
= fract_type_node
;
1061 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Accum. */
1063 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1065 type
= unsigned_long_long_accum_type_node
;
1068 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1070 type
= unsigned_long_accum_type_node
;
1073 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1075 type
= unsigned_short_accum_type_node
;
1080 type
= unsigned_accum_type_node
;
1084 else /* Signed _Accum. */
1086 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1088 type
= long_long_accum_type_node
;
1091 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1093 type
= long_accum_type_node
;
1096 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1098 type
= short_accum_type_node
;
1103 type
= accum_type_node
;
1109 copy
= (char *) alloca (copylen
+ 1);
1110 memcpy (copy
, token
->val
.str
.text
, copylen
);
1111 copy
[copylen
] = '\0';
1113 fixed_from_string (&fixed
, copy
, SCALAR_TYPE_MODE (type
));
1115 /* Create a node with determined type and value. */
1116 value
= build_fixed (type
, fixed
);
1121 /* Convert a series of STRING, WSTRING, STRING16, STRING32 and/or
1122 UTF8STRING tokens into a tree, performing string constant
1123 concatenation. TOK is the first of these. VALP is the location to
1124 write the string into. OBJC_STRING indicates whether an '@' token
1125 preceded the incoming token (in that case, the strings can either
1126 be ObjC strings, preceded by a single '@', or normal strings, not
1127 preceded by '@'. The result will be a CPP_OBJC_STRING). Returns
1128 the CPP token type of the result (CPP_STRING, CPP_WSTRING,
1129 CPP_STRING32, CPP_STRING16, CPP_UTF8STRING, or CPP_OBJC_STRING).
1131 This is unfortunately more work than it should be. If any of the
1132 strings in the series has an L prefix, the result is a wide string
1133 (6.4.5p4). Whether or not the result is a wide string affects the
1134 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
1135 sequences do not continue across the boundary between two strings in
1136 a series (6.4.5p7), so we must not lose the boundaries. Therefore
1137 cpp_interpret_string takes a vector of cpp_string structures, which
1138 we must arrange to provide. */
1140 static enum cpp_ttype
1141 lex_string (const cpp_token
*tok
, tree
*valp
, bool objc_string
, bool translate
)
1145 struct obstack str_ob
;
1146 struct obstack loc_ob
;
1148 enum cpp_ttype type
= tok
->type
;
1150 /* Try to avoid the overhead of creating and destroying an obstack
1151 for the common case of just one string. */
1152 cpp_string str
= tok
->val
.str
;
1153 location_t init_loc
= tok
->src_loc
;
1154 cpp_string
*strs
= &str
;
1155 location_t
*locs
= NULL
;
1157 /* objc_at_sign_was_seen is only used when doing Objective-C string
1158 concatenation. It is 'true' if we have seen an '@' before the
1159 current string, and 'false' if not. We must see exactly one or
1160 zero '@' before each string. */
1161 bool objc_at_sign_was_seen
= false;
1164 tok
= cpp_get_token (parse_in
);
1172 if (objc_at_sign_was_seen
)
1173 error ("repeated %<@%> before Objective-C string");
1175 objc_at_sign_was_seen
= true;
1186 case CPP_UTF8STRING
:
1187 if (type
!= tok
->type
)
1189 if (type
== CPP_STRING
)
1192 error ("unsupported non-standard concatenation of string literals");
1199 gcc_obstack_init (&str_ob
);
1200 gcc_obstack_init (&loc_ob
);
1201 obstack_grow (&str_ob
, &str
, sizeof (cpp_string
));
1202 obstack_grow (&loc_ob
, &init_loc
, sizeof (location_t
));
1206 obstack_grow (&str_ob
, &tok
->val
.str
, sizeof (cpp_string
));
1207 obstack_grow (&loc_ob
, &tok
->src_loc
, sizeof (location_t
));
1210 objc_at_sign_was_seen
= false;
1214 /* It is an error if we saw a '@' with no following string. */
1215 if (objc_at_sign_was_seen
)
1216 error ("stray %<@%> in program");
1218 /* We have read one more token than we want. */
1219 _cpp_backup_tokens (parse_in
, 1);
1222 strs
= XOBFINISH (&str_ob
, cpp_string
*);
1223 locs
= XOBFINISH (&loc_ob
, location_t
*);
1226 if (concats
&& !objc_string
&& !in_system_header_at (input_location
))
1227 warning (OPT_Wtraditional
,
1228 "traditional C rejects string constant concatenation");
1231 ? cpp_interpret_string
: cpp_interpret_string_notranslate
)
1232 (parse_in
, strs
, concats
+ 1, &istr
, type
))
1234 value
= build_string (istr
.len
, (const char *) istr
.text
);
1235 free (CONST_CAST (unsigned char *, istr
.text
));
1239 gcc_assert (g_string_concat_db
);
1240 g_string_concat_db
->record_string_concatenation (concats
+ 1, locs
);
1245 /* Callers cannot generally handle error_mark_node in this context,
1246 so return the empty string instead. cpp_interpret_string has
1252 case CPP_UTF8STRING
:
1253 value
= build_string (1, "");
1256 value
= build_string (TYPE_PRECISION (char16_type_node
)
1257 / TYPE_PRECISION (char_type_node
),
1258 "\0"); /* char16_t is 16 bits */
1261 value
= build_string (TYPE_PRECISION (char32_type_node
)
1262 / TYPE_PRECISION (char_type_node
),
1263 "\0\0\0"); /* char32_t is 32 bits */
1266 value
= build_string (TYPE_PRECISION (wchar_type_node
)
1267 / TYPE_PRECISION (char_type_node
),
1268 "\0\0\0"); /* widest supported wchar_t
1278 case CPP_UTF8STRING
:
1279 TREE_TYPE (value
) = char_array_type_node
;
1282 TREE_TYPE (value
) = char16_array_type_node
;
1285 TREE_TYPE (value
) = char32_array_type_node
;
1288 TREE_TYPE (value
) = wchar_array_type_node
;
1290 *valp
= fix_string_type (value
);
1294 obstack_free (&str_ob
, 0);
1295 obstack_free (&loc_ob
, 0);
1298 return objc_string
? CPP_OBJC_STRING
: type
;
1301 /* Converts a (possibly wide) character constant token into a tree. */
1303 lex_charconst (const cpp_token
*token
)
1307 unsigned int chars_seen
;
1310 result
= cpp_interpret_charconst (parse_in
, token
,
1311 &chars_seen
, &unsignedp
);
1313 if (token
->type
== CPP_WCHAR
)
1314 type
= wchar_type_node
;
1315 else if (token
->type
== CPP_CHAR32
)
1316 type
= char32_type_node
;
1317 else if (token
->type
== CPP_CHAR16
)
1318 type
= char16_type_node
;
1319 else if (token
->type
== CPP_UTF8CHAR
)
1320 type
= char_type_node
;
1321 /* In C, a character constant has type 'int'.
1322 In C++ 'char', but multi-char charconsts have type 'int'. */
1323 else if (!c_dialect_cxx () || chars_seen
> 1)
1324 type
= integer_type_node
;
1326 type
= char_type_node
;
1328 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1329 before possibly widening to HOST_WIDE_INT for build_int_cst. */
1330 if (unsignedp
|| (cppchar_signed_t
) result
>= 0)
1331 value
= build_int_cst (type
, result
);
1333 value
= build_int_cst (type
, (cppchar_signed_t
) result
);
1338 /* Helper function for c_parser_peek_conflict_marker
1339 and cp_lexer_peek_conflict_marker.
1340 Given a possible conflict marker token of kind TOK1_KIND
1341 consisting of a pair of characters, get the token kind for the
1342 standalone final character. */
1345 conflict_marker_get_final_tok_kind (enum cpp_ttype tok1_kind
)
1349 default: gcc_unreachable ();