OSDN Git Service

Implement C++11 user-defined literals.
[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, const char *);
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 (LINEMAP_SYSP (new_map) == 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 (LINEMAP_SYSP (new_map) == 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         const char *suffix = NULL;
318         unsigned int flags = cpp_classify_number (parse_in, tok, &suffix);
319
320         switch (flags & CPP_N_CATEGORY)
321           {
322           case CPP_N_INVALID:
323             /* cpplib has issued an error.  */
324             *value = error_mark_node;
325             break;
326
327           case CPP_N_INTEGER:
328             /* C++ uses '0' to mark virtual functions as pure.
329                Set PURE_ZERO to pass this information to the C++ parser.  */
330             if (tok->val.str.len == 1 && *tok->val.str.text == '0')
331               add_flags = PURE_ZERO;
332             *value = interpret_integer (tok, flags);
333             break;
334
335           case CPP_N_FLOATING:
336             *value = interpret_float (tok, flags, suffix);
337             break;
338
339           default:
340             gcc_unreachable ();
341           }
342
343         if (flags & CPP_N_USERDEF)
344           {
345             tree suffix_id = get_identifier (suffix);
346             int len = tok->val.str.len - strlen (suffix);
347             tree num_string = build_string (len + 1,
348                                             (const char *) tok->val.str.text);
349             TREE_TYPE (num_string) = char_array_type_node;
350             num_string = fix_string_type (num_string);
351             char *str = CONST_CAST (char *, TREE_STRING_POINTER (num_string));
352             str[len] = '\0';
353             tree literal = build_userdef_literal (suffix_id, *value,
354                                                   num_string);
355             *value = literal;
356           }
357       }
358       break;
359
360     case CPP_ATSIGN:
361       /* An @ may give the next token special significance in Objective-C.  */
362       if (c_dialect_objc ())
363         {
364           location_t atloc = *loc;
365           location_t newloc;
366
367         retry_at:
368           tok = cpp_get_token_with_location (parse_in, &newloc);
369           type = tok->type;
370           switch (type)
371             {
372             case CPP_PADDING:
373               goto retry_at;
374
375             case CPP_STRING:
376             case CPP_WSTRING:
377             case CPP_STRING16:
378             case CPP_STRING32:
379             case CPP_UTF8STRING:
380               type = lex_string (tok, value, true, true);
381               break;
382
383             case CPP_NAME:
384               *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node.node));
385               if (OBJC_IS_AT_KEYWORD (C_RID_CODE (*value))
386                   || OBJC_IS_CXX_KEYWORD (C_RID_CODE (*value)))
387                 {
388                   type = CPP_AT_NAME;
389                   /* Note the complication: if we found an OBJC_CXX
390                      keyword, for example, 'class', we will be
391                      returning a token of type CPP_AT_NAME and rid
392                      code RID_CLASS (not RID_AT_CLASS).  The language
393                      parser needs to convert that to RID_AT_CLASS.
394                   */
395                   break;
396                 }
397               /* FALLTHROUGH */
398
399             default:
400               /* ... or not.  */
401               error_at (atloc, "stray %<@%> in program");
402               *loc = newloc;
403               goto retry_after_at;
404             }
405           break;
406         }
407
408       /* FALLTHROUGH */
409     case CPP_HASH:
410     case CPP_PASTE:
411       {
412         unsigned char name[8];
413
414         *cpp_spell_token (parse_in, tok, name, true) = 0;
415
416         error ("stray %qs in program", name);
417       }
418
419       goto retry;
420
421     case CPP_OTHER:
422       {
423         cppchar_t c = tok->val.str.text[0];
424
425         if (c == '"' || c == '\'')
426           error ("missing terminating %c character", (int) c);
427         else if (ISGRAPH (c))
428           error ("stray %qc in program", (int) c);
429         else
430           error ("stray %<\\%o%> in program", (int) c);
431       }
432       goto retry;
433
434     case CPP_CHAR_USERDEF:
435     case CPP_WCHAR_USERDEF:
436     case CPP_CHAR16_USERDEF:
437     case CPP_CHAR32_USERDEF:
438       {
439         tree literal;
440         cpp_token temp_tok = *tok;
441         const char *suffix = cpp_get_userdef_suffix (tok);
442         temp_tok.val.str.len -= strlen (suffix);
443         temp_tok.type = cpp_userdef_char_remove_type (type);
444         literal = build_userdef_literal (get_identifier (suffix),
445                                          lex_charconst (&temp_tok), NULL_TREE);
446         *value = literal;
447       }
448       break;
449
450     case CPP_CHAR:
451     case CPP_WCHAR:
452     case CPP_CHAR16:
453     case CPP_CHAR32:
454       *value = lex_charconst (tok);
455       break;
456
457     case CPP_STRING_USERDEF:
458     case CPP_WSTRING_USERDEF:
459     case CPP_STRING16_USERDEF:
460     case CPP_STRING32_USERDEF:
461     case CPP_UTF8STRING_USERDEF:
462       {
463         tree literal, string;
464         const char *suffix = cpp_get_userdef_suffix (tok);
465         string = build_string (tok->val.str.len - strlen (suffix),
466                                (const char *) tok->val.str.text);
467         literal = build_userdef_literal (get_identifier (suffix),
468                                          string, NULL_TREE);
469         *value = literal;
470       }
471       break;
472
473     case CPP_STRING:
474     case CPP_WSTRING:
475     case CPP_STRING16:
476     case CPP_STRING32:
477     case CPP_UTF8STRING:
478       if ((lex_flags & C_LEX_STRING_NO_JOIN) == 0)
479         {
480           type = lex_string (tok, value, false,
481                              (lex_flags & C_LEX_STRING_NO_TRANSLATE) == 0);
482           break;
483         }
484       *value = build_string (tok->val.str.len, (const char *) tok->val.str.text);
485       break;
486
487     case CPP_PRAGMA:
488       *value = build_int_cst (integer_type_node, tok->val.pragma);
489       break;
490
491       /* These tokens should not be visible outside cpplib.  */
492     case CPP_HEADER_NAME:
493     case CPP_MACRO_ARG:
494       gcc_unreachable ();
495
496     /* CPP_COMMENT will appear when compiling with -C and should be
497        ignored.  */
498      case CPP_COMMENT:
499        goto retry;
500
501     default:
502       *value = NULL_TREE;
503       break;
504     }
505
506   if (cpp_flags)
507     *cpp_flags = tok->flags | add_flags;
508
509   if (!no_more_pch)
510     {
511       no_more_pch = true;
512       c_common_no_more_pch ();
513     }
514
515   timevar_pop (TV_CPP);
516
517   return type;
518 }
519
520 /* Returns the narrowest C-visible unsigned type, starting with the
521    minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
522    there isn't one.  */
523
524 static enum integer_type_kind
525 narrowest_unsigned_type (unsigned HOST_WIDE_INT low,
526                          unsigned HOST_WIDE_INT high,
527                          unsigned int flags)
528 {
529   int itk;
530
531   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
532     itk = itk_unsigned_int;
533   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
534     itk = itk_unsigned_long;
535   else
536     itk = itk_unsigned_long_long;
537
538   for (; itk < itk_none; itk += 2 /* skip unsigned types */)
539     {
540       tree upper;
541
542       if (integer_types[itk] == NULL_TREE)
543         continue;
544       upper = TYPE_MAX_VALUE (integer_types[itk]);
545
546       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
547           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
548               && TREE_INT_CST_LOW (upper) >= low))
549         return (enum integer_type_kind) itk;
550     }
551
552   return itk_none;
553 }
554
555 /* Ditto, but narrowest signed type.  */
556 static enum integer_type_kind
557 narrowest_signed_type (unsigned HOST_WIDE_INT low,
558                        unsigned HOST_WIDE_INT high, unsigned int flags)
559 {
560   int itk;
561
562   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
563     itk = itk_int;
564   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
565     itk = itk_long;
566   else
567     itk = itk_long_long;
568
569
570   for (; itk < itk_none; itk += 2 /* skip signed types */)
571     {
572       tree upper;
573
574       if (integer_types[itk] == NULL_TREE)
575         continue;
576       upper = TYPE_MAX_VALUE (integer_types[itk]);
577
578       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
579           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
580               && TREE_INT_CST_LOW (upper) >= low))
581         return (enum integer_type_kind) itk;
582     }
583
584   return itk_none;
585 }
586
587 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib.  */
588 static tree
589 interpret_integer (const cpp_token *token, unsigned int flags)
590 {
591   tree value, type;
592   enum integer_type_kind itk;
593   cpp_num integer;
594   cpp_options *options = cpp_get_options (parse_in);
595
596   integer = cpp_interpret_integer (parse_in, token, flags);
597   integer = cpp_num_sign_extend (integer, options->precision);
598
599   /* The type of a constant with a U suffix is straightforward.  */
600   if (flags & CPP_N_UNSIGNED)
601     itk = narrowest_unsigned_type (integer.low, integer.high, flags);
602   else
603     {
604       /* The type of a potentially-signed integer constant varies
605          depending on the base it's in, the standard in use, and the
606          length suffixes.  */
607       enum integer_type_kind itk_u
608         = narrowest_unsigned_type (integer.low, integer.high, flags);
609       enum integer_type_kind itk_s
610         = narrowest_signed_type (integer.low, integer.high, flags);
611
612       /* In both C89 and C99, octal and hex constants may be signed or
613          unsigned, whichever fits tighter.  We do not warn about this
614          choice differing from the traditional choice, as the constant
615          is probably a bit pattern and either way will work.  */
616       if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
617         itk = MIN (itk_u, itk_s);
618       else
619         {
620           /* In C99, decimal constants are always signed.
621              In C89, decimal constants that don't fit in long have
622              undefined behavior; we try to make them unsigned long.
623              In GCC's extended C89, that last is true of decimal
624              constants that don't fit in long long, too.  */
625
626           itk = itk_s;
627           if (itk_s > itk_u && itk_s > itk_long)
628             {
629               if (!flag_isoc99)
630                 {
631                   if (itk_u < itk_unsigned_long)
632                     itk_u = itk_unsigned_long;
633                   itk = itk_u;
634                   warning (0, "this decimal constant is unsigned only in ISO C90");
635                 }
636               else
637                 warning (OPT_Wtraditional,
638                          "this decimal constant would be unsigned in ISO C90");
639             }
640         }
641     }
642
643   if (itk == itk_none)
644     /* cpplib has already issued a warning for overflow.  */
645     type = ((flags & CPP_N_UNSIGNED)
646             ? widest_unsigned_literal_type_node
647             : widest_integer_literal_type_node);
648   else
649     {
650       type = integer_types[itk];
651       if (itk > itk_unsigned_long
652           && (flags & CPP_N_WIDTH) != CPP_N_LARGE)
653         emit_diagnostic
654           ((c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99)
655            ? DK_PEDWARN : DK_WARNING,
656            input_location, OPT_Wlong_long,
657            (flags & CPP_N_UNSIGNED)
658            ? "integer constant is too large for %<unsigned long%> type"
659            : "integer constant is too large for %<long%> type");
660     }
661
662   value = build_int_cst_wide (type, integer.low, integer.high);
663
664   /* Convert imaginary to a complex type.  */
665   if (flags & CPP_N_IMAGINARY)
666     value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
667
668   return value;
669 }
670
671 /* Interpret TOKEN, a floating point number with FLAGS as classified
672    by cpplib.  For C++0X SUFFIX may contain a user-defined literal suffix.  */
673 static tree
674 interpret_float (const cpp_token *token, unsigned int flags,
675                  const char *suffix)
676 {
677   tree type;
678   tree const_type;
679   tree value;
680   REAL_VALUE_TYPE real;
681   REAL_VALUE_TYPE real_trunc;
682   char *copy;
683   size_t copylen;
684
685   /* Default (no suffix) depends on whether the FLOAT_CONST_DECIMAL64
686      pragma has been used and is either double or _Decimal64.  Types
687      that are not allowed with decimal float default to double.  */
688   if (flags & CPP_N_DEFAULT)
689     {
690       flags ^= CPP_N_DEFAULT;
691       flags |= CPP_N_MEDIUM;
692
693       if (((flags & CPP_N_HEX) == 0) && ((flags & CPP_N_IMAGINARY) == 0))
694         {
695           warning (OPT_Wunsuffixed_float_constants,
696                    "unsuffixed float constant");
697           if (float_const_decimal64_p ())
698             flags |= CPP_N_DFLOAT;
699         }
700     }
701
702   /* Decode _Fract and _Accum.  */
703   if (flags & CPP_N_FRACT || flags & CPP_N_ACCUM)
704     return interpret_fixed (token, flags);
705
706   /* Decode type based on width and properties. */
707   if (flags & CPP_N_DFLOAT)
708     if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
709       type = dfloat128_type_node;
710     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
711       type = dfloat32_type_node;
712     else
713       type = dfloat64_type_node;
714   else
715     if (flags & CPP_N_WIDTH_MD)
716       {
717         char suffix;
718         enum machine_mode mode;
719
720         if ((flags & CPP_N_WIDTH_MD) == CPP_N_MD_W)
721           suffix = 'w';
722         else
723           suffix = 'q';
724
725         mode = targetm.c.mode_for_suffix (suffix);
726         if (mode == VOIDmode)
727           {
728             error ("unsupported non-standard suffix on floating constant");
729
730             return error_mark_node;
731           }
732         else
733           pedwarn (input_location, OPT_pedantic, "non-standard suffix on floating constant");
734
735         type = c_common_type_for_mode (mode, 0);
736         gcc_assert (type);
737       }
738     else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
739       type = long_double_type_node;
740     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
741              || flag_single_precision_constant)
742       type = float_type_node;
743     else
744       type = double_type_node;
745
746   const_type = excess_precision_type (type);
747   if (!const_type)
748     const_type = type;
749
750   /* Copy the constant to a nul-terminated buffer.  If the constant
751      has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
752      can't handle them.  */
753   copylen = token->val.str.len;
754   if (flags & CPP_N_USERDEF)
755     copylen -= strlen (suffix);
756   else if (flags & CPP_N_DFLOAT)
757     copylen -= 2;
758   else
759     {
760       if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
761         /* Must be an F or L or machine defined suffix.  */
762         copylen--;
763       if (flags & CPP_N_IMAGINARY)
764         /* I or J suffix.  */
765         copylen--;
766     }
767
768   copy = (char *) alloca (copylen + 1);
769   memcpy (copy, token->val.str.text, copylen);
770   copy[copylen] = '\0';
771
772   real_from_string3 (&real, copy, TYPE_MODE (const_type));
773   if (const_type != type)
774     /* Diagnosing if the result of converting the value with excess
775        precision to the semantic type would overflow (with associated
776        double rounding) is more appropriate than diagnosing if the
777        result of converting the string directly to the semantic type
778        would overflow.  */
779     real_convert (&real_trunc, TYPE_MODE (type), &real);
780
781   /* Both C and C++ require a diagnostic for a floating constant
782      outside the range of representable values of its type.  Since we
783      have __builtin_inf* to produce an infinity, this is now a
784      mandatory pedwarn if the target does not support infinities.  */
785   if (REAL_VALUE_ISINF (real)
786       || (const_type != type && REAL_VALUE_ISINF (real_trunc)))
787     {
788       if (!MODE_HAS_INFINITIES (TYPE_MODE (type)))
789         pedwarn (input_location, 0, "floating constant exceeds range of %qT", type);
790       else
791         warning (OPT_Woverflow, "floating constant exceeds range of %qT", type);
792     }
793   /* We also give a warning if the value underflows.  */
794   else if (REAL_VALUES_EQUAL (real, dconst0)
795            || (const_type != type && REAL_VALUES_EQUAL (real_trunc, dconst0)))
796     {
797       REAL_VALUE_TYPE realvoidmode;
798       int overflow = real_from_string (&realvoidmode, copy);
799       if (overflow < 0 || !REAL_VALUES_EQUAL (realvoidmode, dconst0))
800         warning (OPT_Woverflow, "floating constant truncated to zero");
801     }
802
803   /* Create a node with determined type and value.  */
804   value = build_real (const_type, real);
805   if (flags & CPP_N_IMAGINARY)
806     {
807       value = build_complex (NULL_TREE, convert (const_type,
808                                                  integer_zero_node), value);
809       if (type != const_type)
810         {
811           const_type = TREE_TYPE (value);
812           type = build_complex_type (type);
813         }
814     }
815
816   if (type != const_type)
817     value = build1 (EXCESS_PRECISION_EXPR, type, value);
818
819   return value;
820 }
821
822 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
823    by cpplib.  */
824
825 static tree
826 interpret_fixed (const cpp_token *token, unsigned int flags)
827 {
828   tree type;
829   tree value;
830   FIXED_VALUE_TYPE fixed;
831   char *copy;
832   size_t copylen;
833
834   copylen = token->val.str.len;
835
836   if (flags & CPP_N_FRACT) /* _Fract.  */
837     {
838       if (flags & CPP_N_UNSIGNED) /* Unsigned _Fract.  */
839         {
840           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
841             {
842               type = unsigned_long_long_fract_type_node;
843               copylen -= 4;
844             }
845           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
846             {
847               type = unsigned_long_fract_type_node;
848               copylen -= 3;
849             }
850           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
851             {
852               type = unsigned_short_fract_type_node;
853               copylen -= 3;
854             }
855           else
856             {
857               type = unsigned_fract_type_node;
858               copylen -= 2;
859             }
860         }
861       else /* Signed _Fract.  */
862         {
863           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
864             {
865               type = long_long_fract_type_node;
866               copylen -= 3;
867             }
868           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
869             {
870               type = long_fract_type_node;
871               copylen -= 2;
872             }
873           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
874             {
875               type = short_fract_type_node;
876               copylen -= 2;
877             }
878           else
879             {
880               type = fract_type_node;
881               copylen --;
882             }
883           }
884     }
885   else /* _Accum.  */
886     {
887       if (flags & CPP_N_UNSIGNED) /* Unsigned _Accum.  */
888         {
889           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
890             {
891               type = unsigned_long_long_accum_type_node;
892               copylen -= 4;
893             }
894           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
895             {
896               type = unsigned_long_accum_type_node;
897               copylen -= 3;
898             }
899           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
900             {
901               type = unsigned_short_accum_type_node;
902               copylen -= 3;
903              }
904           else
905             {
906               type = unsigned_accum_type_node;
907               copylen -= 2;
908             }
909         }
910       else /* Signed _Accum.  */
911         {
912           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
913             {
914               type = long_long_accum_type_node;
915               copylen -= 3;
916             }
917           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
918             {
919               type = long_accum_type_node;
920               copylen -= 2;
921             }
922           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
923             {
924               type = short_accum_type_node;
925               copylen -= 2;
926             }
927           else
928             {
929               type = accum_type_node;
930               copylen --;
931             }
932         }
933     }
934
935   copy = (char *) alloca (copylen + 1);
936   memcpy (copy, token->val.str.text, copylen);
937   copy[copylen] = '\0';
938
939   fixed_from_string (&fixed, copy, TYPE_MODE (type));
940
941   /* Create a node with determined type and value.  */
942   value = build_fixed (type, fixed);
943
944   return value;
945 }
946
947 /* Convert a series of STRING, WSTRING, STRING16, STRING32 and/or
948    UTF8STRING tokens into a tree, performing string constant
949    concatenation.  TOK is the first of these.  VALP is the location to
950    write the string into.  OBJC_STRING indicates whether an '@' token
951    preceded the incoming token (in that case, the strings can either
952    be ObjC strings, preceded by a single '@', or normal strings, not
953    preceded by '@'.  The result will be a CPP_OBJC_STRING).  Returns
954    the CPP token type of the result (CPP_STRING, CPP_WSTRING,
955    CPP_STRING32, CPP_STRING16, CPP_UTF8STRING, or CPP_OBJC_STRING).
956
957    This is unfortunately more work than it should be.  If any of the
958    strings in the series has an L prefix, the result is a wide string
959    (6.4.5p4).  Whether or not the result is a wide string affects the
960    meaning of octal and hexadecimal escapes (6.4.4.4p6,9).  But escape
961    sequences do not continue across the boundary between two strings in
962    a series (6.4.5p7), so we must not lose the boundaries.  Therefore
963    cpp_interpret_string takes a vector of cpp_string structures, which
964    we must arrange to provide.  */
965
966 static enum cpp_ttype
967 lex_string (const cpp_token *tok, tree *valp, bool objc_string, bool translate)
968 {
969   tree value;
970   size_t concats = 0;
971   struct obstack str_ob;
972   cpp_string istr;
973   enum cpp_ttype type = tok->type;
974
975   /* Try to avoid the overhead of creating and destroying an obstack
976      for the common case of just one string.  */
977   cpp_string str = tok->val.str;
978   cpp_string *strs = &str;
979
980   /* objc_at_sign_was_seen is only used when doing Objective-C string
981      concatenation.  It is 'true' if we have seen an '@' before the
982      current string, and 'false' if not.  We must see exactly one or
983      zero '@' before each string.  */
984   bool objc_at_sign_was_seen = false;
985
986  retry:
987   tok = cpp_get_token (parse_in);
988   switch (tok->type)
989     {
990     case CPP_PADDING:
991       goto retry;
992     case CPP_ATSIGN:
993       if (objc_string)
994         {
995           if (objc_at_sign_was_seen)
996             error ("repeated %<@%> before Objective-C string");
997
998           objc_at_sign_was_seen = true;
999           goto retry;
1000         }
1001       /* FALLTHROUGH */
1002
1003     default:
1004       break;
1005
1006     case CPP_WSTRING:
1007     case CPP_STRING16:
1008     case CPP_STRING32:
1009     case CPP_UTF8STRING:
1010       if (type != tok->type)
1011         {
1012           if (type == CPP_STRING)
1013             type = tok->type;
1014           else
1015             error ("unsupported non-standard concatenation of string literals");
1016         }
1017
1018     case CPP_STRING:
1019       if (!concats)
1020         {
1021           gcc_obstack_init (&str_ob);
1022           obstack_grow (&str_ob, &str, sizeof (cpp_string));
1023         }
1024
1025       concats++;
1026       obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
1027       if (objc_string)
1028         objc_at_sign_was_seen = false;
1029       goto retry;
1030     }
1031
1032   /* It is an error if we saw a '@' with no following string.  */
1033   if (objc_at_sign_was_seen)
1034     error ("stray %<@%> in program");
1035
1036   /* We have read one more token than we want.  */
1037   _cpp_backup_tokens (parse_in, 1);
1038   if (concats)
1039     strs = XOBFINISH (&str_ob, cpp_string *);
1040
1041   if (concats && !objc_string && !in_system_header)
1042     warning (OPT_Wtraditional,
1043              "traditional C rejects string constant concatenation");
1044
1045   if ((translate
1046        ? cpp_interpret_string : cpp_interpret_string_notranslate)
1047       (parse_in, strs, concats + 1, &istr, type))
1048     {
1049       value = build_string (istr.len, (const char *) istr.text);
1050       free (CONST_CAST (unsigned char *, istr.text));
1051     }
1052   else
1053     {
1054       /* Callers cannot generally handle error_mark_node in this context,
1055          so return the empty string instead.  cpp_interpret_string has
1056          issued an error.  */
1057       switch (type)
1058         {
1059         default:
1060         case CPP_STRING:
1061         case CPP_UTF8STRING:
1062           value = build_string (1, "");
1063           break;
1064         case CPP_STRING16:
1065           value = build_string (TYPE_PRECISION (char16_type_node)
1066                                 / TYPE_PRECISION (char_type_node),
1067                                 "\0");  /* char16_t is 16 bits */
1068           break;
1069         case CPP_STRING32:
1070           value = build_string (TYPE_PRECISION (char32_type_node)
1071                                 / TYPE_PRECISION (char_type_node),
1072                                 "\0\0\0");  /* char32_t is 32 bits */
1073           break;
1074         case CPP_WSTRING:
1075           value = build_string (TYPE_PRECISION (wchar_type_node)
1076                                 / TYPE_PRECISION (char_type_node),
1077                                 "\0\0\0");  /* widest supported wchar_t
1078                                                is 32 bits */
1079           break;
1080         }
1081     }
1082
1083   switch (type)
1084     {
1085     default:
1086     case CPP_STRING:
1087     case CPP_UTF8STRING:
1088       TREE_TYPE (value) = char_array_type_node;
1089       break;
1090     case CPP_STRING16:
1091       TREE_TYPE (value) = char16_array_type_node;
1092       break;
1093     case CPP_STRING32:
1094       TREE_TYPE (value) = char32_array_type_node;
1095       break;
1096     case CPP_WSTRING:
1097       TREE_TYPE (value) = wchar_array_type_node;
1098     }
1099   *valp = fix_string_type (value);
1100
1101   if (concats)
1102     obstack_free (&str_ob, 0);
1103
1104   return objc_string ? CPP_OBJC_STRING : type;
1105 }
1106
1107 /* Converts a (possibly wide) character constant token into a tree.  */
1108 static tree
1109 lex_charconst (const cpp_token *token)
1110 {
1111   cppchar_t result;
1112   tree type, value;
1113   unsigned int chars_seen;
1114   int unsignedp = 0;
1115
1116   result = cpp_interpret_charconst (parse_in, token,
1117                                     &chars_seen, &unsignedp);
1118
1119   if (token->type == CPP_WCHAR)
1120     type = wchar_type_node;
1121   else if (token->type == CPP_CHAR32)
1122     type = char32_type_node;
1123   else if (token->type == CPP_CHAR16)
1124     type = char16_type_node;
1125   /* In C, a character constant has type 'int'.
1126      In C++ 'char', but multi-char charconsts have type 'int'.  */
1127   else if (!c_dialect_cxx () || chars_seen > 1)
1128     type = integer_type_node;
1129   else
1130     type = char_type_node;
1131
1132   /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1133      before possibly widening to HOST_WIDE_INT for build_int_cst.  */
1134   if (unsignedp || (cppchar_signed_t) result >= 0)
1135     value = build_int_cst_wide (type, result, 0);
1136   else
1137     value = build_int_cst_wide (type, (cppchar_signed_t) result, -1);
1138
1139   return value;
1140 }