1 /* Mainly the interface between cpplib and the C front ends.
2 Copyright (C) 1987, 1988, 1989, 1992, 1994, 1995, 1996, 1997
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
41 #include "splay-tree.h"
45 /* We may keep statistics about how long which files took to compile. */
46 static int header_time
, body_time
;
47 static splay_tree file_info_tree
;
49 int pending_lang_change
; /* If we need to switch languages - C++ only */
50 int c_header_level
; /* depth in C headers - C++ only */
52 static tree
interpret_integer (const cpp_token
*, unsigned int);
53 static tree
interpret_float (const cpp_token
*, unsigned int);
54 static tree
interpret_fixed (const cpp_token
*, unsigned int);
55 static enum integer_type_kind narrowest_unsigned_type
56 (unsigned HOST_WIDE_INT
, unsigned HOST_WIDE_INT
, unsigned int);
57 static enum integer_type_kind narrowest_signed_type
58 (unsigned HOST_WIDE_INT
, unsigned HOST_WIDE_INT
, unsigned int);
59 static enum cpp_ttype
lex_string (const cpp_token
*, tree
*, bool, bool);
60 static tree
lex_charconst (const cpp_token
*);
61 static void update_header_times (const char *);
62 static int dump_one_header (splay_tree_node
, void *);
63 static void cb_line_change (cpp_reader
*, const cpp_token
*, int);
64 static void cb_ident (cpp_reader
*, unsigned int, const cpp_string
*);
65 static void cb_def_pragma (cpp_reader
*, unsigned int);
66 static void cb_define (cpp_reader
*, unsigned int, cpp_hashnode
*);
67 static void cb_undef (cpp_reader
*, unsigned int, cpp_hashnode
*);
72 struct cpp_callbacks
*cb
;
73 struct c_fileinfo
*toplevel
;
75 /* The get_fileinfo data structure must be initialized before
76 cpp_read_main_file is called. */
77 toplevel
= get_fileinfo ("<top level>");
78 if (flag_detailed_statistics
)
81 body_time
= get_run_time ();
82 toplevel
->time
= body_time
;
85 cb
= cpp_get_callbacks (parse_in
);
87 cb
->line_change
= cb_line_change
;
89 cb
->def_pragma
= cb_def_pragma
;
90 cb
->valid_pch
= c_common_valid_pch
;
91 cb
->read_pch
= c_common_read_pch
;
93 /* Set the debug callbacks if we can use them. */
94 if (debug_info_level
== DINFO_LEVEL_VERBOSE
95 && (write_symbols
== DWARF2_DEBUG
96 || write_symbols
== VMS_AND_DWARF2_DEBUG
))
98 cb
->define
= cb_define
;
104 get_fileinfo (const char *name
)
107 struct c_fileinfo
*fi
;
110 file_info_tree
= splay_tree_new ((splay_tree_compare_fn
) strcmp
,
112 (splay_tree_delete_value_fn
) free
);
114 n
= splay_tree_lookup (file_info_tree
, (splay_tree_key
) name
);
116 return (struct c_fileinfo
*) n
->value
;
118 fi
= XNEW (struct c_fileinfo
);
120 fi
->interface_only
= 0;
121 fi
->interface_unknown
= 1;
122 splay_tree_insert (file_info_tree
, (splay_tree_key
) name
,
123 (splay_tree_value
) fi
);
128 update_header_times (const char *name
)
130 /* Changing files again. This means currently collected time
131 is charged against header time, and body time starts back at 0. */
132 if (flag_detailed_statistics
)
134 int this_time
= get_run_time ();
135 struct c_fileinfo
*file
= get_fileinfo (name
);
136 header_time
+= this_time
- body_time
;
137 file
->time
+= this_time
- body_time
;
138 body_time
= this_time
;
143 dump_one_header (splay_tree_node n
, void * ARG_UNUSED (dummy
))
145 print_time ((const char *) n
->key
,
146 ((struct c_fileinfo
*) n
->value
)->time
);
151 dump_time_statistics (void)
153 struct c_fileinfo
*file
= get_fileinfo (input_filename
);
154 int this_time
= get_run_time ();
155 file
->time
+= this_time
- body_time
;
157 fprintf (stderr
, "\n******\n");
158 print_time ("header files (total)", header_time
);
159 print_time ("main file (total)", this_time
- body_time
);
160 fprintf (stderr
, "ratio = %g : 1\n",
161 (double) header_time
/ (double) (this_time
- body_time
));
162 fprintf (stderr
, "\n******\n");
164 splay_tree_foreach (file_info_tree
, dump_one_header
, 0);
168 cb_ident (cpp_reader
* ARG_UNUSED (pfile
),
169 unsigned int ARG_UNUSED (line
),
170 const cpp_string
* ARG_UNUSED (str
))
172 #ifdef ASM_OUTPUT_IDENT
175 /* Convert escapes in the string. */
176 cpp_string cstr
= { 0, 0 };
177 if (cpp_interpret_string (pfile
, str
, 1, &cstr
, CPP_STRING
))
179 ASM_OUTPUT_IDENT (asm_out_file
, (const char *) cstr
.text
);
180 free (CONST_CAST (unsigned char *, cstr
.text
));
186 /* Called at the start of every non-empty line. TOKEN is the first
187 lexed token on the line. Used for diagnostic line numbers. */
189 cb_line_change (cpp_reader
* ARG_UNUSED (pfile
), const cpp_token
*token
,
192 if (token
->type
!= CPP_EOF
&& !parsing_args
)
193 input_location
= token
->src_loc
;
197 fe_file_change (const struct line_map
*new_map
)
202 if (new_map
->reason
== LC_ENTER
)
204 /* Don't stack the main buffer on the input stack;
205 we already did in compile_file. */
206 if (!MAIN_FILE_P (new_map
))
208 int included_at
= LAST_SOURCE_LINE_LOCATION (new_map
- 1);
210 input_location
= new_map
->start_location
;
211 (*debug_hooks
->start_source_file
) (included_at
, new_map
->to_file
);
212 #ifndef NO_IMPLICIT_EXTERN_C
215 else if (new_map
->sysp
== 2)
218 ++pending_lang_change
;
223 else if (new_map
->reason
== LC_LEAVE
)
225 #ifndef NO_IMPLICIT_EXTERN_C
226 if (c_header_level
&& --c_header_level
== 0)
228 if (new_map
->sysp
== 2)
229 warning (0, "badly nested C headers from preprocessor");
230 --pending_lang_change
;
233 input_location
= new_map
->start_location
;
235 (*debug_hooks
->end_source_file
) (new_map
->to_line
);
238 update_header_times (new_map
->to_file
);
239 in_system_header
= new_map
->sysp
!= 0;
240 input_location
= new_map
->start_location
;
244 cb_def_pragma (cpp_reader
*pfile
, source_location loc
)
246 /* Issue a warning message if we have been asked to do so. Ignore
247 unknown pragmas in system headers unless an explicit
248 -Wunknown-pragmas has been given. */
249 if (warn_unknown_pragmas
> in_system_header
)
251 const unsigned char *space
, *name
;
253 location_t fe_loc
= loc
;
255 space
= name
= (const unsigned char *) "";
256 s
= cpp_get_token (pfile
);
257 if (s
->type
!= CPP_EOF
)
259 space
= cpp_token_as_text (pfile
, s
);
260 s
= cpp_get_token (pfile
);
261 if (s
->type
== CPP_NAME
)
262 name
= cpp_token_as_text (pfile
, s
);
265 warning (OPT_Wunknown_pragmas
, "%Hignoring #pragma %s %s",
266 &fe_loc
, space
, name
);
270 /* #define callback for DWARF and DWARF2 debug info. */
272 cb_define (cpp_reader
*pfile
, source_location loc
, cpp_hashnode
*node
)
274 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
275 (*debug_hooks
->define
) (SOURCE_LINE (map
, loc
),
276 (const char *) cpp_macro_definition (pfile
, node
));
279 /* #undef callback for DWARF and DWARF2 debug info. */
281 cb_undef (cpp_reader
* ARG_UNUSED (pfile
), source_location loc
,
284 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
285 (*debug_hooks
->undef
) (SOURCE_LINE (map
, loc
),
286 (const char *) NODE_NAME (node
));
289 /* Read a token and return its type. Fill *VALUE with its value, if
290 applicable. Fill *CPP_FLAGS with the token's flags, if it is
294 c_lex_with_flags (tree
*value
, location_t
*loc
, unsigned char *cpp_flags
,
297 static bool no_more_pch
;
298 const cpp_token
*tok
;
300 unsigned char add_flags
= 0;
302 timevar_push (TV_CPP
);
304 tok
= cpp_get_token_with_location (parse_in
, loc
);
314 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
));
319 unsigned int flags
= cpp_classify_number (parse_in
, tok
);
321 switch (flags
& CPP_N_CATEGORY
)
324 /* cpplib has issued an error. */
325 *value
= error_mark_node
;
330 /* C++ uses '0' to mark virtual functions as pure.
331 Set PURE_ZERO to pass this information to the C++ parser. */
332 if (tok
->val
.str
.len
== 1 && *tok
->val
.str
.text
== '0')
333 add_flags
= PURE_ZERO
;
334 *value
= interpret_integer (tok
, flags
);
338 *value
= interpret_float (tok
, flags
);
348 /* An @ may give the next token special significance in Objective-C. */
349 if (c_dialect_objc ())
351 location_t atloc
= *loc
;
355 tok
= cpp_get_token_with_location (parse_in
, &newloc
);
366 type
= lex_string (tok
, value
, true, true);
370 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
));
371 if (objc_is_reserved_word (*value
))
380 error ("%Hstray %<@%> in program", &atloc
);
391 unsigned char name
[4];
393 *cpp_spell_token (parse_in
, tok
, name
, true) = 0;
395 error ("stray %qs in program", name
);
402 cppchar_t c
= tok
->val
.str
.text
[0];
404 if (c
== '"' || c
== '\'')
405 error ("missing terminating %c character", (int) c
);
406 else if (ISGRAPH (c
))
407 error ("stray %qc in program", (int) c
);
409 error ("stray %<\\%o%> in program", (int) c
);
417 *value
= lex_charconst (tok
);
424 if ((lex_flags
& C_LEX_RAW_STRINGS
) == 0)
426 type
= lex_string (tok
, value
, false,
427 (lex_flags
& C_LEX_STRING_NO_TRANSLATE
) == 0);
430 *value
= build_string (tok
->val
.str
.len
, (const char *) tok
->val
.str
.text
);
434 *value
= build_int_cst (NULL
, tok
->val
.pragma
);
437 /* These tokens should not be visible outside cpplib. */
438 case CPP_HEADER_NAME
:
449 *cpp_flags
= tok
->flags
| add_flags
;
454 c_common_no_more_pch ();
457 timevar_pop (TV_CPP
);
462 /* Returns the narrowest C-visible unsigned type, starting with the
463 minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
466 static enum integer_type_kind
467 narrowest_unsigned_type (unsigned HOST_WIDE_INT low
,
468 unsigned HOST_WIDE_INT high
,
471 enum integer_type_kind itk
;
473 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
474 itk
= itk_unsigned_int
;
475 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
476 itk
= itk_unsigned_long
;
478 itk
= itk_unsigned_long_long
;
480 for (; itk
< itk_none
; itk
+= 2 /* skip unsigned types */)
482 tree upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
484 if ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) > high
485 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) == high
486 && TREE_INT_CST_LOW (upper
) >= low
))
493 /* Ditto, but narrowest signed type. */
494 static enum integer_type_kind
495 narrowest_signed_type (unsigned HOST_WIDE_INT low
,
496 unsigned HOST_WIDE_INT high
, unsigned int flags
)
498 enum integer_type_kind itk
;
500 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
502 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
508 for (; itk
< itk_none
; itk
+= 2 /* skip signed types */)
510 tree upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
512 if ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) > high
513 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) == high
514 && TREE_INT_CST_LOW (upper
) >= low
))
521 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
523 interpret_integer (const cpp_token
*token
, unsigned int flags
)
526 enum integer_type_kind itk
;
528 cpp_options
*options
= cpp_get_options (parse_in
);
530 integer
= cpp_interpret_integer (parse_in
, token
, flags
);
531 integer
= cpp_num_sign_extend (integer
, options
->precision
);
533 /* The type of a constant with a U suffix is straightforward. */
534 if (flags
& CPP_N_UNSIGNED
)
535 itk
= narrowest_unsigned_type (integer
.low
, integer
.high
, flags
);
538 /* The type of a potentially-signed integer constant varies
539 depending on the base it's in, the standard in use, and the
541 enum integer_type_kind itk_u
542 = narrowest_unsigned_type (integer
.low
, integer
.high
, flags
);
543 enum integer_type_kind itk_s
544 = narrowest_signed_type (integer
.low
, integer
.high
, flags
);
546 /* In both C89 and C99, octal and hex constants may be signed or
547 unsigned, whichever fits tighter. We do not warn about this
548 choice differing from the traditional choice, as the constant
549 is probably a bit pattern and either way will work. */
550 if ((flags
& CPP_N_RADIX
) != CPP_N_DECIMAL
)
551 itk
= MIN (itk_u
, itk_s
);
554 /* In C99, decimal constants are always signed.
555 In C89, decimal constants that don't fit in long have
556 undefined behavior; we try to make them unsigned long.
557 In GCC's extended C89, that last is true of decimal
558 constants that don't fit in long long, too. */
561 if (itk_s
> itk_u
&& itk_s
> itk_long
)
565 if (itk_u
< itk_unsigned_long
)
566 itk_u
= itk_unsigned_long
;
568 warning (0, "this decimal constant is unsigned only in ISO C90");
571 warning (OPT_Wtraditional
,
572 "this decimal constant would be unsigned in ISO C90");
578 /* cpplib has already issued a warning for overflow. */
579 type
= ((flags
& CPP_N_UNSIGNED
)
580 ? widest_unsigned_literal_type_node
581 : widest_integer_literal_type_node
);
583 type
= integer_types
[itk
];
585 if (itk
> itk_unsigned_long
586 && (flags
& CPP_N_WIDTH
) != CPP_N_LARGE
587 && !in_system_header
&& !flag_isoc99
)
588 pedwarn ("integer constant is too large for %qs type",
589 (flags
& CPP_N_UNSIGNED
) ? "unsigned long" : "long");
591 value
= build_int_cst_wide (type
, integer
.low
, integer
.high
);
593 /* Convert imaginary to a complex type. */
594 if (flags
& CPP_N_IMAGINARY
)
595 value
= build_complex (NULL_TREE
, build_int_cst (type
, 0), value
);
600 /* Interpret TOKEN, a floating point number with FLAGS as classified
603 interpret_float (const cpp_token
*token
, unsigned int flags
)
607 REAL_VALUE_TYPE real
;
611 /* Decode _Fract and _Accum. */
612 if (flags
& CPP_N_FRACT
|| flags
& CPP_N_ACCUM
)
613 return interpret_fixed (token
, flags
);
615 /* Decode type based on width and properties. */
616 if (flags
& CPP_N_DFLOAT
)
617 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
618 type
= dfloat128_type_node
;
619 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
620 type
= dfloat32_type_node
;
622 type
= dfloat64_type_node
;
624 if (flags
& CPP_N_WIDTH_MD
)
627 enum machine_mode mode
;
629 if ((flags
& CPP_N_WIDTH_MD
) == CPP_N_MD_W
)
634 mode
= targetm
.c
.mode_for_suffix (suffix
);
635 if (mode
== VOIDmode
)
637 error ("unsupported non-standard suffix on floating constant");
640 return error_mark_node
;
643 pedwarn ("non-standard suffix on floating constant");
645 type
= c_common_type_for_mode (mode
, 0);
648 else if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
649 type
= long_double_type_node
;
650 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
651 || flag_single_precision_constant
)
652 type
= float_type_node
;
654 type
= double_type_node
;
656 /* Copy the constant to a nul-terminated buffer. If the constant
657 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
658 can't handle them. */
659 copylen
= token
->val
.str
.len
;
660 if (flags
& CPP_N_DFLOAT
)
664 if ((flags
& CPP_N_WIDTH
) != CPP_N_MEDIUM
)
665 /* Must be an F or L or machine defined suffix. */
667 if (flags
& CPP_N_IMAGINARY
)
672 copy
= (char *) alloca (copylen
+ 1);
673 memcpy (copy
, token
->val
.str
.text
, copylen
);
674 copy
[copylen
] = '\0';
676 real_from_string3 (&real
, copy
, TYPE_MODE (type
));
678 /* Both C and C++ require a diagnostic for a floating constant
679 outside the range of representable values of its type. Since we
680 have __builtin_inf* to produce an infinity, this is now a
681 mandatory pedwarn if the target does not support infinities. */
682 if (REAL_VALUE_ISINF (real
))
684 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)))
685 pedwarn ("floating constant exceeds range of %qT", type
);
687 warning (OPT_Woverflow
, "floating constant exceeds range of %qT", type
);
689 /* We also give a warning if the value underflows. */
690 else if (REAL_VALUES_EQUAL (real
, dconst0
))
692 REAL_VALUE_TYPE realvoidmode
;
693 int overflow
= real_from_string (&realvoidmode
, copy
);
694 if (overflow
< 0 || !REAL_VALUES_EQUAL (realvoidmode
, dconst0
))
695 warning (OPT_Woverflow
, "floating constant truncated to zero");
698 /* Create a node with determined type and value. */
699 value
= build_real (type
, real
);
700 if (flags
& CPP_N_IMAGINARY
)
701 value
= build_complex (NULL_TREE
, convert (type
, integer_zero_node
), value
);
706 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
710 interpret_fixed (const cpp_token
*token
, unsigned int flags
)
714 FIXED_VALUE_TYPE fixed
;
718 copylen
= token
->val
.str
.len
;
720 if (flags
& CPP_N_FRACT
) /* _Fract. */
722 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Fract. */
724 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
726 type
= unsigned_long_long_fract_type_node
;
729 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
731 type
= unsigned_long_fract_type_node
;
734 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
736 type
= unsigned_short_fract_type_node
;
741 type
= unsigned_fract_type_node
;
745 else /* Signed _Fract. */
747 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
749 type
= long_long_fract_type_node
;
752 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
754 type
= long_fract_type_node
;
757 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
759 type
= short_fract_type_node
;
764 type
= fract_type_node
;
771 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Accum. */
773 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
775 type
= unsigned_long_long_accum_type_node
;
778 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
780 type
= unsigned_long_accum_type_node
;
783 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
785 type
= unsigned_short_accum_type_node
;
790 type
= unsigned_accum_type_node
;
794 else /* Signed _Accum. */
796 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
798 type
= long_long_accum_type_node
;
801 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
803 type
= long_accum_type_node
;
806 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
808 type
= short_accum_type_node
;
813 type
= accum_type_node
;
819 copy
= (char *) alloca (copylen
+ 1);
820 memcpy (copy
, token
->val
.str
.text
, copylen
);
821 copy
[copylen
] = '\0';
823 fixed_from_string (&fixed
, copy
, TYPE_MODE (type
));
825 /* Create a node with determined type and value. */
826 value
= build_fixed (type
, fixed
);
831 /* Convert a series of STRING, WSTRING, STRING16 and/or STRING32 tokens
832 into a tree, performing string constant concatenation. TOK is the
833 first of these. VALP is the location to write the string into.
834 OBJC_STRING indicates whether an '@' token preceded the incoming token.
835 Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
836 CPP_STRING32, CPP_STRING16, or CPP_OBJC_STRING).
838 This is unfortunately more work than it should be. If any of the
839 strings in the series has an L prefix, the result is a wide string
840 (6.4.5p4). Whether or not the result is a wide string affects the
841 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
842 sequences do not continue across the boundary between two strings in
843 a series (6.4.5p7), so we must not lose the boundaries. Therefore
844 cpp_interpret_string takes a vector of cpp_string structures, which
845 we must arrange to provide. */
847 static enum cpp_ttype
848 lex_string (const cpp_token
*tok
, tree
*valp
, bool objc_string
, bool translate
)
852 struct obstack str_ob
;
854 enum cpp_ttype type
= tok
->type
;
856 /* Try to avoid the overhead of creating and destroying an obstack
857 for the common case of just one string. */
858 cpp_string str
= tok
->val
.str
;
859 cpp_string
*strs
= &str
;
862 tok
= cpp_get_token (parse_in
);
868 if (c_dialect_objc ())
881 if (type
!= tok
->type
)
883 if (type
== CPP_STRING
)
886 error ("unsupported non-standard concatenation of string literals");
892 gcc_obstack_init (&str_ob
);
893 obstack_grow (&str_ob
, &str
, sizeof (cpp_string
));
897 obstack_grow (&str_ob
, &tok
->val
.str
, sizeof (cpp_string
));
901 /* We have read one more token than we want. */
902 _cpp_backup_tokens (parse_in
, 1);
904 strs
= XOBFINISH (&str_ob
, cpp_string
*);
906 if (concats
&& !objc_string
&& !in_system_header
)
907 warning (OPT_Wtraditional
,
908 "traditional C rejects string constant concatenation");
911 ? cpp_interpret_string
: cpp_interpret_string_notranslate
)
912 (parse_in
, strs
, concats
+ 1, &istr
, type
))
914 value
= build_string (istr
.len
, (const char *) istr
.text
);
915 free (CONST_CAST (unsigned char *, istr
.text
));
919 /* Callers cannot generally handle error_mark_node in this context,
920 so return the empty string instead. cpp_interpret_string has
926 value
= build_string (1, "");
929 value
= build_string (TYPE_PRECISION (char16_type_node
)
930 / TYPE_PRECISION (char_type_node
),
931 "\0"); /* char16_t is 16 bits */
934 value
= build_string (TYPE_PRECISION (char32_type_node
)
935 / TYPE_PRECISION (char_type_node
),
936 "\0\0\0"); /* char32_t is 32 bits */
939 value
= build_string (TYPE_PRECISION (wchar_type_node
)
940 / TYPE_PRECISION (char_type_node
),
941 "\0\0\0"); /* widest supported wchar_t
951 TREE_TYPE (value
) = char_array_type_node
;
954 TREE_TYPE (value
) = char16_array_type_node
;
957 TREE_TYPE (value
) = char32_array_type_node
;
960 TREE_TYPE (value
) = wchar_array_type_node
;
962 *valp
= fix_string_type (value
);
965 obstack_free (&str_ob
, 0);
967 return objc_string
? CPP_OBJC_STRING
: type
;
970 /* Converts a (possibly wide) character constant token into a tree. */
972 lex_charconst (const cpp_token
*token
)
976 unsigned int chars_seen
;
979 result
= cpp_interpret_charconst (parse_in
, token
,
980 &chars_seen
, &unsignedp
);
982 if (token
->type
== CPP_WCHAR
)
983 type
= wchar_type_node
;
984 else if (token
->type
== CPP_CHAR32
)
985 type
= char32_type_node
;
986 else if (token
->type
== CPP_CHAR16
)
987 type
= char16_type_node
;
988 /* In C, a character constant has type 'int'.
989 In C++ 'char', but multi-char charconsts have type 'int'. */
990 else if (!c_dialect_cxx () || chars_seen
> 1)
991 type
= integer_type_node
;
993 type
= char_type_node
;
995 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
996 before possibly widening to HOST_WIDE_INT for build_int_cst. */
997 if (unsignedp
|| (cppchar_signed_t
) result
>= 0)
998 value
= build_int_cst_wide (type
, result
, 0);
1000 value
= build_int_cst_wide (type
, (cppchar_signed_t
) result
, -1);