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