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 "fixed-value.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 "splay-tree.h"
  41 #include "debug.h"
  42 #include "target.h"
  43
  44 /* We may keep statistics about how long which files took to compile.  */
  45 static int header_time, body_time;
  46 static splay_tree file_info_tree;
  47
  48 int pending_lang_change; /* If we need to switch languages - C++ only */
  49 int c_header_level;      /* depth in C headers - C++ only */
  50
  51 static tree interpret_integer (const cpp_token *, unsigned int);
  52 static tree interpret_float (const cpp_token *, unsigned int);
  53 static tree interpret_fixed (const cpp_token *, unsigned int);
  54 static enum integer_type_kind narrowest_unsigned_type
  55         (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
  56 static enum integer_type_kind narrowest_signed_type
  57         (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
  58 static enum cpp_ttype lex_string (const cpp_token *, tree *, bool, bool);
  59 static tree lex_charconst (const cpp_token *);
  60 static void update_header_times (const char *);
  61 static int dump_one_header (splay_tree_node, void *);
  62 static void cb_line_change (cpp_reader *, const cpp_token *, int);
  63 static void cb_ident (cpp_reader *, unsigned int, const cpp_string *);
  64 static void cb_def_pragma (cpp_reader *, unsigned int);
  65 static void cb_define (cpp_reader *, unsigned int, cpp_hashnode *);
  66 static void cb_undef (cpp_reader *, unsigned int, cpp_hashnode *);
  67 \f
  68 void
  69 init_c_lex (void)
  70 {
  71   struct cpp_callbacks *cb;
  72   struct c_fileinfo *toplevel;
  73
  74   /* The get_fileinfo data structure must be initialized before
  75      cpp_read_main_file is called.  */
  76   toplevel = get_fileinfo ("<top level>");
  77   if (flag_detailed_statistics)
  78     {
  79       header_time = 0;
  80       body_time = get_run_time ();
  81       toplevel->time = body_time;
  82     }
  83
  84   cb = cpp_get_callbacks (parse_in);
  85
  86   cb->line_change = cb_line_change;
  87   cb->ident = cb_ident;
  88   cb->def_pragma = cb_def_pragma;
  89   cb->valid_pch = c_common_valid_pch;
  90   cb->read_pch = c_common_read_pch;
  91
  92   /* Set the debug callbacks if we can use them.  */
  93   if (debug_info_level == DINFO_LEVEL_VERBOSE
  94       && (write_symbols == DWARF2_DEBUG
  95           || write_symbols == VMS_AND_DWARF2_DEBUG))
  96     {
  97       cb->define = cb_define;
  98       cb->undef = cb_undef;
  99     }
 100 }
 101
 102 struct c_fileinfo *
 103 get_fileinfo (const char *name)
 104 {
 105   splay_tree_node n;
 106   struct c_fileinfo *fi;
 107
 108   if (!file_info_tree)
 109     file_info_tree = splay_tree_new ((splay_tree_compare_fn) strcmp,
 110                                      0,
 111                                      (splay_tree_delete_value_fn) free);
 112
 113   n = splay_tree_lookup (file_info_tree, (splay_tree_key) name);
 114   if (n)
 115     return (struct c_fileinfo *) n->value;
 116
 117   fi = XNEW (struct c_fileinfo);
 118   fi->time = 0;
 119   fi->interface_only = 0;
 120   fi->interface_unknown = 1;
 121   splay_tree_insert (file_info_tree, (splay_tree_key) name,
 122                      (splay_tree_value) fi);
 123   return fi;
 124 }
 125
 126 static void
 127 update_header_times (const char *name)
 128 {
 129   /* Changing files again.  This means currently collected time
 130      is charged against header time, and body time starts back at 0.  */
 131   if (flag_detailed_statistics)
 132     {
 133       int this_time = get_run_time ();
 134       struct c_fileinfo *file = get_fileinfo (name);
 135       header_time += this_time - body_time;
 136       file->time += this_time - body_time;
 137       body_time = this_time;
 138     }
 139 }
 140
 141 static int
 142 dump_one_header (splay_tree_node n, void * ARG_UNUSED (dummy))
 143 {
 144   print_time ((const char *) n->key,
 145               ((struct c_fileinfo *) n->value)->time);
 146   return 0;
 147 }
 148
 149 void
 150 dump_time_statistics (void)
 151 {
 152   struct c_fileinfo *file = get_fileinfo (input_filename);
 153   int this_time = get_run_time ();
 154   file->time += this_time - body_time;
 155
 156   fprintf (stderr, "\n******\n");
 157   print_time ("header files (total)", header_time);
 158   print_time ("main file (total)", this_time - body_time);
 159   fprintf (stderr, "ratio = %g : 1\n",
 160            (double) header_time / (double) (this_time - body_time));
 161   fprintf (stderr, "\n******\n");
 162
 163   splay_tree_foreach (file_info_tree, dump_one_header, 0);
 164 }
 165
 166 static void
 167 cb_ident (cpp_reader * ARG_UNUSED (pfile),
 168           unsigned int ARG_UNUSED (line),
 169           const cpp_string * ARG_UNUSED (str))
 170 {
 171 #ifdef ASM_OUTPUT_IDENT
 172   if (!flag_no_ident)
 173     {
 174       /* Convert escapes in the string.  */
 175       cpp_string cstr = { 0, 0 };
 176       if (cpp_interpret_string (pfile, str, 1, &cstr, CPP_STRING))
 177         {
 178           ASM_OUTPUT_IDENT (asm_out_file, (const char *) cstr.text);
 179           free (CONST_CAST (unsigned char *, cstr.text));
 180         }
 181     }
 182 #endif
 183 }
 184
 185 /* Called at the start of every non-empty line.  TOKEN is the first
 186    lexed token on the line.  Used for diagnostic line numbers.  */
 187 static void
 188 cb_line_change (cpp_reader * ARG_UNUSED (pfile), const cpp_token *token,
 189                 int parsing_args)
 190 {
 191   if (token->type != CPP_EOF && !parsing_args)
 192     input_location = token->src_loc;
 193 }
 194
 195 void
 196 fe_file_change (const struct line_map *new_map)
 197 {
 198   if (new_map == NULL)
 199     return;
 200
 201   if (new_map->reason == LC_ENTER)
 202     {
 203       /* Don't stack the main buffer on the input stack;
 204          we already did in compile_file.  */
 205       if (!MAIN_FILE_P (new_map))
 206         {
 207           unsigned int included_at = LAST_SOURCE_LINE_LOCATION (new_map - 1);
 208           int line = 0;
 209           if (included_at > BUILTINS_LOCATION)
 210             line = SOURCE_LINE (new_map - 1, included_at);
 211
 212           input_location = new_map->start_location;
 213           (*debug_hooks->start_source_file) (line, new_map->to_file);
 214 #ifndef NO_IMPLICIT_EXTERN_C
 215           if (c_header_level)
 216             ++c_header_level;
 217           else if (new_map->sysp == 2)
 218             {
 219               c_header_level = 1;
 220               ++pending_lang_change;
 221             }
 222 #endif
 223         }
 224     }
 225   else if (new_map->reason == LC_LEAVE)
 226     {
 227 #ifndef NO_IMPLICIT_EXTERN_C
 228       if (c_header_level && --c_header_level == 0)
 229         {
 230           if (new_map->sysp == 2)
 231             warning (0, "badly nested C headers from preprocessor");
 232           --pending_lang_change;
 233         }
 234 #endif
 235       input_location = new_map->start_location;
 236
 237       (*debug_hooks->end_source_file) (new_map->to_line);
 238     }
 239
 240   update_header_times (new_map->to_file);
 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_at (fe_loc, OPT_Wunknown_pragmas, "ignoring #pragma %s %s",
 267                   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.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             case CPP_STRING16:
 366             case CPP_STRING32:
 367             case CPP_UTF8STRING:
 368               type = lex_string (tok, value, true, true);
 369               break;
 370
 371             case CPP_NAME:
 372               *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node.node));
 373               if (objc_is_reserved_word (*value))
 374                 {
 375                   type = CPP_AT_NAME;
 376                   break;
 377                 }
 378               /* FALLTHROUGH */
 379
 380             default:
 381               /* ... or not.  */
 382               error_at (atloc, "stray %<@%> in program");
 383               *loc = newloc;
 384               goto retry_after_at;
 385             }
 386           break;
 387         }
 388
 389       /* FALLTHROUGH */
 390     case CPP_HASH:
 391     case CPP_PASTE:
 392       {
 393         unsigned char name[8];
 394
 395         *cpp_spell_token (parse_in, tok, name, true) = 0;
 396
 397         error ("stray %qs in program", name);
 398       }
 399
 400       goto retry;
 401
 402     case CPP_OTHER:
 403       {
 404         cppchar_t c = tok->val.str.text[0];
 405
 406         if (c == '"' || c == '\'')
 407           error ("missing terminating %c character", (int) c);
 408         else if (ISGRAPH (c))
 409           error ("stray %qc in program", (int) c);
 410         else
 411           error ("stray %<\\%o%> in program", (int) c);
 412       }
 413       goto retry;
 414
 415     case CPP_CHAR:
 416     case CPP_WCHAR:
 417     case CPP_CHAR16:
 418     case CPP_CHAR32:
 419       *value = lex_charconst (tok);
 420       break;
 421
 422     case CPP_STRING:
 423     case CPP_WSTRING:
 424     case CPP_STRING16:
 425     case CPP_STRING32:
 426     case CPP_UTF8STRING:
 427       if ((lex_flags & C_LEX_STRING_NO_JOIN) == 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     {
 587       type = integer_types[itk];
 588       if (itk > itk_unsigned_long
 589           && (flags & CPP_N_WIDTH) != CPP_N_LARGE)
 590         emit_diagnostic
 591           ((c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99)
 592            ? DK_PEDWARN : DK_WARNING,
 593            input_location, OPT_Wlong_long,
 594            (flags & CPP_N_UNSIGNED)
 595            ? "integer constant is too large for %<unsigned long%> type"
 596            : "integer constant is too large for %<long%> type");
 597     }
 598
 599   value = build_int_cst_wide (type, integer.low, integer.high);
 600
 601   /* Convert imaginary to a complex type.  */
 602   if (flags & CPP_N_IMAGINARY)
 603     value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
 604
 605   return value;
 606 }
 607
 608 /* Interpret TOKEN, a floating point number with FLAGS as classified
 609    by cpplib.  */
 610 static tree
 611 interpret_float (const cpp_token *token, unsigned int flags)
 612 {
 613   tree type;
 614   tree const_type;
 615   tree value;
 616   REAL_VALUE_TYPE real;
 617   REAL_VALUE_TYPE real_trunc;
 618   char *copy;
 619   size_t copylen;
 620
 621   /* Default (no suffix) depends on whether the FLOAT_CONST_DECIMAL64
 622      pragma has been used and is either double or _Decimal64.  Types
 623      that are not allowed with decimal float default to double.  */
 624   if (flags & CPP_N_DEFAULT)
 625     {
 626       flags ^= CPP_N_DEFAULT;
 627       flags |= CPP_N_MEDIUM;
 628
 629       if (((flags & CPP_N_HEX) == 0) && ((flags & CPP_N_IMAGINARY) == 0))
 630         {
 631           warning (OPT_Wunsuffixed_float_constants,
 632                    "unsuffixed float constant");
 633           if (float_const_decimal64_p ())
 634             flags |= CPP_N_DFLOAT;
 635         }
 636     }
 637
 638   /* Decode _Fract and _Accum.  */
 639   if (flags & CPP_N_FRACT || flags & CPP_N_ACCUM)
 640     return interpret_fixed (token, flags);
 641
 642   /* Decode type based on width and properties. */
 643   if (flags & CPP_N_DFLOAT)
 644     if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 645       type = dfloat128_type_node;
 646     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 647       type = dfloat32_type_node;
 648     else
 649       type = dfloat64_type_node;
 650   else
 651     if (flags & CPP_N_WIDTH_MD)
 652       {
 653         char suffix;
 654         enum machine_mode mode;
 655
 656         if ((flags & CPP_N_WIDTH_MD) == CPP_N_MD_W)
 657           suffix = 'w';
 658         else
 659           suffix = 'q';
 660
 661         mode = targetm.c.mode_for_suffix (suffix);
 662         if (mode == VOIDmode)
 663           {
 664             error ("unsupported non-standard suffix on floating constant");
 665             errorcount++;
 666
 667             return error_mark_node;
 668           }
 669         else
 670           pedwarn (input_location, OPT_pedantic, "non-standard suffix on floating constant");
 671
 672         type = c_common_type_for_mode (mode, 0);
 673         gcc_assert (type);
 674       }
 675     else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 676       type = long_double_type_node;
 677     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
 678              || flag_single_precision_constant)
 679       type = float_type_node;
 680     else
 681       type = double_type_node;
 682
 683   const_type = excess_precision_type (type);
 684   if (!const_type)
 685     const_type = type;
 686
 687   /* Copy the constant to a nul-terminated buffer.  If the constant
 688      has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
 689      can't handle them.  */
 690   copylen = token->val.str.len;
 691   if (flags & CPP_N_DFLOAT)
 692     copylen -= 2;
 693   else
 694     {
 695       if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
 696         /* Must be an F or L or machine defined suffix.  */
 697         copylen--;
 698       if (flags & CPP_N_IMAGINARY)
 699         /* I or J suffix.  */
 700         copylen--;
 701     }
 702
 703   copy = (char *) alloca (copylen + 1);
 704   memcpy (copy, token->val.str.text, copylen);
 705   copy[copylen] = '\0';
 706
 707   real_from_string3 (&real, copy, TYPE_MODE (const_type));
 708   if (const_type != type)
 709     /* Diagnosing if the result of converting the value with excess
 710        precision to the semantic type would overflow (with associated
 711        double rounding) is more appropriate than diagnosing if the
 712        result of converting the string directly to the semantic type
 713        would overflow.  */
 714     real_convert (&real_trunc, TYPE_MODE (type), &real);
 715
 716   /* Both C and C++ require a diagnostic for a floating constant
 717      outside the range of representable values of its type.  Since we
 718      have __builtin_inf* to produce an infinity, this is now a
 719      mandatory pedwarn if the target does not support infinities.  */
 720   if (REAL_VALUE_ISINF (real)
 721       || (const_type != type && REAL_VALUE_ISINF (real_trunc)))
 722     {
 723       if (!MODE_HAS_INFINITIES (TYPE_MODE (type)))
 724         pedwarn (input_location, 0, "floating constant exceeds range of %qT", type);
 725       else
 726         warning (OPT_Woverflow, "floating constant exceeds range of %qT", type);
 727     }
 728   /* We also give a warning if the value underflows.  */
 729   else if (REAL_VALUES_EQUAL (real, dconst0)
 730            || (const_type != type && REAL_VALUES_EQUAL (real_trunc, dconst0)))
 731     {
 732       REAL_VALUE_TYPE realvoidmode;
 733       int overflow = real_from_string (&realvoidmode, copy);
 734       if (overflow < 0 || !REAL_VALUES_EQUAL (realvoidmode, dconst0))
 735         warning (OPT_Woverflow, "floating constant truncated to zero");
 736     }
 737
 738   /* Create a node with determined type and value.  */
 739   value = build_real (const_type, real);
 740   if (flags & CPP_N_IMAGINARY)
 741     value = build_complex (NULL_TREE, convert (const_type, integer_zero_node),
 742                            value);
 743
 744   if (type != const_type)
 745     value = build1 (EXCESS_PRECISION_EXPR, type, value);
 746
 747   return value;
 748 }
 749
 750 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
 751    by cpplib.  */
 752
 753 static tree
 754 interpret_fixed (const cpp_token *token, unsigned int flags)
 755 {
 756   tree type;
 757   tree value;
 758   FIXED_VALUE_TYPE fixed;
 759   char *copy;
 760   size_t copylen;
 761
 762   copylen = token->val.str.len;
 763
 764   if (flags & CPP_N_FRACT) /* _Fract.  */
 765     {
 766       if (flags & CPP_N_UNSIGNED) /* Unsigned _Fract.  */
 767         {
 768           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 769             {
 770               type = unsigned_long_long_fract_type_node;
 771               copylen -= 4;
 772             }
 773           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 774             {
 775               type = unsigned_long_fract_type_node;
 776               copylen -= 3;
 777             }
 778           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 779             {
 780               type = unsigned_short_fract_type_node;
 781               copylen -= 3;
 782             }
 783           else
 784             {
 785               type = unsigned_fract_type_node;
 786               copylen -= 2;
 787             }
 788         }
 789       else /* Signed _Fract.  */
 790         {
 791           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 792             {
 793               type = long_long_fract_type_node;
 794               copylen -= 3;
 795             }
 796           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 797             {
 798               type = long_fract_type_node;
 799               copylen -= 2;
 800             }
 801           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 802             {
 803               type = short_fract_type_node;
 804               copylen -= 2;
 805             }
 806           else
 807             {
 808               type = fract_type_node;
 809               copylen --;
 810             }
 811           }
 812     }
 813   else /* _Accum.  */
 814     {
 815       if (flags & CPP_N_UNSIGNED) /* Unsigned _Accum.  */
 816         {
 817           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 818             {
 819               type = unsigned_long_long_accum_type_node;
 820               copylen -= 4;
 821             }
 822           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 823             {
 824               type = unsigned_long_accum_type_node;
 825               copylen -= 3;
 826             }
 827           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 828             {
 829               type = unsigned_short_accum_type_node;
 830               copylen -= 3;
 831              }
 832           else
 833             {
 834               type = unsigned_accum_type_node;
 835               copylen -= 2;
 836             }
 837         }
 838       else /* Signed _Accum.  */
 839         {
 840           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 841             {
 842               type = long_long_accum_type_node;
 843               copylen -= 3;
 844             }
 845           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 846             {
 847               type = long_accum_type_node;
 848               copylen -= 2;
 849             }
 850           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 851             {
 852               type = short_accum_type_node;
 853               copylen -= 2;
 854             }
 855           else
 856             {
 857               type = accum_type_node;
 858               copylen --;
 859             }
 860         }
 861     }
 862
 863   copy = (char *) alloca (copylen + 1);
 864   memcpy (copy, token->val.str.text, copylen);
 865   copy[copylen] = '\0';
 866
 867   fixed_from_string (&fixed, copy, TYPE_MODE (type));
 868
 869   /* Create a node with determined type and value.  */
 870   value = build_fixed (type, fixed);
 871
 872   return value;
 873 }
 874
 875 /* Convert a series of STRING, WSTRING, STRING16, STRING32 and/or
 876    UTF8STRING tokens into a tree, performing string constant
 877    concatenation.  TOK is the first of these.  VALP is the location
 878    to write the string into. OBJC_STRING indicates whether an '@' token
 879    preceded the incoming token.
 880    Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
 881    CPP_STRING32, CPP_STRING16, CPP_UTF8STRING, or CPP_OBJC_STRING).
 882
 883    This is unfortunately more work than it should be.  If any of the
 884    strings in the series has an L prefix, the result is a wide string
 885    (6.4.5p4).  Whether or not the result is a wide string affects the
 886    meaning of octal and hexadecimal escapes (6.4.4.4p6,9).  But escape
 887    sequences do not continue across the boundary between two strings in
 888    a series (6.4.5p7), so we must not lose the boundaries.  Therefore
 889    cpp_interpret_string takes a vector of cpp_string structures, which
 890    we must arrange to provide.  */
 891
 892 static enum cpp_ttype
 893 lex_string (const cpp_token *tok, tree *valp, bool objc_string, bool translate)
 894 {
 895   tree value;
 896   size_t concats = 0;
 897   struct obstack str_ob;
 898   cpp_string istr;
 899   enum cpp_ttype type = tok->type;
 900
 901   /* Try to avoid the overhead of creating and destroying an obstack
 902      for the common case of just one string.  */
 903   cpp_string str = tok->val.str;
 904   cpp_string *strs = &str;
 905
 906  retry:
 907   tok = cpp_get_token (parse_in);
 908   switch (tok->type)
 909     {
 910     case CPP_PADDING:
 911       goto retry;
 912     case CPP_ATSIGN:
 913       if (c_dialect_objc ())
 914         {
 915           objc_string = true;
 916           goto retry;
 917         }
 918       /* FALLTHROUGH */
 919
 920     default:
 921       break;
 922
 923     case CPP_WSTRING:
 924     case CPP_STRING16:
 925     case CPP_STRING32:
 926     case CPP_UTF8STRING:
 927       if (type != tok->type)
 928         {
 929           if (type == CPP_STRING)
 930             type = tok->type;
 931           else
 932             error ("unsupported non-standard concatenation of string literals");
 933         }
 934
 935     case CPP_STRING:
 936       if (!concats)
 937         {
 938           gcc_obstack_init (&str_ob);
 939           obstack_grow (&str_ob, &str, sizeof (cpp_string));
 940         }
 941
 942       concats++;
 943       obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
 944       goto retry;
 945     }
 946
 947   /* We have read one more token than we want.  */
 948   _cpp_backup_tokens (parse_in, 1);
 949   if (concats)
 950     strs = XOBFINISH (&str_ob, cpp_string *);
 951
 952   if (concats && !objc_string && !in_system_header)
 953     warning (OPT_Wtraditional,
 954              "traditional C rejects string constant concatenation");
 955
 956   if ((translate
 957        ? cpp_interpret_string : cpp_interpret_string_notranslate)
 958       (parse_in, strs, concats + 1, &istr, type))
 959     {
 960       value = build_string (istr.len, (const char *) istr.text);
 961       free (CONST_CAST (unsigned char *, istr.text));
 962     }
 963   else
 964     {
 965       /* Callers cannot generally handle error_mark_node in this context,
 966          so return the empty string instead.  cpp_interpret_string has
 967          issued an error.  */
 968       switch (type)
 969         {
 970         default:
 971         case CPP_STRING:
 972         case CPP_UTF8STRING:
 973           value = build_string (1, "");
 974           break;
 975         case CPP_STRING16:
 976           value = build_string (TYPE_PRECISION (char16_type_node)
 977                                 / TYPE_PRECISION (char_type_node),
 978                                 "\0");  /* char16_t is 16 bits */
 979           break;
 980         case CPP_STRING32:
 981           value = build_string (TYPE_PRECISION (char32_type_node)
 982                                 / TYPE_PRECISION (char_type_node),
 983                                 "\0\0\0");  /* char32_t is 32 bits */
 984           break;
 985         case CPP_WSTRING:
 986           value = build_string (TYPE_PRECISION (wchar_type_node)
 987                                 / TYPE_PRECISION (char_type_node),
 988                                 "\0\0\0");  /* widest supported wchar_t
 989                                                is 32 bits */
 990           break;
 991         }
 992     }
 993
 994   switch (type)
 995     {
 996     default:
 997     case CPP_STRING:
 998     case CPP_UTF8STRING:
 999       TREE_TYPE (value) = char_array_type_node;
1000       break;
1001     case CPP_STRING16:
1002       TREE_TYPE (value) = char16_array_type_node;
1003       break;
1004     case CPP_STRING32:
1005       TREE_TYPE (value) = char32_array_type_node;
1006       break;
1007     case CPP_WSTRING:
1008       TREE_TYPE (value) = wchar_array_type_node;
1009     }
1010   *valp = fix_string_type (value);
1011
1012   if (concats)
1013     obstack_free (&str_ob, 0);
1014
1015   return objc_string ? CPP_OBJC_STRING : type;
1016 }
1017
1018 /* Converts a (possibly wide) character constant token into a tree.  */
1019 static tree
1020 lex_charconst (const cpp_token *token)
1021 {
1022   cppchar_t result;
1023   tree type, value;
1024   unsigned int chars_seen;
1025   int unsignedp = 0;
1026
1027   result = cpp_interpret_charconst (parse_in, token,
1028                                     &chars_seen, &unsignedp);
1029
1030   if (token->type == CPP_WCHAR)
1031     type = wchar_type_node;
1032   else if (token->type == CPP_CHAR32)
1033     type = char32_type_node;
1034   else if (token->type == CPP_CHAR16)
1035     type = char16_type_node;
1036   /* In C, a character constant has type 'int'.
1037      In C++ 'char', but multi-char charconsts have type 'int'.  */
1038   else if (!c_dialect_cxx () || chars_seen > 1)
1039     type = integer_type_node;
1040   else
1041     type = char_type_node;
1042
1043   /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1044      before possibly widening to HOST_WIDE_INT for build_int_cst.  */
1045   if (unsignedp || (cppchar_signed_t) result >= 0)
1046     value = build_int_cst_wide (type, result, 0);
1047   else
1048     value = build_int_cst_wide (type, (cppchar_signed_t) result, -1);
1049
1050   return value;
1051 }