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               type = lex_string (tok, value, true, true);
 369               break;
 370
 371             case CPP_NAME:
 372               *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node.node));
 373               if (objc_is_reserved_word (*value))
 374                 {
 375                   type = CPP_AT_NAME;
 376                   break;
 377                 }
 378               /* FALLTHROUGH */
 379
 380             default:
 381               /* ... or not.  */
 382               error_at (atloc, "stray %<@%> in program");
 383               *loc = newloc;
 384               goto retry_after_at;
 385             }
 386           break;
 387         }
 388
 389       /* FALLTHROUGH */
 390     case CPP_HASH:
 391     case CPP_PASTE:
 392       {
 393         unsigned char name[8];
 394
 395         *cpp_spell_token (parse_in, tok, name, true) = 0;
 396
 397         error ("stray %qs in program", name);
 398       }
 399
 400       goto retry;
 401
 402     case CPP_OTHER:
 403       {
 404         cppchar_t c = tok->val.str.text[0];
 405
 406         if (c == '"' || c == '\'')
 407           error ("missing terminating %c character", (int) c);
 408         else if (ISGRAPH (c))
 409           error ("stray %qc in program", (int) c);
 410         else
 411           error ("stray %<\\%o%> in program", (int) c);
 412       }
 413       goto retry;
 414
 415     case CPP_CHAR:
 416     case CPP_WCHAR:
 417     case CPP_CHAR16:
 418     case CPP_CHAR32:
 419       *value = lex_charconst (tok);
 420       break;
 421
 422     case CPP_STRING:
 423     case CPP_WSTRING:
 424     case CPP_STRING16:
 425     case CPP_STRING32:
 426       if ((lex_flags & C_LEX_RAW_STRINGS) == 0)
 427         {
 428           type = lex_string (tok, value, false,
 429                              (lex_flags & C_LEX_STRING_NO_TRANSLATE) == 0);
 430           break;
 431         }
 432       *value = build_string (tok->val.str.len, (const char *) tok->val.str.text);
 433       break;
 434
 435     case CPP_PRAGMA:
 436       *value = build_int_cst (NULL, tok->val.pragma);
 437       break;
 438
 439       /* These tokens should not be visible outside cpplib.  */
 440     case CPP_HEADER_NAME:
 441     case CPP_COMMENT:
 442     case CPP_MACRO_ARG:
 443       gcc_unreachable ();
 444
 445     default:
 446       *value = NULL_TREE;
 447       break;
 448     }
 449
 450   if (cpp_flags)
 451     *cpp_flags = tok->flags | add_flags;
 452
 453   if (!no_more_pch)
 454     {
 455       no_more_pch = true;
 456       c_common_no_more_pch ();
 457     }
 458
 459   timevar_pop (TV_CPP);
 460
 461   return type;
 462 }
 463
 464 /* Returns the narrowest C-visible unsigned type, starting with the
 465    minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
 466    there isn't one.  */
 467
 468 static enum integer_type_kind
 469 narrowest_unsigned_type (unsigned HOST_WIDE_INT low,
 470                          unsigned HOST_WIDE_INT high,
 471                          unsigned int flags)
 472 {
 473   int itk;
 474
 475   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 476     itk = itk_unsigned_int;
 477   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 478     itk = itk_unsigned_long;
 479   else
 480     itk = itk_unsigned_long_long;
 481
 482   for (; itk < itk_none; itk += 2 /* skip unsigned types */)
 483     {
 484       tree upper = TYPE_MAX_VALUE (integer_types[itk]);
 485
 486       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
 487           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
 488               && TREE_INT_CST_LOW (upper) >= low))
 489         return (enum integer_type_kind) itk;
 490     }
 491
 492   return itk_none;
 493 }
 494
 495 /* Ditto, but narrowest signed type.  */
 496 static enum integer_type_kind
 497 narrowest_signed_type (unsigned HOST_WIDE_INT low,
 498                        unsigned HOST_WIDE_INT high, unsigned int flags)
 499 {
 500   int itk;
 501
 502   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 503     itk = itk_int;
 504   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 505     itk = itk_long;
 506   else
 507     itk = itk_long_long;
 508
 509
 510   for (; itk < itk_none; itk += 2 /* skip signed types */)
 511     {
 512       tree upper = TYPE_MAX_VALUE (integer_types[itk]);
 513
 514       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
 515           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
 516               && TREE_INT_CST_LOW (upper) >= low))
 517         return (enum integer_type_kind) itk;
 518     }
 519
 520   return itk_none;
 521 }
 522
 523 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib.  */
 524 static tree
 525 interpret_integer (const cpp_token *token, unsigned int flags)
 526 {
 527   tree value, type;
 528   enum integer_type_kind itk;
 529   cpp_num integer;
 530   cpp_options *options = cpp_get_options (parse_in);
 531
 532   integer = cpp_interpret_integer (parse_in, token, flags);
 533   integer = cpp_num_sign_extend (integer, options->precision);
 534
 535   /* The type of a constant with a U suffix is straightforward.  */
 536   if (flags & CPP_N_UNSIGNED)
 537     itk = narrowest_unsigned_type (integer.low, integer.high, flags);
 538   else
 539     {
 540       /* The type of a potentially-signed integer constant varies
 541          depending on the base it's in, the standard in use, and the
 542          length suffixes.  */
 543       enum integer_type_kind itk_u
 544         = narrowest_unsigned_type (integer.low, integer.high, flags);
 545       enum integer_type_kind itk_s
 546         = narrowest_signed_type (integer.low, integer.high, flags);
 547
 548       /* In both C89 and C99, octal and hex constants may be signed or
 549          unsigned, whichever fits tighter.  We do not warn about this
 550          choice differing from the traditional choice, as the constant
 551          is probably a bit pattern and either way will work.  */
 552       if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
 553         itk = MIN (itk_u, itk_s);
 554       else
 555         {
 556           /* In C99, decimal constants are always signed.
 557              In C89, decimal constants that don't fit in long have
 558              undefined behavior; we try to make them unsigned long.
 559              In GCC's extended C89, that last is true of decimal
 560              constants that don't fit in long long, too.  */
 561
 562           itk = itk_s;
 563           if (itk_s > itk_u && itk_s > itk_long)
 564             {
 565               if (!flag_isoc99)
 566                 {
 567                   if (itk_u < itk_unsigned_long)
 568                     itk_u = itk_unsigned_long;
 569                   itk = itk_u;
 570                   warning (0, "this decimal constant is unsigned only in ISO C90");
 571                 }
 572               else
 573                 warning (OPT_Wtraditional,
 574                          "this decimal constant would be unsigned in ISO C90");
 575             }
 576         }
 577     }
 578
 579   if (itk == itk_none)
 580     /* cpplib has already issued a warning for overflow.  */
 581     type = ((flags & CPP_N_UNSIGNED)
 582             ? widest_unsigned_literal_type_node
 583             : widest_integer_literal_type_node);
 584   else
 585     {
 586       type = integer_types[itk];
 587       if (itk > itk_unsigned_long
 588           && (flags & CPP_N_WIDTH) != CPP_N_LARGE)
 589         emit_diagnostic
 590           ((c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99)
 591            ? DK_PEDWARN : DK_WARNING,
 592            input_location, OPT_Wlong_long,
 593            (flags & CPP_N_UNSIGNED)
 594            ? "integer constant is too large for %<unsigned long%> type"
 595            : "integer constant is too large for %<long%> type");
 596     }
 597
 598   value = build_int_cst_wide (type, integer.low, integer.high);
 599
 600   /* Convert imaginary to a complex type.  */
 601   if (flags & CPP_N_IMAGINARY)
 602     value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
 603
 604   return value;
 605 }
 606
 607 /* Interpret TOKEN, a floating point number with FLAGS as classified
 608    by cpplib.  */
 609 static tree
 610 interpret_float (const cpp_token *token, unsigned int flags)
 611 {
 612   tree type;
 613   tree const_type;
 614   tree value;
 615   REAL_VALUE_TYPE real;
 616   REAL_VALUE_TYPE real_trunc;
 617   char *copy;
 618   size_t copylen;
 619
 620   /* Default (no suffix) depends on whether the FLOAT_CONST_DECIMAL64
 621      pragma has been used and is either double or _Decimal64.  Types
 622      that are not allowed with decimal float default to double.  */
 623   if (flags & CPP_N_DEFAULT)
 624     {
 625       flags ^= CPP_N_DEFAULT;
 626       flags |= CPP_N_MEDIUM;
 627
 628       if (((flags & CPP_N_HEX) == 0) && ((flags & CPP_N_IMAGINARY) == 0))
 629         {
 630           warning (OPT_Wunsuffixed_float_constants,
 631                    "unsuffixed float constant");
 632           if (float_const_decimal64_p ())
 633             flags |= CPP_N_DFLOAT;
 634         }
 635     }
 636
 637   /* Decode _Fract and _Accum.  */
 638   if (flags & CPP_N_FRACT || flags & CPP_N_ACCUM)
 639     return interpret_fixed (token, flags);
 640
 641   /* Decode type based on width and properties. */
 642   if (flags & CPP_N_DFLOAT)
 643     if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 644       type = dfloat128_type_node;
 645     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 646       type = dfloat32_type_node;
 647     else
 648       type = dfloat64_type_node;
 649   else
 650     if (flags & CPP_N_WIDTH_MD)
 651       {
 652         char suffix;
 653         enum machine_mode mode;
 654
 655         if ((flags & CPP_N_WIDTH_MD) == CPP_N_MD_W)
 656           suffix = 'w';
 657         else
 658           suffix = 'q';
 659
 660         mode = targetm.c.mode_for_suffix (suffix);
 661         if (mode == VOIDmode)
 662           {
 663             error ("unsupported non-standard suffix on floating constant");
 664             errorcount++;
 665
 666             return error_mark_node;
 667           }
 668         else
 669           pedwarn (input_location, OPT_pedantic, "non-standard suffix on floating constant");
 670
 671         type = c_common_type_for_mode (mode, 0);
 672         gcc_assert (type);
 673       }
 674     else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 675       type = long_double_type_node;
 676     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
 677              || flag_single_precision_constant)
 678       type = float_type_node;
 679     else
 680       type = double_type_node;
 681
 682   const_type = excess_precision_type (type);
 683   if (!const_type)
 684     const_type = type;
 685
 686   /* Copy the constant to a nul-terminated buffer.  If the constant
 687      has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
 688      can't handle them.  */
 689   copylen = token->val.str.len;
 690   if (flags & CPP_N_DFLOAT)
 691     copylen -= 2;
 692   else
 693     {
 694       if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
 695         /* Must be an F or L or machine defined suffix.  */
 696         copylen--;
 697       if (flags & CPP_N_IMAGINARY)
 698         /* I or J suffix.  */
 699         copylen--;
 700     }
 701
 702   copy = (char *) alloca (copylen + 1);
 703   memcpy (copy, token->val.str.text, copylen);
 704   copy[copylen] = '\0';
 705
 706   real_from_string3 (&real, copy, TYPE_MODE (const_type));
 707   if (const_type != type)
 708     /* Diagnosing if the result of converting the value with excess
 709        precision to the semantic type would overflow (with associated
 710        double rounding) is more appropriate than diagnosing if the
 711        result of converting the string directly to the semantic type
 712        would overflow.  */
 713     real_convert (&real_trunc, TYPE_MODE (type), &real);
 714
 715   /* Both C and C++ require a diagnostic for a floating constant
 716      outside the range of representable values of its type.  Since we
 717      have __builtin_inf* to produce an infinity, this is now a
 718      mandatory pedwarn if the target does not support infinities.  */
 719   if (REAL_VALUE_ISINF (real)
 720       || (const_type != type && REAL_VALUE_ISINF (real_trunc)))
 721     {
 722       if (!MODE_HAS_INFINITIES (TYPE_MODE (type)))
 723         pedwarn (input_location, 0, "floating constant exceeds range of %qT", type);
 724       else
 725         warning (OPT_Woverflow, "floating constant exceeds range of %qT", type);
 726     }
 727   /* We also give a warning if the value underflows.  */
 728   else if (REAL_VALUES_EQUAL (real, dconst0)
 729            || (const_type != type && REAL_VALUES_EQUAL (real_trunc, dconst0)))
 730     {
 731       REAL_VALUE_TYPE realvoidmode;
 732       int overflow = real_from_string (&realvoidmode, copy);
 733       if (overflow < 0 || !REAL_VALUES_EQUAL (realvoidmode, dconst0))
 734         warning (OPT_Woverflow, "floating constant truncated to zero");
 735     }
 736
 737   /* Create a node with determined type and value.  */
 738   value = build_real (const_type, real);
 739   if (flags & CPP_N_IMAGINARY)
 740     value = build_complex (NULL_TREE, convert (const_type, integer_zero_node),
 741                            value);
 742
 743   if (type != const_type)
 744     value = build1 (EXCESS_PRECISION_EXPR, type, value);
 745
 746   return value;
 747 }
 748
 749 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
 750    by cpplib.  */
 751
 752 static tree
 753 interpret_fixed (const cpp_token *token, unsigned int flags)
 754 {
 755   tree type;
 756   tree value;
 757   FIXED_VALUE_TYPE fixed;
 758   char *copy;
 759   size_t copylen;
 760
 761   copylen = token->val.str.len;
 762
 763   if (flags & CPP_N_FRACT) /* _Fract.  */
 764     {
 765       if (flags & CPP_N_UNSIGNED) /* Unsigned _Fract.  */
 766         {
 767           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 768             {
 769               type = unsigned_long_long_fract_type_node;
 770               copylen -= 4;
 771             }
 772           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 773             {
 774               type = unsigned_long_fract_type_node;
 775               copylen -= 3;
 776             }
 777           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 778             {
 779               type = unsigned_short_fract_type_node;
 780               copylen -= 3;
 781             }
 782           else
 783             {
 784               type = unsigned_fract_type_node;
 785               copylen -= 2;
 786             }
 787         }
 788       else /* Signed _Fract.  */
 789         {
 790           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 791             {
 792               type = long_long_fract_type_node;
 793               copylen -= 3;
 794             }
 795           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 796             {
 797               type = long_fract_type_node;
 798               copylen -= 2;
 799             }
 800           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 801             {
 802               type = short_fract_type_node;
 803               copylen -= 2;
 804             }
 805           else
 806             {
 807               type = fract_type_node;
 808               copylen --;
 809             }
 810           }
 811     }
 812   else /* _Accum.  */
 813     {
 814       if (flags & CPP_N_UNSIGNED) /* Unsigned _Accum.  */
 815         {
 816           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 817             {
 818               type = unsigned_long_long_accum_type_node;
 819               copylen -= 4;
 820             }
 821           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 822             {
 823               type = unsigned_long_accum_type_node;
 824               copylen -= 3;
 825             }
 826           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 827             {
 828               type = unsigned_short_accum_type_node;
 829               copylen -= 3;
 830              }
 831           else
 832             {
 833               type = unsigned_accum_type_node;
 834               copylen -= 2;
 835             }
 836         }
 837       else /* Signed _Accum.  */
 838         {
 839           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 840             {
 841               type = long_long_accum_type_node;
 842               copylen -= 3;
 843             }
 844           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 845             {
 846               type = long_accum_type_node;
 847               copylen -= 2;
 848             }
 849           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 850             {
 851               type = short_accum_type_node;
 852               copylen -= 2;
 853             }
 854           else
 855             {
 856               type = accum_type_node;
 857               copylen --;
 858             }
 859         }
 860     }
 861
 862   copy = (char *) alloca (copylen + 1);
 863   memcpy (copy, token->val.str.text, copylen);
 864   copy[copylen] = '\0';
 865
 866   fixed_from_string (&fixed, copy, TYPE_MODE (type));
 867
 868   /* Create a node with determined type and value.  */
 869   value = build_fixed (type, fixed);
 870
 871   return value;
 872 }
 873
 874 /* Convert a series of STRING, WSTRING, STRING16 and/or STRING32 tokens
 875    into a tree, performing string constant concatenation.  TOK is the
 876    first of these.  VALP is the location to write the string into.
 877    OBJC_STRING indicates whether an '@' token preceded the incoming token.
 878    Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
 879    CPP_STRING32, CPP_STRING16, 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       if (type != tok->type)
 925         {
 926           if (type == CPP_STRING)
 927             type = tok->type;
 928           else
 929             error ("unsupported non-standard concatenation of string literals");
 930         }
 931
 932     case CPP_STRING:
 933       if (!concats)
 934         {
 935           gcc_obstack_init (&str_ob);
 936           obstack_grow (&str_ob, &str, sizeof (cpp_string));
 937         }
 938
 939       concats++;
 940       obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
 941       goto retry;
 942     }
 943
 944   /* We have read one more token than we want.  */
 945   _cpp_backup_tokens (parse_in, 1);
 946   if (concats)
 947     strs = XOBFINISH (&str_ob, cpp_string *);
 948
 949   if (concats && !objc_string && !in_system_header)
 950     warning (OPT_Wtraditional,
 951              "traditional C rejects string constant concatenation");
 952
 953   if ((translate
 954        ? cpp_interpret_string : cpp_interpret_string_notranslate)
 955       (parse_in, strs, concats + 1, &istr, type))
 956     {
 957       value = build_string (istr.len, (const char *) istr.text);
 958       free (CONST_CAST (unsigned char *, istr.text));
 959     }
 960   else
 961     {
 962       /* Callers cannot generally handle error_mark_node in this context,
 963          so return the empty string instead.  cpp_interpret_string has
 964          issued an error.  */
 965       switch (type)
 966         {
 967         default:
 968         case CPP_STRING:
 969           value = build_string (1, "");
 970           break;
 971         case CPP_STRING16:
 972           value = build_string (TYPE_PRECISION (char16_type_node)
 973                                 / TYPE_PRECISION (char_type_node),
 974                                 "\0");  /* char16_t is 16 bits */
 975           break;
 976         case CPP_STRING32:
 977           value = build_string (TYPE_PRECISION (char32_type_node)
 978                                 / TYPE_PRECISION (char_type_node),
 979                                 "\0\0\0");  /* char32_t is 32 bits */
 980           break;
 981         case CPP_WSTRING:
 982           value = build_string (TYPE_PRECISION (wchar_type_node)
 983                                 / TYPE_PRECISION (char_type_node),
 984                                 "\0\0\0");  /* widest supported wchar_t
 985                                                is 32 bits */
 986           break;
 987         }
 988     }
 989
 990   switch (type)
 991     {
 992     default:
 993     case CPP_STRING:
 994       TREE_TYPE (value) = char_array_type_node;
 995       break;
 996     case CPP_STRING16:
 997       TREE_TYPE (value) = char16_array_type_node;
 998       break;
 999     case CPP_STRING32:
1000       TREE_TYPE (value) = char32_array_type_node;
1001       break;
1002     case CPP_WSTRING:
1003       TREE_TYPE (value) = wchar_array_type_node;
1004     }
1005   *valp = fix_string_type (value);
1006
1007   if (concats)
1008     obstack_free (&str_ob, 0);
1009
1010   return objc_string ? CPP_OBJC_STRING : type;
1011 }
1012
1013 /* Converts a (possibly wide) character constant token into a tree.  */
1014 static tree
1015 lex_charconst (const cpp_token *token)
1016 {
1017   cppchar_t result;
1018   tree type, value;
1019   unsigned int chars_seen;
1020   int unsignedp = 0;
1021
1022   result = cpp_interpret_charconst (parse_in, token,
1023                                     &chars_seen, &unsignedp);
1024
1025   if (token->type == CPP_WCHAR)
1026     type = wchar_type_node;
1027   else if (token->type == CPP_CHAR32)
1028     type = char32_type_node;
1029   else if (token->type == CPP_CHAR16)
1030     type = char16_type_node;
1031   /* In C, a character constant has type 'int'.
1032      In C++ 'char', but multi-char charconsts have type 'int'.  */
1033   else if (!c_dialect_cxx () || chars_seen > 1)
1034     type = integer_type_node;
1035   else
1036     type = char_type_node;
1037
1038   /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1039      before possibly widening to HOST_WIDE_INT for build_int_cst.  */
1040   if (unsignedp || (cppchar_signed_t) result >= 0)
1041     value = build_int_cst_wide (type, result, 0);
1042   else
1043     value = build_int_cst_wide (type, (cppchar_signed_t) result, -1);
1044
1045   return value;
1046 }