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 input_location
= new_map
->start_location
;
246 cb_def_pragma (cpp_reader
*pfile
, source_location loc
)
248 /* Issue a warning message if we have been asked to do so. Ignore
249 unknown pragmas in system headers unless an explicit
250 -Wunknown-pragmas has been given. */
251 if (warn_unknown_pragmas
> in_system_header
)
253 const unsigned char *space
, *name
;
255 location_t fe_loc
= loc
;
257 space
= name
= (const unsigned char *) "";
258 s
= cpp_get_token (pfile
);
259 if (s
->type
!= CPP_EOF
)
261 space
= cpp_token_as_text (pfile
, s
);
262 s
= cpp_get_token (pfile
);
263 if (s
->type
== CPP_NAME
)
264 name
= cpp_token_as_text (pfile
, s
);
267 warning (OPT_Wunknown_pragmas
, "%Hignoring #pragma %s %s",
268 &fe_loc
, space
, name
);
272 /* #define callback for DWARF and DWARF2 debug info. */
274 cb_define (cpp_reader
*pfile
, source_location loc
, cpp_hashnode
*node
)
276 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
277 (*debug_hooks
->define
) (SOURCE_LINE (map
, loc
),
278 (const char *) cpp_macro_definition (pfile
, node
));
281 /* #undef callback for DWARF and DWARF2 debug info. */
283 cb_undef (cpp_reader
* ARG_UNUSED (pfile
), source_location loc
,
286 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
287 (*debug_hooks
->undef
) (SOURCE_LINE (map
, loc
),
288 (const char *) NODE_NAME (node
));
291 /* Read a token and return its type. Fill *VALUE with its value, if
292 applicable. Fill *CPP_FLAGS with the token's flags, if it is
296 c_lex_with_flags (tree
*value
, location_t
*loc
, unsigned char *cpp_flags
,
299 static bool no_more_pch
;
300 const cpp_token
*tok
;
302 unsigned char add_flags
= 0;
304 timevar_push (TV_CPP
);
306 tok
= cpp_get_token_with_location (parse_in
, loc
);
316 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
));
321 unsigned int flags
= cpp_classify_number (parse_in
, tok
);
323 switch (flags
& CPP_N_CATEGORY
)
326 /* cpplib has issued an error. */
327 *value
= error_mark_node
;
332 /* C++ uses '0' to mark virtual functions as pure.
333 Set PURE_ZERO to pass this information to the C++ parser. */
334 if (tok
->val
.str
.len
== 1 && *tok
->val
.str
.text
== '0')
335 add_flags
= PURE_ZERO
;
336 *value
= interpret_integer (tok
, flags
);
340 *value
= interpret_float (tok
, flags
);
350 /* An @ may give the next token special significance in Objective-C. */
351 if (c_dialect_objc ())
353 location_t atloc
= *loc
;
357 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
));
373 if (objc_is_reserved_word (*value
))
382 error ("%Hstray %<@%> in program", &atloc
);
393 unsigned char name
[4];
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
);
426 if ((lex_flags
& C_LEX_RAW_STRINGS
) == 0)
428 type
= lex_string (tok
, value
, false,
429 (lex_flags
& C_LEX_STRING_NO_TRANSLATE
) == 0);
432 *value
= build_string (tok
->val
.str
.len
, (const char *) tok
->val
.str
.text
);
436 *value
= build_int_cst (NULL
, tok
->val
.pragma
);
439 /* These tokens should not be visible outside cpplib. */
440 case CPP_HEADER_NAME
:
451 *cpp_flags
= tok
->flags
| add_flags
;
456 c_common_no_more_pch ();
459 timevar_pop (TV_CPP
);
464 /* Returns the narrowest C-visible unsigned type, starting with the
465 minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
468 static enum integer_type_kind
469 narrowest_unsigned_type (unsigned HOST_WIDE_INT low
,
470 unsigned HOST_WIDE_INT high
,
475 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
476 itk
= itk_unsigned_int
;
477 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
478 itk
= itk_unsigned_long
;
480 itk
= itk_unsigned_long_long
;
482 for (; itk
< itk_none
; itk
+= 2 /* skip unsigned types */)
484 tree upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
486 if ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) > high
487 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) == high
488 && TREE_INT_CST_LOW (upper
) >= low
))
489 return (enum integer_type_kind
) itk
;
495 /* Ditto, but narrowest signed type. */
496 static enum integer_type_kind
497 narrowest_signed_type (unsigned HOST_WIDE_INT low
,
498 unsigned HOST_WIDE_INT high
, unsigned int flags
)
502 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
504 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
510 for (; itk
< itk_none
; itk
+= 2 /* skip signed types */)
512 tree upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
514 if ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) > high
515 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) == high
516 && TREE_INT_CST_LOW (upper
) >= low
))
517 return (enum integer_type_kind
) itk
;
523 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
525 interpret_integer (const cpp_token
*token
, unsigned int flags
)
528 enum integer_type_kind itk
;
530 cpp_options
*options
= cpp_get_options (parse_in
);
532 integer
= cpp_interpret_integer (parse_in
, token
, flags
);
533 integer
= cpp_num_sign_extend (integer
, options
->precision
);
535 /* The type of a constant with a U suffix is straightforward. */
536 if (flags
& CPP_N_UNSIGNED
)
537 itk
= narrowest_unsigned_type (integer
.low
, integer
.high
, flags
);
540 /* The type of a potentially-signed integer constant varies
541 depending on the base it's in, the standard in use, and the
543 enum integer_type_kind itk_u
544 = narrowest_unsigned_type (integer
.low
, integer
.high
, flags
);
545 enum integer_type_kind itk_s
546 = narrowest_signed_type (integer
.low
, integer
.high
, flags
);
548 /* In both C89 and C99, octal and hex constants may be signed or
549 unsigned, whichever fits tighter. We do not warn about this
550 choice differing from the traditional choice, as the constant
551 is probably a bit pattern and either way will work. */
552 if ((flags
& CPP_N_RADIX
) != CPP_N_DECIMAL
)
553 itk
= MIN (itk_u
, itk_s
);
556 /* In C99, decimal constants are always signed.
557 In C89, decimal constants that don't fit in long have
558 undefined behavior; we try to make them unsigned long.
559 In GCC's extended C89, that last is true of decimal
560 constants that don't fit in long long, too. */
563 if (itk_s
> itk_u
&& itk_s
> itk_long
)
567 if (itk_u
< itk_unsigned_long
)
568 itk_u
= itk_unsigned_long
;
570 warning (0, "this decimal constant is unsigned only in ISO C90");
573 warning (OPT_Wtraditional
,
574 "this decimal constant would be unsigned in ISO C90");
580 /* cpplib has already issued a warning for overflow. */
581 type
= ((flags
& CPP_N_UNSIGNED
)
582 ? widest_unsigned_literal_type_node
583 : widest_integer_literal_type_node
);
586 type
= integer_types
[itk
];
587 if (itk
> itk_unsigned_long
588 && (flags
& CPP_N_WIDTH
) != CPP_N_LARGE
)
590 ((c_dialect_cxx () ? cxx_dialect
== cxx98
: !flag_isoc99
)
591 ? DK_PEDWARN
: DK_WARNING
,
592 input_location
, OPT_Wlong_long
,
593 (flags
& CPP_N_UNSIGNED
)
594 ? "integer constant is too large for %<unsigned long%> type"
595 : "integer constant is too large for %<long%> type");
598 value
= build_int_cst_wide (type
, integer
.low
, integer
.high
);
600 /* Convert imaginary to a complex type. */
601 if (flags
& CPP_N_IMAGINARY
)
602 value
= build_complex (NULL_TREE
, build_int_cst (type
, 0), value
);
607 /* Interpret TOKEN, a floating point number with FLAGS as classified
610 interpret_float (const cpp_token
*token
, unsigned int flags
)
615 REAL_VALUE_TYPE real
;
616 REAL_VALUE_TYPE real_trunc
;
620 /* Default (no suffix) depends on whether the FLOAT_CONST_DECIMAL64
621 pragma has been used and is either double or _Decimal64. Types
622 that are not allowed with decimal float default to double. */
623 if (flags
& CPP_N_DEFAULT
)
625 flags
^= CPP_N_DEFAULT
;
626 flags
|= CPP_N_MEDIUM
;
628 if (((flags
& CPP_N_HEX
) == 0) && ((flags
& CPP_N_IMAGINARY
) == 0))
630 warning (OPT_Wunsuffixed_float_constants
,
631 "unsuffixed float constant");
632 if (float_const_decimal64_p ())
633 flags
|= CPP_N_DFLOAT
;
637 /* Decode _Fract and _Accum. */
638 if (flags
& CPP_N_FRACT
|| flags
& CPP_N_ACCUM
)
639 return interpret_fixed (token
, flags
);
641 /* Decode type based on width and properties. */
642 if (flags
& CPP_N_DFLOAT
)
643 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
644 type
= dfloat128_type_node
;
645 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
646 type
= dfloat32_type_node
;
648 type
= dfloat64_type_node
;
650 if (flags
& CPP_N_WIDTH_MD
)
653 enum machine_mode mode
;
655 if ((flags
& CPP_N_WIDTH_MD
) == CPP_N_MD_W
)
660 mode
= targetm
.c
.mode_for_suffix (suffix
);
661 if (mode
== VOIDmode
)
663 error ("unsupported non-standard suffix on floating constant");
666 return error_mark_node
;
669 pedwarn (input_location
, OPT_pedantic
, "non-standard suffix on floating constant");
671 type
= c_common_type_for_mode (mode
, 0);
674 else if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
675 type
= long_double_type_node
;
676 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
677 || flag_single_precision_constant
)
678 type
= float_type_node
;
680 type
= double_type_node
;
682 const_type
= excess_precision_type (type
);
686 /* Copy the constant to a nul-terminated buffer. If the constant
687 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
688 can't handle them. */
689 copylen
= token
->val
.str
.len
;
690 if (flags
& CPP_N_DFLOAT
)
694 if ((flags
& CPP_N_WIDTH
) != CPP_N_MEDIUM
)
695 /* Must be an F or L or machine defined suffix. */
697 if (flags
& CPP_N_IMAGINARY
)
702 copy
= (char *) alloca (copylen
+ 1);
703 memcpy (copy
, token
->val
.str
.text
, copylen
);
704 copy
[copylen
] = '\0';
706 real_from_string3 (&real
, copy
, TYPE_MODE (const_type
));
707 if (const_type
!= type
)
708 /* Diagnosing if the result of converting the value with excess
709 precision to the semantic type would overflow (with associated
710 double rounding) is more appropriate than diagnosing if the
711 result of converting the string directly to the semantic type
713 real_convert (&real_trunc
, TYPE_MODE (type
), &real
);
715 /* Both C and C++ require a diagnostic for a floating constant
716 outside the range of representable values of its type. Since we
717 have __builtin_inf* to produce an infinity, this is now a
718 mandatory pedwarn if the target does not support infinities. */
719 if (REAL_VALUE_ISINF (real
)
720 || (const_type
!= type
&& REAL_VALUE_ISINF (real_trunc
)))
722 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)))
723 pedwarn (input_location
, 0, "floating constant exceeds range of %qT", type
);
725 warning (OPT_Woverflow
, "floating constant exceeds range of %qT", type
);
727 /* We also give a warning if the value underflows. */
728 else if (REAL_VALUES_EQUAL (real
, dconst0
)
729 || (const_type
!= type
&& REAL_VALUES_EQUAL (real_trunc
, dconst0
)))
731 REAL_VALUE_TYPE realvoidmode
;
732 int overflow
= real_from_string (&realvoidmode
, copy
);
733 if (overflow
< 0 || !REAL_VALUES_EQUAL (realvoidmode
, dconst0
))
734 warning (OPT_Woverflow
, "floating constant truncated to zero");
737 /* Create a node with determined type and value. */
738 value
= build_real (const_type
, real
);
739 if (flags
& CPP_N_IMAGINARY
)
740 value
= build_complex (NULL_TREE
, convert (const_type
, integer_zero_node
),
743 if (type
!= const_type
)
744 value
= build1 (EXCESS_PRECISION_EXPR
, type
, value
);
749 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
753 interpret_fixed (const cpp_token
*token
, unsigned int flags
)
757 FIXED_VALUE_TYPE fixed
;
761 copylen
= token
->val
.str
.len
;
763 if (flags
& CPP_N_FRACT
) /* _Fract. */
765 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Fract. */
767 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
769 type
= unsigned_long_long_fract_type_node
;
772 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
774 type
= unsigned_long_fract_type_node
;
777 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
779 type
= unsigned_short_fract_type_node
;
784 type
= unsigned_fract_type_node
;
788 else /* Signed _Fract. */
790 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
792 type
= long_long_fract_type_node
;
795 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
797 type
= long_fract_type_node
;
800 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
802 type
= short_fract_type_node
;
807 type
= fract_type_node
;
814 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Accum. */
816 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
818 type
= unsigned_long_long_accum_type_node
;
821 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
823 type
= unsigned_long_accum_type_node
;
826 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
828 type
= unsigned_short_accum_type_node
;
833 type
= unsigned_accum_type_node
;
837 else /* Signed _Accum. */
839 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
841 type
= long_long_accum_type_node
;
844 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
846 type
= long_accum_type_node
;
849 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
851 type
= short_accum_type_node
;
856 type
= accum_type_node
;
862 copy
= (char *) alloca (copylen
+ 1);
863 memcpy (copy
, token
->val
.str
.text
, copylen
);
864 copy
[copylen
] = '\0';
866 fixed_from_string (&fixed
, copy
, TYPE_MODE (type
));
868 /* Create a node with determined type and value. */
869 value
= build_fixed (type
, fixed
);
874 /* Convert a series of STRING, WSTRING, STRING16 and/or STRING32 tokens
875 into a tree, performing string constant concatenation. TOK is the
876 first of these. VALP is the location to write the string into.
877 OBJC_STRING indicates whether an '@' token preceded the incoming token.
878 Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
879 CPP_STRING32, CPP_STRING16, or CPP_OBJC_STRING).
881 This is unfortunately more work than it should be. If any of the
882 strings in the series has an L prefix, the result is a wide string
883 (6.4.5p4). Whether or not the result is a wide string affects the
884 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
885 sequences do not continue across the boundary between two strings in
886 a series (6.4.5p7), so we must not lose the boundaries. Therefore
887 cpp_interpret_string takes a vector of cpp_string structures, which
888 we must arrange to provide. */
890 static enum cpp_ttype
891 lex_string (const cpp_token
*tok
, tree
*valp
, bool objc_string
, bool translate
)
895 struct obstack str_ob
;
897 enum cpp_ttype type
= tok
->type
;
899 /* Try to avoid the overhead of creating and destroying an obstack
900 for the common case of just one string. */
901 cpp_string str
= tok
->val
.str
;
902 cpp_string
*strs
= &str
;
905 tok
= cpp_get_token (parse_in
);
911 if (c_dialect_objc ())
924 if (type
!= tok
->type
)
926 if (type
== CPP_STRING
)
929 error ("unsupported non-standard concatenation of string literals");
935 gcc_obstack_init (&str_ob
);
936 obstack_grow (&str_ob
, &str
, sizeof (cpp_string
));
940 obstack_grow (&str_ob
, &tok
->val
.str
, sizeof (cpp_string
));
944 /* We have read one more token than we want. */
945 _cpp_backup_tokens (parse_in
, 1);
947 strs
= XOBFINISH (&str_ob
, cpp_string
*);
949 if (concats
&& !objc_string
&& !in_system_header
)
950 warning (OPT_Wtraditional
,
951 "traditional C rejects string constant concatenation");
954 ? cpp_interpret_string
: cpp_interpret_string_notranslate
)
955 (parse_in
, strs
, concats
+ 1, &istr
, type
))
957 value
= build_string (istr
.len
, (const char *) istr
.text
);
958 free (CONST_CAST (unsigned char *, istr
.text
));
962 /* Callers cannot generally handle error_mark_node in this context,
963 so return the empty string instead. cpp_interpret_string has
969 value
= build_string (1, "");
972 value
= build_string (TYPE_PRECISION (char16_type_node
)
973 / TYPE_PRECISION (char_type_node
),
974 "\0"); /* char16_t is 16 bits */
977 value
= build_string (TYPE_PRECISION (char32_type_node
)
978 / TYPE_PRECISION (char_type_node
),
979 "\0\0\0"); /* char32_t is 32 bits */
982 value
= build_string (TYPE_PRECISION (wchar_type_node
)
983 / TYPE_PRECISION (char_type_node
),
984 "\0\0\0"); /* widest supported wchar_t
994 TREE_TYPE (value
) = char_array_type_node
;
997 TREE_TYPE (value
) = char16_array_type_node
;
1000 TREE_TYPE (value
) = char32_array_type_node
;
1003 TREE_TYPE (value
) = wchar_array_type_node
;
1005 *valp
= fix_string_type (value
);
1008 obstack_free (&str_ob
, 0);
1010 return objc_string
? CPP_OBJC_STRING
: type
;
1013 /* Converts a (possibly wide) character constant token into a tree. */
1015 lex_charconst (const cpp_token
*token
)
1019 unsigned int chars_seen
;
1022 result
= cpp_interpret_charconst (parse_in
, token
,
1023 &chars_seen
, &unsignedp
);
1025 if (token
->type
== CPP_WCHAR
)
1026 type
= wchar_type_node
;
1027 else if (token
->type
== CPP_CHAR32
)
1028 type
= char32_type_node
;
1029 else if (token
->type
== CPP_CHAR16
)
1030 type
= char16_type_node
;
1031 /* In C, a character constant has type 'int'.
1032 In C++ 'char', but multi-char charconsts have type 'int'. */
1033 else if (!c_dialect_cxx () || chars_seen
> 1)
1034 type
= integer_type_node
;
1036 type
= char_type_node
;
1038 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1039 before possibly widening to HOST_WIDE_INT for build_int_cst. */
1040 if (unsignedp
|| (cppchar_signed_t
) result
>= 0)
1041 value
= build_int_cst_wide (type
, result
, 0);
1043 value
= build_int_cst_wide (type
, (cppchar_signed_t
) result
, -1);