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 unsigned int included_at
= LAST_SOURCE_LINE_LOCATION (new_map
- 1);
210 if (included_at
> BUILTINS_LOCATION
)
211 line
= SOURCE_LINE (new_map
- 1, included_at
);
213 input_location
= new_map
->start_location
;
214 (*debug_hooks
->start_source_file
) (line
, new_map
->to_file
);
215 #ifndef NO_IMPLICIT_EXTERN_C
218 else if (new_map
->sysp
== 2)
221 ++pending_lang_change
;
226 else if (new_map
->reason
== LC_LEAVE
)
228 #ifndef NO_IMPLICIT_EXTERN_C
229 if (c_header_level
&& --c_header_level
== 0)
231 if (new_map
->sysp
== 2)
232 warning (0, "badly nested C headers from preprocessor");
233 --pending_lang_change
;
236 input_location
= new_map
->start_location
;
238 (*debug_hooks
->end_source_file
) (new_map
->to_line
);
241 update_header_times (new_map
->to_file
);
242 in_system_header
= new_map
->sysp
!= 0;
243 input_location
= new_map
->start_location
;
247 cb_def_pragma (cpp_reader
*pfile
, source_location loc
)
249 /* Issue a warning message if we have been asked to do so. Ignore
250 unknown pragmas in system headers unless an explicit
251 -Wunknown-pragmas has been given. */
252 if (warn_unknown_pragmas
> in_system_header
)
254 const unsigned char *space
, *name
;
256 location_t fe_loc
= loc
;
258 space
= name
= (const unsigned char *) "";
259 s
= cpp_get_token (pfile
);
260 if (s
->type
!= CPP_EOF
)
262 space
= cpp_token_as_text (pfile
, s
);
263 s
= cpp_get_token (pfile
);
264 if (s
->type
== CPP_NAME
)
265 name
= cpp_token_as_text (pfile
, s
);
268 warning (OPT_Wunknown_pragmas
, "%Hignoring #pragma %s %s",
269 &fe_loc
, space
, name
);
273 /* #define callback for DWARF and DWARF2 debug info. */
275 cb_define (cpp_reader
*pfile
, source_location loc
, cpp_hashnode
*node
)
277 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
278 (*debug_hooks
->define
) (SOURCE_LINE (map
, loc
),
279 (const char *) cpp_macro_definition (pfile
, node
));
282 /* #undef callback for DWARF and DWARF2 debug info. */
284 cb_undef (cpp_reader
* ARG_UNUSED (pfile
), source_location loc
,
287 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
288 (*debug_hooks
->undef
) (SOURCE_LINE (map
, loc
),
289 (const char *) NODE_NAME (node
));
292 /* Read a token and return its type. Fill *VALUE with its value, if
293 applicable. Fill *CPP_FLAGS with the token's flags, if it is
297 c_lex_with_flags (tree
*value
, location_t
*loc
, unsigned char *cpp_flags
,
300 static bool no_more_pch
;
301 const cpp_token
*tok
;
303 unsigned char add_flags
= 0;
305 timevar_push (TV_CPP
);
307 tok
= cpp_get_token_with_location (parse_in
, loc
);
317 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
));
322 unsigned int flags
= cpp_classify_number (parse_in
, tok
);
324 switch (flags
& CPP_N_CATEGORY
)
327 /* cpplib has issued an error. */
328 *value
= error_mark_node
;
333 /* C++ uses '0' to mark virtual functions as pure.
334 Set PURE_ZERO to pass this information to the C++ parser. */
335 if (tok
->val
.str
.len
== 1 && *tok
->val
.str
.text
== '0')
336 add_flags
= PURE_ZERO
;
337 *value
= interpret_integer (tok
, flags
);
341 *value
= interpret_float (tok
, flags
);
351 /* An @ may give the next token special significance in Objective-C. */
352 if (c_dialect_objc ())
354 location_t atloc
= *loc
;
358 tok
= cpp_get_token_with_location (parse_in
, &newloc
);
369 type
= lex_string (tok
, value
, true, true);
373 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
));
374 if (objc_is_reserved_word (*value
))
383 error ("%Hstray %<@%> in program", &atloc
);
394 unsigned char name
[4];
396 *cpp_spell_token (parse_in
, tok
, name
, true) = 0;
398 error ("stray %qs in program", name
);
405 cppchar_t c
= tok
->val
.str
.text
[0];
407 if (c
== '"' || c
== '\'')
408 error ("missing terminating %c character", (int) c
);
409 else if (ISGRAPH (c
))
410 error ("stray %qc in program", (int) c
);
412 error ("stray %<\\%o%> in program", (int) c
);
420 *value
= lex_charconst (tok
);
427 if ((lex_flags
& C_LEX_RAW_STRINGS
) == 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
);
586 type
= integer_types
[itk
];
588 if (itk
> itk_unsigned_long
589 && (flags
& CPP_N_WIDTH
) != CPP_N_LARGE
590 && !in_system_header
&& !flag_isoc99
)
591 pedwarn ("integer constant is too large for %qs type",
592 (flags
& CPP_N_UNSIGNED
) ? "unsigned long" : "long");
594 value
= build_int_cst_wide (type
, integer
.low
, integer
.high
);
596 /* Convert imaginary to a complex type. */
597 if (flags
& CPP_N_IMAGINARY
)
598 value
= build_complex (NULL_TREE
, build_int_cst (type
, 0), value
);
603 /* Interpret TOKEN, a floating point number with FLAGS as classified
606 interpret_float (const cpp_token
*token
, unsigned int flags
)
610 REAL_VALUE_TYPE real
;
614 /* Decode _Fract and _Accum. */
615 if (flags
& CPP_N_FRACT
|| flags
& CPP_N_ACCUM
)
616 return interpret_fixed (token
, flags
);
618 /* Decode type based on width and properties. */
619 if (flags
& CPP_N_DFLOAT
)
620 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
621 type
= dfloat128_type_node
;
622 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
623 type
= dfloat32_type_node
;
625 type
= dfloat64_type_node
;
627 if (flags
& CPP_N_WIDTH_MD
)
630 enum machine_mode mode
;
632 if ((flags
& CPP_N_WIDTH_MD
) == CPP_N_MD_W
)
637 mode
= targetm
.c
.mode_for_suffix (suffix
);
638 if (mode
== VOIDmode
)
640 error ("unsupported non-standard suffix on floating constant");
643 return error_mark_node
;
646 pedwarn ("non-standard suffix on floating constant");
648 type
= c_common_type_for_mode (mode
, 0);
651 else if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
652 type
= long_double_type_node
;
653 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
654 || flag_single_precision_constant
)
655 type
= float_type_node
;
657 type
= double_type_node
;
659 /* Copy the constant to a nul-terminated buffer. If the constant
660 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
661 can't handle them. */
662 copylen
= token
->val
.str
.len
;
663 if (flags
& CPP_N_DFLOAT
)
667 if ((flags
& CPP_N_WIDTH
) != CPP_N_MEDIUM
)
668 /* Must be an F or L or machine defined suffix. */
670 if (flags
& CPP_N_IMAGINARY
)
675 copy
= (char *) alloca (copylen
+ 1);
676 memcpy (copy
, token
->val
.str
.text
, copylen
);
677 copy
[copylen
] = '\0';
679 real_from_string3 (&real
, copy
, TYPE_MODE (type
));
681 /* Both C and C++ require a diagnostic for a floating constant
682 outside the range of representable values of its type. Since we
683 have __builtin_inf* to produce an infinity, this is now a
684 mandatory pedwarn if the target does not support infinities. */
685 if (REAL_VALUE_ISINF (real
))
687 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)))
688 pedwarn ("floating constant exceeds range of %qT", type
);
690 warning (OPT_Woverflow
, "floating constant exceeds range of %qT", type
);
692 /* We also give a warning if the value underflows. */
693 else if (REAL_VALUES_EQUAL (real
, dconst0
))
695 REAL_VALUE_TYPE realvoidmode
;
696 int overflow
= real_from_string (&realvoidmode
, copy
);
697 if (overflow
< 0 || !REAL_VALUES_EQUAL (realvoidmode
, dconst0
))
698 warning (OPT_Woverflow
, "floating constant truncated to zero");
701 /* Create a node with determined type and value. */
702 value
= build_real (type
, real
);
703 if (flags
& CPP_N_IMAGINARY
)
704 value
= build_complex (NULL_TREE
, convert (type
, integer_zero_node
), value
);
709 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
713 interpret_fixed (const cpp_token
*token
, unsigned int flags
)
717 FIXED_VALUE_TYPE fixed
;
721 copylen
= token
->val
.str
.len
;
723 if (flags
& CPP_N_FRACT
) /* _Fract. */
725 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Fract. */
727 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
729 type
= unsigned_long_long_fract_type_node
;
732 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
734 type
= unsigned_long_fract_type_node
;
737 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
739 type
= unsigned_short_fract_type_node
;
744 type
= unsigned_fract_type_node
;
748 else /* Signed _Fract. */
750 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
752 type
= long_long_fract_type_node
;
755 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
757 type
= long_fract_type_node
;
760 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
762 type
= short_fract_type_node
;
767 type
= fract_type_node
;
774 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Accum. */
776 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
778 type
= unsigned_long_long_accum_type_node
;
781 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
783 type
= unsigned_long_accum_type_node
;
786 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
788 type
= unsigned_short_accum_type_node
;
793 type
= unsigned_accum_type_node
;
797 else /* Signed _Accum. */
799 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
801 type
= long_long_accum_type_node
;
804 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
806 type
= long_accum_type_node
;
809 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
811 type
= short_accum_type_node
;
816 type
= accum_type_node
;
822 copy
= (char *) alloca (copylen
+ 1);
823 memcpy (copy
, token
->val
.str
.text
, copylen
);
824 copy
[copylen
] = '\0';
826 fixed_from_string (&fixed
, copy
, TYPE_MODE (type
));
828 /* Create a node with determined type and value. */
829 value
= build_fixed (type
, fixed
);
834 /* Convert a series of STRING, WSTRING, STRING16 and/or STRING32 tokens
835 into a tree, performing string constant concatenation. TOK is the
836 first of these. VALP is the location to write the string into.
837 OBJC_STRING indicates whether an '@' token preceded the incoming token.
838 Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
839 CPP_STRING32, CPP_STRING16, or CPP_OBJC_STRING).
841 This is unfortunately more work than it should be. If any of the
842 strings in the series has an L prefix, the result is a wide string
843 (6.4.5p4). Whether or not the result is a wide string affects the
844 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
845 sequences do not continue across the boundary between two strings in
846 a series (6.4.5p7), so we must not lose the boundaries. Therefore
847 cpp_interpret_string takes a vector of cpp_string structures, which
848 we must arrange to provide. */
850 static enum cpp_ttype
851 lex_string (const cpp_token
*tok
, tree
*valp
, bool objc_string
, bool translate
)
855 struct obstack str_ob
;
857 enum cpp_ttype type
= tok
->type
;
859 /* Try to avoid the overhead of creating and destroying an obstack
860 for the common case of just one string. */
861 cpp_string str
= tok
->val
.str
;
862 cpp_string
*strs
= &str
;
865 tok
= cpp_get_token (parse_in
);
871 if (c_dialect_objc ())
884 if (type
!= tok
->type
)
886 if (type
== CPP_STRING
)
889 error ("unsupported non-standard concatenation of string literals");
895 gcc_obstack_init (&str_ob
);
896 obstack_grow (&str_ob
, &str
, sizeof (cpp_string
));
900 obstack_grow (&str_ob
, &tok
->val
.str
, sizeof (cpp_string
));
904 /* We have read one more token than we want. */
905 _cpp_backup_tokens (parse_in
, 1);
907 strs
= XOBFINISH (&str_ob
, cpp_string
*);
909 if (concats
&& !objc_string
&& !in_system_header
)
910 warning (OPT_Wtraditional
,
911 "traditional C rejects string constant concatenation");
914 ? cpp_interpret_string
: cpp_interpret_string_notranslate
)
915 (parse_in
, strs
, concats
+ 1, &istr
, type
))
917 value
= build_string (istr
.len
, (const char *) istr
.text
);
918 free (CONST_CAST (unsigned char *, istr
.text
));
922 /* Callers cannot generally handle error_mark_node in this context,
923 so return the empty string instead. cpp_interpret_string has
929 value
= build_string (1, "");
932 value
= build_string (TYPE_PRECISION (char16_type_node
)
933 / TYPE_PRECISION (char_type_node
),
934 "\0"); /* char16_t is 16 bits */
937 value
= build_string (TYPE_PRECISION (char32_type_node
)
938 / TYPE_PRECISION (char_type_node
),
939 "\0\0\0"); /* char32_t is 32 bits */
942 value
= build_string (TYPE_PRECISION (wchar_type_node
)
943 / TYPE_PRECISION (char_type_node
),
944 "\0\0\0"); /* widest supported wchar_t
954 TREE_TYPE (value
) = char_array_type_node
;
957 TREE_TYPE (value
) = char16_array_type_node
;
960 TREE_TYPE (value
) = char32_array_type_node
;
963 TREE_TYPE (value
) = wchar_array_type_node
;
965 *valp
= fix_string_type (value
);
968 obstack_free (&str_ob
, 0);
970 return objc_string
? CPP_OBJC_STRING
: type
;
973 /* Converts a (possibly wide) character constant token into a tree. */
975 lex_charconst (const cpp_token
*token
)
979 unsigned int chars_seen
;
982 result
= cpp_interpret_charconst (parse_in
, token
,
983 &chars_seen
, &unsignedp
);
985 if (token
->type
== CPP_WCHAR
)
986 type
= wchar_type_node
;
987 else if (token
->type
== CPP_CHAR32
)
988 type
= char32_type_node
;
989 else if (token
->type
== CPP_CHAR16
)
990 type
= char16_type_node
;
991 /* In C, a character constant has type 'int'.
992 In C++ 'char', but multi-char charconsts have type 'int'. */
993 else if (!c_dialect_cxx () || chars_seen
> 1)
994 type
= integer_type_node
;
996 type
= char_type_node
;
998 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
999 before possibly widening to HOST_WIDE_INT for build_int_cst. */
1000 if (unsignedp
|| (cppchar_signed_t
) result
>= 0)
1001 value
= build_int_cst_wide (type
, result
, 0);
1003 value
= build_int_cst_wide (type
, (cppchar_signed_t
) result
, -1);