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 6This file is part of GCC. 7 8GCC is free software; you can redistribute it and/or modify it under 9the terms of the GNU General Public License as published by the Free 10Software Foundation; either version 2, or (at your option) any later 11version. 12 13GCC is distributed in the hope that it will be useful, but WITHOUT ANY 14WARRANTY; without even the implied warranty of MERCHANTABILITY or 15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16for more details. 17 18You should have received a copy of the GNU General Public License 19along with GCC; see the file COPYING. If not, write to the Free 20Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 2102110-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. */ 46static int header_time, body_time; 47static splay_tree file_info_tree; 48 49int pending_lang_change; /* If we need to switch languages - C++ only */ 50int 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. */ 56int 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). */ 60bool c_lex_return_raw_strings = false; 61 62static tree interpret_integer (const cpp_token *, unsigned int); 63static tree interpret_float (const cpp_token *, unsigned int); 64static enum integer_type_kind narrowest_unsigned_type 65 (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int); 66static enum integer_type_kind narrowest_signed_type 67 (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int); 68static enum cpp_ttype lex_string (const cpp_token *, tree *, bool); 69static tree lex_charconst (const cpp_token *); 70static void update_header_times (const char *); 71static int dump_one_header (splay_tree_node, void *); 72static void cb_line_change (cpp_reader *, const cpp_token *, int); 73static void cb_ident (cpp_reader *, unsigned int, const cpp_string *); 74static void cb_def_pragma (cpp_reader *, unsigned int); 75static void cb_define (cpp_reader *, unsigned int, cpp_hashnode *); 76static void cb_undef (cpp_reader *, unsigned int, cpp_hashnode *); 77 78void 79init_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 112struct c_fileinfo * 113get_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 136static void 137update_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 151static int 152dump_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 159void 160dump_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 176static void 177cb_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. */ 197static void 198cb_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 213void 214fe_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 273static void 274cb_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. */ 308static void 309cb_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. */ 317static void 318cb_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 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 330enum cpp_ttype 331c_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 errorcount++; 367 break; 368 369 case CPP_N_INTEGER: 370 *value = interpret_integer (tok, flags); 371 break; 372 373 case CPP_N_FLOATING: 374 *value = interpret_float (tok, flags); 375 break; 376 377 default: 378 gcc_unreachable (); 379 } 380 } 381 break; 382 383 case CPP_ATSIGN: 384 /* An @ may give the next token special significance in Objective-C. */ 385 if (c_dialect_objc ()) 386 { 387 location_t atloc = input_location; 388 389 retry_at: 390 tok = cpp_get_token (parse_in); 391 type = tok->type; 392 switch (type) 393 { 394 case CPP_PADDING: 395 goto retry_at; 396 397 case CPP_STRING: 398 case CPP_WSTRING: 399 type = lex_string (tok, value, true); 400 break; 401 402 case CPP_NAME: 403 *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node)); 404 if (objc_is_reserved_word (*value)) 405 { 406 type = CPP_AT_NAME; 407 break; 408 } 409 /* FALLTHROUGH */ 410 411 default: 412 /* ... or not. */ 413 error ("%Hstray %<@%> in program", &atloc); 414 goto retry_after_at; 415 } 416 break; 417 } 418 419 /* FALLTHROUGH */ 420 case CPP_HASH: 421 case CPP_PASTE: 422 { 423 unsigned char name[4]; 424 425 *cpp_spell_token (parse_in, tok, name, true) = 0; 426 427 error ("stray %qs in program", name); 428 } 429 430 goto retry; 431 432 case CPP_OTHER: 433 { 434 cppchar_t c = tok->val.str.text[0]; 435 436 if (c == '"' || c == '\'') 437 error ("missing terminating %c character", (int) c); 438 else if (ISGRAPH (c)) 439 error ("stray %qc in program", (int) c); 440 else 441 error ("stray %<\\%o%> in program", (int) c); 442 } 443 goto retry; 444 445 case CPP_CHAR: 446 case CPP_WCHAR: 447 *value = lex_charconst (tok); 448 break; 449 450 case CPP_STRING: 451 case CPP_WSTRING: 452 if (!c_lex_return_raw_strings) 453 { 454 type = lex_string (tok, value, false); 455 break; 456 } 457 458 /* FALLTHROUGH */ 459 460 case CPP_PRAGMA: 461 *value = build_string (tok->val.str.len, (char *) tok->val.str.text); 462 break; 463 464 /* These tokens should not be visible outside cpplib. */ 465 case CPP_HEADER_NAME: 466 case CPP_COMMENT: 467 case CPP_MACRO_ARG: 468 gcc_unreachable (); 469 470 default: 471 *value = NULL_TREE; 472 break; 473 } 474 475 if (cpp_flags) 476 *cpp_flags = tok->flags; 477 478 if (!no_more_pch) 479 { 480 no_more_pch = true; 481 c_common_no_more_pch (); 482 } 483 484 timevar_pop (TV_CPP); 485 486 return type; 487} 488 489enum cpp_ttype 490c_lex (tree *value) 491{ 492 location_t loc; 493 return c_lex_with_flags (value, &loc, NULL); 494} 495 496/* Returns the narrowest C-visible unsigned type, starting with the 497 minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if 498 there isn't one. */ 499 500static enum integer_type_kind 501narrowest_unsigned_type (unsigned HOST_WIDE_INT low, 502 unsigned HOST_WIDE_INT high, 503 unsigned int flags) 504{ 505 enum integer_type_kind itk; 506 507 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL) 508 itk = itk_unsigned_int; 509 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM) 510 itk = itk_unsigned_long; 511 else 512 itk = itk_unsigned_long_long; 513 514 for (; itk < itk_none; itk += 2 /* skip unsigned types */) 515 { 516 tree upper = TYPE_MAX_VALUE (integer_types[itk]); 517 518 if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high 519 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high 520 && TREE_INT_CST_LOW (upper) >= low)) 521 return itk; 522 } 523 524 return itk_none; 525} 526 527/* Ditto, but narrowest signed type. */ 528static enum integer_type_kind 529narrowest_signed_type (unsigned HOST_WIDE_INT low, 530 unsigned HOST_WIDE_INT high, unsigned int flags) 531{ 532 enum integer_type_kind itk; 533 534 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL) 535 itk = itk_int; 536 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM) 537 itk = itk_long; 538 else 539 itk = itk_long_long; 540 541 542 for (; itk < itk_none; itk += 2 /* skip signed types */) 543 { 544 tree upper = TYPE_MAX_VALUE (integer_types[itk]); 545 546 if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high 547 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high 548 && TREE_INT_CST_LOW (upper) >= low)) 549 return itk; 550 } 551 552 return itk_none; 553} 554 555/* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */ 556static tree 557interpret_integer (const cpp_token *token, unsigned int flags) 558{ 559 tree value, type; 560 enum integer_type_kind itk; 561 cpp_num integer; 562 cpp_options *options = cpp_get_options (parse_in); 563 564 integer = cpp_interpret_integer (parse_in, token, flags); 565 integer = cpp_num_sign_extend (integer, options->precision); 566 567 /* The type of a constant with a U suffix is straightforward. */ 568 if (flags & CPP_N_UNSIGNED) 569 itk = narrowest_unsigned_type (integer.low, integer.high, flags); 570 else 571 { 572 /* The type of a potentially-signed integer constant varies 573 depending on the base it's in, the standard in use, and the 574 length suffixes. */ 575 enum integer_type_kind itk_u 576 = narrowest_unsigned_type (integer.low, integer.high, flags); 577 enum integer_type_kind itk_s 578 = narrowest_signed_type (integer.low, integer.high, flags); 579 580 /* In both C89 and C99, octal and hex constants may be signed or 581 unsigned, whichever fits tighter. We do not warn about this 582 choice differing from the traditional choice, as the constant 583 is probably a bit pattern and either way will work. */ 584 if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL) 585 itk = MIN (itk_u, itk_s); 586 else 587 { 588 /* In C99, decimal constants are always signed. 589 In C89, decimal constants that don't fit in long have 590 undefined behavior; we try to make them unsigned long. 591 In GCC's extended C89, that last is true of decimal 592 constants that don't fit in long long, too. */ 593 594 itk = itk_s; 595 if (itk_s > itk_u && itk_s > itk_long) 596 { 597 if (!flag_isoc99) 598 { 599 if (itk_u < itk_unsigned_long) 600 itk_u = itk_unsigned_long; 601 itk = itk_u; 602 warning (0, "this decimal constant is unsigned only in ISO C90"); 603 } 604 else 605 warning (OPT_Wtraditional, 606 "this decimal constant would be unsigned in ISO C90"); 607 } 608 } 609 } 610 611 if (itk == itk_none) 612 /* cpplib has already issued a warning for overflow. */ 613 type = ((flags & CPP_N_UNSIGNED) 614 ? widest_unsigned_literal_type_node 615 : widest_integer_literal_type_node); 616 else 617 type = integer_types[itk]; 618 619 if (itk > itk_unsigned_long 620 && (flags & CPP_N_WIDTH) != CPP_N_LARGE 621 && !in_system_header && !flag_isoc99) 622 pedwarn ("integer constant is too large for %qs type", 623 (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long"); 624 625 value = build_int_cst_wide (type, integer.low, integer.high); 626 627 /* Convert imaginary to a complex type. */ 628 if (flags & CPP_N_IMAGINARY) 629 value = build_complex (NULL_TREE, build_int_cst (type, 0), value); 630 631 return value; 632} 633 634/* Interpret TOKEN, a floating point number with FLAGS as classified 635 by cpplib. */ 636static tree 637interpret_float (const cpp_token *token, unsigned int flags) 638{ 639 tree type; 640 tree value; 641 REAL_VALUE_TYPE real; 642 char *copy; 643 size_t copylen; 644 const char *type_name; 645 646 /* FIXME: make %T work in error/warning, then we don't need type_name. */ 647 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE) 648 { 649 type = long_double_type_node; 650 type_name = "long double"; 651 } 652 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL 653 || flag_single_precision_constant) 654 { 655 type = float_type_node; 656 type_name = "float"; 657 } 658 else 659 { 660 type = double_type_node; 661 type_name = "double"; 662 } 663 664 /* Copy the constant to a nul-terminated buffer. If the constant 665 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF 666 can't handle them. */ 667 copylen = token->val.str.len; 668 if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM) 669 /* Must be an F or L suffix. */ 670 copylen--; 671 if (flags & CPP_N_IMAGINARY) 672 /* I or J suffix. */ 673 copylen--; 674 675 copy = (char *) alloca (copylen + 1); 676 memcpy (copy, token->val.str.text, copylen); 677 copy[copylen] = '\0'; 678 679 real_from_string (&real, copy); 680 real_convert (&real, TYPE_MODE (type), &real); 681 682 /* Both C and C++ require a diagnostic for a floating constant 683 outside the range of representable values of its type. Since we 684 have __builtin_inf* to produce an infinity, it might now be 685 appropriate for this to be a mandatory pedwarn rather than 686 conditioned on -pedantic. */ 687 if (REAL_VALUE_ISINF (real) && pedantic) 688 pedwarn ("floating constant exceeds range of %<%s%>", type_name); 689 690 /* Create a node with determined type and value. */ 691 value = build_real (type, real); 692 if (flags & CPP_N_IMAGINARY) 693 value = build_complex (NULL_TREE, convert (type, integer_zero_node), value); 694 695 return value; 696} 697 698/* Convert a series of STRING and/or WSTRING tokens into a tree, 699 performing string constant concatenation. TOK is the first of 700 these. VALP is the location to write the string into. OBJC_STRING 701 indicates whether an '@' token preceded the incoming token. 702 Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING, 703 or CPP_OBJC_STRING). 704 705 This is unfortunately more work than it should be. If any of the 706 strings in the series has an L prefix, the result is a wide string 707 (6.4.5p4). Whether or not the result is a wide string affects the 708 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape 709 sequences do not continue across the boundary between two strings in 710 a series (6.4.5p7), so we must not lose the boundaries. Therefore 711 cpp_interpret_string takes a vector of cpp_string structures, which 712 we must arrange to provide. */ 713 714static enum cpp_ttype 715lex_string (const cpp_token *tok, tree *valp, bool objc_string) 716{ 717 tree value; 718 bool wide = false; 719 size_t concats = 0; 720 struct obstack str_ob; 721 cpp_string istr; 722 723 /* Try to avoid the overhead of creating and destroying an obstack 724 for the common case of just one string. */ 725 cpp_string str = tok->val.str; 726 cpp_string *strs = &str; 727 728 if (tok->type == CPP_WSTRING) 729 wide = true; 730 731 retry: 732 tok = cpp_get_token (parse_in); 733 switch (tok->type) 734 { 735 case CPP_PADDING: 736 goto retry; 737 case CPP_ATSIGN: 738 if (c_dialect_objc ()) 739 { 740 objc_string = true; 741 goto retry; 742 } 743 /* FALLTHROUGH */ 744 745 default: 746 break; 747 748 case CPP_WSTRING: 749 wide = true; 750 /* FALLTHROUGH */ 751 752 case CPP_STRING: 753 if (!concats) 754 { 755 gcc_obstack_init (&str_ob); 756 obstack_grow (&str_ob, &str, sizeof (cpp_string)); 757 } 758 759 concats++; 760 obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string)); 761 goto retry; 762 } 763 764 /* We have read one more token than we want. */ 765 _cpp_backup_tokens (parse_in, 1); 766 if (concats) 767 strs = XOBFINISH (&str_ob, cpp_string *); 768 769 if (concats && !objc_string && !in_system_header) 770 warning (OPT_Wtraditional, 771 "traditional C rejects string constant concatenation"); 772 773 if ((c_lex_string_translate 774 ? cpp_interpret_string : cpp_interpret_string_notranslate) 775 (parse_in, strs, concats + 1, &istr, wide)) 776 { 777 value = build_string (istr.len, (char *) istr.text); 778 free ((void *) istr.text); 779 780 if (c_lex_string_translate == -1) 781 { 782 int xlated = cpp_interpret_string_notranslate (parse_in, strs, 783 concats + 1, 784 &istr, wide); 785 /* Assume that, if we managed to translate the string above, 786 then the untranslated parsing will always succeed. */ 787 gcc_assert (xlated); 788 789 if (TREE_STRING_LENGTH (value) != (int) istr.len 790 || 0 != strncmp (TREE_STRING_POINTER (value), (char *) istr.text, 791 istr.len)) 792 { 793 /* Arrange for us to return the untranslated string in 794 *valp, but to set up the C type of the translated 795 one. */ 796 *valp = build_string (istr.len, (char *) istr.text); 797 valp = &TREE_CHAIN (*valp); 798 } 799 free ((void *) istr.text); 800 } 801 } 802 else 803 { 804 /* Callers cannot generally handle error_mark_node in this context, 805 so return the empty string instead. cpp_interpret_string has 806 issued an error. */ 807 if (wide) 808 value = build_string (TYPE_PRECISION (wchar_type_node) 809 / TYPE_PRECISION (char_type_node), 810 "\0\0\0"); /* widest supported wchar_t 811 is 32 bits */ 812 else 813 value = build_string (1, ""); 814 } 815 816 TREE_TYPE (value) = wide ? wchar_array_type_node : char_array_type_node; 817 *valp = fix_string_type (value); 818 819 if (concats) 820 obstack_free (&str_ob, 0); 821 822 return objc_string ? CPP_OBJC_STRING : wide ? CPP_WSTRING : CPP_STRING; 823} 824 825/* Converts a (possibly wide) character constant token into a tree. */ 826static tree 827lex_charconst (const cpp_token *token) 828{ 829 cppchar_t result; 830 tree type, value; 831 unsigned int chars_seen; 832 int unsignedp; 833 834 result = cpp_interpret_charconst (parse_in, token, 835 &chars_seen, &unsignedp); 836 837 if (token->type == CPP_WCHAR) 838 type = wchar_type_node; 839 /* In C, a character constant has type 'int'. 840 In C++ 'char', but multi-char charconsts have type 'int'. */ 841 else if (!c_dialect_cxx () || chars_seen > 1) 842 type = integer_type_node; 843 else 844 type = char_type_node; 845 846 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT 847 before possibly widening to HOST_WIDE_INT for build_int_cst. */ 848 if (unsignedp || (cppchar_signed_t) result >= 0) 849 value = build_int_cst_wide (type, result, 0); 850 else 851 value = build_int_cst_wide (type, (cppchar_signed_t) result, -1); 852 853 return value; 854} 855