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