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 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  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
  44 /* We may keep statistics about how long which files took to compile.  */
  45 static int header_time, body_time;
  46 static splay_tree file_info_tree;
  47
  48 #undef WCHAR_TYPE_SIZE
  49 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
  50
  51 /* Number of bytes in a wide character.  */
  52 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
  53
  54 int pending_lang_change; /* If we need to switch languages - C++ only */
  55 int c_header_level;      /* depth in C headers - C++ only */
  56
  57 /* If we need to translate characters received.  This is tri-state:
  58    0 means use only the untranslated string; 1 means use only
  59    the translated string; -1 means chain the translated string
  60    to the untranslated one.  */
  61 int c_lex_string_translate = 1;
  62
  63 static tree interpret_integer (const cpp_token *, unsigned int);
  64 static tree interpret_float (const cpp_token *, unsigned int);
  65 static enum integer_type_kind
  66   narrowest_unsigned_type (tree, unsigned int);
  67 static enum integer_type_kind
  68   narrowest_signed_type (tree, 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   /* Set up filename timing.  Must happen before cpp_read_main_file.  */
  86   file_info_tree = splay_tree_new ((splay_tree_compare_fn)strcmp,
  87                                    0,
  88                                    (splay_tree_delete_value_fn)free);
  89   toplevel = get_fileinfo ("<top level>");
  90   if (flag_detailed_statistics)
  91     {
  92       header_time = 0;
  93       body_time = get_run_time ();
  94       toplevel->time = body_time;
  95     }
  96
  97   cb = cpp_get_callbacks (parse_in);
  98
  99   cb->line_change = cb_line_change;
 100   cb->ident = cb_ident;
 101   cb->def_pragma = cb_def_pragma;
 102   cb->valid_pch = c_common_valid_pch;
 103   cb->read_pch = c_common_read_pch;
 104
 105   /* Set the debug callbacks if we can use them.  */
 106   if (debug_info_level == DINFO_LEVEL_VERBOSE
 107       && (write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG
 108           || write_symbols == VMS_AND_DWARF2_DEBUG))
 109     {
 110       cb->define = cb_define;
 111       cb->undef = cb_undef;
 112     }
 113 }
 114
 115 struct c_fileinfo *
 116 get_fileinfo (const char *name)
 117 {
 118   splay_tree_node n;
 119   struct c_fileinfo *fi;
 120
 121   n = splay_tree_lookup (file_info_tree, (splay_tree_key) name);
 122   if (n)
 123     return (struct c_fileinfo *) n->value;
 124
 125   fi = xmalloc (sizeof (struct c_fileinfo));
 126   fi->time = 0;
 127   fi->interface_only = 0;
 128   fi->interface_unknown = 1;
 129   splay_tree_insert (file_info_tree, (splay_tree_key) name,
 130                      (splay_tree_value) fi);
 131   return fi;
 132 }
 133
 134 static void
 135 update_header_times (const char *name)
 136 {
 137   /* Changing files again.  This means currently collected time
 138      is charged against header time, and body time starts back at 0.  */
 139   if (flag_detailed_statistics)
 140     {
 141       int this_time = get_run_time ();
 142       struct c_fileinfo *file = get_fileinfo (name);
 143       header_time += this_time - body_time;
 144       file->time += this_time - body_time;
 145       body_time = this_time;
 146     }
 147 }
 148
 149 static int
 150 dump_one_header (splay_tree_node n, void * ARG_UNUSED (dummy))
 151 {
 152   print_time ((const char *) n->key,
 153               ((struct c_fileinfo *) n->value)->time);
 154   return 0;
 155 }
 156
 157 void
 158 dump_time_statistics (void)
 159 {
 160   struct c_fileinfo *file = get_fileinfo (input_filename);
 161   int this_time = get_run_time ();
 162   file->time += this_time - body_time;
 163
 164   fprintf (stderr, "\n******\n");
 165   print_time ("header files (total)", header_time);
 166   print_time ("main file (total)", this_time - body_time);
 167   fprintf (stderr, "ratio = %g : 1\n",
 168            (double)header_time / (double)(this_time - body_time));
 169   fprintf (stderr, "\n******\n");
 170
 171   splay_tree_foreach (file_info_tree, dump_one_header, 0);
 172 }
 173
 174 static void
 175 cb_ident (cpp_reader * ARG_UNUSED (pfile),
 176           unsigned int ARG_UNUSED (line),
 177           const cpp_string * ARG_UNUSED (str))
 178 {
 179 #ifdef ASM_OUTPUT_IDENT
 180   if (! flag_no_ident)
 181     {
 182       /* Convert escapes in the string.  */
 183       cpp_string cstr = { 0, 0 };
 184       if (cpp_interpret_string (pfile, str, 1, &cstr, false))
 185         {
 186           ASM_OUTPUT_IDENT (asm_out_file, (const char *) cstr.text);
 187           free ((void *)cstr.text);
 188         }
 189     }
 190 #endif
 191 }
 192
 193 /* Called at the start of every non-empty line.  TOKEN is the first
 194    lexed token on the line.  Used for diagnostic line numbers.  */
 195 static void
 196 cb_line_change (cpp_reader * ARG_UNUSED (pfile), const cpp_token *token,
 197                 int parsing_args)
 198 {
 199   if (token->type != CPP_EOF && !parsing_args)
 200 #ifdef USE_MAPPED_LOCATION
 201     input_location = token->src_loc;
 202 #else
 203     {
 204       source_location loc = token->src_loc;
 205       const struct line_map *map = linemap_lookup (&line_table, loc);
 206       input_line = SOURCE_LINE (map, loc);
 207     }
 208 #endif
 209 }
 210
 211 void
 212 fe_file_change (const struct line_map *new_map)
 213 {
 214   if (new_map == NULL)
 215     return;
 216
 217   if (new_map->reason == LC_ENTER)
 218     {
 219       /* Don't stack the main buffer on the input stack;
 220          we already did in compile_file.  */
 221       if (! MAIN_FILE_P (new_map))
 222         {
 223 #ifdef USE_MAPPED_LOCATION
 224           int included_at = LAST_SOURCE_LINE_LOCATION (new_map - 1);
 225
 226           input_location = included_at;
 227           push_srcloc (new_map->start_location);
 228 #else
 229           int included_at = LAST_SOURCE_LINE (new_map - 1);
 230
 231           input_line = included_at;
 232           push_srcloc (new_map->to_file, 1);
 233 #endif
 234           (*debug_hooks->start_source_file) (included_at, new_map->to_file);
 235 #ifndef NO_IMPLICIT_EXTERN_C
 236           if (c_header_level)
 237             ++c_header_level;
 238           else if (new_map->sysp == 2)
 239             {
 240               c_header_level = 1;
 241               ++pending_lang_change;
 242             }
 243 #endif
 244         }
 245     }
 246   else if (new_map->reason == LC_LEAVE)
 247     {
 248 #ifndef NO_IMPLICIT_EXTERN_C
 249       if (c_header_level && --c_header_level == 0)
 250         {
 251           if (new_map->sysp == 2)
 252             warning ("badly nested C headers from preprocessor");
 253           --pending_lang_change;
 254         }
 255 #endif
 256       pop_srcloc ();
 257
 258       (*debug_hooks->end_source_file) (new_map->to_line);
 259     }
 260
 261   update_header_times (new_map->to_file);
 262   in_system_header = new_map->sysp != 0;
 263 #ifdef USE_MAPPED_LOCATION
 264   input_location = new_map->start_location;
 265 #else
 266   input_filename = new_map->to_file;
 267   input_line = new_map->to_line;
 268 #endif
 269
 270   /* Hook for C++.  */
 271   extract_interface_info ();
 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 #ifndef USE_MAPPED_LOCATION
 283       const struct line_map *map = linemap_lookup (&line_table, loc);
 284 #endif
 285       const unsigned char *space, *name;
 286       const cpp_token *s;
 287
 288       space = name = (const unsigned char *) "";
 289       s = cpp_get_token (pfile);
 290       if (s->type != CPP_EOF)
 291         {
 292           space = cpp_token_as_text (pfile, s);
 293           s = cpp_get_token (pfile);
 294           if (s->type == CPP_NAME)
 295             name = cpp_token_as_text (pfile, s);
 296         }
 297
 298 #ifdef USE_MAPPED_LOCATION
 299       input_location = loc;
 300 #else
 301       input_line = SOURCE_LINE (map, loc);
 302 #endif
 303       warning ("ignoring #pragma %s %s", space, name);
 304     }
 305 }
 306
 307 /* #define callback for DWARF and DWARF2 debug info.  */
 308 static void
 309 cb_define (cpp_reader *pfile, source_location loc, cpp_hashnode *node)
 310 {
 311   const struct line_map *map = linemap_lookup (&line_table, loc);
 312   (*debug_hooks->define) (SOURCE_LINE (map, loc),
 313                           (const char *) cpp_macro_definition (pfile, node));
 314 }
 315
 316 /* #undef callback for DWARF and DWARF2 debug info.  */
 317 static void
 318 cb_undef (cpp_reader * ARG_UNUSED (pfile), source_location loc,
 319           cpp_hashnode *node)
 320 {
 321   const struct line_map *map = linemap_lookup (&line_table, loc);
 322   (*debug_hooks->undef) (SOURCE_LINE (map, loc),
 323                          (const char *) NODE_NAME (node));
 324 }
 325 \f
 326 static inline const cpp_token *
 327 get_nonpadding_token (void)
 328 {
 329   const cpp_token *tok;
 330   timevar_push (TV_CPP);
 331   do
 332     tok = cpp_get_token (parse_in);
 333   while (tok->type == CPP_PADDING);
 334   timevar_pop (TV_CPP);
 335
 336   return tok;
 337 }
 338
 339 int
 340 c_lex_with_flags (tree *value, unsigned char *cpp_flags)
 341 {
 342   const cpp_token *tok;
 343   location_t atloc;
 344   static bool no_more_pch;
 345
 346  retry:
 347   tok = get_nonpadding_token ();
 348
 349  retry_after_at:
 350   switch (tok->type)
 351     {
 352     case CPP_NAME:
 353       *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
 354       break;
 355
 356     case CPP_NUMBER:
 357       {
 358         unsigned int flags = cpp_classify_number (parse_in, tok);
 359
 360         switch (flags & CPP_N_CATEGORY)
 361           {
 362           case CPP_N_INVALID:
 363             /* cpplib has issued an error.  */
 364             *value = error_mark_node;
 365             break;
 366
 367           case CPP_N_INTEGER:
 368             *value = interpret_integer (tok, flags);
 369             break;
 370
 371           case CPP_N_FLOATING:
 372             *value = interpret_float (tok, flags);
 373             break;
 374
 375           default:
 376             abort ();
 377           }
 378       }
 379       break;
 380
 381     case CPP_ATSIGN:
 382       /* An @ may give the next token special significance in Objective-C.  */
 383       atloc = input_location;
 384       tok = get_nonpadding_token ();
 385       if (c_dialect_objc ())
 386         {
 387           tree val;
 388           switch (tok->type)
 389             {
 390             case CPP_NAME:
 391               val = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
 392               if (C_IS_RESERVED_WORD (val)
 393                   && OBJC_IS_AT_KEYWORD (C_RID_CODE (val)))
 394                 {
 395                   *value = val;
 396                   return CPP_AT_NAME;
 397                 }
 398               break;
 399
 400             case CPP_STRING:
 401             case CPP_WSTRING:
 402               return lex_string (tok, value, true);
 403
 404             default: break;
 405             }
 406         }
 407
 408       /* ... or not.  */
 409       error ("%Hstray '@' in program", &atloc);
 410       goto retry_after_at;
 411
 412     case CPP_OTHER:
 413       {
 414         cppchar_t c = tok->val.str.text[0];
 415
 416         if (c == '"' || c == '\'')
 417           error ("missing terminating %c character", (int) c);
 418         else if (ISGRAPH (c))
 419           error ("stray '%c' in program", (int) c);
 420         else
 421           error ("stray '\\%o' in program", (int) c);
 422       }
 423       goto retry;
 424
 425     case CPP_CHAR:
 426     case CPP_WCHAR:
 427       *value = lex_charconst (tok);
 428       break;
 429
 430     case CPP_STRING:
 431     case CPP_WSTRING:
 432       return lex_string (tok, value, false);
 433       break;
 434
 435       /* These tokens should not be visible outside cpplib.  */
 436     case CPP_HEADER_NAME:
 437     case CPP_COMMENT:
 438     case CPP_MACRO_ARG:
 439       abort ();
 440
 441     default:
 442       *value = NULL_TREE;
 443       break;
 444     }
 445
 446   if (! no_more_pch)
 447     {
 448       no_more_pch = true;
 449       c_common_no_more_pch ();
 450     }
 451
 452   if (cpp_flags)
 453     *cpp_flags = tok->flags;
 454   return tok->type;
 455 }
 456
 457 int
 458 c_lex (tree *value)
 459 {
 460   return c_lex_with_flags (value, NULL);
 461 }
 462
 463 /* Returns the narrowest C-visible unsigned type, starting with the
 464    minimum specified by FLAGS, that can fit VALUE, or itk_none if
 465    there isn't one.  */
 466 static enum integer_type_kind
 467 narrowest_unsigned_type (tree value, unsigned int flags)
 468 {
 469   enum integer_type_kind itk;
 470
 471   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 472     itk = itk_unsigned_int;
 473   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 474     itk = itk_unsigned_long;
 475   else
 476     itk = itk_unsigned_long_long;
 477
 478   /* int_fits_type_p must think the type of its first argument is
 479      wider than its second argument, or it won't do the proper check.  */
 480   TREE_TYPE (value) = widest_unsigned_literal_type_node;
 481
 482   for (; itk < itk_none; itk += 2 /* skip unsigned types */)
 483     if (int_fits_type_p (value, integer_types[itk]))
 484       return itk;
 485
 486   return itk_none;
 487 }
 488
 489 /* Ditto, but narrowest signed type.  */
 490 static enum integer_type_kind
 491 narrowest_signed_type (tree value, unsigned int flags)
 492 {
 493   enum integer_type_kind itk;
 494
 495   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 496     itk = itk_int;
 497   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 498     itk = itk_long;
 499   else
 500     itk = itk_long_long;
 501
 502   /* int_fits_type_p must think the type of its first argument is
 503      wider than its second argument, or it won't do the proper check.  */
 504   TREE_TYPE (value) = widest_unsigned_literal_type_node;
 505
 506   for (; itk < itk_none; itk += 2 /* skip signed types */)
 507     if (int_fits_type_p (value, integer_types[itk]))
 508       return itk;
 509
 510   return itk_none;
 511 }
 512
 513 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib.  */
 514 static tree
 515 interpret_integer (const cpp_token *token, unsigned int flags)
 516 {
 517   tree value, type;
 518   enum integer_type_kind itk;
 519   cpp_num integer;
 520   cpp_options *options = cpp_get_options (parse_in);
 521
 522   integer = cpp_interpret_integer (parse_in, token, flags);
 523   integer = cpp_num_sign_extend (integer, options->precision);
 524   value = build_int_2 (integer.low, integer.high);
 525
 526   /* The type of a constant with a U suffix is straightforward.  */
 527   if (flags & CPP_N_UNSIGNED)
 528     itk = narrowest_unsigned_type (value, flags);
 529   else
 530     {
 531       /* The type of a potentially-signed integer constant varies
 532          depending on the base it's in, the standard in use, and the
 533          length suffixes.  */
 534       enum integer_type_kind itk_u = narrowest_unsigned_type (value, flags);
 535       enum integer_type_kind itk_s = narrowest_signed_type (value, flags);
 536
 537       /* In both C89 and C99, octal and hex constants may be signed or
 538          unsigned, whichever fits tighter.  We do not warn about this
 539          choice differing from the traditional choice, as the constant
 540          is probably a bit pattern and either way will work.  */
 541       if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
 542         itk = MIN (itk_u, itk_s);
 543       else
 544         {
 545           /* In C99, decimal constants are always signed.
 546              In C89, decimal constants that don't fit in long have
 547              undefined behavior; we try to make them unsigned long.
 548              In GCC's extended C89, that last is true of decimal
 549              constants that don't fit in long long, too.  */
 550
 551           itk = itk_s;
 552           if (itk_s > itk_u && itk_s > itk_long)
 553             {
 554               if (!flag_isoc99)
 555                 {
 556                   if (itk_u < itk_unsigned_long)
 557                     itk_u = itk_unsigned_long;
 558                   itk = itk_u;
 559                   warning ("this decimal constant is unsigned only in ISO C90");
 560                 }
 561               else if (warn_traditional)
 562                 warning ("this decimal constant would be unsigned in ISO C90");
 563             }
 564         }
 565     }
 566
 567   if (itk == itk_none)
 568     /* cpplib has already issued a warning for overflow.  */
 569     type = ((flags & CPP_N_UNSIGNED)
 570             ? widest_unsigned_literal_type_node
 571             : widest_integer_literal_type_node);
 572   else
 573     type = integer_types[itk];
 574
 575   if (itk > itk_unsigned_long
 576       && (flags & CPP_N_WIDTH) != CPP_N_LARGE
 577       && ! in_system_header && ! flag_isoc99)
 578     pedwarn ("integer constant is too large for \"%s\" type",
 579              (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long");
 580
 581   TREE_TYPE (value) = type;
 582
 583   /* Convert imaginary to a complex type.  */
 584   if (flags & CPP_N_IMAGINARY)
 585     value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
 586
 587   return value;
 588 }
 589
 590 /* Interpret TOKEN, a floating point number with FLAGS as classified
 591    by cpplib.  */
 592 static tree
 593 interpret_float (const cpp_token *token, unsigned int flags)
 594 {
 595   tree type;
 596   tree value;
 597   REAL_VALUE_TYPE real;
 598   char *copy;
 599   size_t copylen;
 600   const char *type_name;
 601
 602   /* FIXME: make %T work in error/warning, then we don't need type_name.  */
 603   if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 604     {
 605       type = long_double_type_node;
 606       type_name = "long double";
 607     }
 608   else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
 609            || flag_single_precision_constant)
 610     {
 611       type = float_type_node;
 612       type_name = "float";
 613     }
 614   else
 615     {
 616       type = double_type_node;
 617       type_name = "double";
 618     }
 619
 620   /* Copy the constant to a nul-terminated buffer.  If the constant
 621      has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
 622      can't handle them.  */
 623   copylen = token->val.str.len;
 624   if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
 625     /* Must be an F or L suffix.  */
 626     copylen--;
 627   if (flags & CPP_N_IMAGINARY)
 628     /* I or J suffix.  */
 629     copylen--;
 630
 631   copy = alloca (copylen + 1);
 632   memcpy (copy, token->val.str.text, copylen);
 633   copy[copylen] = '\0';
 634
 635   real_from_string (&real, copy);
 636   real_convert (&real, TYPE_MODE (type), &real);
 637
 638   /* A diagnostic is required for "soft" overflow by some ISO C
 639      testsuites.  This is not pedwarn, because some people don't want
 640      an error for this.
 641      ??? That's a dubious reason... is this a mandatory diagnostic or
 642      isn't it?   -- zw, 2001-08-21.  */
 643   if (REAL_VALUE_ISINF (real) && pedantic)
 644     warning ("floating constant exceeds range of \"%s\"", type_name);
 645
 646   /* Create a node with determined type and value.  */
 647   value = build_real (type, real);
 648   if (flags & CPP_N_IMAGINARY)
 649     value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
 650
 651   return value;
 652 }
 653
 654 /* Convert a series of STRING and/or WSTRING tokens into a tree,
 655    performing string constant concatenation.  TOK is the first of
 656    these.  VALP is the location to write the string into.  OBJC_STRING
 657    indicates whether an '@' token preceded the incoming token.
 658    Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
 659    or CPP_OBJC_STRING).
 660
 661    This is unfortunately more work than it should be.  If any of the
 662    strings in the series has an L prefix, the result is a wide string
 663    (6.4.5p4).  Whether or not the result is a wide string affects the
 664    meaning of octal and hexadecimal escapes (6.4.4.4p6,9).  But escape
 665    sequences do not continue across the boundary between two strings in
 666    a series (6.4.5p7), so we must not lose the boundaries.  Therefore
 667    cpp_interpret_string takes a vector of cpp_string structures, which
 668    we must arrange to provide.  */
 669
 670 static enum cpp_ttype
 671 lex_string (const cpp_token *tok, tree *valp, bool objc_string)
 672 {
 673   tree value;
 674   bool wide = false;
 675   size_t count = 1;
 676   struct obstack str_ob;
 677   cpp_string istr;
 678
 679   /* Try to avoid the overhead of creating and destroying an obstack
 680      for the common case of just one string.  */
 681   cpp_string str = tok->val.str;
 682   cpp_string *strs = &str;
 683
 684   if (tok->type == CPP_WSTRING)
 685     wide = true;
 686
 687   tok = get_nonpadding_token ();
 688   if (c_dialect_objc () && tok->type == CPP_ATSIGN)
 689     {
 690       objc_string = true;
 691       tok = get_nonpadding_token ();
 692     }
 693   if (tok->type == CPP_STRING || tok->type == CPP_WSTRING)
 694     {
 695       gcc_obstack_init (&str_ob);
 696       obstack_grow (&str_ob, &str, sizeof (cpp_string));
 697
 698       do
 699         {
 700           count++;
 701           if (tok->type == CPP_WSTRING)
 702             wide = true;
 703           obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
 704
 705           tok = get_nonpadding_token ();
 706           if (c_dialect_objc () && tok->type == CPP_ATSIGN)
 707             {
 708               objc_string = true;
 709               tok = get_nonpadding_token ();
 710             }
 711         }
 712       while (tok->type == CPP_STRING || tok->type == CPP_WSTRING);
 713       strs = obstack_finish (&str_ob);
 714     }
 715
 716   /* We have read one more token than we want.  */
 717   _cpp_backup_tokens (parse_in, 1);
 718
 719   if (count > 1 && !objc_string && warn_traditional && !in_system_header)
 720     warning ("traditional C rejects string constant concatenation");
 721
 722   if ((c_lex_string_translate
 723        ? cpp_interpret_string : cpp_interpret_string_notranslate)
 724       (parse_in, strs, count, &istr, wide))
 725     {
 726       value = build_string (istr.len, (char *)istr.text);
 727       free ((void *)istr.text);
 728
 729       if (c_lex_string_translate == -1)
 730         {
 731           if (!cpp_interpret_string_notranslate (parse_in, strs, count,
 732                                                  &istr, wide))
 733             /* Assume that, if we managed to translate the string
 734                above, then the untranslated parsing will always
 735                succeed.  */
 736             abort ();
 737
 738           if (TREE_STRING_LENGTH (value) != (int)istr.len
 739               || 0 != strncmp (TREE_STRING_POINTER (value), (char *)istr.text,
 740                                istr.len))
 741             {
 742               /* Arrange for us to return the untranslated string in
 743                  *valp, but to set up the C type of the translated
 744                  one.  */
 745               *valp = build_string (istr.len, (char *)istr.text);
 746               valp = &TREE_CHAIN (*valp);
 747             }
 748           free ((void *)istr.text);
 749         }
 750     }
 751   else
 752     {
 753       /* Callers cannot generally handle error_mark_node in this context,
 754          so return the empty string instead.  cpp_interpret_string has
 755          issued an error.  */
 756       if (wide)
 757         value = build_string (TYPE_PRECISION (wchar_type_node)
 758                               / TYPE_PRECISION (char_type_node),
 759                               "\0\0\0");  /* widest supported wchar_t
 760                                              is 32 bits */
 761       else
 762         value = build_string (1, "");
 763     }
 764
 765   TREE_TYPE (value) = wide ? wchar_array_type_node : char_array_type_node;
 766   *valp = fix_string_type (value);
 767
 768   if (strs != &str)
 769     obstack_free (&str_ob, 0);
 770
 771   return objc_string ? CPP_OBJC_STRING : wide ? CPP_WSTRING : CPP_STRING;
 772 }
 773
 774 /* Converts a (possibly wide) character constant token into a tree.  */
 775 static tree
 776 lex_charconst (const cpp_token *token)
 777 {
 778   cppchar_t result;
 779   tree type, value;
 780   unsigned int chars_seen;
 781   int unsignedp;
 782
 783   result = cpp_interpret_charconst (parse_in, token,
 784                                     &chars_seen, &unsignedp);
 785
 786   /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
 787      before possibly widening to HOST_WIDE_INT for build_int_2.  */
 788   if (unsignedp || (cppchar_signed_t) result >= 0)
 789     value = build_int_2 (result, 0);
 790   else
 791     value = build_int_2 ((cppchar_signed_t) result, -1);
 792
 793   if (token->type == CPP_WCHAR)
 794     type = wchar_type_node;
 795   /* In C, a character constant has type 'int'.
 796      In C++ 'char', but multi-char charconsts have type 'int'.  */
 797   else if (!c_dialect_cxx () || chars_seen > 1)
 798     type = integer_type_node;
 799   else
 800     type = char_type_node;
 801
 802   TREE_TYPE (value) = type;
 803   return value;
 804 }