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