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   tok = cpp_get_token (parse_in);
 342   type = tok->type;
 343
 344  retry_after_at:
 345 #ifdef USE_MAPPED_LOCATION
 346   *loc = tok->src_loc;
 347 #else
 348   *loc = input_location;
 349 #endif
 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           location_t atloc = input_location;
 394
 395         retry_at:
 396           tok = cpp_get_token (parse_in);
 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);
 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               goto retry_after_at;
 421             }
 422           break;
 423         }
 424
 425       /* FALLTHROUGH */
 426     case CPP_HASH:
 427     case CPP_PASTE:
 428       {
 429         unsigned char name[4];
 430
 431         *cpp_spell_token (parse_in, tok, name, true) = 0;
 432
 433         error ("stray %qs in program", name);
 434       }
 435
 436       goto retry;
 437
 438     case CPP_OTHER:
 439       {
 440         cppchar_t c = tok->val.str.text[0];
 441
 442         if (c == '"' || c == '\'')
 443           error ("missing terminating %c character", (int) c);
 444         else if (ISGRAPH (c))
 445           error ("stray %qc in program", (int) c);
 446         else
 447           error ("stray %<\\%o%> in program", (int) c);
 448       }
 449       goto retry;
 450
 451     case CPP_CHAR:
 452     case CPP_WCHAR:
 453       *value = lex_charconst (tok);
 454       break;
 455
 456     case CPP_STRING:
 457     case CPP_WSTRING:
 458       if (!c_lex_return_raw_strings)
 459         {
 460           type = lex_string (tok, value, false);
 461           break;
 462         }
 463       *value = build_string (tok->val.str.len, (const char *) tok->val.str.text);
 464       break;
 465
 466     case CPP_PRAGMA:
 467       *value = build_int_cst (NULL, tok->val.pragma);
 468       break;
 469
 470       /* These tokens should not be visible outside cpplib.  */
 471     case CPP_HEADER_NAME:
 472     case CPP_COMMENT:
 473     case CPP_MACRO_ARG:
 474       gcc_unreachable ();
 475
 476     default:
 477       *value = NULL_TREE;
 478       break;
 479     }
 480
 481   if (cpp_flags)
 482     *cpp_flags = tok->flags | add_flags;
 483
 484   if (!no_more_pch)
 485     {
 486       no_more_pch = true;
 487       c_common_no_more_pch ();
 488     }
 489
 490   timevar_pop (TV_CPP);
 491
 492   return type;
 493 }
 494
 495 /* Returns the narrowest C-visible unsigned type, starting with the
 496    minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
 497    there isn't one.  */
 498
 499 static enum integer_type_kind
 500 narrowest_unsigned_type (unsigned HOST_WIDE_INT low,
 501                          unsigned HOST_WIDE_INT high,
 502                          unsigned int flags)
 503 {
 504   enum integer_type_kind itk;
 505
 506   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 507     itk = itk_unsigned_int;
 508   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 509     itk = itk_unsigned_long;
 510   else
 511     itk = itk_unsigned_long_long;
 512
 513   for (; itk < itk_none; itk += 2 /* skip unsigned types */)
 514     {
 515       tree upper = TYPE_MAX_VALUE (integer_types[itk]);
 516
 517       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
 518           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
 519               && TREE_INT_CST_LOW (upper) >= low))
 520         return itk;
 521     }
 522
 523   return itk_none;
 524 }
 525
 526 /* Ditto, but narrowest signed type.  */
 527 static enum integer_type_kind
 528 narrowest_signed_type (unsigned HOST_WIDE_INT low,
 529                        unsigned HOST_WIDE_INT high, unsigned int flags)
 530 {
 531   enum integer_type_kind itk;
 532
 533   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 534     itk = itk_int;
 535   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 536     itk = itk_long;
 537   else
 538     itk = itk_long_long;
 539
 540
 541   for (; itk < itk_none; itk += 2 /* skip signed types */)
 542     {
 543       tree upper = TYPE_MAX_VALUE (integer_types[itk]);
 544
 545       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
 546           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
 547               && TREE_INT_CST_LOW (upper) >= low))
 548         return itk;
 549     }
 550
 551   return itk_none;
 552 }
 553
 554 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib.  */
 555 static tree
 556 interpret_integer (const cpp_token *token, unsigned int flags)
 557 {
 558   tree value, type;
 559   enum integer_type_kind itk;
 560   cpp_num integer;
 561   cpp_options *options = cpp_get_options (parse_in);
 562
 563   integer = cpp_interpret_integer (parse_in, token, flags);
 564   integer = cpp_num_sign_extend (integer, options->precision);
 565
 566   /* The type of a constant with a U suffix is straightforward.  */
 567   if (flags & CPP_N_UNSIGNED)
 568     itk = narrowest_unsigned_type (integer.low, integer.high, flags);
 569   else
 570     {
 571       /* The type of a potentially-signed integer constant varies
 572          depending on the base it's in, the standard in use, and the
 573          length suffixes.  */
 574       enum integer_type_kind itk_u
 575         = narrowest_unsigned_type (integer.low, integer.high, flags);
 576       enum integer_type_kind itk_s
 577         = narrowest_signed_type (integer.low, integer.high, flags);
 578
 579       /* In both C89 and C99, octal and hex constants may be signed or
 580          unsigned, whichever fits tighter.  We do not warn about this
 581          choice differing from the traditional choice, as the constant
 582          is probably a bit pattern and either way will work.  */
 583       if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
 584         itk = MIN (itk_u, itk_s);
 585       else
 586         {
 587           /* In C99, decimal constants are always signed.
 588              In C89, decimal constants that don't fit in long have
 589              undefined behavior; we try to make them unsigned long.
 590              In GCC's extended C89, that last is true of decimal
 591              constants that don't fit in long long, too.  */
 592
 593           itk = itk_s;
 594           if (itk_s > itk_u && itk_s > itk_long)
 595             {
 596               if (!flag_isoc99)
 597                 {
 598                   if (itk_u < itk_unsigned_long)
 599                     itk_u = itk_unsigned_long;
 600                   itk = itk_u;
 601                   warning (0, "this decimal constant is unsigned only in ISO C90");
 602                 }
 603               else
 604                 warning (OPT_Wtraditional,
 605                          "this decimal constant would be unsigned in ISO C90");
 606             }
 607         }
 608     }
 609
 610   if (itk == itk_none)
 611     /* cpplib has already issued a warning for overflow.  */
 612     type = ((flags & CPP_N_UNSIGNED)
 613             ? widest_unsigned_literal_type_node
 614             : widest_integer_literal_type_node);
 615   else
 616     type = integer_types[itk];
 617
 618   if (itk > itk_unsigned_long
 619       && (flags & CPP_N_WIDTH) != CPP_N_LARGE
 620       && !in_system_header && !flag_isoc99)
 621     pedwarn ("integer constant is too large for %qs type",
 622              (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long");
 623
 624   value = build_int_cst_wide (type, integer.low, integer.high);
 625
 626   /* Convert imaginary to a complex type.  */
 627   if (flags & CPP_N_IMAGINARY)
 628     value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
 629
 630   return value;
 631 }
 632
 633 /* Interpret TOKEN, a floating point number with FLAGS as classified
 634    by cpplib.  */
 635 static tree
 636 interpret_float (const cpp_token *token, unsigned int flags)
 637 {
 638   tree type;
 639   tree value;
 640   REAL_VALUE_TYPE real;
 641   char *copy;
 642   size_t copylen;
 643
 644   /* Decode _Fract and _Accum.  */
 645   if (flags & CPP_N_FRACT || flags & CPP_N_ACCUM)
 646     return interpret_fixed (token, flags);
 647
 648   /* Decode type based on width and properties. */
 649   if (flags & CPP_N_DFLOAT)
 650     if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 651       type = dfloat128_type_node;
 652     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 653       type = dfloat32_type_node;
 654     else
 655       type = dfloat64_type_node;
 656   else
 657     if (flags & CPP_N_WIDTH_MD)
 658       {
 659         char suffix;
 660         enum machine_mode mode;
 661
 662         if ((flags & CPP_N_WIDTH_MD) == CPP_N_MD_W)
 663           suffix = 'w';
 664         else
 665           suffix = 'q';
 666
 667         mode = targetm.c.mode_for_suffix (suffix);
 668         if (mode == VOIDmode)
 669           {
 670             error ("unsupported non-standard suffix on floating constant");
 671             errorcount++;
 672
 673             return error_mark_node;
 674           }
 675         else if (pedantic)
 676           pedwarn ("non-standard suffix on floating constant");
 677
 678         type = c_common_type_for_mode (mode, 0);
 679         gcc_assert (type);
 680       }
 681     else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 682       type = long_double_type_node;
 683     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
 684              || flag_single_precision_constant)
 685       type = float_type_node;
 686     else
 687       type = double_type_node;
 688
 689   /* Copy the constant to a nul-terminated buffer.  If the constant
 690      has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
 691      can't handle them.  */
 692   copylen = token->val.str.len;
 693   if (flags & CPP_N_DFLOAT)
 694     copylen -= 2;
 695   else
 696     {
 697       if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
 698         /* Must be an F or L or machine defined suffix.  */
 699         copylen--;
 700       if (flags & CPP_N_IMAGINARY)
 701         /* I or J suffix.  */
 702         copylen--;
 703     }
 704
 705   copy = (char *) alloca (copylen + 1);
 706   memcpy (copy, token->val.str.text, copylen);
 707   copy[copylen] = '\0';
 708
 709   real_from_string3 (&real, copy, TYPE_MODE (type));
 710
 711   /* Both C and C++ require a diagnostic for a floating constant
 712      outside the range of representable values of its type.  Since we
 713      have __builtin_inf* to produce an infinity, this is now a
 714      mandatory pedwarn if the target does not support infinities.  */
 715   if (REAL_VALUE_ISINF (real))
 716     {
 717       if (!MODE_HAS_INFINITIES (TYPE_MODE (type)))
 718         pedwarn ("floating constant exceeds range of %qT", type);
 719       else
 720         warning (OPT_Woverflow, "floating constant exceeds range of %qT", type);
 721     }
 722   /* We also give a warning if the value underflows.  */
 723   else if (REAL_VALUES_EQUAL (real, dconst0))
 724     {
 725       REAL_VALUE_TYPE realvoidmode;
 726       int overflow = real_from_string (&realvoidmode, copy);
 727       if (overflow < 0 || !REAL_VALUES_EQUAL (realvoidmode, dconst0))
 728         warning (OPT_Woverflow, "floating constant truncated to zero");
 729     }
 730
 731   /* Create a node with determined type and value.  */
 732   value = build_real (type, real);
 733   if (flags & CPP_N_IMAGINARY)
 734     value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
 735
 736   return value;
 737 }
 738
 739 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
 740    by cpplib.  */
 741
 742 static tree
 743 interpret_fixed (const cpp_token *token, unsigned int flags)
 744 {
 745   tree type;
 746   tree value;
 747   FIXED_VALUE_TYPE fixed;
 748   char *copy;
 749   size_t copylen;
 750
 751   copylen = token->val.str.len;
 752
 753   if (flags & CPP_N_FRACT) /* _Fract.  */
 754     {
 755       if (flags & CPP_N_UNSIGNED) /* Unsigned _Fract.  */
 756         {
 757           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 758             {
 759               type = unsigned_long_long_fract_type_node;
 760               copylen -= 4;
 761             }
 762           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 763             {
 764               type = unsigned_long_fract_type_node;
 765               copylen -= 3;
 766             }
 767           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 768             {
 769               type = unsigned_short_fract_type_node;
 770               copylen -= 3;
 771             }
 772           else
 773             {
 774               type = unsigned_fract_type_node;
 775               copylen -= 2;
 776             }
 777         }
 778       else /* Signed _Fract.  */
 779         {
 780           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 781             {
 782               type = long_long_fract_type_node;
 783               copylen -= 3;
 784             }
 785           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 786             {
 787               type = long_fract_type_node;
 788               copylen -= 2;
 789             }
 790           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 791             {
 792               type = short_fract_type_node;
 793               copylen -= 2;
 794             }
 795           else
 796             {
 797               type = fract_type_node;
 798               copylen --;
 799             }
 800           }
 801     }
 802   else /* _Accum.  */
 803     {
 804       if (flags & CPP_N_UNSIGNED) /* Unsigned _Accum.  */
 805         {
 806           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 807             {
 808               type = unsigned_long_long_accum_type_node;
 809               copylen -= 4;
 810             }
 811           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 812             {
 813               type = unsigned_long_accum_type_node;
 814               copylen -= 3;
 815             }
 816           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 817             {
 818               type = unsigned_short_accum_type_node;
 819               copylen -= 3;
 820              }
 821           else
 822             {
 823               type = unsigned_accum_type_node;
 824               copylen -= 2;
 825             }
 826         }
 827       else /* Signed _Accum.  */
 828         {
 829           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 830             {
 831               type = long_long_accum_type_node;
 832               copylen -= 3;
 833             }
 834           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 835             {
 836               type = long_accum_type_node;
 837               copylen -= 2;
 838             }
 839           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 840             {
 841               type = short_accum_type_node;
 842               copylen -= 2;
 843             }
 844           else
 845             {
 846               type = accum_type_node;
 847               copylen --;
 848             }
 849         }
 850     }
 851
 852   copy = (char *) alloca (copylen + 1);
 853   memcpy (copy, token->val.str.text, copylen);
 854   copy[copylen] = '\0';
 855
 856   fixed_from_string (&fixed, copy, TYPE_MODE (type));
 857
 858   /* Create a node with determined type and value.  */
 859   value = build_fixed (type, fixed);
 860
 861   return value;
 862 }
 863
 864 /* Convert a series of STRING and/or WSTRING tokens into a tree,
 865    performing string constant concatenation.  TOK is the first of
 866    these.  VALP is the location to write the string into.  OBJC_STRING
 867    indicates whether an '@' token preceded the incoming token.
 868    Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
 869    or CPP_OBJC_STRING).
 870
 871    This is unfortunately more work than it should be.  If any of the
 872    strings in the series has an L prefix, the result is a wide string
 873    (6.4.5p4).  Whether or not the result is a wide string affects the
 874    meaning of octal and hexadecimal escapes (6.4.4.4p6,9).  But escape
 875    sequences do not continue across the boundary between two strings in
 876    a series (6.4.5p7), so we must not lose the boundaries.  Therefore
 877    cpp_interpret_string takes a vector of cpp_string structures, which
 878    we must arrange to provide.  */
 879
 880 static enum cpp_ttype
 881 lex_string (const cpp_token *tok, tree *valp, bool objc_string)
 882 {
 883   tree value;
 884   bool wide = false;
 885   size_t concats = 0;
 886   struct obstack str_ob;
 887   cpp_string istr;
 888
 889   /* Try to avoid the overhead of creating and destroying an obstack
 890      for the common case of just one string.  */
 891   cpp_string str = tok->val.str;
 892   cpp_string *strs = &str;
 893
 894   if (tok->type == CPP_WSTRING)
 895     wide = true;
 896
 897  retry:
 898   tok = cpp_get_token (parse_in);
 899   switch (tok->type)
 900     {
 901     case CPP_PADDING:
 902       goto retry;
 903     case CPP_ATSIGN:
 904       if (c_dialect_objc ())
 905         {
 906           objc_string = true;
 907           goto retry;
 908         }
 909       /* FALLTHROUGH */
 910
 911     default:
 912       break;
 913
 914     case CPP_WSTRING:
 915       wide = true;
 916       /* FALLTHROUGH */
 917
 918     case CPP_STRING:
 919       if (!concats)
 920         {
 921           gcc_obstack_init (&str_ob);
 922           obstack_grow (&str_ob, &str, sizeof (cpp_string));
 923         }
 924
 925       concats++;
 926       obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
 927       goto retry;
 928     }
 929
 930   /* We have read one more token than we want.  */
 931   _cpp_backup_tokens (parse_in, 1);
 932   if (concats)
 933     strs = XOBFINISH (&str_ob, cpp_string *);
 934
 935   if (concats && !objc_string && !in_system_header)
 936     warning (OPT_Wtraditional,
 937              "traditional C rejects string constant concatenation");
 938
 939   if ((c_lex_string_translate
 940        ? cpp_interpret_string : cpp_interpret_string_notranslate)
 941       (parse_in, strs, concats + 1, &istr, wide))
 942     {
 943       value = build_string (istr.len, (const char *) istr.text);
 944       free (CONST_CAST (unsigned char *, istr.text));
 945
 946       if (c_lex_string_translate == -1)
 947         {
 948           int xlated = cpp_interpret_string_notranslate (parse_in, strs,
 949                                                          concats + 1,
 950                                                          &istr, wide);
 951           /* Assume that, if we managed to translate the string above,
 952              then the untranslated parsing will always succeed.  */
 953           gcc_assert (xlated);
 954
 955           if (TREE_STRING_LENGTH (value) != (int) istr.len
 956               || 0 != strncmp (TREE_STRING_POINTER (value),
 957                                (const char *) istr.text, istr.len))
 958             {
 959               /* Arrange for us to return the untranslated string in
 960                  *valp, but to set up the C type of the translated
 961                  one.  */
 962               *valp = build_string (istr.len, (const char *) istr.text);
 963               valp = &TREE_CHAIN (*valp);
 964             }
 965           free (CONST_CAST (unsigned char *, istr.text));
 966         }
 967     }
 968   else
 969     {
 970       /* Callers cannot generally handle error_mark_node in this context,
 971          so return the empty string instead.  cpp_interpret_string has
 972          issued an error.  */
 973       if (wide)
 974         value = build_string (TYPE_PRECISION (wchar_type_node)
 975                               / TYPE_PRECISION (char_type_node),
 976                               "\0\0\0");  /* widest supported wchar_t
 977                                              is 32 bits */
 978       else
 979         value = build_string (1, "");
 980     }
 981
 982   TREE_TYPE (value) = wide ? wchar_array_type_node : char_array_type_node;
 983   *valp = fix_string_type (value);
 984
 985   if (concats)
 986     obstack_free (&str_ob, 0);
 987
 988   return objc_string ? CPP_OBJC_STRING : wide ? CPP_WSTRING : CPP_STRING;
 989 }
 990
 991 /* Converts a (possibly wide) character constant token into a tree.  */
 992 static tree
 993 lex_charconst (const cpp_token *token)
 994 {
 995   cppchar_t result;
 996   tree type, value;
 997   unsigned int chars_seen;
 998   int unsignedp;
 999
1000   result = cpp_interpret_charconst (parse_in, token,
1001                                     &chars_seen, &unsignedp);
1002
1003   if (token->type == CPP_WCHAR)
1004     type = wchar_type_node;
1005   /* In C, a character constant has type 'int'.
1006      In C++ 'char', but multi-char charconsts have type 'int'.  */
1007   else if (!c_dialect_cxx () || chars_seen > 1)
1008     type = integer_type_node;
1009   else
1010     type = char_type_node;
1011
1012   /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1013      before possibly widening to HOST_WIDE_INT for build_int_cst.  */
1014   if (unsignedp || (cppchar_signed_t) result >= 0)
1015     value = build_int_cst_wide (type, result, 0);
1016   else
1017     value = build_int_cst_wide (type, (cppchar_signed_t) result, -1);
1018
1019   return value;
1020 }