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
   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 2, 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 COPYING.  If not, write to the Free
  20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  21 02110-1301, USA.  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "tm.h"
  27
  28 #include "real.h"
  29 #include "rtl.h"
  30 #include "tree.h"
  31 #include "input.h"
  32 #include "output.h"
  33 #include "c-tree.h"
  34 #include "c-common.h"
  35 #include "flags.h"
  36 #include "timevar.h"
  37 #include "cpplib.h"
  38 #include "c-pragma.h"
  39 #include "toplev.h"
  40 #include "intl.h"
  41 #include "tm_p.h"
  42 #include "splay-tree.h"
  43 #include "debug.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 ((void *) 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             break;
 368
 369           case CPP_N_INTEGER:
 370             /* C++ uses '0' to mark virtual functions as pure.
 371                Set PURE_ZERO to pass this information to the C++ parser.  */
 372             if (tok->val.str.len == 1 && *tok->val.str.text == '0')
 373               add_flags = PURE_ZERO;
 374             *value = interpret_integer (tok, flags);
 375             break;
 376
 377           case CPP_N_FLOATING:
 378             *value = interpret_float (tok, flags);
 379             break;
 380
 381           default:
 382             gcc_unreachable ();
 383           }
 384       }
 385       break;
 386
 387     case CPP_ATSIGN:
 388       /* An @ may give the next token special significance in Objective-C.  */
 389       if (c_dialect_objc ())
 390         {
 391           location_t atloc = input_location;
 392
 393         retry_at:
 394           tok = cpp_get_token (parse_in);
 395           type = tok->type;
 396           switch (type)
 397             {
 398             case CPP_PADDING:
 399               goto retry_at;
 400
 401             case CPP_STRING:
 402             case CPP_WSTRING:
 403               type = lex_string (tok, value, true);
 404               break;
 405
 406             case CPP_NAME:
 407               *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
 408               if (objc_is_reserved_word (*value))
 409                 {
 410                   type = CPP_AT_NAME;
 411                   break;
 412                 }
 413               /* FALLTHROUGH */
 414
 415             default:
 416               /* ... or not.  */
 417               error ("%Hstray %<@%> in program", &atloc);
 418               goto retry_after_at;
 419             }
 420           break;
 421         }
 422
 423       /* FALLTHROUGH */
 424     case CPP_HASH:
 425     case CPP_PASTE:
 426       {
 427         unsigned char name[4];
 428
 429         *cpp_spell_token (parse_in, tok, name, true) = 0;
 430
 431         error ("stray %qs in program", name);
 432       }
 433
 434       goto retry;
 435
 436     case CPP_OTHER:
 437       {
 438         cppchar_t c = tok->val.str.text[0];
 439
 440         if (c == '"' || c == '\'')
 441           error ("missing terminating %c character", (int) c);
 442         else if (ISGRAPH (c))
 443           error ("stray %qc in program", (int) c);
 444         else
 445           error ("stray %<\\%o%> in program", (int) c);
 446       }
 447       goto retry;
 448
 449     case CPP_CHAR:
 450     case CPP_WCHAR:
 451       *value = lex_charconst (tok);
 452       break;
 453
 454     case CPP_STRING:
 455     case CPP_WSTRING:
 456       if (!c_lex_return_raw_strings)
 457         {
 458           type = lex_string (tok, value, false);
 459           break;
 460         }
 461
 462       /* FALLTHROUGH */
 463
 464     case CPP_PRAGMA:
 465       *value = build_string (tok->val.str.len, (char *) tok->val.str.text);
 466       break;
 467
 468       /* These tokens should not be visible outside cpplib.  */
 469     case CPP_HEADER_NAME:
 470     case CPP_COMMENT:
 471     case CPP_MACRO_ARG:
 472       gcc_unreachable ();
 473
 474     default:
 475       *value = NULL_TREE;
 476       break;
 477     }
 478
 479   if (cpp_flags)
 480     *cpp_flags = tok->flags | add_flags;
 481
 482   if (!no_more_pch)
 483     {
 484       no_more_pch = true;
 485       c_common_no_more_pch ();
 486     }
 487
 488   timevar_pop (TV_CPP);
 489
 490   return type;
 491 }
 492
 493 enum cpp_ttype
 494 pragma_lex (tree *value)
 495 {
 496   location_t loc;
 497   return c_lex_with_flags (value, &loc, NULL);
 498 }
 499
 500 /* Returns the narrowest C-visible unsigned type, starting with the
 501    minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
 502    there isn't one.  */
 503
 504 static enum integer_type_kind
 505 narrowest_unsigned_type (unsigned HOST_WIDE_INT low,
 506                          unsigned HOST_WIDE_INT high,
 507                          unsigned int flags)
 508 {
 509   enum integer_type_kind itk;
 510
 511   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 512     itk = itk_unsigned_int;
 513   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 514     itk = itk_unsigned_long;
 515   else
 516     itk = itk_unsigned_long_long;
 517
 518   for (; itk < itk_none; itk += 2 /* skip unsigned types */)
 519     {
 520       tree upper = TYPE_MAX_VALUE (integer_types[itk]);
 521
 522       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
 523           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
 524               && TREE_INT_CST_LOW (upper) >= low))
 525         return itk;
 526     }
 527
 528   return itk_none;
 529 }
 530
 531 /* Ditto, but narrowest signed type.  */
 532 static enum integer_type_kind
 533 narrowest_signed_type (unsigned HOST_WIDE_INT low,
 534                        unsigned HOST_WIDE_INT high, unsigned int flags)
 535 {
 536   enum integer_type_kind itk;
 537
 538   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 539     itk = itk_int;
 540   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 541     itk = itk_long;
 542   else
 543     itk = itk_long_long;
 544
 545
 546   for (; itk < itk_none; itk += 2 /* skip signed types */)
 547     {
 548       tree upper = TYPE_MAX_VALUE (integer_types[itk]);
 549
 550       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
 551           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
 552               && TREE_INT_CST_LOW (upper) >= low))
 553         return itk;
 554     }
 555
 556   return itk_none;
 557 }
 558
 559 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib.  */
 560 static tree
 561 interpret_integer (const cpp_token *token, unsigned int flags)
 562 {
 563   tree value, type;
 564   enum integer_type_kind itk;
 565   cpp_num integer;
 566   cpp_options *options = cpp_get_options (parse_in);
 567
 568   integer = cpp_interpret_integer (parse_in, token, flags);
 569   integer = cpp_num_sign_extend (integer, options->precision);
 570
 571   /* The type of a constant with a U suffix is straightforward.  */
 572   if (flags & CPP_N_UNSIGNED)
 573     itk = narrowest_unsigned_type (integer.low, integer.high, flags);
 574   else
 575     {
 576       /* The type of a potentially-signed integer constant varies
 577          depending on the base it's in, the standard in use, and the
 578          length suffixes.  */
 579       enum integer_type_kind itk_u
 580         = narrowest_unsigned_type (integer.low, integer.high, flags);
 581       enum integer_type_kind itk_s
 582         = narrowest_signed_type (integer.low, integer.high, flags);
 583
 584       /* In both C89 and C99, octal and hex constants may be signed or
 585          unsigned, whichever fits tighter.  We do not warn about this
 586          choice differing from the traditional choice, as the constant
 587          is probably a bit pattern and either way will work.  */
 588       if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
 589         itk = MIN (itk_u, itk_s);
 590       else
 591         {
 592           /* In C99, decimal constants are always signed.
 593              In C89, decimal constants that don't fit in long have
 594              undefined behavior; we try to make them unsigned long.
 595              In GCC's extended C89, that last is true of decimal
 596              constants that don't fit in long long, too.  */
 597
 598           itk = itk_s;
 599           if (itk_s > itk_u && itk_s > itk_long)
 600             {
 601               if (!flag_isoc99)
 602                 {
 603                   if (itk_u < itk_unsigned_long)
 604                     itk_u = itk_unsigned_long;
 605                   itk = itk_u;
 606                   warning (0, "this decimal constant is unsigned only in ISO C90");
 607                 }
 608               else
 609                 warning (OPT_Wtraditional,
 610                          "this decimal constant would be unsigned in ISO C90");
 611             }
 612         }
 613     }
 614
 615   if (itk == itk_none)
 616     /* cpplib has already issued a warning for overflow.  */
 617     type = ((flags & CPP_N_UNSIGNED)
 618             ? widest_unsigned_literal_type_node
 619             : widest_integer_literal_type_node);
 620   else
 621     type = integer_types[itk];
 622
 623   if (itk > itk_unsigned_long
 624       && (flags & CPP_N_WIDTH) != CPP_N_LARGE
 625       && !in_system_header && !flag_isoc99)
 626     pedwarn ("integer constant is too large for %qs type",
 627              (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long");
 628
 629   value = build_int_cst_wide (type, integer.low, integer.high);
 630
 631   /* Convert imaginary to a complex type.  */
 632   if (flags & CPP_N_IMAGINARY)
 633     value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
 634
 635   return value;
 636 }
 637
 638 /* Interpret TOKEN, a floating point number with FLAGS as classified
 639    by cpplib.  */
 640 static tree
 641 interpret_float (const cpp_token *token, unsigned int flags)
 642 {
 643   tree type;
 644   tree value;
 645   REAL_VALUE_TYPE real;
 646   char *copy;
 647   size_t copylen;
 648
 649   /* Decode type based on width and properties. */
 650   if (flags & CPP_N_DFLOAT)
 651     if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 652       type = dfloat128_type_node;
 653     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 654       type = dfloat32_type_node;
 655     else
 656       type = dfloat64_type_node;
 657   else
 658     if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 659       type = long_double_type_node;
 660     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
 661              || flag_single_precision_constant)
 662       type = float_type_node;
 663     else
 664       type = double_type_node;
 665
 666   /* Copy the constant to a nul-terminated buffer.  If the constant
 667      has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
 668      can't handle them.  */
 669   copylen = token->val.str.len;
 670   if (flags & CPP_N_DFLOAT)
 671     copylen -= 2;
 672   else
 673     {
 674       if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
 675         /* Must be an F or L suffix.  */
 676         copylen--;
 677       if (flags & CPP_N_IMAGINARY)
 678         /* I or J suffix.  */
 679         copylen--;
 680     }
 681
 682   copy = (char *) alloca (copylen + 1);
 683   memcpy (copy, token->val.str.text, copylen);
 684   copy[copylen] = '\0';
 685
 686   real_from_string3 (&real, copy, TYPE_MODE (type));
 687
 688   /* Both C and C++ require a diagnostic for a floating constant
 689      outside the range of representable values of its type.  Since we
 690      have __builtin_inf* to produce an infinity, it might now be
 691      appropriate for this to be a mandatory pedwarn rather than
 692      conditioned on -pedantic.  */
 693   if (REAL_VALUE_ISINF (real) && pedantic)
 694     pedwarn ("floating constant exceeds range of %qT", type);
 695
 696   /* Create a node with determined type and value.  */
 697   value = build_real (type, real);
 698   if (flags & CPP_N_IMAGINARY)
 699     value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
 700
 701   return value;
 702 }
 703
 704 /* Convert a series of STRING and/or WSTRING tokens into a tree,
 705    performing string constant concatenation.  TOK is the first of
 706    these.  VALP is the location to write the string into.  OBJC_STRING
 707    indicates whether an '@' token preceded the incoming token.
 708    Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
 709    or CPP_OBJC_STRING).
 710
 711    This is unfortunately more work than it should be.  If any of the
 712    strings in the series has an L prefix, the result is a wide string
 713    (6.4.5p4).  Whether or not the result is a wide string affects the
 714    meaning of octal and hexadecimal escapes (6.4.4.4p6,9).  But escape
 715    sequences do not continue across the boundary between two strings in
 716    a series (6.4.5p7), so we must not lose the boundaries.  Therefore
 717    cpp_interpret_string takes a vector of cpp_string structures, which
 718    we must arrange to provide.  */
 719
 720 static enum cpp_ttype
 721 lex_string (const cpp_token *tok, tree *valp, bool objc_string)
 722 {
 723   tree value;
 724   bool wide = false;
 725   size_t concats = 0;
 726   struct obstack str_ob;
 727   cpp_string istr;
 728
 729   /* Try to avoid the overhead of creating and destroying an obstack
 730      for the common case of just one string.  */
 731   cpp_string str = tok->val.str;
 732   cpp_string *strs = &str;
 733
 734   if (tok->type == CPP_WSTRING)
 735     wide = true;
 736
 737  retry:
 738   tok = cpp_get_token (parse_in);
 739   switch (tok->type)
 740     {
 741     case CPP_PADDING:
 742       goto retry;
 743     case CPP_ATSIGN:
 744       if (c_dialect_objc ())
 745         {
 746           objc_string = true;
 747           goto retry;
 748         }
 749       /* FALLTHROUGH */
 750
 751     default:
 752       break;
 753
 754     case CPP_WSTRING:
 755       wide = true;
 756       /* FALLTHROUGH */
 757
 758     case CPP_STRING:
 759       if (!concats)
 760         {
 761           gcc_obstack_init (&str_ob);
 762           obstack_grow (&str_ob, &str, sizeof (cpp_string));
 763         }
 764
 765       concats++;
 766       obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
 767       goto retry;
 768     }
 769
 770   /* We have read one more token than we want.  */
 771   _cpp_backup_tokens (parse_in, 1);
 772   if (concats)
 773     strs = XOBFINISH (&str_ob, cpp_string *);
 774
 775   if (concats && !objc_string && !in_system_header)
 776     warning (OPT_Wtraditional,
 777              "traditional C rejects string constant concatenation");
 778
 779   if ((c_lex_string_translate
 780        ? cpp_interpret_string : cpp_interpret_string_notranslate)
 781       (parse_in, strs, concats + 1, &istr, wide))
 782     {
 783       value = build_string (istr.len, (char *) istr.text);
 784       free ((void *) istr.text);
 785
 786       if (c_lex_string_translate == -1)
 787         {
 788           int xlated = cpp_interpret_string_notranslate (parse_in, strs,
 789                                                          concats + 1,
 790                                                          &istr, wide);
 791           /* Assume that, if we managed to translate the string above,
 792              then the untranslated parsing will always succeed.  */
 793           gcc_assert (xlated);
 794
 795           if (TREE_STRING_LENGTH (value) != (int) istr.len
 796               || 0 != strncmp (TREE_STRING_POINTER (value), (char *) istr.text,
 797                                istr.len))
 798             {
 799               /* Arrange for us to return the untranslated string in
 800                  *valp, but to set up the C type of the translated
 801                  one.  */
 802               *valp = build_string (istr.len, (char *) istr.text);
 803               valp = &TREE_CHAIN (*valp);
 804             }
 805           free ((void *) istr.text);
 806         }
 807     }
 808   else
 809     {
 810       /* Callers cannot generally handle error_mark_node in this context,
 811          so return the empty string instead.  cpp_interpret_string has
 812          issued an error.  */
 813       if (wide)
 814         value = build_string (TYPE_PRECISION (wchar_type_node)
 815                               / TYPE_PRECISION (char_type_node),
 816                               "\0\0\0");  /* widest supported wchar_t
 817                                              is 32 bits */
 818       else
 819         value = build_string (1, "");
 820     }
 821
 822   TREE_TYPE (value) = wide ? wchar_array_type_node : char_array_type_node;
 823   *valp = fix_string_type (value);
 824
 825   if (concats)
 826     obstack_free (&str_ob, 0);
 827
 828   return objc_string ? CPP_OBJC_STRING : wide ? CPP_WSTRING : CPP_STRING;
 829 }
 830
 831 /* Converts a (possibly wide) character constant token into a tree.  */
 832 static tree
 833 lex_charconst (const cpp_token *token)
 834 {
 835   cppchar_t result;
 836   tree type, value;
 837   unsigned int chars_seen;
 838   int unsignedp;
 839
 840   result = cpp_interpret_charconst (parse_in, token,
 841                                     &chars_seen, &unsignedp);
 842
 843   if (token->type == CPP_WCHAR)
 844     type = wchar_type_node;
 845   /* In C, a character constant has type 'int'.
 846      In C++ 'char', but multi-char charconsts have type 'int'.  */
 847   else if (!c_dialect_cxx () || chars_seen > 1)
 848     type = integer_type_node;
 849   else
 850     type = char_type_node;
 851
 852   /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
 853      before possibly widening to HOST_WIDE_INT for build_int_cst.  */
 854   if (unsignedp || (cppchar_signed_t) result >= 0)
 855     value = build_int_cst_wide (type, result, 0);
 856   else
 857     value = build_int_cst_wide (type, (cppchar_signed_t) result, -1);
 858
 859   return value;
 860 }