gcc/c-lex.c

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