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 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 "expr.h"
  31 #include "input.h"
  32 #include "output.h"
  33 #include "c-tree.h"
  34 #include "c-common.h"
  35 #include "flags.h"
  36 #include "timevar.h"
  37 #include "cpplib.h"
  38 #include "c-pragma.h"
  39 #include "toplev.h"
  40 #include "intl.h"
  41 #include "tm_p.h"
  42 #include "splay-tree.h"
  43 #include "debug.h"
  44
  45 /* The current line map.  */
  46 static const struct line_map *map;
  47
  48 /* The line used to refresh the lineno global variable after each token.  */
  49 static unsigned int src_lineno;
  50
  51 /* We may keep statistics about how long which files took to compile.  */
  52 static int header_time, body_time;
  53 static splay_tree file_info_tree;
  54
  55 #undef WCHAR_TYPE_SIZE
  56 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
  57
  58 /* Number of bytes in a wide character.  */
  59 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
  60
  61 int pending_lang_change; /* If we need to switch languages - C++ only */
  62 int c_header_level;      /* depth in C headers - C++ only */
  63
  64 static tree interpret_integer (const cpp_token *, unsigned int);
  65 static tree interpret_float (const cpp_token *, unsigned int);
  66 static enum integer_type_kind
  67   narrowest_unsigned_type (tree, unsigned int);
  68 static enum integer_type_kind
  69   narrowest_signed_type (tree, unsigned int);
  70 static enum cpp_ttype lex_string (const cpp_token *, tree *, bool);
  71 static tree lex_charconst (const cpp_token *);
  72 static void update_header_times (const char *);
  73 static int dump_one_header (splay_tree_node, void *);
  74 static void cb_line_change (cpp_reader *, const cpp_token *, int);
  75 static void cb_dir_change (cpp_reader *, const char *);
  76 static void cb_ident (cpp_reader *, unsigned int, const cpp_string *);
  77 static void cb_def_pragma (cpp_reader *, unsigned int);
  78 static void cb_define (cpp_reader *, unsigned int, cpp_hashnode *);
  79 static void cb_undef (cpp_reader *, unsigned int, cpp_hashnode *);
  80 \f
  81 void
  82 init_c_lex (void)
  83 {
  84   struct cpp_callbacks *cb;
  85   struct c_fileinfo *toplevel;
  86
  87   /* Set up filename timing.  Must happen before cpp_read_main_file.  */
  88   file_info_tree = splay_tree_new ((splay_tree_compare_fn)strcmp,
  89                                    0,
  90                                    (splay_tree_delete_value_fn)free);
  91   toplevel = get_fileinfo ("<top level>");
  92   if (flag_detailed_statistics)
  93     {
  94       header_time = 0;
  95       body_time = get_run_time ();
  96       toplevel->time = body_time;
  97     }
  98
  99   cb = cpp_get_callbacks (parse_in);
 100
 101   cb->line_change = cb_line_change;
 102   cb->dir_change = cb_dir_change;
 103   cb->ident = cb_ident;
 104   cb->def_pragma = cb_def_pragma;
 105   cb->valid_pch = c_common_valid_pch;
 106   cb->read_pch = c_common_read_pch;
 107
 108   /* Set the debug callbacks if we can use them.  */
 109   if (debug_info_level == DINFO_LEVEL_VERBOSE
 110       && (write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG
 111           || write_symbols == VMS_AND_DWARF2_DEBUG))
 112     {
 113       cb->define = cb_define;
 114       cb->undef = cb_undef;
 115     }
 116 }
 117
 118 struct c_fileinfo *
 119 get_fileinfo (const char *name)
 120 {
 121   splay_tree_node n;
 122   struct c_fileinfo *fi;
 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 = xmalloc (sizeof (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 *dummy ATTRIBUTE_UNUSED)
 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 *pfile ATTRIBUTE_UNUSED,
 179           unsigned int line ATTRIBUTE_UNUSED,
 180           const cpp_string *str ATTRIBUTE_UNUSED)
 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 ((void *)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 *pfile ATTRIBUTE_UNUSED, const cpp_token *token,
 200                 int parsing_args ATTRIBUTE_UNUSED)
 201 {
 202   src_lineno = SOURCE_LINE (map, token->line);
 203 }
 204
 205 static void
 206 cb_dir_change (cpp_reader *pfile ATTRIBUTE_UNUSED, const char *dir)
 207 {
 208   if (! set_src_pwd (dir))
 209     warning ("too late for # directive to set debug directory");
 210 }
 211
 212 void
 213 fe_file_change (const struct line_map *new_map)
 214 {
 215   unsigned int to_line = SOURCE_LINE (new_map, new_map->to_line);
 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 (map == NULL)
 222         main_input_filename = new_map->to_file;
 223       else
 224         {
 225           int included_at = SOURCE_LINE (new_map - 1, new_map->from_line - 1);
 226
 227           input_line = included_at;
 228           push_srcloc (new_map->to_file, 1);
 229           (*debug_hooks->start_source_file) (included_at, new_map->to_file);
 230 #ifndef NO_IMPLICIT_EXTERN_C
 231           if (c_header_level)
 232             ++c_header_level;
 233           else if (new_map->sysp == 2)
 234             {
 235               c_header_level = 1;
 236               ++pending_lang_change;
 237             }
 238 #endif
 239         }
 240     }
 241   else if (new_map->reason == LC_LEAVE)
 242     {
 243 #ifndef NO_IMPLICIT_EXTERN_C
 244       if (c_header_level && --c_header_level == 0)
 245         {
 246           if (new_map->sysp == 2)
 247             warning ("badly nested C headers from preprocessor");
 248           --pending_lang_change;
 249         }
 250 #endif
 251       pop_srcloc ();
 252
 253       (*debug_hooks->end_source_file) (to_line);
 254     }
 255
 256   update_header_times (new_map->to_file);
 257   in_system_header = new_map->sysp != 0;
 258   input_filename = new_map->to_file;
 259   input_line = to_line;
 260   map = new_map;
 261
 262   /* Hook for C++.  */
 263   extract_interface_info ();
 264 }
 265
 266 static void
 267 cb_def_pragma (cpp_reader *pfile, unsigned int line)
 268 {
 269   /* Issue a warning message if we have been asked to do so.  Ignore
 270      unknown pragmas in system headers unless an explicit
 271      -Wunknown-pragmas has been given.  */
 272   if (warn_unknown_pragmas > in_system_header)
 273     {
 274       const unsigned char *space, *name;
 275       const cpp_token *s;
 276
 277       space = name = (const unsigned char *) "";
 278       s = cpp_get_token (pfile);
 279       if (s->type != CPP_EOF)
 280         {
 281           space = cpp_token_as_text (pfile, s);
 282           s = cpp_get_token (pfile);
 283           if (s->type == CPP_NAME)
 284             name = cpp_token_as_text (pfile, s);
 285         }
 286
 287       input_line = SOURCE_LINE (map, line);
 288       warning ("ignoring #pragma %s %s", space, name);
 289     }
 290 }
 291
 292 /* #define callback for DWARF and DWARF2 debug info.  */
 293 static void
 294 cb_define (cpp_reader *pfile, unsigned int line, cpp_hashnode *node)
 295 {
 296   (*debug_hooks->define) (SOURCE_LINE (map, line),
 297                           (const char *) cpp_macro_definition (pfile, node));
 298 }
 299
 300 /* #undef callback for DWARF and DWARF2 debug info.  */
 301 static void
 302 cb_undef (cpp_reader *pfile ATTRIBUTE_UNUSED, unsigned int line,
 303           cpp_hashnode *node)
 304 {
 305   (*debug_hooks->undef) (SOURCE_LINE (map, line),
 306                          (const char *) NODE_NAME (node));
 307 }
 308 \f
 309 static inline const cpp_token *
 310 get_nonpadding_token (void)
 311 {
 312   const cpp_token *tok;
 313   timevar_push (TV_CPP);
 314   do
 315     tok = cpp_get_token (parse_in);
 316   while (tok->type == CPP_PADDING);
 317   timevar_pop (TV_CPP);
 318
 319   /* The C++ front end does horrible things with the current line
 320      number.  To ensure an accurate line number, we must reset it
 321      every time we advance a token.  */
 322   input_line = src_lineno;
 323
 324   return tok;
 325 }
 326
 327 int
 328 c_lex (tree *value)
 329 {
 330   const cpp_token *tok;
 331   location_t atloc;
 332   static bool no_more_pch;
 333
 334  retry:
 335   tok = get_nonpadding_token ();
 336
 337  retry_after_at:
 338   switch (tok->type)
 339     {
 340     case CPP_NAME:
 341       *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
 342       break;
 343
 344     case CPP_NUMBER:
 345       {
 346         unsigned int flags = cpp_classify_number (parse_in, tok);
 347
 348         switch (flags & CPP_N_CATEGORY)
 349           {
 350           case CPP_N_INVALID:
 351             /* cpplib has issued an error.  */
 352             *value = error_mark_node;
 353             break;
 354
 355           case CPP_N_INTEGER:
 356             *value = interpret_integer (tok, flags);
 357             break;
 358
 359           case CPP_N_FLOATING:
 360             *value = interpret_float (tok, flags);
 361             break;
 362
 363           default:
 364             abort ();
 365           }
 366       }
 367       break;
 368
 369     case CPP_ATSIGN:
 370       /* An @ may give the next token special significance in Objective-C.  */
 371       atloc = input_location;
 372       tok = get_nonpadding_token ();
 373       if (c_dialect_objc ())
 374         {
 375           tree val;
 376           switch (tok->type)
 377             {
 378             case CPP_NAME:
 379               val = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
 380               if (C_IS_RESERVED_WORD (val)
 381                   && OBJC_IS_AT_KEYWORD (C_RID_CODE (val)))
 382                 {
 383                   *value = val;
 384                   return CPP_AT_NAME;
 385                 }
 386               break;
 387
 388             case CPP_STRING:
 389             case CPP_WSTRING:
 390               return lex_string (tok, value, true);
 391
 392             default: break;
 393             }
 394         }
 395
 396       /* ... or not.  */
 397       error ("%Hstray '@' in program", &atloc);
 398       goto retry_after_at;
 399
 400     case CPP_OTHER:
 401       {
 402         cppchar_t c = tok->val.str.text[0];
 403
 404         if (c == '"' || c == '\'')
 405           error ("missing terminating %c character", (int) c);
 406         else if (ISGRAPH (c))
 407           error ("stray '%c' in program", (int) c);
 408         else
 409           error ("stray '\\%o' in program", (int) c);
 410       }
 411       goto retry;
 412
 413     case CPP_CHAR:
 414     case CPP_WCHAR:
 415       *value = lex_charconst (tok);
 416       break;
 417
 418     case CPP_STRING:
 419     case CPP_WSTRING:
 420       return lex_string (tok, value, false);
 421       break;
 422
 423       /* These tokens should not be visible outside cpplib.  */
 424     case CPP_HEADER_NAME:
 425     case CPP_COMMENT:
 426     case CPP_MACRO_ARG:
 427       abort ();
 428
 429     default:
 430       *value = NULL_TREE;
 431       break;
 432     }
 433
 434   if (! no_more_pch)
 435     {
 436       no_more_pch = true;
 437       c_common_no_more_pch ();
 438     }
 439
 440   return tok->type;
 441 }
 442
 443 /* Returns the narrowest C-visible unsigned type, starting with the
 444    minimum specified by FLAGS, that can fit VALUE, or itk_none if
 445    there isn't one.  */
 446 static enum integer_type_kind
 447 narrowest_unsigned_type (tree value, unsigned int flags)
 448 {
 449   enum integer_type_kind itk;
 450
 451   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 452     itk = itk_unsigned_int;
 453   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 454     itk = itk_unsigned_long;
 455   else
 456     itk = itk_unsigned_long_long;
 457
 458   /* int_fits_type_p must think the type of its first argument is
 459      wider than its second argument, or it won't do the proper check.  */
 460   TREE_TYPE (value) = widest_unsigned_literal_type_node;
 461
 462   for (; itk < itk_none; itk += 2 /* skip unsigned types */)
 463     if (int_fits_type_p (value, integer_types[itk]))
 464       return itk;
 465
 466   return itk_none;
 467 }
 468
 469 /* Ditto, but narrowest signed type.  */
 470 static enum integer_type_kind
 471 narrowest_signed_type (tree value, unsigned int flags)
 472 {
 473   enum integer_type_kind itk;
 474
 475   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 476     itk = itk_int;
 477   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 478     itk = itk_long;
 479   else
 480     itk = itk_long_long;
 481
 482   /* int_fits_type_p must think the type of its first argument is
 483      wider than its second argument, or it won't do the proper check.  */
 484   TREE_TYPE (value) = widest_unsigned_literal_type_node;
 485
 486   for (; itk < itk_none; itk += 2 /* skip signed types */)
 487     if (int_fits_type_p (value, integer_types[itk]))
 488       return itk;
 489
 490   return itk_none;
 491 }
 492
 493 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib.  */
 494 static tree
 495 interpret_integer (const cpp_token *token, unsigned int flags)
 496 {
 497   tree value, type;
 498   enum integer_type_kind itk;
 499   cpp_num integer;
 500   cpp_options *options = cpp_get_options (parse_in);
 501
 502   integer = cpp_interpret_integer (parse_in, token, flags);
 503   integer = cpp_num_sign_extend (integer, options->precision);
 504   value = build_int_2_wide (integer.low, integer.high);
 505
 506   /* The type of a constant with a U suffix is straightforward.  */
 507   if (flags & CPP_N_UNSIGNED)
 508     itk = narrowest_unsigned_type (value, flags);
 509   else
 510     {
 511       /* The type of a potentially-signed integer constant varies
 512          depending on the base it's in, the standard in use, and the
 513          length suffixes.  */
 514       enum integer_type_kind itk_u = narrowest_unsigned_type (value, flags);
 515       enum integer_type_kind itk_s = narrowest_signed_type (value, flags);
 516
 517       /* In both C89 and C99, octal and hex constants may be signed or
 518          unsigned, whichever fits tighter.  We do not warn about this
 519          choice differing from the traditional choice, as the constant
 520          is probably a bit pattern and either way will work.  */
 521       if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
 522         itk = MIN (itk_u, itk_s);
 523       else
 524         {
 525           /* In C99, decimal constants are always signed.
 526              In C89, decimal constants that don't fit in long have
 527              undefined behavior; we try to make them unsigned long.
 528              In GCC's extended C89, that last is true of decimal
 529              constants that don't fit in long long, too.  */
 530
 531           itk = itk_s;
 532           if (itk_s > itk_u && itk_s > itk_long)
 533             {
 534               if (!flag_isoc99)
 535                 {
 536                   if (itk_u < itk_unsigned_long)
 537                     itk_u = itk_unsigned_long;
 538                   itk = itk_u;
 539                   warning ("this decimal constant is unsigned only in ISO C90");
 540                 }
 541               else if (warn_traditional)
 542                 warning ("this decimal constant would be unsigned in ISO C90");
 543             }
 544         }
 545     }
 546
 547   if (itk == itk_none)
 548     /* cpplib has already issued a warning for overflow.  */
 549     type = ((flags & CPP_N_UNSIGNED)
 550             ? widest_unsigned_literal_type_node
 551             : widest_integer_literal_type_node);
 552   else
 553     type = integer_types[itk];
 554
 555   if (itk > itk_unsigned_long
 556       && (flags & CPP_N_WIDTH) != CPP_N_LARGE
 557       && ! in_system_header && ! flag_isoc99)
 558     pedwarn ("integer constant is too large for \"%s\" type",
 559              (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long");
 560
 561   TREE_TYPE (value) = type;
 562
 563   /* Convert imaginary to a complex type.  */
 564   if (flags & CPP_N_IMAGINARY)
 565     value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
 566
 567   return value;
 568 }
 569
 570 /* Interpret TOKEN, a floating point number with FLAGS as classified
 571    by cpplib.  */
 572 static tree
 573 interpret_float (const cpp_token *token, unsigned int flags)
 574 {
 575   tree type;
 576   tree value;
 577   REAL_VALUE_TYPE real;
 578   char *copy;
 579   size_t copylen;
 580   const char *typename;
 581
 582   /* FIXME: make %T work in error/warning, then we don't need typename.  */
 583   if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 584     {
 585       type = long_double_type_node;
 586       typename = "long double";
 587     }
 588   else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
 589            || flag_single_precision_constant)
 590     {
 591       type = float_type_node;
 592       typename = "float";
 593     }
 594   else
 595     {
 596       type = double_type_node;
 597       typename = "double";
 598     }
 599
 600   /* Copy the constant to a nul-terminated buffer.  If the constant
 601      has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
 602      can't handle them.  */
 603   copylen = token->val.str.len;
 604   if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
 605     /* Must be an F or L suffix.  */
 606     copylen--;
 607   if (flags & CPP_N_IMAGINARY)
 608     /* I or J suffix.  */
 609     copylen--;
 610
 611   copy = alloca (copylen + 1);
 612   memcpy (copy, token->val.str.text, copylen);
 613   copy[copylen] = '\0';
 614
 615   real_from_string (&real, copy);
 616   real_convert (&real, TYPE_MODE (type), &real);
 617
 618   /* A diagnostic is required for "soft" overflow by some ISO C
 619      testsuites.  This is not pedwarn, because some people don't want
 620      an error for this.
 621      ??? That's a dubious reason... is this a mandatory diagnostic or
 622      isn't it?   -- zw, 2001-08-21.  */
 623   if (REAL_VALUE_ISINF (real) && pedantic)
 624     warning ("floating constant exceeds range of \"%s\"", typename);
 625
 626   /* Create a node with determined type and value.  */
 627   value = build_real (type, real);
 628   if (flags & CPP_N_IMAGINARY)
 629     value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
 630
 631   return value;
 632 }
 633
 634 /* Convert a series of STRING and/or WSTRING tokens into a tree,
 635    performing string constant concatenation.  TOK is the first of
 636    these.  VALP is the location to write the string into.  OBJC_STRING
 637    indicates whether an '@' token preceded the incoming token.
 638    Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
 639    or CPP_OBJC_STRING).
 640
 641    This is unfortunately more work than it should be.  If any of the
 642    strings in the series has an L prefix, the result is a wide string
 643    (6.4.5p4).  Whether or not the result is a wide string affects the
 644    meaning of octal and hexadecimal escapes (6.4.4.4p6,9).  But escape
 645    sequences do not continue across the boundary between two strings in
 646    a series (6.4.5p7), so we must not lose the boundaries.  Therefore
 647    cpp_interpret_string takes a vector of cpp_string structures, which
 648    we must arrange to provide.  */
 649
 650 static enum cpp_ttype
 651 lex_string (const cpp_token *tok, tree *valp, bool objc_string)
 652 {
 653   tree value;
 654   bool wide = false;
 655   size_t count = 1;
 656   struct obstack str_ob;
 657   cpp_string istr;
 658
 659   /* Try to avoid the overhead of creating and destroying an obstack
 660      for the common case of just one string.  */
 661   cpp_string str = tok->val.str;
 662   cpp_string *strs = &str;
 663
 664   if (tok->type == CPP_WSTRING)
 665     wide = true;
 666
 667   tok = get_nonpadding_token ();
 668   if (c_dialect_objc () && tok->type == CPP_ATSIGN)
 669     {
 670       objc_string = true;
 671       tok = get_nonpadding_token ();
 672     }
 673   if (tok->type == CPP_STRING || tok->type == CPP_WSTRING)
 674     {
 675       gcc_obstack_init (&str_ob);
 676       obstack_grow (&str_ob, &str, sizeof (cpp_string));
 677
 678       do
 679         {
 680           count++;
 681           if (tok->type == CPP_WSTRING)
 682             wide = true;
 683           obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
 684
 685           tok = get_nonpadding_token ();
 686           if (c_dialect_objc () && tok->type == CPP_ATSIGN)
 687             {
 688               objc_string = true;
 689               tok = get_nonpadding_token ();
 690             }
 691         }
 692       while (tok->type == CPP_STRING || tok->type == CPP_WSTRING);
 693       strs = obstack_finish (&str_ob);
 694     }
 695
 696   /* We have read one more token than we want.  */
 697   _cpp_backup_tokens (parse_in, 1);
 698
 699   if (count > 1 && !objc_string && warn_traditional && !in_system_header)
 700     warning ("traditional C rejects string constant concatenation");
 701
 702   if (cpp_interpret_string (parse_in, strs, count, &istr, wide))
 703     {
 704       value = build_string (istr.len, (char *)istr.text);
 705       free ((void *)istr.text);
 706     }
 707   else
 708     {
 709       /* Callers cannot generally handle error_mark_node in this context,
 710          so return the empty string instead.  cpp_interpret_string has
 711          issued an error.  */
 712       if (wide)
 713         value = build_string (TYPE_PRECISION (wchar_type_node)
 714                               / TYPE_PRECISION (char_type_node),
 715                               "\0\0\0");  /* widest supported wchar_t
 716                                              is 32 bits */
 717       else
 718         value = build_string (1, "");
 719     }
 720
 721   TREE_TYPE (value) = wide ? wchar_array_type_node : char_array_type_node;
 722   *valp = fix_string_type (value);
 723
 724   if (strs != &str)
 725     obstack_free (&str_ob, 0);
 726
 727   return objc_string ? CPP_OBJC_STRING : wide ? CPP_WSTRING : CPP_STRING;
 728 }
 729
 730 /* Converts a (possibly wide) character constant token into a tree.  */
 731 static tree
 732 lex_charconst (const cpp_token *token)
 733 {
 734   cppchar_t result;
 735   tree type, value;
 736   unsigned int chars_seen;
 737   int unsignedp;
 738
 739   result = cpp_interpret_charconst (parse_in, token,
 740                                     &chars_seen, &unsignedp);
 741
 742   /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
 743      before possibly widening to HOST_WIDE_INT for build_int_2.  */
 744   if (unsignedp || (cppchar_signed_t) result >= 0)
 745     value = build_int_2 (result, 0);
 746   else
 747     value = build_int_2 ((cppchar_signed_t) result, -1);
 748
 749   if (token->type == CPP_WCHAR)
 750     type = wchar_type_node;
 751   /* In C, a character constant has type 'int'.
 752      In C++ 'char', but multi-char charconsts have type 'int'.  */
 753   else if (!c_dialect_cxx () || chars_seen > 1)
 754     type = integer_type_node;
 755   else
 756     type = char_type_node;
 757
 758   TREE_TYPE (value) = type;
 759   return value;
 760 }