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