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