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