OSDN Git Service

be83b61b34ca1f90b98680197dc25a106c1b7cea
[pf3gnuchains/gcc-fork.git] / gcc / c-family / 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, 2009, 2010,
4    2011 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 "tree.h"
28 #include "input.h"
29 #include "output.h"
30 #include "c-common.h"
31 #include "flags.h"
32 #include "timevar.h"
33 #include "cpplib.h"
34 #include "c-pragma.h"
35 #include "intl.h"
36 #include "splay-tree.h"
37 #include "debug.h"
38 #include "target.h"
39
40 /* We may keep statistics about how long which files took to compile.  */
41 static int header_time, body_time;
42 static splay_tree file_info_tree;
43
44 int pending_lang_change; /* If we need to switch languages - C++ only */
45 int c_header_level;      /* depth in C headers - C++ only */
46
47 static tree interpret_integer (const cpp_token *, unsigned int);
48 static tree interpret_float (const cpp_token *, unsigned int);
49 static tree interpret_fixed (const cpp_token *, unsigned int);
50 static enum integer_type_kind narrowest_unsigned_type
51         (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
52 static enum integer_type_kind narrowest_signed_type
53         (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
54 static enum cpp_ttype lex_string (const cpp_token *, tree *, bool, bool);
55 static tree lex_charconst (const cpp_token *);
56 static void update_header_times (const char *);
57 static int dump_one_header (splay_tree_node, void *);
58 static void cb_line_change (cpp_reader *, const cpp_token *, int);
59 static void cb_ident (cpp_reader *, unsigned int, const cpp_string *);
60 static void cb_def_pragma (cpp_reader *, unsigned int);
61 static void cb_define (cpp_reader *, unsigned int, cpp_hashnode *);
62 static void cb_undef (cpp_reader *, unsigned int, cpp_hashnode *);
63 \f
64 void
65 init_c_lex (void)
66 {
67   struct cpp_callbacks *cb;
68   struct c_fileinfo *toplevel;
69
70   /* The get_fileinfo data structure must be initialized before
71      cpp_read_main_file is called.  */
72   toplevel = get_fileinfo ("<top level>");
73   if (flag_detailed_statistics)
74     {
75       header_time = 0;
76       body_time = get_run_time ();
77       toplevel->time = body_time;
78     }
79
80   cb = cpp_get_callbacks (parse_in);
81
82   cb->line_change = cb_line_change;
83   cb->ident = cb_ident;
84   cb->def_pragma = cb_def_pragma;
85   cb->valid_pch = c_common_valid_pch;
86   cb->read_pch = c_common_read_pch;
87
88   /* Set the debug callbacks if we can use them.  */
89   if ((debug_info_level == DINFO_LEVEL_VERBOSE
90        && (write_symbols == DWARF2_DEBUG
91            || write_symbols == VMS_AND_DWARF2_DEBUG))
92       || flag_dump_go_spec != NULL)
93     {
94       cb->define = cb_define;
95       cb->undef = cb_undef;
96     }
97 }
98
99 struct c_fileinfo *
100 get_fileinfo (const char *name)
101 {
102   splay_tree_node n;
103   struct c_fileinfo *fi;
104
105   if (!file_info_tree)
106     file_info_tree = splay_tree_new ((splay_tree_compare_fn) strcmp,
107                                      0,
108                                      (splay_tree_delete_value_fn) free);
109
110   n = splay_tree_lookup (file_info_tree, (splay_tree_key) name);
111   if (n)
112     return (struct c_fileinfo *) n->value;
113
114   fi = XNEW (struct c_fileinfo);
115   fi->time = 0;
116   fi->interface_only = 0;
117   fi->interface_unknown = 1;
118   splay_tree_insert (file_info_tree, (splay_tree_key) name,
119                      (splay_tree_value) fi);
120   return fi;
121 }
122
123 static void
124 update_header_times (const char *name)
125 {
126   /* Changing files again.  This means currently collected time
127      is charged against header time, and body time starts back at 0.  */
128   if (flag_detailed_statistics)
129     {
130       int this_time = get_run_time ();
131       struct c_fileinfo *file = get_fileinfo (name);
132       header_time += this_time - body_time;
133       file->time += this_time - body_time;
134       body_time = this_time;
135     }
136 }
137
138 static int
139 dump_one_header (splay_tree_node n, void * ARG_UNUSED (dummy))
140 {
141   print_time ((const char *) n->key,
142               ((struct c_fileinfo *) n->value)->time);
143   return 0;
144 }
145
146 void
147 dump_time_statistics (void)
148 {
149   struct c_fileinfo *file = get_fileinfo (input_filename);
150   int this_time = get_run_time ();
151   file->time += this_time - body_time;
152
153   fprintf (stderr, "\n******\n");
154   print_time ("header files (total)", header_time);
155   print_time ("main file (total)", this_time - body_time);
156   fprintf (stderr, "ratio = %g : 1\n",
157            (double) header_time / (double) (this_time - body_time));
158   fprintf (stderr, "\n******\n");
159
160   splay_tree_foreach (file_info_tree, dump_one_header, 0);
161 }
162
163 static void
164 cb_ident (cpp_reader * ARG_UNUSED (pfile),
165           unsigned int ARG_UNUSED (line),
166           const cpp_string * ARG_UNUSED (str))
167 {
168 #ifdef ASM_OUTPUT_IDENT
169   if (!flag_no_ident)
170     {
171       /* Convert escapes in the string.  */
172       cpp_string cstr = { 0, 0 };
173       if (cpp_interpret_string (pfile, str, 1, &cstr, CPP_STRING))
174         {
175           ASM_OUTPUT_IDENT (asm_out_file, (const char *) cstr.text);
176           free (CONST_CAST (unsigned char *, cstr.text));
177         }
178     }
179 #endif
180 }
181
182 /* Called at the start of every non-empty line.  TOKEN is the first
183    lexed token on the line.  Used for diagnostic line numbers.  */
184 static void
185 cb_line_change (cpp_reader * ARG_UNUSED (pfile), const cpp_token *token,
186                 int parsing_args)
187 {
188   if (token->type != CPP_EOF && !parsing_args)
189     input_location = token->src_loc;
190 }
191
192 void
193 fe_file_change (const struct line_map *new_map)
194 {
195   if (new_map == NULL)
196     return;
197
198   if (new_map->reason == LC_ENTER)
199     {
200       /* Don't stack the main buffer on the input stack;
201          we already did in compile_file.  */
202       if (!MAIN_FILE_P (new_map))
203         {
204           unsigned int included_at = LAST_SOURCE_LINE_LOCATION (new_map - 1);
205           int line = 0;
206           if (included_at > BUILTINS_LOCATION)
207             line = SOURCE_LINE (new_map - 1, included_at);
208
209           input_location = new_map->start_location;
210           (*debug_hooks->start_source_file) (line, LINEMAP_FILE (new_map));
211 #ifndef NO_IMPLICIT_EXTERN_C
212           if (c_header_level)
213             ++c_header_level;
214           else if (new_map->sysp == 2)
215             {
216               c_header_level = 1;
217               ++pending_lang_change;
218             }
219 #endif
220         }
221     }
222   else if (new_map->reason == LC_LEAVE)
223     {
224 #ifndef NO_IMPLICIT_EXTERN_C
225       if (c_header_level && --c_header_level == 0)
226         {
227           if (new_map->sysp == 2)
228             warning (0, "badly nested C headers from preprocessor");
229           --pending_lang_change;
230         }
231 #endif
232       input_location = new_map->start_location;
233
234       (*debug_hooks->end_source_file) (LINEMAP_LINE (new_map));
235     }
236
237   update_header_times (LINEMAP_FILE (new_map));
238   input_location = new_map->start_location;
239 }
240
241 static void
242 cb_def_pragma (cpp_reader *pfile, source_location loc)
243 {
244   /* Issue a warning message if we have been asked to do so.  Ignore
245      unknown pragmas in system headers unless an explicit
246      -Wunknown-pragmas has been given.  */
247   if (warn_unknown_pragmas > in_system_header)
248     {
249       const unsigned char *space, *name;
250       const cpp_token *s;
251       location_t fe_loc = loc;
252
253       space = name = (const unsigned char *) "";
254       s = cpp_get_token (pfile);
255       if (s->type != CPP_EOF)
256         {
257           space = cpp_token_as_text (pfile, s);
258           s = cpp_get_token (pfile);
259           if (s->type == CPP_NAME)
260             name = cpp_token_as_text (pfile, s);
261         }
262
263       warning_at (fe_loc, OPT_Wunknown_pragmas, "ignoring #pragma %s %s",
264                   space, name);
265     }
266 }
267
268 /* #define callback for DWARF and DWARF2 debug info.  */
269 static void
270 cb_define (cpp_reader *pfile, source_location loc, cpp_hashnode *node)
271 {
272   const struct line_map *map = linemap_lookup (line_table, loc);
273   (*debug_hooks->define) (SOURCE_LINE (map, loc),
274                           (const char *) cpp_macro_definition (pfile, node));
275 }
276
277 /* #undef callback for DWARF and DWARF2 debug info.  */
278 static void
279 cb_undef (cpp_reader * ARG_UNUSED (pfile), source_location loc,
280           cpp_hashnode *node)
281 {
282   const struct line_map *map = linemap_lookup (line_table, loc);
283   (*debug_hooks->undef) (SOURCE_LINE (map, loc),
284                          (const char *) NODE_NAME (node));
285 }
286 \f
287 /* Read a token and return its type.  Fill *VALUE with its value, if
288    applicable.  Fill *CPP_FLAGS with the token's flags, if it is
289    non-NULL.  */
290
291 enum cpp_ttype
292 c_lex_with_flags (tree *value, location_t *loc, unsigned char *cpp_flags,
293                   int lex_flags)
294 {
295   static bool no_more_pch;
296   const cpp_token *tok;
297   enum cpp_ttype type;
298   unsigned char add_flags = 0;
299
300   timevar_push (TV_CPP);
301  retry:
302   tok = cpp_get_token_with_location (parse_in, loc);
303   type = tok->type;
304
305  retry_after_at:
306   switch (type)
307     {
308     case CPP_PADDING:
309       goto retry;
310
311     case CPP_NAME:
312       *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node.node));
313       break;
314
315     case CPP_NUMBER:
316       {
317         unsigned int flags = cpp_classify_number (parse_in, tok);
318
319         switch (flags & CPP_N_CATEGORY)
320           {
321           case CPP_N_INVALID:
322             /* cpplib has issued an error.  */
323             *value = error_mark_node;
324             break;
325
326           case CPP_N_INTEGER:
327             /* C++ uses '0' to mark virtual functions as pure.
328                Set PURE_ZERO to pass this information to the C++ parser.  */
329             if (tok->val.str.len == 1 && *tok->val.str.text == '0')
330               add_flags = PURE_ZERO;
331             *value = interpret_integer (tok, flags);
332             break;
333
334           case CPP_N_FLOATING:
335             *value = interpret_float (tok, flags);
336             break;
337
338           default:
339             gcc_unreachable ();
340           }
341       }
342       break;
343
344     case CPP_ATSIGN:
345       /* An @ may give the next token special significance in Objective-C.  */
346       if (c_dialect_objc ())
347         {
348           location_t atloc = *loc;
349           location_t newloc;
350
351         retry_at:
352           tok = cpp_get_token_with_location (parse_in, &newloc);
353           type = tok->type;
354           switch (type)
355             {
356             case CPP_PADDING:
357               goto retry_at;
358
359             case CPP_STRING:
360             case CPP_WSTRING:
361             case CPP_STRING16:
362             case CPP_STRING32:
363             case CPP_UTF8STRING:
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.node));
369               if (OBJC_IS_AT_KEYWORD (C_RID_CODE (*value))
370                   || OBJC_IS_CXX_KEYWORD (C_RID_CODE (*value)))
371                 {
372                   type = CPP_AT_NAME;
373                   /* Note the complication: if we found an OBJC_CXX
374                      keyword, for example, 'class', we will be
375                      returning a token of type CPP_AT_NAME and rid
376                      code RID_CLASS (not RID_AT_CLASS).  The language
377                      parser needs to convert that to RID_AT_CLASS.
378                   */
379                   break;
380                 }
381               /* FALLTHROUGH */
382
383             default:
384               /* ... or not.  */
385               error_at (atloc, "stray %<@%> in program");
386               *loc = newloc;
387               goto retry_after_at;
388             }
389           break;
390         }
391
392       /* FALLTHROUGH */
393     case CPP_HASH:
394     case CPP_PASTE:
395       {
396         unsigned char name[8];
397
398         *cpp_spell_token (parse_in, tok, name, true) = 0;
399
400         error ("stray %qs in program", name);
401       }
402
403       goto retry;
404
405     case CPP_OTHER:
406       {
407         cppchar_t c = tok->val.str.text[0];
408
409         if (c == '"' || c == '\'')
410           error ("missing terminating %c character", (int) c);
411         else if (ISGRAPH (c))
412           error ("stray %qc in program", (int) c);
413         else
414           error ("stray %<\\%o%> in program", (int) c);
415       }
416       goto retry;
417
418     case CPP_CHAR:
419     case CPP_WCHAR:
420     case CPP_CHAR16:
421     case CPP_CHAR32:
422       *value = lex_charconst (tok);
423       break;
424
425     case CPP_STRING:
426     case CPP_WSTRING:
427     case CPP_STRING16:
428     case CPP_STRING32:
429     case CPP_UTF8STRING:
430       if ((lex_flags & C_LEX_STRING_NO_JOIN) == 0)
431         {
432           type = lex_string (tok, value, false,
433                              (lex_flags & C_LEX_STRING_NO_TRANSLATE) == 0);
434           break;
435         }
436       *value = build_string (tok->val.str.len, (const char *) tok->val.str.text);
437       break;
438
439     case CPP_PRAGMA:
440       *value = build_int_cst (integer_type_node, tok->val.pragma);
441       break;
442
443       /* These tokens should not be visible outside cpplib.  */
444     case CPP_HEADER_NAME:
445     case CPP_MACRO_ARG:
446       gcc_unreachable ();
447
448     /* CPP_COMMENT will appear when compiling with -C and should be
449        ignored.  */
450      case CPP_COMMENT:
451        goto retry;
452
453     default:
454       *value = NULL_TREE;
455       break;
456     }
457
458   if (cpp_flags)
459     *cpp_flags = tok->flags | add_flags;
460
461   if (!no_more_pch)
462     {
463       no_more_pch = true;
464       c_common_no_more_pch ();
465     }
466
467   timevar_pop (TV_CPP);
468
469   return type;
470 }
471
472 /* Returns the narrowest C-visible unsigned type, starting with the
473    minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
474    there isn't one.  */
475
476 static enum integer_type_kind
477 narrowest_unsigned_type (unsigned HOST_WIDE_INT low,
478                          unsigned HOST_WIDE_INT high,
479                          unsigned int flags)
480 {
481   int itk;
482
483   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
484     itk = itk_unsigned_int;
485   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
486     itk = itk_unsigned_long;
487   else
488     itk = itk_unsigned_long_long;
489
490   for (; itk < itk_none; itk += 2 /* skip unsigned types */)
491     {
492       tree upper;
493
494       if (integer_types[itk] == NULL_TREE)
495         continue;
496       upper = TYPE_MAX_VALUE (integer_types[itk]);
497
498       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
499           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
500               && TREE_INT_CST_LOW (upper) >= low))
501         return (enum integer_type_kind) itk;
502     }
503
504   return itk_none;
505 }
506
507 /* Ditto, but narrowest signed type.  */
508 static enum integer_type_kind
509 narrowest_signed_type (unsigned HOST_WIDE_INT low,
510                        unsigned HOST_WIDE_INT high, unsigned int flags)
511 {
512   int itk;
513
514   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
515     itk = itk_int;
516   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
517     itk = itk_long;
518   else
519     itk = itk_long_long;
520
521
522   for (; itk < itk_none; itk += 2 /* skip signed types */)
523     {
524       tree upper;
525
526       if (integer_types[itk] == NULL_TREE)
527         continue;
528       upper = TYPE_MAX_VALUE (integer_types[itk]);
529
530       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
531           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
532               && TREE_INT_CST_LOW (upper) >= low))
533         return (enum integer_type_kind) itk;
534     }
535
536   return itk_none;
537 }
538
539 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib.  */
540 static tree
541 interpret_integer (const cpp_token *token, unsigned int flags)
542 {
543   tree value, type;
544   enum integer_type_kind itk;
545   cpp_num integer;
546   cpp_options *options = cpp_get_options (parse_in);
547
548   integer = cpp_interpret_integer (parse_in, token, flags);
549   integer = cpp_num_sign_extend (integer, options->precision);
550
551   /* The type of a constant with a U suffix is straightforward.  */
552   if (flags & CPP_N_UNSIGNED)
553     itk = narrowest_unsigned_type (integer.low, integer.high, flags);
554   else
555     {
556       /* The type of a potentially-signed integer constant varies
557          depending on the base it's in, the standard in use, and the
558          length suffixes.  */
559       enum integer_type_kind itk_u
560         = narrowest_unsigned_type (integer.low, integer.high, flags);
561       enum integer_type_kind itk_s
562         = narrowest_signed_type (integer.low, integer.high, flags);
563
564       /* In both C89 and C99, octal and hex constants may be signed or
565          unsigned, whichever fits tighter.  We do not warn about this
566          choice differing from the traditional choice, as the constant
567          is probably a bit pattern and either way will work.  */
568       if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
569         itk = MIN (itk_u, itk_s);
570       else
571         {
572           /* In C99, decimal constants are always signed.
573              In C89, decimal constants that don't fit in long have
574              undefined behavior; we try to make them unsigned long.
575              In GCC's extended C89, that last is true of decimal
576              constants that don't fit in long long, too.  */
577
578           itk = itk_s;
579           if (itk_s > itk_u && itk_s > itk_long)
580             {
581               if (!flag_isoc99)
582                 {
583                   if (itk_u < itk_unsigned_long)
584                     itk_u = itk_unsigned_long;
585                   itk = itk_u;
586                   warning (0, "this decimal constant is unsigned only in ISO C90");
587                 }
588               else
589                 warning (OPT_Wtraditional,
590                          "this decimal constant would be unsigned in ISO C90");
591             }
592         }
593     }
594
595   if (itk == itk_none)
596     /* cpplib has already issued a warning for overflow.  */
597     type = ((flags & CPP_N_UNSIGNED)
598             ? widest_unsigned_literal_type_node
599             : widest_integer_literal_type_node);
600   else
601     {
602       type = integer_types[itk];
603       if (itk > itk_unsigned_long
604           && (flags & CPP_N_WIDTH) != CPP_N_LARGE)
605         emit_diagnostic
606           ((c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99)
607            ? DK_PEDWARN : DK_WARNING,
608            input_location, OPT_Wlong_long,
609            (flags & CPP_N_UNSIGNED)
610            ? "integer constant is too large for %<unsigned long%> type"
611            : "integer constant is too large for %<long%> type");
612     }
613
614   value = build_int_cst_wide (type, integer.low, integer.high);
615
616   /* Convert imaginary to a complex type.  */
617   if (flags & CPP_N_IMAGINARY)
618     value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
619
620   return value;
621 }
622
623 /* Interpret TOKEN, a floating point number with FLAGS as classified
624    by cpplib.  */
625 static tree
626 interpret_float (const cpp_token *token, unsigned int flags)
627 {
628   tree type;
629   tree const_type;
630   tree value;
631   REAL_VALUE_TYPE real;
632   REAL_VALUE_TYPE real_trunc;
633   char *copy;
634   size_t copylen;
635
636   /* Default (no suffix) depends on whether the FLOAT_CONST_DECIMAL64
637      pragma has been used and is either double or _Decimal64.  Types
638      that are not allowed with decimal float default to double.  */
639   if (flags & CPP_N_DEFAULT)
640     {
641       flags ^= CPP_N_DEFAULT;
642       flags |= CPP_N_MEDIUM;
643
644       if (((flags & CPP_N_HEX) == 0) && ((flags & CPP_N_IMAGINARY) == 0))
645         {
646           warning (OPT_Wunsuffixed_float_constants,
647                    "unsuffixed float constant");
648           if (float_const_decimal64_p ())
649             flags |= CPP_N_DFLOAT;
650         }
651     }
652
653   /* Decode _Fract and _Accum.  */
654   if (flags & CPP_N_FRACT || flags & CPP_N_ACCUM)
655     return interpret_fixed (token, flags);
656
657   /* Decode type based on width and properties. */
658   if (flags & CPP_N_DFLOAT)
659     if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
660       type = dfloat128_type_node;
661     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
662       type = dfloat32_type_node;
663     else
664       type = dfloat64_type_node;
665   else
666     if (flags & CPP_N_WIDTH_MD)
667       {
668         char suffix;
669         enum machine_mode mode;
670
671         if ((flags & CPP_N_WIDTH_MD) == CPP_N_MD_W)
672           suffix = 'w';
673         else
674           suffix = 'q';
675
676         mode = targetm.c.mode_for_suffix (suffix);
677         if (mode == VOIDmode)
678           {
679             error ("unsupported non-standard suffix on floating constant");
680
681             return error_mark_node;
682           }
683         else
684           pedwarn (input_location, OPT_pedantic, "non-standard suffix on floating constant");
685
686         type = c_common_type_for_mode (mode, 0);
687         gcc_assert (type);
688       }
689     else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
690       type = long_double_type_node;
691     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
692              || flag_single_precision_constant)
693       type = float_type_node;
694     else
695       type = double_type_node;
696
697   const_type = excess_precision_type (type);
698   if (!const_type)
699     const_type = type;
700
701   /* Copy the constant to a nul-terminated buffer.  If the constant
702      has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
703      can't handle them.  */
704   copylen = token->val.str.len;
705   if (flags & CPP_N_DFLOAT)
706     copylen -= 2;
707   else
708     {
709       if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
710         /* Must be an F or L or machine defined suffix.  */
711         copylen--;
712       if (flags & CPP_N_IMAGINARY)
713         /* I or J suffix.  */
714         copylen--;
715     }
716
717   copy = (char *) alloca (copylen + 1);
718   memcpy (copy, token->val.str.text, copylen);
719   copy[copylen] = '\0';
720
721   real_from_string3 (&real, copy, TYPE_MODE (const_type));
722   if (const_type != type)
723     /* Diagnosing if the result of converting the value with excess
724        precision to the semantic type would overflow (with associated
725        double rounding) is more appropriate than diagnosing if the
726        result of converting the string directly to the semantic type
727        would overflow.  */
728     real_convert (&real_trunc, TYPE_MODE (type), &real);
729
730   /* Both C and C++ require a diagnostic for a floating constant
731      outside the range of representable values of its type.  Since we
732      have __builtin_inf* to produce an infinity, this is now a
733      mandatory pedwarn if the target does not support infinities.  */
734   if (REAL_VALUE_ISINF (real)
735       || (const_type != type && REAL_VALUE_ISINF (real_trunc)))
736     {
737       if (!MODE_HAS_INFINITIES (TYPE_MODE (type)))
738         pedwarn (input_location, 0, "floating constant exceeds range of %qT", type);
739       else
740         warning (OPT_Woverflow, "floating constant exceeds range of %qT", type);
741     }
742   /* We also give a warning if the value underflows.  */
743   else if (REAL_VALUES_EQUAL (real, dconst0)
744            || (const_type != type && REAL_VALUES_EQUAL (real_trunc, dconst0)))
745     {
746       REAL_VALUE_TYPE realvoidmode;
747       int overflow = real_from_string (&realvoidmode, copy);
748       if (overflow < 0 || !REAL_VALUES_EQUAL (realvoidmode, dconst0))
749         warning (OPT_Woverflow, "floating constant truncated to zero");
750     }
751
752   /* Create a node with determined type and value.  */
753   value = build_real (const_type, real);
754   if (flags & CPP_N_IMAGINARY)
755     {
756       value = build_complex (NULL_TREE, convert (const_type,
757                                                  integer_zero_node), value);
758       if (type != const_type)
759         {
760           const_type = TREE_TYPE (value);
761           type = build_complex_type (type);
762         }
763     }
764
765   if (type != const_type)
766     value = build1 (EXCESS_PRECISION_EXPR, type, value);
767
768   return value;
769 }
770
771 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
772    by cpplib.  */
773
774 static tree
775 interpret_fixed (const cpp_token *token, unsigned int flags)
776 {
777   tree type;
778   tree value;
779   FIXED_VALUE_TYPE fixed;
780   char *copy;
781   size_t copylen;
782
783   copylen = token->val.str.len;
784
785   if (flags & CPP_N_FRACT) /* _Fract.  */
786     {
787       if (flags & CPP_N_UNSIGNED) /* Unsigned _Fract.  */
788         {
789           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
790             {
791               type = unsigned_long_long_fract_type_node;
792               copylen -= 4;
793             }
794           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
795             {
796               type = unsigned_long_fract_type_node;
797               copylen -= 3;
798             }
799           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
800             {
801               type = unsigned_short_fract_type_node;
802               copylen -= 3;
803             }
804           else
805             {
806               type = unsigned_fract_type_node;
807               copylen -= 2;
808             }
809         }
810       else /* Signed _Fract.  */
811         {
812           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
813             {
814               type = long_long_fract_type_node;
815               copylen -= 3;
816             }
817           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
818             {
819               type = long_fract_type_node;
820               copylen -= 2;
821             }
822           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
823             {
824               type = short_fract_type_node;
825               copylen -= 2;
826             }
827           else
828             {
829               type = fract_type_node;
830               copylen --;
831             }
832           }
833     }
834   else /* _Accum.  */
835     {
836       if (flags & CPP_N_UNSIGNED) /* Unsigned _Accum.  */
837         {
838           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
839             {
840               type = unsigned_long_long_accum_type_node;
841               copylen -= 4;
842             }
843           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
844             {
845               type = unsigned_long_accum_type_node;
846               copylen -= 3;
847             }
848           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
849             {
850               type = unsigned_short_accum_type_node;
851               copylen -= 3;
852              }
853           else
854             {
855               type = unsigned_accum_type_node;
856               copylen -= 2;
857             }
858         }
859       else /* Signed _Accum.  */
860         {
861           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
862             {
863               type = long_long_accum_type_node;
864               copylen -= 3;
865             }
866           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
867             {
868               type = long_accum_type_node;
869               copylen -= 2;
870             }
871           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
872             {
873               type = short_accum_type_node;
874               copylen -= 2;
875             }
876           else
877             {
878               type = accum_type_node;
879               copylen --;
880             }
881         }
882     }
883
884   copy = (char *) alloca (copylen + 1);
885   memcpy (copy, token->val.str.text, copylen);
886   copy[copylen] = '\0';
887
888   fixed_from_string (&fixed, copy, TYPE_MODE (type));
889
890   /* Create a node with determined type and value.  */
891   value = build_fixed (type, fixed);
892
893   return value;
894 }
895
896 /* Convert a series of STRING, WSTRING, STRING16, STRING32 and/or
897    UTF8STRING tokens into a tree, performing string constant
898    concatenation.  TOK is the first of these.  VALP is the location to
899    write the string into.  OBJC_STRING indicates whether an '@' token
900    preceded the incoming token (in that case, the strings can either
901    be ObjC strings, preceded by a single '@', or normal strings, not
902    preceded by '@'.  The result will be a CPP_OBJC_STRING).  Returns
903    the CPP token type of the result (CPP_STRING, CPP_WSTRING,
904    CPP_STRING32, CPP_STRING16, CPP_UTF8STRING, or CPP_OBJC_STRING).
905
906    This is unfortunately more work than it should be.  If any of the
907    strings in the series has an L prefix, the result is a wide string
908    (6.4.5p4).  Whether or not the result is a wide string affects the
909    meaning of octal and hexadecimal escapes (6.4.4.4p6,9).  But escape
910    sequences do not continue across the boundary between two strings in
911    a series (6.4.5p7), so we must not lose the boundaries.  Therefore
912    cpp_interpret_string takes a vector of cpp_string structures, which
913    we must arrange to provide.  */
914
915 static enum cpp_ttype
916 lex_string (const cpp_token *tok, tree *valp, bool objc_string, bool translate)
917 {
918   tree value;
919   size_t concats = 0;
920   struct obstack str_ob;
921   cpp_string istr;
922   enum cpp_ttype type = tok->type;
923
924   /* Try to avoid the overhead of creating and destroying an obstack
925      for the common case of just one string.  */
926   cpp_string str = tok->val.str;
927   cpp_string *strs = &str;
928
929   /* objc_at_sign_was_seen is only used when doing Objective-C string
930      concatenation.  It is 'true' if we have seen an '@' before the
931      current string, and 'false' if not.  We must see exactly one or
932      zero '@' before each string.  */
933   bool objc_at_sign_was_seen = false;
934
935  retry:
936   tok = cpp_get_token (parse_in);
937   switch (tok->type)
938     {
939     case CPP_PADDING:
940       goto retry;
941     case CPP_ATSIGN:
942       if (objc_string)
943         {
944           if (objc_at_sign_was_seen)
945             error ("repeated %<@%> before Objective-C string");
946
947           objc_at_sign_was_seen = true;
948           goto retry;
949         }
950       /* FALLTHROUGH */
951
952     default:
953       break;
954
955     case CPP_WSTRING:
956     case CPP_STRING16:
957     case CPP_STRING32:
958     case CPP_UTF8STRING:
959       if (type != tok->type)
960         {
961           if (type == CPP_STRING)
962             type = tok->type;
963           else
964             error ("unsupported non-standard concatenation of string literals");
965         }
966
967     case CPP_STRING:
968       if (!concats)
969         {
970           gcc_obstack_init (&str_ob);
971           obstack_grow (&str_ob, &str, sizeof (cpp_string));
972         }
973
974       concats++;
975       obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
976       if (objc_string)
977         objc_at_sign_was_seen = false;
978       goto retry;
979     }
980
981   /* It is an error if we saw a '@' with no following string.  */
982   if (objc_at_sign_was_seen)
983     error ("stray %<@%> in program");
984
985   /* We have read one more token than we want.  */
986   _cpp_backup_tokens (parse_in, 1);
987   if (concats)
988     strs = XOBFINISH (&str_ob, cpp_string *);
989
990   if (concats && !objc_string && !in_system_header)
991     warning (OPT_Wtraditional,
992              "traditional C rejects string constant concatenation");
993
994   if ((translate
995        ? cpp_interpret_string : cpp_interpret_string_notranslate)
996       (parse_in, strs, concats + 1, &istr, type))
997     {
998       value = build_string (istr.len, (const char *) istr.text);
999       free (CONST_CAST (unsigned char *, istr.text));
1000     }
1001   else
1002     {
1003       /* Callers cannot generally handle error_mark_node in this context,
1004          so return the empty string instead.  cpp_interpret_string has
1005          issued an error.  */
1006       switch (type)
1007         {
1008         default:
1009         case CPP_STRING:
1010         case CPP_UTF8STRING:
1011           value = build_string (1, "");
1012           break;
1013         case CPP_STRING16:
1014           value = build_string (TYPE_PRECISION (char16_type_node)
1015                                 / TYPE_PRECISION (char_type_node),
1016                                 "\0");  /* char16_t is 16 bits */
1017           break;
1018         case CPP_STRING32:
1019           value = build_string (TYPE_PRECISION (char32_type_node)
1020                                 / TYPE_PRECISION (char_type_node),
1021                                 "\0\0\0");  /* char32_t is 32 bits */
1022           break;
1023         case CPP_WSTRING:
1024           value = build_string (TYPE_PRECISION (wchar_type_node)
1025                                 / TYPE_PRECISION (char_type_node),
1026                                 "\0\0\0");  /* widest supported wchar_t
1027                                                is 32 bits */
1028           break;
1029         }
1030     }
1031
1032   switch (type)
1033     {
1034     default:
1035     case CPP_STRING:
1036     case CPP_UTF8STRING:
1037       TREE_TYPE (value) = char_array_type_node;
1038       break;
1039     case CPP_STRING16:
1040       TREE_TYPE (value) = char16_array_type_node;
1041       break;
1042     case CPP_STRING32:
1043       TREE_TYPE (value) = char32_array_type_node;
1044       break;
1045     case CPP_WSTRING:
1046       TREE_TYPE (value) = wchar_array_type_node;
1047     }
1048   *valp = fix_string_type (value);
1049
1050   if (concats)
1051     obstack_free (&str_ob, 0);
1052
1053   return objc_string ? CPP_OBJC_STRING : type;
1054 }
1055
1056 /* Converts a (possibly wide) character constant token into a tree.  */
1057 static tree
1058 lex_charconst (const cpp_token *token)
1059 {
1060   cppchar_t result;
1061   tree type, value;
1062   unsigned int chars_seen;
1063   int unsignedp = 0;
1064
1065   result = cpp_interpret_charconst (parse_in, token,
1066                                     &chars_seen, &unsignedp);
1067
1068   if (token->type == CPP_WCHAR)
1069     type = wchar_type_node;
1070   else if (token->type == CPP_CHAR32)
1071     type = char32_type_node;
1072   else if (token->type == CPP_CHAR16)
1073     type = char16_type_node;
1074   /* In C, a character constant has type 'int'.
1075      In C++ 'char', but multi-char charconsts have type 'int'.  */
1076   else if (!c_dialect_cxx () || chars_seen > 1)
1077     type = integer_type_node;
1078   else
1079     type = char_type_node;
1080
1081   /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1082      before possibly widening to HOST_WIDE_INT for build_int_cst.  */
1083   if (unsignedp || (cppchar_signed_t) result >= 0)
1084     value = build_int_cst_wide (type, result, 0);
1085   else
1086     value = build_int_cst_wide (type, (cppchar_signed_t) result, -1);
1087
1088   return value;
1089 }