1 /* Mainly the interface between cpplib and the C front ends.
2 Copyright (C) 1987-2016 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
;
85 /* Set the debug callbacks if we can use them. */
86 if ((debug_info_level
== DINFO_LEVEL_VERBOSE
87 && (write_symbols
== DWARF2_DEBUG
88 || write_symbols
== VMS_AND_DWARF2_DEBUG
))
89 || flag_dump_go_spec
!= NULL
)
91 cb
->define
= cb_define
;
97 get_fileinfo (const char *name
)
100 struct c_fileinfo
*fi
;
103 file_info_tree
= splay_tree_new ((splay_tree_compare_fn
) strcmp
,
105 (splay_tree_delete_value_fn
) free
);
107 n
= splay_tree_lookup (file_info_tree
, (splay_tree_key
) name
);
109 return (struct c_fileinfo
*) n
->value
;
111 fi
= XNEW (struct c_fileinfo
);
113 fi
->interface_only
= 0;
114 fi
->interface_unknown
= 1;
115 splay_tree_insert (file_info_tree
, (splay_tree_key
) name
,
116 (splay_tree_value
) fi
);
121 update_header_times (const char *name
)
123 /* Changing files again. This means currently collected time
124 is charged against header time, and body time starts back at 0. */
125 if (flag_detailed_statistics
)
127 int this_time
= get_run_time ();
128 struct c_fileinfo
*file
= get_fileinfo (name
);
129 header_time
+= this_time
- body_time
;
130 file
->time
+= this_time
- body_time
;
131 body_time
= this_time
;
136 dump_one_header (splay_tree_node n
, void * ARG_UNUSED (dummy
))
138 print_time ((const char *) n
->key
,
139 ((struct c_fileinfo
*) n
->value
)->time
);
144 dump_time_statistics (void)
146 struct c_fileinfo
*file
= get_fileinfo (LOCATION_FILE (input_location
));
147 int this_time
= get_run_time ();
148 file
->time
+= this_time
- body_time
;
150 fprintf (stderr
, "\n******\n");
151 print_time ("header files (total)", header_time
);
152 print_time ("main file (total)", this_time
- body_time
);
153 fprintf (stderr
, "ratio = %g : 1\n",
154 (double) header_time
/ (double) (this_time
- body_time
));
155 fprintf (stderr
, "\n******\n");
157 splay_tree_foreach (file_info_tree
, dump_one_header
, 0);
161 cb_ident (cpp_reader
* ARG_UNUSED (pfile
),
162 unsigned int ARG_UNUSED (line
),
163 const cpp_string
* ARG_UNUSED (str
))
167 /* Convert escapes in the string. */
168 cpp_string cstr
= { 0, 0 };
169 if (cpp_interpret_string (pfile
, str
, 1, &cstr
, CPP_STRING
))
171 targetm
.asm_out
.output_ident ((const char *) cstr
.text
);
172 free (CONST_CAST (unsigned char *, cstr
.text
));
177 /* Called at the start of every non-empty line. TOKEN is the first
178 lexed token on the line. Used for diagnostic line numbers. */
180 cb_line_change (cpp_reader
* ARG_UNUSED (pfile
), const cpp_token
*token
,
183 if (token
->type
!= CPP_EOF
&& !parsing_args
)
184 input_location
= token
->src_loc
;
188 fe_file_change (const line_map_ordinary
*new_map
)
193 if (new_map
->reason
== LC_ENTER
)
195 /* Don't stack the main buffer on the input stack;
196 we already did in compile_file. */
197 if (!MAIN_FILE_P (new_map
))
199 unsigned int included_at
= LAST_SOURCE_LINE_LOCATION (new_map
- 1);
201 if (included_at
> BUILTINS_LOCATION
)
202 line
= SOURCE_LINE (new_map
- 1, included_at
);
204 input_location
= new_map
->start_location
;
205 (*debug_hooks
->start_source_file
) (line
, LINEMAP_FILE (new_map
));
206 #ifndef NO_IMPLICIT_EXTERN_C
209 else if (LINEMAP_SYSP (new_map
) == 2)
212 ++pending_lang_change
;
217 else if (new_map
->reason
== LC_LEAVE
)
219 #ifndef NO_IMPLICIT_EXTERN_C
220 if (c_header_level
&& --c_header_level
== 0)
222 if (LINEMAP_SYSP (new_map
) == 2)
223 warning (0, "badly nested C headers from preprocessor");
224 --pending_lang_change
;
227 input_location
= new_map
->start_location
;
229 (*debug_hooks
->end_source_file
) (LINEMAP_LINE (new_map
));
232 update_header_times (LINEMAP_FILE (new_map
));
233 input_location
= new_map
->start_location
;
237 cb_def_pragma (cpp_reader
*pfile
, source_location loc
)
239 /* Issue a warning message if we have been asked to do so. Ignore
240 unknown pragmas in system headers unless an explicit
241 -Wunknown-pragmas has been given. */
242 if (warn_unknown_pragmas
> in_system_header_at (input_location
))
244 const unsigned char *space
, *name
;
246 location_t fe_loc
= loc
;
248 space
= name
= (const unsigned char *) "";
249 s
= cpp_get_token (pfile
);
250 if (s
->type
!= CPP_EOF
)
252 space
= cpp_token_as_text (pfile
, s
);
253 s
= cpp_get_token (pfile
);
254 if (s
->type
== CPP_NAME
)
255 name
= cpp_token_as_text (pfile
, s
);
258 warning_at (fe_loc
, OPT_Wunknown_pragmas
, "ignoring #pragma %s %s",
263 /* #define callback for DWARF and DWARF2 debug info. */
265 cb_define (cpp_reader
*pfile
, source_location loc
, cpp_hashnode
*node
)
267 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
268 (*debug_hooks
->define
) (SOURCE_LINE (linemap_check_ordinary (map
), loc
),
269 (const char *) cpp_macro_definition (pfile
, node
));
272 /* #undef callback for DWARF and DWARF2 debug info. */
274 cb_undef (cpp_reader
* ARG_UNUSED (pfile
), source_location loc
,
277 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
278 (*debug_hooks
->undef
) (SOURCE_LINE (linemap_check_ordinary (map
), loc
),
279 (const char *) NODE_NAME (node
));
282 /* Wrapper around cpp_get_token to skip CPP_PADDING tokens
283 and not consume CPP_EOF. */
284 static const cpp_token
*
285 get_token_no_padding (cpp_reader
*pfile
)
289 const cpp_token
*ret
= cpp_peek_token (pfile
, 0);
290 if (ret
->type
== CPP_EOF
)
292 ret
= cpp_get_token (pfile
);
293 if (ret
->type
!= CPP_PADDING
)
298 /* Callback for has_attribute. */
300 c_common_has_attribute (cpp_reader
*pfile
)
303 tree attr_name
= NULL_TREE
;
304 const cpp_token
*token
;
306 token
= get_token_no_padding (pfile
);
307 if (token
->type
!= CPP_OPEN_PAREN
)
309 cpp_error (pfile
, CPP_DL_ERROR
,
310 "missing '(' after \"__has_attribute\"");
313 token
= get_token_no_padding (pfile
);
314 if (token
->type
== CPP_NAME
)
316 attr_name
= get_identifier ((const char *)
317 cpp_token_as_text (pfile
, token
));
318 if (c_dialect_cxx ())
321 const cpp_token
*nxt_token
;
323 nxt_token
= cpp_peek_token (pfile
, idx
++);
324 while (nxt_token
->type
== CPP_PADDING
);
325 if (nxt_token
->type
== CPP_SCOPE
)
327 get_token_no_padding (pfile
); // Eat scope.
328 nxt_token
= get_token_no_padding (pfile
);
329 if (nxt_token
->type
== CPP_NAME
)
331 tree attr_ns
= attr_name
;
333 = get_identifier ((const char *)
334 cpp_token_as_text (pfile
, nxt_token
));
335 attr_name
= build_tree_list (attr_ns
, attr_id
);
339 cpp_error (pfile
, CPP_DL_ERROR
,
340 "attribute identifier required after scope");
341 attr_name
= NULL_TREE
;
346 /* Some standard attributes need special handling. */
347 if (is_attribute_p ("noreturn", attr_name
))
349 else if (is_attribute_p ("deprecated", attr_name
))
351 else if (is_attribute_p ("maybe_unused", attr_name
)
352 || is_attribute_p ("nodiscard", attr_name
))
355 attr_name
= NULL_TREE
;
361 const struct attribute_spec
*attr
= lookup_attribute_spec (attr_name
);
368 cpp_error (pfile
, CPP_DL_ERROR
,
369 "macro \"__has_attribute\" requires an identifier");
373 if (get_token_no_padding (pfile
)->type
!= CPP_CLOSE_PAREN
)
374 cpp_error (pfile
, CPP_DL_ERROR
,
375 "missing ')' after \"__has_attribute\"");
380 /* Read a token and return its type. Fill *VALUE with its value, if
381 applicable. Fill *CPP_FLAGS with the token's flags, if it is
385 c_lex_with_flags (tree
*value
, location_t
*loc
, unsigned char *cpp_flags
,
388 static bool no_more_pch
;
389 const cpp_token
*tok
;
391 unsigned char add_flags
= 0;
392 enum overflow_type overflow
= OT_NONE
;
394 timevar_push (TV_CPP
);
396 tok
= cpp_get_token_with_location (parse_in
, loc
);
406 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
.node
));
411 const char *suffix
= NULL
;
412 unsigned int flags
= cpp_classify_number (parse_in
, tok
, &suffix
, *loc
);
414 switch (flags
& CPP_N_CATEGORY
)
417 /* cpplib has issued an error. */
418 *value
= error_mark_node
;
422 /* C++ uses '0' to mark virtual functions as pure.
423 Set PURE_ZERO to pass this information to the C++ parser. */
424 if (tok
->val
.str
.len
== 1 && *tok
->val
.str
.text
== '0')
425 add_flags
= PURE_ZERO
;
426 *value
= interpret_integer (tok
, flags
, &overflow
);
430 *value
= interpret_float (tok
, flags
, suffix
, &overflow
);
437 if (flags
& CPP_N_USERDEF
)
441 tree suffix_id
= get_identifier (suffix
);
442 int len
= tok
->val
.str
.len
- strlen (suffix
);
443 /* If this is going to be used as a C string to pass to a
444 raw literal operator, we need to add a trailing NUL. */
445 tree num_string
= build_string (len
+ 1,
446 (const char *) tok
->val
.str
.text
);
447 TREE_TYPE (num_string
) = char_array_type_node
;
448 num_string
= fix_string_type (num_string
);
449 str
= CONST_CAST (char *, TREE_STRING_POINTER (num_string
));
451 literal
= build_userdef_literal (suffix_id
, *value
, overflow
,
459 /* An @ may give the next token special significance in Objective-C. */
460 if (c_dialect_objc ())
462 location_t atloc
= *loc
;
466 tok
= cpp_get_token_with_location (parse_in
, &newloc
);
478 type
= lex_string (tok
, value
, true, true);
482 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
.node
));
483 if (OBJC_IS_AT_KEYWORD (C_RID_CODE (*value
))
484 || OBJC_IS_CXX_KEYWORD (C_RID_CODE (*value
)))
487 /* Note the complication: if we found an OBJC_CXX
488 keyword, for example, 'class', we will be
489 returning a token of type CPP_AT_NAME and rid
490 code RID_CLASS (not RID_AT_CLASS). The language
491 parser needs to convert that to RID_AT_CLASS.
499 error_at (atloc
, "stray %<@%> in program");
510 unsigned char name
[8];
512 *cpp_spell_token (parse_in
, tok
, name
, true) = 0;
514 error_at (*loc
, "stray %qs in program", name
);
521 cppchar_t c
= tok
->val
.str
.text
[0];
523 if (c
== '"' || c
== '\'')
524 error_at (*loc
, "missing terminating %c character", (int) c
);
525 else if (ISGRAPH (c
))
526 error_at (*loc
, "stray %qc in program", (int) c
);
528 error_at (*loc
, "stray %<\\%o%> in program", (int) c
);
532 case CPP_CHAR_USERDEF
:
533 case CPP_WCHAR_USERDEF
:
534 case CPP_CHAR16_USERDEF
:
535 case CPP_CHAR32_USERDEF
:
536 case CPP_UTF8CHAR_USERDEF
:
539 cpp_token temp_tok
= *tok
;
540 const char *suffix
= cpp_get_userdef_suffix (tok
);
541 temp_tok
.val
.str
.len
-= strlen (suffix
);
542 temp_tok
.type
= cpp_userdef_char_remove_type (type
);
543 literal
= build_userdef_literal (get_identifier (suffix
),
544 lex_charconst (&temp_tok
),
555 *value
= lex_charconst (tok
);
558 case CPP_STRING_USERDEF
:
559 case CPP_WSTRING_USERDEF
:
560 case CPP_STRING16_USERDEF
:
561 case CPP_STRING32_USERDEF
:
562 case CPP_UTF8STRING_USERDEF
:
564 tree literal
, string
;
565 const char *suffix
= cpp_get_userdef_suffix (tok
);
566 string
= build_string (tok
->val
.str
.len
- strlen (suffix
),
567 (const char *) tok
->val
.str
.text
);
568 literal
= build_userdef_literal (get_identifier (suffix
),
569 string
, OT_NONE
, NULL_TREE
);
579 if ((lex_flags
& C_LEX_STRING_NO_JOIN
) == 0)
581 type
= lex_string (tok
, value
, false,
582 (lex_flags
& C_LEX_STRING_NO_TRANSLATE
) == 0);
585 *value
= build_string (tok
->val
.str
.len
, (const char *) tok
->val
.str
.text
);
589 *value
= build_int_cst (integer_type_node
, tok
->val
.pragma
);
592 /* These tokens should not be visible outside cpplib. */
593 case CPP_HEADER_NAME
:
597 /* CPP_COMMENT will appear when compiling with -C and should be
608 *cpp_flags
= tok
->flags
| add_flags
;
613 c_common_no_more_pch ();
616 timevar_pop (TV_CPP
);
621 /* Returns the narrowest C-visible unsigned type, starting with the
622 minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
625 static enum integer_type_kind
626 narrowest_unsigned_type (const widest_int
&val
, unsigned int flags
)
630 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
631 itk
= itk_unsigned_int
;
632 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
633 itk
= itk_unsigned_long
;
635 itk
= itk_unsigned_long_long
;
637 for (; itk
< itk_none
; itk
+= 2 /* skip unsigned types */)
641 if (integer_types
[itk
] == NULL_TREE
)
643 upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
645 if (wi::geu_p (wi::to_widest (upper
), val
))
646 return (enum integer_type_kind
) itk
;
652 /* Ditto, but narrowest signed type. */
653 static enum integer_type_kind
654 narrowest_signed_type (const widest_int
&val
, unsigned int flags
)
658 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
660 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
665 for (; itk
< itk_none
; itk
+= 2 /* skip signed types */)
669 if (integer_types
[itk
] == NULL_TREE
)
671 upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
673 if (wi::geu_p (wi::to_widest (upper
), val
))
674 return (enum integer_type_kind
) itk
;
680 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
682 interpret_integer (const cpp_token
*token
, unsigned int flags
,
683 enum overflow_type
*overflow
)
686 enum integer_type_kind itk
;
688 HOST_WIDE_INT ival
[3];
692 integer
= cpp_interpret_integer (parse_in
, token
, flags
);
693 if (integer
.overflow
)
694 *overflow
= OT_OVERFLOW
;
696 ival
[0] = integer
.low
;
697 ival
[1] = integer
.high
;
699 widest_int wval
= widest_int::from_array (ival
, 3);
701 /* The type of a constant with a U suffix is straightforward. */
702 if (flags
& CPP_N_UNSIGNED
)
703 itk
= narrowest_unsigned_type (wval
, flags
);
706 /* The type of a potentially-signed integer constant varies
707 depending on the base it's in, the standard in use, and the
709 enum integer_type_kind itk_u
710 = narrowest_unsigned_type (wval
, flags
);
711 enum integer_type_kind itk_s
712 = narrowest_signed_type (wval
, flags
);
714 /* In both C89 and C99, octal and hex constants may be signed or
715 unsigned, whichever fits tighter. We do not warn about this
716 choice differing from the traditional choice, as the constant
717 is probably a bit pattern and either way will work. */
718 if ((flags
& CPP_N_RADIX
) != CPP_N_DECIMAL
)
719 itk
= MIN (itk_u
, itk_s
);
722 /* In C99, decimal constants are always signed.
723 In C89, decimal constants that don't fit in long have
724 undefined behavior; we try to make them unsigned long.
725 In GCC's extended C89, that last is true of decimal
726 constants that don't fit in long long, too. */
729 if (itk_s
> itk_u
&& itk_s
> itk_long
)
733 if (itk_u
< itk_unsigned_long
)
734 itk_u
= itk_unsigned_long
;
736 warning (0, "this decimal constant is unsigned only in ISO C90");
739 warning (OPT_Wtraditional
,
740 "this decimal constant would be unsigned in ISO C90");
746 /* cpplib has already issued a warning for overflow. */
747 type
= ((flags
& CPP_N_UNSIGNED
)
748 ? widest_unsigned_literal_type_node
749 : widest_integer_literal_type_node
);
752 type
= integer_types
[itk
];
753 if (itk
> itk_unsigned_long
754 && (flags
& CPP_N_WIDTH
) != CPP_N_LARGE
)
756 ((c_dialect_cxx () ? cxx_dialect
== cxx98
: !flag_isoc99
)
757 ? DK_PEDWARN
: DK_WARNING
,
758 input_location
, OPT_Wlong_long
,
759 (flags
& CPP_N_UNSIGNED
)
760 ? "integer constant is too large for %<unsigned long%> type"
761 : "integer constant is too large for %<long%> type");
764 value
= wide_int_to_tree (type
, wval
);
766 /* Convert imaginary to a complex type. */
767 if (flags
& CPP_N_IMAGINARY
)
768 value
= build_complex (NULL_TREE
, build_int_cst (type
, 0), value
);
773 /* Interpret TOKEN, a floating point number with FLAGS as classified
774 by cpplib. For C++11 SUFFIX may contain a user-defined literal suffix. */
776 interpret_float (const cpp_token
*token
, unsigned int flags
,
777 const char *suffix
, enum overflow_type
*overflow
)
782 REAL_VALUE_TYPE real
;
783 REAL_VALUE_TYPE real_trunc
;
789 /* Default (no suffix) depends on whether the FLOAT_CONST_DECIMAL64
790 pragma has been used and is either double or _Decimal64. Types
791 that are not allowed with decimal float default to double. */
792 if (flags
& CPP_N_DEFAULT
)
794 flags
^= CPP_N_DEFAULT
;
795 flags
|= CPP_N_MEDIUM
;
797 if (((flags
& CPP_N_HEX
) == 0) && ((flags
& CPP_N_IMAGINARY
) == 0))
799 warning (OPT_Wunsuffixed_float_constants
,
800 "unsuffixed float constant");
801 if (float_const_decimal64_p ())
802 flags
|= CPP_N_DFLOAT
;
806 /* Decode _Fract and _Accum. */
807 if (flags
& CPP_N_FRACT
|| flags
& CPP_N_ACCUM
)
808 return interpret_fixed (token
, flags
);
810 /* Decode type based on width and properties. */
811 if (flags
& CPP_N_DFLOAT
)
812 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
813 type
= dfloat128_type_node
;
814 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
815 type
= dfloat32_type_node
;
817 type
= dfloat64_type_node
;
819 if (flags
& CPP_N_WIDTH_MD
)
824 if ((flags
& CPP_N_WIDTH_MD
) == CPP_N_MD_W
)
829 mode
= targetm
.c
.mode_for_suffix (suffix
);
830 if (mode
== VOIDmode
)
832 error ("unsupported non-standard suffix on floating constant");
834 return error_mark_node
;
837 pedwarn (input_location
, OPT_Wpedantic
, "non-standard suffix on floating constant");
839 type
= c_common_type_for_mode (mode
, 0);
842 else if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
843 type
= long_double_type_node
;
844 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
845 || flag_single_precision_constant
)
846 type
= float_type_node
;
848 type
= double_type_node
;
850 const_type
= excess_precision_type (type
);
854 /* Copy the constant to a nul-terminated buffer. If the constant
855 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
856 can't handle them. */
857 copylen
= token
->val
.str
.len
;
858 if (flags
& CPP_N_USERDEF
)
859 copylen
-= strlen (suffix
);
860 else if (flags
& CPP_N_DFLOAT
)
864 if ((flags
& CPP_N_WIDTH
) != CPP_N_MEDIUM
)
865 /* Must be an F or L or machine defined suffix. */
867 if (flags
& CPP_N_IMAGINARY
)
872 copy
= (char *) alloca (copylen
+ 1);
873 if (cxx_dialect
> cxx11
)
876 for (size_t i
= 0; i
< copylen
; ++i
)
877 if (token
->val
.str
.text
[i
] != '\'')
878 copy
[maxlen
++] = token
->val
.str
.text
[i
];
883 memcpy (copy
, token
->val
.str
.text
, copylen
);
884 copy
[copylen
] = '\0';
887 real_from_string3 (&real
, copy
, TYPE_MODE (const_type
));
888 if (const_type
!= type
)
889 /* Diagnosing if the result of converting the value with excess
890 precision to the semantic type would overflow (with associated
891 double rounding) is more appropriate than diagnosing if the
892 result of converting the string directly to the semantic type
894 real_convert (&real_trunc
, TYPE_MODE (type
), &real
);
896 /* Both C and C++ require a diagnostic for a floating constant
897 outside the range of representable values of its type. Since we
898 have __builtin_inf* to produce an infinity, this is now a
899 mandatory pedwarn if the target does not support infinities. */
900 if (REAL_VALUE_ISINF (real
)
901 || (const_type
!= type
&& REAL_VALUE_ISINF (real_trunc
)))
903 *overflow
= OT_OVERFLOW
;
904 if (!(flags
& CPP_N_USERDEF
))
906 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)))
907 pedwarn (input_location
, 0,
908 "floating constant exceeds range of %qT", type
);
910 warning (OPT_Woverflow
,
911 "floating constant exceeds range of %qT", type
);
914 /* We also give a warning if the value underflows. */
915 else if (real_equal (&real
, &dconst0
)
916 || (const_type
!= type
917 && real_equal (&real_trunc
, &dconst0
)))
919 REAL_VALUE_TYPE realvoidmode
;
920 int oflow
= real_from_string (&realvoidmode
, copy
);
921 *overflow
= (oflow
== 0 ? OT_NONE
922 : (oflow
< 0 ? OT_UNDERFLOW
: OT_OVERFLOW
));
923 if (!(flags
& CPP_N_USERDEF
))
925 if (oflow
< 0 || !real_equal (&realvoidmode
, &dconst0
))
926 warning (OPT_Woverflow
, "floating constant truncated to zero");
930 /* Create a node with determined type and value. */
931 value
= build_real (const_type
, real
);
932 if (flags
& CPP_N_IMAGINARY
)
934 value
= build_complex (NULL_TREE
,
935 fold_convert (const_type
,
936 integer_zero_node
), value
);
937 if (type
!= const_type
)
939 const_type
= TREE_TYPE (value
);
940 type
= build_complex_type (type
);
944 if (type
!= const_type
)
945 value
= build1 (EXCESS_PRECISION_EXPR
, type
, value
);
950 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
954 interpret_fixed (const cpp_token
*token
, unsigned int flags
)
958 FIXED_VALUE_TYPE fixed
;
962 copylen
= token
->val
.str
.len
;
964 if (flags
& CPP_N_FRACT
) /* _Fract. */
966 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Fract. */
968 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
970 type
= unsigned_long_long_fract_type_node
;
973 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
975 type
= unsigned_long_fract_type_node
;
978 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
980 type
= unsigned_short_fract_type_node
;
985 type
= unsigned_fract_type_node
;
989 else /* Signed _Fract. */
991 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
993 type
= long_long_fract_type_node
;
996 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
998 type
= long_fract_type_node
;
1001 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1003 type
= short_fract_type_node
;
1008 type
= fract_type_node
;
1015 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Accum. */
1017 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1019 type
= unsigned_long_long_accum_type_node
;
1022 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1024 type
= unsigned_long_accum_type_node
;
1027 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1029 type
= unsigned_short_accum_type_node
;
1034 type
= unsigned_accum_type_node
;
1038 else /* Signed _Accum. */
1040 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1042 type
= long_long_accum_type_node
;
1045 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1047 type
= long_accum_type_node
;
1050 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1052 type
= short_accum_type_node
;
1057 type
= accum_type_node
;
1063 copy
= (char *) alloca (copylen
+ 1);
1064 memcpy (copy
, token
->val
.str
.text
, copylen
);
1065 copy
[copylen
] = '\0';
1067 fixed_from_string (&fixed
, copy
, TYPE_MODE (type
));
1069 /* Create a node with determined type and value. */
1070 value
= build_fixed (type
, fixed
);
1075 /* Convert a series of STRING, WSTRING, STRING16, STRING32 and/or
1076 UTF8STRING tokens into a tree, performing string constant
1077 concatenation. TOK is the first of these. VALP is the location to
1078 write the string into. OBJC_STRING indicates whether an '@' token
1079 preceded the incoming token (in that case, the strings can either
1080 be ObjC strings, preceded by a single '@', or normal strings, not
1081 preceded by '@'. The result will be a CPP_OBJC_STRING). Returns
1082 the CPP token type of the result (CPP_STRING, CPP_WSTRING,
1083 CPP_STRING32, CPP_STRING16, CPP_UTF8STRING, or CPP_OBJC_STRING).
1085 This is unfortunately more work than it should be. If any of the
1086 strings in the series has an L prefix, the result is a wide string
1087 (6.4.5p4). Whether or not the result is a wide string affects the
1088 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
1089 sequences do not continue across the boundary between two strings in
1090 a series (6.4.5p7), so we must not lose the boundaries. Therefore
1091 cpp_interpret_string takes a vector of cpp_string structures, which
1092 we must arrange to provide. */
1094 static enum cpp_ttype
1095 lex_string (const cpp_token
*tok
, tree
*valp
, bool objc_string
, bool translate
)
1099 struct obstack str_ob
;
1101 enum cpp_ttype type
= tok
->type
;
1103 /* Try to avoid the overhead of creating and destroying an obstack
1104 for the common case of just one string. */
1105 cpp_string str
= tok
->val
.str
;
1106 cpp_string
*strs
= &str
;
1108 /* objc_at_sign_was_seen is only used when doing Objective-C string
1109 concatenation. It is 'true' if we have seen an '@' before the
1110 current string, and 'false' if not. We must see exactly one or
1111 zero '@' before each string. */
1112 bool objc_at_sign_was_seen
= false;
1115 tok
= cpp_get_token (parse_in
);
1123 if (objc_at_sign_was_seen
)
1124 error ("repeated %<@%> before Objective-C string");
1126 objc_at_sign_was_seen
= true;
1137 case CPP_UTF8STRING
:
1138 if (type
!= tok
->type
)
1140 if (type
== CPP_STRING
)
1143 error ("unsupported non-standard concatenation of string literals");
1149 gcc_obstack_init (&str_ob
);
1150 obstack_grow (&str_ob
, &str
, sizeof (cpp_string
));
1154 obstack_grow (&str_ob
, &tok
->val
.str
, sizeof (cpp_string
));
1156 objc_at_sign_was_seen
= false;
1160 /* It is an error if we saw a '@' with no following string. */
1161 if (objc_at_sign_was_seen
)
1162 error ("stray %<@%> in program");
1164 /* We have read one more token than we want. */
1165 _cpp_backup_tokens (parse_in
, 1);
1167 strs
= XOBFINISH (&str_ob
, cpp_string
*);
1169 if (concats
&& !objc_string
&& !in_system_header_at (input_location
))
1170 warning (OPT_Wtraditional
,
1171 "traditional C rejects string constant concatenation");
1174 ? cpp_interpret_string
: cpp_interpret_string_notranslate
)
1175 (parse_in
, strs
, concats
+ 1, &istr
, type
))
1177 value
= build_string (istr
.len
, (const char *) istr
.text
);
1178 free (CONST_CAST (unsigned char *, istr
.text
));
1182 /* Callers cannot generally handle error_mark_node in this context,
1183 so return the empty string instead. cpp_interpret_string has
1189 case CPP_UTF8STRING
:
1190 value
= build_string (1, "");
1193 value
= build_string (TYPE_PRECISION (char16_type_node
)
1194 / TYPE_PRECISION (char_type_node
),
1195 "\0"); /* char16_t is 16 bits */
1198 value
= build_string (TYPE_PRECISION (char32_type_node
)
1199 / TYPE_PRECISION (char_type_node
),
1200 "\0\0\0"); /* char32_t is 32 bits */
1203 value
= build_string (TYPE_PRECISION (wchar_type_node
)
1204 / TYPE_PRECISION (char_type_node
),
1205 "\0\0\0"); /* widest supported wchar_t
1215 case CPP_UTF8STRING
:
1216 TREE_TYPE (value
) = char_array_type_node
;
1219 TREE_TYPE (value
) = char16_array_type_node
;
1222 TREE_TYPE (value
) = char32_array_type_node
;
1225 TREE_TYPE (value
) = wchar_array_type_node
;
1227 *valp
= fix_string_type (value
);
1230 obstack_free (&str_ob
, 0);
1232 return objc_string
? CPP_OBJC_STRING
: type
;
1235 /* Converts a (possibly wide) character constant token into a tree. */
1237 lex_charconst (const cpp_token
*token
)
1241 unsigned int chars_seen
;
1244 result
= cpp_interpret_charconst (parse_in
, token
,
1245 &chars_seen
, &unsignedp
);
1247 if (token
->type
== CPP_WCHAR
)
1248 type
= wchar_type_node
;
1249 else if (token
->type
== CPP_CHAR32
)
1250 type
= char32_type_node
;
1251 else if (token
->type
== CPP_CHAR16
)
1252 type
= char16_type_node
;
1253 else if (token
->type
== CPP_UTF8CHAR
)
1254 type
= char_type_node
;
1255 /* In C, a character constant has type 'int'.
1256 In C++ 'char', but multi-char charconsts have type 'int'. */
1257 else if (!c_dialect_cxx () || chars_seen
> 1)
1258 type
= integer_type_node
;
1260 type
= char_type_node
;
1262 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1263 before possibly widening to HOST_WIDE_INT for build_int_cst. */
1264 if (unsignedp
|| (cppchar_signed_t
) result
>= 0)
1265 value
= build_int_cst (type
, result
);
1267 value
= build_int_cst (type
, (cppchar_signed_t
) result
);
1272 /* Helper function for c_parser_peek_conflict_marker
1273 and cp_lexer_peek_conflict_marker.
1274 Given a possible conflict marker token of kind TOK1_KIND
1275 consisting of a pair of characters, get the token kind for the
1276 standalone final character. */
1279 conflict_marker_get_final_tok_kind (enum cpp_ttype tok1_kind
)
1283 default: gcc_unreachable ();