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 "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_with_flags (tree *value, unsigned char *cpp_flags)
 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   if (cpp_flags)
 440     *cpp_flags = tok->flags;
 441   return tok->type;
 442 }
 443
 444 int
 445 c_lex (tree *value)
 446 {
 447   return c_lex_with_flags (value, NULL);
 448 }
 449
 450 /* Returns the narrowest C-visible unsigned type, starting with the
 451    minimum specified by FLAGS, that can fit VALUE, or itk_none if
 452    there isn't one.  */
 453 static enum integer_type_kind
 454 narrowest_unsigned_type (tree value, unsigned int flags)
 455 {
 456   enum integer_type_kind itk;
 457
 458   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 459     itk = itk_unsigned_int;
 460   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 461     itk = itk_unsigned_long;
 462   else
 463     itk = itk_unsigned_long_long;
 464
 465   /* int_fits_type_p must think the type of its first argument is
 466      wider than its second argument, or it won't do the proper check.  */
 467   TREE_TYPE (value) = widest_unsigned_literal_type_node;
 468
 469   for (; itk < itk_none; itk += 2 /* skip unsigned types */)
 470     if (int_fits_type_p (value, integer_types[itk]))
 471       return itk;
 472
 473   return itk_none;
 474 }
 475
 476 /* Ditto, but narrowest signed type.  */
 477 static enum integer_type_kind
 478 narrowest_signed_type (tree value, unsigned int flags)
 479 {
 480   enum integer_type_kind itk;
 481
 482   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 483     itk = itk_int;
 484   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 485     itk = itk_long;
 486   else
 487     itk = itk_long_long;
 488
 489   /* int_fits_type_p must think the type of its first argument is
 490      wider than its second argument, or it won't do the proper check.  */
 491   TREE_TYPE (value) = widest_unsigned_literal_type_node;
 492
 493   for (; itk < itk_none; itk += 2 /* skip signed types */)
 494     if (int_fits_type_p (value, integer_types[itk]))
 495       return itk;
 496
 497   return itk_none;
 498 }
 499
 500 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib.  */
 501 static tree
 502 interpret_integer (const cpp_token *token, unsigned int flags)
 503 {
 504   tree value, type;
 505   enum integer_type_kind itk;
 506   cpp_num integer;
 507   cpp_options *options = cpp_get_options (parse_in);
 508
 509   integer = cpp_interpret_integer (parse_in, token, flags);
 510   integer = cpp_num_sign_extend (integer, options->precision);
 511   value = build_int_2_wide (integer.low, integer.high);
 512
 513   /* The type of a constant with a U suffix is straightforward.  */
 514   if (flags & CPP_N_UNSIGNED)
 515     itk = narrowest_unsigned_type (value, flags);
 516   else
 517     {
 518       /* The type of a potentially-signed integer constant varies
 519          depending on the base it's in, the standard in use, and the
 520          length suffixes.  */
 521       enum integer_type_kind itk_u = narrowest_unsigned_type (value, flags);
 522       enum integer_type_kind itk_s = narrowest_signed_type (value, flags);
 523
 524       /* In both C89 and C99, octal and hex constants may be signed or
 525          unsigned, whichever fits tighter.  We do not warn about this
 526          choice differing from the traditional choice, as the constant
 527          is probably a bit pattern and either way will work.  */
 528       if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
 529         itk = MIN (itk_u, itk_s);
 530       else
 531         {
 532           /* In C99, decimal constants are always signed.
 533              In C89, decimal constants that don't fit in long have
 534              undefined behavior; we try to make them unsigned long.
 535              In GCC's extended C89, that last is true of decimal
 536              constants that don't fit in long long, too.  */
 537
 538           itk = itk_s;
 539           if (itk_s > itk_u && itk_s > itk_long)
 540             {
 541               if (!flag_isoc99)
 542                 {
 543                   if (itk_u < itk_unsigned_long)
 544                     itk_u = itk_unsigned_long;
 545                   itk = itk_u;
 546                   warning ("this decimal constant is unsigned only in ISO C90");
 547                 }
 548               else if (warn_traditional)
 549                 warning ("this decimal constant would be unsigned in ISO C90");
 550             }
 551         }
 552     }
 553
 554   if (itk == itk_none)
 555     /* cpplib has already issued a warning for overflow.  */
 556     type = ((flags & CPP_N_UNSIGNED)
 557             ? widest_unsigned_literal_type_node
 558             : widest_integer_literal_type_node);
 559   else
 560     type = integer_types[itk];
 561
 562   if (itk > itk_unsigned_long
 563       && (flags & CPP_N_WIDTH) != CPP_N_LARGE
 564       && ! in_system_header && ! flag_isoc99)
 565     pedwarn ("integer constant is too large for \"%s\" type",
 566              (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long");
 567
 568   TREE_TYPE (value) = type;
 569
 570   /* Convert imaginary to a complex type.  */
 571   if (flags & CPP_N_IMAGINARY)
 572     value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
 573
 574   return value;
 575 }
 576
 577 /* Interpret TOKEN, a floating point number with FLAGS as classified
 578    by cpplib.  */
 579 static tree
 580 interpret_float (const cpp_token *token, unsigned int flags)
 581 {
 582   tree type;
 583   tree value;
 584   REAL_VALUE_TYPE real;
 585   char *copy;
 586   size_t copylen;
 587   const char *typename;
 588
 589   /* FIXME: make %T work in error/warning, then we don't need typename.  */
 590   if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 591     {
 592       type = long_double_type_node;
 593       typename = "long double";
 594     }
 595   else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
 596            || flag_single_precision_constant)
 597     {
 598       type = float_type_node;
 599       typename = "float";
 600     }
 601   else
 602     {
 603       type = double_type_node;
 604       typename = "double";
 605     }
 606
 607   /* Copy the constant to a nul-terminated buffer.  If the constant
 608      has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
 609      can't handle them.  */
 610   copylen = token->val.str.len;
 611   if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
 612     /* Must be an F or L suffix.  */
 613     copylen--;
 614   if (flags & CPP_N_IMAGINARY)
 615     /* I or J suffix.  */
 616     copylen--;
 617
 618   copy = alloca (copylen + 1);
 619   memcpy (copy, token->val.str.text, copylen);
 620   copy[copylen] = '\0';
 621
 622   real_from_string (&real, copy);
 623   real_convert (&real, TYPE_MODE (type), &real);
 624
 625   /* A diagnostic is required for "soft" overflow by some ISO C
 626      testsuites.  This is not pedwarn, because some people don't want
 627      an error for this.
 628      ??? That's a dubious reason... is this a mandatory diagnostic or
 629      isn't it?   -- zw, 2001-08-21.  */
 630   if (REAL_VALUE_ISINF (real) && pedantic)
 631     warning ("floating constant exceeds range of \"%s\"", typename);
 632
 633   /* Create a node with determined type and value.  */
 634   value = build_real (type, real);
 635   if (flags & CPP_N_IMAGINARY)
 636     value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
 637
 638   return value;
 639 }
 640
 641 /* Convert a series of STRING and/or WSTRING tokens into a tree,
 642    performing string constant concatenation.  TOK is the first of
 643    these.  VALP is the location to write the string into.  OBJC_STRING
 644    indicates whether an '@' token preceded the incoming token.
 645    Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
 646    or CPP_OBJC_STRING).
 647
 648    This is unfortunately more work than it should be.  If any of the
 649    strings in the series has an L prefix, the result is a wide string
 650    (6.4.5p4).  Whether or not the result is a wide string affects the
 651    meaning of octal and hexadecimal escapes (6.4.4.4p6,9).  But escape
 652    sequences do not continue across the boundary between two strings in
 653    a series (6.4.5p7), so we must not lose the boundaries.  Therefore
 654    cpp_interpret_string takes a vector of cpp_string structures, which
 655    we must arrange to provide.  */
 656
 657 static enum cpp_ttype
 658 lex_string (const cpp_token *tok, tree *valp, bool objc_string)
 659 {
 660   tree value;
 661   bool wide = false;
 662   size_t count = 1;
 663   struct obstack str_ob;
 664   cpp_string istr;
 665
 666   /* Try to avoid the overhead of creating and destroying an obstack
 667      for the common case of just one string.  */
 668   cpp_string str = tok->val.str;
 669   cpp_string *strs = &str;
 670
 671   if (tok->type == CPP_WSTRING)
 672     wide = true;
 673
 674   tok = get_nonpadding_token ();
 675   if (c_dialect_objc () && tok->type == CPP_ATSIGN)
 676     {
 677       objc_string = true;
 678       tok = get_nonpadding_token ();
 679     }
 680   if (tok->type == CPP_STRING || tok->type == CPP_WSTRING)
 681     {
 682       gcc_obstack_init (&str_ob);
 683       obstack_grow (&str_ob, &str, sizeof (cpp_string));
 684
 685       do
 686         {
 687           count++;
 688           if (tok->type == CPP_WSTRING)
 689             wide = true;
 690           obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
 691
 692           tok = get_nonpadding_token ();
 693           if (c_dialect_objc () && tok->type == CPP_ATSIGN)
 694             {
 695               objc_string = true;
 696               tok = get_nonpadding_token ();
 697             }
 698         }
 699       while (tok->type == CPP_STRING || tok->type == CPP_WSTRING);
 700       strs = obstack_finish (&str_ob);
 701     }
 702
 703   /* We have read one more token than we want.  */
 704   _cpp_backup_tokens (parse_in, 1);
 705
 706   if (count > 1 && !objc_string && warn_traditional && !in_system_header)
 707     warning ("traditional C rejects string constant concatenation");
 708
 709   if (cpp_interpret_string (parse_in, strs, count, &istr, wide))
 710     {
 711       value = build_string (istr.len, (char *)istr.text);
 712       free ((void *)istr.text);
 713     }
 714   else
 715     {
 716       /* Callers cannot generally handle error_mark_node in this context,
 717          so return the empty string instead.  cpp_interpret_string has
 718          issued an error.  */
 719       if (wide)
 720         value = build_string (TYPE_PRECISION (wchar_type_node)
 721                               / TYPE_PRECISION (char_type_node),
 722                               "\0\0\0");  /* widest supported wchar_t
 723                                              is 32 bits */
 724       else
 725         value = build_string (1, "");
 726     }
 727
 728   TREE_TYPE (value) = wide ? wchar_array_type_node : char_array_type_node;
 729   *valp = fix_string_type (value);
 730
 731   if (strs != &str)
 732     obstack_free (&str_ob, 0);
 733
 734   return objc_string ? CPP_OBJC_STRING : wide ? CPP_WSTRING : CPP_STRING;
 735 }
 736
 737 /* Converts a (possibly wide) character constant token into a tree.  */
 738 static tree
 739 lex_charconst (const cpp_token *token)
 740 {
 741   cppchar_t result;
 742   tree type, value;
 743   unsigned int chars_seen;
 744   int unsignedp;
 745
 746   result = cpp_interpret_charconst (parse_in, token,
 747                                     &chars_seen, &unsignedp);
 748
 749   /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
 750      before possibly widening to HOST_WIDE_INT for build_int_2.  */
 751   if (unsignedp || (cppchar_signed_t) result >= 0)
 752     value = build_int_2 (result, 0);
 753   else
 754     value = build_int_2 ((cppchar_signed_t) result, -1);
 755
 756   if (token->type == CPP_WCHAR)
 757     type = wchar_type_node;
 758   /* In C, a character constant has type 'int'.
 759      In C++ 'char', but multi-char charconsts have type 'int'.  */
 760   else if (!c_dialect_cxx () || chars_seen > 1)
 761     type = integer_type_node;
 762   else
 763     type = char_type_node;
 764
 765   TREE_TYPE (value) = type;
 766   return value;
 767 }