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