OSDN Git Service

Index: libcpp/ChangeLog
[pf3gnuchains/gcc-fork.git] / gcc / c-lex.c
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 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING.  If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.  */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26
27 #include "real.h"
28 #include "rtl.h"
29 #include "tree.h"
30 #include "input.h"
31 #include "output.h"
32 #include "c-tree.h"
33 #include "c-common.h"
34 #include "flags.h"
35 #include "timevar.h"
36 #include "cpplib.h"
37 #include "c-pragma.h"
38 #include "toplev.h"
39 #include "intl.h"
40 #include "tm_p.h"
41 #include "splay-tree.h"
42 #include "debug.h"
43
44 /* We may keep statistics about how long which files took to compile.  */
45 static int header_time, body_time;
46 static splay_tree file_info_tree;
47
48 #undef WCHAR_TYPE_SIZE
49 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
50
51 /* Number of bytes in a wide character.  */
52 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
53
54 int pending_lang_change; /* If we need to switch languages - C++ only */
55 int c_header_level;      /* depth in C headers - C++ only */
56
57 /* If we need to translate characters received.  This is tri-state:
58    0 means use only the untranslated string; 1 means use only
59    the translated string; -1 means chain the translated string
60    to the untranslated one.  */
61 int c_lex_string_translate = 1;
62
63 /* True if strings should be passed to the caller of c_lex completely
64    unmolested (no concatenation, no translation).  */
65 bool c_lex_return_raw_strings = false;
66
67 static tree interpret_integer (const cpp_token *, unsigned int);
68 static tree interpret_float (const cpp_token *, unsigned int);
69 static enum integer_type_kind narrowest_unsigned_type
70         (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
71 static enum integer_type_kind narrowest_signed_type
72         (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
73 static enum cpp_ttype lex_string (const cpp_token *, tree *, bool);
74 static tree lex_charconst (const cpp_token *);
75 static void update_header_times (const char *);
76 static int dump_one_header (splay_tree_node, void *);
77 static void cb_line_change (cpp_reader *, const cpp_token *, int);
78 static void cb_ident (cpp_reader *, unsigned int, const cpp_string *);
79 static void cb_def_pragma (cpp_reader *, unsigned int);
80 static void cb_define (cpp_reader *, unsigned int, cpp_hashnode *);
81 static void cb_undef (cpp_reader *, unsigned int, cpp_hashnode *);
82 \f
83 void
84 init_c_lex (void)
85 {
86   struct cpp_callbacks *cb;
87   struct c_fileinfo *toplevel;
88
89   /* The get_fileinfo data structure must be initialized before
90      cpp_read_main_file is called.  */
91   toplevel = get_fileinfo ("<top level>");
92   if (flag_detailed_statistics)
93     {
94       header_time = 0;
95       body_time = get_run_time ();
96       toplevel->time = body_time;
97     }
98
99   cb = cpp_get_callbacks (parse_in);
100
101   cb->line_change = cb_line_change;
102   cb->ident = cb_ident;
103   cb->def_pragma = cb_def_pragma;
104   cb->valid_pch = c_common_valid_pch;
105   cb->read_pch = c_common_read_pch;
106
107   /* Set the debug callbacks if we can use them.  */
108   if (debug_info_level == DINFO_LEVEL_VERBOSE
109       && (write_symbols == DWARF2_DEBUG
110           || write_symbols == VMS_AND_DWARF2_DEBUG))
111     {
112       cb->define = cb_define;
113       cb->undef = cb_undef;
114     }
115 }
116
117 struct c_fileinfo *
118 get_fileinfo (const char *name)
119 {
120   splay_tree_node n;
121   struct c_fileinfo *fi;
122
123   if (!file_info_tree)
124     file_info_tree = splay_tree_new ((splay_tree_compare_fn) strcmp,
125                                      0,
126                                      (splay_tree_delete_value_fn) free);
127
128   n = splay_tree_lookup (file_info_tree, (splay_tree_key) name);
129   if (n)
130     return (struct c_fileinfo *) n->value;
131
132   fi = XNEW (struct c_fileinfo);
133   fi->time = 0;
134   fi->interface_only = 0;
135   fi->interface_unknown = 1;
136   splay_tree_insert (file_info_tree, (splay_tree_key) name,
137                      (splay_tree_value) fi);
138   return fi;
139 }
140
141 static void
142 update_header_times (const char *name)
143 {
144   /* Changing files again.  This means currently collected time
145      is charged against header time, and body time starts back at 0.  */
146   if (flag_detailed_statistics)
147     {
148       int this_time = get_run_time ();
149       struct c_fileinfo *file = get_fileinfo (name);
150       header_time += this_time - body_time;
151       file->time += this_time - body_time;
152       body_time = this_time;
153     }
154 }
155
156 static int
157 dump_one_header (splay_tree_node n, void * ARG_UNUSED (dummy))
158 {
159   print_time ((const char *) n->key,
160               ((struct c_fileinfo *) n->value)->time);
161   return 0;
162 }
163
164 void
165 dump_time_statistics (void)
166 {
167   struct c_fileinfo *file = get_fileinfo (input_filename);
168   int this_time = get_run_time ();
169   file->time += this_time - body_time;
170
171   fprintf (stderr, "\n******\n");
172   print_time ("header files (total)", header_time);
173   print_time ("main file (total)", this_time - body_time);
174   fprintf (stderr, "ratio = %g : 1\n",
175            (double) header_time / (double) (this_time - body_time));
176   fprintf (stderr, "\n******\n");
177
178   splay_tree_foreach (file_info_tree, dump_one_header, 0);
179 }
180
181 static void
182 cb_ident (cpp_reader * ARG_UNUSED (pfile),
183           unsigned int ARG_UNUSED (line),
184           const cpp_string * ARG_UNUSED (str))
185 {
186 #ifdef ASM_OUTPUT_IDENT
187   if (!flag_no_ident)
188     {
189       /* Convert escapes in the string.  */
190       cpp_string cstr = { 0, 0 };
191       if (cpp_interpret_string (pfile, str, 1, &cstr, false))
192         {
193           ASM_OUTPUT_IDENT (asm_out_file, (const char *) cstr.text);
194           free ((void *) cstr.text);
195         }
196     }
197 #endif
198 }
199
200 /* Called at the start of every non-empty line.  TOKEN is the first
201    lexed token on the line.  Used for diagnostic line numbers.  */
202 static void
203 cb_line_change (cpp_reader * ARG_UNUSED (pfile), const cpp_token *token,
204                 int parsing_args)
205 {
206   if (token->type != CPP_EOF && !parsing_args)
207 #ifdef USE_MAPPED_LOCATION
208     input_location = token->src_loc;
209 #else
210     {
211       source_location loc = token->src_loc;
212       const struct line_map *map = linemap_lookup (&line_table, loc);
213       input_line = SOURCE_LINE (map, loc);
214     }
215 #endif
216 }
217
218 void
219 fe_file_change (const struct line_map *new_map)
220 {
221   if (new_map == NULL)
222     return;
223
224   if (new_map->reason == LC_ENTER)
225     {
226       /* Don't stack the main buffer on the input stack;
227          we already did in compile_file.  */
228       if (!MAIN_FILE_P (new_map))
229         {
230 #ifdef USE_MAPPED_LOCATION
231           int included_at = LAST_SOURCE_LINE_LOCATION (new_map - 1);
232
233           input_location = included_at;
234           push_srcloc (new_map->start_location);
235 #else
236           int included_at = LAST_SOURCE_LINE (new_map - 1);
237
238           input_line = included_at;
239           push_srcloc (new_map->to_file, 1);
240 #endif
241           (*debug_hooks->start_source_file) (included_at, new_map->to_file);
242 #ifndef NO_IMPLICIT_EXTERN_C
243           if (c_header_level)
244             ++c_header_level;
245           else if (new_map->sysp == 2)
246             {
247               c_header_level = 1;
248               ++pending_lang_change;
249             }
250 #endif
251         }
252     }
253   else if (new_map->reason == LC_LEAVE)
254     {
255 #ifndef NO_IMPLICIT_EXTERN_C
256       if (c_header_level && --c_header_level == 0)
257         {
258           if (new_map->sysp == 2)
259             warning ("badly nested C headers from preprocessor");
260           --pending_lang_change;
261         }
262 #endif
263       pop_srcloc ();
264
265       (*debug_hooks->end_source_file) (new_map->to_line);
266     }
267
268   update_header_times (new_map->to_file);
269   in_system_header = new_map->sysp != 0;
270 #ifdef USE_MAPPED_LOCATION
271   input_location = new_map->start_location;
272 #else
273   input_filename = new_map->to_file;
274   input_line = new_map->to_line;
275 #endif
276 }
277
278 static void
279 cb_def_pragma (cpp_reader *pfile, source_location loc)
280 {
281   /* Issue a warning message if we have been asked to do so.  Ignore
282      unknown pragmas in system headers unless an explicit
283      -Wunknown-pragmas has been given.  */
284   if (warn_unknown_pragmas > in_system_header)
285     {
286       const unsigned char *space, *name;
287       const cpp_token *s;
288 #ifndef USE_MAPPED_LOCATION
289       location_t fe_loc;
290       const struct line_map *map = linemap_lookup (&line_table, loc);
291       fe_loc.file = map->to_file;
292       fe_loc.line = SOURCE_LINE (map, loc);
293 #else
294       location_t fe_loc = loc;
295 #endif
296
297       space = name = (const unsigned char *) "";
298       s = cpp_get_token (pfile);
299       if (s->type != CPP_EOF)
300         {
301           space = cpp_token_as_text (pfile, s);
302           s = cpp_get_token (pfile);
303           if (s->type == CPP_NAME)
304             name = cpp_token_as_text (pfile, s);
305         }
306
307       warning ("%Hignoring #pragma %s %s", &fe_loc, space, name);
308     }
309 }
310
311 /* #define callback for DWARF and DWARF2 debug info.  */
312 static void
313 cb_define (cpp_reader *pfile, source_location loc, cpp_hashnode *node)
314 {
315   const struct line_map *map = linemap_lookup (&line_table, loc);
316   (*debug_hooks->define) (SOURCE_LINE (map, loc),
317                           (const char *) cpp_macro_definition (pfile, node));
318 }
319
320 /* #undef callback for DWARF and DWARF2 debug info.  */
321 static void
322 cb_undef (cpp_reader * ARG_UNUSED (pfile), source_location loc,
323           cpp_hashnode *node)
324 {
325   const struct line_map *map = linemap_lookup (&line_table, loc);
326   (*debug_hooks->undef) (SOURCE_LINE (map, loc),
327                          (const char *) NODE_NAME (node));
328 }
329 \f
330 /* Read a token and return its type.  Fill *VALUE with its value, if
331    applicable.  Fill *CPP_FLAGS with the token's flags, if it is
332    non-NULL.  */
333
334 enum cpp_ttype
335 c_lex_with_flags (tree *value, location_t *loc, unsigned char *cpp_flags)
336 {
337   static bool no_more_pch;
338   const cpp_token *tok;
339   enum cpp_ttype type;
340
341   timevar_push (TV_CPP);
342  retry:
343   tok = cpp_get_token (parse_in);
344   type = tok->type;
345   
346  retry_after_at:
347 #ifdef USE_MAPPED_LOCATION
348   *loc = tok->src_loc;
349 #else
350   *loc = input_location;
351 #endif
352   switch (type)
353     {
354     case CPP_PADDING:
355       goto retry;
356       
357     case CPP_NAME:
358       *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
359       break;
360
361     case CPP_NUMBER:
362       {
363         unsigned int flags = cpp_classify_number (parse_in, tok);
364
365         switch (flags & CPP_N_CATEGORY)
366           {
367           case CPP_N_INVALID:
368             /* cpplib has issued an error.  */
369             *value = error_mark_node;
370             break;
371
372           case CPP_N_INTEGER:
373             *value = interpret_integer (tok, flags);
374             break;
375
376           case CPP_N_FLOATING:
377             *value = interpret_float (tok, flags);
378             break;
379
380           default:
381             gcc_unreachable ();
382           }
383       }
384       break;
385
386     case CPP_ATSIGN:
387       /* An @ may give the next token special significance in Objective-C.  */
388       if (c_dialect_objc ())
389         {
390           location_t atloc = input_location;
391           
392         retry_at:
393           tok = cpp_get_token (parse_in);
394           type = tok->type;
395           switch (type)
396             {
397             case CPP_PADDING:
398               goto retry_at;
399               
400             case CPP_STRING:
401             case CPP_WSTRING:
402               type = lex_string (tok, value, true);
403               break;
404
405             case CPP_NAME:
406               *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
407               if (objc_is_reserved_word (*value))
408                 {
409                   type = CPP_AT_NAME;
410                   break;
411                 }
412               /* FALLTHROUGH */
413
414             default:
415               /* ... or not.  */
416               error ("%Hstray %<@%> in program", &atloc);
417               goto retry_after_at;
418             }
419           break;
420         }
421
422       /* FALLTHROUGH */
423     case CPP_HASH:
424     case CPP_PASTE:
425       {
426         unsigned char name[4];
427         
428         *cpp_spell_token (parse_in, tok, name, true) = 0;
429         
430         error ("stray %qs in program", name);
431       }
432       
433       goto retry;
434
435     case CPP_OTHER:
436       {
437         cppchar_t c = tok->val.str.text[0];
438
439         if (c == '"' || c == '\'')
440           error ("missing terminating %c character", (int) c);
441         else if (ISGRAPH (c))
442           error ("stray %qc in program", (int) c);
443         else
444           error ("stray %<\\%o%> in program", (int) c);
445       }
446       goto retry;
447
448     case CPP_CHAR:
449     case CPP_WCHAR:
450       *value = lex_charconst (tok);
451       break;
452
453     case CPP_STRING:
454     case CPP_WSTRING:
455       if (!c_lex_return_raw_strings)
456         {
457           type = lex_string (tok, value, false);
458           break;
459         }
460       
461       /* FALLTHROUGH */
462
463     case CPP_PRAGMA:
464       *value = build_string (tok->val.str.len, (char *) tok->val.str.text);
465       break;
466
467       /* These tokens should not be visible outside cpplib.  */
468     case CPP_HEADER_NAME:
469     case CPP_COMMENT:
470     case CPP_MACRO_ARG:
471       gcc_unreachable ();
472
473     default:
474       *value = NULL_TREE;
475       break;
476     }
477
478   if (cpp_flags)
479     *cpp_flags = tok->flags;
480
481   if (!no_more_pch)
482     {
483       no_more_pch = true;
484       c_common_no_more_pch ();
485     }
486   
487   timevar_pop (TV_CPP);
488   
489   return type;
490 }
491
492 enum cpp_ttype
493 c_lex (tree *value)
494 {
495   location_t loc;
496   return c_lex_with_flags (value, &loc, NULL);
497 }
498
499 /* Returns the narrowest C-visible unsigned type, starting with the
500    minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
501    there isn't one.  */
502
503 static enum integer_type_kind
504 narrowest_unsigned_type (unsigned HOST_WIDE_INT low,
505                          unsigned HOST_WIDE_INT high,
506                          unsigned int flags)
507 {
508   enum integer_type_kind itk;
509
510   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
511     itk = itk_unsigned_int;
512   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
513     itk = itk_unsigned_long;
514   else
515     itk = itk_unsigned_long_long;
516
517   for (; itk < itk_none; itk += 2 /* skip unsigned types */)
518     {
519       tree upper = TYPE_MAX_VALUE (integer_types[itk]);
520
521       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
522           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
523               && TREE_INT_CST_LOW (upper) >= low))
524         return itk;
525     }
526
527   return itk_none;
528 }
529
530 /* Ditto, but narrowest signed type.  */
531 static enum integer_type_kind
532 narrowest_signed_type (unsigned HOST_WIDE_INT low,
533                        unsigned HOST_WIDE_INT high, unsigned int flags)
534 {
535   enum integer_type_kind itk;
536
537   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
538     itk = itk_int;
539   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
540     itk = itk_long;
541   else
542     itk = itk_long_long;
543
544
545   for (; itk < itk_none; itk += 2 /* skip signed types */)
546     {
547       tree upper = TYPE_MAX_VALUE (integer_types[itk]);
548       
549       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
550           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
551               && TREE_INT_CST_LOW (upper) >= low))
552         return itk;
553     }
554
555   return itk_none;
556 }
557
558 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib.  */
559 static tree
560 interpret_integer (const cpp_token *token, unsigned int flags)
561 {
562   tree value, type;
563   enum integer_type_kind itk;
564   cpp_num integer;
565   cpp_options *options = cpp_get_options (parse_in);
566
567   integer = cpp_interpret_integer (parse_in, token, flags);
568   integer = cpp_num_sign_extend (integer, options->precision);
569
570   /* The type of a constant with a U suffix is straightforward.  */
571   if (flags & CPP_N_UNSIGNED)
572     itk = narrowest_unsigned_type (integer.low, integer.high, flags);
573   else
574     {
575       /* The type of a potentially-signed integer constant varies
576          depending on the base it's in, the standard in use, and the
577          length suffixes.  */
578       enum integer_type_kind itk_u
579         = narrowest_unsigned_type (integer.low, integer.high, flags);
580       enum integer_type_kind itk_s
581         = narrowest_signed_type (integer.low, integer.high, flags);
582
583       /* In both C89 and C99, octal and hex constants may be signed or
584          unsigned, whichever fits tighter.  We do not warn about this
585          choice differing from the traditional choice, as the constant
586          is probably a bit pattern and either way will work.  */
587       if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
588         itk = MIN (itk_u, itk_s);
589       else
590         {
591           /* In C99, decimal constants are always signed.
592              In C89, decimal constants that don't fit in long have
593              undefined behavior; we try to make them unsigned long.
594              In GCC's extended C89, that last is true of decimal
595              constants that don't fit in long long, too.  */
596
597           itk = itk_s;
598           if (itk_s > itk_u && itk_s > itk_long)
599             {
600               if (!flag_isoc99)
601                 {
602                   if (itk_u < itk_unsigned_long)
603                     itk_u = itk_unsigned_long;
604                   itk = itk_u;
605                   warning ("this decimal constant is unsigned only in ISO C90");
606                 }
607               else if (warn_traditional)
608                 warning ("this decimal constant would be unsigned in ISO C90");
609             }
610         }
611     }
612
613   if (itk == itk_none)
614     /* cpplib has already issued a warning for overflow.  */
615     type = ((flags & CPP_N_UNSIGNED)
616             ? widest_unsigned_literal_type_node
617             : widest_integer_literal_type_node);
618   else
619     type = integer_types[itk];
620
621   if (itk > itk_unsigned_long
622       && (flags & CPP_N_WIDTH) != CPP_N_LARGE
623       && !in_system_header && !flag_isoc99)
624     pedwarn ("integer constant is too large for %qs type",
625              (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long");
626
627   value = build_int_cst_wide (type, integer.low, integer.high);
628
629   /* Convert imaginary to a complex type.  */
630   if (flags & CPP_N_IMAGINARY)
631     value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
632
633   return value;
634 }
635
636 /* Interpret TOKEN, a floating point number with FLAGS as classified
637    by cpplib.  */
638 static tree
639 interpret_float (const cpp_token *token, unsigned int flags)
640 {
641   tree type;
642   tree value;
643   REAL_VALUE_TYPE real;
644   char *copy;
645   size_t copylen;
646   const char *type_name;
647
648   /* FIXME: make %T work in error/warning, then we don't need type_name.  */
649   if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
650     {
651       type = long_double_type_node;
652       type_name = "long double";
653     }
654   else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
655            || flag_single_precision_constant)
656     {
657       type = float_type_node;
658       type_name = "float";
659     }
660   else
661     {
662       type = double_type_node;
663       type_name = "double";
664     }
665
666   /* Copy the constant to a nul-terminated buffer.  If the constant
667      has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
668      can't handle them.  */
669   copylen = token->val.str.len;
670   if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
671     /* Must be an F or L suffix.  */
672     copylen--;
673   if (flags & CPP_N_IMAGINARY)
674     /* I or J suffix.  */
675     copylen--;
676
677   copy = (char *) alloca (copylen + 1);
678   memcpy (copy, token->val.str.text, copylen);
679   copy[copylen] = '\0';
680
681   real_from_string (&real, copy);
682   real_convert (&real, TYPE_MODE (type), &real);
683
684   /* Both C and C++ require a diagnostic for a floating constant
685      outside the range of representable values of its type.  Since we
686      have __builtin_inf* to produce an infinity, it might now be
687      appropriate for this to be a mandatory pedwarn rather than
688      conditioned on -pedantic.  */
689   if (REAL_VALUE_ISINF (real) && pedantic)
690     pedwarn ("floating constant exceeds range of %<%s%>", type_name);
691
692   /* Create a node with determined type and value.  */
693   value = build_real (type, real);
694   if (flags & CPP_N_IMAGINARY)
695     value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
696
697   return value;
698 }
699
700 /* Convert a series of STRING and/or WSTRING tokens into a tree,
701    performing string constant concatenation.  TOK is the first of
702    these.  VALP is the location to write the string into.  OBJC_STRING
703    indicates whether an '@' token preceded the incoming token.
704    Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
705    or CPP_OBJC_STRING).
706
707    This is unfortunately more work than it should be.  If any of the
708    strings in the series has an L prefix, the result is a wide string
709    (6.4.5p4).  Whether or not the result is a wide string affects the
710    meaning of octal and hexadecimal escapes (6.4.4.4p6,9).  But escape
711    sequences do not continue across the boundary between two strings in
712    a series (6.4.5p7), so we must not lose the boundaries.  Therefore
713    cpp_interpret_string takes a vector of cpp_string structures, which
714    we must arrange to provide.  */
715
716 static enum cpp_ttype
717 lex_string (const cpp_token *tok, tree *valp, bool objc_string)
718 {
719   tree value;
720   bool wide = false;
721   size_t concats = 0;
722   struct obstack str_ob;
723   cpp_string istr;
724
725   /* Try to avoid the overhead of creating and destroying an obstack
726      for the common case of just one string.  */
727   cpp_string str = tok->val.str;
728   cpp_string *strs = &str;
729
730   if (tok->type == CPP_WSTRING)
731     wide = true;
732
733  retry:
734   tok = cpp_get_token (parse_in);
735   switch (tok->type)
736     {
737     case CPP_PADDING:
738       goto retry;
739     case CPP_ATSIGN:
740       if (c_dialect_objc ())
741         {
742           objc_string = true;
743           goto retry;
744         }
745       /* FALLTHROUGH */
746       
747     default:
748       break;
749       
750     case CPP_WSTRING:
751       wide = true;
752       /* FALLTHROUGH */
753       
754     case CPP_STRING:
755       if (!concats)
756         {
757           gcc_obstack_init (&str_ob);
758           obstack_grow (&str_ob, &str, sizeof (cpp_string));
759         }
760         
761       concats++;
762       obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
763       goto retry;
764     }
765
766   /* We have read one more token than we want.  */
767   _cpp_backup_tokens (parse_in, 1);
768   if (concats)
769     strs = (cpp_string *) obstack_finish (&str_ob);
770
771   if (concats && !objc_string && warn_traditional && !in_system_header)
772     warning ("traditional C rejects string constant concatenation");
773
774   if ((c_lex_string_translate
775        ? cpp_interpret_string : cpp_interpret_string_notranslate)
776       (parse_in, strs, concats + 1, &istr, wide))
777     {
778       value = build_string (istr.len, (char *) istr.text);
779       free ((void *) istr.text);
780
781       if (c_lex_string_translate == -1)
782         {
783           int xlated = cpp_interpret_string_notranslate (parse_in, strs,
784                                                          concats + 1,
785                                                          &istr, wide);
786           /* Assume that, if we managed to translate the string above,
787              then the untranslated parsing will always succeed.  */
788           gcc_assert (xlated);
789           
790           if (TREE_STRING_LENGTH (value) != (int) istr.len
791               || 0 != strncmp (TREE_STRING_POINTER (value), (char *) istr.text,
792                                istr.len))
793             {
794               /* Arrange for us to return the untranslated string in
795                  *valp, but to set up the C type of the translated
796                  one.  */
797               *valp = build_string (istr.len, (char *) istr.text);
798               valp = &TREE_CHAIN (*valp);
799             }
800           free ((void *) istr.text);
801         }
802     }
803   else
804     {
805       /* Callers cannot generally handle error_mark_node in this context,
806          so return the empty string instead.  cpp_interpret_string has
807          issued an error.  */
808       if (wide)
809         value = build_string (TYPE_PRECISION (wchar_type_node)
810                               / TYPE_PRECISION (char_type_node),
811                               "\0\0\0");  /* widest supported wchar_t
812                                              is 32 bits */
813       else
814         value = build_string (1, "");
815     }
816
817   TREE_TYPE (value) = wide ? wchar_array_type_node : char_array_type_node;
818   *valp = fix_string_type (value);
819
820   if (concats)
821     obstack_free (&str_ob, 0);
822
823   return objc_string ? CPP_OBJC_STRING : wide ? CPP_WSTRING : CPP_STRING;
824 }
825
826 /* Converts a (possibly wide) character constant token into a tree.  */
827 static tree
828 lex_charconst (const cpp_token *token)
829 {
830   cppchar_t result;
831   tree type, value;
832   unsigned int chars_seen;
833   int unsignedp;
834
835   result = cpp_interpret_charconst (parse_in, token,
836                                     &chars_seen, &unsignedp);
837
838   if (token->type == CPP_WCHAR)
839     type = wchar_type_node;
840   /* In C, a character constant has type 'int'.
841      In C++ 'char', but multi-char charconsts have type 'int'.  */
842   else if (!c_dialect_cxx () || chars_seen > 1)
843     type = integer_type_node;
844   else
845     type = char_type_node;
846
847   /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
848      before possibly widening to HOST_WIDE_INT for build_int_cst.  */
849   if (unsignedp || (cppchar_signed_t) result >= 0)
850     value = build_int_cst_wide (type, result, 0);
851   else
852     value = build_int_cst_wide (type, (cppchar_signed_t) result, -1);
853
854   return value;
855 }