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