1 /* Mainly the interface between cpplib and the C front ends.
2 Copyright (C) 1987-2013 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"
33 #include "splay-tree.h"
37 /* We may keep statistics about how long which files took to compile. */
38 static int header_time
, body_time
;
39 static splay_tree file_info_tree
;
41 int pending_lang_change
; /* If we need to switch languages - C++ only */
42 int c_header_level
; /* depth in C headers - C++ and UPC only */
44 static tree
interpret_integer (const cpp_token
*, unsigned int,
45 enum overflow_type
*);
46 static tree
interpret_float (const cpp_token
*, unsigned int, const char *,
47 enum overflow_type
*);
48 static tree
interpret_fixed (const cpp_token
*, unsigned int);
49 static enum integer_type_kind narrowest_unsigned_type
50 (unsigned HOST_WIDE_INT
, unsigned HOST_WIDE_INT
, unsigned int);
51 static enum integer_type_kind narrowest_signed_type
52 (unsigned HOST_WIDE_INT
, unsigned HOST_WIDE_INT
, unsigned int);
53 static enum cpp_ttype
lex_string (const cpp_token
*, tree
*, bool, bool);
54 static tree
lex_charconst (const cpp_token
*);
55 static void update_header_times (const char *);
56 static int dump_one_header (splay_tree_node
, void *);
57 static void cb_line_change (cpp_reader
*, const cpp_token
*, int);
58 static void cb_ident (cpp_reader
*, unsigned int, const cpp_string
*);
59 static void cb_def_pragma (cpp_reader
*, unsigned int);
60 static void cb_define (cpp_reader
*, unsigned int, cpp_hashnode
*);
61 static void cb_undef (cpp_reader
*, unsigned int, cpp_hashnode
*);
66 struct cpp_callbacks
*cb
;
67 struct c_fileinfo
*toplevel
;
69 /* The get_fileinfo data structure must be initialized before
70 cpp_read_main_file is called. */
71 toplevel
= get_fileinfo ("<top level>");
72 if (flag_detailed_statistics
)
75 body_time
= get_run_time ();
76 toplevel
->time
= body_time
;
79 cb
= cpp_get_callbacks (parse_in
);
81 cb
->line_change
= cb_line_change
;
83 cb
->def_pragma
= cb_def_pragma
;
84 cb
->valid_pch
= c_common_valid_pch
;
85 cb
->read_pch
= c_common_read_pch
;
87 /* Set the debug callbacks if we can use them. */
88 if ((debug_info_level
== DINFO_LEVEL_VERBOSE
89 && (write_symbols
== DWARF2_DEBUG
90 || write_symbols
== VMS_AND_DWARF2_DEBUG
))
91 || flag_dump_go_spec
!= NULL
)
93 cb
->define
= cb_define
;
99 get_fileinfo (const char *name
)
102 struct c_fileinfo
*fi
;
105 file_info_tree
= splay_tree_new ((splay_tree_compare_fn
) strcmp
,
107 (splay_tree_delete_value_fn
) free
);
109 n
= splay_tree_lookup (file_info_tree
, (splay_tree_key
) name
);
111 return (struct c_fileinfo
*) n
->value
;
113 fi
= XNEW (struct c_fileinfo
);
115 fi
->interface_only
= 0;
116 fi
->interface_unknown
= 1;
117 splay_tree_insert (file_info_tree
, (splay_tree_key
) name
,
118 (splay_tree_value
) fi
);
123 update_header_times (const char *name
)
125 /* Changing files again. This means currently collected time
126 is charged against header time, and body time starts back at 0. */
127 if (flag_detailed_statistics
)
129 int this_time
= get_run_time ();
130 struct c_fileinfo
*file
= get_fileinfo (name
);
131 header_time
+= this_time
- body_time
;
132 file
->time
+= this_time
- body_time
;
133 body_time
= this_time
;
138 dump_one_header (splay_tree_node n
, void * ARG_UNUSED (dummy
))
140 print_time ((const char *) n
->key
,
141 ((struct c_fileinfo
*) n
->value
)->time
);
146 dump_time_statistics (void)
148 struct c_fileinfo
*file
= get_fileinfo (input_filename
);
149 int this_time
= get_run_time ();
150 file
->time
+= this_time
- body_time
;
152 fprintf (stderr
, "\n******\n");
153 print_time ("header files (total)", header_time
);
154 print_time ("main file (total)", this_time
- body_time
);
155 fprintf (stderr
, "ratio = %g : 1\n",
156 (double) header_time
/ (double) (this_time
- body_time
));
157 fprintf (stderr
, "\n******\n");
159 splay_tree_foreach (file_info_tree
, dump_one_header
, 0);
163 cb_ident (cpp_reader
* ARG_UNUSED (pfile
),
164 unsigned int ARG_UNUSED (line
),
165 const cpp_string
* ARG_UNUSED (str
))
169 /* Convert escapes in the string. */
170 cpp_string cstr
= { 0, 0 };
171 if (cpp_interpret_string (pfile
, str
, 1, &cstr
, CPP_STRING
))
173 targetm
.asm_out
.output_ident ((const char *) cstr
.text
);
174 free (CONST_CAST (unsigned char *, cstr
.text
));
179 /* Called at the start of every non-empty line. TOKEN is the first
180 lexed token on the line. Used for diagnostic line numbers. */
182 cb_line_change (cpp_reader
* ARG_UNUSED (pfile
), const cpp_token
*token
,
185 if (token
->type
!= CPP_EOF
&& !parsing_args
)
186 input_location
= token
->src_loc
;
190 fe_file_change (const struct line_map
*new_map
)
195 if (new_map
->reason
== LC_ENTER
)
197 /* Don't stack the main buffer on the input stack;
198 we already did in compile_file. */
199 if (!MAIN_FILE_P (new_map
))
201 unsigned int included_at
= LAST_SOURCE_LINE_LOCATION (new_map
- 1);
203 if (included_at
> BUILTINS_LOCATION
)
204 line
= SOURCE_LINE (new_map
- 1, included_at
);
206 input_location
= new_map
->start_location
;
207 (*debug_hooks
->start_source_file
) (line
, LINEMAP_FILE (new_map
));
210 else if (LINEMAP_SYSP (new_map
) == 2)
213 #ifndef NO_IMPLICIT_EXTERN_C
214 ++pending_lang_change
;
219 else if (new_map
->reason
== LC_LEAVE
)
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 #ifndef NO_IMPLICIT_EXTERN_C
226 --pending_lang_change
;
229 input_location
= new_map
->start_location
;
231 (*debug_hooks
->end_source_file
) (LINEMAP_LINE (new_map
));
234 update_header_times (LINEMAP_FILE (new_map
));
235 input_location
= new_map
->start_location
;
239 cb_def_pragma (cpp_reader
*pfile
, source_location loc
)
241 /* Issue a warning message if we have been asked to do so. Ignore
242 unknown pragmas in system headers unless an explicit
243 -Wunknown-pragmas has been given. */
244 if (warn_unknown_pragmas
> in_system_header
)
246 const unsigned char *space
, *name
;
248 location_t fe_loc
= loc
;
250 space
= name
= (const unsigned char *) "";
251 s
= cpp_get_token (pfile
);
252 if (s
->type
!= CPP_EOF
)
254 space
= cpp_token_as_text (pfile
, s
);
255 s
= cpp_get_token (pfile
);
256 if (s
->type
== CPP_NAME
)
257 name
= cpp_token_as_text (pfile
, s
);
260 warning_at (fe_loc
, OPT_Wunknown_pragmas
, "ignoring #pragma %s %s",
265 /* #define callback for DWARF and DWARF2 debug info. */
267 cb_define (cpp_reader
*pfile
, source_location loc
, cpp_hashnode
*node
)
269 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
270 (*debug_hooks
->define
) (SOURCE_LINE (map
, loc
),
271 (const char *) cpp_macro_definition (pfile
, node
));
274 /* #undef callback for DWARF and DWARF2 debug info. */
276 cb_undef (cpp_reader
* ARG_UNUSED (pfile
), source_location loc
,
279 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
280 (*debug_hooks
->undef
) (SOURCE_LINE (map
, loc
),
281 (const char *) NODE_NAME (node
));
284 /* Read a token and return its type. Fill *VALUE with its value, if
285 applicable. Fill *CPP_FLAGS with the token's flags, if it is
289 c_lex_with_flags (tree
*value
, location_t
*loc
, unsigned char *cpp_flags
,
292 static bool no_more_pch
;
293 const cpp_token
*tok
;
295 unsigned char add_flags
= 0;
296 enum overflow_type overflow
= OT_NONE
;
298 timevar_push (TV_CPP
);
300 tok
= cpp_get_token_with_location (parse_in
, loc
);
310 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
.node
));
315 const char *suffix
= NULL
;
316 unsigned int flags
= cpp_classify_number (parse_in
, tok
, &suffix
, *loc
);
318 switch (flags
& CPP_N_CATEGORY
)
321 /* cpplib has issued an error. */
322 *value
= error_mark_node
;
326 /* C++ uses '0' to mark virtual functions as pure.
327 Set PURE_ZERO to pass this information to the C++ parser. */
328 if (tok
->val
.str
.len
== 1 && *tok
->val
.str
.text
== '0')
329 add_flags
= PURE_ZERO
;
330 *value
= interpret_integer (tok
, flags
, &overflow
);
334 *value
= interpret_float (tok
, flags
, suffix
, &overflow
);
341 if (flags
& CPP_N_USERDEF
)
345 tree suffix_id
= get_identifier (suffix
);
346 int len
= tok
->val
.str
.len
- strlen (suffix
);
347 /* If this is going to be used as a C string to pass to a
348 raw literal operator, we need to add a trailing NUL. */
349 tree num_string
= build_string (len
+ 1,
350 (const char *) tok
->val
.str
.text
);
351 TREE_TYPE (num_string
) = char_array_type_node
;
352 num_string
= fix_string_type (num_string
);
353 str
= CONST_CAST (char *, TREE_STRING_POINTER (num_string
));
355 literal
= build_userdef_literal (suffix_id
, *value
, overflow
,
363 /* An @ may give the next token special significance in Objective-C. */
364 if (c_dialect_objc ())
366 location_t atloc
= *loc
;
370 tok
= cpp_get_token_with_location (parse_in
, &newloc
);
382 type
= lex_string (tok
, value
, true, true);
386 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
.node
));
387 if (OBJC_IS_AT_KEYWORD (C_RID_CODE (*value
))
388 || OBJC_IS_CXX_KEYWORD (C_RID_CODE (*value
)))
391 /* Note the complication: if we found an OBJC_CXX
392 keyword, for example, 'class', we will be
393 returning a token of type CPP_AT_NAME and rid
394 code RID_CLASS (not RID_AT_CLASS). The language
395 parser needs to convert that to RID_AT_CLASS.
403 error_at (atloc
, "stray %<@%> in program");
414 unsigned char name
[8];
416 *cpp_spell_token (parse_in
, tok
, name
, true) = 0;
418 error_at (*loc
, "stray %qs in program", name
);
425 cppchar_t c
= tok
->val
.str
.text
[0];
427 if (c
== '"' || c
== '\'')
428 error ("missing terminating %c character", (int) c
);
429 else if (ISGRAPH (c
))
430 error ("stray %qc in program", (int) c
);
432 error ("stray %<\\%o%> in program", (int) c
);
436 case CPP_CHAR_USERDEF
:
437 case CPP_WCHAR_USERDEF
:
438 case CPP_CHAR16_USERDEF
:
439 case CPP_CHAR32_USERDEF
:
442 cpp_token temp_tok
= *tok
;
443 const char *suffix
= cpp_get_userdef_suffix (tok
);
444 temp_tok
.val
.str
.len
-= strlen (suffix
);
445 temp_tok
.type
= cpp_userdef_char_remove_type (type
);
446 literal
= build_userdef_literal (get_identifier (suffix
),
447 lex_charconst (&temp_tok
),
457 *value
= lex_charconst (tok
);
460 case CPP_STRING_USERDEF
:
461 case CPP_WSTRING_USERDEF
:
462 case CPP_STRING16_USERDEF
:
463 case CPP_STRING32_USERDEF
:
464 case CPP_UTF8STRING_USERDEF
:
466 tree literal
, string
;
467 const char *suffix
= cpp_get_userdef_suffix (tok
);
468 string
= build_string (tok
->val
.str
.len
- strlen (suffix
),
469 (const char *) tok
->val
.str
.text
);
470 literal
= build_userdef_literal (get_identifier (suffix
),
471 string
, OT_NONE
, NULL_TREE
);
481 if ((lex_flags
& C_LEX_STRING_NO_JOIN
) == 0)
483 type
= lex_string (tok
, value
, false,
484 (lex_flags
& C_LEX_STRING_NO_TRANSLATE
) == 0);
487 *value
= build_string (tok
->val
.str
.len
, (const char *) tok
->val
.str
.text
);
491 *value
= build_int_cst (integer_type_node
, tok
->val
.pragma
);
494 /* These tokens should not be visible outside cpplib. */
495 case CPP_HEADER_NAME
:
499 /* CPP_COMMENT will appear when compiling with -C and should be
510 *cpp_flags
= tok
->flags
| add_flags
;
515 c_common_no_more_pch ();
518 timevar_pop (TV_CPP
);
523 /* Returns the narrowest C-visible unsigned type, starting with the
524 minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
527 static enum integer_type_kind
528 narrowest_unsigned_type (unsigned HOST_WIDE_INT low
,
529 unsigned HOST_WIDE_INT high
,
534 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
535 itk
= itk_unsigned_int
;
536 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
537 itk
= itk_unsigned_long
;
539 itk
= itk_unsigned_long_long
;
541 for (; itk
< itk_none
; itk
+= 2 /* skip unsigned types */)
545 if (integer_types
[itk
] == NULL_TREE
)
547 upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
549 if ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) > high
550 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) == high
551 && TREE_INT_CST_LOW (upper
) >= low
))
552 return (enum integer_type_kind
) itk
;
558 /* Ditto, but narrowest signed type. */
559 static enum integer_type_kind
560 narrowest_signed_type (unsigned HOST_WIDE_INT low
,
561 unsigned HOST_WIDE_INT high
, unsigned int flags
)
565 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
567 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
573 for (; itk
< itk_none
; itk
+= 2 /* skip signed types */)
577 if (integer_types
[itk
] == NULL_TREE
)
579 upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
581 if ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) > high
582 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) == high
583 && TREE_INT_CST_LOW (upper
) >= low
))
584 return (enum integer_type_kind
) itk
;
590 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
592 interpret_integer (const cpp_token
*token
, unsigned int flags
,
593 enum overflow_type
*overflow
)
596 enum integer_type_kind itk
;
601 integer
= cpp_interpret_integer (parse_in
, token
, flags
);
602 if (integer
.overflow
)
603 *overflow
= OT_OVERFLOW
;
605 /* The type of a constant with a U suffix is straightforward. */
606 if (flags
& CPP_N_UNSIGNED
)
607 itk
= narrowest_unsigned_type (integer
.low
, integer
.high
, flags
);
610 /* The type of a potentially-signed integer constant varies
611 depending on the base it's in, the standard in use, and the
613 enum integer_type_kind itk_u
614 = narrowest_unsigned_type (integer
.low
, integer
.high
, flags
);
615 enum integer_type_kind itk_s
616 = narrowest_signed_type (integer
.low
, integer
.high
, flags
);
618 /* In both C89 and C99, octal and hex constants may be signed or
619 unsigned, whichever fits tighter. We do not warn about this
620 choice differing from the traditional choice, as the constant
621 is probably a bit pattern and either way will work. */
622 if ((flags
& CPP_N_RADIX
) != CPP_N_DECIMAL
)
623 itk
= MIN (itk_u
, itk_s
);
626 /* In C99, decimal constants are always signed.
627 In C89, decimal constants that don't fit in long have
628 undefined behavior; we try to make them unsigned long.
629 In GCC's extended C89, that last is true of decimal
630 constants that don't fit in long long, too. */
633 if (itk_s
> itk_u
&& itk_s
> itk_long
)
637 if (itk_u
< itk_unsigned_long
)
638 itk_u
= itk_unsigned_long
;
640 warning (0, "this decimal constant is unsigned only in ISO C90");
643 warning (OPT_Wtraditional
,
644 "this decimal constant would be unsigned in ISO C90");
650 /* cpplib has already issued a warning for overflow. */
651 type
= ((flags
& CPP_N_UNSIGNED
)
652 ? widest_unsigned_literal_type_node
653 : widest_integer_literal_type_node
);
656 type
= integer_types
[itk
];
657 if (itk
> itk_unsigned_long
658 && (flags
& CPP_N_WIDTH
) != CPP_N_LARGE
)
660 ((c_dialect_cxx () ? cxx_dialect
== cxx98
: !flag_isoc99
)
661 ? DK_PEDWARN
: DK_WARNING
,
662 input_location
, OPT_Wlong_long
,
663 (flags
& CPP_N_UNSIGNED
)
664 ? "integer constant is too large for %<unsigned long%> type"
665 : "integer constant is too large for %<long%> type");
668 value
= build_int_cst_wide (type
, integer
.low
, integer
.high
);
670 /* Convert imaginary to a complex type. */
671 if (flags
& CPP_N_IMAGINARY
)
672 value
= build_complex (NULL_TREE
, build_int_cst (type
, 0), value
);
677 /* Interpret TOKEN, a floating point number with FLAGS as classified
678 by cpplib. For C++0X SUFFIX may contain a user-defined literal suffix. */
680 interpret_float (const cpp_token
*token
, unsigned int flags
,
681 const char *suffix
, enum overflow_type
*overflow
)
686 REAL_VALUE_TYPE real
;
687 REAL_VALUE_TYPE real_trunc
;
693 /* Default (no suffix) depends on whether the FLOAT_CONST_DECIMAL64
694 pragma has been used and is either double or _Decimal64. Types
695 that are not allowed with decimal float default to double. */
696 if (flags
& CPP_N_DEFAULT
)
698 flags
^= CPP_N_DEFAULT
;
699 flags
|= CPP_N_MEDIUM
;
701 if (((flags
& CPP_N_HEX
) == 0) && ((flags
& CPP_N_IMAGINARY
) == 0))
703 warning (OPT_Wunsuffixed_float_constants
,
704 "unsuffixed float constant");
705 if (float_const_decimal64_p ())
706 flags
|= CPP_N_DFLOAT
;
710 /* Decode _Fract and _Accum. */
711 if (flags
& CPP_N_FRACT
|| flags
& CPP_N_ACCUM
)
712 return interpret_fixed (token
, flags
);
714 /* Decode type based on width and properties. */
715 if (flags
& CPP_N_DFLOAT
)
716 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
717 type
= dfloat128_type_node
;
718 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
719 type
= dfloat32_type_node
;
721 type
= dfloat64_type_node
;
723 if (flags
& CPP_N_WIDTH_MD
)
726 enum machine_mode mode
;
728 if ((flags
& CPP_N_WIDTH_MD
) == CPP_N_MD_W
)
733 mode
= targetm
.c
.mode_for_suffix (suffix
);
734 if (mode
== VOIDmode
)
736 error ("unsupported non-standard suffix on floating constant");
738 return error_mark_node
;
741 pedwarn (input_location
, OPT_Wpedantic
, "non-standard suffix on floating constant");
743 type
= c_common_type_for_mode (mode
, 0);
746 else if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
747 type
= long_double_type_node
;
748 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
749 || flag_single_precision_constant
)
750 type
= float_type_node
;
752 type
= double_type_node
;
754 const_type
= excess_precision_type (type
);
758 /* Copy the constant to a nul-terminated buffer. If the constant
759 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
760 can't handle them. */
761 copylen
= token
->val
.str
.len
;
762 if (flags
& CPP_N_USERDEF
)
763 copylen
-= strlen (suffix
);
764 else if (flags
& CPP_N_DFLOAT
)
768 if ((flags
& CPP_N_WIDTH
) != CPP_N_MEDIUM
)
769 /* Must be an F or L or machine defined suffix. */
771 if (flags
& CPP_N_IMAGINARY
)
776 copy
= (char *) alloca (copylen
+ 1);
777 if (cxx_dialect
> cxx11
)
780 for (size_t i
= 0; i
< copylen
; ++i
)
781 if (token
->val
.str
.text
[i
] != '\'')
782 copy
[maxlen
++] = token
->val
.str
.text
[i
];
787 memcpy (copy
, token
->val
.str
.text
, copylen
);
788 copy
[copylen
] = '\0';
791 real_from_string3 (&real
, copy
, TYPE_MODE (const_type
));
792 if (const_type
!= type
)
793 /* Diagnosing if the result of converting the value with excess
794 precision to the semantic type would overflow (with associated
795 double rounding) is more appropriate than diagnosing if the
796 result of converting the string directly to the semantic type
798 real_convert (&real_trunc
, TYPE_MODE (type
), &real
);
800 /* Both C and C++ require a diagnostic for a floating constant
801 outside the range of representable values of its type. Since we
802 have __builtin_inf* to produce an infinity, this is now a
803 mandatory pedwarn if the target does not support infinities. */
804 if (REAL_VALUE_ISINF (real
)
805 || (const_type
!= type
&& REAL_VALUE_ISINF (real_trunc
)))
807 *overflow
= OT_OVERFLOW
;
808 if (!(flags
& CPP_N_USERDEF
))
810 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)))
811 pedwarn (input_location
, 0,
812 "floating constant exceeds range of %qT", type
);
814 warning (OPT_Woverflow
,
815 "floating constant exceeds range of %qT", type
);
818 /* We also give a warning if the value underflows. */
819 else if (REAL_VALUES_EQUAL (real
, dconst0
)
820 || (const_type
!= type
821 && REAL_VALUES_EQUAL (real_trunc
, dconst0
)))
823 REAL_VALUE_TYPE realvoidmode
;
824 int oflow
= real_from_string (&realvoidmode
, copy
);
825 *overflow
= (oflow
== 0 ? OT_NONE
826 : (oflow
< 0 ? OT_UNDERFLOW
: OT_OVERFLOW
));
827 if (!(flags
& CPP_N_USERDEF
))
829 if (oflow
< 0 || !REAL_VALUES_EQUAL (realvoidmode
, dconst0
))
830 warning (OPT_Woverflow
, "floating constant truncated to zero");
834 /* Create a node with determined type and value. */
835 value
= build_real (const_type
, real
);
836 if (flags
& CPP_N_IMAGINARY
)
838 value
= build_complex (NULL_TREE
, convert (const_type
,
839 integer_zero_node
), value
);
840 if (type
!= const_type
)
842 const_type
= TREE_TYPE (value
);
843 type
= build_complex_type (type
);
847 if (type
!= const_type
)
848 value
= build1 (EXCESS_PRECISION_EXPR
, type
, value
);
853 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
857 interpret_fixed (const cpp_token
*token
, unsigned int flags
)
861 FIXED_VALUE_TYPE fixed
;
865 copylen
= token
->val
.str
.len
;
867 if (flags
& CPP_N_FRACT
) /* _Fract. */
869 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Fract. */
871 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
873 type
= unsigned_long_long_fract_type_node
;
876 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
878 type
= unsigned_long_fract_type_node
;
881 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
883 type
= unsigned_short_fract_type_node
;
888 type
= unsigned_fract_type_node
;
892 else /* Signed _Fract. */
894 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
896 type
= long_long_fract_type_node
;
899 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
901 type
= long_fract_type_node
;
904 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
906 type
= short_fract_type_node
;
911 type
= fract_type_node
;
918 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Accum. */
920 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
922 type
= unsigned_long_long_accum_type_node
;
925 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
927 type
= unsigned_long_accum_type_node
;
930 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
932 type
= unsigned_short_accum_type_node
;
937 type
= unsigned_accum_type_node
;
941 else /* Signed _Accum. */
943 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
945 type
= long_long_accum_type_node
;
948 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
950 type
= long_accum_type_node
;
953 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
955 type
= short_accum_type_node
;
960 type
= accum_type_node
;
966 copy
= (char *) alloca (copylen
+ 1);
967 memcpy (copy
, token
->val
.str
.text
, copylen
);
968 copy
[copylen
] = '\0';
970 fixed_from_string (&fixed
, copy
, TYPE_MODE (type
));
972 /* Create a node with determined type and value. */
973 value
= build_fixed (type
, fixed
);
978 /* Convert a series of STRING, WSTRING, STRING16, STRING32 and/or
979 UTF8STRING tokens into a tree, performing string constant
980 concatenation. TOK is the first of these. VALP is the location to
981 write the string into. OBJC_STRING indicates whether an '@' token
982 preceded the incoming token (in that case, the strings can either
983 be ObjC strings, preceded by a single '@', or normal strings, not
984 preceded by '@'. The result will be a CPP_OBJC_STRING). Returns
985 the CPP token type of the result (CPP_STRING, CPP_WSTRING,
986 CPP_STRING32, CPP_STRING16, CPP_UTF8STRING, or CPP_OBJC_STRING).
988 This is unfortunately more work than it should be. If any of the
989 strings in the series has an L prefix, the result is a wide string
990 (6.4.5p4). Whether or not the result is a wide string affects the
991 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
992 sequences do not continue across the boundary between two strings in
993 a series (6.4.5p7), so we must not lose the boundaries. Therefore
994 cpp_interpret_string takes a vector of cpp_string structures, which
995 we must arrange to provide. */
997 static enum cpp_ttype
998 lex_string (const cpp_token
*tok
, tree
*valp
, bool objc_string
, bool translate
)
1002 struct obstack str_ob
;
1004 enum cpp_ttype type
= tok
->type
;
1006 /* Try to avoid the overhead of creating and destroying an obstack
1007 for the common case of just one string. */
1008 cpp_string str
= tok
->val
.str
;
1009 cpp_string
*strs
= &str
;
1011 /* objc_at_sign_was_seen is only used when doing Objective-C string
1012 concatenation. It is 'true' if we have seen an '@' before the
1013 current string, and 'false' if not. We must see exactly one or
1014 zero '@' before each string. */
1015 bool objc_at_sign_was_seen
= false;
1018 tok
= cpp_get_token (parse_in
);
1026 if (objc_at_sign_was_seen
)
1027 error ("repeated %<@%> before Objective-C string");
1029 objc_at_sign_was_seen
= true;
1040 case CPP_UTF8STRING
:
1041 if (type
!= tok
->type
)
1043 if (type
== CPP_STRING
)
1046 error ("unsupported non-standard concatenation of string literals");
1052 gcc_obstack_init (&str_ob
);
1053 obstack_grow (&str_ob
, &str
, sizeof (cpp_string
));
1057 obstack_grow (&str_ob
, &tok
->val
.str
, sizeof (cpp_string
));
1059 objc_at_sign_was_seen
= false;
1063 /* It is an error if we saw a '@' with no following string. */
1064 if (objc_at_sign_was_seen
)
1065 error ("stray %<@%> in program");
1067 /* We have read one more token than we want. */
1068 _cpp_backup_tokens (parse_in
, 1);
1070 strs
= XOBFINISH (&str_ob
, cpp_string
*);
1072 if (concats
&& !objc_string
&& !in_system_header
)
1073 warning (OPT_Wtraditional
,
1074 "traditional C rejects string constant concatenation");
1077 ? cpp_interpret_string
: cpp_interpret_string_notranslate
)
1078 (parse_in
, strs
, concats
+ 1, &istr
, type
))
1080 value
= build_string (istr
.len
, (const char *) istr
.text
);
1081 free (CONST_CAST (unsigned char *, istr
.text
));
1085 /* Callers cannot generally handle error_mark_node in this context,
1086 so return the empty string instead. cpp_interpret_string has
1092 case CPP_UTF8STRING
:
1093 value
= build_string (1, "");
1096 value
= build_string (TYPE_PRECISION (char16_type_node
)
1097 / TYPE_PRECISION (char_type_node
),
1098 "\0"); /* char16_t is 16 bits */
1101 value
= build_string (TYPE_PRECISION (char32_type_node
)
1102 / TYPE_PRECISION (char_type_node
),
1103 "\0\0\0"); /* char32_t is 32 bits */
1106 value
= build_string (TYPE_PRECISION (wchar_type_node
)
1107 / TYPE_PRECISION (char_type_node
),
1108 "\0\0\0"); /* widest supported wchar_t
1118 case CPP_UTF8STRING
:
1119 TREE_TYPE (value
) = char_array_type_node
;
1122 TREE_TYPE (value
) = char16_array_type_node
;
1125 TREE_TYPE (value
) = char32_array_type_node
;
1128 TREE_TYPE (value
) = wchar_array_type_node
;
1130 *valp
= fix_string_type (value
);
1133 obstack_free (&str_ob
, 0);
1135 return objc_string
? CPP_OBJC_STRING
: type
;
1138 /* Converts a (possibly wide) character constant token into a tree. */
1140 lex_charconst (const cpp_token
*token
)
1144 unsigned int chars_seen
;
1147 result
= cpp_interpret_charconst (parse_in
, token
,
1148 &chars_seen
, &unsignedp
);
1150 if (token
->type
== CPP_WCHAR
)
1151 type
= wchar_type_node
;
1152 else if (token
->type
== CPP_CHAR32
)
1153 type
= char32_type_node
;
1154 else if (token
->type
== CPP_CHAR16
)
1155 type
= char16_type_node
;
1156 /* In C, a character constant has type 'int'.
1157 In C++ 'char', but multi-char charconsts have type 'int'. */
1158 else if (!c_dialect_cxx () || chars_seen
> 1)
1159 type
= integer_type_node
;
1161 type
= char_type_node
;
1163 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1164 before possibly widening to HOST_WIDE_INT for build_int_cst. */
1165 if (unsignedp
|| (cppchar_signed_t
) result
>= 0)
1166 value
= build_int_cst_wide (type
, result
, 0);
1168 value
= build_int_cst_wide (type
, (cppchar_signed_t
) result
, -1);