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