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_2 (integer.low, integer.high);
 592   TREE_TYPE (value) = type;
 593
 594   /* Convert imaginary to a complex type.  */
 595   if (flags & CPP_N_IMAGINARY)
 596     value = build_complex (NULL_TREE,
 597                            convert (type, integer_zero_node), value);
 598
 599   return value;
 600 }
 601
 602 /* Interpret TOKEN, a floating point number with FLAGS as classified
 603    by cpplib.  */
 604 static tree
 605 interpret_float (const cpp_token *token, unsigned int flags)
 606 {
 607   tree type;
 608   tree value;
 609   REAL_VALUE_TYPE real;
 610   char *copy;
 611   size_t copylen;
 612   const char *type_name;
 613
 614   /* FIXME: make %T work in error/warning, then we don't need type_name.  */
 615   if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 616     {
 617       type = long_double_type_node;
 618       type_name = "long double";
 619     }
 620   else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
 621            || flag_single_precision_constant)
 622     {
 623       type = float_type_node;
 624       type_name = "float";
 625     }
 626   else
 627     {
 628       type = double_type_node;
 629       type_name = "double";
 630     }
 631
 632   /* Copy the constant to a nul-terminated buffer.  If the constant
 633      has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
 634      can't handle them.  */
 635   copylen = token->val.str.len;
 636   if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
 637     /* Must be an F or L suffix.  */
 638     copylen--;
 639   if (flags & CPP_N_IMAGINARY)
 640     /* I or J suffix.  */
 641     copylen--;
 642
 643   copy = (char *) alloca (copylen + 1);
 644   memcpy (copy, token->val.str.text, copylen);
 645   copy[copylen] = '\0';
 646
 647   real_from_string (&real, copy);
 648   real_convert (&real, TYPE_MODE (type), &real);
 649
 650   /* A diagnostic is required for "soft" overflow by some ISO C
 651      testsuites.  This is not pedwarn, because some people don't want
 652      an error for this.
 653      ??? That's a dubious reason... is this a mandatory diagnostic or
 654      isn't it?   -- zw, 2001-08-21.  */
 655   if (REAL_VALUE_ISINF (real) && pedantic)
 656     warning ("floating constant exceeds range of \"%s\"", type_name);
 657
 658   /* Create a node with determined type and value.  */
 659   value = build_real (type, real);
 660   if (flags & CPP_N_IMAGINARY)
 661     value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
 662
 663   return value;
 664 }
 665
 666 /* Convert a series of STRING and/or WSTRING tokens into a tree,
 667    performing string constant concatenation.  TOK is the first of
 668    these.  VALP is the location to write the string into.  OBJC_STRING
 669    indicates whether an '@' token preceded the incoming token.
 670    Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
 671    or CPP_OBJC_STRING).
 672
 673    This is unfortunately more work than it should be.  If any of the
 674    strings in the series has an L prefix, the result is a wide string
 675    (6.4.5p4).  Whether or not the result is a wide string affects the
 676    meaning of octal and hexadecimal escapes (6.4.4.4p6,9).  But escape
 677    sequences do not continue across the boundary between two strings in
 678    a series (6.4.5p7), so we must not lose the boundaries.  Therefore
 679    cpp_interpret_string takes a vector of cpp_string structures, which
 680    we must arrange to provide.  */
 681
 682 static enum cpp_ttype
 683 lex_string (const cpp_token *tok, tree *valp, bool objc_string)
 684 {
 685   tree value;
 686   bool wide = false;
 687   size_t count = 1;
 688   struct obstack str_ob;
 689   cpp_string istr;
 690
 691   /* Try to avoid the overhead of creating and destroying an obstack
 692      for the common case of just one string.  */
 693   cpp_string str = tok->val.str;
 694   cpp_string *strs = &str;
 695
 696   if (tok->type == CPP_WSTRING)
 697     wide = true;
 698
 699   tok = get_nonpadding_token ();
 700   if (c_dialect_objc () && tok->type == CPP_ATSIGN)
 701     {
 702       objc_string = true;
 703       tok = get_nonpadding_token ();
 704     }
 705   if (tok->type == CPP_STRING || tok->type == CPP_WSTRING)
 706     {
 707       gcc_obstack_init (&str_ob);
 708       obstack_grow (&str_ob, &str, sizeof (cpp_string));
 709
 710       do
 711         {
 712           count++;
 713           if (tok->type == CPP_WSTRING)
 714             wide = true;
 715           obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
 716
 717           tok = get_nonpadding_token ();
 718           if (c_dialect_objc () && tok->type == CPP_ATSIGN)
 719             {
 720               objc_string = true;
 721               tok = get_nonpadding_token ();
 722             }
 723         }
 724       while (tok->type == CPP_STRING || tok->type == CPP_WSTRING);
 725       strs = (cpp_string *) obstack_finish (&str_ob);
 726     }
 727
 728   /* We have read one more token than we want.  */
 729   _cpp_backup_tokens (parse_in, 1);
 730
 731   if (count > 1 && !objc_string && warn_traditional && !in_system_header)
 732     warning ("traditional C rejects string constant concatenation");
 733
 734   if ((c_lex_string_translate
 735        ? cpp_interpret_string : cpp_interpret_string_notranslate)
 736       (parse_in, strs, count, &istr, wide))
 737     {
 738       value = build_string (istr.len, (char *)istr.text);
 739       free ((void *)istr.text);
 740
 741       if (c_lex_string_translate == -1)
 742         {
 743           if (!cpp_interpret_string_notranslate (parse_in, strs, count,
 744                                                  &istr, wide))
 745             /* Assume that, if we managed to translate the string
 746                above, then the untranslated parsing will always
 747                succeed.  */
 748             abort ();
 749
 750           if (TREE_STRING_LENGTH (value) != (int)istr.len
 751               || 0 != strncmp (TREE_STRING_POINTER (value), (char *)istr.text,
 752                                istr.len))
 753             {
 754               /* Arrange for us to return the untranslated string in
 755                  *valp, but to set up the C type of the translated
 756                  one.  */
 757               *valp = build_string (istr.len, (char *)istr.text);
 758               valp = &TREE_CHAIN (*valp);
 759             }
 760           free ((void *)istr.text);
 761         }
 762     }
 763   else
 764     {
 765       /* Callers cannot generally handle error_mark_node in this context,
 766          so return the empty string instead.  cpp_interpret_string has
 767          issued an error.  */
 768       if (wide)
 769         value = build_string (TYPE_PRECISION (wchar_type_node)
 770                               / TYPE_PRECISION (char_type_node),
 771                               "\0\0\0");  /* widest supported wchar_t
 772                                              is 32 bits */
 773       else
 774         value = build_string (1, "");
 775     }
 776
 777   TREE_TYPE (value) = wide ? wchar_array_type_node : char_array_type_node;
 778   *valp = fix_string_type (value);
 779
 780   if (strs != &str)
 781     obstack_free (&str_ob, 0);
 782
 783   return objc_string ? CPP_OBJC_STRING : wide ? CPP_WSTRING : CPP_STRING;
 784 }
 785
 786 /* Converts a (possibly wide) character constant token into a tree.  */
 787 static tree
 788 lex_charconst (const cpp_token *token)
 789 {
 790   cppchar_t result;
 791   tree type, value;
 792   unsigned int chars_seen;
 793   int unsignedp;
 794
 795   result = cpp_interpret_charconst (parse_in, token,
 796                                     &chars_seen, &unsignedp);
 797
 798   /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
 799      before possibly widening to HOST_WIDE_INT for build_int_2.  */
 800   if (unsignedp || (cppchar_signed_t) result >= 0)
 801     value = build_int_2 (result, 0);
 802   else
 803     value = build_int_2 ((cppchar_signed_t) result, -1);
 804
 805   if (token->type == CPP_WCHAR)
 806     type = wchar_type_node;
 807   /* In C, a character constant has type 'int'.
 808      In C++ 'char', but multi-char charconsts have type 'int'.  */
 809   else if (!c_dialect_cxx () || chars_seen > 1)
 810     type = integer_type_node;
 811   else
 812     type = char_type_node;
 813
 814   TREE_TYPE (value) = type;
 815   return value;
 816 }