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