gcc/c-lex.c

   1 /* Mainly the interface between cpplib and the C front ends.
   2    Copyright (C) 1987, 1988, 1989, 1992, 1994, 1995, 1996, 1997
   3    1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26
  27 #include "real.h"
  28 #include "rtl.h"
  29 #include "tree.h"
  30 #include "input.h"
  31 #include "output.h"
  32 #include "c-tree.h"
  33 #include "c-common.h"
  34 #include "flags.h"
  35 #include "timevar.h"
  36 #include "cpplib.h"
  37 #include "c-pragma.h"
  38 #include "toplev.h"
  39 #include "intl.h"
  40 #include "tm_p.h"
  41 #include "splay-tree.h"
  42 #include "debug.h"
  43 #include "target.h"
  44
  45 /* We may keep statistics about how long which files took to compile.  */
  46 static int header_time, body_time;
  47 static splay_tree file_info_tree;
  48
  49 int pending_lang_change; /* If we need to switch languages - C++ only */
  50 int c_header_level;      /* depth in C headers - C++ only */
  51
  52 static tree interpret_integer (const cpp_token *, unsigned int);
  53 static tree interpret_float (const cpp_token *, unsigned int);
  54 static tree interpret_fixed (const cpp_token *, unsigned int);
  55 static enum integer_type_kind narrowest_unsigned_type
  56         (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
  57 static enum integer_type_kind narrowest_signed_type
  58         (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
  59 static enum cpp_ttype lex_string (const cpp_token *, tree *, bool, bool);
  60 static tree lex_charconst (const cpp_token *);
  61 static void update_header_times (const char *);
  62 static int dump_one_header (splay_tree_node, void *);
  63 static void cb_line_change (cpp_reader *, const cpp_token *, int);
  64 static void cb_ident (cpp_reader *, unsigned int, const cpp_string *);
  65 static void cb_def_pragma (cpp_reader *, unsigned int);
  66 static void cb_define (cpp_reader *, unsigned int, cpp_hashnode *);
  67 static void cb_undef (cpp_reader *, unsigned int, cpp_hashnode *);
  68 \f
  69 void
  70 init_c_lex (void)
  71 {
  72   struct cpp_callbacks *cb;
  73   struct c_fileinfo *toplevel;
  74
  75   /* The get_fileinfo data structure must be initialized before
  76      cpp_read_main_file is called.  */
  77   toplevel = get_fileinfo ("<top level>");
  78   if (flag_detailed_statistics)
  79     {
  80       header_time = 0;
  81       body_time = get_run_time ();
  82       toplevel->time = body_time;
  83     }
  84
  85   cb = cpp_get_callbacks (parse_in);
  86
  87   cb->line_change = cb_line_change;
  88   cb->ident = cb_ident;
  89   cb->def_pragma = cb_def_pragma;
  90   cb->valid_pch = c_common_valid_pch;
  91   cb->read_pch = c_common_read_pch;
  92
  93   /* Set the debug callbacks if we can use them.  */
  94   if (debug_info_level == DINFO_LEVEL_VERBOSE
  95       && (write_symbols == DWARF2_DEBUG
  96           || write_symbols == VMS_AND_DWARF2_DEBUG))
  97     {
  98       cb->define = cb_define;
  99       cb->undef = cb_undef;
 100     }
 101 }
 102
 103 struct c_fileinfo *
 104 get_fileinfo (const char *name)
 105 {
 106   splay_tree_node n;
 107   struct c_fileinfo *fi;
 108
 109   if (!file_info_tree)
 110     file_info_tree = splay_tree_new ((splay_tree_compare_fn) strcmp,
 111                                      0,
 112                                      (splay_tree_delete_value_fn) free);
 113
 114   n = splay_tree_lookup (file_info_tree, (splay_tree_key) name);
 115   if (n)
 116     return (struct c_fileinfo *) n->value;
 117
 118   fi = XNEW (struct c_fileinfo);
 119   fi->time = 0;
 120   fi->interface_only = 0;
 121   fi->interface_unknown = 1;
 122   splay_tree_insert (file_info_tree, (splay_tree_key) name,
 123                      (splay_tree_value) fi);
 124   return fi;
 125 }
 126
 127 static void
 128 update_header_times (const char *name)
 129 {
 130   /* Changing files again.  This means currently collected time
 131      is charged against header time, and body time starts back at 0.  */
 132   if (flag_detailed_statistics)
 133     {
 134       int this_time = get_run_time ();
 135       struct c_fileinfo *file = get_fileinfo (name);
 136       header_time += this_time - body_time;
 137       file->time += this_time - body_time;
 138       body_time = this_time;
 139     }
 140 }
 141
 142 static int
 143 dump_one_header (splay_tree_node n, void * ARG_UNUSED (dummy))
 144 {
 145   print_time ((const char *) n->key,
 146               ((struct c_fileinfo *) n->value)->time);
 147   return 0;
 148 }
 149
 150 void
 151 dump_time_statistics (void)
 152 {
 153   struct c_fileinfo *file = get_fileinfo (input_filename);
 154   int this_time = get_run_time ();
 155   file->time += this_time - body_time;
 156
 157   fprintf (stderr, "\n******\n");
 158   print_time ("header files (total)", header_time);
 159   print_time ("main file (total)", this_time - body_time);
 160   fprintf (stderr, "ratio = %g : 1\n",
 161            (double) header_time / (double) (this_time - body_time));
 162   fprintf (stderr, "\n******\n");
 163
 164   splay_tree_foreach (file_info_tree, dump_one_header, 0);
 165 }
 166
 167 static void
 168 cb_ident (cpp_reader * ARG_UNUSED (pfile),
 169           unsigned int ARG_UNUSED (line),
 170           const cpp_string * ARG_UNUSED (str))
 171 {
 172 #ifdef ASM_OUTPUT_IDENT
 173   if (!flag_no_ident)
 174     {
 175       /* Convert escapes in the string.  */
 176       cpp_string cstr = { 0, 0 };
 177       if (cpp_interpret_string (pfile, str, 1, &cstr, CPP_STRING))
 178         {
 179           ASM_OUTPUT_IDENT (asm_out_file, (const char *) cstr.text);
 180           free (CONST_CAST (unsigned char *, cstr.text));
 181         }
 182     }
 183 #endif
 184 }
 185
 186 /* Called at the start of every non-empty line.  TOKEN is the first
 187    lexed token on the line.  Used for diagnostic line numbers.  */
 188 static void
 189 cb_line_change (cpp_reader * ARG_UNUSED (pfile), const cpp_token *token,
 190                 int parsing_args)
 191 {
 192   if (token->type != CPP_EOF && !parsing_args)
 193     input_location = token->src_loc;
 194 }
 195
 196 void
 197 fe_file_change (const struct line_map *new_map)
 198 {
 199   if (new_map == NULL)
 200     return;
 201
 202   if (new_map->reason == LC_ENTER)
 203     {
 204       /* Don't stack the main buffer on the input stack;
 205          we already did in compile_file.  */
 206       if (!MAIN_FILE_P (new_map))
 207         {
 208           unsigned int included_at = LAST_SOURCE_LINE_LOCATION (new_map - 1);
 209           int line = 0;
 210           if (included_at > BUILTINS_LOCATION)
 211             line = SOURCE_LINE (new_map - 1, included_at);
 212
 213           input_location = new_map->start_location;
 214           (*debug_hooks->start_source_file) (line, new_map->to_file);
 215 #ifndef NO_IMPLICIT_EXTERN_C
 216           if (c_header_level)
 217             ++c_header_level;
 218           else if (new_map->sysp == 2)
 219             {
 220               c_header_level = 1;
 221               ++pending_lang_change;
 222             }
 223 #endif
 224         }
 225     }
 226   else if (new_map->reason == LC_LEAVE)
 227     {
 228 #ifndef NO_IMPLICIT_EXTERN_C
 229       if (c_header_level && --c_header_level == 0)
 230         {
 231           if (new_map->sysp == 2)
 232             warning (0, "badly nested C headers from preprocessor");
 233           --pending_lang_change;
 234         }
 235 #endif
 236       input_location = new_map->start_location;
 237
 238       (*debug_hooks->end_source_file) (new_map->to_line);
 239     }
 240
 241   update_header_times (new_map->to_file);
 242   in_system_header = new_map->sysp != 0;
 243   input_location = new_map->start_location;
 244 }
 245
 246 static void
 247 cb_def_pragma (cpp_reader *pfile, source_location loc)
 248 {
 249   /* Issue a warning message if we have been asked to do so.  Ignore
 250      unknown pragmas in system headers unless an explicit
 251      -Wunknown-pragmas has been given.  */
 252   if (warn_unknown_pragmas > in_system_header)
 253     {
 254       const unsigned char *space, *name;
 255       const cpp_token *s;
 256       location_t fe_loc = loc;
 257
 258       space = name = (const unsigned char *) "";
 259       s = cpp_get_token (pfile);
 260       if (s->type != CPP_EOF)
 261         {
 262           space = cpp_token_as_text (pfile, s);
 263           s = cpp_get_token (pfile);
 264           if (s->type == CPP_NAME)
 265             name = cpp_token_as_text (pfile, s);
 266         }
 267
 268       warning (OPT_Wunknown_pragmas, "%Hignoring #pragma %s %s",
 269                &fe_loc, space, name);
 270     }
 271 }
 272
 273 /* #define callback for DWARF and DWARF2 debug info.  */
 274 static void
 275 cb_define (cpp_reader *pfile, source_location loc, cpp_hashnode *node)
 276 {
 277   const struct line_map *map = linemap_lookup (line_table, loc);
 278   (*debug_hooks->define) (SOURCE_LINE (map, loc),
 279                           (const char *) cpp_macro_definition (pfile, node));
 280 }
 281
 282 /* #undef callback for DWARF and DWARF2 debug info.  */
 283 static void
 284 cb_undef (cpp_reader * ARG_UNUSED (pfile), source_location loc,
 285           cpp_hashnode *node)
 286 {
 287   const struct line_map *map = linemap_lookup (line_table, loc);
 288   (*debug_hooks->undef) (SOURCE_LINE (map, loc),
 289                          (const char *) NODE_NAME (node));
 290 }
 291 \f
 292 /* Read a token and return its type.  Fill *VALUE with its value, if
 293    applicable.  Fill *CPP_FLAGS with the token's flags, if it is
 294    non-NULL.  */
 295
 296 enum cpp_ttype
 297 c_lex_with_flags (tree *value, location_t *loc, unsigned char *cpp_flags,
 298                   int lex_flags)
 299 {
 300   static bool no_more_pch;
 301   const cpp_token *tok;
 302   enum cpp_ttype type;
 303   unsigned char add_flags = 0;
 304
 305   timevar_push (TV_CPP);
 306  retry:
 307   tok = cpp_get_token_with_location (parse_in, loc);
 308   type = tok->type;
 309
 310  retry_after_at:
 311   switch (type)
 312     {
 313     case CPP_PADDING:
 314       goto retry;
 315
 316     case CPP_NAME:
 317       *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
 318       break;
 319
 320     case CPP_NUMBER:
 321       {
 322         unsigned int flags = cpp_classify_number (parse_in, tok);
 323
 324         switch (flags & CPP_N_CATEGORY)
 325           {
 326           case CPP_N_INVALID:
 327             /* cpplib has issued an error.  */
 328             *value = error_mark_node;
 329             errorcount++;
 330             break;
 331
 332           case CPP_N_INTEGER:
 333             /* C++ uses '0' to mark virtual functions as pure.
 334                Set PURE_ZERO to pass this information to the C++ parser.  */
 335             if (tok->val.str.len == 1 && *tok->val.str.text == '0')
 336               add_flags = PURE_ZERO;
 337             *value = interpret_integer (tok, flags);
 338             break;
 339
 340           case CPP_N_FLOATING:
 341             *value = interpret_float (tok, flags);
 342             break;
 343
 344           default:
 345             gcc_unreachable ();
 346           }
 347       }
 348       break;
 349
 350     case CPP_ATSIGN:
 351       /* An @ may give the next token special significance in Objective-C.  */
 352       if (c_dialect_objc ())
 353         {
 354           location_t atloc = *loc;
 355           location_t newloc;
 356
 357         retry_at:
 358           tok = cpp_get_token_with_location (parse_in, &newloc);
 359           type = tok->type;
 360           switch (type)
 361             {
 362             case CPP_PADDING:
 363               goto retry_at;
 364
 365             case CPP_STRING:
 366             case CPP_WSTRING:
 367             case CPP_STRING16:
 368             case CPP_STRING32:
 369               type = lex_string (tok, value, true, true);
 370               break;
 371
 372             case CPP_NAME:
 373               *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
 374               if (objc_is_reserved_word (*value))
 375                 {
 376                   type = CPP_AT_NAME;
 377                   break;
 378                 }
 379               /* FALLTHROUGH */
 380
 381             default:
 382               /* ... or not.  */
 383               error ("%Hstray %<@%> in program", &atloc);
 384               *loc = newloc;
 385               goto retry_after_at;
 386             }
 387           break;
 388         }
 389
 390       /* FALLTHROUGH */
 391     case CPP_HASH:
 392     case CPP_PASTE:
 393       {
 394         unsigned char name[4];
 395
 396         *cpp_spell_token (parse_in, tok, name, true) = 0;
 397
 398         error ("stray %qs in program", name);
 399       }
 400
 401       goto retry;
 402
 403     case CPP_OTHER:
 404       {
 405         cppchar_t c = tok->val.str.text[0];
 406
 407         if (c == '"' || c == '\'')
 408           error ("missing terminating %c character", (int) c);
 409         else if (ISGRAPH (c))
 410           error ("stray %qc in program", (int) c);
 411         else
 412           error ("stray %<\\%o%> in program", (int) c);
 413       }
 414       goto retry;
 415
 416     case CPP_CHAR:
 417     case CPP_WCHAR:
 418     case CPP_CHAR16:
 419     case CPP_CHAR32:
 420       *value = lex_charconst (tok);
 421       break;
 422
 423     case CPP_STRING:
 424     case CPP_WSTRING:
 425     case CPP_STRING16:
 426     case CPP_STRING32:
 427       if ((lex_flags & C_LEX_RAW_STRINGS) == 0)
 428         {
 429           type = lex_string (tok, value, false,
 430                              (lex_flags & C_LEX_STRING_NO_TRANSLATE) == 0);
 431           break;
 432         }
 433       *value = build_string (tok->val.str.len, (const char *) tok->val.str.text);
 434       break;
 435
 436     case CPP_PRAGMA:
 437       *value = build_int_cst (NULL, tok->val.pragma);
 438       break;
 439
 440       /* These tokens should not be visible outside cpplib.  */
 441     case CPP_HEADER_NAME:
 442     case CPP_COMMENT:
 443     case CPP_MACRO_ARG:
 444       gcc_unreachable ();
 445
 446     default:
 447       *value = NULL_TREE;
 448       break;
 449     }
 450
 451   if (cpp_flags)
 452     *cpp_flags = tok->flags | add_flags;
 453
 454   if (!no_more_pch)
 455     {
 456       no_more_pch = true;
 457       c_common_no_more_pch ();
 458     }
 459
 460   timevar_pop (TV_CPP);
 461
 462   return type;
 463 }
 464
 465 /* Returns the narrowest C-visible unsigned type, starting with the
 466    minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
 467    there isn't one.  */
 468
 469 static enum integer_type_kind
 470 narrowest_unsigned_type (unsigned HOST_WIDE_INT low,
 471                          unsigned HOST_WIDE_INT high,
 472                          unsigned int flags)
 473 {
 474   int itk;
 475
 476   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 477     itk = itk_unsigned_int;
 478   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 479     itk = itk_unsigned_long;
 480   else
 481     itk = itk_unsigned_long_long;
 482
 483   for (; itk < itk_none; itk += 2 /* skip unsigned types */)
 484     {
 485       tree upper = TYPE_MAX_VALUE (integer_types[itk]);
 486
 487       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
 488           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
 489               && TREE_INT_CST_LOW (upper) >= low))
 490         return (enum integer_type_kind) itk;
 491     }
 492
 493   return itk_none;
 494 }
 495
 496 /* Ditto, but narrowest signed type.  */
 497 static enum integer_type_kind
 498 narrowest_signed_type (unsigned HOST_WIDE_INT low,
 499                        unsigned HOST_WIDE_INT high, unsigned int flags)
 500 {
 501   int itk;
 502
 503   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 504     itk = itk_int;
 505   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 506     itk = itk_long;
 507   else
 508     itk = itk_long_long;
 509
 510
 511   for (; itk < itk_none; itk += 2 /* skip signed types */)
 512     {
 513       tree upper = TYPE_MAX_VALUE (integer_types[itk]);
 514
 515       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
 516           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
 517               && TREE_INT_CST_LOW (upper) >= low))
 518         return (enum integer_type_kind) itk;
 519     }
 520
 521   return itk_none;
 522 }
 523
 524 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib.  */
 525 static tree
 526 interpret_integer (const cpp_token *token, unsigned int flags)
 527 {
 528   tree value, type;
 529   enum integer_type_kind itk;
 530   cpp_num integer;
 531   cpp_options *options = cpp_get_options (parse_in);
 532
 533   integer = cpp_interpret_integer (parse_in, token, flags);
 534   integer = cpp_num_sign_extend (integer, options->precision);
 535
 536   /* The type of a constant with a U suffix is straightforward.  */
 537   if (flags & CPP_N_UNSIGNED)
 538     itk = narrowest_unsigned_type (integer.low, integer.high, flags);
 539   else
 540     {
 541       /* The type of a potentially-signed integer constant varies
 542          depending on the base it's in, the standard in use, and the
 543          length suffixes.  */
 544       enum integer_type_kind itk_u
 545         = narrowest_unsigned_type (integer.low, integer.high, flags);
 546       enum integer_type_kind itk_s
 547         = narrowest_signed_type (integer.low, integer.high, flags);
 548
 549       /* In both C89 and C99, octal and hex constants may be signed or
 550          unsigned, whichever fits tighter.  We do not warn about this
 551          choice differing from the traditional choice, as the constant
 552          is probably a bit pattern and either way will work.  */
 553       if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
 554         itk = MIN (itk_u, itk_s);
 555       else
 556         {
 557           /* In C99, decimal constants are always signed.
 558              In C89, decimal constants that don't fit in long have
 559              undefined behavior; we try to make them unsigned long.
 560              In GCC's extended C89, that last is true of decimal
 561              constants that don't fit in long long, too.  */
 562
 563           itk = itk_s;
 564           if (itk_s > itk_u && itk_s > itk_long)
 565             {
 566               if (!flag_isoc99)
 567                 {
 568                   if (itk_u < itk_unsigned_long)
 569                     itk_u = itk_unsigned_long;
 570                   itk = itk_u;
 571                   warning (0, "this decimal constant is unsigned only in ISO C90");
 572                 }
 573               else
 574                 warning (OPT_Wtraditional,
 575                          "this decimal constant would be unsigned in ISO C90");
 576             }
 577         }
 578     }
 579
 580   if (itk == itk_none)
 581     /* cpplib has already issued a warning for overflow.  */
 582     type = ((flags & CPP_N_UNSIGNED)
 583             ? widest_unsigned_literal_type_node
 584             : widest_integer_literal_type_node);
 585   else
 586     type = integer_types[itk];
 587
 588   if (itk > itk_unsigned_long
 589       && (flags & CPP_N_WIDTH) != CPP_N_LARGE
 590       && !in_system_header && !flag_isoc99)
 591     pedwarn ("integer constant is too large for %qs type",
 592              (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long");
 593
 594   value = build_int_cst_wide (type, integer.low, integer.high);
 595
 596   /* Convert imaginary to a complex type.  */
 597   if (flags & CPP_N_IMAGINARY)
 598     value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
 599
 600   return value;
 601 }
 602
 603 /* Interpret TOKEN, a floating point number with FLAGS as classified
 604    by cpplib.  */
 605 static tree
 606 interpret_float (const cpp_token *token, unsigned int flags)
 607 {
 608   tree type;
 609   tree value;
 610   REAL_VALUE_TYPE real;
 611   char *copy;
 612   size_t copylen;
 613
 614   /* Decode _Fract and _Accum.  */
 615   if (flags & CPP_N_FRACT || flags & CPP_N_ACCUM)
 616     return interpret_fixed (token, flags);
 617
 618   /* Decode type based on width and properties. */
 619   if (flags & CPP_N_DFLOAT)
 620     if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 621       type = dfloat128_type_node;
 622     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 623       type = dfloat32_type_node;
 624     else
 625       type = dfloat64_type_node;
 626   else
 627     if (flags & CPP_N_WIDTH_MD)
 628       {
 629         char suffix;
 630         enum machine_mode mode;
 631
 632         if ((flags & CPP_N_WIDTH_MD) == CPP_N_MD_W)
 633           suffix = 'w';
 634         else
 635           suffix = 'q';
 636
 637         mode = targetm.c.mode_for_suffix (suffix);
 638         if (mode == VOIDmode)
 639           {
 640             error ("unsupported non-standard suffix on floating constant");
 641             errorcount++;
 642
 643             return error_mark_node;
 644           }
 645         else if (pedantic)
 646           pedwarn ("non-standard suffix on floating constant");
 647
 648         type = c_common_type_for_mode (mode, 0);
 649         gcc_assert (type);
 650       }
 651     else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 652       type = long_double_type_node;
 653     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
 654              || flag_single_precision_constant)
 655       type = float_type_node;
 656     else
 657       type = double_type_node;
 658
 659   /* Copy the constant to a nul-terminated buffer.  If the constant
 660      has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
 661      can't handle them.  */
 662   copylen = token->val.str.len;
 663   if (flags & CPP_N_DFLOAT)
 664     copylen -= 2;
 665   else
 666     {
 667       if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
 668         /* Must be an F or L or machine defined suffix.  */
 669         copylen--;
 670       if (flags & CPP_N_IMAGINARY)
 671         /* I or J suffix.  */
 672         copylen--;
 673     }
 674
 675   copy = (char *) alloca (copylen + 1);
 676   memcpy (copy, token->val.str.text, copylen);
 677   copy[copylen] = '\0';
 678
 679   real_from_string3 (&real, copy, TYPE_MODE (type));
 680
 681   /* Both C and C++ require a diagnostic for a floating constant
 682      outside the range of representable values of its type.  Since we
 683      have __builtin_inf* to produce an infinity, this is now a
 684      mandatory pedwarn if the target does not support infinities.  */
 685   if (REAL_VALUE_ISINF (real))
 686     {
 687       if (!MODE_HAS_INFINITIES (TYPE_MODE (type)))
 688         pedwarn ("floating constant exceeds range of %qT", type);
 689       else
 690         warning (OPT_Woverflow, "floating constant exceeds range of %qT", type);
 691     }
 692   /* We also give a warning if the value underflows.  */
 693   else if (REAL_VALUES_EQUAL (real, dconst0))
 694     {
 695       REAL_VALUE_TYPE realvoidmode;
 696       int overflow = real_from_string (&realvoidmode, copy);
 697       if (overflow < 0 || !REAL_VALUES_EQUAL (realvoidmode, dconst0))
 698         warning (OPT_Woverflow, "floating constant truncated to zero");
 699     }
 700
 701   /* Create a node with determined type and value.  */
 702   value = build_real (type, real);
 703   if (flags & CPP_N_IMAGINARY)
 704     value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
 705
 706   return value;
 707 }
 708
 709 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
 710    by cpplib.  */
 711
 712 static tree
 713 interpret_fixed (const cpp_token *token, unsigned int flags)
 714 {
 715   tree type;
 716   tree value;
 717   FIXED_VALUE_TYPE fixed;
 718   char *copy;
 719   size_t copylen;
 720
 721   copylen = token->val.str.len;
 722
 723   if (flags & CPP_N_FRACT) /* _Fract.  */
 724     {
 725       if (flags & CPP_N_UNSIGNED) /* Unsigned _Fract.  */
 726         {
 727           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 728             {
 729               type = unsigned_long_long_fract_type_node;
 730               copylen -= 4;
 731             }
 732           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 733             {
 734               type = unsigned_long_fract_type_node;
 735               copylen -= 3;
 736             }
 737           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 738             {
 739               type = unsigned_short_fract_type_node;
 740               copylen -= 3;
 741             }
 742           else
 743             {
 744               type = unsigned_fract_type_node;
 745               copylen -= 2;
 746             }
 747         }
 748       else /* Signed _Fract.  */
 749         {
 750           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 751             {
 752               type = long_long_fract_type_node;
 753               copylen -= 3;
 754             }
 755           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 756             {
 757               type = long_fract_type_node;
 758               copylen -= 2;
 759             }
 760           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 761             {
 762               type = short_fract_type_node;
 763               copylen -= 2;
 764             }
 765           else
 766             {
 767               type = fract_type_node;
 768               copylen --;
 769             }
 770           }
 771     }
 772   else /* _Accum.  */
 773     {
 774       if (flags & CPP_N_UNSIGNED) /* Unsigned _Accum.  */
 775         {
 776           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 777             {
 778               type = unsigned_long_long_accum_type_node;
 779               copylen -= 4;
 780             }
 781           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 782             {
 783               type = unsigned_long_accum_type_node;
 784               copylen -= 3;
 785             }
 786           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 787             {
 788               type = unsigned_short_accum_type_node;
 789               copylen -= 3;
 790              }
 791           else
 792             {
 793               type = unsigned_accum_type_node;
 794               copylen -= 2;
 795             }
 796         }
 797       else /* Signed _Accum.  */
 798         {
 799           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 800             {
 801               type = long_long_accum_type_node;
 802               copylen -= 3;
 803             }
 804           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 805             {
 806               type = long_accum_type_node;
 807               copylen -= 2;
 808             }
 809           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 810             {
 811               type = short_accum_type_node;
 812               copylen -= 2;
 813             }
 814           else
 815             {
 816               type = accum_type_node;
 817               copylen --;
 818             }
 819         }
 820     }
 821
 822   copy = (char *) alloca (copylen + 1);
 823   memcpy (copy, token->val.str.text, copylen);
 824   copy[copylen] = '\0';
 825
 826   fixed_from_string (&fixed, copy, TYPE_MODE (type));
 827
 828   /* Create a node with determined type and value.  */
 829   value = build_fixed (type, fixed);
 830
 831   return value;
 832 }
 833
 834 /* Convert a series of STRING, WSTRING, STRING16 and/or STRING32 tokens
 835    into a tree, performing string constant concatenation.  TOK is the
 836    first of these.  VALP is the location to write the string into.
 837    OBJC_STRING indicates whether an '@' token preceded the incoming token.
 838    Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
 839    CPP_STRING32, CPP_STRING16, or CPP_OBJC_STRING).
 840
 841    This is unfortunately more work than it should be.  If any of the
 842    strings in the series has an L prefix, the result is a wide string
 843    (6.4.5p4).  Whether or not the result is a wide string affects the
 844    meaning of octal and hexadecimal escapes (6.4.4.4p6,9).  But escape
 845    sequences do not continue across the boundary between two strings in
 846    a series (6.4.5p7), so we must not lose the boundaries.  Therefore
 847    cpp_interpret_string takes a vector of cpp_string structures, which
 848    we must arrange to provide.  */
 849
 850 static enum cpp_ttype
 851 lex_string (const cpp_token *tok, tree *valp, bool objc_string, bool translate)
 852 {
 853   tree value;
 854   size_t concats = 0;
 855   struct obstack str_ob;
 856   cpp_string istr;
 857   enum cpp_ttype type = tok->type;
 858
 859   /* Try to avoid the overhead of creating and destroying an obstack
 860      for the common case of just one string.  */
 861   cpp_string str = tok->val.str;
 862   cpp_string *strs = &str;
 863
 864  retry:
 865   tok = cpp_get_token (parse_in);
 866   switch (tok->type)
 867     {
 868     case CPP_PADDING:
 869       goto retry;
 870     case CPP_ATSIGN:
 871       if (c_dialect_objc ())
 872         {
 873           objc_string = true;
 874           goto retry;
 875         }
 876       /* FALLTHROUGH */
 877
 878     default:
 879       break;
 880
 881     case CPP_WSTRING:
 882     case CPP_STRING16:
 883     case CPP_STRING32:
 884       if (type != tok->type)
 885         {
 886           if (type == CPP_STRING)
 887             type = tok->type;
 888           else
 889             error ("unsupported non-standard concatenation of string literals");
 890         }
 891
 892     case CPP_STRING:
 893       if (!concats)
 894         {
 895           gcc_obstack_init (&str_ob);
 896           obstack_grow (&str_ob, &str, sizeof (cpp_string));
 897         }
 898
 899       concats++;
 900       obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
 901       goto retry;
 902     }
 903
 904   /* We have read one more token than we want.  */
 905   _cpp_backup_tokens (parse_in, 1);
 906   if (concats)
 907     strs = XOBFINISH (&str_ob, cpp_string *);
 908
 909   if (concats && !objc_string && !in_system_header)
 910     warning (OPT_Wtraditional,
 911              "traditional C rejects string constant concatenation");
 912
 913   if ((translate
 914        ? cpp_interpret_string : cpp_interpret_string_notranslate)
 915       (parse_in, strs, concats + 1, &istr, type))
 916     {
 917       value = build_string (istr.len, (const char *) istr.text);
 918       free (CONST_CAST (unsigned char *, istr.text));
 919     }
 920   else
 921     {
 922       /* Callers cannot generally handle error_mark_node in this context,
 923          so return the empty string instead.  cpp_interpret_string has
 924          issued an error.  */
 925       switch (type)
 926         {
 927         default:
 928         case CPP_STRING:
 929           value = build_string (1, "");
 930           break;
 931         case CPP_STRING16:
 932           value = build_string (TYPE_PRECISION (char16_type_node)
 933                                 / TYPE_PRECISION (char_type_node),
 934                                 "\0");  /* char16_t is 16 bits */
 935           break;
 936         case CPP_STRING32:
 937           value = build_string (TYPE_PRECISION (char32_type_node)
 938                                 / TYPE_PRECISION (char_type_node),
 939                                 "\0\0\0");  /* char32_t is 32 bits */
 940           break;
 941         case CPP_WSTRING:
 942           value = build_string (TYPE_PRECISION (wchar_type_node)
 943                                 / TYPE_PRECISION (char_type_node),
 944                                 "\0\0\0");  /* widest supported wchar_t
 945                                                is 32 bits */
 946           break;
 947         }
 948     }
 949
 950   switch (type)
 951     {
 952     default:
 953     case CPP_STRING:
 954       TREE_TYPE (value) = char_array_type_node;
 955       break;
 956     case CPP_STRING16:
 957       TREE_TYPE (value) = char16_array_type_node;
 958       break;
 959     case CPP_STRING32:
 960       TREE_TYPE (value) = char32_array_type_node;
 961       break;
 962     case CPP_WSTRING:
 963       TREE_TYPE (value) = wchar_array_type_node;
 964     }
 965   *valp = fix_string_type (value);
 966
 967   if (concats)
 968     obstack_free (&str_ob, 0);
 969
 970   return objc_string ? CPP_OBJC_STRING : type;
 971 }
 972
 973 /* Converts a (possibly wide) character constant token into a tree.  */
 974 static tree
 975 lex_charconst (const cpp_token *token)
 976 {
 977   cppchar_t result;
 978   tree type, value;
 979   unsigned int chars_seen;
 980   int unsignedp;
 981
 982   result = cpp_interpret_charconst (parse_in, token,
 983                                     &chars_seen, &unsignedp);
 984
 985   if (token->type == CPP_WCHAR)
 986     type = wchar_type_node;
 987   else if (token->type == CPP_CHAR32)
 988     type = char32_type_node;
 989   else if (token->type == CPP_CHAR16)
 990     type = char16_type_node;
 991   /* In C, a character constant has type 'int'.
 992      In C++ 'char', but multi-char charconsts have type 'int'.  */
 993   else if (!c_dialect_cxx () || chars_seen > 1)
 994     type = integer_type_node;
 995   else
 996     type = char_type_node;
 997
 998   /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
 999      before possibly widening to HOST_WIDE_INT for build_int_cst.  */
1000   if (unsignedp || (cppchar_signed_t) result >= 0)
1001     value = build_int_cst_wide (type, result, 0);
1002   else
1003     value = build_int_cst_wide (type, (cppchar_signed_t) result, -1);
1004
1005   return value;
1006 }