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