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
   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 /* If we need to translate characters received.  This is tri-state:
  53    0 means use only the untranslated string; 1 means use only
  54    the translated string; -1 means chain the translated string
  55    to the untranslated one.  */
  56 int c_lex_string_translate = 1;
  57
  58 /* True if strings should be passed to the caller of c_lex completely
  59    unmolested (no concatenation, no translation).  */
  60 bool c_lex_return_raw_strings = false;
  61
  62 static tree interpret_integer (const cpp_token *, unsigned int);
  63 static tree interpret_float (const cpp_token *, unsigned int);
  64 static enum integer_type_kind narrowest_unsigned_type
  65         (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
  66 static enum integer_type_kind narrowest_signed_type
  67         (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
  68 static enum cpp_ttype lex_string (const cpp_token *, tree *, bool);
  69 static tree lex_charconst (const cpp_token *);
  70 static void update_header_times (const char *);
  71 static int dump_one_header (splay_tree_node, void *);
  72 static void cb_line_change (cpp_reader *, const cpp_token *, int);
  73 static void cb_ident (cpp_reader *, unsigned int, const cpp_string *);
  74 static void cb_def_pragma (cpp_reader *, unsigned int);
  75 static void cb_define (cpp_reader *, unsigned int, cpp_hashnode *);
  76 static void cb_undef (cpp_reader *, unsigned int, cpp_hashnode *);
  77 \f
  78 void
  79 init_c_lex (void)
  80 {
  81   struct cpp_callbacks *cb;
  82   struct c_fileinfo *toplevel;
  83
  84   /* The get_fileinfo data structure must be initialized before
  85      cpp_read_main_file is called.  */
  86   toplevel = get_fileinfo ("<top level>");
  87   if (flag_detailed_statistics)
  88     {
  89       header_time = 0;
  90       body_time = get_run_time ();
  91       toplevel->time = body_time;
  92     }
  93
  94   cb = cpp_get_callbacks (parse_in);
  95
  96   cb->line_change = cb_line_change;
  97   cb->ident = cb_ident;
  98   cb->def_pragma = cb_def_pragma;
  99   cb->valid_pch = c_common_valid_pch;
 100   cb->read_pch = c_common_read_pch;
 101
 102   /* Set the debug callbacks if we can use them.  */
 103   if (debug_info_level == DINFO_LEVEL_VERBOSE
 104       && (write_symbols == DWARF2_DEBUG
 105           || write_symbols == VMS_AND_DWARF2_DEBUG))
 106     {
 107       cb->define = cb_define;
 108       cb->undef = cb_undef;
 109     }
 110 }
 111
 112 struct c_fileinfo *
 113 get_fileinfo (const char *name)
 114 {
 115   splay_tree_node n;
 116   struct c_fileinfo *fi;
 117
 118   if (!file_info_tree)
 119     file_info_tree = splay_tree_new ((splay_tree_compare_fn) strcmp,
 120                                      0,
 121                                      (splay_tree_delete_value_fn) free);
 122
 123   n = splay_tree_lookup (file_info_tree, (splay_tree_key) name);
 124   if (n)
 125     return (struct c_fileinfo *) n->value;
 126
 127   fi = XNEW (struct c_fileinfo);
 128   fi->time = 0;
 129   fi->interface_only = 0;
 130   fi->interface_unknown = 1;
 131   splay_tree_insert (file_info_tree, (splay_tree_key) name,
 132                      (splay_tree_value) fi);
 133   return fi;
 134 }
 135
 136 static void
 137 update_header_times (const char *name)
 138 {
 139   /* Changing files again.  This means currently collected time
 140      is charged against header time, and body time starts back at 0.  */
 141   if (flag_detailed_statistics)
 142     {
 143       int this_time = get_run_time ();
 144       struct c_fileinfo *file = get_fileinfo (name);
 145       header_time += this_time - body_time;
 146       file->time += this_time - body_time;
 147       body_time = this_time;
 148     }
 149 }
 150
 151 static int
 152 dump_one_header (splay_tree_node n, void * ARG_UNUSED (dummy))
 153 {
 154   print_time ((const char *) n->key,
 155               ((struct c_fileinfo *) n->value)->time);
 156   return 0;
 157 }
 158
 159 void
 160 dump_time_statistics (void)
 161 {
 162   struct c_fileinfo *file = get_fileinfo (input_filename);
 163   int this_time = get_run_time ();
 164   file->time += this_time - body_time;
 165
 166   fprintf (stderr, "\n******\n");
 167   print_time ("header files (total)", header_time);
 168   print_time ("main file (total)", this_time - body_time);
 169   fprintf (stderr, "ratio = %g : 1\n",
 170            (double) header_time / (double) (this_time - body_time));
 171   fprintf (stderr, "\n******\n");
 172
 173   splay_tree_foreach (file_info_tree, dump_one_header, 0);
 174 }
 175
 176 static void
 177 cb_ident (cpp_reader * ARG_UNUSED (pfile),
 178           unsigned int ARG_UNUSED (line),
 179           const cpp_string * ARG_UNUSED (str))
 180 {
 181 #ifdef ASM_OUTPUT_IDENT
 182   if (!flag_no_ident)
 183     {
 184       /* Convert escapes in the string.  */
 185       cpp_string cstr = { 0, 0 };
 186       if (cpp_interpret_string (pfile, str, 1, &cstr, false))
 187         {
 188           ASM_OUTPUT_IDENT (asm_out_file, (const char *) cstr.text);
 189           free (CONST_CAST (cstr.text));
 190         }
 191     }
 192 #endif
 193 }
 194
 195 /* Called at the start of every non-empty line.  TOKEN is the first
 196    lexed token on the line.  Used for diagnostic line numbers.  */
 197 static void
 198 cb_line_change (cpp_reader * ARG_UNUSED (pfile), const cpp_token *token,
 199                 int parsing_args)
 200 {
 201   if (token->type != CPP_EOF && !parsing_args)
 202 #ifdef USE_MAPPED_LOCATION
 203     input_location = token->src_loc;
 204 #else
 205     {
 206       source_location loc = token->src_loc;
 207       const struct line_map *map = linemap_lookup (&line_table, loc);
 208       input_line = SOURCE_LINE (map, loc);
 209     }
 210 #endif
 211 }
 212
 213 void
 214 fe_file_change (const struct line_map *new_map)
 215 {
 216   if (new_map == NULL)
 217     return;
 218
 219   if (new_map->reason == LC_ENTER)
 220     {
 221       /* Don't stack the main buffer on the input stack;
 222          we already did in compile_file.  */
 223       if (!MAIN_FILE_P (new_map))
 224         {
 225 #ifdef USE_MAPPED_LOCATION
 226           int included_at = LAST_SOURCE_LINE_LOCATION (new_map - 1);
 227
 228           input_location = included_at;
 229           push_srcloc (new_map->start_location);
 230 #else
 231           int included_at = LAST_SOURCE_LINE (new_map - 1);
 232
 233           input_line = included_at;
 234           push_srcloc (new_map->to_file, 1);
 235 #endif
 236           (*debug_hooks->start_source_file) (included_at, new_map->to_file);
 237 #ifndef NO_IMPLICIT_EXTERN_C
 238           if (c_header_level)
 239             ++c_header_level;
 240           else if (new_map->sysp == 2)
 241             {
 242               c_header_level = 1;
 243               ++pending_lang_change;
 244             }
 245 #endif
 246         }
 247     }
 248   else if (new_map->reason == LC_LEAVE)
 249     {
 250 #ifndef NO_IMPLICIT_EXTERN_C
 251       if (c_header_level && --c_header_level == 0)
 252         {
 253           if (new_map->sysp == 2)
 254             warning (0, "badly nested C headers from preprocessor");
 255           --pending_lang_change;
 256         }
 257 #endif
 258       pop_srcloc ();
 259
 260       (*debug_hooks->end_source_file) (new_map->to_line);
 261     }
 262
 263   update_header_times (new_map->to_file);
 264   in_system_header = new_map->sysp != 0;
 265 #ifdef USE_MAPPED_LOCATION
 266   input_location = new_map->start_location;
 267 #else
 268   input_filename = new_map->to_file;
 269   input_line = new_map->to_line;
 270 #endif
 271 }
 272
 273 static void
 274 cb_def_pragma (cpp_reader *pfile, source_location loc)
 275 {
 276   /* Issue a warning message if we have been asked to do so.  Ignore
 277      unknown pragmas in system headers unless an explicit
 278      -Wunknown-pragmas has been given.  */
 279   if (warn_unknown_pragmas > in_system_header)
 280     {
 281       const unsigned char *space, *name;
 282       const cpp_token *s;
 283 #ifndef USE_MAPPED_LOCATION
 284       location_t fe_loc;
 285       const struct line_map *map = linemap_lookup (&line_table, loc);
 286       fe_loc.file = map->to_file;
 287       fe_loc.line = SOURCE_LINE (map, loc);
 288 #else
 289       location_t fe_loc = loc;
 290 #endif
 291
 292       space = name = (const unsigned char *) "";
 293       s = cpp_get_token (pfile);
 294       if (s->type != CPP_EOF)
 295         {
 296           space = cpp_token_as_text (pfile, s);
 297           s = cpp_get_token (pfile);
 298           if (s->type == CPP_NAME)
 299             name = cpp_token_as_text (pfile, s);
 300         }
 301
 302       warning (OPT_Wunknown_pragmas, "%Hignoring #pragma %s %s",
 303                &fe_loc, space, name);
 304     }
 305 }
 306
 307 /* #define callback for DWARF and DWARF2 debug info.  */
 308 static void
 309 cb_define (cpp_reader *pfile, source_location loc, cpp_hashnode *node)
 310 {
 311   const struct line_map *map = linemap_lookup (&line_table, loc);
 312   (*debug_hooks->define) (SOURCE_LINE (map, loc),
 313                           (const char *) cpp_macro_definition (pfile, node));
 314 }
 315
 316 /* #undef callback for DWARF and DWARF2 debug info.  */
 317 static void
 318 cb_undef (cpp_reader * ARG_UNUSED (pfile), source_location loc,
 319           cpp_hashnode *node)
 320 {
 321   const struct line_map *map = linemap_lookup (&line_table, loc);
 322   (*debug_hooks->undef) (SOURCE_LINE (map, loc),
 323                          (const char *) NODE_NAME (node));
 324 }
 325 \f
 326 /* Read a token and return its type.  Fill *VALUE with its value, if
 327    applicable.  Fill *CPP_FLAGS with the token's flags, if it is
 328    non-NULL.  */
 329
 330 enum cpp_ttype
 331 c_lex_with_flags (tree *value, location_t *loc, unsigned char *cpp_flags)
 332 {
 333   static bool no_more_pch;
 334   const cpp_token *tok;
 335   enum cpp_ttype type;
 336   unsigned char add_flags = 0;
 337
 338   timevar_push (TV_CPP);
 339  retry:
 340   tok = cpp_get_token (parse_in);
 341   type = tok->type;
 342
 343  retry_after_at:
 344 #ifdef USE_MAPPED_LOCATION
 345   *loc = tok->src_loc;
 346 #else
 347   *loc = input_location;
 348 #endif
 349   switch (type)
 350     {
 351     case CPP_PADDING:
 352       goto retry;
 353
 354     case CPP_NAME:
 355       *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
 356       break;
 357
 358     case CPP_NUMBER:
 359       {
 360         unsigned int flags = cpp_classify_number (parse_in, tok);
 361
 362         switch (flags & CPP_N_CATEGORY)
 363           {
 364           case CPP_N_INVALID:
 365             /* cpplib has issued an error.  */
 366             *value = error_mark_node;
 367             errorcount++;
 368             break;
 369
 370           case CPP_N_INTEGER:
 371             /* C++ uses '0' to mark virtual functions as pure.
 372                Set PURE_ZERO to pass this information to the C++ parser.  */
 373             if (tok->val.str.len == 1 && *tok->val.str.text == '0')
 374               add_flags = PURE_ZERO;
 375             *value = interpret_integer (tok, flags);
 376             break;
 377
 378           case CPP_N_FLOATING:
 379             *value = interpret_float (tok, flags);
 380             break;
 381
 382           default:
 383             gcc_unreachable ();
 384           }
 385       }
 386       break;
 387
 388     case CPP_ATSIGN:
 389       /* An @ may give the next token special significance in Objective-C.  */
 390       if (c_dialect_objc ())
 391         {
 392           location_t atloc = input_location;
 393
 394         retry_at:
 395           tok = cpp_get_token (parse_in);
 396           type = tok->type;
 397           switch (type)
 398             {
 399             case CPP_PADDING:
 400               goto retry_at;
 401
 402             case CPP_STRING:
 403             case CPP_WSTRING:
 404               type = lex_string (tok, value, true);
 405               break;
 406
 407             case CPP_NAME:
 408               *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
 409               if (objc_is_reserved_word (*value))
 410                 {
 411                   type = CPP_AT_NAME;
 412                   break;
 413                 }
 414               /* FALLTHROUGH */
 415
 416             default:
 417               /* ... or not.  */
 418               error ("%Hstray %<@%> in program", &atloc);
 419               goto retry_after_at;
 420             }
 421           break;
 422         }
 423
 424       /* FALLTHROUGH */
 425     case CPP_HASH:
 426     case CPP_PASTE:
 427       {
 428         unsigned char name[4];
 429
 430         *cpp_spell_token (parse_in, tok, name, true) = 0;
 431
 432         error ("stray %qs in program", name);
 433       }
 434
 435       goto retry;
 436
 437     case CPP_OTHER:
 438       {
 439         cppchar_t c = tok->val.str.text[0];
 440
 441         if (c == '"' || c == '\'')
 442           error ("missing terminating %c character", (int) c);
 443         else if (ISGRAPH (c))
 444           error ("stray %qc in program", (int) c);
 445         else
 446           error ("stray %<\\%o%> in program", (int) c);
 447       }
 448       goto retry;
 449
 450     case CPP_CHAR:
 451     case CPP_WCHAR:
 452       *value = lex_charconst (tok);
 453       break;
 454
 455     case CPP_STRING:
 456     case CPP_WSTRING:
 457       if (!c_lex_return_raw_strings)
 458         {
 459           type = lex_string (tok, value, false);
 460           break;
 461         }
 462       *value = build_string (tok->val.str.len, (const char *) tok->val.str.text);
 463       break;
 464
 465     case CPP_PRAGMA:
 466       *value = build_int_cst (NULL, tok->val.pragma);
 467       break;
 468
 469       /* These tokens should not be visible outside cpplib.  */
 470     case CPP_HEADER_NAME:
 471     case CPP_COMMENT:
 472     case CPP_MACRO_ARG:
 473       gcc_unreachable ();
 474
 475     default:
 476       *value = NULL_TREE;
 477       break;
 478     }
 479
 480   if (cpp_flags)
 481     *cpp_flags = tok->flags | add_flags;
 482
 483   if (!no_more_pch)
 484     {
 485       no_more_pch = true;
 486       c_common_no_more_pch ();
 487     }
 488
 489   timevar_pop (TV_CPP);
 490
 491   return type;
 492 }
 493
 494 /* Returns the narrowest C-visible unsigned type, starting with the
 495    minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
 496    there isn't one.  */
 497
 498 static enum integer_type_kind
 499 narrowest_unsigned_type (unsigned HOST_WIDE_INT low,
 500                          unsigned HOST_WIDE_INT high,
 501                          unsigned int flags)
 502 {
 503   enum integer_type_kind itk;
 504
 505   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 506     itk = itk_unsigned_int;
 507   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 508     itk = itk_unsigned_long;
 509   else
 510     itk = itk_unsigned_long_long;
 511
 512   for (; itk < itk_none; itk += 2 /* skip unsigned 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 itk;
 520     }
 521
 522   return itk_none;
 523 }
 524
 525 /* Ditto, but narrowest signed type.  */
 526 static enum integer_type_kind
 527 narrowest_signed_type (unsigned HOST_WIDE_INT low,
 528                        unsigned HOST_WIDE_INT high, unsigned int flags)
 529 {
 530   enum integer_type_kind itk;
 531
 532   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 533     itk = itk_int;
 534   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 535     itk = itk_long;
 536   else
 537     itk = itk_long_long;
 538
 539
 540   for (; itk < itk_none; itk += 2 /* skip signed types */)
 541     {
 542       tree upper = TYPE_MAX_VALUE (integer_types[itk]);
 543
 544       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
 545           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
 546               && TREE_INT_CST_LOW (upper) >= low))
 547         return itk;
 548     }
 549
 550   return itk_none;
 551 }
 552
 553 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib.  */
 554 static tree
 555 interpret_integer (const cpp_token *token, unsigned int flags)
 556 {
 557   tree value, type;
 558   enum integer_type_kind itk;
 559   cpp_num integer;
 560   cpp_options *options = cpp_get_options (parse_in);
 561
 562   integer = cpp_interpret_integer (parse_in, token, flags);
 563   integer = cpp_num_sign_extend (integer, options->precision);
 564
 565   /* The type of a constant with a U suffix is straightforward.  */
 566   if (flags & CPP_N_UNSIGNED)
 567     itk = narrowest_unsigned_type (integer.low, integer.high, flags);
 568   else
 569     {
 570       /* The type of a potentially-signed integer constant varies
 571          depending on the base it's in, the standard in use, and the
 572          length suffixes.  */
 573       enum integer_type_kind itk_u
 574         = narrowest_unsigned_type (integer.low, integer.high, flags);
 575       enum integer_type_kind itk_s
 576         = narrowest_signed_type (integer.low, integer.high, flags);
 577
 578       /* In both C89 and C99, octal and hex constants may be signed or
 579          unsigned, whichever fits tighter.  We do not warn about this
 580          choice differing from the traditional choice, as the constant
 581          is probably a bit pattern and either way will work.  */
 582       if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
 583         itk = MIN (itk_u, itk_s);
 584       else
 585         {
 586           /* In C99, decimal constants are always signed.
 587              In C89, decimal constants that don't fit in long have
 588              undefined behavior; we try to make them unsigned long.
 589              In GCC's extended C89, that last is true of decimal
 590              constants that don't fit in long long, too.  */
 591
 592           itk = itk_s;
 593           if (itk_s > itk_u && itk_s > itk_long)
 594             {
 595               if (!flag_isoc99)
 596                 {
 597                   if (itk_u < itk_unsigned_long)
 598                     itk_u = itk_unsigned_long;
 599                   itk = itk_u;
 600                   warning (0, "this decimal constant is unsigned only in ISO C90");
 601                 }
 602               else
 603                 warning (OPT_Wtraditional,
 604                          "this decimal constant would be unsigned in ISO C90");
 605             }
 606         }
 607     }
 608
 609   if (itk == itk_none)
 610     /* cpplib has already issued a warning for overflow.  */
 611     type = ((flags & CPP_N_UNSIGNED)
 612             ? widest_unsigned_literal_type_node
 613             : widest_integer_literal_type_node);
 614   else
 615     type = integer_types[itk];
 616
 617   if (itk > itk_unsigned_long
 618       && (flags & CPP_N_WIDTH) != CPP_N_LARGE
 619       && !in_system_header && !flag_isoc99)
 620     pedwarn ("integer constant is too large for %qs type",
 621              (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long");
 622
 623   value = build_int_cst_wide (type, integer.low, integer.high);
 624
 625   /* Convert imaginary to a complex type.  */
 626   if (flags & CPP_N_IMAGINARY)
 627     value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
 628
 629   return value;
 630 }
 631
 632 /* Interpret TOKEN, a floating point number with FLAGS as classified
 633    by cpplib.  */
 634 static tree
 635 interpret_float (const cpp_token *token, unsigned int flags)
 636 {
 637   tree type;
 638   tree value;
 639   REAL_VALUE_TYPE real;
 640   char *copy;
 641   size_t copylen;
 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 if (pedantic)
 671           pedwarn ("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   /* Copy the constant to a nul-terminated buffer.  If the constant
 685      has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
 686      can't handle them.  */
 687   copylen = token->val.str.len;
 688   if (flags & CPP_N_DFLOAT)
 689     copylen -= 2;
 690   else
 691     {
 692       if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
 693         /* Must be an F or L or machine defined suffix.  */
 694         copylen--;
 695       if (flags & CPP_N_IMAGINARY)
 696         /* I or J suffix.  */
 697         copylen--;
 698     }
 699
 700   copy = (char *) alloca (copylen + 1);
 701   memcpy (copy, token->val.str.text, copylen);
 702   copy[copylen] = '\0';
 703
 704   real_from_string3 (&real, copy, TYPE_MODE (type));
 705
 706   /* Both C and C++ require a diagnostic for a floating constant
 707      outside the range of representable values of its type.  Since we
 708      have __builtin_inf* to produce an infinity, this is now a
 709      mandatory pedwarn if the target does not support infinities.  */
 710   if (REAL_VALUE_ISINF (real))
 711     {
 712       if (!MODE_HAS_INFINITIES (TYPE_MODE (type)))
 713         pedwarn ("floating constant exceeds range of %qT", type);
 714       else
 715         warning (OPT_Woverflow, "floating constant exceeds range of %qT", type);
 716     }
 717   /* We also give a warning if the value underflows.  */
 718   else if (REAL_VALUES_EQUAL (real, dconst0))
 719     {
 720       REAL_VALUE_TYPE realvoidmode;
 721       int overflow = real_from_string (&realvoidmode, copy);
 722       if (overflow < 0 || !REAL_VALUES_EQUAL (realvoidmode, dconst0))
 723         warning (OPT_Woverflow, "floating constant truncated to zero");
 724     }
 725
 726   /* Create a node with determined type and value.  */
 727   value = build_real (type, real);
 728   if (flags & CPP_N_IMAGINARY)
 729     value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
 730
 731   return value;
 732 }
 733
 734 /* Convert a series of STRING and/or WSTRING tokens into a tree,
 735    performing string constant concatenation.  TOK is the first of
 736    these.  VALP is the location to write the string into.  OBJC_STRING
 737    indicates whether an '@' token preceded the incoming token.
 738    Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
 739    or CPP_OBJC_STRING).
 740
 741    This is unfortunately more work than it should be.  If any of the
 742    strings in the series has an L prefix, the result is a wide string
 743    (6.4.5p4).  Whether or not the result is a wide string affects the
 744    meaning of octal and hexadecimal escapes (6.4.4.4p6,9).  But escape
 745    sequences do not continue across the boundary between two strings in
 746    a series (6.4.5p7), so we must not lose the boundaries.  Therefore
 747    cpp_interpret_string takes a vector of cpp_string structures, which
 748    we must arrange to provide.  */
 749
 750 static enum cpp_ttype
 751 lex_string (const cpp_token *tok, tree *valp, bool objc_string)
 752 {
 753   tree value;
 754   bool wide = false;
 755   size_t concats = 0;
 756   struct obstack str_ob;
 757   cpp_string istr;
 758
 759   /* Try to avoid the overhead of creating and destroying an obstack
 760      for the common case of just one string.  */
 761   cpp_string str = tok->val.str;
 762   cpp_string *strs = &str;
 763
 764   if (tok->type == CPP_WSTRING)
 765     wide = true;
 766
 767  retry:
 768   tok = cpp_get_token (parse_in);
 769   switch (tok->type)
 770     {
 771     case CPP_PADDING:
 772       goto retry;
 773     case CPP_ATSIGN:
 774       if (c_dialect_objc ())
 775         {
 776           objc_string = true;
 777           goto retry;
 778         }
 779       /* FALLTHROUGH */
 780
 781     default:
 782       break;
 783
 784     case CPP_WSTRING:
 785       wide = true;
 786       /* FALLTHROUGH */
 787
 788     case CPP_STRING:
 789       if (!concats)
 790         {
 791           gcc_obstack_init (&str_ob);
 792           obstack_grow (&str_ob, &str, sizeof (cpp_string));
 793         }
 794
 795       concats++;
 796       obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
 797       goto retry;
 798     }
 799
 800   /* We have read one more token than we want.  */
 801   _cpp_backup_tokens (parse_in, 1);
 802   if (concats)
 803     strs = XOBFINISH (&str_ob, cpp_string *);
 804
 805   if (concats && !objc_string && !in_system_header)
 806     warning (OPT_Wtraditional,
 807              "traditional C rejects string constant concatenation");
 808
 809   if ((c_lex_string_translate
 810        ? cpp_interpret_string : cpp_interpret_string_notranslate)
 811       (parse_in, strs, concats + 1, &istr, wide))
 812     {
 813       value = build_string (istr.len, (const char *) istr.text);
 814       free (CONST_CAST (istr.text));
 815
 816       if (c_lex_string_translate == -1)
 817         {
 818           int xlated = cpp_interpret_string_notranslate (parse_in, strs,
 819                                                          concats + 1,
 820                                                          &istr, wide);
 821           /* Assume that, if we managed to translate the string above,
 822              then the untranslated parsing will always succeed.  */
 823           gcc_assert (xlated);
 824
 825           if (TREE_STRING_LENGTH (value) != (int) istr.len
 826               || 0 != strncmp (TREE_STRING_POINTER (value),
 827                                (const char *) istr.text, istr.len))
 828             {
 829               /* Arrange for us to return the untranslated string in
 830                  *valp, but to set up the C type of the translated
 831                  one.  */
 832               *valp = build_string (istr.len, (const char *) istr.text);
 833               valp = &TREE_CHAIN (*valp);
 834             }
 835           free (CONST_CAST (istr.text));
 836         }
 837     }
 838   else
 839     {
 840       /* Callers cannot generally handle error_mark_node in this context,
 841          so return the empty string instead.  cpp_interpret_string has
 842          issued an error.  */
 843       if (wide)
 844         value = build_string (TYPE_PRECISION (wchar_type_node)
 845                               / TYPE_PRECISION (char_type_node),
 846                               "\0\0\0");  /* widest supported wchar_t
 847                                              is 32 bits */
 848       else
 849         value = build_string (1, "");
 850     }
 851
 852   TREE_TYPE (value) = wide ? wchar_array_type_node : char_array_type_node;
 853   *valp = fix_string_type (value);
 854
 855   if (concats)
 856     obstack_free (&str_ob, 0);
 857
 858   return objc_string ? CPP_OBJC_STRING : wide ? CPP_WSTRING : CPP_STRING;
 859 }
 860
 861 /* Converts a (possibly wide) character constant token into a tree.  */
 862 static tree
 863 lex_charconst (const cpp_token *token)
 864 {
 865   cppchar_t result;
 866   tree type, value;
 867   unsigned int chars_seen;
 868   int unsignedp;
 869
 870   result = cpp_interpret_charconst (parse_in, token,
 871                                     &chars_seen, &unsignedp);
 872
 873   if (token->type == CPP_WCHAR)
 874     type = wchar_type_node;
 875   /* In C, a character constant has type 'int'.
 876      In C++ 'char', but multi-char charconsts have type 'int'.  */
 877   else if (!c_dialect_cxx () || chars_seen > 1)
 878     type = integer_type_node;
 879   else
 880     type = char_type_node;
 881
 882   /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
 883      before possibly widening to HOST_WIDE_INT for build_int_cst.  */
 884   if (unsignedp || (cppchar_signed_t) result >= 0)
 885     value = build_int_cst_wide (type, result, 0);
 886   else
 887     value = build_int_cst_wide (type, (cppchar_signed_t) result, -1);
 888
 889   return value;
 890 }