1 //===-- Mangled.cpp ---------------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 11 // FreeBSD9-STABLE requires this to know about size_t in cxxabi.h 12 #include <cstddef> 13 #if defined(_MSC_VER) 14 // Cannot enable the builtin demangler on msvc as it does not support the cpp11 within the implementation. 15 #elif defined (__FreeBSD__) 16 #define LLDB_USE_BUILTIN_DEMANGLER 17 #else 18 #include <cxxabi.h> 19 #endif 20 21 #ifdef LLDB_USE_BUILTIN_DEMANGLER 22 23 //---------------------------------------------------------------------- 24 // Inlined copy of: 25 // http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_demangle.cpp 26 // revision 197169. 27 // 28 // Changes include: 29 // - remove the "__cxxabiv1" namespace 30 // - stripped GCC attributes() 31 // - removed extern "C" from the cxa_demangle function 32 // - Changed the scope of the unnamed namespace to include cxa_demangle 33 // function. 34 // - Added "#undef _LIBCPP_EXTERN_TEMPLATE" to avoid warning 35 //---------------------------------------------------------------------- 36 37 #undef _LIBCPP_EXTERN_TEMPLATE // Avoid warning below 38 39 //===-------------------------- cxa_demangle.cpp --------------------------===// 40 // 41 // The LLVM Compiler Infrastructure 42 // 43 // This file is dual licensed under the MIT and the University of Illinois Open 44 // Source Licenses. See LICENSE.TXT for details. 45 // 46 //===----------------------------------------------------------------------===// 47 48 #define _LIBCPP_EXTERN_TEMPLATE(...) 49 #define _LIBCPP_NO_EXCEPTIONS 50 51 #include <vector> 52 #include <algorithm> 53 #include <string> 54 #include <numeric> 55 #include <cstdlib> 56 #include <cstring> 57 #include <cctype> 58 59 60 namespace 61 { 62 63 enum 64 { 65 unknown_error = -4, 66 invalid_args = -3, 67 invalid_mangled_name, 68 memory_alloc_failure, 69 success 70 }; 71 72 template <class C> 73 const char* parse_type(const char* first, const char* last, C& db); 74 template <class C> 75 const char* parse_encoding(const char* first, const char* last, C& db); 76 template <class C> 77 const char* parse_name(const char* first, const char* last, C& db); 78 template <class C> 79 const char* parse_expression(const char* first, const char* last, C& db); 80 template <class C> 81 const char* parse_template_args(const char* first, const char* last, C& db); 82 template <class C> 83 const char* parse_operator_name(const char* first, const char* last, C& db); 84 template <class C> 85 const char* parse_unqualified_name(const char* first, const char* last, C& db); 86 template <class C> 87 const char* parse_decltype(const char* first, const char* last, C& db); 88 89 template <class C> 90 void 91 print_stack(const C& db) 92 { 93 printf("---------\n"); 94 printf("names:\n"); 95 for (auto& s : db.names) 96 printf("{%s#%s}\n", s.first.c_str(), s.second.c_str()); 97 int i = -1; 98 printf("subs:\n"); 99 for (auto& v : db.subs) 100 { 101 if (i >= 0) 102 printf("S%i_ = {", i); 103 else 104 printf("S_ = {"); 105 for (auto& s : v) 106 printf("{%s#%s}", s.first.c_str(), s.second.c_str()); 107 printf("}\n"); 108 ++i; 109 } 110 printf("template_param:\n"); 111 for (auto& t : db.template_param) 112 { 113 printf("--\n"); 114 i = -1; 115 for (auto& v : t) 116 { 117 if (i >= 0) 118 printf("T%i_ = {", i); 119 else 120 printf("T_ = {"); 121 for (auto& s : v) 122 printf("{%s#%s}", s.first.c_str(), s.second.c_str()); 123 printf("}\n"); 124 ++i; 125 } 126 } 127 printf("---------\n\n"); 128 } 129 130 template <class C> 131 void 132 print_state(const char* msg, const char* first, const char* last, const C& db) 133 { 134 printf("%s: ", msg); 135 for (; first != last; ++first) 136 printf("%c", *first); 137 printf("\n"); 138 print_stack(db); 139 } 140 141 // <number> ::= [n] <non-negative decimal integer> 142 143 const char* 144 parse_number(const char* first, const char* last) 145 { 146 if (first != last) 147 { 148 const char* t = first; 149 if (*t == 'n') 150 ++t; 151 if (t != last) 152 { 153 if (*t == '0') 154 { 155 first = t+1; 156 } 157 else if ('1' <= *t && *t <= '9') 158 { 159 first = t+1; 160 while (first != last && std::isdigit(*first)) 161 ++first; 162 } 163 } 164 } 165 return first; 166 } 167 168 template <class Float> 169 struct float_data; 170 171 template <> 172 struct float_data<float> 173 { 174 static const size_t mangled_size = 8; 175 static const size_t max_demangled_size = 24; 176 static constexpr const char* spec = "%af"; 177 }; 178 179 constexpr const char* float_data<float>::spec; 180 181 template <> 182 struct float_data<double> 183 { 184 static const size_t mangled_size = 16; 185 static const size_t max_demangled_size = 32; 186 static constexpr const char* spec = "%a"; 187 }; 188 189 constexpr const char* float_data<double>::spec; 190 191 template <> 192 struct float_data<long double> 193 { 194 static const size_t mangled_size = 20; // May need to be adjusted to 16 or 24 on other platforms 195 static const size_t max_demangled_size = 40; 196 static constexpr const char* spec = "%LaL"; 197 }; 198 199 constexpr const char* float_data<long double>::spec; 200 201 template <class Float, class C> 202 const char* 203 parse_floating_number(const char* first, const char* last, C& db) 204 { 205 const size_t N = float_data<Float>::mangled_size; 206 if (static_cast<std::size_t>(last - first) > N) 207 { 208 last = first + N; 209 union 210 { 211 Float value; 212 char buf[sizeof(Float)]; 213 }; 214 const char* t = first; 215 char* e = buf; 216 for (; t != last; ++t, ++e) 217 { 218 if (!isxdigit(*t)) 219 return first; 220 unsigned d1 = isdigit(*t) ? static_cast<unsigned>(*t - '0') : 221 static_cast<unsigned>(*t - 'a' + 10); 222 ++t; 223 unsigned d0 = isdigit(*t) ? static_cast<unsigned>(*t - '0') : 224 static_cast<unsigned>(*t - 'a' + 10); 225 *e = static_cast<char>((d1 << 4) + d0); 226 } 227 if (*t == 'E') 228 { 229 #if __LITTLE_ENDIAN__ 230 std::reverse(buf, e); 231 #endif 232 char num[float_data<Float>::max_demangled_size] = {0}; 233 int n = snprintf(num, sizeof(num), float_data<Float>::spec, value); 234 if (static_cast<std::size_t>(n) >= sizeof(num)) 235 return first; 236 db.names.push_back(typename C::String(num, static_cast<std::size_t>(n))); 237 first = t+1; 238 } 239 } 240 return first; 241 } 242 243 // <source-name> ::= <positive length number> <identifier> 244 245 template <class C> 246 const char* 247 parse_source_name(const char* first, const char* last, C& db) 248 { 249 if (first != last) 250 { 251 char c = *first; 252 if (isdigit(c) && first+1 != last) 253 { 254 const char* t = first+1; 255 size_t n = static_cast<size_t>(c - '0'); 256 for (c = *t; isdigit(c); c = *t) 257 { 258 n = n * 10 + static_cast<size_t>(c - '0'); 259 if (++t == last) 260 return first; 261 } 262 if (static_cast<size_t>(last - t) >= n) 263 { 264 typename C::String r(t, n); 265 if (r.substr(0, 10) == "_GLOBAL__N") 266 db.names.push_back("(anonymous namespace)"); 267 else 268 db.names.push_back(std::move(r)); 269 first = t + n; 270 } 271 } 272 } 273 return first; 274 } 275 276 // <substitution> ::= S <seq-id> _ 277 // ::= S_ 278 // <substitution> ::= Sa # ::std::allocator 279 // <substitution> ::= Sb # ::std::basic_string 280 // <substitution> ::= Ss # ::std::basic_string < char, 281 // ::std::char_traits<char>, 282 // ::std::allocator<char> > 283 // <substitution> ::= Si # ::std::basic_istream<char, std::char_traits<char> > 284 // <substitution> ::= So # ::std::basic_ostream<char, std::char_traits<char> > 285 // <substitution> ::= Sd # ::std::basic_iostream<char, std::char_traits<char> > 286 287 template <class C> 288 const char* 289 parse_substitution(const char* first, const char* last, C& db) 290 { 291 if (last - first >= 2) 292 { 293 if (*first == 'S') 294 { 295 switch (first[1]) 296 { 297 case 'a': 298 db.names.push_back("std::allocator"); 299 first += 2; 300 break; 301 case 'b': 302 db.names.push_back("std::basic_string"); 303 first += 2; 304 break; 305 case 's': 306 db.names.push_back("std::string"); 307 first += 2; 308 break; 309 case 'i': 310 db.names.push_back("std::istream"); 311 first += 2; 312 break; 313 case 'o': 314 db.names.push_back("std::ostream"); 315 first += 2; 316 break; 317 case 'd': 318 db.names.push_back("std::iostream"); 319 first += 2; 320 break; 321 case '_': 322 if (!db.subs.empty()) 323 { 324 for (const auto& n : db.subs.front()) 325 db.names.push_back(n); 326 first += 2; 327 } 328 break; 329 default: 330 if (std::isdigit(first[1]) || std::isupper(first[1])) 331 { 332 size_t sub = 0; 333 const char* t = first+1; 334 if (std::isdigit(*t)) 335 sub = static_cast<size_t>(*t - '0'); 336 else 337 sub = static_cast<size_t>(*t - 'A') + 10; 338 for (++t; t != last && (std::isdigit(*t) || std::isupper(*t)); ++t) 339 { 340 sub *= 36; 341 if (std::isdigit(*t)) 342 sub += static_cast<size_t>(*t - '0'); 343 else 344 sub += static_cast<size_t>(*t - 'A') + 10; 345 } 346 if (t == last || *t != '_') 347 return first; 348 ++sub; 349 if (sub < db.subs.size()) 350 { 351 for (const auto& n : db.subs[sub]) 352 db.names.push_back(n); 353 first = t+1; 354 } 355 } 356 break; 357 } 358 } 359 } 360 return first; 361 } 362 363 // <builtin-type> ::= v # void 364 // ::= w # wchar_t 365 // ::= b # bool 366 // ::= c # char 367 // ::= a # signed char 368 // ::= h # unsigned char 369 // ::= s # short 370 // ::= t # unsigned short 371 // ::= i # int 372 // ::= j # unsigned int 373 // ::= l # long 374 // ::= m # unsigned long 375 // ::= x # long long, __int64 376 // ::= y # unsigned long long, __int64 377 // ::= n # __int128 378 // ::= o # unsigned __int128 379 // ::= f # float 380 // ::= d # double 381 // ::= e # long double, __float80 382 // ::= g # __float128 383 // ::= z # ellipsis 384 // ::= Dd # IEEE 754r decimal floating point (64 bits) 385 // ::= De # IEEE 754r decimal floating point (128 bits) 386 // ::= Df # IEEE 754r decimal floating point (32 bits) 387 // ::= Dh # IEEE 754r half-precision floating point (16 bits) 388 // ::= Di # char32_t 389 // ::= Ds # char16_t 390 // ::= Da # auto (in dependent new-expressions) 391 // ::= Dn # std::nullptr_t (i.e., decltype(nullptr)) 392 // ::= u <source-name> # vendor extended type 393 394 template <class C> 395 const char* 396 parse_builtin_type(const char* first, const char* last, C& db) 397 { 398 if (first != last) 399 { 400 switch (*first) 401 { 402 case 'v': 403 db.names.push_back("void"); 404 ++first; 405 break; 406 case 'w': 407 db.names.push_back("wchar_t"); 408 ++first; 409 break; 410 case 'b': 411 db.names.push_back("bool"); 412 ++first; 413 break; 414 case 'c': 415 db.names.push_back("char"); 416 ++first; 417 break; 418 case 'a': 419 db.names.push_back("signed char"); 420 ++first; 421 break; 422 case 'h': 423 db.names.push_back("unsigned char"); 424 ++first; 425 break; 426 case 's': 427 db.names.push_back("short"); 428 ++first; 429 break; 430 case 't': 431 db.names.push_back("unsigned short"); 432 ++first; 433 break; 434 case 'i': 435 db.names.push_back("int"); 436 ++first; 437 break; 438 case 'j': 439 db.names.push_back("unsigned int"); 440 ++first; 441 break; 442 case 'l': 443 db.names.push_back("long"); 444 ++first; 445 break; 446 case 'm': 447 db.names.push_back("unsigned long"); 448 ++first; 449 break; 450 case 'x': 451 db.names.push_back("long long"); 452 ++first; 453 break; 454 case 'y': 455 db.names.push_back("unsigned long long"); 456 ++first; 457 break; 458 case 'n': 459 db.names.push_back("__int128"); 460 ++first; 461 break; 462 case 'o': 463 db.names.push_back("unsigned __int128"); 464 ++first; 465 break; 466 case 'f': 467 db.names.push_back("float"); 468 ++first; 469 break; 470 case 'd': 471 db.names.push_back("double"); 472 ++first; 473 break; 474 case 'e': 475 db.names.push_back("long double"); 476 ++first; 477 break; 478 case 'g': 479 db.names.push_back("__float128"); 480 ++first; 481 break; 482 case 'z': 483 db.names.push_back("..."); 484 ++first; 485 break; 486 case 'u': 487 { 488 const char*t = parse_source_name(first+1, last, db); 489 if (t != first+1) 490 first = t; 491 } 492 break; 493 case 'D': 494 if (first+1 != last) 495 { 496 switch (first[1]) 497 { 498 case 'd': 499 db.names.push_back("decimal64"); 500 first += 2; 501 break; 502 case 'e': 503 db.names.push_back("decimal128"); 504 first += 2; 505 break; 506 case 'f': 507 db.names.push_back("decimal32"); 508 first += 2; 509 break; 510 case 'h': 511 db.names.push_back("decimal16"); 512 first += 2; 513 break; 514 case 'i': 515 db.names.push_back("char32_t"); 516 first += 2; 517 break; 518 case 's': 519 db.names.push_back("char16_t"); 520 first += 2; 521 break; 522 case 'a': 523 db.names.push_back("auto"); 524 first += 2; 525 break; 526 case 'n': 527 db.names.push_back("std::nullptr_t"); 528 first += 2; 529 break; 530 } 531 } 532 break; 533 } 534 } 535 return first; 536 } 537 538 // <CV-qualifiers> ::= [r] [V] [K] 539 540 const char* 541 parse_cv_qualifiers(const char* first, const char* last, unsigned& cv) 542 { 543 cv = 0; 544 if (first != last) 545 { 546 if (*first == 'r') 547 { 548 cv |= 4; 549 ++first; 550 } 551 if (*first == 'V') 552 { 553 cv |= 2; 554 ++first; 555 } 556 if (*first == 'K') 557 { 558 cv |= 1; 559 ++first; 560 } 561 } 562 return first; 563 } 564 565 // <template-param> ::= T_ # first template parameter 566 // ::= T <parameter-2 non-negative number> _ 567 568 template <class C> 569 const char* 570 parse_template_param(const char* first, const char* last, C& db) 571 { 572 if (last - first >= 2) 573 { 574 if (*first == 'T') 575 { 576 if (first[1] == '_') 577 { 578 if (db.template_param.empty()) 579 return first; 580 if (!db.template_param.back().empty()) 581 { 582 for (auto& t : db.template_param.back().front()) 583 db.names.push_back(t); 584 first += 2; 585 } 586 else 587 { 588 db.names.push_back("T_"); 589 first += 2; 590 db.fix_forward_references = true; 591 } 592 } 593 else if (isdigit(first[1])) 594 { 595 const char* t = first+1; 596 size_t sub = static_cast<size_t>(*t - '0'); 597 for (++t; t != last && isdigit(*t); ++t) 598 { 599 sub *= 10; 600 sub += static_cast<size_t>(*t - '0'); 601 } 602 if (t == last || *t != '_' || db.template_param.empty()) 603 return first; 604 ++sub; 605 if (sub < db.template_param.back().size()) 606 { 607 for (auto& temp : db.template_param.back()[sub]) 608 db.names.push_back(temp); 609 first = t+1; 610 } 611 else 612 { 613 db.names.push_back(typename C::String(first, t+1)); 614 first = t+1; 615 db.fix_forward_references = true; 616 } 617 } 618 } 619 } 620 return first; 621 } 622 623 // cc <type> <expression> # const_cast<type> (expression) 624 625 template <class C> 626 const char* 627 parse_const_cast_expr(const char* first, const char* last, C& db) 628 { 629 if (last - first >= 3 && first[0] == 'c' && first[1] == 'c') 630 { 631 const char* t = parse_type(first+2, last, db); 632 if (t != first+2) 633 { 634 const char* t1 = parse_expression(t, last, db); 635 if (t1 != t) 636 { 637 if (db.names.size() < 2) 638 return first; 639 auto expr = db.names.back().move_full(); 640 db.names.pop_back(); 641 db.names.back() = "const_cast<" + db.names.back().move_full() + ">(" + expr + ")"; 642 first = t1; 643 } 644 } 645 } 646 return first; 647 } 648 649 // dc <type> <expression> # dynamic_cast<type> (expression) 650 651 template <class C> 652 const char* 653 parse_dynamic_cast_expr(const char* first, const char* last, C& db) 654 { 655 if (last - first >= 3 && first[0] == 'd' && first[1] == 'c') 656 { 657 const char* t = parse_type(first+2, last, db); 658 if (t != first+2) 659 { 660 const char* t1 = parse_expression(t, last, db); 661 if (t1 != t) 662 { 663 if (db.names.size() < 2) 664 return first; 665 auto expr = db.names.back().move_full(); 666 db.names.pop_back(); 667 db.names.back() = "dynamic_cast<" + db.names.back().move_full() + ">(" + expr + ")"; 668 first = t1; 669 } 670 } 671 } 672 return first; 673 } 674 675 // rc <type> <expression> # reinterpret_cast<type> (expression) 676 677 template <class C> 678 const char* 679 parse_reinterpret_cast_expr(const char* first, const char* last, C& db) 680 { 681 if (last - first >= 3 && first[0] == 'r' && first[1] == 'c') 682 { 683 const char* t = parse_type(first+2, last, db); 684 if (t != first+2) 685 { 686 const char* t1 = parse_expression(t, last, db); 687 if (t1 != t) 688 { 689 if (db.names.size() < 2) 690 return first; 691 auto expr = db.names.back().move_full(); 692 db.names.pop_back(); 693 db.names.back() = "reinterpret_cast<" + db.names.back().move_full() + ">(" + expr + ")"; 694 first = t1; 695 } 696 } 697 } 698 return first; 699 } 700 701 // sc <type> <expression> # static_cast<type> (expression) 702 703 template <class C> 704 const char* 705 parse_static_cast_expr(const char* first, const char* last, C& db) 706 { 707 if (last - first >= 3 && first[0] == 's' && first[1] == 'c') 708 { 709 const char* t = parse_type(first+2, last, db); 710 if (t != first+2) 711 { 712 const char* t1 = parse_expression(t, last, db); 713 if (t1 != t) 714 { 715 if (db.names.size() < 2) 716 return first; 717 auto expr = db.names.back().move_full(); 718 db.names.pop_back(); 719 db.names.back() = "static_cast<" + db.names.back().move_full() + ">(" + expr + ")"; 720 first = t1; 721 } 722 } 723 } 724 return first; 725 } 726 727 // sp <expression> # pack expansion 728 729 template <class C> 730 const char* 731 parse_pack_expansion(const char* first, const char* last, C& db) 732 { 733 if (last - first >= 3 && first[0] == 's' && first[1] == 'p') 734 { 735 const char* t = parse_expression(first+2, last, db); 736 if (t != first+2) 737 first = t; 738 } 739 return first; 740 } 741 742 // st <type> # sizeof (a type) 743 744 template <class C> 745 const char* 746 parse_sizeof_type_expr(const char* first, const char* last, C& db) 747 { 748 if (last - first >= 3 && first[0] == 's' && first[1] == 't') 749 { 750 const char* t = parse_type(first+2, last, db); 751 if (t != first+2) 752 { 753 if (db.names.empty()) 754 return first; 755 db.names.back() = "sizeof (" + db.names.back().move_full() + ")"; 756 first = t; 757 } 758 } 759 return first; 760 } 761 762 // sz <expr> # sizeof (a expression) 763 764 template <class C> 765 const char* 766 parse_sizeof_expr_expr(const char* first, const char* last, C& db) 767 { 768 if (last - first >= 3 && first[0] == 's' && first[1] == 'z') 769 { 770 const char* t = parse_expression(first+2, last, db); 771 if (t != first+2) 772 { 773 if (db.names.empty()) 774 return first; 775 db.names.back() = "sizeof (" + db.names.back().move_full() + ")"; 776 first = t; 777 } 778 } 779 return first; 780 } 781 782 // sZ <template-param> # size of a parameter pack 783 784 template <class C> 785 const char* 786 parse_sizeof_param_pack_expr(const char* first, const char* last, C& db) 787 { 788 if (last - first >= 3 && first[0] == 's' && first[1] == 'Z' && first[2] == 'T') 789 { 790 size_t k0 = db.names.size(); 791 const char* t = parse_template_param(first+2, last, db); 792 size_t k1 = db.names.size(); 793 if (t != first+2) 794 { 795 typename C::String tmp("sizeof...("); 796 size_t k = k0; 797 if (k != k1) 798 { 799 tmp += db.names[k].move_full(); 800 for (++k; k != k1; ++k) 801 tmp += ", " + db.names[k].move_full(); 802 } 803 tmp += ")"; 804 for (; k1 != k0; --k1) 805 db.names.pop_back(); 806 db.names.push_back(std::move(tmp)); 807 first = t; 808 } 809 } 810 return first; 811 } 812 813 // <function-param> ::= fp <top-level CV-qualifiers> _ # L == 0, first parameter 814 // ::= fp <top-level CV-qualifiers> <parameter-2 non-negative number> _ # L == 0, second and later parameters 815 // ::= fL <L-1 non-negative number> p <top-level CV-qualifiers> _ # L > 0, first parameter 816 // ::= fL <L-1 non-negative number> p <top-level CV-qualifiers> <parameter-2 non-negative number> _ # L > 0, second and later parameters 817 818 template <class C> 819 const char* 820 parse_function_param(const char* first, const char* last, C& db) 821 { 822 if (last - first >= 3 && *first == 'f') 823 { 824 if (first[1] == 'p') 825 { 826 unsigned cv; 827 const char* t = parse_cv_qualifiers(first+2, last, cv); 828 const char* t1 = parse_number(t, last); 829 if (t1 != last && *t1 == '_') 830 { 831 db.names.push_back("fp" + typename C::String(t, t1)); 832 first = t1+1; 833 } 834 } 835 else if (first[1] == 'L') 836 { 837 unsigned cv; 838 const char* t0 = parse_number(first+2, last); 839 if (t0 != last && *t0 == 'p') 840 { 841 ++t0; 842 const char* t = parse_cv_qualifiers(t0, last, cv); 843 const char* t1 = parse_number(t, last); 844 if (t1 != last && *t1 == '_') 845 { 846 db.names.push_back("fp" + typename C::String(t, t1)); 847 first = t1+1; 848 } 849 } 850 } 851 } 852 return first; 853 } 854 855 // sZ <function-param> # size of a function parameter pack 856 857 template <class C> 858 const char* 859 parse_sizeof_function_param_pack_expr(const char* first, const char* last, C& db) 860 { 861 if (last - first >= 3 && first[0] == 's' && first[1] == 'Z' && first[2] == 'f') 862 { 863 const char* t = parse_function_param(first+2, last, db); 864 if (t != first+2) 865 { 866 if (db.names.empty()) 867 return first; 868 db.names.back() = "sizeof...(" + db.names.back().move_full() + ")"; 869 first = t; 870 } 871 } 872 return first; 873 } 874 875 // te <expression> # typeid (expression) 876 // ti <type> # typeid (type) 877 878 template <class C> 879 const char* 880 parse_typeid_expr(const char* first, const char* last, C& db) 881 { 882 if (last - first >= 3 && first[0] == 't' && (first[1] == 'e' || first[1] == 'i')) 883 { 884 const char* t; 885 if (first[1] == 'e') 886 t = parse_expression(first+2, last, db); 887 else 888 t = parse_type(first+2, last, db); 889 if (t != first+2) 890 { 891 if (db.names.empty()) 892 return first; 893 db.names.back() = "typeid(" + db.names.back().move_full() + ")"; 894 first = t; 895 } 896 } 897 return first; 898 } 899 900 // tw <expression> # throw expression 901 902 template <class C> 903 const char* 904 parse_throw_expr(const char* first, const char* last, C& db) 905 { 906 if (last - first >= 3 && first[0] == 't' && first[1] == 'w') 907 { 908 const char* t = parse_expression(first+2, last, db); 909 if (t != first+2) 910 { 911 if (db.names.empty()) 912 return first; 913 db.names.back() = "throw " + db.names.back().move_full(); 914 first = t; 915 } 916 } 917 return first; 918 } 919 920 // ds <expression> <expression> # expr.*expr 921 922 template <class C> 923 const char* 924 parse_dot_star_expr(const char* first, const char* last, C& db) 925 { 926 if (last - first >= 3 && first[0] == 'd' && first[1] == 's') 927 { 928 const char* t = parse_expression(first+2, last, db); 929 if (t != first+2) 930 { 931 const char* t1 = parse_expression(t, last, db); 932 if (t1 != t) 933 { 934 if (db.names.size() < 2) 935 return first; 936 auto expr = db.names.back().move_full(); 937 db.names.pop_back(); 938 db.names.back().first += ".*" + expr; 939 first = t1; 940 } 941 } 942 } 943 return first; 944 } 945 946 // <simple-id> ::= <source-name> [ <template-args> ] 947 948 template <class C> 949 const char* 950 parse_simple_id(const char* first, const char* last, C& db) 951 { 952 if (first != last) 953 { 954 const char* t = parse_source_name(first, last, db); 955 if (t != first) 956 { 957 const char* t1 = parse_template_args(t, last, db); 958 if (t1 != t) 959 { 960 if (db.names.size() < 2) 961 return first; 962 auto args = db.names.back().move_full(); 963 db.names.pop_back(); 964 db.names.back().first += std::move(args); 965 } 966 first = t1; 967 } 968 else 969 first = t; 970 } 971 return first; 972 } 973 974 // <unresolved-type> ::= <template-param> 975 // ::= <decltype> 976 // ::= <substitution> 977 978 template <class C> 979 const char* 980 parse_unresolved_type(const char* first, const char* last, C& db) 981 { 982 if (first != last) 983 { 984 const char* t = first; 985 switch (*first) 986 { 987 case 'T': 988 { 989 size_t k0 = db.names.size(); 990 t = parse_template_param(first, last, db); 991 size_t k1 = db.names.size(); 992 if (t != first && k1 == k0 + 1) 993 { 994 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator())); 995 first = t; 996 } 997 else 998 { 999 for (; k1 != k0; --k1) 1000 db.names.pop_back(); 1001 } 1002 break; 1003 } 1004 case 'D': 1005 t = parse_decltype(first, last, db); 1006 if (t != first) 1007 { 1008 if (db.names.empty()) 1009 return first; 1010 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator())); 1011 first = t; 1012 } 1013 break; 1014 case 'S': 1015 t = parse_substitution(first, last, db); 1016 if (t != first) 1017 first = t; 1018 else 1019 { 1020 if (last - first > 2 && first[1] == 't') 1021 { 1022 t = parse_unqualified_name(first+2, last, db); 1023 if (t != first+2) 1024 { 1025 if (db.names.empty()) 1026 return first; 1027 db.names.back().first.insert(0, "std::"); 1028 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator())); 1029 first = t; 1030 } 1031 } 1032 } 1033 break; 1034 } 1035 } 1036 return first; 1037 } 1038 1039 // <destructor-name> ::= <unresolved-type> # e.g., ~T or ~decltype(f()) 1040 // ::= <simple-id> # e.g., ~A<2*N> 1041 1042 template <class C> 1043 const char* 1044 parse_destructor_name(const char* first, const char* last, C& db) 1045 { 1046 if (first != last) 1047 { 1048 const char* t = parse_unresolved_type(first, last, db); 1049 if (t == first) 1050 t = parse_simple_id(first, last, db); 1051 if (t != first) 1052 { 1053 if (db.names.empty()) 1054 return first; 1055 db.names.back().first.insert(0, "~"); 1056 first = t; 1057 } 1058 } 1059 return first; 1060 } 1061 1062 // <base-unresolved-name> ::= <simple-id> # unresolved name 1063 // extension ::= <operator-name> # unresolved operator-function-id 1064 // extension ::= <operator-name> <template-args> # unresolved operator template-id 1065 // ::= on <operator-name> # unresolved operator-function-id 1066 // ::= on <operator-name> <template-args> # unresolved operator template-id 1067 // ::= dn <destructor-name> # destructor or pseudo-destructor; 1068 // # e.g. ~X or ~X<N-1> 1069 1070 template <class C> 1071 const char* 1072 parse_base_unresolved_name(const char* first, const char* last, C& db) 1073 { 1074 if (last - first >= 2) 1075 { 1076 if ((first[0] == 'o' || first[0] == 'd') && first[1] == 'n') 1077 { 1078 if (first[0] == 'o') 1079 { 1080 const char* t = parse_operator_name(first+2, last, db); 1081 if (t != first+2) 1082 { 1083 first = parse_template_args(t, last, db); 1084 if (first != t) 1085 { 1086 if (db.names.size() < 2) 1087 return first; 1088 auto args = db.names.back().move_full(); 1089 db.names.pop_back(); 1090 db.names.back().first += std::move(args); 1091 } 1092 } 1093 } 1094 else 1095 { 1096 const char* t = parse_destructor_name(first+2, last, db); 1097 if (t != first+2) 1098 first = t; 1099 } 1100 } 1101 else 1102 { 1103 const char* t = parse_simple_id(first, last, db); 1104 if (t == first) 1105 { 1106 t = parse_operator_name(first, last, db); 1107 if (t != first) 1108 { 1109 first = parse_template_args(t, last, db); 1110 if (first != t) 1111 { 1112 if (db.names.size() < 2) 1113 return first; 1114 auto args = db.names.back().move_full(); 1115 db.names.pop_back(); 1116 db.names.back().first += std::move(args); 1117 } 1118 } 1119 } 1120 else 1121 first = t; 1122 } 1123 } 1124 return first; 1125 } 1126 1127 // <unresolved-qualifier-level> ::= <simple-id> 1128 1129 template <class C> 1130 const char* 1131 parse_unresolved_qualifier_level(const char* first, const char* last, C& db) 1132 { 1133 return parse_simple_id(first, last, db); 1134 } 1135 1136 // <unresolved-name> 1137 // extension ::= srN <unresolved-type> [<template-args>] <unresolved-qualifier-level>* E <base-unresolved-name> 1138 // ::= [gs] <base-unresolved-name> # x or (with "gs") ::x 1139 // ::= [gs] sr <unresolved-qualifier-level>+ E <base-unresolved-name> 1140 // # A::x, N::y, A<T>::z; "gs" means leading "::" 1141 // ::= sr <unresolved-type> <base-unresolved-name> # T::x / decltype(p)::x 1142 // extension ::= sr <unresolved-type> <template-args> <base-unresolved-name> 1143 // # T::N::x /decltype(p)::N::x 1144 // (ignored) ::= srN <unresolved-type> <unresolved-qualifier-level>+ E <base-unresolved-name> 1145 1146 template <class C> 1147 const char* 1148 parse_unresolved_name(const char* first, const char* last, C& db) 1149 { 1150 if (last - first > 2) 1151 { 1152 const char* t = first; 1153 bool global = false; 1154 if (t[0] == 'g' && t[1] == 's') 1155 { 1156 global = true; 1157 t += 2; 1158 } 1159 const char* t2 = parse_base_unresolved_name(t, last, db); 1160 if (t2 != t) 1161 { 1162 if (global) 1163 { 1164 if (db.names.empty()) 1165 return first; 1166 db.names.back().first.insert(0, "::"); 1167 } 1168 first = t2; 1169 } 1170 else if (last - t > 2 && t[0] == 's' && t[1] == 'r') 1171 { 1172 if (t[2] == 'N') 1173 { 1174 t += 3; 1175 const char* t1 = parse_unresolved_type(t, last, db); 1176 if (t1 == t || t1 == last) 1177 return first; 1178 t = t1; 1179 t1 = parse_template_args(t, last, db); 1180 if (t1 != t) 1181 { 1182 if (db.names.size() < 2) 1183 return first; 1184 auto args = db.names.back().move_full(); 1185 db.names.pop_back(); 1186 db.names.back().first += std::move(args); 1187 t = t1; 1188 if (t == last) 1189 { 1190 db.names.pop_back(); 1191 return first; 1192 } 1193 } 1194 while (*t != 'E') 1195 { 1196 t1 = parse_unresolved_qualifier_level(t, last, db); 1197 if (t1 == t || t1 == last || db.names.size() < 2) 1198 return first; 1199 auto s = db.names.back().move_full(); 1200 db.names.pop_back(); 1201 db.names.back().first += "::" + std::move(s); 1202 t = t1; 1203 } 1204 ++t; 1205 t1 = parse_base_unresolved_name(t, last, db); 1206 if (t1 == t) 1207 { 1208 if (!db.names.empty()) 1209 db.names.pop_back(); 1210 return first; 1211 } 1212 if (db.names.size() < 2) 1213 return first; 1214 auto s = db.names.back().move_full(); 1215 db.names.pop_back(); 1216 db.names.back().first += "::" + std::move(s); 1217 first = t1; 1218 } 1219 else 1220 { 1221 t += 2; 1222 const char* t1 = parse_unresolved_type(t, last, db); 1223 if (t1 != t) 1224 { 1225 t = t1; 1226 t1 = parse_template_args(t, last, db); 1227 if (t1 != t) 1228 { 1229 if (db.names.size() < 2) 1230 return first; 1231 auto args = db.names.back().move_full(); 1232 db.names.pop_back(); 1233 db.names.back().first += std::move(args); 1234 t = t1; 1235 } 1236 t1 = parse_base_unresolved_name(t, last, db); 1237 if (t1 == t) 1238 { 1239 if (!db.names.empty()) 1240 db.names.pop_back(); 1241 return first; 1242 } 1243 if (db.names.size() < 2) 1244 return first; 1245 auto s = db.names.back().move_full(); 1246 db.names.pop_back(); 1247 db.names.back().first += "::" + std::move(s); 1248 first = t1; 1249 } 1250 else 1251 { 1252 t1 = parse_unresolved_qualifier_level(t, last, db); 1253 if (t1 == t || t1 == last) 1254 return first; 1255 t = t1; 1256 if (global) 1257 { 1258 if (db.names.empty()) 1259 return first; 1260 db.names.back().first.insert(0, "::"); 1261 } 1262 while (*t != 'E') 1263 { 1264 t1 = parse_unresolved_qualifier_level(t, last, db); 1265 if (t1 == t || t1 == last || db.names.size() < 2) 1266 return first; 1267 auto s = db.names.back().move_full(); 1268 db.names.pop_back(); 1269 db.names.back().first += "::" + std::move(s); 1270 t = t1; 1271 } 1272 ++t; 1273 t1 = parse_base_unresolved_name(t, last, db); 1274 if (t1 == t) 1275 { 1276 if (!db.names.empty()) 1277 db.names.pop_back(); 1278 return first; 1279 } 1280 if (db.names.size() < 2) 1281 return first; 1282 auto s = db.names.back().move_full(); 1283 db.names.pop_back(); 1284 db.names.back().first += "::" + std::move(s); 1285 first = t1; 1286 } 1287 } 1288 } 1289 } 1290 return first; 1291 } 1292 1293 // dt <expression> <unresolved-name> # expr.name 1294 1295 template <class C> 1296 const char* 1297 parse_dot_expr(const char* first, const char* last, C& db) 1298 { 1299 if (last - first >= 3 && first[0] == 'd' && first[1] == 't') 1300 { 1301 const char* t = parse_expression(first+2, last, db); 1302 if (t != first+2) 1303 { 1304 const char* t1 = parse_unresolved_name(t, last, db); 1305 if (t1 != t) 1306 { 1307 if (db.names.size() < 2) 1308 return first; 1309 auto name = db.names.back().move_full(); 1310 db.names.pop_back(); 1311 db.names.back().first += "." + name; 1312 first = t1; 1313 } 1314 } 1315 } 1316 return first; 1317 } 1318 1319 // cl <expression>+ E # call 1320 1321 template <class C> 1322 const char* 1323 parse_call_expr(const char* first, const char* last, C& db) 1324 { 1325 if (last - first >= 4 && first[0] == 'c' && first[1] == 'l') 1326 { 1327 const char* t = parse_expression(first+2, last, db); 1328 if (t != first+2) 1329 { 1330 if (t == last) 1331 return first; 1332 if (db.names.empty()) 1333 return first; 1334 db.names.back().first += db.names.back().second; 1335 db.names.back().second = typename C::String(); 1336 db.names.back().first.append("("); 1337 bool first_expr = true; 1338 while (*t != 'E') 1339 { 1340 const char* t1 = parse_expression(t, last, db); 1341 if (t1 == t || t1 == last) 1342 return first; 1343 if (db.names.empty()) 1344 return first; 1345 auto tmp = db.names.back().move_full(); 1346 db.names.pop_back(); 1347 if (!tmp.empty()) 1348 { 1349 if (db.names.empty()) 1350 return first; 1351 if (!first_expr) 1352 { 1353 db.names.back().first.append(", "); 1354 first_expr = false; 1355 } 1356 db.names.back().first.append(tmp); 1357 } 1358 t = t1; 1359 } 1360 ++t; 1361 if (db.names.empty()) 1362 return first; 1363 db.names.back().first.append(")"); 1364 first = t; 1365 } 1366 } 1367 return first; 1368 } 1369 1370 // [gs] nw <expression>* _ <type> E # new (expr-list) type 1371 // [gs] nw <expression>* _ <type> <initializer> # new (expr-list) type (init) 1372 // [gs] na <expression>* _ <type> E # new[] (expr-list) type 1373 // [gs] na <expression>* _ <type> <initializer> # new[] (expr-list) type (init) 1374 // <initializer> ::= pi <expression>* E # parenthesized initialization 1375 1376 template <class C> 1377 const char* 1378 parse_new_expr(const char* first, const char* last, C& db) 1379 { 1380 if (last - first >= 4) 1381 { 1382 const char* t = first; 1383 bool parsed_gs = false; 1384 if (t[0] == 'g' && t[1] == 's') 1385 { 1386 t += 2; 1387 parsed_gs = true; 1388 } 1389 if (t[0] == 'n' && (t[1] == 'w' || t[1] == 'a')) 1390 { 1391 bool is_array = t[1] == 'a'; 1392 t += 2; 1393 if (t == last) 1394 return first; 1395 bool has_expr_list = false; 1396 bool first_expr = true; 1397 while (*t != '_') 1398 { 1399 const char* t1 = parse_expression(t, last, db); 1400 if (t1 == t || t1 == last) 1401 return first; 1402 has_expr_list = true; 1403 if (!first_expr) 1404 { 1405 if (db.names.empty()) 1406 return first; 1407 auto tmp = db.names.back().move_full(); 1408 db.names.pop_back(); 1409 if (!tmp.empty()) 1410 { 1411 if (db.names.empty()) 1412 return first; 1413 db.names.back().first.append(", "); 1414 db.names.back().first.append(tmp); 1415 first_expr = false; 1416 } 1417 } 1418 t = t1; 1419 } 1420 ++t; 1421 const char* t1 = parse_type(t, last, db); 1422 if (t1 == t || t1 == last) 1423 return first; 1424 t = t1; 1425 bool has_init = false; 1426 if (last - t >= 3 && t[0] == 'p' && t[1] == 'i') 1427 { 1428 t += 2; 1429 has_init = true; 1430 first_expr = true; 1431 while (*t != 'E') 1432 { 1433 t1 = parse_expression(t, last, db); 1434 if (t1 == t || t1 == last) 1435 return first; 1436 if (!first_expr) 1437 { 1438 if (db.names.empty()) 1439 return first; 1440 auto tmp = db.names.back().move_full(); 1441 db.names.pop_back(); 1442 if (!tmp.empty()) 1443 { 1444 if (db.names.empty()) 1445 return first; 1446 db.names.back().first.append(", "); 1447 db.names.back().first.append(tmp); 1448 first_expr = false; 1449 } 1450 } 1451 t = t1; 1452 } 1453 } 1454 if (*t != 'E') 1455 return first; 1456 typename C::String init_list; 1457 if (has_init) 1458 { 1459 if (db.names.empty()) 1460 return first; 1461 init_list = db.names.back().move_full(); 1462 db.names.pop_back(); 1463 } 1464 if (db.names.empty()) 1465 return first; 1466 auto type = db.names.back().move_full(); 1467 db.names.pop_back(); 1468 typename C::String expr_list; 1469 if (has_expr_list) 1470 { 1471 if (db.names.empty()) 1472 return first; 1473 expr_list = db.names.back().move_full(); 1474 db.names.pop_back(); 1475 } 1476 typename C::String r; 1477 if (parsed_gs) 1478 r = "::"; 1479 if (is_array) 1480 r += "[] "; 1481 else 1482 r += " "; 1483 if (has_expr_list) 1484 r += "(" + expr_list + ") "; 1485 r += type; 1486 if (has_init) 1487 r += " (" + init_list + ")"; 1488 db.names.push_back(std::move(r)); 1489 first = t+1; 1490 } 1491 } 1492 return first; 1493 } 1494 1495 // cv <type> <expression> # conversion with one argument 1496 // cv <type> _ <expression>* E # conversion with a different number of arguments 1497 1498 template <class C> 1499 const char* 1500 parse_conversion_expr(const char* first, const char* last, C& db) 1501 { 1502 if (last - first >= 3 && first[0] == 'c' && first[1] == 'v') 1503 { 1504 bool try_to_parse_template_args = db.try_to_parse_template_args; 1505 db.try_to_parse_template_args = false; 1506 const char* t = parse_type(first+2, last, db); 1507 db.try_to_parse_template_args = try_to_parse_template_args; 1508 if (t != first+2 && t != last) 1509 { 1510 if (*t != '_') 1511 { 1512 const char* t1 = parse_expression(t, last, db); 1513 if (t1 == t) 1514 return first; 1515 t = t1; 1516 } 1517 else 1518 { 1519 ++t; 1520 if (t == last) 1521 return first; 1522 if (*t == 'E') 1523 db.names.emplace_back(); 1524 else 1525 { 1526 bool first_expr = true; 1527 while (*t != 'E') 1528 { 1529 const char* t1 = parse_expression(t, last, db); 1530 if (t1 == t || t1 == last) 1531 return first; 1532 if (!first_expr) 1533 { 1534 if (db.names.empty()) 1535 return first; 1536 auto tmp = db.names.back().move_full(); 1537 db.names.pop_back(); 1538 if (!tmp.empty()) 1539 { 1540 if (db.names.empty()) 1541 return first; 1542 db.names.back().first.append(", "); 1543 db.names.back().first.append(tmp); 1544 first_expr = false; 1545 } 1546 } 1547 t = t1; 1548 } 1549 } 1550 ++t; 1551 } 1552 if (db.names.size() < 2) 1553 return first; 1554 auto tmp = db.names.back().move_full(); 1555 db.names.pop_back(); 1556 db.names.back() = "(" + db.names.back().move_full() + ")(" + tmp + ")"; 1557 first = t; 1558 } 1559 } 1560 return first; 1561 } 1562 1563 // pt <expression> <expression> # expr->name 1564 1565 template <class C> 1566 const char* 1567 parse_arrow_expr(const char* first, const char* last, C& db) 1568 { 1569 if (last - first >= 3 && first[0] == 'p' && first[1] == 't') 1570 { 1571 const char* t = parse_expression(first+2, last, db); 1572 if (t != first+2) 1573 { 1574 const char* t1 = parse_expression(t, last, db); 1575 if (t1 != t) 1576 { 1577 if (db.names.size() < 2) 1578 return first; 1579 auto tmp = db.names.back().move_full(); 1580 db.names.pop_back(); 1581 db.names.back().first += "->"; 1582 db.names.back().first += tmp; 1583 first = t1; 1584 } 1585 } 1586 } 1587 return first; 1588 } 1589 1590 // <ref-qualifier> ::= R # & ref-qualifier 1591 // <ref-qualifier> ::= O # && ref-qualifier 1592 1593 // <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E 1594 1595 template <class C> 1596 const char* 1597 parse_function_type(const char* first, const char* last, C& db) 1598 { 1599 if (first != last && *first == 'F') 1600 { 1601 const char* t = first+1; 1602 if (t != last) 1603 { 1604 bool externC = false; 1605 if (*t == 'Y') 1606 { 1607 externC = true; 1608 if (++t == last) 1609 return first; 1610 } 1611 const char* t1 = parse_type(t, last, db); 1612 if (t1 != t) 1613 { 1614 t = t1; 1615 typename C::String sig("("); 1616 int ref_qual = 0; 1617 while (true) 1618 { 1619 if (t == last) 1620 { 1621 db.names.pop_back(); 1622 return first; 1623 } 1624 if (*t == 'E') 1625 { 1626 ++t; 1627 break; 1628 } 1629 if (*t == 'v') 1630 { 1631 ++t; 1632 continue; 1633 } 1634 if (*t == 'R' && t+1 != last && t[1] == 'E') 1635 { 1636 ref_qual = 1; 1637 ++t; 1638 continue; 1639 } 1640 if (*t == 'O' && t+1 != last && t[1] == 'E') 1641 { 1642 ref_qual = 2; 1643 ++t; 1644 continue; 1645 } 1646 size_t k0 = db.names.size(); 1647 t1 = parse_type(t, last, db); 1648 size_t k1 = db.names.size(); 1649 if (t1 == t || t1 == last) 1650 return first; 1651 for (size_t k = k0; k < k1; ++k) 1652 { 1653 if (sig.size() > 1) 1654 sig += ", "; 1655 sig += db.names[k].move_full(); 1656 } 1657 for (size_t k = k0; k < k1; ++k) 1658 db.names.pop_back(); 1659 t = t1; 1660 } 1661 sig += ")"; 1662 switch (ref_qual) 1663 { 1664 case 1: 1665 sig += " &"; 1666 break; 1667 case 2: 1668 sig += " &&"; 1669 break; 1670 } 1671 if (db.names.empty()) 1672 return first; 1673 db.names.back().first += " "; 1674 db.names.back().second.insert(0, sig); 1675 first = t; 1676 } 1677 } 1678 } 1679 return first; 1680 } 1681 1682 // <pointer-to-member-type> ::= M <class type> <member type> 1683 1684 template <class C> 1685 const char* 1686 parse_pointer_to_member_type(const char* first, const char* last, C& db) 1687 { 1688 if (first != last && *first == 'M') 1689 { 1690 const char* t = parse_type(first+1, last, db); 1691 if (t != first+1) 1692 { 1693 const char* t2 = parse_type(t, last, db); 1694 if (t2 != t) 1695 { 1696 if (db.names.size() < 2) 1697 return first; 1698 auto func = std::move(db.names.back()); 1699 db.names.pop_back(); 1700 auto class_type = std::move(db.names.back()); 1701 if (func.second.front() == '(') 1702 { 1703 db.names.back().first = std::move(func.first) + "(" + class_type.move_full() + "::*"; 1704 db.names.back().second = ")" + std::move(func.second); 1705 } 1706 else 1707 { 1708 db.names.back().first = std::move(func.first) + " " + class_type.move_full() + "::*"; 1709 db.names.back().second = std::move(func.second); 1710 } 1711 first = t2; 1712 } 1713 } 1714 } 1715 return first; 1716 } 1717 1718 // <array-type> ::= A <positive dimension number> _ <element type> 1719 // ::= A [<dimension expression>] _ <element type> 1720 1721 template <class C> 1722 const char* 1723 parse_array_type(const char* first, const char* last, C& db) 1724 { 1725 if (first != last && *first == 'A' && first+1 != last) 1726 { 1727 if (first[1] == '_') 1728 { 1729 const char* t = parse_type(first+2, last, db); 1730 if (t != first+2) 1731 { 1732 if (db.names.empty()) 1733 return first; 1734 if (db.names.back().second.substr(0, 2) == " [") 1735 db.names.back().second.erase(0, 1); 1736 db.names.back().second.insert(0, " []"); 1737 first = t; 1738 } 1739 } 1740 else if ('1' <= first[1] && first[1] <= '9') 1741 { 1742 const char* t = parse_number(first+1, last); 1743 if (t != last && *t == '_') 1744 { 1745 const char* t2 = parse_type(t+1, last, db); 1746 if (t2 != t+1) 1747 { 1748 if (db.names.empty()) 1749 return first; 1750 if (db.names.back().second.substr(0, 2) == " [") 1751 db.names.back().second.erase(0, 1); 1752 db.names.back().second.insert(0, " [" + typename C::String(first+1, t) + "]"); 1753 first = t2; 1754 } 1755 } 1756 } 1757 else 1758 { 1759 const char* t = parse_expression(first+1, last, db); 1760 if (t != first+1 && t != last && *t == '_') 1761 { 1762 const char* t2 = parse_type(++t, last, db); 1763 if (t2 != t) 1764 { 1765 if (db.names.size() < 2) 1766 return first; 1767 auto type = std::move(db.names.back()); 1768 db.names.pop_back(); 1769 auto expr = std::move(db.names.back()); 1770 db.names.back().first = std::move(type.first); 1771 if (type.second.substr(0, 2) == " [") 1772 type.second.erase(0, 1); 1773 db.names.back().second = " [" + expr.move_full() + "]" + std::move(type.second); 1774 first = t2; 1775 } 1776 } 1777 } 1778 } 1779 return first; 1780 } 1781 1782 // <decltype> ::= Dt <expression> E # decltype of an id-expression or class member access (C++0x) 1783 // ::= DT <expression> E # decltype of an expression (C++0x) 1784 1785 template <class C> 1786 const char* 1787 parse_decltype(const char* first, const char* last, C& db) 1788 { 1789 if (last - first >= 4 && first[0] == 'D') 1790 { 1791 switch (first[1]) 1792 { 1793 case 't': 1794 case 'T': 1795 { 1796 const char* t = parse_expression(first+2, last, db); 1797 if (t != first+2 && t != last && *t == 'E') 1798 { 1799 if (db.names.empty()) 1800 return first; 1801 db.names.back() = "decltype(" + db.names.back().move_full() + ")"; 1802 first = t+1; 1803 } 1804 } 1805 break; 1806 } 1807 } 1808 return first; 1809 } 1810 1811 // extension: 1812 // <vector-type> ::= Dv <positive dimension number> _ 1813 // <extended element type> 1814 // ::= Dv [<dimension expression>] _ <element type> 1815 // <extended element type> ::= <element type> 1816 // ::= p # AltiVec vector pixel 1817 1818 template <class C> 1819 const char* 1820 parse_vector_type(const char* first, const char* last, C& db) 1821 { 1822 if (last - first > 3 && first[0] == 'D' && first[1] == 'v') 1823 { 1824 if ('1' <= first[2] && first[2] <= '9') 1825 { 1826 const char* t = parse_number(first+2, last); 1827 if (t == last || *t != '_') 1828 return first; 1829 const char* num = first + 2; 1830 size_t sz = static_cast<size_t>(t - num); 1831 if (++t != last) 1832 { 1833 if (*t != 'p') 1834 { 1835 const char* t1 = parse_type(t, last, db); 1836 if (t1 != t) 1837 { 1838 if (db.names.empty()) 1839 return first; 1840 db.names.back().first += " vector[" + typename C::String(num, sz) + "]"; 1841 first = t1; 1842 } 1843 } 1844 else 1845 { 1846 ++t; 1847 db.names.push_back("pixel vector[" + typename C::String(num, sz) + "]"); 1848 first = t; 1849 } 1850 } 1851 } 1852 else 1853 { 1854 typename C::String num; 1855 const char* t1 = first+2; 1856 if (*t1 != '_') 1857 { 1858 const char* t = parse_expression(t1, last, db); 1859 if (t != t1) 1860 { 1861 if (db.names.empty()) 1862 return first; 1863 num = db.names.back().move_full(); 1864 db.names.pop_back(); 1865 t1 = t; 1866 } 1867 } 1868 if (t1 != last && *t1 == '_' && ++t1 != last) 1869 { 1870 const char* t = parse_type(t1, last, db); 1871 if (t != t1) 1872 { 1873 if (db.names.empty()) 1874 return first; 1875 db.names.back().first += " vector[" + num + "]"; 1876 first = t; 1877 } 1878 } 1879 } 1880 } 1881 return first; 1882 } 1883 1884 // <type> ::= <builtin-type> 1885 // ::= <function-type> 1886 // ::= <class-enum-type> 1887 // ::= <array-type> 1888 // ::= <pointer-to-member-type> 1889 // ::= <template-param> 1890 // ::= <template-template-param> <template-args> 1891 // ::= <decltype> 1892 // ::= <substitution> 1893 // ::= <CV-qualifiers> <type> 1894 // ::= P <type> # pointer-to 1895 // ::= R <type> # reference-to 1896 // ::= O <type> # rvalue reference-to (C++0x) 1897 // ::= C <type> # complex pair (C 2000) 1898 // ::= G <type> # imaginary (C 2000) 1899 // ::= Dp <type> # pack expansion (C++0x) 1900 // ::= U <source-name> <type> # vendor extended type qualifier 1901 // extension := U <objc-name> <objc-type> # objc-type<identifier> 1902 // extension := <vector-type> # <vector-type> starts with Dv 1903 1904 // <objc-name> ::= <k0 number> objcproto <k1 number> <identifier> # k0 = 9 + <number of digits in k1> + k1 1905 // <objc-type> := <source-name> # PU<11+>objcproto 11objc_object<source-name> 11objc_object -> id<source-name> 1906 1907 template <class C> 1908 const char* 1909 parse_type(const char* first, const char* last, C& db) 1910 { 1911 if (first != last) 1912 { 1913 switch (*first) 1914 { 1915 case 'r': 1916 case 'V': 1917 case 'K': 1918 { 1919 unsigned cv = 0; 1920 const char* t = parse_cv_qualifiers(first, last, cv); 1921 if (t != first) 1922 { 1923 bool is_function = *t == 'F'; 1924 size_t k0 = db.names.size(); 1925 const char* t1 = parse_type(t, last, db); 1926 size_t k1 = db.names.size(); 1927 if (t1 != t) 1928 { 1929 if (is_function) 1930 db.subs.pop_back(); 1931 db.subs.emplace_back(db.names.get_allocator()); 1932 for (size_t k = k0; k < k1; ++k) 1933 { 1934 if (is_function) 1935 { 1936 size_t p = db.names[k].second.size(); 1937 if (db.names[k].second[p-2] == '&') 1938 p -= 3; 1939 else if (db.names[k].second.back() == '&') 1940 p -= 2; 1941 if (cv & 1) 1942 { 1943 db.names[k].second.insert(p, " const"); 1944 p += 6; 1945 } 1946 if (cv & 2) 1947 { 1948 db.names[k].second.insert(p, " volatile"); 1949 p += 9; 1950 } 1951 if (cv & 4) 1952 db.names[k].second.insert(p, " restrict"); 1953 } 1954 else 1955 { 1956 if (cv & 1) 1957 db.names[k].first.append(" const"); 1958 if (cv & 2) 1959 db.names[k].first.append(" volatile"); 1960 if (cv & 4) 1961 db.names[k].first.append(" restrict"); 1962 } 1963 db.subs.back().push_back(db.names[k]); 1964 } 1965 first = t1; 1966 } 1967 } 1968 } 1969 break; 1970 default: 1971 { 1972 const char* t = parse_builtin_type(first, last, db); 1973 if (t != first) 1974 { 1975 first = t; 1976 } 1977 else 1978 { 1979 switch (*first) 1980 { 1981 case 'A': 1982 t = parse_array_type(first, last, db); 1983 if (t != first) 1984 { 1985 if (db.names.empty()) 1986 return first; 1987 first = t; 1988 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator())); 1989 } 1990 break; 1991 case 'C': 1992 t = parse_type(first+1, last, db); 1993 if (t != first+1) 1994 { 1995 if (db.names.empty()) 1996 return first; 1997 db.names.back().first.append(" complex"); 1998 first = t; 1999 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator())); 2000 } 2001 break; 2002 case 'F': 2003 t = parse_function_type(first, last, db); 2004 if (t != first) 2005 { 2006 if (db.names.empty()) 2007 return first; 2008 first = t; 2009 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator())); 2010 } 2011 break; 2012 case 'G': 2013 t = parse_type(first+1, last, db); 2014 if (t != first+1) 2015 { 2016 if (db.names.empty()) 2017 return first; 2018 db.names.back().first.append(" imaginary"); 2019 first = t; 2020 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator())); 2021 } 2022 break; 2023 case 'M': 2024 t = parse_pointer_to_member_type(first, last, db); 2025 if (t != first) 2026 { 2027 if (db.names.empty()) 2028 return first; 2029 first = t; 2030 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator())); 2031 } 2032 break; 2033 case 'O': 2034 { 2035 size_t k0 = db.names.size(); 2036 t = parse_type(first+1, last, db); 2037 size_t k1 = db.names.size(); 2038 if (t != first+1) 2039 { 2040 db.subs.emplace_back(db.names.get_allocator()); 2041 for (size_t k = k0; k < k1; ++k) 2042 { 2043 if (db.names[k].second.substr(0, 2) == " [") 2044 { 2045 db.names[k].first += " ("; 2046 db.names[k].second.insert(0, ")"); 2047 } 2048 else if (db.names[k].second.front() == '(') 2049 { 2050 db.names[k].first += "("; 2051 db.names[k].second.insert(0, ")"); 2052 } 2053 db.names[k].first.append("&&"); 2054 db.subs.back().push_back(db.names[k]); 2055 } 2056 first = t; 2057 } 2058 break; 2059 } 2060 case 'P': 2061 { 2062 size_t k0 = db.names.size(); 2063 t = parse_type(first+1, last, db); 2064 size_t k1 = db.names.size(); 2065 if (t != first+1) 2066 { 2067 db.subs.emplace_back(db.names.get_allocator()); 2068 for (size_t k = k0; k < k1; ++k) 2069 { 2070 if (db.names[k].second.substr(0, 2) == " [") 2071 { 2072 db.names[k].first += " ("; 2073 db.names[k].second.insert(0, ")"); 2074 } 2075 else if (db.names[k].second.front() == '(') 2076 { 2077 db.names[k].first += "("; 2078 db.names[k].second.insert(0, ")"); 2079 } 2080 if (first[1] != 'U' || db.names[k].first.substr(0, 12) != "objc_object<") 2081 { 2082 db.names[k].first.append("*"); 2083 } 2084 else 2085 { 2086 db.names[k].first.replace(0, 11, "id"); 2087 } 2088 db.subs.back().push_back(db.names[k]); 2089 } 2090 first = t; 2091 } 2092 break; 2093 } 2094 case 'R': 2095 { 2096 size_t k0 = db.names.size(); 2097 t = parse_type(first+1, last, db); 2098 size_t k1 = db.names.size(); 2099 if (t != first+1) 2100 { 2101 db.subs.emplace_back(db.names.get_allocator()); 2102 for (size_t k = k0; k < k1; ++k) 2103 { 2104 if (db.names[k].second.substr(0, 2) == " [") 2105 { 2106 db.names[k].first += " ("; 2107 db.names[k].second.insert(0, ")"); 2108 } 2109 else if (db.names[k].second.front() == '(') 2110 { 2111 db.names[k].first += "("; 2112 db.names[k].second.insert(0, ")"); 2113 } 2114 db.names[k].first.append("&"); 2115 db.subs.back().push_back(db.names[k]); 2116 } 2117 first = t; 2118 } 2119 break; 2120 } 2121 case 'T': 2122 { 2123 size_t k0 = db.names.size(); 2124 t = parse_template_param(first, last, db); 2125 size_t k1 = db.names.size(); 2126 if (t != first) 2127 { 2128 db.subs.emplace_back(db.names.get_allocator()); 2129 for (size_t k = k0; k < k1; ++k) 2130 db.subs.back().push_back(db.names[k]); 2131 if (db.try_to_parse_template_args && k1 == k0+1) 2132 { 2133 const char* t1 = parse_template_args(t, last, db); 2134 if (t1 != t) 2135 { 2136 auto args = db.names.back().move_full(); 2137 db.names.pop_back(); 2138 db.names.back().first += std::move(args); 2139 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator())); 2140 t = t1; 2141 } 2142 } 2143 first = t; 2144 } 2145 break; 2146 } 2147 case 'U': 2148 if (first+1 != last) 2149 { 2150 t = parse_source_name(first+1, last, db); 2151 if (t != first+1) 2152 { 2153 const char* t2 = parse_type(t, last, db); 2154 if (t2 != t) 2155 { 2156 if (db.names.size() < 2) 2157 return first; 2158 auto type = db.names.back().move_full(); 2159 db.names.pop_back(); 2160 if (db.names.back().first.substr(0, 9) != "objcproto") 2161 { 2162 db.names.back() = type + " " + db.names.back().move_full(); 2163 } 2164 else 2165 { 2166 auto proto = db.names.back().move_full(); 2167 db.names.pop_back(); 2168 t = parse_source_name(proto.data() + 9, proto.data() + proto.size(), db); 2169 if (t != proto.data() + 9) 2170 { 2171 db.names.back() = type + "<" + db.names.back().move_full() + ">"; 2172 } 2173 else 2174 { 2175 db.names.push_back(type + " " + proto); 2176 } 2177 } 2178 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator())); 2179 first = t2; 2180 } 2181 } 2182 } 2183 break; 2184 case 'S': 2185 if (first+1 != last && first[1] == 't') 2186 { 2187 t = parse_name(first, last, db); 2188 if (t != first) 2189 { 2190 if (db.names.empty()) 2191 return first; 2192 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator())); 2193 first = t; 2194 } 2195 } 2196 else 2197 { 2198 t = parse_substitution(first, last, db); 2199 if (t != first) 2200 { 2201 first = t; 2202 // Parsed a substitution. If the substitution is a 2203 // <template-param> it might be followed by <template-args>. 2204 t = parse_template_args(first, last, db); 2205 if (t != first) 2206 { 2207 if (db.names.size() < 2) 2208 return first; 2209 auto template_args = db.names.back().move_full(); 2210 db.names.pop_back(); 2211 db.names.back().first += template_args; 2212 // Need to create substitution for <template-template-param> <template-args> 2213 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator())); 2214 first = t; 2215 } 2216 } 2217 } 2218 break; 2219 case 'D': 2220 if (first+1 != last) 2221 { 2222 switch (first[1]) 2223 { 2224 case 'p': 2225 { 2226 size_t k0 = db.names.size(); 2227 t = parse_type(first+2, last, db); 2228 size_t k1 = db.names.size(); 2229 if (t != first+2) 2230 { 2231 db.subs.emplace_back(db.names.get_allocator()); 2232 for (size_t k = k0; k < k1; ++k) 2233 db.subs.back().push_back(db.names[k]); 2234 first = t; 2235 return first; 2236 } 2237 break; 2238 } 2239 case 't': 2240 case 'T': 2241 t = parse_decltype(first, last, db); 2242 if (t != first) 2243 { 2244 if (db.names.empty()) 2245 return first; 2246 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator())); 2247 first = t; 2248 return first; 2249 } 2250 break; 2251 case 'v': 2252 t = parse_vector_type(first, last, db); 2253 if (t != first) 2254 { 2255 if (db.names.empty()) 2256 return first; 2257 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator())); 2258 first = t; 2259 return first; 2260 } 2261 break; 2262 } 2263 } 2264 // drop through 2265 default: 2266 // must check for builtin-types before class-enum-types to avoid 2267 // ambiguities with operator-names 2268 t = parse_builtin_type(first, last, db); 2269 if (t != first) 2270 { 2271 first = t; 2272 } 2273 else 2274 { 2275 t = parse_name(first, last, db); 2276 if (t != first) 2277 { 2278 if (db.names.empty()) 2279 return first; 2280 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator())); 2281 first = t; 2282 } 2283 } 2284 break; 2285 } 2286 } 2287 break; 2288 } 2289 } 2290 } 2291 return first; 2292 } 2293 2294 // <operator-name> 2295 // ::= aa # && 2296 // ::= ad # & (unary) 2297 // ::= an # & 2298 // ::= aN # &= 2299 // ::= aS # = 2300 // ::= cl # () 2301 // ::= cm # , 2302 // ::= co # ~ 2303 // ::= cv <type> # (cast) 2304 // ::= da # delete[] 2305 // ::= de # * (unary) 2306 // ::= dl # delete 2307 // ::= dv # / 2308 // ::= dV # /= 2309 // ::= eo # ^ 2310 // ::= eO # ^= 2311 // ::= eq # == 2312 // ::= ge # >= 2313 // ::= gt # > 2314 // ::= ix # [] 2315 // ::= le # <= 2316 // ::= ls # << 2317 // ::= lS # <<= 2318 // ::= lt # < 2319 // ::= mi # - 2320 // ::= mI # -= 2321 // ::= ml # * 2322 // ::= mL # *= 2323 // ::= mm # -- (postfix in <expression> context) 2324 // ::= na # new[] 2325 // ::= ne # != 2326 // ::= ng # - (unary) 2327 // ::= nt # ! 2328 // ::= nw # new 2329 // ::= oo # || 2330 // ::= or # | 2331 // ::= oR # |= 2332 // ::= pm # ->* 2333 // ::= pl # + 2334 // ::= pL # += 2335 // ::= pp # ++ (postfix in <expression> context) 2336 // ::= ps # + (unary) 2337 // ::= pt # -> 2338 // ::= qu # ? 2339 // ::= rm # % 2340 // ::= rM # %= 2341 // ::= rs # >> 2342 // ::= rS # >>= 2343 // ::= v <digit> <source-name> # vendor extended operator 2344 2345 template <class C> 2346 const char* 2347 parse_operator_name(const char* first, const char* last, C& db) 2348 { 2349 if (last - first >= 2) 2350 { 2351 switch (first[0]) 2352 { 2353 case 'a': 2354 switch (first[1]) 2355 { 2356 case 'a': 2357 db.names.push_back("operator&&"); 2358 first += 2; 2359 break; 2360 case 'd': 2361 case 'n': 2362 db.names.push_back("operator&"); 2363 first += 2; 2364 break; 2365 case 'N': 2366 db.names.push_back("operator&="); 2367 first += 2; 2368 break; 2369 case 'S': 2370 db.names.push_back("operator="); 2371 first += 2; 2372 break; 2373 } 2374 break; 2375 case 'c': 2376 switch (first[1]) 2377 { 2378 case 'l': 2379 db.names.push_back("operator()"); 2380 first += 2; 2381 break; 2382 case 'm': 2383 db.names.push_back("operator,"); 2384 first += 2; 2385 break; 2386 case 'o': 2387 db.names.push_back("operator~"); 2388 first += 2; 2389 break; 2390 case 'v': 2391 { 2392 bool try_to_parse_template_args = db.try_to_parse_template_args; 2393 db.try_to_parse_template_args = false; 2394 const char* t = parse_type(first+2, last, db); 2395 db.try_to_parse_template_args = try_to_parse_template_args; 2396 if (t != first+2) 2397 { 2398 if (db.names.empty()) 2399 return first; 2400 db.names.back().first.insert(0, "operator "); 2401 db.parsed_ctor_dtor_cv = true; 2402 first = t; 2403 } 2404 } 2405 break; 2406 } 2407 break; 2408 case 'd': 2409 switch (first[1]) 2410 { 2411 case 'a': 2412 db.names.push_back("operator delete[]"); 2413 first += 2; 2414 break; 2415 case 'e': 2416 db.names.push_back("operator*"); 2417 first += 2; 2418 break; 2419 case 'l': 2420 db.names.push_back("operator delete"); 2421 first += 2; 2422 break; 2423 case 'v': 2424 db.names.push_back("operator/"); 2425 first += 2; 2426 break; 2427 case 'V': 2428 db.names.push_back("operator/="); 2429 first += 2; 2430 break; 2431 } 2432 break; 2433 case 'e': 2434 switch (first[1]) 2435 { 2436 case 'o': 2437 db.names.push_back("operator^"); 2438 first += 2; 2439 break; 2440 case 'O': 2441 db.names.push_back("operator^="); 2442 first += 2; 2443 break; 2444 case 'q': 2445 db.names.push_back("operator=="); 2446 first += 2; 2447 break; 2448 } 2449 break; 2450 case 'g': 2451 switch (first[1]) 2452 { 2453 case 'e': 2454 db.names.push_back("operator>="); 2455 first += 2; 2456 break; 2457 case 't': 2458 db.names.push_back("operator>"); 2459 first += 2; 2460 break; 2461 } 2462 break; 2463 case 'i': 2464 if (first[1] == 'x') 2465 { 2466 db.names.push_back("operator[]"); 2467 first += 2; 2468 } 2469 break; 2470 case 'l': 2471 switch (first[1]) 2472 { 2473 case 'e': 2474 db.names.push_back("operator<="); 2475 first += 2; 2476 break; 2477 case 's': 2478 db.names.push_back("operator<<"); 2479 first += 2; 2480 break; 2481 case 'S': 2482 db.names.push_back("operator<<="); 2483 first += 2; 2484 break; 2485 case 't': 2486 db.names.push_back("operator<"); 2487 first += 2; 2488 break; 2489 } 2490 break; 2491 case 'm': 2492 switch (first[1]) 2493 { 2494 case 'i': 2495 db.names.push_back("operator-"); 2496 first += 2; 2497 break; 2498 case 'I': 2499 db.names.push_back("operator-="); 2500 first += 2; 2501 break; 2502 case 'l': 2503 db.names.push_back("operator*"); 2504 first += 2; 2505 break; 2506 case 'L': 2507 db.names.push_back("operator*="); 2508 first += 2; 2509 break; 2510 case 'm': 2511 db.names.push_back("operator--"); 2512 first += 2; 2513 break; 2514 } 2515 break; 2516 case 'n': 2517 switch (first[1]) 2518 { 2519 case 'a': 2520 db.names.push_back("operator new[]"); 2521 first += 2; 2522 break; 2523 case 'e': 2524 db.names.push_back("operator!="); 2525 first += 2; 2526 break; 2527 case 'g': 2528 db.names.push_back("operator-"); 2529 first += 2; 2530 break; 2531 case 't': 2532 db.names.push_back("operator!"); 2533 first += 2; 2534 break; 2535 case 'w': 2536 db.names.push_back("operator new"); 2537 first += 2; 2538 break; 2539 } 2540 break; 2541 case 'o': 2542 switch (first[1]) 2543 { 2544 case 'o': 2545 db.names.push_back("operator||"); 2546 first += 2; 2547 break; 2548 case 'r': 2549 db.names.push_back("operator|"); 2550 first += 2; 2551 break; 2552 case 'R': 2553 db.names.push_back("operator|="); 2554 first += 2; 2555 break; 2556 } 2557 break; 2558 case 'p': 2559 switch (first[1]) 2560 { 2561 case 'm': 2562 db.names.push_back("operator->*"); 2563 first += 2; 2564 break; 2565 case 'l': 2566 db.names.push_back("operator+"); 2567 first += 2; 2568 break; 2569 case 'L': 2570 db.names.push_back("operator+="); 2571 first += 2; 2572 break; 2573 case 'p': 2574 db.names.push_back("operator++"); 2575 first += 2; 2576 break; 2577 case 's': 2578 db.names.push_back("operator+"); 2579 first += 2; 2580 break; 2581 case 't': 2582 db.names.push_back("operator->"); 2583 first += 2; 2584 break; 2585 } 2586 break; 2587 case 'q': 2588 if (first[1] == 'u') 2589 { 2590 db.names.push_back("operator?"); 2591 first += 2; 2592 } 2593 break; 2594 case 'r': 2595 switch (first[1]) 2596 { 2597 case 'm': 2598 db.names.push_back("operator%"); 2599 first += 2; 2600 break; 2601 case 'M': 2602 db.names.push_back("operator%="); 2603 first += 2; 2604 break; 2605 case 's': 2606 db.names.push_back("operator>>"); 2607 first += 2; 2608 break; 2609 case 'S': 2610 db.names.push_back("operator>>="); 2611 first += 2; 2612 break; 2613 } 2614 break; 2615 case 'v': 2616 if (std::isdigit(first[1])) 2617 { 2618 const char* t = parse_source_name(first+2, last, db); 2619 if (t != first+2) 2620 { 2621 if (db.names.empty()) 2622 return first; 2623 db.names.back().first.insert(0, "operator "); 2624 first = t; 2625 } 2626 } 2627 break; 2628 } 2629 } 2630 return first; 2631 } 2632 2633 template <class C> 2634 const char* 2635 parse_integer_literal(const char* first, const char* last, const typename C::String& lit, C& db) 2636 { 2637 const char* t = parse_number(first, last); 2638 if (t != first && t != last && *t == 'E') 2639 { 2640 if (lit.size() > 3) 2641 db.names.push_back("(" + lit + ")"); 2642 else 2643 db.names.emplace_back(); 2644 if (*first == 'n') 2645 { 2646 db.names.back().first += '-'; 2647 ++first; 2648 } 2649 db.names.back().first.append(first, t); 2650 if (lit.size() <= 3) 2651 db.names.back().first += lit; 2652 first = t+1; 2653 } 2654 return first; 2655 } 2656 2657 // <expr-primary> ::= L <type> <value number> E # integer literal 2658 // ::= L <type> <value float> E # floating literal 2659 // ::= L <string type> E # string literal 2660 // ::= L <nullptr type> E # nullptr literal (i.e., "LDnE") 2661 // ::= L <type> <real-part float> _ <imag-part float> E # complex floating point literal (C 2000) 2662 // ::= L <mangled-name> E # external name 2663 2664 template <class C> 2665 const char* 2666 parse_expr_primary(const char* first, const char* last, C& db) 2667 { 2668 if (last - first >= 4 && *first == 'L') 2669 { 2670 switch (first[1]) 2671 { 2672 case 'w': 2673 { 2674 const char* t = parse_integer_literal(first+2, last, "wchar_t", db); 2675 if (t != first+2) 2676 first = t; 2677 } 2678 break; 2679 case 'b': 2680 if (first[3] == 'E') 2681 { 2682 switch (first[2]) 2683 { 2684 case '0': 2685 db.names.push_back("false"); 2686 first += 4; 2687 break; 2688 case '1': 2689 db.names.push_back("true"); 2690 first += 4; 2691 break; 2692 } 2693 } 2694 break; 2695 case 'c': 2696 { 2697 const char* t = parse_integer_literal(first+2, last, "char", db); 2698 if (t != first+2) 2699 first = t; 2700 } 2701 break; 2702 case 'a': 2703 { 2704 const char* t = parse_integer_literal(first+2, last, "signed char", db); 2705 if (t != first+2) 2706 first = t; 2707 } 2708 break; 2709 case 'h': 2710 { 2711 const char* t = parse_integer_literal(first+2, last, "unsigned char", db); 2712 if (t != first+2) 2713 first = t; 2714 } 2715 break; 2716 case 's': 2717 { 2718 const char* t = parse_integer_literal(first+2, last, "short", db); 2719 if (t != first+2) 2720 first = t; 2721 } 2722 break; 2723 case 't': 2724 { 2725 const char* t = parse_integer_literal(first+2, last, "unsigned short", db); 2726 if (t != first+2) 2727 first = t; 2728 } 2729 break; 2730 case 'i': 2731 { 2732 const char* t = parse_integer_literal(first+2, last, "", db); 2733 if (t != first+2) 2734 first = t; 2735 } 2736 break; 2737 case 'j': 2738 { 2739 const char* t = parse_integer_literal(first+2, last, "u", db); 2740 if (t != first+2) 2741 first = t; 2742 } 2743 break; 2744 case 'l': 2745 { 2746 const char* t = parse_integer_literal(first+2, last, "l", db); 2747 if (t != first+2) 2748 first = t; 2749 } 2750 break; 2751 case 'm': 2752 { 2753 const char* t = parse_integer_literal(first+2, last, "ul", db); 2754 if (t != first+2) 2755 first = t; 2756 } 2757 break; 2758 case 'x': 2759 { 2760 const char* t = parse_integer_literal(first+2, last, "ll", db); 2761 if (t != first+2) 2762 first = t; 2763 } 2764 break; 2765 case 'y': 2766 { 2767 const char* t = parse_integer_literal(first+2, last, "ull", db); 2768 if (t != first+2) 2769 first = t; 2770 } 2771 break; 2772 case 'n': 2773 { 2774 const char* t = parse_integer_literal(first+2, last, "__int128", db); 2775 if (t != first+2) 2776 first = t; 2777 } 2778 break; 2779 case 'o': 2780 { 2781 const char* t = parse_integer_literal(first+2, last, "unsigned __int128", db); 2782 if (t != first+2) 2783 first = t; 2784 } 2785 break; 2786 case 'f': 2787 { 2788 const char* t = parse_floating_number<float>(first+2, last, db); 2789 if (t != first+2) 2790 first = t; 2791 } 2792 break; 2793 case 'd': 2794 { 2795 const char* t = parse_floating_number<double>(first+2, last, db); 2796 if (t != first+2) 2797 first = t; 2798 } 2799 break; 2800 case 'e': 2801 { 2802 const char* t = parse_floating_number<long double>(first+2, last, db); 2803 if (t != first+2) 2804 first = t; 2805 } 2806 break; 2807 case '_': 2808 if (first[2] == 'Z') 2809 { 2810 const char* t = parse_encoding(first+3, last, db); 2811 if (t != first+3 && t != last && *t == 'E') 2812 first = t+1; 2813 } 2814 break; 2815 case 'T': 2816 // Invalid mangled name per 2817 // http://sourcerytools.com/pipermail/cxx-abi-dev/2011-August/002422.html 2818 break; 2819 default: 2820 { 2821 // might be named type 2822 const char* t = parse_type(first+1, last, db); 2823 if (t != first+1 && t != last) 2824 { 2825 if (*t != 'E') 2826 { 2827 const char* n = t; 2828 for (; n != last && isdigit(*n); ++n) 2829 ; 2830 if (n != t && n != last && *n == 'E') 2831 { 2832 if (db.names.empty()) 2833 return first; 2834 db.names.back() = "(" + db.names.back().move_full() + ")" + typename C::String(t, n); 2835 first = n+1; 2836 break; 2837 } 2838 } 2839 else 2840 { 2841 first = t+1; 2842 break; 2843 } 2844 } 2845 } 2846 } 2847 } 2848 return first; 2849 } 2850 2851 template <class String> 2852 String 2853 base_name(String& s) 2854 { 2855 if (s.empty()) 2856 return s; 2857 if (s == "std::string") 2858 { 2859 s = "std::basic_string<char, std::char_traits<char>, std::allocator<char> >"; 2860 return "basic_string"; 2861 } 2862 if (s == "std::istream") 2863 { 2864 s = "std::basic_istream<char, std::char_traits<char> >"; 2865 return "basic_istream"; 2866 } 2867 if (s == "std::ostream") 2868 { 2869 s = "std::basic_ostream<char, std::char_traits<char> >"; 2870 return "basic_ostream"; 2871 } 2872 if (s == "std::iostream") 2873 { 2874 s = "std::basic_iostream<char, std::char_traits<char> >"; 2875 return "basic_iostream"; 2876 } 2877 const char* const pf = s.data(); 2878 const char* pe = pf + s.size(); 2879 if (pe[-1] == '>') 2880 { 2881 unsigned c = 1; 2882 while (true) 2883 { 2884 if (--pe == pf) 2885 return String(); 2886 if (pe[-1] == '<') 2887 { 2888 if (--c == 0) 2889 { 2890 --pe; 2891 break; 2892 } 2893 } 2894 else if (pe[-1] == '>') 2895 ++c; 2896 } 2897 } 2898 const char* p0 = pe - 1; 2899 for (; p0 != pf; --p0) 2900 { 2901 if (*p0 == ':') 2902 { 2903 ++p0; 2904 break; 2905 } 2906 } 2907 return String(p0, pe); 2908 } 2909 2910 // <ctor-dtor-name> ::= C1 # complete object constructor 2911 // ::= C2 # base object constructor 2912 // ::= C3 # complete object allocating constructor 2913 // extension ::= C5 # ? 2914 // ::= D0 # deleting destructor 2915 // ::= D1 # complete object destructor 2916 // ::= D2 # base object destructor 2917 // extension ::= D5 # ? 2918 2919 template <class C> 2920 const char* 2921 parse_ctor_dtor_name(const char* first, const char* last, C& db) 2922 { 2923 if (last-first >= 2 && !db.names.empty()) 2924 { 2925 switch (first[0]) 2926 { 2927 case 'C': 2928 switch (first[1]) 2929 { 2930 case '1': 2931 case '2': 2932 case '3': 2933 case '5': 2934 if (db.names.empty()) 2935 return first; 2936 db.names.push_back(base_name(db.names.back().first)); 2937 first += 2; 2938 db.parsed_ctor_dtor_cv = true; 2939 break; 2940 } 2941 break; 2942 case 'D': 2943 switch (first[1]) 2944 { 2945 case '0': 2946 case '1': 2947 case '2': 2948 case '5': 2949 if (db.names.empty()) 2950 return first; 2951 db.names.push_back("~" + base_name(db.names.back().first)); 2952 first += 2; 2953 db.parsed_ctor_dtor_cv = true; 2954 break; 2955 } 2956 break; 2957 } 2958 } 2959 return first; 2960 } 2961 2962 // <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ 2963 // ::= <closure-type-name> 2964 // 2965 // <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ 2966 // 2967 // <lambda-sig> ::= <parameter type>+ # Parameter types or "v" if the lambda has no parameters 2968 2969 template <class C> 2970 const char* 2971 parse_unnamed_type_name(const char* first, const char* last, C& db) 2972 { 2973 if (last - first > 2 && first[0] == 'U') 2974 { 2975 char type = first[1]; 2976 switch (type) 2977 { 2978 case 't': 2979 { 2980 db.names.push_back(typename C::String("'unnamed")); 2981 const char* t0 = first+2; 2982 if (t0 == last) 2983 { 2984 db.names.pop_back(); 2985 return first; 2986 } 2987 if (std::isdigit(*t0)) 2988 { 2989 const char* t1 = t0 + 1; 2990 while (t1 != last && std::isdigit(*t1)) 2991 ++t1; 2992 db.names.back().first.append(t0, t1); 2993 t0 = t1; 2994 } 2995 db.names.back().first.push_back('\''); 2996 if (t0 == last || *t0 != '_') 2997 { 2998 db.names.pop_back(); 2999 return first; 3000 } 3001 first = t0 + 1; 3002 } 3003 break; 3004 case 'l': 3005 { 3006 db.names.push_back(typename C::String("'lambda'(")); 3007 const char* t0 = first+2; 3008 if (first[2] == 'v') 3009 { 3010 db.names.back().first += ')'; 3011 ++t0; 3012 } 3013 else 3014 { 3015 const char* t1 = parse_type(t0, last, db); 3016 if (t1 == t0) 3017 { 3018 db.names.pop_back(); 3019 return first; 3020 } 3021 if (db.names.size() < 2) 3022 return first; 3023 auto tmp = db.names.back().move_full(); 3024 db.names.pop_back(); 3025 db.names.back().first.append(tmp); 3026 t0 = t1; 3027 while (true) 3028 { 3029 t1 = parse_type(t0, last, db); 3030 if (t1 == t0) 3031 break; 3032 if (db.names.size() < 2) 3033 return first; 3034 tmp = db.names.back().move_full(); 3035 db.names.pop_back(); 3036 if (!tmp.empty()) 3037 { 3038 db.names.back().first.append(", "); 3039 db.names.back().first.append(tmp); 3040 } 3041 t0 = t1; 3042 } 3043 db.names.back().first.append(")"); 3044 } 3045 if (t0 == last || *t0 != 'E') 3046 { 3047 db.names.pop_back(); 3048 return first; 3049 } 3050 ++t0; 3051 if (t0 == last) 3052 { 3053 db.names.pop_back(); 3054 return first; 3055 } 3056 if (std::isdigit(*t0)) 3057 { 3058 const char* t1 = t0 + 1; 3059 while (t1 != last && std::isdigit(*t1)) 3060 ++t1; 3061 db.names.back().first.insert(db.names.back().first.begin()+7, t0, t1); 3062 t0 = t1; 3063 } 3064 if (t0 == last || *t0 != '_') 3065 { 3066 db.names.pop_back(); 3067 return first; 3068 } 3069 first = t0 + 1; 3070 } 3071 break; 3072 } 3073 } 3074 return first; 3075 } 3076 3077 // <unqualified-name> ::= <operator-name> 3078 // ::= <ctor-dtor-name> 3079 // ::= <source-name> 3080 // ::= <unnamed-type-name> 3081 3082 template <class C> 3083 const char* 3084 parse_unqualified_name(const char* first, const char* last, C& db) 3085 { 3086 if (first != last) 3087 { 3088 const char* t; 3089 switch (*first) 3090 { 3091 case 'C': 3092 case 'D': 3093 t = parse_ctor_dtor_name(first, last, db); 3094 if (t != first) 3095 first = t; 3096 break; 3097 case 'U': 3098 t = parse_unnamed_type_name(first, last, db); 3099 if (t != first) 3100 first = t; 3101 break; 3102 case '1': 3103 case '2': 3104 case '3': 3105 case '4': 3106 case '5': 3107 case '6': 3108 case '7': 3109 case '8': 3110 case '9': 3111 t = parse_source_name(first, last, db); 3112 if (t != first) 3113 first = t; 3114 break; 3115 default: 3116 t = parse_operator_name(first, last, db); 3117 if (t != first) 3118 first = t; 3119 break; 3120 }; 3121 } 3122 return first; 3123 } 3124 3125 // <unscoped-name> ::= <unqualified-name> 3126 // ::= St <unqualified-name> # ::std:: 3127 // extension ::= StL<unqualified-name> 3128 3129 template <class C> 3130 const char* 3131 parse_unscoped_name(const char* first, const char* last, C& db) 3132 { 3133 if (last - first >= 2) 3134 { 3135 const char* t0 = first; 3136 bool St = false; 3137 if (first[0] == 'S' && first[1] == 't') 3138 { 3139 t0 += 2; 3140 St = true; 3141 if (t0 != last && *t0 == 'L') 3142 ++t0; 3143 } 3144 const char* t1 = parse_unqualified_name(t0, last, db); 3145 if (t1 != t0) 3146 { 3147 if (St) 3148 { 3149 if (db.names.empty()) 3150 return first; 3151 db.names.back().first.insert(0, "std::"); 3152 } 3153 first = t1; 3154 } 3155 } 3156 return first; 3157 } 3158 3159 // at <type> # alignof (a type) 3160 3161 template <class C> 3162 const char* 3163 parse_alignof_type(const char* first, const char* last, C& db) 3164 { 3165 if (last - first >= 3 && first[0] == 'a' && first[1] == 't') 3166 { 3167 const char* t = parse_type(first+2, last, db); 3168 if (t != first+2) 3169 { 3170 if (db.names.empty()) 3171 return first; 3172 db.names.back().first = "alignof (" + db.names.back().move_full() + ")"; 3173 first = t; 3174 } 3175 } 3176 return first; 3177 } 3178 3179 // az <expression> # alignof (a expression) 3180 3181 template <class C> 3182 const char* 3183 parse_alignof_expr(const char* first, const char* last, C& db) 3184 { 3185 if (last - first >= 3 && first[0] == 'a' && first[1] == 'z') 3186 { 3187 const char* t = parse_expression(first+2, last, db); 3188 if (t != first+2) 3189 { 3190 if (db.names.empty()) 3191 return first; 3192 db.names.back().first = "alignof (" + db.names.back().move_full() + ")"; 3193 first = t; 3194 } 3195 } 3196 return first; 3197 } 3198 3199 template <class C> 3200 const char* 3201 parse_noexcept_expression(const char* first, const char* last, C& db) 3202 { 3203 const char* t1 = parse_expression(first, last, db); 3204 if (t1 != first) 3205 { 3206 if (db.names.empty()) 3207 return first; 3208 db.names.back().first = "noexcept (" + db.names.back().move_full() + ")"; 3209 first = t1; 3210 } 3211 return first; 3212 } 3213 3214 template <class C> 3215 const char* 3216 parse_prefix_expression(const char* first, const char* last, const typename C::String& op, C& db) 3217 { 3218 const char* t1 = parse_expression(first, last, db); 3219 if (t1 != first) 3220 { 3221 if (db.names.empty()) 3222 return first; 3223 db.names.back().first = op + "(" + db.names.back().move_full() + ")"; 3224 first = t1; 3225 } 3226 return first; 3227 } 3228 3229 template <class C> 3230 const char* 3231 parse_binary_expression(const char* first, const char* last, const typename C::String& op, C& db) 3232 { 3233 const char* t1 = parse_expression(first, last, db); 3234 if (t1 != first) 3235 { 3236 const char* t2 = parse_expression(t1, last, db); 3237 if (t2 != t1) 3238 { 3239 if (db.names.size() < 2) 3240 return first; 3241 auto op2 = db.names.back().move_full(); 3242 db.names.pop_back(); 3243 auto op1 = db.names.back().move_full(); 3244 auto& nm = db.names.back().first; 3245 nm.clear(); 3246 if (op == ">") 3247 nm += '('; 3248 nm += "(" + op1 + ") " + op + " (" + op2 + ")"; 3249 if (op == ">") 3250 nm += ')'; 3251 first = t2; 3252 } 3253 else 3254 db.names.pop_back(); 3255 } 3256 return first; 3257 } 3258 3259 // <expression> ::= <unary operator-name> <expression> 3260 // ::= <binary operator-name> <expression> <expression> 3261 // ::= <ternary operator-name> <expression> <expression> <expression> 3262 // ::= cl <expression>+ E # call 3263 // ::= cv <type> <expression> # conversion with one argument 3264 // ::= cv <type> _ <expression>* E # conversion with a different number of arguments 3265 // ::= [gs] nw <expression>* _ <type> E # new (expr-list) type 3266 // ::= [gs] nw <expression>* _ <type> <initializer> # new (expr-list) type (init) 3267 // ::= [gs] na <expression>* _ <type> E # new[] (expr-list) type 3268 // ::= [gs] na <expression>* _ <type> <initializer> # new[] (expr-list) type (init) 3269 // ::= [gs] dl <expression> # delete expression 3270 // ::= [gs] da <expression> # delete[] expression 3271 // ::= pp_ <expression> # prefix ++ 3272 // ::= mm_ <expression> # prefix -- 3273 // ::= ti <type> # typeid (type) 3274 // ::= te <expression> # typeid (expression) 3275 // ::= dc <type> <expression> # dynamic_cast<type> (expression) 3276 // ::= sc <type> <expression> # static_cast<type> (expression) 3277 // ::= cc <type> <expression> # const_cast<type> (expression) 3278 // ::= rc <type> <expression> # reinterpret_cast<type> (expression) 3279 // ::= st <type> # sizeof (a type) 3280 // ::= sz <expression> # sizeof (an expression) 3281 // ::= at <type> # alignof (a type) 3282 // ::= az <expression> # alignof (an expression) 3283 // ::= nx <expression> # noexcept (expression) 3284 // ::= <template-param> 3285 // ::= <function-param> 3286 // ::= dt <expression> <unresolved-name> # expr.name 3287 // ::= pt <expression> <unresolved-name> # expr->name 3288 // ::= ds <expression> <expression> # expr.*expr 3289 // ::= sZ <template-param> # size of a parameter pack 3290 // ::= sZ <function-param> # size of a function parameter pack 3291 // ::= sp <expression> # pack expansion 3292 // ::= tw <expression> # throw expression 3293 // ::= tr # throw with no operand (rethrow) 3294 // ::= <unresolved-name> # f(p), N::f(p), ::f(p), 3295 // # freestanding dependent name (e.g., T::x), 3296 // # objectless nonstatic member reference 3297 // ::= <expr-primary> 3298 3299 template <class C> 3300 const char* 3301 parse_expression(const char* first, const char* last, C& db) 3302 { 3303 if (last - first >= 2) 3304 { 3305 const char* t = first; 3306 bool parsed_gs = false; 3307 if (last - first >= 4 && t[0] == 'g' && t[1] == 's') 3308 { 3309 t += 2; 3310 parsed_gs = true; 3311 } 3312 switch (*t) 3313 { 3314 case 'L': 3315 first = parse_expr_primary(first, last, db); 3316 break; 3317 case 'T': 3318 first = parse_template_param(first, last, db); 3319 break; 3320 case 'f': 3321 first = parse_function_param(first, last, db); 3322 break; 3323 case 'a': 3324 switch (t[1]) 3325 { 3326 case 'a': 3327 t = parse_binary_expression(first+2, last, "&&", db); 3328 if (t != first+2) 3329 first = t; 3330 break; 3331 case 'd': 3332 t = parse_prefix_expression(first+2, last, "&", db); 3333 if (t != first+2) 3334 first = t; 3335 break; 3336 case 'n': 3337 t = parse_binary_expression(first+2, last, "&", db); 3338 if (t != first+2) 3339 first = t; 3340 break; 3341 case 'N': 3342 t = parse_binary_expression(first+2, last, "&=", db); 3343 if (t != first+2) 3344 first = t; 3345 break; 3346 case 'S': 3347 t = parse_binary_expression(first+2, last, "=", db); 3348 if (t != first+2) 3349 first = t; 3350 break; 3351 case 't': 3352 first = parse_alignof_type(first, last, db); 3353 break; 3354 case 'z': 3355 first = parse_alignof_expr(first, last, db); 3356 break; 3357 } 3358 break; 3359 case 'c': 3360 switch (t[1]) 3361 { 3362 case 'c': 3363 first = parse_const_cast_expr(first, last, db); 3364 break; 3365 case 'l': 3366 first = parse_call_expr(first, last, db); 3367 break; 3368 case 'm': 3369 t = parse_binary_expression(first+2, last, ",", db); 3370 if (t != first+2) 3371 first = t; 3372 break; 3373 case 'o': 3374 t = parse_prefix_expression(first+2, last, "~", db); 3375 if (t != first+2) 3376 first = t; 3377 break; 3378 case 'v': 3379 first = parse_conversion_expr(first, last, db); 3380 break; 3381 } 3382 break; 3383 case 'd': 3384 switch (t[1]) 3385 { 3386 case 'a': 3387 { 3388 const char* t1 = parse_expression(t+2, last, db); 3389 if (t1 != t+2) 3390 { 3391 if (db.names.empty()) 3392 return first; 3393 db.names.back().first = (parsed_gs ? typename C::String("::") : typename C::String()) + 3394 "delete[] " + db.names.back().move_full(); 3395 first = t1; 3396 } 3397 } 3398 break; 3399 case 'c': 3400 first = parse_dynamic_cast_expr(first, last, db); 3401 break; 3402 case 'e': 3403 t = parse_prefix_expression(first+2, last, "*", db); 3404 if (t != first+2) 3405 first = t; 3406 break; 3407 case 'l': 3408 { 3409 const char* t1 = parse_expression(t+2, last, db); 3410 if (t1 != t+2) 3411 { 3412 if (db.names.empty()) 3413 return first; 3414 db.names.back().first = (parsed_gs ? typename C::String("::") : typename C::String()) + 3415 "delete " + db.names.back().move_full(); 3416 first = t1; 3417 } 3418 } 3419 break; 3420 case 'n': 3421 return parse_unresolved_name(first, last, db); 3422 case 's': 3423 first = parse_dot_star_expr(first, last, db); 3424 break; 3425 case 't': 3426 first = parse_dot_expr(first, last, db); 3427 break; 3428 case 'v': 3429 t = parse_binary_expression(first+2, last, "/", db); 3430 if (t != first+2) 3431 first = t; 3432 break; 3433 case 'V': 3434 t = parse_binary_expression(first+2, last, "/=", db); 3435 if (t != first+2) 3436 first = t; 3437 break; 3438 } 3439 break; 3440 case 'e': 3441 switch (t[1]) 3442 { 3443 case 'o': 3444 t = parse_binary_expression(first+2, last, "^", db); 3445 if (t != first+2) 3446 first = t; 3447 break; 3448 case 'O': 3449 t = parse_binary_expression(first+2, last, "^=", db); 3450 if (t != first+2) 3451 first = t; 3452 break; 3453 case 'q': 3454 t = parse_binary_expression(first+2, last, "==", db); 3455 if (t != first+2) 3456 first = t; 3457 break; 3458 } 3459 break; 3460 case 'g': 3461 switch (t[1]) 3462 { 3463 case 'e': 3464 t = parse_binary_expression(first+2, last, ">=", db); 3465 if (t != first+2) 3466 first = t; 3467 break; 3468 case 't': 3469 t = parse_binary_expression(first+2, last, ">", db); 3470 if (t != first+2) 3471 first = t; 3472 break; 3473 } 3474 break; 3475 case 'i': 3476 if (t[1] == 'x') 3477 { 3478 const char* t1 = parse_expression(first+2, last, db); 3479 if (t1 != first+2) 3480 { 3481 const char* t2 = parse_expression(t1, last, db); 3482 if (t2 != t1) 3483 { 3484 if (db.names.size() < 2) 3485 return first; 3486 auto op2 = db.names.back().move_full(); 3487 db.names.pop_back(); 3488 auto op1 = db.names.back().move_full(); 3489 db.names.back() = "(" + op1 + ")[" + op2 + "]"; 3490 first = t2; 3491 } 3492 else 3493 db.names.pop_back(); 3494 } 3495 } 3496 break; 3497 case 'l': 3498 switch (t[1]) 3499 { 3500 case 'e': 3501 t = parse_binary_expression(first+2, last, "<=", db); 3502 if (t != first+2) 3503 first = t; 3504 break; 3505 case 's': 3506 t = parse_binary_expression(first+2, last, "<<", db); 3507 if (t != first+2) 3508 first = t; 3509 break; 3510 case 'S': 3511 t = parse_binary_expression(first+2, last, "<<=", db); 3512 if (t != first+2) 3513 first = t; 3514 break; 3515 case 't': 3516 t = parse_binary_expression(first+2, last, "<", db); 3517 if (t != first+2) 3518 first = t; 3519 break; 3520 } 3521 break; 3522 case 'm': 3523 switch (t[1]) 3524 { 3525 case 'i': 3526 t = parse_binary_expression(first+2, last, "-", db); 3527 if (t != first+2) 3528 first = t; 3529 break; 3530 case 'I': 3531 t = parse_binary_expression(first+2, last, "-=", db); 3532 if (t != first+2) 3533 first = t; 3534 break; 3535 case 'l': 3536 t = parse_binary_expression(first+2, last, "*", db); 3537 if (t != first+2) 3538 first = t; 3539 break; 3540 case 'L': 3541 t = parse_binary_expression(first+2, last, "*=", db); 3542 if (t != first+2) 3543 first = t; 3544 break; 3545 case 'm': 3546 if (first+2 != last && first[2] == '_') 3547 { 3548 t = parse_prefix_expression(first+3, last, "--", db); 3549 if (t != first+3) 3550 first = t; 3551 } 3552 else 3553 { 3554 const char* t1 = parse_expression(first+2, last, db); 3555 if (t1 != first+2) 3556 { 3557 if (db.names.empty()) 3558 return first; 3559 db.names.back() = "(" + db.names.back().move_full() + ")--"; 3560 first = t1; 3561 } 3562 } 3563 break; 3564 } 3565 break; 3566 case 'n': 3567 switch (t[1]) 3568 { 3569 case 'a': 3570 case 'w': 3571 first = parse_new_expr(first, last, db); 3572 break; 3573 case 'e': 3574 t = parse_binary_expression(first+2, last, "!=", db); 3575 if (t != first+2) 3576 first = t; 3577 break; 3578 case 'g': 3579 t = parse_prefix_expression(first+2, last, "-", db); 3580 if (t != first+2) 3581 first = t; 3582 break; 3583 case 't': 3584 t = parse_prefix_expression(first+2, last, "!", db); 3585 if (t != first+2) 3586 first = t; 3587 break; 3588 case 'x': 3589 t = parse_noexcept_expression(first+2, last, db); 3590 if (t != first+2) 3591 first = t; 3592 break; 3593 } 3594 break; 3595 case 'o': 3596 switch (t[1]) 3597 { 3598 case 'n': 3599 return parse_unresolved_name(first, last, db); 3600 case 'o': 3601 t = parse_binary_expression(first+2, last, "||", db); 3602 if (t != first+2) 3603 first = t; 3604 break; 3605 case 'r': 3606 t = parse_binary_expression(first+2, last, "|", db); 3607 if (t != first+2) 3608 first = t; 3609 break; 3610 case 'R': 3611 t = parse_binary_expression(first+2, last, "|=", db); 3612 if (t != first+2) 3613 first = t; 3614 break; 3615 } 3616 break; 3617 case 'p': 3618 switch (t[1]) 3619 { 3620 case 'm': 3621 t = parse_binary_expression(first+2, last, "->*", db); 3622 if (t != first+2) 3623 first = t; 3624 break; 3625 case 'l': 3626 t = parse_binary_expression(first+2, last, "+", db); 3627 if (t != first+2) 3628 first = t; 3629 break; 3630 case 'L': 3631 t = parse_binary_expression(first+2, last, "+=", db); 3632 if (t != first+2) 3633 first = t; 3634 break; 3635 case 'p': 3636 if (first+2 != last && first[2] == '_') 3637 { 3638 t = parse_prefix_expression(first+3, last, "++", db); 3639 if (t != first+3) 3640 first = t; 3641 } 3642 else 3643 { 3644 const char* t1 = parse_expression(first+2, last, db); 3645 if (t1 != first+2) 3646 { 3647 if (db.names.empty()) 3648 return first; 3649 db.names.back() = "(" + db.names.back().move_full() + ")++"; 3650 first = t1; 3651 } 3652 } 3653 break; 3654 case 's': 3655 t = parse_prefix_expression(first+2, last, "+", db); 3656 if (t != first+2) 3657 first = t; 3658 break; 3659 case 't': 3660 first = parse_arrow_expr(first, last, db); 3661 break; 3662 } 3663 break; 3664 case 'q': 3665 if (t[1] == 'u') 3666 { 3667 const char* t1 = parse_expression(first+2, last, db); 3668 if (t1 != first+2) 3669 { 3670 const char* t2 = parse_expression(t1, last, db); 3671 if (t2 != t1) 3672 { 3673 const char* t3 = parse_expression(t2, last, db); 3674 if (t3 != t2) 3675 { 3676 if (db.names.size() < 3) 3677 return first; 3678 auto op3 = db.names.back().move_full(); 3679 db.names.pop_back(); 3680 auto op2 = db.names.back().move_full(); 3681 db.names.pop_back(); 3682 auto op1 = db.names.back().move_full(); 3683 db.names.back() = "(" + op1 + ") ? (" + op2 + ") : (" + op3 + ")"; 3684 first = t3; 3685 } 3686 else 3687 { 3688 db.names.pop_back(); 3689 db.names.pop_back(); 3690 } 3691 } 3692 else 3693 db.names.pop_back(); 3694 } 3695 } 3696 break; 3697 case 'r': 3698 switch (t[1]) 3699 { 3700 case 'c': 3701 first = parse_reinterpret_cast_expr(first, last, db); 3702 break; 3703 case 'm': 3704 t = parse_binary_expression(first+2, last, "%", db); 3705 if (t != first+2) 3706 first = t; 3707 break; 3708 case 'M': 3709 t = parse_binary_expression(first+2, last, "%=", db); 3710 if (t != first+2) 3711 first = t; 3712 break; 3713 case 's': 3714 t = parse_binary_expression(first+2, last, ">>", db); 3715 if (t != first+2) 3716 first = t; 3717 break; 3718 case 'S': 3719 t = parse_binary_expression(first+2, last, ">>=", db); 3720 if (t != first+2) 3721 first = t; 3722 break; 3723 } 3724 break; 3725 case 's': 3726 switch (t[1]) 3727 { 3728 case 'c': 3729 first = parse_static_cast_expr(first, last, db); 3730 break; 3731 case 'p': 3732 first = parse_pack_expansion(first, last, db); 3733 break; 3734 case 'r': 3735 return parse_unresolved_name(first, last, db); 3736 case 't': 3737 first = parse_sizeof_type_expr(first, last, db); 3738 break; 3739 case 'z': 3740 first = parse_sizeof_expr_expr(first, last, db); 3741 break; 3742 case 'Z': 3743 if (last - t >= 3) 3744 { 3745 switch (t[2]) 3746 { 3747 case 'T': 3748 first = parse_sizeof_param_pack_expr(first, last, db); 3749 break; 3750 case 'f': 3751 first = parse_sizeof_function_param_pack_expr(first, last, db); 3752 break; 3753 } 3754 } 3755 break; 3756 } 3757 break; 3758 case 't': 3759 switch (t[1]) 3760 { 3761 case 'e': 3762 case 'i': 3763 first = parse_typeid_expr(first, last, db); 3764 break; 3765 case 'r': 3766 db.names.push_back("throw"); 3767 first += 2; 3768 break; 3769 case 'w': 3770 first = parse_throw_expr(first, last, db); 3771 break; 3772 } 3773 break; 3774 case '1': 3775 case '2': 3776 case '3': 3777 case '4': 3778 case '5': 3779 case '6': 3780 case '7': 3781 case '8': 3782 case '9': 3783 return parse_unresolved_name(first, last, db); 3784 } 3785 } 3786 return first; 3787 } 3788 3789 // <template-arg> ::= <type> # type or template 3790 // ::= X <expression> E # expression 3791 // ::= <expr-primary> # simple expressions 3792 // ::= J <template-arg>* E # argument pack 3793 // ::= LZ <encoding> E # extension 3794 3795 template <class C> 3796 const char* 3797 parse_template_arg(const char* first, const char* last, C& db) 3798 { 3799 if (first != last) 3800 { 3801 const char* t; 3802 switch (*first) 3803 { 3804 case 'X': 3805 t = parse_expression(first+1, last, db); 3806 if (t != first+1) 3807 { 3808 if (t != last && *t == 'E') 3809 first = t+1; 3810 } 3811 break; 3812 case 'J': 3813 t = first+1; 3814 if (t == last) 3815 return first; 3816 while (*t != 'E') 3817 { 3818 const char* t1 = parse_template_arg(t, last, db); 3819 if (t1 == t) 3820 return first; 3821 t = t1; 3822 } 3823 first = t+1; 3824 break; 3825 case 'L': 3826 // <expr-primary> or LZ <encoding> E 3827 if (first+1 != last && first[1] == 'Z') 3828 { 3829 t = parse_encoding(first+2, last, db); 3830 if (t != first+2 && t != last && *t == 'E') 3831 first = t+1; 3832 } 3833 else 3834 first = parse_expr_primary(first, last, db); 3835 break; 3836 default: 3837 // <type> 3838 first = parse_type(first, last, db); 3839 break; 3840 } 3841 } 3842 return first; 3843 } 3844 3845 // <template-args> ::= I <template-arg>* E 3846 // extension, the abi says <template-arg>+ 3847 3848 template <class C> 3849 const char* 3850 parse_template_args(const char* first, const char* last, C& db) 3851 { 3852 if (last - first >= 2 && *first == 'I') 3853 { 3854 if (db.tag_templates) 3855 db.template_param.back().clear(); 3856 const char* t = first+1; 3857 typename C::String args("<"); 3858 while (*t != 'E') 3859 { 3860 if (db.tag_templates) 3861 db.template_param.emplace_back(db.names.get_allocator()); 3862 size_t k0 = db.names.size(); 3863 const char* t1 = parse_template_arg(t, last, db); 3864 size_t k1 = db.names.size(); 3865 if (db.tag_templates) 3866 db.template_param.pop_back(); 3867 if (t1 == t || t1 == last) 3868 return first; 3869 if (db.tag_templates) 3870 { 3871 db.template_param.back().emplace_back(db.names.get_allocator()); 3872 for (size_t k = k0; k < k1; ++k) 3873 db.template_param.back().back().push_back(db.names[k]); 3874 } 3875 for (size_t k = k0; k < k1; ++k) 3876 { 3877 if (args.size() > 1) 3878 args += ", "; 3879 args += db.names[k].move_full(); 3880 } 3881 for (; k1 != k0; --k1) 3882 db.names.pop_back(); 3883 t = t1; 3884 } 3885 first = t + 1; 3886 if (args.back() != '>') 3887 args += ">"; 3888 else 3889 args += " >"; 3890 db.names.push_back(std::move(args)); 3891 3892 } 3893 return first; 3894 } 3895 3896 // <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E 3897 // ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E 3898 // 3899 // <prefix> ::= <prefix> <unqualified-name> 3900 // ::= <template-prefix> <template-args> 3901 // ::= <template-param> 3902 // ::= <decltype> 3903 // ::= # empty 3904 // ::= <substitution> 3905 // ::= <prefix> <data-member-prefix> 3906 // extension ::= L 3907 // 3908 // <template-prefix> ::= <prefix> <template unqualified-name> 3909 // ::= <template-param> 3910 // ::= <substitution> 3911 3912 template <class C> 3913 const char* 3914 parse_nested_name(const char* first, const char* last, C& db) 3915 { 3916 if (first != last && *first == 'N') 3917 { 3918 unsigned cv; 3919 const char* t0 = parse_cv_qualifiers(first+1, last, cv); 3920 if (t0 == last) 3921 return first; 3922 db.ref = 0; 3923 if (*t0 == 'R') 3924 { 3925 db.ref = 1; 3926 ++t0; 3927 } 3928 else if (*t0 == 'O') 3929 { 3930 db.ref = 2; 3931 ++t0; 3932 } 3933 db.names.emplace_back(); 3934 if (last - t0 >= 2 && t0[0] == 'S' && t0[1] == 't') 3935 { 3936 t0 += 2; 3937 db.names.back().first = "std"; 3938 } 3939 if (t0 == last) 3940 { 3941 db.names.pop_back(); 3942 return first; 3943 } 3944 bool pop_subs = false; 3945 while (*t0 != 'E') 3946 { 3947 const char* t1; 3948 switch (*t0) 3949 { 3950 case 'S': 3951 if (t0 + 1 != last && t0[1] == 't') 3952 goto do_parse_unqualified_name; 3953 t1 = parse_substitution(t0, last, db); 3954 if (t1 != t0 && t1 != last) 3955 { 3956 auto name = db.names.back().move_full(); 3957 db.names.pop_back(); 3958 if (!db.names.back().first.empty()) 3959 { 3960 db.names.back().first += "::" + name; 3961 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator())); 3962 } 3963 else 3964 db.names.back().first = name; 3965 pop_subs = true; 3966 t0 = t1; 3967 } 3968 else 3969 return first; 3970 break; 3971 case 'T': 3972 t1 = parse_template_param(t0, last, db); 3973 if (t1 != t0 && t1 != last) 3974 { 3975 auto name = db.names.back().move_full(); 3976 db.names.pop_back(); 3977 if (!db.names.back().first.empty()) 3978 db.names.back().first += "::" + name; 3979 else 3980 db.names.back().first = name; 3981 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator())); 3982 pop_subs = true; 3983 t0 = t1; 3984 } 3985 else 3986 return first; 3987 break; 3988 case 'D': 3989 if (t0 + 1 != last && t0[1] != 't' && t0[1] != 'T') 3990 goto do_parse_unqualified_name; 3991 t1 = parse_decltype(t0, last, db); 3992 if (t1 != t0 && t1 != last) 3993 { 3994 auto name = db.names.back().move_full(); 3995 db.names.pop_back(); 3996 if (!db.names.back().first.empty()) 3997 db.names.back().first += "::" + name; 3998 else 3999 db.names.back().first = name; 4000 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator())); 4001 pop_subs = true; 4002 t0 = t1; 4003 } 4004 else 4005 return first; 4006 break; 4007 case 'I': 4008 t1 = parse_template_args(t0, last, db); 4009 if (t1 != t0 && t1 != last) 4010 { 4011 auto name = db.names.back().move_full(); 4012 db.names.pop_back(); 4013 db.names.back().first += name; 4014 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator())); 4015 t0 = t1; 4016 } 4017 else 4018 return first; 4019 break; 4020 case 'L': 4021 if (++t0 == last) 4022 return first; 4023 break; 4024 default: 4025 do_parse_unqualified_name: 4026 t1 = parse_unqualified_name(t0, last, db); 4027 if (t1 != t0 && t1 != last) 4028 { 4029 auto name = db.names.back().move_full(); 4030 db.names.pop_back(); 4031 if (!db.names.back().first.empty()) 4032 db.names.back().first += "::" + name; 4033 else 4034 db.names.back().first = name; 4035 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator())); 4036 pop_subs = true; 4037 t0 = t1; 4038 } 4039 else 4040 return first; 4041 } 4042 } 4043 first = t0 + 1; 4044 db.cv = cv; 4045 if (pop_subs && !db.subs.empty()) 4046 db.subs.pop_back(); 4047 } 4048 return first; 4049 } 4050 4051 // <discriminator> := _ <non-negative number> # when number < 10 4052 // := __ <non-negative number> _ # when number >= 10 4053 // extension := decimal-digit+ 4054 4055 const char* 4056 parse_discriminator(const char* first, const char* last) 4057 { 4058 // parse but ignore discriminator 4059 if (first != last) 4060 { 4061 if (*first == '_') 4062 { 4063 const char* t1 = first+1; 4064 if (t1 != last) 4065 { 4066 if (std::isdigit(*t1)) 4067 first = t1+1; 4068 else if (*t1 == '_') 4069 { 4070 for (++t1; t1 != last && std::isdigit(*t1); ++t1) 4071 ; 4072 if (t1 != last && *t1 == '_') 4073 first = t1 + 1; 4074 } 4075 } 4076 } 4077 else if (std::isdigit(*first)) 4078 { 4079 const char* t1 = first+1; 4080 for (; t1 != last && std::isdigit(*t1); ++t1) 4081 ; 4082 first = t1; 4083 } 4084 } 4085 return first; 4086 } 4087 4088 // <local-name> := Z <function encoding> E <entity name> [<discriminator>] 4089 // := Z <function encoding> E s [<discriminator>] 4090 // := Z <function encoding> Ed [ <parameter number> ] _ <entity name> 4091 4092 template <class C> 4093 const char* 4094 parse_local_name(const char* first, const char* last, C& db) 4095 { 4096 if (first != last && *first == 'Z') 4097 { 4098 const char* t = parse_encoding(first+1, last, db); 4099 if (t != first+1 && t != last && *t == 'E' && ++t != last) 4100 { 4101 switch (*t) 4102 { 4103 case 's': 4104 first = parse_discriminator(t+1, last); 4105 if (db.names.empty()) 4106 return first; 4107 db.names.back().first.append("::string literal"); 4108 break; 4109 case 'd': 4110 if (++t != last) 4111 { 4112 const char* t1 = parse_number(t, last); 4113 if (t1 != last && *t1 == '_') 4114 { 4115 t = t1 + 1; 4116 t1 = parse_name(t, last, db); 4117 if (t1 != t) 4118 { 4119 if (db.names.size() < 2) 4120 return first; 4121 auto name = db.names.back().move_full(); 4122 db.names.pop_back(); 4123 db.names.back().first.append("::"); 4124 db.names.back().first.append(name); 4125 first = t1; 4126 } 4127 else 4128 db.names.pop_back(); 4129 } 4130 } 4131 break; 4132 default: 4133 { 4134 const char* t1 = parse_name(t, last, db); 4135 if (t1 != t) 4136 { 4137 // parse but ignore discriminator 4138 first = parse_discriminator(t1, last); 4139 if (db.names.size() < 2) 4140 return first; 4141 auto name = db.names.back().move_full(); 4142 db.names.pop_back(); 4143 db.names.back().first.append("::"); 4144 db.names.back().first.append(name); 4145 } 4146 else 4147 db.names.pop_back(); 4148 } 4149 break; 4150 } 4151 } 4152 } 4153 return first; 4154 } 4155 4156 // <name> ::= <nested-name> // N 4157 // ::= <local-name> # See Scope Encoding below // Z 4158 // ::= <unscoped-template-name> <template-args> 4159 // ::= <unscoped-name> 4160 4161 // <unscoped-template-name> ::= <unscoped-name> 4162 // ::= <substitution> 4163 4164 template <class C> 4165 const char* 4166 parse_name(const char* first, const char* last, C& db) 4167 { 4168 if (last - first >= 2) 4169 { 4170 const char* t0 = first; 4171 // extension: ignore L here 4172 if (*t0 == 'L') 4173 ++t0; 4174 switch (*t0) 4175 { 4176 case 'N': 4177 { 4178 const char* t1 = parse_nested_name(t0, last, db); 4179 if (t1 != t0) 4180 first = t1; 4181 break; 4182 } 4183 case 'Z': 4184 { 4185 const char* t1 = parse_local_name(t0, last, db); 4186 if (t1 != t0) 4187 first = t1; 4188 break; 4189 } 4190 default: 4191 { 4192 const char* t1 = parse_unscoped_name(t0, last, db); 4193 if (t1 != t0) 4194 { 4195 if (t1 != last && *t1 == 'I') // <unscoped-template-name> <template-args> 4196 { 4197 if (db.names.empty()) 4198 return first; 4199 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator())); 4200 t0 = t1; 4201 t1 = parse_template_args(t0, last, db); 4202 if (t1 != t0) 4203 { 4204 if (db.names.size() < 2) 4205 return first; 4206 auto tmp = db.names.back().move_full(); 4207 db.names.pop_back(); 4208 db.names.back().first += tmp; 4209 first = t1; 4210 } 4211 } 4212 else // <unscoped-name> 4213 first = t1; 4214 } 4215 else 4216 { // try <substitution> <template-args> 4217 t1 = parse_substitution(t0, last, db); 4218 if (t1 != t0 && t1 != last && *t1 == 'I') 4219 { 4220 t0 = t1; 4221 t1 = parse_template_args(t0, last, db); 4222 if (t1 != t0) 4223 { 4224 if (db.names.size() < 2) 4225 return first; 4226 auto tmp = db.names.back().move_full(); 4227 db.names.pop_back(); 4228 db.names.back().first += tmp; 4229 first = t1; 4230 } 4231 } 4232 } 4233 break; 4234 } 4235 } 4236 } 4237 return first; 4238 } 4239 4240 // <call-offset> ::= h <nv-offset> _ 4241 // ::= v <v-offset> _ 4242 // 4243 // <nv-offset> ::= <offset number> 4244 // # non-virtual base override 4245 // 4246 // <v-offset> ::= <offset number> _ <virtual offset number> 4247 // # virtual base override, with vcall offset 4248 4249 const char* 4250 parse_call_offset(const char* first, const char* last) 4251 { 4252 if (first != last) 4253 { 4254 switch (*first) 4255 { 4256 case 'h': 4257 { 4258 const char* t = parse_number(first + 1, last); 4259 if (t != first + 1 && t != last && *t == '_') 4260 first = t + 1; 4261 } 4262 break; 4263 case 'v': 4264 { 4265 const char* t = parse_number(first + 1, last); 4266 if (t != first + 1 && t != last && *t == '_') 4267 { 4268 const char* t2 = parse_number(++t, last); 4269 if (t2 != t && t2 != last && *t2 == '_') 4270 first = t2 + 1; 4271 } 4272 } 4273 break; 4274 } 4275 } 4276 return first; 4277 } 4278 4279 // <special-name> ::= TV <type> # virtual table 4280 // ::= TT <type> # VTT structure (construction vtable index) 4281 // ::= TI <type> # typeinfo structure 4282 // ::= TS <type> # typeinfo name (null-terminated byte string) 4283 // ::= Tc <call-offset> <call-offset> <base encoding> 4284 // # base is the nominal target function of thunk 4285 // # first call-offset is 'this' adjustment 4286 // # second call-offset is result adjustment 4287 // ::= T <call-offset> <base encoding> 4288 // # base is the nominal target function of thunk 4289 // ::= GV <object name> # Guard variable for one-time initialization 4290 // # No <type> 4291 // extension ::= TC <first type> <number> _ <second type> # construction vtable for second-in-first 4292 // extension ::= GR <object name> # reference temporary for object 4293 4294 template <class C> 4295 const char* 4296 parse_special_name(const char* first, const char* last, C& db) 4297 { 4298 if (last - first > 2) 4299 { 4300 const char* t; 4301 switch (*first) 4302 { 4303 case 'T': 4304 switch (first[1]) 4305 { 4306 case 'V': 4307 // TV <type> # virtual table 4308 t = parse_type(first+2, last, db); 4309 if (t != first+2) 4310 { 4311 if (db.names.empty()) 4312 return first; 4313 db.names.back().first.insert(0, "vtable for "); 4314 first = t; 4315 } 4316 break; 4317 case 'T': 4318 // TT <type> # VTT structure (construction vtable index) 4319 t = parse_type(first+2, last, db); 4320 if (t != first+2) 4321 { 4322 if (db.names.empty()) 4323 return first; 4324 db.names.back().first.insert(0, "VTT for "); 4325 first = t; 4326 } 4327 break; 4328 case 'I': 4329 // TI <type> # typeinfo structure 4330 t = parse_type(first+2, last, db); 4331 if (t != first+2) 4332 { 4333 if (db.names.empty()) 4334 return first; 4335 db.names.back().first.insert(0, "typeinfo for "); 4336 first = t; 4337 } 4338 break; 4339 case 'S': 4340 // TS <type> # typeinfo name (null-terminated byte string) 4341 t = parse_type(first+2, last, db); 4342 if (t != first+2) 4343 { 4344 if (db.names.empty()) 4345 return first; 4346 db.names.back().first.insert(0, "typeinfo name for "); 4347 first = t; 4348 } 4349 break; 4350 case 'c': 4351 // Tc <call-offset> <call-offset> <base encoding> 4352 { 4353 const char* t0 = parse_call_offset(first+2, last); 4354 if (t0 == first+2) 4355 break; 4356 const char* t1 = parse_call_offset(t0, last); 4357 if (t1 == t0) 4358 break; 4359 t = parse_encoding(t1, last, db); 4360 if (t != t1) 4361 { 4362 if (db.names.empty()) 4363 return first; 4364 db.names.back().first.insert(0, "covariant return thunk to "); 4365 first = t; 4366 } 4367 } 4368 break; 4369 case 'C': 4370 // extension ::= TC <first type> <number> _ <second type> # construction vtable for second-in-first 4371 t = parse_type(first+2, last, db); 4372 if (t != first+2) 4373 { 4374 const char* t0 = parse_number(t, last); 4375 if (t0 != t && t0 != last && *t0 == '_') 4376 { 4377 const char* t1 = parse_type(++t0, last, db); 4378 if (t1 != t0) 4379 { 4380 if (db.names.size() < 2) 4381 return first; 4382 auto left = db.names.back().move_full(); 4383 db.names.pop_back(); 4384 db.names.back().first = "construction vtable for " + 4385 std::move(left) + "-in-" + 4386 db.names.back().move_full(); 4387 first = t1; 4388 } 4389 } 4390 } 4391 break; 4392 default: 4393 // T <call-offset> <base encoding> 4394 { 4395 const char* t0 = parse_call_offset(first+1, last); 4396 if (t0 == first+1) 4397 break; 4398 t = parse_encoding(t0, last, db); 4399 if (t != t0) 4400 { 4401 if (db.names.empty()) 4402 return first; 4403 if (first[2] == 'v') 4404 { 4405 db.names.back().first.insert(0, "virtual thunk to "); 4406 first = t; 4407 } 4408 else 4409 { 4410 db.names.back().first.insert(0, "non-virtual thunk to "); 4411 first = t; 4412 } 4413 } 4414 } 4415 break; 4416 } 4417 break; 4418 case 'G': 4419 switch (first[1]) 4420 { 4421 case 'V': 4422 // GV <object name> # Guard variable for one-time initialization 4423 t = parse_name(first+2, last, db); 4424 if (t != first+2) 4425 { 4426 if (db.names.empty()) 4427 return first; 4428 db.names.back().first.insert(0, "guard variable for "); 4429 first = t; 4430 } 4431 break; 4432 case 'R': 4433 // extension ::= GR <object name> # reference temporary for object 4434 t = parse_name(first+2, last, db); 4435 if (t != first+2) 4436 { 4437 if (db.names.empty()) 4438 return first; 4439 db.names.back().first.insert(0, "reference temporary for "); 4440 first = t; 4441 } 4442 break; 4443 } 4444 break; 4445 } 4446 } 4447 return first; 4448 } 4449 4450 template <class T> 4451 class save_value 4452 { 4453 T& restore_; 4454 T original_value_; 4455 public: 4456 save_value(T& restore) 4457 : restore_(restore), 4458 original_value_(restore) 4459 {} 4460 4461 ~save_value() 4462 { 4463 restore_ = std::move(original_value_); 4464 } 4465 4466 save_value(const save_value&) = delete; 4467 save_value& operator=(const save_value&) = delete; 4468 }; 4469 4470 // <encoding> ::= <function name> <bare-function-type> 4471 // ::= <data name> 4472 // ::= <special-name> 4473 4474 template <class C> 4475 const char* 4476 parse_encoding(const char* first, const char* last, C& db) 4477 { 4478 if (first != last) 4479 { 4480 save_value<decltype(db.encoding_depth)> su(db.encoding_depth); 4481 ++db.encoding_depth; 4482 save_value<decltype(db.tag_templates)> sb(db.tag_templates); 4483 if (db.encoding_depth > 1) 4484 db.tag_templates = true; 4485 switch (*first) 4486 { 4487 case 'G': 4488 case 'T': 4489 first = parse_special_name(first, last, db); 4490 break; 4491 default: 4492 { 4493 const char* t = parse_name(first, last, db); 4494 unsigned cv = db.cv; 4495 unsigned ref = db.ref; 4496 if (t != first) 4497 { 4498 if (t != last && *t != 'E' && *t != '.') 4499 { 4500 save_value<bool> sb2(db.tag_templates); 4501 db.tag_templates = false; 4502 const char* t2; 4503 typename C::String ret2; 4504 if (db.names.empty()) 4505 return first; 4506 const typename C::String& nm = db.names.back().first; 4507 if (nm.empty()) 4508 return first; 4509 if (!db.parsed_ctor_dtor_cv && nm.back() == '>' && nm[nm.size()-2] != '-' 4510 && nm[nm.size()-2] != '>') 4511 { 4512 t2 = parse_type(t, last, db); 4513 if (t2 == t) 4514 return first; 4515 if (db.names.size() < 2) 4516 return first; 4517 auto ret1 = std::move(db.names.back().first); 4518 ret2 = std::move(db.names.back().second); 4519 if (ret2.empty()) 4520 ret1 += ' '; 4521 db.names.pop_back(); 4522 db.names.back().first.insert(0, ret1); 4523 t = t2; 4524 } 4525 db.names.back().first += '('; 4526 if (t != last && *t == 'v') 4527 { 4528 ++t; 4529 } 4530 else 4531 { 4532 bool first_arg = true; 4533 while (true) 4534 { 4535 size_t k0 = db.names.size(); 4536 t2 = parse_type(t, last, db); 4537 size_t k1 = db.names.size(); 4538 if (t2 == t) 4539 break; 4540 if (k1 > k0) 4541 { 4542 typename C::String tmp; 4543 for (size_t k = k0; k < k1; ++k) 4544 { 4545 if (!tmp.empty()) 4546 tmp += ", "; 4547 tmp += db.names[k].move_full(); 4548 } 4549 for (size_t k = k0; k < k1; ++k) 4550 db.names.pop_back(); 4551 if (!tmp.empty()) 4552 { 4553 if (db.names.empty()) 4554 return first; 4555 if (!first_arg) 4556 db.names.back().first += ", "; 4557 else 4558 first_arg = false; 4559 db.names.back().first += tmp; 4560 } 4561 } 4562 t = t2; 4563 } 4564 } 4565 if (db.names.empty()) 4566 return first; 4567 db.names.back().first += ')'; 4568 if (cv & 1) 4569 db.names.back().first.append(" const"); 4570 if (cv & 2) 4571 db.names.back().first.append(" volatile"); 4572 if (cv & 4) 4573 db.names.back().first.append(" restrict"); 4574 if (ref == 1) 4575 db.names.back().first.append(" &"); 4576 else if (ref == 2) 4577 db.names.back().first.append(" &&"); 4578 db.names.back().first += ret2; 4579 first = t; 4580 } 4581 else 4582 first = t; 4583 } 4584 break; 4585 } 4586 } 4587 } 4588 return first; 4589 } 4590 4591 // _block_invoke 4592 // _block_invoke<decimal-digit>+ 4593 // _block_invoke_<decimal-digit>+ 4594 4595 template <class C> 4596 const char* 4597 parse_block_invoke(const char* first, const char* last, C& db) 4598 { 4599 if (last - first >= 13) 4600 { 4601 const char test[] = "_block_invoke"; 4602 const char* t = first; 4603 for (int i = 0; i < 13; ++i, ++t) 4604 { 4605 if (*t != test[i]) 4606 return first; 4607 } 4608 if (t != last) 4609 { 4610 if (*t == '_') 4611 { 4612 // must have at least 1 decimal digit 4613 if (++t == last || !std::isdigit(*t)) 4614 return first; 4615 ++t; 4616 } 4617 // parse zero or more digits 4618 while (t != last && isdigit(*t)) 4619 ++t; 4620 } 4621 if (db.names.empty()) 4622 return first; 4623 db.names.back().first.insert(0, "invocation function for block in "); 4624 first = t; 4625 } 4626 return first; 4627 } 4628 4629 // extension 4630 // <dot-suffix> := .<anything and everything> 4631 4632 template <class C> 4633 const char* 4634 parse_dot_suffix(const char* first, const char* last, C& db) 4635 { 4636 if (first != last && *first == '.') 4637 { 4638 if (db.names.empty()) 4639 return first; 4640 db.names.back().first += " (" + typename C::String(first, last) + ")"; 4641 first = last; 4642 } 4643 return first; 4644 } 4645 4646 // <block-involcaton-function> ___Z<encoding>_block_invoke 4647 // <block-involcaton-function> ___Z<encoding>_block_invoke<decimal-digit>+ 4648 // <block-involcaton-function> ___Z<encoding>_block_invoke_<decimal-digit>+ 4649 // <mangled-name> ::= _Z<encoding> 4650 // ::= <type> 4651 4652 template <class C> 4653 void 4654 demangle(const char* first, const char* last, C& db, int& status) 4655 { 4656 if (first >= last) 4657 { 4658 status = invalid_mangled_name; 4659 return; 4660 } 4661 if (*first == '_') 4662 { 4663 if (last - first >= 4) 4664 { 4665 if (first[1] == 'Z') 4666 { 4667 const char* t = parse_encoding(first+2, last, db); 4668 if (t != first+2 && t != last && *t == '.') 4669 t = parse_dot_suffix(t, last, db); 4670 if (t != last) 4671 status = invalid_mangled_name; 4672 } 4673 else if (first[1] == '_' && first[2] == '_' && first[3] == 'Z') 4674 { 4675 const char* t = parse_encoding(first+4, last, db); 4676 if (t != first+4 && t != last) 4677 { 4678 const char* t1 = parse_block_invoke(t, last, db); 4679 if (t1 != last) 4680 status = invalid_mangled_name; 4681 } 4682 else 4683 status = invalid_mangled_name; 4684 } 4685 else 4686 status = invalid_mangled_name; 4687 } 4688 else 4689 status = invalid_mangled_name; 4690 } 4691 else 4692 { 4693 const char* t = parse_type(first, last, db); 4694 if (t != last) 4695 status = invalid_mangled_name; 4696 } 4697 if (status == success && db.names.empty()) 4698 status = invalid_mangled_name; 4699 } 4700 4701 template <std::size_t N> 4702 class arena 4703 { 4704 static const std::size_t alignment = 16; 4705 alignas(alignment) char buf_[N]; 4706 char* ptr_; 4707 4708 std::size_t 4709 align_up(std::size_t n) noexcept 4710 {return n + (alignment-1) & ~(alignment-1);} 4711 4712 bool 4713 pointer_in_buffer(char* p) noexcept 4714 {return buf_ <= p && p <= buf_ + N;} 4715 4716 public: 4717 arena() noexcept : ptr_(buf_) {} 4718 ~arena() {ptr_ = nullptr;} 4719 arena(const arena&) = delete; 4720 arena& operator=(const arena&) = delete; 4721 4722 char* allocate(std::size_t n); 4723 void deallocate(char* p, std::size_t n) noexcept; 4724 4725 static constexpr std::size_t size() {return N;} 4726 std::size_t used() const {return static_cast<std::size_t>(ptr_ - buf_);} 4727 void reset() {ptr_ = buf_;} 4728 }; 4729 4730 template <std::size_t N> 4731 char* 4732 arena<N>::allocate(std::size_t n) 4733 { 4734 n = align_up(n); 4735 if (static_cast<std::size_t>(buf_ + N - ptr_) >= n) 4736 { 4737 char* r = ptr_; 4738 ptr_ += n; 4739 return r; 4740 } 4741 return static_cast<char*>(std::malloc(n)); 4742 } 4743 4744 template <std::size_t N> 4745 void 4746 arena<N>::deallocate(char* p, std::size_t n) noexcept 4747 { 4748 if (pointer_in_buffer(p)) 4749 { 4750 n = align_up(n); 4751 if (p + n == ptr_) 4752 ptr_ = p; 4753 } 4754 else 4755 std::free(p); 4756 } 4757 4758 template <class T, std::size_t N> 4759 class short_alloc 4760 { 4761 arena<N>& a_; 4762 public: 4763 typedef T value_type; 4764 4765 public: 4766 template <class _Up> struct rebind {typedef short_alloc<_Up, N> other;}; 4767 4768 short_alloc(arena<N>& a) noexcept : a_(a) {} 4769 template <class U> 4770 short_alloc(const short_alloc<U, N>& a) noexcept 4771 : a_(a.a_) {} 4772 short_alloc(const short_alloc&) = default; 4773 short_alloc& operator=(const short_alloc&) = delete; 4774 4775 T* allocate(std::size_t n) 4776 { 4777 return reinterpret_cast<T*>(a_.allocate(n*sizeof(T))); 4778 } 4779 void deallocate(T* p, std::size_t n) noexcept 4780 { 4781 a_.deallocate(reinterpret_cast<char*>(p), n*sizeof(T)); 4782 } 4783 4784 template <class T1, std::size_t N1, class U, std::size_t M> 4785 friend 4786 bool 4787 operator==(const short_alloc<T1, N1>& x, const short_alloc<U, M>& y) noexcept; 4788 4789 template <class U, std::size_t M> friend class short_alloc; 4790 }; 4791 4792 template <class T, std::size_t N, class U, std::size_t M> 4793 inline 4794 bool 4795 operator==(const short_alloc<T, N>& x, const short_alloc<U, M>& y) noexcept 4796 { 4797 return N == M && &x.a_ == &y.a_; 4798 } 4799 4800 template <class T, std::size_t N, class U, std::size_t M> 4801 inline 4802 bool 4803 operator!=(const short_alloc<T, N>& x, const short_alloc<U, M>& y) noexcept 4804 { 4805 return !(x == y); 4806 } 4807 4808 template <class T> 4809 class malloc_alloc 4810 { 4811 public: 4812 typedef T value_type; 4813 4814 malloc_alloc() = default; 4815 template <class U> malloc_alloc(const malloc_alloc<U>&) noexcept {} 4816 4817 T* allocate(std::size_t n) 4818 { 4819 return static_cast<T*>(std::malloc(n*sizeof(T))); 4820 } 4821 void deallocate(T* p, std::size_t) noexcept 4822 { 4823 std::free(p); 4824 } 4825 }; 4826 4827 template <class T, class U> 4828 inline 4829 bool 4830 operator==(const malloc_alloc<T>&, const malloc_alloc<U>&) noexcept 4831 { 4832 return true; 4833 } 4834 4835 template <class T, class U> 4836 inline 4837 bool 4838 operator!=(const malloc_alloc<T>& x, const malloc_alloc<U>& y) noexcept 4839 { 4840 return !(x == y); 4841 } 4842 4843 const size_t bs = 4 * 1024; 4844 template <class T> using Alloc = short_alloc<T, bs>; 4845 template <class T> using Vector = std::vector<T, Alloc<T>>; 4846 using String = std::basic_string<char, std::char_traits<char>, malloc_alloc<char>>; 4847 4848 struct string_pair 4849 { 4850 String first; 4851 String second; 4852 4853 string_pair() = default; 4854 string_pair(String f) : first(std::move(f)) {} 4855 string_pair(String f, String s) 4856 : first(std::move(f)), second(std::move(s)) {} 4857 template <size_t N> 4858 string_pair(const char (&s)[N]) : first(s, N-1) {} 4859 4860 size_t size() const {return first.size() + second.size();} 4861 String full() const {return first + second;} 4862 String move_full() {return std::move(first) + std::move(second);} 4863 }; 4864 4865 struct Db 4866 { 4867 typedef String String; 4868 typedef Vector<string_pair> sub_type; 4869 typedef Vector<sub_type> template_param_type; 4870 Vector<string_pair> names; 4871 Vector<sub_type> subs; 4872 Vector<template_param_type> template_param; 4873 unsigned cv; 4874 unsigned ref; 4875 unsigned encoding_depth; 4876 bool parsed_ctor_dtor_cv; 4877 bool tag_templates; 4878 bool fix_forward_references; 4879 bool try_to_parse_template_args; 4880 4881 template <size_t N> 4882 Db(arena<N>& ar) : 4883 names(ar), 4884 subs(0, names, ar), 4885 template_param(0, subs, ar) 4886 {} 4887 }; 4888 4889 char* 4890 __cxa_demangle(const char* mangled_name, char* buf, size_t* n, int* status) 4891 { 4892 if (mangled_name == nullptr || (buf != nullptr && n == nullptr)) 4893 { 4894 if (status) 4895 *status = invalid_args; 4896 return nullptr; 4897 } 4898 size_t internal_size = buf != nullptr ? *n : 0; 4899 arena<bs> a; 4900 Db db(a); 4901 db.cv = 0; 4902 db.ref = 0; 4903 db.encoding_depth = 0; 4904 db.parsed_ctor_dtor_cv = false; 4905 db.tag_templates = true; 4906 db.template_param.emplace_back(a); 4907 db.fix_forward_references = false; 4908 db.try_to_parse_template_args = true; 4909 int internal_status = success; 4910 size_t len = std::strlen(mangled_name); 4911 demangle(mangled_name, mangled_name + len, db, 4912 internal_status); 4913 if (internal_status == success && db.fix_forward_references && 4914 !db.template_param.empty() && !db.template_param.front().empty()) 4915 { 4916 db.fix_forward_references = false; 4917 db.tag_templates = false; 4918 db.names.clear(); 4919 db.subs.clear(); 4920 demangle(mangled_name, mangled_name + len, db, internal_status); 4921 if (db.fix_forward_references) 4922 internal_status = invalid_mangled_name; 4923 } 4924 if (internal_status == success) 4925 { 4926 size_t sz = db.names.back().size() + 1; 4927 if (sz > internal_size) 4928 { 4929 char* newbuf = static_cast<char*>(std::realloc(buf, sz)); 4930 if (newbuf == nullptr) 4931 { 4932 internal_status = memory_alloc_failure; 4933 buf = nullptr; 4934 } 4935 else 4936 { 4937 buf = newbuf; 4938 if (n != nullptr) 4939 *n = sz; 4940 } 4941 } 4942 if (buf != nullptr) 4943 { 4944 db.names.back().first += db.names.back().second; 4945 std::memcpy(buf, db.names.back().first.data(), sz-1); 4946 buf[sz-1] = char(0); 4947 } 4948 } 4949 else 4950 buf = nullptr; 4951 if (status) 4952 *status = internal_status; 4953 return buf; 4954 } 4955 4956 } 4957 #endif 4958 4959 4960 #include "llvm/ADT/DenseMap.h" 4961 4962 #include "lldb/Core/ConstString.h" 4963 #include "lldb/Core/Mangled.h" 4964 #include "lldb/Core/RegularExpression.h" 4965 #include "lldb/Core/Stream.h" 4966 #include "lldb/Core/Timer.h" 4967 #include <ctype.h> 4968 #include <string.h> 4969 #include <stdlib.h> 4970 4971 using namespace lldb_private; 4972 4973 static inline bool 4974 cstring_is_mangled (const char *s) 4975 { 4976 if (s) 4977 return s[0] == '_' && s[1] == 'Z'; 4978 return false; 4979 } 4980 4981 #pragma mark Mangled 4982 //---------------------------------------------------------------------- 4983 // Default constructor 4984 //---------------------------------------------------------------------- 4985 Mangled::Mangled () : 4986 m_mangled(), 4987 m_demangled() 4988 { 4989 } 4990 4991 //---------------------------------------------------------------------- 4992 // Constructor with an optional string and a boolean indicating if it is 4993 // the mangled version. 4994 //---------------------------------------------------------------------- 4995 Mangled::Mangled (const ConstString &s, bool mangled) : 4996 m_mangled(), 4997 m_demangled() 4998 { 4999 if (s) 5000 SetValue(s, mangled); 5001 } 5002 5003 Mangled::Mangled (const ConstString &s) : 5004 m_mangled(), 5005 m_demangled() 5006 { 5007 if (s) 5008 SetValue(s); 5009 } 5010 5011 //---------------------------------------------------------------------- 5012 // Destructor 5013 //---------------------------------------------------------------------- 5014 Mangled::~Mangled () 5015 { 5016 } 5017 5018 //---------------------------------------------------------------------- 5019 // Convert to pointer operator. This allows code to check any Mangled 5020 // objects to see if they contain anything valid using code such as: 5021 // 5022 // Mangled mangled(...); 5023 // if (mangled) 5024 // { ... 5025 //---------------------------------------------------------------------- 5026 Mangled::operator void* () const 5027 { 5028 return (m_mangled) ? const_cast<Mangled*>(this) : NULL; 5029 } 5030 5031 //---------------------------------------------------------------------- 5032 // Logical NOT operator. This allows code to check any Mangled 5033 // objects to see if they are invalid using code such as: 5034 // 5035 // Mangled mangled(...); 5036 // if (!file_spec) 5037 // { ... 5038 //---------------------------------------------------------------------- 5039 bool 5040 Mangled::operator! () const 5041 { 5042 return !m_mangled; 5043 } 5044 5045 //---------------------------------------------------------------------- 5046 // Clear the mangled and demangled values. 5047 //---------------------------------------------------------------------- 5048 void 5049 Mangled::Clear () 5050 { 5051 m_mangled.Clear(); 5052 m_demangled.Clear(); 5053 } 5054 5055 5056 //---------------------------------------------------------------------- 5057 // Compare the the string values. 5058 //---------------------------------------------------------------------- 5059 int 5060 Mangled::Compare (const Mangled& a, const Mangled& b) 5061 { 5062 return ConstString::Compare(a.GetName(ePreferMangled), a.GetName(ePreferMangled)); 5063 } 5064 5065 5066 5067 //---------------------------------------------------------------------- 5068 // Set the string value in this objects. If "mangled" is true, then 5069 // the mangled named is set with the new value in "s", else the 5070 // demangled name is set. 5071 //---------------------------------------------------------------------- 5072 void 5073 Mangled::SetValue (const ConstString &s, bool mangled) 5074 { 5075 if (s) 5076 { 5077 if (mangled) 5078 { 5079 m_demangled.Clear(); 5080 m_mangled = s; 5081 } 5082 else 5083 { 5084 m_demangled = s; 5085 m_mangled.Clear(); 5086 } 5087 } 5088 else 5089 { 5090 m_demangled.Clear(); 5091 m_mangled.Clear(); 5092 } 5093 } 5094 5095 void 5096 Mangled::SetValue (const ConstString &name) 5097 { 5098 if (name) 5099 { 5100 if (cstring_is_mangled(name.GetCString())) 5101 { 5102 m_demangled.Clear(); 5103 m_mangled = name; 5104 } 5105 else 5106 { 5107 m_demangled = name; 5108 m_mangled.Clear(); 5109 } 5110 } 5111 else 5112 { 5113 m_demangled.Clear(); 5114 m_mangled.Clear(); 5115 } 5116 } 5117 5118 5119 //---------------------------------------------------------------------- 5120 // Generate the demangled name on demand using this accessor. Code in 5121 // this class will need to use this accessor if it wishes to decode 5122 // the demangled name. The result is cached and will be kept until a 5123 // new string value is supplied to this object, or until the end of the 5124 // object's lifetime. 5125 //---------------------------------------------------------------------- 5126 const ConstString& 5127 Mangled::GetDemangledName () const 5128 { 5129 // Check to make sure we have a valid mangled name and that we 5130 // haven't already decoded our mangled name. 5131 if (m_mangled && !m_demangled) 5132 { 5133 // We need to generate and cache the demangled name. 5134 Timer scoped_timer (__PRETTY_FUNCTION__, 5135 "Mangled::GetDemangledName (m_mangled = %s)", 5136 m_mangled.GetCString()); 5137 5138 // Don't bother running anything that isn't mangled 5139 const char *mangled_cstr = m_mangled.GetCString(); 5140 if (cstring_is_mangled(mangled_cstr)) 5141 { 5142 if (!m_mangled.GetMangledCounterpart(m_demangled)) 5143 { 5144 // We didn't already mangle this name, demangle it and if all goes well 5145 // add it to our map. 5146 #ifdef LLDB_USE_BUILTIN_DEMANGLER 5147 char *demangled_name = __cxa_demangle (mangled_cstr, NULL, NULL, NULL); 5148 #elif defined(_MSC_VER) 5149 // Cannot demangle on msvc. 5150 char *demangled_name = nullptr; 5151 #else 5152 char *demangled_name = abi::__cxa_demangle (mangled_cstr, NULL, NULL, NULL); 5153 #endif 5154 5155 if (demangled_name) 5156 { 5157 m_demangled.SetCStringWithMangledCounterpart(demangled_name, m_mangled); 5158 free (demangled_name); 5159 } 5160 } 5161 } 5162 if (!m_demangled) 5163 { 5164 // Set the demangled string to the empty string to indicate we 5165 // tried to parse it once and failed. 5166 m_demangled.SetCString(""); 5167 } 5168 } 5169 5170 return m_demangled; 5171 } 5172 5173 5174 bool 5175 Mangled::NameMatches (const RegularExpression& regex) const 5176 { 5177 if (m_mangled && regex.Execute (m_mangled.AsCString())) 5178 return true; 5179 5180 if (GetDemangledName() && regex.Execute (m_demangled.AsCString())) 5181 return true; 5182 return false; 5183 } 5184 5185 //---------------------------------------------------------------------- 5186 // Get the demangled name if there is one, else return the mangled name. 5187 //---------------------------------------------------------------------- 5188 const ConstString& 5189 Mangled::GetName (Mangled::NamePreference preference) const 5190 { 5191 if (preference == ePreferDemangled) 5192 { 5193 // Call the accessor to make sure we get a demangled name in case 5194 // it hasn't been demangled yet... 5195 if (GetDemangledName()) 5196 return m_demangled; 5197 return m_mangled; 5198 } 5199 else 5200 { 5201 if (m_mangled) 5202 return m_mangled; 5203 return GetDemangledName(); 5204 } 5205 } 5206 5207 //---------------------------------------------------------------------- 5208 // Dump a Mangled object to stream "s". We don't force our 5209 // demangled name to be computed currently (we don't use the accessor). 5210 //---------------------------------------------------------------------- 5211 void 5212 Mangled::Dump (Stream *s) const 5213 { 5214 if (m_mangled) 5215 { 5216 *s << ", mangled = " << m_mangled; 5217 } 5218 if (m_demangled) 5219 { 5220 const char * demangled = m_demangled.AsCString(); 5221 s->Printf(", demangled = %s", demangled[0] ? demangled : "<error>"); 5222 } 5223 } 5224 5225 //---------------------------------------------------------------------- 5226 // Dumps a debug version of this string with extra object and state 5227 // information to stream "s". 5228 //---------------------------------------------------------------------- 5229 void 5230 Mangled::DumpDebug (Stream *s) const 5231 { 5232 s->Printf("%*p: Mangled mangled = ", (int)sizeof(void*) * 2, this); 5233 m_mangled.DumpDebug(s); 5234 s->Printf(", demangled = "); 5235 m_demangled.DumpDebug(s); 5236 } 5237 5238 //---------------------------------------------------------------------- 5239 // Return the size in byte that this object takes in memory. The size 5240 // includes the size of the objects it owns, and not the strings that 5241 // it references because they are shared strings. 5242 //---------------------------------------------------------------------- 5243 size_t 5244 Mangled::MemorySize () const 5245 { 5246 return m_mangled.MemorySize() + m_demangled.MemorySize(); 5247 } 5248 5249 //---------------------------------------------------------------------- 5250 // Dump OBJ to the supplied stream S. 5251 //---------------------------------------------------------------------- 5252 Stream& 5253 operator << (Stream& s, const Mangled& obj) 5254 { 5255 if (obj.GetMangledName()) 5256 s << "mangled = '" << obj.GetMangledName() << "'"; 5257 5258 const ConstString& demangled = obj.GetDemangledName(); 5259 if (demangled) 5260 s << ", demangled = '" << demangled << '\''; 5261 else 5262 s << ", demangled = <error>"; 5263 return s; 5264 } 5265