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