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"
28 #include "fixed-value.h"
40 #include "splay-tree.h"
44 /* We may keep statistics about how long which files took to compile. */
45 static int header_time, body_time;
46 static splay_tree file_info_tree;
48 int pending_lang_change; /* If we need to switch languages - C++ only */
49 int c_header_level; /* depth in C headers - C++ only */
51 static tree interpret_integer (const cpp_token *, unsigned int);
52 static tree interpret_float (const cpp_token *, unsigned int);
53 static tree interpret_fixed (const cpp_token *, unsigned int);
54 static enum integer_type_kind narrowest_unsigned_type
55 (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
56 static enum integer_type_kind narrowest_signed_type
57 (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
58 static enum cpp_ttype lex_string (const cpp_token *, tree *, bool, bool);
59 static tree lex_charconst (const cpp_token *);
60 static void update_header_times (const char *);
61 static int dump_one_header (splay_tree_node, void *);
62 static void cb_line_change (cpp_reader *, const cpp_token *, int);
63 static void cb_ident (cpp_reader *, unsigned int, const cpp_string *);
64 static void cb_def_pragma (cpp_reader *, unsigned int);
65 static void cb_define (cpp_reader *, unsigned int, cpp_hashnode *);
66 static void cb_undef (cpp_reader *, unsigned int, cpp_hashnode *);
71 struct cpp_callbacks *cb;
72 struct c_fileinfo *toplevel;
74 /* The get_fileinfo data structure must be initialized before
75 cpp_read_main_file is called. */
76 toplevel = get_fileinfo ("<top level>");
77 if (flag_detailed_statistics)
80 body_time = get_run_time ();
81 toplevel->time = body_time;
84 cb = cpp_get_callbacks (parse_in);
86 cb->line_change = cb_line_change;
88 cb->def_pragma = cb_def_pragma;
89 cb->valid_pch = c_common_valid_pch;
90 cb->read_pch = c_common_read_pch;
92 /* Set the debug callbacks if we can use them. */
93 if (debug_info_level == DINFO_LEVEL_VERBOSE
94 && (write_symbols == DWARF2_DEBUG
95 || write_symbols == VMS_AND_DWARF2_DEBUG))
97 cb->define = cb_define;
103 get_fileinfo (const char *name)
106 struct c_fileinfo *fi;
109 file_info_tree = splay_tree_new ((splay_tree_compare_fn) strcmp,
111 (splay_tree_delete_value_fn) free);
113 n = splay_tree_lookup (file_info_tree, (splay_tree_key) name);
115 return (struct c_fileinfo *) n->value;
117 fi = XNEW (struct c_fileinfo);
119 fi->interface_only = 0;
120 fi->interface_unknown = 1;
121 splay_tree_insert (file_info_tree, (splay_tree_key) name,
122 (splay_tree_value) fi);
127 update_header_times (const char *name)
129 /* Changing files again. This means currently collected time
130 is charged against header time, and body time starts back at 0. */
131 if (flag_detailed_statistics)
133 int this_time = get_run_time ();
134 struct c_fileinfo *file = get_fileinfo (name);
135 header_time += this_time - body_time;
136 file->time += this_time - body_time;
137 body_time = this_time;
142 dump_one_header (splay_tree_node n, void * ARG_UNUSED (dummy))
144 print_time ((const char *) n->key,
145 ((struct c_fileinfo *) n->value)->time);
150 dump_time_statistics (void)
152 struct c_fileinfo *file = get_fileinfo (input_filename);
153 int this_time = get_run_time ();
154 file->time += this_time - body_time;
156 fprintf (stderr, "\n******\n");
157 print_time ("header files (total)", header_time);
158 print_time ("main file (total)", this_time - body_time);
159 fprintf (stderr, "ratio = %g : 1\n",
160 (double) header_time / (double) (this_time - body_time));
161 fprintf (stderr, "\n******\n");
163 splay_tree_foreach (file_info_tree, dump_one_header, 0);
167 cb_ident (cpp_reader * ARG_UNUSED (pfile),
168 unsigned int ARG_UNUSED (line),
169 const cpp_string * ARG_UNUSED (str))
171 #ifdef ASM_OUTPUT_IDENT
174 /* Convert escapes in the string. */
175 cpp_string cstr = { 0, 0 };
176 if (cpp_interpret_string (pfile, str, 1, &cstr, CPP_STRING))
178 ASM_OUTPUT_IDENT (asm_out_file, (const char *) cstr.text);
179 free (CONST_CAST (unsigned char *, cstr.text));
185 /* Called at the start of every non-empty line. TOKEN is the first
186 lexed token on the line. Used for diagnostic line numbers. */
188 cb_line_change (cpp_reader * ARG_UNUSED (pfile), const cpp_token *token,
191 if (token->type != CPP_EOF && !parsing_args)
192 input_location = token->src_loc;
196 fe_file_change (const struct line_map *new_map)
201 if (new_map->reason == LC_ENTER)
203 /* Don't stack the main buffer on the input stack;
204 we already did in compile_file. */
205 if (!MAIN_FILE_P (new_map))
207 unsigned int included_at = LAST_SOURCE_LINE_LOCATION (new_map - 1);
209 if (included_at > BUILTINS_LOCATION)
210 line = SOURCE_LINE (new_map - 1, included_at);
212 input_location = new_map->start_location;
213 (*debug_hooks->start_source_file) (line, new_map->to_file);
214 #ifndef NO_IMPLICIT_EXTERN_C
217 else if (new_map->sysp == 2)
220 ++pending_lang_change;
225 else if (new_map->reason == LC_LEAVE)
227 #ifndef NO_IMPLICIT_EXTERN_C
228 if (c_header_level && --c_header_level == 0)
230 if (new_map->sysp == 2)
231 warning (0, "badly nested C headers from preprocessor");
232 --pending_lang_change;
235 input_location = new_map->start_location;
237 (*debug_hooks->end_source_file) (new_map->to_line);
240 update_header_times (new_map->to_file);
241 input_location = new_map->start_location;
245 cb_def_pragma (cpp_reader *pfile, source_location loc)
247 /* Issue a warning message if we have been asked to do so. Ignore
248 unknown pragmas in system headers unless an explicit
249 -Wunknown-pragmas has been given. */
250 if (warn_unknown_pragmas > in_system_header)
252 const unsigned char *space, *name;
254 location_t fe_loc = loc;
256 space = name = (const unsigned char *) "";
257 s = cpp_get_token (pfile);
258 if (s->type != CPP_EOF)
260 space = cpp_token_as_text (pfile, s);
261 s = cpp_get_token (pfile);
262 if (s->type == CPP_NAME)
263 name = cpp_token_as_text (pfile, s);
266 warning_at (fe_loc, OPT_Wunknown_pragmas, "ignoring #pragma %s %s",
271 /* #define callback for DWARF and DWARF2 debug info. */
273 cb_define (cpp_reader *pfile, source_location loc, cpp_hashnode *node)
275 const struct line_map *map = linemap_lookup (line_table, loc);
276 (*debug_hooks->define) (SOURCE_LINE (map, loc),
277 (const char *) cpp_macro_definition (pfile, node));
280 /* #undef callback for DWARF and DWARF2 debug info. */
282 cb_undef (cpp_reader * ARG_UNUSED (pfile), source_location loc,
285 const struct line_map *map = linemap_lookup (line_table, loc);
286 (*debug_hooks->undef) (SOURCE_LINE (map, loc),
287 (const char *) NODE_NAME (node));
290 /* Read a token and return its type. Fill *VALUE with its value, if
291 applicable. Fill *CPP_FLAGS with the token's flags, if it is
295 c_lex_with_flags (tree *value, location_t *loc, unsigned char *cpp_flags,
298 static bool no_more_pch;
299 const cpp_token *tok;
301 unsigned char add_flags = 0;
303 timevar_push (TV_CPP);
305 tok = cpp_get_token_with_location (parse_in, loc);
315 *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node.node));
320 unsigned int flags = cpp_classify_number (parse_in, tok);
322 switch (flags & CPP_N_CATEGORY)
325 /* cpplib has issued an error. */
326 *value = error_mark_node;
331 /* C++ uses '0' to mark virtual functions as pure.
332 Set PURE_ZERO to pass this information to the C++ parser. */
333 if (tok->val.str.len == 1 && *tok->val.str.text == '0')
334 add_flags = PURE_ZERO;
335 *value = interpret_integer (tok, flags);
339 *value = interpret_float (tok, flags);
349 /* An @ may give the next token special significance in Objective-C. */
350 if (c_dialect_objc ())
352 location_t atloc = *loc;
356 tok = cpp_get_token_with_location (parse_in, &newloc);
368 type = lex_string (tok, value, true, true);
372 *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node.node));
373 if (objc_is_reserved_word (*value))
382 error_at (atloc, "stray %<@%> in program");
393 unsigned char name[8];
395 *cpp_spell_token (parse_in, tok, name, true) = 0;
397 error ("stray %qs in program", name);
404 cppchar_t c = tok->val.str.text[0];
406 if (c == '"' || c == '\'')
407 error ("missing terminating %c character", (int) c);
408 else if (ISGRAPH (c))
409 error ("stray %qc in program", (int) c);
411 error ("stray %<\\%o%> in program", (int) c);
419 *value = lex_charconst (tok);
427 if ((lex_flags & C_LEX_STRING_NO_JOIN) == 0)
429 type = lex_string (tok, value, false,
430 (lex_flags & C_LEX_STRING_NO_TRANSLATE) == 0);
433 *value = build_string (tok->val.str.len, (const char *) tok->val.str.text);
437 *value = build_int_cst (NULL, tok->val.pragma);
440 /* These tokens should not be visible outside cpplib. */
441 case CPP_HEADER_NAME:
452 *cpp_flags = tok->flags | add_flags;
457 c_common_no_more_pch ();
460 timevar_pop (TV_CPP);
465 /* Returns the narrowest C-visible unsigned type, starting with the
466 minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
469 static enum integer_type_kind
470 narrowest_unsigned_type (unsigned HOST_WIDE_INT low,
471 unsigned HOST_WIDE_INT high,
476 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
477 itk = itk_unsigned_int;
478 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
479 itk = itk_unsigned_long;
481 itk = itk_unsigned_long_long;
483 for (; itk < itk_none; itk += 2 /* skip unsigned types */)
485 tree upper = TYPE_MAX_VALUE (integer_types[itk]);
487 if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
488 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
489 && TREE_INT_CST_LOW (upper) >= low))
490 return (enum integer_type_kind) itk;
496 /* Ditto, but narrowest signed type. */
497 static enum integer_type_kind
498 narrowest_signed_type (unsigned HOST_WIDE_INT low,
499 unsigned HOST_WIDE_INT high, unsigned int flags)
503 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
505 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
511 for (; itk < itk_none; itk += 2 /* skip signed types */)
513 tree upper = TYPE_MAX_VALUE (integer_types[itk]);
515 if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
516 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
517 && TREE_INT_CST_LOW (upper) >= low))
518 return (enum integer_type_kind) itk;
524 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
526 interpret_integer (const cpp_token *token, unsigned int flags)
529 enum integer_type_kind itk;
531 cpp_options *options = cpp_get_options (parse_in);
533 integer = cpp_interpret_integer (parse_in, token, flags);
534 integer = cpp_num_sign_extend (integer, options->precision);
536 /* The type of a constant with a U suffix is straightforward. */
537 if (flags & CPP_N_UNSIGNED)
538 itk = narrowest_unsigned_type (integer.low, integer.high, flags);
541 /* The type of a potentially-signed integer constant varies
542 depending on the base it's in, the standard in use, and the
544 enum integer_type_kind itk_u
545 = narrowest_unsigned_type (integer.low, integer.high, flags);
546 enum integer_type_kind itk_s
547 = narrowest_signed_type (integer.low, integer.high, flags);
549 /* In both C89 and C99, octal and hex constants may be signed or
550 unsigned, whichever fits tighter. We do not warn about this
551 choice differing from the traditional choice, as the constant
552 is probably a bit pattern and either way will work. */
553 if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
554 itk = MIN (itk_u, itk_s);
557 /* In C99, decimal constants are always signed.
558 In C89, decimal constants that don't fit in long have
559 undefined behavior; we try to make them unsigned long.
560 In GCC's extended C89, that last is true of decimal
561 constants that don't fit in long long, too. */
564 if (itk_s > itk_u && itk_s > itk_long)
568 if (itk_u < itk_unsigned_long)
569 itk_u = itk_unsigned_long;
571 warning (0, "this decimal constant is unsigned only in ISO C90");
574 warning (OPT_Wtraditional,
575 "this decimal constant would be unsigned in ISO C90");
581 /* cpplib has already issued a warning for overflow. */
582 type = ((flags & CPP_N_UNSIGNED)
583 ? widest_unsigned_literal_type_node
584 : widest_integer_literal_type_node);
587 type = integer_types[itk];
588 if (itk > itk_unsigned_long
589 && (flags & CPP_N_WIDTH) != CPP_N_LARGE)
591 ((c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99)
592 ? DK_PEDWARN : DK_WARNING,
593 input_location, OPT_Wlong_long,
594 (flags & CPP_N_UNSIGNED)
595 ? "integer constant is too large for %<unsigned long%> type"
596 : "integer constant is too large for %<long%> type");
599 value = build_int_cst_wide (type, integer.low, integer.high);
601 /* Convert imaginary to a complex type. */
602 if (flags & CPP_N_IMAGINARY)
603 value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
608 /* Interpret TOKEN, a floating point number with FLAGS as classified
611 interpret_float (const cpp_token *token, unsigned int flags)
616 REAL_VALUE_TYPE real;
617 REAL_VALUE_TYPE real_trunc;
621 /* Default (no suffix) depends on whether the FLOAT_CONST_DECIMAL64
622 pragma has been used and is either double or _Decimal64. Types
623 that are not allowed with decimal float default to double. */
624 if (flags & CPP_N_DEFAULT)
626 flags ^= CPP_N_DEFAULT;
627 flags |= CPP_N_MEDIUM;
629 if (((flags & CPP_N_HEX) == 0) && ((flags & CPP_N_IMAGINARY) == 0))
631 warning (OPT_Wunsuffixed_float_constants,
632 "unsuffixed float constant");
633 if (float_const_decimal64_p ())
634 flags |= CPP_N_DFLOAT;
638 /* Decode _Fract and _Accum. */
639 if (flags & CPP_N_FRACT || flags & CPP_N_ACCUM)
640 return interpret_fixed (token, flags);
642 /* Decode type based on width and properties. */
643 if (flags & CPP_N_DFLOAT)
644 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
645 type = dfloat128_type_node;
646 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
647 type = dfloat32_type_node;
649 type = dfloat64_type_node;
651 if (flags & CPP_N_WIDTH_MD)
654 enum machine_mode mode;
656 if ((flags & CPP_N_WIDTH_MD) == CPP_N_MD_W)
661 mode = targetm.c.mode_for_suffix (suffix);
662 if (mode == VOIDmode)
664 error ("unsupported non-standard suffix on floating constant");
667 return error_mark_node;
670 pedwarn (input_location, OPT_pedantic, "non-standard suffix on floating constant");
672 type = c_common_type_for_mode (mode, 0);
675 else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
676 type = long_double_type_node;
677 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
678 || flag_single_precision_constant)
679 type = float_type_node;
681 type = double_type_node;
683 const_type = excess_precision_type (type);
687 /* Copy the constant to a nul-terminated buffer. If the constant
688 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
689 can't handle them. */
690 copylen = token->val.str.len;
691 if (flags & CPP_N_DFLOAT)
695 if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
696 /* Must be an F or L or machine defined suffix. */
698 if (flags & CPP_N_IMAGINARY)
703 copy = (char *) alloca (copylen + 1);
704 memcpy (copy, token->val.str.text, copylen);
705 copy[copylen] = '\0';
707 real_from_string3 (&real, copy, TYPE_MODE (const_type));
708 if (const_type != type)
709 /* Diagnosing if the result of converting the value with excess
710 precision to the semantic type would overflow (with associated
711 double rounding) is more appropriate than diagnosing if the
712 result of converting the string directly to the semantic type
714 real_convert (&real_trunc, TYPE_MODE (type), &real);
716 /* Both C and C++ require a diagnostic for a floating constant
717 outside the range of representable values of its type. Since we
718 have __builtin_inf* to produce an infinity, this is now a
719 mandatory pedwarn if the target does not support infinities. */
720 if (REAL_VALUE_ISINF (real)
721 || (const_type != type && REAL_VALUE_ISINF (real_trunc)))
723 if (!MODE_HAS_INFINITIES (TYPE_MODE (type)))
724 pedwarn (input_location, 0, "floating constant exceeds range of %qT", type);
726 warning (OPT_Woverflow, "floating constant exceeds range of %qT", type);
728 /* We also give a warning if the value underflows. */
729 else if (REAL_VALUES_EQUAL (real, dconst0)
730 || (const_type != type && REAL_VALUES_EQUAL (real_trunc, dconst0)))
732 REAL_VALUE_TYPE realvoidmode;
733 int overflow = real_from_string (&realvoidmode, copy);
734 if (overflow < 0 || !REAL_VALUES_EQUAL (realvoidmode, dconst0))
735 warning (OPT_Woverflow, "floating constant truncated to zero");
738 /* Create a node with determined type and value. */
739 value = build_real (const_type, real);
740 if (flags & CPP_N_IMAGINARY)
741 value = build_complex (NULL_TREE, convert (const_type, integer_zero_node),
744 if (type != const_type)
745 value = build1 (EXCESS_PRECISION_EXPR, type, value);
750 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
754 interpret_fixed (const cpp_token *token, unsigned int flags)
758 FIXED_VALUE_TYPE fixed;
762 copylen = token->val.str.len;
764 if (flags & CPP_N_FRACT) /* _Fract. */
766 if (flags & CPP_N_UNSIGNED) /* Unsigned _Fract. */
768 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
770 type = unsigned_long_long_fract_type_node;
773 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
775 type = unsigned_long_fract_type_node;
778 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
780 type = unsigned_short_fract_type_node;
785 type = unsigned_fract_type_node;
789 else /* Signed _Fract. */
791 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
793 type = long_long_fract_type_node;
796 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
798 type = long_fract_type_node;
801 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
803 type = short_fract_type_node;
808 type = fract_type_node;
815 if (flags & CPP_N_UNSIGNED) /* Unsigned _Accum. */
817 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
819 type = unsigned_long_long_accum_type_node;
822 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
824 type = unsigned_long_accum_type_node;
827 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
829 type = unsigned_short_accum_type_node;
834 type = unsigned_accum_type_node;
838 else /* Signed _Accum. */
840 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
842 type = long_long_accum_type_node;
845 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
847 type = long_accum_type_node;
850 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
852 type = short_accum_type_node;
857 type = accum_type_node;
863 copy = (char *) alloca (copylen + 1);
864 memcpy (copy, token->val.str.text, copylen);
865 copy[copylen] = '\0';
867 fixed_from_string (&fixed, copy, TYPE_MODE (type));
869 /* Create a node with determined type and value. */
870 value = build_fixed (type, fixed);
875 /* Convert a series of STRING, WSTRING, STRING16, STRING32 and/or
876 UTF8STRING tokens into a tree, performing string constant
877 concatenation. TOK is the first of these. VALP is the location
878 to write the string into. OBJC_STRING indicates whether an '@' token
879 preceded the incoming token.
880 Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
881 CPP_STRING32, CPP_STRING16, CPP_UTF8STRING, or CPP_OBJC_STRING).
883 This is unfortunately more work than it should be. If any of the
884 strings in the series has an L prefix, the result is a wide string
885 (6.4.5p4). Whether or not the result is a wide string affects the
886 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
887 sequences do not continue across the boundary between two strings in
888 a series (6.4.5p7), so we must not lose the boundaries. Therefore
889 cpp_interpret_string takes a vector of cpp_string structures, which
890 we must arrange to provide. */
892 static enum cpp_ttype
893 lex_string (const cpp_token *tok, tree *valp, bool objc_string, bool translate)
897 struct obstack str_ob;
899 enum cpp_ttype type = tok->type;
901 /* Try to avoid the overhead of creating and destroying an obstack
902 for the common case of just one string. */
903 cpp_string str = tok->val.str;
904 cpp_string *strs = &str;
907 tok = cpp_get_token (parse_in);
913 if (c_dialect_objc ())
927 if (type != tok->type)
929 if (type == CPP_STRING)
932 error ("unsupported non-standard concatenation of string literals");
938 gcc_obstack_init (&str_ob);
939 obstack_grow (&str_ob, &str, sizeof (cpp_string));
943 obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
947 /* We have read one more token than we want. */
948 _cpp_backup_tokens (parse_in, 1);
950 strs = XOBFINISH (&str_ob, cpp_string *);
952 if (concats && !objc_string && !in_system_header)
953 warning (OPT_Wtraditional,
954 "traditional C rejects string constant concatenation");
957 ? cpp_interpret_string : cpp_interpret_string_notranslate)
958 (parse_in, strs, concats + 1, &istr, type))
960 value = build_string (istr.len, (const char *) istr.text);
961 free (CONST_CAST (unsigned char *, istr.text));
965 /* Callers cannot generally handle error_mark_node in this context,
966 so return the empty string instead. cpp_interpret_string has
973 value = build_string (1, "");
976 value = build_string (TYPE_PRECISION (char16_type_node)
977 / TYPE_PRECISION (char_type_node),
978 "\0"); /* char16_t is 16 bits */
981 value = build_string (TYPE_PRECISION (char32_type_node)
982 / TYPE_PRECISION (char_type_node),
983 "\0\0\0"); /* char32_t is 32 bits */
986 value = build_string (TYPE_PRECISION (wchar_type_node)
987 / TYPE_PRECISION (char_type_node),
988 "\0\0\0"); /* widest supported wchar_t
999 TREE_TYPE (value) = char_array_type_node;
1002 TREE_TYPE (value) = char16_array_type_node;
1005 TREE_TYPE (value) = char32_array_type_node;
1008 TREE_TYPE (value) = wchar_array_type_node;
1010 *valp = fix_string_type (value);
1013 obstack_free (&str_ob, 0);
1015 return objc_string ? CPP_OBJC_STRING : type;
1018 /* Converts a (possibly wide) character constant token into a tree. */
1020 lex_charconst (const cpp_token *token)
1024 unsigned int chars_seen;
1027 result = cpp_interpret_charconst (parse_in, token,
1028 &chars_seen, &unsignedp);
1030 if (token->type == CPP_WCHAR)
1031 type = wchar_type_node;
1032 else if (token->type == CPP_CHAR32)
1033 type = char32_type_node;
1034 else if (token->type == CPP_CHAR16)
1035 type = char16_type_node;
1036 /* In C, a character constant has type 'int'.
1037 In C++ 'char', but multi-char charconsts have type 'int'. */
1038 else if (!c_dialect_cxx () || chars_seen > 1)
1039 type = integer_type_node;
1041 type = char_type_node;
1043 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1044 before possibly widening to HOST_WIDE_INT for build_int_cst. */
1045 if (unsignedp || (cppchar_signed_t) result >= 0)
1046 value = build_int_cst_wide (type, result, 0);
1048 value = build_int_cst_wide (type, (cppchar_signed_t) result, -1);