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