Makefile.am: Add install-pdf target as copied from automake v1.10 rules.
[official-gcc.git] / gcc / c-lex.c
blob108bc5cff17474e3fe33d10ea94a5bae84366cd4
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
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 2, or (at your option) any later
11 version.
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
16 for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
21 02110-1301, USA. */
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
28 #include "real.h"
29 #include "rtl.h"
30 #include "tree.h"
31 #include "input.h"
32 #include "output.h"
33 #include "c-tree.h"
34 #include "c-common.h"
35 #include "flags.h"
36 #include "timevar.h"
37 #include "cpplib.h"
38 #include "c-pragma.h"
39 #include "toplev.h"
40 #include "intl.h"
41 #include "tm_p.h"
42 #include "splay-tree.h"
43 #include "debug.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 enum integer_type_kind narrowest_unsigned_type
65 (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
66 static enum integer_type_kind narrowest_signed_type
67 (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
68 static enum cpp_ttype lex_string (const cpp_token *, tree *, bool);
69 static tree lex_charconst (const cpp_token *);
70 static void update_header_times (const char *);
71 static int dump_one_header (splay_tree_node, void *);
72 static void cb_line_change (cpp_reader *, const cpp_token *, int);
73 static void cb_ident (cpp_reader *, unsigned int, const cpp_string *);
74 static void cb_def_pragma (cpp_reader *, unsigned int);
75 static void cb_define (cpp_reader *, unsigned int, cpp_hashnode *);
76 static void cb_undef (cpp_reader *, unsigned int, cpp_hashnode *);
78 void
79 init_c_lex (void)
81 struct cpp_callbacks *cb;
82 struct c_fileinfo *toplevel;
84 /* The get_fileinfo data structure must be initialized before
85 cpp_read_main_file is called. */
86 toplevel = get_fileinfo ("<top level>");
87 if (flag_detailed_statistics)
89 header_time = 0;
90 body_time = get_run_time ();
91 toplevel->time = body_time;
94 cb = cpp_get_callbacks (parse_in);
96 cb->line_change = cb_line_change;
97 cb->ident = cb_ident;
98 cb->def_pragma = cb_def_pragma;
99 cb->valid_pch = c_common_valid_pch;
100 cb->read_pch = c_common_read_pch;
102 /* Set the debug callbacks if we can use them. */
103 if (debug_info_level == DINFO_LEVEL_VERBOSE
104 && (write_symbols == DWARF2_DEBUG
105 || write_symbols == VMS_AND_DWARF2_DEBUG))
107 cb->define = cb_define;
108 cb->undef = cb_undef;
112 struct c_fileinfo *
113 get_fileinfo (const char *name)
115 splay_tree_node n;
116 struct c_fileinfo *fi;
118 if (!file_info_tree)
119 file_info_tree = splay_tree_new ((splay_tree_compare_fn) strcmp,
121 (splay_tree_delete_value_fn) free);
123 n = splay_tree_lookup (file_info_tree, (splay_tree_key) name);
124 if (n)
125 return (struct c_fileinfo *) n->value;
127 fi = XNEW (struct c_fileinfo);
128 fi->time = 0;
129 fi->interface_only = 0;
130 fi->interface_unknown = 1;
131 splay_tree_insert (file_info_tree, (splay_tree_key) name,
132 (splay_tree_value) fi);
133 return fi;
136 static void
137 update_header_times (const char *name)
139 /* Changing files again. This means currently collected time
140 is charged against header time, and body time starts back at 0. */
141 if (flag_detailed_statistics)
143 int this_time = get_run_time ();
144 struct c_fileinfo *file = get_fileinfo (name);
145 header_time += this_time - body_time;
146 file->time += this_time - body_time;
147 body_time = this_time;
151 static int
152 dump_one_header (splay_tree_node n, void * ARG_UNUSED (dummy))
154 print_time ((const char *) n->key,
155 ((struct c_fileinfo *) n->value)->time);
156 return 0;
159 void
160 dump_time_statistics (void)
162 struct c_fileinfo *file = get_fileinfo (input_filename);
163 int this_time = get_run_time ();
164 file->time += this_time - body_time;
166 fprintf (stderr, "\n******\n");
167 print_time ("header files (total)", header_time);
168 print_time ("main file (total)", this_time - body_time);
169 fprintf (stderr, "ratio = %g : 1\n",
170 (double) header_time / (double) (this_time - body_time));
171 fprintf (stderr, "\n******\n");
173 splay_tree_foreach (file_info_tree, dump_one_header, 0);
176 static void
177 cb_ident (cpp_reader * ARG_UNUSED (pfile),
178 unsigned int ARG_UNUSED (line),
179 const cpp_string * ARG_UNUSED (str))
181 #ifdef ASM_OUTPUT_IDENT
182 if (!flag_no_ident)
184 /* Convert escapes in the string. */
185 cpp_string cstr = { 0, 0 };
186 if (cpp_interpret_string (pfile, str, 1, &cstr, false))
188 ASM_OUTPUT_IDENT (asm_out_file, (const char *) cstr.text);
189 free ((void *) cstr.text);
192 #endif
195 /* Called at the start of every non-empty line. TOKEN is the first
196 lexed token on the line. Used for diagnostic line numbers. */
197 static void
198 cb_line_change (cpp_reader * ARG_UNUSED (pfile), const cpp_token *token,
199 int parsing_args)
201 if (token->type != CPP_EOF && !parsing_args)
202 #ifdef USE_MAPPED_LOCATION
203 input_location = token->src_loc;
204 #else
206 source_location loc = token->src_loc;
207 const struct line_map *map = linemap_lookup (&line_table, loc);
208 input_line = SOURCE_LINE (map, loc);
210 #endif
213 void
214 fe_file_change (const struct line_map *new_map)
216 if (new_map == NULL)
217 return;
219 if (new_map->reason == LC_ENTER)
221 /* Don't stack the main buffer on the input stack;
222 we already did in compile_file. */
223 if (!MAIN_FILE_P (new_map))
225 #ifdef USE_MAPPED_LOCATION
226 int included_at = LAST_SOURCE_LINE_LOCATION (new_map - 1);
228 input_location = included_at;
229 push_srcloc (new_map->start_location);
230 #else
231 int included_at = LAST_SOURCE_LINE (new_map - 1);
233 input_line = included_at;
234 push_srcloc (new_map->to_file, 1);
235 #endif
236 (*debug_hooks->start_source_file) (included_at, new_map->to_file);
237 #ifndef NO_IMPLICIT_EXTERN_C
238 if (c_header_level)
239 ++c_header_level;
240 else if (new_map->sysp == 2)
242 c_header_level = 1;
243 ++pending_lang_change;
245 #endif
248 else if (new_map->reason == LC_LEAVE)
250 #ifndef NO_IMPLICIT_EXTERN_C
251 if (c_header_level && --c_header_level == 0)
253 if (new_map->sysp == 2)
254 warning (0, "badly nested C headers from preprocessor");
255 --pending_lang_change;
257 #endif
258 pop_srcloc ();
260 (*debug_hooks->end_source_file) (new_map->to_line);
263 update_header_times (new_map->to_file);
264 in_system_header = new_map->sysp != 0;
265 #ifdef USE_MAPPED_LOCATION
266 input_location = new_map->start_location;
267 #else
268 input_filename = new_map->to_file;
269 input_line = new_map->to_line;
270 #endif
273 static void
274 cb_def_pragma (cpp_reader *pfile, source_location loc)
276 /* Issue a warning message if we have been asked to do so. Ignore
277 unknown pragmas in system headers unless an explicit
278 -Wunknown-pragmas has been given. */
279 if (warn_unknown_pragmas > in_system_header)
281 const unsigned char *space, *name;
282 const cpp_token *s;
283 #ifndef USE_MAPPED_LOCATION
284 location_t fe_loc;
285 const struct line_map *map = linemap_lookup (&line_table, loc);
286 fe_loc.file = map->to_file;
287 fe_loc.line = SOURCE_LINE (map, loc);
288 #else
289 location_t fe_loc = loc;
290 #endif
292 space = name = (const unsigned char *) "";
293 s = cpp_get_token (pfile);
294 if (s->type != CPP_EOF)
296 space = cpp_token_as_text (pfile, s);
297 s = cpp_get_token (pfile);
298 if (s->type == CPP_NAME)
299 name = cpp_token_as_text (pfile, s);
302 warning (OPT_Wunknown_pragmas, "%Hignoring #pragma %s %s",
303 &fe_loc, space, name);
307 /* #define callback for DWARF and DWARF2 debug info. */
308 static void
309 cb_define (cpp_reader *pfile, source_location loc, cpp_hashnode *node)
311 const struct line_map *map = linemap_lookup (&line_table, loc);
312 (*debug_hooks->define) (SOURCE_LINE (map, loc),
313 (const char *) cpp_macro_definition (pfile, node));
316 /* #undef callback for DWARF and DWARF2 debug info. */
317 static void
318 cb_undef (cpp_reader * ARG_UNUSED (pfile), source_location loc,
319 cpp_hashnode *node)
321 const struct line_map *map = linemap_lookup (&line_table, loc);
322 (*debug_hooks->undef) (SOURCE_LINE (map, loc),
323 (const char *) NODE_NAME (node));
326 /* Read a token and return its type. Fill *VALUE with its value, if
327 applicable. Fill *CPP_FLAGS with the token's flags, if it is
328 non-NULL. */
330 enum cpp_ttype
331 c_lex_with_flags (tree *value, location_t *loc, unsigned char *cpp_flags)
333 static bool no_more_pch;
334 const cpp_token *tok;
335 enum cpp_ttype type;
336 unsigned char add_flags = 0;
338 timevar_push (TV_CPP);
339 retry:
340 tok = cpp_get_token (parse_in);
341 type = tok->type;
343 retry_after_at:
344 #ifdef USE_MAPPED_LOCATION
345 *loc = tok->src_loc;
346 #else
347 *loc = input_location;
348 #endif
349 switch (type)
351 case CPP_PADDING:
352 goto retry;
354 case CPP_NAME:
355 *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
356 break;
358 case CPP_NUMBER:
360 unsigned int flags = cpp_classify_number (parse_in, tok);
362 switch (flags & CPP_N_CATEGORY)
364 case CPP_N_INVALID:
365 /* cpplib has issued an error. */
366 *value = error_mark_node;
367 errorcount++;
368 break;
370 case CPP_N_INTEGER:
371 /* C++ uses '0' to mark virtual functions as pure.
372 Set PURE_ZERO to pass this information to the C++ parser. */
373 if (tok->val.str.len == 1 && *tok->val.str.text == '0')
374 add_flags = PURE_ZERO;
375 *value = interpret_integer (tok, flags);
376 break;
378 case CPP_N_FLOATING:
379 *value = interpret_float (tok, flags);
380 break;
382 default:
383 gcc_unreachable ();
386 break;
388 case CPP_ATSIGN:
389 /* An @ may give the next token special significance in Objective-C. */
390 if (c_dialect_objc ())
392 location_t atloc = input_location;
394 retry_at:
395 tok = cpp_get_token (parse_in);
396 type = tok->type;
397 switch (type)
399 case CPP_PADDING:
400 goto retry_at;
402 case CPP_STRING:
403 case CPP_WSTRING:
404 type = lex_string (tok, value, true);
405 break;
407 case CPP_NAME:
408 *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
409 if (objc_is_reserved_word (*value))
411 type = CPP_AT_NAME;
412 break;
414 /* FALLTHROUGH */
416 default:
417 /* ... or not. */
418 error ("%Hstray %<@%> in program", &atloc);
419 goto retry_after_at;
421 break;
424 /* FALLTHROUGH */
425 case CPP_HASH:
426 case CPP_PASTE:
428 unsigned char name[4];
430 *cpp_spell_token (parse_in, tok, name, true) = 0;
432 error ("stray %qs in program", name);
435 goto retry;
437 case CPP_OTHER:
439 cppchar_t c = tok->val.str.text[0];
441 if (c == '"' || c == '\'')
442 error ("missing terminating %c character", (int) c);
443 else if (ISGRAPH (c))
444 error ("stray %qc in program", (int) c);
445 else
446 error ("stray %<\\%o%> in program", (int) c);
448 goto retry;
450 case CPP_CHAR:
451 case CPP_WCHAR:
452 *value = lex_charconst (tok);
453 break;
455 case CPP_STRING:
456 case CPP_WSTRING:
457 if (!c_lex_return_raw_strings)
459 type = lex_string (tok, value, false);
460 break;
462 *value = build_string (tok->val.str.len, (char *) tok->val.str.text);
463 break;
465 case CPP_PRAGMA:
466 *value = build_int_cst (NULL, tok->val.pragma);
467 break;
469 /* These tokens should not be visible outside cpplib. */
470 case CPP_HEADER_NAME:
471 case CPP_COMMENT:
472 case CPP_MACRO_ARG:
473 gcc_unreachable ();
475 default:
476 *value = NULL_TREE;
477 break;
480 if (cpp_flags)
481 *cpp_flags = tok->flags | add_flags;
483 if (!no_more_pch)
485 no_more_pch = true;
486 c_common_no_more_pch ();
489 timevar_pop (TV_CPP);
491 return type;
494 /* Returns the narrowest C-visible unsigned type, starting with the
495 minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
496 there isn't one. */
498 static enum integer_type_kind
499 narrowest_unsigned_type (unsigned HOST_WIDE_INT low,
500 unsigned HOST_WIDE_INT high,
501 unsigned int flags)
503 enum integer_type_kind itk;
505 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
506 itk = itk_unsigned_int;
507 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
508 itk = itk_unsigned_long;
509 else
510 itk = itk_unsigned_long_long;
512 for (; itk < itk_none; itk += 2 /* skip unsigned types */)
514 tree upper = TYPE_MAX_VALUE (integer_types[itk]);
516 if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
517 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
518 && TREE_INT_CST_LOW (upper) >= low))
519 return itk;
522 return itk_none;
525 /* Ditto, but narrowest signed type. */
526 static enum integer_type_kind
527 narrowest_signed_type (unsigned HOST_WIDE_INT low,
528 unsigned HOST_WIDE_INT high, unsigned int flags)
530 enum integer_type_kind itk;
532 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
533 itk = itk_int;
534 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
535 itk = itk_long;
536 else
537 itk = itk_long_long;
540 for (; itk < itk_none; itk += 2 /* skip signed types */)
542 tree upper = TYPE_MAX_VALUE (integer_types[itk]);
544 if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
545 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
546 && TREE_INT_CST_LOW (upper) >= low))
547 return itk;
550 return itk_none;
553 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
554 static tree
555 interpret_integer (const cpp_token *token, unsigned int flags)
557 tree value, type;
558 enum integer_type_kind itk;
559 cpp_num integer;
560 cpp_options *options = cpp_get_options (parse_in);
562 integer = cpp_interpret_integer (parse_in, token, flags);
563 integer = cpp_num_sign_extend (integer, options->precision);
565 /* The type of a constant with a U suffix is straightforward. */
566 if (flags & CPP_N_UNSIGNED)
567 itk = narrowest_unsigned_type (integer.low, integer.high, flags);
568 else
570 /* The type of a potentially-signed integer constant varies
571 depending on the base it's in, the standard in use, and the
572 length suffixes. */
573 enum integer_type_kind itk_u
574 = narrowest_unsigned_type (integer.low, integer.high, flags);
575 enum integer_type_kind itk_s
576 = narrowest_signed_type (integer.low, integer.high, flags);
578 /* In both C89 and C99, octal and hex constants may be signed or
579 unsigned, whichever fits tighter. We do not warn about this
580 choice differing from the traditional choice, as the constant
581 is probably a bit pattern and either way will work. */
582 if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
583 itk = MIN (itk_u, itk_s);
584 else
586 /* In C99, decimal constants are always signed.
587 In C89, decimal constants that don't fit in long have
588 undefined behavior; we try to make them unsigned long.
589 In GCC's extended C89, that last is true of decimal
590 constants that don't fit in long long, too. */
592 itk = itk_s;
593 if (itk_s > itk_u && itk_s > itk_long)
595 if (!flag_isoc99)
597 if (itk_u < itk_unsigned_long)
598 itk_u = itk_unsigned_long;
599 itk = itk_u;
600 warning (0, "this decimal constant is unsigned only in ISO C90");
602 else
603 warning (OPT_Wtraditional,
604 "this decimal constant would be unsigned in ISO C90");
609 if (itk == itk_none)
610 /* cpplib has already issued a warning for overflow. */
611 type = ((flags & CPP_N_UNSIGNED)
612 ? widest_unsigned_literal_type_node
613 : widest_integer_literal_type_node);
614 else
615 type = integer_types[itk];
617 if (itk > itk_unsigned_long
618 && (flags & CPP_N_WIDTH) != CPP_N_LARGE
619 && !in_system_header && !flag_isoc99)
620 pedwarn ("integer constant is too large for %qs type",
621 (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long");
623 value = build_int_cst_wide (type, integer.low, integer.high);
625 /* Convert imaginary to a complex type. */
626 if (flags & CPP_N_IMAGINARY)
627 value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
629 return value;
632 /* Interpret TOKEN, a floating point number with FLAGS as classified
633 by cpplib. */
634 static tree
635 interpret_float (const cpp_token *token, unsigned int flags)
637 tree type;
638 tree value;
639 REAL_VALUE_TYPE real;
640 char *copy;
641 size_t copylen;
643 /* Decode type based on width and properties. */
644 if (flags & CPP_N_DFLOAT)
645 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
646 type = dfloat128_type_node;
647 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
648 type = dfloat32_type_node;
649 else
650 type = dfloat64_type_node;
651 else
652 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
653 type = long_double_type_node;
654 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
655 || flag_single_precision_constant)
656 type = float_type_node;
657 else
658 type = double_type_node;
660 /* Copy the constant to a nul-terminated buffer. If the constant
661 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
662 can't handle them. */
663 copylen = token->val.str.len;
664 if (flags & CPP_N_DFLOAT)
665 copylen -= 2;
666 else
668 if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
669 /* Must be an F or L suffix. */
670 copylen--;
671 if (flags & CPP_N_IMAGINARY)
672 /* I or J suffix. */
673 copylen--;
676 copy = (char *) alloca (copylen + 1);
677 memcpy (copy, token->val.str.text, copylen);
678 copy[copylen] = '\0';
680 real_from_string3 (&real, copy, TYPE_MODE (type));
682 /* Both C and C++ require a diagnostic for a floating constant
683 outside the range of representable values of its type. Since we
684 have __builtin_inf* to produce an infinity, it might now be
685 appropriate for this to be a mandatory pedwarn rather than
686 conditioned on -pedantic. */
687 if (REAL_VALUE_ISINF (real) && pedantic)
688 pedwarn ("floating constant exceeds range of %qT", type);
690 /* Create a node with determined type and value. */
691 value = build_real (type, real);
692 if (flags & CPP_N_IMAGINARY)
693 value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
695 return value;
698 /* Convert a series of STRING and/or WSTRING tokens into a tree,
699 performing string constant concatenation. TOK is the first of
700 these. VALP is the location to write the string into. OBJC_STRING
701 indicates whether an '@' token preceded the incoming token.
702 Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
703 or CPP_OBJC_STRING).
705 This is unfortunately more work than it should be. If any of the
706 strings in the series has an L prefix, the result is a wide string
707 (6.4.5p4). Whether or not the result is a wide string affects the
708 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
709 sequences do not continue across the boundary between two strings in
710 a series (6.4.5p7), so we must not lose the boundaries. Therefore
711 cpp_interpret_string takes a vector of cpp_string structures, which
712 we must arrange to provide. */
714 static enum cpp_ttype
715 lex_string (const cpp_token *tok, tree *valp, bool objc_string)
717 tree value;
718 bool wide = false;
719 size_t concats = 0;
720 struct obstack str_ob;
721 cpp_string istr;
723 /* Try to avoid the overhead of creating and destroying an obstack
724 for the common case of just one string. */
725 cpp_string str = tok->val.str;
726 cpp_string *strs = &str;
728 if (tok->type == CPP_WSTRING)
729 wide = true;
731 retry:
732 tok = cpp_get_token (parse_in);
733 switch (tok->type)
735 case CPP_PADDING:
736 goto retry;
737 case CPP_ATSIGN:
738 if (c_dialect_objc ())
740 objc_string = true;
741 goto retry;
743 /* FALLTHROUGH */
745 default:
746 break;
748 case CPP_WSTRING:
749 wide = true;
750 /* FALLTHROUGH */
752 case CPP_STRING:
753 if (!concats)
755 gcc_obstack_init (&str_ob);
756 obstack_grow (&str_ob, &str, sizeof (cpp_string));
759 concats++;
760 obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
761 goto retry;
764 /* We have read one more token than we want. */
765 _cpp_backup_tokens (parse_in, 1);
766 if (concats)
767 strs = XOBFINISH (&str_ob, cpp_string *);
769 if (concats && !objc_string && !in_system_header)
770 warning (OPT_Wtraditional,
771 "traditional C rejects string constant concatenation");
773 if ((c_lex_string_translate
774 ? cpp_interpret_string : cpp_interpret_string_notranslate)
775 (parse_in, strs, concats + 1, &istr, wide))
777 value = build_string (istr.len, (char *) istr.text);
778 free ((void *) istr.text);
780 if (c_lex_string_translate == -1)
782 int xlated = cpp_interpret_string_notranslate (parse_in, strs,
783 concats + 1,
784 &istr, wide);
785 /* Assume that, if we managed to translate the string above,
786 then the untranslated parsing will always succeed. */
787 gcc_assert (xlated);
789 if (TREE_STRING_LENGTH (value) != (int) istr.len
790 || 0 != strncmp (TREE_STRING_POINTER (value), (char *) istr.text,
791 istr.len))
793 /* Arrange for us to return the untranslated string in
794 *valp, but to set up the C type of the translated
795 one. */
796 *valp = build_string (istr.len, (char *) istr.text);
797 valp = &TREE_CHAIN (*valp);
799 free ((void *) istr.text);
802 else
804 /* Callers cannot generally handle error_mark_node in this context,
805 so return the empty string instead. cpp_interpret_string has
806 issued an error. */
807 if (wide)
808 value = build_string (TYPE_PRECISION (wchar_type_node)
809 / TYPE_PRECISION (char_type_node),
810 "\0\0\0"); /* widest supported wchar_t
811 is 32 bits */
812 else
813 value = build_string (1, "");
816 TREE_TYPE (value) = wide ? wchar_array_type_node : char_array_type_node;
817 *valp = fix_string_type (value);
819 if (concats)
820 obstack_free (&str_ob, 0);
822 return objc_string ? CPP_OBJC_STRING : wide ? CPP_WSTRING : CPP_STRING;
825 /* Converts a (possibly wide) character constant token into a tree. */
826 static tree
827 lex_charconst (const cpp_token *token)
829 cppchar_t result;
830 tree type, value;
831 unsigned int chars_seen;
832 int unsignedp;
834 result = cpp_interpret_charconst (parse_in, token,
835 &chars_seen, &unsignedp);
837 if (token->type == CPP_WCHAR)
838 type = wchar_type_node;
839 /* In C, a character constant has type 'int'.
840 In C++ 'char', but multi-char charconsts have type 'int'. */
841 else if (!c_dialect_cxx () || chars_seen > 1)
842 type = integer_type_node;
843 else
844 type = char_type_node;
846 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
847 before possibly widening to HOST_WIDE_INT for build_int_cst. */
848 if (unsignedp || (cppchar_signed_t) result >= 0)
849 value = build_int_cst_wide (type, result, 0);
850 else
851 value = build_int_cst_wide (type, (cppchar_signed_t) result, -1);
853 return value;