1 /* Mainly the interface between cpplib and the C front ends.
2 Copyright (C) 1987-2018 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"
30 #include "file-prefix-map.h" /* remap_macro_filename() */
34 /* We may keep statistics about how long which files took to compile. */
35 static int header_time
, body_time
;
36 static splay_tree file_info_tree
;
38 int pending_lang_change
; /* If we need to switch languages - C++ only */
39 int c_header_level
; /* depth in C headers - C++ only */
41 static tree
interpret_integer (const cpp_token
*, unsigned int,
42 enum overflow_type
*);
43 static tree
interpret_float (const cpp_token
*, unsigned int, const char *,
44 enum overflow_type
*);
45 static tree
interpret_fixed (const cpp_token
*, unsigned int);
46 static enum integer_type_kind narrowest_unsigned_type
47 (const widest_int
&, unsigned int);
48 static enum integer_type_kind narrowest_signed_type
49 (const widest_int
&, unsigned int);
50 static enum cpp_ttype
lex_string (const cpp_token
*, tree
*, bool, bool);
51 static tree
lex_charconst (const cpp_token
*);
52 static void update_header_times (const char *);
53 static int dump_one_header (splay_tree_node
, void *);
54 static void cb_line_change (cpp_reader
*, const cpp_token
*, int);
55 static void cb_ident (cpp_reader
*, unsigned int, const cpp_string
*);
56 static void cb_def_pragma (cpp_reader
*, unsigned int);
57 static void cb_define (cpp_reader
*, unsigned int, cpp_hashnode
*);
58 static void cb_undef (cpp_reader
*, unsigned int, cpp_hashnode
*);
63 struct cpp_callbacks
*cb
;
64 struct c_fileinfo
*toplevel
;
66 /* The get_fileinfo data structure must be initialized before
67 cpp_read_main_file is called. */
68 toplevel
= get_fileinfo ("<top level>");
69 if (flag_detailed_statistics
)
72 body_time
= get_run_time ();
73 toplevel
->time
= body_time
;
76 cb
= cpp_get_callbacks (parse_in
);
78 cb
->line_change
= cb_line_change
;
80 cb
->def_pragma
= cb_def_pragma
;
81 cb
->valid_pch
= c_common_valid_pch
;
82 cb
->read_pch
= c_common_read_pch
;
83 cb
->has_attribute
= c_common_has_attribute
;
84 cb
->get_source_date_epoch
= cb_get_source_date_epoch
;
85 cb
->get_suggestion
= cb_get_suggestion
;
86 cb
->remap_filename
= remap_macro_filename
;
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
)
94 cb
->define
= cb_define
;
100 get_fileinfo (const char *name
)
103 struct c_fileinfo
*fi
;
106 file_info_tree
= splay_tree_new (splay_tree_compare_strings
,
108 splay_tree_delete_pointers
);
110 n
= splay_tree_lookup (file_info_tree
, (splay_tree_key
) name
);
112 return (struct c_fileinfo
*) n
->value
;
114 fi
= XNEW (struct c_fileinfo
);
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
);
124 update_header_times (const char *name
)
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
)
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
;
139 dump_one_header (splay_tree_node n
, void * ARG_UNUSED (dummy
))
141 print_time ((const char *) n
->key
,
142 ((struct c_fileinfo
*) n
->value
)->time
);
147 dump_time_statistics (void)
149 struct c_fileinfo
*file
= get_fileinfo (LOCATION_FILE (input_location
));
150 int this_time
= get_run_time ();
151 file
->time
+= this_time
- body_time
;
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");
160 splay_tree_foreach (file_info_tree
, dump_one_header
, 0);
164 cb_ident (cpp_reader
* ARG_UNUSED (pfile
),
165 unsigned int ARG_UNUSED (line
),
166 const cpp_string
* ARG_UNUSED (str
))
170 /* Convert escapes in the string. */
171 cpp_string cstr
= { 0, 0 };
172 if (cpp_interpret_string (pfile
, str
, 1, &cstr
, CPP_STRING
))
174 targetm
.asm_out
.output_ident ((const char *) cstr
.text
);
175 free (CONST_CAST (unsigned char *, cstr
.text
));
180 /* Called at the start of every non-empty line. TOKEN is the first
181 lexed token on the line. Used for diagnostic line numbers. */
183 cb_line_change (cpp_reader
* ARG_UNUSED (pfile
), const cpp_token
*token
,
186 if (token
->type
!= CPP_EOF
&& !parsing_args
)
187 input_location
= token
->src_loc
;
191 fe_file_change (const line_map_ordinary
*new_map
)
196 if (new_map
->reason
== LC_ENTER
)
198 /* Don't stack the main buffer on the input stack;
199 we already did in compile_file. */
200 if (!MAIN_FILE_P (new_map
))
202 location_t included_at
= linemap_included_from (new_map
);
204 if (included_at
> BUILTINS_LOCATION
)
205 line
= SOURCE_LINE (new_map
- 1, included_at
);
207 input_location
= new_map
->start_location
;
208 (*debug_hooks
->start_source_file
) (line
, LINEMAP_FILE (new_map
));
209 #ifdef SYSTEM_IMPLICIT_EXTERN_C
212 else if (LINEMAP_SYSP (new_map
) == 2)
215 ++pending_lang_change
;
220 else if (new_map
->reason
== LC_LEAVE
)
222 #ifdef SYSTEM_IMPLICIT_EXTERN_C
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 --pending_lang_change
;
230 input_location
= new_map
->start_location
;
232 (*debug_hooks
->end_source_file
) (LINEMAP_LINE (new_map
));
235 update_header_times (LINEMAP_FILE (new_map
));
236 input_location
= new_map
->start_location
;
240 cb_def_pragma (cpp_reader
*pfile
, location_t loc
)
242 /* Issue a warning message if we have been asked to do so. Ignore
243 unknown pragmas in system headers unless an explicit
244 -Wunknown-pragmas has been given. */
245 if (warn_unknown_pragmas
> in_system_header_at (input_location
))
247 const unsigned char *space
, *name
;
249 location_t fe_loc
= loc
;
251 space
= name
= (const unsigned char *) "";
252 s
= cpp_get_token (pfile
);
253 if (s
->type
!= CPP_EOF
)
255 space
= cpp_token_as_text (pfile
, s
);
256 s
= cpp_get_token (pfile
);
257 if (s
->type
== CPP_NAME
)
258 name
= cpp_token_as_text (pfile
, s
);
261 warning_at (fe_loc
, OPT_Wunknown_pragmas
, "ignoring #pragma %s %s",
266 /* #define callback for DWARF and DWARF2 debug info. */
268 cb_define (cpp_reader
*pfile
, location_t loc
, cpp_hashnode
*node
)
270 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
271 (*debug_hooks
->define
) (SOURCE_LINE (linemap_check_ordinary (map
), loc
),
272 (const char *) cpp_macro_definition (pfile
, node
));
275 /* #undef callback for DWARF and DWARF2 debug info. */
277 cb_undef (cpp_reader
* ARG_UNUSED (pfile
), location_t loc
,
280 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
281 (*debug_hooks
->undef
) (SOURCE_LINE (linemap_check_ordinary (map
), loc
),
282 (const char *) NODE_NAME (node
));
285 /* Wrapper around cpp_get_token to skip CPP_PADDING tokens
286 and not consume CPP_EOF. */
287 static const cpp_token
*
288 get_token_no_padding (cpp_reader
*pfile
)
292 const cpp_token
*ret
= cpp_peek_token (pfile
, 0);
293 if (ret
->type
== CPP_EOF
)
295 ret
= cpp_get_token (pfile
);
296 if (ret
->type
!= CPP_PADDING
)
301 /* Callback for has_attribute. */
303 c_common_has_attribute (cpp_reader
*pfile
)
306 tree attr_name
= NULL_TREE
;
307 const cpp_token
*token
;
309 token
= get_token_no_padding (pfile
);
310 if (token
->type
!= CPP_OPEN_PAREN
)
312 cpp_error (pfile
, CPP_DL_ERROR
,
313 "missing '(' after \"__has_attribute\"");
316 token
= get_token_no_padding (pfile
);
317 if (token
->type
== CPP_NAME
)
319 attr_name
= get_identifier ((const char *)
320 cpp_token_as_text (pfile
, token
));
321 attr_name
= canonicalize_attr_name (attr_name
);
322 if (c_dialect_cxx ())
325 const cpp_token
*nxt_token
;
327 nxt_token
= cpp_peek_token (pfile
, idx
++);
328 while (nxt_token
->type
== CPP_PADDING
);
329 if (nxt_token
->type
== CPP_SCOPE
)
331 get_token_no_padding (pfile
); // Eat scope.
332 nxt_token
= get_token_no_padding (pfile
);
333 if (nxt_token
->type
== CPP_NAME
)
335 tree attr_ns
= attr_name
;
337 = get_identifier ((const char *)
338 cpp_token_as_text (pfile
, nxt_token
));
339 attr_name
= build_tree_list (attr_ns
, attr_id
);
343 cpp_error (pfile
, CPP_DL_ERROR
,
344 "attribute identifier required after scope");
345 attr_name
= NULL_TREE
;
350 /* Some standard attributes need special handling. */
351 if (is_attribute_p ("noreturn", attr_name
))
353 else if (is_attribute_p ("deprecated", attr_name
))
355 else if (is_attribute_p ("maybe_unused", attr_name
)
356 || is_attribute_p ("nodiscard", attr_name
)
357 || is_attribute_p ("fallthrough", attr_name
))
359 else if (is_attribute_p ("no_unique_address", attr_name
)
360 || is_attribute_p ("likely", attr_name
)
361 || is_attribute_p ("unlikely", attr_name
))
364 attr_name
= NULL_TREE
;
370 const struct attribute_spec
*attr
= lookup_attribute_spec (attr_name
);
377 cpp_error (pfile
, CPP_DL_ERROR
,
378 "macro \"__has_attribute\" requires an identifier");
382 if (get_token_no_padding (pfile
)->type
!= CPP_CLOSE_PAREN
)
383 cpp_error (pfile
, CPP_DL_ERROR
,
384 "missing ')' after \"__has_attribute\"");
389 /* Read a token and return its type. Fill *VALUE with its value, if
390 applicable. Fill *CPP_FLAGS with the token's flags, if it is
394 c_lex_with_flags (tree
*value
, location_t
*loc
, unsigned char *cpp_flags
,
397 static bool no_more_pch
;
398 const cpp_token
*tok
;
400 unsigned char add_flags
= 0;
401 enum overflow_type overflow
= OT_NONE
;
403 timevar_push (TV_CPP
);
405 tok
= cpp_get_token_with_location (parse_in
, loc
);
415 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
.node
));
420 const char *suffix
= NULL
;
421 unsigned int flags
= cpp_classify_number (parse_in
, tok
, &suffix
, *loc
);
423 switch (flags
& CPP_N_CATEGORY
)
426 /* cpplib has issued an error. */
427 *value
= error_mark_node
;
431 /* C++ uses '0' to mark virtual functions as pure.
432 Set PURE_ZERO to pass this information to the C++ parser. */
433 if (tok
->val
.str
.len
== 1 && *tok
->val
.str
.text
== '0')
434 add_flags
= PURE_ZERO
;
435 *value
= interpret_integer (tok
, flags
, &overflow
);
439 *value
= interpret_float (tok
, flags
, suffix
, &overflow
);
446 if (flags
& CPP_N_USERDEF
)
450 tree suffix_id
= get_identifier (suffix
);
451 int len
= tok
->val
.str
.len
- strlen (suffix
);
452 /* If this is going to be used as a C string to pass to a
453 raw literal operator, we need to add a trailing NUL. */
454 tree num_string
= build_string (len
+ 1,
455 (const char *) tok
->val
.str
.text
);
456 TREE_TYPE (num_string
) = char_array_type_node
;
457 num_string
= fix_string_type (num_string
);
458 str
= CONST_CAST (char *, TREE_STRING_POINTER (num_string
));
460 literal
= build_userdef_literal (suffix_id
, *value
, overflow
,
468 /* An @ may give the next token special significance in Objective-C. */
469 if (c_dialect_objc ())
471 location_t atloc
= *loc
;
475 tok
= cpp_get_token_with_location (parse_in
, &newloc
);
487 type
= lex_string (tok
, value
, true, true);
491 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
.node
));
492 if (OBJC_IS_AT_KEYWORD (C_RID_CODE (*value
))
493 || OBJC_IS_CXX_KEYWORD (C_RID_CODE (*value
)))
496 /* Note the complication: if we found an OBJC_CXX
497 keyword, for example, 'class', we will be
498 returning a token of type CPP_AT_NAME and rid
499 code RID_CLASS (not RID_AT_CLASS). The language
500 parser needs to convert that to RID_AT_CLASS.
508 error_at (atloc
, "stray %<@%> in program");
519 unsigned char name
[8];
521 *cpp_spell_token (parse_in
, tok
, name
, true) = 0;
523 error_at (*loc
, "stray %qs in program", name
);
530 cppchar_t c
= tok
->val
.str
.text
[0];
532 if (c
== '"' || c
== '\'')
533 error_at (*loc
, "missing terminating %c character", (int) c
);
534 else if (ISGRAPH (c
))
535 error_at (*loc
, "stray %qc in program", (int) c
);
537 error_at (*loc
, "stray %<\\%o%> in program", (int) c
);
541 case CPP_CHAR_USERDEF
:
542 case CPP_WCHAR_USERDEF
:
543 case CPP_CHAR16_USERDEF
:
544 case CPP_CHAR32_USERDEF
:
545 case CPP_UTF8CHAR_USERDEF
:
548 cpp_token temp_tok
= *tok
;
549 const char *suffix
= cpp_get_userdef_suffix (tok
);
550 temp_tok
.val
.str
.len
-= strlen (suffix
);
551 temp_tok
.type
= cpp_userdef_char_remove_type (type
);
552 literal
= build_userdef_literal (get_identifier (suffix
),
553 lex_charconst (&temp_tok
),
564 *value
= lex_charconst (tok
);
567 case CPP_STRING_USERDEF
:
568 case CPP_WSTRING_USERDEF
:
569 case CPP_STRING16_USERDEF
:
570 case CPP_STRING32_USERDEF
:
571 case CPP_UTF8STRING_USERDEF
:
573 tree literal
, string
;
574 const char *suffix
= cpp_get_userdef_suffix (tok
);
575 string
= build_string (tok
->val
.str
.len
- strlen (suffix
),
576 (const char *) tok
->val
.str
.text
);
577 literal
= build_userdef_literal (get_identifier (suffix
),
578 string
, OT_NONE
, NULL_TREE
);
588 if ((lex_flags
& C_LEX_STRING_NO_JOIN
) == 0)
590 type
= lex_string (tok
, value
, false,
591 (lex_flags
& C_LEX_STRING_NO_TRANSLATE
) == 0);
594 *value
= build_string (tok
->val
.str
.len
, (const char *) tok
->val
.str
.text
);
598 *value
= build_int_cst (integer_type_node
, tok
->val
.pragma
);
601 /* These tokens should not be visible outside cpplib. */
602 case CPP_HEADER_NAME
:
606 /* CPP_COMMENT will appear when compiling with -C. Ignore, except
607 when it is a FALLTHROUGH comment, in that case set
608 PREV_FALLTHROUGH flag on the next non-comment token. */
610 if (tok
->flags
& PREV_FALLTHROUGH
)
614 tok
= cpp_get_token_with_location (parse_in
, loc
);
617 while (type
== CPP_PADDING
|| type
== CPP_COMMENT
);
618 add_flags
|= PREV_FALLTHROUGH
;
629 *cpp_flags
= tok
->flags
| add_flags
;
634 c_common_no_more_pch ();
637 timevar_pop (TV_CPP
);
642 /* Returns the narrowest C-visible unsigned type, starting with the
643 minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
646 static enum integer_type_kind
647 narrowest_unsigned_type (const widest_int
&val
, unsigned int flags
)
651 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
652 itk
= itk_unsigned_int
;
653 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
654 itk
= itk_unsigned_long
;
656 itk
= itk_unsigned_long_long
;
658 for (; itk
< itk_none
; itk
+= 2 /* skip unsigned types */)
662 if (integer_types
[itk
] == NULL_TREE
)
664 upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
666 if (wi::geu_p (wi::to_widest (upper
), val
))
667 return (enum integer_type_kind
) itk
;
673 /* Ditto, but narrowest signed type. */
674 static enum integer_type_kind
675 narrowest_signed_type (const widest_int
&val
, unsigned int flags
)
679 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
681 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
686 for (; itk
< itk_none
; itk
+= 2 /* skip signed types */)
690 if (integer_types
[itk
] == NULL_TREE
)
692 upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
694 if (wi::geu_p (wi::to_widest (upper
), val
))
695 return (enum integer_type_kind
) itk
;
701 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
703 interpret_integer (const cpp_token
*token
, unsigned int flags
,
704 enum overflow_type
*overflow
)
707 enum integer_type_kind itk
;
709 HOST_WIDE_INT ival
[3];
713 integer
= cpp_interpret_integer (parse_in
, token
, flags
);
714 if (integer
.overflow
)
715 *overflow
= OT_OVERFLOW
;
717 ival
[0] = integer
.low
;
718 ival
[1] = integer
.high
;
720 widest_int wval
= widest_int::from_array (ival
, 3);
722 /* The type of a constant with a U suffix is straightforward. */
723 if (flags
& CPP_N_UNSIGNED
)
724 itk
= narrowest_unsigned_type (wval
, flags
);
727 /* The type of a potentially-signed integer constant varies
728 depending on the base it's in, the standard in use, and the
730 enum integer_type_kind itk_u
731 = narrowest_unsigned_type (wval
, flags
);
732 enum integer_type_kind itk_s
733 = narrowest_signed_type (wval
, flags
);
735 /* In both C89 and C99, octal and hex constants may be signed or
736 unsigned, whichever fits tighter. We do not warn about this
737 choice differing from the traditional choice, as the constant
738 is probably a bit pattern and either way will work. */
739 if ((flags
& CPP_N_RADIX
) != CPP_N_DECIMAL
)
740 itk
= MIN (itk_u
, itk_s
);
743 /* In C99, decimal constants are always signed.
744 In C89, decimal constants that don't fit in long have
745 undefined behavior; we try to make them unsigned long.
746 In GCC's extended C89, that last is true of decimal
747 constants that don't fit in long long, too. */
750 if (itk_s
> itk_u
&& itk_s
> itk_long
)
754 if (itk_u
< itk_unsigned_long
)
755 itk_u
= itk_unsigned_long
;
757 warning (0, "this decimal constant is unsigned only in ISO C90");
760 warning (OPT_Wtraditional
,
761 "this decimal constant would be unsigned in ISO C90");
767 /* cpplib has already issued a warning for overflow. */
768 type
= ((flags
& CPP_N_UNSIGNED
)
769 ? widest_unsigned_literal_type_node
770 : widest_integer_literal_type_node
);
773 type
= integer_types
[itk
];
774 if (itk
> itk_unsigned_long
775 && (flags
& CPP_N_WIDTH
) != CPP_N_LARGE
)
777 ((c_dialect_cxx () ? cxx_dialect
== cxx98
: !flag_isoc99
)
778 ? DK_PEDWARN
: DK_WARNING
,
779 input_location
, OPT_Wlong_long
,
780 (flags
& CPP_N_UNSIGNED
)
781 ? "integer constant is too large for %<unsigned long%> type"
782 : "integer constant is too large for %<long%> type");
785 value
= wide_int_to_tree (type
, wval
);
787 /* Convert imaginary to a complex type. */
788 if (flags
& CPP_N_IMAGINARY
)
789 value
= build_complex (NULL_TREE
, build_int_cst (type
, 0), value
);
794 /* Interpret TOKEN, a floating point number with FLAGS as classified
795 by cpplib. For C++11 SUFFIX may contain a user-defined literal suffix. */
797 interpret_float (const cpp_token
*token
, unsigned int flags
,
798 const char *suffix
, enum overflow_type
*overflow
)
803 REAL_VALUE_TYPE real
;
804 REAL_VALUE_TYPE real_trunc
;
810 /* Default (no suffix) depends on whether the FLOAT_CONST_DECIMAL64
811 pragma has been used and is either double or _Decimal64. Types
812 that are not allowed with decimal float default to double. */
813 if (flags
& CPP_N_DEFAULT
)
815 flags
^= CPP_N_DEFAULT
;
816 flags
|= CPP_N_MEDIUM
;
818 if (((flags
& CPP_N_HEX
) == 0) && ((flags
& CPP_N_IMAGINARY
) == 0))
820 warning (OPT_Wunsuffixed_float_constants
,
821 "unsuffixed float constant");
822 if (float_const_decimal64_p ())
823 flags
|= CPP_N_DFLOAT
;
827 /* Decode _Fract and _Accum. */
828 if (flags
& CPP_N_FRACT
|| flags
& CPP_N_ACCUM
)
829 return interpret_fixed (token
, flags
);
831 /* Decode type based on width and properties. */
832 if (flags
& CPP_N_DFLOAT
)
833 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
834 type
= dfloat128_type_node
;
835 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
836 type
= dfloat32_type_node
;
838 type
= dfloat64_type_node
;
840 if (flags
& CPP_N_WIDTH_MD
)
845 if ((flags
& CPP_N_WIDTH_MD
) == CPP_N_MD_W
)
850 mode
= targetm
.c
.mode_for_suffix (suffix
);
851 if (mode
== VOIDmode
)
853 error ("unsupported non-standard suffix on floating constant");
855 return error_mark_node
;
858 pedwarn (input_location
, OPT_Wpedantic
, "non-standard suffix on floating constant");
860 type
= c_common_type_for_mode (mode
, 0);
863 else if ((flags
& (CPP_N_FLOATN
| CPP_N_FLOATNX
)) != 0)
865 unsigned int n
= (flags
& CPP_N_WIDTH_FLOATN_NX
) >> CPP_FLOATN_SHIFT
;
866 bool extended
= (flags
& CPP_N_FLOATNX
) != 0;
868 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
869 if (floatn_nx_types
[i
].n
== (int) n
870 && floatn_nx_types
[i
].extended
== extended
)
872 type
= FLOATN_NX_TYPE_NODE (i
);
875 if (type
== NULL_TREE
)
877 error ("unsupported non-standard suffix on floating constant");
878 return error_mark_node
;
881 pedwarn (input_location
, OPT_Wpedantic
, "non-standard suffix on floating constant");
883 else if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
884 type
= long_double_type_node
;
885 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
886 || flag_single_precision_constant
)
887 type
= float_type_node
;
889 type
= double_type_node
;
891 const_type
= excess_precision_type (type
);
895 /* Copy the constant to a nul-terminated buffer. If the constant
896 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
897 can't handle them. */
898 copylen
= token
->val
.str
.len
;
899 if (flags
& CPP_N_USERDEF
)
900 copylen
-= strlen (suffix
);
901 else if (flags
& CPP_N_DFLOAT
)
905 if ((flags
& CPP_N_WIDTH
) != CPP_N_MEDIUM
)
906 /* Must be an F or L or machine defined suffix. */
908 if (flags
& CPP_N_IMAGINARY
)
911 if (flags
& CPP_N_FLOATNX
)
913 if (flags
& (CPP_N_FLOATN
| CPP_N_FLOATNX
))
915 unsigned int n
= (flags
& CPP_N_WIDTH_FLOATN_NX
) >> CPP_FLOATN_SHIFT
;
924 copy
= (char *) alloca (copylen
+ 1);
925 if (cxx_dialect
> cxx11
)
928 for (size_t i
= 0; i
< copylen
; ++i
)
929 if (token
->val
.str
.text
[i
] != '\'')
930 copy
[maxlen
++] = token
->val
.str
.text
[i
];
935 memcpy (copy
, token
->val
.str
.text
, copylen
);
936 copy
[copylen
] = '\0';
939 real_from_string3 (&real
, copy
, TYPE_MODE (const_type
));
940 if (const_type
!= type
)
941 /* Diagnosing if the result of converting the value with excess
942 precision to the semantic type would overflow (with associated
943 double rounding) is more appropriate than diagnosing if the
944 result of converting the string directly to the semantic type
946 real_convert (&real_trunc
, TYPE_MODE (type
), &real
);
948 /* Both C and C++ require a diagnostic for a floating constant
949 outside the range of representable values of its type. Since we
950 have __builtin_inf* to produce an infinity, this is now a
951 mandatory pedwarn if the target does not support infinities. */
952 if (REAL_VALUE_ISINF (real
)
953 || (const_type
!= type
&& REAL_VALUE_ISINF (real_trunc
)))
955 *overflow
= OT_OVERFLOW
;
956 if (!(flags
& CPP_N_USERDEF
))
958 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)))
959 pedwarn (input_location
, 0,
960 "floating constant exceeds range of %qT", type
);
962 warning (OPT_Woverflow
,
963 "floating constant exceeds range of %qT", type
);
966 /* We also give a warning if the value underflows. */
967 else if (real_equal (&real
, &dconst0
)
968 || (const_type
!= type
969 && real_equal (&real_trunc
, &dconst0
)))
971 REAL_VALUE_TYPE realvoidmode
;
972 int oflow
= real_from_string (&realvoidmode
, copy
);
973 *overflow
= (oflow
== 0 ? OT_NONE
974 : (oflow
< 0 ? OT_UNDERFLOW
: OT_OVERFLOW
));
975 if (!(flags
& CPP_N_USERDEF
))
977 if (oflow
< 0 || !real_equal (&realvoidmode
, &dconst0
))
978 warning (OPT_Woverflow
, "floating constant truncated to zero");
982 /* Create a node with determined type and value. */
983 value
= build_real (const_type
, real
);
984 if (flags
& CPP_N_IMAGINARY
)
986 value
= build_complex (NULL_TREE
,
987 fold_convert (const_type
,
988 integer_zero_node
), value
);
989 if (type
!= const_type
)
991 const_type
= TREE_TYPE (value
);
992 type
= build_complex_type (type
);
996 if (type
!= const_type
)
997 value
= build1_loc (token
->src_loc
, EXCESS_PRECISION_EXPR
, type
, value
);
1002 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
1006 interpret_fixed (const cpp_token
*token
, unsigned int flags
)
1010 FIXED_VALUE_TYPE fixed
;
1014 copylen
= token
->val
.str
.len
;
1016 if (flags
& CPP_N_FRACT
) /* _Fract. */
1018 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Fract. */
1020 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1022 type
= unsigned_long_long_fract_type_node
;
1025 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1027 type
= unsigned_long_fract_type_node
;
1030 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1032 type
= unsigned_short_fract_type_node
;
1037 type
= unsigned_fract_type_node
;
1041 else /* Signed _Fract. */
1043 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1045 type
= long_long_fract_type_node
;
1048 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1050 type
= long_fract_type_node
;
1053 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1055 type
= short_fract_type_node
;
1060 type
= fract_type_node
;
1067 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Accum. */
1069 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1071 type
= unsigned_long_long_accum_type_node
;
1074 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1076 type
= unsigned_long_accum_type_node
;
1079 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1081 type
= unsigned_short_accum_type_node
;
1086 type
= unsigned_accum_type_node
;
1090 else /* Signed _Accum. */
1092 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1094 type
= long_long_accum_type_node
;
1097 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1099 type
= long_accum_type_node
;
1102 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1104 type
= short_accum_type_node
;
1109 type
= accum_type_node
;
1115 copy
= (char *) alloca (copylen
+ 1);
1116 memcpy (copy
, token
->val
.str
.text
, copylen
);
1117 copy
[copylen
] = '\0';
1119 fixed_from_string (&fixed
, copy
, SCALAR_TYPE_MODE (type
));
1121 /* Create a node with determined type and value. */
1122 value
= build_fixed (type
, fixed
);
1127 /* Convert a series of STRING, WSTRING, STRING16, STRING32 and/or
1128 UTF8STRING tokens into a tree, performing string constant
1129 concatenation. TOK is the first of these. VALP is the location to
1130 write the string into. OBJC_STRING indicates whether an '@' token
1131 preceded the incoming token (in that case, the strings can either
1132 be ObjC strings, preceded by a single '@', or normal strings, not
1133 preceded by '@'. The result will be a CPP_OBJC_STRING). Returns
1134 the CPP token type of the result (CPP_STRING, CPP_WSTRING,
1135 CPP_STRING32, CPP_STRING16, CPP_UTF8STRING, or CPP_OBJC_STRING).
1137 This is unfortunately more work than it should be. If any of the
1138 strings in the series has an L prefix, the result is a wide string
1139 (6.4.5p4). Whether or not the result is a wide string affects the
1140 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
1141 sequences do not continue across the boundary between two strings in
1142 a series (6.4.5p7), so we must not lose the boundaries. Therefore
1143 cpp_interpret_string takes a vector of cpp_string structures, which
1144 we must arrange to provide. */
1146 static enum cpp_ttype
1147 lex_string (const cpp_token
*tok
, tree
*valp
, bool objc_string
, bool translate
)
1151 struct obstack str_ob
;
1152 struct obstack loc_ob
;
1154 enum cpp_ttype type
= tok
->type
;
1156 /* Try to avoid the overhead of creating and destroying an obstack
1157 for the common case of just one string. */
1158 cpp_string str
= tok
->val
.str
;
1159 location_t init_loc
= tok
->src_loc
;
1160 cpp_string
*strs
= &str
;
1161 location_t
*locs
= NULL
;
1163 /* objc_at_sign_was_seen is only used when doing Objective-C string
1164 concatenation. It is 'true' if we have seen an '@' before the
1165 current string, and 'false' if not. We must see exactly one or
1166 zero '@' before each string. */
1167 bool objc_at_sign_was_seen
= false;
1170 tok
= cpp_get_token (parse_in
);
1178 if (objc_at_sign_was_seen
)
1179 error ("repeated %<@%> before Objective-C string");
1181 objc_at_sign_was_seen
= true;
1192 case CPP_UTF8STRING
:
1193 if (type
!= tok
->type
)
1195 if (type
== CPP_STRING
)
1198 error ("unsupported non-standard concatenation of string literals");
1205 gcc_obstack_init (&str_ob
);
1206 gcc_obstack_init (&loc_ob
);
1207 obstack_grow (&str_ob
, &str
, sizeof (cpp_string
));
1208 obstack_grow (&loc_ob
, &init_loc
, sizeof (location_t
));
1212 obstack_grow (&str_ob
, &tok
->val
.str
, sizeof (cpp_string
));
1213 obstack_grow (&loc_ob
, &tok
->src_loc
, sizeof (location_t
));
1216 objc_at_sign_was_seen
= false;
1220 /* It is an error if we saw a '@' with no following string. */
1221 if (objc_at_sign_was_seen
)
1222 error ("stray %<@%> in program");
1224 /* We have read one more token than we want. */
1225 _cpp_backup_tokens (parse_in
, 1);
1228 strs
= XOBFINISH (&str_ob
, cpp_string
*);
1229 locs
= XOBFINISH (&loc_ob
, location_t
*);
1232 if (concats
&& !objc_string
&& !in_system_header_at (input_location
))
1233 warning (OPT_Wtraditional
,
1234 "traditional C rejects string constant concatenation");
1237 ? cpp_interpret_string
: cpp_interpret_string_notranslate
)
1238 (parse_in
, strs
, concats
+ 1, &istr
, type
))
1240 value
= build_string (istr
.len
, (const char *) istr
.text
);
1241 free (CONST_CAST (unsigned char *, istr
.text
));
1245 gcc_assert (g_string_concat_db
);
1246 g_string_concat_db
->record_string_concatenation (concats
+ 1, locs
);
1251 /* Callers cannot generally handle error_mark_node in this context,
1252 so return the empty string instead. cpp_interpret_string has
1258 case CPP_UTF8STRING
:
1259 value
= build_string (1, "");
1262 value
= build_string (TYPE_PRECISION (char16_type_node
)
1263 / TYPE_PRECISION (char_type_node
),
1264 "\0"); /* char16_t is 16 bits */
1267 value
= build_string (TYPE_PRECISION (char32_type_node
)
1268 / TYPE_PRECISION (char_type_node
),
1269 "\0\0\0"); /* char32_t is 32 bits */
1272 value
= build_string (TYPE_PRECISION (wchar_type_node
)
1273 / TYPE_PRECISION (char_type_node
),
1274 "\0\0\0"); /* widest supported wchar_t
1284 case CPP_UTF8STRING
:
1285 TREE_TYPE (value
) = char_array_type_node
;
1288 TREE_TYPE (value
) = char16_array_type_node
;
1291 TREE_TYPE (value
) = char32_array_type_node
;
1294 TREE_TYPE (value
) = wchar_array_type_node
;
1296 *valp
= fix_string_type (value
);
1300 obstack_free (&str_ob
, 0);
1301 obstack_free (&loc_ob
, 0);
1304 return objc_string
? CPP_OBJC_STRING
: type
;
1307 /* Converts a (possibly wide) character constant token into a tree. */
1309 lex_charconst (const cpp_token
*token
)
1313 unsigned int chars_seen
;
1316 result
= cpp_interpret_charconst (parse_in
, token
,
1317 &chars_seen
, &unsignedp
);
1319 if (token
->type
== CPP_WCHAR
)
1320 type
= wchar_type_node
;
1321 else if (token
->type
== CPP_CHAR32
)
1322 type
= char32_type_node
;
1323 else if (token
->type
== CPP_CHAR16
)
1324 type
= char16_type_node
;
1325 else if (token
->type
== CPP_UTF8CHAR
)
1326 type
= char_type_node
;
1327 /* In C, a character constant has type 'int'.
1328 In C++ 'char', but multi-char charconsts have type 'int'. */
1329 else if (!c_dialect_cxx () || chars_seen
> 1)
1330 type
= integer_type_node
;
1332 type
= char_type_node
;
1334 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1335 before possibly widening to HOST_WIDE_INT for build_int_cst. */
1336 if (unsignedp
|| (cppchar_signed_t
) result
>= 0)
1337 value
= build_int_cst (type
, result
);
1339 value
= build_int_cst (type
, (cppchar_signed_t
) result
);
1344 /* Helper function for c_parser_peek_conflict_marker
1345 and cp_lexer_peek_conflict_marker.
1346 Given a possible conflict marker token of kind TOK1_KIND
1347 consisting of a pair of characters, get the token kind for the
1348 standalone final character. */
1351 conflict_marker_get_final_tok_kind (enum cpp_ttype tok1_kind
)
1355 default: gcc_unreachable ();