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, false))
 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           int included_at = LAST_SOURCE_LINE_LOCATION (new_map - 1);
 209
 210           input_location = new_map->start_location;
 211           (*debug_hooks->start_source_file) (included_at, new_map->to_file);
 212 #ifndef NO_IMPLICIT_EXTERN_C
 213           if (c_header_level)
 214             ++c_header_level;
 215           else if (new_map->sysp == 2)
 216             {
 217               c_header_level = 1;
 218               ++pending_lang_change;
 219             }
 220 #endif
 221         }
 222     }
 223   else if (new_map->reason == LC_LEAVE)
 224     {
 225 #ifndef NO_IMPLICIT_EXTERN_C
 226       if (c_header_level && --c_header_level == 0)
 227         {
 228           if (new_map->sysp == 2)
 229             warning (0, "badly nested C headers from preprocessor");
 230           --pending_lang_change;
 231         }
 232 #endif
 233       input_location = new_map->start_location;
 234
 235       (*debug_hooks->end_source_file) (new_map->to_line);
 236     }
 237
 238   update_header_times (new_map->to_file);
 239   in_system_header = new_map->sysp != 0;
 240   input_location = new_map->start_location;
 241 }
 242
 243 static void
 244 cb_def_pragma (cpp_reader *pfile, source_location loc)
 245 {
 246   /* Issue a warning message if we have been asked to do so.  Ignore
 247      unknown pragmas in system headers unless an explicit
 248      -Wunknown-pragmas has been given.  */
 249   if (warn_unknown_pragmas > in_system_header)
 250     {
 251       const unsigned char *space, *name;
 252       const cpp_token *s;
 253       location_t fe_loc = loc;
 254
 255       space = name = (const unsigned char *) "";
 256       s = cpp_get_token (pfile);
 257       if (s->type != CPP_EOF)
 258         {
 259           space = cpp_token_as_text (pfile, s);
 260           s = cpp_get_token (pfile);
 261           if (s->type == CPP_NAME)
 262             name = cpp_token_as_text (pfile, s);
 263         }
 264
 265       warning (OPT_Wunknown_pragmas, "%Hignoring #pragma %s %s",
 266                &fe_loc, space, name);
 267     }
 268 }
 269
 270 /* #define callback for DWARF and DWARF2 debug info.  */
 271 static void
 272 cb_define (cpp_reader *pfile, source_location loc, cpp_hashnode *node)
 273 {
 274   const struct line_map *map = linemap_lookup (line_table, loc);
 275   (*debug_hooks->define) (SOURCE_LINE (map, loc),
 276                           (const char *) cpp_macro_definition (pfile, node));
 277 }
 278
 279 /* #undef callback for DWARF and DWARF2 debug info.  */
 280 static void
 281 cb_undef (cpp_reader * ARG_UNUSED (pfile), source_location loc,
 282           cpp_hashnode *node)
 283 {
 284   const struct line_map *map = linemap_lookup (line_table, loc);
 285   (*debug_hooks->undef) (SOURCE_LINE (map, loc),
 286                          (const char *) NODE_NAME (node));
 287 }
 288 \f
 289 /* Read a token and return its type.  Fill *VALUE with its value, if
 290    applicable.  Fill *CPP_FLAGS with the token's flags, if it is
 291    non-NULL.  */
 292
 293 enum cpp_ttype
 294 c_lex_with_flags (tree *value, location_t *loc, unsigned char *cpp_flags,
 295                   int lex_flags)
 296 {
 297   static bool no_more_pch;
 298   const cpp_token *tok;
 299   enum cpp_ttype type;
 300   unsigned char add_flags = 0;
 301
 302   timevar_push (TV_CPP);
 303  retry:
 304   tok = cpp_get_token_with_location (parse_in, loc);
 305   type = tok->type;
 306
 307  retry_after_at:
 308   switch (type)
 309     {
 310     case CPP_PADDING:
 311       goto retry;
 312
 313     case CPP_NAME:
 314       *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
 315       break;
 316
 317     case CPP_NUMBER:
 318       {
 319         unsigned int flags = cpp_classify_number (parse_in, tok);
 320
 321         switch (flags & CPP_N_CATEGORY)
 322           {
 323           case CPP_N_INVALID:
 324             /* cpplib has issued an error.  */
 325             *value = error_mark_node;
 326             errorcount++;
 327             break;
 328
 329           case CPP_N_INTEGER:
 330             /* C++ uses '0' to mark virtual functions as pure.
 331                Set PURE_ZERO to pass this information to the C++ parser.  */
 332             if (tok->val.str.len == 1 && *tok->val.str.text == '0')
 333               add_flags = PURE_ZERO;
 334             *value = interpret_integer (tok, flags);
 335             break;
 336
 337           case CPP_N_FLOATING:
 338             *value = interpret_float (tok, flags);
 339             break;
 340
 341           default:
 342             gcc_unreachable ();
 343           }
 344       }
 345       break;
 346
 347     case CPP_ATSIGN:
 348       /* An @ may give the next token special significance in Objective-C.  */
 349       if (c_dialect_objc ())
 350         {
 351           location_t atloc = *loc;
 352           location_t newloc;
 353
 354         retry_at:
 355           tok = cpp_get_token_with_location (parse_in, &newloc);
 356           type = tok->type;
 357           switch (type)
 358             {
 359             case CPP_PADDING:
 360               goto retry_at;
 361
 362             case CPP_STRING:
 363             case CPP_WSTRING:
 364               type = lex_string (tok, value, true, true);
 365               break;
 366
 367             case CPP_NAME:
 368               *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
 369               if (objc_is_reserved_word (*value))
 370                 {
 371                   type = CPP_AT_NAME;
 372                   break;
 373                 }
 374               /* FALLTHROUGH */
 375
 376             default:
 377               /* ... or not.  */
 378               error ("%Hstray %<@%> in program", &atloc);
 379               *loc = newloc;
 380               goto retry_after_at;
 381             }
 382           break;
 383         }
 384
 385       /* FALLTHROUGH */
 386     case CPP_HASH:
 387     case CPP_PASTE:
 388       {
 389         unsigned char name[4];
 390
 391         *cpp_spell_token (parse_in, tok, name, true) = 0;
 392
 393         error ("stray %qs in program", name);
 394       }
 395
 396       goto retry;
 397
 398     case CPP_OTHER:
 399       {
 400         cppchar_t c = tok->val.str.text[0];
 401
 402         if (c == '"' || c == '\'')
 403           error ("missing terminating %c character", (int) c);
 404         else if (ISGRAPH (c))
 405           error ("stray %qc in program", (int) c);
 406         else
 407           error ("stray %<\\%o%> in program", (int) c);
 408       }
 409       goto retry;
 410
 411     case CPP_CHAR:
 412     case CPP_WCHAR:
 413       *value = lex_charconst (tok);
 414       break;
 415
 416     case CPP_STRING:
 417     case CPP_WSTRING:
 418       if ((lex_flags & C_LEX_RAW_STRINGS) == 0)
 419         {
 420           type = lex_string (tok, value, false,
 421                              (lex_flags & C_LEX_STRING_NO_TRANSLATE) == 0);
 422           break;
 423         }
 424       *value = build_string (tok->val.str.len, (const char *) tok->val.str.text);
 425       break;
 426
 427     case CPP_PRAGMA:
 428       *value = build_int_cst (NULL, tok->val.pragma);
 429       break;
 430
 431       /* These tokens should not be visible outside cpplib.  */
 432     case CPP_HEADER_NAME:
 433     case CPP_COMMENT:
 434     case CPP_MACRO_ARG:
 435       gcc_unreachable ();
 436
 437     default:
 438       *value = NULL_TREE;
 439       break;
 440     }
 441
 442   if (cpp_flags)
 443     *cpp_flags = tok->flags | add_flags;
 444
 445   if (!no_more_pch)
 446     {
 447       no_more_pch = true;
 448       c_common_no_more_pch ();
 449     }
 450
 451   timevar_pop (TV_CPP);
 452
 453   return type;
 454 }
 455
 456 /* Returns the narrowest C-visible unsigned type, starting with the
 457    minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
 458    there isn't one.  */
 459
 460 static enum integer_type_kind
 461 narrowest_unsigned_type (unsigned HOST_WIDE_INT low,
 462                          unsigned HOST_WIDE_INT high,
 463                          unsigned int flags)
 464 {
 465   enum integer_type_kind itk;
 466
 467   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 468     itk = itk_unsigned_int;
 469   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 470     itk = itk_unsigned_long;
 471   else
 472     itk = itk_unsigned_long_long;
 473
 474   for (; itk < itk_none; itk += 2 /* skip unsigned types */)
 475     {
 476       tree upper = TYPE_MAX_VALUE (integer_types[itk]);
 477
 478       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
 479           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
 480               && TREE_INT_CST_LOW (upper) >= low))
 481         return itk;
 482     }
 483
 484   return itk_none;
 485 }
 486
 487 /* Ditto, but narrowest signed type.  */
 488 static enum integer_type_kind
 489 narrowest_signed_type (unsigned HOST_WIDE_INT low,
 490                        unsigned HOST_WIDE_INT high, unsigned int flags)
 491 {
 492   enum integer_type_kind itk;
 493
 494   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 495     itk = itk_int;
 496   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 497     itk = itk_long;
 498   else
 499     itk = itk_long_long;
 500
 501
 502   for (; itk < itk_none; itk += 2 /* skip signed types */)
 503     {
 504       tree upper = TYPE_MAX_VALUE (integer_types[itk]);
 505
 506       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
 507           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
 508               && TREE_INT_CST_LOW (upper) >= low))
 509         return itk;
 510     }
 511
 512   return itk_none;
 513 }
 514
 515 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib.  */
 516 static tree
 517 interpret_integer (const cpp_token *token, unsigned int flags)
 518 {
 519   tree value, type;
 520   enum integer_type_kind itk;
 521   cpp_num integer;
 522   cpp_options *options = cpp_get_options (parse_in);
 523
 524   integer = cpp_interpret_integer (parse_in, token, flags);
 525   integer = cpp_num_sign_extend (integer, options->precision);
 526
 527   /* The type of a constant with a U suffix is straightforward.  */
 528   if (flags & CPP_N_UNSIGNED)
 529     itk = narrowest_unsigned_type (integer.low, integer.high, flags);
 530   else
 531     {
 532       /* The type of a potentially-signed integer constant varies
 533          depending on the base it's in, the standard in use, and the
 534          length suffixes.  */
 535       enum integer_type_kind itk_u
 536         = narrowest_unsigned_type (integer.low, integer.high, flags);
 537       enum integer_type_kind itk_s
 538         = narrowest_signed_type (integer.low, integer.high, flags);
 539
 540       /* In both C89 and C99, octal and hex constants may be signed or
 541          unsigned, whichever fits tighter.  We do not warn about this
 542          choice differing from the traditional choice, as the constant
 543          is probably a bit pattern and either way will work.  */
 544       if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
 545         itk = MIN (itk_u, itk_s);
 546       else
 547         {
 548           /* In C99, decimal constants are always signed.
 549              In C89, decimal constants that don't fit in long have
 550              undefined behavior; we try to make them unsigned long.
 551              In GCC's extended C89, that last is true of decimal
 552              constants that don't fit in long long, too.  */
 553
 554           itk = itk_s;
 555           if (itk_s > itk_u && itk_s > itk_long)
 556             {
 557               if (!flag_isoc99)
 558                 {
 559                   if (itk_u < itk_unsigned_long)
 560                     itk_u = itk_unsigned_long;
 561                   itk = itk_u;
 562                   warning (0, "this decimal constant is unsigned only in ISO C90");
 563                 }
 564               else
 565                 warning (OPT_Wtraditional,
 566                          "this decimal constant would be unsigned in ISO C90");
 567             }
 568         }
 569     }
 570
 571   if (itk == itk_none)
 572     /* cpplib has already issued a warning for overflow.  */
 573     type = ((flags & CPP_N_UNSIGNED)
 574             ? widest_unsigned_literal_type_node
 575             : widest_integer_literal_type_node);
 576   else
 577     type = integer_types[itk];
 578
 579   if (itk > itk_unsigned_long
 580       && (flags & CPP_N_WIDTH) != CPP_N_LARGE
 581       && !in_system_header && !flag_isoc99)
 582     pedwarn ("integer constant is too large for %qs type",
 583              (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long");
 584
 585   value = build_int_cst_wide (type, integer.low, integer.high);
 586
 587   /* Convert imaginary to a complex type.  */
 588   if (flags & CPP_N_IMAGINARY)
 589     value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
 590
 591   return value;
 592 }
 593
 594 /* Interpret TOKEN, a floating point number with FLAGS as classified
 595    by cpplib.  */
 596 static tree
 597 interpret_float (const cpp_token *token, unsigned int flags)
 598 {
 599   tree type;
 600   tree value;
 601   REAL_VALUE_TYPE real;
 602   char *copy;
 603   size_t copylen;
 604
 605   /* Decode _Fract and _Accum.  */
 606   if (flags & CPP_N_FRACT || flags & CPP_N_ACCUM)
 607     return interpret_fixed (token, flags);
 608
 609   /* Decode type based on width and properties. */
 610   if (flags & CPP_N_DFLOAT)
 611     if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 612       type = dfloat128_type_node;
 613     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 614       type = dfloat32_type_node;
 615     else
 616       type = dfloat64_type_node;
 617   else
 618     if (flags & CPP_N_WIDTH_MD)
 619       {
 620         char suffix;
 621         enum machine_mode mode;
 622
 623         if ((flags & CPP_N_WIDTH_MD) == CPP_N_MD_W)
 624           suffix = 'w';
 625         else
 626           suffix = 'q';
 627
 628         mode = targetm.c.mode_for_suffix (suffix);
 629         if (mode == VOIDmode)
 630           {
 631             error ("unsupported non-standard suffix on floating constant");
 632             errorcount++;
 633
 634             return error_mark_node;
 635           }
 636         else if (pedantic)
 637           pedwarn ("non-standard suffix on floating constant");
 638
 639         type = c_common_type_for_mode (mode, 0);
 640         gcc_assert (type);
 641       }
 642     else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 643       type = long_double_type_node;
 644     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
 645              || flag_single_precision_constant)
 646       type = float_type_node;
 647     else
 648       type = double_type_node;
 649
 650   /* Copy the constant to a nul-terminated buffer.  If the constant
 651      has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
 652      can't handle them.  */
 653   copylen = token->val.str.len;
 654   if (flags & CPP_N_DFLOAT)
 655     copylen -= 2;
 656   else
 657     {
 658       if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
 659         /* Must be an F or L or machine defined suffix.  */
 660         copylen--;
 661       if (flags & CPP_N_IMAGINARY)
 662         /* I or J suffix.  */
 663         copylen--;
 664     }
 665
 666   copy = (char *) alloca (copylen + 1);
 667   memcpy (copy, token->val.str.text, copylen);
 668   copy[copylen] = '\0';
 669
 670   real_from_string3 (&real, copy, TYPE_MODE (type));
 671
 672   /* Both C and C++ require a diagnostic for a floating constant
 673      outside the range of representable values of its type.  Since we
 674      have __builtin_inf* to produce an infinity, this is now a
 675      mandatory pedwarn if the target does not support infinities.  */
 676   if (REAL_VALUE_ISINF (real))
 677     {
 678       if (!MODE_HAS_INFINITIES (TYPE_MODE (type)))
 679         pedwarn ("floating constant exceeds range of %qT", type);
 680       else
 681         warning (OPT_Woverflow, "floating constant exceeds range of %qT", type);
 682     }
 683   /* We also give a warning if the value underflows.  */
 684   else if (REAL_VALUES_EQUAL (real, dconst0))
 685     {
 686       REAL_VALUE_TYPE realvoidmode;
 687       int overflow = real_from_string (&realvoidmode, copy);
 688       if (overflow < 0 || !REAL_VALUES_EQUAL (realvoidmode, dconst0))
 689         warning (OPT_Woverflow, "floating constant truncated to zero");
 690     }
 691
 692   /* Create a node with determined type and value.  */
 693   value = build_real (type, real);
 694   if (flags & CPP_N_IMAGINARY)
 695     value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
 696
 697   return value;
 698 }
 699
 700 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
 701    by cpplib.  */
 702
 703 static tree
 704 interpret_fixed (const cpp_token *token, unsigned int flags)
 705 {
 706   tree type;
 707   tree value;
 708   FIXED_VALUE_TYPE fixed;
 709   char *copy;
 710   size_t copylen;
 711
 712   copylen = token->val.str.len;
 713
 714   if (flags & CPP_N_FRACT) /* _Fract.  */
 715     {
 716       if (flags & CPP_N_UNSIGNED) /* Unsigned _Fract.  */
 717         {
 718           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 719             {
 720               type = unsigned_long_long_fract_type_node;
 721               copylen -= 4;
 722             }
 723           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 724             {
 725               type = unsigned_long_fract_type_node;
 726               copylen -= 3;
 727             }
 728           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 729             {
 730               type = unsigned_short_fract_type_node;
 731               copylen -= 3;
 732             }
 733           else
 734             {
 735               type = unsigned_fract_type_node;
 736               copylen -= 2;
 737             }
 738         }
 739       else /* Signed _Fract.  */
 740         {
 741           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 742             {
 743               type = long_long_fract_type_node;
 744               copylen -= 3;
 745             }
 746           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 747             {
 748               type = long_fract_type_node;
 749               copylen -= 2;
 750             }
 751           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 752             {
 753               type = short_fract_type_node;
 754               copylen -= 2;
 755             }
 756           else
 757             {
 758               type = fract_type_node;
 759               copylen --;
 760             }
 761           }
 762     }
 763   else /* _Accum.  */
 764     {
 765       if (flags & CPP_N_UNSIGNED) /* Unsigned _Accum.  */
 766         {
 767           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 768             {
 769               type = unsigned_long_long_accum_type_node;
 770               copylen -= 4;
 771             }
 772           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 773             {
 774               type = unsigned_long_accum_type_node;
 775               copylen -= 3;
 776             }
 777           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 778             {
 779               type = unsigned_short_accum_type_node;
 780               copylen -= 3;
 781              }
 782           else
 783             {
 784               type = unsigned_accum_type_node;
 785               copylen -= 2;
 786             }
 787         }
 788       else /* Signed _Accum.  */
 789         {
 790           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 791             {
 792               type = long_long_accum_type_node;
 793               copylen -= 3;
 794             }
 795           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 796             {
 797               type = long_accum_type_node;
 798               copylen -= 2;
 799             }
 800           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 801             {
 802               type = short_accum_type_node;
 803               copylen -= 2;
 804             }
 805           else
 806             {
 807               type = accum_type_node;
 808               copylen --;
 809             }
 810         }
 811     }
 812
 813   copy = (char *) alloca (copylen + 1);
 814   memcpy (copy, token->val.str.text, copylen);
 815   copy[copylen] = '\0';
 816
 817   fixed_from_string (&fixed, copy, TYPE_MODE (type));
 818
 819   /* Create a node with determined type and value.  */
 820   value = build_fixed (type, fixed);
 821
 822   return value;
 823 }
 824
 825 /* Convert a series of STRING and/or WSTRING tokens into a tree,
 826    performing string constant concatenation.  TOK is the first of
 827    these.  VALP is the location to write the string into.  OBJC_STRING
 828    indicates whether an '@' token preceded the incoming token.
 829    Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
 830    or CPP_OBJC_STRING).
 831
 832    This is unfortunately more work than it should be.  If any of the
 833    strings in the series has an L prefix, the result is a wide string
 834    (6.4.5p4).  Whether or not the result is a wide string affects the
 835    meaning of octal and hexadecimal escapes (6.4.4.4p6,9).  But escape
 836    sequences do not continue across the boundary between two strings in
 837    a series (6.4.5p7), so we must not lose the boundaries.  Therefore
 838    cpp_interpret_string takes a vector of cpp_string structures, which
 839    we must arrange to provide.  */
 840
 841 static enum cpp_ttype
 842 lex_string (const cpp_token *tok, tree *valp, bool objc_string, bool translate)
 843 {
 844   tree value;
 845   bool wide = false;
 846   size_t concats = 0;
 847   struct obstack str_ob;
 848   cpp_string istr;
 849
 850   /* Try to avoid the overhead of creating and destroying an obstack
 851      for the common case of just one string.  */
 852   cpp_string str = tok->val.str;
 853   cpp_string *strs = &str;
 854
 855   if (tok->type == CPP_WSTRING)
 856     wide = true;
 857
 858  retry:
 859   tok = cpp_get_token (parse_in);
 860   switch (tok->type)
 861     {
 862     case CPP_PADDING:
 863       goto retry;
 864     case CPP_ATSIGN:
 865       if (c_dialect_objc ())
 866         {
 867           objc_string = true;
 868           goto retry;
 869         }
 870       /* FALLTHROUGH */
 871
 872     default:
 873       break;
 874
 875     case CPP_WSTRING:
 876       wide = true;
 877       /* FALLTHROUGH */
 878
 879     case CPP_STRING:
 880       if (!concats)
 881         {
 882           gcc_obstack_init (&str_ob);
 883           obstack_grow (&str_ob, &str, sizeof (cpp_string));
 884         }
 885
 886       concats++;
 887       obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
 888       goto retry;
 889     }
 890
 891   /* We have read one more token than we want.  */
 892   _cpp_backup_tokens (parse_in, 1);
 893   if (concats)
 894     strs = XOBFINISH (&str_ob, cpp_string *);
 895
 896   if (concats && !objc_string && !in_system_header)
 897     warning (OPT_Wtraditional,
 898              "traditional C rejects string constant concatenation");
 899
 900   if ((translate
 901        ? cpp_interpret_string : cpp_interpret_string_notranslate)
 902       (parse_in, strs, concats + 1, &istr, wide))
 903     {
 904       value = build_string (istr.len, (const char *) istr.text);
 905       free (CONST_CAST (unsigned char *, istr.text));
 906     }
 907   else
 908     {
 909       /* Callers cannot generally handle error_mark_node in this context,
 910          so return the empty string instead.  cpp_interpret_string has
 911          issued an error.  */
 912       if (wide)
 913         value = build_string (TYPE_PRECISION (wchar_type_node)
 914                               / TYPE_PRECISION (char_type_node),
 915                               "\0\0\0");  /* widest supported wchar_t
 916                                              is 32 bits */
 917       else
 918         value = build_string (1, "");
 919     }
 920
 921   TREE_TYPE (value) = wide ? wchar_array_type_node : char_array_type_node;
 922   *valp = fix_string_type (value);
 923
 924   if (concats)
 925     obstack_free (&str_ob, 0);
 926
 927   return objc_string ? CPP_OBJC_STRING : wide ? CPP_WSTRING : CPP_STRING;
 928 }
 929
 930 /* Converts a (possibly wide) character constant token into a tree.  */
 931 static tree
 932 lex_charconst (const cpp_token *token)
 933 {
 934   cppchar_t result;
 935   tree type, value;
 936   unsigned int chars_seen;
 937   int unsignedp;
 938
 939   result = cpp_interpret_charconst (parse_in, token,
 940                                     &chars_seen, &unsignedp);
 941
 942   if (token->type == CPP_WCHAR)
 943     type = wchar_type_node;
 944   /* In C, a character constant has type 'int'.
 945      In C++ 'char', but multi-char charconsts have type 'int'.  */
 946   else if (!c_dialect_cxx () || chars_seen > 1)
 947     type = integer_type_node;
 948   else
 949     type = char_type_node;
 950
 951   /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
 952      before possibly widening to HOST_WIDE_INT for build_int_cst.  */
 953   if (unsignedp || (cppchar_signed_t) result >= 0)
 954     value = build_int_cst_wide (type, result, 0);
 955   else
 956     value = build_int_cst_wide (type, (cppchar_signed_t) result, -1);
 957
 958   return value;
 959 }