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