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 #include "cxa_demangle.h" 11 12 #include <stdlib.h> 13 #include <string.h> 14 #include <ctype.h> 15 #include <stdio.h> 16 #include <new> 17 #include <algorithm> 18 #include <assert.h> 19 20 #ifdef DEBUGGING 21 22 #include <string> 23 #include <typeinfo> 24 25 #endif 26 27 namespace __cxxabiv1 28 { 29 30 namespace __libcxxabi 31 { 32 33 #pragma GCC visibility push(hidden) 34 35 class __node 36 { 37 __node(const __node&); 38 __node& operator=(const __node&); 39 public: 40 const char* __name_; 41 size_t __size_; 42 __node* __left_; 43 __node* __right_; 44 long __cached_size_; 45 long double __value_; 46 public: 47 __node() 48 : __name_(0), __size_(0), __left_(0), __right_(0), __cached_size_(-1) 49 {} 50 virtual ~__node() {}; 51 52 void reset_cached_size() 53 { 54 __cached_size_ = -1; 55 if (__left_) 56 __left_->reset_cached_size(); 57 if (__right_) 58 __right_->reset_cached_size(); 59 } 60 61 virtual size_t first_size() const {return 0;} 62 virtual size_t second_size() const {return 0;} 63 virtual size_t size() const 64 { 65 if (__cached_size_ == -1) 66 const_cast<long&>(__cached_size_) = static_cast<long>(first_size() + second_size()); 67 return static_cast<size_t>(__cached_size_); 68 } 69 virtual char* first_demangled_name(char* buf) const {return buf;} 70 virtual char* second_demangled_name(char* buf) const {return buf;} 71 virtual char* get_demangled_name(char* buf) const 72 { 73 return second_demangled_name(first_demangled_name(buf)); 74 } 75 virtual size_t base_size() const {return size();} 76 virtual char* get_base_name(char* buf) const 77 { 78 return get_demangled_name(buf); 79 } 80 81 virtual bool ends_with_template(bool /*parsing*/ = false) const 82 { 83 return false; 84 } 85 virtual bool is_ctor_dtor_conv() const 86 { 87 return false; 88 } 89 virtual __node* base_name() const 90 { 91 return const_cast<__node*>(this); 92 } 93 virtual bool is_reference_or_pointer_to_function_or_array() const 94 { 95 return false; 96 } 97 virtual bool is_function() const 98 { 99 return false; 100 } 101 virtual bool is_cv_qualifer() const 102 { 103 return false; 104 } 105 virtual bool is_array() const 106 { 107 return false; 108 } 109 110 virtual bool fix_forward_references(__node**, __node**) 111 { 112 return true; 113 } 114 virtual __node* extract_cv(__node*&) const 115 { 116 return 0; 117 } 118 virtual size_t list_len() const 119 { 120 return 0; 121 } 122 virtual bool is_sub() const 123 { 124 return false; 125 } 126 }; 127 128 #ifdef DEBUGGING 129 130 void display(__node* x, int indent = 0) 131 { 132 if (x) 133 { 134 for (int i = 0; i < 2*indent; ++i) 135 printf(" "); 136 size_t sz = x->size(); 137 char* buf = (char*)calloc(sz+10, 1); 138 x->get_demangled_name(buf); 139 printf("%s [%ld] %s, %p\n", typeid(*x).name(), sz, buf, x); 140 if (strlen(buf) != sz) 141 { 142 printf("strlen(buf) = %ld and size = %ld\n", strlen(buf), sz); 143 } 144 free(buf); 145 display(x->__left_, indent+1); 146 display(x->__right_, indent+1); 147 } 148 } 149 150 #endif 151 152 class __block_invoke 153 : public __node 154 { 155 static const ptrdiff_t n = sizeof("invocation function for block in ") - 1; 156 public: 157 __block_invoke(__node* type) 158 { 159 __right_ = type; 160 } 161 162 virtual size_t first_size() const 163 { 164 if (__cached_size_ == -1) 165 const_cast<long&>(__cached_size_) = n + static_cast<long>(__right_->size()); 166 return static_cast<size_t>(__cached_size_); 167 } 168 virtual char* first_demangled_name(char* buf) const 169 { 170 strncpy(buf, "invocation function for block in ", n); 171 return __right_->get_demangled_name(buf+n); 172 } 173 virtual __node* base_name() const 174 { 175 return __right_->base_name(); 176 } 177 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 178 { 179 return __right_->fix_forward_references(t_begin, t_end); 180 } 181 }; 182 183 class __vtable 184 : public __node 185 { 186 static const ptrdiff_t n = sizeof("vtable for ") - 1; 187 public: 188 __vtable(__node* type) 189 { 190 __right_ = type; 191 } 192 193 virtual size_t first_size() const 194 { 195 if (__cached_size_ == -1) 196 const_cast<long&>(__cached_size_) = n + static_cast<long>(__right_->size()); 197 return static_cast<size_t>(__cached_size_); 198 } 199 virtual char* first_demangled_name(char* buf) const 200 { 201 strncpy(buf, "vtable for ", n); 202 return __right_->get_demangled_name(buf+n); 203 } 204 virtual __node* base_name() const 205 { 206 return __right_->base_name(); 207 } 208 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 209 { 210 return __right_->fix_forward_references(t_begin, t_end); 211 } 212 }; 213 214 class __VTT 215 : public __node 216 { 217 static const ptrdiff_t n = sizeof("VTT for ") - 1; 218 public: 219 __VTT(__node* type) 220 { 221 __right_ = type; 222 } 223 224 virtual size_t first_size() const 225 { 226 if (__cached_size_ == -1) 227 const_cast<long&>(__cached_size_) = n + static_cast<long>(__right_->size()); 228 return static_cast<size_t>(__cached_size_); 229 } 230 virtual char* first_demangled_name(char* buf) const 231 { 232 strncpy(buf, "VTT for ", n); 233 return __right_->get_demangled_name(buf+n); 234 } 235 virtual __node* base_name() const 236 { 237 return __right_->base_name(); 238 } 239 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 240 { 241 return __right_->fix_forward_references(t_begin, t_end); 242 } 243 }; 244 245 class __construction_vtable 246 : public __node 247 { 248 static const ptrdiff_t n = sizeof("construction vtable for ") - 1 + 4; 249 public: 250 __construction_vtable(__node* left, __node* right) 251 { 252 __left_ = left; 253 __right_ = right; 254 } 255 256 virtual size_t first_size() const 257 { 258 if (__cached_size_ == -1) 259 const_cast<long&>(__cached_size_) = n + static_cast<long>(__left_->size() 260 + __right_->size()); 261 return static_cast<size_t>(__cached_size_); 262 } 263 virtual char* first_demangled_name(char* buf) const 264 { 265 strncpy(buf, "construction vtable for ", n-4); 266 buf = __left_->get_demangled_name(buf+n-4); 267 *buf++ = '-'; 268 *buf++ = 'i'; 269 *buf++ = 'n'; 270 *buf++ = '-'; 271 return __right_->get_demangled_name(buf); 272 } 273 virtual __node* base_name() const 274 { 275 return __right_->base_name(); 276 } 277 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 278 { 279 bool r = true; 280 if (__left_) 281 r = __left_->fix_forward_references(t_begin, t_end); 282 return r && __right_->fix_forward_references(t_begin, t_end); 283 } 284 }; 285 286 class __typeinfo 287 : public __node 288 { 289 static const ptrdiff_t n = sizeof("typeinfo for ") - 1; 290 public: 291 __typeinfo(__node* type) 292 { 293 __right_ = type; 294 } 295 296 virtual size_t first_size() const 297 { 298 if (__cached_size_ == -1) 299 const_cast<long&>(__cached_size_) = n + static_cast<long>(__right_->size()); 300 return static_cast<size_t>(__cached_size_); 301 } 302 virtual char* first_demangled_name(char* buf) const 303 { 304 strncpy(buf, "typeinfo for ", n); 305 return __right_->get_demangled_name(buf+n); 306 } 307 virtual __node* base_name() const 308 { 309 return __right_->base_name(); 310 } 311 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 312 { 313 return __right_->fix_forward_references(t_begin, t_end); 314 } 315 }; 316 317 class __typeinfo_name 318 : public __node 319 { 320 static const ptrdiff_t n = sizeof("typeinfo name for ") - 1; 321 public: 322 __typeinfo_name(__node* type) 323 { 324 __right_ = type; 325 } 326 327 virtual size_t first_size() const 328 { 329 if (__cached_size_ == -1) 330 const_cast<long&>(__cached_size_) = n + static_cast<long>(__right_->size()); 331 return static_cast<size_t>(__cached_size_); 332 } 333 virtual char* first_demangled_name(char* buf) const 334 { 335 strncpy(buf, "typeinfo name for ", n); 336 return __right_->get_demangled_name(buf+n); 337 } 338 virtual __node* base_name() const 339 { 340 return __right_->base_name(); 341 } 342 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 343 { 344 return __right_->fix_forward_references(t_begin, t_end); 345 } 346 }; 347 348 class __covariant_return_thunk 349 : public __node 350 { 351 static const ptrdiff_t n = sizeof("covariant return thunk to ") - 1; 352 public: 353 __covariant_return_thunk(__node* type) 354 { 355 __right_ = type; 356 } 357 358 virtual size_t first_size() const 359 { 360 if (__cached_size_ == -1) 361 const_cast<long&>(__cached_size_) = n + static_cast<long>(__right_->size()); 362 return static_cast<size_t>(__cached_size_); 363 } 364 virtual char* first_demangled_name(char* buf) const 365 { 366 strncpy(buf, "covariant return thunk to ", n); 367 return __right_->get_demangled_name(buf+n); 368 } 369 virtual __node* base_name() const 370 { 371 return __right_->base_name(); 372 } 373 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 374 { 375 return __right_->fix_forward_references(t_begin, t_end); 376 } 377 }; 378 379 class __virtual_thunk 380 : public __node 381 { 382 static const size_t n = sizeof("virtual thunk to ") - 1; 383 public: 384 __virtual_thunk(__node* type) 385 { 386 __right_ = type; 387 } 388 389 virtual size_t first_size() const 390 { 391 if (__cached_size_ == -1) 392 const_cast<long&>(__cached_size_) = static_cast<long>(n + __right_->size()); 393 return static_cast<size_t>(__cached_size_); 394 } 395 virtual char* first_demangled_name(char* buf) const 396 { 397 strncpy(buf, "virtual thunk to ", n); 398 return __right_->get_demangled_name(buf+n); 399 } 400 virtual __node* base_name() const 401 { 402 return __right_->base_name(); 403 } 404 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 405 { 406 return __right_->fix_forward_references(t_begin, t_end); 407 } 408 }; 409 410 class __non_virtual_thunk 411 : public __node 412 { 413 static const size_t n = sizeof("non-virtual thunk to ") - 1; 414 public: 415 __non_virtual_thunk(__node* type) 416 { 417 __right_ = type; 418 } 419 420 virtual size_t first_size() const 421 { 422 if (__cached_size_ == -1) 423 const_cast<long&>(__cached_size_) = static_cast<long>(n + __right_->size()); 424 return static_cast<size_t>(__cached_size_); 425 } 426 virtual char* first_demangled_name(char* buf) const 427 { 428 strncpy(buf, "non-virtual thunk to ", n); 429 return __right_->get_demangled_name(buf+n); 430 } 431 virtual __node* base_name() const 432 { 433 return __right_->base_name(); 434 } 435 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 436 { 437 return __right_->fix_forward_references(t_begin, t_end); 438 } 439 }; 440 441 class __guard_variable 442 : public __node 443 { 444 static const size_t n = sizeof("guard variable for ") - 1; 445 public: 446 __guard_variable(__node* type) 447 { 448 __right_ = type; 449 } 450 451 virtual size_t first_size() const 452 { 453 if (__cached_size_ == -1) 454 const_cast<long&>(__cached_size_) = static_cast<long>(n + __right_->size()); 455 return static_cast<size_t>(__cached_size_); 456 } 457 virtual char* first_demangled_name(char* buf) const 458 { 459 strncpy(buf, "guard variable for ", n); 460 return __right_->get_demangled_name(buf+n); 461 } 462 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 463 { 464 return __right_->fix_forward_references(t_begin, t_end); 465 } 466 }; 467 468 class __reference_temporary 469 : public __node 470 { 471 static const size_t n = sizeof("reference temporary for ") - 1; 472 public: 473 __reference_temporary(__node* type) 474 { 475 __right_ = type; 476 } 477 478 virtual size_t first_size() const 479 { 480 if (__cached_size_ == -1) 481 const_cast<long&>(__cached_size_) = static_cast<long>(n + __right_->size()); 482 return static_cast<size_t>(__cached_size_); 483 } 484 virtual char* first_demangled_name(char* buf) const 485 { 486 strncpy(buf, "reference temporary for ", n); 487 return __right_->get_demangled_name(buf+n); 488 } 489 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 490 { 491 return __right_->fix_forward_references(t_begin, t_end); 492 } 493 }; 494 495 class __source_name 496 : public __node 497 { 498 public: 499 __source_name(const char* __name, size_t __size) 500 { 501 __name_ = __name; 502 __size_ = __size; 503 } 504 505 virtual size_t first_size() const 506 { 507 if (__cached_size_ == -1) 508 { 509 if (__size_ >= 10 && strncmp(__name_, "_GLOBAL__N", 10) == 0) 510 const_cast<long&>(__cached_size_) = 21; 511 else 512 const_cast<long&>(__cached_size_) = static_cast<long>(__size_); 513 } 514 return static_cast<size_t>(__cached_size_); 515 } 516 virtual char* first_demangled_name(char* buf) const 517 { 518 if (__size_ >= 10 && strncmp(__name_, "_GLOBAL__N", 10) == 0) 519 return strncpy(buf, "(anonymous namespace)", 21) + 21; 520 return strncpy(buf, __name_, __size_) + __size_; 521 } 522 }; 523 524 class __operator_new 525 : public __node 526 { 527 public: 528 529 virtual size_t first_size() const {return sizeof("operator new") - 1;} 530 virtual char* first_demangled_name(char* buf) const 531 { 532 return strncpy(buf, "operator new", sizeof("operator new") - 1) + 533 sizeof("operator new") - 1; 534 } 535 }; 536 537 class __operator_new_array 538 : public __node 539 { 540 public: 541 542 virtual size_t first_size() const {return sizeof("operator new[]") - 1;} 543 virtual char* first_demangled_name(char* buf) const 544 { 545 return strncpy(buf, "operator new[]", sizeof("operator new[]") - 1) + 546 sizeof("operator new[]") - 1; 547 } 548 }; 549 550 class __operator_delete 551 : public __node 552 { 553 public: 554 555 virtual size_t first_size() const {return sizeof("operator delete") - 1;} 556 virtual char* first_demangled_name(char* buf) const 557 { 558 return strncpy(buf, "operator delete", sizeof("operator delete") - 1) + 559 sizeof("operator delete") - 1; 560 } 561 }; 562 563 class __operator_delete_array 564 : public __node 565 { 566 public: 567 568 virtual size_t first_size() const {return sizeof("operator delete[]") - 1;} 569 virtual char* first_demangled_name(char* buf) const 570 { 571 return strncpy(buf, "operator delete[]", sizeof("operator delete[]") - 1) + 572 sizeof("operator delete[]") - 1; 573 } 574 }; 575 576 class __operator_logical_and 577 : public __node 578 { 579 public: 580 581 __operator_logical_and() {} 582 __operator_logical_and(__node* op1, __node* op2) 583 { 584 __left_ = op1; 585 __right_ = op2; 586 } 587 virtual size_t first_size() const 588 { 589 if (__cached_size_ == -1) 590 { 591 if (__left_) 592 const_cast<long&>(__cached_size_) = static_cast<long>( 593 __left_->size() + 8 + 594 __right_->size()); 595 else 596 const_cast<long&>(__cached_size_) = sizeof("operator&&") - 1; 597 } 598 return static_cast<size_t>(__cached_size_); 599 } 600 virtual char* first_demangled_name(char* buf) const 601 { 602 if (__left_) 603 { 604 *buf++ = '('; 605 buf = __left_->get_demangled_name(buf); 606 strncpy(buf, ") && (", 6); 607 buf += 6; 608 buf = __right_->get_demangled_name(buf); 609 *buf++ = ')'; 610 } 611 else 612 { 613 strncpy(buf, "operator&&", sizeof("operator&&") - 1); 614 buf += sizeof("operator&&") - 1; 615 } 616 return buf; 617 } 618 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 619 { 620 bool r = true; 621 if (__left_) 622 r = r && __left_->fix_forward_references(t_begin, t_end); 623 if (__right_) 624 r = r && __right_->fix_forward_references(t_begin, t_end); 625 return r; 626 } 627 }; 628 629 class __operator_addressof 630 : public __node 631 { 632 public: 633 634 __operator_addressof() {} 635 explicit __operator_addressof(__node* op) 636 { 637 __left_ = op; 638 } 639 virtual size_t first_size() const 640 { 641 if (__cached_size_ == -1) 642 { 643 if (__left_) 644 const_cast<long&>(__cached_size_) = static_cast<long>(3 + __left_->size()); 645 else 646 const_cast<long&>(__cached_size_) = sizeof("operator&") - 1; 647 } 648 return static_cast<size_t>(__cached_size_); 649 } 650 virtual char* first_demangled_name(char* buf) const 651 { 652 if (__left_) 653 { 654 *buf++ = '&'; 655 *buf++ = '('; 656 buf = __left_->get_demangled_name(buf); 657 *buf++ = ')'; 658 } 659 else 660 { 661 strncpy(buf, "operator&", sizeof("operator&") - 1); 662 buf += sizeof("operator&") - 1; 663 } 664 return buf; 665 } 666 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 667 { 668 if (__left_) 669 return __left_->fix_forward_references(t_begin, t_end); 670 return true; 671 } 672 }; 673 674 class __operator_bit_and 675 : public __node 676 { 677 public: 678 679 __operator_bit_and() {} 680 __operator_bit_and(__node* op1, __node* op2) 681 { 682 __left_ = op1; 683 __right_ = op2; 684 } 685 virtual size_t first_size() const 686 { 687 if (__cached_size_ == -1) 688 { 689 if (__left_) 690 const_cast<long&>(__cached_size_) = static_cast<long>( 691 __left_->size() + 7 + 692 __right_->size()); 693 else 694 const_cast<long&>(__cached_size_) = sizeof("operator&") - 1; 695 } 696 return static_cast<size_t>(__cached_size_); 697 } 698 virtual char* first_demangled_name(char* buf) const 699 { 700 if (__left_) 701 { 702 *buf++ = '('; 703 buf = __left_->get_demangled_name(buf); 704 strncpy(buf, ") & (", 5); 705 buf += 5; 706 buf = __right_->get_demangled_name(buf); 707 *buf++ = ')'; 708 } 709 else 710 { 711 strncpy(buf, "operator&", sizeof("operator&") - 1); 712 buf += sizeof("operator&") - 1; 713 } 714 return buf; 715 } 716 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 717 { 718 bool r = true; 719 if (__left_) 720 r = r && __left_->fix_forward_references(t_begin, t_end); 721 if (__right_) 722 r = r && __right_->fix_forward_references(t_begin, t_end); 723 return r; 724 } 725 }; 726 727 class __operator_and_equal 728 : public __node 729 { 730 public: 731 732 __operator_and_equal() {} 733 __operator_and_equal(__node* op1, __node* op2) 734 { 735 __left_ = op1; 736 __right_ = op2; 737 } 738 virtual size_t first_size() const 739 { 740 if (__cached_size_ == -1) 741 { 742 if (__left_) 743 const_cast<long&>(__cached_size_) = static_cast<long>( 744 __left_->size() + 8 + 745 __right_->size()); 746 else 747 const_cast<long&>(__cached_size_) = sizeof("operator&=") - 1; 748 } 749 return static_cast<size_t>(__cached_size_); 750 } 751 virtual char* first_demangled_name(char* buf) const 752 { 753 if (__left_) 754 { 755 *buf++ = '('; 756 buf = __left_->get_demangled_name(buf); 757 strncpy(buf, ") &= (", 6); 758 buf += 6; 759 buf = __right_->get_demangled_name(buf); 760 *buf++ = ')'; 761 } 762 else 763 { 764 strncpy(buf, "operator&=", sizeof("operator&=") - 1); 765 buf += sizeof("operator&=") - 1; 766 } 767 return buf; 768 } 769 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 770 { 771 bool r = true; 772 if (__left_) 773 r = r && __left_->fix_forward_references(t_begin, t_end); 774 if (__right_) 775 r = r && __right_->fix_forward_references(t_begin, t_end); 776 return r; 777 } 778 }; 779 780 class __operator_equal 781 : public __node 782 { 783 public: 784 785 __operator_equal() {} 786 __operator_equal(__node* op1, __node* op2) 787 { 788 __left_ = op1; 789 __right_ = op2; 790 } 791 virtual size_t first_size() const 792 { 793 if (__cached_size_ == -1) 794 { 795 if (__left_) 796 const_cast<long&>(__cached_size_) = static_cast<long>( 797 __left_->size() + 7 + 798 __right_->size()); 799 else 800 const_cast<long&>(__cached_size_) = sizeof("operator=") - 1; 801 } 802 return static_cast<size_t>(__cached_size_); 803 } 804 virtual char* first_demangled_name(char* buf) const 805 { 806 if (__left_) 807 { 808 *buf++ = '('; 809 buf = __left_->get_demangled_name(buf); 810 strncpy(buf, ") = (", 5); 811 buf += 5; 812 buf = __right_->get_demangled_name(buf); 813 *buf++ = ')'; 814 } 815 else 816 { 817 strncpy(buf, "operator=", sizeof("operator=") - 1); 818 buf += sizeof("operator=") - 1; 819 } 820 return buf; 821 } 822 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 823 { 824 bool r = true; 825 if (__left_) 826 r = r && __left_->fix_forward_references(t_begin, t_end); 827 if (__right_) 828 r = r && __right_->fix_forward_references(t_begin, t_end); 829 return r; 830 } 831 }; 832 833 class __operator_alignof_type 834 : public __node 835 { 836 public: 837 838 __operator_alignof_type() {} 839 __operator_alignof_type(__node* op) 840 { 841 __right_ = op; 842 } 843 virtual size_t first_size() const 844 { 845 if (__cached_size_ == -1) 846 { 847 if (__right_) 848 const_cast<long&>(__cached_size_) = static_cast<long>(__right_->size() + 10); 849 else 850 const_cast<long&>(__cached_size_) = sizeof("operator alignof") - 1; 851 } 852 return static_cast<size_t>(__cached_size_); 853 } 854 virtual char* first_demangled_name(char* buf) const 855 { 856 if (__right_) 857 { 858 strncpy(buf, "alignof (", 9); 859 buf += 9; 860 buf = __right_->get_demangled_name(buf); 861 *buf++ = ')'; 862 } 863 else 864 { 865 strncpy(buf, "operator alignof", sizeof("operator alignof") - 1); 866 buf += sizeof("operator alignof") - 1; 867 } 868 return buf; 869 } 870 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 871 { 872 if (__right_) 873 return __right_->fix_forward_references(t_begin, t_end); 874 return true; 875 } 876 }; 877 878 class __operator_alignof_expression 879 : public __node 880 { 881 public: 882 883 __operator_alignof_expression() {} 884 __operator_alignof_expression(__node* op) 885 { 886 __right_ = op; 887 } 888 virtual size_t first_size() const 889 { 890 if (__cached_size_ == -1) 891 { 892 if (__right_) 893 const_cast<long&>(__cached_size_) = static_cast<long>(__right_->size() + 10); 894 else 895 const_cast<long&>(__cached_size_) = sizeof("operator alignof") - 1; 896 } 897 return static_cast<size_t>(__cached_size_); 898 } 899 virtual char* first_demangled_name(char* buf) const 900 { 901 if (__right_) 902 { 903 strncpy(buf, "alignof (", 9); 904 buf += 9; 905 buf = __right_->get_demangled_name(buf); 906 *buf++ = ')'; 907 } 908 else 909 { 910 strncpy(buf, "operator alignof", sizeof("operator alignof") - 1); 911 buf += sizeof("operator alignof") - 1; 912 } 913 return buf; 914 } 915 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 916 { 917 if (__right_) 918 return __right_->fix_forward_references(t_begin, t_end); 919 return true; 920 } 921 }; 922 923 class __operator_paren 924 : public __node 925 { 926 public: 927 928 virtual size_t first_size() const {return sizeof("operator()") - 1;} 929 virtual char* first_demangled_name(char* buf) const 930 { 931 strncpy(buf, "operator()", sizeof("operator()") - 1); 932 return buf + sizeof("operator()") - 1; 933 } 934 }; 935 936 class __operator_comma 937 : public __node 938 { 939 public: 940 941 __operator_comma() {} 942 __operator_comma(__node* op1, __node* op2) 943 { 944 __left_ = op1; 945 __right_ = op2; 946 } 947 virtual size_t first_size() const 948 { 949 if (__cached_size_ == -1) 950 { 951 if (__left_) 952 const_cast<long&>(__cached_size_) = static_cast<long>( 953 __left_->size() + 7 + 954 __right_->size()); 955 else 956 const_cast<long&>(__cached_size_) = sizeof("operator,") - 1; 957 } 958 return static_cast<size_t>(__cached_size_); 959 } 960 virtual char* first_demangled_name(char* buf) const 961 { 962 if (__left_) 963 { 964 *buf++ = '('; 965 buf = __left_->get_demangled_name(buf); 966 strncpy(buf, ") , (", 5); 967 buf += 5; 968 buf = __right_->get_demangled_name(buf); 969 *buf++ = ')'; 970 } 971 else 972 { 973 strncpy(buf, "operator,", sizeof("operator,") - 1); 974 buf += sizeof("operator,") - 1; 975 } 976 return buf; 977 } 978 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 979 { 980 bool r = true; 981 if (__left_) 982 r = r && __left_->fix_forward_references(t_begin, t_end); 983 if (__right_) 984 r = r && __right_->fix_forward_references(t_begin, t_end); 985 return r; 986 } 987 }; 988 989 class __operator_tilda 990 : public __node 991 { 992 public: 993 994 __operator_tilda() {} 995 explicit __operator_tilda(__node* op) 996 { 997 __left_ = op; 998 } 999 virtual size_t first_size() const 1000 { 1001 if (__cached_size_ == -1) 1002 { 1003 if (__left_) 1004 const_cast<long&>(__cached_size_) = static_cast<long>(3 + __left_->size()); 1005 else 1006 const_cast<long&>(__cached_size_) = sizeof("operator~") - 1; 1007 } 1008 return static_cast<size_t>(__cached_size_); 1009 } 1010 virtual char* first_demangled_name(char* buf) const 1011 { 1012 if (__left_) 1013 { 1014 *buf++ = '~'; 1015 *buf++ = '('; 1016 buf = __left_->get_demangled_name(buf); 1017 *buf++ = ')'; 1018 } 1019 else 1020 { 1021 strncpy(buf, "operator~", sizeof("operator~") - 1); 1022 buf += sizeof("operator~") - 1; 1023 } 1024 return buf; 1025 } 1026 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1027 { 1028 if (__left_) 1029 return __left_->fix_forward_references(t_begin, t_end); 1030 return true; 1031 } 1032 }; 1033 1034 class __operator_cast 1035 : public __node 1036 { 1037 static const size_t n = sizeof("operator ") - 1; 1038 public: 1039 1040 explicit __operator_cast(__node* type) 1041 { 1042 __right_ = type; 1043 } 1044 __operator_cast(__node* type, __node* arg) 1045 { 1046 __size_ = 1; 1047 __right_ = type; 1048 __left_ = arg; 1049 } 1050 virtual size_t first_size() const 1051 { 1052 if (__cached_size_ == -1) 1053 { 1054 size_t off; 1055 if (__size_) 1056 { 1057 off = 4; 1058 off += __right_->size(); 1059 if (__left_) 1060 off += __left_->size(); 1061 } 1062 else 1063 off = n + __right_->size();; 1064 const_cast<long&>(__cached_size_) = static_cast<long>(off); 1065 } 1066 return static_cast<size_t>(__cached_size_); 1067 } 1068 virtual char* first_demangled_name(char* buf) const 1069 { 1070 if (__size_) 1071 { 1072 *buf++ = '('; 1073 buf = __right_->get_demangled_name(buf); 1074 *buf++ = ')'; 1075 *buf++ = '('; 1076 if (__left_) 1077 buf = __left_->get_demangled_name(buf); 1078 *buf++ = ')'; 1079 } 1080 else 1081 { 1082 strncpy(buf, "operator ", n); 1083 buf = __right_->get_demangled_name(buf+n); 1084 } 1085 return buf; 1086 } 1087 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1088 { 1089 bool r = true; 1090 if (__left_) 1091 r = r && __left_->fix_forward_references(t_begin, t_end); 1092 r = r && __right_->fix_forward_references(t_begin, t_end); 1093 return r; 1094 } 1095 virtual bool is_ctor_dtor_conv() const 1096 { 1097 return true; 1098 } 1099 }; 1100 1101 class __cast_literal 1102 : public __node 1103 { 1104 public: 1105 1106 __cast_literal(__node* type, const char* f, const char* l) 1107 { 1108 __left_ = type; 1109 __name_ = f; 1110 __size_ = static_cast<size_t>(l - f); 1111 } 1112 virtual size_t first_size() const 1113 { 1114 if (__cached_size_ == -1) 1115 const_cast<long&>(__cached_size_) = static_cast<long>(2 + 1116 __left_->size() + __size_); 1117 return static_cast<size_t>(__cached_size_); 1118 } 1119 virtual char* first_demangled_name(char* buf) const 1120 { 1121 *buf++ = '('; 1122 buf = __left_->get_demangled_name(buf); 1123 *buf++ = ')'; 1124 strncpy(buf, __name_, __size_); 1125 return buf + __size_; 1126 } 1127 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1128 { 1129 return __left_->fix_forward_references(t_begin, t_end); 1130 } 1131 }; 1132 1133 class __operator_dereference 1134 : public __node 1135 { 1136 public: 1137 1138 __operator_dereference() {} 1139 explicit __operator_dereference(__node* op) 1140 { 1141 __left_ = op; 1142 } 1143 virtual size_t first_size() const 1144 { 1145 if (__cached_size_ == -1) 1146 { 1147 if (__left_) 1148 const_cast<long&>(__cached_size_) = static_cast<long>(3 + __left_->size()); 1149 else 1150 const_cast<long&>(__cached_size_) = sizeof("operator*") - 1; 1151 } 1152 return static_cast<size_t>(__cached_size_); 1153 } 1154 virtual char* first_demangled_name(char* buf) const 1155 { 1156 if (__left_) 1157 { 1158 *buf++ = '*'; 1159 *buf++ = '('; 1160 buf = __left_->get_demangled_name(buf); 1161 *buf++ = ')'; 1162 } 1163 else 1164 { 1165 strncpy(buf, "operator*", sizeof("operator*") - 1); 1166 buf += sizeof("operator*") - 1; 1167 } 1168 return buf; 1169 } 1170 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1171 { 1172 if (__left_) 1173 return __left_->fix_forward_references(t_begin, t_end); 1174 return true; 1175 } 1176 }; 1177 1178 class __operator_divide 1179 : public __node 1180 { 1181 public: 1182 1183 __operator_divide() {} 1184 __operator_divide(__node* op1, __node* op2) 1185 { 1186 __left_ = op1; 1187 __right_ = op2; 1188 } 1189 virtual size_t first_size() const 1190 { 1191 if (__cached_size_ == -1) 1192 { 1193 if (__left_) 1194 const_cast<long&>(__cached_size_) = static_cast<long>( 1195 __left_->size() + 7 + 1196 __right_->size()); 1197 else 1198 const_cast<long&>(__cached_size_) = sizeof("operator/") - 1; 1199 } 1200 return static_cast<size_t>(__cached_size_); 1201 } 1202 virtual char* first_demangled_name(char* buf) const 1203 { 1204 if (__left_) 1205 { 1206 *buf++ = '('; 1207 buf = __left_->get_demangled_name(buf); 1208 strncpy(buf, ") / (", 5); 1209 buf += 5; 1210 buf = __right_->get_demangled_name(buf); 1211 *buf++ = ')'; 1212 } 1213 else 1214 { 1215 strncpy(buf, "operator/", sizeof("operator/") - 1); 1216 buf += sizeof("operator/") - 1; 1217 } 1218 return buf; 1219 } 1220 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1221 { 1222 bool r = true; 1223 if (__left_) 1224 r = r && __left_->fix_forward_references(t_begin, t_end); 1225 if (__right_) 1226 r = r && __right_->fix_forward_references(t_begin, t_end); 1227 return r; 1228 } 1229 }; 1230 1231 class __operator_divide_equal 1232 : public __node 1233 { 1234 public: 1235 1236 __operator_divide_equal() {} 1237 __operator_divide_equal(__node* op1, __node* op2) 1238 { 1239 __left_ = op1; 1240 __right_ = op2; 1241 } 1242 virtual size_t first_size() const 1243 { 1244 if (__cached_size_ == -1) 1245 { 1246 if (__left_) 1247 const_cast<long&>(__cached_size_) = static_cast<long>( 1248 __left_->size() + 8 + 1249 __right_->size()); 1250 else 1251 const_cast<long&>(__cached_size_) = sizeof("operator/=") - 1; 1252 } 1253 return static_cast<size_t>(__cached_size_); 1254 } 1255 virtual char* first_demangled_name(char* buf) const 1256 { 1257 if (__left_) 1258 { 1259 *buf++ = '('; 1260 buf = __left_->get_demangled_name(buf); 1261 strncpy(buf, ") /= (", 6); 1262 buf += 6; 1263 buf = __right_->get_demangled_name(buf); 1264 *buf++ = ')'; 1265 } 1266 else 1267 { 1268 strncpy(buf, "operator/=", sizeof("operator/=") - 1); 1269 buf += sizeof("operator/=") - 1; 1270 } 1271 return buf; 1272 } 1273 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1274 { 1275 bool r = true; 1276 if (__left_) 1277 r = r && __left_->fix_forward_references(t_begin, t_end); 1278 if (__right_) 1279 r = r && __right_->fix_forward_references(t_begin, t_end); 1280 return r; 1281 } 1282 }; 1283 1284 class __operator_xor 1285 : public __node 1286 { 1287 public: 1288 1289 __operator_xor() {} 1290 __operator_xor(__node* op1, __node* op2) 1291 { 1292 __left_ = op1; 1293 __right_ = op2; 1294 } 1295 virtual size_t first_size() const 1296 { 1297 if (__cached_size_ == -1) 1298 { 1299 if (__left_) 1300 const_cast<long&>(__cached_size_) = static_cast<long>( 1301 __left_->size() + 7 + 1302 __right_->size()); 1303 else 1304 const_cast<long&>(__cached_size_) = sizeof("operator^") - 1; 1305 } 1306 return static_cast<size_t>(__cached_size_); 1307 } 1308 virtual char* first_demangled_name(char* buf) const 1309 { 1310 if (__left_) 1311 { 1312 *buf++ = '('; 1313 buf = __left_->get_demangled_name(buf); 1314 strncpy(buf, ") ^ (", 5); 1315 buf += 5; 1316 buf = __right_->get_demangled_name(buf); 1317 *buf++ = ')'; 1318 } 1319 else 1320 { 1321 strncpy(buf, "operator^", sizeof("operator^") - 1); 1322 buf += sizeof("operator^") - 1; 1323 } 1324 return buf; 1325 } 1326 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1327 { 1328 bool r = true; 1329 if (__left_) 1330 r = r && __left_->fix_forward_references(t_begin, t_end); 1331 if (__right_) 1332 r = r && __right_->fix_forward_references(t_begin, t_end); 1333 return r; 1334 } 1335 }; 1336 1337 class __operator_xor_equal 1338 : public __node 1339 { 1340 public: 1341 1342 __operator_xor_equal() {} 1343 __operator_xor_equal(__node* op1, __node* op2) 1344 { 1345 __left_ = op1; 1346 __right_ = op2; 1347 } 1348 virtual size_t first_size() const 1349 { 1350 if (__cached_size_ == -1) 1351 { 1352 if (__left_) 1353 const_cast<long&>(__cached_size_) = static_cast<long>( 1354 __left_->size() + 8 + 1355 __right_->size()); 1356 else 1357 const_cast<long&>(__cached_size_) = sizeof("operator^=") - 1; 1358 } 1359 return static_cast<size_t>(__cached_size_); 1360 } 1361 virtual char* first_demangled_name(char* buf) const 1362 { 1363 if (__left_) 1364 { 1365 *buf++ = '('; // strncpy(buf, "(", 1); 1366 buf = __left_->get_demangled_name(buf); 1367 strncpy(buf, ") ^= (", 6); 1368 buf += 6; 1369 buf = __right_->get_demangled_name(buf); 1370 *buf++ = ')'; 1371 } 1372 else 1373 { 1374 strncpy(buf, "operator^=", sizeof("operator^=") - 1); 1375 buf += sizeof("operator^=") - 1; 1376 } 1377 return buf; 1378 } 1379 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1380 { 1381 bool r = true; 1382 if (__left_) 1383 r = r && __left_->fix_forward_references(t_begin, t_end); 1384 if (__right_) 1385 r = r && __right_->fix_forward_references(t_begin, t_end); 1386 return r; 1387 } 1388 }; 1389 1390 class __operator_equality 1391 : public __node 1392 { 1393 public: 1394 1395 __operator_equality() {} 1396 __operator_equality(__node* op1, __node* op2) 1397 { 1398 __left_ = op1; 1399 __right_ = op2; 1400 } 1401 virtual size_t first_size() const 1402 { 1403 if (__cached_size_ == -1) 1404 { 1405 if (__left_) 1406 const_cast<long&>(__cached_size_) = static_cast<long>( 1407 __left_->size() + 8 + 1408 __right_->size()); 1409 else 1410 const_cast<long&>(__cached_size_) = sizeof("operator==") - 1; 1411 } 1412 return static_cast<size_t>(__cached_size_); 1413 } 1414 virtual char* first_demangled_name(char* buf) const 1415 { 1416 if (__left_) 1417 { 1418 *buf++ = '('; 1419 buf = __left_->get_demangled_name(buf); 1420 strncpy(buf, ") == (", 6); 1421 buf += 6; 1422 buf = __right_->get_demangled_name(buf); 1423 *buf++ = ')'; 1424 } 1425 else 1426 { 1427 strncpy(buf, "operator==", sizeof("operator==") - 1); 1428 buf += sizeof("operator==") - 1; 1429 } 1430 return buf; 1431 } 1432 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1433 { 1434 bool r = true; 1435 if (__left_) 1436 r = r && __left_->fix_forward_references(t_begin, t_end); 1437 if (__right_) 1438 r = r && __right_->fix_forward_references(t_begin, t_end); 1439 return r; 1440 } 1441 }; 1442 1443 class __operator_greater_equal 1444 : public __node 1445 { 1446 public: 1447 1448 __operator_greater_equal() {} 1449 __operator_greater_equal(__node* op1, __node* op2) 1450 { 1451 __left_ = op1; 1452 __right_ = op2; 1453 } 1454 virtual size_t first_size() const 1455 { 1456 if (__cached_size_ == -1) 1457 { 1458 if (__left_) 1459 const_cast<long&>(__cached_size_) = static_cast<long>( 1460 __left_->size() + 8 + 1461 __right_->size()); 1462 else 1463 const_cast<long&>(__cached_size_) = sizeof("operator>=") - 1; 1464 } 1465 return static_cast<size_t>(__cached_size_); 1466 } 1467 virtual char* first_demangled_name(char* buf) const 1468 { 1469 if (__left_) 1470 { 1471 *buf++ = '('; 1472 buf = __left_->get_demangled_name(buf); 1473 strncpy(buf, ") >= (", 6); 1474 buf += 6; 1475 buf = __right_->get_demangled_name(buf); 1476 *buf++ = ')'; 1477 } 1478 else 1479 { 1480 strncpy(buf, "operator>=", sizeof("operator>=") - 1); 1481 buf += sizeof("operator>=") - 1; 1482 } 1483 return buf; 1484 } 1485 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1486 { 1487 bool r = true; 1488 if (__left_) 1489 r = r && __left_->fix_forward_references(t_begin, t_end); 1490 if (__right_) 1491 r = r && __right_->fix_forward_references(t_begin, t_end); 1492 return r; 1493 } 1494 }; 1495 1496 class __operator_greater 1497 : public __node 1498 { 1499 public: 1500 1501 __operator_greater() {} 1502 __operator_greater(__node* op1, __node* op2) 1503 { 1504 __left_ = op1; 1505 __right_ = op2; 1506 } 1507 virtual size_t first_size() const 1508 { 1509 if (__cached_size_ == -1) 1510 { 1511 if (__left_) 1512 const_cast<long&>(__cached_size_) = static_cast<long>( 1513 __left_->size() + 9 + 1514 __right_->size()); 1515 else 1516 const_cast<long&>(__cached_size_) = sizeof("operator>") - 1; 1517 } 1518 return static_cast<size_t>(__cached_size_); 1519 } 1520 virtual char* first_demangled_name(char* buf) const 1521 { 1522 if (__left_) 1523 { 1524 *buf++ = '('; 1525 *buf++ = '('; 1526 buf = __left_->get_demangled_name(buf); 1527 strncpy(buf, ") > (", 5); 1528 buf += 5; 1529 buf = __right_->get_demangled_name(buf); 1530 *buf++ = ')'; 1531 *buf++ = ')'; 1532 } 1533 else 1534 { 1535 strncpy(buf, "operator>", sizeof("operator>") - 1); 1536 buf += sizeof("operator>") - 1; 1537 } 1538 return buf; 1539 } 1540 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1541 { 1542 bool r = true; 1543 if (__left_) 1544 r = r && __left_->fix_forward_references(t_begin, t_end); 1545 if (__right_) 1546 r = r && __right_->fix_forward_references(t_begin, t_end); 1547 return r; 1548 } 1549 }; 1550 1551 class __operator_brackets 1552 : public __node 1553 { 1554 public: 1555 1556 virtual size_t first_size() const {return sizeof("operator[]") - 1;} 1557 virtual char* first_demangled_name(char* buf) const 1558 { 1559 strncpy(buf, "operator[]", sizeof("operator[]") - 1); 1560 return buf + sizeof("operator[]") - 1; 1561 } 1562 }; 1563 1564 class __operator_less_equal 1565 : public __node 1566 { 1567 public: 1568 1569 __operator_less_equal() {} 1570 __operator_less_equal(__node* op1, __node* op2) 1571 { 1572 __left_ = op1; 1573 __right_ = op2; 1574 } 1575 virtual size_t first_size() const 1576 { 1577 if (__cached_size_ == -1) 1578 { 1579 if (__left_) 1580 const_cast<long&>(__cached_size_) = static_cast<long>( 1581 __left_->size() + 8 + 1582 __right_->size()); 1583 else 1584 const_cast<long&>(__cached_size_) = sizeof("operator<=") - 1; 1585 } 1586 return static_cast<size_t>(__cached_size_); 1587 } 1588 virtual char* first_demangled_name(char* buf) const 1589 { 1590 if (__left_) 1591 { 1592 *buf++ = '('; 1593 buf = __left_->get_demangled_name(buf); 1594 strncpy(buf, ") <= (", 6); 1595 buf += 6; 1596 buf = __right_->get_demangled_name(buf); 1597 *buf++ = ')'; 1598 } 1599 else 1600 { 1601 strncpy(buf, "operator<=", sizeof("operator<=") - 1); 1602 buf += sizeof("operator<=") - 1; 1603 } 1604 return buf; 1605 } 1606 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1607 { 1608 bool r = true; 1609 if (__left_) 1610 r = r && __left_->fix_forward_references(t_begin, t_end); 1611 if (__right_) 1612 r = r && __right_->fix_forward_references(t_begin, t_end); 1613 return r; 1614 } 1615 }; 1616 1617 class __operator_less 1618 : public __node 1619 { 1620 public: 1621 1622 __operator_less() {} 1623 __operator_less(__node* op1, __node* op2) 1624 { 1625 __left_ = op1; 1626 __right_ = op2; 1627 } 1628 virtual size_t first_size() const 1629 { 1630 if (__cached_size_ == -1) 1631 { 1632 if (__left_) 1633 const_cast<long&>(__cached_size_) = static_cast<long>( 1634 __left_->size() + 7 + 1635 __right_->size()); 1636 else 1637 const_cast<long&>(__cached_size_) = sizeof("operator<") - 1; 1638 } 1639 return static_cast<size_t>(__cached_size_); 1640 } 1641 virtual char* first_demangled_name(char* buf) const 1642 { 1643 if (__left_) 1644 { 1645 *buf++ = '('; 1646 buf = __left_->get_demangled_name(buf); 1647 strncpy(buf, ") < (", 5); 1648 buf += 5; 1649 buf = __right_->get_demangled_name(buf); 1650 *buf++ = ')'; 1651 } 1652 else 1653 { 1654 strncpy(buf, "operator<", sizeof("operator<") - 1); 1655 buf += sizeof("operator<") - 1; 1656 } 1657 return buf; 1658 } 1659 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1660 { 1661 bool r = true; 1662 if (__left_) 1663 r = r && __left_->fix_forward_references(t_begin, t_end); 1664 if (__right_) 1665 r = r && __right_->fix_forward_references(t_begin, t_end); 1666 return r; 1667 } 1668 }; 1669 1670 class __operator_left_shift 1671 : public __node 1672 { 1673 public: 1674 1675 __operator_left_shift() {} 1676 __operator_left_shift(__node* op1, __node* op2) 1677 { 1678 __left_ = op1; 1679 __right_ = op2; 1680 } 1681 virtual size_t first_size() const 1682 { 1683 if (__cached_size_ == -1) 1684 { 1685 if (__left_) 1686 const_cast<long&>(__cached_size_) = static_cast<long>( 1687 __left_->size() + 8 + 1688 __right_->size()); 1689 else 1690 const_cast<long&>(__cached_size_) = sizeof("operator<<") - 1; 1691 } 1692 return static_cast<size_t>(__cached_size_); 1693 } 1694 virtual char* first_demangled_name(char* buf) const 1695 { 1696 if (__left_) 1697 { 1698 *buf++ = '('; 1699 buf = __left_->get_demangled_name(buf); 1700 strncpy(buf, ") << (", 6); 1701 buf += 6; 1702 buf = __right_->get_demangled_name(buf); 1703 *buf++ = ')'; 1704 } 1705 else 1706 { 1707 strncpy(buf, "operator<<", sizeof("operator<<") - 1); 1708 buf += sizeof("operator<<") - 1; 1709 } 1710 return buf; 1711 } 1712 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1713 { 1714 bool r = true; 1715 if (__left_) 1716 r = r && __left_->fix_forward_references(t_begin, t_end); 1717 if (__right_) 1718 r = r && __right_->fix_forward_references(t_begin, t_end); 1719 return r; 1720 } 1721 }; 1722 1723 class __operator_left_shift_equal 1724 : public __node 1725 { 1726 public: 1727 1728 __operator_left_shift_equal() {} 1729 __operator_left_shift_equal(__node* op1, __node* op2) 1730 { 1731 __left_ = op1; 1732 __right_ = op2; 1733 } 1734 virtual size_t first_size() const 1735 { 1736 if (__cached_size_ == -1) 1737 { 1738 if (__left_) 1739 const_cast<long&>(__cached_size_) = static_cast<long>( 1740 __left_->size() + 9 + 1741 __right_->size()); 1742 else 1743 const_cast<long&>(__cached_size_) = sizeof("operator<<=") - 1; 1744 } 1745 return static_cast<size_t>(__cached_size_); 1746 } 1747 virtual char* first_demangled_name(char* buf) const 1748 { 1749 if (__left_) 1750 { 1751 *buf++ = '('; 1752 buf = __left_->get_demangled_name(buf); 1753 strncpy(buf, ") <<= (", 7); 1754 buf += 7; 1755 buf = __right_->get_demangled_name(buf); 1756 *buf++ = ')'; 1757 } 1758 else 1759 { 1760 strncpy(buf, "operator<<=", sizeof("operator<<=") - 1); 1761 buf += sizeof("operator<<=") - 1; 1762 } 1763 return buf; 1764 } 1765 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1766 { 1767 bool r = true; 1768 if (__left_) 1769 r = r && __left_->fix_forward_references(t_begin, t_end); 1770 if (__right_) 1771 r = r && __right_->fix_forward_references(t_begin, t_end); 1772 return r; 1773 } 1774 }; 1775 1776 class __operator_minus 1777 : public __node 1778 { 1779 public: 1780 1781 __operator_minus() {} 1782 __operator_minus(__node* op1, __node* op2) 1783 { 1784 __left_ = op1; 1785 __right_ = op2; 1786 } 1787 virtual size_t first_size() const 1788 { 1789 if (__cached_size_ == -1) 1790 { 1791 if (__left_) 1792 const_cast<long&>(__cached_size_) = static_cast<long>( 1793 __left_->size() + 7 + 1794 __right_->size()); 1795 else 1796 const_cast<long&>(__cached_size_) = sizeof("operator-") - 1; 1797 } 1798 return static_cast<size_t>(__cached_size_); 1799 } 1800 virtual char* first_demangled_name(char* buf) const 1801 { 1802 if (__left_) 1803 { 1804 *buf++ = '('; 1805 buf = __left_->get_demangled_name(buf); 1806 strncpy(buf, ") - (", 5); 1807 buf += 5; 1808 buf = __right_->get_demangled_name(buf); 1809 *buf++ = ')'; 1810 } 1811 else 1812 { 1813 strncpy(buf, "operator-", sizeof("operator-") - 1); 1814 buf += sizeof("operator-") - 1; 1815 } 1816 return buf; 1817 } 1818 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1819 { 1820 bool r = true; 1821 if (__left_) 1822 r = r && __left_->fix_forward_references(t_begin, t_end); 1823 if (__right_) 1824 r = r && __right_->fix_forward_references(t_begin, t_end); 1825 return r; 1826 } 1827 }; 1828 1829 class __operator_minus_equal 1830 : public __node 1831 { 1832 public: 1833 1834 __operator_minus_equal() {} 1835 __operator_minus_equal(__node* op1, __node* op2) 1836 { 1837 __left_ = op1; 1838 __right_ = op2; 1839 } 1840 virtual size_t first_size() const 1841 { 1842 if (__cached_size_ == -1) 1843 { 1844 if (__left_) 1845 const_cast<long&>(__cached_size_) = static_cast<long>( 1846 __left_->size() + 8 + 1847 __right_->size()); 1848 else 1849 const_cast<long&>(__cached_size_) = sizeof("operator-=") - 1; 1850 } 1851 return static_cast<size_t>(__cached_size_); 1852 } 1853 virtual char* first_demangled_name(char* buf) const 1854 { 1855 if (__left_) 1856 { 1857 *buf++ = '('; 1858 buf = __left_->get_demangled_name(buf); 1859 strncpy(buf, ") -= (", 6); 1860 buf += 6; 1861 buf = __right_->get_demangled_name(buf); 1862 *buf++ = ')'; 1863 } 1864 else 1865 { 1866 strncpy(buf, "operator-=", sizeof("operator-=") - 1); 1867 buf += sizeof("operator-=") - 1; 1868 } 1869 return buf; 1870 } 1871 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1872 { 1873 bool r = true; 1874 if (__left_) 1875 r = r && __left_->fix_forward_references(t_begin, t_end); 1876 if (__right_) 1877 r = r && __right_->fix_forward_references(t_begin, t_end); 1878 return r; 1879 } 1880 }; 1881 1882 class __operator_times 1883 : public __node 1884 { 1885 public: 1886 1887 __operator_times() {} 1888 __operator_times(__node* op1, __node* op2) 1889 { 1890 __left_ = op1; 1891 __right_ = op2; 1892 } 1893 virtual size_t first_size() const 1894 { 1895 if (__cached_size_ == -1) 1896 { 1897 if (__left_) 1898 const_cast<long&>(__cached_size_) = static_cast<long>( 1899 __left_->size() + 7 + 1900 __right_->size()); 1901 else 1902 const_cast<long&>(__cached_size_) = sizeof("operator*") - 1; 1903 } 1904 return static_cast<size_t>(__cached_size_); 1905 } 1906 virtual char* first_demangled_name(char* buf) const 1907 { 1908 if (__left_) 1909 { 1910 *buf++ = '('; 1911 buf = __left_->get_demangled_name(buf); 1912 strncpy(buf, ") * (", 5); 1913 buf += 5; 1914 buf = __right_->get_demangled_name(buf); 1915 *buf++ = ')'; 1916 } 1917 else 1918 { 1919 strncpy(buf, "operator*", sizeof("operator*") - 1); 1920 buf += sizeof("operator*") - 1; 1921 } 1922 return buf; 1923 } 1924 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1925 { 1926 bool r = true; 1927 if (__left_) 1928 r = r && __left_->fix_forward_references(t_begin, t_end); 1929 if (__right_) 1930 r = r && __right_->fix_forward_references(t_begin, t_end); 1931 return r; 1932 } 1933 }; 1934 1935 class __operator_times_equal 1936 : public __node 1937 { 1938 public: 1939 1940 __operator_times_equal() {} 1941 __operator_times_equal(__node* op1, __node* op2) 1942 { 1943 __left_ = op1; 1944 __right_ = op2; 1945 } 1946 virtual size_t first_size() const 1947 { 1948 if (__cached_size_ == -1) 1949 { 1950 if (__left_) 1951 const_cast<long&>(__cached_size_) = static_cast<long>( 1952 __left_->size() + 8 + 1953 __right_->size()); 1954 else 1955 const_cast<long&>(__cached_size_) = sizeof("operator*=") - 1; 1956 } 1957 return static_cast<size_t>(__cached_size_); 1958 } 1959 virtual char* first_demangled_name(char* buf) const 1960 { 1961 if (__left_) 1962 { 1963 *buf++ = '('; 1964 buf = __left_->get_demangled_name(buf); 1965 strncpy(buf, ") *= (", 6); 1966 buf += 6; 1967 buf = __right_->get_demangled_name(buf); 1968 *buf++ = ')'; 1969 } 1970 else 1971 { 1972 strncpy(buf, "operator*=", sizeof("operator*=") - 1); 1973 buf += sizeof("operator*=") - 1; 1974 } 1975 return buf; 1976 } 1977 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1978 { 1979 bool r = true; 1980 if (__left_) 1981 r = r && __left_->fix_forward_references(t_begin, t_end); 1982 if (__right_) 1983 r = r && __right_->fix_forward_references(t_begin, t_end); 1984 return r; 1985 } 1986 }; 1987 1988 class __operator_decrement 1989 : public __node 1990 { 1991 public: 1992 1993 __operator_decrement() {} 1994 explicit __operator_decrement(bool prefix, __node* op) 1995 { 1996 __size_ = prefix; 1997 __left_ = op; 1998 } 1999 virtual size_t first_size() const 2000 { 2001 if (__cached_size_ == -1) 2002 { 2003 if (__left_) 2004 const_cast<long&>(__cached_size_) = static_cast<long>(4 + __left_->size()); 2005 else 2006 const_cast<long&>(__cached_size_) = sizeof("operator--") - 1; 2007 } 2008 return static_cast<size_t>(__cached_size_); 2009 } 2010 virtual char* first_demangled_name(char* buf) const 2011 { 2012 if (__left_) 2013 { 2014 if (__size_) 2015 { 2016 *buf++ = '-'; 2017 *buf++ = '-'; 2018 *buf++ = '('; 2019 } 2020 else 2021 *buf++ = '('; 2022 buf = __left_->get_demangled_name(buf); 2023 if (__size_) 2024 *buf++ = ')'; 2025 else 2026 { 2027 *buf++ = ')'; 2028 *buf++ = '-'; 2029 *buf++ = '-'; 2030 } 2031 } 2032 else 2033 { 2034 strncpy(buf, "operator--", sizeof("operator--") - 1); 2035 buf += sizeof("operator--") - 1; 2036 } 2037 return buf; 2038 } 2039 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2040 { 2041 if (__left_) 2042 return __left_->fix_forward_references(t_begin, t_end); 2043 return true; 2044 } 2045 }; 2046 2047 class __operator_not_equal 2048 : public __node 2049 { 2050 public: 2051 2052 __operator_not_equal() {} 2053 __operator_not_equal(__node* op1, __node* op2) 2054 { 2055 __left_ = op1; 2056 __right_ = op2; 2057 } 2058 virtual size_t first_size() const 2059 { 2060 if (__cached_size_ == -1) 2061 { 2062 if (__left_) 2063 const_cast<long&>(__cached_size_) = static_cast<long>( 2064 __left_->size() + 8 + 2065 __right_->size()); 2066 else 2067 const_cast<long&>(__cached_size_) = sizeof("operator!=") - 1; 2068 } 2069 return static_cast<size_t>(__cached_size_); 2070 } 2071 virtual char* first_demangled_name(char* buf) const 2072 { 2073 if (__left_) 2074 { 2075 *buf++ = '('; 2076 buf = __left_->get_demangled_name(buf); 2077 strncpy(buf, ") != (", 6); 2078 buf += 6; 2079 buf = __right_->get_demangled_name(buf); 2080 *buf++ = ')'; 2081 } 2082 else 2083 { 2084 strncpy(buf, "operator!=", sizeof("operator!=") - 1); 2085 buf += sizeof("operator!=") - 1; 2086 } 2087 return buf; 2088 } 2089 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2090 { 2091 bool r = true; 2092 if (__left_) 2093 r = r && __left_->fix_forward_references(t_begin, t_end); 2094 if (__right_) 2095 r = r && __right_->fix_forward_references(t_begin, t_end); 2096 return r; 2097 } 2098 }; 2099 2100 class __operator_negate 2101 : public __node 2102 { 2103 public: 2104 2105 __operator_negate() {} 2106 explicit __operator_negate(__node* op) 2107 { 2108 __left_ = op; 2109 } 2110 virtual size_t first_size() const 2111 { 2112 if (__cached_size_ == -1) 2113 { 2114 if (__left_) 2115 const_cast<long&>(__cached_size_) = static_cast<long>(3 + __left_->size()); 2116 else 2117 const_cast<long&>(__cached_size_) = sizeof("operator-") - 1; 2118 } 2119 return static_cast<size_t>(__cached_size_); 2120 } 2121 virtual char* first_demangled_name(char* buf) const 2122 { 2123 if (__left_) 2124 { 2125 *buf++ = '-'; 2126 *buf++ = '('; 2127 buf = __left_->get_demangled_name(buf); 2128 *buf++ = ')'; 2129 } 2130 else 2131 { 2132 strncpy(buf, "operator-", sizeof("operator-") - 1); 2133 buf += sizeof("operator-") - 1; 2134 } 2135 return buf; 2136 } 2137 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2138 { 2139 if (__left_) 2140 return __left_->fix_forward_references(t_begin, t_end); 2141 return true; 2142 } 2143 }; 2144 2145 class __operator_logical_not 2146 : public __node 2147 { 2148 public: 2149 2150 __operator_logical_not() {} 2151 explicit __operator_logical_not(__node* op) 2152 { 2153 __left_ = op; 2154 } 2155 virtual size_t first_size() const 2156 { 2157 if (__cached_size_ == -1) 2158 { 2159 if (__left_) 2160 const_cast<long&>(__cached_size_) = static_cast<long>(3 + __left_->size()); 2161 else 2162 const_cast<long&>(__cached_size_) = sizeof("operator!") - 1; 2163 } 2164 return static_cast<size_t>(__cached_size_); 2165 } 2166 virtual char* first_demangled_name(char* buf) const 2167 { 2168 if (__left_) 2169 { 2170 *buf++ = '!'; 2171 *buf++ = '('; 2172 buf = __left_->get_demangled_name(buf); 2173 *buf++ = ')'; 2174 } 2175 else 2176 { 2177 strncpy(buf, "operator!", sizeof("operator!") - 1); 2178 buf += sizeof("operator!") - 1; 2179 } 2180 return buf; 2181 } 2182 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2183 { 2184 if (__left_) 2185 return __left_->fix_forward_references(t_begin, t_end); 2186 return true; 2187 } 2188 }; 2189 2190 class __operator_logical_or 2191 : public __node 2192 { 2193 public: 2194 2195 __operator_logical_or() {} 2196 __operator_logical_or(__node* op1, __node* op2) 2197 { 2198 __left_ = op1; 2199 __right_ = op2; 2200 } 2201 virtual size_t first_size() const 2202 { 2203 if (__cached_size_ == -1) 2204 { 2205 if (__left_) 2206 const_cast<long&>(__cached_size_) = static_cast<long>( 2207 __left_->size() + 8 + 2208 __right_->size()); 2209 else 2210 const_cast<long&>(__cached_size_) = sizeof("operator||") - 1; 2211 } 2212 return static_cast<size_t>(__cached_size_); 2213 } 2214 virtual char* first_demangled_name(char* buf) const 2215 { 2216 if (__left_) 2217 { 2218 *buf++ = '('; 2219 buf = __left_->get_demangled_name(buf); 2220 strncpy(buf, ") || (", 6); 2221 buf += 6; 2222 buf = __right_->get_demangled_name(buf); 2223 *buf++ = ')'; 2224 } 2225 else 2226 { 2227 strncpy(buf, "operator||", sizeof("operator||") - 1); 2228 buf += sizeof("operator||") - 1; 2229 } 2230 return buf; 2231 } 2232 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2233 { 2234 bool r = true; 2235 if (__left_) 2236 r = r && __left_->fix_forward_references(t_begin, t_end); 2237 if (__right_) 2238 r = r && __right_->fix_forward_references(t_begin, t_end); 2239 return r; 2240 } 2241 }; 2242 2243 class __operator_bit_or 2244 : public __node 2245 { 2246 public: 2247 2248 __operator_bit_or() {} 2249 __operator_bit_or(__node* op1, __node* op2) 2250 { 2251 __left_ = op1; 2252 __right_ = op2; 2253 } 2254 virtual size_t first_size() const 2255 { 2256 if (__cached_size_ == -1) 2257 { 2258 if (__left_) 2259 const_cast<long&>(__cached_size_) = static_cast<long>( 2260 __left_->size() + 7 + 2261 __right_->size()); 2262 else 2263 const_cast<long&>(__cached_size_) = sizeof("operator|") - 1; 2264 } 2265 return static_cast<size_t>(__cached_size_); 2266 } 2267 virtual char* first_demangled_name(char* buf) const 2268 { 2269 if (__left_) 2270 { 2271 *buf++ = '('; 2272 buf = __left_->get_demangled_name(buf); 2273 strncpy(buf, ") | (", 5); 2274 buf += 5; 2275 buf = __right_->get_demangled_name(buf); 2276 *buf++ = ')'; 2277 } 2278 else 2279 { 2280 strncpy(buf, "operator|", sizeof("operator|") - 1); 2281 buf += sizeof("operator|") - 1; 2282 } 2283 return buf; 2284 } 2285 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2286 { 2287 bool r = true; 2288 if (__left_) 2289 r = r && __left_->fix_forward_references(t_begin, t_end); 2290 if (__right_) 2291 r = r && __right_->fix_forward_references(t_begin, t_end); 2292 return r; 2293 } 2294 }; 2295 2296 class __operator_or_equal 2297 : public __node 2298 { 2299 public: 2300 2301 __operator_or_equal() {} 2302 __operator_or_equal(__node* op1, __node* op2) 2303 { 2304 __left_ = op1; 2305 __right_ = op2; 2306 } 2307 virtual size_t first_size() const 2308 { 2309 if (__cached_size_ == -1) 2310 { 2311 if (__left_) 2312 const_cast<long&>(__cached_size_) = static_cast<long>( 2313 __left_->size() + 8 + 2314 __right_->size()); 2315 else 2316 const_cast<long&>(__cached_size_) = sizeof("operator|=") - 1; 2317 } 2318 return static_cast<size_t>(__cached_size_); 2319 } 2320 virtual char* first_demangled_name(char* buf) const 2321 { 2322 if (__left_) 2323 { 2324 *buf++ = '('; 2325 buf = __left_->get_demangled_name(buf); 2326 strncpy(buf, ") |= (", 6); 2327 buf += 6; 2328 buf = __right_->get_demangled_name(buf); 2329 *buf++ = ')'; 2330 } 2331 else 2332 { 2333 strncpy(buf, "operator|=", sizeof("operator|=") - 1); 2334 buf += sizeof("operator|=") - 1; 2335 } 2336 return buf; 2337 } 2338 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2339 { 2340 bool r = true; 2341 if (__left_) 2342 r = r && __left_->fix_forward_references(t_begin, t_end); 2343 if (__right_) 2344 r = r && __right_->fix_forward_references(t_begin, t_end); 2345 return r; 2346 } 2347 }; 2348 2349 class __operator_pointer_to_member 2350 : public __node 2351 { 2352 public: 2353 2354 __operator_pointer_to_member() {} 2355 __operator_pointer_to_member(__node* op1, __node* op2) 2356 { 2357 __left_ = op1; 2358 __right_ = op2; 2359 } 2360 virtual size_t first_size() const 2361 { 2362 if (__cached_size_ == -1) 2363 { 2364 if (__left_) 2365 const_cast<long&>(__cached_size_) = static_cast<long>( 2366 __left_->size() + 9 + 2367 __right_->size()); 2368 else 2369 const_cast<long&>(__cached_size_) = sizeof("operator->*") - 1; 2370 } 2371 return static_cast<size_t>(__cached_size_); 2372 } 2373 virtual char* first_demangled_name(char* buf) const 2374 { 2375 if (__left_) 2376 { 2377 *buf++ = '('; 2378 buf = __left_->get_demangled_name(buf); 2379 strncpy(buf, ") ->* (", 7); 2380 buf += 7; 2381 buf = __right_->get_demangled_name(buf); 2382 *buf++ = ')'; 2383 } 2384 else 2385 { 2386 strncpy(buf, "operator->*", sizeof("operator->*") - 1); 2387 buf += sizeof("operator->*") - 1; 2388 } 2389 return buf; 2390 } 2391 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2392 { 2393 bool r = true; 2394 if (__left_) 2395 r = r && __left_->fix_forward_references(t_begin, t_end); 2396 if (__right_) 2397 r = r && __right_->fix_forward_references(t_begin, t_end); 2398 return r; 2399 } 2400 }; 2401 2402 class __operator_plus 2403 : public __node 2404 { 2405 public: 2406 2407 __operator_plus() {} 2408 __operator_plus(__node* op1, __node* op2) 2409 { 2410 __left_ = op1; 2411 __right_ = op2; 2412 } 2413 virtual size_t first_size() const 2414 { 2415 if (__cached_size_ == -1) 2416 { 2417 if (__left_) 2418 const_cast<long&>(__cached_size_) = static_cast<long>( 2419 __left_->size() + 7 + 2420 __right_->size()); 2421 else 2422 const_cast<long&>(__cached_size_) = sizeof("operator+") - 1; 2423 } 2424 return static_cast<size_t>(__cached_size_); 2425 } 2426 virtual char* first_demangled_name(char* buf) const 2427 { 2428 if (__left_) 2429 { 2430 *buf++ = '('; 2431 buf = __left_->get_demangled_name(buf); 2432 strncpy(buf, ") + (", 5); 2433 buf += 5; 2434 buf = __right_->get_demangled_name(buf); 2435 *buf++ = ')'; 2436 } 2437 else 2438 { 2439 strncpy(buf, "operator+", sizeof("operator+") - 1); 2440 buf += sizeof("operator+") - 1; 2441 } 2442 return buf; 2443 } 2444 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2445 { 2446 bool r = true; 2447 if (__left_) 2448 r = r && __left_->fix_forward_references(t_begin, t_end); 2449 if (__right_) 2450 r = r && __right_->fix_forward_references(t_begin, t_end); 2451 return r; 2452 } 2453 }; 2454 2455 class __operator_plus_equal 2456 : public __node 2457 { 2458 public: 2459 2460 __operator_plus_equal() {} 2461 __operator_plus_equal(__node* op1, __node* op2) 2462 { 2463 __left_ = op1; 2464 __right_ = op2; 2465 } 2466 virtual size_t first_size() const 2467 { 2468 if (__cached_size_ == -1) 2469 { 2470 if (__left_) 2471 const_cast<long&>(__cached_size_) = static_cast<long>( 2472 __left_->size() + 8 + 2473 __right_->size()); 2474 else 2475 const_cast<long&>(__cached_size_) = sizeof("operator+=") - 1; 2476 } 2477 return static_cast<size_t>(__cached_size_); 2478 } 2479 virtual char* first_demangled_name(char* buf) const 2480 { 2481 if (__left_) 2482 { 2483 *buf++ = '('; 2484 buf = __left_->get_demangled_name(buf); 2485 strncpy(buf, ") += (", 6); 2486 buf += 6; 2487 buf = __right_->get_demangled_name(buf); 2488 *buf++ = ')'; 2489 } 2490 else 2491 { 2492 strncpy(buf, "operator+=", sizeof("operator+=") - 1); 2493 buf += sizeof("operator+=") - 1; 2494 } 2495 return buf; 2496 } 2497 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2498 { 2499 bool r = true; 2500 if (__left_) 2501 r = r && __left_->fix_forward_references(t_begin, t_end); 2502 if (__right_) 2503 r = r && __right_->fix_forward_references(t_begin, t_end); 2504 return r; 2505 } 2506 }; 2507 2508 class __operator_increment 2509 : public __node 2510 { 2511 public: 2512 2513 __operator_increment() {} 2514 explicit __operator_increment(bool prefix, __node* op) 2515 { 2516 __size_ = prefix; 2517 __left_ = op; 2518 } 2519 virtual size_t first_size() const 2520 { 2521 if (__cached_size_ == -1) 2522 { 2523 if (__left_) 2524 const_cast<long&>(__cached_size_) = static_cast<long>(4 + __left_->size()); 2525 else 2526 const_cast<long&>(__cached_size_) = sizeof("operator++") - 1; 2527 } 2528 return static_cast<size_t>(__cached_size_); 2529 } 2530 virtual char* first_demangled_name(char* buf) const 2531 { 2532 if (__left_) 2533 { 2534 if (__size_) 2535 { 2536 *buf++ = '+'; 2537 *buf++ = '+'; 2538 *buf++ = '('; 2539 } 2540 else 2541 *buf++ = '('; 2542 buf = __left_->get_demangled_name(buf); 2543 if (__size_) 2544 *buf++ = ')'; 2545 else 2546 { 2547 *buf++ = ')'; 2548 *buf++ = '+'; 2549 *buf++ = '+'; 2550 } 2551 } 2552 else 2553 { 2554 strncpy(buf, "operator++", sizeof("operator++") - 1); 2555 buf += sizeof("operator++") - 1; 2556 } 2557 return buf; 2558 } 2559 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2560 { 2561 if (__left_) 2562 return __left_->fix_forward_references(t_begin, t_end); 2563 return true; 2564 } 2565 }; 2566 2567 class __operator_unary_plus 2568 : public __node 2569 { 2570 public: 2571 2572 __operator_unary_plus() {} 2573 explicit __operator_unary_plus(__node* op) 2574 { 2575 __left_ = op; 2576 } 2577 virtual size_t first_size() const 2578 { 2579 if (__cached_size_ == -1) 2580 { 2581 if (__left_) 2582 const_cast<long&>(__cached_size_) = static_cast<long>(3 + __left_->size()); 2583 else 2584 const_cast<long&>(__cached_size_) = sizeof("operator+") - 1; 2585 } 2586 return static_cast<size_t>(__cached_size_); 2587 } 2588 virtual char* first_demangled_name(char* buf) const 2589 { 2590 if (__left_) 2591 { 2592 *buf++ = '+'; 2593 *buf++ = '('; 2594 buf = __left_->get_demangled_name(buf); 2595 *buf++ = ')'; 2596 } 2597 else 2598 { 2599 strncpy(buf, "operator+", sizeof("operator+") - 1); 2600 buf += sizeof("operator+") - 1; 2601 } 2602 return buf; 2603 } 2604 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2605 { 2606 if (__left_) 2607 return __left_->fix_forward_references(t_begin, t_end); 2608 return true; 2609 } 2610 }; 2611 2612 class __operator_arrow 2613 : public __node 2614 { 2615 public: 2616 2617 __operator_arrow() {} 2618 __operator_arrow(__node* op1, __node* op2) 2619 { 2620 __left_ = op1; 2621 __right_ = op2; 2622 } 2623 virtual size_t first_size() const 2624 { 2625 if (__cached_size_ == -1) 2626 { 2627 if (__left_) 2628 const_cast<long&>(__cached_size_) = static_cast<long>( 2629 __left_->size() + 8 + 2630 __right_->size()); 2631 else 2632 const_cast<long&>(__cached_size_) = sizeof("operator->") - 1; 2633 } 2634 return static_cast<size_t>(__cached_size_); 2635 } 2636 virtual char* first_demangled_name(char* buf) const 2637 { 2638 if (__left_) 2639 { 2640 *buf++ = '('; 2641 buf = __left_->get_demangled_name(buf); 2642 strncpy(buf, ") -> (", 6); 2643 buf += 6; 2644 buf = __right_->get_demangled_name(buf); 2645 *buf++ = ')'; 2646 } 2647 else 2648 { 2649 strncpy(buf, "operator->", sizeof("operator->") - 1); 2650 buf += sizeof("operator->") - 1; 2651 } 2652 return buf; 2653 } 2654 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2655 { 2656 bool r = true; 2657 if (__left_) 2658 r = r && __left_->fix_forward_references(t_begin, t_end); 2659 if (__right_) 2660 r = r && __right_->fix_forward_references(t_begin, t_end); 2661 return r; 2662 } 2663 }; 2664 2665 class __operator_conditional 2666 : public __node 2667 { 2668 public: 2669 2670 __operator_conditional() {} 2671 __operator_conditional(__node* op1, __node* op2, __node* op3) 2672 { 2673 __name_ = (const char*)op1; 2674 __left_ = op2; 2675 __right_ = op3; 2676 } 2677 virtual size_t first_size() const 2678 { 2679 if (__cached_size_ == -1) 2680 { 2681 if (__left_) 2682 { 2683 __node* op1 = (__node*)__name_; 2684 const_cast<long&>(__cached_size_) = static_cast<long>( 2685 op1->size() + 2686 __left_->size() + 12 + 2687 __right_->size()); 2688 } 2689 else 2690 const_cast<long&>(__cached_size_) = sizeof("operator?") - 1; 2691 } 2692 return static_cast<size_t>(__cached_size_); 2693 } 2694 virtual char* first_demangled_name(char* buf) const 2695 { 2696 if (__left_) 2697 { 2698 __node* op1 = (__node*)__name_; 2699 *buf++ = '('; 2700 buf = op1->get_demangled_name(buf); 2701 strncpy(buf, ") ? (", 5); 2702 buf += 5; 2703 buf = __left_->get_demangled_name(buf); 2704 strncpy(buf, ") : (", 5); 2705 buf += 5; 2706 buf = __right_->get_demangled_name(buf); 2707 *buf++ = ')'; 2708 } 2709 else 2710 { 2711 strncpy(buf, "operator?", sizeof("operator?") - 1); 2712 buf += sizeof("operator?") - 1; 2713 } 2714 return buf; 2715 } 2716 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2717 { 2718 bool r = true; 2719 if (__name_) 2720 r = r && ((__node*)__name_)->fix_forward_references(t_begin, t_end); 2721 if (__left_) 2722 r = r && __left_->fix_forward_references(t_begin, t_end); 2723 if (__right_) 2724 r = r && __right_->fix_forward_references(t_begin, t_end); 2725 return r; 2726 } 2727 }; 2728 2729 class __operator_mod 2730 : public __node 2731 { 2732 public: 2733 2734 __operator_mod() {} 2735 __operator_mod(__node* op1, __node* op2) 2736 { 2737 __left_ = op1; 2738 __right_ = op2; 2739 } 2740 virtual size_t first_size() const 2741 { 2742 if (__cached_size_ == -1) 2743 { 2744 if (__left_) 2745 const_cast<long&>(__cached_size_) = static_cast<long>( 2746 __left_->size() + 7 + 2747 __right_->size()); 2748 else 2749 const_cast<long&>(__cached_size_) = sizeof("operator%") - 1; 2750 } 2751 return static_cast<size_t>(__cached_size_); 2752 } 2753 virtual char* first_demangled_name(char* buf) const 2754 { 2755 if (__left_) 2756 { 2757 *buf++ = '('; 2758 buf = __left_->get_demangled_name(buf); 2759 strncpy(buf, ") % (", 5); 2760 buf += 5; 2761 buf = __right_->get_demangled_name(buf); 2762 *buf++ = ')'; 2763 } 2764 else 2765 { 2766 strncpy(buf, "operator%", sizeof("operator%") - 1); 2767 buf += sizeof("operator%") - 1; 2768 } 2769 return buf; 2770 } 2771 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2772 { 2773 bool r = true; 2774 if (__left_) 2775 r = r && __left_->fix_forward_references(t_begin, t_end); 2776 if (__right_) 2777 r = r && __right_->fix_forward_references(t_begin, t_end); 2778 return r; 2779 } 2780 }; 2781 2782 class __operator_mod_equal 2783 : public __node 2784 { 2785 public: 2786 2787 __operator_mod_equal() {} 2788 __operator_mod_equal(__node* op1, __node* op2) 2789 { 2790 __left_ = op1; 2791 __right_ = op2; 2792 } 2793 virtual size_t first_size() const 2794 { 2795 if (__cached_size_ == -1) 2796 { 2797 if (__left_) 2798 const_cast<long&>(__cached_size_) = static_cast<long>( 2799 __left_->size() + 8 + 2800 __right_->size()); 2801 else 2802 const_cast<long&>(__cached_size_) = sizeof("operator%=") - 1; 2803 } 2804 return static_cast<size_t>(__cached_size_); 2805 } 2806 virtual char* first_demangled_name(char* buf) const 2807 { 2808 if (__left_) 2809 { 2810 *buf++ = '('; 2811 buf = __left_->get_demangled_name(buf); 2812 strncpy(buf, ") %= (", 6); 2813 buf += 6; 2814 buf = __right_->get_demangled_name(buf); 2815 *buf++ = ')'; 2816 } 2817 else 2818 { 2819 strncpy(buf, "operator%=", sizeof("operator%=") - 1); 2820 buf += sizeof("operator%=") - 1; 2821 } 2822 return buf; 2823 } 2824 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2825 { 2826 bool r = true; 2827 if (__left_) 2828 r = r && __left_->fix_forward_references(t_begin, t_end); 2829 if (__right_) 2830 r = r && __right_->fix_forward_references(t_begin, t_end); 2831 return r; 2832 } 2833 }; 2834 2835 class __operator_right_shift 2836 : public __node 2837 { 2838 public: 2839 2840 __operator_right_shift() {} 2841 __operator_right_shift(__node* op1, __node* op2) 2842 { 2843 __left_ = op1; 2844 __right_ = op2; 2845 } 2846 virtual size_t first_size() const 2847 { 2848 if (__cached_size_ == -1) 2849 { 2850 if (__left_) 2851 const_cast<long&>(__cached_size_) = static_cast<long>( 2852 __left_->size() + 8 + 2853 __right_->size()); 2854 else 2855 const_cast<long&>(__cached_size_) = sizeof("operator>>") - 1; 2856 } 2857 return static_cast<size_t>(__cached_size_); 2858 } 2859 virtual char* first_demangled_name(char* buf) const 2860 { 2861 if (__left_) 2862 { 2863 *buf++ = '('; 2864 buf = __left_->get_demangled_name(buf); 2865 strncpy(buf, ") >> (", 6); 2866 buf += 6; 2867 buf = __right_->get_demangled_name(buf); 2868 *buf++ = ')'; 2869 } 2870 else 2871 { 2872 strncpy(buf, "operator>>", sizeof("operator>>") - 1); 2873 buf += sizeof("operator>>") - 1; 2874 } 2875 return buf; 2876 } 2877 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2878 { 2879 bool r = true; 2880 if (__left_) 2881 r = r && __left_->fix_forward_references(t_begin, t_end); 2882 if (__right_) 2883 r = r && __right_->fix_forward_references(t_begin, t_end); 2884 return r; 2885 } 2886 }; 2887 2888 class __operator_right_shift_equal 2889 : public __node 2890 { 2891 public: 2892 2893 __operator_right_shift_equal() {} 2894 __operator_right_shift_equal(__node* op1, __node* op2) 2895 { 2896 __left_ = op1; 2897 __right_ = op2; 2898 } 2899 virtual size_t first_size() const 2900 { 2901 if (__cached_size_ == -1) 2902 { 2903 if (__left_) 2904 const_cast<long&>(__cached_size_) = static_cast<long>( 2905 __left_->size() + 9 + 2906 __right_->size()); 2907 else 2908 const_cast<long&>(__cached_size_) = sizeof("operator>>=") - 1; 2909 } 2910 return static_cast<size_t>(__cached_size_); 2911 } 2912 virtual char* first_demangled_name(char* buf) const 2913 { 2914 if (__left_) 2915 { 2916 *buf++ = '('; 2917 buf = __left_->get_demangled_name(buf); 2918 strncpy(buf, ") >>= (", 7); 2919 buf += 7; 2920 buf = __right_->get_demangled_name(buf); 2921 *buf++ = ')'; 2922 } 2923 else 2924 { 2925 strncpy(buf, "operator>>=", sizeof("operator>>=") - 1); 2926 buf += sizeof("operator>>=") - 1; 2927 } 2928 return buf; 2929 } 2930 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2931 { 2932 bool r = true; 2933 if (__left_) 2934 r = r && __left_->fix_forward_references(t_begin, t_end); 2935 if (__right_) 2936 r = r && __right_->fix_forward_references(t_begin, t_end); 2937 return r; 2938 } 2939 }; 2940 2941 class __operator_sizeof_type 2942 : public __node 2943 { 2944 public: 2945 2946 __operator_sizeof_type() {} 2947 __operator_sizeof_type(__node* op) 2948 { 2949 __right_ = op; 2950 } 2951 virtual size_t first_size() const 2952 { 2953 if (__cached_size_ == -1) 2954 { 2955 if (__right_) 2956 const_cast<long&>(__cached_size_) = static_cast<long>(__right_->size() + 9); 2957 else 2958 const_cast<long&>(__cached_size_) = sizeof("operator sizeof") - 1; 2959 } 2960 return static_cast<size_t>(__cached_size_); 2961 } 2962 virtual char* first_demangled_name(char* buf) const 2963 { 2964 if (__right_) 2965 { 2966 strncpy(buf, "sizeof (", 8); 2967 buf += 8; 2968 buf = __right_->get_demangled_name(buf); 2969 *buf++ = ')'; 2970 } 2971 else 2972 { 2973 strncpy(buf, "operator sizeof", sizeof("operator sizeof") - 1); 2974 buf += sizeof("operator sizeof") - 1; 2975 } 2976 return buf; 2977 } 2978 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2979 { 2980 if (__right_) 2981 return __right_->fix_forward_references(t_begin, t_end); 2982 return true; 2983 } 2984 }; 2985 2986 class __operator_sizeof_expression 2987 : public __node 2988 { 2989 public: 2990 2991 __operator_sizeof_expression() {} 2992 __operator_sizeof_expression(__node* op) 2993 { 2994 __right_ = op; 2995 } 2996 virtual size_t first_size() const 2997 { 2998 if (__cached_size_ == -1) 2999 { 3000 if (__right_) 3001 const_cast<long&>(__cached_size_) = static_cast<long>(__right_->size() + 9); 3002 else 3003 const_cast<long&>(__cached_size_) = sizeof("operator sizeof") - 1; 3004 } 3005 return static_cast<size_t>(__cached_size_); 3006 } 3007 virtual char* first_demangled_name(char* buf) const 3008 { 3009 if (__right_) 3010 { 3011 strncpy(buf, "sizeof (", 8); 3012 buf += 8; 3013 buf = __right_->get_demangled_name(buf); 3014 *buf++ = ')'; 3015 } 3016 else 3017 { 3018 strncpy(buf, "operator sizeof", sizeof("operator sizeof") - 1); 3019 buf += sizeof("operator sizeof") - 1; 3020 } 3021 return buf; 3022 } 3023 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3024 { 3025 if (__right_) 3026 return __right_->fix_forward_references(t_begin, t_end); 3027 return true; 3028 } 3029 }; 3030 3031 class __typeid 3032 : public __node 3033 { 3034 public: 3035 3036 __typeid(__node* op) 3037 { 3038 __right_ = op; 3039 } 3040 virtual size_t first_size() const 3041 { 3042 if (__cached_size_ == -1) 3043 const_cast<long&>(__cached_size_) = static_cast<long>(__right_->size() + 8); 3044 return static_cast<size_t>(__cached_size_); 3045 } 3046 virtual char* first_demangled_name(char* buf) const 3047 { 3048 strncpy(buf, "typeid(", 7); 3049 buf += 7; 3050 buf = __right_->get_demangled_name(buf); 3051 *buf++ = ')'; 3052 return buf; 3053 } 3054 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3055 { 3056 return __right_->fix_forward_references(t_begin, t_end); 3057 } 3058 }; 3059 3060 class __throw 3061 : public __node 3062 { 3063 public: 3064 3065 __throw(__node* op) 3066 { 3067 __right_ = op; 3068 } 3069 virtual size_t first_size() const 3070 { 3071 if (__cached_size_ == -1) 3072 const_cast<long&>(__cached_size_) = static_cast<long>(__right_->size() + 6); 3073 return static_cast<size_t>(__cached_size_); 3074 } 3075 virtual char* first_demangled_name(char* buf) const 3076 { 3077 strncpy(buf, "throw ", 6); 3078 return __right_->get_demangled_name(buf+6); 3079 } 3080 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3081 { 3082 return __right_->fix_forward_references(t_begin, t_end); 3083 } 3084 }; 3085 3086 class __rethrow 3087 : public __node 3088 { 3089 static const ptrdiff_t n = sizeof("throw") - 1; 3090 public: 3091 3092 virtual size_t first_size() const {return n;} 3093 virtual char* first_demangled_name(char* buf) const 3094 { 3095 strncpy(buf, "throw", n); 3096 return buf+n; 3097 } 3098 }; 3099 3100 class __operator_sizeof_param_pack 3101 : public __node 3102 { 3103 public: 3104 3105 __operator_sizeof_param_pack(__node* op) 3106 { 3107 __right_ = op; 3108 } 3109 virtual size_t first_size() const 3110 { 3111 if (__cached_size_ == -1) 3112 const_cast<long&>(__cached_size_) = static_cast<long>(__right_->size() + 11); 3113 return static_cast<size_t>(__cached_size_); 3114 } 3115 virtual char* first_demangled_name(char* buf) const 3116 { 3117 strncpy(buf, "sizeof...(", 10); 3118 buf += 10; 3119 buf = __right_->get_demangled_name(buf); 3120 *buf++ = ')'; 3121 return buf; 3122 } 3123 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3124 { 3125 return __right_->fix_forward_references(t_begin, t_end); 3126 } 3127 }; 3128 3129 class __const_cast 3130 : public __node 3131 { 3132 public: 3133 3134 __const_cast(__node* op1, __node* op2) 3135 { 3136 __left_ = op1; 3137 __right_ = op2; 3138 } 3139 virtual size_t first_size() const 3140 { 3141 if (__cached_size_ == -1) 3142 const_cast<long&>(__cached_size_) = static_cast<long>(__left_->size() + 3143 14 + __right_->size()); 3144 return static_cast<size_t>(__cached_size_); 3145 } 3146 virtual char* first_demangled_name(char* buf) const 3147 { 3148 strncpy(buf, "const_cast<", 11); 3149 buf += 11; 3150 buf = __left_->get_demangled_name(buf); 3151 *buf++ = '>'; 3152 *buf++ = '('; 3153 buf = __right_->get_demangled_name(buf); 3154 *buf++ = ')'; 3155 return buf; 3156 } 3157 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3158 { 3159 return __left_->fix_forward_references(t_begin, t_end) && 3160 __right_->fix_forward_references(t_begin, t_end); 3161 } 3162 }; 3163 3164 class __dynamic_cast 3165 : public __node 3166 { 3167 public: 3168 3169 __dynamic_cast(__node* op1, __node* op2) 3170 { 3171 __left_ = op1; 3172 __right_ = op2; 3173 } 3174 virtual size_t first_size() const 3175 { 3176 if (__cached_size_ == -1) 3177 const_cast<long&>(__cached_size_) = static_cast<long>(__left_->size() + 3178 16 + __right_->size()); 3179 return static_cast<size_t>(__cached_size_); 3180 } 3181 virtual char* first_demangled_name(char* buf) const 3182 { 3183 strncpy(buf, "dynamic_cast<", 13); 3184 buf += 13; 3185 buf = __left_->get_demangled_name(buf); 3186 *buf++ = '>'; 3187 *buf++ = '('; 3188 buf = __right_->get_demangled_name(buf); 3189 *buf++ = ')'; 3190 return buf; 3191 } 3192 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3193 { 3194 return __left_->fix_forward_references(t_begin, t_end) && 3195 __right_->fix_forward_references(t_begin, t_end); 3196 } 3197 }; 3198 3199 class __reinterpret_cast 3200 : public __node 3201 { 3202 public: 3203 3204 __reinterpret_cast(__node* op1, __node* op2) 3205 { 3206 __left_ = op1; 3207 __right_ = op2; 3208 } 3209 virtual size_t first_size() const 3210 { 3211 if (__cached_size_ == -1) 3212 const_cast<long&>(__cached_size_) = static_cast<long>(__left_->size() + 3213 20 + __right_->size()); 3214 return static_cast<size_t>(__cached_size_); 3215 } 3216 virtual char* first_demangled_name(char* buf) const 3217 { 3218 strncpy(buf, "reinterpret_cast<", 17); 3219 buf += 17; 3220 buf = __left_->get_demangled_name(buf); 3221 *buf++ = '>'; 3222 *buf++ = '('; 3223 buf = __right_->get_demangled_name(buf); 3224 *buf++ = ')'; 3225 return buf; 3226 } 3227 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3228 { 3229 return __left_->fix_forward_references(t_begin, t_end) && 3230 __right_->fix_forward_references(t_begin, t_end); 3231 } 3232 }; 3233 3234 class __static_cast 3235 : public __node 3236 { 3237 public: 3238 3239 __static_cast(__node* op1, __node* op2) 3240 { 3241 __left_ = op1; 3242 __right_ = op2; 3243 } 3244 virtual size_t first_size() const 3245 { 3246 if (__cached_size_ == -1) 3247 const_cast<long&>(__cached_size_) = static_cast<long>(__left_->size() + 3248 15 + __right_->size()); 3249 return static_cast<size_t>(__cached_size_); 3250 } 3251 virtual char* first_demangled_name(char* buf) const 3252 { 3253 strncpy(buf, "static_cast<", 12); 3254 buf += 12; 3255 buf = __left_->get_demangled_name(buf); 3256 *buf++ = '>'; 3257 *buf++ = '('; 3258 buf = __right_->get_demangled_name(buf); 3259 *buf++ = ')'; 3260 return buf; 3261 } 3262 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3263 { 3264 return __left_->fix_forward_references(t_begin, t_end) && 3265 __right_->fix_forward_references(t_begin, t_end); 3266 } 3267 }; 3268 3269 class __call_expr 3270 : public __node 3271 { 3272 public: 3273 3274 __call_expr(__node* op1, __node* op2) 3275 { 3276 __left_ = op1; 3277 __right_ = op2; 3278 } 3279 virtual size_t first_size() const 3280 { 3281 if (__cached_size_ == -1) 3282 { 3283 size_t off = __left_->size() + 2; 3284 if (__right_) 3285 off += __right_->size(); 3286 const_cast<long&>(__cached_size_) = static_cast<long>(off); 3287 } 3288 return static_cast<size_t>(__cached_size_); 3289 } 3290 virtual char* first_demangled_name(char* buf) const 3291 { 3292 buf = __left_->get_demangled_name(buf); 3293 *buf++ = '('; 3294 if (__right_) 3295 buf = __right_->get_demangled_name(buf); 3296 *buf++ = ')'; 3297 return buf; 3298 } 3299 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3300 { 3301 bool r = __left_->fix_forward_references(t_begin, t_end); 3302 if (__right_) 3303 r = r && __right_->fix_forward_references(t_begin, t_end); 3304 return r; 3305 } 3306 }; 3307 3308 class __delete_array_expr 3309 : public __node 3310 { 3311 public: 3312 3313 __delete_array_expr(bool global, __node* op) 3314 { 3315 __size_ = global; 3316 __right_ = op; 3317 } 3318 virtual size_t first_size() const 3319 { 3320 if (__cached_size_ == -1) 3321 const_cast<long&>(__cached_size_) = static_cast<long>((__size_ ? 2 : 0) + 3322 9 + __right_->size()); 3323 return static_cast<size_t>(__cached_size_); 3324 } 3325 virtual char* first_demangled_name(char* buf) const 3326 { 3327 if (__size_) 3328 { 3329 *buf++ = ':'; 3330 *buf++ = ':'; 3331 } 3332 strncpy(buf, "delete[] ", 9); 3333 return __right_->get_demangled_name(buf+9); 3334 } 3335 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3336 { 3337 return __right_->fix_forward_references(t_begin, t_end); 3338 } 3339 }; 3340 3341 class __delete_expr 3342 : public __node 3343 { 3344 public: 3345 3346 __delete_expr(bool global, __node* op) 3347 { 3348 __size_ = global; 3349 __right_ = op; 3350 } 3351 virtual size_t first_size() const 3352 { 3353 if (__cached_size_ == -1) 3354 const_cast<long&>(__cached_size_) = static_cast<long>((__size_ ? 2 : 0) + 3355 7 + __right_->size()); 3356 return static_cast<size_t>(__cached_size_); 3357 } 3358 virtual char* first_demangled_name(char* buf) const 3359 { 3360 if (__size_) 3361 { 3362 *buf++ = ':'; 3363 *buf++ = ':'; 3364 } 3365 strncpy(buf, "delete ", 7); 3366 return __right_->get_demangled_name(buf+7); 3367 } 3368 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3369 { 3370 return __right_->fix_forward_references(t_begin, t_end); 3371 } 3372 }; 3373 3374 class __new_expr 3375 : public __node 3376 { 3377 public: 3378 3379 __new_expr(bool global, bool is_array, bool has_init, 3380 __node* expr, __node* type, __node* init) 3381 { 3382 __size_ = (unsigned)global | 3383 ((unsigned)is_array << 1) | 3384 ((unsigned)has_init << 2); 3385 __left_ = expr; 3386 __name_ = (const char*)type; 3387 __right_ = init; 3388 } 3389 virtual size_t first_size() const 3390 { 3391 if (__cached_size_ == -1) 3392 { 3393 size_t off = 4; 3394 if (__size_ & 1) 3395 off += 2; 3396 if (__size_ & 2) 3397 off += 2; 3398 if (__left_) 3399 { 3400 off += 2; 3401 off += __left_->size(); 3402 } 3403 __node* type = (__node*)__name_; 3404 off += type->size(); 3405 if (__size_ & 4) 3406 { 3407 off += 2; 3408 if (__right_) 3409 off += __right_->size(); 3410 } 3411 const_cast<long&>(__cached_size_) = static_cast<long>(off); 3412 } 3413 return static_cast<size_t>(__cached_size_); 3414 } 3415 virtual char* first_demangled_name(char* buf) const 3416 { 3417 if (__size_ & 1) 3418 { 3419 *buf++ = ':'; 3420 *buf++ = ':'; 3421 } 3422 *buf++ = 'n'; 3423 *buf++ = 'e'; 3424 *buf++ = 'w'; 3425 if (__size_ & 2) 3426 { 3427 *buf++ = '['; 3428 *buf++ = ']'; 3429 } 3430 if (__left_) 3431 { 3432 *buf++ = '('; 3433 buf = __left_->get_demangled_name(buf); 3434 *buf++ = ')'; 3435 } 3436 *buf++ = ' '; 3437 __node* type = (__node*)__name_; 3438 buf = type->get_demangled_name(buf); 3439 if (__size_ & 4) 3440 { 3441 *buf++ = '('; 3442 if (__right_) 3443 buf = __right_->get_demangled_name(buf); 3444 *buf++ = ')'; 3445 } 3446 return buf; 3447 } 3448 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3449 { 3450 __node* type = (__node*)__name_; 3451 bool r = type->fix_forward_references(t_begin, t_end); 3452 if (__left_) 3453 r = r && __left_->fix_forward_references(t_begin, t_end);; 3454 if (__right_) 3455 r = r && __right_->fix_forward_references(t_begin, t_end);; 3456 return r; 3457 } 3458 }; 3459 3460 class __dot_star_expr 3461 : public __node 3462 { 3463 public: 3464 3465 __dot_star_expr(__node* op1, __node* op2) 3466 { 3467 __left_ = op1; 3468 __right_ = op2; 3469 } 3470 virtual size_t first_size() const 3471 { 3472 if (__cached_size_ == -1) 3473 const_cast<long&>(__cached_size_) = static_cast<long>(__left_->size() + 3474 2 + __right_->size()); 3475 return static_cast<size_t>(__cached_size_); 3476 } 3477 virtual char* first_demangled_name(char* buf) const 3478 { 3479 buf = __left_->get_demangled_name(buf); 3480 *buf++ = '.'; 3481 *buf++ = '*'; 3482 return __right_->get_demangled_name(buf); 3483 } 3484 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3485 { 3486 return __left_->fix_forward_references(t_begin, t_end) && 3487 __right_->fix_forward_references(t_begin, t_end); 3488 } 3489 }; 3490 3491 class __dot_expr 3492 : public __node 3493 { 3494 public: 3495 3496 __dot_expr(__node* op1, __node* op2) 3497 { 3498 __left_ = op1; 3499 __right_ = op2; 3500 } 3501 virtual size_t first_size() const 3502 { 3503 if (__cached_size_ == -1) 3504 const_cast<long&>(__cached_size_) = static_cast<long>(__left_->size() + 3505 1 + __right_->size()); 3506 return static_cast<size_t>(__cached_size_); 3507 } 3508 virtual char* first_demangled_name(char* buf) const 3509 { 3510 buf = __left_->get_demangled_name(buf); 3511 *buf++ = '.'; 3512 return __right_->get_demangled_name(buf); 3513 } 3514 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3515 { 3516 return __left_->fix_forward_references(t_begin, t_end) && 3517 __right_->fix_forward_references(t_begin, t_end); 3518 } 3519 }; 3520 3521 class __arrow_expr 3522 : public __node 3523 { 3524 public: 3525 3526 __arrow_expr(__node* op1, __node* op2) 3527 { 3528 __left_ = op1; 3529 __right_ = op2; 3530 } 3531 virtual size_t first_size() const 3532 { 3533 if (__cached_size_ == -1) 3534 const_cast<long&>(__cached_size_) = static_cast<long>(__left_->size() + 3535 2 + __right_->size()); 3536 return static_cast<size_t>(__cached_size_); 3537 } 3538 virtual char* first_demangled_name(char* buf) const 3539 { 3540 buf = __left_->get_demangled_name(buf); 3541 *buf++ = '-'; 3542 *buf++ = '>'; 3543 return __right_->get_demangled_name(buf); 3544 } 3545 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3546 { 3547 return __left_->fix_forward_references(t_begin, t_end) && 3548 __right_->fix_forward_references(t_begin, t_end); 3549 } 3550 }; 3551 3552 class __std_qualified_name 3553 : public __node 3554 { 3555 static const ptrdiff_t n = sizeof("std") - 1; 3556 public: 3557 3558 __std_qualified_name() 3559 { 3560 } 3561 virtual size_t first_size() const 3562 { 3563 return n; 3564 } 3565 3566 virtual char* first_demangled_name(char* buf) const 3567 { 3568 *buf++ = 's'; 3569 *buf++ = 't'; 3570 *buf++ = 'd'; 3571 return buf; 3572 } 3573 }; 3574 3575 class __sub_allocator 3576 : public __node 3577 { 3578 static const ptrdiff_t n = sizeof("std::allocator") - 1; 3579 public: 3580 3581 virtual size_t first_size() const 3582 { 3583 return n; 3584 } 3585 virtual char* first_demangled_name(char* buf) const 3586 { 3587 strncpy(buf, "std::allocator", n); 3588 return buf + n; 3589 } 3590 }; 3591 3592 class __sub_basic_string 3593 : public __node 3594 { 3595 static const ptrdiff_t n = sizeof("std::basic_string") - 1; 3596 public: 3597 3598 virtual size_t first_size() const 3599 { 3600 return n; 3601 } 3602 virtual char* first_demangled_name(char* buf) const 3603 { 3604 strncpy(buf, "std::basic_string", n); 3605 return buf + n; 3606 } 3607 }; 3608 3609 class __sub_string 3610 : public __node 3611 { 3612 static const size_t n = sizeof("std::string") - 1; 3613 static const size_t ne = sizeof("std::basic_string<char, std::char_traits<char>, std::allocator<char> >") - 1; 3614 public: 3615 3616 virtual size_t first_size() const 3617 { 3618 if (__size_) 3619 return ne; 3620 return n; 3621 } 3622 virtual char* first_demangled_name(char* buf) const 3623 { 3624 if (__size_) 3625 { 3626 strncpy(buf, "std::basic_string<char, std::char_traits<char>, std::allocator<char> >", ne); 3627 buf += ne; 3628 } 3629 else 3630 { 3631 strncpy(buf, "std::string", n); 3632 buf += n; 3633 } 3634 return buf; 3635 } 3636 3637 virtual size_t base_size() const 3638 { 3639 return 12; 3640 } 3641 virtual char* get_base_name(char* buf) const 3642 { 3643 strncpy(buf, "basic_string", 12); 3644 return buf + 12; 3645 } 3646 3647 virtual __node* base_name() const 3648 { 3649 const_cast<size_t&>(__size_) = true; 3650 return const_cast<__node*>(static_cast<const __node*>(this)); 3651 } 3652 }; 3653 3654 class __sub_istream 3655 : public __node 3656 { 3657 static const ptrdiff_t n = sizeof("std::istream") - 1; 3658 public: 3659 3660 virtual size_t first_size() const {return n;} 3661 virtual char* first_demangled_name(char* buf) const 3662 { 3663 strncpy(buf, "std::istream", n); 3664 return buf + n; 3665 } 3666 }; 3667 3668 class __sub_ostream 3669 : public __node 3670 { 3671 static const ptrdiff_t n = sizeof("std::ostream") - 1; 3672 public: 3673 3674 virtual size_t first_size() const {return n;} 3675 virtual char* first_demangled_name(char* buf) const 3676 { 3677 strncpy(buf, "std::ostream", n); 3678 return buf + n; 3679 } 3680 }; 3681 3682 class __sub_iostream 3683 : public __node 3684 { 3685 static const ptrdiff_t n = sizeof("std::iostream") - 1; 3686 public: 3687 3688 virtual size_t first_size() const {return n;} 3689 virtual char* first_demangled_name(char* buf) const 3690 { 3691 strncpy(buf, "std::iostream", n); 3692 return buf + n; 3693 } 3694 }; 3695 3696 class __sub 3697 : public __node 3698 { 3699 public: 3700 3701 explicit __sub(__node* arg) 3702 { 3703 __left_ = arg; 3704 } 3705 explicit __sub(size_t arg) 3706 { 3707 __size_ = arg; 3708 } 3709 virtual size_t first_size() const 3710 { 3711 return __left_->first_size(); 3712 } 3713 virtual char* first_demangled_name(char* buf) const 3714 { 3715 return __left_->first_demangled_name(buf); 3716 } 3717 virtual size_t second_size() const 3718 { 3719 return __left_->second_size(); 3720 } 3721 virtual char* second_demangled_name(char* buf) const 3722 { 3723 return __left_->second_demangled_name(buf); 3724 } 3725 virtual bool ends_with_template(bool parsing = false) const 3726 { 3727 return __left_->ends_with_template(parsing); 3728 } 3729 virtual __node* base_name() const 3730 { 3731 return __left_->base_name(); 3732 } 3733 virtual bool is_reference_or_pointer_to_function_or_array() const 3734 { 3735 return __left_->is_reference_or_pointer_to_function_or_array(); 3736 } 3737 virtual bool is_function() const 3738 { 3739 if (__left_ == 0) 3740 return false; 3741 return __left_->is_function(); 3742 } 3743 virtual bool is_cv_qualifer() const 3744 { 3745 return __left_->is_cv_qualifer(); 3746 } 3747 virtual bool is_ctor_dtor_conv() const 3748 { 3749 return __left_->is_ctor_dtor_conv(); 3750 } 3751 virtual bool is_array() const 3752 { 3753 return __left_->is_array(); 3754 } 3755 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3756 { 3757 if (__left_ == 0) 3758 { 3759 if (__size_ < static_cast<size_t>(t_end - t_begin)) 3760 { 3761 __left_ = t_begin[__size_]; 3762 __size_ = 0; 3763 } 3764 else 3765 return false; 3766 } 3767 return true; 3768 } 3769 virtual size_t list_len() const 3770 { 3771 return __left_->list_len(); 3772 } 3773 virtual bool is_sub() const 3774 { 3775 return true; 3776 } 3777 }; 3778 3779 class __unscoped_template_name 3780 : public __node 3781 { 3782 public: 3783 __unscoped_template_name(__node* name, __node* args) 3784 {__left_ = name; __right_ = args;} 3785 3786 virtual size_t first_size() const 3787 { 3788 if (__cached_size_ == -1) 3789 const_cast<long&>(__cached_size_) = static_cast<long>(__left_->size() + 3790 __right_->size()); 3791 return static_cast<size_t>(__cached_size_); 3792 } 3793 virtual char* first_demangled_name(char* buf) const 3794 { 3795 buf = __left_->get_demangled_name(buf); 3796 return __right_->get_demangled_name(buf); 3797 } 3798 virtual bool ends_with_template(bool parsing = false) const 3799 { 3800 return __right_->ends_with_template(parsing); 3801 } 3802 virtual __node* base_name() const 3803 { 3804 return __left_->base_name(); 3805 } 3806 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3807 { 3808 return __left_->fix_forward_references(t_begin, t_end) && 3809 __right_->fix_forward_references(t_begin, t_end); 3810 } 3811 }; 3812 3813 // length == 0: __left_ == NULL 3814 // length == 1: __left_ != NULL, __right_ == NULL 3815 // length > 1: __left_ != NULL, __right_ != NULL 3816 class __list 3817 : public __node 3818 { 3819 public: 3820 explicit __list(__node* type) 3821 {__left_ = type;} 3822 3823 virtual size_t first_size() const 3824 { 3825 if (__cached_size_ == -1) 3826 { 3827 if (__left_ == NULL) 3828 const_cast<long&>(__cached_size_) = 0; 3829 else if (__right_ == NULL) 3830 const_cast<long&>(__cached_size_) = static_cast<long>(__left_->size()); 3831 else 3832 { 3833 size_t off = __right_->size(); 3834 if (off > 0) 3835 off += 2; 3836 const_cast<long&>(__cached_size_) = static_cast<long>(__left_->size() + off); 3837 } 3838 } 3839 return static_cast<size_t>(__cached_size_); 3840 } 3841 virtual char* first_demangled_name(char* buf) const 3842 { 3843 if (__left_ != NULL) 3844 { 3845 char* t = __left_->get_demangled_name(buf + (__size_ ? 2 : 0)); 3846 if (__size_ == 0) 3847 buf = t; 3848 else if (t != buf+2) 3849 { 3850 *buf++ = ','; 3851 *buf++ = ' '; 3852 buf = t; 3853 } 3854 if (__right_) 3855 buf = __right_->get_demangled_name(buf); 3856 } 3857 return buf; 3858 } 3859 virtual bool ends_with_template(bool parsing = false) const 3860 { 3861 if (__right_ && __right_->size() > 0) 3862 { 3863 return __right_->ends_with_template(parsing); 3864 } 3865 else if (__left_ && __left_->size() > 0) 3866 { 3867 return __left_->ends_with_template(parsing); 3868 } 3869 return false; 3870 } 3871 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3872 { 3873 bool r = true; 3874 if (__left_) 3875 r = r && __left_->fix_forward_references(t_begin, t_end); 3876 if (__right_) 3877 r = r && __right_->fix_forward_references(t_begin, t_end); 3878 return r; 3879 } 3880 virtual size_t list_len() const 3881 { 3882 if (!__left_) 3883 return 0; 3884 if (!__right_) 3885 return 1; 3886 return 1 + __right_->list_len(); 3887 } 3888 }; 3889 3890 class __template_args 3891 : public __node 3892 { 3893 public: 3894 __template_args(__node* name, __node* list) 3895 { 3896 __left_ = name; 3897 __right_ = list; 3898 } 3899 3900 virtual size_t first_size() const 3901 { 3902 if (__cached_size_ == -1) 3903 { 3904 size_t off = 2; 3905 if (__right_) 3906 { 3907 if (__right_->ends_with_template()) 3908 ++off; 3909 off += __right_->size(); 3910 } 3911 const_cast<long&>(__cached_size_) = static_cast<long>(__left_->size() + off); 3912 } 3913 return static_cast<size_t>(__cached_size_); 3914 } 3915 virtual char* first_demangled_name(char* buf) const 3916 { 3917 buf = __left_->get_demangled_name(buf); 3918 *buf++ = '<'; 3919 if (__right_) 3920 { 3921 buf = __right_->get_demangled_name(buf); 3922 if (buf[-1] == '>') 3923 *buf++ = ' '; 3924 } 3925 *buf++ = '>'; 3926 return buf; 3927 } 3928 virtual bool ends_with_template(bool /*parsing*/ = false) const 3929 { 3930 return true; 3931 } 3932 virtual __node* base_name() const 3933 { 3934 return __left_->base_name(); 3935 } 3936 virtual bool is_ctor_dtor_conv() const 3937 { 3938 return __left_->is_ctor_dtor_conv(); 3939 } 3940 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3941 { 3942 bool r = __left_->fix_forward_references(t_begin, t_end); 3943 if (__right_) 3944 r = r && __right_->fix_forward_references(t_begin, t_end); 3945 return r; 3946 } 3947 }; 3948 3949 class __function_args 3950 : public __node 3951 { 3952 public: 3953 __function_args(__node* list) 3954 {__right_ = list;} 3955 3956 virtual size_t first_size() const 3957 { 3958 if (__cached_size_ == -1) 3959 const_cast<long&>(__cached_size_) = static_cast<long>(2 + __right_->size()); 3960 return static_cast<size_t>(__cached_size_); 3961 } 3962 virtual char* first_demangled_name(char* buf) const 3963 { 3964 *buf++ = '('; 3965 buf = __right_->get_demangled_name(buf); 3966 *buf++ = ')'; 3967 return buf; 3968 } 3969 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3970 { 3971 return __right_->fix_forward_references(t_begin, t_end); 3972 } 3973 }; 3974 3975 class ___lambda_node 3976 : public __node 3977 { 3978 public: 3979 ___lambda_node(__node* params, const char *number, size_t number_size) 3980 { 3981 __right_ = params; 3982 __name_ = number; 3983 __size_ = number_size; 3984 } 3985 3986 virtual size_t first_size() const 3987 { 3988 if (__cached_size_ == -1) 3989 { 3990 size_t r = 2; 3991 r += sizeof("'lambda'")-1; 3992 if (__right_) 3993 r += __right_->size(); 3994 r += __size_; 3995 const_cast<long&>(__cached_size_) = static_cast<long>(r); 3996 } 3997 return static_cast<size_t>(__cached_size_); 3998 } 3999 virtual char* first_demangled_name(char* buf) const 4000 { 4001 size_t n = sizeof("'lambda") - 1; 4002 strncpy(buf, "'lambda", n); 4003 buf += n; 4004 if (__size_) 4005 { 4006 strncpy(buf, __name_, __size_); 4007 buf += __size_; 4008 } 4009 *buf++ = '\''; 4010 *buf++ = '('; 4011 if (__right_) 4012 buf = __right_->get_demangled_name(buf); 4013 *buf++ = ')'; 4014 return buf; 4015 } 4016 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 4017 { 4018 if (__right_) 4019 return __right_->fix_forward_references(t_begin, t_end); 4020 return true; 4021 } 4022 }; 4023 4024 class __unnamed 4025 : public __node 4026 { 4027 public: 4028 __unnamed(const char *number, size_t number_size) 4029 { 4030 __name_ = number; 4031 __size_ = number_size; 4032 } 4033 4034 virtual size_t first_size() const 4035 { 4036 if (__cached_size_ == -1) 4037 { 4038 size_t r = 0; 4039 r += sizeof("'unnamed'")-1; 4040 r += __size_; 4041 const_cast<long&>(__cached_size_) = static_cast<long>(r); 4042 } 4043 return static_cast<size_t>(__cached_size_); 4044 } 4045 virtual char* first_demangled_name(char* buf) const 4046 { 4047 size_t n = sizeof("'unnamed") - 1; 4048 strncpy(buf, "'unnamed", n); 4049 buf += n; 4050 if (__size_) 4051 { 4052 strncpy(buf, __name_, __size_); 4053 buf += __size_; 4054 } 4055 *buf++ = '\''; 4056 return buf; 4057 } 4058 }; 4059 4060 class __cv_qualifiers 4061 : public __node 4062 { 4063 public: 4064 __cv_qualifiers(size_t cv, __node* type) 4065 { 4066 __left_ = type; 4067 __size_ = __left_->is_function() ? cv << 5 : cv; 4068 } 4069 4070 virtual size_t first_size() const 4071 { 4072 size_t s = __left_->first_size(); 4073 if (__size_ & 4) 4074 s += sizeof(" restrict")-1; 4075 if (__size_ & 2) 4076 s += sizeof(" volatile")-1; 4077 if (__size_ & 1) 4078 s += sizeof(" const")-1; 4079 if (__size_ & 8) 4080 s += sizeof(" &")-1; 4081 if (__size_ & 16) 4082 s += sizeof(" &&")-1; 4083 return s; 4084 } 4085 virtual char* first_demangled_name(char* buf) const 4086 { 4087 buf = __left_->first_demangled_name(buf); 4088 if (__size_ & 1) 4089 { 4090 const size_t n = sizeof(" const")-1; 4091 strncpy(buf, " const", n); 4092 buf += n; 4093 } 4094 if (__size_ & 2) 4095 { 4096 const size_t n = sizeof(" volatile")-1; 4097 strncpy(buf, " volatile", n); 4098 buf += n; 4099 } 4100 if (__size_ & 4) 4101 { 4102 const size_t n = sizeof(" restrict")-1; 4103 strncpy(buf, " restrict", n); 4104 buf += n; 4105 } 4106 if (__size_ & 8) 4107 { 4108 *buf++ = ' '; 4109 *buf++ = '&'; 4110 } 4111 if (__size_ & 16) 4112 { 4113 *buf++ = ' '; 4114 *buf++ = '&'; 4115 *buf++ = '&'; 4116 } 4117 return buf; 4118 } 4119 virtual size_t second_size() const 4120 { 4121 size_t s = __left_->second_size(); 4122 if (__size_ & 128) 4123 s += sizeof(" restrict")-1; 4124 if (__size_ & 64) 4125 s += sizeof(" volatile")-1; 4126 if (__size_ & 32) 4127 s += sizeof(" const")-1; 4128 if (__size_ & 256) 4129 s += sizeof(" &")-1; 4130 if (__size_ & 512) 4131 s += sizeof(" &&")-1; 4132 return s; 4133 } 4134 virtual char* second_demangled_name(char* buf) const 4135 { 4136 buf = __left_->second_demangled_name(buf); 4137 if (__size_ & 32) 4138 { 4139 const size_t n = sizeof(" const")-1; 4140 strncpy(buf, " const", n); 4141 buf += n; 4142 } 4143 if (__size_ & 64) 4144 { 4145 const size_t n = sizeof(" volatile")-1; 4146 strncpy(buf, " volatile", n); 4147 buf += n; 4148 } 4149 if (__size_ & 128) 4150 { 4151 const size_t n = sizeof(" restrict")-1; 4152 strncpy(buf, " restrict", n); 4153 buf += n; 4154 } 4155 if (__size_ & 256) 4156 { 4157 *buf++ = ' '; 4158 *buf++ = '&'; 4159 } 4160 if (__size_ & 512) 4161 { 4162 *buf++ = ' '; 4163 *buf++ = '&'; 4164 *buf++ = '&'; 4165 } 4166 return buf; 4167 } 4168 virtual __node* base_name() const 4169 { 4170 return __left_->base_name(); 4171 } 4172 virtual bool is_reference_or_pointer_to_function_or_array() const 4173 { 4174 return __left_->is_reference_or_pointer_to_function_or_array(); 4175 } 4176 virtual bool is_function() const 4177 { 4178 return __left_->is_function(); 4179 } 4180 virtual bool is_cv_qualifer() const 4181 { 4182 return true; 4183 } 4184 virtual __node* extract_cv(__node*& rt) const 4185 { 4186 if (rt == this) 4187 { 4188 rt = __left_; 4189 return const_cast<__node*>(static_cast<const __node*>(this)); 4190 } 4191 return 0; 4192 } 4193 virtual bool ends_with_template(bool parsing = false) const 4194 { 4195 if (parsing) 4196 return __left_->ends_with_template(parsing); 4197 return false; 4198 } 4199 virtual bool is_ctor_dtor_conv() const 4200 { 4201 return __left_->is_ctor_dtor_conv(); 4202 } 4203 virtual bool is_array() const 4204 { 4205 return __left_->is_array(); 4206 } 4207 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 4208 { 4209 return __left_->fix_forward_references(t_begin, t_end); 4210 } 4211 virtual size_t list_len() const 4212 { 4213 return __left_->list_len(); 4214 } 4215 }; 4216 4217 class __extended_qualifier 4218 : public __node 4219 { 4220 public: 4221 __extended_qualifier(__node* name, __node* type) 4222 { 4223 __left_ = type; 4224 __right_ = name; 4225 __size_ = __left_->is_function() ? 1 : 0; 4226 } 4227 4228 virtual size_t first_size() const 4229 { 4230 size_t s = __left_->first_size(); 4231 if (__size_ == 0) 4232 s += __right_->size() + 1; 4233 return s; 4234 } 4235 virtual char* first_demangled_name(char* buf) const 4236 { 4237 buf = __left_->first_demangled_name(buf); 4238 if (__size_ == 0) 4239 { 4240 *buf++ = ' '; 4241 buf = __right_->get_demangled_name(buf); 4242 } 4243 return buf; 4244 } 4245 virtual size_t second_size() const 4246 { 4247 size_t s = __left_->second_size(); 4248 if (__size_ == 1) 4249 s += __right_->size() + 1; 4250 return s; 4251 } 4252 virtual char* second_demangled_name(char* buf) const 4253 { 4254 buf = __left_->second_demangled_name(buf); 4255 if (__size_ == 1) 4256 { 4257 *buf++ = ' '; 4258 buf = __right_->get_demangled_name(buf); 4259 } 4260 return buf; 4261 } 4262 virtual __node* base_name() const 4263 { 4264 return __left_->base_name(); 4265 } 4266 virtual bool is_reference_or_pointer_to_function_or_array() const 4267 { 4268 return __left_->is_reference_or_pointer_to_function_or_array(); 4269 } 4270 virtual bool is_function() const 4271 { 4272 return __left_->is_function(); 4273 } 4274 virtual bool is_cv_qualifer() const 4275 { 4276 return true; 4277 } 4278 virtual __node* extract_cv(__node*& rt) const 4279 { 4280 if (rt == this) 4281 { 4282 rt = __left_; 4283 return const_cast<__node*>(static_cast<const __node*>(this)); 4284 } 4285 return 0; 4286 } 4287 virtual bool ends_with_template(bool parsing = false) const 4288 { 4289 return __left_->ends_with_template(parsing); 4290 } 4291 virtual bool is_ctor_dtor_conv() const 4292 { 4293 return __left_->is_ctor_dtor_conv(); 4294 } 4295 virtual bool is_array() const 4296 { 4297 return __left_->is_array(); 4298 } 4299 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 4300 { 4301 return __left_->fix_forward_references(t_begin, t_end); 4302 } 4303 virtual size_t list_len() const 4304 { 4305 return __left_->list_len(); 4306 } 4307 }; 4308 4309 class __function 4310 : public __node 4311 { 4312 public: 4313 4314 __function(__node* name, __node* signature, size_t ret_goes_first = true) 4315 { 4316 __size_ = ret_goes_first; 4317 __left_ = name; 4318 __right_ = signature; 4319 } 4320 4321 virtual size_t first_size() const 4322 { 4323 size_t off = 0; 4324 if (__size_) 4325 { 4326 off = __right_->first_size(); 4327 if (off > 0 && (__left_ == NULL || 4328 !__right_->__left_->is_reference_or_pointer_to_function_or_array())) 4329 ++off; 4330 } 4331 else 4332 off = 5; 4333 if (__left_) 4334 off += __left_->first_size(); 4335 else 4336 ++off; 4337 return off; 4338 } 4339 4340 virtual size_t second_size() const 4341 { 4342 size_t off = 0; 4343 if (__left_ == NULL) 4344 off = 1; 4345 off += __right_->second_size(); 4346 if (!__size_) 4347 { 4348 off += 2; 4349 off += __right_->first_size(); 4350 } 4351 return off; 4352 } 4353 4354 virtual char* first_demangled_name(char* buf) const 4355 { 4356 if (__size_) 4357 { 4358 const char* t = buf; 4359 buf = __right_->first_demangled_name(buf); 4360 if (buf != t && (__left_ == NULL || 4361 !__right_->__left_->is_reference_or_pointer_to_function_or_array())) 4362 *buf++ = ' '; 4363 } 4364 else 4365 { 4366 strncpy(buf, "auto ", 5); 4367 buf += 5; 4368 } 4369 if (__left_) 4370 buf = __left_->first_demangled_name(buf); 4371 else 4372 *buf++ = '('; 4373 return buf; 4374 } 4375 virtual char* second_demangled_name(char* buf) const 4376 { 4377 if (__left_ == NULL) 4378 *buf++ = ')'; 4379 buf = __right_->second_demangled_name(buf); 4380 if (!__size_) 4381 { 4382 *buf++ = '-'; 4383 *buf++ = '>'; 4384 buf = __right_->first_demangled_name(buf); 4385 } 4386 return buf; 4387 } 4388 virtual char* get_demangled_name(char* buf) const 4389 { 4390 if (__size_) 4391 { 4392 const char* t = buf; 4393 buf = __right_->first_demangled_name(buf); 4394 if (buf != t && (__left_ == NULL || 4395 !__right_->__left_->is_reference_or_pointer_to_function_or_array())) 4396 *buf++ = ' '; 4397 } 4398 else 4399 { 4400 strncpy(buf, "auto ", 5); 4401 buf += 5; 4402 } 4403 if (__left_) 4404 buf = __left_->first_demangled_name(buf); 4405 buf = __right_->second_demangled_name(buf); 4406 if (!__size_) 4407 { 4408 *buf++ = '-'; 4409 *buf++ = '>'; 4410 buf = __right_->first_demangled_name(buf); 4411 } 4412 return buf; 4413 } 4414 4415 virtual size_t size() const 4416 { 4417 if (__cached_size_ == -1) 4418 { 4419 size_t off = 0; 4420 if (__size_) 4421 { 4422 off = __right_->first_size(); 4423 if (off > 0 && (__left_ == NULL || 4424 !__right_->__left_->is_reference_or_pointer_to_function_or_array())) 4425 ++off; 4426 } 4427 else 4428 off = 5; 4429 if (__left_) 4430 off += __left_->first_size(); 4431 off += __right_->second_size(); 4432 if (!__size_) 4433 { 4434 off += 2; 4435 off += __right_->first_size(); 4436 } 4437 const_cast<long&>(__cached_size_) = static_cast<long>(off); 4438 } 4439 return static_cast<size_t>(__cached_size_); 4440 } 4441 4442 virtual bool is_function() const 4443 { 4444 return true; 4445 } 4446 virtual bool is_ctor_dtor_conv() const 4447 { 4448 return __left_->is_ctor_dtor_conv(); 4449 } 4450 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 4451 { 4452 bool r = true; 4453 if (__left_) 4454 r = r && __left_->fix_forward_references(t_begin, t_end); 4455 r = r && __right_->fix_forward_references(t_begin, t_end); 4456 return r; 4457 } 4458 }; 4459 4460 class __function_signature 4461 : public __node 4462 { 4463 public: 4464 __function_signature(__node* ret, __node* args) 4465 { 4466 __left_ = ret; 4467 __right_ = args; 4468 } 4469 virtual size_t first_size() const 4470 { 4471 return __left_ ? __left_->first_size() : 0; 4472 } 4473 4474 virtual size_t second_size() const 4475 { 4476 return 2 + (__right_ ? __right_->size() : 0) 4477 + (__left_ ? __left_->second_size() : 0); 4478 } 4479 4480 virtual char* first_demangled_name(char* buf) const 4481 { 4482 if (__left_) 4483 buf = __left_->first_demangled_name(buf); 4484 return buf; 4485 } 4486 4487 virtual char* second_demangled_name(char* buf) const 4488 { 4489 *buf++ = '('; 4490 if (__right_) 4491 buf = __right_->get_demangled_name(buf); 4492 *buf++ = ')'; 4493 if (__left_) 4494 buf = __left_->second_demangled_name(buf); 4495 return buf; 4496 } 4497 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 4498 { 4499 bool r = true; 4500 if (__left_) 4501 r = r && __left_->fix_forward_references(t_begin, t_end); 4502 if (__right_) 4503 r = r && __right_->fix_forward_references(t_begin, t_end); 4504 return r; 4505 } 4506 }; 4507 4508 class __pointer_to 4509 : public __node 4510 { 4511 public: 4512 4513 explicit __pointer_to(__node* type) 4514 { 4515 __left_ = type; 4516 } 4517 virtual size_t first_size() const 4518 { 4519 return __left_->first_size() + (__left_->is_array() ? 3 : 1); 4520 } 4521 virtual size_t second_size() const 4522 { 4523 return __left_->second_size() + (__left_->is_array() ? 1 : 0); 4524 } 4525 virtual char* first_demangled_name(char* buf) const 4526 { 4527 buf = __left_->first_demangled_name(buf); 4528 if (__left_->is_array()) 4529 { 4530 *buf++ = ' '; 4531 *buf++ = '('; 4532 *buf++ = '*'; 4533 } 4534 else 4535 *buf++ = '*'; 4536 return buf; 4537 } 4538 virtual char* second_demangled_name(char* buf) const 4539 { 4540 if (__left_->is_array()) 4541 *buf++ = ')'; 4542 return __left_->second_demangled_name(buf); 4543 } 4544 virtual __node* base_name() const 4545 { 4546 return __left_->base_name(); 4547 } 4548 virtual bool is_reference_or_pointer_to_function_or_array() const 4549 { 4550 return __left_->is_function() || 4551 __left_->is_reference_or_pointer_to_function_or_array(); 4552 } 4553 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 4554 { 4555 return __left_->fix_forward_references(t_begin, t_end); 4556 } 4557 virtual size_t list_len() const 4558 { 4559 return __left_->list_len(); 4560 } 4561 }; 4562 4563 class __lvalue_reference_to 4564 : public __node 4565 { 4566 public: 4567 4568 explicit __lvalue_reference_to(__node* type) 4569 { 4570 __left_ = type; 4571 } 4572 virtual size_t first_size() const 4573 { 4574 return __left_->first_size() + (__left_->is_array() ? 3 : 1); 4575 } 4576 virtual size_t second_size() const 4577 { 4578 return __left_->second_size() + (__left_->is_array() ? 1 : 0); 4579 } 4580 virtual char* first_demangled_name(char* buf) const 4581 { 4582 buf = __left_->first_demangled_name(buf); 4583 if (__left_->is_array()) 4584 { 4585 *buf++ = ' '; 4586 *buf++ = '('; 4587 *buf++ = '&'; 4588 } 4589 else 4590 *buf++ = '&'; 4591 return buf; 4592 } 4593 virtual char* second_demangled_name(char* buf) const 4594 { 4595 if (__left_->is_array()) 4596 *buf++ = ')'; 4597 return __left_->second_demangled_name(buf); 4598 } 4599 virtual __node* base_name() const 4600 { 4601 return __left_->base_name(); 4602 } 4603 virtual bool is_reference_or_pointer_to_function_or_array() const 4604 { 4605 return __left_->is_function(); 4606 } 4607 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 4608 { 4609 return __left_->fix_forward_references(t_begin, t_end); 4610 } 4611 virtual size_t list_len() const 4612 { 4613 return __left_->list_len(); 4614 } 4615 }; 4616 4617 class __rvalue_reference_to 4618 : public __node 4619 { 4620 public: 4621 4622 explicit __rvalue_reference_to(__node* type) 4623 { 4624 __left_ = type; 4625 } 4626 virtual size_t first_size() const 4627 { 4628 return __left_->first_size() + (__left_->is_array() ? 4 : 2); 4629 } 4630 virtual size_t second_size() const 4631 { 4632 return __left_->second_size() + (__left_->is_array() ? 1 : 0); 4633 } 4634 virtual char* first_demangled_name(char* buf) const 4635 { 4636 buf = __left_->first_demangled_name(buf); 4637 if (__left_->is_array()) 4638 { 4639 strncpy(buf, " (&&", 4); 4640 buf += 4; 4641 } 4642 else 4643 { 4644 *buf++ = '&'; 4645 *buf++ = '&'; 4646 } 4647 return buf; 4648 } 4649 virtual char* second_demangled_name(char* buf) const 4650 { 4651 if (__left_->is_array()) 4652 *buf++ = ')'; 4653 return __left_->second_demangled_name(buf); 4654 } 4655 virtual __node* base_name() const 4656 { 4657 return __left_->base_name(); 4658 } 4659 virtual bool is_reference_or_pointer_to_function_or_array() const 4660 { 4661 return __left_->is_function(); 4662 } 4663 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 4664 { 4665 return __left_->fix_forward_references(t_begin, t_end); 4666 } 4667 virtual size_t list_len() const 4668 { 4669 return __left_->list_len(); 4670 } 4671 }; 4672 4673 class __d_complex 4674 : public __node 4675 { 4676 static const size_t n = sizeof(" complex") - 1; 4677 public: 4678 4679 explicit __d_complex(__node* type) 4680 { 4681 __left_ = type; 4682 } 4683 virtual size_t first_size() const 4684 { 4685 if (__cached_size_ == -1) 4686 const_cast<long&>(__cached_size_) = static_cast<long>(n + __left_->size()); 4687 return static_cast<size_t>(__cached_size_); 4688 } 4689 virtual char* first_demangled_name(char* buf) const 4690 { 4691 buf = __left_->get_demangled_name(buf); 4692 strncpy(buf, " complex", n); 4693 return buf + n; 4694 } 4695 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 4696 { 4697 return __left_->fix_forward_references(t_begin, t_end); 4698 } 4699 }; 4700 4701 class __imaginary 4702 : public __node 4703 { 4704 static const size_t n = sizeof(" imaginary") - 1; 4705 public: 4706 4707 explicit __imaginary(__node* type) 4708 { 4709 __left_ = type; 4710 } 4711 virtual size_t first_size() const 4712 { 4713 if (__cached_size_ == -1) 4714 const_cast<long&>(__cached_size_) = static_cast<long>(n + __left_->size()); 4715 return static_cast<size_t>(__cached_size_); 4716 } 4717 virtual char* first_demangled_name(char* buf) const 4718 { 4719 buf = __left_->get_demangled_name(buf); 4720 strncpy(buf, " imaginary", n); 4721 return buf + n; 4722 } 4723 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 4724 { 4725 return __left_->fix_forward_references(t_begin, t_end); 4726 } 4727 }; 4728 4729 class __pack_expansion 4730 : public __node 4731 { 4732 public: 4733 4734 explicit __pack_expansion(__node* type) 4735 { 4736 __left_ = type; 4737 } 4738 virtual size_t first_size() const 4739 { 4740 if (__cached_size_ == -1) 4741 { 4742 size_t len = __left_->list_len(); 4743 size_t off = 0; 4744 if (len != 0) 4745 { 4746 if (__left_->is_sub() || len == 1) 4747 off = __left_->size(); 4748 else 4749 { 4750 __node* top = __left_; 4751 __node* bottom = top; 4752 while (!bottom->__left_->is_sub()) 4753 bottom = bottom->__left_; 4754 __node* sub = bottom->__left_; 4755 __node* i = sub->__left_; 4756 bool first = true; 4757 top->reset_cached_size(); 4758 while (i) 4759 { 4760 if (!first) 4761 off += 2; 4762 bottom->__left_ = i->__left_; 4763 off += top->size(); 4764 top->reset_cached_size(); 4765 i = i->__right_; 4766 first = false; 4767 } 4768 bottom->__left_ = sub; 4769 } 4770 } 4771 const_cast<long&>(__cached_size_) = static_cast<long>(off); 4772 } 4773 return static_cast<size_t>(__cached_size_); 4774 } 4775 virtual char* first_demangled_name(char* buf) const 4776 { 4777 size_t len = __left_->list_len(); 4778 if (len != 0) 4779 { 4780 if (__left_->is_sub() || len == 1) 4781 buf = __left_->get_demangled_name(buf); 4782 else 4783 { 4784 __node* top = __left_; 4785 __node* bottom = top; 4786 while (!bottom->__left_->is_sub()) 4787 bottom = bottom->__left_; 4788 __node* sub = bottom->__left_; 4789 __node* i = sub->__left_; 4790 bool first = true; 4791 top->reset_cached_size(); 4792 while (i) 4793 { 4794 if (!first) 4795 { 4796 *buf++ = ','; 4797 *buf++ = ' '; 4798 } 4799 bottom->__left_ = i->__left_; 4800 buf = top->get_demangled_name(buf); 4801 top->reset_cached_size(); 4802 i = i->__right_; 4803 first = false; 4804 } 4805 bottom->__left_ = sub; 4806 } 4807 } 4808 return buf; 4809 } 4810 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 4811 { 4812 return __left_->fix_forward_references(t_begin, t_end); 4813 } 4814 }; 4815 4816 class __void 4817 : public __node 4818 { 4819 static const size_t n = sizeof("void") - 1; 4820 public: 4821 4822 virtual size_t first_size() const {return n;} 4823 virtual char* first_demangled_name(char* buf) const 4824 { 4825 strncpy(buf, "void", n); 4826 return buf + n; 4827 } 4828 }; 4829 4830 class __wchar_t 4831 : public __node 4832 { 4833 static const size_t n = sizeof("wchar_t") - 1; 4834 public: 4835 4836 virtual size_t first_size() const {return n;} 4837 virtual char* first_demangled_name(char* buf) const 4838 { 4839 strncpy(buf, "wchar_t", n); 4840 return buf + n; 4841 } 4842 }; 4843 4844 class __wchar_t_literal 4845 : public __node 4846 { 4847 public: 4848 explicit __wchar_t_literal(const char* __first, const char* __last) 4849 { 4850 __name_ = __first; 4851 __size_ = static_cast<size_t>(__last - __first); 4852 } 4853 4854 virtual size_t first_size() const 4855 { 4856 return __size_+9; 4857 } 4858 virtual char* first_demangled_name(char* buf) const 4859 { 4860 strncpy(buf, "(wchar_t)", 9); 4861 buf += 9; 4862 strncpy(buf, __name_, __size_); 4863 return buf + __size_; 4864 } 4865 }; 4866 4867 class __bool 4868 : public __node 4869 { 4870 static const size_t n = sizeof("bool") - 1; 4871 public: 4872 4873 virtual size_t first_size() const {return n;} 4874 virtual char* first_demangled_name(char* buf) const 4875 { 4876 strncpy(buf, "bool", n); 4877 return buf + n; 4878 } 4879 }; 4880 4881 class __bool_literal 4882 : public __node 4883 { 4884 public: 4885 explicit __bool_literal(const char* __name, unsigned __size) 4886 { 4887 __name_ = __name; 4888 __size_ = __size; 4889 } 4890 4891 virtual size_t first_size() const 4892 { 4893 return __size_; 4894 } 4895 virtual char* first_demangled_name(char* buf) const 4896 { 4897 strncpy(buf, __name_, __size_); 4898 return buf + __size_; 4899 } 4900 }; 4901 4902 class __char 4903 : public __node 4904 { 4905 static const size_t n = sizeof("char") - 1; 4906 public: 4907 4908 virtual size_t first_size() const {return n;} 4909 virtual char* first_demangled_name(char* buf) const 4910 { 4911 strncpy(buf, "char", n); 4912 return buf + n; 4913 } 4914 }; 4915 4916 class __char_literal 4917 : public __node 4918 { 4919 public: 4920 explicit __char_literal(const char* __first, const char* __last) 4921 { 4922 __name_ = __first; 4923 __size_ = static_cast<size_t>(__last - __first); 4924 } 4925 4926 virtual size_t first_size() const 4927 { 4928 return __size_+6; 4929 } 4930 virtual char* first_demangled_name(char* buf) const 4931 { 4932 strncpy(buf, "(char)", 6); 4933 buf += 6; 4934 if (*__name_ == 'n') 4935 { 4936 *buf++ = '-'; // strncpy(buf+6, "-", 1); 4937 strncpy(buf, __name_+1, __size_-1); 4938 buf += __size_ - 1; 4939 } 4940 else 4941 { 4942 strncpy(buf, __name_, __size_); 4943 buf += __size_; 4944 } 4945 return buf; 4946 } 4947 }; 4948 4949 class __signed_char 4950 : public __node 4951 { 4952 static const size_t n = sizeof("signed char") - 1; 4953 public: 4954 4955 virtual size_t first_size() const {return n;} 4956 virtual char* first_demangled_name(char* buf) const 4957 { 4958 strncpy(buf, "signed char", n); 4959 return buf + n; 4960 } 4961 }; 4962 4963 class __signed_char_literal 4964 : public __node 4965 { 4966 public: 4967 explicit __signed_char_literal(const char* __first, const char* __last) 4968 { 4969 __name_ = __first; 4970 __size_ = static_cast<size_t>(__last - __first); 4971 } 4972 4973 virtual size_t first_size() const 4974 { 4975 return __size_+13; 4976 } 4977 virtual char* first_demangled_name(char* buf) const 4978 { 4979 strncpy(buf, "(signed char)", 13); 4980 buf += 13; 4981 if (*__name_ == 'n') 4982 { 4983 *buf++ = '-'; 4984 strncpy(buf, __name_+1, __size_-1); 4985 buf += __size_ - 1; 4986 } 4987 else 4988 { 4989 strncpy(buf, __name_, __size_); 4990 buf += __size_; 4991 } 4992 return buf; 4993 } 4994 }; 4995 4996 class __unsigned_char 4997 : public __node 4998 { 4999 static const size_t n = sizeof("unsigned char") - 1; 5000 public: 5001 5002 virtual size_t first_size() const {return n;} 5003 virtual char* first_demangled_name(char* buf) const 5004 { 5005 strncpy(buf, "unsigned char", n); 5006 return buf + n; 5007 } 5008 }; 5009 5010 class __unsigned_char_literal 5011 : public __node 5012 { 5013 public: 5014 explicit __unsigned_char_literal(const char* __first, const char* __last) 5015 { 5016 __name_ = __first; 5017 __size_ = static_cast<size_t>(__last - __first); 5018 } 5019 5020 virtual size_t first_size() const 5021 { 5022 return __size_+15; 5023 } 5024 virtual char* first_demangled_name(char* buf) const 5025 { 5026 strncpy(buf, "(unsigned char)", 15); 5027 buf += 15; 5028 strncpy(buf, __name_, __size_); 5029 return buf + __size_; 5030 } 5031 }; 5032 5033 class __short 5034 : public __node 5035 { 5036 static const size_t n = sizeof("short") - 1; 5037 public: 5038 5039 virtual size_t first_size() const {return n;} 5040 virtual char* first_demangled_name(char* buf) const 5041 { 5042 strncpy(buf, "short", n); 5043 return buf + n; 5044 } 5045 }; 5046 5047 class __short_literal 5048 : public __node 5049 { 5050 public: 5051 explicit __short_literal(const char* __first, const char* __last) 5052 { 5053 __name_ = __first; 5054 __size_ = static_cast<size_t>(__last - __first); 5055 } 5056 5057 virtual size_t first_size() const 5058 { 5059 return __size_+7; 5060 } 5061 virtual char* first_demangled_name(char* buf) const 5062 { 5063 strncpy(buf, "(short)", 7); 5064 buf += 7; 5065 if (*__name_ == 'n') 5066 { 5067 *buf++ = '-'; 5068 strncpy(buf, __name_+1, __size_-1); 5069 buf += __size_ - 1; 5070 } 5071 else 5072 { 5073 strncpy(buf, __name_, __size_); 5074 buf += __size_; 5075 } 5076 return buf; 5077 } 5078 }; 5079 5080 class __unsigned_short 5081 : public __node 5082 { 5083 static const size_t n = sizeof("unsigned short") - 1; 5084 public: 5085 5086 virtual size_t first_size() const {return n;} 5087 virtual char* first_demangled_name(char* buf) const 5088 { 5089 strncpy(buf, "unsigned short", n); 5090 return buf + n; 5091 } 5092 }; 5093 5094 class __unsigned_short_literal 5095 : public __node 5096 { 5097 public: 5098 explicit __unsigned_short_literal(const char* __first, const char* __last) 5099 { 5100 __name_ = __first; 5101 __size_ = static_cast<size_t>(__last - __first); 5102 } 5103 5104 virtual size_t first_size() const 5105 { 5106 return __size_+16; 5107 } 5108 virtual char* first_demangled_name(char* buf) const 5109 { 5110 strncpy(buf, "(unsigned short)", 16); 5111 buf += 16; 5112 strncpy(buf, __name_, __size_); 5113 return buf + __size_; 5114 } 5115 }; 5116 5117 class __int 5118 : public __node 5119 { 5120 static const size_t n = sizeof("int") - 1; 5121 public: 5122 5123 virtual size_t first_size() const {return n;} 5124 virtual char* first_demangled_name(char* buf) const 5125 { 5126 *buf++ = 'i'; 5127 *buf++ = 'n'; 5128 *buf++ = 't'; 5129 return buf; 5130 } 5131 }; 5132 5133 class __int_literal 5134 : public __node 5135 { 5136 public: 5137 explicit __int_literal(const char* __first, const char* __last) 5138 { 5139 __name_ = __first; 5140 __size_ = static_cast<size_t>(__last - __first); 5141 } 5142 5143 virtual size_t first_size() const 5144 { 5145 return __size_; 5146 } 5147 virtual char* first_demangled_name(char* buf) const 5148 { 5149 if (*__name_ == 'n') 5150 { 5151 *buf++ = '-'; 5152 strncpy(buf, __name_+1, __size_-1); 5153 buf += __size_ - 1; 5154 } 5155 else 5156 { 5157 strncpy(buf, __name_, __size_); 5158 buf += __size_; 5159 } 5160 return buf; 5161 } 5162 }; 5163 5164 class __unsigned_int 5165 : public __node 5166 { 5167 static const size_t n = sizeof("unsigned int") - 1; 5168 public: 5169 5170 virtual size_t first_size() const {return n;} 5171 virtual char* first_demangled_name(char* buf) const 5172 { 5173 strncpy(buf, "unsigned int", n); 5174 return buf + n; 5175 } 5176 }; 5177 5178 class __unsigned_int_literal 5179 : public __node 5180 { 5181 public: 5182 explicit __unsigned_int_literal(const char* __first, const char* __last) 5183 { 5184 __name_ = __first; 5185 __size_ = static_cast<size_t>(__last - __first); 5186 } 5187 5188 virtual size_t first_size() const 5189 { 5190 return __size_+1; 5191 } 5192 virtual char* first_demangled_name(char* buf) const 5193 { 5194 strncpy(buf, __name_, __size_); 5195 buf += __size_; 5196 *buf++ = 'u'; 5197 return buf; 5198 } 5199 }; 5200 5201 class __long 5202 : public __node 5203 { 5204 static const size_t n = sizeof("long") - 1; 5205 public: 5206 5207 virtual size_t first_size() const {return n;} 5208 virtual char* first_demangled_name(char* buf) const 5209 { 5210 strncpy(buf, "long", n); 5211 return buf + n; 5212 } 5213 }; 5214 5215 class __long_literal 5216 : public __node 5217 { 5218 public: 5219 explicit __long_literal(const char* __first, const char* __last) 5220 { 5221 __name_ = __first; 5222 __size_ = static_cast<size_t>(__last - __first); 5223 } 5224 5225 virtual size_t first_size() const 5226 { 5227 return __size_+1; 5228 } 5229 virtual char* first_demangled_name(char* buf) const 5230 { 5231 if (*__name_ == 'n') 5232 { 5233 *buf++ = '-'; // strncpy(buf, "-", 1); 5234 strncpy(buf, __name_+1, __size_-1); 5235 buf += __size_ - 1; 5236 } 5237 else 5238 { 5239 strncpy(buf, __name_, __size_); 5240 buf += __size_; 5241 } 5242 *buf++ = 'l'; 5243 return buf; 5244 } 5245 }; 5246 5247 class __unsigned_long 5248 : public __node 5249 { 5250 static const size_t n = sizeof("unsigned long") - 1; 5251 public: 5252 5253 virtual size_t first_size() const {return n;} 5254 virtual char* first_demangled_name(char* buf) const 5255 { 5256 strncpy(buf, "unsigned long", n); 5257 return buf + n; 5258 } 5259 }; 5260 5261 class __unsigned_long_literal 5262 : public __node 5263 { 5264 public: 5265 explicit __unsigned_long_literal(const char* __first, const char* __last) 5266 { 5267 __name_ = __first; 5268 __size_ = static_cast<size_t>(__last - __first); 5269 } 5270 5271 virtual size_t first_size() const 5272 { 5273 return __size_+2; 5274 } 5275 virtual char* first_demangled_name(char* buf) const 5276 { 5277 strncpy(buf, __name_, __size_); 5278 buf += __size_; 5279 *buf++ = 'u'; 5280 *buf++ = 'l'; 5281 return buf; 5282 } 5283 }; 5284 5285 class __long_long 5286 : public __node 5287 { 5288 static const size_t n = sizeof("long long") - 1; 5289 public: 5290 5291 virtual size_t first_size() const {return n;} 5292 virtual char* first_demangled_name(char* buf) const 5293 { 5294 strncpy(buf, "long long", n); 5295 return buf + n; 5296 } 5297 }; 5298 5299 class __long_long_literal 5300 : public __node 5301 { 5302 public: 5303 explicit __long_long_literal(const char* __first, const char* __last) 5304 { 5305 __name_ = __first; 5306 __size_ = static_cast<size_t>(__last - __first); 5307 } 5308 5309 virtual size_t first_size() const 5310 { 5311 return __size_+2; 5312 } 5313 virtual char* first_demangled_name(char* buf) const 5314 { 5315 if (*__name_ == 'n') 5316 { 5317 *buf++ = '-'; 5318 strncpy(buf, __name_+1, __size_-1); 5319 buf += __size_ - 1; 5320 } 5321 else 5322 { 5323 strncpy(buf, __name_, __size_); 5324 buf += __size_; 5325 } 5326 *buf++ = 'l'; 5327 *buf++ = 'l'; 5328 return buf; 5329 } 5330 }; 5331 5332 class __unsigned_long_long 5333 : public __node 5334 { 5335 static const size_t n = sizeof("unsigned long long") - 1; 5336 public: 5337 5338 virtual size_t first_size() const {return n;} 5339 virtual char* first_demangled_name(char* buf) const 5340 { 5341 strncpy(buf, "unsigned long long", n); 5342 return buf + n; 5343 } 5344 }; 5345 5346 class __unsigned_long_long_literal 5347 : public __node 5348 { 5349 public: 5350 explicit __unsigned_long_long_literal(const char* __first, const char* __last) 5351 { 5352 __name_ = __first; 5353 __size_ = static_cast<size_t>(__last - __first); 5354 } 5355 5356 virtual size_t first_size() const 5357 { 5358 return __size_+3; 5359 } 5360 virtual char* first_demangled_name(char* buf) const 5361 { 5362 strncpy(buf, __name_, __size_); 5363 buf += __size_; 5364 *buf++ = 'u'; 5365 *buf++ = 'l'; 5366 *buf++ = 'l'; 5367 return buf; 5368 } 5369 }; 5370 5371 class __signed_int128 5372 : public __node 5373 { 5374 static const size_t n = sizeof("__int128") - 1; 5375 public: 5376 5377 virtual size_t first_size() const {return n;} 5378 virtual char* first_demangled_name(char* buf) const 5379 { 5380 strncpy(buf, "__int128", n); 5381 return buf + n; 5382 } 5383 }; 5384 5385 class __int128_literal 5386 : public __node 5387 { 5388 public: 5389 explicit __int128_literal(const char* __first, const char* __last) 5390 { 5391 __name_ = __first; 5392 __size_ = static_cast<size_t>(__last - __first); 5393 } 5394 5395 virtual size_t first_size() const 5396 { 5397 return __size_+10; 5398 } 5399 virtual char* first_demangled_name(char* buf) const 5400 { 5401 strncpy(buf, "(__int128)", 10); 5402 buf += 10; 5403 if (*__name_ == 'n') 5404 { 5405 *buf++ = '-'; 5406 strncpy(buf, __name_+1, __size_-1); 5407 buf += __size_ - 1; 5408 } 5409 else 5410 { 5411 strncpy(buf, __name_, __size_); 5412 buf += __size_; 5413 } 5414 return buf; 5415 } 5416 }; 5417 5418 class __unsigned_int128 5419 : public __node 5420 { 5421 static const size_t n = sizeof("unsigned __int128") - 1; 5422 public: 5423 5424 virtual size_t first_size() const {return n;} 5425 virtual char* first_demangled_name(char* buf) const 5426 { 5427 strncpy(buf, "unsigned __int128", n); 5428 return buf + n; 5429 } 5430 }; 5431 5432 class __unsigned_int128_literal 5433 : public __node 5434 { 5435 public: 5436 explicit __unsigned_int128_literal(const char* __first, const char* __last) 5437 { 5438 __name_ = __first; 5439 __size_ = static_cast<size_t>(__last - __first); 5440 } 5441 5442 virtual size_t first_size() const 5443 { 5444 return __size_+19; 5445 } 5446 virtual char* first_demangled_name(char* buf) const 5447 { 5448 strncpy(buf, "(unsigned __int128)", 19); 5449 buf += 19; 5450 strncpy(buf, __name_, __size_); 5451 return buf + __size_; 5452 } 5453 }; 5454 5455 class __float_literal 5456 : public __node 5457 { 5458 public: 5459 explicit __float_literal(float value) 5460 { 5461 __value_ = value; 5462 } 5463 5464 virtual size_t first_size() const 5465 { 5466 if (__cached_size_ == -1) 5467 { 5468 char num[20] = {0}; 5469 float v = static_cast<float>(__value_); 5470 const_cast<long&>(__cached_size_) = sprintf(num, "%a", v)+1; 5471 } 5472 return static_cast<size_t>(__cached_size_); 5473 } 5474 virtual char* first_demangled_name(char* buf) const 5475 { 5476 char num[20] = {0}; 5477 float v = static_cast<float>(__value_); 5478 int n = sprintf(num, "%a", v); 5479 strncpy(buf, num, static_cast<size_t>(n)); 5480 buf += n; 5481 *buf++ = 'f'; 5482 return buf; 5483 } 5484 }; 5485 5486 class __float 5487 : public __node 5488 { 5489 static const size_t n = sizeof("float") - 1; 5490 public: 5491 5492 virtual size_t first_size() const {return n;} 5493 virtual char* first_demangled_name(char* buf) const 5494 { 5495 strncpy(buf, "float", n); 5496 return buf + n; 5497 } 5498 }; 5499 5500 class __double_literal 5501 : public __node 5502 { 5503 public: 5504 explicit __double_literal(double value) 5505 { 5506 __value_ = value; 5507 } 5508 5509 virtual size_t first_size() const 5510 { 5511 if (__cached_size_ == -1) 5512 { 5513 char num[30] = {0}; 5514 double v = static_cast<double>(__value_); 5515 const_cast<long&>(__cached_size_) = sprintf(num, "%a", v); 5516 } 5517 return static_cast<size_t>(__cached_size_); 5518 } 5519 virtual char* first_demangled_name(char* buf) const 5520 { 5521 char num[30] = {0}; 5522 double v = static_cast<double>(__value_); 5523 int n = sprintf(num, "%a", v); 5524 strncpy(buf, num, static_cast<size_t>(n)); 5525 return buf + n; 5526 } 5527 }; 5528 5529 class __double 5530 : public __node 5531 { 5532 static const size_t n = sizeof("double") - 1; 5533 public: 5534 5535 virtual size_t first_size() const {return n;} 5536 virtual char* first_demangled_name(char* buf) const 5537 { 5538 strncpy(buf, "double", n); 5539 return buf + n; 5540 } 5541 }; 5542 5543 class __long_double 5544 : public __node 5545 { 5546 static const size_t n = sizeof("long double") - 1; 5547 public: 5548 5549 virtual size_t first_size() const {return n;} 5550 virtual char* first_demangled_name(char* buf) const 5551 { 5552 strncpy(buf, "long double", n); 5553 return buf + n; 5554 } 5555 }; 5556 5557 class __float128 5558 : public __node 5559 { 5560 static const size_t n = sizeof("__float128") - 1; 5561 public: 5562 5563 virtual size_t first_size() const {return n;} 5564 virtual char* first_demangled_name(char* buf) const 5565 { 5566 strncpy(buf, "__float128", n); 5567 return buf + n; 5568 } 5569 }; 5570 5571 class __ellipsis 5572 : public __node 5573 { 5574 static const size_t n = sizeof("...") - 1; 5575 public: 5576 5577 virtual size_t first_size() const {return n;} 5578 virtual char* first_demangled_name(char* buf) const 5579 { 5580 *buf++ = '.'; 5581 *buf++ = '.'; 5582 *buf++ = '.'; 5583 return buf; 5584 } 5585 }; 5586 5587 class __decimal64 5588 : public __node 5589 { 5590 static const size_t n = sizeof("decimal64") - 1; 5591 public: 5592 5593 virtual size_t first_size() const {return n;} 5594 virtual char* first_demangled_name(char* buf) const 5595 { 5596 strncpy(buf, "decimal64", n); 5597 return buf + n; 5598 } 5599 }; 5600 5601 class __decimal128 5602 : public __node 5603 { 5604 static const size_t n = sizeof("decimal128") - 1; 5605 public: 5606 5607 virtual size_t first_size() const {return n;} 5608 virtual char* first_demangled_name(char* buf) const 5609 { 5610 strncpy(buf, "decimal128", n); 5611 return buf + n; 5612 } 5613 }; 5614 5615 class __decimal32 5616 : public __node 5617 { 5618 static const size_t n = sizeof("decimal32") - 1; 5619 public: 5620 5621 virtual size_t first_size() const {return n;} 5622 virtual char* first_demangled_name(char* buf) const 5623 { 5624 strncpy(buf, "decimal32", n); 5625 return buf + n; 5626 } 5627 }; 5628 5629 class __decimal16 5630 : public __node 5631 { 5632 static const size_t n = sizeof("decimal16") - 1; 5633 public: 5634 5635 virtual size_t first_size() const {return n;} 5636 virtual char* first_demangled_name(char* buf) const 5637 { 5638 strncpy(buf, "decimal16", n); 5639 return buf + n; 5640 } 5641 }; 5642 5643 class __d_char32_t 5644 : public __node 5645 { 5646 static const size_t n = sizeof("char32_t") - 1; 5647 public: 5648 5649 virtual size_t first_size() const {return n;} 5650 virtual char* first_demangled_name(char* buf) const 5651 { 5652 strncpy(buf, "char32_t", n); 5653 return buf + n; 5654 } 5655 }; 5656 5657 class __d_char16_t 5658 : public __node 5659 { 5660 static const size_t n = sizeof("char16_t") - 1; 5661 public: 5662 5663 virtual size_t first_size() const {return n;} 5664 virtual char* first_demangled_name(char* buf) const 5665 { 5666 strncpy(buf, "char16_t", n); 5667 return buf + n; 5668 } 5669 }; 5670 5671 class __auto 5672 : public __node 5673 { 5674 static const size_t n = sizeof("auto") - 1; 5675 public: 5676 5677 virtual size_t first_size() const {return n;} 5678 virtual char* first_demangled_name(char* buf) const 5679 { 5680 strncpy(buf, "auto", n); 5681 return buf + n; 5682 } 5683 }; 5684 5685 class __nullptr_t 5686 : public __node 5687 { 5688 static const size_t n = sizeof("std::nullptr_t") - 1; 5689 public: 5690 5691 virtual size_t first_size() const {return n;} 5692 virtual char* first_demangled_name(char* buf) const 5693 { 5694 strncpy(buf, "std::nullptr_t", n); 5695 return buf + n; 5696 } 5697 }; 5698 5699 class __array 5700 : public __node 5701 { 5702 public: 5703 5704 explicit __array(__node* type) 5705 { 5706 __left_ = type; 5707 } 5708 5709 __array(__node* type, size_t dim) 5710 { 5711 __left_ = type; 5712 __size_ = dim; 5713 } 5714 5715 __array(__node* type, __node* dim) 5716 { 5717 __left_ = type; 5718 __right_ = dim; 5719 } 5720 5721 virtual size_t size() const 5722 { 5723 if (__cached_size_ == -1) 5724 { 5725 size_t r = __left_->size() + 3; 5726 if (__right_ != 0) 5727 r += __right_->size(); 5728 else if (__size_ != 0) 5729 r += static_cast<size_t>(snprintf(0, 0, "%ld", __size_)); 5730 const_cast<long&>(__cached_size_) = static_cast<long>(r); 5731 } 5732 return static_cast<size_t>(__cached_size_); 5733 } 5734 5735 virtual char* get_demangled_name(char* buf) const 5736 { 5737 buf = __left_->get_demangled_name(buf); 5738 *buf++ = ' '; 5739 *buf++ = '['; 5740 if (__right_ != 0) 5741 buf = __right_->get_demangled_name(buf); 5742 else if (__size_ != 0) 5743 { 5744 int rs = sprintf(buf, "%ld", __size_); 5745 buf += rs; 5746 } 5747 *buf++ = ']'; 5748 return buf; 5749 } 5750 5751 virtual size_t first_size() const 5752 { 5753 return __left_->first_size(); 5754 } 5755 5756 virtual char* first_demangled_name(char* buf) const 5757 { 5758 return __left_->first_demangled_name(buf); 5759 } 5760 5761 virtual size_t second_size() const 5762 { 5763 size_t r = 2 + __left_->second_size(); 5764 if (!__left_->is_array()) 5765 ++r; 5766 if (__right_ != 0) 5767 r += __right_->size(); 5768 else if (__size_ != 0) 5769 r += static_cast<size_t>(snprintf(0, 0, "%ld", __size_)); 5770 return r; 5771 } 5772 5773 virtual char* second_demangled_name(char* buf) const 5774 { 5775 *buf++ = ' '; 5776 *buf++ = '['; 5777 if (__right_ != 0) 5778 buf = __right_->get_demangled_name(buf); 5779 else if (__size_ != 0) 5780 { 5781 int off = sprintf(buf, "%ld", __size_); 5782 buf += off; 5783 } 5784 char* t = buf; 5785 buf = __left_->second_demangled_name(buf); 5786 *t = ']'; 5787 if (buf == t) 5788 ++buf; 5789 return buf; 5790 } 5791 virtual bool is_array() const 5792 { 5793 return true; 5794 } 5795 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 5796 { 5797 bool r = __left_->fix_forward_references(t_begin, t_end); 5798 if (__right_) 5799 r = r && __right_->fix_forward_references(t_begin, t_end); 5800 return r; 5801 } 5802 }; 5803 5804 class __pointer_to_member_type 5805 : public __node 5806 { 5807 public: 5808 5809 __pointer_to_member_type(__node* class_type, __node* member_type) 5810 { 5811 __left_ = class_type; 5812 __right_ = member_type; 5813 } 5814 5815 virtual size_t first_size() const 5816 { 5817 if (__cached_size_ == -1) 5818 const_cast<long&>(__cached_size_) = static_cast<long>(__left_->size() + 3 5819 + __right_->first_size() 5820 + __right_->second_size()); 5821 return static_cast<size_t>(__cached_size_); 5822 } 5823 virtual char* first_demangled_name(char* buf) const 5824 { 5825 buf = __right_->first_demangled_name(buf); 5826 buf = __left_->get_demangled_name(buf); 5827 *buf++ = ':'; 5828 *buf++ = ':'; 5829 *buf++ = '*'; 5830 return __right_->second_demangled_name(buf); 5831 } 5832 virtual __node* base_name() const 5833 { 5834 return __left_->base_name(); 5835 } 5836 virtual bool is_reference_or_pointer_to_function_or_array() const 5837 { 5838 return __right_->is_function(); 5839 } 5840 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 5841 { 5842 return __left_->fix_forward_references(t_begin, t_end) && 5843 __right_->fix_forward_references(t_begin, t_end); 5844 } 5845 }; 5846 5847 class __decltype_node 5848 : public __node 5849 { 5850 public: 5851 5852 explicit __decltype_node(__node* expr) 5853 { 5854 __right_ = expr; 5855 } 5856 5857 virtual size_t first_size() const 5858 { 5859 if (__cached_size_ == -1) 5860 const_cast<long&>(__cached_size_) = static_cast<long>(10 + __right_->size()); 5861 return static_cast<size_t>(__cached_size_); 5862 } 5863 5864 virtual char* first_demangled_name(char* buf) const 5865 { 5866 strncpy(buf, "decltype(", 9); 5867 buf += 9; 5868 buf = __right_->get_demangled_name(buf); 5869 *buf++ = ')'; 5870 return buf; 5871 } 5872 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 5873 { 5874 return __right_->fix_forward_references(t_begin, t_end); 5875 } 5876 }; 5877 5878 class __nested_delimeter 5879 : public __node 5880 { 5881 public: 5882 5883 explicit __nested_delimeter(__node* prev, __node* arg) 5884 { 5885 __left_ = prev; 5886 __right_ = arg; 5887 } 5888 5889 virtual size_t first_size() const 5890 { 5891 if (__cached_size_ == -1) 5892 const_cast<long&>(__cached_size_) = static_cast<long>(__left_->size() + 5893 __right_->size() + 2); 5894 return static_cast<size_t>(__cached_size_); 5895 } 5896 5897 virtual char* first_demangled_name(char* buf) const 5898 { 5899 buf = __left_->get_demangled_name(buf); 5900 *buf++ = ':'; 5901 *buf++ = ':'; 5902 return __right_->get_demangled_name(buf); 5903 } 5904 5905 virtual bool ends_with_template(bool parsing = false) const 5906 { 5907 return __right_->ends_with_template(parsing); 5908 } 5909 virtual __node* base_name() const 5910 { 5911 return __right_->base_name(); 5912 } 5913 virtual bool is_ctor_dtor_conv() const 5914 { 5915 return __right_->is_ctor_dtor_conv(); 5916 } 5917 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 5918 { 5919 return __left_->fix_forward_references(t_begin, t_end) && 5920 __right_->fix_forward_references(t_begin, t_end); 5921 } 5922 virtual __node* extract_cv(__node*&) const 5923 { 5924 return __right_->extract_cv(const_cast<__node*&>(__right_)); 5925 } 5926 }; 5927 5928 class __unresolved_name 5929 : public __node 5930 { 5931 public: 5932 5933 __unresolved_name(__node* prev, __node* arg) 5934 { 5935 __left_ = prev; 5936 __right_ = arg; 5937 } 5938 5939 __unresolved_name(bool global, __node* prev, __node* arg) 5940 { 5941 __size_ = global; 5942 __left_ = prev; 5943 __right_ = arg; 5944 } 5945 5946 virtual size_t first_size() const 5947 { 5948 if (__cached_size_ == -1) 5949 const_cast<long&>(__cached_size_) = static_cast<long>((__left_ ? 5950 __left_->size() + 2 : 0) + 5951 __right_->size() + __size_ * 2); 5952 return static_cast<size_t>(__cached_size_); 5953 } 5954 5955 virtual char* first_demangled_name(char* buf) const 5956 { 5957 if (__size_) 5958 { 5959 *buf++ = ':'; 5960 *buf++ = ':'; 5961 } 5962 if (__left_) 5963 { 5964 buf = __left_->get_demangled_name(buf); 5965 *buf++ = ':'; 5966 *buf++ = ':'; 5967 } 5968 return __right_->get_demangled_name(buf); 5969 } 5970 5971 virtual bool ends_with_template(bool parsing = false) const 5972 { 5973 return __right_->ends_with_template(parsing); 5974 } 5975 virtual __node* base_name() const 5976 { 5977 return __right_->base_name(); 5978 } 5979 virtual bool is_ctor_dtor_conv() const 5980 { 5981 return __right_->is_ctor_dtor_conv(); 5982 } 5983 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 5984 { 5985 bool r = true; 5986 if (__left_) 5987 r = __left_->fix_forward_references(t_begin, t_end); 5988 return r && __right_->fix_forward_references(t_begin, t_end); 5989 } 5990 virtual __node* extract_cv(__node*&) const 5991 { 5992 return __right_->extract_cv(const_cast<__node*&>(__right_)); 5993 } 5994 }; 5995 5996 class __string_literal 5997 : public __node 5998 { 5999 public: 6000 6001 virtual size_t first_size() const 6002 { 6003 return 14; 6004 } 6005 6006 virtual char* first_demangled_name(char* buf) const 6007 { 6008 strncpy(buf, "string literal", 14); 6009 return buf + 14; 6010 } 6011 }; 6012 6013 class __constructor 6014 : public __node 6015 { 6016 public: 6017 6018 explicit __constructor(__node* name) 6019 { 6020 __right_ = name; 6021 } 6022 6023 virtual size_t first_size() const 6024 { 6025 if (__cached_size_ == -1) 6026 const_cast<long&>(__cached_size_) = static_cast<long>(__right_->base_size()); 6027 return static_cast<size_t>(__cached_size_); 6028 } 6029 6030 virtual char* first_demangled_name(char* buf) const 6031 { 6032 return __right_->get_base_name(buf); 6033 } 6034 virtual __node* base_name() const 6035 { 6036 return __right_->base_name(); 6037 } 6038 virtual bool ends_with_template(bool parsing = false) const 6039 { 6040 return __right_->ends_with_template(parsing); 6041 } 6042 virtual bool is_ctor_dtor_conv() const 6043 { 6044 return true; 6045 } 6046 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 6047 { 6048 return __right_->fix_forward_references(t_begin, t_end); 6049 } 6050 }; 6051 6052 class __destructor 6053 : public __node 6054 { 6055 public: 6056 6057 explicit __destructor(__node* name) 6058 { 6059 __right_ = name; 6060 } 6061 6062 virtual size_t first_size() const 6063 { 6064 if (__cached_size_ == -1) 6065 const_cast<long&>(__cached_size_) = static_cast<long>(__right_->base_size() + 1); 6066 return static_cast<size_t>(__cached_size_); 6067 } 6068 6069 virtual char* first_demangled_name(char* buf) const 6070 { 6071 *buf++ = '~'; 6072 return __right_->get_base_name(buf); 6073 } 6074 virtual __node* base_name() const 6075 { 6076 return __right_->base_name(); 6077 } 6078 virtual bool is_ctor_dtor_conv() const 6079 { 6080 return true; 6081 } 6082 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 6083 { 6084 return __right_->fix_forward_references(t_begin, t_end); 6085 } 6086 }; 6087 6088 class __dot_suffix 6089 : public __node 6090 { 6091 public: 6092 __dot_suffix(__node* name, const char* suffix, size_t sz) 6093 { 6094 __left_ = name; 6095 __name_ = suffix; 6096 __size_ = sz; 6097 } 6098 6099 virtual size_t first_size() const 6100 { 6101 if (__cached_size_ == -1) 6102 { 6103 size_t off = __left_->size(); 6104 off += __size_ + 3; 6105 const_cast<long&>(__cached_size_) = static_cast<long>(off); 6106 } 6107 return static_cast<size_t>(__cached_size_); 6108 } 6109 virtual char* first_demangled_name(char* buf) const 6110 { 6111 buf = __left_->get_demangled_name(buf); 6112 *buf++ = ' '; 6113 *buf++ = '('; 6114 strncpy(buf, __name_, __size_); 6115 buf += __size_; 6116 *buf++ = ')'; 6117 return buf; 6118 } 6119 virtual __node* base_name() const 6120 { 6121 return __left_->base_name(); 6122 } 6123 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 6124 { 6125 return __left_->fix_forward_references(t_begin, t_end); 6126 } 6127 }; 6128 6129 class __vector_type 6130 : public __node 6131 { 6132 public: 6133 __vector_type(__node* type, const char* num, size_t sz) 6134 { 6135 __left_ = type; 6136 __name_ = num; 6137 __size_ = sz; 6138 } 6139 6140 __vector_type(__node* type, __node* num) 6141 { 6142 __left_ = type; 6143 __right_ = num; 6144 } 6145 6146 virtual size_t first_size() const 6147 { 6148 if (__cached_size_ == -1) 6149 { 6150 size_t off = 5; 6151 if (__left_) 6152 off = __left_->size(); 6153 off += 9; 6154 if (__right_) 6155 off += __right_->size(); 6156 else if (__size_ > 0) 6157 off += __size_; 6158 const_cast<long&>(__cached_size_) = static_cast<long>(off); 6159 } 6160 return static_cast<size_t>(__cached_size_); 6161 } 6162 virtual char* first_demangled_name(char* buf) const 6163 { 6164 if (__left_) 6165 buf = __left_->get_demangled_name(buf); 6166 else 6167 { 6168 strncpy(buf, "pixel", 5); 6169 buf += 5; 6170 } 6171 strncpy(buf, " vector[", 8); 6172 buf += 8; 6173 if (__right_) 6174 buf = __right_->get_demangled_name(buf); 6175 else if (__size_ > 0) 6176 { 6177 strncpy(buf, __name_, __size_); 6178 buf += __size_; 6179 } 6180 *buf++ = ']'; 6181 return buf; 6182 } 6183 virtual __node* base_name() const 6184 { 6185 if (__left_) 6186 return __left_->base_name(); 6187 return __left_; 6188 } 6189 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 6190 { 6191 bool r = true; 6192 if (__left_) 6193 r = __left_->fix_forward_references(t_begin, t_end); 6194 if (__right_) 6195 r = r && __right_->fix_forward_references(t_begin, t_end); 6196 return r; 6197 } 6198 }; 6199 6200 6201 enum {invalid_args = -3, invalid_mangled_name, memory_alloc_failure, success, 6202 not_yet_implemented}; 6203 6204 __demangle_tree::__demangle_tree(const char* mangled_name, char* buf, size_t bs) 6205 : __mangled_name_begin_(0), __mangled_name_end_(0), 6206 __status_(invalid_mangled_name), __root_(0), 6207 __node_begin_(0), __node_end_(0), __node_cap_(0), 6208 __sub_begin_(0), __sub_end_(0), __sub_cap_(0), 6209 __t_begin_(0), __t_end_(0), __t_cap_(0), 6210 __tag_templates_(true), 6211 __fix_forward_references_(false) 6212 { 6213 size_t n = strlen(mangled_name); 6214 size_t ms = n + 2*n*sizeof(__node) + 2*n*sizeof(__node*); 6215 char* m; 6216 if (ms <= bs) 6217 { 6218 m = buf; 6219 __owns_buf_ = false; 6220 } 6221 else 6222 { 6223 m = static_cast<char*>(malloc(ms)); 6224 __owns_buf_ = true; 6225 } 6226 if (m == NULL) 6227 { 6228 __status_ = memory_alloc_failure; 6229 return; 6230 } 6231 __node_begin_ = __node_end_ = (__node*)(m); 6232 __node_cap_ = __node_begin_ + 2*n; 6233 __sub_begin_ = __sub_end_ = (__node**)(__node_cap_); 6234 __sub_cap_ = __sub_begin_ + n; 6235 __t_begin_ = __t_end_ = (__node**)(__sub_cap_); 6236 __t_cap_ = __t_begin_ + n; 6237 __mangled_name_begin_ = (const char*)(__t_cap_); 6238 __mangled_name_end_ = __mangled_name_begin_ + n; 6239 strncpy(const_cast<char*>(__mangled_name_begin_), mangled_name, n); 6240 } 6241 6242 __demangle_tree::~__demangle_tree() 6243 { 6244 if (__owns_buf_) 6245 free(__node_begin_); 6246 } 6247 6248 __demangle_tree::__demangle_tree(__demangle_tree& t) 6249 : __mangled_name_begin_(t.__mangled_name_begin_), 6250 __mangled_name_end_(t.__mangled_name_end_), 6251 __status_(t.__status_), __root_(t.__root_), 6252 __node_begin_(t.__node_begin_), __node_end_(t.__node_end_), 6253 __node_cap_(t.__node_cap_), 6254 __sub_begin_(t.__sub_begin_), __sub_end_(t.__sub_end_), 6255 __sub_cap_(t.__sub_cap_), 6256 __t_begin_(t.__t_begin_), __t_end_(t.__t_end_), 6257 __t_cap_(t.__t_cap_), 6258 __tag_templates_(t.__tag_templates_), 6259 __fix_forward_references_(t.__fix_forward_references_), 6260 __owns_buf_(t.__owns_buf_) 6261 { 6262 t.__mangled_name_begin_ = 0; 6263 t.__mangled_name_end_ = 0; 6264 t.__status_ = invalid_mangled_name; 6265 t.__root_ = 0; 6266 t.__node_begin_ = t.__node_end_ = t.__node_cap_ = 0; 6267 t.__sub_begin_ = t.__sub_end_ = t.__sub_cap_ = 0; 6268 t.__t_begin_ = t.__t_end_ = t.__t_cap_ = 0; 6269 t.__owns_buf_ = false; 6270 } 6271 6272 __demangle_tree::__demangle_tree(__demangle_tree_rv rv) 6273 : __mangled_name_begin_(rv.ptr_->__mangled_name_begin_), 6274 __mangled_name_end_(rv.ptr_->__mangled_name_end_), 6275 __status_(rv.ptr_->__status_), __root_(rv.ptr_->__root_), 6276 __node_begin_(rv.ptr_->__node_begin_), __node_end_(rv.ptr_->__node_end_), 6277 __node_cap_(rv.ptr_->__node_cap_), 6278 __sub_begin_(rv.ptr_->__sub_begin_), __sub_end_(rv.ptr_->__sub_end_), 6279 __sub_cap_(rv.ptr_->__sub_cap_), 6280 __t_begin_(rv.ptr_->__t_begin_), __t_end_(rv.ptr_->__t_end_), 6281 __t_cap_(rv.ptr_->__t_cap_), 6282 __tag_templates_(rv.ptr_->__tag_templates_), 6283 __fix_forward_references_(rv.ptr_->__fix_forward_references_), 6284 __owns_buf_(rv.ptr_->__owns_buf_) 6285 { 6286 rv.ptr_->__mangled_name_begin_ = 0; 6287 rv.ptr_->__mangled_name_end_ = 0; 6288 rv.ptr_->__status_ = invalid_mangled_name; 6289 rv.ptr_->__root_ = 0; 6290 rv.ptr_->__node_begin_ = rv.ptr_->__node_end_ = rv.ptr_->__node_cap_ = 0; 6291 rv.ptr_->__sub_begin_ = rv.ptr_->__sub_end_ = rv.ptr_->__sub_cap_ = 0; 6292 rv.ptr_->__t_begin_ = rv.ptr_->__t_end_ = rv.ptr_->__t_cap_ = 0; 6293 rv.ptr_->__owns_buf_ = false; 6294 } 6295 6296 int 6297 __demangle_tree::__status() const 6298 { 6299 return __status_; 6300 } 6301 6302 size_t 6303 __demangle_tree::size() const 6304 { 6305 return __status_ == success ? __root_->size() : 0; 6306 } 6307 6308 char* 6309 __demangle_tree::__get_demangled_name(char* buf) const 6310 { 6311 if (__status_ == success) 6312 return __root_->get_demangled_name(buf); 6313 return 0; 6314 } 6315 6316 template <class _Tp> 6317 bool 6318 __demangle_tree::__make() 6319 { 6320 if (__node_end_ < __node_cap_) 6321 { 6322 ::new (__node_end_) _Tp(); 6323 __root_ = __node_end_; 6324 ++__node_end_; 6325 return true; 6326 } 6327 __status_ = memory_alloc_failure; 6328 return false; 6329 } 6330 6331 template <class _Tp, class _A0> 6332 bool 6333 __demangle_tree::__make(_A0 __a0) 6334 { 6335 if (__node_end_ < __node_cap_) 6336 { 6337 ::new (__node_end_) _Tp(__a0); 6338 __root_ = __node_end_; 6339 ++__node_end_; 6340 return true; 6341 } 6342 __status_ = memory_alloc_failure; 6343 return false; 6344 } 6345 6346 template <class _Tp, class _A0, class _A1> 6347 bool 6348 __demangle_tree::__make(_A0 __a0, _A1 __a1) 6349 { 6350 if (__node_end_ < __node_cap_) 6351 { 6352 ::new (__node_end_) _Tp(__a0, __a1); 6353 __root_ = __node_end_; 6354 ++__node_end_; 6355 return true; 6356 } 6357 __status_ = memory_alloc_failure; 6358 return false; 6359 } 6360 6361 template <class _Tp, class _A0, class _A1, class _A2> 6362 bool 6363 __demangle_tree::__make(_A0 __a0, _A1 __a1, _A2 __a2) 6364 { 6365 if (__node_end_ < __node_cap_) 6366 { 6367 ::new (__node_end_) _Tp(__a0, __a1, __a2); 6368 __root_ = __node_end_; 6369 ++__node_end_; 6370 return true; 6371 } 6372 __status_ = memory_alloc_failure; 6373 return false; 6374 } 6375 6376 template <class _Tp, class _A0, class _A1, class _A2, class _A3> 6377 bool 6378 __demangle_tree::__make(_A0 __a0, _A1 __a1, _A2 __a2, _A3 __a3) 6379 { 6380 if (__node_end_ < __node_cap_) 6381 { 6382 ::new (__node_end_) _Tp(__a0, __a1, __a2, __a3); 6383 __root_ = __node_end_; 6384 ++__node_end_; 6385 return true; 6386 } 6387 __status_ = memory_alloc_failure; 6388 return false; 6389 } 6390 6391 template <class _Tp, class _A0, class _A1, class _A2, class _A3, class _A4> 6392 bool 6393 __demangle_tree::__make(_A0 __a0, _A1 __a1, _A2 __a2, _A3 __a3, _A4 __a4) 6394 { 6395 if (__node_end_ < __node_cap_) 6396 { 6397 ::new (__node_end_) _Tp(__a0, __a1, __a2, __a3, __a4); 6398 __root_ = __node_end_; 6399 ++__node_end_; 6400 return true; 6401 } 6402 __status_ = memory_alloc_failure; 6403 return false; 6404 } 6405 6406 template <class _Tp, class _A0, class _A1, class _A2, class _A3, class _A4, 6407 class _A5> 6408 bool 6409 __demangle_tree::__make(_A0 __a0, _A1 __a1, _A2 __a2, _A3 __a3, _A4 __a4, 6410 _A5 __a5) 6411 { 6412 if (__node_end_ < __node_cap_) 6413 { 6414 ::new (__node_end_) _Tp(__a0, __a1, __a2, __a3, __a4, __a5); 6415 __root_ = __node_end_; 6416 ++__node_end_; 6417 return true; 6418 } 6419 __status_ = memory_alloc_failure; 6420 return false; 6421 } 6422 6423 // <CV-qualifiers> ::= [r] [V] [K] # restrict (C99), volatile, const 6424 // [R | O] # & or && 6425 6426 const char* 6427 __demangle_tree::__parse_cv_qualifiers(const char* first, const char* last, 6428 unsigned& cv, bool look_for_ref_quals) 6429 { 6430 if (look_for_ref_quals) 6431 { 6432 for (; first != last; ++first) 6433 { 6434 switch (*first) 6435 { 6436 case 'r': 6437 cv |= 4; 6438 break; 6439 case 'V': 6440 cv |= 2; 6441 break; 6442 case 'K': 6443 cv |= 1; 6444 break; 6445 case 'R': 6446 cv |= 8; 6447 break; 6448 case 'O': 6449 cv |= 16; 6450 break; 6451 default: 6452 return first; 6453 } 6454 } 6455 } 6456 else 6457 { 6458 for (; first != last; ++first) 6459 { 6460 switch (*first) 6461 { 6462 case 'r': 6463 cv |= 4; 6464 break; 6465 case 'V': 6466 cv |= 2; 6467 break; 6468 case 'K': 6469 cv |= 1; 6470 break; 6471 default: 6472 return first; 6473 } 6474 } 6475 } 6476 return first; 6477 } 6478 6479 // <builtin-type> ::= v # void 6480 // ::= w # wchar_t 6481 // ::= b # bool 6482 // ::= c # char 6483 // ::= a # signed char 6484 // ::= h # unsigned char 6485 // ::= s # short 6486 // ::= t # unsigned short 6487 // ::= i # int 6488 // ::= j # unsigned int 6489 // ::= l # long 6490 // ::= m # unsigned long 6491 // ::= x # long long, __int64 6492 // ::= y # unsigned long long, __int64 6493 // ::= n # __int128 6494 // ::= o # unsigned __int128 6495 // ::= f # float 6496 // ::= d # double 6497 // ::= e # long double, __float80 6498 // ::= g # __float128 6499 // ::= z # ellipsis 6500 // ::= Dd # IEEE 754r decimal floating point (64 bits) 6501 // ::= De # IEEE 754r decimal floating point (128 bits) 6502 // ::= Df # IEEE 754r decimal floating point (32 bits) 6503 // ::= Dh # IEEE 754r half-precision floating point (16 bits) 6504 // ::= Di # char32_t 6505 // ::= Ds # char16_t 6506 // ::= Da # auto (in dependent new-expressions) 6507 // ::= Dn # std::nullptr_t (i.e., decltype(nullptr)) 6508 // ::= u <source-name> # vendor extended type 6509 6510 const char* 6511 __demangle_tree::__parse_builtin_type(const char* first, const char* last) 6512 { 6513 if (first != last) 6514 { 6515 switch (*first) 6516 { 6517 case 'v': 6518 if (__make<__void>()) 6519 ++first; 6520 break; 6521 case 'w': 6522 if (__make<__wchar_t>()) 6523 ++first; 6524 break; 6525 case 'b': 6526 if (__make<__bool>()) 6527 ++first; 6528 break; 6529 case 'c': 6530 if (__make<__char>()) 6531 ++first; 6532 break; 6533 case 'a': 6534 if (__make<__signed_char>()) 6535 ++first; 6536 break; 6537 case 'h': 6538 if (__make<__unsigned_char>()) 6539 ++first; 6540 break; 6541 case 's': 6542 if (__make<__short>()) 6543 ++first; 6544 break; 6545 case 't': 6546 if (__make<__unsigned_short>()) 6547 ++first; 6548 break; 6549 case 'i': 6550 if (__make<__int>()) 6551 ++first; 6552 break; 6553 case 'j': 6554 if (__make<__unsigned_int>()) 6555 ++first; 6556 break; 6557 case 'l': 6558 if (__make<__long>()) 6559 ++first; 6560 break; 6561 case 'm': 6562 if (__make<__unsigned_long>()) 6563 ++first; 6564 break; 6565 case 'x': 6566 if (__make<__long_long>()) 6567 ++first; 6568 break; 6569 case 'y': 6570 if (__make<__unsigned_long_long>()) 6571 ++first; 6572 break; 6573 case 'n': 6574 if (__make<__signed_int128>()) 6575 ++first; 6576 break; 6577 case 'o': 6578 if (__make<__unsigned_int128>()) 6579 ++first; 6580 break; 6581 case 'f': 6582 if (__make<__float>()) 6583 ++first; 6584 break; 6585 case 'd': 6586 if (__make<__double>()) 6587 ++first; 6588 break; 6589 case 'e': 6590 if (__make<__long_double>()) 6591 ++first; 6592 break; 6593 case 'g': 6594 if (__make<__float128>()) 6595 ++first; 6596 break; 6597 case 'z': 6598 if (__make<__ellipsis>()) 6599 ++first; 6600 break; 6601 case 'D': 6602 if (first+1 != last) 6603 { 6604 switch (first[1]) 6605 { 6606 case 'd': 6607 if (__make<__decimal64>()) 6608 first += 2; 6609 break; 6610 case 'e': 6611 if (__make<__decimal128>()) 6612 first += 2; 6613 break; 6614 case 'f': 6615 if (__make<__decimal32>()) 6616 first += 2; 6617 break; 6618 case 'h': 6619 if (__make<__decimal16>()) 6620 first += 2; 6621 break; 6622 case 'i': 6623 if (__make<__d_char32_t>()) 6624 first += 2; 6625 break; 6626 case 's': 6627 if (__make<__d_char16_t>()) 6628 first += 2; 6629 break; 6630 case 'a': 6631 if (__make<__auto>()) 6632 first += 2; 6633 break; 6634 case 'n': 6635 if (__make<__nullptr_t>()) 6636 first += 2; 6637 break; 6638 } 6639 } 6640 break; 6641 } 6642 } 6643 return first; 6644 } 6645 6646 // <bare-function-type> ::= <signature type>+ 6647 // # types are possible return type, then parameter types 6648 6649 const char* 6650 __demangle_tree::__parse_bare_function_type(const char* first, const char* last) 6651 { 6652 if (first != last) 6653 { 6654 bool prev_tag_templates = __tag_templates_; 6655 __tag_templates_ = false; 6656 const char* t = __parse_type(first, last); 6657 if (t != first && __make<__list>(__root_)) 6658 { 6659 const char* t0 = t; 6660 __node* head = __root_; 6661 __node* prev = head; 6662 while (true) 6663 { 6664 t = __parse_type(t0, last); 6665 if (t != t0) 6666 { 6667 if (__make<__list>(__root_)) 6668 { 6669 t0 = t; 6670 prev->__right_ = __root_; 6671 __root_->__size_ = prev->__size_ + 1; 6672 prev = __root_; 6673 } 6674 else 6675 break; 6676 } 6677 else 6678 { 6679 first = t; 6680 __root_ = head; 6681 break; 6682 } 6683 } 6684 } 6685 __tag_templates_ = prev_tag_templates; 6686 } 6687 return first; 6688 } 6689 6690 // <function-type> ::= F [Y] <bare-function-type> E 6691 6692 const char* 6693 __demangle_tree::__parse_function_type(const char* first, const char* last) 6694 { 6695 if (first != last && *first == 'F') 6696 { 6697 const char* t = first+1; 6698 if (t != last) 6699 { 6700 bool externC = false; 6701 if (*t == 'Y') 6702 { 6703 externC = true; 6704 if (++t == last) 6705 return first; 6706 } 6707 const char* t1 = __parse_type(t, last); 6708 if (t1 != t) 6709 { 6710 __node* ret = __root_; 6711 t = t1; 6712 t1 = __parse_bare_function_type(t, last); 6713 if (t1 != t && t1 != last && *t1 == 'E') 6714 { 6715 if (dynamic_cast<__void*>(__root_->__left_) != NULL) 6716 __root_->__left_ = NULL; 6717 if (__make<__function_signature>(ret, __root_)) 6718 { 6719 if (__make<__function>((__node*)0, __root_)) 6720 first = t1+1; 6721 } 6722 } 6723 } 6724 } 6725 } 6726 return first; 6727 } 6728 6729 const char* 6730 __demangle_tree::__parse_hex_number(const char* first, const char* last, unsigned long long& n) 6731 { 6732 const char* t = first; 6733 for (; t != last && isxdigit(*t); ++t) 6734 { 6735 if (t == first) 6736 n = 0; 6737 if (isdigit(*t)) 6738 n = n * 16 + static_cast<unsigned long long>(*t - '0'); 6739 else if (isupper(*t)) 6740 n = n * 16 + static_cast<unsigned long long>(*t - 'A') + 10; 6741 else 6742 n = n * 16 + static_cast<unsigned long long>(*t - 'a') + 10; 6743 } 6744 first = t; 6745 return first; 6746 } 6747 6748 // <expr-primary> ::= L <type> <value number> E # integer literal 6749 // ::= L <type> <value float> E # floating literal 6750 // ::= L <string type> E # string literal 6751 // ::= L <nullptr type> E # nullptr literal (i.e., "LDnE") 6752 // ::= L <type> <real-part float> _ <imag-part float> E # complex floating point literal (C 2000) 6753 // ::= L <mangled-name> E # external name 6754 6755 const char* 6756 __demangle_tree::__parse_expr_primary(const char* first, const char* last) 6757 { 6758 if (last - first >= 4 && *first == 'L') 6759 { 6760 switch (first[1]) 6761 { 6762 case 'w': 6763 { 6764 const char* t = __parse_number(first+2, last); 6765 if (t != first+2 && t != last && *t == 'E') 6766 { 6767 if (__make<__wchar_t_literal>(first+2, t)) 6768 first = t+1; 6769 } 6770 } 6771 break; 6772 case 'b': 6773 if (first[3] == 'E') 6774 { 6775 switch (first[2]) 6776 { 6777 case '0': 6778 if (__make<__bool_literal>("false", 5u)) 6779 first += 4; 6780 break; 6781 case '1': 6782 if (__make<__bool_literal>("true", 4u)) 6783 first += 4; 6784 break; 6785 } 6786 } 6787 break; 6788 case 'c': 6789 { 6790 const char* t = __parse_number(first+2, last); 6791 if (t != first+2 && t != last && *t == 'E') 6792 { 6793 if (__make<__char_literal>(first+2, t)) 6794 first = t+1; 6795 } 6796 } 6797 break; 6798 case 'a': 6799 { 6800 const char* t = __parse_number(first+2, last); 6801 if (t != first+2 && t != last && *t == 'E') 6802 { 6803 if (__make<__signed_char_literal>(first+2, t)) 6804 first = t+1; 6805 } 6806 } 6807 break; 6808 case 'h': 6809 { 6810 const char* t = __parse_number(first+2, last); 6811 if (t != first+2 && t != last && *t == 'E') 6812 { 6813 if (__make<__unsigned_char_literal>(first+2, t)) 6814 first = t+1; 6815 } 6816 } 6817 break; 6818 case 's': 6819 { 6820 const char* t = __parse_number(first+2, last); 6821 if (t != first+2 && t != last && *t == 'E') 6822 { 6823 if (__make<__short_literal>(first+2, t)) 6824 first = t+1; 6825 } 6826 } 6827 break; 6828 case 't': 6829 { 6830 const char* t = __parse_number(first+2, last); 6831 if (t != first+2 && t != last && *t == 'E') 6832 { 6833 if (__make<__unsigned_short_literal>(first+2, t)) 6834 first = t+1; 6835 } 6836 } 6837 break; 6838 case 'i': 6839 { 6840 const char* t = __parse_number(first+2, last); 6841 if (t != first+2 && t != last && *t == 'E') 6842 { 6843 if (__make<__int_literal>(first+2, t)) 6844 first = t+1; 6845 } 6846 } 6847 break; 6848 case 'j': 6849 { 6850 const char* t = __parse_number(first+2, last); 6851 if (t != first+2 && t != last && *t == 'E') 6852 { 6853 if (__make<__unsigned_int_literal>(first+2, t)) 6854 first = t+1; 6855 } 6856 } 6857 break; 6858 case 'l': 6859 { 6860 const char* t = __parse_number(first+2, last); 6861 if (t != first+2 && t != last && *t == 'E') 6862 { 6863 if (__make<__long_literal>(first+2, t)) 6864 first = t+1; 6865 } 6866 } 6867 break; 6868 case 'm': 6869 { 6870 const char* t = __parse_number(first+2, last); 6871 if (t != first+2 && t != last && *t == 'E') 6872 { 6873 if (__make<__unsigned_long_literal>(first+2, t)) 6874 first = t+1; 6875 } 6876 } 6877 break; 6878 case 'x': 6879 { 6880 const char* t = __parse_number(first+2, last); 6881 if (t != first+2 && t != last && *t == 'E') 6882 { 6883 if (__make<__long_long_literal>(first+2, t)) 6884 first = t+1; 6885 } 6886 } 6887 break; 6888 case 'y': 6889 { 6890 const char* t = __parse_number(first+2, last); 6891 if (t != first+2 && t != last && *t == 'E') 6892 { 6893 if (__make<__unsigned_long_long_literal>(first+2, t)) 6894 first = t+1; 6895 } 6896 } 6897 break; 6898 case 'n': 6899 { 6900 const char* t = __parse_number(first+2, last); 6901 if (t != first+2 && t != last && *t == 'E') 6902 { 6903 if (__make<__int128_literal>(first+2, t)) 6904 first = t+1; 6905 } 6906 } 6907 break; 6908 case 'o': 6909 { 6910 const char* t = __parse_number(first+2, last); 6911 if (t != first+2 && t != last && *t == 'E') 6912 { 6913 if (__make<__unsigned_int128_literal>(first+2, t)) 6914 first = t+1; 6915 } 6916 } 6917 break; 6918 case 'f': 6919 { 6920 if (last - (first+2) <= 8) 6921 return first; 6922 unsigned long long j; 6923 const char* t = __parse_hex_number(first+2, first+10, j); 6924 if (t != first+2 && t != last && *t == 'E') 6925 { 6926 unsigned i = static_cast<unsigned>(j); 6927 float value = *(float*)&i; 6928 if (__make<__float_literal>(value)) 6929 first = t+1; 6930 } 6931 } 6932 break; 6933 case 'd': 6934 { 6935 if (last - (first+2) <= 16) 6936 return first; 6937 unsigned long long j; 6938 const char* t = __parse_hex_number(first+2, first+18, j); 6939 if (t != first+2 && t != last && *t == 'E') 6940 { 6941 double value = *(double*)&j; 6942 if (__make<__double_literal>(value)) 6943 first = t+1; 6944 } 6945 } 6946 break; 6947 case 'e': 6948 break; 6949 case '_': 6950 if (first[2] == 'Z') 6951 { 6952 const char* t = __parse_encoding(first+3, last); 6953 if (t != first+3 && t != last && *t == 'E') 6954 first = t+1; 6955 } 6956 break; 6957 case 'T': 6958 // Invalid mangled name per 6959 // http://sourcerytools.com/pipermail/cxx-abi-dev/2011-August/002422.html 6960 break; 6961 default: 6962 { 6963 // might be named type 6964 const char* t = __parse_type(first+1, last); 6965 if (t != first+1 && t != last) 6966 { 6967 if (*t != 'E') 6968 { 6969 const char* n = t; 6970 for (; n != last && isdigit(*n); ++n) 6971 ; 6972 if (n != t && n != last && *n == 'E') 6973 { 6974 if (__make<__cast_literal>(__root_, t, n)) 6975 { 6976 first = n+1; 6977 break; 6978 } 6979 } 6980 } 6981 else 6982 { 6983 first = t+1; 6984 break; 6985 } 6986 } 6987 } 6988 // assert(!"case in __parse_expr_primary not implemented"); 6989 __status_ = not_yet_implemented; 6990 } 6991 } 6992 return first; 6993 } 6994 6995 // <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ 6996 // ::= <closure-type-name> 6997 // 6998 // <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ 6999 // 7000 // <lambda-sig> ::= <parameter type>+ # Parameter types or "v" if the lambda has no parameters 7001 7002 const char* 7003 __demangle_tree::__parse_unnamed_type_name(const char* first, const char* last) 7004 { 7005 if (last - first > 2 && first[0] == 'U') 7006 { 7007 char type = first[1]; 7008 switch (type) 7009 { 7010 case 't': 7011 case 'l': 7012 { 7013 const char* t = first + 2; 7014 __node* params = 0; 7015 if (type == 'l') 7016 { 7017 if (*t == 'v') 7018 { 7019 // void lambda 7020 ++t; 7021 if (t != last && *t == 'E') 7022 ++t; 7023 else 7024 return first; 7025 } 7026 else 7027 { 7028 const char* t1 = __parse_type(t, last); 7029 if (t1 == t || !__make<__list>(__root_)) 7030 return first; 7031 params = __root_; 7032 __node* prev = params; 7033 t = t1; 7034 while (true) 7035 { 7036 t1 = __parse_type(t, last); 7037 if (t1 == t) 7038 break; 7039 if (!__make<__list>(__root_)) 7040 return first; 7041 t = t1; 7042 prev->__right_ = __root_; 7043 __root_->__size_ = prev->__size_ + 1; 7044 prev = __root_; 7045 } 7046 if (t == last || *t != 'E') 7047 return first; 7048 ++t; 7049 } 7050 } 7051 const char* number_start = t; 7052 const char* number_end = __parse_number(t, last); 7053 if (number_end == last || *number_end != '_') 7054 return first; 7055 t = number_end + 1; 7056 if (type == 'l') 7057 { 7058 if (!__make<___lambda_node>(params, number_start, static_cast<size_t>(number_end - number_start))) 7059 return first; 7060 } 7061 else 7062 { 7063 if (!__make<__unnamed>(number_start, static_cast<size_t>(number_end - number_start))) 7064 return first; 7065 } 7066 first = t; 7067 } 7068 break; 7069 } 7070 } 7071 return first; 7072 } 7073 7074 // <ctor-dtor-name> ::= C1 # complete object constructor 7075 // ::= C2 # base object constructor 7076 // ::= C3 # complete object allocating constructor 7077 // ::= D0 # deleting destructor 7078 // ::= D1 # complete object destructor 7079 // ::= D2 # base object destructor 7080 7081 const char* 7082 __demangle_tree::__parse_ctor_dtor_name(const char* first, const char* last) 7083 { 7084 if (last-first >= 2 && __root_) 7085 { 7086 switch (first[0]) 7087 { 7088 case 'C': 7089 switch (first[1]) 7090 { 7091 case '1': 7092 case '2': 7093 case '3': 7094 if (__make<__constructor>(__root_->base_name())) 7095 first += 2; 7096 break; 7097 } 7098 break; 7099 case 'D': 7100 switch (first[1]) 7101 { 7102 case '0': 7103 case '1': 7104 case '2': 7105 if (__make<__destructor>(__root_->base_name())) 7106 first += 2; 7107 break; 7108 } 7109 break; 7110 } 7111 } 7112 return first; 7113 } 7114 7115 const char* 7116 __demangle_tree::__parse_unscoped_template_name(const char* first, const char*) 7117 { 7118 // assert(!"__parse_unscoped_template_name not implemented"); 7119 __status_ = not_yet_implemented; 7120 return first; 7121 } 7122 7123 // <discriminator> := _ <non-negative number> # when number < 10 7124 // := __ <non-negative number> _ # when number >= 10 7125 // extension := decimal-digit+ 7126 7127 const char* 7128 __demangle_tree::__parse_discriminator(const char* first, const char* last) 7129 { 7130 // parse but ignore discriminator 7131 if (first != last) 7132 { 7133 if (*first == '_') 7134 { 7135 const char* t1 = first+1; 7136 if (t1 != last) 7137 { 7138 if (isdigit(*t1)) 7139 first = t1+1; 7140 else if (*t1 == '_') 7141 { 7142 for (++t1; t1 != last && isdigit(*t1); ++t1) 7143 ; 7144 if (t1 != last && *t1 == '_') 7145 first = t1 + 1; 7146 } 7147 } 7148 } 7149 else if (isdigit(*first)) 7150 { 7151 const char* t1 = first+1; 7152 for (; t1 != last && isdigit(*t1); ++t1) 7153 ; 7154 first = t1; 7155 } 7156 } 7157 return first; 7158 } 7159 7160 // <local-name> := Z <function encoding> E <entity name> [<discriminator>] 7161 // := Z <function encoding> E s [<discriminator>] 7162 // := Z <function encoding> Ed [ <parameter number> ] _ <entity name> 7163 7164 const char* 7165 __demangle_tree::__parse_local_name(const char* first, const char* last) 7166 { 7167 if (first != last && *first == 'Z') 7168 { 7169 const char* t = __parse_encoding(first+1, last); 7170 if (t != first+1 && t != last && *t == 'E' && ++t != last) 7171 { 7172 __node* encoding = __root_; 7173 switch (*t) 7174 { 7175 case 's': 7176 { 7177 const char*t1 = __parse_discriminator(t+1, last); 7178 if (__make<__string_literal>()) 7179 { 7180 if (__make<__nested_delimeter>(encoding, __root_)) 7181 first = t1; 7182 } 7183 } 7184 break; 7185 case 'd': 7186 // assert(!"__parse_local_name d not implemented"); 7187 __status_ = not_yet_implemented; 7188 break; 7189 default: 7190 { 7191 const char*t1 = __parse_name(t, last); 7192 if (t1 != t) 7193 { 7194 // parse but ignore discriminator 7195 t1 = __parse_discriminator(t1, last); 7196 if (__make<__nested_delimeter>(encoding, __root_)) 7197 first = t1; 7198 } 7199 } 7200 break; 7201 } 7202 } 7203 } 7204 return first; 7205 } 7206 7207 // <destructor-name> ::= <unresolved-type> # e.g., ~T or ~decltype(f()) 7208 // ::= <simple-id> # e.g., ~A<2*N> 7209 7210 const char* 7211 __demangle_tree::__parse_destructor_name(const char* first, const char* last) 7212 { 7213 if (first != last) 7214 { 7215 const char* t = __parse_unresolved_type(first, last); 7216 if (t == first) 7217 t = __parse_simple_id(first, last); 7218 if (t != first && __make<__destructor>(__root_)) 7219 first = t; 7220 } 7221 return first; 7222 } 7223 7224 // <simple-id> ::= <source-name> [ <template-args> ] 7225 7226 const char* 7227 __demangle_tree::__parse_simple_id(const char* first, const char* last) 7228 { 7229 if (first != last) 7230 { 7231 const char* t = __parse_source_name(first, last); 7232 if (t != first) 7233 first = __parse_template_args(t, last); 7234 else 7235 first = t; 7236 } 7237 return first; 7238 } 7239 7240 // <base-unresolved-name> ::= <simple-id> # unresolved name 7241 // extension ::= <operator-name> # unresolved operator-function-id 7242 // extension ::= <operator-name> <template-args> # unresolved operator template-id 7243 // ::= on <operator-name> # unresolved operator-function-id 7244 // ::= on <operator-name> <template-args> # unresolved operator template-id 7245 // ::= dn <destructor-name> # destructor or pseudo-destructor; 7246 // # e.g. ~X or ~X<N-1> 7247 7248 const char* 7249 __demangle_tree::__parse_base_unresolved_name(const char* first, const char* last) 7250 { 7251 if (last - first >= 2) 7252 { 7253 if ((first[0] == 'o' || first[0] == 'd') && first[1] == 'n') 7254 { 7255 if (first[0] == 'o') 7256 { 7257 const char* t = __parse_operator_name(first+2, last); 7258 if (t != first+2) 7259 first = __parse_template_args(t, last); 7260 else 7261 first = t; 7262 } 7263 else 7264 { 7265 const char* t = __parse_destructor_name(first+2, last); 7266 if (t != first+2) 7267 first = t; 7268 } 7269 } 7270 else 7271 { 7272 const char* t = __parse_simple_id(first, last); 7273 if (t == first) 7274 { 7275 t = __parse_operator_name(first, last); 7276 if (t != first) 7277 t = __parse_template_args(t, last); 7278 } 7279 if (t != first) 7280 first = t; 7281 } 7282 } 7283 return first; 7284 } 7285 7286 // <unresolved-type> ::= <template-param> 7287 // ::= <decltype> 7288 // ::= <substitution> 7289 7290 const char* 7291 __demangle_tree::__parse_unresolved_type(const char* first, const char* last) 7292 { 7293 if (first != last) 7294 { 7295 const char* t; 7296 switch (*first) 7297 { 7298 case 'T': 7299 t = __parse_template_param(first, last); 7300 if (t != first) 7301 { 7302 if (__sub_end_ == __sub_cap_) 7303 __status_ = memory_alloc_failure; 7304 else 7305 { 7306 *__sub_end_++ = __root_; 7307 first = t; 7308 } 7309 } 7310 break; 7311 case 'D': 7312 t = __parse_decltype(first, last); 7313 if (t != first) 7314 { 7315 if (__sub_end_ == __sub_cap_) 7316 __status_ = memory_alloc_failure; 7317 else 7318 { 7319 *__sub_end_++ = __root_; 7320 first = t; 7321 } 7322 } 7323 break; 7324 case 'S': 7325 t = __parse_substitution(first, last); 7326 if (t != first) 7327 first = t; 7328 break; 7329 } 7330 } 7331 return first; 7332 } 7333 7334 // <unresolved-qualifier-level> ::= <source-name> [ <template-args> ] 7335 7336 const char* 7337 __demangle_tree::__parse_unresolved_qualifier_level(const char* first, const char* last) 7338 { 7339 if (first != last) 7340 { 7341 const char* t = __parse_source_name(first, last); 7342 if (t != first) 7343 first = __parse_template_args(t, last); 7344 } 7345 return first; 7346 } 7347 7348 // <unresolved-name> 7349 // extension ::= srN <unresolved-type> [<template-args>] <unresolved-qualifier-level>* E <base-unresolved-name> 7350 // ::= [gs] <base-unresolved-name> # x or (with "gs") ::x 7351 // ::= [gs] sr <unresolved-qualifier-level>+ E <base-unresolved-name> 7352 // # A::x, N::y, A<T>::z; "gs" means leading "::" 7353 // ::= sr <unresolved-type> <base-unresolved-name> # T::x / decltype(p)::x 7354 // # T::N::x /decltype(p)::N::x 7355 // (ignored) ::= srN <unresolved-type> <unresolved-qualifier-level>+ E <base-unresolved-name> 7356 7357 const char* 7358 __demangle_tree::__parse_unresolved_name(const char* first, const char* last) 7359 { 7360 if (last - first > 2) 7361 { 7362 const char* t = first; 7363 bool global = false; 7364 if (t[0] == 'g' && t[1] == 's') 7365 { 7366 global = true; 7367 t += 2; 7368 } 7369 const char* t2 = __parse_base_unresolved_name(t, last); 7370 if (t2 != t) 7371 { 7372 if (__make<__unresolved_name>(global, (__node*)0, __root_)) 7373 first = t2; 7374 } 7375 else if (last - t > 2 && t[0] == 's' && t[1] == 'r') 7376 { 7377 if (!global && t[2] == 'N') 7378 { 7379 t2 = __parse_unresolved_type(t+3, last); 7380 if (t2 != t+3 && t2 != last) 7381 { 7382 t = __parse_template_args(t2, last); 7383 if (t == last) 7384 return first; 7385 __node* name = __root_; 7386 while (*t != 'E') 7387 { 7388 t2 = __parse_unresolved_qualifier_level(t, last); 7389 if (t2 == t || t2 == last) 7390 return first; 7391 if (!__make<__nested_delimeter>(name, __root_)) 7392 return first; 7393 name = __root_; 7394 t = t2; 7395 } 7396 t2 = __parse_base_unresolved_name(++t, last); 7397 if (t2 != t && __make<__unresolved_name>(false, name, __root_)) 7398 first = t2; 7399 } 7400 } 7401 else 7402 { 7403 if (!global) 7404 { 7405 t2 = __parse_unresolved_type(t+2, last); 7406 if (t2 != t+2) 7407 { 7408 t = t2; 7409 __node* name = __root_; 7410 t2 = __parse_base_unresolved_name(t, last); 7411 if (t2 != t && __make<__unresolved_name>(false, name, __root_)) 7412 return t2; 7413 return first; 7414 } 7415 } 7416 t2 = __parse_unresolved_qualifier_level(t+2, last); 7417 if (t2 != t+2 && t2 != last) 7418 { 7419 __node* name = __root_; 7420 t = t2; 7421 while (*t != 'E') 7422 { 7423 t2 = __parse_unresolved_qualifier_level(t, last); 7424 if (t2 == t || t2 == last) 7425 return first; 7426 if (!__make<__nested_delimeter>(name, __root_)) 7427 return first; 7428 name = __root_; 7429 t = t2; 7430 } 7431 t2 = __parse_base_unresolved_name(++t, last); 7432 if (t2 != t && __make<__unresolved_name>(global, name, __root_)) 7433 first = t2; 7434 } 7435 } 7436 } 7437 } 7438 return first; 7439 } 7440 7441 // <function-param> ::= fp <top-level CV-qualifiers> _ # L == 0, first parameter 7442 // ::= fp <top-level CV-qualifiers> <parameter-2 non-negative number> _ # L == 0, second and later parameters 7443 // ::= fL <L-1 non-negative number> p <top-level CV-qualifiers> _ # L > 0, first parameter 7444 // ::= fL <L-1 non-negative number> p <top-level CV-qualifiers> 7445 7446 const char* 7447 __demangle_tree::__parse_function_param(const char* first, const char* last) 7448 { 7449 if (last - first >= 3 && *first == 'f') 7450 { 7451 if (first[1] == 'p') 7452 { 7453 // assert(!"__parse_function_param not implemented"); 7454 __status_ = not_yet_implemented; 7455 } 7456 else if (first[1] == 'L') 7457 { 7458 // assert(!"__parse_function_param not implemented"); 7459 __status_ = not_yet_implemented; 7460 } 7461 } 7462 return first; 7463 } 7464 7465 // at <type> # alignof (a type) 7466 7467 const char* 7468 __demangle_tree::__parse_alignof_expr(const char* first, const char* last) 7469 { 7470 if (last - first >= 3 && first[0] == 'a' && first[1] == 't') 7471 { 7472 const char* t = __parse_type(first+2, last); 7473 if (t != first+2) 7474 { 7475 if (__make<__operator_alignof_expression>(__root_)) 7476 first = t; 7477 } 7478 } 7479 return first; 7480 } 7481 7482 // cc <type> <expression> # const_cast<type> (expression) 7483 7484 const char* 7485 __demangle_tree::__parse_const_cast_expr(const char* first, const char* last) 7486 { 7487 if (last - first >= 3 && first[0] == 'c' && first[1] == 'c') 7488 { 7489 const char* t = __parse_type(first+2, last); 7490 if (t != first+2) 7491 { 7492 __node* type = __root_; 7493 const char* t1 = __parse_expression(t, last); 7494 if (t1 != t) 7495 { 7496 if (__make<__const_cast>(type, __root_)) 7497 first = t1; 7498 } 7499 } 7500 } 7501 return first; 7502 } 7503 7504 // cl <expression>+ E # call 7505 7506 const char* 7507 __demangle_tree::__parse_call_expr(const char* first, const char* last) 7508 { 7509 if (last - first >= 4 && first[0] == 'c' && first[1] == 'l') 7510 { 7511 const char* t = __parse_expression(first+2, last); 7512 if (t != first+2) 7513 { 7514 if (t == last) 7515 return first; 7516 __node* name = __root_; 7517 __node* args = 0; 7518 __node* prev = 0; 7519 while (*t != 'E') 7520 { 7521 const char* t1 = __parse_expression(t, last); 7522 if (t1 == t || t1 == last) 7523 return first; 7524 if (!__make<__list>(__root_)) 7525 return first; 7526 if (args == 0) 7527 args = __root_; 7528 if (prev) 7529 { 7530 prev->__right_ = __root_; 7531 __root_->__size_ = prev->__size_ + 1; 7532 } 7533 prev = __root_; 7534 t = t1; 7535 } 7536 ++t; 7537 if (__make<__call_expr>(name, args)) 7538 first = t; 7539 } 7540 } 7541 return first; 7542 } 7543 7544 // cv <type> <expression> # conversion with one argument 7545 // cv <type> _ <expression>* E # conversion with a different number of arguments 7546 7547 const char* 7548 __demangle_tree::__parse_conversion_expr(const char* first, const char* last) 7549 { 7550 if (last - first >= 3 && first[0] == 'c' && first[1] == 'v') 7551 { 7552 const char* t = __parse_type(first+2, last); 7553 if (t != first+2 && t != last) 7554 { 7555 __node* type = __root_; 7556 __node* args = 0; 7557 if (*t != '_') 7558 { 7559 const char* t1 = __parse_expression(t, last); 7560 if (t1 == t) 7561 return first; 7562 args = __root_; 7563 t = t1; 7564 } 7565 else 7566 { 7567 ++t; 7568 if (t == last) 7569 return first; 7570 __node* prev = 0; 7571 while (*t != 'E') 7572 { 7573 const char* t1 = __parse_expression(t, last); 7574 if (t1 == t || t1 == last) 7575 return first; 7576 if (!__make<__list>(__root_)) 7577 return first; 7578 if (args == 0) 7579 args = __root_; 7580 if (prev) 7581 { 7582 prev->__right_ = __root_; 7583 __root_->__size_ = prev->__size_ + 1; 7584 } 7585 prev = __root_; 7586 t = t1; 7587 } 7588 ++t; 7589 } 7590 if (__make<__operator_cast>(type, args)) 7591 first = t; 7592 } 7593 } 7594 return first; 7595 } 7596 7597 // [gs] da <expression> # delete[] expression 7598 7599 const char* 7600 __demangle_tree::__parse_delete_array_expr(const char* first, const char* last) 7601 { 7602 if (last - first >= 4) 7603 { 7604 const char* t = first; 7605 bool parsed_gs = false; 7606 if (t[0] == 'g' && t[1] == 's') 7607 { 7608 t += 2; 7609 parsed_gs = true; 7610 } 7611 if (t[0] == 'd' && t[1] == 'a') 7612 { 7613 t += 2; 7614 const char* t1 = __parse_expression(t, last); 7615 if (t1 != t) 7616 { 7617 if (__make<__delete_array_expr>(parsed_gs, __root_)) 7618 first = t1; 7619 } 7620 } 7621 } 7622 return first; 7623 } 7624 7625 // dc <type> <expression> # dynamic_cast<type> (expression) 7626 7627 const char* 7628 __demangle_tree::__parse_dynamic_cast_expr(const char* first, const char* last) 7629 { 7630 if (last - first >= 3 && first[0] == 'd' && first[1] == 'c') 7631 { 7632 const char* t = __parse_type(first+2, last); 7633 if (t != first+2) 7634 { 7635 __node* type = __root_; 7636 const char* t1 = __parse_expression(t, last); 7637 if (t1 != t) 7638 { 7639 if (__make<__dynamic_cast>(type, __root_)) 7640 first = t1; 7641 } 7642 } 7643 } 7644 return first; 7645 } 7646 7647 // [gs] dl <expression> # delete expression 7648 7649 const char* 7650 __demangle_tree::__parse_delete_expr(const char* first, const char* last) 7651 { 7652 if (last - first >= 4) 7653 { 7654 const char* t = first; 7655 bool parsed_gs = false; 7656 if (t[0] == 'g' && t[1] == 's') 7657 { 7658 t += 2; 7659 parsed_gs = true; 7660 } 7661 if (t[0] == 'd' && t[1] == 'l') 7662 { 7663 t += 2; 7664 const char* t1 = __parse_expression(t, last); 7665 if (t1 != t) 7666 { 7667 if (__make<__delete_expr>(parsed_gs, __root_)) 7668 first = t1; 7669 } 7670 } 7671 } 7672 return first; 7673 } 7674 7675 // ds <expression> <expression> # expr.*expr 7676 7677 const char* 7678 __demangle_tree::__parse_dot_star_expr(const char* first, const char* last) 7679 { 7680 if (last - first >= 3 && first[0] == 'd' && first[1] == 's') 7681 { 7682 const char* t = __parse_expression(first+2, last); 7683 if (t != first+2) 7684 { 7685 __node* expr = __root_; 7686 const char* t1 = __parse_expression(t, last); 7687 if (t1 != t) 7688 { 7689 if (__make<__dot_star_expr>(expr, __root_)) 7690 first = t1; 7691 } 7692 } 7693 } 7694 return first; 7695 } 7696 7697 // dt <expression> <unresolved-name> # expr.name 7698 7699 const char* 7700 __demangle_tree::__parse_dot_expr(const char* first, const char* last) 7701 { 7702 if (last - first >= 3 && first[0] == 'd' && first[1] == 't') 7703 { 7704 const char* t = __parse_expression(first+2, last); 7705 if (t != first+2) 7706 { 7707 __node* expr = __root_; 7708 const char* t1 = __parse_unresolved_name(t, last); 7709 if (t1 != t) 7710 { 7711 if (__make<__dot_expr>(expr, __root_)) 7712 first = t1; 7713 } 7714 } 7715 } 7716 return first; 7717 } 7718 7719 // mm_ <expression> # prefix -- 7720 7721 const char* 7722 __demangle_tree::__parse_decrement_expr(const char* first, const char* last) 7723 { 7724 if (last - first > 3 && first[0] == 'm' && first[1] == 'm' && first[2] == '_') 7725 { 7726 const char* t = __parse_expression(first+3, last); 7727 if (t != first+3) 7728 { 7729 if (__make<__operator_decrement>(true, __root_)) 7730 first = t; 7731 } 7732 } 7733 return first; 7734 } 7735 7736 // pp_ <expression> # prefix ++ 7737 7738 const char* 7739 __demangle_tree::__parse_increment_expr(const char* first, const char* last) 7740 { 7741 if (last - first > 3 && first[0] == 'p' && first[1] == 'p' && first[2] == '_') 7742 { 7743 const char* t = __parse_expression(first+3, last); 7744 if (t != first+3) 7745 { 7746 if (__make<__operator_increment>(true, __root_)) 7747 first = t; 7748 } 7749 } 7750 return first; 7751 } 7752 7753 // [gs] nw <expression>* _ <type> E # new (expr-list) type 7754 // [gs] nw <expression>* _ <type> <initializer> # new (expr-list) type (init) 7755 // [gs] na <expression>* _ <type> E # new[] (expr-list) type 7756 // [gs] na <expression>* _ <type> <initializer> # new[] (expr-list) type (init) 7757 // <initializer> ::= pi <expression>* E # parenthesized initialization 7758 7759 const char* 7760 __demangle_tree::__parse_new_expr(const char* first, const char* last) 7761 { 7762 if (last - first >= 4) 7763 { 7764 const char* t = first; 7765 bool parsed_gs = false; 7766 if (t[0] == 'g' && t[1] == 's') 7767 { 7768 t += 2; 7769 parsed_gs = true; 7770 } 7771 if (t[0] == 'n' && (t[1] == 'w' || t[1] == 'a')) 7772 { 7773 bool is_array = t[1] == 'a'; 7774 t += 2; 7775 if (t == last) 7776 return first; 7777 __node* expr = 0; 7778 __node* prev = 0; 7779 while (*t != '_') 7780 { 7781 const char* t1 = __parse_expression(t, last); 7782 if (t1 == t || t1 == last) 7783 return first; 7784 if (!__make<__list>(__root_)) 7785 return first; 7786 if (expr == 0) 7787 expr = __root_; 7788 if (prev) 7789 { 7790 prev->__right_ = __root_; 7791 __root_->__size_ = prev->__size_ + 1; 7792 } 7793 prev = __root_; 7794 t = t1; 7795 } 7796 ++t; 7797 const char* t1 = __parse_type(t, last); 7798 if (t1 == t || t1 == last) 7799 return first; 7800 t = t1; 7801 __node* type = __root_; 7802 __node* init = 0; 7803 prev = 0; 7804 bool has_init = false; 7805 if (last - t >= 3 && t[0] == 'p' && t[1] == 'i') 7806 { 7807 t += 2; 7808 has_init = true; 7809 while (*t != 'E') 7810 { 7811 t1 = __parse_expression(t, last); 7812 if (t1 == t || t1 == last) 7813 return first; 7814 if (!__make<__list>(__root_)) 7815 return first; 7816 if (init == 0) 7817 init = __root_; 7818 if (prev) 7819 { 7820 prev->__right_ = __root_; 7821 __root_->__size_ = prev->__size_ + 1; 7822 } 7823 prev = __root_; 7824 t = t1; 7825 } 7826 } 7827 if (*t != 'E') 7828 return first; 7829 if (__make<__new_expr>(parsed_gs, is_array, has_init, 7830 expr, type, init)) 7831 first = t; 7832 } 7833 } 7834 return first; 7835 } 7836 7837 // pt <expression> <unresolved-name> # expr->name 7838 7839 const char* 7840 __demangle_tree::__parse_arrow_expr(const char* first, const char* last) 7841 { 7842 if (last - first >= 3 && first[0] == 'p' && first[1] == 't') 7843 { 7844 const char* t = __parse_expression(first+2, last); 7845 if (t != first+2) 7846 { 7847 __node* expr = __root_; 7848 const char* t1 = __parse_unresolved_name(t, last); 7849 if (t1 != t) 7850 { 7851 if (__make<__arrow_expr>(expr, __root_)) 7852 first = t1; 7853 } 7854 } 7855 } 7856 return first; 7857 } 7858 7859 // rc <type> <expression> # reinterpret_cast<type> (expression) 7860 7861 const char* 7862 __demangle_tree::__parse_reinterpret_cast_expr(const char* first, const char* last) 7863 { 7864 if (last - first >= 3 && first[0] == 'r' && first[1] == 'c') 7865 { 7866 const char* t = __parse_type(first+2, last); 7867 if (t != first+2) 7868 { 7869 __node* type = __root_; 7870 const char* t1 = __parse_expression(t, last); 7871 if (t1 != t) 7872 { 7873 if (__make<__reinterpret_cast>(type, __root_)) 7874 first = t1; 7875 } 7876 } 7877 } 7878 return first; 7879 } 7880 7881 // sc <type> <expression> # static_cast<type> (expression) 7882 7883 const char* 7884 __demangle_tree::__parse_static_cast_expr(const char* first, const char* last) 7885 { 7886 if (last - first >= 3 && first[0] == 's' && first[1] == 'c') 7887 { 7888 const char* t = __parse_type(first+2, last); 7889 if (t != first+2) 7890 { 7891 __node* type = __root_; 7892 const char* t1 = __parse_expression(t, last); 7893 if (t1 != t) 7894 { 7895 if (__make<__static_cast>(type, __root_)) 7896 first = t1; 7897 } 7898 } 7899 } 7900 return first; 7901 } 7902 7903 // st <type> # sizeof (a type) 7904 7905 const char* 7906 __demangle_tree::__parse_sizeof_type_expr(const char* first, const char* last) 7907 { 7908 if (last - first >= 3 && first[0] == 's' && first[1] == 't') 7909 { 7910 const char* t = __parse_type(first+2, last); 7911 if (t != first+2) 7912 { 7913 if (__make<__operator_sizeof_expression>(__root_)) 7914 first = t; 7915 } 7916 } 7917 return first; 7918 } 7919 7920 // sZ <template-param> # size of a parameter pack 7921 7922 const char* 7923 __demangle_tree::__parse_sizeof_param_pack_expr(const char* first, const char* last) 7924 { 7925 if (last - first >= 3 && first[0] == 's' && first[1] == 'Z' && first[2] == 'T') 7926 { 7927 const char* t = __parse_template_param(first+2, last); 7928 if (t != first+2) 7929 { 7930 if (__make<__operator_sizeof_param_pack>(__root_)) 7931 first = t; 7932 } 7933 } 7934 return first; 7935 } 7936 7937 // sZ <function-param> # size of a function parameter pack 7938 7939 const char* 7940 __demangle_tree::__parse_sizeof_function_param_pack_expr(const char* first, const char* last) 7941 { 7942 if (last - first >= 3 && first[0] == 's' && first[1] == 'Z' && first[2] == 'f') 7943 { 7944 const char* t = __parse_function_param(first+2, last); 7945 if (t != first+2) 7946 { 7947 if (__make<__operator_sizeof_param_pack>(__root_)) 7948 first = t; 7949 } 7950 } 7951 return first; 7952 } 7953 7954 // sp <expression> # pack expansion 7955 7956 const char* 7957 __demangle_tree::__parse_pack_expansion(const char* first, const char* last) 7958 { 7959 if (last - first >= 3 && first[0] == 's' && first[1] == 'p') 7960 { 7961 const char* t = __parse_expression(first+2, last); 7962 if (t != first+2) 7963 { 7964 if (__make<__pack_expansion>(__root_)) 7965 first = t; 7966 } 7967 } 7968 return first; 7969 } 7970 7971 // te <expression> # typeid (expression) 7972 // ti <type> # typeid (type) 7973 7974 const char* 7975 __demangle_tree::__parse_typeid_expr(const char* first, const char* last) 7976 { 7977 if (last - first >= 3 && first[0] == 't' && (first[1] == 'e' || first[1] == 'i')) 7978 { 7979 const char* t; 7980 if (first[1] == 'e') 7981 t = __parse_expression(first+2, last); 7982 else 7983 t = __parse_type(first+2, last); 7984 if (t != first+2) 7985 { 7986 if (__make<__typeid>(__root_)) 7987 first = t; 7988 } 7989 } 7990 return first; 7991 } 7992 7993 // tw <expression> # throw expression 7994 7995 const char* 7996 __demangle_tree::__parse_throw_expr(const char* first, const char* last) 7997 { 7998 if (last - first >= 3 && first[0] == 't' && first[1] == 'w') 7999 { 8000 const char* t = __parse_expression(first+2, last); 8001 if (t != first+2) 8002 { 8003 if (__make<__throw>(__root_)) 8004 first = t; 8005 } 8006 } 8007 return first; 8008 } 8009 8010 // <expression> ::= <unary operator-name> <expression> 8011 // ::= <binary operator-name> <expression> <expression> 8012 // ::= <ternary operator-name> <expression> <expression> <expression> 8013 // ::= cl <expression>+ E # call 8014 // ::= cv <type> <expression> # conversion with one argument 8015 // ::= cv <type> _ <expression>* E # conversion with a different number of arguments 8016 // ::= [gs] nw <expression>* _ <type> E # new (expr-list) type 8017 // ::= [gs] nw <expression>* _ <type> <initializer> # new (expr-list) type (init) 8018 // ::= [gs] na <expression>* _ <type> E # new[] (expr-list) type 8019 // ::= [gs] na <expression>* _ <type> <initializer> # new[] (expr-list) type (init) 8020 // ::= [gs] dl <expression> # delete expression 8021 // ::= [gs] da <expression> # delete[] expression 8022 // ::= pp_ <expression> # prefix ++ 8023 // ::= mm_ <expression> # prefix -- 8024 // ::= ti <type> # typeid (type) 8025 // ::= te <expression> # typeid (expression) 8026 // ::= dc <type> <expression> # dynamic_cast<type> (expression) 8027 // ::= sc <type> <expression> # static_cast<type> (expression) 8028 // ::= cc <type> <expression> # const_cast<type> (expression) 8029 // ::= rc <type> <expression> # reinterpret_cast<type> (expression) 8030 // ::= st <type> # sizeof (a type) 8031 // ::= at <type> # alignof (a type) 8032 // ::= <template-param> 8033 // ::= <function-param> 8034 // ::= dt <expression> <unresolved-name> # expr.name 8035 // ::= pt <expression> <unresolved-name> # expr->name 8036 // ::= ds <expression> <expression> # expr.*expr 8037 // ::= sZ <template-param> # size of a parameter pack 8038 // ::= sZ <function-param> # size of a function parameter pack 8039 // ::= sp <expression> # pack expansion 8040 // ::= tw <expression> # throw expression 8041 // ::= tr # throw with no operand (rethrow) 8042 // ::= <unresolved-name> # f(p), N::f(p), ::f(p), 8043 // # freestanding dependent name (e.g., T::x), 8044 // # objectless nonstatic member reference 8045 // ::= <expr-primary> 8046 8047 const char* 8048 __demangle_tree::__parse_expression(const char* first, const char* last) 8049 { 8050 if (last - first >= 2) 8051 { 8052 const char* t = first; 8053 bool parsed_gs = false; 8054 if (last - first >= 4 && t[0] == 'g' && t[1] == 's') 8055 { 8056 t += 2; 8057 parsed_gs = true; 8058 } 8059 switch (*t) 8060 { 8061 case 'L': 8062 t = __parse_expr_primary(first, last); 8063 break; 8064 case 'T': 8065 t = __parse_template_param(first, last); 8066 break; 8067 case 'f': 8068 t = __parse_function_param(first, last); 8069 break; 8070 case 'a': 8071 if (t[1] == 't') 8072 t = __parse_alignof_expr(first, last); 8073 break; 8074 case 'c': 8075 switch (t[1]) 8076 { 8077 case 'c': 8078 t = __parse_const_cast_expr(first, last); 8079 break; 8080 case 'l': 8081 t = __parse_call_expr(first, last); 8082 break; 8083 case 'v': 8084 t = __parse_conversion_expr(first, last); 8085 break; 8086 } 8087 break; 8088 case 'd': 8089 switch (t[1]) 8090 { 8091 case 'a': 8092 t = __parse_delete_array_expr(first, last); 8093 break; 8094 case 'c': 8095 t = __parse_dynamic_cast_expr(first, last); 8096 break; 8097 case 'l': 8098 t = __parse_delete_expr(first, last); 8099 break; 8100 case 's': 8101 t = __parse_dot_star_expr(first, last); 8102 break; 8103 case 't': 8104 t = __parse_dot_expr(first, last); 8105 break; 8106 } 8107 break; 8108 case 'm': 8109 t = __parse_decrement_expr(first, last); 8110 break; 8111 case 'n': 8112 switch (t[1]) 8113 { 8114 case 'a': 8115 case 'w': 8116 t = __parse_new_expr(first, last); 8117 break; 8118 } 8119 break; 8120 case 'p': 8121 switch (t[1]) 8122 { 8123 case 'p': 8124 t = __parse_increment_expr(first, last); 8125 break; 8126 case 't': 8127 t = __parse_arrow_expr(first, last); 8128 break; 8129 } 8130 break; 8131 case 'r': 8132 t = __parse_reinterpret_cast_expr(first, last); 8133 break; 8134 case 's': 8135 switch (t[1]) 8136 { 8137 case 'c': 8138 t = __parse_static_cast_expr(first, last); 8139 break; 8140 case 'p': 8141 t = __parse_pack_expansion(first, last); 8142 break; 8143 case 't': 8144 t = __parse_sizeof_type_expr(first, last); 8145 break; 8146 case 'Z': 8147 if (last - t >= 3) 8148 { 8149 switch (t[2]) 8150 { 8151 case 'T': 8152 t = __parse_sizeof_param_pack_expr(first, last); 8153 break; 8154 case 'f': 8155 t = __parse_sizeof_function_param_pack_expr(first, last); 8156 break; 8157 } 8158 } 8159 break; 8160 } 8161 break; 8162 case 't': 8163 switch (t[1]) 8164 { 8165 case 'e': 8166 case 'i': 8167 t = __parse_typeid_expr(first, last); 8168 break; 8169 case 'r': 8170 if (__make<__rethrow>()) 8171 t = first +2; 8172 break; 8173 case 'w': 8174 t = __parse_throw_expr(first, last); 8175 break; 8176 } 8177 break; 8178 } 8179 if ((!parsed_gs && t == first) || (parsed_gs && t == first+2)) 8180 { 8181 int op; 8182 t = __parse_operator_name(first, last, &op); 8183 if (t == first) 8184 first = __parse_unresolved_name(first, last); 8185 else 8186 first = t; 8187 } 8188 else 8189 first = t; 8190 } 8191 return first; 8192 } 8193 8194 // <array-type> ::= A <positive dimension number> _ <element type> 8195 // ::= A [<dimension expression>] _ <element type> 8196 8197 const char* 8198 __demangle_tree::__parse_array_type(const char* first, const char* last) 8199 { 8200 if (first != last && *first == 'A' && first+1 != last) 8201 { 8202 if (first[1] == '_') 8203 { 8204 const char* t = __parse_type(first+2, last); 8205 if (t != first+2) 8206 { 8207 if (__make<__array>(__root_)) 8208 first = t; 8209 } 8210 } 8211 else if ('1' <= first[1] && first[1] <= '9') 8212 { 8213 size_t dim = static_cast<size_t>(first[1] - '0'); 8214 const char* t = first+2; 8215 for (; t != last && isdigit(*t); ++t) 8216 dim = dim * 10 + static_cast<size_t>(*t - '0'); 8217 if (t != last && *t == '_') 8218 { 8219 const char* t2 = __parse_type(t+1, last); 8220 if (t2 != t+1) 8221 { 8222 if (__make<__array>(__root_, dim)) 8223 first = t2; 8224 } 8225 } 8226 } 8227 else 8228 { 8229 const char* t = __parse_expression(first+1, last); 8230 if (t != first+1 && t != last && *t == '_') 8231 { 8232 __node* dim = __root_; 8233 const char* t2 = __parse_type(++t, last); 8234 if (t2 != t) 8235 { 8236 if (__make<__array>(__root_, dim)) 8237 first = t2; 8238 } 8239 } 8240 } 8241 } 8242 return first; 8243 } 8244 8245 // <class-enum-type> ::= <name> 8246 8247 const char* 8248 __demangle_tree::__parse_class_enum_type(const char* first, const char* last) 8249 { 8250 return __parse_name(first, last); 8251 } 8252 8253 // <pointer-to-member-type> ::= M <class type> <member type> 8254 8255 const char* 8256 __demangle_tree::__parse_pointer_to_member_type(const char* first, const char* last) 8257 { 8258 if (first != last && *first == 'M') 8259 { 8260 const char* t = __parse_type(first+1, last); 8261 if (t != first+1) 8262 { 8263 __node* class_type = __root_; 8264 const char* t2 = __parse_type(t, last, true, true); 8265 if (t2 != t) 8266 { 8267 if (__make<__pointer_to_member_type>(class_type, __root_)) 8268 first = t2; 8269 } 8270 } 8271 } 8272 return first; 8273 } 8274 8275 // <decltype> ::= Dt <expression> E # decltype of an id-expression or class member access (C++0x) 8276 // ::= DT <expression> E # decltype of an expression (C++0x) 8277 8278 const char* 8279 __demangle_tree::__parse_decltype(const char* first, const char* last) 8280 { 8281 if (last - first >= 4 && first[0] == 'D') 8282 { 8283 switch (first[1]) 8284 { 8285 case 't': 8286 case 'T': 8287 { 8288 const char* t = __parse_expression(first+2, last); 8289 if (t != first+2 && t != last && *t == 'E') 8290 { 8291 if (__make<__decltype_node>(__root_)) 8292 first = t+1; 8293 } 8294 } 8295 break; 8296 } 8297 } 8298 return first; 8299 } 8300 8301 // <template-param> ::= T_ # first template parameter 8302 // ::= T <parameter-2 non-negative number> _ 8303 8304 const char* 8305 __demangle_tree::__parse_template_param(const char* first, const char* last) 8306 { 8307 if (last - first >= 2) 8308 { 8309 if (*first == 'T') 8310 { 8311 if (first[1] == '_') 8312 { 8313 if (__t_begin_ != __t_end_) 8314 { 8315 if (__make<__sub>(*__t_begin_)) 8316 first += 2; 8317 } 8318 else 8319 { 8320 if (__make<__sub>(size_t(0))) 8321 { 8322 first += 2; 8323 __fix_forward_references_ = true; 8324 } 8325 } 8326 } 8327 else if (isdigit(first[1])) 8328 { 8329 const char* t = first+1; 8330 size_t sub = static_cast<size_t>(*t - '0'); 8331 for (++t; t != last && isdigit(*t); ++t) 8332 { 8333 sub *= 10; 8334 sub += static_cast<size_t>(*t - '0'); 8335 } 8336 if (t == last || *t != '_') 8337 return first; 8338 ++sub; 8339 if (sub < static_cast<size_t>(__t_end_ - __t_begin_)) 8340 { 8341 if (__make<__sub>(__t_begin_[sub])) 8342 first = t+1; 8343 } 8344 else 8345 { 8346 if (__make<__sub>(sub)) 8347 { 8348 first = t+1; 8349 __fix_forward_references_ = true; 8350 } 8351 } 8352 } 8353 } 8354 } 8355 return first; 8356 } 8357 8358 // extension: 8359 // <vector-type> ::= Dv <positive dimension number> _ 8360 // <extended element type> 8361 // ::= Dv [<dimension expression>] _ <element type> 8362 // <extended element type> ::= <element type> 8363 // ::= p # AltiVec vector pixel 8364 8365 const char* 8366 __demangle_tree::__parse_vector_type(const char* first, const char* last) 8367 { 8368 if (last - first > 3 && first[0] == 'D' && first[1] == 'v') 8369 { 8370 if ('1' <= first[2] && first[2] <= '9') 8371 { 8372 const char* t = first+3; 8373 while (*t != '_') 8374 { 8375 if (!isdigit(*t) || ++t == last) 8376 return first; 8377 } 8378 const char* num = first + 2; 8379 size_t sz = static_cast<size_t>(t - num); 8380 if (++t != last) 8381 { 8382 if (*t != 'p') 8383 { 8384 const char* t1 = __parse_type(t, last); 8385 if (t1 != t) 8386 { 8387 if (__make<__vector_type>(__root_, num, sz)) 8388 first = t1; 8389 } 8390 } 8391 else 8392 { 8393 ++t; 8394 if (__make<__vector_type>((__node*)0, num, sz)) 8395 first = t; 8396 } 8397 } 8398 } 8399 else 8400 { 8401 __node* num = 0; 8402 const char* t1 = first+2; 8403 if (*t1 != '_') 8404 { 8405 const char* t = __parse_expression(t1, last); 8406 if (t != t1) 8407 num = __root_; 8408 t1 = t; 8409 } 8410 if (t1 != last && *t1 == '_' && ++t1 != last) 8411 { 8412 const char* t = __parse_type(t1, last); 8413 if (t != t1) 8414 { 8415 if (__make<__vector_type>(__root_, num)) 8416 first = t; 8417 } 8418 } 8419 } 8420 } 8421 return first; 8422 } 8423 8424 // <type> ::= <builtin-type> 8425 // ::= <function-type> 8426 // ::= <class-enum-type> 8427 // ::= <array-type> 8428 // ::= <pointer-to-member-type> 8429 // ::= <template-param> 8430 // ::= <template-template-param> <template-args> 8431 // ::= <decltype> 8432 // ::= <substitution> 8433 // ::= <CV-qualifiers> <type> 8434 // ::= P <type> # pointer-to 8435 // ::= R <type> # reference-to 8436 // ::= O <type> # rvalue reference-to (C++0x) 8437 // ::= C <type> # complex pair (C 2000) 8438 // ::= G <type> # imaginary (C 2000) 8439 // ::= Dp <type> # pack expansion (C++0x) 8440 // ::= U <source-name> <type> # vendor extended type qualifier 8441 // extension := <vector-type> # <vector-type> starts with Dv 8442 8443 const char* 8444 __demangle_tree::__parse_type(const char* first, const char* last, 8445 bool try_to_parse_template_args, 8446 bool look_for_ref_quals) 8447 { 8448 unsigned cv = 0; 8449 const char* t = __parse_cv_qualifiers(first, last, cv, look_for_ref_quals); 8450 if (t != first) 8451 { 8452 const char* t2 = __parse_type(t, last, try_to_parse_template_args); 8453 if (t2 != t) 8454 { 8455 if (__make<__cv_qualifiers>(cv, __root_)) 8456 { 8457 if (__sub_end_ == __sub_cap_) 8458 __status_ = memory_alloc_failure; 8459 else 8460 { 8461 *__sub_end_++ = __root_; 8462 first = t2; 8463 } 8464 } 8465 } 8466 return first; 8467 } 8468 if (first != last) 8469 { 8470 switch (*first) 8471 { 8472 case 'A': 8473 t = __parse_array_type(first, last); 8474 if (t != first) 8475 { 8476 if (__sub_end_ == __sub_cap_) 8477 __status_ = memory_alloc_failure; 8478 else 8479 { 8480 *__sub_end_++ = __root_; 8481 first = t; 8482 } 8483 } 8484 break; 8485 case 'C': 8486 t = __parse_type(first+1, last, try_to_parse_template_args); 8487 if (t != first+1) 8488 { 8489 if (__make<__d_complex>(__root_)) 8490 { 8491 if (__sub_end_ == __sub_cap_) 8492 __status_ = memory_alloc_failure; 8493 else 8494 { 8495 *__sub_end_++ = __root_; 8496 first = t; 8497 } 8498 } 8499 return first; 8500 } 8501 break; 8502 case 'F': 8503 t = __parse_function_type(first, last); 8504 if (t != first) 8505 { 8506 if (__sub_end_ == __sub_cap_) 8507 __status_ = memory_alloc_failure; 8508 else 8509 { 8510 *__sub_end_++ = __root_; 8511 first = t; 8512 } 8513 } 8514 break; 8515 case 'G': 8516 t = __parse_type(first+1, last, try_to_parse_template_args); 8517 if (t != first+1) 8518 { 8519 if (__make<__imaginary>(__root_)) 8520 { 8521 if (__sub_end_ == __sub_cap_) 8522 __status_ = memory_alloc_failure; 8523 else 8524 { 8525 *__sub_end_++ = __root_; 8526 first = t; 8527 } 8528 } 8529 return first; 8530 } 8531 break; 8532 case 'M': 8533 t = __parse_pointer_to_member_type(first, last); 8534 if (t != first) 8535 { 8536 if (__sub_end_ == __sub_cap_) 8537 __status_ = memory_alloc_failure; 8538 else 8539 { 8540 *__sub_end_++ = __root_; 8541 first = t; 8542 } 8543 } 8544 break; 8545 case 'O': 8546 t = __parse_type(first+1, last, try_to_parse_template_args); 8547 if (t != first+1) 8548 { 8549 if (__make<__rvalue_reference_to>(__root_)) 8550 { 8551 if (__sub_end_ == __sub_cap_) 8552 __status_ = memory_alloc_failure; 8553 else 8554 { 8555 *__sub_end_++ = __root_; 8556 first = t; 8557 } 8558 } 8559 return first; 8560 } 8561 break; 8562 case 'P': 8563 t = __parse_type(first+1, last, try_to_parse_template_args); 8564 if (t != first+1) 8565 { 8566 if (__make<__pointer_to>(__root_)) 8567 { 8568 if (__sub_end_ == __sub_cap_) 8569 __status_ = memory_alloc_failure; 8570 else 8571 { 8572 *__sub_end_++ = __root_; 8573 first = t; 8574 } 8575 } 8576 return first; 8577 } 8578 break; 8579 case 'R': 8580 t = __parse_type(first+1, last, try_to_parse_template_args); 8581 if (t != first+1) 8582 { 8583 if (__make<__lvalue_reference_to>(__root_)) 8584 { 8585 if (__sub_end_ == __sub_cap_) 8586 __status_ = memory_alloc_failure; 8587 else 8588 { 8589 *__sub_end_++ = __root_; 8590 first = t; 8591 } 8592 } 8593 return first; 8594 } 8595 break; 8596 case 'T': 8597 t = __parse_template_param(first, last); 8598 if (t != first) 8599 { 8600 if (__sub_end_ == __sub_cap_) 8601 __status_ = memory_alloc_failure; 8602 else 8603 { 8604 *__sub_end_++ = __root_; 8605 if (try_to_parse_template_args) 8606 { 8607 const char* t2 = __parse_template_args(t, last); 8608 if (t2 != t) 8609 { 8610 if (__sub_end_ < __sub_cap_) 8611 { 8612 *__sub_end_++ = __root_; 8613 first = t2; 8614 } 8615 else 8616 __status_ = memory_alloc_failure; 8617 } 8618 else 8619 { 8620 first = t; 8621 } 8622 } 8623 else 8624 { 8625 first = t; 8626 } 8627 } 8628 } 8629 break; 8630 case 'U': 8631 if (first+1 != last) 8632 { 8633 t = __parse_source_name(first+1, last); 8634 if (t != first+1) 8635 { 8636 __node* name = __root_; 8637 const char* t2 = __parse_type(t, last, try_to_parse_template_args); 8638 if (t2 != t) 8639 { 8640 if (__make<__extended_qualifier>(name, __root_)) 8641 { 8642 if (__sub_end_ == __sub_cap_) 8643 __status_ = memory_alloc_failure; 8644 else 8645 { 8646 *__sub_end_++ = __root_; 8647 first = t2; 8648 } 8649 } 8650 return first; 8651 } 8652 } 8653 } 8654 break; 8655 case 'S': 8656 if (first+1 != last && first[1] == 't') 8657 { 8658 t = __parse_class_enum_type(first, last); 8659 if (t != first) 8660 { 8661 if (__sub_end_ == __sub_cap_) 8662 __status_ = memory_alloc_failure; 8663 else 8664 { 8665 *__sub_end_++ = __root_; 8666 first = t; 8667 } 8668 } 8669 } 8670 else 8671 { 8672 t = __parse_substitution(first, last); 8673 if (t != first) 8674 { 8675 first = t; 8676 // Parsed a substitution. If the substitution is a 8677 // <template-param> it might be followed by <template-args>. 8678 t = __parse_template_args(first, last); 8679 if (t != first) 8680 { 8681 // Need to create substitution for <template-template-param> <template-args> 8682 if (__sub_end_ == __sub_cap_) 8683 __status_ = memory_alloc_failure; 8684 else 8685 { 8686 *__sub_end_++ = __root_; 8687 first = t; 8688 } 8689 } 8690 } 8691 } 8692 break; 8693 case 'D': 8694 if (first+1 != last) 8695 { 8696 switch (first[1]) 8697 { 8698 case 'p': 8699 t = __parse_type(first+2, last, try_to_parse_template_args); 8700 if (t != first+1) 8701 { 8702 if (__make<__pack_expansion>(__root_)) 8703 { 8704 if (__sub_end_ == __sub_cap_) 8705 __status_ = memory_alloc_failure; 8706 else 8707 { 8708 *__sub_end_++ = __root_; 8709 first = t; 8710 } 8711 } 8712 return first; 8713 } 8714 break; 8715 case 't': 8716 case 'T': 8717 t = __parse_decltype(first, last); 8718 if (t != first) 8719 { 8720 if (__sub_end_ == __sub_cap_) 8721 __status_ = memory_alloc_failure; 8722 else 8723 { 8724 *__sub_end_++ = __root_; 8725 first = t; 8726 } 8727 return first; 8728 } 8729 break; 8730 case 'v': 8731 t = __parse_vector_type(first, last); 8732 if (t != first) 8733 { 8734 if (__sub_end_ == __sub_cap_) 8735 __status_ = memory_alloc_failure; 8736 else 8737 { 8738 *__sub_end_++ = __root_; 8739 first = t; 8740 } 8741 return first; 8742 } 8743 break; 8744 } 8745 } 8746 // drop through 8747 default: 8748 // must check for builtin-types before class-enum-types to avoid 8749 // ambiguities with operator-names 8750 t = __parse_builtin_type(first, last); 8751 if (t != first) 8752 { 8753 first = t; 8754 } 8755 else 8756 { 8757 t = __parse_class_enum_type(first, last); 8758 if (t != first) 8759 { 8760 if (__sub_end_ == __sub_cap_) 8761 __status_ = memory_alloc_failure; 8762 else 8763 { 8764 *__sub_end_++ = __root_; 8765 first = t; 8766 } 8767 } 8768 } 8769 break; 8770 } 8771 } 8772 return first; 8773 } 8774 8775 // <number> ::= [n] <non-negative decimal integer> 8776 8777 const char* 8778 __demangle_tree::__parse_number(const char* first, const char* last) 8779 { 8780 if (first != last) 8781 { 8782 const char* t = first; 8783 if (*t == 'n') 8784 ++t; 8785 if (t != last) 8786 { 8787 if (*t == '0') 8788 { 8789 first = t+1; 8790 } 8791 else if ('1' <= *t && *t <= '9') 8792 { 8793 first = t+1; 8794 while (first != last && isdigit(*first)) 8795 ++first; 8796 } 8797 } 8798 } 8799 return first; 8800 } 8801 8802 // <call-offset> ::= h <nv-offset> _ 8803 // ::= v <v-offset> _ 8804 // 8805 // <nv-offset> ::= <offset number> 8806 // # non-virtual base override 8807 // 8808 // <v-offset> ::= <offset number> _ <virtual offset number> 8809 // # virtual base override, with vcall offset 8810 8811 const char* 8812 __demangle_tree::__parse_call_offset(const char* first, const char* last) 8813 { 8814 if (first != last) 8815 { 8816 switch (*first) 8817 { 8818 case 'h': 8819 { 8820 const char* t = __parse_number(first + 1, last); 8821 if (t != first + 1 && t != last && *t == '_') 8822 first = t + 1; 8823 } 8824 break; 8825 case 'v': 8826 { 8827 const char* t = __parse_number(first + 1, last); 8828 if (t != first + 1 && t != last && *t == '_') 8829 { 8830 const char* t2 = __parse_number(++t, last); 8831 if (t2 != t && t2 != last && *t2 == '_') 8832 first = t2 + 1; 8833 } 8834 } 8835 break; 8836 } 8837 } 8838 return first; 8839 } 8840 8841 // <special-name> ::= TV <type> # virtual table 8842 // ::= TT <type> # VTT structure (construction vtable index) 8843 // ::= TI <type> # typeinfo structure 8844 // ::= TS <type> # typeinfo name (null-terminated byte string) 8845 // ::= Tc <call-offset> <call-offset> <base encoding> 8846 // # base is the nominal target function of thunk 8847 // # first call-offset is 'this' adjustment 8848 // # second call-offset is result adjustment 8849 // ::= T <call-offset> <base encoding> 8850 // # base is the nominal target function of thunk 8851 // ::= GV <object name> # Guard variable for one-time initialization 8852 // # No <type> 8853 // extension ::= TC <first type> <number> _ <second type> # construction vtable for second-in-first 8854 // extension ::= GR <object name> # reference temporary for object 8855 8856 const char* 8857 __demangle_tree::__parse_special_name(const char* first, const char* last) 8858 { 8859 if (last - first > 2) 8860 { 8861 const char* t; 8862 switch (*first) 8863 { 8864 case 'T': 8865 switch (first[1]) 8866 { 8867 case 'V': 8868 // TV <type> # virtual table 8869 t = __parse_type(first+2, last); 8870 if (t != first+2 && __make<__vtable>(__root_)) 8871 first = t; 8872 break; 8873 case 'T': 8874 // TT <type> # VTT structure (construction vtable index) 8875 t = __parse_type(first+2, last); 8876 if (t != first+2 && __make<__VTT>(__root_)) 8877 first = t; 8878 break; 8879 case 'I': 8880 // TI <type> # typeinfo structure 8881 t = __parse_type(first+2, last); 8882 if (t != first+2 && __make<__typeinfo>(__root_)) 8883 first = t; 8884 break; 8885 case 'S': 8886 // TS <type> # typeinfo name (null-terminated byte string) 8887 t = __parse_type(first+2, last); 8888 if (t != first+2 && __make<__typeinfo_name>(__root_)) 8889 first = t; 8890 break; 8891 case 'c': 8892 // Tc <call-offset> <call-offset> <base encoding> 8893 { 8894 const char* t0 = __parse_call_offset(first+2, last); 8895 if (t0 == first+2) 8896 break; 8897 const char* t1 = __parse_call_offset(t0, last); 8898 if (t1 == t0) 8899 break; 8900 t = __parse_encoding(t1, last); 8901 if (t != t1 && __make<__covariant_return_thunk>(__root_)) 8902 first = t; 8903 } 8904 break; 8905 case 'C': 8906 // extension ::= TC <first type> <number> _ <second type> # construction vtable for second-in-first 8907 t = __parse_type(first+2, last); 8908 if (t != first+2) 8909 { 8910 __node* op1 = __root_; 8911 const char* t0 = __parse_number(t, last); 8912 if (t0 != t && t0 != last && *t0 == '_') 8913 { 8914 const char* t1 = __parse_type(++t0, last); 8915 if (t1 != t0) 8916 { 8917 if (__make<__construction_vtable>(__root_, op1)) 8918 first = t1; 8919 } 8920 } 8921 } 8922 break; 8923 default: 8924 // T <call-offset> <base encoding> 8925 { 8926 const char* t0 = __parse_call_offset(first+1, last); 8927 if (t0 == first+1) 8928 break; 8929 t = __parse_encoding(t0, last); 8930 if (t != t0) 8931 { 8932 if (first[2] == 'v') 8933 { 8934 if (__make<__virtual_thunk>(__root_)) 8935 first = t; 8936 } 8937 else 8938 { 8939 if (__make<__non_virtual_thunk>(__root_)) 8940 first = t; 8941 } 8942 } 8943 } 8944 break; 8945 } 8946 break; 8947 case 'G': 8948 switch (first[1]) 8949 { 8950 case 'V': 8951 // GV <object name> # Guard variable for one-time initialization 8952 t = __parse_name(first+2, last); 8953 if (t != first+2 && __make<__guard_variable>(__root_)) 8954 first = t; 8955 break; 8956 case 'R': 8957 // extension ::= GR <object name> # reference temporary for object 8958 t = __parse_name(first+2, last); 8959 if (t != first+2 && __make<__reference_temporary>(__root_)) 8960 first = t; 8961 break; 8962 } 8963 break; 8964 } 8965 } 8966 return first; 8967 } 8968 8969 // <operator-name> 8970 // ::= aa # && 8971 // ::= ad # & (unary) 8972 // ::= an # & 8973 // ::= aN # &= 8974 // ::= aS # = 8975 // ::= at # alignof (a type) 8976 // ::= az # alignof (an expression) 8977 // ::= cl # () 8978 // ::= cm # , 8979 // ::= co # ~ 8980 // ::= cv <type> # (cast) 8981 // ::= da # delete[] 8982 // ::= de # * (unary) 8983 // ::= dl # delete 8984 // ::= dv # / 8985 // ::= dV # /= 8986 // ::= eo # ^ 8987 // ::= eO # ^= 8988 // ::= eq # == 8989 // ::= ge # >= 8990 // ::= gt # > 8991 // ::= ix # [] 8992 // ::= le # <= 8993 // ::= ls # << 8994 // ::= lS # <<= 8995 // ::= lt # < 8996 // ::= mi # - 8997 // ::= mI # -= 8998 // ::= ml # * 8999 // ::= mL # *= 9000 // ::= mm # -- (postfix in <expression> context) 9001 // ::= na # new[] 9002 // ::= ne # != 9003 // ::= ng # - (unary) 9004 // ::= nt # ! 9005 // ::= nw # new 9006 // ::= oo # || 9007 // ::= or # | 9008 // ::= oR # |= 9009 // ::= pm # ->* 9010 // ::= pl # + 9011 // ::= pL # += 9012 // ::= pp # ++ (postfix in <expression> context) 9013 // ::= ps # + (unary) 9014 // ::= pt # -> 9015 // ::= qu # ? 9016 // ::= rm # % 9017 // ::= rM # %= 9018 // ::= rs # >> 9019 // ::= rS # >>= 9020 // ::= st # sizeof (a type) 9021 // ::= sz # sizeof (an expression) 9022 // ::= v <digit> <source-name> # vendor extended operator 9023 9024 const char* 9025 __demangle_tree::__parse_operator_name(const char* first, const char* last, int* type) 9026 { 9027 if (last - first >= 2) 9028 { 9029 switch (*first) 9030 { 9031 case 'a': 9032 switch (first[1]) 9033 { 9034 case 'a': 9035 // && 9036 if (type) 9037 { 9038 const char* t = __parse_expression(first+2, last); 9039 if (t != first+2) 9040 { 9041 __node* op1 = __root_; 9042 const char* t2 = __parse_expression(t, last); 9043 if (t != t2) 9044 { 9045 if (__make<__operator_logical_and>(op1, __root_)) 9046 { 9047 *type = 2; 9048 first = t2; 9049 } 9050 } 9051 } 9052 } 9053 else 9054 { 9055 if (__make<__operator_logical_and>()) 9056 first += 2; 9057 } 9058 break; 9059 case 'd': 9060 // & (unary) 9061 if (type) 9062 { 9063 const char* t = __parse_expression(first+2, last); 9064 if (t != first+2) 9065 { 9066 if (__make<__operator_addressof>(__root_)) 9067 { 9068 *type = 1; 9069 first = t; 9070 } 9071 } 9072 } 9073 else 9074 { 9075 if (__make<__operator_addressof>()) 9076 first += 2; 9077 } 9078 break; 9079 case 'n': 9080 // & 9081 if (type) 9082 { 9083 const char* t = __parse_expression(first+2, last); 9084 if (t != first+2) 9085 { 9086 __node* op1 = __root_; 9087 const char* t2 = __parse_expression(t, last); 9088 if (t != t2) 9089 { 9090 if (__make<__operator_bit_and>(op1, __root_)) 9091 { 9092 *type = 2; 9093 first = t2; 9094 } 9095 } 9096 } 9097 } 9098 else 9099 { 9100 if (__make<__operator_bit_and>()) 9101 first += 2; 9102 } 9103 break; 9104 case 'N': 9105 // &= 9106 if (type) 9107 { 9108 const char* t = __parse_expression(first+2, last); 9109 if (t != first+2) 9110 { 9111 __node* op1 = __root_; 9112 const char* t2 = __parse_expression(t, last); 9113 if (t != t2) 9114 { 9115 if (__make<__operator_and_equal>(op1, __root_)) 9116 { 9117 *type = 2; 9118 first = t2; 9119 } 9120 } 9121 } 9122 } 9123 else 9124 { 9125 if (__make<__operator_and_equal>()) 9126 first += 2; 9127 } 9128 break; 9129 case 'S': 9130 // = 9131 if (type) 9132 { 9133 const char* t = __parse_expression(first+2, last); 9134 if (t != first+2) 9135 { 9136 __node* op1 = __root_; 9137 const char* t2 = __parse_expression(t, last); 9138 if (t != t2) 9139 { 9140 if (__make<__operator_equal>(op1, __root_)) 9141 { 9142 *type = 2; 9143 first = t2; 9144 } 9145 } 9146 } 9147 } 9148 else 9149 { 9150 if (__make<__operator_equal>()) 9151 first += 2; 9152 } 9153 break; 9154 case 't': 9155 // alignof (a type) 9156 if (type) 9157 { 9158 const char* t = __parse_expression(first+2, last); 9159 if (t != first+2) 9160 { 9161 if (__make<__operator_alignof_type>(__root_)) 9162 { 9163 *type = -1; 9164 first = t; 9165 } 9166 } 9167 } 9168 else 9169 { 9170 if (__make<__operator_alignof_type>()) 9171 first += 2; 9172 } 9173 break; 9174 case 'z': 9175 // alignof (an expression) 9176 if (type) 9177 { 9178 const char* t = __parse_expression(first+2, last); 9179 if (t != first+2) 9180 { 9181 if (__make<__operator_alignof_expression>(__root_)) 9182 { 9183 *type = -1; 9184 first = t; 9185 } 9186 } 9187 } 9188 else 9189 { 9190 if (__make<__operator_alignof_expression>()) 9191 first += 2; 9192 } 9193 break; 9194 } 9195 break; 9196 case 'c': 9197 switch (first[1]) 9198 { 9199 case 'l': 9200 // () 9201 if (__make<__operator_paren>()) 9202 { 9203 first += 2; 9204 if (type) 9205 *type = -1; 9206 } 9207 break; 9208 case 'm': 9209 // , 9210 if (type) 9211 { 9212 const char* t = __parse_expression(first+2, last); 9213 if (t != first+2) 9214 { 9215 __node* op1 = __root_; 9216 const char* t2 = __parse_expression(t, last); 9217 if (t != t2) 9218 { 9219 if (__make<__operator_comma>(op1, __root_)) 9220 { 9221 *type = 2; 9222 first = t2; 9223 } 9224 } 9225 } 9226 } 9227 else 9228 { 9229 if (__make<__operator_comma>()) 9230 first += 2; 9231 } 9232 break; 9233 case 'o': 9234 // ~ 9235 if (type) 9236 { 9237 const char* t = __parse_expression(first+2, last); 9238 if (t != first+2) 9239 { 9240 if (__make<__operator_tilda>(__root_)) 9241 { 9242 *type = 1; 9243 first = t; 9244 } 9245 } 9246 } 9247 else 9248 { 9249 if (__make<__operator_tilda>()) 9250 first += 2; 9251 } 9252 break; 9253 case 'v': 9254 // cast <type> 9255 { 9256 const char* t = __parse_type(first+2, last, false, true); 9257 if (t != first+2) 9258 { 9259 __node* cast_type = __root_; 9260 if (type) 9261 { 9262 const char* t2 = __parse_expression(t, last); 9263 if (t2 != t) 9264 { 9265 if (__make<__operator_cast>(cast_type, __root_)) 9266 { 9267 *type = -1; 9268 first = t2; 9269 } 9270 } 9271 } 9272 else 9273 { 9274 if (__make<__operator_cast>(cast_type)) 9275 first = t; 9276 } 9277 } 9278 } 9279 break; 9280 } 9281 break; 9282 case 'd': 9283 switch (first[1]) 9284 { 9285 case 'a': 9286 // delete[] 9287 if (__make<__operator_delete_array>()) 9288 { 9289 first += 2; 9290 if (type) 9291 *type = -1; 9292 } 9293 break; 9294 case 'e': 9295 // * (unary) 9296 if (type) 9297 { 9298 const char* t = __parse_expression(first+2, last); 9299 if (t != first+2) 9300 { 9301 if (__make<__operator_dereference>(__root_)) 9302 { 9303 *type = 1; 9304 first = t; 9305 } 9306 } 9307 } 9308 else 9309 { 9310 if (__make<__operator_dereference>()) 9311 first += 2; 9312 } 9313 break; 9314 case 'l': 9315 // delete 9316 if (__make<__operator_delete>()) 9317 { 9318 first += 2; 9319 if (type) 9320 *type = -1; 9321 } 9322 break; 9323 case 'v': 9324 // / 9325 if (type) 9326 { 9327 const char* t = __parse_expression(first+2, last); 9328 if (t != first+2) 9329 { 9330 __node* op1 = __root_; 9331 const char* t2 = __parse_expression(t, last); 9332 if (t != t2) 9333 { 9334 if (__make<__operator_divide>(op1, __root_)) 9335 { 9336 *type = 2; 9337 first = t2; 9338 } 9339 } 9340 } 9341 } 9342 else 9343 { 9344 if (__make<__operator_divide>()) 9345 first += 2; 9346 } 9347 break; 9348 case 'V': 9349 // /= 9350 if (type) 9351 { 9352 const char* t = __parse_expression(first+2, last); 9353 if (t != first+2) 9354 { 9355 __node* op1 = __root_; 9356 const char* t2 = __parse_expression(t, last); 9357 if (t != t2) 9358 { 9359 if (__make<__operator_divide_equal>(op1, __root_)) 9360 { 9361 *type = 2; 9362 first = t2; 9363 } 9364 } 9365 } 9366 } 9367 else 9368 { 9369 if (__make<__operator_divide_equal>()) 9370 first += 2; 9371 } 9372 break; 9373 } 9374 break; 9375 case 'e': 9376 switch (first[1]) 9377 { 9378 case 'o': 9379 // ^ 9380 if (type) 9381 { 9382 const char* t = __parse_expression(first+2, last); 9383 if (t != first+2) 9384 { 9385 __node* op1 = __root_; 9386 const char* t2 = __parse_expression(t, last); 9387 if (t != t2) 9388 { 9389 if (__make<__operator_xor>(op1, __root_)) 9390 { 9391 *type = 2; 9392 first = t2; 9393 } 9394 } 9395 } 9396 } 9397 else 9398 { 9399 if (__make<__operator_xor>()) 9400 first += 2; 9401 } 9402 break; 9403 case 'O': 9404 // ^= 9405 if (type) 9406 { 9407 const char* t = __parse_expression(first+2, last); 9408 if (t != first+2) 9409 { 9410 __node* op1 = __root_; 9411 const char* t2 = __parse_expression(t, last); 9412 if (t != t2) 9413 { 9414 if (__make<__operator_xor_equal>(op1, __root_)) 9415 { 9416 *type = 2; 9417 first = t2; 9418 } 9419 } 9420 } 9421 } 9422 else 9423 { 9424 if (__make<__operator_xor_equal>()) 9425 first += 2; 9426 } 9427 break; 9428 case 'q': 9429 // == 9430 if (type) 9431 { 9432 const char* t = __parse_expression(first+2, last); 9433 if (t != first+2) 9434 { 9435 __node* op1 = __root_; 9436 const char* t2 = __parse_expression(t, last); 9437 if (t != t2) 9438 { 9439 if (__make<__operator_equality>(op1, __root_)) 9440 { 9441 *type = 2; 9442 first = t2; 9443 } 9444 } 9445 } 9446 } 9447 else 9448 { 9449 if (__make<__operator_equality>()) 9450 first += 2; 9451 } 9452 break; 9453 } 9454 break; 9455 case 'g': 9456 switch (first[1]) 9457 { 9458 case 'e': 9459 // >= 9460 if (type) 9461 { 9462 const char* t = __parse_expression(first+2, last); 9463 if (t != first+2) 9464 { 9465 __node* op1 = __root_; 9466 const char* t2 = __parse_expression(t, last); 9467 if (t != t2) 9468 { 9469 if (__make<__operator_greater_equal>(op1, __root_)) 9470 { 9471 *type = 2; 9472 first = t2; 9473 } 9474 } 9475 } 9476 } 9477 else 9478 { 9479 if (__make<__operator_greater_equal>()) 9480 first += 2; 9481 } 9482 break; 9483 case 't': 9484 // > 9485 if (type) 9486 { 9487 const char* t = __parse_expression(first+2, last); 9488 if (t != first+2) 9489 { 9490 __node* op1 = __root_; 9491 const char* t2 = __parse_expression(t, last); 9492 if (t != t2) 9493 { 9494 if (__make<__operator_greater>(op1, __root_)) 9495 { 9496 *type = 2; 9497 first = t2; 9498 } 9499 } 9500 } 9501 } 9502 else 9503 { 9504 if (__make<__operator_greater>()) 9505 first += 2; 9506 } 9507 break; 9508 } 9509 break; 9510 case 'i': 9511 // [] 9512 if (first[1] == 'x' && __make<__operator_brackets>()) 9513 { 9514 first += 2; 9515 if (type) 9516 *type = -1; 9517 } 9518 break; 9519 case 'l': 9520 switch (first[1]) 9521 { 9522 case 'e': 9523 // <= 9524 if (type) 9525 { 9526 const char* t = __parse_expression(first+2, last); 9527 if (t != first+2) 9528 { 9529 __node* op1 = __root_; 9530 const char* t2 = __parse_expression(t, last); 9531 if (t != t2) 9532 { 9533 if (__make<__operator_less_equal>(op1, __root_)) 9534 { 9535 *type = 2; 9536 first = t2; 9537 } 9538 } 9539 } 9540 } 9541 else 9542 { 9543 if (__make<__operator_less_equal>()) 9544 first += 2; 9545 } 9546 break; 9547 case 's': 9548 // << 9549 if (type) 9550 { 9551 const char* t = __parse_expression(first+2, last); 9552 if (t != first+2) 9553 { 9554 __node* op1 = __root_; 9555 const char* t2 = __parse_expression(t, last); 9556 if (t != t2) 9557 { 9558 if (__make<__operator_left_shift>(op1, __root_)) 9559 { 9560 *type = 2; 9561 first = t2; 9562 } 9563 } 9564 } 9565 } 9566 else 9567 { 9568 if (__make<__operator_left_shift>()) 9569 first += 2; 9570 } 9571 break; 9572 case 'S': 9573 // <<= 9574 if (type) 9575 { 9576 const char* t = __parse_expression(first+2, last); 9577 if (t != first+2) 9578 { 9579 __node* op1 = __root_; 9580 const char* t2 = __parse_expression(t, last); 9581 if (t != t2) 9582 { 9583 if (__make<__operator_left_shift_equal>(op1, __root_)) 9584 { 9585 *type = 2; 9586 first = t2; 9587 } 9588 } 9589 } 9590 } 9591 else 9592 { 9593 if (__make<__operator_left_shift_equal>()) 9594 first += 2; 9595 } 9596 break; 9597 case 't': 9598 // < 9599 if (type) 9600 { 9601 const char* t = __parse_expression(first+2, last); 9602 if (t != first+2) 9603 { 9604 __node* op1 = __root_; 9605 const char* t2 = __parse_expression(t, last); 9606 if (t != t2) 9607 { 9608 if (__make<__operator_less>(op1, __root_)) 9609 { 9610 *type = 2; 9611 first = t2; 9612 } 9613 } 9614 } 9615 } 9616 else 9617 { 9618 if (__make<__operator_less>()) 9619 first += 2; 9620 } 9621 break; 9622 } 9623 break; 9624 case 'm': 9625 switch (first[1]) 9626 { 9627 case 'i': 9628 // - 9629 if (type) 9630 { 9631 const char* t = __parse_expression(first+2, last); 9632 if (t != first+2) 9633 { 9634 __node* op1 = __root_; 9635 const char* t2 = __parse_expression(t, last); 9636 if (t != t2) 9637 { 9638 if (__make<__operator_minus>(op1, __root_)) 9639 { 9640 *type = 2; 9641 first = t2; 9642 } 9643 } 9644 } 9645 } 9646 else 9647 { 9648 if (__make<__operator_minus>()) 9649 first += 2; 9650 } 9651 break; 9652 case 'I': 9653 // -= 9654 if (type) 9655 { 9656 const char* t = __parse_expression(first+2, last); 9657 if (t != first+2) 9658 { 9659 __node* op1 = __root_; 9660 const char* t2 = __parse_expression(t, last); 9661 if (t != t2) 9662 { 9663 if (__make<__operator_minus_equal>(op1, __root_)) 9664 { 9665 *type = 2; 9666 first = t2; 9667 } 9668 } 9669 } 9670 } 9671 else 9672 { 9673 if (__make<__operator_minus_equal>()) 9674 first += 2; 9675 } 9676 break; 9677 case 'l': 9678 // * 9679 if (type) 9680 { 9681 const char* t = __parse_expression(first+2, last); 9682 if (t != first+2) 9683 { 9684 __node* op1 = __root_; 9685 const char* t2 = __parse_expression(t, last); 9686 if (t != t2) 9687 { 9688 if (__make<__operator_times>(op1, __root_)) 9689 { 9690 *type = 2; 9691 first = t2; 9692 } 9693 } 9694 } 9695 } 9696 else 9697 { 9698 if (__make<__operator_times>()) 9699 first += 2; 9700 } 9701 break; 9702 case 'L': 9703 // *= 9704 if (type) 9705 { 9706 const char* t = __parse_expression(first+2, last); 9707 if (t != first+2) 9708 { 9709 __node* op1 = __root_; 9710 const char* t2 = __parse_expression(t, last); 9711 if (t != t2) 9712 { 9713 if (__make<__operator_times_equal>(op1, __root_)) 9714 { 9715 *type = 2; 9716 first = t2; 9717 } 9718 } 9719 } 9720 } 9721 else 9722 { 9723 if (__make<__operator_times_equal>()) 9724 first += 2; 9725 } 9726 break; 9727 case 'm': 9728 // -- (postfix in <expression> context) 9729 if (type) 9730 { 9731 const char* t = __parse_expression(first+2, last); 9732 if (t != first+2) 9733 { 9734 if (__make<__operator_decrement>(false, __root_)) 9735 { 9736 *type = 1; 9737 first = t; 9738 } 9739 } 9740 } 9741 else 9742 { 9743 if (__make<__operator_decrement>()) 9744 first += 2; 9745 } 9746 break; 9747 } 9748 break; 9749 case 'n': 9750 switch (first[1]) 9751 { 9752 case 'a': 9753 // new[] 9754 if (__make<__operator_new_array>()) 9755 { 9756 first += 2; 9757 if (type) 9758 *type = -1; 9759 } 9760 break; 9761 case 'e': 9762 // != 9763 if (type) 9764 { 9765 const char* t = __parse_expression(first+2, last); 9766 if (t != first+2) 9767 { 9768 __node* op1 = __root_; 9769 const char* t2 = __parse_expression(t, last); 9770 if (t != t2) 9771 { 9772 if (__make<__operator_not_equal>(op1, __root_)) 9773 { 9774 *type = 2; 9775 first = t2; 9776 } 9777 } 9778 } 9779 } 9780 else 9781 { 9782 if (__make<__operator_not_equal>()) 9783 first += 2; 9784 } 9785 break; 9786 case 'g': 9787 // - (unary) 9788 if (type) 9789 { 9790 const char* t = __parse_expression(first+2, last); 9791 if (t != first+2) 9792 { 9793 if (__make<__operator_negate>(__root_)) 9794 { 9795 *type = 1; 9796 first = t; 9797 } 9798 } 9799 } 9800 else 9801 { 9802 if (__make<__operator_negate>()) 9803 first += 2; 9804 } 9805 break; 9806 case 't': 9807 // ! 9808 if (type) 9809 { 9810 const char* t = __parse_expression(first+2, last); 9811 if (t != first+2) 9812 { 9813 if (__make<__operator_logical_not>(__root_)) 9814 { 9815 *type = 1; 9816 first = t; 9817 } 9818 } 9819 } 9820 else 9821 { 9822 if (__make<__operator_logical_not>()) 9823 first += 2; 9824 } 9825 break; 9826 case 'w': 9827 // new 9828 if (__make<__operator_new>()) 9829 { 9830 first += 2; 9831 if (type) 9832 *type = -1; 9833 } 9834 break; 9835 } 9836 break; 9837 case 'o': 9838 switch (first[1]) 9839 { 9840 case 'o': 9841 // || 9842 if (type) 9843 { 9844 const char* t = __parse_expression(first+2, last); 9845 if (t != first+2) 9846 { 9847 __node* op1 = __root_; 9848 const char* t2 = __parse_expression(t, last); 9849 if (t != t2) 9850 { 9851 if (__make<__operator_logical_or>(op1, __root_)) 9852 { 9853 *type = 2; 9854 first = t2; 9855 } 9856 } 9857 } 9858 } 9859 else 9860 { 9861 if (__make<__operator_logical_or>()) 9862 first += 2; 9863 } 9864 break; 9865 case 'r': 9866 // | 9867 if (type) 9868 { 9869 const char* t = __parse_expression(first+2, last); 9870 if (t != first+2) 9871 { 9872 __node* op1 = __root_; 9873 const char* t2 = __parse_expression(t, last); 9874 if (t != t2) 9875 { 9876 if (__make<__operator_bit_or>(op1, __root_)) 9877 { 9878 *type = 2; 9879 first = t2; 9880 } 9881 } 9882 } 9883 } 9884 else 9885 { 9886 if (__make<__operator_bit_or>()) 9887 first += 2; 9888 } 9889 break; 9890 case 'R': 9891 // |= 9892 if (type) 9893 { 9894 const char* t = __parse_expression(first+2, last); 9895 if (t != first+2) 9896 { 9897 __node* op1 = __root_; 9898 const char* t2 = __parse_expression(t, last); 9899 if (t != t2) 9900 { 9901 if (__make<__operator_or_equal>(op1, __root_)) 9902 { 9903 *type = 2; 9904 first = t2; 9905 } 9906 } 9907 } 9908 } 9909 else 9910 { 9911 if (__make<__operator_or_equal>()) 9912 first += 2; 9913 } 9914 break; 9915 } 9916 break; 9917 case 'p': 9918 switch (first[1]) 9919 { 9920 case 'm': 9921 // ->* 9922 if (type) 9923 { 9924 const char* t = __parse_expression(first+2, last); 9925 if (t != first+2) 9926 { 9927 __node* op1 = __root_; 9928 const char* t2 = __parse_expression(t, last); 9929 if (t != t2) 9930 { 9931 if (__make<__operator_pointer_to_member>(op1, __root_)) 9932 { 9933 *type = 2; 9934 first = t2; 9935 } 9936 } 9937 } 9938 } 9939 else 9940 { 9941 if (__make<__operator_pointer_to_member>()) 9942 first += 2; 9943 } 9944 break; 9945 case 'l': 9946 // + 9947 if (type) 9948 { 9949 const char* t = __parse_expression(first+2, last); 9950 if (t != first+2) 9951 { 9952 __node* op1 = __root_; 9953 const char* t2 = __parse_expression(t, last); 9954 if (t != t2) 9955 { 9956 if (__make<__operator_plus>(op1, __root_)) 9957 { 9958 *type = 2; 9959 first = t2; 9960 } 9961 } 9962 } 9963 } 9964 else 9965 { 9966 if (__make<__operator_plus>()) 9967 first += 2; 9968 } 9969 break; 9970 case 'L': 9971 // += 9972 if (type) 9973 { 9974 const char* t = __parse_expression(first+2, last); 9975 if (t != first+2) 9976 { 9977 __node* op1 = __root_; 9978 const char* t2 = __parse_expression(t, last); 9979 if (t != t2) 9980 { 9981 if (__make<__operator_plus_equal>(op1, __root_)) 9982 { 9983 *type = 2; 9984 first = t2; 9985 } 9986 } 9987 } 9988 } 9989 else 9990 { 9991 if (__make<__operator_plus_equal>()) 9992 first += 2; 9993 } 9994 break; 9995 case 'p': 9996 // ++ (postfix in <expression> context) 9997 if (type) 9998 { 9999 const char* t = __parse_expression(first+2, last); 10000 if (t != first+2) 10001 { 10002 if (__make<__operator_increment>(false, __root_)) 10003 { 10004 *type = 1; 10005 first = t; 10006 } 10007 } 10008 } 10009 else 10010 { 10011 if (__make<__operator_increment>()) 10012 first += 2; 10013 } 10014 break; 10015 case 's': 10016 // + (unary) 10017 if (type) 10018 { 10019 const char* t = __parse_expression(first+2, last); 10020 if (t != first+2) 10021 { 10022 if (__make<__operator_unary_plus>(__root_)) 10023 { 10024 *type = 1; 10025 first = t; 10026 } 10027 } 10028 } 10029 else 10030 { 10031 if (__make<__operator_unary_plus>()) 10032 first += 2; 10033 } 10034 break; 10035 case 't': 10036 // -> 10037 if (type) 10038 { 10039 const char* t = __parse_expression(first+2, last); 10040 if (t != first+2) 10041 { 10042 __node* op1 = __root_; 10043 const char* t2 = __parse_expression(t, last); 10044 if (t != t2) 10045 { 10046 if (__make<__operator_arrow>(op1, __root_)) 10047 { 10048 *type = 2; 10049 first = t2; 10050 } 10051 } 10052 } 10053 } 10054 else 10055 { 10056 if (__make<__operator_arrow>()) 10057 first += 2; 10058 } 10059 break; 10060 } 10061 break; 10062 case 'q': 10063 // ? 10064 if (first[1] == 'u') 10065 { 10066 if (type) 10067 { 10068 const char* t = __parse_expression(first+2, last); 10069 if (t != first+2) 10070 { 10071 __node* op1 = __root_; 10072 const char* t2 = __parse_expression(t, last); 10073 if (t != t2) 10074 { 10075 __node* op2 = __root_; 10076 const char* t3 = __parse_expression(t2, last); 10077 if (t3 != t2) 10078 { 10079 if (__make<__operator_conditional>(op1, op2, __root_)) 10080 { 10081 *type = 3; 10082 first = t3; 10083 } 10084 } 10085 } 10086 } 10087 } 10088 else 10089 { 10090 if (__make<__operator_conditional>()) 10091 first += 2; 10092 } 10093 } 10094 break; 10095 case 'r': 10096 switch (first[1]) 10097 { 10098 case 'm': 10099 // % 10100 if (type) 10101 { 10102 const char* t = __parse_expression(first+2, last); 10103 if (t != first+2) 10104 { 10105 __node* op1 = __root_; 10106 const char* t2 = __parse_expression(t, last); 10107 if (t != t2) 10108 { 10109 if (__make<__operator_mod>(op1, __root_)) 10110 { 10111 *type = 2; 10112 first = t2; 10113 } 10114 } 10115 } 10116 } 10117 else 10118 { 10119 if (__make<__operator_mod>()) 10120 first += 2; 10121 } 10122 break; 10123 case 'M': 10124 // %= 10125 if (type) 10126 { 10127 const char* t = __parse_expression(first+2, last); 10128 if (t != first+2) 10129 { 10130 __node* op1 = __root_; 10131 const char* t2 = __parse_expression(t, last); 10132 if (t != t2) 10133 { 10134 if (__make<__operator_mod_equal>(op1, __root_)) 10135 { 10136 *type = 2; 10137 first = t2; 10138 } 10139 } 10140 } 10141 } 10142 else 10143 { 10144 if (__make<__operator_mod_equal>()) 10145 first += 2; 10146 } 10147 break; 10148 case 's': 10149 // >> 10150 if (type) 10151 { 10152 const char* t = __parse_expression(first+2, last); 10153 if (t != first+2) 10154 { 10155 __node* op1 = __root_; 10156 const char* t2 = __parse_expression(t, last); 10157 if (t != t2) 10158 { 10159 if (__make<__operator_right_shift>(op1, __root_)) 10160 { 10161 *type = 2; 10162 first = t2; 10163 } 10164 } 10165 } 10166 } 10167 else 10168 { 10169 if (__make<__operator_right_shift>()) 10170 first += 2; 10171 } 10172 break; 10173 case 'S': 10174 // >>= 10175 if (type) 10176 { 10177 const char* t = __parse_expression(first+2, last); 10178 if (t != first+2) 10179 { 10180 __node* op1 = __root_; 10181 const char* t2 = __parse_expression(t, last); 10182 if (t != t2) 10183 { 10184 if (__make<__operator_right_shift_equal>(op1, __root_)) 10185 { 10186 *type = 2; 10187 first = t2; 10188 } 10189 } 10190 } 10191 } 10192 else 10193 { 10194 if (__make<__operator_right_shift_equal>()) 10195 first += 2; 10196 } 10197 break; 10198 } 10199 break; 10200 case 's': 10201 switch (first[1]) 10202 { 10203 case 't': 10204 // sizeof (a type) 10205 if (type) 10206 { 10207 const char* t = __parse_expression(first+2, last); 10208 if (t != first+2) 10209 { 10210 if (__make<__operator_sizeof_type>(__root_)) 10211 { 10212 *type = -1; 10213 first = t; 10214 } 10215 } 10216 } 10217 else 10218 { 10219 if (__make<__operator_sizeof_type>()) 10220 first += 2; 10221 } 10222 break; 10223 case 'z': 10224 // sizeof (an expression) 10225 if (type) 10226 { 10227 const char* t = __parse_expression(first+2, last); 10228 if (t != first+2) 10229 { 10230 if (__make<__operator_sizeof_expression>(__root_)) 10231 { 10232 *type = -1; 10233 first = t; 10234 } 10235 } 10236 } 10237 else 10238 { 10239 if (__make<__operator_sizeof_expression>()) 10240 first += 2; 10241 } 10242 break; 10243 } 10244 break; 10245 } 10246 } 10247 return first; 10248 } 10249 10250 // <source-name> ::= <positive length number> <identifier> 10251 10252 const char* 10253 __demangle_tree::__parse_source_name(const char* first, const char* last) 10254 { 10255 if (first != last) 10256 { 10257 char c = *first; 10258 if ('1' <= c && c <= '9' && first+1 != last) 10259 { 10260 const char* t = first+1; 10261 size_t n = static_cast<size_t>(c - '0'); 10262 for (c = *t; '0' <= c && c <= '9'; c = *t) 10263 { 10264 n = n * 10 + static_cast<size_t>(c - '0'); 10265 if (++t == last) 10266 return first; 10267 } 10268 if (static_cast<size_t>(last - t) >= n && __make<__source_name>(t, n)) 10269 first = t + n; 10270 } 10271 } 10272 return first; 10273 } 10274 10275 // <unqualified-name> ::= <operator-name> 10276 // ::= <ctor-dtor-name> 10277 // ::= <source-name> 10278 // ::= <unnamed-type-name> 10279 10280 const char* 10281 __demangle_tree::__parse_unqualified_name(const char* first, const char* last) 10282 { 10283 const char* t = __parse_source_name(first, last); 10284 if (t == first) 10285 { 10286 t = __parse_ctor_dtor_name(first, last); 10287 if (t == first) 10288 { 10289 t = __parse_operator_name(first, last); 10290 if (t == first) 10291 first = __parse_unnamed_type_name(first, last); 10292 else 10293 first = t; 10294 } 10295 else 10296 first = t; 10297 } 10298 else 10299 first = t; 10300 return first; 10301 } 10302 10303 // <unscoped-name> ::= <unqualified-name> 10304 // ::= St <unqualified-name> # ::std:: 10305 // extension ::= StL<unqualified-name> 10306 10307 const char* 10308 __demangle_tree::__parse_unscoped_name(const char* first, const char* last) 10309 { 10310 if (last - first >= 2) 10311 { 10312 const char* t0 = first; 10313 if (first[0] == 'S' && first[1] == 't') 10314 { 10315 t0 += 2; 10316 if (t0 != last && *t0 == 'L') 10317 ++t0; 10318 } 10319 const char* t1 = __parse_unqualified_name(t0, last); 10320 if (t1 != t0) 10321 { 10322 if (t0 != first) 10323 { 10324 __node* name = __root_; 10325 if (__make<__std_qualified_name>()) 10326 { 10327 if (__make<__nested_delimeter>(__root_, name)) 10328 first = t1; 10329 } 10330 } 10331 else 10332 first = t1; 10333 } 10334 } 10335 return first; 10336 } 10337 10338 // <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E 10339 // ::= N [<CV-qualifiers>] <template-prefix> <template-args> E 10340 // 10341 // <prefix> ::= <prefix> <unqualified-name> 10342 // ::= <template-prefix> <template-args> 10343 // ::= <template-param> 10344 // ::= <decltype> 10345 // ::= # empty 10346 // ::= <substitution> 10347 // ::= <prefix> <data-member-prefix> 10348 // extension ::= L 10349 // 10350 // <template-prefix> ::= <prefix> <template unqualified-name> 10351 // ::= <template-param> 10352 // ::= <substitution> 10353 10354 const char* 10355 __demangle_tree::__parse_nested_name(const char* first, const char* last) 10356 { 10357 if (first != last && *first == 'N') 10358 { 10359 unsigned cv = 0; 10360 const char* t0 = __parse_cv_qualifiers(first+1, last, cv, true); 10361 __node* prev = NULL; 10362 if (last - t0 >= 2 && t0[0] == 'S' && t0[1] == 't') 10363 { 10364 t0 += 2; 10365 if (!__make<__std_qualified_name>()) 10366 return first; 10367 prev = __root_; 10368 } 10369 while (t0 != last) 10370 { 10371 bool can_sub = true; 10372 bool make_nested = true; 10373 const char* t1 = NULL; 10374 switch (*t0) 10375 { 10376 case '1': 10377 case '2': 10378 case '3': 10379 case '4': 10380 case '5': 10381 case '6': 10382 case '7': 10383 case '8': 10384 case '9': 10385 t1 = __parse_source_name(t0, last); 10386 if (t1 == t0 || t1 == last) 10387 return first; 10388 if (*t1 == 'M') 10389 { 10390 // This is a data-member-prefix 10391 ++t1; 10392 } 10393 else if (*t1 == 'I') 10394 { 10395 // has following <template-args> 10396 if (prev) 10397 { 10398 if (!__make<__nested_delimeter>(prev, __root_)) 10399 return first; 10400 make_nested = false; 10401 } 10402 if (__sub_end_ == __sub_cap_) 10403 { 10404 __status_ = memory_alloc_failure; 10405 return first; 10406 } 10407 else 10408 *__sub_end_++ = __root_; 10409 const char* t2 = __parse_template_args(t1, last); 10410 if (t2 == t1) 10411 return first; 10412 t1 = t2; 10413 } 10414 break; 10415 case 'D': 10416 if (t0+1 != last && (t0[1] == 't' || t0[1] == 'T')) 10417 { 10418 t1 = __parse_decltype(t0, last); 10419 break; 10420 } 10421 // check for Dt, DT here, else drop through 10422 case 'C': 10423 t1 = __parse_ctor_dtor_name(t0, last); 10424 if (t1 == t0 || t1 == last) 10425 return first; 10426 if (*t1 == 'I') 10427 { 10428 // has following <template-args> 10429 if (prev) 10430 { 10431 if (!__make<__nested_delimeter>(prev, __root_)) 10432 return first; 10433 make_nested = false; 10434 } 10435 if (__sub_end_ == __sub_cap_) 10436 { 10437 __status_ = memory_alloc_failure; 10438 return first; 10439 } 10440 else 10441 *__sub_end_++ = __root_; 10442 const char* t2 = __parse_template_args(t1, last); 10443 if (t2 == t1) 10444 return first; 10445 t1 = t2; 10446 } 10447 break; 10448 case 'U': 10449 t1 = __parse_unnamed_type_name(t0, last); 10450 if (t1 == t0 || t1 == last) 10451 return first; 10452 break; 10453 case 'T': 10454 t1 = __parse_template_param(t0, last); 10455 if (t1 == t0 || t1 == last) 10456 return first; 10457 if (*t1 == 'I') 10458 { 10459 // has following <template-args> 10460 if (prev) 10461 { 10462 if (!__make<__nested_delimeter>(prev, __root_)) 10463 return first; 10464 make_nested = false; 10465 } 10466 if (__sub_end_ == __sub_cap_) 10467 { 10468 __status_ = memory_alloc_failure; 10469 return first; 10470 } 10471 else 10472 *__sub_end_++ = __root_; 10473 const char* t2 = __parse_template_args(t1, last); 10474 if (t2 == t1) 10475 return first; 10476 t1 = t2; 10477 } 10478 break; 10479 case 'S': 10480 t1 = __parse_substitution(t0, last); 10481 if (t1 == t0 || t1 == last) 10482 return first; 10483 if (*t1 == 'I') 10484 { 10485 const char* t2 = __parse_template_args(t1, last); 10486 if (t2 == t1) 10487 return first; 10488 t1 = t2; 10489 } 10490 else 10491 can_sub = false; 10492 break; 10493 case 'L': 10494 // extension: ignore L here 10495 ++t0; 10496 continue; 10497 default: 10498 t1 = __parse_operator_name(t0, last); 10499 if (t1 == t0 || t1 == last) 10500 return first; 10501 if (*t1 == 'I') 10502 { 10503 // has following <template-args> 10504 if (prev) 10505 { 10506 if (!__make<__nested_delimeter>(prev, __root_)) 10507 return first; 10508 make_nested = false; 10509 } 10510 if (__sub_end_ == __sub_cap_) 10511 { 10512 __status_ = memory_alloc_failure; 10513 return first; 10514 } 10515 else 10516 *__sub_end_++ = __root_; 10517 const char* t2 = __parse_template_args(t1, last); 10518 if (t2 == t1) 10519 return first; 10520 t1 = t2; 10521 } 10522 break; 10523 } 10524 if (t1 == t0 || t1 == last) 10525 return first; 10526 if (prev && make_nested) 10527 { 10528 if (!__make<__nested_delimeter>(prev, __root_)) 10529 return first; 10530 can_sub = true; 10531 } 10532 if (can_sub && *t1 != 'E') 10533 { 10534 if (__sub_end_ == __sub_cap_) 10535 { 10536 __status_ = memory_alloc_failure; 10537 return first; 10538 } 10539 else 10540 *__sub_end_++ = __root_; 10541 } 10542 if (*t1 == 'E') 10543 { 10544 if (cv != 0) 10545 { 10546 if (!__make<__cv_qualifiers>(cv, __root_)) 10547 return first; 10548 } 10549 first = t1+1; 10550 break; 10551 } 10552 prev = __root_; 10553 t0 = t1; 10554 } 10555 } 10556 return first; 10557 } 10558 10559 // <template-arg> ::= <type> # type or template 10560 // ::= X <expression> E # expression 10561 // ::= <expr-primary> # simple expressions 10562 // ::= J <template-arg>* E # argument pack 10563 // ::= LZ <encoding> E # extension 10564 10565 const char* 10566 __demangle_tree::__parse_template_arg(const char* first, const char* last) 10567 { 10568 if (first != last) 10569 { 10570 const char* t; 10571 switch (*first) 10572 { 10573 case 'X': 10574 t = __parse_expression(first+1, last); 10575 if (t != first+1) 10576 { 10577 if (t != last && *t == 'E') 10578 first = t+1; 10579 } 10580 break; 10581 case 'J': 10582 t = first+1; 10583 if (t == last) 10584 return first; 10585 if (*t == 'E') 10586 { 10587 if (__make<__list>((__node*)0)) 10588 first = t+1; 10589 } 10590 else 10591 { 10592 __node* list = NULL; 10593 __node* prev = NULL; 10594 do 10595 { 10596 const char* t2 = __parse_template_arg(t, last); 10597 if (t2 == t || !__make<__list>(__root_)) 10598 return first; 10599 if (list == 0) 10600 list = __root_; 10601 if (prev) 10602 { 10603 prev->__right_ = __root_; 10604 __root_->__size_ = prev->__size_ + 1; 10605 } 10606 prev = __root_; 10607 t = t2; 10608 } while (t != last && *t != 'E'); 10609 first = t+1; 10610 __root_ = list; 10611 } 10612 break; 10613 case 'L': 10614 // <expr-primary> or LZ <encoding> E 10615 if (first+1 != last && first[1] == 'Z') 10616 { 10617 t = __parse_encoding(first+2, last); 10618 if (t != first+2 && t != last && *t == 'E') 10619 first = t+1; 10620 } 10621 else 10622 first = __parse_expr_primary(first, last); 10623 break; 10624 default: 10625 // <type> 10626 first = __parse_type(first, last); 10627 break; 10628 } 10629 } 10630 return first; 10631 } 10632 10633 // <template-args> ::= I <template-arg>* E 10634 // extension, the abi says <template-arg>+ 10635 10636 const char* 10637 __demangle_tree::__parse_template_args(const char* first, const char* last) 10638 { 10639 if (last - first >= 2 && *first == 'I') 10640 { 10641 __node* args = NULL; 10642 __node* prev = NULL; 10643 __node* name = __root_; 10644 if (__tag_templates_) 10645 __t_end_ = __t_begin_; 10646 const char* t = first+1; 10647 while (*t != 'E') 10648 { 10649 bool prev_tag_templates = __tag_templates_; 10650 __node** prev_t_begin = __t_begin_; 10651 __node** prev_t_end = __t_end_; 10652 if (__tag_templates_) 10653 __t_begin_ = __t_end_; 10654 const char* t2 = __parse_template_arg(t, last); 10655 if (prev_tag_templates) 10656 { 10657 __tag_templates_ = prev_tag_templates; 10658 __t_begin_ = prev_t_begin; 10659 __t_end_ = prev_t_end; 10660 } 10661 if (t2 == t || t2 == last) 10662 break; 10663 if (!__make<__list>(__root_)) 10664 return first; 10665 if (args == 0) 10666 args = __root_; 10667 if (prev) 10668 { 10669 prev->__right_ = __root_; 10670 __root_->__size_ = prev->__size_ + 1; 10671 } 10672 prev = __root_; 10673 if (__tag_templates_) 10674 { 10675 if (__t_end_ == __t_cap_) 10676 { 10677 __status_ = memory_alloc_failure; 10678 return first; 10679 } 10680 if (__root_->__left_) 10681 *__t_end_++ = __root_->__left_; 10682 else 10683 *__t_end_++ = __root_; 10684 } 10685 t = t2; 10686 } 10687 if (t != last && *t == 'E') 10688 { 10689 if (__make<__template_args>(name, args)) 10690 first = t+1; 10691 } 10692 } 10693 return first; 10694 } 10695 10696 // <substitution> ::= S <seq-id> _ 10697 // ::= S_ 10698 // <substitution> ::= Sa # ::std::allocator 10699 // <substitution> ::= Sb # ::std::basic_string 10700 // <substitution> ::= Ss # ::std::basic_string < char, 10701 // ::std::char_traits<char>, 10702 // ::std::allocator<char> > 10703 // <substitution> ::= Si # ::std::basic_istream<char, std::char_traits<char> > 10704 // <substitution> ::= So # ::std::basic_ostream<char, std::char_traits<char> > 10705 // <substitution> ::= Sd # ::std::basic_iostream<char, std::char_traits<char> > 10706 10707 const char* 10708 __demangle_tree::__parse_substitution(const char* first, const char* last) 10709 { 10710 if (last - first >= 2) 10711 { 10712 if (*first == 'S') 10713 { 10714 switch (first[1]) 10715 { 10716 case 'a': 10717 if (__make<__sub_allocator>()) 10718 first += 2; 10719 break; 10720 case 'b': 10721 if (__make<__sub_basic_string>()) 10722 first += 2; 10723 break; 10724 case 's': 10725 if (__make<__sub_string>()) 10726 first += 2; 10727 break; 10728 case 'i': 10729 if (__make<__sub_istream>()) 10730 first += 2; 10731 break; 10732 case 'o': 10733 if (__make<__sub_ostream>()) 10734 first += 2; 10735 break; 10736 case 'd': 10737 if (__make<__sub_iostream>()) 10738 first += 2; 10739 break; 10740 case '_': 10741 if (__sub_begin_ != __sub_end_) 10742 { 10743 if (__make<__sub>(*__sub_begin_)) 10744 first += 2; 10745 } 10746 break; 10747 default: 10748 if (isdigit(first[1]) || isupper(first[1])) 10749 { 10750 size_t sub = 0; 10751 const char* t = first+1; 10752 if (isdigit(*t)) 10753 sub = static_cast<size_t>(*t - '0'); 10754 else 10755 sub = static_cast<size_t>(*t - 'A') + 10; 10756 for (++t; t != last && (isdigit(*t) || isupper(*t)); ++t) 10757 { 10758 sub *= 36; 10759 if (isdigit(*t)) 10760 sub += static_cast<size_t>(*t - '0'); 10761 else 10762 sub += static_cast<size_t>(*t - 'A') + 10; 10763 } 10764 if (t == last || *t != '_') 10765 return first; 10766 ++sub; 10767 if (sub < static_cast<size_t>(__sub_end_ - __sub_begin_)) 10768 { 10769 if (__make<__sub>(__sub_begin_[sub])) 10770 first = t+1; 10771 } 10772 } 10773 break; 10774 } 10775 } 10776 } 10777 return first; 10778 } 10779 10780 // <name> ::= <nested-name> 10781 // ::= <local-name> # See Scope Encoding below 10782 // ::= <unscoped-template-name> <template-args> 10783 // ::= <unscoped-name> 10784 10785 const char* 10786 __demangle_tree::__parse_name(const char* first, const char* last) 10787 { 10788 if (first != last) 10789 { 10790 const char* t0 = first; 10791 // extension: ignore L here 10792 if (*t0 == 'L') 10793 ++t0; 10794 const char* t = __parse_nested_name(t0, last); 10795 if (t == t0) 10796 { 10797 t = __parse_local_name(t0, last); 10798 if (t == t0) 10799 { 10800 // not <nested-name> nor <local-name> 10801 // Try to parse <unscoped-template-name> <template-args> or 10802 // <unscoped-name> which are nearly ambiguous. 10803 // This logic occurs nowhere else. 10804 if (last - t0 >= 2) 10805 { 10806 if (t0[0] == 'S' && (t0[1] == '_' || 10807 isdigit(t0[1]) || 10808 isupper(t0[1]) || 10809 t0[1] == 'a' || 10810 t0[1] == 'b')) 10811 { 10812 t = __parse_substitution(t0, last); 10813 if (t != t0) 10814 { 10815 const char* t2 = __parse_template_args(t, last); 10816 if (t2 != t) 10817 first = t2; 10818 } 10819 } 10820 else // Not a substitution, except maybe St 10821 { 10822 t = __parse_unscoped_name(t0, last); 10823 if (t != t0) 10824 { 10825 // unscoped-name might be <unscoped-template-name> 10826 if (t != last && *t == 'I') 10827 { 10828 if (__sub_end_ == __sub_cap_) 10829 { 10830 __status_ = memory_alloc_failure; 10831 return first; 10832 } 10833 *__sub_end_++ = __root_; 10834 const char* t2 = __parse_template_args(t, last); 10835 if (t2 != t) 10836 first = t2; 10837 } 10838 else 10839 { 10840 // <unscoped-name> 10841 first = t; 10842 } 10843 } 10844 } 10845 } 10846 } 10847 else 10848 first = t; 10849 } 10850 else 10851 first = t; 10852 } 10853 return first; 10854 } 10855 10856 // extension 10857 // <dot-suffix> := .<anything and everything> 10858 10859 const char* 10860 __demangle_tree::__parse_dot_suffix(const char* first, const char* last) 10861 { 10862 if (first != last && *first == '.') 10863 { 10864 if (__make<__dot_suffix>(__root_, first, static_cast<size_t>(last-first))) 10865 first = last; 10866 } 10867 return first; 10868 } 10869 10870 // _block_invoke 10871 // _block_invoke<decimal-digit>+ 10872 // _block_invoke_<decimal-digit>+ 10873 10874 const char* 10875 __demangle_tree::__parse_block_invoke(const char* first, const char* last) 10876 { 10877 if (last - first >= 13) 10878 { 10879 const char test[] = "_block_invoke"; 10880 const char* t = first; 10881 for (int i = 0; i < 13; ++i, ++t) 10882 { 10883 if (*t != test[i]) 10884 return first; 10885 } 10886 if (t != last) 10887 { 10888 if (*t == '_') 10889 { 10890 // must have at least 1 decimal digit 10891 if (++t == last || !isdigit(*t)) 10892 return first; 10893 ++t; 10894 } 10895 // parse zero or more digits 10896 while (t != last && isdigit(*t)) 10897 ++t; 10898 } 10899 if (__make<__block_invoke>(__root_)) 10900 first = t; 10901 } 10902 return first; 10903 } 10904 10905 // <encoding> ::= <function name> <bare-function-type> 10906 // ::= <data name> 10907 // ::= <special-name> 10908 10909 const char* 10910 __demangle_tree::__parse_encoding(const char* first, const char* last) 10911 { 10912 const char* t = __parse_name(first, last); 10913 if (t != first) 10914 { 10915 if (t != last && *t != 'E' && *t != '.') 10916 { 10917 __node* name = __root_; 10918 bool has_return = name->ends_with_template(true) && 10919 !name->is_ctor_dtor_conv(); 10920 __node* ret = NULL; 10921 const char* t2; 10922 bool prev_tag_templates = __tag_templates_; 10923 __tag_templates_ = false; 10924 if (has_return) 10925 { 10926 t2 = __parse_type(t, last); 10927 if (t2 != t) 10928 { 10929 ret = __root_; 10930 t = t2; 10931 } 10932 else 10933 return first; 10934 } 10935 t2 = __parse_bare_function_type(t, last); 10936 if (t2 != t) 10937 { 10938 if (dynamic_cast<__void*>(__root_->__left_) != NULL) 10939 __root_->__left_ = NULL; 10940 if (__make<__function_signature>(ret, __root_)) 10941 { 10942 __node* cv = name->extract_cv(name); 10943 if (__make<__function>(name, __root_)) 10944 { 10945 if (cv) 10946 { 10947 cv->__left_ = __root_; 10948 cv->__size_ <<= 5; 10949 __root_ = cv; 10950 } 10951 first = t2; 10952 } 10953 } 10954 } 10955 __tag_templates_ = prev_tag_templates; 10956 } 10957 else 10958 first = t; 10959 } 10960 else 10961 first = __parse_special_name(first, last); 10962 return first; 10963 } 10964 10965 // <block-involcaton-function> ___Z<encoding>_block_invoke 10966 // <block-involcaton-function> ___Z<encoding>_block_invoke<decimal-digit>+ 10967 // <block-involcaton-function> ___Z<encoding>_block_invoke_<decimal-digit>+ 10968 // <mangled-name> ::= _Z<encoding> 10969 // ::= <type> 10970 10971 void 10972 __demangle_tree::__parse() 10973 { 10974 if (__mangled_name_begin_ == __mangled_name_end_) 10975 { 10976 __status_ = invalid_mangled_name; 10977 return; 10978 } 10979 const char* t = NULL; 10980 if (__mangled_name_end_ - __mangled_name_begin_ >= 2 && 10981 __mangled_name_begin_[0] == '_' && 10982 __mangled_name_begin_[1] == 'Z') 10983 { 10984 t = __parse_encoding(__mangled_name_begin_+2, __mangled_name_end_); 10985 if (t != __mangled_name_begin_+2 && t != __mangled_name_end_ && *t == '.') 10986 t = __parse_dot_suffix(t, __mangled_name_end_); 10987 } 10988 else if (__mangled_name_end_ - __mangled_name_begin_ >= 4 && 10989 __mangled_name_begin_[0] == '_' && 10990 __mangled_name_begin_[1] == '_' && 10991 __mangled_name_begin_[2] == '_' && 10992 __mangled_name_begin_[3] == 'Z') 10993 { 10994 t = __parse_encoding(__mangled_name_begin_+4, __mangled_name_end_); 10995 if (t != __mangled_name_begin_+4 && t != __mangled_name_end_) 10996 t = __parse_block_invoke(t, __mangled_name_end_); 10997 else 10998 t = __mangled_name_begin_; 10999 } 11000 else 11001 t = __parse_type(__mangled_name_begin_, __mangled_name_end_); 11002 if (t == __mangled_name_end_ && __root_) 11003 { 11004 if (__fix_forward_references_) 11005 { 11006 if (__root_->fix_forward_references(__t_begin_, __t_end_)) 11007 __status_ = success; 11008 } 11009 else 11010 __status_ = success; 11011 } 11012 } 11013 11014 __demangle_tree 11015 __demangle(const char* mangled_name, char* buf, size_t bs) 11016 { 11017 __demangle_tree t(mangled_name, buf, bs); 11018 if (t.__status() == invalid_mangled_name) 11019 t.__parse(); 11020 return t; 11021 } 11022 11023 __demangle_tree 11024 __demangle(const char* mangled_name) 11025 { 11026 return __demangle(mangled_name, 0, 0); 11027 } 11028 11029 char* 11030 __demangle(__demangle_tree dmg_tree, char* buf, size_t* n, int* status) 11031 { 11032 if (dmg_tree.__status() != success) 11033 { 11034 if (status) 11035 *status = dmg_tree.__status(); 11036 return NULL; 11037 } 11038 #ifdef DEBUGGING 11039 display(dmg_tree.__root_); 11040 printf("\n"); 11041 #endif 11042 const size_t bs = buf == NULL ? 0 : *n; 11043 ptrdiff_t sm = dmg_tree.__mangled_name_end_ - dmg_tree.__mangled_name_begin_; 11044 ptrdiff_t est = sm + 60 * ( 11045 (dmg_tree.__node_end_ - dmg_tree.__node_begin_) + 11046 (dmg_tree.__sub_end_ - dmg_tree.__sub_begin_) + 11047 (dmg_tree.__t_end_ - dmg_tree.__t_begin_)); 11048 const unsigned N = 4096; 11049 char tmp[N]; 11050 ptrdiff_t s; 11051 if (static_cast<size_t>(est) <= bs) 11052 { 11053 char* e = dmg_tree.__get_demangled_name(buf); 11054 *e++ = '\0'; 11055 s = e - buf; 11056 } 11057 else if (static_cast<size_t>(est) <= N) 11058 { 11059 char* e = dmg_tree.__get_demangled_name(tmp); 11060 *e++ = '\0'; 11061 s = e - tmp; 11062 } 11063 else 11064 s = static_cast<ptrdiff_t>(dmg_tree.size() + 1); 11065 if (static_cast<size_t>(s) > bs) 11066 { 11067 buf = static_cast<char*>(realloc(buf, static_cast<size_t>(s))); 11068 if (buf == NULL) 11069 { 11070 if (status) 11071 *status = memory_alloc_failure; 11072 return NULL; 11073 } 11074 if (n) 11075 *n = static_cast<size_t>(s); 11076 } 11077 if (static_cast<size_t>(est) > bs) 11078 { 11079 if (static_cast<size_t>(est) <= N) 11080 strncpy(buf, tmp, static_cast<size_t>(s)); 11081 else 11082 *dmg_tree.__get_demangled_name(buf) = '\0'; 11083 } 11084 if (status) 11085 *status = success; 11086 return buf; 11087 } 11088 11089 } // __libcxxabi 11090 11091 #pragma GCC visibility pop 11092 #pragma GCC visibility push(default) 11093 11094 extern "C" 11095 { 11096 11097 char* 11098 __cxa_demangle(const char* mangled_name, char* buf, size_t* n, int* status) 11099 { 11100 if (mangled_name == NULL || (buf != NULL && n == NULL)) 11101 { 11102 if (status) 11103 *status = __libcxxabi::invalid_args; 11104 return NULL; 11105 } 11106 const size_t bs = 4 * 1024; 11107 __attribute((aligned(16))) char static_buf[bs]; 11108 11109 buf = __libcxxabi::__demangle(__libcxxabi::__demangle(mangled_name, 11110 static_buf, bs), 11111 buf, n, status); 11112 return buf; 11113 } 11114 11115 } // extern "C" 11116 11117 } // abi 11118