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