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
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 /* If we need to translate characters received. This is tri-state:
53 0 means use only the untranslated string; 1 means use only
54 the translated string; -1 means chain the translated string
55 to the untranslated one. */
56 int c_lex_string_translate
= 1;
58 /* True if strings should be passed to the caller of c_lex completely
59 unmolested (no concatenation, no translation). */
60 bool c_lex_return_raw_strings
= false;
62 static tree
interpret_integer (const cpp_token
*, unsigned int);
63 static tree
interpret_float (const cpp_token
*, unsigned int);
64 static tree
interpret_fixed (const cpp_token
*, unsigned int);
65 static enum integer_type_kind narrowest_unsigned_type
66 (unsigned HOST_WIDE_INT
, unsigned HOST_WIDE_INT
, unsigned int);
67 static enum integer_type_kind narrowest_signed_type
68 (unsigned HOST_WIDE_INT
, unsigned HOST_WIDE_INT
, unsigned int);
69 static enum cpp_ttype
lex_string (const cpp_token
*, tree
*, bool);
70 static tree
lex_charconst (const cpp_token
*);
71 static void update_header_times (const char *);
72 static int dump_one_header (splay_tree_node
, void *);
73 static void cb_line_change (cpp_reader
*, const cpp_token
*, int);
74 static void cb_ident (cpp_reader
*, unsigned int, const cpp_string
*);
75 static void cb_def_pragma (cpp_reader
*, unsigned int);
76 static void cb_define (cpp_reader
*, unsigned int, cpp_hashnode
*);
77 static void cb_undef (cpp_reader
*, unsigned int, cpp_hashnode
*);
82 struct cpp_callbacks
*cb
;
83 struct c_fileinfo
*toplevel
;
85 /* The get_fileinfo data structure must be initialized before
86 cpp_read_main_file is called. */
87 toplevel
= get_fileinfo ("<top level>");
88 if (flag_detailed_statistics
)
91 body_time
= get_run_time ();
92 toplevel
->time
= body_time
;
95 cb
= cpp_get_callbacks (parse_in
);
97 cb
->line_change
= cb_line_change
;
99 cb
->def_pragma
= cb_def_pragma
;
100 cb
->valid_pch
= c_common_valid_pch
;
101 cb
->read_pch
= c_common_read_pch
;
103 /* Set the debug callbacks if we can use them. */
104 if (debug_info_level
== DINFO_LEVEL_VERBOSE
105 && (write_symbols
== DWARF2_DEBUG
106 || write_symbols
== VMS_AND_DWARF2_DEBUG
))
108 cb
->define
= cb_define
;
109 cb
->undef
= cb_undef
;
114 get_fileinfo (const char *name
)
117 struct c_fileinfo
*fi
;
120 file_info_tree
= splay_tree_new ((splay_tree_compare_fn
) strcmp
,
122 (splay_tree_delete_value_fn
) free
);
124 n
= splay_tree_lookup (file_info_tree
, (splay_tree_key
) name
);
126 return (struct c_fileinfo
*) n
->value
;
128 fi
= XNEW (struct c_fileinfo
);
130 fi
->interface_only
= 0;
131 fi
->interface_unknown
= 1;
132 splay_tree_insert (file_info_tree
, (splay_tree_key
) name
,
133 (splay_tree_value
) fi
);
138 update_header_times (const char *name
)
140 /* Changing files again. This means currently collected time
141 is charged against header time, and body time starts back at 0. */
142 if (flag_detailed_statistics
)
144 int this_time
= get_run_time ();
145 struct c_fileinfo
*file
= get_fileinfo (name
);
146 header_time
+= this_time
- body_time
;
147 file
->time
+= this_time
- body_time
;
148 body_time
= this_time
;
153 dump_one_header (splay_tree_node n
, void * ARG_UNUSED (dummy
))
155 print_time ((const char *) n
->key
,
156 ((struct c_fileinfo
*) n
->value
)->time
);
161 dump_time_statistics (void)
163 struct c_fileinfo
*file
= get_fileinfo (input_filename
);
164 int this_time
= get_run_time ();
165 file
->time
+= this_time
- body_time
;
167 fprintf (stderr
, "\n******\n");
168 print_time ("header files (total)", header_time
);
169 print_time ("main file (total)", this_time
- body_time
);
170 fprintf (stderr
, "ratio = %g : 1\n",
171 (double) header_time
/ (double) (this_time
- body_time
));
172 fprintf (stderr
, "\n******\n");
174 splay_tree_foreach (file_info_tree
, dump_one_header
, 0);
178 cb_ident (cpp_reader
* ARG_UNUSED (pfile
),
179 unsigned int ARG_UNUSED (line
),
180 const cpp_string
* ARG_UNUSED (str
))
182 #ifdef ASM_OUTPUT_IDENT
185 /* Convert escapes in the string. */
186 cpp_string cstr
= { 0, 0 };
187 if (cpp_interpret_string (pfile
, str
, 1, &cstr
, false))
189 ASM_OUTPUT_IDENT (asm_out_file
, (const char *) cstr
.text
);
190 free (CONST_CAST (unsigned char *, cstr
.text
));
196 /* Called at the start of every non-empty line. TOKEN is the first
197 lexed token on the line. Used for diagnostic line numbers. */
199 cb_line_change (cpp_reader
* ARG_UNUSED (pfile
), const cpp_token
*token
,
202 if (token
->type
!= CPP_EOF
&& !parsing_args
)
203 #ifdef USE_MAPPED_LOCATION
204 input_location
= token
->src_loc
;
207 source_location loc
= token
->src_loc
;
208 const struct line_map
*map
= linemap_lookup (&line_table
, loc
);
209 input_line
= SOURCE_LINE (map
, loc
);
215 fe_file_change (const struct line_map
*new_map
)
220 if (new_map
->reason
== LC_ENTER
)
222 /* Don't stack the main buffer on the input stack;
223 we already did in compile_file. */
224 if (!MAIN_FILE_P (new_map
))
226 #ifdef USE_MAPPED_LOCATION
227 int included_at
= LAST_SOURCE_LINE_LOCATION (new_map
- 1);
229 input_location
= included_at
;
230 push_srcloc (new_map
->start_location
);
232 int included_at
= LAST_SOURCE_LINE (new_map
- 1);
234 input_line
= included_at
;
235 push_srcloc (new_map
->to_file
, 1);
237 (*debug_hooks
->start_source_file
) (included_at
, new_map
->to_file
);
238 #ifndef NO_IMPLICIT_EXTERN_C
241 else if (new_map
->sysp
== 2)
244 ++pending_lang_change
;
249 else if (new_map
->reason
== LC_LEAVE
)
251 #ifndef NO_IMPLICIT_EXTERN_C
252 if (c_header_level
&& --c_header_level
== 0)
254 if (new_map
->sysp
== 2)
255 warning (0, "badly nested C headers from preprocessor");
256 --pending_lang_change
;
261 (*debug_hooks
->end_source_file
) (new_map
->to_line
);
264 update_header_times (new_map
->to_file
);
265 in_system_header
= new_map
->sysp
!= 0;
266 #ifdef USE_MAPPED_LOCATION
267 input_location
= new_map
->start_location
;
269 input_filename
= new_map
->to_file
;
270 input_line
= new_map
->to_line
;
275 cb_def_pragma (cpp_reader
*pfile
, source_location loc
)
277 /* Issue a warning message if we have been asked to do so. Ignore
278 unknown pragmas in system headers unless an explicit
279 -Wunknown-pragmas has been given. */
280 if (warn_unknown_pragmas
> in_system_header
)
282 const unsigned char *space
, *name
;
284 #ifndef USE_MAPPED_LOCATION
286 const struct line_map
*map
= linemap_lookup (&line_table
, loc
);
287 fe_loc
.file
= map
->to_file
;
288 fe_loc
.line
= SOURCE_LINE (map
, loc
);
290 location_t fe_loc
= loc
;
293 space
= name
= (const unsigned char *) "";
294 s
= cpp_get_token (pfile
);
295 if (s
->type
!= CPP_EOF
)
297 space
= cpp_token_as_text (pfile
, s
);
298 s
= cpp_get_token (pfile
);
299 if (s
->type
== CPP_NAME
)
300 name
= cpp_token_as_text (pfile
, s
);
303 warning (OPT_Wunknown_pragmas
, "%Hignoring #pragma %s %s",
304 &fe_loc
, space
, name
);
308 /* #define callback for DWARF and DWARF2 debug info. */
310 cb_define (cpp_reader
*pfile
, source_location loc
, cpp_hashnode
*node
)
312 const struct line_map
*map
= linemap_lookup (&line_table
, loc
);
313 (*debug_hooks
->define
) (SOURCE_LINE (map
, loc
),
314 (const char *) cpp_macro_definition (pfile
, node
));
317 /* #undef callback for DWARF and DWARF2 debug info. */
319 cb_undef (cpp_reader
* ARG_UNUSED (pfile
), source_location loc
,
322 const struct line_map
*map
= linemap_lookup (&line_table
, loc
);
323 (*debug_hooks
->undef
) (SOURCE_LINE (map
, loc
),
324 (const char *) NODE_NAME (node
));
327 /* Read a token and return its type. Fill *VALUE with its value, if
328 applicable. Fill *CPP_FLAGS with the token's flags, if it is
332 c_lex_with_flags (tree
*value
, location_t
*loc
, unsigned char *cpp_flags
)
334 static bool no_more_pch
;
335 const cpp_token
*tok
;
337 unsigned char add_flags
= 0;
339 timevar_push (TV_CPP
);
341 tok
= cpp_get_token (parse_in
);
345 #ifdef USE_MAPPED_LOCATION
348 *loc
= input_location
;
356 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
));
361 unsigned int flags
= cpp_classify_number (parse_in
, tok
);
363 switch (flags
& CPP_N_CATEGORY
)
366 /* cpplib has issued an error. */
367 *value
= error_mark_node
;
372 /* C++ uses '0' to mark virtual functions as pure.
373 Set PURE_ZERO to pass this information to the C++ parser. */
374 if (tok
->val
.str
.len
== 1 && *tok
->val
.str
.text
== '0')
375 add_flags
= PURE_ZERO
;
376 *value
= interpret_integer (tok
, flags
);
380 *value
= interpret_float (tok
, flags
);
390 /* An @ may give the next token special significance in Objective-C. */
391 if (c_dialect_objc ())
393 location_t atloc
= input_location
;
396 tok
= cpp_get_token (parse_in
);
405 type
= lex_string (tok
, value
, true);
409 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
));
410 if (objc_is_reserved_word (*value
))
419 error ("%Hstray %<@%> in program", &atloc
);
429 unsigned char name
[4];
431 *cpp_spell_token (parse_in
, tok
, name
, true) = 0;
433 error ("stray %qs in program", name
);
440 cppchar_t c
= tok
->val
.str
.text
[0];
442 if (c
== '"' || c
== '\'')
443 error ("missing terminating %c character", (int) c
);
444 else if (ISGRAPH (c
))
445 error ("stray %qc in program", (int) c
);
447 error ("stray %<\\%o%> in program", (int) c
);
453 *value
= lex_charconst (tok
);
458 if (!c_lex_return_raw_strings
)
460 type
= lex_string (tok
, value
, false);
463 *value
= build_string (tok
->val
.str
.len
, (const char *) tok
->val
.str
.text
);
467 *value
= build_int_cst (NULL
, tok
->val
.pragma
);
470 /* These tokens should not be visible outside cpplib. */
471 case CPP_HEADER_NAME
:
482 *cpp_flags
= tok
->flags
| add_flags
;
487 c_common_no_more_pch ();
490 timevar_pop (TV_CPP
);
495 /* Returns the narrowest C-visible unsigned type, starting with the
496 minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
499 static enum integer_type_kind
500 narrowest_unsigned_type (unsigned HOST_WIDE_INT low
,
501 unsigned HOST_WIDE_INT high
,
504 enum integer_type_kind itk
;
506 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
507 itk
= itk_unsigned_int
;
508 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
509 itk
= itk_unsigned_long
;
511 itk
= itk_unsigned_long_long
;
513 for (; itk
< itk_none
; itk
+= 2 /* skip unsigned types */)
515 tree upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
517 if ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) > high
518 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) == high
519 && TREE_INT_CST_LOW (upper
) >= low
))
526 /* Ditto, but narrowest signed type. */
527 static enum integer_type_kind
528 narrowest_signed_type (unsigned HOST_WIDE_INT low
,
529 unsigned HOST_WIDE_INT high
, unsigned int flags
)
531 enum integer_type_kind itk
;
533 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
535 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
541 for (; itk
< itk_none
; itk
+= 2 /* skip signed types */)
543 tree upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
545 if ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) > high
546 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) == high
547 && TREE_INT_CST_LOW (upper
) >= low
))
554 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
556 interpret_integer (const cpp_token
*token
, unsigned int flags
)
559 enum integer_type_kind itk
;
561 cpp_options
*options
= cpp_get_options (parse_in
);
563 integer
= cpp_interpret_integer (parse_in
, token
, flags
);
564 integer
= cpp_num_sign_extend (integer
, options
->precision
);
566 /* The type of a constant with a U suffix is straightforward. */
567 if (flags
& CPP_N_UNSIGNED
)
568 itk
= narrowest_unsigned_type (integer
.low
, integer
.high
, flags
);
571 /* The type of a potentially-signed integer constant varies
572 depending on the base it's in, the standard in use, and the
574 enum integer_type_kind itk_u
575 = narrowest_unsigned_type (integer
.low
, integer
.high
, flags
);
576 enum integer_type_kind itk_s
577 = narrowest_signed_type (integer
.low
, integer
.high
, flags
);
579 /* In both C89 and C99, octal and hex constants may be signed or
580 unsigned, whichever fits tighter. We do not warn about this
581 choice differing from the traditional choice, as the constant
582 is probably a bit pattern and either way will work. */
583 if ((flags
& CPP_N_RADIX
) != CPP_N_DECIMAL
)
584 itk
= MIN (itk_u
, itk_s
);
587 /* In C99, decimal constants are always signed.
588 In C89, decimal constants that don't fit in long have
589 undefined behavior; we try to make them unsigned long.
590 In GCC's extended C89, that last is true of decimal
591 constants that don't fit in long long, too. */
594 if (itk_s
> itk_u
&& itk_s
> itk_long
)
598 if (itk_u
< itk_unsigned_long
)
599 itk_u
= itk_unsigned_long
;
601 warning (0, "this decimal constant is unsigned only in ISO C90");
604 warning (OPT_Wtraditional
,
605 "this decimal constant would be unsigned in ISO C90");
611 /* cpplib has already issued a warning for overflow. */
612 type
= ((flags
& CPP_N_UNSIGNED
)
613 ? widest_unsigned_literal_type_node
614 : widest_integer_literal_type_node
);
616 type
= integer_types
[itk
];
618 if (itk
> itk_unsigned_long
619 && (flags
& CPP_N_WIDTH
) != CPP_N_LARGE
620 && !in_system_header
&& !flag_isoc99
)
621 pedwarn ("integer constant is too large for %qs type",
622 (flags
& CPP_N_UNSIGNED
) ? "unsigned long" : "long");
624 value
= build_int_cst_wide (type
, integer
.low
, integer
.high
);
626 /* Convert imaginary to a complex type. */
627 if (flags
& CPP_N_IMAGINARY
)
628 value
= build_complex (NULL_TREE
, build_int_cst (type
, 0), value
);
633 /* Interpret TOKEN, a floating point number with FLAGS as classified
636 interpret_float (const cpp_token
*token
, unsigned int flags
)
640 REAL_VALUE_TYPE real
;
644 /* Decode _Fract and _Accum. */
645 if (flags
& CPP_N_FRACT
|| flags
& CPP_N_ACCUM
)
646 return interpret_fixed (token
, flags
);
648 /* Decode type based on width and properties. */
649 if (flags
& CPP_N_DFLOAT
)
650 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
651 type
= dfloat128_type_node
;
652 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
653 type
= dfloat32_type_node
;
655 type
= dfloat64_type_node
;
657 if (flags
& CPP_N_WIDTH_MD
)
660 enum machine_mode mode
;
662 if ((flags
& CPP_N_WIDTH_MD
) == CPP_N_MD_W
)
667 mode
= targetm
.c
.mode_for_suffix (suffix
);
668 if (mode
== VOIDmode
)
670 error ("unsupported non-standard suffix on floating constant");
673 return error_mark_node
;
676 pedwarn ("non-standard suffix on floating constant");
678 type
= c_common_type_for_mode (mode
, 0);
681 else if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
682 type
= long_double_type_node
;
683 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
684 || flag_single_precision_constant
)
685 type
= float_type_node
;
687 type
= double_type_node
;
689 /* Copy the constant to a nul-terminated buffer. If the constant
690 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
691 can't handle them. */
692 copylen
= token
->val
.str
.len
;
693 if (flags
& CPP_N_DFLOAT
)
697 if ((flags
& CPP_N_WIDTH
) != CPP_N_MEDIUM
)
698 /* Must be an F or L or machine defined suffix. */
700 if (flags
& CPP_N_IMAGINARY
)
705 copy
= (char *) alloca (copylen
+ 1);
706 memcpy (copy
, token
->val
.str
.text
, copylen
);
707 copy
[copylen
] = '\0';
709 real_from_string3 (&real
, copy
, TYPE_MODE (type
));
711 /* Both C and C++ require a diagnostic for a floating constant
712 outside the range of representable values of its type. Since we
713 have __builtin_inf* to produce an infinity, this is now a
714 mandatory pedwarn if the target does not support infinities. */
715 if (REAL_VALUE_ISINF (real
))
717 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)))
718 pedwarn ("floating constant exceeds range of %qT", type
);
720 warning (OPT_Woverflow
, "floating constant exceeds range of %qT", type
);
722 /* We also give a warning if the value underflows. */
723 else if (REAL_VALUES_EQUAL (real
, dconst0
))
725 REAL_VALUE_TYPE realvoidmode
;
726 int overflow
= real_from_string (&realvoidmode
, copy
);
727 if (overflow
< 0 || !REAL_VALUES_EQUAL (realvoidmode
, dconst0
))
728 warning (OPT_Woverflow
, "floating constant truncated to zero");
731 /* Create a node with determined type and value. */
732 value
= build_real (type
, real
);
733 if (flags
& CPP_N_IMAGINARY
)
734 value
= build_complex (NULL_TREE
, convert (type
, integer_zero_node
), value
);
739 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
743 interpret_fixed (const cpp_token
*token
, unsigned int flags
)
747 FIXED_VALUE_TYPE fixed
;
751 copylen
= token
->val
.str
.len
;
753 if (flags
& CPP_N_FRACT
) /* _Fract. */
755 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Fract. */
757 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
759 type
= unsigned_long_long_fract_type_node
;
762 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
764 type
= unsigned_long_fract_type_node
;
767 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
769 type
= unsigned_short_fract_type_node
;
774 type
= unsigned_fract_type_node
;
778 else /* Signed _Fract. */
780 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
782 type
= long_long_fract_type_node
;
785 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
787 type
= long_fract_type_node
;
790 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
792 type
= short_fract_type_node
;
797 type
= fract_type_node
;
804 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Accum. */
806 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
808 type
= unsigned_long_long_accum_type_node
;
811 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
813 type
= unsigned_long_accum_type_node
;
816 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
818 type
= unsigned_short_accum_type_node
;
823 type
= unsigned_accum_type_node
;
827 else /* Signed _Accum. */
829 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
831 type
= long_long_accum_type_node
;
834 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
836 type
= long_accum_type_node
;
839 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
841 type
= short_accum_type_node
;
846 type
= accum_type_node
;
852 copy
= (char *) alloca (copylen
+ 1);
853 memcpy (copy
, token
->val
.str
.text
, copylen
);
854 copy
[copylen
] = '\0';
856 fixed_from_string (&fixed
, copy
, TYPE_MODE (type
));
858 /* Create a node with determined type and value. */
859 value
= build_fixed (type
, fixed
);
864 /* Convert a series of STRING and/or WSTRING tokens into a tree,
865 performing string constant concatenation. TOK is the first of
866 these. VALP is the location to write the string into. OBJC_STRING
867 indicates whether an '@' token preceded the incoming token.
868 Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
871 This is unfortunately more work than it should be. If any of the
872 strings in the series has an L prefix, the result is a wide string
873 (6.4.5p4). Whether or not the result is a wide string affects the
874 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
875 sequences do not continue across the boundary between two strings in
876 a series (6.4.5p7), so we must not lose the boundaries. Therefore
877 cpp_interpret_string takes a vector of cpp_string structures, which
878 we must arrange to provide. */
880 static enum cpp_ttype
881 lex_string (const cpp_token
*tok
, tree
*valp
, bool objc_string
)
886 struct obstack str_ob
;
889 /* Try to avoid the overhead of creating and destroying an obstack
890 for the common case of just one string. */
891 cpp_string str
= tok
->val
.str
;
892 cpp_string
*strs
= &str
;
894 if (tok
->type
== CPP_WSTRING
)
898 tok
= cpp_get_token (parse_in
);
904 if (c_dialect_objc ())
921 gcc_obstack_init (&str_ob
);
922 obstack_grow (&str_ob
, &str
, sizeof (cpp_string
));
926 obstack_grow (&str_ob
, &tok
->val
.str
, sizeof (cpp_string
));
930 /* We have read one more token than we want. */
931 _cpp_backup_tokens (parse_in
, 1);
933 strs
= XOBFINISH (&str_ob
, cpp_string
*);
935 if (concats
&& !objc_string
&& !in_system_header
)
936 warning (OPT_Wtraditional
,
937 "traditional C rejects string constant concatenation");
939 if ((c_lex_string_translate
940 ? cpp_interpret_string
: cpp_interpret_string_notranslate
)
941 (parse_in
, strs
, concats
+ 1, &istr
, wide
))
943 value
= build_string (istr
.len
, (const char *) istr
.text
);
944 free (CONST_CAST (unsigned char *, istr
.text
));
946 if (c_lex_string_translate
== -1)
948 int xlated
= cpp_interpret_string_notranslate (parse_in
, strs
,
951 /* Assume that, if we managed to translate the string above,
952 then the untranslated parsing will always succeed. */
955 if (TREE_STRING_LENGTH (value
) != (int) istr
.len
956 || 0 != strncmp (TREE_STRING_POINTER (value
),
957 (const char *) istr
.text
, istr
.len
))
959 /* Arrange for us to return the untranslated string in
960 *valp, but to set up the C type of the translated
962 *valp
= build_string (istr
.len
, (const char *) istr
.text
);
963 valp
= &TREE_CHAIN (*valp
);
965 free (CONST_CAST (unsigned char *, istr
.text
));
970 /* Callers cannot generally handle error_mark_node in this context,
971 so return the empty string instead. cpp_interpret_string has
974 value
= build_string (TYPE_PRECISION (wchar_type_node
)
975 / TYPE_PRECISION (char_type_node
),
976 "\0\0\0"); /* widest supported wchar_t
979 value
= build_string (1, "");
982 TREE_TYPE (value
) = wide
? wchar_array_type_node
: char_array_type_node
;
983 *valp
= fix_string_type (value
);
986 obstack_free (&str_ob
, 0);
988 return objc_string
? CPP_OBJC_STRING
: wide
? CPP_WSTRING
: CPP_STRING
;
991 /* Converts a (possibly wide) character constant token into a tree. */
993 lex_charconst (const cpp_token
*token
)
997 unsigned int chars_seen
;
1000 result
= cpp_interpret_charconst (parse_in
, token
,
1001 &chars_seen
, &unsignedp
);
1003 if (token
->type
== CPP_WCHAR
)
1004 type
= wchar_type_node
;
1005 /* In C, a character constant has type 'int'.
1006 In C++ 'char', but multi-char charconsts have type 'int'. */
1007 else if (!c_dialect_cxx () || chars_seen
> 1)
1008 type
= integer_type_node
;
1010 type
= char_type_node
;
1012 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1013 before possibly widening to HOST_WIDE_INT for build_int_cst. */
1014 if (unsignedp
|| (cppchar_signed_t
) result
>= 0)
1015 value
= build_int_cst_wide (type
, result
, 0);
1017 value
= build_int_cst_wide (type
, (cppchar_signed_t
) result
, -1);