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