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