1 //===-------------------------- cxa_demangle.cpp --------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is dual licensed under the MIT and the University of Illinois Open 6 // Source Licenses. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #define _LIBCPP_NO_EXCEPTIONS 11 12 #include "__cxxabi_config.h" 13 14 #include <vector> 15 #include <algorithm> 16 #include <string> 17 #include <numeric> 18 #include <cstdlib> 19 #include <cstring> 20 #include <cctype> 21 22 #ifdef _MSC_VER 23 // snprintf is implemented in VS 2015 24 #if _MSC_VER < 1900 25 #define snprintf _snprintf_s 26 #endif 27 #endif 28 29 namespace __cxxabiv1 30 { 31 32 namespace 33 { 34 35 enum 36 { 37 unknown_error = -4, 38 invalid_args = -3, 39 invalid_mangled_name, 40 memory_alloc_failure, 41 success 42 }; 43 44 template <std::size_t N> 45 class 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 59 public: 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 73 template <std::size_t N> 74 char* 75 arena<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 87 template <std::size_t N> 88 void 89 arena<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 101 template <class T, std::size_t N> 102 class short_alloc 103 { 104 arena<N>& a_; 105 public: 106 typedef T value_type; 107 108 public: 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 135 template <class T, std::size_t N, class U, std::size_t M> 136 inline 137 bool 138 operator==(const short_alloc<T, N>& x, const short_alloc<U, M>& y) noexcept 139 { 140 return N == M && &x.a_ == &y.a_; 141 } 142 143 template <class T, std::size_t N, class U, std::size_t M> 144 inline 145 bool 146 operator!=(const short_alloc<T, N>& x, const short_alloc<U, M>& y) noexcept 147 { 148 return !(x == y); 149 } 150 151 template <class T> 152 class malloc_alloc 153 { 154 public: 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 187 template <class T, class U> 188 inline 189 bool 190 operator==(const malloc_alloc<T>&, const malloc_alloc<U>&) noexcept 191 { 192 return true; 193 } 194 195 template <class T, class U> 196 inline 197 bool 198 operator!=(const malloc_alloc<T>& x, const malloc_alloc<U>& y) noexcept 199 { 200 return !(x == y); 201 } 202 203 const size_t bs = 4 * 1024; 204 template <class T> using Alloc = short_alloc<T, bs>; 205 template <class T> using Vector = std::vector<T, Alloc<T>>; 206 207 template <class StrT> 208 struct 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 226 struct 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 252 const char* parse_type(const char* first, const char* last, Db& db); 253 const char* parse_encoding(const char* first, const char* last, Db& db); 254 const char* parse_name(const char* first, const char* last, Db& db, 255 bool* ends_with_template_args = 0); 256 const char* parse_expression(const char* first, const char* last, Db& db); 257 const char* parse_template_args(const char* first, const char* last, Db& db); 258 const char* parse_operator_name(const char* first, const char* last, Db& db); 259 const char* parse_unqualified_name(const char* first, const char* last, Db& db); 260 const char* parse_decltype(const char* first, const char* last, Db& db); 261 262 template <class C> 263 void 264 print_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 303 template <class C> 304 void 305 print_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 316 const char* 317 parse_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 341 template <class Float> 342 struct float_data; 343 344 template <> 345 struct 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 352 constexpr const char* float_data<float>::spec; 353 354 template <> 355 struct 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 362 constexpr const char* float_data<double>::spec; 363 364 template <> 365 struct 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 379 constexpr const char* float_data<long double>::spec; 380 381 template <class Float> 382 const char* 383 parse_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 425 const char* 426 parse_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 466 const char* 467 parse_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 573 const char* 574 parse_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 722 const char* 723 parse_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 750 const char* 751 parse_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 806 const char* 807 parse_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 833 const char* 834 parse_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 860 const char* 861 parse_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 887 const char* 888 parse_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 912 const char* 913 parse_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 926 const char* 927 parse_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 945 const char* 946 parse_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 964 const char* 965 parse_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 997 const char* 998 parse_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 1035 const char* 1036 parse_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 1055 const char* 1056 parse_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 1078 const char* 1079 parse_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 1097 const char* 1098 parse_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 1122 const char* 1123 parse_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 1151 const char* 1152 parse_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 1214 const char* 1215 parse_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 1241 const char* 1242 parse_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 1299 const char* 1300 parse_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 1315 const char* 1316 parse_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 1463 const char* 1464 parse_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 1490 const char* 1491 parse_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 1544 const char* 1545 parse_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 1665 const char* 1666 parse_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 1731 const char* 1732 parse_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 1760 const char* 1761 parse_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 1848 const char* 1849 parse_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 1884 const char* 1885 parse_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 1947 const char* 1948 parse_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 1979 const char* 1980 parse_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 2067 const char* 2068 parse_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 t = parse_template_args(first, last, db); 2368 if (t != first) 2369 { 2370 if (db.names.size() < 2) 2371 return first; 2372 auto template_args = db.names.back().move_full(); 2373 db.names.pop_back(); 2374 db.names.back().first += template_args; 2375 // Need to create substitution for <template-template-param> <template-args> 2376 db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator())); 2377 first = t; 2378 } 2379 } 2380 } 2381 break; 2382 case 'D': 2383 if (first+1 != last) 2384 { 2385 switch (first[1]) 2386 { 2387 case 'p': 2388 { 2389 size_t k0 = db.names.size(); 2390 t = parse_type(first+2, last, db); 2391 size_t k1 = db.names.size(); 2392 if (t != first+2) 2393 { 2394 db.subs.emplace_back(db.names.get_allocator()); 2395 for (size_t k = k0; k < k1; ++k) 2396 db.subs.back().push_back(db.names[k]); 2397 first = t; 2398 return first; 2399 } 2400 break; 2401 } 2402 case 't': 2403 case 'T': 2404 t = parse_decltype(first, last, db); 2405 if (t != first) 2406 { 2407 if (db.names.empty()) 2408 return first; 2409 db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator())); 2410 first = t; 2411 return first; 2412 } 2413 break; 2414 case 'v': 2415 t = parse_vector_type(first, last, db); 2416 if (t != first) 2417 { 2418 if (db.names.empty()) 2419 return first; 2420 db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator())); 2421 first = t; 2422 return first; 2423 } 2424 break; 2425 } 2426 } 2427 _LIBCPP_FALLTHROUGH(); 2428 default: 2429 // must check for builtin-types before class-enum-types to avoid 2430 // ambiguities with operator-names 2431 t = parse_builtin_type(first, last, db); 2432 if (t != first) 2433 { 2434 first = t; 2435 } 2436 else 2437 { 2438 t = parse_name(first, last, db); 2439 if (t != first) 2440 { 2441 if (db.names.empty()) 2442 return first; 2443 db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator())); 2444 first = t; 2445 } 2446 } 2447 break; 2448 } 2449 } 2450 break; 2451 } 2452 } 2453 } 2454 return first; 2455 } 2456 2457 // <operator-name> 2458 // ::= aa # && 2459 // ::= ad # & (unary) 2460 // ::= an # & 2461 // ::= aN # &= 2462 // ::= aS # = 2463 // ::= cl # () 2464 // ::= cm # , 2465 // ::= co # ~ 2466 // ::= cv <type> # (cast) 2467 // ::= da # delete[] 2468 // ::= de # * (unary) 2469 // ::= dl # delete 2470 // ::= dv # / 2471 // ::= dV # /= 2472 // ::= eo # ^ 2473 // ::= eO # ^= 2474 // ::= eq # == 2475 // ::= ge # >= 2476 // ::= gt # > 2477 // ::= ix # [] 2478 // ::= le # <= 2479 // ::= li <source-name> # operator "" 2480 // ::= ls # << 2481 // ::= lS # <<= 2482 // ::= lt # < 2483 // ::= mi # - 2484 // ::= mI # -= 2485 // ::= ml # * 2486 // ::= mL # *= 2487 // ::= mm # -- (postfix in <expression> context) 2488 // ::= na # new[] 2489 // ::= ne # != 2490 // ::= ng # - (unary) 2491 // ::= nt # ! 2492 // ::= nw # new 2493 // ::= oo # || 2494 // ::= or # | 2495 // ::= oR # |= 2496 // ::= pm # ->* 2497 // ::= pl # + 2498 // ::= pL # += 2499 // ::= pp # ++ (postfix in <expression> context) 2500 // ::= ps # + (unary) 2501 // ::= pt # -> 2502 // ::= qu # ? 2503 // ::= rm # % 2504 // ::= rM # %= 2505 // ::= rs # >> 2506 // ::= rS # >>= 2507 // ::= v <digit> <source-name> # vendor extended operator 2508 2509 const char* 2510 parse_operator_name(const char* first, const char* last, Db& db) 2511 { 2512 if (last - first >= 2) 2513 { 2514 switch (first[0]) 2515 { 2516 case 'a': 2517 switch (first[1]) 2518 { 2519 case 'a': 2520 db.names.push_back("operator&&"); 2521 first += 2; 2522 break; 2523 case 'd': 2524 case 'n': 2525 db.names.push_back("operator&"); 2526 first += 2; 2527 break; 2528 case 'N': 2529 db.names.push_back("operator&="); 2530 first += 2; 2531 break; 2532 case 'S': 2533 db.names.push_back("operator="); 2534 first += 2; 2535 break; 2536 } 2537 break; 2538 case 'c': 2539 switch (first[1]) 2540 { 2541 case 'l': 2542 db.names.push_back("operator()"); 2543 first += 2; 2544 break; 2545 case 'm': 2546 db.names.push_back("operator,"); 2547 first += 2; 2548 break; 2549 case 'o': 2550 db.names.push_back("operator~"); 2551 first += 2; 2552 break; 2553 case 'v': 2554 { 2555 bool try_to_parse_template_args = db.try_to_parse_template_args; 2556 db.try_to_parse_template_args = false; 2557 const char* t = parse_type(first+2, last, db); 2558 db.try_to_parse_template_args = try_to_parse_template_args; 2559 if (t != first+2) 2560 { 2561 if (db.names.empty()) 2562 return first; 2563 db.names.back().first.insert(0, "operator "); 2564 db.parsed_ctor_dtor_cv = true; 2565 first = t; 2566 } 2567 } 2568 break; 2569 } 2570 break; 2571 case 'd': 2572 switch (first[1]) 2573 { 2574 case 'a': 2575 db.names.push_back("operator delete[]"); 2576 first += 2; 2577 break; 2578 case 'e': 2579 db.names.push_back("operator*"); 2580 first += 2; 2581 break; 2582 case 'l': 2583 db.names.push_back("operator delete"); 2584 first += 2; 2585 break; 2586 case 'v': 2587 db.names.push_back("operator/"); 2588 first += 2; 2589 break; 2590 case 'V': 2591 db.names.push_back("operator/="); 2592 first += 2; 2593 break; 2594 } 2595 break; 2596 case 'e': 2597 switch (first[1]) 2598 { 2599 case 'o': 2600 db.names.push_back("operator^"); 2601 first += 2; 2602 break; 2603 case 'O': 2604 db.names.push_back("operator^="); 2605 first += 2; 2606 break; 2607 case 'q': 2608 db.names.push_back("operator=="); 2609 first += 2; 2610 break; 2611 } 2612 break; 2613 case 'g': 2614 switch (first[1]) 2615 { 2616 case 'e': 2617 db.names.push_back("operator>="); 2618 first += 2; 2619 break; 2620 case 't': 2621 db.names.push_back("operator>"); 2622 first += 2; 2623 break; 2624 } 2625 break; 2626 case 'i': 2627 if (first[1] == 'x') 2628 { 2629 db.names.push_back("operator[]"); 2630 first += 2; 2631 } 2632 break; 2633 case 'l': 2634 switch (first[1]) 2635 { 2636 case 'e': 2637 db.names.push_back("operator<="); 2638 first += 2; 2639 break; 2640 case 'i': 2641 { 2642 const char* t = parse_source_name(first+2, last, db); 2643 if (t != first+2) 2644 { 2645 if (db.names.empty()) 2646 return first; 2647 db.names.back().first.insert(0, "operator\"\" "); 2648 first = t; 2649 } 2650 } 2651 break; 2652 case 's': 2653 db.names.push_back("operator<<"); 2654 first += 2; 2655 break; 2656 case 'S': 2657 db.names.push_back("operator<<="); 2658 first += 2; 2659 break; 2660 case 't': 2661 db.names.push_back("operator<"); 2662 first += 2; 2663 break; 2664 } 2665 break; 2666 case 'm': 2667 switch (first[1]) 2668 { 2669 case 'i': 2670 db.names.push_back("operator-"); 2671 first += 2; 2672 break; 2673 case 'I': 2674 db.names.push_back("operator-="); 2675 first += 2; 2676 break; 2677 case 'l': 2678 db.names.push_back("operator*"); 2679 first += 2; 2680 break; 2681 case 'L': 2682 db.names.push_back("operator*="); 2683 first += 2; 2684 break; 2685 case 'm': 2686 db.names.push_back("operator--"); 2687 first += 2; 2688 break; 2689 } 2690 break; 2691 case 'n': 2692 switch (first[1]) 2693 { 2694 case 'a': 2695 db.names.push_back("operator new[]"); 2696 first += 2; 2697 break; 2698 case 'e': 2699 db.names.push_back("operator!="); 2700 first += 2; 2701 break; 2702 case 'g': 2703 db.names.push_back("operator-"); 2704 first += 2; 2705 break; 2706 case 't': 2707 db.names.push_back("operator!"); 2708 first += 2; 2709 break; 2710 case 'w': 2711 db.names.push_back("operator new"); 2712 first += 2; 2713 break; 2714 } 2715 break; 2716 case 'o': 2717 switch (first[1]) 2718 { 2719 case 'o': 2720 db.names.push_back("operator||"); 2721 first += 2; 2722 break; 2723 case 'r': 2724 db.names.push_back("operator|"); 2725 first += 2; 2726 break; 2727 case 'R': 2728 db.names.push_back("operator|="); 2729 first += 2; 2730 break; 2731 } 2732 break; 2733 case 'p': 2734 switch (first[1]) 2735 { 2736 case 'm': 2737 db.names.push_back("operator->*"); 2738 first += 2; 2739 break; 2740 case 'l': 2741 db.names.push_back("operator+"); 2742 first += 2; 2743 break; 2744 case 'L': 2745 db.names.push_back("operator+="); 2746 first += 2; 2747 break; 2748 case 'p': 2749 db.names.push_back("operator++"); 2750 first += 2; 2751 break; 2752 case 's': 2753 db.names.push_back("operator+"); 2754 first += 2; 2755 break; 2756 case 't': 2757 db.names.push_back("operator->"); 2758 first += 2; 2759 break; 2760 } 2761 break; 2762 case 'q': 2763 if (first[1] == 'u') 2764 { 2765 db.names.push_back("operator?"); 2766 first += 2; 2767 } 2768 break; 2769 case 'r': 2770 switch (first[1]) 2771 { 2772 case 'm': 2773 db.names.push_back("operator%"); 2774 first += 2; 2775 break; 2776 case 'M': 2777 db.names.push_back("operator%="); 2778 first += 2; 2779 break; 2780 case 's': 2781 db.names.push_back("operator>>"); 2782 first += 2; 2783 break; 2784 case 'S': 2785 db.names.push_back("operator>>="); 2786 first += 2; 2787 break; 2788 } 2789 break; 2790 case 'v': 2791 if (std::isdigit(first[1])) 2792 { 2793 const char* t = parse_source_name(first+2, last, db); 2794 if (t != first+2) 2795 { 2796 if (db.names.empty()) 2797 return first; 2798 db.names.back().first.insert(0, "operator "); 2799 first = t; 2800 } 2801 } 2802 break; 2803 } 2804 } 2805 return first; 2806 } 2807 2808 const char* 2809 parse_integer_literal(const char* first, const char* last, const Db::String& lit, Db& db) 2810 { 2811 const char* t = parse_number(first, last); 2812 if (t != first && t != last && *t == 'E') 2813 { 2814 if (lit.size() > 3) 2815 db.names.push_back("(" + lit + ")"); 2816 else 2817 db.names.emplace_back(); 2818 if (*first == 'n') 2819 { 2820 db.names.back().first += '-'; 2821 ++first; 2822 } 2823 db.names.back().first.append(first, t); 2824 if (lit.size() <= 3) 2825 db.names.back().first += lit; 2826 first = t+1; 2827 } 2828 return first; 2829 } 2830 2831 // <expr-primary> ::= L <type> <value number> E # integer literal 2832 // ::= L <type> <value float> E # floating literal 2833 // ::= L <string type> E # string literal 2834 // ::= L <nullptr type> E # nullptr literal (i.e., "LDnE") 2835 // ::= L <type> <real-part float> _ <imag-part float> E # complex floating point literal (C 2000) 2836 // ::= L <mangled-name> E # external name 2837 2838 const char* 2839 parse_expr_primary(const char* first, const char* last, Db& db) 2840 { 2841 if (last - first >= 4 && *first == 'L') 2842 { 2843 switch (first[1]) 2844 { 2845 case 'w': 2846 { 2847 const char* t = parse_integer_literal(first+2, last, "wchar_t", db); 2848 if (t != first+2) 2849 first = t; 2850 } 2851 break; 2852 case 'b': 2853 if (first[3] == 'E') 2854 { 2855 switch (first[2]) 2856 { 2857 case '0': 2858 db.names.push_back("false"); 2859 first += 4; 2860 break; 2861 case '1': 2862 db.names.push_back("true"); 2863 first += 4; 2864 break; 2865 } 2866 } 2867 break; 2868 case 'c': 2869 { 2870 const char* t = parse_integer_literal(first+2, last, "char", db); 2871 if (t != first+2) 2872 first = t; 2873 } 2874 break; 2875 case 'a': 2876 { 2877 const char* t = parse_integer_literal(first+2, last, "signed char", db); 2878 if (t != first+2) 2879 first = t; 2880 } 2881 break; 2882 case 'h': 2883 { 2884 const char* t = parse_integer_literal(first+2, last, "unsigned char", db); 2885 if (t != first+2) 2886 first = t; 2887 } 2888 break; 2889 case 's': 2890 { 2891 const char* t = parse_integer_literal(first+2, last, "short", db); 2892 if (t != first+2) 2893 first = t; 2894 } 2895 break; 2896 case 't': 2897 { 2898 const char* t = parse_integer_literal(first+2, last, "unsigned short", db); 2899 if (t != first+2) 2900 first = t; 2901 } 2902 break; 2903 case 'i': 2904 { 2905 const char* t = parse_integer_literal(first+2, last, "", db); 2906 if (t != first+2) 2907 first = t; 2908 } 2909 break; 2910 case 'j': 2911 { 2912 const char* t = parse_integer_literal(first+2, last, "u", db); 2913 if (t != first+2) 2914 first = t; 2915 } 2916 break; 2917 case 'l': 2918 { 2919 const char* t = parse_integer_literal(first+2, last, "l", db); 2920 if (t != first+2) 2921 first = t; 2922 } 2923 break; 2924 case 'm': 2925 { 2926 const char* t = parse_integer_literal(first+2, last, "ul", db); 2927 if (t != first+2) 2928 first = t; 2929 } 2930 break; 2931 case 'x': 2932 { 2933 const char* t = parse_integer_literal(first+2, last, "ll", db); 2934 if (t != first+2) 2935 first = t; 2936 } 2937 break; 2938 case 'y': 2939 { 2940 const char* t = parse_integer_literal(first+2, last, "ull", db); 2941 if (t != first+2) 2942 first = t; 2943 } 2944 break; 2945 case 'n': 2946 { 2947 const char* t = parse_integer_literal(first+2, last, "__int128", db); 2948 if (t != first+2) 2949 first = t; 2950 } 2951 break; 2952 case 'o': 2953 { 2954 const char* t = parse_integer_literal(first+2, last, "unsigned __int128", db); 2955 if (t != first+2) 2956 first = t; 2957 } 2958 break; 2959 case 'f': 2960 { 2961 const char* t = parse_floating_number<float>(first+2, last, db); 2962 if (t != first+2) 2963 first = t; 2964 } 2965 break; 2966 case 'd': 2967 { 2968 const char* t = parse_floating_number<double>(first+2, last, db); 2969 if (t != first+2) 2970 first = t; 2971 } 2972 break; 2973 case 'e': 2974 { 2975 const char* t = parse_floating_number<long double>(first+2, last, db); 2976 if (t != first+2) 2977 first = t; 2978 } 2979 break; 2980 case '_': 2981 if (first[2] == 'Z') 2982 { 2983 const char* t = parse_encoding(first+3, last, db); 2984 if (t != first+3 && t != last && *t == 'E') 2985 first = t+1; 2986 } 2987 break; 2988 case 'T': 2989 // Invalid mangled name per 2990 // http://sourcerytools.com/pipermail/cxx-abi-dev/2011-August/002422.html 2991 break; 2992 default: 2993 { 2994 // might be named type 2995 const char* t = parse_type(first+1, last, db); 2996 if (t != first+1 && t != last) 2997 { 2998 if (*t != 'E') 2999 { 3000 const char* n = t; 3001 for (; n != last && isdigit(*n); ++n) 3002 ; 3003 if (n != t && n != last && *n == 'E') 3004 { 3005 if (db.names.empty()) 3006 return first; 3007 db.names.back() = "(" + db.names.back().move_full() + ")" + Db::String(t, n); 3008 first = n+1; 3009 break; 3010 } 3011 } 3012 else 3013 { 3014 first = t+1; 3015 break; 3016 } 3017 } 3018 } 3019 } 3020 } 3021 return first; 3022 } 3023 3024 template <class String> 3025 String 3026 base_name(String& s) 3027 { 3028 if (s.empty()) 3029 return s; 3030 if (s == "std::string") 3031 { 3032 s = "std::basic_string<char, std::char_traits<char>, std::allocator<char> >"; 3033 return "basic_string"; 3034 } 3035 if (s == "std::istream") 3036 { 3037 s = "std::basic_istream<char, std::char_traits<char> >"; 3038 return "basic_istream"; 3039 } 3040 if (s == "std::ostream") 3041 { 3042 s = "std::basic_ostream<char, std::char_traits<char> >"; 3043 return "basic_ostream"; 3044 } 3045 if (s == "std::iostream") 3046 { 3047 s = "std::basic_iostream<char, std::char_traits<char> >"; 3048 return "basic_iostream"; 3049 } 3050 const char* const pf = s.data(); 3051 const char* pe = pf + s.size(); 3052 if (pe[-1] == '>') 3053 { 3054 unsigned c = 1; 3055 while (true) 3056 { 3057 if (--pe == pf) 3058 return String(); 3059 if (pe[-1] == '<') 3060 { 3061 if (--c == 0) 3062 { 3063 --pe; 3064 break; 3065 } 3066 } 3067 else if (pe[-1] == '>') 3068 ++c; 3069 } 3070 } 3071 if (pe - pf <= 1) 3072 return String(); 3073 const char* p0 = pe - 1; 3074 for (; p0 != pf; --p0) 3075 { 3076 if (*p0 == ':') 3077 { 3078 ++p0; 3079 break; 3080 } 3081 if (!isalpha(*p0) && !isdigit(*p0) && *p0 != '_') 3082 { 3083 return String(); 3084 } 3085 } 3086 return String(p0, pe); 3087 } 3088 3089 // <ctor-dtor-name> ::= C1 # complete object constructor 3090 // ::= C2 # base object constructor 3091 // ::= C3 # complete object allocating constructor 3092 // extension ::= C5 # ? 3093 // ::= D0 # deleting destructor 3094 // ::= D1 # complete object destructor 3095 // ::= D2 # base object destructor 3096 // extension ::= D5 # ? 3097 3098 const char* 3099 parse_ctor_dtor_name(const char* first, const char* last, Db& db) 3100 { 3101 if (last-first >= 2 && !db.names.empty()) 3102 { 3103 switch (first[0]) 3104 { 3105 case 'C': 3106 switch (first[1]) 3107 { 3108 case '1': 3109 case '2': 3110 case '3': 3111 case '5': 3112 if (db.names.empty()) 3113 return first; 3114 db.names.push_back(base_name(db.names.back().first)); 3115 first += 2; 3116 db.parsed_ctor_dtor_cv = true; 3117 break; 3118 } 3119 break; 3120 case 'D': 3121 switch (first[1]) 3122 { 3123 case '0': 3124 case '1': 3125 case '2': 3126 case '5': 3127 if (db.names.empty()) 3128 return first; 3129 db.names.push_back("~" + base_name(db.names.back().first)); 3130 first += 2; 3131 db.parsed_ctor_dtor_cv = true; 3132 break; 3133 } 3134 break; 3135 } 3136 } 3137 return first; 3138 } 3139 3140 // <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ 3141 // ::= <closure-type-name> 3142 // 3143 // <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ 3144 // 3145 // <lambda-sig> ::= <parameter type>+ # Parameter types or "v" if the lambda has no parameters 3146 3147 const char* 3148 parse_unnamed_type_name(const char* first, const char* last, Db& db) 3149 { 3150 if (last - first > 2 && first[0] == 'U') 3151 { 3152 char type = first[1]; 3153 switch (type) 3154 { 3155 case 't': 3156 { 3157 db.names.push_back(Db::String("'unnamed")); 3158 const char* t0 = first+2; 3159 if (t0 == last) 3160 { 3161 db.names.pop_back(); 3162 return first; 3163 } 3164 if (std::isdigit(*t0)) 3165 { 3166 const char* t1 = t0 + 1; 3167 while (t1 != last && std::isdigit(*t1)) 3168 ++t1; 3169 db.names.back().first.append(t0, t1); 3170 t0 = t1; 3171 } 3172 db.names.back().first.push_back('\''); 3173 if (t0 == last || *t0 != '_') 3174 { 3175 db.names.pop_back(); 3176 return first; 3177 } 3178 first = t0 + 1; 3179 } 3180 break; 3181 case 'l': 3182 { 3183 size_t lambda_pos = db.names.size(); 3184 db.names.push_back(Db::String("'lambda'(")); 3185 const char* t0 = first+2; 3186 if (first[2] == 'v') 3187 { 3188 db.names.back().first += ')'; 3189 ++t0; 3190 } 3191 else 3192 { 3193 bool is_first_it = true; 3194 while (true) 3195 { 3196 long k0 = static_cast<long>(db.names.size()); 3197 const char* t1 = parse_type(t0, last, db); 3198 long k1 = static_cast<long>(db.names.size()); 3199 if (t1 == t0) 3200 break; 3201 if (k0 >= k1) 3202 return first; 3203 // If the call to parse_type above found a pack expansion 3204 // substitution, then multiple names could have been 3205 // inserted into the name table. Walk through the names, 3206 // appending each onto the lambda's parameter list. 3207 std::for_each(db.names.begin() + k0, db.names.begin() + k1, 3208 [&](Db::sub_type::value_type &pair) { 3209 if (pair.empty()) 3210 return; 3211 auto &lambda = db.names[lambda_pos].first; 3212 if (!is_first_it) 3213 lambda.append(", "); 3214 is_first_it = false; 3215 lambda.append(pair.move_full()); 3216 }); 3217 db.names.erase(db.names.begin() + k0, db.names.end()); 3218 t0 = t1; 3219 } 3220 if (is_first_it) 3221 { 3222 if (!db.names.empty()) 3223 db.names.pop_back(); 3224 return first; 3225 } 3226 if (db.names.empty() || db.names.size() - 1 != lambda_pos) 3227 return first; 3228 db.names.back().first.append(")"); 3229 } 3230 if (t0 == last || *t0 != 'E') 3231 { 3232 if (!db.names.empty()) 3233 db.names.pop_back(); 3234 return first; 3235 } 3236 ++t0; 3237 if (t0 == last) 3238 { 3239 if(!db.names.empty()) 3240 db.names.pop_back(); 3241 return first; 3242 } 3243 if (std::isdigit(*t0)) 3244 { 3245 const char* t1 = t0 + 1; 3246 while (t1 != last && std::isdigit(*t1)) 3247 ++t1; 3248 db.names.back().first.insert(db.names.back().first.begin()+7, t0, t1); 3249 t0 = t1; 3250 } 3251 if (t0 == last || *t0 != '_') 3252 { 3253 if(!db.names.empty()) 3254 db.names.pop_back(); 3255 return first; 3256 } 3257 first = t0 + 1; 3258 } 3259 break; 3260 } 3261 } 3262 return first; 3263 } 3264 3265 // <unqualified-name> ::= <operator-name> 3266 // ::= <ctor-dtor-name> 3267 // ::= <source-name> 3268 // ::= <unnamed-type-name> 3269 3270 const char* 3271 parse_unqualified_name(const char* first, const char* last, Db& db) 3272 { 3273 if (first != last) 3274 { 3275 const char* t; 3276 switch (*first) 3277 { 3278 case 'C': 3279 case 'D': 3280 t = parse_ctor_dtor_name(first, last, db); 3281 if (t != first) 3282 first = t; 3283 break; 3284 case 'U': 3285 t = parse_unnamed_type_name(first, last, db); 3286 if (t != first) 3287 first = t; 3288 break; 3289 case '1': 3290 case '2': 3291 case '3': 3292 case '4': 3293 case '5': 3294 case '6': 3295 case '7': 3296 case '8': 3297 case '9': 3298 t = parse_source_name(first, last, db); 3299 if (t != first) 3300 first = t; 3301 break; 3302 default: 3303 t = parse_operator_name(first, last, db); 3304 if (t != first) 3305 first = t; 3306 break; 3307 }; 3308 } 3309 return first; 3310 } 3311 3312 // <unscoped-name> ::= <unqualified-name> 3313 // ::= St <unqualified-name> # ::std:: 3314 // extension ::= StL<unqualified-name> 3315 3316 const char* 3317 parse_unscoped_name(const char* first, const char* last, Db& db) 3318 { 3319 if (last - first >= 2) 3320 { 3321 const char* t0 = first; 3322 bool St = false; 3323 if (first[0] == 'S' && first[1] == 't') 3324 { 3325 t0 += 2; 3326 St = true; 3327 if (t0 != last && *t0 == 'L') 3328 ++t0; 3329 } 3330 const char* t1 = parse_unqualified_name(t0, last, db); 3331 if (t1 != t0) 3332 { 3333 if (St) 3334 { 3335 if (db.names.empty()) 3336 return first; 3337 db.names.back().first.insert(0, "std::"); 3338 } 3339 first = t1; 3340 } 3341 } 3342 return first; 3343 } 3344 3345 // at <type> # alignof (a type) 3346 3347 const char* 3348 parse_alignof_type(const char* first, const char* last, Db& db) 3349 { 3350 if (last - first >= 3 && first[0] == 'a' && first[1] == 't') 3351 { 3352 const char* t = parse_type(first+2, last, db); 3353 if (t != first+2) 3354 { 3355 if (db.names.empty()) 3356 return first; 3357 db.names.back().first = "alignof (" + db.names.back().move_full() + ")"; 3358 first = t; 3359 } 3360 } 3361 return first; 3362 } 3363 3364 // az <expression> # alignof (a expression) 3365 3366 const char* 3367 parse_alignof_expr(const char* first, const char* last, Db& db) 3368 { 3369 if (last - first >= 3 && first[0] == 'a' && first[1] == 'z') 3370 { 3371 const char* t = parse_expression(first+2, last, db); 3372 if (t != first+2) 3373 { 3374 if (db.names.empty()) 3375 return first; 3376 db.names.back().first = "alignof (" + db.names.back().move_full() + ")"; 3377 first = t; 3378 } 3379 } 3380 return first; 3381 } 3382 3383 const char* 3384 parse_noexcept_expression(const char* first, const char* last, Db& db) 3385 { 3386 const char* t1 = parse_expression(first, last, db); 3387 if (t1 != first) 3388 { 3389 if (db.names.empty()) 3390 return first; 3391 db.names.back().first = "noexcept (" + db.names.back().move_full() + ")"; 3392 first = t1; 3393 } 3394 return first; 3395 } 3396 3397 const char* 3398 parse_prefix_expression(const char* first, const char* last, const Db::String& op, Db& db) 3399 { 3400 const char* t1 = parse_expression(first, last, db); 3401 if (t1 != first) 3402 { 3403 if (db.names.empty()) 3404 return first; 3405 db.names.back().first = op + "(" + db.names.back().move_full() + ")"; 3406 first = t1; 3407 } 3408 return first; 3409 } 3410 3411 const char* 3412 parse_binary_expression(const char* first, const char* last, const Db::String& op, Db& db) 3413 { 3414 const char* t1 = parse_expression(first, last, db); 3415 if (t1 != first) 3416 { 3417 const char* t2 = parse_expression(t1, last, db); 3418 if (t2 != t1) 3419 { 3420 if (db.names.size() < 2) 3421 return first; 3422 auto op2 = db.names.back().move_full(); 3423 db.names.pop_back(); 3424 auto op1 = db.names.back().move_full(); 3425 auto& nm = db.names.back().first; 3426 nm.clear(); 3427 if (op == ">") 3428 nm += '('; 3429 nm += "(" + op1 + ") " + op + " (" + op2 + ")"; 3430 if (op == ">") 3431 nm += ')'; 3432 first = t2; 3433 } 3434 else if(!db.names.empty()) 3435 db.names.pop_back(); 3436 } 3437 return first; 3438 } 3439 3440 // <expression> ::= <unary operator-name> <expression> 3441 // ::= <binary operator-name> <expression> <expression> 3442 // ::= <ternary operator-name> <expression> <expression> <expression> 3443 // ::= cl <expression>+ E # call 3444 // ::= cv <type> <expression> # conversion with one argument 3445 // ::= cv <type> _ <expression>* E # conversion with a different number of arguments 3446 // ::= [gs] nw <expression>* _ <type> E # new (expr-list) type 3447 // ::= [gs] nw <expression>* _ <type> <initializer> # new (expr-list) type (init) 3448 // ::= [gs] na <expression>* _ <type> E # new[] (expr-list) type 3449 // ::= [gs] na <expression>* _ <type> <initializer> # new[] (expr-list) type (init) 3450 // ::= [gs] dl <expression> # delete expression 3451 // ::= [gs] da <expression> # delete[] expression 3452 // ::= pp_ <expression> # prefix ++ 3453 // ::= mm_ <expression> # prefix -- 3454 // ::= ti <type> # typeid (type) 3455 // ::= te <expression> # typeid (expression) 3456 // ::= dc <type> <expression> # dynamic_cast<type> (expression) 3457 // ::= sc <type> <expression> # static_cast<type> (expression) 3458 // ::= cc <type> <expression> # const_cast<type> (expression) 3459 // ::= rc <type> <expression> # reinterpret_cast<type> (expression) 3460 // ::= st <type> # sizeof (a type) 3461 // ::= sz <expression> # sizeof (an expression) 3462 // ::= at <type> # alignof (a type) 3463 // ::= az <expression> # alignof (an expression) 3464 // ::= nx <expression> # noexcept (expression) 3465 // ::= <template-param> 3466 // ::= <function-param> 3467 // ::= dt <expression> <unresolved-name> # expr.name 3468 // ::= pt <expression> <unresolved-name> # expr->name 3469 // ::= ds <expression> <expression> # expr.*expr 3470 // ::= sZ <template-param> # size of a parameter pack 3471 // ::= sZ <function-param> # size of a function parameter pack 3472 // ::= sp <expression> # pack expansion 3473 // ::= tw <expression> # throw expression 3474 // ::= tr # throw with no operand (rethrow) 3475 // ::= <unresolved-name> # f(p), N::f(p), ::f(p), 3476 // # freestanding dependent name (e.g., T::x), 3477 // # objectless nonstatic member reference 3478 // ::= <expr-primary> 3479 3480 const char* 3481 parse_expression(const char* first, const char* last, Db& db) 3482 { 3483 if (last - first >= 2) 3484 { 3485 const char* t = first; 3486 bool parsed_gs = false; 3487 if (last - first >= 4 && t[0] == 'g' && t[1] == 's') 3488 { 3489 t += 2; 3490 parsed_gs = true; 3491 } 3492 switch (*t) 3493 { 3494 case 'L': 3495 first = parse_expr_primary(first, last, db); 3496 break; 3497 case 'T': 3498 first = parse_template_param(first, last, db); 3499 break; 3500 case 'f': 3501 first = parse_function_param(first, last, db); 3502 break; 3503 case 'a': 3504 switch (t[1]) 3505 { 3506 case 'a': 3507 t = parse_binary_expression(first+2, last, "&&", db); 3508 if (t != first+2) 3509 first = t; 3510 break; 3511 case 'd': 3512 t = parse_prefix_expression(first+2, last, "&", db); 3513 if (t != first+2) 3514 first = t; 3515 break; 3516 case 'n': 3517 t = parse_binary_expression(first+2, last, "&", db); 3518 if (t != first+2) 3519 first = t; 3520 break; 3521 case 'N': 3522 t = parse_binary_expression(first+2, last, "&=", db); 3523 if (t != first+2) 3524 first = t; 3525 break; 3526 case 'S': 3527 t = parse_binary_expression(first+2, last, "=", db); 3528 if (t != first+2) 3529 first = t; 3530 break; 3531 case 't': 3532 first = parse_alignof_type(first, last, db); 3533 break; 3534 case 'z': 3535 first = parse_alignof_expr(first, last, db); 3536 break; 3537 } 3538 break; 3539 case 'c': 3540 switch (t[1]) 3541 { 3542 case 'c': 3543 first = parse_const_cast_expr(first, last, db); 3544 break; 3545 case 'l': 3546 first = parse_call_expr(first, last, db); 3547 break; 3548 case 'm': 3549 t = parse_binary_expression(first+2, last, ",", db); 3550 if (t != first+2) 3551 first = t; 3552 break; 3553 case 'o': 3554 t = parse_prefix_expression(first+2, last, "~", db); 3555 if (t != first+2) 3556 first = t; 3557 break; 3558 case 'v': 3559 first = parse_conversion_expr(first, last, db); 3560 break; 3561 } 3562 break; 3563 case 'd': 3564 switch (t[1]) 3565 { 3566 case 'a': 3567 { 3568 const char* t1 = parse_expression(t+2, last, db); 3569 if (t1 != t+2) 3570 { 3571 if (db.names.empty()) 3572 return first; 3573 db.names.back().first = (parsed_gs ? Db::String("::") : Db::String()) + 3574 "delete[] " + db.names.back().move_full(); 3575 first = t1; 3576 } 3577 } 3578 break; 3579 case 'c': 3580 first = parse_dynamic_cast_expr(first, last, db); 3581 break; 3582 case 'e': 3583 t = parse_prefix_expression(first+2, last, "*", db); 3584 if (t != first+2) 3585 first = t; 3586 break; 3587 case 'l': 3588 { 3589 const char* t1 = parse_expression(t+2, last, db); 3590 if (t1 != t+2) 3591 { 3592 if (db.names.empty()) 3593 return first; 3594 db.names.back().first = (parsed_gs ? Db::String("::") : Db::String()) + 3595 "delete " + db.names.back().move_full(); 3596 first = t1; 3597 } 3598 } 3599 break; 3600 case 'n': 3601 return parse_unresolved_name(first, last, db); 3602 case 's': 3603 first = parse_dot_star_expr(first, last, db); 3604 break; 3605 case 't': 3606 first = parse_dot_expr(first, last, db); 3607 break; 3608 case 'v': 3609 t = parse_binary_expression(first+2, last, "/", db); 3610 if (t != first+2) 3611 first = t; 3612 break; 3613 case 'V': 3614 t = parse_binary_expression(first+2, last, "/=", db); 3615 if (t != first+2) 3616 first = t; 3617 break; 3618 } 3619 break; 3620 case 'e': 3621 switch (t[1]) 3622 { 3623 case 'o': 3624 t = parse_binary_expression(first+2, last, "^", db); 3625 if (t != first+2) 3626 first = t; 3627 break; 3628 case 'O': 3629 t = parse_binary_expression(first+2, last, "^=", db); 3630 if (t != first+2) 3631 first = t; 3632 break; 3633 case 'q': 3634 t = parse_binary_expression(first+2, last, "==", db); 3635 if (t != first+2) 3636 first = t; 3637 break; 3638 } 3639 break; 3640 case 'g': 3641 switch (t[1]) 3642 { 3643 case 'e': 3644 t = parse_binary_expression(first+2, last, ">=", db); 3645 if (t != first+2) 3646 first = t; 3647 break; 3648 case 't': 3649 t = parse_binary_expression(first+2, last, ">", db); 3650 if (t != first+2) 3651 first = t; 3652 break; 3653 } 3654 break; 3655 case 'i': 3656 if (t[1] == 'x') 3657 { 3658 const char* t1 = parse_expression(first+2, last, db); 3659 if (t1 != first+2) 3660 { 3661 const char* t2 = parse_expression(t1, last, db); 3662 if (t2 != t1) 3663 { 3664 if (db.names.size() < 2) 3665 return first; 3666 auto op2 = db.names.back().move_full(); 3667 db.names.pop_back(); 3668 auto op1 = db.names.back().move_full(); 3669 db.names.back() = "(" + op1 + ")[" + op2 + "]"; 3670 first = t2; 3671 } 3672 else if (!db.names.empty()) 3673 db.names.pop_back(); 3674 } 3675 } 3676 break; 3677 case 'l': 3678 switch (t[1]) 3679 { 3680 case 'e': 3681 t = parse_binary_expression(first+2, last, "<=", db); 3682 if (t != first+2) 3683 first = t; 3684 break; 3685 case 's': 3686 t = parse_binary_expression(first+2, last, "<<", db); 3687 if (t != first+2) 3688 first = t; 3689 break; 3690 case 'S': 3691 t = parse_binary_expression(first+2, last, "<<=", db); 3692 if (t != first+2) 3693 first = t; 3694 break; 3695 case 't': 3696 t = parse_binary_expression(first+2, last, "<", db); 3697 if (t != first+2) 3698 first = t; 3699 break; 3700 } 3701 break; 3702 case 'm': 3703 switch (t[1]) 3704 { 3705 case 'i': 3706 t = parse_binary_expression(first+2, last, "-", db); 3707 if (t != first+2) 3708 first = t; 3709 break; 3710 case 'I': 3711 t = parse_binary_expression(first+2, last, "-=", db); 3712 if (t != first+2) 3713 first = t; 3714 break; 3715 case 'l': 3716 t = parse_binary_expression(first+2, last, "*", db); 3717 if (t != first+2) 3718 first = t; 3719 break; 3720 case 'L': 3721 t = parse_binary_expression(first+2, last, "*=", db); 3722 if (t != first+2) 3723 first = t; 3724 break; 3725 case 'm': 3726 if (first+2 != last && first[2] == '_') 3727 { 3728 t = parse_prefix_expression(first+3, last, "--", db); 3729 if (t != first+3) 3730 first = t; 3731 } 3732 else 3733 { 3734 const char* t1 = parse_expression(first+2, last, db); 3735 if (t1 != first+2) 3736 { 3737 if (db.names.empty()) 3738 return first; 3739 db.names.back() = "(" + db.names.back().move_full() + ")--"; 3740 first = t1; 3741 } 3742 } 3743 break; 3744 } 3745 break; 3746 case 'n': 3747 switch (t[1]) 3748 { 3749 case 'a': 3750 case 'w': 3751 first = parse_new_expr(first, last, db); 3752 break; 3753 case 'e': 3754 t = parse_binary_expression(first+2, last, "!=", db); 3755 if (t != first+2) 3756 first = t; 3757 break; 3758 case 'g': 3759 t = parse_prefix_expression(first+2, last, "-", db); 3760 if (t != first+2) 3761 first = t; 3762 break; 3763 case 't': 3764 t = parse_prefix_expression(first+2, last, "!", db); 3765 if (t != first+2) 3766 first = t; 3767 break; 3768 case 'x': 3769 t = parse_noexcept_expression(first+2, last, db); 3770 if (t != first+2) 3771 first = t; 3772 break; 3773 } 3774 break; 3775 case 'o': 3776 switch (t[1]) 3777 { 3778 case 'n': 3779 return parse_unresolved_name(first, last, db); 3780 case 'o': 3781 t = parse_binary_expression(first+2, last, "||", db); 3782 if (t != first+2) 3783 first = t; 3784 break; 3785 case 'r': 3786 t = parse_binary_expression(first+2, last, "|", db); 3787 if (t != first+2) 3788 first = t; 3789 break; 3790 case 'R': 3791 t = parse_binary_expression(first+2, last, "|=", db); 3792 if (t != first+2) 3793 first = t; 3794 break; 3795 } 3796 break; 3797 case 'p': 3798 switch (t[1]) 3799 { 3800 case 'm': 3801 t = parse_binary_expression(first+2, last, "->*", db); 3802 if (t != first+2) 3803 first = t; 3804 break; 3805 case 'l': 3806 t = parse_binary_expression(first+2, last, "+", db); 3807 if (t != first+2) 3808 first = t; 3809 break; 3810 case 'L': 3811 t = parse_binary_expression(first+2, last, "+=", db); 3812 if (t != first+2) 3813 first = t; 3814 break; 3815 case 'p': 3816 if (first+2 != last && first[2] == '_') 3817 { 3818 t = parse_prefix_expression(first+3, last, "++", db); 3819 if (t != first+3) 3820 first = t; 3821 } 3822 else 3823 { 3824 const char* t1 = parse_expression(first+2, last, db); 3825 if (t1 != first+2) 3826 { 3827 if (db.names.empty()) 3828 return first; 3829 db.names.back() = "(" + db.names.back().move_full() + ")++"; 3830 first = t1; 3831 } 3832 } 3833 break; 3834 case 's': 3835 t = parse_prefix_expression(first+2, last, "+", db); 3836 if (t != first+2) 3837 first = t; 3838 break; 3839 case 't': 3840 first = parse_arrow_expr(first, last, db); 3841 break; 3842 } 3843 break; 3844 case 'q': 3845 if (t[1] == 'u') 3846 { 3847 const char* t1 = parse_expression(first+2, last, db); 3848 if (t1 != first+2) 3849 { 3850 const char* t2 = parse_expression(t1, last, db); 3851 if (t2 != t1) 3852 { 3853 const char* t3 = parse_expression(t2, last, db); 3854 if (t3 != t2) 3855 { 3856 if (db.names.size() < 3) 3857 return first; 3858 auto op3 = db.names.back().move_full(); 3859 db.names.pop_back(); 3860 auto op2 = db.names.back().move_full(); 3861 db.names.pop_back(); 3862 auto op1 = db.names.back().move_full(); 3863 db.names.back() = "(" + op1 + ") ? (" + op2 + ") : (" + op3 + ")"; 3864 first = t3; 3865 } 3866 else 3867 { 3868 if (db.names.size() < 2) 3869 return first; 3870 db.names.pop_back(); 3871 db.names.pop_back(); 3872 } 3873 } 3874 else if (!db.names.empty()) 3875 db.names.pop_back(); 3876 } 3877 } 3878 break; 3879 case 'r': 3880 switch (t[1]) 3881 { 3882 case 'c': 3883 first = parse_reinterpret_cast_expr(first, last, db); 3884 break; 3885 case 'm': 3886 t = parse_binary_expression(first+2, last, "%", db); 3887 if (t != first+2) 3888 first = t; 3889 break; 3890 case 'M': 3891 t = parse_binary_expression(first+2, last, "%=", db); 3892 if (t != first+2) 3893 first = t; 3894 break; 3895 case 's': 3896 t = parse_binary_expression(first+2, last, ">>", db); 3897 if (t != first+2) 3898 first = t; 3899 break; 3900 case 'S': 3901 t = parse_binary_expression(first+2, last, ">>=", db); 3902 if (t != first+2) 3903 first = t; 3904 break; 3905 } 3906 break; 3907 case 's': 3908 switch (t[1]) 3909 { 3910 case 'c': 3911 first = parse_static_cast_expr(first, last, db); 3912 break; 3913 case 'p': 3914 first = parse_pack_expansion(first, last, db); 3915 break; 3916 case 'r': 3917 return parse_unresolved_name(first, last, db); 3918 case 't': 3919 first = parse_sizeof_type_expr(first, last, db); 3920 break; 3921 case 'z': 3922 first = parse_sizeof_expr_expr(first, last, db); 3923 break; 3924 case 'Z': 3925 if (last - t >= 3) 3926 { 3927 switch (t[2]) 3928 { 3929 case 'T': 3930 first = parse_sizeof_param_pack_expr(first, last, db); 3931 break; 3932 case 'f': 3933 first = parse_sizeof_function_param_pack_expr(first, last, db); 3934 break; 3935 } 3936 } 3937 break; 3938 } 3939 break; 3940 case 't': 3941 switch (t[1]) 3942 { 3943 case 'e': 3944 case 'i': 3945 first = parse_typeid_expr(first, last, db); 3946 break; 3947 case 'r': 3948 db.names.push_back("throw"); 3949 first += 2; 3950 break; 3951 case 'w': 3952 first = parse_throw_expr(first, last, db); 3953 break; 3954 } 3955 break; 3956 case '1': 3957 case '2': 3958 case '3': 3959 case '4': 3960 case '5': 3961 case '6': 3962 case '7': 3963 case '8': 3964 case '9': 3965 return parse_unresolved_name(first, last, db); 3966 } 3967 } 3968 return first; 3969 } 3970 3971 // <template-arg> ::= <type> # type or template 3972 // ::= X <expression> E # expression 3973 // ::= <expr-primary> # simple expressions 3974 // ::= J <template-arg>* E # argument pack 3975 // ::= LZ <encoding> E # extension 3976 3977 const char* 3978 parse_template_arg(const char* first, const char* last, Db& db) 3979 { 3980 if (first != last) 3981 { 3982 const char* t; 3983 switch (*first) 3984 { 3985 case 'X': 3986 t = parse_expression(first+1, last, db); 3987 if (t != first+1) 3988 { 3989 if (t != last && *t == 'E') 3990 first = t+1; 3991 } 3992 break; 3993 case 'J': 3994 t = first+1; 3995 if (t == last) 3996 return first; 3997 while (*t != 'E') 3998 { 3999 const char* t1 = parse_template_arg(t, last, db); 4000 if (t1 == t) 4001 return first; 4002 t = t1; 4003 } 4004 first = t+1; 4005 break; 4006 case 'L': 4007 // <expr-primary> or LZ <encoding> E 4008 if (first+1 != last && first[1] == 'Z') 4009 { 4010 t = parse_encoding(first+2, last, db); 4011 if (t != first+2 && t != last && *t == 'E') 4012 first = t+1; 4013 } 4014 else 4015 first = parse_expr_primary(first, last, db); 4016 break; 4017 default: 4018 // <type> 4019 first = parse_type(first, last, db); 4020 break; 4021 } 4022 } 4023 return first; 4024 } 4025 4026 // <template-args> ::= I <template-arg>* E 4027 // extension, the abi says <template-arg>+ 4028 4029 const char* 4030 parse_template_args(const char* first, const char* last, Db& db) 4031 { 4032 if (last - first >= 2 && *first == 'I') 4033 { 4034 if (db.tag_templates) 4035 db.template_param.back().clear(); 4036 const char* t = first+1; 4037 Db::String args("<"); 4038 while (*t != 'E') 4039 { 4040 if (db.tag_templates) 4041 db.template_param.emplace_back(db.names.get_allocator()); 4042 size_t k0 = db.names.size(); 4043 const char* t1 = parse_template_arg(t, last, db); 4044 size_t k1 = db.names.size(); 4045 if (db.tag_templates) 4046 db.template_param.pop_back(); 4047 if (t1 == t || t1 == last) 4048 return first; 4049 if (db.tag_templates) 4050 { 4051 db.template_param.back().emplace_back(db.names.get_allocator()); 4052 for (size_t k = k0; k < k1; ++k) 4053 db.template_param.back().back().push_back(db.names[k]); 4054 } 4055 for (size_t k = k0; k < k1; ++k) 4056 { 4057 if (args.size() > 1) 4058 args += ", "; 4059 args += db.names[k].move_full(); 4060 } 4061 for (; k1 > k0; --k1) 4062 if (!db.names.empty()) 4063 db.names.pop_back(); 4064 t = t1; 4065 } 4066 first = t + 1; 4067 if (args.back() != '>') 4068 args += ">"; 4069 else 4070 args += " >"; 4071 db.names.push_back(std::move(args)); 4072 4073 } 4074 return first; 4075 } 4076 4077 // <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E 4078 // ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E 4079 // 4080 // <prefix> ::= <prefix> <unqualified-name> 4081 // ::= <template-prefix> <template-args> 4082 // ::= <template-param> 4083 // ::= <decltype> 4084 // ::= # empty 4085 // ::= <substitution> 4086 // ::= <prefix> <data-member-prefix> 4087 // extension ::= L 4088 // 4089 // <template-prefix> ::= <prefix> <template unqualified-name> 4090 // ::= <template-param> 4091 // ::= <substitution> 4092 4093 const char* 4094 parse_nested_name(const char* first, const char* last, Db& db, 4095 bool* ends_with_template_args) 4096 { 4097 if (first != last && *first == 'N') 4098 { 4099 unsigned cv; 4100 const char* t0 = parse_cv_qualifiers(first+1, last, cv); 4101 if (t0 == last) 4102 return first; 4103 db.ref = 0; 4104 if (*t0 == 'R') 4105 { 4106 db.ref = 1; 4107 ++t0; 4108 } 4109 else if (*t0 == 'O') 4110 { 4111 db.ref = 2; 4112 ++t0; 4113 } 4114 db.names.emplace_back(); 4115 if (last - t0 >= 2 && t0[0] == 'S' && t0[1] == 't') 4116 { 4117 t0 += 2; 4118 db.names.back().first = "std"; 4119 } 4120 if (t0 == last) 4121 { 4122 db.names.pop_back(); 4123 return first; 4124 } 4125 bool pop_subs = false; 4126 bool component_ends_with_template_args = false; 4127 while (*t0 != 'E') 4128 { 4129 component_ends_with_template_args = false; 4130 const char* t1; 4131 switch (*t0) 4132 { 4133 case 'S': 4134 if (t0 + 1 != last && t0[1] == 't') 4135 goto do_parse_unqualified_name; 4136 t1 = parse_substitution(t0, last, db); 4137 if (t1 != t0 && t1 != last) 4138 { 4139 auto name = db.names.back().move_full(); 4140 db.names.pop_back(); 4141 if (db.names.empty()) 4142 return first; 4143 if (!db.names.back().first.empty()) 4144 { 4145 db.names.back().first += "::" + name; 4146 db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator())); 4147 } 4148 else 4149 db.names.back().first = name; 4150 pop_subs = true; 4151 t0 = t1; 4152 } 4153 else 4154 return first; 4155 break; 4156 case 'T': 4157 t1 = parse_template_param(t0, last, db); 4158 if (t1 != t0 && t1 != last) 4159 { 4160 auto name = db.names.back().move_full(); 4161 db.names.pop_back(); 4162 if (db.names.empty()) 4163 return first; 4164 if (!db.names.back().first.empty()) 4165 db.names.back().first += "::" + name; 4166 else 4167 db.names.back().first = name; 4168 db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator())); 4169 pop_subs = true; 4170 t0 = t1; 4171 } 4172 else 4173 return first; 4174 break; 4175 case 'D': 4176 if (t0 + 1 != last && t0[1] != 't' && t0[1] != 'T') 4177 goto do_parse_unqualified_name; 4178 t1 = parse_decltype(t0, last, db); 4179 if (t1 != t0 && t1 != last) 4180 { 4181 auto name = db.names.back().move_full(); 4182 db.names.pop_back(); 4183 if (db.names.empty()) 4184 return first; 4185 if (!db.names.back().first.empty()) 4186 db.names.back().first += "::" + name; 4187 else 4188 db.names.back().first = name; 4189 db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator())); 4190 pop_subs = true; 4191 t0 = t1; 4192 } 4193 else 4194 return first; 4195 break; 4196 case 'I': 4197 t1 = parse_template_args(t0, last, db); 4198 if (t1 != t0 && t1 != last) 4199 { 4200 auto name = db.names.back().move_full(); 4201 db.names.pop_back(); 4202 if (db.names.empty()) 4203 return first; 4204 db.names.back().first += name; 4205 db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator())); 4206 t0 = t1; 4207 component_ends_with_template_args = true; 4208 } 4209 else 4210 return first; 4211 break; 4212 case 'L': 4213 if (++t0 == last) 4214 return first; 4215 break; 4216 default: 4217 do_parse_unqualified_name: 4218 t1 = parse_unqualified_name(t0, last, db); 4219 if (t1 != t0 && t1 != last) 4220 { 4221 auto name = db.names.back().move_full(); 4222 db.names.pop_back(); 4223 if (db.names.empty()) 4224 return first; 4225 if (!db.names.back().first.empty()) 4226 db.names.back().first += "::" + name; 4227 else 4228 db.names.back().first = name; 4229 db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator())); 4230 pop_subs = true; 4231 t0 = t1; 4232 } 4233 else 4234 return first; 4235 } 4236 } 4237 first = t0 + 1; 4238 db.cv = cv; 4239 if (pop_subs && !db.subs.empty()) 4240 db.subs.pop_back(); 4241 if (ends_with_template_args) 4242 *ends_with_template_args = component_ends_with_template_args; 4243 } 4244 return first; 4245 } 4246 4247 // <discriminator> := _ <non-negative number> # when number < 10 4248 // := __ <non-negative number> _ # when number >= 10 4249 // extension := decimal-digit+ # at the end of string 4250 4251 const char* 4252 parse_discriminator(const char* first, const char* last) 4253 { 4254 // parse but ignore discriminator 4255 if (first != last) 4256 { 4257 if (*first == '_') 4258 { 4259 const char* t1 = first+1; 4260 if (t1 != last) 4261 { 4262 if (std::isdigit(*t1)) 4263 first = t1+1; 4264 else if (*t1 == '_') 4265 { 4266 for (++t1; t1 != last && std::isdigit(*t1); ++t1) 4267 ; 4268 if (t1 != last && *t1 == '_') 4269 first = t1 + 1; 4270 } 4271 } 4272 } 4273 else if (std::isdigit(*first)) 4274 { 4275 const char* t1 = first+1; 4276 for (; t1 != last && std::isdigit(*t1); ++t1) 4277 ; 4278 if (t1 == last) 4279 first = last; 4280 } 4281 } 4282 return first; 4283 } 4284 4285 // <local-name> := Z <function encoding> E <entity name> [<discriminator>] 4286 // := Z <function encoding> E s [<discriminator>] 4287 // := Z <function encoding> Ed [ <parameter number> ] _ <entity name> 4288 4289 const char* 4290 parse_local_name(const char* first, const char* last, Db& db, 4291 bool* ends_with_template_args) 4292 { 4293 if (first != last && *first == 'Z') 4294 { 4295 const char* t = parse_encoding(first+1, last, db); 4296 if (t != first+1 && t != last && *t == 'E' && ++t != last) 4297 { 4298 switch (*t) 4299 { 4300 case 's': 4301 first = parse_discriminator(t+1, last); 4302 if (db.names.empty()) 4303 return first; 4304 db.names.back().first.append("::string literal"); 4305 break; 4306 case 'd': 4307 if (++t != last) 4308 { 4309 const char* t1 = parse_number(t, last); 4310 if (t1 != last && *t1 == '_') 4311 { 4312 t = t1 + 1; 4313 t1 = parse_name(t, last, db, 4314 ends_with_template_args); 4315 if (t1 != t) 4316 { 4317 if (db.names.size() < 2) 4318 return first; 4319 auto name = db.names.back().move_full(); 4320 db.names.pop_back(); 4321 if (db.names.empty()) 4322 return first; 4323 db.names.back().first.append("::"); 4324 db.names.back().first.append(name); 4325 first = t1; 4326 } 4327 else if (!db.names.empty()) 4328 db.names.pop_back(); 4329 } 4330 } 4331 break; 4332 default: 4333 { 4334 const char* t1 = parse_name(t, last, db, 4335 ends_with_template_args); 4336 if (t1 != t) 4337 { 4338 // parse but ignore discriminator 4339 first = parse_discriminator(t1, last); 4340 if (db.names.size() < 2) 4341 return first; 4342 auto name = db.names.back().move_full(); 4343 db.names.pop_back(); 4344 if (db.names.empty()) 4345 return first; 4346 db.names.back().first.append("::"); 4347 db.names.back().first.append(name); 4348 } 4349 else if (!db.names.empty()) 4350 db.names.pop_back(); 4351 } 4352 break; 4353 } 4354 } 4355 } 4356 return first; 4357 } 4358 4359 // <name> ::= <nested-name> // N 4360 // ::= <local-name> # See Scope Encoding below // Z 4361 // ::= <unscoped-template-name> <template-args> 4362 // ::= <unscoped-name> 4363 4364 // <unscoped-template-name> ::= <unscoped-name> 4365 // ::= <substitution> 4366 4367 const char* 4368 parse_name(const char* first, const char* last, Db& db, 4369 bool* ends_with_template_args) 4370 { 4371 if (last - first >= 2) 4372 { 4373 const char* t0 = first; 4374 // extension: ignore L here 4375 if (*t0 == 'L') 4376 ++t0; 4377 switch (*t0) 4378 { 4379 case 'N': 4380 { 4381 const char* t1 = parse_nested_name(t0, last, db, 4382 ends_with_template_args); 4383 if (t1 != t0) 4384 first = t1; 4385 break; 4386 } 4387 case 'Z': 4388 { 4389 const char* t1 = parse_local_name(t0, last, db, 4390 ends_with_template_args); 4391 if (t1 != t0) 4392 first = t1; 4393 break; 4394 } 4395 default: 4396 { 4397 const char* t1 = parse_unscoped_name(t0, last, db); 4398 if (t1 != t0) 4399 { 4400 if (t1 != last && *t1 == 'I') // <unscoped-template-name> <template-args> 4401 { 4402 if (db.names.empty()) 4403 return first; 4404 db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator())); 4405 t0 = t1; 4406 t1 = parse_template_args(t0, last, db); 4407 if (t1 != t0) 4408 { 4409 if (db.names.size() < 2) 4410 return first; 4411 auto tmp = db.names.back().move_full(); 4412 db.names.pop_back(); 4413 if (db.names.empty()) 4414 return first; 4415 db.names.back().first += tmp; 4416 first = t1; 4417 if (ends_with_template_args) 4418 *ends_with_template_args = true; 4419 } 4420 } 4421 else // <unscoped-name> 4422 first = t1; 4423 } 4424 else 4425 { // try <substitution> <template-args> 4426 t1 = parse_substitution(t0, last, db); 4427 if (t1 != t0 && t1 != last && *t1 == 'I') 4428 { 4429 t0 = t1; 4430 t1 = parse_template_args(t0, last, db); 4431 if (t1 != t0) 4432 { 4433 if (db.names.size() < 2) 4434 return first; 4435 auto tmp = db.names.back().move_full(); 4436 db.names.pop_back(); 4437 if (db.names.empty()) 4438 return first; 4439 db.names.back().first += tmp; 4440 first = t1; 4441 if (ends_with_template_args) 4442 *ends_with_template_args = true; 4443 } 4444 } 4445 } 4446 break; 4447 } 4448 } 4449 } 4450 return first; 4451 } 4452 4453 // <call-offset> ::= h <nv-offset> _ 4454 // ::= v <v-offset> _ 4455 // 4456 // <nv-offset> ::= <offset number> 4457 // # non-virtual base override 4458 // 4459 // <v-offset> ::= <offset number> _ <virtual offset number> 4460 // # virtual base override, with vcall offset 4461 4462 const char* 4463 parse_call_offset(const char* first, const char* last) 4464 { 4465 if (first != last) 4466 { 4467 switch (*first) 4468 { 4469 case 'h': 4470 { 4471 const char* t = parse_number(first + 1, last); 4472 if (t != first + 1 && t != last && *t == '_') 4473 first = t + 1; 4474 } 4475 break; 4476 case 'v': 4477 { 4478 const char* t = parse_number(first + 1, last); 4479 if (t != first + 1 && t != last && *t == '_') 4480 { 4481 const char* t2 = parse_number(++t, last); 4482 if (t2 != t && t2 != last && *t2 == '_') 4483 first = t2 + 1; 4484 } 4485 } 4486 break; 4487 } 4488 } 4489 return first; 4490 } 4491 4492 // <special-name> ::= TV <type> # virtual table 4493 // ::= TT <type> # VTT structure (construction vtable index) 4494 // ::= TI <type> # typeinfo structure 4495 // ::= TS <type> # typeinfo name (null-terminated byte string) 4496 // ::= Tc <call-offset> <call-offset> <base encoding> 4497 // # base is the nominal target function of thunk 4498 // # first call-offset is 'this' adjustment 4499 // # second call-offset is result adjustment 4500 // ::= T <call-offset> <base encoding> 4501 // # base is the nominal target function of thunk 4502 // ::= GV <object name> # Guard variable for one-time initialization 4503 // # No <type> 4504 // ::= TW <object name> # Thread-local wrapper 4505 // ::= TH <object name> # Thread-local initialization 4506 // extension ::= TC <first type> <number> _ <second type> # construction vtable for second-in-first 4507 // extension ::= GR <object name> # reference temporary for object 4508 4509 const char* 4510 parse_special_name(const char* first, const char* last, Db& db) 4511 { 4512 if (last - first > 2) 4513 { 4514 const char* t; 4515 switch (*first) 4516 { 4517 case 'T': 4518 switch (first[1]) 4519 { 4520 case 'V': 4521 // TV <type> # virtual table 4522 t = parse_type(first+2, last, db); 4523 if (t != first+2) 4524 { 4525 if (db.names.empty()) 4526 return first; 4527 db.names.back().first.insert(0, "vtable for "); 4528 first = t; 4529 } 4530 break; 4531 case 'T': 4532 // TT <type> # VTT structure (construction vtable index) 4533 t = parse_type(first+2, last, db); 4534 if (t != first+2) 4535 { 4536 if (db.names.empty()) 4537 return first; 4538 db.names.back().first.insert(0, "VTT for "); 4539 first = t; 4540 } 4541 break; 4542 case 'I': 4543 // TI <type> # typeinfo structure 4544 t = parse_type(first+2, last, db); 4545 if (t != first+2) 4546 { 4547 if (db.names.empty()) 4548 return first; 4549 db.names.back().first.insert(0, "typeinfo for "); 4550 first = t; 4551 } 4552 break; 4553 case 'S': 4554 // TS <type> # typeinfo name (null-terminated byte string) 4555 t = parse_type(first+2, last, db); 4556 if (t != first+2) 4557 { 4558 if (db.names.empty()) 4559 return first; 4560 db.names.back().first.insert(0, "typeinfo name for "); 4561 first = t; 4562 } 4563 break; 4564 case 'c': 4565 // Tc <call-offset> <call-offset> <base encoding> 4566 { 4567 const char* t0 = parse_call_offset(first+2, last); 4568 if (t0 == first+2) 4569 break; 4570 const char* t1 = parse_call_offset(t0, last); 4571 if (t1 == t0) 4572 break; 4573 t = parse_encoding(t1, last, db); 4574 if (t != t1) 4575 { 4576 if (db.names.empty()) 4577 return first; 4578 db.names.back().first.insert(0, "covariant return thunk to "); 4579 first = t; 4580 } 4581 } 4582 break; 4583 case 'C': 4584 // extension ::= TC <first type> <number> _ <second type> # construction vtable for second-in-first 4585 t = parse_type(first+2, last, db); 4586 if (t != first+2) 4587 { 4588 const char* t0 = parse_number(t, last); 4589 if (t0 != t && t0 != last && *t0 == '_') 4590 { 4591 const char* t1 = parse_type(++t0, last, db); 4592 if (t1 != t0) 4593 { 4594 if (db.names.size() < 2) 4595 return first; 4596 auto left = db.names.back().move_full(); 4597 db.names.pop_back(); 4598 if (db.names.empty()) 4599 return first; 4600 db.names.back().first = "construction vtable for " + 4601 std::move(left) + "-in-" + 4602 db.names.back().move_full(); 4603 first = t1; 4604 } 4605 } 4606 } 4607 break; 4608 case 'W': 4609 // TW <object name> # Thread-local wrapper 4610 t = parse_name(first + 2, last, db); 4611 if (t != first + 2) 4612 { 4613 if (db.names.empty()) 4614 return first; 4615 db.names.back().first.insert(0, "thread-local wrapper routine for "); 4616 first = t; 4617 } 4618 break; 4619 case 'H': 4620 //TH <object name> # Thread-local initialization 4621 t = parse_name(first + 2, last, db); 4622 if (t != first + 2) 4623 { 4624 if (db.names.empty()) 4625 return first; 4626 db.names.back().first.insert(0, "thread-local initialization routine for "); 4627 first = t; 4628 } 4629 break; 4630 default: 4631 // T <call-offset> <base encoding> 4632 { 4633 const char* t0 = parse_call_offset(first+1, last); 4634 if (t0 == first+1) 4635 break; 4636 t = parse_encoding(t0, last, db); 4637 if (t != t0) 4638 { 4639 if (db.names.empty()) 4640 return first; 4641 if (first[1] == 'v') 4642 { 4643 db.names.back().first.insert(0, "virtual thunk to "); 4644 first = t; 4645 } 4646 else 4647 { 4648 db.names.back().first.insert(0, "non-virtual thunk to "); 4649 first = t; 4650 } 4651 } 4652 } 4653 break; 4654 } 4655 break; 4656 case 'G': 4657 switch (first[1]) 4658 { 4659 case 'V': 4660 // GV <object name> # Guard variable for one-time initialization 4661 t = parse_name(first+2, last, db); 4662 if (t != first+2) 4663 { 4664 if (db.names.empty()) 4665 return first; 4666 db.names.back().first.insert(0, "guard variable for "); 4667 first = t; 4668 } 4669 break; 4670 case 'R': 4671 // extension ::= GR <object name> # reference temporary for object 4672 t = parse_name(first+2, last, db); 4673 if (t != first+2) 4674 { 4675 if (db.names.empty()) 4676 return first; 4677 db.names.back().first.insert(0, "reference temporary for "); 4678 first = t; 4679 } 4680 break; 4681 } 4682 break; 4683 } 4684 } 4685 return first; 4686 } 4687 4688 template <class T> 4689 class save_value 4690 { 4691 T& restore_; 4692 T original_value_; 4693 public: 4694 save_value(T& restore) 4695 : restore_(restore), 4696 original_value_(restore) 4697 {} 4698 4699 ~save_value() 4700 { 4701 restore_ = std::move(original_value_); 4702 } 4703 4704 save_value(const save_value&) = delete; 4705 save_value& operator=(const save_value&) = delete; 4706 }; 4707 4708 // <encoding> ::= <function name> <bare-function-type> 4709 // ::= <data name> 4710 // ::= <special-name> 4711 4712 const char* 4713 parse_encoding(const char* first, const char* last, Db& db) 4714 { 4715 if (first != last) 4716 { 4717 save_value<decltype(db.encoding_depth)> su(db.encoding_depth); 4718 ++db.encoding_depth; 4719 save_value<decltype(db.tag_templates)> sb(db.tag_templates); 4720 if (db.encoding_depth > 1) 4721 db.tag_templates = true; 4722 save_value<decltype(db.parsed_ctor_dtor_cv)> sp(db.parsed_ctor_dtor_cv); 4723 db.parsed_ctor_dtor_cv = false; 4724 switch (*first) 4725 { 4726 case 'G': 4727 case 'T': 4728 first = parse_special_name(first, last, db); 4729 break; 4730 default: 4731 { 4732 bool ends_with_template_args = false; 4733 const char* t = parse_name(first, last, db, 4734 &ends_with_template_args); 4735 unsigned cv = db.cv; 4736 unsigned ref = db.ref; 4737 if (t != first) 4738 { 4739 if (t != last && *t != 'E' && *t != '.') 4740 { 4741 save_value<bool> sb2(db.tag_templates); 4742 db.tag_templates = false; 4743 const char* t2; 4744 Db::String ret2; 4745 if (db.names.empty()) 4746 return first; 4747 const Db::String& nm = db.names.back().first; 4748 if (nm.empty()) 4749 return first; 4750 if (!db.parsed_ctor_dtor_cv && ends_with_template_args) 4751 { 4752 t2 = parse_type(t, last, db); 4753 if (t2 == t) 4754 return first; 4755 if (db.names.size() < 2) 4756 return first; 4757 auto ret1 = std::move(db.names.back().first); 4758 ret2 = std::move(db.names.back().second); 4759 if (ret2.empty()) 4760 ret1 += ' '; 4761 db.names.pop_back(); 4762 if (db.names.empty()) 4763 return first; 4764 4765 db.names.back().first.insert(0, ret1); 4766 t = t2; 4767 } 4768 db.names.back().first += '('; 4769 if (t != last && *t == 'v') 4770 { 4771 ++t; 4772 } 4773 else 4774 { 4775 bool first_arg = true; 4776 while (true) 4777 { 4778 size_t k0 = db.names.size(); 4779 t2 = parse_type(t, last, db); 4780 size_t k1 = db.names.size(); 4781 if (t2 == t) 4782 break; 4783 if (k1 > k0) 4784 { 4785 Db::String tmp; 4786 for (size_t k = k0; k < k1; ++k) 4787 { 4788 if (!tmp.empty()) 4789 tmp += ", "; 4790 tmp += db.names[k].move_full(); 4791 } 4792 for (size_t k = k0; k < k1; ++k) { 4793 if (db.names.empty()) 4794 return first; 4795 db.names.pop_back(); 4796 } 4797 if (!tmp.empty()) 4798 { 4799 if (db.names.empty()) 4800 return first; 4801 if (!first_arg) 4802 db.names.back().first += ", "; 4803 else 4804 first_arg = false; 4805 db.names.back().first += tmp; 4806 } 4807 } 4808 t = t2; 4809 } 4810 } 4811 if (db.names.empty()) 4812 return first; 4813 db.names.back().first += ')'; 4814 if (cv & 1) 4815 db.names.back().first.append(" const"); 4816 if (cv & 2) 4817 db.names.back().first.append(" volatile"); 4818 if (cv & 4) 4819 db.names.back().first.append(" restrict"); 4820 if (ref == 1) 4821 db.names.back().first.append(" &"); 4822 else if (ref == 2) 4823 db.names.back().first.append(" &&"); 4824 db.names.back().first += ret2; 4825 first = t; 4826 } 4827 else 4828 first = t; 4829 } 4830 break; 4831 } 4832 } 4833 } 4834 return first; 4835 } 4836 4837 // _block_invoke 4838 // _block_invoke<decimal-digit>+ 4839 // _block_invoke_<decimal-digit>+ 4840 4841 const char* 4842 parse_block_invoke(const char* first, const char* last, Db& db) 4843 { 4844 if (last - first >= 13) 4845 { 4846 const char test[] = "_block_invoke"; 4847 const char* t = first; 4848 for (int i = 0; i < 13; ++i, ++t) 4849 { 4850 if (*t != test[i]) 4851 return first; 4852 } 4853 if (t != last) 4854 { 4855 if (*t == '_') 4856 { 4857 // must have at least 1 decimal digit 4858 if (++t == last || !std::isdigit(*t)) 4859 return first; 4860 ++t; 4861 } 4862 // parse zero or more digits 4863 while (t != last && isdigit(*t)) 4864 ++t; 4865 } 4866 if (db.names.empty()) 4867 return first; 4868 db.names.back().first.insert(0, "invocation function for block in "); 4869 first = t; 4870 } 4871 return first; 4872 } 4873 4874 // extension 4875 // <dot-suffix> := .<anything and everything> 4876 4877 const char* 4878 parse_dot_suffix(const char* first, const char* last, Db& db) 4879 { 4880 if (first != last && *first == '.') 4881 { 4882 if (db.names.empty()) 4883 return first; 4884 db.names.back().first += " (" + Db::String(first, last) + ")"; 4885 first = last; 4886 } 4887 return first; 4888 } 4889 4890 // <block-involcaton-function> ___Z<encoding>_block_invoke 4891 // <block-involcaton-function> ___Z<encoding>_block_invoke<decimal-digit>+ 4892 // <block-involcaton-function> ___Z<encoding>_block_invoke_<decimal-digit>+ 4893 // <mangled-name> ::= _Z<encoding> 4894 // ::= <type> 4895 4896 void 4897 demangle(const char* first, const char* last, Db& db, int& status) 4898 { 4899 if (first >= last) 4900 { 4901 status = invalid_mangled_name; 4902 return; 4903 } 4904 if (*first == '_') 4905 { 4906 if (last - first >= 4) 4907 { 4908 if (first[1] == 'Z') 4909 { 4910 const char* t = parse_encoding(first+2, last, db); 4911 if (t != first+2 && t != last && *t == '.') 4912 t = parse_dot_suffix(t, last, db); 4913 if (t != last) 4914 status = invalid_mangled_name; 4915 } 4916 else if (first[1] == '_' && first[2] == '_' && first[3] == 'Z') 4917 { 4918 const char* t = parse_encoding(first+4, last, db); 4919 if (t != first+4 && t != last) 4920 { 4921 const char* t1 = parse_block_invoke(t, last, db); 4922 if (t1 != last) 4923 status = invalid_mangled_name; 4924 } 4925 else 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 { 4936 const char* t = parse_type(first, last, db); 4937 if (t != last) 4938 status = invalid_mangled_name; 4939 } 4940 if (status == success && db.names.empty()) 4941 status = invalid_mangled_name; 4942 } 4943 4944 } // unnamed namespace 4945 4946 extern "C" _LIBCXXABI_FUNC_VIS char * 4947 __cxa_demangle(const char *mangled_name, char *buf, size_t *n, int *status) { 4948 if (mangled_name == nullptr || (buf != nullptr && n == nullptr)) 4949 { 4950 if (status) 4951 *status = invalid_args; 4952 return nullptr; 4953 } 4954 4955 size_t internal_size = buf != nullptr ? *n : 0; 4956 arena<bs> a; 4957 Db db(a); 4958 db.template_param.emplace_back(a); 4959 int internal_status = success; 4960 size_t len = std::strlen(mangled_name); 4961 demangle(mangled_name, mangled_name + len, db, 4962 internal_status); 4963 if (internal_status == success && db.fix_forward_references && 4964 !db.template_param.empty() && !db.template_param.front().empty()) 4965 { 4966 db.fix_forward_references = false; 4967 db.tag_templates = false; 4968 db.names.clear(); 4969 db.subs.clear(); 4970 demangle(mangled_name, mangled_name + len, db, internal_status); 4971 if (db.fix_forward_references) 4972 internal_status = invalid_mangled_name; 4973 } 4974 if (internal_status == success) 4975 { 4976 size_t sz = db.names.back().size() + 1; 4977 if (sz > internal_size) 4978 { 4979 char* newbuf = static_cast<char*>(std::realloc(buf, sz)); 4980 if (newbuf == nullptr) 4981 { 4982 internal_status = memory_alloc_failure; 4983 buf = nullptr; 4984 } 4985 else 4986 { 4987 buf = newbuf; 4988 if (n != nullptr) 4989 *n = sz; 4990 } 4991 } 4992 if (buf != nullptr) 4993 { 4994 db.names.back().first += db.names.back().second; 4995 std::memcpy(buf, db.names.back().first.data(), sz-1); 4996 buf[sz-1] = char(0); 4997 } 4998 } 4999 else 5000 buf = nullptr; 5001 if (status) 5002 *status = internal_status; 5003 return buf; 5004 } 5005 5006 } // __cxxabiv1 5007