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