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