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