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 (OPT_Wunknown_pragmas, "%Hignoring #pragma %s %s",
 268                &fe_loc, 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));
 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));
 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 ("%Hstray %<@%> in program", &atloc);
 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[4];
 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     type = integer_types[itk];
 586
 587   if (itk > itk_unsigned_long
 588       && (flags & CPP_N_WIDTH) != CPP_N_LARGE
 589       && !in_system_header && !flag_isoc99)
 590     pedwarn (input_location, 0, "integer constant is too large for %qs type",
 591              (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long");
 592
 593   value = build_int_cst_wide (type, integer.low, integer.high);
 594
 595   /* Convert imaginary to a complex type.  */
 596   if (flags & CPP_N_IMAGINARY)
 597     value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
 598
 599   return value;
 600 }
 601
 602 /* Interpret TOKEN, a floating point number with FLAGS as classified
 603    by cpplib.  */
 604 static tree
 605 interpret_float (const cpp_token *token, unsigned int flags)
 606 {
 607   tree type;
 608   tree const_type;
 609   tree value;
 610   REAL_VALUE_TYPE real;
 611   REAL_VALUE_TYPE real_trunc;
 612   char *copy;
 613   size_t copylen;
 614
 615   /* Default (no suffix) is double.  */
 616   if (flags & CPP_N_DEFAULT)
 617     {
 618       flags ^= CPP_N_DEFAULT;
 619       flags |= CPP_N_MEDIUM;
 620     }
 621
 622   /* Decode _Fract and _Accum.  */
 623   if (flags & CPP_N_FRACT || flags & CPP_N_ACCUM)
 624     return interpret_fixed (token, flags);
 625
 626   /* Decode type based on width and properties. */
 627   if (flags & CPP_N_DFLOAT)
 628     if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 629       type = dfloat128_type_node;
 630     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 631       type = dfloat32_type_node;
 632     else
 633       type = dfloat64_type_node;
 634   else
 635     if (flags & CPP_N_WIDTH_MD)
 636       {
 637         char suffix;
 638         enum machine_mode mode;
 639
 640         if ((flags & CPP_N_WIDTH_MD) == CPP_N_MD_W)
 641           suffix = 'w';
 642         else
 643           suffix = 'q';
 644
 645         mode = targetm.c.mode_for_suffix (suffix);
 646         if (mode == VOIDmode)
 647           {
 648             error ("unsupported non-standard suffix on floating constant");
 649             errorcount++;
 650
 651             return error_mark_node;
 652           }
 653         else
 654           pedwarn (input_location, OPT_pedantic, "non-standard suffix on floating constant");
 655
 656         type = c_common_type_for_mode (mode, 0);
 657         gcc_assert (type);
 658       }
 659     else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 660       type = long_double_type_node;
 661     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
 662              || flag_single_precision_constant)
 663       type = float_type_node;
 664     else
 665       type = double_type_node;
 666
 667   const_type = excess_precision_type (type);
 668   if (!const_type)
 669     const_type = type;
 670
 671   /* Copy the constant to a nul-terminated buffer.  If the constant
 672      has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
 673      can't handle them.  */
 674   copylen = token->val.str.len;
 675   if (flags & CPP_N_DFLOAT)
 676     copylen -= 2;
 677   else
 678     {
 679       if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
 680         /* Must be an F or L or machine defined suffix.  */
 681         copylen--;
 682       if (flags & CPP_N_IMAGINARY)
 683         /* I or J suffix.  */
 684         copylen--;
 685     }
 686
 687   copy = (char *) alloca (copylen + 1);
 688   memcpy (copy, token->val.str.text, copylen);
 689   copy[copylen] = '\0';
 690
 691   real_from_string3 (&real, copy, TYPE_MODE (const_type));
 692   if (const_type != type)
 693     /* Diagnosing if the result of converting the value with excess
 694        precision to the semantic type would overflow (with associated
 695        double rounding) is more appropriate than diagnosing if the
 696        result of converting the string directly to the semantic type
 697        would overflow.  */
 698     real_convert (&real_trunc, TYPE_MODE (type), &real);
 699
 700   /* Both C and C++ require a diagnostic for a floating constant
 701      outside the range of representable values of its type.  Since we
 702      have __builtin_inf* to produce an infinity, this is now a
 703      mandatory pedwarn if the target does not support infinities.  */
 704   if (REAL_VALUE_ISINF (real)
 705       || (const_type != type && REAL_VALUE_ISINF (real_trunc)))
 706     {
 707       if (!MODE_HAS_INFINITIES (TYPE_MODE (type)))
 708         pedwarn (input_location, 0, "floating constant exceeds range of %qT", type);
 709       else
 710         warning (OPT_Woverflow, "floating constant exceeds range of %qT", type);
 711     }
 712   /* We also give a warning if the value underflows.  */
 713   else if (REAL_VALUES_EQUAL (real, dconst0)
 714            || (const_type != type && REAL_VALUES_EQUAL (real_trunc, dconst0)))
 715     {
 716       REAL_VALUE_TYPE realvoidmode;
 717       int overflow = real_from_string (&realvoidmode, copy);
 718       if (overflow < 0 || !REAL_VALUES_EQUAL (realvoidmode, dconst0))
 719         warning (OPT_Woverflow, "floating constant truncated to zero");
 720     }
 721
 722   /* Create a node with determined type and value.  */
 723   value = build_real (const_type, real);
 724   if (flags & CPP_N_IMAGINARY)
 725     value = build_complex (NULL_TREE, convert (const_type, integer_zero_node),
 726                            value);
 727
 728   if (type != const_type)
 729     value = build1 (EXCESS_PRECISION_EXPR, type, value);
 730
 731   return value;
 732 }
 733
 734 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
 735    by cpplib.  */
 736
 737 static tree
 738 interpret_fixed (const cpp_token *token, unsigned int flags)
 739 {
 740   tree type;
 741   tree value;
 742   FIXED_VALUE_TYPE fixed;
 743   char *copy;
 744   size_t copylen;
 745
 746   copylen = token->val.str.len;
 747
 748   if (flags & CPP_N_FRACT) /* _Fract.  */
 749     {
 750       if (flags & CPP_N_UNSIGNED) /* Unsigned _Fract.  */
 751         {
 752           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 753             {
 754               type = unsigned_long_long_fract_type_node;
 755               copylen -= 4;
 756             }
 757           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 758             {
 759               type = unsigned_long_fract_type_node;
 760               copylen -= 3;
 761             }
 762           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 763             {
 764               type = unsigned_short_fract_type_node;
 765               copylen -= 3;
 766             }
 767           else
 768             {
 769               type = unsigned_fract_type_node;
 770               copylen -= 2;
 771             }
 772         }
 773       else /* Signed _Fract.  */
 774         {
 775           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 776             {
 777               type = long_long_fract_type_node;
 778               copylen -= 3;
 779             }
 780           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 781             {
 782               type = long_fract_type_node;
 783               copylen -= 2;
 784             }
 785           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 786             {
 787               type = short_fract_type_node;
 788               copylen -= 2;
 789             }
 790           else
 791             {
 792               type = fract_type_node;
 793               copylen --;
 794             }
 795           }
 796     }
 797   else /* _Accum.  */
 798     {
 799       if (flags & CPP_N_UNSIGNED) /* Unsigned _Accum.  */
 800         {
 801           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 802             {
 803               type = unsigned_long_long_accum_type_node;
 804               copylen -= 4;
 805             }
 806           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 807             {
 808               type = unsigned_long_accum_type_node;
 809               copylen -= 3;
 810             }
 811           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 812             {
 813               type = unsigned_short_accum_type_node;
 814               copylen -= 3;
 815              }
 816           else
 817             {
 818               type = unsigned_accum_type_node;
 819               copylen -= 2;
 820             }
 821         }
 822       else /* Signed _Accum.  */
 823         {
 824           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 825             {
 826               type = long_long_accum_type_node;
 827               copylen -= 3;
 828             }
 829           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 830             {
 831               type = long_accum_type_node;
 832               copylen -= 2;
 833             }
 834           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 835             {
 836               type = short_accum_type_node;
 837               copylen -= 2;
 838             }
 839           else
 840             {
 841               type = accum_type_node;
 842               copylen --;
 843             }
 844         }
 845     }
 846
 847   copy = (char *) alloca (copylen + 1);
 848   memcpy (copy, token->val.str.text, copylen);
 849   copy[copylen] = '\0';
 850
 851   fixed_from_string (&fixed, copy, TYPE_MODE (type));
 852
 853   /* Create a node with determined type and value.  */
 854   value = build_fixed (type, fixed);
 855
 856   return value;
 857 }
 858
 859 /* Convert a series of STRING, WSTRING, STRING16 and/or STRING32 tokens
 860    into a tree, performing string constant concatenation.  TOK is the
 861    first of these.  VALP is the location to write the string into.
 862    OBJC_STRING indicates whether an '@' token preceded the incoming token.
 863    Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
 864    CPP_STRING32, CPP_STRING16, or CPP_OBJC_STRING).
 865
 866    This is unfortunately more work than it should be.  If any of the
 867    strings in the series has an L prefix, the result is a wide string
 868    (6.4.5p4).  Whether or not the result is a wide string affects the
 869    meaning of octal and hexadecimal escapes (6.4.4.4p6,9).  But escape
 870    sequences do not continue across the boundary between two strings in
 871    a series (6.4.5p7), so we must not lose the boundaries.  Therefore
 872    cpp_interpret_string takes a vector of cpp_string structures, which
 873    we must arrange to provide.  */
 874
 875 static enum cpp_ttype
 876 lex_string (const cpp_token *tok, tree *valp, bool objc_string, bool translate)
 877 {
 878   tree value;
 879   size_t concats = 0;
 880   struct obstack str_ob;
 881   cpp_string istr;
 882   enum cpp_ttype type = tok->type;
 883
 884   /* Try to avoid the overhead of creating and destroying an obstack
 885      for the common case of just one string.  */
 886   cpp_string str = tok->val.str;
 887   cpp_string *strs = &str;
 888
 889  retry:
 890   tok = cpp_get_token (parse_in);
 891   switch (tok->type)
 892     {
 893     case CPP_PADDING:
 894       goto retry;
 895     case CPP_ATSIGN:
 896       if (c_dialect_objc ())
 897         {
 898           objc_string = true;
 899           goto retry;
 900         }
 901       /* FALLTHROUGH */
 902
 903     default:
 904       break;
 905
 906     case CPP_WSTRING:
 907     case CPP_STRING16:
 908     case CPP_STRING32:
 909       if (type != tok->type)
 910         {
 911           if (type == CPP_STRING)
 912             type = tok->type;
 913           else
 914             error ("unsupported non-standard concatenation of string literals");
 915         }
 916
 917     case CPP_STRING:
 918       if (!concats)
 919         {
 920           gcc_obstack_init (&str_ob);
 921           obstack_grow (&str_ob, &str, sizeof (cpp_string));
 922         }
 923
 924       concats++;
 925       obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
 926       goto retry;
 927     }
 928
 929   /* We have read one more token than we want.  */
 930   _cpp_backup_tokens (parse_in, 1);
 931   if (concats)
 932     strs = XOBFINISH (&str_ob, cpp_string *);
 933
 934   if (concats && !objc_string && !in_system_header)
 935     warning (OPT_Wtraditional,
 936              "traditional C rejects string constant concatenation");
 937
 938   if ((translate
 939        ? cpp_interpret_string : cpp_interpret_string_notranslate)
 940       (parse_in, strs, concats + 1, &istr, type))
 941     {
 942       value = build_string (istr.len, (const char *) istr.text);
 943       free (CONST_CAST (unsigned char *, istr.text));
 944     }
 945   else
 946     {
 947       /* Callers cannot generally handle error_mark_node in this context,
 948          so return the empty string instead.  cpp_interpret_string has
 949          issued an error.  */
 950       switch (type)
 951         {
 952         default:
 953         case CPP_STRING:
 954           value = build_string (1, "");
 955           break;
 956         case CPP_STRING16:
 957           value = build_string (TYPE_PRECISION (char16_type_node)
 958                                 / TYPE_PRECISION (char_type_node),
 959                                 "\0");  /* char16_t is 16 bits */
 960           break;
 961         case CPP_STRING32:
 962           value = build_string (TYPE_PRECISION (char32_type_node)
 963                                 / TYPE_PRECISION (char_type_node),
 964                                 "\0\0\0");  /* char32_t is 32 bits */
 965           break;
 966         case CPP_WSTRING:
 967           value = build_string (TYPE_PRECISION (wchar_type_node)
 968                                 / TYPE_PRECISION (char_type_node),
 969                                 "\0\0\0");  /* widest supported wchar_t
 970                                                is 32 bits */
 971           break;
 972         }
 973     }
 974
 975   switch (type)
 976     {
 977     default:
 978     case CPP_STRING:
 979       TREE_TYPE (value) = char_array_type_node;
 980       break;
 981     case CPP_STRING16:
 982       TREE_TYPE (value) = char16_array_type_node;
 983       break;
 984     case CPP_STRING32:
 985       TREE_TYPE (value) = char32_array_type_node;
 986       break;
 987     case CPP_WSTRING:
 988       TREE_TYPE (value) = wchar_array_type_node;
 989     }
 990   *valp = fix_string_type (value);
 991
 992   if (concats)
 993     obstack_free (&str_ob, 0);
 994
 995   return objc_string ? CPP_OBJC_STRING : type;
 996 }
 997
 998 /* Converts a (possibly wide) character constant token into a tree.  */
 999 static tree
1000 lex_charconst (const cpp_token *token)
1001 {
1002   cppchar_t result;
1003   tree type, value;
1004   unsigned int chars_seen;
1005   int unsignedp = 0;
1006
1007   result = cpp_interpret_charconst (parse_in, token,
1008                                     &chars_seen, &unsignedp);
1009
1010   if (token->type == CPP_WCHAR)
1011     type = wchar_type_node;
1012   else if (token->type == CPP_CHAR32)
1013     type = char32_type_node;
1014   else if (token->type == CPP_CHAR16)
1015     type = char16_type_node;
1016   /* In C, a character constant has type 'int'.
1017      In C++ 'char', but multi-char charconsts have type 'int'.  */
1018   else if (!c_dialect_cxx () || chars_seen > 1)
1019     type = integer_type_node;
1020   else
1021     type = char_type_node;
1022
1023   /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1024      before possibly widening to HOST_WIDE_INT for build_int_cst.  */
1025   if (unsignedp || (cppchar_signed_t) result >= 0)
1026     value = build_int_cst_wide (type, result, 0);
1027   else
1028     value = build_int_cst_wide (type, (cppchar_signed_t) result, -1);
1029
1030   return value;
1031 }