gcc/c-lex.c

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