contrib/gcc-4.0/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 /* True if strings should be passed to the caller of c_lex completely
  64    unmolested (no concatenation, no translation).  */
  65 bool c_lex_return_raw_strings = false;
  66
  67 static tree interpret_integer (const cpp_token *, unsigned int);
  68 static tree interpret_float (const cpp_token *, unsigned int);
  69 static enum integer_type_kind narrowest_unsigned_type
  70         (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
  71 static enum integer_type_kind narrowest_signed_type
  72         (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
  73 static enum cpp_ttype lex_string (const cpp_token *, tree *, bool);
  74 static tree lex_charconst (const cpp_token *);
  75 static void update_header_times (const char *);
  76 static int dump_one_header (splay_tree_node, void *);
  77 static void cb_line_change (cpp_reader *, const cpp_token *, int);
  78 static void cb_ident (cpp_reader *, unsigned int, const cpp_string *);
  79 static void cb_def_pragma (cpp_reader *, unsigned int);
  80 static void cb_define (cpp_reader *, unsigned int, cpp_hashnode *);
  81 static void cb_undef (cpp_reader *, unsigned int, cpp_hashnode *);
  82 \f
  83 void
  84 init_c_lex (void)
  85 {
  86   struct cpp_callbacks *cb;
  87   struct c_fileinfo *toplevel;
  88
  89   /* The get_fileinfo data structure must be initialized before
  90      cpp_read_main_file is called.  */
  91   toplevel = get_fileinfo ("<top level>");
  92   if (flag_detailed_statistics)
  93     {
  94       header_time = 0;
  95       body_time = get_run_time ();
  96       toplevel->time = body_time;
  97     }
  98
  99   cb = cpp_get_callbacks (parse_in);
 100
 101   cb->line_change = cb_line_change;
 102   cb->ident = cb_ident;
 103   cb->def_pragma = cb_def_pragma;
 104   cb->valid_pch = c_common_valid_pch;
 105   cb->read_pch = c_common_read_pch;
 106
 107   /* Set the debug callbacks if we can use them.  */
 108   if (debug_info_level == DINFO_LEVEL_VERBOSE
 109       && (write_symbols == DWARF2_DEBUG
 110           || write_symbols == VMS_AND_DWARF2_DEBUG))
 111     {
 112       cb->define = cb_define;
 113       cb->undef = cb_undef;
 114     }
 115 }
 116
 117 struct c_fileinfo *
 118 get_fileinfo (const char *name)
 119 {
 120   splay_tree_node n;
 121   struct c_fileinfo *fi;
 122
 123   if (!file_info_tree)
 124     file_info_tree = splay_tree_new ((splay_tree_compare_fn) strcmp,
 125                                      0,
 126                                      (splay_tree_delete_value_fn) free);
 127
 128   n = splay_tree_lookup (file_info_tree, (splay_tree_key) name);
 129   if (n)
 130     return (struct c_fileinfo *) n->value;
 131
 132   fi = XNEW (struct c_fileinfo);
 133   fi->time = 0;
 134   fi->interface_only = 0;
 135   fi->interface_unknown = 1;
 136   splay_tree_insert (file_info_tree, (splay_tree_key) name,
 137                      (splay_tree_value) fi);
 138   return fi;
 139 }
 140
 141 static void
 142 update_header_times (const char *name)
 143 {
 144   /* Changing files again.  This means currently collected time
 145      is charged against header time, and body time starts back at 0.  */
 146   if (flag_detailed_statistics)
 147     {
 148       int this_time = get_run_time ();
 149       struct c_fileinfo *file = get_fileinfo (name);
 150       header_time += this_time - body_time;
 151       file->time += this_time - body_time;
 152       body_time = this_time;
 153     }
 154 }
 155
 156 static int
 157 dump_one_header (splay_tree_node n, void * ARG_UNUSED (dummy))
 158 {
 159   print_time ((const char *) n->key,
 160               ((struct c_fileinfo *) n->value)->time);
 161   return 0;
 162 }
 163
 164 void
 165 dump_time_statistics (void)
 166 {
 167   struct c_fileinfo *file = get_fileinfo (input_filename);
 168   int this_time = get_run_time ();
 169   file->time += this_time - body_time;
 170
 171   fprintf (stderr, "\n******\n");
 172   print_time ("header files (total)", header_time);
 173   print_time ("main file (total)", this_time - body_time);
 174   fprintf (stderr, "ratio = %g : 1\n",
 175            (double) header_time / (double) (this_time - body_time));
 176   fprintf (stderr, "\n******\n");
 177
 178   splay_tree_foreach (file_info_tree, dump_one_header, 0);
 179 }
 180
 181 static void
 182 cb_ident (cpp_reader * ARG_UNUSED (pfile),
 183           unsigned int ARG_UNUSED (line),
 184           const cpp_string * ARG_UNUSED (str))
 185 {
 186 #ifdef ASM_OUTPUT_IDENT
 187   if (!flag_no_ident)
 188     {
 189       /* Convert escapes in the string.  */
 190       cpp_string cstr = { 0, 0 };
 191       if (cpp_interpret_string (pfile, str, 1, &cstr, false))
 192         {
 193           ASM_OUTPUT_IDENT (asm_out_file, (const char *) cstr.text);
 194           free ((void *) cstr.text);
 195         }
 196     }
 197 #endif
 198 }
 199
 200 /* Called at the start of every non-empty line.  TOKEN is the first
 201    lexed token on the line.  Used for diagnostic line numbers.  */
 202 static void
 203 cb_line_change (cpp_reader * ARG_UNUSED (pfile), const cpp_token *token,
 204                 int parsing_args)
 205 {
 206   if (token->type != CPP_EOF && !parsing_args)
 207 #ifdef USE_MAPPED_LOCATION
 208     input_location = token->src_loc;
 209 #else
 210     {
 211       source_location loc = token->src_loc;
 212       const struct line_map *map = linemap_lookup (&line_table, loc);
 213       input_line = SOURCE_LINE (map, loc);
 214     }
 215 #endif
 216 }
 217
 218 void
 219 fe_file_change (const struct line_map *new_map)
 220 {
 221   if (new_map == NULL)
 222     return;
 223
 224   if (new_map->reason == LC_ENTER)
 225     {
 226       /* Don't stack the main buffer on the input stack;
 227          we already did in compile_file.  */
 228       if (!MAIN_FILE_P (new_map))
 229         {
 230 #ifdef USE_MAPPED_LOCATION
 231           int included_at = LAST_SOURCE_LINE_LOCATION (new_map - 1);
 232
 233           input_location = included_at;
 234           push_srcloc (new_map->start_location);
 235 #else
 236           int included_at = LAST_SOURCE_LINE (new_map - 1);
 237
 238           input_line = included_at;
 239           push_srcloc (new_map->to_file, 1);
 240 #endif
 241           (*debug_hooks->start_source_file) (included_at, new_map->to_file);
 242 #ifndef NO_IMPLICIT_EXTERN_C
 243           if (c_header_level)
 244             ++c_header_level;
 245           else if (new_map->sysp == 2)
 246             {
 247               c_header_level = 1;
 248               ++pending_lang_change;
 249             }
 250 #endif
 251         }
 252     }
 253   else if (new_map->reason == LC_LEAVE)
 254     {
 255 #ifndef NO_IMPLICIT_EXTERN_C
 256       if (c_header_level && --c_header_level == 0)
 257         {
 258           if (new_map->sysp == 2)
 259             warning ("badly nested C headers from preprocessor");
 260           --pending_lang_change;
 261         }
 262 #endif
 263       pop_srcloc ();
 264
 265       (*debug_hooks->end_source_file) (new_map->to_line);
 266     }
 267
 268   update_header_times (new_map->to_file);
 269   in_system_header = new_map->sysp != 0;
 270 #ifdef USE_MAPPED_LOCATION
 271   input_location = new_map->start_location;
 272 #else
 273   input_filename = new_map->to_file;
 274   input_line = new_map->to_line;
 275 #endif
 276 }
 277
 278 static void
 279 cb_def_pragma (cpp_reader *pfile, source_location loc)
 280 {
 281   /* Issue a warning message if we have been asked to do so.  Ignore
 282      unknown pragmas in system headers unless an explicit
 283      -Wunknown-pragmas has been given.  */
 284   if (warn_unknown_pragmas > in_system_header)
 285     {
 286       const unsigned char *space, *name;
 287       const cpp_token *s;
 288 #ifndef USE_MAPPED_LOCATION
 289       location_t fe_loc;
 290       const struct line_map *map = linemap_lookup (&line_table, loc);
 291       fe_loc.file = map->to_file;
 292       fe_loc.line = SOURCE_LINE (map, loc);
 293 #else
 294       location_t fe_loc = loc;
 295 #endif
 296
 297       space = name = (const unsigned char *) "";
 298       s = cpp_get_token (pfile);
 299       if (s->type != CPP_EOF)
 300         {
 301           space = cpp_token_as_text (pfile, s);
 302           s = cpp_get_token (pfile);
 303           if (s->type == CPP_NAME)
 304             name = cpp_token_as_text (pfile, s);
 305         }
 306
 307       warning ("%Hignoring #pragma %s %s", &fe_loc, space, name);
 308     }
 309 }
 310
 311 /* #define callback for DWARF and DWARF2 debug info.  */
 312 static void
 313 cb_define (cpp_reader *pfile, source_location loc, cpp_hashnode *node)
 314 {
 315   const struct line_map *map = linemap_lookup (&line_table, loc);
 316   (*debug_hooks->define) (SOURCE_LINE (map, loc),
 317                           (const char *) cpp_macro_definition (pfile, node));
 318 }
 319
 320 /* #undef callback for DWARF and DWARF2 debug info.  */
 321 static void
 322 cb_undef (cpp_reader * ARG_UNUSED (pfile), source_location loc,
 323           cpp_hashnode *node)
 324 {
 325   const struct line_map *map = linemap_lookup (&line_table, loc);
 326   (*debug_hooks->undef) (SOURCE_LINE (map, loc),
 327                          (const char *) NODE_NAME (node));
 328 }
 329 \f
 330 /* Read a token and return its type.  Fill *VALUE with its value, if
 331    applicable.  Fill *CPP_FLAGS with the token's flags, if it is
 332    non-NULL.  */
 333
 334 enum cpp_ttype
 335 c_lex_with_flags (tree *value, unsigned char *cpp_flags)
 336 {
 337   static bool no_more_pch;
 338   const cpp_token *tok;
 339   enum cpp_ttype type;
 340
 341   timevar_push (TV_CPP);
 342  retry:
 343   tok = cpp_get_token (parse_in);
 344   type = tok->type;
 345
 346  retry_after_at:
 347   switch (type)
 348     {
 349     case CPP_PADDING:
 350       goto retry;
 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             gcc_unreachable ();
 377           }
 378       }
 379       break;
 380
 381     case CPP_ATSIGN:
 382       /* An @ may give the next token special significance in Objective-C.  */
 383       if (c_dialect_objc ())
 384         {
 385           location_t atloc = input_location;
 386
 387         retry_at:
 388           tok = cpp_get_token (parse_in);
 389           type = tok->type;
 390           switch (type)
 391             {
 392             case CPP_PADDING:
 393               goto retry_at;
 394
 395             case CPP_STRING:
 396             case CPP_WSTRING:
 397               type = lex_string (tok, value, true);
 398               break;
 399
 400             case CPP_NAME:
 401               *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
 402               if (objc_is_reserved_word (*value))
 403                 {
 404                   type = CPP_AT_NAME;
 405                   break;
 406                 }
 407               /* FALLTHROUGH */
 408
 409             default:
 410               /* ... or not.  */
 411               error ("%Hstray %<@%> in program", &atloc);
 412               goto retry_after_at;
 413             }
 414           break;
 415         }
 416
 417       /* FALLTHROUGH */
 418     case CPP_HASH:
 419     case CPP_PASTE:
 420       {
 421         unsigned char name[4];
 422
 423         *cpp_spell_token (parse_in, tok, name) = 0;
 424
 425         error ("stray %qs in program", name);
 426       }
 427
 428       goto retry;
 429
 430     case CPP_OTHER:
 431       {
 432         cppchar_t c = tok->val.str.text[0];
 433
 434         if (c == '"' || c == '\'')
 435           error ("missing terminating %c character", (int) c);
 436         else if (ISGRAPH (c))
 437           error ("stray %qc in program", (int) c);
 438         else
 439           error ("stray %<\\%o%> in program", (int) c);
 440       }
 441       goto retry;
 442
 443     case CPP_CHAR:
 444     case CPP_WCHAR:
 445       *value = lex_charconst (tok);
 446       break;
 447
 448     case CPP_STRING:
 449     case CPP_WSTRING:
 450       if (!c_lex_return_raw_strings)
 451         {
 452           type = lex_string (tok, value, false);
 453           break;
 454         }
 455
 456       /* FALLTHROUGH */
 457
 458     case CPP_PRAGMA:
 459       *value = build_string (tok->val.str.len, (char *) tok->val.str.text);
 460       break;
 461
 462       /* These tokens should not be visible outside cpplib.  */
 463     case CPP_HEADER_NAME:
 464     case CPP_COMMENT:
 465     case CPP_MACRO_ARG:
 466       gcc_unreachable ();
 467
 468     default:
 469       *value = NULL_TREE;
 470       break;
 471     }
 472
 473   if (cpp_flags)
 474     *cpp_flags = tok->flags;
 475
 476   if (!no_more_pch)
 477     {
 478       no_more_pch = true;
 479       c_common_no_more_pch ();
 480     }
 481
 482   timevar_pop (TV_CPP);
 483
 484   return type;
 485 }
 486
 487 enum cpp_ttype
 488 c_lex (tree *value)
 489 {
 490   return c_lex_with_flags (value, NULL);
 491 }
 492
 493 /* Returns the narrowest C-visible unsigned type, starting with the
 494    minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
 495    there isn't one.  */
 496
 497 static enum integer_type_kind
 498 narrowest_unsigned_type (unsigned HOST_WIDE_INT low,
 499                          unsigned HOST_WIDE_INT high,
 500                          unsigned int flags)
 501 {
 502   enum integer_type_kind itk;
 503
 504   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 505     itk = itk_unsigned_int;
 506   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 507     itk = itk_unsigned_long;
 508   else
 509     itk = itk_unsigned_long_long;
 510
 511   for (; itk < itk_none; itk += 2 /* skip unsigned types */)
 512     {
 513       tree upper = TYPE_MAX_VALUE (integer_types[itk]);
 514
 515       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
 516           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
 517               && TREE_INT_CST_LOW (upper) >= low))
 518         return itk;
 519     }
 520
 521   return itk_none;
 522 }
 523
 524 /* Ditto, but narrowest signed type.  */
 525 static enum integer_type_kind
 526 narrowest_signed_type (unsigned HOST_WIDE_INT low,
 527                        unsigned HOST_WIDE_INT high, unsigned int flags)
 528 {
 529   enum integer_type_kind itk;
 530
 531   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 532     itk = itk_int;
 533   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 534     itk = itk_long;
 535   else
 536     itk = itk_long_long;
 537
 538
 539   for (; itk < itk_none; itk += 2 /* skip signed types */)
 540     {
 541       tree upper = TYPE_MAX_VALUE (integer_types[itk]);
 542
 543       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
 544           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
 545               && TREE_INT_CST_LOW (upper) >= low))
 546         return itk;
 547     }
 548
 549   return itk_none;
 550 }
 551
 552 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib.  */
 553 static tree
 554 interpret_integer (const cpp_token *token, unsigned int flags)
 555 {
 556   tree value, type;
 557   enum integer_type_kind itk;
 558   cpp_num integer;
 559   cpp_options *options = cpp_get_options (parse_in);
 560
 561   integer = cpp_interpret_integer (parse_in, token, flags);
 562   integer = cpp_num_sign_extend (integer, options->precision);
 563
 564   /* The type of a constant with a U suffix is straightforward.  */
 565   if (flags & CPP_N_UNSIGNED)
 566     itk = narrowest_unsigned_type (integer.low, integer.high, flags);
 567   else
 568     {
 569       /* The type of a potentially-signed integer constant varies
 570          depending on the base it's in, the standard in use, and the
 571          length suffixes.  */
 572       enum integer_type_kind itk_u
 573         = narrowest_unsigned_type (integer.low, integer.high, flags);
 574       enum integer_type_kind itk_s
 575         = narrowest_signed_type (integer.low, integer.high, flags);
 576
 577       /* In both C89 and C99, octal and hex constants may be signed or
 578          unsigned, whichever fits tighter.  We do not warn about this
 579          choice differing from the traditional choice, as the constant
 580          is probably a bit pattern and either way will work.  */
 581       if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
 582         itk = MIN (itk_u, itk_s);
 583       else
 584         {
 585           /* In C99, decimal constants are always signed.
 586              In C89, decimal constants that don't fit in long have
 587              undefined behavior; we try to make them unsigned long.
 588              In GCC's extended C89, that last is true of decimal
 589              constants that don't fit in long long, too.  */
 590
 591           itk = itk_s;
 592           if (itk_s > itk_u && itk_s > itk_long)
 593             {
 594               if (!flag_isoc99)
 595                 {
 596                   if (itk_u < itk_unsigned_long)
 597                     itk_u = itk_unsigned_long;
 598                   itk = itk_u;
 599                   warning ("this decimal constant is unsigned only in ISO C90");
 600                 }
 601               else if (warn_traditional)
 602                 warning ("this decimal constant would be unsigned in ISO C90");
 603             }
 604         }
 605     }
 606
 607   if (itk == itk_none)
 608     /* cpplib has already issued a warning for overflow.  */
 609     type = ((flags & CPP_N_UNSIGNED)
 610             ? widest_unsigned_literal_type_node
 611             : widest_integer_literal_type_node);
 612   else
 613     type = integer_types[itk];
 614
 615   if (itk > itk_unsigned_long
 616       && (flags & CPP_N_WIDTH) != CPP_N_LARGE
 617       && !in_system_header && !flag_isoc99)
 618     pedwarn ("integer constant is too large for %qs type",
 619              (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long");
 620
 621   value = build_int_cst_wide (type, integer.low, integer.high);
 622
 623   /* Convert imaginary to a complex type.  */
 624   if (flags & CPP_N_IMAGINARY)
 625     value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
 626
 627   return value;
 628 }
 629
 630 /* Interpret TOKEN, a floating point number with FLAGS as classified
 631    by cpplib.  */
 632 static tree
 633 interpret_float (const cpp_token *token, unsigned int flags)
 634 {
 635   tree type;
 636   tree value;
 637   REAL_VALUE_TYPE real;
 638   char *copy;
 639   size_t copylen;
 640   const char *type_name;
 641
 642   /* FIXME: make %T work in error/warning, then we don't need type_name.  */
 643   if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 644     {
 645       type = long_double_type_node;
 646       type_name = "long double";
 647     }
 648   else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
 649            || flag_single_precision_constant)
 650     {
 651       type = float_type_node;
 652       type_name = "float";
 653     }
 654   else
 655     {
 656       type = double_type_node;
 657       type_name = "double";
 658     }
 659
 660   /* Copy the constant to a nul-terminated buffer.  If the constant
 661      has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
 662      can't handle them.  */
 663   copylen = token->val.str.len;
 664   if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
 665     /* Must be an F or L suffix.  */
 666     copylen--;
 667   if (flags & CPP_N_IMAGINARY)
 668     /* I or J suffix.  */
 669     copylen--;
 670
 671   copy = (char *) alloca (copylen + 1);
 672   memcpy (copy, token->val.str.text, copylen);
 673   copy[copylen] = '\0';
 674
 675   real_from_string (&real, copy);
 676   real_convert (&real, TYPE_MODE (type), &real);
 677
 678   /* Both C and C++ require a diagnostic for a floating constant
 679      outside the range of representable values of its type.  Since we
 680      have __builtin_inf* to produce an infinity, it might now be
 681      appropriate for this to be a mandatory pedwarn rather than
 682      conditioned on -pedantic.  */
 683   if (REAL_VALUE_ISINF (real) && pedantic)
 684     pedwarn ("floating constant exceeds range of %<%s%>", type_name);
 685
 686   /* Create a node with determined type and value.  */
 687   value = build_real (type, real);
 688   if (flags & CPP_N_IMAGINARY)
 689     value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
 690
 691   return value;
 692 }
 693
 694 /* Convert a series of STRING and/or WSTRING tokens into a tree,
 695    performing string constant concatenation.  TOK is the first of
 696    these.  VALP is the location to write the string into.  OBJC_STRING
 697    indicates whether an '@' token preceded the incoming token.
 698    Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
 699    or CPP_OBJC_STRING).
 700
 701    This is unfortunately more work than it should be.  If any of the
 702    strings in the series has an L prefix, the result is a wide string
 703    (6.4.5p4).  Whether or not the result is a wide string affects the
 704    meaning of octal and hexadecimal escapes (6.4.4.4p6,9).  But escape
 705    sequences do not continue across the boundary between two strings in
 706    a series (6.4.5p7), so we must not lose the boundaries.  Therefore
 707    cpp_interpret_string takes a vector of cpp_string structures, which
 708    we must arrange to provide.  */
 709
 710 static enum cpp_ttype
 711 lex_string (const cpp_token *tok, tree *valp, bool objc_string)
 712 {
 713   tree value;
 714   bool wide = false;
 715   size_t concats = 0;
 716   struct obstack str_ob;
 717   cpp_string istr;
 718
 719   /* Try to avoid the overhead of creating and destroying an obstack
 720      for the common case of just one string.  */
 721   cpp_string str = tok->val.str;
 722   cpp_string *strs = &str;
 723
 724   if (tok->type == CPP_WSTRING)
 725     wide = true;
 726
 727  retry:
 728   tok = cpp_get_token (parse_in);
 729   switch (tok->type)
 730     {
 731     case CPP_PADDING:
 732       goto retry;
 733     case CPP_ATSIGN:
 734       if (c_dialect_objc ())
 735         {
 736           objc_string = true;
 737           goto retry;
 738         }
 739       /* FALLTHROUGH */
 740
 741     default:
 742       break;
 743
 744     case CPP_WSTRING:
 745       wide = true;
 746       /* FALLTHROUGH */
 747
 748     case CPP_STRING:
 749       if (!concats)
 750         {
 751           gcc_obstack_init (&str_ob);
 752           obstack_grow (&str_ob, &str, sizeof (cpp_string));
 753         }
 754
 755       concats++;
 756       obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
 757       goto retry;
 758     }
 759
 760   /* We have read one more token than we want.  */
 761   _cpp_backup_tokens (parse_in, 1);
 762   if (concats)
 763     strs = (cpp_string *) obstack_finish (&str_ob);
 764
 765   if (concats && !objc_string && warn_traditional && !in_system_header)
 766     warning ("traditional C rejects string constant concatenation");
 767
 768   if ((c_lex_string_translate
 769        ? cpp_interpret_string : cpp_interpret_string_notranslate)
 770       (parse_in, strs, concats + 1, &istr, wide))
 771     {
 772       value = build_string (istr.len, (char *) istr.text);
 773       free ((void *) istr.text);
 774
 775       if (c_lex_string_translate == -1)
 776         {
 777           int xlated = cpp_interpret_string_notranslate (parse_in, strs,
 778                                                          concats + 1,
 779                                                          &istr, wide);
 780           /* Assume that, if we managed to translate the string above,
 781              then the untranslated parsing will always succeed.  */
 782           gcc_assert (xlated);
 783
 784           if (TREE_STRING_LENGTH (value) != (int) istr.len
 785               || 0 != strncmp (TREE_STRING_POINTER (value), (char *) istr.text,
 786                                istr.len))
 787             {
 788               /* Arrange for us to return the untranslated string in
 789                  *valp, but to set up the C type of the translated
 790                  one.  */
 791               *valp = build_string (istr.len, (char *) istr.text);
 792               valp = &TREE_CHAIN (*valp);
 793             }
 794           free ((void *) istr.text);
 795         }
 796     }
 797   else
 798     {
 799       /* Callers cannot generally handle error_mark_node in this context,
 800          so return the empty string instead.  cpp_interpret_string has
 801          issued an error.  */
 802       if (wide)
 803         value = build_string (TYPE_PRECISION (wchar_type_node)
 804                               / TYPE_PRECISION (char_type_node),
 805                               "\0\0\0");  /* widest supported wchar_t
 806                                              is 32 bits */
 807       else
 808         value = build_string (1, "");
 809     }
 810
 811   TREE_TYPE (value) = wide ? wchar_array_type_node : char_array_type_node;
 812   *valp = fix_string_type (value);
 813
 814   if (concats)
 815     obstack_free (&str_ob, 0);
 816
 817   return objc_string ? CPP_OBJC_STRING : wide ? CPP_WSTRING : CPP_STRING;
 818 }
 819
 820 /* Converts a (possibly wide) character constant token into a tree.  */
 821 static tree
 822 lex_charconst (const cpp_token *token)
 823 {
 824   cppchar_t result;
 825   tree type, value;
 826   unsigned int chars_seen;
 827   int unsignedp;
 828
 829   result = cpp_interpret_charconst (parse_in, token,
 830                                     &chars_seen, &unsignedp);
 831
 832   if (token->type == CPP_WCHAR)
 833     type = wchar_type_node;
 834   /* In C, a character constant has type 'int'.
 835      In C++ 'char', but multi-char charconsts have type 'int'.  */
 836   else if (!c_dialect_cxx () || chars_seen > 1)
 837     type = integer_type_node;
 838   else
 839     type = char_type_node;
 840
 841   /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
 842      before possibly widening to HOST_WIDE_INT for build_int_cst.  */
 843   if (unsignedp || (cppchar_signed_t) result >= 0)
 844     value = build_int_cst_wide (type, result, 0);
 845   else
 846     value = build_int_cst_wide (type, (cppchar_signed_t) result, -1);
 847
 848   return value;
 849 }