OSDN Git Service

617cd7ee52c092eb108b82f158da450ae34f62a7
[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, 2005, 2007, 2008
4    Free Software Foundation, Inc.
5
6 This file is part of GCC.
7
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
11 version.
12
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.
17
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/>.  */
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 #include "target.h"
44
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;
48
49 int pending_lang_change; /* If we need to switch languages - C++ only */
50 int c_header_level;      /* depth in C headers - C++ only */
51
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 *);
68 \f
69 void
70 init_c_lex (void)
71 {
72   struct cpp_callbacks *cb;
73   struct c_fileinfo *toplevel;
74
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)
79     {
80       header_time = 0;
81       body_time = get_run_time ();
82       toplevel->time = body_time;
83     }
84
85   cb = cpp_get_callbacks (parse_in);
86
87   cb->line_change = cb_line_change;
88   cb->ident = cb_ident;
89   cb->def_pragma = cb_def_pragma;
90   cb->valid_pch = c_common_valid_pch;
91   cb->read_pch = c_common_read_pch;
92
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))
97     {
98       cb->define = cb_define;
99       cb->undef = cb_undef;
100     }
101 }
102
103 struct c_fileinfo *
104 get_fileinfo (const char *name)
105 {
106   splay_tree_node n;
107   struct c_fileinfo *fi;
108
109   if (!file_info_tree)
110     file_info_tree = splay_tree_new ((splay_tree_compare_fn) strcmp,
111                                      0,
112                                      (splay_tree_delete_value_fn) free);
113
114   n = splay_tree_lookup (file_info_tree, (splay_tree_key) name);
115   if (n)
116     return (struct c_fileinfo *) n->value;
117
118   fi = XNEW (struct c_fileinfo);
119   fi->time = 0;
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);
124   return fi;
125 }
126
127 static void
128 update_header_times (const char *name)
129 {
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)
133     {
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;
139     }
140 }
141
142 static int
143 dump_one_header (splay_tree_node n, void * ARG_UNUSED (dummy))
144 {
145   print_time ((const char *) n->key,
146               ((struct c_fileinfo *) n->value)->time);
147   return 0;
148 }
149
150 void
151 dump_time_statistics (void)
152 {
153   struct c_fileinfo *file = get_fileinfo (input_filename);
154   int this_time = get_run_time ();
155   file->time += this_time - body_time;
156
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");
163
164   splay_tree_foreach (file_info_tree, dump_one_header, 0);
165 }
166
167 static void
168 cb_ident (cpp_reader * ARG_UNUSED (pfile),
169           unsigned int ARG_UNUSED (line),
170           const cpp_string * ARG_UNUSED (str))
171 {
172 #ifdef ASM_OUTPUT_IDENT
173   if (!flag_no_ident)
174     {
175       /* Convert escapes in the string.  */
176       cpp_string cstr = { 0, 0 };
177       if (cpp_interpret_string (pfile, str, 1, &cstr, false))
178         {
179           ASM_OUTPUT_IDENT (asm_out_file, (const char *) cstr.text);
180           free (CONST_CAST (unsigned char *, cstr.text));
181         }
182     }
183 #endif
184 }
185
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.  */
188 static void
189 cb_line_change (cpp_reader * ARG_UNUSED (pfile), const cpp_token *token,
190                 int parsing_args)
191 {
192   if (token->type != CPP_EOF && !parsing_args)
193     input_location = token->src_loc;
194 }
195
196 void
197 fe_file_change (const struct line_map *new_map)
198 {
199   if (new_map == NULL)
200     return;
201
202   if (new_map->reason == LC_ENTER)
203     {
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))
207         {
208           int included_at = LAST_SOURCE_LINE_LOCATION (new_map - 1);
209
210           input_location = new_map->start_location;
211           (*debug_hooks->start_source_file) (included_at, new_map->to_file);
212 #ifndef NO_IMPLICIT_EXTERN_C
213           if (c_header_level)
214             ++c_header_level;
215           else if (new_map->sysp == 2)
216             {
217               c_header_level = 1;
218               ++pending_lang_change;
219             }
220 #endif
221         }
222     }
223   else if (new_map->reason == LC_LEAVE)
224     {
225 #ifndef NO_IMPLICIT_EXTERN_C
226       if (c_header_level && --c_header_level == 0)
227         {
228           if (new_map->sysp == 2)
229             warning (0, "badly nested C headers from preprocessor");
230           --pending_lang_change;
231         }
232 #endif
233       input_location = new_map->start_location;
234
235       (*debug_hooks->end_source_file) (new_map->to_line);
236     }
237
238   update_header_times (new_map->to_file);
239   in_system_header = new_map->sysp != 0;
240   input_location = new_map->start_location;
241 }
242
243 static void
244 cb_def_pragma (cpp_reader *pfile, source_location loc)
245 {
246   /* Issue a warning message if we have been asked to do so.  Ignore
247      unknown pragmas in system headers unless an explicit
248      -Wunknown-pragmas has been given.  */
249   if (warn_unknown_pragmas > in_system_header)
250     {
251       const unsigned char *space, *name;
252       const cpp_token *s;
253       location_t fe_loc = loc;
254
255       space = name = (const unsigned char *) "";
256       s = cpp_get_token (pfile);
257       if (s->type != CPP_EOF)
258         {
259           space = cpp_token_as_text (pfile, s);
260           s = cpp_get_token (pfile);
261           if (s->type == CPP_NAME)
262             name = cpp_token_as_text (pfile, s);
263         }
264
265       warning (OPT_Wunknown_pragmas, "%Hignoring #pragma %s %s",
266                &fe_loc, space, name);
267     }
268 }
269
270 /* #define callback for DWARF and DWARF2 debug info.  */
271 static void
272 cb_define (cpp_reader *pfile, source_location loc, cpp_hashnode *node)
273 {
274   const struct line_map *map = linemap_lookup (line_table, loc);
275   (*debug_hooks->define) (SOURCE_LINE (map, loc),
276                           (const char *) cpp_macro_definition (pfile, node));
277 }
278
279 /* #undef callback for DWARF and DWARF2 debug info.  */
280 static void
281 cb_undef (cpp_reader * ARG_UNUSED (pfile), source_location loc,
282           cpp_hashnode *node)
283 {
284   const struct line_map *map = linemap_lookup (line_table, loc);
285   (*debug_hooks->undef) (SOURCE_LINE (map, loc),
286                          (const char *) NODE_NAME (node));
287 }
288 \f
289 /* Read a token and return its type.  Fill *VALUE with its value, if
290    applicable.  Fill *CPP_FLAGS with the token's flags, if it is
291    non-NULL.  */
292
293 enum cpp_ttype
294 c_lex_with_flags (tree *value, location_t *loc, unsigned char *cpp_flags,
295                   int lex_flags)
296 {
297   static bool no_more_pch;
298   const cpp_token *tok;
299   enum cpp_ttype type;
300   unsigned char add_flags = 0;
301
302   timevar_push (TV_CPP);
303  retry:
304   tok = cpp_get_token_with_location (parse_in, loc);
305   type = tok->type;
306
307  retry_after_at:
308   switch (type)
309     {
310     case CPP_PADDING:
311       goto retry;
312
313     case CPP_NAME:
314       *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
315       break;
316
317     case CPP_NUMBER:
318       {
319         unsigned int flags = cpp_classify_number (parse_in, tok);
320
321         switch (flags & CPP_N_CATEGORY)
322           {
323           case CPP_N_INVALID:
324             /* cpplib has issued an error.  */
325             *value = error_mark_node;
326             errorcount++;
327             break;
328
329           case CPP_N_INTEGER:
330             /* C++ uses '0' to mark virtual functions as pure.
331                Set PURE_ZERO to pass this information to the C++ parser.  */
332             if (tok->val.str.len == 1 && *tok->val.str.text == '0')
333               add_flags = PURE_ZERO;
334             *value = interpret_integer (tok, flags);
335             break;
336
337           case CPP_N_FLOATING:
338             *value = interpret_float (tok, flags);
339             break;
340
341           default:
342             gcc_unreachable ();
343           }
344       }
345       break;
346
347     case CPP_ATSIGN:
348       /* An @ may give the next token special significance in Objective-C.  */
349       if (c_dialect_objc ())
350         {
351           location_t atloc = *loc;
352           location_t newloc;
353
354         retry_at:
355           tok = cpp_get_token_with_location (parse_in, &newloc);
356           type = tok->type;
357           switch (type)
358             {
359             case CPP_PADDING:
360               goto retry_at;
361
362             case CPP_STRING:
363             case CPP_WSTRING:
364               type = lex_string (tok, value, true, true);
365               break;
366
367             case CPP_NAME:
368               *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
369               if (objc_is_reserved_word (*value))
370                 {
371                   type = CPP_AT_NAME;
372                   break;
373                 }
374               /* FALLTHROUGH */
375
376             default:
377               /* ... or not.  */
378               error ("%Hstray %<@%> in program", &atloc);
379               *loc = newloc;
380               goto retry_after_at;
381             }
382           break;
383         }
384
385       /* FALLTHROUGH */
386     case CPP_HASH:
387     case CPP_PASTE:
388       {
389         unsigned char name[4];
390
391         *cpp_spell_token (parse_in, tok, name, true) = 0;
392
393         error ("stray %qs in program", name);
394       }
395
396       goto retry;
397
398     case CPP_OTHER:
399       {
400         cppchar_t c = tok->val.str.text[0];
401
402         if (c == '"' || c == '\'')
403           error ("missing terminating %c character", (int) c);
404         else if (ISGRAPH (c))
405           error ("stray %qc in program", (int) c);
406         else
407           error ("stray %<\\%o%> in program", (int) c);
408       }
409       goto retry;
410
411     case CPP_CHAR:
412     case CPP_WCHAR:
413       *value = lex_charconst (tok);
414       break;
415
416     case CPP_STRING:
417     case CPP_WSTRING:
418       if ((lex_flags & C_LEX_RAW_STRINGS) == 0)
419         {
420           type = lex_string (tok, value, false,
421                              (lex_flags & C_LEX_STRING_NO_TRANSLATE) == 0);
422           break;
423         }
424       *value = build_string (tok->val.str.len, (const char *) tok->val.str.text);
425       break;
426       
427     case CPP_PRAGMA:
428       *value = build_int_cst (NULL, tok->val.pragma);
429       break;
430
431       /* These tokens should not be visible outside cpplib.  */
432     case CPP_HEADER_NAME:
433     case CPP_COMMENT:
434     case CPP_MACRO_ARG:
435       gcc_unreachable ();
436
437     default:
438       *value = NULL_TREE;
439       break;
440     }
441
442   if (cpp_flags)
443     *cpp_flags = tok->flags | add_flags;
444
445   if (!no_more_pch)
446     {
447       no_more_pch = true;
448       c_common_no_more_pch ();
449     }
450
451   timevar_pop (TV_CPP);
452
453   return type;
454 }
455
456 /* Returns the narrowest C-visible unsigned type, starting with the
457    minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
458    there isn't one.  */
459
460 static enum integer_type_kind
461 narrowest_unsigned_type (unsigned HOST_WIDE_INT low,
462                          unsigned HOST_WIDE_INT high,
463                          unsigned int flags)
464 {
465   enum integer_type_kind itk;
466
467   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
468     itk = itk_unsigned_int;
469   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
470     itk = itk_unsigned_long;
471   else
472     itk = itk_unsigned_long_long;
473
474   for (; itk < itk_none; itk += 2 /* skip unsigned types */)
475     {
476       tree upper = TYPE_MAX_VALUE (integer_types[itk]);
477
478       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
479           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
480               && TREE_INT_CST_LOW (upper) >= low))
481         return itk;
482     }
483
484   return itk_none;
485 }
486
487 /* Ditto, but narrowest signed type.  */
488 static enum integer_type_kind
489 narrowest_signed_type (unsigned HOST_WIDE_INT low,
490                        unsigned HOST_WIDE_INT high, unsigned int flags)
491 {
492   enum integer_type_kind itk;
493
494   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
495     itk = itk_int;
496   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
497     itk = itk_long;
498   else
499     itk = itk_long_long;
500
501
502   for (; itk < itk_none; itk += 2 /* skip signed types */)
503     {
504       tree upper = TYPE_MAX_VALUE (integer_types[itk]);
505
506       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
507           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
508               && TREE_INT_CST_LOW (upper) >= low))
509         return itk;
510     }
511
512   return itk_none;
513 }
514
515 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib.  */
516 static tree
517 interpret_integer (const cpp_token *token, unsigned int flags)
518 {
519   tree value, type;
520   enum integer_type_kind itk;
521   cpp_num integer;
522   cpp_options *options = cpp_get_options (parse_in);
523
524   integer = cpp_interpret_integer (parse_in, token, flags);
525   integer = cpp_num_sign_extend (integer, options->precision);
526
527   /* The type of a constant with a U suffix is straightforward.  */
528   if (flags & CPP_N_UNSIGNED)
529     itk = narrowest_unsigned_type (integer.low, integer.high, flags);
530   else
531     {
532       /* The type of a potentially-signed integer constant varies
533          depending on the base it's in, the standard in use, and the
534          length suffixes.  */
535       enum integer_type_kind itk_u
536         = narrowest_unsigned_type (integer.low, integer.high, flags);
537       enum integer_type_kind itk_s
538         = narrowest_signed_type (integer.low, integer.high, flags);
539
540       /* In both C89 and C99, octal and hex constants may be signed or
541          unsigned, whichever fits tighter.  We do not warn about this
542          choice differing from the traditional choice, as the constant
543          is probably a bit pattern and either way will work.  */
544       if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
545         itk = MIN (itk_u, itk_s);
546       else
547         {
548           /* In C99, decimal constants are always signed.
549              In C89, decimal constants that don't fit in long have
550              undefined behavior; we try to make them unsigned long.
551              In GCC's extended C89, that last is true of decimal
552              constants that don't fit in long long, too.  */
553
554           itk = itk_s;
555           if (itk_s > itk_u && itk_s > itk_long)
556             {
557               if (!flag_isoc99)
558                 {
559                   if (itk_u < itk_unsigned_long)
560                     itk_u = itk_unsigned_long;
561                   itk = itk_u;
562                   warning (0, "this decimal constant is unsigned only in ISO C90");
563                 }
564               else
565                 warning (OPT_Wtraditional,
566                          "this decimal constant would be unsigned in ISO C90");
567             }
568         }
569     }
570
571   if (itk == itk_none)
572     /* cpplib has already issued a warning for overflow.  */
573     type = ((flags & CPP_N_UNSIGNED)
574             ? widest_unsigned_literal_type_node
575             : widest_integer_literal_type_node);
576   else
577     type = integer_types[itk];
578
579   if (itk > itk_unsigned_long
580       && (flags & CPP_N_WIDTH) != CPP_N_LARGE
581       && !in_system_header && !flag_isoc99)
582     pedwarn ("integer constant is too large for %qs type",
583              (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long");
584
585   value = build_int_cst_wide (type, integer.low, integer.high);
586
587   /* Convert imaginary to a complex type.  */
588   if (flags & CPP_N_IMAGINARY)
589     value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
590
591   return value;
592 }
593
594 /* Interpret TOKEN, a floating point number with FLAGS as classified
595    by cpplib.  */
596 static tree
597 interpret_float (const cpp_token *token, unsigned int flags)
598 {
599   tree type;
600   tree value;
601   REAL_VALUE_TYPE real;
602   char *copy;
603   size_t copylen;
604
605   /* Decode _Fract and _Accum.  */
606   if (flags & CPP_N_FRACT || flags & CPP_N_ACCUM)
607     return interpret_fixed (token, flags);
608
609   /* Decode type based on width and properties. */
610   if (flags & CPP_N_DFLOAT)
611     if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
612       type = dfloat128_type_node;
613     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
614       type = dfloat32_type_node;
615     else
616       type = dfloat64_type_node;
617   else
618     if (flags & CPP_N_WIDTH_MD)
619       {
620         char suffix;
621         enum machine_mode mode;
622
623         if ((flags & CPP_N_WIDTH_MD) == CPP_N_MD_W)
624           suffix = 'w';
625         else
626           suffix = 'q';
627
628         mode = targetm.c.mode_for_suffix (suffix);
629         if (mode == VOIDmode)
630           {
631             error ("unsupported non-standard suffix on floating constant");
632             errorcount++;
633
634             return error_mark_node;
635           }
636         else if (pedantic)
637           pedwarn ("non-standard suffix on floating constant");
638
639         type = c_common_type_for_mode (mode, 0);
640         gcc_assert (type);
641       }
642     else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
643       type = long_double_type_node;
644     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
645              || flag_single_precision_constant)
646       type = float_type_node;
647     else
648       type = double_type_node;
649
650   /* Copy the constant to a nul-terminated buffer.  If the constant
651      has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
652      can't handle them.  */
653   copylen = token->val.str.len;
654   if (flags & CPP_N_DFLOAT) 
655     copylen -= 2;
656   else 
657     {
658       if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
659         /* Must be an F or L or machine defined suffix.  */
660         copylen--;
661       if (flags & CPP_N_IMAGINARY)
662         /* I or J suffix.  */
663         copylen--;
664     }
665
666   copy = (char *) alloca (copylen + 1);
667   memcpy (copy, token->val.str.text, copylen);
668   copy[copylen] = '\0';
669
670   real_from_string3 (&real, copy, TYPE_MODE (type));
671
672   /* Both C and C++ require a diagnostic for a floating constant
673      outside the range of representable values of its type.  Since we
674      have __builtin_inf* to produce an infinity, this is now a
675      mandatory pedwarn if the target does not support infinities.  */
676   if (REAL_VALUE_ISINF (real)) 
677     {
678       if (!MODE_HAS_INFINITIES (TYPE_MODE (type)))
679         pedwarn ("floating constant exceeds range of %qT", type);
680       else
681         warning (OPT_Woverflow, "floating constant exceeds range of %qT", type);
682     }
683   /* We also give a warning if the value underflows.  */
684   else if (REAL_VALUES_EQUAL (real, dconst0))
685     {
686       REAL_VALUE_TYPE realvoidmode;
687       int overflow = real_from_string (&realvoidmode, copy);
688       if (overflow < 0 || !REAL_VALUES_EQUAL (realvoidmode, dconst0)) 
689         warning (OPT_Woverflow, "floating constant truncated to zero");
690     }
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 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
701    by cpplib.  */
702
703 static tree
704 interpret_fixed (const cpp_token *token, unsigned int flags)
705 {
706   tree type;
707   tree value;
708   FIXED_VALUE_TYPE fixed;
709   char *copy;
710   size_t copylen;
711
712   copylen = token->val.str.len;
713
714   if (flags & CPP_N_FRACT) /* _Fract.  */
715     {
716       if (flags & CPP_N_UNSIGNED) /* Unsigned _Fract.  */
717         {
718           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
719             {
720               type = unsigned_long_long_fract_type_node;
721               copylen -= 4;
722             }
723           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
724             {
725               type = unsigned_long_fract_type_node;
726               copylen -= 3;
727             }
728           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
729             {
730               type = unsigned_short_fract_type_node;
731               copylen -= 3;
732             }
733           else
734             {
735               type = unsigned_fract_type_node;
736               copylen -= 2;
737             }
738         }
739       else /* Signed _Fract.  */
740         {
741           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
742             {
743               type = long_long_fract_type_node;
744               copylen -= 3;
745             }
746           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
747             {
748               type = long_fract_type_node;
749               copylen -= 2;
750             }
751           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
752             {
753               type = short_fract_type_node;
754               copylen -= 2;
755             }
756           else
757             {
758               type = fract_type_node;
759               copylen --;
760             }
761           }
762     }
763   else /* _Accum.  */
764     {
765       if (flags & CPP_N_UNSIGNED) /* Unsigned _Accum.  */
766         {
767           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
768             {
769               type = unsigned_long_long_accum_type_node;
770               copylen -= 4;
771             }
772           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
773             {
774               type = unsigned_long_accum_type_node;
775               copylen -= 3;
776             }
777           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
778             {
779               type = unsigned_short_accum_type_node;
780               copylen -= 3;
781              }
782           else
783             {
784               type = unsigned_accum_type_node;
785               copylen -= 2;
786             }
787         }
788       else /* Signed _Accum.  */
789         {
790           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
791             {
792               type = long_long_accum_type_node;
793               copylen -= 3;
794             }
795           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
796             {
797               type = long_accum_type_node;
798               copylen -= 2;
799             }
800           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
801             {
802               type = short_accum_type_node;
803               copylen -= 2;
804             }
805           else
806             {
807               type = accum_type_node;
808               copylen --;
809             }
810         }
811     }
812
813   copy = (char *) alloca (copylen + 1);
814   memcpy (copy, token->val.str.text, copylen);
815   copy[copylen] = '\0';
816
817   fixed_from_string (&fixed, copy, TYPE_MODE (type));
818
819   /* Create a node with determined type and value.  */
820   value = build_fixed (type, fixed);
821
822   return value;
823 }
824
825 /* Convert a series of STRING and/or WSTRING tokens into a tree,
826    performing string constant concatenation.  TOK is the first of
827    these.  VALP is the location to write the string into.  OBJC_STRING
828    indicates whether an '@' token preceded the incoming token.
829    Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
830    or CPP_OBJC_STRING).
831
832    This is unfortunately more work than it should be.  If any of the
833    strings in the series has an L prefix, the result is a wide string
834    (6.4.5p4).  Whether or not the result is a wide string affects the
835    meaning of octal and hexadecimal escapes (6.4.4.4p6,9).  But escape
836    sequences do not continue across the boundary between two strings in
837    a series (6.4.5p7), so we must not lose the boundaries.  Therefore
838    cpp_interpret_string takes a vector of cpp_string structures, which
839    we must arrange to provide.  */
840
841 static enum cpp_ttype
842 lex_string (const cpp_token *tok, tree *valp, bool objc_string, bool translate)
843 {
844   tree value;
845   bool wide = false;
846   size_t concats = 0;
847   struct obstack str_ob;
848   cpp_string istr;
849
850   /* Try to avoid the overhead of creating and destroying an obstack
851      for the common case of just one string.  */
852   cpp_string str = tok->val.str;
853   cpp_string *strs = &str;
854
855   if (tok->type == CPP_WSTRING)
856     wide = true;
857
858  retry:
859   tok = cpp_get_token (parse_in);
860   switch (tok->type)
861     {
862     case CPP_PADDING:
863       goto retry;
864     case CPP_ATSIGN:
865       if (c_dialect_objc ())
866         {
867           objc_string = true;
868           goto retry;
869         }
870       /* FALLTHROUGH */
871
872     default:
873       break;
874
875     case CPP_WSTRING:
876       wide = true;
877       /* FALLTHROUGH */
878
879     case CPP_STRING:
880       if (!concats)
881         {
882           gcc_obstack_init (&str_ob);
883           obstack_grow (&str_ob, &str, sizeof (cpp_string));
884         }
885
886       concats++;
887       obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
888       goto retry;
889     }
890
891   /* We have read one more token than we want.  */
892   _cpp_backup_tokens (parse_in, 1);
893   if (concats)
894     strs = XOBFINISH (&str_ob, cpp_string *);
895
896   if (concats && !objc_string && !in_system_header)
897     warning (OPT_Wtraditional,
898              "traditional C rejects string constant concatenation");
899
900   if ((translate
901        ? cpp_interpret_string : cpp_interpret_string_notranslate)
902       (parse_in, strs, concats + 1, &istr, wide))
903     {
904       value = build_string (istr.len, (const char *) istr.text);
905       free (CONST_CAST (unsigned char *, istr.text));
906     }
907   else
908     {
909       /* Callers cannot generally handle error_mark_node in this context,
910          so return the empty string instead.  cpp_interpret_string has
911          issued an error.  */
912       if (wide)
913         value = build_string (TYPE_PRECISION (wchar_type_node)
914                               / TYPE_PRECISION (char_type_node),
915                               "\0\0\0");  /* widest supported wchar_t
916                                              is 32 bits */
917       else
918         value = build_string (1, "");
919     }
920
921   TREE_TYPE (value) = wide ? wchar_array_type_node : char_array_type_node;
922   *valp = fix_string_type (value);
923
924   if (concats)
925     obstack_free (&str_ob, 0);
926
927   return objc_string ? CPP_OBJC_STRING : wide ? CPP_WSTRING : CPP_STRING;
928 }
929
930 /* Converts a (possibly wide) character constant token into a tree.  */
931 static tree
932 lex_charconst (const cpp_token *token)
933 {
934   cppchar_t result;
935   tree type, value;
936   unsigned int chars_seen;
937   int unsignedp;
938
939   result = cpp_interpret_charconst (parse_in, token,
940                                     &chars_seen, &unsignedp);
941
942   if (token->type == CPP_WCHAR)
943     type = wchar_type_node;
944   /* In C, a character constant has type 'int'.
945      In C++ 'char', but multi-char charconsts have type 'int'.  */
946   else if (!c_dialect_cxx () || chars_seen > 1)
947     type = integer_type_node;
948   else
949     type = char_type_node;
950
951   /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
952      before possibly widening to HOST_WIDE_INT for build_int_cst.  */
953   if (unsignedp || (cppchar_signed_t) result >= 0)
954     value = build_int_cst_wide (type, result, 0);
955   else
956     value = build_int_cst_wide (type, (cppchar_signed_t) result, -1);
957
958   return value;
959 }