cxa_demangle.cpp revision 889b02d72d523ba716ce08403c284e60f0a9431d
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 21#ifdef DEBUGGING 22 23#include <string> 24#include <typeinfo> 25 26#endif 27 28namespace __cxxabiv1 29{ 30 31namespace __libcxxabi 32{ 33 34#pragma GCC visibility push(hidden) 35 36class __node 37{ 38 __node(const __node&); 39 __node& operator=(const __node&); 40public: 41 const char* __name_; 42 size_t __size_; 43 __node* __left_; 44 __node* __right_; 45 long double __value_; 46 long __cached_size_; 47public: 48 __node() 49 : __name_(0), __size_(0), __left_(0), __right_(0), __cached_size_(-1) 50 {} 51 virtual ~__node() {}; 52 53 void reset_cached_size() 54 { 55 __cached_size_ = -1; 56 if (__left_) 57 __left_->reset_cached_size(); 58 if (__right_) 59 __right_->reset_cached_size(); 60 } 61 62 virtual size_t first_size() const {return 0;} 63 virtual size_t second_size() const {return 0;} 64 virtual size_t size() const 65 { 66 if (__cached_size_ == -1) 67 const_cast<long&>(__cached_size_) = first_size() + second_size(); 68 return __cached_size_; 69 } 70 virtual char* first_demangled_name(char* buf) const {return buf;} 71 virtual char* second_demangled_name(char* buf) const {return buf;} 72 virtual char* get_demangled_name(char* buf) const 73 { 74 return second_demangled_name(first_demangled_name(buf)); 75 } 76 virtual size_t base_size() const {return size();} 77 virtual char* get_base_name(char* buf) const 78 { 79 return get_demangled_name(buf); 80 } 81 virtual ptrdiff_t print_base_name(char* f, char* l) const 82 { 83 return print(f, l); 84 } 85 virtual bool ends_with_template() const 86 { 87 return false; 88 } 89 virtual bool is_ctor_dtor_conv() const 90 { 91 return false; 92 } 93 virtual __node* base_name() const 94 { 95 return const_cast<__node*>(this); 96 } 97 virtual bool is_reference_or_pointer_to_function_or_array() const 98 { 99 return false; 100 } 101 virtual bool is_function() const 102 { 103 return false; 104 } 105 virtual bool is_cv_qualifer() const 106 { 107 return false; 108 } 109 virtual bool is_array() const 110 { 111 return false; 112 } 113 114 virtual bool fix_forward_references(__node**, __node**) 115 { 116 return true; 117 } 118 virtual __node* extract_cv(__node*&) const 119 { 120 return 0; 121 } 122 virtual size_t list_len() const 123 { 124 return 0; 125 } 126 virtual bool is_sub() const 127 { 128 return false; 129 } 130 131 virtual ptrdiff_t print(char* f, char* l) const 132 { 133 const ptrdiff_t sz1 = print_first(f, l); 134 return sz1 + print_second(f+std::min(sz1, l-f), l); 135 } 136 virtual ptrdiff_t print_first(char*, char*) const 137 { 138 return 0; 139 } 140 virtual ptrdiff_t print_second(char*, char*) const 141 { 142 return 0; 143 } 144}; 145 146#ifdef DEBUGGING 147 148void display(__node* x, int indent = 0) 149{ 150 if (x) 151 { 152 for (int i = 0; i < 2*indent; ++i) 153 printf(" "); 154 std::string buf(x->size(), '\0'); 155 x->print(&buf.front(), &buf.back()+1); 156 printf("%s %s, %p\n", typeid(*x).name(), buf.c_str(), x); 157 display(x->__left_, indent+1); 158 display(x->__right_, indent+1); 159 } 160} 161 162#endif 163 164class __vtable 165 : public __node 166{ 167 static const ptrdiff_t n = sizeof("vtable for ") - 1; 168public: 169 __vtable(__node* type) 170 { 171 __right_ = type; 172 } 173 174 virtual size_t first_size() const 175 { 176 if (__cached_size_ == -1) 177 const_cast<long&>(__cached_size_) = n + __right_->size(); 178 return __cached_size_; 179 } 180 virtual char* first_demangled_name(char* buf) const 181 { 182 strncpy(buf, "vtable for ", n); 183 return __right_->get_demangled_name(buf+n); 184 } 185 virtual ptrdiff_t print_first(char* f, char* l) const 186 { 187 const ptrdiff_t r = l - f; 188 if (r < n) 189 return n + __right_->print(l, l); 190 ptrdiff_t sz = __right_->print(f+n, l) + n; 191 if (r >= sz) 192 { 193 *f++ = 'v'; 194 *f++ = 't'; 195 *f++ = 'a'; 196 *f++ = 'b'; 197 *f++ = 'l'; 198 *f++ = 'e'; 199 *f++ = ' '; 200 *f++ = 'f'; 201 *f++ = 'o'; 202 *f++ = 'r'; 203 *f = ' '; 204 } 205 return sz; 206 } 207 virtual __node* base_name() const 208 { 209 return __right_->base_name(); 210 } 211 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 212 { 213 return __right_->fix_forward_references(t_begin, t_end); 214 } 215}; 216 217class __VTT 218 : public __node 219{ 220 static const ptrdiff_t n = sizeof("VTT for ") - 1; 221public: 222 __VTT(__node* type) 223 { 224 __right_ = type; 225 } 226 227 virtual size_t first_size() const 228 { 229 if (__cached_size_ == -1) 230 const_cast<long&>(__cached_size_) = n + __right_->size(); 231 return __cached_size_; 232 } 233 virtual char* first_demangled_name(char* buf) const 234 { 235 strncpy(buf, "VTT for ", n); 236 return __right_->get_demangled_name(buf+n); 237 } 238 virtual ptrdiff_t print_first(char* f, char* l) const 239 { 240 const ptrdiff_t r = l - f; 241 if (r < n) 242 return n + __right_->print(l, l); 243 ptrdiff_t sz = __right_->print(f+n, l) + n; 244 if (r >= sz) 245 { 246 *f++ = 'V'; 247 *f++ = 'T'; 248 *f++ = 'T'; 249 *f++ = ' '; 250 *f++ = 'f'; 251 *f++ = 'o'; 252 *f++ = 'r'; 253 *f = ' '; 254 } 255 return sz; 256 } 257 virtual __node* base_name() const 258 { 259 return __right_->base_name(); 260 } 261 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 262 { 263 return __right_->fix_forward_references(t_begin, t_end); 264 } 265}; 266 267class __typeinfo 268 : public __node 269{ 270 static const ptrdiff_t n = sizeof("typeinfo for ") - 1; 271public: 272 __typeinfo(__node* type) 273 { 274 __right_ = type; 275 } 276 277 virtual size_t first_size() const 278 { 279 if (__cached_size_ == -1) 280 const_cast<long&>(__cached_size_) = n + __right_->size(); 281 return __cached_size_; 282 } 283 virtual char* first_demangled_name(char* buf) const 284 { 285 strncpy(buf, "typeinfo for ", n); 286 return __right_->get_demangled_name(buf+n); 287 } 288 virtual ptrdiff_t print_first(char* f, char* l) const 289 { 290 const ptrdiff_t r = l - f; 291 if (r < n) 292 return n + __right_->print(l, l); 293 ptrdiff_t sz = __right_->print(f+n, l) + n; 294 if (r >= sz) 295 { 296 *f++ = 't'; 297 *f++ = 'y'; 298 *f++ = 'p'; 299 *f++ = 'e'; 300 *f++ = 'i'; 301 *f++ = 'n'; 302 *f++ = 'f'; 303 *f++ = 'o'; 304 *f++ = ' '; 305 *f++ = 'f'; 306 *f++ = 'o'; 307 *f++ = 'r'; 308 *f = ' '; 309 } 310 return sz; 311 } 312 virtual __node* base_name() const 313 { 314 return __right_->base_name(); 315 } 316 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 317 { 318 return __right_->fix_forward_references(t_begin, t_end); 319 } 320}; 321 322class __typeinfo_name 323 : public __node 324{ 325 static const ptrdiff_t n = sizeof("typeinfo name for ") - 1; 326public: 327 __typeinfo_name(__node* type) 328 { 329 __right_ = type; 330 } 331 332 virtual size_t first_size() const 333 { 334 if (__cached_size_ == -1) 335 const_cast<long&>(__cached_size_) = n + __right_->size(); 336 return __cached_size_; 337 } 338 virtual char* first_demangled_name(char* buf) const 339 { 340 strncpy(buf, "typeinfo name for ", n); 341 return __right_->get_demangled_name(buf+n); 342 } 343 virtual ptrdiff_t print_first(char* f, char* l) const 344 { 345 const ptrdiff_t r = l - f; 346 if (r < n) 347 return n + __right_->print(l, l); 348 ptrdiff_t sz = __right_->print(f+n, l) + n; 349 if (r >= sz) 350 { 351 *f++ = 't'; 352 *f++ = 'y'; 353 *f++ = 'p'; 354 *f++ = 'e'; 355 *f++ = 'i'; 356 *f++ = 'n'; 357 *f++ = 'f'; 358 *f++ = 'o'; 359 *f++ = ' '; 360 *f++ = 'n'; 361 *f++ = 'a'; 362 *f++ = 'm'; 363 *f++ = 'e'; 364 *f++ = ' '; 365 *f++ = 'f'; 366 *f++ = 'o'; 367 *f++ = 'r'; 368 *f = ' '; 369 } 370 return sz; 371 } 372 virtual __node* base_name() const 373 { 374 return __right_->base_name(); 375 } 376 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 377 { 378 return __right_->fix_forward_references(t_begin, t_end); 379 } 380}; 381 382class __covariant_return_thunk 383 : public __node 384{ 385 static const ptrdiff_t n = sizeof("covariant return thunk to ") - 1; 386public: 387 __covariant_return_thunk(__node* type) 388 { 389 __right_ = type; 390 } 391 392 virtual size_t first_size() const 393 { 394 if (__cached_size_ == -1) 395 const_cast<long&>(__cached_size_) = n + __right_->size(); 396 return __cached_size_; 397 } 398 virtual char* first_demangled_name(char* buf) const 399 { 400 strncpy(buf, "covariant return thunk to ", n); 401 return __right_->get_demangled_name(buf+n); 402 } 403 virtual ptrdiff_t print_first(char* f, char* l) const 404 { 405 const ptrdiff_t r = l - f; 406 if (r < n) 407 return n + __right_->print(l, l); 408 ptrdiff_t sz = __right_->print(f+n, l) + n; 409 if (r >= sz) 410 { 411 *f++ = 'c'; 412 *f++ = 'o'; 413 *f++ = 'v'; 414 *f++ = 'a'; 415 *f++ = 'r'; 416 *f++ = 'i'; 417 *f++ = 'a'; 418 *f++ = 'n'; 419 *f++ = 't'; 420 *f++ = ' '; 421 *f++ = 'r'; 422 *f++ = 'e'; 423 *f++ = 't'; 424 *f++ = 'u'; 425 *f++ = 'r'; 426 *f++ = 'n'; 427 *f++ = ' '; 428 *f++ = 't'; 429 *f++ = 'h'; 430 *f++ = 'u'; 431 *f++ = 'n'; 432 *f++ = 'k'; 433 *f++ = ' '; 434 *f++ = 't'; 435 *f++ = 'o'; 436 *f = ' '; 437 } 438 return sz; 439 } 440 virtual __node* base_name() const 441 { 442 return __right_->base_name(); 443 } 444 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 445 { 446 return __right_->fix_forward_references(t_begin, t_end); 447 } 448}; 449 450class __virtual_thunk 451 : public __node 452{ 453 static const size_t n = sizeof("virtual thunk to ") - 1; 454public: 455 __virtual_thunk(__node* type) 456 { 457 __right_ = type; 458 } 459 460 virtual size_t first_size() const 461 { 462 if (__cached_size_ == -1) 463 const_cast<long&>(__cached_size_) = n + __right_->size(); 464 return __cached_size_; 465 } 466 virtual char* first_demangled_name(char* buf) const 467 { 468 strncpy(buf, "virtual thunk to ", n); 469 return __right_->get_demangled_name(buf+n); 470 } 471 virtual ptrdiff_t print_first(char* f, char* l) const 472 { 473 const ptrdiff_t r = l - f; 474 if (r < n) 475 return n + __right_->print(l, l); 476 ptrdiff_t sz = __right_->print(f+n, l) + n; 477 if (r >= sz) 478 { 479 *f++ = 'v'; 480 *f++ = 'i'; 481 *f++ = 'r'; 482 *f++ = 't'; 483 *f++ = 'u'; 484 *f++ = 'a'; 485 *f++ = 'l'; 486 *f++ = ' '; 487 *f++ = 't'; 488 *f++ = 'h'; 489 *f++ = 'u'; 490 *f++ = 'n'; 491 *f++ = 'k'; 492 *f++ = ' '; 493 *f++ = 't'; 494 *f++ = 'o'; 495 *f = ' '; 496 } 497 return sz; 498 } 499 virtual __node* base_name() const 500 { 501 return __right_->base_name(); 502 } 503 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 504 { 505 return __right_->fix_forward_references(t_begin, t_end); 506 } 507}; 508 509class __non_virtual_thunk 510 : public __node 511{ 512 static const size_t n = sizeof("non-virtual thunk to ") - 1; 513public: 514 __non_virtual_thunk(__node* type) 515 { 516 __right_ = type; 517 } 518 519 virtual size_t first_size() const 520 { 521 if (__cached_size_ == -1) 522 const_cast<long&>(__cached_size_) = n + __right_->size(); 523 return __cached_size_; 524 } 525 virtual char* first_demangled_name(char* buf) const 526 { 527 strncpy(buf, "non-virtual thunk to ", n); 528 return __right_->get_demangled_name(buf+n); 529 } 530 virtual ptrdiff_t print_first(char* f, char* l) const 531 { 532 const ptrdiff_t r = l - f; 533 if (r < n) 534 return n + __right_->print(l, l); 535 ptrdiff_t sz = __right_->print(f+n, l) + n; 536 if (r >= sz) 537 { 538 *f++ = 'n'; 539 *f++ = 'o'; 540 *f++ = 'n'; 541 *f++ = '-'; 542 *f++ = 'v'; 543 *f++ = 'i'; 544 *f++ = 'r'; 545 *f++ = 't'; 546 *f++ = 'u'; 547 *f++ = 'a'; 548 *f++ = 'l'; 549 *f++ = ' '; 550 *f++ = 't'; 551 *f++ = 'h'; 552 *f++ = 'u'; 553 *f++ = 'n'; 554 *f++ = 'k'; 555 *f++ = ' '; 556 *f++ = 't'; 557 *f++ = 'o'; 558 *f = ' '; 559 } 560 return sz; 561 } 562 virtual __node* base_name() const 563 { 564 return __right_->base_name(); 565 } 566 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 567 { 568 return __right_->fix_forward_references(t_begin, t_end); 569 } 570}; 571 572class __guard_variable 573 : public __node 574{ 575 static const size_t n = sizeof("guard variable for ") - 1; 576public: 577 __guard_variable(__node* type) 578 { 579 __right_ = type; 580 } 581 582 virtual size_t first_size() const 583 { 584 if (__cached_size_ == -1) 585 const_cast<long&>(__cached_size_) = n + __right_->size(); 586 return __cached_size_; 587 } 588 virtual char* first_demangled_name(char* buf) const 589 { 590 strncpy(buf, "guard variable for ", n); 591 return __right_->get_demangled_name(buf+n); 592 } 593 virtual ptrdiff_t print_first(char* f, char* l) const 594 { 595 const ptrdiff_t r = l - f; 596 if (r < n) 597 return n + __right_->print(l, l); 598 ptrdiff_t sz = __right_->print(f+n, l) + n; 599 if (r >= sz) 600 { 601 *f++ = 'g'; 602 *f++ = 'u'; 603 *f++ = 'a'; 604 *f++ = 'r'; 605 *f++ = 'd'; 606 *f++ = ' '; 607 *f++ = 'v'; 608 *f++ = 'a'; 609 *f++ = 'r'; 610 *f++ = 'i'; 611 *f++ = 'a'; 612 *f++ = 'b'; 613 *f++ = 'l'; 614 *f++ = 'e'; 615 *f++ = ' '; 616 *f++ = 'f'; 617 *f++ = 'o'; 618 *f++ = 'r'; 619 *f = ' '; 620 } 621 return sz; 622 } 623 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 624 { 625 return __right_->fix_forward_references(t_begin, t_end); 626 } 627}; 628 629class __source_name 630 : public __node 631{ 632public: 633 __source_name(const char* __name, unsigned __size) 634 { 635 __name_ = __name; 636 __size_ = __size; 637 } 638 639 virtual size_t first_size() const 640 { 641 if (__cached_size_ == -1) 642 { 643 if (__size_ >= 10 && strncmp(__name_, "_GLOBAL__N", 10) == 0) 644 const_cast<long&>(__cached_size_) = 21; 645 else 646 const_cast<long&>(__cached_size_) = __size_; 647 } 648 return __cached_size_; 649 } 650 virtual char* first_demangled_name(char* buf) const 651 { 652 if (__size_ >= 10 && strncmp(__name_, "_GLOBAL__N", 10) == 0) 653 return strncpy(buf, "(anonymous namespace)", 21) + 21; 654 return strncpy(buf, __name_, __size_) + __size_; 655 } 656 virtual ptrdiff_t print_first(char* f, char* l) const 657 { 658 const ptrdiff_t r = l - f; 659 if (__size_ >= 10 && strncmp(__name_, "_GLOBAL__N", 10) == 0) 660 { 661 const ptrdiff_t n = sizeof("(anonymous namespace)") - 1; 662 if (r >= n) 663 { 664 *f++ = '('; 665 *f++ = 'a'; 666 *f++ = 'n'; 667 *f++ = 'o'; 668 *f++ = 'n'; 669 *f++ = 'y'; 670 *f++ = 'm'; 671 *f++ = 'o'; 672 *f++ = 'u'; 673 *f++ = 's'; 674 *f++ = ' '; 675 *f++ = 'n'; 676 *f++ = 'a'; 677 *f++ = 'm'; 678 *f++ = 'e'; 679 *f++ = 's'; 680 *f++ = 'p'; 681 *f++ = 'a'; 682 *f++ = 'c'; 683 *f++ = 'e'; 684 *f = ')'; 685 } 686 return n; 687 } 688 if (r >= __size_) 689 strncpy(f, __name_, __size_); 690 return __size_; 691 } 692}; 693 694class __operator_new 695 : public __node 696{ 697public: 698 699 virtual size_t first_size() const {return sizeof("operator new") - 1;} 700 virtual char* first_demangled_name(char* buf) const 701 { 702 return strncpy(buf, "operator new", sizeof("operator new") - 1) + 703 sizeof("operator new") - 1; 704 } 705 virtual ptrdiff_t print_first(char* f, char* l) const 706 { 707 const ptrdiff_t r = l - f; 708 const ptrdiff_t n = sizeof("operator new") - 1; 709 if (r >= n) 710 { 711 *f++ = 'o'; 712 *f++ = 'p'; 713 *f++ = 'e'; 714 *f++ = 'r'; 715 *f++ = 'a'; 716 *f++ = 't'; 717 *f++ = 'o'; 718 *f++ = 'r'; 719 *f++ = ' '; 720 *f++ = 'n'; 721 *f++ = 'e'; 722 *f = 'w'; 723 } 724 return n; 725 } 726}; 727 728class __operator_new_array 729 : public __node 730{ 731public: 732 733 virtual size_t first_size() const {return sizeof("operator new[]") - 1;} 734 virtual char* first_demangled_name(char* buf) const 735 { 736 return strncpy(buf, "operator new[]", sizeof("operator new[]") - 1) + 737 sizeof("operator new[]") - 1; 738 } 739 virtual ptrdiff_t print_first(char* f, char* l) const 740 { 741 const ptrdiff_t r = l - f; 742 const ptrdiff_t n = sizeof("operator new[]") - 1; 743 if (r >= n) 744 { 745 *f++ = 'o'; 746 *f++ = 'p'; 747 *f++ = 'e'; 748 *f++ = 'r'; 749 *f++ = 'a'; 750 *f++ = 't'; 751 *f++ = 'o'; 752 *f++ = 'r'; 753 *f++ = ' '; 754 *f++ = 'n'; 755 *f++ = 'e'; 756 *f++ = 'w'; 757 *f++ = '['; 758 *f = ']'; 759 } 760 return n; 761 } 762}; 763 764class __operator_delete 765 : public __node 766{ 767public: 768 769 virtual size_t first_size() const {return sizeof("operator delete") - 1;} 770 virtual char* first_demangled_name(char* buf) const 771 { 772 return strncpy(buf, "operator delete", sizeof("operator delete") - 1) + 773 sizeof("operator delete") - 1; 774 } 775 virtual ptrdiff_t print_first(char* f, char* l) const 776 { 777 const ptrdiff_t r = l - f; 778 const ptrdiff_t n = sizeof("operator delete") - 1; 779 if (r >= n) 780 { 781 *f++ = 'o'; 782 *f++ = 'p'; 783 *f++ = 'e'; 784 *f++ = 'r'; 785 *f++ = 'a'; 786 *f++ = 't'; 787 *f++ = 'o'; 788 *f++ = 'r'; 789 *f++ = ' '; 790 *f++ = 'd'; 791 *f++ = 'e'; 792 *f++ = 'l'; 793 *f++ = 'e'; 794 *f++ = 't'; 795 *f = 'e'; 796 } 797 return n; 798 } 799}; 800 801class __operator_delete_array 802 : public __node 803{ 804public: 805 806 virtual size_t first_size() const {return sizeof("operator delete[]") - 1;} 807 virtual char* first_demangled_name(char* buf) const 808 { 809 return strncpy(buf, "operator delete[]", sizeof("operator delete[]") - 1) + 810 sizeof("operator delete[]") - 1; 811 } 812 virtual ptrdiff_t print_first(char* f, char* l) const 813 { 814 const ptrdiff_t r = l - f; 815 const ptrdiff_t n = sizeof("operator delete[]") - 1; 816 if (r >= n) 817 { 818 *f++ = 'o'; 819 *f++ = 'p'; 820 *f++ = 'e'; 821 *f++ = 'r'; 822 *f++ = 'a'; 823 *f++ = 't'; 824 *f++ = 'o'; 825 *f++ = 'r'; 826 *f++ = ' '; 827 *f++ = 'd'; 828 *f++ = 'e'; 829 *f++ = 'l'; 830 *f++ = 'e'; 831 *f++ = 't'; 832 *f++ = 'e'; 833 *f++ = '['; 834 *f = ']'; 835 } 836 return n; 837 } 838}; 839 840class __operator_logical_and 841 : public __node 842{ 843public: 844 845 __operator_logical_and() {} 846 __operator_logical_and(__node* op1, __node* op2) 847 { 848 __left_ = op1; 849 __right_ = op2; 850 } 851 virtual size_t first_size() const 852 { 853 if (__cached_size_ == -1) 854 { 855 if (__left_) 856 const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size(); 857 else 858 const_cast<long&>(__cached_size_) = sizeof("operator&&") - 1; 859 } 860 return __cached_size_; 861 } 862 virtual char* first_demangled_name(char* buf) const 863 { 864 if (__left_) 865 { 866 *buf++ = '('; 867 buf = __left_->get_demangled_name(buf); 868 strncpy(buf, ") && (", 6); 869 buf += 6; 870 buf = __right_->get_demangled_name(buf); 871 *buf++ = ')'; 872 } 873 else 874 { 875 strncpy(buf, "operator&&", sizeof("operator&&") - 1); 876 buf += sizeof("operator&&") - 1; 877 } 878 return buf; 879 } 880 virtual ptrdiff_t print_first(char* f, char* l) const 881 { 882 const ptrdiff_t r = l - f; 883 if (__left_) 884 { 885 const ptrdiff_t n1 = 8; 886 if (r < n1) 887 return n1 + __left_->print(l, l) + __right_->print(l, l); 888 ptrdiff_t sz1 = __left_->print(f+1, l); 889 if (r < n1 + sz1) 890 return n1 + sz1 + __right_->print(l, l); 891 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 892 if (r >= n1 + sz1 + sz2) 893 { 894 *f = '('; 895 f += 1 + sz1; 896 *f++ = ')'; 897 *f++ = ' '; 898 *f++ = '&'; 899 *f++ = '&'; 900 *f++ = ' '; 901 *f = '('; 902 f += 1 + sz2; 903 *f = ')'; 904 } 905 return n1 + sz1 + sz2; 906 } 907 const ptrdiff_t n2 = sizeof("operator&&") - 1; 908 if (r >= n2) 909 { 910 *f++ = 'o'; 911 *f++ = 'p'; 912 *f++ = 'e'; 913 *f++ = 'r'; 914 *f++ = 'a'; 915 *f++ = 't'; 916 *f++ = 'o'; 917 *f++ = 'r'; 918 *f++ = '&'; 919 *f = '&'; 920 } 921 return n2; 922 } 923 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 924 { 925 bool r = true; 926 if (__left_) 927 r = r && __left_->fix_forward_references(t_begin, t_end); 928 if (__right_) 929 r = r && __right_->fix_forward_references(t_begin, t_end); 930 return r; 931 } 932}; 933 934class __operator_addressof 935 : public __node 936{ 937public: 938 939 __operator_addressof() {} 940 explicit __operator_addressof(__node* op) 941 { 942 __left_ = op; 943 } 944 virtual size_t first_size() const 945 { 946 if (__cached_size_ == -1) 947 { 948 if (__left_) 949 const_cast<long&>(__cached_size_) = 3+__left_->size(); 950 else 951 const_cast<long&>(__cached_size_) = sizeof("operator&") - 1; 952 } 953 return __cached_size_; 954 } 955 virtual char* first_demangled_name(char* buf) const 956 { 957 if (__left_) 958 { 959 *buf++ = '&'; 960 *buf++ = '('; 961 buf = __left_->get_demangled_name(buf); 962 *buf++ = ')'; 963 } 964 else 965 { 966 strncpy(buf, "operator&", sizeof("operator&") - 1); 967 buf += sizeof("operator&") - 1; 968 } 969 return buf; 970 } 971 virtual ptrdiff_t print_first(char* f, char* l) const 972 { 973 const ptrdiff_t r = l - f; 974 if (__left_) 975 { 976 const ptrdiff_t n1 = 3; 977 if (r < n1) 978 return n1 + __left_->print(l, l); 979 ptrdiff_t sz1 = __left_->print(f+2, l); 980 if (r >= n1 + sz1) 981 { 982 *f++ = '&'; 983 *f = '('; 984 f += 1 + sz1; 985 *f = ')'; 986 } 987 return n1 + sz1; 988 } 989 const ptrdiff_t n2 = sizeof("operator&") - 1; 990 if (r >= n2) 991 { 992 *f++ = 'o'; 993 *f++ = 'p'; 994 *f++ = 'e'; 995 *f++ = 'r'; 996 *f++ = 'a'; 997 *f++ = 't'; 998 *f++ = 'o'; 999 *f++ = 'r'; 1000 *f = '&'; 1001 } 1002 return n2; 1003 } 1004 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1005 { 1006 if (__left_) 1007 return __left_->fix_forward_references(t_begin, t_end); 1008 return true; 1009 } 1010}; 1011 1012class __operator_bit_and 1013 : public __node 1014{ 1015public: 1016 1017 __operator_bit_and() {} 1018 __operator_bit_and(__node* op1, __node* op2) 1019 { 1020 __left_ = op1; 1021 __right_ = op2; 1022 } 1023 virtual size_t first_size() const 1024 { 1025 if (__cached_size_ == -1) 1026 { 1027 if (__left_) 1028 const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size(); 1029 else 1030 const_cast<long&>(__cached_size_) = sizeof("operator&") - 1; 1031 } 1032 return __cached_size_; 1033 } 1034 virtual char* first_demangled_name(char* buf) const 1035 { 1036 if (__left_) 1037 { 1038 *buf++ = '('; 1039 buf = __left_->get_demangled_name(buf); 1040 strncpy(buf, ") & (", 5); 1041 buf += 5; 1042 buf = __right_->get_demangled_name(buf); 1043 *buf++ = ')'; 1044 } 1045 else 1046 { 1047 strncpy(buf, "operator&", sizeof("operator&") - 1); 1048 buf += sizeof("operator&") - 1; 1049 } 1050 return buf; 1051 } 1052 virtual ptrdiff_t print_first(char* f, char* l) const 1053 { 1054 const ptrdiff_t r = l - f; 1055 if (__left_) 1056 { 1057 const ptrdiff_t n1 = 7; 1058 if (r < n1) 1059 return n1 + __left_->print(l, l) + __right_->print(l, l); 1060 ptrdiff_t sz1 = __left_->print(f+1, l); 1061 if (r < n1 + sz1) 1062 return n1 + sz1 + __right_->print(l, l); 1063 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 1064 if (r >= n1 + sz1 + sz2) 1065 { 1066 *f = '('; 1067 f += 1 + sz1; 1068 *f++ = ')'; 1069 *f++ = ' '; 1070 *f++ = '&'; 1071 *f++ = ' '; 1072 *f = '('; 1073 f += 1 + sz2; 1074 *f = ')'; 1075 } 1076 return n1 + sz1 + sz2; 1077 } 1078 const ptrdiff_t n2 = sizeof("operator&") - 1; 1079 if (r >= n2) 1080 { 1081 *f++ = 'o'; 1082 *f++ = 'p'; 1083 *f++ = 'e'; 1084 *f++ = 'r'; 1085 *f++ = 'a'; 1086 *f++ = 't'; 1087 *f++ = 'o'; 1088 *f++ = 'r'; 1089 *f = '&'; 1090 } 1091 return n2; 1092 } 1093 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1094 { 1095 bool r = true; 1096 if (__left_) 1097 r = r && __left_->fix_forward_references(t_begin, t_end); 1098 if (__right_) 1099 r = r && __right_->fix_forward_references(t_begin, t_end); 1100 return r; 1101 } 1102}; 1103 1104class __operator_and_equal 1105 : public __node 1106{ 1107public: 1108 1109 __operator_and_equal() {} 1110 __operator_and_equal(__node* op1, __node* op2) 1111 { 1112 __left_ = op1; 1113 __right_ = op2; 1114 } 1115 virtual size_t first_size() const 1116 { 1117 if (__cached_size_ == -1) 1118 { 1119 if (__left_) 1120 const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size(); 1121 else 1122 const_cast<long&>(__cached_size_) = sizeof("operator&=") - 1; 1123 } 1124 return __cached_size_; 1125 } 1126 virtual char* first_demangled_name(char* buf) const 1127 { 1128 if (__left_) 1129 { 1130 *buf++ = '('; 1131 buf = __left_->get_demangled_name(buf); 1132 strncpy(buf, ") &= (", 6); 1133 buf += 6; 1134 buf = __right_->get_demangled_name(buf); 1135 *buf++ = ')'; 1136 } 1137 else 1138 { 1139 strncpy(buf, "operator&=", sizeof("operator&=") - 1); 1140 buf += sizeof("operator&=") - 1; 1141 } 1142 return buf; 1143 } 1144 virtual ptrdiff_t print_first(char* f, char* l) const 1145 { 1146 const ptrdiff_t r = l - f; 1147 if (__left_) 1148 { 1149 const ptrdiff_t n1 = 8; 1150 if (r < n1) 1151 return n1 + __left_->print(l, l) + __right_->print(l, l); 1152 ptrdiff_t sz1 = __left_->print(f+1, l); 1153 if (r < n1 + sz1) 1154 return n1 + sz1 + __right_->print(l, l); 1155 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 1156 if (r >= n1 + sz1 + sz2) 1157 { 1158 *f = '('; 1159 f += 1 + sz1; 1160 *f++ = ')'; 1161 *f++ = ' '; 1162 *f++ = '&'; 1163 *f++ = '='; 1164 *f++ = ' '; 1165 *f = '('; 1166 f += 1 + sz2; 1167 *f = ')'; 1168 } 1169 return n1 + sz1 + sz2; 1170 } 1171 const ptrdiff_t n2 = sizeof("operator&=") - 1; 1172 if (r >= n2) 1173 { 1174 *f++ = 'o'; 1175 *f++ = 'p'; 1176 *f++ = 'e'; 1177 *f++ = 'r'; 1178 *f++ = 'a'; 1179 *f++ = 't'; 1180 *f++ = 'o'; 1181 *f++ = 'r'; 1182 *f++ = '&'; 1183 *f = '='; 1184 } 1185 return n2; 1186 } 1187 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1188 { 1189 bool r = true; 1190 if (__left_) 1191 r = r && __left_->fix_forward_references(t_begin, t_end); 1192 if (__right_) 1193 r = r && __right_->fix_forward_references(t_begin, t_end); 1194 return r; 1195 } 1196}; 1197 1198class __operator_equal 1199 : public __node 1200{ 1201public: 1202 1203 __operator_equal() {} 1204 __operator_equal(__node* op1, __node* op2) 1205 { 1206 __left_ = op1; 1207 __right_ = op2; 1208 } 1209 virtual size_t first_size() const 1210 { 1211 if (__cached_size_ == -1) 1212 { 1213 if (__left_) 1214 const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size(); 1215 else 1216 const_cast<long&>(__cached_size_) = sizeof("operator=") - 1; 1217 } 1218 return __cached_size_; 1219 } 1220 virtual char* first_demangled_name(char* buf) const 1221 { 1222 if (__left_) 1223 { 1224 *buf++ = '('; 1225 buf = __left_->get_demangled_name(buf); 1226 strncpy(buf, ") = (", 5); 1227 buf += 5; 1228 buf = __right_->get_demangled_name(buf); 1229 *buf++ = ')'; 1230 } 1231 else 1232 { 1233 strncpy(buf, "operator=", sizeof("operator=") - 1); 1234 buf += sizeof("operator=") - 1; 1235 } 1236 return buf; 1237 } 1238 virtual ptrdiff_t print_first(char* f, char* l) const 1239 { 1240 const ptrdiff_t r = l - f; 1241 if (__left_) 1242 { 1243 const ptrdiff_t n1 = 7; 1244 if (r < n1) 1245 return n1 + __left_->print(l, l) + __right_->print(l, l); 1246 ptrdiff_t sz1 = __left_->print(f+1, l); 1247 if (r < n1 + sz1) 1248 return n1 + sz1 + __right_->print(l, l); 1249 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 1250 if (r >= n1 + sz1 + sz2) 1251 { 1252 *f = '('; 1253 f += 1 + sz1; 1254 *f++ = ')'; 1255 *f++ = ' '; 1256 *f++ = '='; 1257 *f++ = ' '; 1258 *f = '('; 1259 f += 1 + sz2; 1260 *f = ')'; 1261 } 1262 return n1 + sz1 + sz2; 1263 } 1264 const ptrdiff_t n2 = sizeof("operator=") - 1; 1265 if (r >= n2) 1266 { 1267 *f++ = 'o'; 1268 *f++ = 'p'; 1269 *f++ = 'e'; 1270 *f++ = 'r'; 1271 *f++ = 'a'; 1272 *f++ = 't'; 1273 *f++ = 'o'; 1274 *f++ = 'r'; 1275 *f = '='; 1276 } 1277 return n2; 1278 } 1279 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1280 { 1281 bool r = true; 1282 if (__left_) 1283 r = r && __left_->fix_forward_references(t_begin, t_end); 1284 if (__right_) 1285 r = r && __right_->fix_forward_references(t_begin, t_end); 1286 return r; 1287 } 1288}; 1289 1290class __operator_alignof_type 1291 : public __node 1292{ 1293public: 1294 1295 __operator_alignof_type() {} 1296 __operator_alignof_type(__node* op) 1297 { 1298 __right_ = op; 1299 } 1300 virtual size_t first_size() const 1301 { 1302 if (__cached_size_ == -1) 1303 { 1304 if (__right_) 1305 const_cast<long&>(__cached_size_) = __right_->size() + 10; 1306 else 1307 const_cast<long&>(__cached_size_) = sizeof("operator alignof") - 1; 1308 } 1309 return __cached_size_; 1310 } 1311 virtual char* first_demangled_name(char* buf) const 1312 { 1313 if (__right_) 1314 { 1315 strncpy(buf, "alignof (", 9); 1316 buf += 9; 1317 buf = __right_->get_demangled_name(buf); 1318 *buf++ = ')'; 1319 } 1320 else 1321 { 1322 strncpy(buf, "operator alignof", sizeof("operator alignof") - 1); 1323 buf += sizeof("operator alignof") - 1; 1324 } 1325 return buf; 1326 } 1327 virtual ptrdiff_t print_first(char* f, char* l) const 1328 { 1329 const ptrdiff_t r = l - f; 1330 if (__right_) 1331 { 1332 const ptrdiff_t n1 = sizeof("alignof ()") - 1; 1333 if (r < n1) 1334 return n1 + __right_->print(l, l); 1335 ptrdiff_t sz1 = __right_->print(f+(n1-1), l); 1336 if (r >= n1 + sz1) 1337 { 1338 *f++ = 'a'; 1339 *f++ = 'l'; 1340 *f++ = 'i'; 1341 *f++ = 'g'; 1342 *f++ = 'n'; 1343 *f++ = 'o'; 1344 *f++ = 'f'; 1345 *f++ = ' '; 1346 *f = '('; 1347 f += 1 + sz1; 1348 *f = ')'; 1349 } 1350 return n1 + sz1; 1351 } 1352 const ptrdiff_t n2 = sizeof("operator alignof") - 1; 1353 if (r >= n2) 1354 { 1355 *f++ = 'o'; 1356 *f++ = 'p'; 1357 *f++ = 'e'; 1358 *f++ = 'r'; 1359 *f++ = 'a'; 1360 *f++ = 't'; 1361 *f++ = 'o'; 1362 *f++ = 'r'; 1363 *f++ = ' '; 1364 *f++ = 'a'; 1365 *f++ = 'l'; 1366 *f++ = 'i'; 1367 *f++ = 'g'; 1368 *f++ = 'n'; 1369 *f++ = 'o'; 1370 *f = 'f'; 1371 } 1372 return n2; 1373 } 1374 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1375 { 1376 if (__right_) 1377 return __right_->fix_forward_references(t_begin, t_end); 1378 return true; 1379 } 1380}; 1381 1382class __operator_alignof_expression 1383 : public __node 1384{ 1385public: 1386 1387 __operator_alignof_expression() {} 1388 __operator_alignof_expression(__node* op) 1389 { 1390 __right_ = op; 1391 } 1392 virtual size_t first_size() const 1393 { 1394 if (__cached_size_ == -1) 1395 { 1396 if (__right_) 1397 const_cast<long&>(__cached_size_) = __right_->size() + 10; 1398 else 1399 const_cast<long&>(__cached_size_) = sizeof("operator alignof") - 1; 1400 } 1401 return __cached_size_; 1402 } 1403 virtual char* first_demangled_name(char* buf) const 1404 { 1405 if (__right_) 1406 { 1407 strncpy(buf, "alignof (", 9); 1408 buf += 9; 1409 buf = __right_->get_demangled_name(buf); 1410 *buf++ = ')'; 1411 } 1412 else 1413 { 1414 strncpy(buf, "operator alignof", sizeof("operator alignof") - 1); 1415 buf += sizeof("operator alignof") - 1; 1416 } 1417 return buf; 1418 } 1419 virtual ptrdiff_t print_first(char* f, char* l) const 1420 { 1421 const ptrdiff_t r = l - f; 1422 if (__right_) 1423 { 1424 const ptrdiff_t n1 = sizeof("alignof ()") - 1; 1425 if (r < n1) 1426 return n1 + __right_->print(l, l); 1427 ptrdiff_t sz1 = __right_->print(f+(n1-1), l); 1428 if (r >= n1 + sz1) 1429 { 1430 *f++ = 'a'; 1431 *f++ = 'l'; 1432 *f++ = 'i'; 1433 *f++ = 'g'; 1434 *f++ = 'n'; 1435 *f++ = 'o'; 1436 *f++ = 'f'; 1437 *f++ = ' '; 1438 *f = '('; 1439 f += 1 + sz1; 1440 *f = ')'; 1441 } 1442 return n1 + sz1; 1443 } 1444 const ptrdiff_t n2 = sizeof("operator alignof") - 1; 1445 if (r >= n2) 1446 { 1447 *f++ = 'o'; 1448 *f++ = 'p'; 1449 *f++ = 'e'; 1450 *f++ = 'r'; 1451 *f++ = 'a'; 1452 *f++ = 't'; 1453 *f++ = 'o'; 1454 *f++ = 'r'; 1455 *f++ = ' '; 1456 *f++ = 'a'; 1457 *f++ = 'l'; 1458 *f++ = 'i'; 1459 *f++ = 'g'; 1460 *f++ = 'n'; 1461 *f++ = 'o'; 1462 *f = 'f'; 1463 } 1464 return n2; 1465 } 1466 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1467 { 1468 if (__right_) 1469 return __right_->fix_forward_references(t_begin, t_end); 1470 return true; 1471 } 1472}; 1473 1474class __operator_paren 1475 : public __node 1476{ 1477public: 1478 1479 virtual size_t first_size() const {return sizeof("operator()") - 1;} 1480 virtual char* first_demangled_name(char* buf) const 1481 { 1482 strncpy(buf, "operator()", sizeof("operator()") - 1); 1483 return buf + sizeof("operator()") - 1; 1484 } 1485 virtual ptrdiff_t print_first(char* f, char* l) const 1486 { 1487 const ptrdiff_t r = l - f; 1488 const ptrdiff_t n = sizeof("operator()") - 1; 1489 if (r >= n) 1490 { 1491 *f++ = 'o'; 1492 *f++ = 'p'; 1493 *f++ = 'e'; 1494 *f++ = 'r'; 1495 *f++ = 'a'; 1496 *f++ = 't'; 1497 *f++ = 'o'; 1498 *f++ = 'r'; 1499 *f++ = '('; 1500 *f = ')'; 1501 } 1502 return n; 1503 } 1504}; 1505 1506class __operator_comma 1507 : public __node 1508{ 1509public: 1510 1511 __operator_comma() {} 1512 __operator_comma(__node* op1, __node* op2) 1513 { 1514 __left_ = op1; 1515 __right_ = op2; 1516 } 1517 virtual size_t first_size() const 1518 { 1519 if (__cached_size_ == -1) 1520 { 1521 if (__left_) 1522 const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size(); 1523 else 1524 const_cast<long&>(__cached_size_) = sizeof("operator,") - 1; 1525 } 1526 return __cached_size_; 1527 } 1528 virtual char* first_demangled_name(char* buf) const 1529 { 1530 if (__left_) 1531 { 1532 *buf++ = '('; 1533 buf = __left_->get_demangled_name(buf); 1534 strncpy(buf, ") , (", 5); 1535 buf += 5; 1536 buf = __right_->get_demangled_name(buf); 1537 *buf++ = ')'; 1538 } 1539 else 1540 { 1541 strncpy(buf, "operator,", sizeof("operator,") - 1); 1542 buf += sizeof("operator,") - 1; 1543 } 1544 return buf; 1545 } 1546 virtual ptrdiff_t print_first(char* f, char* l) const 1547 { 1548 const ptrdiff_t r = l - f; 1549 if (__left_) 1550 { 1551 const ptrdiff_t n1 = 7; 1552 if (r < n1) 1553 return n1 + __left_->print(l, l) + __right_->print(l, l); 1554 ptrdiff_t sz1 = __left_->print(f+1, l); 1555 if (r < n1 + sz1) 1556 return n1 + sz1 + __right_->print(l, l); 1557 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 1558 if (r >= n1 + sz1 + sz2) 1559 { 1560 *f = '('; 1561 f += 1 + sz1; 1562 *f++ = ')'; 1563 *f++ = ' '; 1564 *f++ = ','; 1565 *f++ = ' '; 1566 *f = '('; 1567 f += 1 + sz2; 1568 *f = ')'; 1569 } 1570 return n1 + sz1 + sz2; 1571 } 1572 const ptrdiff_t n2 = sizeof("operator,") - 1; 1573 if (r >= n2) 1574 { 1575 *f++ = 'o'; 1576 *f++ = 'p'; 1577 *f++ = 'e'; 1578 *f++ = 'r'; 1579 *f++ = 'a'; 1580 *f++ = 't'; 1581 *f++ = 'o'; 1582 *f++ = 'r'; 1583 *f = ','; 1584 } 1585 return n2; 1586 } 1587 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1588 { 1589 bool r = true; 1590 if (__left_) 1591 r = r && __left_->fix_forward_references(t_begin, t_end); 1592 if (__right_) 1593 r = r && __right_->fix_forward_references(t_begin, t_end); 1594 return r; 1595 } 1596}; 1597 1598class __operator_tilda 1599 : public __node 1600{ 1601public: 1602 1603 __operator_tilda() {} 1604 explicit __operator_tilda(__node* op) 1605 { 1606 __left_ = op; 1607 } 1608 virtual size_t first_size() const 1609 { 1610 if (__cached_size_ == -1) 1611 { 1612 if (__left_) 1613 const_cast<long&>(__cached_size_) = 3+__left_->size(); 1614 else 1615 const_cast<long&>(__cached_size_) = sizeof("operator~") - 1; 1616 } 1617 return __cached_size_; 1618 } 1619 virtual char* first_demangled_name(char* buf) const 1620 { 1621 if (__left_) 1622 { 1623 *buf++ = '~'; 1624 *buf++ = '('; 1625 buf = __left_->get_demangled_name(buf); 1626 *buf++ = ')'; 1627 } 1628 else 1629 { 1630 strncpy(buf, "operator~", sizeof("operator~") - 1); 1631 buf += sizeof("operator~") - 1; 1632 } 1633 return buf; 1634 } 1635 virtual ptrdiff_t print_first(char* f, char* l) const 1636 { 1637 const ptrdiff_t r = l - f; 1638 if (__left_) 1639 { 1640 const ptrdiff_t n1 = 3; 1641 if (r < n1) 1642 return n1 + __left_->print(l, l); 1643 ptrdiff_t sz1 = __left_->print(f+2, l); 1644 if (r >= n1 + sz1) 1645 { 1646 *f++ = '~'; 1647 *f = '('; 1648 f += 1 + sz1; 1649 *f = ')'; 1650 } 1651 return n1 + sz1; 1652 } 1653 const ptrdiff_t n2 = sizeof("operator~") - 1; 1654 if (r >= n2) 1655 { 1656 *f++ = 'o'; 1657 *f++ = 'p'; 1658 *f++ = 'e'; 1659 *f++ = 'r'; 1660 *f++ = 'a'; 1661 *f++ = 't'; 1662 *f++ = 'o'; 1663 *f++ = 'r'; 1664 *f = '~'; 1665 } 1666 return n2; 1667 } 1668 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1669 { 1670 if (__left_) 1671 return __left_->fix_forward_references(t_begin, t_end); 1672 return true; 1673 } 1674}; 1675 1676class __operator_cast 1677 : public __node 1678{ 1679 static const size_t n = sizeof("operator ") - 1; 1680public: 1681 1682 explicit __operator_cast(__node* type) 1683 { 1684 __right_ = type; 1685 } 1686 __operator_cast(__node* type, __node* arg) 1687 { 1688 __size_ = 1; 1689 __right_ = type; 1690 __left_ = arg; 1691 } 1692 virtual size_t first_size() const 1693 { 1694 if (__cached_size_ == -1) 1695 { 1696 size_t off; 1697 if (__size_) 1698 { 1699 off = 4; 1700 off += __right_->size(); 1701 if (__left_) 1702 off += __left_->size(); 1703 } 1704 else 1705 off = n + __right_->size();; 1706 const_cast<long&>(__cached_size_) = off; 1707 } 1708 return __cached_size_; 1709 } 1710 virtual char* first_demangled_name(char* buf) const 1711 { 1712 if (__size_) 1713 { 1714 *buf++ = '('; 1715 buf = __right_->get_demangled_name(buf); 1716 *buf++ = ')'; 1717 *buf++ = '('; 1718 if (__left_) 1719 buf = __left_->get_demangled_name(buf); 1720 *buf++ = ')'; 1721 } 1722 else 1723 { 1724 strncpy(buf, "operator ", n); 1725 buf = __right_->get_demangled_name(buf+n); 1726 } 1727 return buf; 1728 } 1729 virtual ptrdiff_t print_first(char* f, char* l) const 1730 { 1731 const ptrdiff_t r = l - f; 1732 if (__size_) 1733 { 1734 const ptrdiff_t n1 = 4; 1735 if (r < n1) 1736 return n1 + __right_->print(l, l) + 1737 (__left_ ? __left_->print(l, l) : 0); 1738 ptrdiff_t sz1 = __right_->print(f+1, l); 1739 if (r < n1 + sz1) 1740 return n1 + sz1 + (__left_ ? __left_->print(l, l) : 0); 1741 ptrdiff_t sz2 = __left_ ? __left_->print(f+3+sz1, l) : 0; 1742 if (r >= n1 + sz1 + sz2) 1743 { 1744 *f = '('; 1745 f += 1 + sz1; 1746 *f++ = ')'; 1747 *f = '('; 1748 f += 1 + sz2; 1749 *f = ')'; 1750 } 1751 return n1 + sz1 + sz2; 1752 } 1753 const ptrdiff_t n2 = sizeof("operator ") - 1; 1754 if (r < n2) 1755 return n2 + __right_->print(l, l); 1756 ptrdiff_t sz1 = __right_->print(f+n2, l); 1757 if (r >= n2 + sz1) 1758 { 1759 *f++ = 'o'; 1760 *f++ = 'p'; 1761 *f++ = 'e'; 1762 *f++ = 'r'; 1763 *f++ = 'a'; 1764 *f++ = 't'; 1765 *f++ = 'o'; 1766 *f++ = 'r'; 1767 *f = ' '; 1768 } 1769 return n2 + sz1; 1770 } 1771 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1772 { 1773 bool r = true; 1774 if (__left_) 1775 r = r && __left_->fix_forward_references(t_begin, t_end); 1776 r = r && __right_->fix_forward_references(t_begin, t_end); 1777 return r; 1778 } 1779 virtual bool is_ctor_dtor_conv() const 1780 { 1781 return true; 1782 } 1783}; 1784 1785class __cast_literal 1786 : public __node 1787{ 1788public: 1789 1790 __cast_literal(__node* type, const char* f, const char* l) 1791 { 1792 __left_ = type; 1793 __name_ = f; 1794 __size_ = l - f; 1795 } 1796 virtual size_t first_size() const 1797 { 1798 if (__cached_size_ == -1) 1799 const_cast<long&>(__cached_size_) = 2 + __left_->size() + __size_; 1800 return __cached_size_; 1801 } 1802 virtual char* first_demangled_name(char* buf) const 1803 { 1804 *buf++ = '('; 1805 buf = __left_->get_demangled_name(buf); 1806 *buf++ = ')'; 1807 strncpy(buf, __name_, __size_); 1808 return buf + __size_; 1809 } 1810 virtual ptrdiff_t print_first(char* f, char* l) const 1811 { 1812 const ptrdiff_t r = l - f; 1813 const ptrdiff_t n = 2; 1814 if (r < __size_ + n) 1815 return __size_ + n + __left_->print(l, l); 1816 ptrdiff_t sz = __left_->print(f+1, l); 1817 if (r >= __size_ + n + sz) 1818 { 1819 *f = '('; 1820 f += 1 + sz; 1821 *f++ = ')'; 1822 strncpy(f, __name_, __size_); 1823 } 1824 return __size_ + n + sz; 1825 } 1826 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1827 { 1828 return __left_->fix_forward_references(t_begin, t_end); 1829 } 1830}; 1831 1832class __operator_dereference 1833 : public __node 1834{ 1835public: 1836 1837 __operator_dereference() {} 1838 explicit __operator_dereference(__node* op) 1839 { 1840 __left_ = op; 1841 } 1842 virtual size_t first_size() const 1843 { 1844 if (__cached_size_ == -1) 1845 { 1846 if (__left_) 1847 const_cast<long&>(__cached_size_) = 3+__left_->size(); 1848 else 1849 const_cast<long&>(__cached_size_) = sizeof("operator*") - 1; 1850 } 1851 return __cached_size_; 1852 } 1853 virtual char* first_demangled_name(char* buf) const 1854 { 1855 if (__left_) 1856 { 1857 *buf++ = '*'; 1858 *buf++ = '('; 1859 buf = __left_->get_demangled_name(buf); 1860 *buf++ = ')'; 1861 } 1862 else 1863 { 1864 strncpy(buf, "operator*", sizeof("operator*") - 1); 1865 buf += sizeof("operator*") - 1; 1866 } 1867 return buf; 1868 } 1869 virtual ptrdiff_t print_first(char* f, char* l) const 1870 { 1871 const ptrdiff_t r = l - f; 1872 if (__left_) 1873 { 1874 const ptrdiff_t n1 = 3; 1875 if (r < n1) 1876 return n1 + __left_->print(l, l); 1877 ptrdiff_t sz1 = __left_->print(f+2, l); 1878 if (r >= n1 + sz1) 1879 { 1880 *f++ = '*'; 1881 *f = '('; 1882 f += 1 + sz1; 1883 *f = ')'; 1884 } 1885 return n1 + sz1; 1886 } 1887 const ptrdiff_t n2 = sizeof("operator*") - 1; 1888 if (r >= n2) 1889 { 1890 *f++ = 'o'; 1891 *f++ = 'p'; 1892 *f++ = 'e'; 1893 *f++ = 'r'; 1894 *f++ = 'a'; 1895 *f++ = 't'; 1896 *f++ = 'o'; 1897 *f++ = 'r'; 1898 *f = '*'; 1899 } 1900 return n2; 1901 } 1902 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1903 { 1904 if (__left_) 1905 return __left_->fix_forward_references(t_begin, t_end); 1906 return true; 1907 } 1908}; 1909 1910class __operator_divide 1911 : public __node 1912{ 1913public: 1914 1915 __operator_divide() {} 1916 __operator_divide(__node* op1, __node* op2) 1917 { 1918 __left_ = op1; 1919 __right_ = op2; 1920 } 1921 virtual size_t first_size() const 1922 { 1923 if (__cached_size_ == -1) 1924 { 1925 if (__left_) 1926 const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size(); 1927 else 1928 const_cast<long&>(__cached_size_) = sizeof("operator/") - 1; 1929 } 1930 return __cached_size_; 1931 } 1932 virtual char* first_demangled_name(char* buf) const 1933 { 1934 if (__left_) 1935 { 1936 *buf++ = '('; 1937 buf = __left_->get_demangled_name(buf); 1938 strncpy(buf, ") / (", 5); 1939 buf += 5; 1940 buf = __right_->get_demangled_name(buf); 1941 *buf++ = ')'; 1942 } 1943 else 1944 { 1945 strncpy(buf, "operator/", sizeof("operator/") - 1); 1946 buf += sizeof("operator/") - 1; 1947 } 1948 return buf; 1949 } 1950 virtual ptrdiff_t print_first(char* f, char* l) const 1951 { 1952 const ptrdiff_t r = l - f; 1953 if (__left_) 1954 { 1955 const ptrdiff_t n1 = 7; 1956 if (r < n1) 1957 return n1 + __left_->print(l, l) + __right_->print(l, l); 1958 ptrdiff_t sz1 = __left_->print(f+1, l); 1959 if (r < n1 + sz1) 1960 return n1 + sz1 + __right_->print(l, l); 1961 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 1962 if (r >= n1 + sz1 + sz2) 1963 { 1964 *f = '('; 1965 f += 1 + sz1; 1966 *f++ = ')'; 1967 *f++ = ' '; 1968 *f++ = '/'; 1969 *f++ = ' '; 1970 *f = '('; 1971 f += 1 + sz2; 1972 *f = ')'; 1973 } 1974 return n1 + sz1 + sz2; 1975 } 1976 const ptrdiff_t n2 = sizeof("operator/") - 1; 1977 if (r >= n2) 1978 { 1979 *f++ = 'o'; 1980 *f++ = 'p'; 1981 *f++ = 'e'; 1982 *f++ = 'r'; 1983 *f++ = 'a'; 1984 *f++ = 't'; 1985 *f++ = 'o'; 1986 *f++ = 'r'; 1987 *f = '/'; 1988 } 1989 return n2; 1990 } 1991 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 1992 { 1993 bool r = true; 1994 if (__left_) 1995 r = r && __left_->fix_forward_references(t_begin, t_end); 1996 if (__right_) 1997 r = r && __right_->fix_forward_references(t_begin, t_end); 1998 return r; 1999 } 2000}; 2001 2002class __operator_divide_equal 2003 : public __node 2004{ 2005public: 2006 2007 __operator_divide_equal() {} 2008 __operator_divide_equal(__node* op1, __node* op2) 2009 { 2010 __left_ = op1; 2011 __right_ = op2; 2012 } 2013 virtual size_t first_size() const 2014 { 2015 if (__cached_size_ == -1) 2016 { 2017 if (__left_) 2018 const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size(); 2019 else 2020 const_cast<long&>(__cached_size_) = sizeof("operator/=") - 1; 2021 } 2022 return __cached_size_; 2023 } 2024 virtual char* first_demangled_name(char* buf) const 2025 { 2026 if (__left_) 2027 { 2028 *buf++ = '('; 2029 buf = __left_->get_demangled_name(buf); 2030 strncpy(buf, ") /= (", 6); 2031 buf += 6; 2032 buf = __right_->get_demangled_name(buf); 2033 *buf++ = ')'; 2034 } 2035 else 2036 { 2037 strncpy(buf, "operator/=", sizeof("operator/=") - 1); 2038 buf += sizeof("operator/=") - 1; 2039 } 2040 return buf; 2041 } 2042 virtual ptrdiff_t print_first(char* f, char* l) const 2043 { 2044 const ptrdiff_t r = l - f; 2045 if (__left_) 2046 { 2047 const ptrdiff_t n1 = 8; 2048 if (r < n1) 2049 return n1 + __left_->print(l, l) + __right_->print(l, l); 2050 ptrdiff_t sz1 = __left_->print(f+1, l); 2051 if (r < n1 + sz1) 2052 return n1 + sz1 + __right_->print(l, l); 2053 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 2054 if (r >= n1 + sz1 + sz2) 2055 { 2056 *f = '('; 2057 f += 1 + sz1; 2058 *f++ = ')'; 2059 *f++ = ' '; 2060 *f++ = '/'; 2061 *f++ = '='; 2062 *f++ = ' '; 2063 *f = '('; 2064 f += 1 + sz2; 2065 *f = ')'; 2066 } 2067 return n1 + sz1 + sz2; 2068 } 2069 const ptrdiff_t n2 = sizeof("operator/=") - 1; 2070 if (r >= n2) 2071 { 2072 *f++ = 'o'; 2073 *f++ = 'p'; 2074 *f++ = 'e'; 2075 *f++ = 'r'; 2076 *f++ = 'a'; 2077 *f++ = 't'; 2078 *f++ = 'o'; 2079 *f++ = 'r'; 2080 *f++ = '/'; 2081 *f = '='; 2082 } 2083 return n2; 2084 } 2085 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2086 { 2087 bool r = true; 2088 if (__left_) 2089 r = r && __left_->fix_forward_references(t_begin, t_end); 2090 if (__right_) 2091 r = r && __right_->fix_forward_references(t_begin, t_end); 2092 return r; 2093 } 2094}; 2095 2096class __operator_xor 2097 : public __node 2098{ 2099public: 2100 2101 __operator_xor() {} 2102 __operator_xor(__node* op1, __node* op2) 2103 { 2104 __left_ = op1; 2105 __right_ = op2; 2106 } 2107 virtual size_t first_size() const 2108 { 2109 if (__cached_size_ == -1) 2110 { 2111 if (__left_) 2112 const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size(); 2113 else 2114 const_cast<long&>(__cached_size_) = sizeof("operator^") - 1; 2115 } 2116 return __cached_size_; 2117 } 2118 virtual char* first_demangled_name(char* buf) const 2119 { 2120 if (__left_) 2121 { 2122 *buf++ = '('; 2123 buf = __left_->get_demangled_name(buf); 2124 strncpy(buf, ") ^ (", 5); 2125 buf += 5; 2126 buf = __right_->get_demangled_name(buf); 2127 *buf++ = ')'; 2128 } 2129 else 2130 { 2131 strncpy(buf, "operator^", sizeof("operator^") - 1); 2132 buf += sizeof("operator^") - 1; 2133 } 2134 return buf; 2135 } 2136 virtual ptrdiff_t print_first(char* f, char* l) const 2137 { 2138 const ptrdiff_t r = l - f; 2139 if (__left_) 2140 { 2141 const ptrdiff_t n1 = 7; 2142 if (r < n1) 2143 return n1 + __left_->print(l, l) + __right_->print(l, l); 2144 ptrdiff_t sz1 = __left_->print(f+1, l); 2145 if (r < n1 + sz1) 2146 return n1 + sz1 + __right_->print(l, l); 2147 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 2148 if (r >= n1 + sz1 + sz2) 2149 { 2150 *f = '('; 2151 f += 1 + sz1; 2152 *f++ = ')'; 2153 *f++ = ' '; 2154 *f++ = '^'; 2155 *f++ = ' '; 2156 *f = '('; 2157 f += 1 + sz2; 2158 *f = ')'; 2159 } 2160 return n1 + sz1 + sz2; 2161 } 2162 const ptrdiff_t n2 = sizeof("operator^") - 1; 2163 if (r >= n2) 2164 { 2165 *f++ = 'o'; 2166 *f++ = 'p'; 2167 *f++ = 'e'; 2168 *f++ = 'r'; 2169 *f++ = 'a'; 2170 *f++ = 't'; 2171 *f++ = 'o'; 2172 *f++ = 'r'; 2173 *f = '^'; 2174 } 2175 return n2; 2176 } 2177 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2178 { 2179 bool r = true; 2180 if (__left_) 2181 r = r && __left_->fix_forward_references(t_begin, t_end); 2182 if (__right_) 2183 r = r && __right_->fix_forward_references(t_begin, t_end); 2184 return r; 2185 } 2186}; 2187 2188class __operator_xor_equal 2189 : public __node 2190{ 2191public: 2192 2193 __operator_xor_equal() {} 2194 __operator_xor_equal(__node* op1, __node* op2) 2195 { 2196 __left_ = op1; 2197 __right_ = op2; 2198 } 2199 virtual size_t first_size() const 2200 { 2201 if (__cached_size_ == -1) 2202 { 2203 if (__left_) 2204 const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size(); 2205 else 2206 const_cast<long&>(__cached_size_) = sizeof("operator^=") - 1; 2207 } 2208 return __cached_size_; 2209 } 2210 virtual char* first_demangled_name(char* buf) const 2211 { 2212 if (__left_) 2213 { 2214 *buf++ = '('; // strncpy(buf, "(", 1); 2215 buf = __left_->get_demangled_name(buf); 2216 strncpy(buf, ") ^= (", 6); 2217 buf += 6; 2218 buf = __right_->get_demangled_name(buf); 2219 *buf++ = ')'; 2220 } 2221 else 2222 { 2223 strncpy(buf, "operator^=", sizeof("operator^=") - 1); 2224 buf += sizeof("operator^=") - 1; 2225 } 2226 return buf; 2227 } 2228 virtual ptrdiff_t print_first(char* f, char* l) const 2229 { 2230 const ptrdiff_t r = l - f; 2231 if (__left_) 2232 { 2233 const ptrdiff_t n1 = 8; 2234 if (r < n1) 2235 return n1 + __left_->print(l, l) + __right_->print(l, l); 2236 ptrdiff_t sz1 = __left_->print(f+1, l); 2237 if (r < n1 + sz1) 2238 return n1 + sz1 + __right_->print(l, l); 2239 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 2240 if (r >= n1 + sz1 + sz2) 2241 { 2242 *f = '('; 2243 f += 1 + sz1; 2244 *f++ = ')'; 2245 *f++ = ' '; 2246 *f++ = '^'; 2247 *f++ = '='; 2248 *f++ = ' '; 2249 *f = '('; 2250 f += 1 + sz2; 2251 *f = ')'; 2252 } 2253 return n1 + sz1 + sz2; 2254 } 2255 const ptrdiff_t n2 = sizeof("operator^=") - 1; 2256 if (r >= n2) 2257 { 2258 *f++ = 'o'; 2259 *f++ = 'p'; 2260 *f++ = 'e'; 2261 *f++ = 'r'; 2262 *f++ = 'a'; 2263 *f++ = 't'; 2264 *f++ = 'o'; 2265 *f++ = 'r'; 2266 *f++ = '^'; 2267 *f = '='; 2268 } 2269 return n2; 2270 } 2271 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2272 { 2273 bool r = true; 2274 if (__left_) 2275 r = r && __left_->fix_forward_references(t_begin, t_end); 2276 if (__right_) 2277 r = r && __right_->fix_forward_references(t_begin, t_end); 2278 return r; 2279 } 2280}; 2281 2282class __operator_equality 2283 : public __node 2284{ 2285public: 2286 2287 __operator_equality() {} 2288 __operator_equality(__node* op1, __node* op2) 2289 { 2290 __left_ = op1; 2291 __right_ = op2; 2292 } 2293 virtual size_t first_size() const 2294 { 2295 if (__cached_size_ == -1) 2296 { 2297 if (__left_) 2298 const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size(); 2299 else 2300 const_cast<long&>(__cached_size_) = sizeof("operator==") - 1; 2301 } 2302 return __cached_size_; 2303 } 2304 virtual char* first_demangled_name(char* buf) const 2305 { 2306 if (__left_) 2307 { 2308 *buf++ = '('; 2309 buf = __left_->get_demangled_name(buf); 2310 strncpy(buf, ") == (", 6); 2311 buf += 6; 2312 buf = __right_->get_demangled_name(buf); 2313 *buf++ = ')'; 2314 } 2315 else 2316 { 2317 strncpy(buf, "operator==", sizeof("operator==") - 1); 2318 buf += sizeof("operator==") - 1; 2319 } 2320 return buf; 2321 } 2322 virtual ptrdiff_t print_first(char* f, char* l) const 2323 { 2324 const ptrdiff_t r = l - f; 2325 if (__left_) 2326 { 2327 const ptrdiff_t n1 = 8; 2328 if (r < n1) 2329 return n1 + __left_->print(l, l) + __right_->print(l, l); 2330 ptrdiff_t sz1 = __left_->print(f+1, l); 2331 if (r < n1 + sz1) 2332 return n1 + sz1 + __right_->print(l, l); 2333 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 2334 if (r >= n1 + sz1 + sz2) 2335 { 2336 *f = '('; 2337 f += 1 + sz1; 2338 *f++ = ')'; 2339 *f++ = ' '; 2340 *f++ = '='; 2341 *f++ = '='; 2342 *f++ = ' '; 2343 *f = '('; 2344 f += 1 + sz2; 2345 *f = ')'; 2346 } 2347 return n1 + sz1 + sz2; 2348 } 2349 const ptrdiff_t n2 = sizeof("operator==") - 1; 2350 if (r >= n2) 2351 { 2352 *f++ = 'o'; 2353 *f++ = 'p'; 2354 *f++ = 'e'; 2355 *f++ = 'r'; 2356 *f++ = 'a'; 2357 *f++ = 't'; 2358 *f++ = 'o'; 2359 *f++ = 'r'; 2360 *f++ = '='; 2361 *f = '='; 2362 } 2363 return n2; 2364 } 2365 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2366 { 2367 bool r = true; 2368 if (__left_) 2369 r = r && __left_->fix_forward_references(t_begin, t_end); 2370 if (__right_) 2371 r = r && __right_->fix_forward_references(t_begin, t_end); 2372 return r; 2373 } 2374}; 2375 2376class __operator_greater_equal 2377 : public __node 2378{ 2379public: 2380 2381 __operator_greater_equal() {} 2382 __operator_greater_equal(__node* op1, __node* op2) 2383 { 2384 __left_ = op1; 2385 __right_ = op2; 2386 } 2387 virtual size_t first_size() const 2388 { 2389 if (__cached_size_ == -1) 2390 { 2391 if (__left_) 2392 const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size(); 2393 else 2394 const_cast<long&>(__cached_size_) = sizeof("operator>=") - 1; 2395 } 2396 return __cached_size_; 2397 } 2398 virtual char* first_demangled_name(char* buf) const 2399 { 2400 if (__left_) 2401 { 2402 *buf++ = '('; 2403 buf = __left_->get_demangled_name(buf); 2404 strncpy(buf, ") >= (", 6); 2405 buf += 6; 2406 buf = __right_->get_demangled_name(buf); 2407 *buf++ = ')'; 2408 } 2409 else 2410 { 2411 strncpy(buf, "operator>=", sizeof("operator>=") - 1); 2412 buf += sizeof("operator>=") - 1; 2413 } 2414 return buf; 2415 } 2416 virtual ptrdiff_t print_first(char* f, char* l) const 2417 { 2418 const ptrdiff_t r = l - f; 2419 if (__left_) 2420 { 2421 const ptrdiff_t n1 = 8; 2422 if (r < n1) 2423 return n1 + __left_->print(l, l) + __right_->print(l, l); 2424 ptrdiff_t sz1 = __left_->print(f+1, l); 2425 if (r < n1 + sz1) 2426 return n1 + sz1 + __right_->print(l, l); 2427 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 2428 if (r >= n1 + sz1 + sz2) 2429 { 2430 *f = '('; 2431 f += 1 + sz1; 2432 *f++ = ')'; 2433 *f++ = ' '; 2434 *f++ = '>'; 2435 *f++ = '='; 2436 *f++ = ' '; 2437 *f = '('; 2438 f += 1 + sz2; 2439 *f = ')'; 2440 } 2441 return n1 + sz1 + sz2; 2442 } 2443 const ptrdiff_t n2 = sizeof("operator>=") - 1; 2444 if (r >= n2) 2445 { 2446 *f++ = 'o'; 2447 *f++ = 'p'; 2448 *f++ = 'e'; 2449 *f++ = 'r'; 2450 *f++ = 'a'; 2451 *f++ = 't'; 2452 *f++ = 'o'; 2453 *f++ = 'r'; 2454 *f++ = '>'; 2455 *f = '='; 2456 } 2457 return n2; 2458 } 2459 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2460 { 2461 bool r = true; 2462 if (__left_) 2463 r = r && __left_->fix_forward_references(t_begin, t_end); 2464 if (__right_) 2465 r = r && __right_->fix_forward_references(t_begin, t_end); 2466 return r; 2467 } 2468}; 2469 2470class __operator_greater 2471 : public __node 2472{ 2473public: 2474 2475 __operator_greater() {} 2476 __operator_greater(__node* op1, __node* op2) 2477 { 2478 __left_ = op1; 2479 __right_ = op2; 2480 } 2481 virtual size_t first_size() const 2482 { 2483 if (__cached_size_ == -1) 2484 { 2485 if (__left_) 2486 const_cast<long&>(__cached_size_) = __left_->size() + 9 + __right_->size(); 2487 else 2488 const_cast<long&>(__cached_size_) = sizeof("operator>") - 1; 2489 } 2490 return __cached_size_; 2491 } 2492 virtual char* first_demangled_name(char* buf) const 2493 { 2494 if (__left_) 2495 { 2496 *buf++ = '('; 2497 *buf++ = '('; 2498 buf = __left_->get_demangled_name(buf); 2499 strncpy(buf, ") > (", 5); 2500 buf += 5; 2501 buf = __right_->get_demangled_name(buf); 2502 *buf++ = ')'; 2503 *buf++ = ')'; 2504 } 2505 else 2506 { 2507 strncpy(buf, "operator>", sizeof("operator>") - 1); 2508 buf += sizeof("operator>") - 1; 2509 } 2510 return buf; 2511 } 2512 virtual ptrdiff_t print_first(char* f, char* l) const 2513 { 2514 const ptrdiff_t r = l - f; 2515 if (__left_) 2516 { 2517 const ptrdiff_t n1 = 9; 2518 if (r < n1) 2519 return n1 + __left_->print(l, l) + __right_->print(l, l); 2520 ptrdiff_t sz1 = __left_->print(f+2, l); 2521 if (r < n1 + sz1) 2522 return n1 + sz1 + __right_->print(l, l); 2523 ptrdiff_t sz2 = __right_->print(f+(n1-2)+sz1, l); 2524 if (r >= n1 + sz1 + sz2) 2525 { 2526 *f++ = '('; 2527 *f = '('; 2528 f += 1 + sz1; 2529 *f++ = ')'; 2530 *f++ = ' '; 2531 *f++ = '>'; 2532 *f++ = ' '; 2533 *f = '('; 2534 f += 1 + sz2; 2535 *f++ = ')'; 2536 *f = ')'; 2537 } 2538 return n1 + sz1 + sz2; 2539 } 2540 const ptrdiff_t n2 = sizeof("operator>") - 1; 2541 if (r >= n2) 2542 { 2543 *f++ = 'o'; 2544 *f++ = 'p'; 2545 *f++ = 'e'; 2546 *f++ = 'r'; 2547 *f++ = 'a'; 2548 *f++ = 't'; 2549 *f++ = 'o'; 2550 *f++ = 'r'; 2551 *f = '>'; 2552 } 2553 return n2; 2554 } 2555 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2556 { 2557 bool r = true; 2558 if (__left_) 2559 r = r && __left_->fix_forward_references(t_begin, t_end); 2560 if (__right_) 2561 r = r && __right_->fix_forward_references(t_begin, t_end); 2562 return r; 2563 } 2564}; 2565 2566class __operator_brackets 2567 : public __node 2568{ 2569public: 2570 2571 virtual size_t first_size() const {return sizeof("operator[]") - 1;} 2572 virtual char* first_demangled_name(char* buf) const 2573 { 2574 strncpy(buf, "operator[]", sizeof("operator[]") - 1); 2575 return buf + sizeof("operator[]") - 1; 2576 } 2577 virtual ptrdiff_t print_first(char* f, char* l) const 2578 { 2579 const ptrdiff_t r = l - f; 2580 const ptrdiff_t n = sizeof("operator[]") - 1; 2581 if (r >= n) 2582 { 2583 *f++ = 'o'; 2584 *f++ = 'p'; 2585 *f++ = 'e'; 2586 *f++ = 'r'; 2587 *f++ = 'a'; 2588 *f++ = 't'; 2589 *f++ = 'o'; 2590 *f++ = 'r'; 2591 *f++ = '['; 2592 *f = ']'; 2593 } 2594 return n; 2595 } 2596}; 2597 2598class __operator_less_equal 2599 : public __node 2600{ 2601public: 2602 2603 __operator_less_equal() {} 2604 __operator_less_equal(__node* op1, __node* op2) 2605 { 2606 __left_ = op1; 2607 __right_ = op2; 2608 } 2609 virtual size_t first_size() const 2610 { 2611 if (__cached_size_ == -1) 2612 { 2613 if (__left_) 2614 const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size(); 2615 else 2616 const_cast<long&>(__cached_size_) = sizeof("operator<=") - 1; 2617 } 2618 return __cached_size_; 2619 } 2620 virtual char* first_demangled_name(char* buf) const 2621 { 2622 if (__left_) 2623 { 2624 *buf++ = '('; 2625 buf = __left_->get_demangled_name(buf); 2626 strncpy(buf, ") <= (", 6); 2627 buf += 6; 2628 buf = __right_->get_demangled_name(buf); 2629 *buf++ = ')'; 2630 } 2631 else 2632 { 2633 strncpy(buf, "operator<=", sizeof("operator<=") - 1); 2634 buf += sizeof("operator<=") - 1; 2635 } 2636 return buf; 2637 } 2638 virtual ptrdiff_t print_first(char* f, char* l) const 2639 { 2640 const ptrdiff_t r = l - f; 2641 if (__left_) 2642 { 2643 const ptrdiff_t n1 = 8; 2644 if (r < n1) 2645 return n1 + __left_->print(l, l) + __right_->print(l, l); 2646 ptrdiff_t sz1 = __left_->print(f+1, l); 2647 if (r < n1 + sz1) 2648 return n1 + sz1 + __right_->print(l, l); 2649 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 2650 if (r >= n1 + sz1 + sz2) 2651 { 2652 *f = '('; 2653 f += 1 + sz1; 2654 *f++ = ')'; 2655 *f++ = ' '; 2656 *f++ = '<'; 2657 *f++ = '='; 2658 *f++ = ' '; 2659 *f = '('; 2660 f += 1 + sz2; 2661 *f = ')'; 2662 } 2663 return n1 + sz1 + sz2; 2664 } 2665 const ptrdiff_t n2 = sizeof("operator<=") - 1; 2666 if (r >= n2) 2667 { 2668 *f++ = 'o'; 2669 *f++ = 'p'; 2670 *f++ = 'e'; 2671 *f++ = 'r'; 2672 *f++ = 'a'; 2673 *f++ = 't'; 2674 *f++ = 'o'; 2675 *f++ = 'r'; 2676 *f++ = '<'; 2677 *f = '='; 2678 } 2679 return n2; 2680 } 2681 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2682 { 2683 bool r = true; 2684 if (__left_) 2685 r = r && __left_->fix_forward_references(t_begin, t_end); 2686 if (__right_) 2687 r = r && __right_->fix_forward_references(t_begin, t_end); 2688 return r; 2689 } 2690}; 2691 2692class __operator_less 2693 : public __node 2694{ 2695public: 2696 2697 __operator_less() {} 2698 __operator_less(__node* op1, __node* op2) 2699 { 2700 __left_ = op1; 2701 __right_ = op2; 2702 } 2703 virtual size_t first_size() const 2704 { 2705 if (__cached_size_ == -1) 2706 { 2707 if (__left_) 2708 const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size(); 2709 else 2710 const_cast<long&>(__cached_size_) = sizeof("operator<") - 1; 2711 } 2712 return __cached_size_; 2713 } 2714 virtual char* first_demangled_name(char* buf) const 2715 { 2716 if (__left_) 2717 { 2718 *buf++ = '('; 2719 buf = __left_->get_demangled_name(buf); 2720 strncpy(buf, ") < (", 5); 2721 buf += 5; 2722 buf = __right_->get_demangled_name(buf); 2723 *buf++ = ')'; 2724 } 2725 else 2726 { 2727 strncpy(buf, "operator<", sizeof("operator<") - 1); 2728 buf += sizeof("operator<") - 1; 2729 } 2730 return buf; 2731 } 2732 virtual ptrdiff_t print_first(char* f, char* l) const 2733 { 2734 const ptrdiff_t r = l - f; 2735 if (__left_) 2736 { 2737 const ptrdiff_t n1 = 7; 2738 if (r < n1) 2739 return n1 + __left_->print(l, l) + __right_->print(l, l); 2740 ptrdiff_t sz1 = __left_->print(f+1, l); 2741 if (r < n1 + sz1) 2742 return n1 + sz1 + __right_->print(l, l); 2743 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 2744 if (r >= n1 + sz1 + sz2) 2745 { 2746 *f = '('; 2747 f += 1 + sz1; 2748 *f++ = ')'; 2749 *f++ = ' '; 2750 *f++ = '<'; 2751 *f++ = ' '; 2752 *f = '('; 2753 f += 1 + sz2; 2754 *f = ')'; 2755 } 2756 return n1 + sz1 + sz2; 2757 } 2758 const ptrdiff_t n2 = sizeof("operator<") - 1; 2759 if (r >= n2) 2760 { 2761 *f++ = 'o'; 2762 *f++ = 'p'; 2763 *f++ = 'e'; 2764 *f++ = 'r'; 2765 *f++ = 'a'; 2766 *f++ = 't'; 2767 *f++ = 'o'; 2768 *f++ = 'r'; 2769 *f = '<'; 2770 } 2771 return n2; 2772 } 2773 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2774 { 2775 bool r = true; 2776 if (__left_) 2777 r = r && __left_->fix_forward_references(t_begin, t_end); 2778 if (__right_) 2779 r = r && __right_->fix_forward_references(t_begin, t_end); 2780 return r; 2781 } 2782}; 2783 2784class __operator_left_shift 2785 : public __node 2786{ 2787public: 2788 2789 __operator_left_shift() {} 2790 __operator_left_shift(__node* op1, __node* op2) 2791 { 2792 __left_ = op1; 2793 __right_ = op2; 2794 } 2795 virtual size_t first_size() const 2796 { 2797 if (__cached_size_ == -1) 2798 { 2799 if (__left_) 2800 const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size(); 2801 else 2802 const_cast<long&>(__cached_size_) = sizeof("operator<<") - 1; 2803 } 2804 return __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 ptrdiff_t print_first(char* f, char* l) const 2825 { 2826 const ptrdiff_t r = l - f; 2827 if (__left_) 2828 { 2829 const ptrdiff_t n1 = 8; 2830 if (r < n1) 2831 return n1 + __left_->print(l, l) + __right_->print(l, l); 2832 ptrdiff_t sz1 = __left_->print(f+1, l); 2833 if (r < n1 + sz1) 2834 return n1 + sz1 + __right_->print(l, l); 2835 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 2836 if (r >= n1 + sz1 + sz2) 2837 { 2838 *f = '('; 2839 f += 1 + sz1; 2840 *f++ = ')'; 2841 *f++ = ' '; 2842 *f++ = '<'; 2843 *f++ = '<'; 2844 *f++ = ' '; 2845 *f = '('; 2846 f += 1 + sz2; 2847 *f = ')'; 2848 } 2849 return n1 + sz1 + sz2; 2850 } 2851 const ptrdiff_t n2 = sizeof("operator<<") - 1; 2852 if (r >= n2) 2853 { 2854 *f++ = 'o'; 2855 *f++ = 'p'; 2856 *f++ = 'e'; 2857 *f++ = 'r'; 2858 *f++ = 'a'; 2859 *f++ = 't'; 2860 *f++ = 'o'; 2861 *f++ = 'r'; 2862 *f++ = '<'; 2863 *f = '<'; 2864 } 2865 return n2; 2866 } 2867 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2868 { 2869 bool r = true; 2870 if (__left_) 2871 r = r && __left_->fix_forward_references(t_begin, t_end); 2872 if (__right_) 2873 r = r && __right_->fix_forward_references(t_begin, t_end); 2874 return r; 2875 } 2876}; 2877 2878class __operator_left_shift_equal 2879 : public __node 2880{ 2881public: 2882 2883 __operator_left_shift_equal() {} 2884 __operator_left_shift_equal(__node* op1, __node* op2) 2885 { 2886 __left_ = op1; 2887 __right_ = op2; 2888 } 2889 virtual size_t first_size() const 2890 { 2891 if (__cached_size_ == -1) 2892 { 2893 if (__left_) 2894 const_cast<long&>(__cached_size_) = __left_->size() + 9 + __right_->size(); 2895 else 2896 const_cast<long&>(__cached_size_) = sizeof("operator<<=") - 1; 2897 } 2898 return __cached_size_; 2899 } 2900 virtual char* first_demangled_name(char* buf) const 2901 { 2902 if (__left_) 2903 { 2904 *buf++ = '('; 2905 buf = __left_->get_demangled_name(buf); 2906 strncpy(buf, ") <<= (", 7); 2907 buf += 7; 2908 buf = __right_->get_demangled_name(buf); 2909 *buf++ = ')'; 2910 } 2911 else 2912 { 2913 strncpy(buf, "operator<<=", sizeof("operator<<=") - 1); 2914 buf += sizeof("operator<<=") - 1; 2915 } 2916 return buf; 2917 } 2918 virtual ptrdiff_t print_first(char* f, char* l) const 2919 { 2920 const ptrdiff_t r = l - f; 2921 if (__left_) 2922 { 2923 const ptrdiff_t n1 = 9; 2924 if (r < n1) 2925 return n1 + __left_->print(l, l) + __right_->print(l, l); 2926 ptrdiff_t sz1 = __left_->print(f+1, l); 2927 if (r < n1 + sz1) 2928 return n1 + sz1 + __right_->print(l, l); 2929 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 2930 if (r >= n1 + sz1 + sz2) 2931 { 2932 *f = '('; 2933 f += 1 + sz1; 2934 *f++ = ')'; 2935 *f++ = ' '; 2936 *f++ = '<'; 2937 *f++ = '<'; 2938 *f++ = '='; 2939 *f++ = ' '; 2940 *f = '('; 2941 f += 1 + sz2; 2942 *f = ')'; 2943 } 2944 return n1 + sz1 + sz2; 2945 } 2946 const ptrdiff_t n2 = sizeof("operator<<=") - 1; 2947 if (r >= n2) 2948 { 2949 *f++ = 'o'; 2950 *f++ = 'p'; 2951 *f++ = 'e'; 2952 *f++ = 'r'; 2953 *f++ = 'a'; 2954 *f++ = 't'; 2955 *f++ = 'o'; 2956 *f++ = 'r'; 2957 *f++ = '<'; 2958 *f++ = '<'; 2959 *f = '='; 2960 } 2961 return n2; 2962 } 2963 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 2964 { 2965 bool r = true; 2966 if (__left_) 2967 r = r && __left_->fix_forward_references(t_begin, t_end); 2968 if (__right_) 2969 r = r && __right_->fix_forward_references(t_begin, t_end); 2970 return r; 2971 } 2972}; 2973 2974class __operator_minus 2975 : public __node 2976{ 2977public: 2978 2979 __operator_minus() {} 2980 __operator_minus(__node* op1, __node* op2) 2981 { 2982 __left_ = op1; 2983 __right_ = op2; 2984 } 2985 virtual size_t first_size() const 2986 { 2987 if (__cached_size_ == -1) 2988 { 2989 if (__left_) 2990 const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size(); 2991 else 2992 const_cast<long&>(__cached_size_) = sizeof("operator-") - 1; 2993 } 2994 return __cached_size_; 2995 } 2996 virtual char* first_demangled_name(char* buf) const 2997 { 2998 if (__left_) 2999 { 3000 *buf++ = '('; 3001 buf = __left_->get_demangled_name(buf); 3002 strncpy(buf, ") - (", 5); 3003 buf += 5; 3004 buf = __right_->get_demangled_name(buf); 3005 *buf++ = ')'; 3006 } 3007 else 3008 { 3009 strncpy(buf, "operator-", sizeof("operator-") - 1); 3010 buf += sizeof("operator-") - 1; 3011 } 3012 return buf; 3013 } 3014 virtual ptrdiff_t print_first(char* f, char* l) const 3015 { 3016 const ptrdiff_t r = l - f; 3017 if (__left_) 3018 { 3019 const ptrdiff_t n1 = 7; 3020 if (r < n1) 3021 return n1 + __left_->print(l, l) + __right_->print(l, l); 3022 ptrdiff_t sz1 = __left_->print(f+1, l); 3023 if (r < n1 + sz1) 3024 return n1 + sz1 + __right_->print(l, l); 3025 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 3026 if (r >= n1 + sz1 + sz2) 3027 { 3028 *f = '('; 3029 f += 1 + sz1; 3030 *f++ = ')'; 3031 *f++ = ' '; 3032 *f++ = '-'; 3033 *f++ = ' '; 3034 *f = '('; 3035 f += 1 + sz2; 3036 *f = ')'; 3037 } 3038 return n1 + sz1 + sz2; 3039 } 3040 const ptrdiff_t n2 = sizeof("operator-") - 1; 3041 if (r >= n2) 3042 { 3043 *f++ = 'o'; 3044 *f++ = 'p'; 3045 *f++ = 'e'; 3046 *f++ = 'r'; 3047 *f++ = 'a'; 3048 *f++ = 't'; 3049 *f++ = 'o'; 3050 *f++ = 'r'; 3051 *f = '-'; 3052 } 3053 return n2; 3054 } 3055 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3056 { 3057 bool r = true; 3058 if (__left_) 3059 r = r && __left_->fix_forward_references(t_begin, t_end); 3060 if (__right_) 3061 r = r && __right_->fix_forward_references(t_begin, t_end); 3062 return r; 3063 } 3064}; 3065 3066class __operator_minus_equal 3067 : public __node 3068{ 3069public: 3070 3071 __operator_minus_equal() {} 3072 __operator_minus_equal(__node* op1, __node* op2) 3073 { 3074 __left_ = op1; 3075 __right_ = op2; 3076 } 3077 virtual size_t first_size() const 3078 { 3079 if (__cached_size_ == -1) 3080 { 3081 if (__left_) 3082 const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size(); 3083 else 3084 const_cast<long&>(__cached_size_) = sizeof("operator-=") - 1; 3085 } 3086 return __cached_size_; 3087 } 3088 virtual char* first_demangled_name(char* buf) const 3089 { 3090 if (__left_) 3091 { 3092 *buf++ = '('; 3093 buf = __left_->get_demangled_name(buf); 3094 strncpy(buf, ") -= (", 6); 3095 buf += 6; 3096 buf = __right_->get_demangled_name(buf); 3097 *buf++ = ')'; 3098 } 3099 else 3100 { 3101 strncpy(buf, "operator-=", sizeof("operator-=") - 1); 3102 buf += sizeof("operator-=") - 1; 3103 } 3104 return buf; 3105 } 3106 virtual ptrdiff_t print_first(char* f, char* l) const 3107 { 3108 const ptrdiff_t r = l - f; 3109 if (__left_) 3110 { 3111 const ptrdiff_t n1 = 8; 3112 if (r < n1) 3113 return n1 + __left_->print(l, l) + __right_->print(l, l); 3114 ptrdiff_t sz1 = __left_->print(f+1, l); 3115 if (r < n1 + sz1) 3116 return n1 + sz1 + __right_->print(l, l); 3117 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 3118 if (r >= n1 + sz1 + sz2) 3119 { 3120 *f = '('; 3121 f += 1 + sz1; 3122 *f++ = ')'; 3123 *f++ = ' '; 3124 *f++ = '-'; 3125 *f++ = '='; 3126 *f++ = ' '; 3127 *f = '('; 3128 f += 1 + sz2; 3129 *f = ')'; 3130 } 3131 return n1 + sz1 + sz2; 3132 } 3133 const ptrdiff_t n2 = sizeof("operator-=") - 1; 3134 if (r >= n2) 3135 { 3136 *f++ = 'o'; 3137 *f++ = 'p'; 3138 *f++ = 'e'; 3139 *f++ = 'r'; 3140 *f++ = 'a'; 3141 *f++ = 't'; 3142 *f++ = 'o'; 3143 *f++ = 'r'; 3144 *f++ = '-'; 3145 *f = '='; 3146 } 3147 return n2; 3148 } 3149 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3150 { 3151 bool r = true; 3152 if (__left_) 3153 r = r && __left_->fix_forward_references(t_begin, t_end); 3154 if (__right_) 3155 r = r && __right_->fix_forward_references(t_begin, t_end); 3156 return r; 3157 } 3158}; 3159 3160class __operator_times 3161 : public __node 3162{ 3163public: 3164 3165 __operator_times() {} 3166 __operator_times(__node* op1, __node* op2) 3167 { 3168 __left_ = op1; 3169 __right_ = op2; 3170 } 3171 virtual size_t first_size() const 3172 { 3173 if (__cached_size_ == -1) 3174 { 3175 if (__left_) 3176 const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size(); 3177 else 3178 const_cast<long&>(__cached_size_) = sizeof("operator*") - 1; 3179 } 3180 return __cached_size_; 3181 } 3182 virtual char* first_demangled_name(char* buf) const 3183 { 3184 if (__left_) 3185 { 3186 *buf++ = '('; 3187 buf = __left_->get_demangled_name(buf); 3188 strncpy(buf, ") * (", 5); 3189 buf += 5; 3190 buf = __right_->get_demangled_name(buf); 3191 *buf++ = ')'; 3192 } 3193 else 3194 { 3195 strncpy(buf, "operator*", sizeof("operator*") - 1); 3196 buf += sizeof("operator*") - 1; 3197 } 3198 return buf; 3199 } 3200 virtual ptrdiff_t print_first(char* f, char* l) const 3201 { 3202 const ptrdiff_t r = l - f; 3203 if (__left_) 3204 { 3205 const ptrdiff_t n1 = 7; 3206 if (r < n1) 3207 return n1 + __left_->print(l, l) + __right_->print(l, l); 3208 ptrdiff_t sz1 = __left_->print(f+1, l); 3209 if (r < n1 + sz1) 3210 return n1 + sz1 + __right_->print(l, l); 3211 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 3212 if (r >= n1 + sz1 + sz2) 3213 { 3214 *f = '('; 3215 f += 1 + sz1; 3216 *f++ = ')'; 3217 *f++ = ' '; 3218 *f++ = '*'; 3219 *f++ = ' '; 3220 *f = '('; 3221 f += 1 + sz2; 3222 *f = ')'; 3223 } 3224 return n1 + sz1 + sz2; 3225 } 3226 const ptrdiff_t n2 = sizeof("operator*") - 1; 3227 if (r >= n2) 3228 { 3229 *f++ = 'o'; 3230 *f++ = 'p'; 3231 *f++ = 'e'; 3232 *f++ = 'r'; 3233 *f++ = 'a'; 3234 *f++ = 't'; 3235 *f++ = 'o'; 3236 *f++ = 'r'; 3237 *f = '*'; 3238 } 3239 return n2; 3240 } 3241 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3242 { 3243 bool r = true; 3244 if (__left_) 3245 r = r && __left_->fix_forward_references(t_begin, t_end); 3246 if (__right_) 3247 r = r && __right_->fix_forward_references(t_begin, t_end); 3248 return r; 3249 } 3250}; 3251 3252class __operator_times_equal 3253 : public __node 3254{ 3255public: 3256 3257 __operator_times_equal() {} 3258 __operator_times_equal(__node* op1, __node* op2) 3259 { 3260 __left_ = op1; 3261 __right_ = op2; 3262 } 3263 virtual size_t first_size() const 3264 { 3265 if (__cached_size_ == -1) 3266 { 3267 if (__left_) 3268 const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size(); 3269 else 3270 const_cast<long&>(__cached_size_) = sizeof("operator*=") - 1; 3271 } 3272 return __cached_size_; 3273 } 3274 virtual char* first_demangled_name(char* buf) const 3275 { 3276 if (__left_) 3277 { 3278 *buf++ = '('; 3279 buf = __left_->get_demangled_name(buf); 3280 strncpy(buf, ") *= (", 6); 3281 buf += 6; 3282 buf = __right_->get_demangled_name(buf); 3283 *buf++ = ')'; 3284 } 3285 else 3286 { 3287 strncpy(buf, "operator*=", sizeof("operator*=") - 1); 3288 buf += sizeof("operator*=") - 1; 3289 } 3290 return buf; 3291 } 3292 virtual ptrdiff_t print_first(char* f, char* l) const 3293 { 3294 const ptrdiff_t r = l - f; 3295 if (__left_) 3296 { 3297 const ptrdiff_t n1 = 8; 3298 if (r < n1) 3299 return n1 + __left_->print(l, l) + __right_->print(l, l); 3300 ptrdiff_t sz1 = __left_->print(f+1, l); 3301 if (r < n1 + sz1) 3302 return n1 + sz1 + __right_->print(l, l); 3303 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 3304 if (r >= n1 + sz1 + sz2) 3305 { 3306 *f = '('; 3307 f += 1 + sz1; 3308 *f++ = ')'; 3309 *f++ = ' '; 3310 *f++ = '*'; 3311 *f++ = '='; 3312 *f++ = ' '; 3313 *f = '('; 3314 f += 1 + sz2; 3315 *f = ')'; 3316 } 3317 return n1 + sz1 + sz2; 3318 } 3319 const ptrdiff_t n2 = sizeof("operator*=") - 1; 3320 if (r >= n2) 3321 { 3322 *f++ = 'o'; 3323 *f++ = 'p'; 3324 *f++ = 'e'; 3325 *f++ = 'r'; 3326 *f++ = 'a'; 3327 *f++ = 't'; 3328 *f++ = 'o'; 3329 *f++ = 'r'; 3330 *f++ = '*'; 3331 *f = '='; 3332 } 3333 return n2; 3334 } 3335 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3336 { 3337 bool r = true; 3338 if (__left_) 3339 r = r && __left_->fix_forward_references(t_begin, t_end); 3340 if (__right_) 3341 r = r && __right_->fix_forward_references(t_begin, t_end); 3342 return r; 3343 } 3344}; 3345 3346class __operator_decrement 3347 : public __node 3348{ 3349public: 3350 3351 __operator_decrement() {} 3352 explicit __operator_decrement(bool prefix, __node* op) 3353 { 3354 __size_ = prefix; 3355 __left_ = op; 3356 } 3357 virtual size_t first_size() const 3358 { 3359 if (__cached_size_ == -1) 3360 { 3361 if (__left_) 3362 const_cast<long&>(__cached_size_) = 4+__left_->size(); 3363 else 3364 const_cast<long&>(__cached_size_) = sizeof("operator--") - 1; 3365 } 3366 return __cached_size_; 3367 } 3368 virtual char* first_demangled_name(char* buf) const 3369 { 3370 if (__left_) 3371 { 3372 if (__size_) 3373 { 3374 *buf++ = '-'; 3375 *buf++ = '-'; 3376 *buf++ = '('; 3377 } 3378 else 3379 *buf++ = '('; 3380 buf = __left_->get_demangled_name(buf); 3381 if (__size_) 3382 *buf++ = ')'; 3383 else 3384 { 3385 *buf++ = ')'; 3386 *buf++ = '-'; 3387 *buf++ = '-'; 3388 } 3389 } 3390 else 3391 { 3392 strncpy(buf, "operator--", sizeof("operator--") - 1); 3393 buf += sizeof("operator--") - 1; 3394 } 3395 return buf; 3396 } 3397 virtual ptrdiff_t print_first(char* f, char* l) const 3398 { 3399 const ptrdiff_t r = l - f; 3400 if (__left_) 3401 { 3402 const ptrdiff_t n1 = 4; 3403 if (r < n1) 3404 return n1 + __left_->print(l, l); 3405 ptrdiff_t sz1 = __left_->print(f + (__size_ ? 3 : 1), l); 3406 if (r >= n1 + sz1) 3407 { 3408 if (__size_) 3409 { 3410 *f++ = '-'; 3411 *f++ = '-'; 3412 *f = '('; 3413 f += 1+sz1; 3414 *f = ')'; 3415 } 3416 else 3417 { 3418 *f = '('; 3419 f += 1+sz1; 3420 *f++ = ')'; 3421 *f++ = '-'; 3422 *f = '-'; 3423 } 3424 } 3425 return n1 + sz1; 3426 } 3427 const ptrdiff_t n2 = sizeof("operator--") - 1; 3428 if (r >= n2) 3429 { 3430 *f++ = 'o'; 3431 *f++ = 'p'; 3432 *f++ = 'e'; 3433 *f++ = 'r'; 3434 *f++ = 'a'; 3435 *f++ = 't'; 3436 *f++ = 'o'; 3437 *f++ = 'r'; 3438 *f++ = '-'; 3439 *f = '-'; 3440 } 3441 return n2; 3442 } 3443 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3444 { 3445 if (__left_) 3446 return __left_->fix_forward_references(t_begin, t_end); 3447 return true; 3448 } 3449}; 3450 3451class __operator_not_equal 3452 : public __node 3453{ 3454public: 3455 3456 __operator_not_equal() {} 3457 __operator_not_equal(__node* op1, __node* op2) 3458 { 3459 __left_ = op1; 3460 __right_ = op2; 3461 } 3462 virtual size_t first_size() const 3463 { 3464 if (__cached_size_ == -1) 3465 { 3466 if (__left_) 3467 const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size(); 3468 else 3469 const_cast<long&>(__cached_size_) = sizeof("operator!=") - 1; 3470 } 3471 return __cached_size_; 3472 } 3473 virtual char* first_demangled_name(char* buf) const 3474 { 3475 if (__left_) 3476 { 3477 *buf++ = '('; 3478 buf = __left_->get_demangled_name(buf); 3479 strncpy(buf, ") != (", 6); 3480 buf += 6; 3481 buf = __right_->get_demangled_name(buf); 3482 *buf++ = ')'; 3483 } 3484 else 3485 { 3486 strncpy(buf, "operator!=", sizeof("operator!=") - 1); 3487 buf += sizeof("operator!=") - 1; 3488 } 3489 return buf; 3490 } 3491 virtual ptrdiff_t print_first(char* f, char* l) const 3492 { 3493 const ptrdiff_t r = l - f; 3494 if (__left_) 3495 { 3496 const ptrdiff_t n1 = 8; 3497 if (r < n1) 3498 return n1 + __left_->print(l, l) + __right_->print(l, l); 3499 ptrdiff_t sz1 = __left_->print(f+1, l); 3500 if (r < n1 + sz1) 3501 return n1 + sz1 + __right_->print(l, l); 3502 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 3503 if (r >= n1 + sz1 + sz2) 3504 { 3505 *f = '('; 3506 f += 1 + sz1; 3507 *f++ = ')'; 3508 *f++ = ' '; 3509 *f++ = '!'; 3510 *f++ = '='; 3511 *f++ = ' '; 3512 *f = '('; 3513 f += 1 + sz2; 3514 *f = ')'; 3515 } 3516 return n1 + sz1 + sz2; 3517 } 3518 const ptrdiff_t n2 = sizeof("operator!=") - 1; 3519 if (r >= n2) 3520 { 3521 *f++ = 'o'; 3522 *f++ = 'p'; 3523 *f++ = 'e'; 3524 *f++ = 'r'; 3525 *f++ = 'a'; 3526 *f++ = 't'; 3527 *f++ = 'o'; 3528 *f++ = 'r'; 3529 *f++ = '!'; 3530 *f = '='; 3531 } 3532 return n2; 3533 } 3534 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3535 { 3536 bool r = true; 3537 if (__left_) 3538 r = r && __left_->fix_forward_references(t_begin, t_end); 3539 if (__right_) 3540 r = r && __right_->fix_forward_references(t_begin, t_end); 3541 return r; 3542 } 3543}; 3544 3545class __operator_negate 3546 : public __node 3547{ 3548public: 3549 3550 __operator_negate() {} 3551 explicit __operator_negate(__node* op) 3552 { 3553 __left_ = op; 3554 } 3555 virtual size_t first_size() const 3556 { 3557 if (__cached_size_ == -1) 3558 { 3559 if (__left_) 3560 const_cast<long&>(__cached_size_) = 3+__left_->size(); 3561 else 3562 const_cast<long&>(__cached_size_) = sizeof("operator-") - 1; 3563 } 3564 return __cached_size_; 3565 } 3566 virtual char* first_demangled_name(char* buf) const 3567 { 3568 if (__left_) 3569 { 3570 *buf++ = '-'; 3571 *buf++ = '('; 3572 buf = __left_->get_demangled_name(buf); 3573 *buf++ = ')'; 3574 } 3575 else 3576 { 3577 strncpy(buf, "operator-", sizeof("operator-") - 1); 3578 buf += sizeof("operator-") - 1; 3579 } 3580 return buf; 3581 } 3582 virtual ptrdiff_t print_first(char* f, char* l) const 3583 { 3584 const ptrdiff_t r = l - f; 3585 if (__left_) 3586 { 3587 const ptrdiff_t n1 = 3; 3588 if (r < n1) 3589 return n1 + __left_->print(l, l); 3590 ptrdiff_t sz1 = __left_->print(f+2, l); 3591 if (r >= n1 + sz1) 3592 { 3593 *f++ = '-'; 3594 *f = '('; 3595 f += 1 + sz1; 3596 *f = ')'; 3597 } 3598 return n1 + sz1; 3599 } 3600 const ptrdiff_t n2 = sizeof("operator-") - 1; 3601 if (r >= n2) 3602 { 3603 *f++ = 'o'; 3604 *f++ = 'p'; 3605 *f++ = 'e'; 3606 *f++ = 'r'; 3607 *f++ = 'a'; 3608 *f++ = 't'; 3609 *f++ = 'o'; 3610 *f++ = 'r'; 3611 *f = '-'; 3612 } 3613 return n2; 3614 } 3615 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3616 { 3617 if (__left_) 3618 return __left_->fix_forward_references(t_begin, t_end); 3619 return true; 3620 } 3621}; 3622 3623class __operator_logical_not 3624 : public __node 3625{ 3626public: 3627 3628 __operator_logical_not() {} 3629 explicit __operator_logical_not(__node* op) 3630 { 3631 __left_ = op; 3632 } 3633 virtual size_t first_size() const 3634 { 3635 if (__cached_size_ == -1) 3636 { 3637 if (__left_) 3638 const_cast<long&>(__cached_size_) = 3+__left_->size(); 3639 else 3640 const_cast<long&>(__cached_size_) = sizeof("operator!") - 1; 3641 } 3642 return __cached_size_; 3643 } 3644 virtual char* first_demangled_name(char* buf) const 3645 { 3646 if (__left_) 3647 { 3648 *buf++ = '!'; 3649 *buf++ = '('; 3650 buf = __left_->get_demangled_name(buf); 3651 *buf++ = ')'; 3652 } 3653 else 3654 { 3655 strncpy(buf, "operator!", sizeof("operator!") - 1); 3656 buf += sizeof("operator!") - 1; 3657 } 3658 return buf; 3659 } 3660 virtual ptrdiff_t print_first(char* f, char* l) const 3661 { 3662 const ptrdiff_t r = l - f; 3663 if (__left_) 3664 { 3665 const ptrdiff_t n1 = 3; 3666 if (r < n1) 3667 return n1 + __left_->print(l, l); 3668 ptrdiff_t sz1 = __left_->print(f+2, l); 3669 if (r >= n1 + sz1) 3670 { 3671 *f++ = '!'; 3672 *f = '('; 3673 f += 1 + sz1; 3674 *f = ')'; 3675 } 3676 return n1 + sz1; 3677 } 3678 const ptrdiff_t n2 = sizeof("operator!") - 1; 3679 if (r >= n2) 3680 { 3681 *f++ = 'o'; 3682 *f++ = 'p'; 3683 *f++ = 'e'; 3684 *f++ = 'r'; 3685 *f++ = 'a'; 3686 *f++ = 't'; 3687 *f++ = 'o'; 3688 *f++ = 'r'; 3689 *f = '!'; 3690 } 3691 return n2; 3692 } 3693 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3694 { 3695 if (__left_) 3696 return __left_->fix_forward_references(t_begin, t_end); 3697 return true; 3698 } 3699}; 3700 3701class __operator_logical_or 3702 : public __node 3703{ 3704public: 3705 3706 __operator_logical_or() {} 3707 __operator_logical_or(__node* op1, __node* op2) 3708 { 3709 __left_ = op1; 3710 __right_ = op2; 3711 } 3712 virtual size_t first_size() const 3713 { 3714 if (__cached_size_ == -1) 3715 { 3716 if (__left_) 3717 const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size(); 3718 else 3719 const_cast<long&>(__cached_size_) = sizeof("operator||") - 1; 3720 } 3721 return __cached_size_; 3722 } 3723 virtual char* first_demangled_name(char* buf) const 3724 { 3725 if (__left_) 3726 { 3727 *buf++ = '('; 3728 buf = __left_->get_demangled_name(buf); 3729 strncpy(buf, ") || (", 6); 3730 buf += 6; 3731 buf = __right_->get_demangled_name(buf); 3732 *buf++ = ')'; 3733 } 3734 else 3735 { 3736 strncpy(buf, "operator||", sizeof("operator||") - 1); 3737 buf += sizeof("operator||") - 1; 3738 } 3739 return buf; 3740 } 3741 virtual ptrdiff_t print_first(char* f, char* l) const 3742 { 3743 const ptrdiff_t r = l - f; 3744 if (__left_) 3745 { 3746 const ptrdiff_t n1 = 8; 3747 if (r < n1) 3748 return n1 + __left_->print(l, l) + __right_->print(l, l); 3749 ptrdiff_t sz1 = __left_->print(f+1, l); 3750 if (r < n1 + sz1) 3751 return n1 + sz1 + __right_->print(l, l); 3752 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 3753 if (r >= n1 + sz1 + sz2) 3754 { 3755 *f = '('; 3756 f += 1 + sz1; 3757 *f++ = ')'; 3758 *f++ = ' '; 3759 *f++ = '|'; 3760 *f++ = '|'; 3761 *f++ = ' '; 3762 *f = '('; 3763 f += 1 + sz2; 3764 *f = ')'; 3765 } 3766 return n1 + sz1 + sz2; 3767 } 3768 const ptrdiff_t n2 = sizeof("operator||") - 1; 3769 if (r >= n2) 3770 { 3771 *f++ = 'o'; 3772 *f++ = 'p'; 3773 *f++ = 'e'; 3774 *f++ = 'r'; 3775 *f++ = 'a'; 3776 *f++ = 't'; 3777 *f++ = 'o'; 3778 *f++ = 'r'; 3779 *f++ = '|'; 3780 *f = '|'; 3781 } 3782 return n2; 3783 } 3784 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3785 { 3786 bool r = true; 3787 if (__left_) 3788 r = r && __left_->fix_forward_references(t_begin, t_end); 3789 if (__right_) 3790 r = r && __right_->fix_forward_references(t_begin, t_end); 3791 return r; 3792 } 3793}; 3794 3795class __operator_bit_or 3796 : public __node 3797{ 3798public: 3799 3800 __operator_bit_or() {} 3801 __operator_bit_or(__node* op1, __node* op2) 3802 { 3803 __left_ = op1; 3804 __right_ = op2; 3805 } 3806 virtual size_t first_size() const 3807 { 3808 if (__cached_size_ == -1) 3809 { 3810 if (__left_) 3811 const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size(); 3812 else 3813 const_cast<long&>(__cached_size_) = sizeof("operator|") - 1; 3814 } 3815 return __cached_size_; 3816 } 3817 virtual char* first_demangled_name(char* buf) const 3818 { 3819 if (__left_) 3820 { 3821 *buf++ = '('; 3822 buf = __left_->get_demangled_name(buf); 3823 strncpy(buf, ") | (", 5); 3824 buf += 5; 3825 buf = __right_->get_demangled_name(buf); 3826 *buf++ = ')'; 3827 } 3828 else 3829 { 3830 strncpy(buf, "operator|", sizeof("operator|") - 1); 3831 buf += sizeof("operator|") - 1; 3832 } 3833 return buf; 3834 } 3835 virtual ptrdiff_t print_first(char* f, char* l) const 3836 { 3837 const ptrdiff_t r = l - f; 3838 if (__left_) 3839 { 3840 const ptrdiff_t n1 = 7; 3841 if (r < n1) 3842 return n1 + __left_->print(l, l) + __right_->print(l, l); 3843 ptrdiff_t sz1 = __left_->print(f+1, l); 3844 if (r < n1 + sz1) 3845 return n1 + sz1 + __right_->print(l, l); 3846 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 3847 if (r >= n1 + sz1 + sz2) 3848 { 3849 *f = '('; 3850 f += 1 + sz1; 3851 *f++ = ')'; 3852 *f++ = ' '; 3853 *f++ = '|'; 3854 *f++ = ' '; 3855 *f = '('; 3856 f += 1 + sz2; 3857 *f = ')'; 3858 } 3859 return n1 + sz1 + sz2; 3860 } 3861 const ptrdiff_t n2 = sizeof("operator|") - 1; 3862 if (r >= n2) 3863 { 3864 *f++ = 'o'; 3865 *f++ = 'p'; 3866 *f++ = 'e'; 3867 *f++ = 'r'; 3868 *f++ = 'a'; 3869 *f++ = 't'; 3870 *f++ = 'o'; 3871 *f++ = 'r'; 3872 *f = '|'; 3873 } 3874 return n2; 3875 } 3876 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3877 { 3878 bool r = true; 3879 if (__left_) 3880 r = r && __left_->fix_forward_references(t_begin, t_end); 3881 if (__right_) 3882 r = r && __right_->fix_forward_references(t_begin, t_end); 3883 return r; 3884 } 3885}; 3886 3887class __operator_or_equal 3888 : public __node 3889{ 3890public: 3891 3892 __operator_or_equal() {} 3893 __operator_or_equal(__node* op1, __node* op2) 3894 { 3895 __left_ = op1; 3896 __right_ = op2; 3897 } 3898 virtual size_t first_size() const 3899 { 3900 if (__cached_size_ == -1) 3901 { 3902 if (__left_) 3903 const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size(); 3904 else 3905 const_cast<long&>(__cached_size_) = sizeof("operator|=") - 1; 3906 } 3907 return __cached_size_; 3908 } 3909 virtual char* first_demangled_name(char* buf) const 3910 { 3911 if (__left_) 3912 { 3913 *buf++ = '('; 3914 buf = __left_->get_demangled_name(buf); 3915 strncpy(buf, ") |= (", 6); 3916 buf += 6; 3917 buf = __right_->get_demangled_name(buf); 3918 *buf++ = ')'; 3919 } 3920 else 3921 { 3922 strncpy(buf, "operator|=", sizeof("operator|=") - 1); 3923 buf += sizeof("operator|=") - 1; 3924 } 3925 return buf; 3926 } 3927 virtual ptrdiff_t print_first(char* f, char* l) const 3928 { 3929 const ptrdiff_t r = l - f; 3930 if (__left_) 3931 { 3932 const ptrdiff_t n1 = 8; 3933 if (r < n1) 3934 return n1 + __left_->print(l, l) + __right_->print(l, l); 3935 ptrdiff_t sz1 = __left_->print(f+1, l); 3936 if (r < n1 + sz1) 3937 return n1 + sz1 + __right_->print(l, l); 3938 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 3939 if (r >= n1 + sz1 + sz2) 3940 { 3941 *f = '('; 3942 f += 1 + sz1; 3943 *f++ = ')'; 3944 *f++ = ' '; 3945 *f++ = '|'; 3946 *f++ = '='; 3947 *f++ = ' '; 3948 *f = '('; 3949 f += 1 + sz2; 3950 *f = ')'; 3951 } 3952 return n1 + sz1 + sz2; 3953 } 3954 const ptrdiff_t n2 = sizeof("operator|=") - 1; 3955 if (r >= n2) 3956 { 3957 *f++ = 'o'; 3958 *f++ = 'p'; 3959 *f++ = 'e'; 3960 *f++ = 'r'; 3961 *f++ = 'a'; 3962 *f++ = 't'; 3963 *f++ = 'o'; 3964 *f++ = 'r'; 3965 *f++ = '|'; 3966 *f = '='; 3967 } 3968 return n2; 3969 } 3970 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 3971 { 3972 bool r = true; 3973 if (__left_) 3974 r = r && __left_->fix_forward_references(t_begin, t_end); 3975 if (__right_) 3976 r = r && __right_->fix_forward_references(t_begin, t_end); 3977 return r; 3978 } 3979}; 3980 3981class __operator_pointer_to_member 3982 : public __node 3983{ 3984public: 3985 3986 __operator_pointer_to_member() {} 3987 __operator_pointer_to_member(__node* op1, __node* op2) 3988 { 3989 __left_ = op1; 3990 __right_ = op2; 3991 } 3992 virtual size_t first_size() const 3993 { 3994 if (__cached_size_ == -1) 3995 { 3996 if (__left_) 3997 const_cast<long&>(__cached_size_) = __left_->size() + 9 + __right_->size(); 3998 else 3999 const_cast<long&>(__cached_size_) = sizeof("operator->*") - 1; 4000 } 4001 return __cached_size_; 4002 } 4003 virtual char* first_demangled_name(char* buf) const 4004 { 4005 if (__left_) 4006 { 4007 *buf++ = '('; 4008 buf = __left_->get_demangled_name(buf); 4009 strncpy(buf, ") ->* (", 7); 4010 buf += 7; 4011 buf = __right_->get_demangled_name(buf); 4012 *buf++ = ')'; 4013 } 4014 else 4015 { 4016 strncpy(buf, "operator->*", sizeof("operator->*") - 1); 4017 buf += sizeof("operator->*") - 1; 4018 } 4019 return buf; 4020 } 4021 virtual ptrdiff_t print_first(char* f, char* l) const 4022 { 4023 const ptrdiff_t r = l - f; 4024 if (__left_) 4025 { 4026 const ptrdiff_t n1 = 9; 4027 if (r < n1) 4028 return n1 + __left_->print(l, l) + __right_->print(l, l); 4029 ptrdiff_t sz1 = __left_->print(f+1, l); 4030 if (r < n1 + sz1) 4031 return n1 + sz1 + __right_->print(l, l); 4032 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 4033 if (r >= n1 + sz1 + sz2) 4034 { 4035 *f = '('; 4036 f += 1 + sz1; 4037 *f++ = ')'; 4038 *f++ = ' '; 4039 *f++ = '-'; 4040 *f++ = '>'; 4041 *f++ = '*'; 4042 *f++ = ' '; 4043 *f = '('; 4044 f += 1 + sz2; 4045 *f = ')'; 4046 } 4047 return n1 + sz1 + sz2; 4048 } 4049 const ptrdiff_t n2 = sizeof("operator->*") - 1; 4050 if (r >= n2) 4051 { 4052 *f++ = 'o'; 4053 *f++ = 'p'; 4054 *f++ = 'e'; 4055 *f++ = 'r'; 4056 *f++ = 'a'; 4057 *f++ = 't'; 4058 *f++ = 'o'; 4059 *f++ = 'r'; 4060 *f++ = '-'; 4061 *f++ = '>'; 4062 *f = '*'; 4063 } 4064 return n2; 4065 } 4066 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 4067 { 4068 bool r = true; 4069 if (__left_) 4070 r = r && __left_->fix_forward_references(t_begin, t_end); 4071 if (__right_) 4072 r = r && __right_->fix_forward_references(t_begin, t_end); 4073 return r; 4074 } 4075}; 4076 4077class __operator_plus 4078 : public __node 4079{ 4080public: 4081 4082 __operator_plus() {} 4083 __operator_plus(__node* op1, __node* op2) 4084 { 4085 __left_ = op1; 4086 __right_ = op2; 4087 } 4088 virtual size_t first_size() const 4089 { 4090 if (__cached_size_ == -1) 4091 { 4092 if (__left_) 4093 const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size(); 4094 else 4095 const_cast<long&>(__cached_size_) = sizeof("operator+") - 1; 4096 } 4097 return __cached_size_; 4098 } 4099 virtual char* first_demangled_name(char* buf) const 4100 { 4101 if (__left_) 4102 { 4103 *buf++ = '('; 4104 buf = __left_->get_demangled_name(buf); 4105 strncpy(buf, ") + (", 5); 4106 buf += 5; 4107 buf = __right_->get_demangled_name(buf); 4108 *buf++ = ')'; 4109 } 4110 else 4111 { 4112 strncpy(buf, "operator+", sizeof("operator+") - 1); 4113 buf += sizeof("operator+") - 1; 4114 } 4115 return buf; 4116 } 4117 virtual ptrdiff_t print_first(char* f, char* l) const 4118 { 4119 const ptrdiff_t r = l - f; 4120 if (__left_) 4121 { 4122 const ptrdiff_t n1 = 7; 4123 if (r < n1) 4124 return n1 + __left_->print(l, l) + __right_->print(l, l); 4125 ptrdiff_t sz1 = __left_->print(f+1, l); 4126 if (r < n1 + sz1) 4127 return n1 + sz1 + __right_->print(l, l); 4128 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 4129 if (r >= n1 + sz1 + sz2) 4130 { 4131 *f = '('; 4132 f += 1 + sz1; 4133 *f++ = ')'; 4134 *f++ = ' '; 4135 *f++ = '+'; 4136 *f++ = ' '; 4137 *f = '('; 4138 f += 1 + sz2; 4139 *f = ')'; 4140 } 4141 return n1 + sz1 + sz2; 4142 } 4143 const ptrdiff_t n2 = sizeof("operator+") - 1; 4144 if (r >= n2) 4145 { 4146 *f++ = 'o'; 4147 *f++ = 'p'; 4148 *f++ = 'e'; 4149 *f++ = 'r'; 4150 *f++ = 'a'; 4151 *f++ = 't'; 4152 *f++ = 'o'; 4153 *f++ = 'r'; 4154 *f = '+'; 4155 } 4156 return n2; 4157 } 4158 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 4159 { 4160 bool r = true; 4161 if (__left_) 4162 r = r && __left_->fix_forward_references(t_begin, t_end); 4163 if (__right_) 4164 r = r && __right_->fix_forward_references(t_begin, t_end); 4165 return r; 4166 } 4167}; 4168 4169class __operator_plus_equal 4170 : public __node 4171{ 4172public: 4173 4174 __operator_plus_equal() {} 4175 __operator_plus_equal(__node* op1, __node* op2) 4176 { 4177 __left_ = op1; 4178 __right_ = op2; 4179 } 4180 virtual size_t first_size() const 4181 { 4182 if (__cached_size_ == -1) 4183 { 4184 if (__left_) 4185 const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size(); 4186 else 4187 const_cast<long&>(__cached_size_) = sizeof("operator+=") - 1; 4188 } 4189 return __cached_size_; 4190 } 4191 virtual char* first_demangled_name(char* buf) const 4192 { 4193 if (__left_) 4194 { 4195 *buf++ = '('; 4196 buf = __left_->get_demangled_name(buf); 4197 strncpy(buf, ") += (", 6); 4198 buf += 6; 4199 buf = __right_->get_demangled_name(buf); 4200 *buf++ = ')'; 4201 } 4202 else 4203 { 4204 strncpy(buf, "operator+=", sizeof("operator+=") - 1); 4205 buf += sizeof("operator+=") - 1; 4206 } 4207 return buf; 4208 } 4209 virtual ptrdiff_t print_first(char* f, char* l) const 4210 { 4211 const ptrdiff_t r = l - f; 4212 if (__left_) 4213 { 4214 const ptrdiff_t n1 = 8; 4215 if (r < n1) 4216 return n1 + __left_->print(l, l) + __right_->print(l, l); 4217 ptrdiff_t sz1 = __left_->print(f+1, l); 4218 if (r < n1 + sz1) 4219 return n1 + sz1 + __right_->print(l, l); 4220 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 4221 if (r >= n1 + sz1 + sz2) 4222 { 4223 *f = '('; 4224 f += 1 + sz1; 4225 *f++ = ')'; 4226 *f++ = ' '; 4227 *f++ = '+'; 4228 *f++ = '='; 4229 *f++ = ' '; 4230 *f = '('; 4231 f += 1 + sz2; 4232 *f = ')'; 4233 } 4234 return n1 + sz1 + sz2; 4235 } 4236 const ptrdiff_t n2 = sizeof("operator+=") - 1; 4237 if (r >= n2) 4238 { 4239 *f++ = 'o'; 4240 *f++ = 'p'; 4241 *f++ = 'e'; 4242 *f++ = 'r'; 4243 *f++ = 'a'; 4244 *f++ = 't'; 4245 *f++ = 'o'; 4246 *f++ = 'r'; 4247 *f++ = '+'; 4248 *f = '='; 4249 } 4250 return n2; 4251 } 4252 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 4253 { 4254 bool r = true; 4255 if (__left_) 4256 r = r && __left_->fix_forward_references(t_begin, t_end); 4257 if (__right_) 4258 r = r && __right_->fix_forward_references(t_begin, t_end); 4259 return r; 4260 } 4261}; 4262 4263class __operator_increment 4264 : public __node 4265{ 4266public: 4267 4268 __operator_increment() {} 4269 explicit __operator_increment(bool prefix, __node* op) 4270 { 4271 __size_ = prefix; 4272 __left_ = op; 4273 } 4274 virtual size_t first_size() const 4275 { 4276 if (__cached_size_ == -1) 4277 { 4278 if (__left_) 4279 const_cast<long&>(__cached_size_) = 4+__left_->size(); 4280 else 4281 const_cast<long&>(__cached_size_) = sizeof("operator++") - 1; 4282 } 4283 return __cached_size_; 4284 } 4285 virtual char* first_demangled_name(char* buf) const 4286 { 4287 if (__left_) 4288 { 4289 if (__size_) 4290 { 4291 *buf++ = '+'; 4292 *buf++ = '+'; 4293 *buf++ = '('; 4294 } 4295 else 4296 *buf++ = '('; 4297 buf = __left_->get_demangled_name(buf); 4298 if (__size_) 4299 *buf++ = ')'; 4300 else 4301 { 4302 *buf++ = ')'; 4303 *buf++ = '+'; 4304 *buf++ = '+'; 4305 } 4306 } 4307 else 4308 { 4309 strncpy(buf, "operator++", sizeof("operator++") - 1); 4310 buf += sizeof("operator++") - 1; 4311 } 4312 return buf; 4313 } 4314 virtual ptrdiff_t print_first(char* f, char* l) const 4315 { 4316 const ptrdiff_t r = l - f; 4317 if (__left_) 4318 { 4319 const ptrdiff_t n1 = 4; 4320 if (r < n1) 4321 return n1 + __left_->print(l, l); 4322 ptrdiff_t sz1 = __left_->print(f + (__size_ ? 3 : 1), l); 4323 if (r >= n1 + sz1) 4324 { 4325 if (__size_) 4326 { 4327 *f++ = '+'; 4328 *f++ = '+'; 4329 *f = '('; 4330 f += 1+sz1; 4331 *f = ')'; 4332 } 4333 else 4334 { 4335 *f = '('; 4336 f += 1+sz1; 4337 *f++ = ')'; 4338 *f++ = '+'; 4339 *f = '+'; 4340 } 4341 } 4342 return n1 + sz1; 4343 } 4344 const ptrdiff_t n2 = sizeof("operator++") - 1; 4345 if (r >= n2) 4346 { 4347 *f++ = 'o'; 4348 *f++ = 'p'; 4349 *f++ = 'e'; 4350 *f++ = 'r'; 4351 *f++ = 'a'; 4352 *f++ = 't'; 4353 *f++ = 'o'; 4354 *f++ = 'r'; 4355 *f++ = '+'; 4356 *f = '+'; 4357 } 4358 return n2; 4359 } 4360 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 4361 { 4362 if (__left_) 4363 return __left_->fix_forward_references(t_begin, t_end); 4364 return true; 4365 } 4366}; 4367 4368class __operator_unary_plus 4369 : public __node 4370{ 4371public: 4372 4373 __operator_unary_plus() {} 4374 explicit __operator_unary_plus(__node* op) 4375 { 4376 __left_ = op; 4377 } 4378 virtual size_t first_size() const 4379 { 4380 if (__cached_size_ == -1) 4381 { 4382 if (__left_) 4383 const_cast<long&>(__cached_size_) = 3+__left_->size(); 4384 else 4385 const_cast<long&>(__cached_size_) = sizeof("operator+") - 1; 4386 } 4387 return __cached_size_; 4388 } 4389 virtual char* first_demangled_name(char* buf) const 4390 { 4391 if (__left_) 4392 { 4393 *buf++ = '+'; 4394 *buf++ = '('; 4395 buf = __left_->get_demangled_name(buf); 4396 *buf++ = ')'; 4397 } 4398 else 4399 { 4400 strncpy(buf, "operator+", sizeof("operator+") - 1); 4401 buf += sizeof("operator+") - 1; 4402 } 4403 return buf; 4404 } 4405 virtual ptrdiff_t print_first(char* f, char* l) const 4406 { 4407 const ptrdiff_t r = l - f; 4408 if (__left_) 4409 { 4410 const ptrdiff_t n1 = 3; 4411 if (r < n1) 4412 return n1 + __left_->print(l, l); 4413 ptrdiff_t sz1 = __left_->print(f+2, l); 4414 if (r >= n1 + sz1) 4415 { 4416 *f++ = '+'; 4417 *f = '('; 4418 f += 1 + sz1; 4419 *f = ')'; 4420 } 4421 return n1 + sz1; 4422 } 4423 const ptrdiff_t n2 = sizeof("operator+") - 1; 4424 if (r >= n2) 4425 { 4426 *f++ = 'o'; 4427 *f++ = 'p'; 4428 *f++ = 'e'; 4429 *f++ = 'r'; 4430 *f++ = 'a'; 4431 *f++ = 't'; 4432 *f++ = 'o'; 4433 *f++ = 'r'; 4434 *f = '+'; 4435 } 4436 return n2; 4437 } 4438 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 4439 { 4440 if (__left_) 4441 return __left_->fix_forward_references(t_begin, t_end); 4442 return true; 4443 } 4444}; 4445 4446class __operator_arrow 4447 : public __node 4448{ 4449public: 4450 4451 __operator_arrow() {} 4452 __operator_arrow(__node* op1, __node* op2) 4453 { 4454 __left_ = op1; 4455 __right_ = op2; 4456 } 4457 virtual size_t first_size() const 4458 { 4459 if (__cached_size_ == -1) 4460 { 4461 if (__left_) 4462 const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size(); 4463 else 4464 const_cast<long&>(__cached_size_) = sizeof("operator->") - 1; 4465 } 4466 return __cached_size_; 4467 } 4468 virtual char* first_demangled_name(char* buf) const 4469 { 4470 if (__left_) 4471 { 4472 *buf++ = '('; 4473 buf = __left_->get_demangled_name(buf); 4474 strncpy(buf, ") -> (", 6); 4475 buf += 6; 4476 buf = __right_->get_demangled_name(buf); 4477 *buf++ = ')'; 4478 } 4479 else 4480 { 4481 strncpy(buf, "operator->", sizeof("operator->") - 1); 4482 buf += sizeof("operator->") - 1; 4483 } 4484 return buf; 4485 } 4486 virtual ptrdiff_t print_first(char* f, char* l) const 4487 { 4488 const ptrdiff_t r = l - f; 4489 if (__left_) 4490 { 4491 const ptrdiff_t n1 = 8; 4492 if (r < n1) 4493 return n1 + __left_->print(l, l) + __right_->print(l, l); 4494 ptrdiff_t sz1 = __left_->print(f+1, l); 4495 if (r < n1 + sz1) 4496 return n1 + sz1 + __right_->print(l, l); 4497 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 4498 if (r >= n1 + sz1 + sz2) 4499 { 4500 *f = '('; 4501 f += 1 + sz1; 4502 *f++ = ')'; 4503 *f++ = ' '; 4504 *f++ = '-'; 4505 *f++ = '>'; 4506 *f++ = ' '; 4507 *f = '('; 4508 f += 1 + sz2; 4509 *f = ')'; 4510 } 4511 return n1 + sz1 + sz2; 4512 } 4513 const ptrdiff_t n2 = sizeof("operator->") - 1; 4514 if (r >= n2) 4515 { 4516 *f++ = 'o'; 4517 *f++ = 'p'; 4518 *f++ = 'e'; 4519 *f++ = 'r'; 4520 *f++ = 'a'; 4521 *f++ = 't'; 4522 *f++ = 'o'; 4523 *f++ = 'r'; 4524 *f++ = '-'; 4525 *f = '>'; 4526 } 4527 return n2; 4528 } 4529 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 4530 { 4531 bool r = true; 4532 if (__left_) 4533 r = r && __left_->fix_forward_references(t_begin, t_end); 4534 if (__right_) 4535 r = r && __right_->fix_forward_references(t_begin, t_end); 4536 return r; 4537 } 4538}; 4539 4540class __operator_conditional 4541 : public __node 4542{ 4543public: 4544 4545 __operator_conditional() {} 4546 __operator_conditional(__node* op1, __node* op2, __node* op3) 4547 { 4548 __name_ = (const char*)op1; 4549 __left_ = op2; 4550 __right_ = op3; 4551 } 4552 virtual size_t first_size() const 4553 { 4554 if (__cached_size_ == -1) 4555 { 4556 if (__left_) 4557 { 4558 __node* op1 = (__node*)__name_; 4559 const_cast<long&>(__cached_size_) = op1->size() + __left_->size() + 12 + __right_->size(); 4560 } 4561 else 4562 const_cast<long&>(__cached_size_) = sizeof("operator?") - 1; 4563 } 4564 return __cached_size_; 4565 } 4566 virtual char* first_demangled_name(char* buf) const 4567 { 4568 if (__left_) 4569 { 4570 __node* op1 = (__node*)__name_; 4571 *buf++ = '('; 4572 buf = op1->get_demangled_name(buf); 4573 strncpy(buf, ") ? (", 5); 4574 buf += 5; 4575 buf = __left_->get_demangled_name(buf); 4576 strncpy(buf, ") : (", 5); 4577 buf += 5; 4578 buf = __right_->get_demangled_name(buf); 4579 *buf++ = ')'; 4580 } 4581 else 4582 { 4583 strncpy(buf, "operator?", sizeof("operator?") - 1); 4584 buf += sizeof("operator?") - 1; 4585 } 4586 return buf; 4587 } 4588 virtual ptrdiff_t print_first(char* f, char* l) const 4589 { 4590 const ptrdiff_t r = l - f; 4591 if (__left_) 4592 { 4593 const ptrdiff_t n1 = 12; 4594 __node* op1 = (__node*)__name_; 4595 if (r < n1) 4596 return n1 + op1->print(l, l) + __left_->print(l, l) + 4597 __right_->print(l, l); 4598 ptrdiff_t sz1 = op1->print(f+1, l); 4599 if (r < n1 + sz1) 4600 return n1 + sz1 + __left_->print(l, l) + __right_->print(l, l); 4601 ptrdiff_t sz2 = __left_->print(f+6+sz1, l); 4602 if (r < n1 + sz1 + sz2) 4603 return n1 + sz1 + sz2 + __right_->print(l, l); 4604 ptrdiff_t sz3 = __right_->print(f+11+sz1+sz2, l); 4605 if (r >= n1 + sz1 + sz2 + sz3) 4606 { 4607 *f = '('; 4608 f += 1 + sz1; 4609 *f++ = ')'; 4610 *f++ = ' '; 4611 *f++ = '?'; 4612 *f++ = ' '; 4613 *f = '('; 4614 f += 1 + sz2; 4615 *f++ = ')'; 4616 *f++ = ' '; 4617 *f++ = ':'; 4618 *f++ = ' '; 4619 *f = '('; 4620 f += 1 + sz3; 4621 *f = ')'; 4622 } 4623 return n1 + sz1 + sz2 + sz3; 4624 } 4625 const ptrdiff_t n2 = sizeof("operator?") - 1; 4626 if (r >= n2) 4627 { 4628 *f++ = 'o'; 4629 *f++ = 'p'; 4630 *f++ = 'e'; 4631 *f++ = 'r'; 4632 *f++ = 'a'; 4633 *f++ = 't'; 4634 *f++ = 'o'; 4635 *f++ = 'r'; 4636 *f = '?'; 4637 } 4638 return n2; 4639 } 4640 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 4641 { 4642 bool r = true; 4643 if (__name_) 4644 r = r && ((__node*)__name_)->fix_forward_references(t_begin, t_end); 4645 if (__left_) 4646 r = r && __left_->fix_forward_references(t_begin, t_end); 4647 if (__right_) 4648 r = r && __right_->fix_forward_references(t_begin, t_end); 4649 return r; 4650 } 4651}; 4652 4653class __operator_mod 4654 : public __node 4655{ 4656public: 4657 4658 __operator_mod() {} 4659 __operator_mod(__node* op1, __node* op2) 4660 { 4661 __left_ = op1; 4662 __right_ = op2; 4663 } 4664 virtual size_t first_size() const 4665 { 4666 if (__cached_size_ == -1) 4667 { 4668 if (__left_) 4669 const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size(); 4670 else 4671 const_cast<long&>(__cached_size_) = sizeof("operator%") - 1; 4672 } 4673 return __cached_size_; 4674 } 4675 virtual char* first_demangled_name(char* buf) const 4676 { 4677 if (__left_) 4678 { 4679 *buf++ = '('; 4680 buf = __left_->get_demangled_name(buf); 4681 strncpy(buf, ") % (", 5); 4682 buf += 5; 4683 buf = __right_->get_demangled_name(buf); 4684 *buf++ = ')'; 4685 } 4686 else 4687 { 4688 strncpy(buf, "operator%", sizeof("operator%") - 1); 4689 buf += sizeof("operator%") - 1; 4690 } 4691 return buf; 4692 } 4693 virtual ptrdiff_t print_first(char* f, char* l) const 4694 { 4695 const ptrdiff_t r = l - f; 4696 if (__left_) 4697 { 4698 const ptrdiff_t n1 = 7; 4699 if (r < n1) 4700 return n1 + __left_->print(l, l) + __right_->print(l, l); 4701 ptrdiff_t sz1 = __left_->print(f+1, l); 4702 if (r < n1 + sz1) 4703 return n1 + sz1 + __right_->print(l, l); 4704 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 4705 if (r >= n1 + sz1 + sz2) 4706 { 4707 *f = '('; 4708 f += 1 + sz1; 4709 *f++ = ')'; 4710 *f++ = ' '; 4711 *f++ = '%'; 4712 *f++ = ' '; 4713 *f = '('; 4714 f += 1 + sz2; 4715 *f = ')'; 4716 } 4717 return n1 + sz1 + sz2; 4718 } 4719 const ptrdiff_t n2 = sizeof("operator%") - 1; 4720 if (r >= n2) 4721 { 4722 *f++ = 'o'; 4723 *f++ = 'p'; 4724 *f++ = 'e'; 4725 *f++ = 'r'; 4726 *f++ = 'a'; 4727 *f++ = 't'; 4728 *f++ = 'o'; 4729 *f++ = 'r'; 4730 *f = '%'; 4731 } 4732 return n2; 4733 } 4734 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 4735 { 4736 bool r = true; 4737 if (__left_) 4738 r = r && __left_->fix_forward_references(t_begin, t_end); 4739 if (__right_) 4740 r = r && __right_->fix_forward_references(t_begin, t_end); 4741 return r; 4742 } 4743}; 4744 4745class __operator_mod_equal 4746 : public __node 4747{ 4748public: 4749 4750 __operator_mod_equal() {} 4751 __operator_mod_equal(__node* op1, __node* op2) 4752 { 4753 __left_ = op1; 4754 __right_ = op2; 4755 } 4756 virtual size_t first_size() const 4757 { 4758 if (__cached_size_ == -1) 4759 { 4760 if (__left_) 4761 const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size(); 4762 else 4763 const_cast<long&>(__cached_size_) = sizeof("operator%=") - 1; 4764 } 4765 return __cached_size_; 4766 } 4767 virtual char* first_demangled_name(char* buf) const 4768 { 4769 if (__left_) 4770 { 4771 *buf++ = '('; 4772 buf = __left_->get_demangled_name(buf); 4773 strncpy(buf, ") %= (", 6); 4774 buf += 6; 4775 buf = __right_->get_demangled_name(buf); 4776 *buf++ = ')'; 4777 } 4778 else 4779 { 4780 strncpy(buf, "operator%=", sizeof("operator%=") - 1); 4781 buf += sizeof("operator%=") - 1; 4782 } 4783 return buf; 4784 } 4785 virtual ptrdiff_t print_first(char* f, char* l) const 4786 { 4787 const ptrdiff_t r = l - f; 4788 if (__left_) 4789 { 4790 const ptrdiff_t n1 = 8; 4791 if (r < n1) 4792 return n1 + __left_->print(l, l) + __right_->print(l, l); 4793 ptrdiff_t sz1 = __left_->print(f+1, l); 4794 if (r < n1 + sz1) 4795 return n1 + sz1 + __right_->print(l, l); 4796 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 4797 if (r >= n1 + sz1 + sz2) 4798 { 4799 *f = '('; 4800 f += 1 + sz1; 4801 *f++ = ')'; 4802 *f++ = ' '; 4803 *f++ = '%'; 4804 *f++ = '='; 4805 *f++ = ' '; 4806 *f = '('; 4807 f += 1 + sz2; 4808 *f = ')'; 4809 } 4810 return n1 + sz1 + sz2; 4811 } 4812 const ptrdiff_t n2 = sizeof("operator%=") - 1; 4813 if (r >= n2) 4814 { 4815 *f++ = 'o'; 4816 *f++ = 'p'; 4817 *f++ = 'e'; 4818 *f++ = 'r'; 4819 *f++ = 'a'; 4820 *f++ = 't'; 4821 *f++ = 'o'; 4822 *f++ = 'r'; 4823 *f++ = '%'; 4824 *f = '='; 4825 } 4826 return n2; 4827 } 4828 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 4829 { 4830 bool r = true; 4831 if (__left_) 4832 r = r && __left_->fix_forward_references(t_begin, t_end); 4833 if (__right_) 4834 r = r && __right_->fix_forward_references(t_begin, t_end); 4835 return r; 4836 } 4837}; 4838 4839class __operator_right_shift 4840 : public __node 4841{ 4842public: 4843 4844 __operator_right_shift() {} 4845 __operator_right_shift(__node* op1, __node* op2) 4846 { 4847 __left_ = op1; 4848 __right_ = op2; 4849 } 4850 virtual size_t first_size() const 4851 { 4852 if (__cached_size_ == -1) 4853 { 4854 if (__left_) 4855 const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size(); 4856 else 4857 const_cast<long&>(__cached_size_) = sizeof("operator>>") - 1; 4858 } 4859 return __cached_size_; 4860 } 4861 virtual char* first_demangled_name(char* buf) const 4862 { 4863 if (__left_) 4864 { 4865 *buf++ = '('; 4866 buf = __left_->get_demangled_name(buf); 4867 strncpy(buf, ") >> (", 6); 4868 buf += 6; 4869 buf = __right_->get_demangled_name(buf); 4870 *buf++ = ')'; 4871 } 4872 else 4873 { 4874 strncpy(buf, "operator>>", sizeof("operator>>") - 1); 4875 buf += sizeof("operator>>") - 1; 4876 } 4877 return buf; 4878 } 4879 virtual ptrdiff_t print_first(char* f, char* l) const 4880 { 4881 const ptrdiff_t r = l - f; 4882 if (__left_) 4883 { 4884 const ptrdiff_t n1 = 8; 4885 if (r < n1) 4886 return n1 + __left_->print(l, l) + __right_->print(l, l); 4887 ptrdiff_t sz1 = __left_->print(f+1, l); 4888 if (r < n1 + sz1) 4889 return n1 + sz1 + __right_->print(l, l); 4890 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 4891 if (r >= n1 + sz1 + sz2) 4892 { 4893 *f = '('; 4894 f += 1 + sz1; 4895 *f++ = ')'; 4896 *f++ = ' '; 4897 *f++ = '>'; 4898 *f++ = '>'; 4899 *f++ = ' '; 4900 *f = '('; 4901 f += 1 + sz2; 4902 *f = ')'; 4903 } 4904 return n1 + sz1 + sz2; 4905 } 4906 const ptrdiff_t n2 = sizeof("operator>>") - 1; 4907 if (r >= n2) 4908 { 4909 *f++ = 'o'; 4910 *f++ = 'p'; 4911 *f++ = 'e'; 4912 *f++ = 'r'; 4913 *f++ = 'a'; 4914 *f++ = 't'; 4915 *f++ = 'o'; 4916 *f++ = 'r'; 4917 *f++ = '>'; 4918 *f = '>'; 4919 } 4920 return n2; 4921 } 4922 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 4923 { 4924 bool r = true; 4925 if (__left_) 4926 r = r && __left_->fix_forward_references(t_begin, t_end); 4927 if (__right_) 4928 r = r && __right_->fix_forward_references(t_begin, t_end); 4929 return r; 4930 } 4931}; 4932 4933class __operator_right_shift_equal 4934 : public __node 4935{ 4936public: 4937 4938 __operator_right_shift_equal() {} 4939 __operator_right_shift_equal(__node* op1, __node* op2) 4940 { 4941 __left_ = op1; 4942 __right_ = op2; 4943 } 4944 virtual size_t first_size() const 4945 { 4946 if (__cached_size_ == -1) 4947 { 4948 if (__left_) 4949 const_cast<long&>(__cached_size_) = __left_->size() + 9 + __right_->size(); 4950 else 4951 const_cast<long&>(__cached_size_) = sizeof("operator>>=") - 1; 4952 } 4953 return __cached_size_; 4954 } 4955 virtual char* first_demangled_name(char* buf) const 4956 { 4957 if (__left_) 4958 { 4959 *buf++ = '('; 4960 buf = __left_->get_demangled_name(buf); 4961 strncpy(buf, ") >>= (", 7); 4962 buf += 7; 4963 buf = __right_->get_demangled_name(buf); 4964 *buf++ = ')'; 4965 } 4966 else 4967 { 4968 strncpy(buf, "operator>>=", sizeof("operator>>=") - 1); 4969 buf += sizeof("operator>>=") - 1; 4970 } 4971 return buf; 4972 } 4973 virtual ptrdiff_t print_first(char* f, char* l) const 4974 { 4975 const ptrdiff_t r = l - f; 4976 if (__left_) 4977 { 4978 const ptrdiff_t n1 = 9; 4979 if (r < n1) 4980 return n1 + __left_->print(l, l) + __right_->print(l, l); 4981 ptrdiff_t sz1 = __left_->print(f+1, l); 4982 if (r < n1 + sz1) 4983 return n1 + sz1 + __right_->print(l, l); 4984 ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l); 4985 if (r >= n1 + sz1 + sz2) 4986 { 4987 *f = '('; 4988 f += 1 + sz1; 4989 *f++ = ')'; 4990 *f++ = ' '; 4991 *f++ = '>'; 4992 *f++ = '>'; 4993 *f++ = '='; 4994 *f++ = ' '; 4995 *f = '('; 4996 f += 1 + sz2; 4997 *f = ')'; 4998 } 4999 return n1 + sz1 + sz2; 5000 } 5001 const ptrdiff_t n2 = sizeof("operator>>=") - 1; 5002 if (r >= n2) 5003 { 5004 *f++ = 'o'; 5005 *f++ = 'p'; 5006 *f++ = 'e'; 5007 *f++ = 'r'; 5008 *f++ = 'a'; 5009 *f++ = 't'; 5010 *f++ = 'o'; 5011 *f++ = 'r'; 5012 *f++ = '>'; 5013 *f++ = '>'; 5014 *f = '='; 5015 } 5016 return n2; 5017 } 5018 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 5019 { 5020 bool r = true; 5021 if (__left_) 5022 r = r && __left_->fix_forward_references(t_begin, t_end); 5023 if (__right_) 5024 r = r && __right_->fix_forward_references(t_begin, t_end); 5025 return r; 5026 } 5027}; 5028 5029class __operator_sizeof_type 5030 : public __node 5031{ 5032public: 5033 5034 __operator_sizeof_type() {} 5035 __operator_sizeof_type(__node* op) 5036 { 5037 __right_ = op; 5038 } 5039 virtual size_t first_size() const 5040 { 5041 if (__cached_size_ == -1) 5042 { 5043 if (__right_) 5044 const_cast<long&>(__cached_size_) = __right_->size() + 9; 5045 else 5046 const_cast<long&>(__cached_size_) = sizeof("operator sizeof") - 1; 5047 } 5048 return __cached_size_; 5049 } 5050 virtual char* first_demangled_name(char* buf) const 5051 { 5052 if (__right_) 5053 { 5054 strncpy(buf, "sizeof (", 8); 5055 buf += 8; 5056 buf = __right_->get_demangled_name(buf); 5057 *buf++ = ')'; 5058 } 5059 else 5060 { 5061 strncpy(buf, "operator sizeof", sizeof("operator sizeof") - 1); 5062 buf += sizeof("operator sizeof") - 1; 5063 } 5064 return buf; 5065 } 5066 virtual ptrdiff_t print_first(char* f, char* l) const 5067 { 5068 const ptrdiff_t r = l - f; 5069 if (__right_) 5070 { 5071 const ptrdiff_t n1 = sizeof("sizeof ()") - 1; 5072 if (r < n1) 5073 return n1 + __right_->print(l, l); 5074 ptrdiff_t sz1 = __right_->print(f+(n1-1), l); 5075 if (r >= n1 + sz1) 5076 { 5077 *f++ = 's'; 5078 *f++ = 'i'; 5079 *f++ = 'z'; 5080 *f++ = 'e'; 5081 *f++ = 'o'; 5082 *f++ = 'f'; 5083 *f++ = ' '; 5084 *f = '('; 5085 f += 1 + sz1; 5086 *f = ')'; 5087 } 5088 return n1 + sz1; 5089 } 5090 const ptrdiff_t n2 = sizeof("operator sizeof") - 1; 5091 if (r >= n2) 5092 { 5093 *f++ = 'o'; 5094 *f++ = 'p'; 5095 *f++ = 'e'; 5096 *f++ = 'r'; 5097 *f++ = 'a'; 5098 *f++ = 't'; 5099 *f++ = 'o'; 5100 *f++ = 'r'; 5101 *f++ = ' '; 5102 *f++ = 's'; 5103 *f++ = 'i'; 5104 *f++ = 'z'; 5105 *f++ = 'e'; 5106 *f++ = 'o'; 5107 *f = 'f'; 5108 } 5109 return n2; 5110 } 5111 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 5112 { 5113 if (__right_) 5114 return __right_->fix_forward_references(t_begin, t_end); 5115 return true; 5116 } 5117}; 5118 5119class __operator_sizeof_expression 5120 : public __node 5121{ 5122public: 5123 5124 __operator_sizeof_expression() {} 5125 __operator_sizeof_expression(__node* op) 5126 { 5127 __right_ = op; 5128 } 5129 virtual size_t first_size() const 5130 { 5131 if (__cached_size_ == -1) 5132 { 5133 if (__right_) 5134 const_cast<long&>(__cached_size_) = __right_->size() + 9; 5135 else 5136 const_cast<long&>(__cached_size_) = sizeof("operator sizeof") - 1; 5137 } 5138 return __cached_size_; 5139 } 5140 virtual char* first_demangled_name(char* buf) const 5141 { 5142 if (__right_) 5143 { 5144 strncpy(buf, "sizeof (", 8); 5145 buf += 8; 5146 buf = __right_->get_demangled_name(buf); 5147 *buf++ = ')'; 5148 } 5149 else 5150 { 5151 strncpy(buf, "operator sizeof", sizeof("operator sizeof") - 1); 5152 buf += sizeof("operator sizeof") - 1; 5153 } 5154 return buf; 5155 } 5156 virtual ptrdiff_t print_first(char* f, char* l) const 5157 { 5158 const ptrdiff_t r = l - f; 5159 if (__right_) 5160 { 5161 const ptrdiff_t n1 = sizeof("sizeof ()") - 1; 5162 if (r < n1) 5163 return n1 + __right_->print(l, l); 5164 ptrdiff_t sz1 = __right_->print(f+(n1-1), l); 5165 if (r >= n1 + sz1) 5166 { 5167 *f++ = 's'; 5168 *f++ = 'i'; 5169 *f++ = 'z'; 5170 *f++ = 'e'; 5171 *f++ = 'o'; 5172 *f++ = 'f'; 5173 *f++ = ' '; 5174 *f = '('; 5175 f += 1 + sz1; 5176 *f = ')'; 5177 } 5178 return n1 + sz1; 5179 } 5180 const ptrdiff_t n2 = sizeof("operator sizeof") - 1; 5181 if (r >= n2) 5182 { 5183 *f++ = 'o'; 5184 *f++ = 'p'; 5185 *f++ = 'e'; 5186 *f++ = 'r'; 5187 *f++ = 'a'; 5188 *f++ = 't'; 5189 *f++ = 'o'; 5190 *f++ = 'r'; 5191 *f++ = ' '; 5192 *f++ = 's'; 5193 *f++ = 'i'; 5194 *f++ = 'z'; 5195 *f++ = 'e'; 5196 *f++ = 'o'; 5197 *f = 'f'; 5198 } 5199 return n2; 5200 } 5201 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 5202 { 5203 if (__right_) 5204 return __right_->fix_forward_references(t_begin, t_end); 5205 return true; 5206 } 5207}; 5208 5209class __typeid 5210 : public __node 5211{ 5212public: 5213 5214 __typeid(__node* op) 5215 { 5216 __right_ = op; 5217 } 5218 virtual size_t first_size() const 5219 { 5220 if (__cached_size_ == -1) 5221 const_cast<long&>(__cached_size_) = __right_->size() + 8; 5222 return __cached_size_; 5223 } 5224 virtual char* first_demangled_name(char* buf) const 5225 { 5226 strncpy(buf, "typeid(", 7); 5227 buf += 7; 5228 buf = __right_->get_demangled_name(buf); 5229 *buf++ = ')'; 5230 return buf; 5231 } 5232 virtual ptrdiff_t print_first(char* f, char* l) const 5233 { 5234 const ptrdiff_t r = l - f; 5235 const ptrdiff_t n1 = sizeof("typeid()") - 1; 5236 if (r < n1) 5237 return n1 + __right_->print(l, l); 5238 ptrdiff_t sz1 = __right_->print(f+(n1-1), l); 5239 if (r >= n1 + sz1) 5240 { 5241 *f++ = 't'; 5242 *f++ = 'y'; 5243 *f++ = 'p'; 5244 *f++ = 'e'; 5245 *f++ = 'i'; 5246 *f++ = 'd'; 5247 *f = '('; 5248 f += 1 + sz1; 5249 *f = ')'; 5250 } 5251 return n1 + sz1; 5252 } 5253 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 5254 { 5255 return __right_->fix_forward_references(t_begin, t_end); 5256 } 5257}; 5258 5259class __throw 5260 : public __node 5261{ 5262public: 5263 5264 __throw(__node* op) 5265 { 5266 __right_ = op; 5267 } 5268 virtual size_t first_size() const 5269 { 5270 if (__cached_size_ == -1) 5271 const_cast<long&>(__cached_size_) = __right_->size() + 6; 5272 return __cached_size_; 5273 } 5274 virtual char* first_demangled_name(char* buf) const 5275 { 5276 strncpy(buf, "throw ", 6); 5277 return __right_->get_demangled_name(buf+6); 5278 } 5279 virtual ptrdiff_t print_first(char* f, char* l) const 5280 { 5281 const ptrdiff_t r = l - f; 5282 const ptrdiff_t n1 = sizeof("throw ") - 1; 5283 if (r < n1) 5284 return n1 + __right_->print(l, l); 5285 ptrdiff_t sz1 = __right_->print(f+n1, l); 5286 if (r >= n1 + sz1) 5287 { 5288 *f++ = 't'; 5289 *f++ = 'h'; 5290 *f++ = 'r'; 5291 *f++ = 'o'; 5292 *f++ = 'w'; 5293 *f = ' '; 5294 } 5295 return n1 + sz1; 5296 } 5297 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 5298 { 5299 return __right_->fix_forward_references(t_begin, t_end); 5300 } 5301}; 5302 5303class __rethrow 5304 : public __node 5305{ 5306 static const ptrdiff_t n = sizeof("throw") - 1; 5307public: 5308 5309 virtual size_t first_size() const {return n;} 5310 virtual char* first_demangled_name(char* buf) const 5311 { 5312 strncpy(buf, "throw", n); 5313 return buf+n; 5314 } 5315 virtual ptrdiff_t print_first(char* f, char* l) const 5316 { 5317 const ptrdiff_t r = l - f; 5318 if (r >= n) 5319 { 5320 *f++ = 't'; 5321 *f++ = 'h'; 5322 *f++ = 'r'; 5323 *f++ = 'o'; 5324 *f = 'w'; 5325 } 5326 return n; 5327 } 5328}; 5329 5330class __operator_sizeof_param_pack 5331 : public __node 5332{ 5333public: 5334 5335 __operator_sizeof_param_pack(__node* op) 5336 { 5337 __right_ = op; 5338 } 5339 virtual size_t first_size() const 5340 { 5341 if (__cached_size_ == -1) 5342 const_cast<long&>(__cached_size_) = __right_->size() + 11; 5343 return __cached_size_; 5344 } 5345 virtual char* first_demangled_name(char* buf) const 5346 { 5347 strncpy(buf, "sizeof...(", 10); 5348 buf += 10; 5349 buf = __right_->get_demangled_name(buf); 5350 *buf++ = ')'; 5351 return buf; 5352 } 5353 virtual ptrdiff_t print_first(char* f, char* l) const 5354 { 5355 const ptrdiff_t r = l - f; 5356 const ptrdiff_t n1 = sizeof("sizeof...()") - 1; 5357 if (r < n1) 5358 return n1 + __right_->print(l, l); 5359 ptrdiff_t sz1 = __right_->print(f+(n1-1), l); 5360 if (r >= n1 + sz1) 5361 { 5362 *f++ = 's'; 5363 *f++ = 'i'; 5364 *f++ = 'z'; 5365 *f++ = 'e'; 5366 *f++ = 'o'; 5367 *f++ = 'f'; 5368 *f++ = '.'; 5369 *f++ = '.'; 5370 *f++ = '.'; 5371 *f = '('; 5372 f += 1+sz1; 5373 *f = ')'; 5374 } 5375 return n1 + sz1; 5376 } 5377 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 5378 { 5379 return __right_->fix_forward_references(t_begin, t_end); 5380 } 5381}; 5382 5383class __const_cast 5384 : public __node 5385{ 5386public: 5387 5388 __const_cast(__node* op1, __node* op2) 5389 { 5390 __left_ = op1; 5391 __right_ = op2; 5392 } 5393 virtual size_t first_size() const 5394 { 5395 if (__cached_size_ == -1) 5396 const_cast<long&>(__cached_size_) = __left_->size() + 14 + __right_->size(); 5397 return __cached_size_; 5398 } 5399 virtual char* first_demangled_name(char* buf) const 5400 { 5401 strncpy(buf, "const_cast<", 11); 5402 buf += 11; 5403 buf = __left_->get_demangled_name(buf); 5404 *buf++ = '>'; 5405 *buf++ = '('; 5406 buf = __right_->get_demangled_name(buf); 5407 *buf++ = ')'; 5408 return buf; 5409 } 5410 virtual ptrdiff_t print_first(char* f, char* l) const 5411 { 5412 const ptrdiff_t r = l - f; 5413 const ptrdiff_t n1 = sizeof("const_cast<>()") - 1; 5414 if (r < n1) 5415 return n1 + __left_->print(l, l) + __right_->print(l, l); 5416 ptrdiff_t sz1 = __left_->print(f+(n1-3), l); 5417 if (r < n1 + sz1) 5418 return n1 + sz1 + __right_->print(l, l); 5419 ptrdiff_t sz2 = __right_->print(f+sz1+(n1-1), l); 5420 if (r >= n1 + sz1 + sz2) 5421 { 5422 *f++ = 'c'; 5423 *f++ = 'o'; 5424 *f++ = 'n'; 5425 *f++ = 's'; 5426 *f++ = 't'; 5427 *f++ = '_'; 5428 *f++ = 'c'; 5429 *f++ = 'a'; 5430 *f++ = 's'; 5431 *f++ = 't'; 5432 *f = '<'; 5433 f += 1+sz1; 5434 *f++ = '>'; 5435 *f = '('; 5436 f += 1+sz2; 5437 *f = ')'; 5438 } 5439 return n1 + sz1 + sz2; 5440 } 5441 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 5442 { 5443 return __left_->fix_forward_references(t_begin, t_end) && 5444 __right_->fix_forward_references(t_begin, t_end); 5445 } 5446}; 5447 5448class __dynamic_cast 5449 : public __node 5450{ 5451public: 5452 5453 __dynamic_cast(__node* op1, __node* op2) 5454 { 5455 __left_ = op1; 5456 __right_ = op2; 5457 } 5458 virtual size_t first_size() const 5459 { 5460 if (__cached_size_ == -1) 5461 const_cast<long&>(__cached_size_) = __left_->size() + 16 + __right_->size(); 5462 return __cached_size_; 5463 } 5464 virtual char* first_demangled_name(char* buf) const 5465 { 5466 strncpy(buf, "dynamic_cast<", 13); 5467 buf += 13; 5468 buf = __left_->get_demangled_name(buf); 5469 *buf++ = '>'; 5470 *buf++ = '('; 5471 buf = __right_->get_demangled_name(buf); 5472 *buf++ = ')'; 5473 return buf; 5474 } 5475 virtual ptrdiff_t print_first(char* f, char* l) const 5476 { 5477 const ptrdiff_t r = l - f; 5478 const ptrdiff_t n1 = sizeof("dynamic_cast<>()") - 1; 5479 if (r < n1) 5480 return n1 + __left_->print(l, l) + __right_->print(l, l); 5481 ptrdiff_t sz1 = __left_->print(f+(n1-3), l); 5482 if (r < n1 + sz1) 5483 return n1 + sz1 + __right_->print(l, l); 5484 ptrdiff_t sz2 = __right_->print(f+sz1+(n1-1), l); 5485 if (r >= n1 + sz1 + sz2) 5486 { 5487 *f++ = 'd'; 5488 *f++ = 'y'; 5489 *f++ = 'n'; 5490 *f++ = 'a'; 5491 *f++ = 'm'; 5492 *f++ = 'i'; 5493 *f++ = 'c'; 5494 *f++ = '_'; 5495 *f++ = 'c'; 5496 *f++ = 'a'; 5497 *f++ = 's'; 5498 *f++ = 't'; 5499 *f = '<'; 5500 f += 1+sz1; 5501 *f++ = '>'; 5502 *f = '('; 5503 f += 1+sz2; 5504 *f = ')'; 5505 } 5506 return n1 + sz1 + sz2; 5507 } 5508 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 5509 { 5510 return __left_->fix_forward_references(t_begin, t_end) && 5511 __right_->fix_forward_references(t_begin, t_end); 5512 } 5513}; 5514 5515class __reinterpret_cast 5516 : public __node 5517{ 5518public: 5519 5520 __reinterpret_cast(__node* op1, __node* op2) 5521 { 5522 __left_ = op1; 5523 __right_ = op2; 5524 } 5525 virtual size_t first_size() const 5526 { 5527 if (__cached_size_ == -1) 5528 const_cast<long&>(__cached_size_) = __left_->size() + 20 + __right_->size(); 5529 return __cached_size_; 5530 } 5531 virtual char* first_demangled_name(char* buf) const 5532 { 5533 strncpy(buf, "reinterpret_cast<", 17); 5534 buf += 17; 5535 buf = __left_->get_demangled_name(buf); 5536 *buf++ = '>'; 5537 *buf++ = '('; 5538 buf = __right_->get_demangled_name(buf); 5539 *buf++ = ')'; 5540 return buf; 5541 } 5542 virtual ptrdiff_t print_first(char* f, char* l) const 5543 { 5544 const ptrdiff_t r = l - f; 5545 const ptrdiff_t n1 = sizeof("reinterpret_cast<>()") - 1; 5546 if (r < n1) 5547 return n1 + __left_->print(l, l) + __right_->print(l, l); 5548 ptrdiff_t sz1 = __left_->print(f+(n1-3), l); 5549 if (r < n1 + sz1) 5550 return n1 + sz1 + __right_->print(l, l); 5551 ptrdiff_t sz2 = __right_->print(f+sz1+(n1-1), l); 5552 if (r >= n1 + sz1 + sz2) 5553 { 5554 *f++ = 'r'; 5555 *f++ = 'e'; 5556 *f++ = 'i'; 5557 *f++ = 'n'; 5558 *f++ = 't'; 5559 *f++ = 'e'; 5560 *f++ = 'r'; 5561 *f++ = 'p'; 5562 *f++ = 'r'; 5563 *f++ = 'e'; 5564 *f++ = 't'; 5565 *f++ = '_'; 5566 *f++ = 'c'; 5567 *f++ = 'a'; 5568 *f++ = 's'; 5569 *f++ = 't'; 5570 *f = '<'; 5571 f += 1+sz1; 5572 *f++ = '>'; 5573 *f = '('; 5574 f += 1+sz2; 5575 *f = ')'; 5576 } 5577 return n1 + sz1 + sz2; 5578 } 5579 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 5580 { 5581 return __left_->fix_forward_references(t_begin, t_end) && 5582 __right_->fix_forward_references(t_begin, t_end); 5583 } 5584}; 5585 5586class __static_cast 5587 : public __node 5588{ 5589public: 5590 5591 __static_cast(__node* op1, __node* op2) 5592 { 5593 __left_ = op1; 5594 __right_ = op2; 5595 } 5596 virtual size_t first_size() const 5597 { 5598 if (__cached_size_ == -1) 5599 const_cast<long&>(__cached_size_) = __left_->size() + 15 + __right_->size(); 5600 return __cached_size_; 5601 } 5602 virtual char* first_demangled_name(char* buf) const 5603 { 5604 strncpy(buf, "static_cast<", 12); 5605 buf += 12; 5606 buf = __left_->get_demangled_name(buf); 5607 *buf++ = '>'; 5608 *buf++ = '('; 5609 buf = __right_->get_demangled_name(buf); 5610 *buf++ = ')'; 5611 return buf; 5612 } 5613 virtual ptrdiff_t print_first(char* f, char* l) const 5614 { 5615 const ptrdiff_t r = l - f; 5616 const ptrdiff_t n1 = sizeof("static_cast<>()") - 1; 5617 if (r < n1) 5618 return n1 + __left_->print(l, l) + __right_->print(l, l); 5619 ptrdiff_t sz1 = __left_->print(f+(n1-3), l); 5620 if (r < n1 + sz1) 5621 return n1 + sz1 + __right_->print(l, l); 5622 ptrdiff_t sz2 = __right_->print(f+sz1+(n1-1), l); 5623 if (r >= n1 + sz1 + sz2) 5624 { 5625 *f++ = 's'; 5626 *f++ = 't'; 5627 *f++ = 'a'; 5628 *f++ = 't'; 5629 *f++ = 'i'; 5630 *f++ = 'c'; 5631 *f++ = '_'; 5632 *f++ = 'c'; 5633 *f++ = 'a'; 5634 *f++ = 's'; 5635 *f++ = 't'; 5636 *f = '<'; 5637 f += 1+sz1; 5638 *f++ = '>'; 5639 *f = '('; 5640 f += 1+sz2; 5641 *f = ')'; 5642 } 5643 return n1 + sz1 + sz2; 5644 } 5645 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 5646 { 5647 return __left_->fix_forward_references(t_begin, t_end) && 5648 __right_->fix_forward_references(t_begin, t_end); 5649 } 5650}; 5651 5652class __call_expr 5653 : public __node 5654{ 5655public: 5656 5657 __call_expr(__node* op1, __node* op2) 5658 { 5659 __left_ = op1; 5660 __right_ = op2; 5661 } 5662 virtual size_t first_size() const 5663 { 5664 if (__cached_size_ == -1) 5665 { 5666 size_t off = __left_->size() + 2; 5667 if (__right_) 5668 off += __right_->size(); 5669 const_cast<long&>(__cached_size_) = off; 5670 } 5671 return __cached_size_; 5672 } 5673 virtual char* first_demangled_name(char* buf) const 5674 { 5675 buf = __left_->get_demangled_name(buf); 5676 *buf++ = '('; 5677 if (__right_) 5678 buf = __right_->get_demangled_name(buf); 5679 *buf++ = ')'; 5680 return buf; 5681 } 5682 virtual ptrdiff_t print_first(char* f, char* l) const 5683 { 5684 const ptrdiff_t r = l - f; 5685 const ptrdiff_t n1 = sizeof("()") - 1; 5686 if (r < n1) 5687 return n1 + __left_->print(l, l) + (__right_ ? __right_->print(l, l) : 0); 5688 ptrdiff_t sz1 = __left_->print(f, l); 5689 if (r < n1 + sz1) 5690 return n1 + sz1 + (__right_ ? __right_->print(l, l) : 0); 5691 ptrdiff_t sz2 = __right_ ? __right_->print(f+sz1+1, l) : 0; 5692 if (r >= n1 + sz1 + sz2) 5693 { 5694 f += sz1; 5695 *f = '('; 5696 f += 1+sz2; 5697 *f = ')'; 5698 } 5699 return n1 + sz1 + sz2; 5700 } 5701 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 5702 { 5703 bool r = __left_->fix_forward_references(t_begin, t_end); 5704 if (__right_) 5705 r = r && __right_->fix_forward_references(t_begin, t_end); 5706 return r; 5707 } 5708}; 5709 5710class __delete_array_expr 5711 : public __node 5712{ 5713public: 5714 5715 __delete_array_expr(bool global, __node* op) 5716 { 5717 __size_ = global; 5718 __right_ = op; 5719 } 5720 virtual size_t first_size() const 5721 { 5722 if (__cached_size_ == -1) 5723 const_cast<long&>(__cached_size_) = (__size_ ? 2 : 0) + 9 + __right_->size(); 5724 return __cached_size_; 5725 } 5726 virtual char* first_demangled_name(char* buf) const 5727 { 5728 if (__size_) 5729 { 5730 *buf++ = ':'; 5731 *buf++ = ':'; 5732 } 5733 strncpy(buf, "delete[] ", 9); 5734 return __right_->get_demangled_name(buf+9); 5735 } 5736 virtual ptrdiff_t print_first(char* f, char* l) const 5737 { 5738 const ptrdiff_t r = l - f; 5739 const ptrdiff_t n1 = sizeof("delete[] ") - 1 + (__size_ ? 2 : 0); 5740 if (r < n1) 5741 return n1 + __right_->print(l, l); 5742 ptrdiff_t sz1 = __right_->print(f+n1, l); 5743 if (r >= n1 + sz1) 5744 { 5745 if (__size_) 5746 { 5747 *f++ = ':'; 5748 *f++ = ':'; 5749 } 5750 *f++ = 'd'; 5751 *f++ = 'e'; 5752 *f++ = 'l'; 5753 *f++ = 'e'; 5754 *f++ = 't'; 5755 *f++ = 'e'; 5756 *f++ = '['; 5757 *f++ = ']'; 5758 *f = ' '; 5759 } 5760 return n1 + sz1; 5761 } 5762 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 5763 { 5764 return __right_->fix_forward_references(t_begin, t_end); 5765 } 5766}; 5767 5768class __delete_expr 5769 : public __node 5770{ 5771public: 5772 5773 __delete_expr(bool global, __node* op) 5774 { 5775 __size_ = global; 5776 __right_ = op; 5777 } 5778 virtual size_t first_size() const 5779 { 5780 if (__cached_size_ == -1) 5781 const_cast<long&>(__cached_size_) = (__size_ ? 2 : 0) + 7 + __right_->size(); 5782 return __cached_size_; 5783 } 5784 virtual char* first_demangled_name(char* buf) const 5785 { 5786 if (__size_) 5787 { 5788 *buf++ = ':'; 5789 *buf++ = ':'; 5790 } 5791 strncpy(buf, "delete ", 7); 5792 return __right_->get_demangled_name(buf+7); 5793 } 5794 virtual ptrdiff_t print_first(char* f, char* l) const 5795 { 5796 const ptrdiff_t r = l - f; 5797 const ptrdiff_t n1 = sizeof("delete ") - 1 + (__size_ ? 2 : 0); 5798 if (r < n1) 5799 return n1 + __right_->print(l, l); 5800 ptrdiff_t sz1 = __right_->print(f+n1, l); 5801 if (r >= n1 + sz1) 5802 { 5803 if (__size_) 5804 { 5805 *f++ = ':'; 5806 *f++ = ':'; 5807 } 5808 *f++ = 'd'; 5809 *f++ = 'e'; 5810 *f++ = 'l'; 5811 *f++ = 'e'; 5812 *f++ = 't'; 5813 *f++ = 'e'; 5814 *f = ' '; 5815 } 5816 return n1 + sz1; 5817 } 5818 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 5819 { 5820 return __right_->fix_forward_references(t_begin, t_end); 5821 } 5822}; 5823 5824class __new_expr 5825 : public __node 5826{ 5827public: 5828 5829 __new_expr(bool global, bool is_array, bool has_init, 5830 __node* expr, __node* type, __node* init) 5831 { 5832 __size_ = (unsigned)global | 5833 ((unsigned)is_array << 1) | 5834 ((unsigned)has_init << 2); 5835 __left_ = expr; 5836 __name_ = (const char*)type; 5837 __right_ = init; 5838 } 5839 virtual size_t first_size() const 5840 { 5841 if (__cached_size_ == -1) 5842 { 5843 size_t off = 4; 5844 if (__size_ & 1) 5845 off += 2; 5846 if (__size_ & 2) 5847 off += 2; 5848 if (__left_) 5849 { 5850 off += 2; 5851 off += __left_->size(); 5852 } 5853 __node* type = (__node*)__name_; 5854 off += type->size(); 5855 if (__size_ & 4) 5856 { 5857 off += 2; 5858 if (__right_) 5859 off += __right_->size(); 5860 } 5861 const_cast<long&>(__cached_size_) = off; 5862 } 5863 return __cached_size_; 5864 } 5865 virtual char* first_demangled_name(char* buf) const 5866 { 5867 if (__size_ & 1) 5868 { 5869 *buf++ = ':'; 5870 *buf++ = ':'; 5871 } 5872 *buf++ = 'n'; 5873 *buf++ = 'e'; 5874 *buf++ = 'w'; 5875 if (__size_ & 2) 5876 { 5877 *buf++ = '['; 5878 *buf++ = ']'; 5879 } 5880 if (__left_) 5881 { 5882 *buf++ = '('; 5883 buf = __left_->get_demangled_name(buf); 5884 *buf++ = ')'; 5885 } 5886 *buf++ = ' '; 5887 __node* type = (__node*)__name_; 5888 buf = type->get_demangled_name(buf); 5889 if (__size_ & 4) 5890 { 5891 *buf++ = '('; 5892 if (__right_) 5893 buf = __right_->get_demangled_name(buf); 5894 *buf++ = ')'; 5895 } 5896 return buf; 5897 } 5898 virtual ptrdiff_t print_first(char* f, char* l) const 5899 { 5900 const ptrdiff_t r = l - f; 5901 const ptrdiff_t n1 = sizeof("new ") - 1 + (__size_ & 1 ? 2 : 0) + 5902 (__size_ & 2 ? 2 : 0) + (__left_ ? 2 : 0) + (__size_ & 4 ? 2 : 0); 5903 __node* type = (__node*)__name_; 5904 if (r < n1) 5905 return n1 + (__left_ ? __left_->print(l, l) : 0) + 5906 type->print(l, l) + 5907 (__right_ ? __right_->print(l, l) : 0); 5908 ptrdiff_t sz1 = __left_ ? __left_->print(f+4+ 5909 (__size_ & 1 ? 2 : 0) + 5910 (__size_ & 2 ? 2 : 0), l) : 0; 5911 if (r < n1 + sz1) 5912 return n1 + sz1 + type->print(l, l) + 5913 (__right_ ? __right_->print(l, l) : 0); 5914 ptrdiff_t sz2 = type->print(f+(n1-(__size_ & 4 ? 2 : 0)+sz1), l); 5915 if (r < n1 + sz1 + sz2) 5916 return n1 + sz1 + sz2 + (__right_ ? __right_->print(l, l) : 0); 5917 ptrdiff_t sz3 = __right_ ? __right_->print(f+(n1-1)+sz1+sz2, l) : 0; 5918 if (r >= n1 + sz1 + sz2 + sz3) 5919 { 5920 if (__size_ & 1) 5921 { 5922 *f++ = ':'; 5923 *f++ = ':'; 5924 } 5925 *f++ = 'n'; 5926 *f++ = 'e'; 5927 *f++ = 'w'; 5928 if (__size_ & 2) 5929 { 5930 *f++ = '['; 5931 *f++ = ']'; 5932 } 5933 if (__left_) 5934 { 5935 *f = '('; 5936 f += 1 + sz1; 5937 *f++ = ')'; 5938 } 5939 *f = ' '; 5940 if (__size_ & 4) 5941 { 5942 f += 1 + sz2; 5943 *f = '('; 5944 f += 1 + sz3; 5945 *f = ')'; 5946 } 5947 } 5948 return n1 + sz1 + sz2 + sz3; 5949 } 5950 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 5951 { 5952 __node* type = (__node*)__name_; 5953 bool r = type->fix_forward_references(t_begin, t_end); 5954 if (__left_) 5955 r = r && __left_->fix_forward_references(t_begin, t_end);; 5956 if (__right_) 5957 r = r && __right_->fix_forward_references(t_begin, t_end);; 5958 return r; 5959 } 5960}; 5961 5962class __dot_star_expr 5963 : public __node 5964{ 5965public: 5966 5967 __dot_star_expr(__node* op1, __node* op2) 5968 { 5969 __left_ = op1; 5970 __right_ = op2; 5971 } 5972 virtual size_t first_size() const 5973 { 5974 if (__cached_size_ == -1) 5975 const_cast<long&>(__cached_size_) = __left_->size() + 2 + __right_->size(); 5976 return __cached_size_; 5977 } 5978 virtual char* first_demangled_name(char* buf) const 5979 { 5980 buf = __left_->get_demangled_name(buf); 5981 *buf++ = '.'; 5982 *buf++ = '*'; 5983 return __right_->get_demangled_name(buf); 5984 } 5985 virtual ptrdiff_t print_first(char* f, char* l) const 5986 { 5987 const ptrdiff_t r = l - f; 5988 const ptrdiff_t n = sizeof(".*") - 1; 5989 if (r < n) 5990 return n + __left_->print(l, l) + __right_->print(l, l); 5991 ptrdiff_t sz1 = __left_->print(f, l); 5992 if (r < n + sz1) 5993 return n + sz1 + __right_->print(l, l); 5994 ptrdiff_t sz2 = __right_->print(f+sz1+n, l); 5995 if (r >= n + sz1 + sz2) 5996 { 5997 f += sz1; 5998 *f++ = '.'; 5999 *f = '*'; 6000 } 6001 return n + sz1 + sz2; 6002 } 6003 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 6004 { 6005 return __left_->fix_forward_references(t_begin, t_end) && 6006 __right_->fix_forward_references(t_begin, t_end); 6007 } 6008}; 6009 6010class __dot_expr 6011 : public __node 6012{ 6013public: 6014 6015 __dot_expr(__node* op1, __node* op2) 6016 { 6017 __left_ = op1; 6018 __right_ = op2; 6019 } 6020 virtual size_t first_size() const 6021 { 6022 if (__cached_size_ == -1) 6023 const_cast<long&>(__cached_size_) = __left_->size() + 1 + __right_->size(); 6024 return __cached_size_; 6025 } 6026 virtual char* first_demangled_name(char* buf) const 6027 { 6028 buf = __left_->get_demangled_name(buf); 6029 *buf++ = '.'; 6030 return __right_->get_demangled_name(buf); 6031 } 6032 virtual ptrdiff_t print_first(char* f, char* l) const 6033 { 6034 const ptrdiff_t r = l - f; 6035 const ptrdiff_t n = sizeof(".") - 1; 6036 if (r < n) 6037 return n + __left_->print(l, l) + __right_->print(l, l); 6038 ptrdiff_t sz1 = __left_->print(f, l); 6039 if (r < n + sz1) 6040 return n + sz1 + __right_->print(l, l); 6041 ptrdiff_t sz2 = __right_->print(f+sz1+n, l); 6042 if (r >= n + sz1 + sz2) 6043 f[sz1] = '.'; 6044 return n + sz1 + sz2; 6045 } 6046 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 6047 { 6048 return __left_->fix_forward_references(t_begin, t_end) && 6049 __right_->fix_forward_references(t_begin, t_end); 6050 } 6051}; 6052 6053class __arrow_expr 6054 : public __node 6055{ 6056public: 6057 6058 __arrow_expr(__node* op1, __node* op2) 6059 { 6060 __left_ = op1; 6061 __right_ = op2; 6062 } 6063 virtual size_t first_size() const 6064 { 6065 if (__cached_size_ == -1) 6066 const_cast<long&>(__cached_size_) = __left_->size() + 2 + __right_->size(); 6067 return __cached_size_; 6068 } 6069 virtual char* first_demangled_name(char* buf) const 6070 { 6071 buf = __left_->get_demangled_name(buf); 6072 *buf++ = '-'; 6073 *buf++ = '>'; 6074 return __right_->get_demangled_name(buf); 6075 } 6076 virtual ptrdiff_t print_first(char* f, char* l) const 6077 { 6078 const ptrdiff_t r = l - f; 6079 const ptrdiff_t n = sizeof("->") - 1; 6080 if (r < n) 6081 return n + __left_->print(l, l) + __right_->print(l, l); 6082 ptrdiff_t sz1 = __left_->print(f, l); 6083 if (r < n + sz1) 6084 return n + sz1 + __right_->print(l, l); 6085 ptrdiff_t sz2 = __right_->print(f+sz1+n, l); 6086 if (r >= n + sz1 + sz2) 6087 { 6088 f += sz1; 6089 *f++ = '-'; 6090 *f = '>'; 6091 } 6092 return n + sz1 + sz2; 6093 } 6094 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 6095 { 6096 return __left_->fix_forward_references(t_begin, t_end) && 6097 __right_->fix_forward_references(t_begin, t_end); 6098 } 6099}; 6100 6101class __std_qualified_name 6102 : public __node 6103{ 6104 static const ptrdiff_t n = sizeof("std") - 1; 6105public: 6106 6107 __std_qualified_name() 6108 { 6109 } 6110 virtual size_t first_size() const 6111 { 6112 return n; 6113 } 6114 6115 virtual char* first_demangled_name(char* buf) const 6116 { 6117 *buf++ = 's'; 6118 *buf++ = 't'; 6119 *buf++ = 'd'; 6120 return buf; 6121 } 6122 virtual ptrdiff_t print_first(char* f, char* l) const 6123 { 6124 const ptrdiff_t r = l - f; 6125 if (r >= n) 6126 { 6127 *f++ = 's'; 6128 *f++ = 't'; 6129 *f = 'd'; 6130 } 6131 return n; 6132 } 6133}; 6134 6135class __sub_allocator 6136 : public __node 6137{ 6138 static const ptrdiff_t n = sizeof("std::allocator") - 1; 6139public: 6140 6141 virtual size_t first_size() const 6142 { 6143 return n; 6144 } 6145 virtual char* first_demangled_name(char* buf) const 6146 { 6147 strncpy(buf, "std::allocator", n); 6148 return buf + n; 6149 } 6150 virtual ptrdiff_t print_first(char* f, char* l) const 6151 { 6152 const ptrdiff_t r = l - f; 6153 if (r >= n) 6154 { 6155 *f++ = 's'; 6156 *f++ = 't'; 6157 *f++ = 'd'; 6158 *f++ = ':'; 6159 *f++ = ':'; 6160 *f++ = 'a'; 6161 *f++ = 'l'; 6162 *f++ = 'l'; 6163 *f++ = 'o'; 6164 *f++ = 'c'; 6165 *f++ = 'a'; 6166 *f++ = 't'; 6167 *f++ = 'o'; 6168 *f = 'r'; 6169 } 6170 return n; 6171 } 6172}; 6173 6174class __sub_basic_string 6175 : public __node 6176{ 6177 static const ptrdiff_t n = sizeof("std::basic_string") - 1; 6178public: 6179 6180 virtual size_t first_size() const 6181 { 6182 return n; 6183 } 6184 virtual char* first_demangled_name(char* buf) const 6185 { 6186 strncpy(buf, "std::basic_string", n); 6187 return buf + n; 6188 } 6189 virtual ptrdiff_t print_first(char* f, char* l) const 6190 { 6191 const ptrdiff_t r = l - f; 6192 if (r >= n) 6193 { 6194 *f++ = 's'; 6195 *f++ = 't'; 6196 *f++ = 'd'; 6197 *f++ = ':'; 6198 *f++ = ':'; 6199 *f++ = 'b'; 6200 *f++ = 'a'; 6201 *f++ = 's'; 6202 *f++ = 'i'; 6203 *f++ = 'c'; 6204 *f++ = '_'; 6205 *f++ = 's'; 6206 *f++ = 't'; 6207 *f++ = 'r'; 6208 *f++ = 'i'; 6209 *f++ = 'n'; 6210 *f = 'g'; 6211 } 6212 return n; 6213 } 6214}; 6215 6216class __sub_string 6217 : public __node 6218{ 6219 static const size_t n = sizeof("std::string") - 1; 6220 static const size_t ne = sizeof("std::basic_string<char, std::char_traits<char>, std::allocator<char> >") - 1; 6221public: 6222 6223 virtual size_t first_size() const 6224 { 6225 if (__size_) 6226 return ne; 6227 return n; 6228 } 6229 virtual char* first_demangled_name(char* buf) const 6230 { 6231 if (__size_) 6232 { 6233 strncpy(buf, "std::basic_string<char, std::char_traits<char>, std::allocator<char> >", ne); 6234 buf += ne; 6235 } 6236 else 6237 { 6238 strncpy(buf, "std::string", n); 6239 buf += n; 6240 } 6241 return buf; 6242 } 6243 6244 virtual ptrdiff_t print_first(char* f, char* l) const 6245 { 6246 const ptrdiff_t r = l - f; 6247 if (__size_) 6248 { 6249 const ptrdiff_t n1 = 6250 sizeof("std::basic_string<char, std::char_traits<char>," 6251 " std::allocator<char> >") - 1; 6252 if (r >= n1) 6253 strncpy(f, "std::basic_string<char, std::char_traits<char>," 6254 " std::allocator<char> >", n1); 6255 return n1; 6256 } 6257 const ptrdiff_t n2 = sizeof("std::string") - 1; 6258 if (r >= n2) 6259 { 6260 *f++ = 's'; 6261 *f++ = 't'; 6262 *f++ = 'd'; 6263 *f++ = ':'; 6264 *f++ = ':'; 6265 *f++ = 's'; 6266 *f++ = 't'; 6267 *f++ = 'r'; 6268 *f++ = 'i'; 6269 *f++ = 'n'; 6270 *f = 'g'; 6271 } 6272 return n2; 6273 } 6274 virtual size_t base_size() const 6275 { 6276 return 12; 6277 } 6278 virtual char* get_base_name(char* buf) const 6279 { 6280 strncpy(buf, "basic_string", 12); 6281 return buf + 12; 6282 } 6283 virtual ptrdiff_t print_base_name(char* f, char* l) const 6284 { 6285 const ptrdiff_t r = l - f; 6286 const ptrdiff_t n = sizeof("basic_string") - 1; 6287 if (r >= n) 6288 { 6289 *f++ = 'b'; 6290 *f++ = 'a'; 6291 *f++ = 's'; 6292 *f++ = 'i'; 6293 *f++ = 'c'; 6294 *f++ = '_'; 6295 *f++ = 's'; 6296 *f++ = 't'; 6297 *f++ = 'r'; 6298 *f++ = 'i'; 6299 *f++ = 'n'; 6300 *f = 'g'; 6301 } 6302 return n; 6303 } 6304 6305 virtual __node* base_name() const 6306 { 6307 const_cast<size_t&>(__size_) = true; 6308 return const_cast<__node*>(static_cast<const __node*>(this)); 6309 } 6310}; 6311 6312class __sub_istream 6313 : public __node 6314{ 6315 static const ptrdiff_t n = sizeof("std::istream") - 1; 6316public: 6317 6318 virtual size_t first_size() const {return n;} 6319 virtual char* first_demangled_name(char* buf) const 6320 { 6321 strncpy(buf, "std::istream", n); 6322 return buf + n; 6323 } 6324 virtual ptrdiff_t print_first(char* f, char* l) const 6325 { 6326 const ptrdiff_t r = l - f; 6327 if (r >= n) 6328 { 6329 *f++ = 's'; 6330 *f++ = 't'; 6331 *f++ = 'd'; 6332 *f++ = ':'; 6333 *f++ = ':'; 6334 *f++ = 'i'; 6335 *f++ = 's'; 6336 *f++ = 't'; 6337 *f++ = 'r'; 6338 *f++ = 'e'; 6339 *f++ = 'a'; 6340 *f = 'm'; 6341 } 6342 return n; 6343 } 6344}; 6345 6346class __sub_ostream 6347 : public __node 6348{ 6349 static const ptrdiff_t n = sizeof("std::ostream") - 1; 6350public: 6351 6352 virtual size_t first_size() const {return n;} 6353 virtual char* first_demangled_name(char* buf) const 6354 { 6355 strncpy(buf, "std::ostream", n); 6356 return buf + n; 6357 } 6358 virtual ptrdiff_t print_first(char* f, char* l) const 6359 { 6360 const ptrdiff_t r = l - f; 6361 if (r >= n) 6362 { 6363 *f++ = 's'; 6364 *f++ = 't'; 6365 *f++ = 'd'; 6366 *f++ = ':'; 6367 *f++ = ':'; 6368 *f++ = 'o'; 6369 *f++ = 's'; 6370 *f++ = 't'; 6371 *f++ = 'r'; 6372 *f++ = 'e'; 6373 *f++ = 'a'; 6374 *f = 'm'; 6375 } 6376 return n; 6377 } 6378}; 6379 6380class __sub_iostream 6381 : public __node 6382{ 6383 static const ptrdiff_t n = sizeof("std::iostream") - 1; 6384public: 6385 6386 virtual size_t first_size() const {return n;} 6387 virtual char* first_demangled_name(char* buf) const 6388 { 6389 strncpy(buf, "std::iostream", n); 6390 return buf + n; 6391 } 6392 virtual ptrdiff_t print_first(char* f, char* l) const 6393 { 6394 const ptrdiff_t r = l - f; 6395 if (r >= n) 6396 { 6397 *f++ = 's'; 6398 *f++ = 't'; 6399 *f++ = 'd'; 6400 *f++ = ':'; 6401 *f++ = ':'; 6402 *f++ = 'i'; 6403 *f++ = 'o'; 6404 *f++ = 's'; 6405 *f++ = 't'; 6406 *f++ = 'r'; 6407 *f++ = 'e'; 6408 *f++ = 'a'; 6409 *f = 'm'; 6410 } 6411 return n; 6412 } 6413}; 6414 6415class __sub 6416 : public __node 6417{ 6418public: 6419 6420 explicit __sub(__node* arg) 6421 { 6422 __left_ = arg; 6423 } 6424 explicit __sub(size_t arg) 6425 { 6426 __size_ = arg; 6427 } 6428 virtual size_t first_size() const 6429 { 6430 return __left_->first_size(); 6431 } 6432 virtual char* first_demangled_name(char* buf) const 6433 { 6434 return __left_->first_demangled_name(buf); 6435 } 6436 virtual size_t second_size() const 6437 { 6438 return __left_->second_size(); 6439 } 6440 virtual char* second_demangled_name(char* buf) const 6441 { 6442 return __left_->second_demangled_name(buf); 6443 } 6444 virtual ptrdiff_t print_first(char* f, char* l) const 6445 { 6446 return __left_->print_first(f, l); 6447 } 6448 virtual ptrdiff_t print_second(char* f, char* l) const 6449 { 6450 return __left_->print_second(f, l); 6451 } 6452 virtual bool ends_with_template() const 6453 { 6454 return __left_->ends_with_template(); 6455 } 6456 virtual __node* base_name() const 6457 { 6458 return __left_->base_name(); 6459 } 6460 virtual bool is_reference_or_pointer_to_function_or_array() const 6461 { 6462 return __left_->is_reference_or_pointer_to_function_or_array(); 6463 } 6464 virtual bool is_function() const 6465 { 6466 return __left_->is_function(); 6467 } 6468 virtual bool is_cv_qualifer() const 6469 { 6470 return __left_->is_cv_qualifer(); 6471 } 6472 virtual bool is_ctor_dtor_conv() const 6473 { 6474 return __left_->is_ctor_dtor_conv(); 6475 } 6476 virtual bool is_array() const 6477 { 6478 return __left_->is_array(); 6479 } 6480 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 6481 { 6482 if (__left_ == 0) 6483 { 6484 if (__size_ < t_end - t_begin) 6485 { 6486 __left_ = t_begin[__size_]; 6487 __size_ = 0; 6488 } 6489 else 6490 return false; 6491 } 6492 return true; 6493 } 6494 virtual size_t list_len() const 6495 { 6496 return __left_->list_len(); 6497 } 6498 virtual bool is_sub() const 6499 { 6500 return true; 6501 } 6502}; 6503 6504class __unscoped_template_name 6505 : public __node 6506{ 6507public: 6508 __unscoped_template_name(__node* name, __node* args) 6509 {__left_ = name; __right_ = args;} 6510 6511 virtual size_t first_size() const 6512 { 6513 if (__cached_size_ == -1) 6514 const_cast<long&>(__cached_size_) = __left_->size() + __right_->size(); 6515 return __cached_size_; 6516 } 6517 virtual char* first_demangled_name(char* buf) const 6518 { 6519 buf = __left_->get_demangled_name(buf); 6520 return __right_->get_demangled_name(buf); 6521 } 6522 virtual ptrdiff_t print_first(char* f, char* l) const 6523 { 6524 const ptrdiff_t r = l - f; 6525 ptrdiff_t sz1 = __left_->print(f, l); 6526 if (r < sz1) 6527 return sz1 + __right_->print(l, l); 6528 return sz1 + __right_->print(f + sz1, l); 6529 } 6530 virtual bool ends_with_template() const 6531 { 6532 return __right_->ends_with_template(); 6533 } 6534 virtual __node* base_name() const 6535 { 6536 return __left_->base_name(); 6537 } 6538 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 6539 { 6540 return __left_->fix_forward_references(t_begin, t_end) && 6541 __right_->fix_forward_references(t_begin, t_end); 6542 } 6543}; 6544 6545// length == 0: __left_ == NULL 6546// length == 1: __left_ != NULL, __right_ == NULL 6547// length > 1: __left_ != NULL, __right_ != NULL 6548class __list 6549 : public __node 6550{ 6551public: 6552 explicit __list(__node* type) 6553 {__left_ = type;} 6554 6555 virtual size_t first_size() const 6556 { 6557 if (__cached_size_ == -1) 6558 { 6559 if (__left_ == NULL) 6560 const_cast<long&>(__cached_size_) = 0; 6561 else if (__right_ == NULL) 6562 const_cast<long&>(__cached_size_) = __left_->size(); 6563 else 6564 { 6565 size_t off = __right_->size(); 6566 if (off > 0) 6567 off += 2; 6568 const_cast<long&>(__cached_size_) = __left_->size() + off; 6569 } 6570 } 6571 return __cached_size_; 6572 } 6573 virtual char* first_demangled_name(char* buf) const 6574 { 6575 if (__left_ != NULL) 6576 { 6577 char* t = __left_->get_demangled_name(buf + (__size_ ? 2 : 0)); 6578 if (__size_ == 0) 6579 buf = t; 6580 else if (t != buf+2) 6581 { 6582 *buf++ = ','; 6583 *buf++ = ' '; 6584 buf = t; 6585 } 6586 if (__right_) 6587 buf = __right_->get_demangled_name(buf); 6588 } 6589 return buf; 6590 } 6591 virtual ptrdiff_t print_first(char* f, char* l) const 6592 { 6593 if (__left_ == 0) 6594 return 0; 6595 const ptrdiff_t r = l - f; 6596 ptrdiff_t n = 0; 6597 if (__size_) 6598 { 6599 n = 2; 6600 if (r < n) 6601 { 6602 ptrdiff_t sz1 = __left_->print(l, l); 6603 if (sz1 == 0) 6604 n = 0; 6605 return n + sz1 + (__right_ ? __right_->print(l, l) : 0); 6606 } 6607 } 6608 const ptrdiff_t sz1 = __left_->print(f+n, l); 6609 if (sz1 == 0) 6610 n = 0; 6611 else if (n != 0) 6612 { 6613 f[0] = ','; 6614 f[1] = ' '; 6615 } 6616 const ptrdiff_t sz2 = __right_ ? __right_->print(f+std::min(n+sz1, r), l) : 0; 6617 return n + sz1 + sz2; 6618 } 6619 virtual bool ends_with_template() const 6620 { 6621 if (__right_ != NULL) 6622 return __right_->ends_with_template(); 6623 if (__left_ != NULL) 6624 return __left_->ends_with_template(); 6625 return false; 6626 } 6627 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 6628 { 6629 bool r = true; 6630 if (__left_) 6631 r = r && __left_->fix_forward_references(t_begin, t_end); 6632 if (__right_) 6633 r = r && __right_->fix_forward_references(t_begin, t_end); 6634 return r; 6635 } 6636 virtual size_t list_len() const 6637 { 6638 if (!__left_) 6639 return 0; 6640 if (!__right_) 6641 return 1; 6642 return 1 + __right_->list_len(); 6643 } 6644}; 6645 6646class __template_args 6647 : public __node 6648{ 6649public: 6650 __template_args(__node* name, __node* list) 6651 { 6652 __left_ = name; 6653 __right_ = list; 6654 } 6655 6656 virtual size_t first_size() const 6657 { 6658 if (__cached_size_ == -1) 6659 { 6660 size_t off = 2; 6661 if (__right_) 6662 { 6663 if (__right_->ends_with_template()) 6664 ++off; 6665 off += __right_->size(); 6666 } 6667 const_cast<long&>(__cached_size_) = __left_->size() + off; 6668 } 6669 return __cached_size_; 6670 } 6671 virtual char* first_demangled_name(char* buf) const 6672 { 6673 buf = __left_->get_demangled_name(buf); 6674 *buf++ = '<'; 6675 if (__right_) 6676 { 6677 buf = __right_->get_demangled_name(buf); 6678 if (buf[-1] == '>') 6679 *buf++ = ' '; 6680 } 6681 *buf++ = '>'; 6682 return buf; 6683 } 6684 virtual ptrdiff_t print_first(char* f, char* l) const 6685 { 6686 const ptrdiff_t r = l - f; 6687 const ptrdiff_t sz1 = __left_->print(f, l); 6688 ptrdiff_t sz2 = 0; 6689 ptrdiff_t n = 2; 6690 if (__right_) 6691 { 6692 sz2 = __right_->print(f+std::min(sz1+1, r), l); 6693 if (r >= sz1 + sz2 + 2) 6694 { 6695 if (f[sz1+sz2] == '>') 6696 { 6697 f[sz1+sz2+1] = ' '; 6698 ++n; 6699 } 6700 } 6701 else if (__right_->ends_with_template()) 6702 ++n; 6703 } 6704 if (r >= sz1 + sz2 + n) 6705 { 6706 f[sz1] = '<'; 6707 f[sz1+sz2+n-1] = '>'; 6708 } 6709 return n + sz1 + sz2; 6710 } 6711 6712 virtual bool ends_with_template() const 6713 { 6714 return true; 6715 } 6716 virtual __node* base_name() const 6717 { 6718 return __left_->base_name(); 6719 } 6720 virtual bool is_ctor_dtor_conv() const 6721 { 6722 return __left_->is_ctor_dtor_conv(); 6723 } 6724 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 6725 { 6726 bool r = __left_->fix_forward_references(t_begin, t_end); 6727 if (__right_) 6728 r = r && __right_->fix_forward_references(t_begin, t_end); 6729 return r; 6730 } 6731}; 6732 6733class __function_args 6734 : public __node 6735{ 6736public: 6737 __function_args(__node* list) 6738 {__right_ = list;} 6739 6740 virtual size_t first_size() const 6741 { 6742 if (__cached_size_ == -1) 6743 const_cast<long&>(__cached_size_) = 2 + __right_->size(); 6744 return __cached_size_; 6745 } 6746 virtual char* first_demangled_name(char* buf) const 6747 { 6748 *buf++ = '('; 6749 buf = __right_->get_demangled_name(buf); 6750 *buf++ = ')'; 6751 return buf; 6752 } 6753 virtual ptrdiff_t print_first(char* f, char* l) const 6754 { 6755 const ptrdiff_t r = l - f; 6756 const ptrdiff_t n = 2; 6757 if (r < n) 6758 return n + __right_->print(l, l); 6759 ptrdiff_t sz1 = __right_->print(f+1, l); 6760 if (r >= n + sz1) 6761 { 6762 *f = '('; 6763 f += 1 + sz1; 6764 *f = ')'; 6765 } 6766 return n + sz1; 6767 } 6768 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 6769 { 6770 return __right_->fix_forward_references(t_begin, t_end); 6771 } 6772}; 6773 6774class __cv_qualifiers 6775 : public __node 6776{ 6777public: 6778 __cv_qualifiers(size_t cv, __node* type) 6779 { 6780 __left_ = type; 6781 __size_ = __left_->is_function() ? cv << 5 : cv; 6782 } 6783 6784 virtual size_t first_size() const 6785 { 6786 size_t s = __left_->first_size(); 6787 if (__size_ & 4) 6788 s += sizeof(" restrict")-1; 6789 if (__size_ & 2) 6790 s += sizeof(" volatile")-1; 6791 if (__size_ & 1) 6792 s += sizeof(" const")-1; 6793 if (__size_ & 8) 6794 s += sizeof(" &")-1; 6795 if (__size_ & 16) 6796 s += sizeof(" &&")-1; 6797 return s; 6798 } 6799 virtual char* first_demangled_name(char* buf) const 6800 { 6801 buf = __left_->first_demangled_name(buf); 6802 if (__size_ & 1) 6803 { 6804 const size_t n = sizeof(" const")-1; 6805 strncpy(buf, " const", n); 6806 buf += n; 6807 } 6808 if (__size_ & 2) 6809 { 6810 const size_t n = sizeof(" volatile")-1; 6811 strncpy(buf, " volatile", n); 6812 buf += n; 6813 } 6814 if (__size_ & 4) 6815 { 6816 const size_t n = sizeof(" restrict")-1; 6817 strncpy(buf, " restrict", n); 6818 buf += n; 6819 } 6820 if (__size_ & 8) 6821 { 6822 *buf++ = ' '; 6823 *buf++ = '&'; 6824 } 6825 if (__size_ & 16) 6826 { 6827 *buf++ = ' '; 6828 *buf++ = '&'; 6829 *buf++ = '&'; 6830 } 6831 return buf; 6832 } 6833 virtual ptrdiff_t print_first(char* f, char* l) const 6834 { 6835 const ptrdiff_t r = l - f; 6836 const ptrdiff_t sz = __left_->print_first(f, l); 6837 ptrdiff_t n = 0; 6838 if (__size_ & 0x1F) 6839 { 6840 if (__size_ & 1) 6841 { 6842 const ptrdiff_t d = sizeof(" const")-1; 6843 if (r >= sz + n + d) 6844 { 6845 char* t = f + sz + n; 6846 *t++ = ' '; 6847 *t++ = 'c'; 6848 *t++ = 'o'; 6849 *t++ = 'n'; 6850 *t++ = 's'; 6851 *t = 't'; 6852 } 6853 n += d; 6854 } 6855 if (__size_ & 2) 6856 { 6857 const ptrdiff_t d = sizeof(" volatile")-1; 6858 if (r >= sz + n + d) 6859 { 6860 char* t = f + sz + n; 6861 *t++ = ' '; 6862 *t++ = 'v'; 6863 *t++ = 'o'; 6864 *t++ = 'l'; 6865 *t++ = 'a'; 6866 *t++ = 't'; 6867 *t++ = 'i'; 6868 *t++ = 'l'; 6869 *t = 'e'; 6870 } 6871 n += d; 6872 } 6873 if (__size_ & 4) 6874 { 6875 const ptrdiff_t d = sizeof(" restrict")-1; 6876 if (r >= sz + n + d) 6877 { 6878 char* t = f + sz + n; 6879 *t++ = ' '; 6880 *t++ = 'r'; 6881 *t++ = 'e'; 6882 *t++ = 's'; 6883 *t++ = 't'; 6884 *t++ = 'r'; 6885 *t++ = 'i'; 6886 *t++ = 'c'; 6887 *t = 't'; 6888 } 6889 n += d; 6890 } 6891 if (__size_ & 8) 6892 { 6893 const ptrdiff_t d = sizeof(" &")-1; 6894 if (r >= sz + n + d) 6895 { 6896 char* t = f + sz + n; 6897 *t++ = ' '; 6898 *t = '&'; 6899 } 6900 n += d; 6901 } 6902 if (__size_ & 16) 6903 { 6904 const ptrdiff_t d = sizeof(" &&")-1; 6905 if (r >= sz + n + d) 6906 { 6907 char* t = f + sz + n; 6908 *t++ = ' '; 6909 *t++ = '&'; 6910 *t = '&'; 6911 } 6912 n += d; 6913 } 6914 } 6915 return n + sz; 6916 } 6917 virtual size_t second_size() const 6918 { 6919 size_t s = __left_->second_size(); 6920 if (__size_ & 128) 6921 s += sizeof(" restrict")-1; 6922 if (__size_ & 64) 6923 s += sizeof(" volatile")-1; 6924 if (__size_ & 32) 6925 s += sizeof(" const")-1; 6926 if (__size_ & 256) 6927 s += sizeof(" &")-1; 6928 if (__size_ & 512) 6929 s += sizeof(" &&")-1; 6930 return s; 6931 } 6932 virtual char* second_demangled_name(char* buf) const 6933 { 6934 buf = __left_->second_demangled_name(buf); 6935 if (__size_ & 32) 6936 { 6937 const size_t n = sizeof(" const")-1; 6938 strncpy(buf, " const", n); 6939 buf += n; 6940 } 6941 if (__size_ & 64) 6942 { 6943 const size_t n = sizeof(" volatile")-1; 6944 strncpy(buf, " volatile", n); 6945 buf += n; 6946 } 6947 if (__size_ & 128) 6948 { 6949 const size_t n = sizeof(" restrict")-1; 6950 strncpy(buf, " restrict", n); 6951 buf += n; 6952 } 6953 if (__size_ & 256) 6954 { 6955 *buf++ = ' '; 6956 *buf++ = '&'; 6957 } 6958 if (__size_ & 512) 6959 { 6960 *buf++ = ' '; 6961 *buf++ = '&'; 6962 *buf++ = '&'; 6963 } 6964 return buf; 6965 } 6966 virtual ptrdiff_t print_second(char* f, char* l) const 6967 { 6968 const ptrdiff_t r = l - f; 6969 const ptrdiff_t sz = __left_->print_second(f, l); 6970 ptrdiff_t n = 0; 6971 if (__size_ & 0x3E0) 6972 { 6973 if (__size_ & 32) 6974 { 6975 const ptrdiff_t d = sizeof(" const")-1; 6976 if (r >= sz + n + d) 6977 { 6978 char* t = f + sz + n; 6979 *t++ = ' '; 6980 *t++ = 'c'; 6981 *t++ = 'o'; 6982 *t++ = 'n'; 6983 *t++ = 's'; 6984 *t = 't'; 6985 } 6986 n += d; 6987 } 6988 if (__size_ & 64) 6989 { 6990 const ptrdiff_t d = sizeof(" volatile")-1; 6991 if (r >= sz + n + d) 6992 { 6993 char* t = f + sz + n; 6994 *t++ = ' '; 6995 *t++ = 'v'; 6996 *t++ = 'o'; 6997 *t++ = 'l'; 6998 *t++ = 'a'; 6999 *t++ = 't'; 7000 *t++ = 'i'; 7001 *t++ = 'l'; 7002 *t = 'e'; 7003 } 7004 n += d; 7005 } 7006 if (__size_ & 128) 7007 { 7008 const ptrdiff_t d = sizeof(" restrict")-1; 7009 if (r >= sz + n + d) 7010 { 7011 char* t = f + sz + n; 7012 *t++ = ' '; 7013 *t++ = 'r'; 7014 *t++ = 'e'; 7015 *t++ = 's'; 7016 *t++ = 't'; 7017 *t++ = 'r'; 7018 *t++ = 'i'; 7019 *t++ = 'c'; 7020 *t = 't'; 7021 } 7022 n += d; 7023 } 7024 if (__size_ & 256) 7025 { 7026 const ptrdiff_t d = sizeof(" &")-1; 7027 if (r >= sz + n + d) 7028 { 7029 char* t = f + sz + n; 7030 *t++ = ' '; 7031 *t = '&'; 7032 } 7033 n += d; 7034 } 7035 if (__size_ & 512) 7036 { 7037 const ptrdiff_t d = sizeof(" &&")-1; 7038 if (r >= sz + n + d) 7039 { 7040 char* t = f + sz + n; 7041 *t++ = ' '; 7042 *t++ = '&'; 7043 *t = '&'; 7044 } 7045 n += d; 7046 } 7047 } 7048 return n + sz; 7049 } 7050 virtual __node* base_name() const 7051 { 7052 return __left_->base_name(); 7053 } 7054 virtual bool is_reference_or_pointer_to_function_or_array() const 7055 { 7056 return __left_->is_reference_or_pointer_to_function_or_array(); 7057 } 7058 virtual bool is_function() const 7059 { 7060 return __left_->is_function(); 7061 } 7062 virtual bool is_cv_qualifer() const 7063 { 7064 return true; 7065 } 7066 virtual __node* extract_cv(__node*& rt) const 7067 { 7068 if (rt == this) 7069 { 7070 rt = __left_; 7071 return const_cast<__node*>(static_cast<const __node*>(this)); 7072 } 7073 return 0; 7074 } 7075 virtual bool ends_with_template() const 7076 { 7077 return __left_->ends_with_template(); 7078 } 7079 virtual bool is_ctor_dtor_conv() const 7080 { 7081 return __left_->is_ctor_dtor_conv(); 7082 } 7083 virtual bool is_array() const 7084 { 7085 return __left_->is_array(); 7086 } 7087 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 7088 { 7089 return __left_->fix_forward_references(t_begin, t_end); 7090 } 7091 virtual size_t list_len() const 7092 { 7093 return __left_->list_len(); 7094 } 7095}; 7096 7097class __extended_qualifier 7098 : public __node 7099{ 7100public: 7101 __extended_qualifier(__node* name, __node* type) 7102 { 7103 __left_ = type; 7104 __right_ = name; 7105 __size_ = __left_->is_function() ? 1 : 0; 7106 } 7107 7108 virtual size_t first_size() const 7109 { 7110 size_t s = __left_->first_size(); 7111 if (__size_ == 0) 7112 s += __right_->size() + 1; 7113 return s; 7114 } 7115 virtual char* first_demangled_name(char* buf) const 7116 { 7117 buf = __left_->first_demangled_name(buf); 7118 if (__size_ == 0) 7119 { 7120 *buf++ = ' '; 7121 buf = __right_->get_demangled_name(buf); 7122 } 7123 return buf; 7124 } 7125 virtual ptrdiff_t print_first(char* f, char* l) const 7126 { 7127 const ptrdiff_t r = l - f; 7128 const ptrdiff_t sz1 = __left_->print_first(f, l); 7129 ptrdiff_t sz2 = 0; 7130 ptrdiff_t n = 0; 7131 if (__size_ == 0) 7132 { 7133 if (r < sz1 + 1) 7134 return sz1 + 1 + __right_->print(l, l); 7135 sz2 = __right_->print(f+1+sz1, l); 7136 n = 1; 7137 f[sz1] = ' '; 7138 } 7139 return n + sz1 + sz2; 7140 } 7141 virtual size_t second_size() const 7142 { 7143 size_t s = __left_->second_size(); 7144 if (__size_ == 1) 7145 s += __right_->size() + 1; 7146 return s; 7147 } 7148 virtual char* second_demangled_name(char* buf) const 7149 { 7150 buf = __left_->second_demangled_name(buf); 7151 if (__size_ == 1) 7152 { 7153 *buf++ = ' '; 7154 buf = __right_->get_demangled_name(buf); 7155 } 7156 return buf; 7157 } 7158 virtual ptrdiff_t print_second(char* f, char* l) const 7159 { 7160 const ptrdiff_t r = l - f; 7161 const ptrdiff_t sz1 = __left_->print_second(f, l); 7162 ptrdiff_t sz2 = 0; 7163 ptrdiff_t n = 0; 7164 if (__size_ == 1) 7165 { 7166 if (r < sz1 + 1) 7167 return sz1 + 1 + __right_->print(l, l); 7168 sz2 = __right_->print(f+1+sz1, l); 7169 n = 1; 7170 f[sz1] = ' '; 7171 } 7172 return n + sz1 + sz2; 7173 } 7174 virtual __node* base_name() const 7175 { 7176 return __left_->base_name(); 7177 } 7178 virtual bool is_reference_or_pointer_to_function_or_array() const 7179 { 7180 return __left_->is_reference_or_pointer_to_function_or_array(); 7181 } 7182 virtual bool is_function() const 7183 { 7184 return __left_->is_function(); 7185 } 7186 virtual bool is_cv_qualifer() const 7187 { 7188 return true; 7189 } 7190 virtual __node* extract_cv(__node*& rt) const 7191 { 7192 if (rt == this) 7193 { 7194 rt = __left_; 7195 return const_cast<__node*>(static_cast<const __node*>(this)); 7196 } 7197 return 0; 7198 } 7199 virtual bool ends_with_template() const 7200 { 7201 return __left_->ends_with_template(); 7202 } 7203 virtual bool is_ctor_dtor_conv() const 7204 { 7205 return __left_->is_ctor_dtor_conv(); 7206 } 7207 virtual bool is_array() const 7208 { 7209 return __left_->is_array(); 7210 } 7211 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 7212 { 7213 return __left_->fix_forward_references(t_begin, t_end); 7214 } 7215 virtual size_t list_len() const 7216 { 7217 return __left_->list_len(); 7218 } 7219}; 7220 7221class __function 7222 : public __node 7223{ 7224public: 7225 7226 __function(__node* name, __node* signature, size_t ret_goes_first = true) 7227 { 7228 __size_ = ret_goes_first; 7229 __left_ = name; 7230 __right_ = signature; 7231 } 7232 7233 virtual size_t first_size() const 7234 { 7235 size_t off = 0; 7236 if (__size_) 7237 { 7238 off = __right_->first_size(); 7239 if (off > 0 && (__left_ == NULL || 7240 !__right_->__left_->is_reference_or_pointer_to_function_or_array())) 7241 ++off; 7242 } 7243 else 7244 off = 5; 7245 if (__left_) 7246 off += __left_->first_size(); 7247 else 7248 ++off; 7249 return off; 7250 } 7251 7252 virtual size_t second_size() const 7253 { 7254 size_t off = 0; 7255 if (__left_ == NULL) 7256 off = 1; 7257 off += __right_->second_size(); 7258 if (!__size_) 7259 { 7260 off += 2; 7261 off += __right_->first_size(); 7262 } 7263 return off; 7264 } 7265 7266 virtual char* first_demangled_name(char* buf) const 7267 { 7268 if (__size_) 7269 { 7270 const char* t = buf; 7271 buf = __right_->first_demangled_name(buf); 7272 if (buf != t && (__left_ == NULL || 7273 !__right_->__left_->is_reference_or_pointer_to_function_or_array())) 7274 *buf++ = ' '; 7275 } 7276 else 7277 { 7278 strncpy(buf, "auto ", 5); 7279 buf += 5; 7280 } 7281 if (__left_) 7282 buf = __left_->first_demangled_name(buf); 7283 else 7284 *buf++ = '('; 7285 return buf; 7286 } 7287 virtual ptrdiff_t print_first(char* f, char* l) const 7288 { 7289 const ptrdiff_t r = l - f; 7290 ptrdiff_t n = 0; 7291 ptrdiff_t sz1 = 0; 7292 ptrdiff_t sz2 = 0; 7293 if (__size_) 7294 { 7295 sz1 = __right_->print_first(f, l); 7296 if (sz1 != 0 && (__left_ == NULL || 7297 !__right_->__left_->is_reference_or_pointer_to_function_or_array())) 7298 { 7299 ++n; 7300 if (r >= sz1 + 1) 7301 f[sz1] = ' '; 7302 } 7303 } 7304 else 7305 { 7306 n = 5; 7307 if (r >= 5) 7308 { 7309 char* t = f; 7310 *t++ = 'a'; 7311 *t++ = 'u'; 7312 *t++ = 't'; 7313 *t++ = 'o'; 7314 *t++ = ' '; 7315 } 7316 } 7317 if (__left_) 7318 sz2 = __left_->print_first(f + std::min(n + sz1, r), l); 7319 else 7320 { 7321 ++n; 7322 if (r >= n + sz1) 7323 f[n+sz1-1] = '('; 7324 } 7325 return n + sz1 + sz2; 7326 } 7327 7328 virtual char* second_demangled_name(char* buf) const 7329 { 7330 if (__left_ == NULL) 7331 *buf++ = ')'; 7332 buf = __right_->second_demangled_name(buf); 7333 if (!__size_) 7334 { 7335 *buf++ = '-'; 7336 *buf++ = '>'; 7337 buf = __right_->first_demangled_name(buf); 7338 } 7339 return buf; 7340 } 7341 virtual ptrdiff_t print_second(char* f, char* l) const 7342 { 7343 const ptrdiff_t r = l - f; 7344 ptrdiff_t n = 0; 7345 ptrdiff_t sz1 = 0; 7346 ptrdiff_t sz2 = 0; 7347 if (__left_ == NULL) 7348 { 7349 n = 1; 7350 if (r >= 1) 7351 *f = ')'; 7352 } 7353 sz1 = __right_->print_second(f+std::min(r, n), l); 7354 if (!__size_) 7355 { 7356 if (r > n+sz1+1) 7357 { 7358 f[n+sz1] = '-'; 7359 f[n+sz1+1] = '>'; 7360 } 7361 n += 2; 7362 sz2 = __right_->print_first(f+std::min(r, n+sz1), l); 7363 } 7364 return n + sz1 + sz2; 7365 } 7366 7367 virtual bool is_function() const 7368 { 7369 return true; 7370 } 7371 virtual bool is_ctor_dtor_conv() const 7372 { 7373 return __left_->is_ctor_dtor_conv(); 7374 } 7375 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 7376 { 7377 bool r = true; 7378 if (__left_) 7379 r = r && __left_->fix_forward_references(t_begin, t_end); 7380 r = r && __right_->fix_forward_references(t_begin, t_end); 7381 return r; 7382 } 7383}; 7384 7385class __function_signature 7386 : public __node 7387{ 7388public: 7389 __function_signature(__node* ret, __node* args) 7390 { 7391 __left_ = ret; 7392 __right_ = args; 7393 } 7394 virtual size_t first_size() const 7395 { 7396 return __left_ ? __left_->first_size() : 0; 7397 } 7398 7399 virtual size_t second_size() const 7400 { 7401 return 2 + (__right_ ? __right_->size() : 0) 7402 + (__left_ ? __left_->second_size() : 0); 7403 } 7404 7405 virtual char* first_demangled_name(char* buf) const 7406 { 7407 if (__left_) 7408 buf = __left_->first_demangled_name(buf); 7409 return buf; 7410 } 7411 virtual ptrdiff_t print_first(char* f, char* l) const 7412 { 7413 return __left_ ? __left_->print_first(f, l) : 0; 7414 } 7415 7416 virtual char* second_demangled_name(char* buf) const 7417 { 7418 *buf++ = '('; 7419 if (__right_) 7420 buf = __right_->get_demangled_name(buf); 7421 *buf++ = ')'; 7422 if (__left_) 7423 buf = __left_->second_demangled_name(buf); 7424 return buf; 7425 } 7426 virtual ptrdiff_t print_second(char* f, char* l) const 7427 { 7428 const ptrdiff_t r = l - f; 7429 const ptrdiff_t sz1 = __right_ ? __right_->print(f+std::min<ptrdiff_t>(1, r), l) : 0; 7430 const ptrdiff_t sz2 = __left_ ? __left_->print_second(f+std::min(2+sz1, r), l) : 0; 7431 if (r >= 2 + sz1 + sz2) 7432 { 7433 *f = '('; 7434 f += 1 + sz1; 7435 *f = ')'; 7436 } 7437 return 2 + sz1 + sz2; 7438 } 7439 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 7440 { 7441 bool r = true; 7442 if (__left_) 7443 r = r && __left_->fix_forward_references(t_begin, t_end); 7444 if (__right_) 7445 r = r && __right_->fix_forward_references(t_begin, t_end); 7446 return r; 7447 } 7448}; 7449 7450class __pointer_to 7451 : public __node 7452{ 7453public: 7454 7455 explicit __pointer_to(__node* type) 7456 { 7457 __left_ = type; 7458 } 7459 virtual size_t first_size() const 7460 { 7461 return __left_->first_size() + (__left_->is_array() ? 3 : 1); 7462 } 7463 virtual size_t second_size() const 7464 { 7465 return __left_->second_size() + (__left_->is_array() ? 1 : 0); 7466 } 7467 virtual char* first_demangled_name(char* buf) const 7468 { 7469 buf = __left_->first_demangled_name(buf); 7470 if (__left_->is_array()) 7471 { 7472 *buf++ = ' '; 7473 *buf++ = '('; 7474 *buf++ = '*'; 7475 } 7476 else 7477 *buf++ = '*'; 7478 return buf; 7479 } 7480 virtual ptrdiff_t print_first(char* f, char* l) const 7481 { 7482 const ptrdiff_t r = l - f; 7483 const ptrdiff_t sz = __left_->print_first(f, l); 7484 ptrdiff_t n; 7485 if (__left_->is_array()) 7486 { 7487 n = 3; 7488 if (r >= sz + n) 7489 { 7490 f += sz; 7491 *f++ = ' '; 7492 *f++ = '('; 7493 *f = '*'; 7494 } 7495 } 7496 else 7497 { 7498 n = 1; 7499 if (r >= sz + n) 7500 f[sz] = '*'; 7501 } 7502 return sz + n; 7503 } 7504 virtual char* second_demangled_name(char* buf) const 7505 { 7506 if (__left_->is_array()) 7507 *buf++ = ')'; 7508 return __left_->second_demangled_name(buf); 7509 } 7510 virtual ptrdiff_t print_second(char* f, char* l) const 7511 { 7512 const ptrdiff_t r = l - f; 7513 ptrdiff_t n = 0; 7514 if (__left_->is_array()) 7515 { 7516 n = 1; 7517 if (r > n) 7518 *f = ')'; 7519 } 7520 return __left_->print_second(f + std::min(n, r), l) + n; 7521 } 7522 virtual __node* base_name() const 7523 { 7524 return __left_->base_name(); 7525 } 7526 virtual bool is_reference_or_pointer_to_function_or_array() const 7527 { 7528 return __left_->is_function() || 7529 __left_->is_reference_or_pointer_to_function_or_array(); 7530 } 7531 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 7532 { 7533 return __left_->fix_forward_references(t_begin, t_end); 7534 } 7535 virtual size_t list_len() const 7536 { 7537 return __left_->list_len(); 7538 } 7539}; 7540 7541class __lvalue_reference_to 7542 : public __node 7543{ 7544public: 7545 7546 explicit __lvalue_reference_to(__node* type) 7547 { 7548 __left_ = type; 7549 } 7550 virtual size_t first_size() const 7551 { 7552 return __left_->first_size() + (__left_->is_array() ? 3 : 1); 7553 } 7554 virtual size_t second_size() const 7555 { 7556 return __left_->second_size() + (__left_->is_array() ? 1 : 0); 7557 } 7558 virtual char* first_demangled_name(char* buf) const 7559 { 7560 buf = __left_->first_demangled_name(buf); 7561 if (__left_->is_array()) 7562 { 7563 *buf++ = ' '; 7564 *buf++ = '('; 7565 *buf++ = '&'; 7566 } 7567 else 7568 *buf++ = '&'; 7569 return buf; 7570 } 7571 virtual ptrdiff_t print_first(char* f, char* l) const 7572 { 7573 const ptrdiff_t r = l - f; 7574 const ptrdiff_t sz = __left_->print_first(f, l); 7575 ptrdiff_t n; 7576 if (__left_->is_array()) 7577 { 7578 n = 3; 7579 if (r >= sz + n) 7580 { 7581 f += sz; 7582 *f++ = ' '; 7583 *f++ = '('; 7584 *f = '&'; 7585 } 7586 } 7587 else 7588 { 7589 n = 1; 7590 if (r >= sz + n) 7591 f[sz] = '&'; 7592 } 7593 return sz + n; 7594 } 7595 virtual char* second_demangled_name(char* buf) const 7596 { 7597 if (__left_->is_array()) 7598 *buf++ = ')'; 7599 return __left_->second_demangled_name(buf); 7600 } 7601 virtual ptrdiff_t print_second(char* f, char* l) const 7602 { 7603 const ptrdiff_t r = l - f; 7604 ptrdiff_t n = 0; 7605 if (__left_->is_array()) 7606 { 7607 n = 1; 7608 if (r > n) 7609 *f = ')'; 7610 } 7611 return __left_->print_second(f + std::min(n, r), l) + n; 7612 } 7613 virtual __node* base_name() const 7614 { 7615 return __left_->base_name(); 7616 } 7617 virtual bool is_reference_or_pointer_to_function_or_array() const 7618 { 7619 return __left_->is_function(); 7620 } 7621 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 7622 { 7623 return __left_->fix_forward_references(t_begin, t_end); 7624 } 7625 virtual size_t list_len() const 7626 { 7627 return __left_->list_len(); 7628 } 7629}; 7630 7631class __rvalue_reference_to 7632 : public __node 7633{ 7634public: 7635 7636 explicit __rvalue_reference_to(__node* type) 7637 { 7638 __left_ = type; 7639 } 7640 virtual size_t first_size() const 7641 { 7642 return __left_->first_size() + (__left_->is_array() ? 4 : 2); 7643 } 7644 virtual size_t second_size() const 7645 { 7646 return __left_->second_size() + (__left_->is_array() ? 1 : 0); 7647 } 7648 virtual char* first_demangled_name(char* buf) const 7649 { 7650 buf = __left_->first_demangled_name(buf); 7651 if (__left_->is_array()) 7652 { 7653 strncpy(buf, " (&&", 4); 7654 buf += 4; 7655 } 7656 else 7657 { 7658 *buf++ = '&'; 7659 *buf++ = '&'; 7660 } 7661 return buf; 7662 } 7663 virtual ptrdiff_t print_first(char* f, char* l) const 7664 { 7665 const ptrdiff_t r = l - f; 7666 const ptrdiff_t sz = __left_->print_first(f, l); 7667 ptrdiff_t n; 7668 if (__left_->is_array()) 7669 { 7670 n = 4; 7671 if (r >= sz + n) 7672 { 7673 f += sz; 7674 *f++ = ' '; 7675 *f++ = '('; 7676 *f++ = '&'; 7677 *f = '&'; 7678 } 7679 } 7680 else 7681 { 7682 n = 2; 7683 if (r >= sz + n) 7684 { 7685 f += sz; 7686 *f++ = '&'; 7687 *f = '&'; 7688 } 7689 } 7690 return sz + n; 7691 } 7692 virtual char* second_demangled_name(char* buf) const 7693 { 7694 if (__left_->is_array()) 7695 *buf++ = ')'; 7696 return __left_->second_demangled_name(buf); 7697 } 7698 virtual ptrdiff_t print_second(char* f, char* l) const 7699 { 7700 const ptrdiff_t r = l - f; 7701 ptrdiff_t n = 0; 7702 if (__left_->is_array()) 7703 { 7704 n = 1; 7705 if (r > n) 7706 *f = ')'; 7707 } 7708 return __left_->print_second(f + std::min(n, r), l) + n; 7709 } 7710 virtual __node* base_name() const 7711 { 7712 return __left_->base_name(); 7713 } 7714 virtual bool is_reference_or_pointer_to_function_or_array() const 7715 { 7716 return __left_->is_function(); 7717 } 7718 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 7719 { 7720 return __left_->fix_forward_references(t_begin, t_end); 7721 } 7722 virtual size_t list_len() const 7723 { 7724 return __left_->list_len(); 7725 } 7726}; 7727 7728class __d_complex 7729 : public __node 7730{ 7731 static const size_t n = sizeof(" complex") - 1; 7732public: 7733 7734 explicit __d_complex(__node* type) 7735 { 7736 __left_ = type; 7737 } 7738 virtual size_t first_size() const 7739 { 7740 if (__cached_size_ == -1) 7741 const_cast<long&>(__cached_size_) = n + __left_->size(); 7742 return __cached_size_; 7743 } 7744 virtual char* first_demangled_name(char* buf) const 7745 { 7746 buf = __left_->get_demangled_name(buf); 7747 strncpy(buf, " complex", n); 7748 return buf + n; 7749 } 7750 virtual ptrdiff_t print_first(char* f, char* l) const 7751 { 7752 const ptrdiff_t r = l - f; 7753 const ptrdiff_t sz = __left_->print(f, l); 7754 const ptrdiff_t n = sizeof(" complex") - 1; 7755 if (r >= sz + n) 7756 { 7757 f += sz; 7758 *f++ = ' '; 7759 *f++ = 'c'; 7760 *f++ = 'o'; 7761 *f++ = 'm'; 7762 *f++ = 'p'; 7763 *f++ = 'l'; 7764 *f++ = 'e'; 7765 *f = 'x'; 7766 } 7767 return sz + n; 7768 } 7769 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 7770 { 7771 return __left_->fix_forward_references(t_begin, t_end); 7772 } 7773}; 7774 7775class __imaginary 7776 : public __node 7777{ 7778 static const size_t n = sizeof(" imaginary") - 1; 7779public: 7780 7781 explicit __imaginary(__node* type) 7782 { 7783 __left_ = type; 7784 } 7785 virtual size_t first_size() const 7786 { 7787 if (__cached_size_ == -1) 7788 const_cast<long&>(__cached_size_) = n + __left_->size(); 7789 return __cached_size_; 7790 } 7791 virtual char* first_demangled_name(char* buf) const 7792 { 7793 buf = __left_->get_demangled_name(buf); 7794 strncpy(buf, " imaginary", n); 7795 return buf + n; 7796 } 7797 virtual ptrdiff_t print_first(char* f, char* l) const 7798 { 7799 const ptrdiff_t r = l - f; 7800 const ptrdiff_t sz = __left_->print(f, l); 7801 const ptrdiff_t n = sizeof(" imaginary") - 1; 7802 if (r >= sz + n) 7803 { 7804 f += sz; 7805 *f++ = ' '; 7806 *f++ = 'i'; 7807 *f++ = 'm'; 7808 *f++ = 'a'; 7809 *f++ = 'g'; 7810 *f++ = 'i'; 7811 *f++ = 'n'; 7812 *f++ = 'a'; 7813 *f++ = 'r'; 7814 *f = 'y'; 7815 } 7816 return sz + n; 7817 } 7818 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 7819 { 7820 return __left_->fix_forward_references(t_begin, t_end); 7821 } 7822}; 7823 7824class __pack_expansion 7825 : public __node 7826{ 7827public: 7828 7829 explicit __pack_expansion(__node* type) 7830 { 7831 __left_ = type; 7832 } 7833 virtual size_t first_size() const 7834 { 7835 if (__cached_size_ == -1) 7836 { 7837 size_t len = __left_->list_len(); 7838 size_t off = 0; 7839 if (len != 0) 7840 { 7841 if (__left_->is_sub() || len == 1) 7842 off = __left_->size(); 7843 else 7844 { 7845 __node* top = __left_; 7846 __node* bottom = top; 7847 while (!bottom->__left_->is_sub()) 7848 bottom = bottom->__left_; 7849 __node* sub = bottom->__left_; 7850 __node* i = sub->__left_; 7851 bool first = true; 7852 top->reset_cached_size(); 7853 while (i) 7854 { 7855 if (!first) 7856 off += 2; 7857 bottom->__left_ = i->__left_; 7858 off += top->size(); 7859 top->reset_cached_size(); 7860 i = i->__right_; 7861 first = false; 7862 } 7863 bottom->__left_ = sub; 7864 } 7865 } 7866 const_cast<long&>(__cached_size_) = off; 7867 } 7868 return __cached_size_; 7869 } 7870 virtual char* first_demangled_name(char* buf) const 7871 { 7872 size_t len = __left_->list_len(); 7873 if (len != 0) 7874 { 7875 if (__left_->is_sub() || len == 1) 7876 buf = __left_->get_demangled_name(buf); 7877 else 7878 { 7879 __node* top = __left_; 7880 __node* bottom = top; 7881 while (!bottom->__left_->is_sub()) 7882 bottom = bottom->__left_; 7883 __node* sub = bottom->__left_; 7884 __node* i = sub->__left_; 7885 bool first = true; 7886 top->reset_cached_size(); 7887 while (i) 7888 { 7889 if (!first) 7890 { 7891 *buf++ = ','; 7892 *buf++ = ' '; 7893 } 7894 bottom->__left_ = i->__left_; 7895 buf = top->get_demangled_name(buf); 7896 top->reset_cached_size(); 7897 i = i->__right_; 7898 first = false; 7899 } 7900 bottom->__left_ = sub; 7901 } 7902 } 7903 return buf; 7904 } 7905 virtual ptrdiff_t print_first(char* f, char* l) const 7906 { 7907 const ptrdiff_t r = l - f; 7908 const ptrdiff_t len = __left_->list_len(); 7909 ptrdiff_t sz = 0; 7910 if (len != 0) 7911 { 7912 if (__left_->is_sub() || len == 1) 7913 sz = __left_->print(f, l); 7914 else 7915 { 7916 __node* top = __left_; 7917 __node* bottom = top; 7918 while (!bottom->__left_->is_sub()) 7919 bottom = bottom->__left_; 7920 __node* sub = bottom->__left_; 7921 __node* i = sub->__left_; 7922 bool first = true; 7923 while (i) 7924 { 7925 if (!first) 7926 { 7927 if (r >= sz+2) 7928 { 7929 f[sz] = ','; 7930 f[sz+1] = ' '; 7931 } 7932 sz += 2; 7933 } 7934 bottom->__left_ = i->__left_; 7935 sz += top->print(f+std::min(sz, r), l); 7936 i = i->__right_; 7937 first = false; 7938 } 7939 bottom->__left_ = sub; 7940 } 7941 } 7942 return sz; 7943 } 7944 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 7945 { 7946 return __left_->fix_forward_references(t_begin, t_end); 7947 } 7948}; 7949 7950class __void 7951 : public __node 7952{ 7953 static const size_t n = sizeof("void") - 1; 7954public: 7955 7956 virtual size_t first_size() const {return n;} 7957 virtual char* first_demangled_name(char* buf) const 7958 { 7959 strncpy(buf, "void", n); 7960 return buf + n; 7961 } 7962 virtual ptrdiff_t print_first(char* f, char* l) const 7963 { 7964 const ptrdiff_t r = l - f; 7965 if (r >= n) 7966 { 7967 *f++ = 'v'; 7968 *f++ = 'o'; 7969 *f++ = 'i'; 7970 *f = 'd'; 7971 } 7972 return n; 7973 } 7974}; 7975 7976class __wchar_t 7977 : public __node 7978{ 7979 static const size_t n = sizeof("wchar_t") - 1; 7980public: 7981 7982 virtual size_t first_size() const {return n;} 7983 virtual char* first_demangled_name(char* buf) const 7984 { 7985 strncpy(buf, "wchar_t", n); 7986 return buf + n; 7987 } 7988 virtual ptrdiff_t print_first(char* f, char* l) const 7989 { 7990 const ptrdiff_t r = l - f; 7991 if (r >= n) 7992 { 7993 *f++ = 'w'; 7994 *f++ = 'c'; 7995 *f++ = 'h'; 7996 *f++ = 'a'; 7997 *f++ = 'r'; 7998 *f++ = '_'; 7999 *f = 't'; 8000 } 8001 return n; 8002 } 8003}; 8004 8005class __wchar_t_literal 8006 : public __node 8007{ 8008public: 8009 explicit __wchar_t_literal(const char* __first, const char* __last) 8010 { 8011 __name_ = __first; 8012 __size_ = __last - __first; 8013 } 8014 8015 virtual size_t first_size() const 8016 { 8017 return __size_+9; 8018 } 8019 virtual char* first_demangled_name(char* buf) const 8020 { 8021 strncpy(buf, "(wchar_t)", 9); 8022 buf += 9; 8023 strncpy(buf, __name_, __size_); 8024 return buf + __size_; 8025 } 8026 virtual ptrdiff_t print_first(char* f, char* l) const 8027 { 8028 const ptrdiff_t r = l - f; 8029 const ptrdiff_t n = sizeof("(wchar_t)") - 1; 8030 if (r >= n + __size_) 8031 { 8032 *f++ = '('; 8033 *f++ = 'w'; 8034 *f++ = 'c'; 8035 *f++ = 'h'; 8036 *f++ = 'a'; 8037 *f++ = 'r'; 8038 *f++ = '_'; 8039 *f++ = 't'; 8040 *f++ = ')'; 8041 strncpy(f, __name_, __size_); 8042 } 8043 return n + __size_; 8044 } 8045}; 8046 8047class __bool 8048 : public __node 8049{ 8050 static const size_t n = sizeof("bool") - 1; 8051public: 8052 8053 virtual size_t first_size() const {return n;} 8054 virtual char* first_demangled_name(char* buf) const 8055 { 8056 strncpy(buf, "bool", n); 8057 return buf + n; 8058 } 8059 virtual ptrdiff_t print_first(char* f, char* l) const 8060 { 8061 const ptrdiff_t r = l - f; 8062 if (r >= n) 8063 { 8064 *f++ = 'b'; 8065 *f++ = 'o'; 8066 *f++ = 'o'; 8067 *f = 'l'; 8068 } 8069 return n; 8070 } 8071}; 8072 8073class __bool_literal 8074 : public __node 8075{ 8076public: 8077 explicit __bool_literal(const char* __name, unsigned __size) 8078 { 8079 __name_ = __name; 8080 __size_ = __size; 8081 } 8082 8083 virtual size_t first_size() const 8084 { 8085 return __size_; 8086 } 8087 virtual char* first_demangled_name(char* buf) const 8088 { 8089 strncpy(buf, __name_, __size_); 8090 return buf + __size_; 8091 } 8092 virtual ptrdiff_t print_first(char* f, char* l) const 8093 { 8094 const ptrdiff_t r = l - f; 8095 if (r >= __size_) 8096 strncpy(f, __name_, __size_); 8097 return __size_; 8098 } 8099}; 8100 8101class __char 8102 : public __node 8103{ 8104 static const size_t n = sizeof("char") - 1; 8105public: 8106 8107 virtual size_t first_size() const {return n;} 8108 virtual char* first_demangled_name(char* buf) const 8109 { 8110 strncpy(buf, "char", n); 8111 return buf + n; 8112 } 8113 virtual ptrdiff_t print_first(char* f, char* l) const 8114 { 8115 const ptrdiff_t r = l - f; 8116 if (r >= n) 8117 { 8118 *f++ = 'c'; 8119 *f++ = 'h'; 8120 *f++ = 'a'; 8121 *f = 'r'; 8122 } 8123 return n; 8124 } 8125}; 8126 8127class __char_literal 8128 : public __node 8129{ 8130public: 8131 explicit __char_literal(const char* __first, const char* __last) 8132 { 8133 __name_ = __first; 8134 __size_ = __last - __first; 8135 } 8136 8137 virtual size_t first_size() const 8138 { 8139 return __size_+6; 8140 } 8141 virtual char* first_demangled_name(char* buf) const 8142 { 8143 strncpy(buf, "(char)", 6); 8144 buf += 6; 8145 if (*__name_ == 'n') 8146 { 8147 *buf++ = '-'; // strncpy(buf+6, "-", 1); 8148 strncpy(buf, __name_+1, __size_-1); 8149 buf += __size_ - 1; 8150 } 8151 else 8152 { 8153 strncpy(buf, __name_, __size_); 8154 buf += __size_; 8155 } 8156 return buf; 8157 } 8158 virtual ptrdiff_t print_first(char* f, char* l) const 8159 { 8160 const ptrdiff_t r = l - f; 8161 const ptrdiff_t n = sizeof("(char)") - 1; 8162 if (r >= __size_ + n) 8163 { 8164 *f++ = '('; 8165 *f++ = 'c'; 8166 *f++ = 'h'; 8167 *f++ = 'a'; 8168 *f++ = 'r'; 8169 *f++ = ')'; 8170 if (*__name_ == 'n') 8171 { 8172 *f++ = '-'; 8173 strncpy(f, __name_+1, __size_-1); 8174 } 8175 else 8176 strncpy(f, __name_, __size_); 8177 } 8178 return __size_ + n; 8179 } 8180}; 8181 8182class __signed_char 8183 : public __node 8184{ 8185 static const size_t n = sizeof("signed char") - 1; 8186public: 8187 8188 virtual size_t first_size() const {return n;} 8189 virtual char* first_demangled_name(char* buf) const 8190 { 8191 strncpy(buf, "signed char", n); 8192 return buf + n; 8193 } 8194 virtual ptrdiff_t print_first(char* f, char* l) const 8195 { 8196 const ptrdiff_t r = l - f; 8197 if (r >= n) 8198 { 8199 *f++ = 's'; 8200 *f++ = 'i'; 8201 *f++ = 'g'; 8202 *f++ = 'n'; 8203 *f++ = 'e'; 8204 *f++ = 'd'; 8205 *f++ = ' '; 8206 *f++ = 'c'; 8207 *f++ = 'h'; 8208 *f++ = 'a'; 8209 *f = 'r'; 8210 } 8211 return n; 8212 } 8213}; 8214 8215class __signed_char_literal 8216 : public __node 8217{ 8218public: 8219 explicit __signed_char_literal(const char* __first, const char* __last) 8220 { 8221 __name_ = __first; 8222 __size_ = __last - __first; 8223 } 8224 8225 virtual size_t first_size() const 8226 { 8227 return __size_+13; 8228 } 8229 virtual char* first_demangled_name(char* buf) const 8230 { 8231 strncpy(buf, "(signed char)", 13); 8232 buf += 13; 8233 if (*__name_ == 'n') 8234 { 8235 *buf++ = '-'; 8236 strncpy(buf, __name_+1, __size_-1); 8237 buf += __size_ - 1; 8238 } 8239 else 8240 { 8241 strncpy(buf, __name_, __size_); 8242 buf += __size_; 8243 } 8244 return buf; 8245 } 8246 virtual ptrdiff_t print_first(char* f, char* l) const 8247 { 8248 const ptrdiff_t r = l - f; 8249 const ptrdiff_t n = sizeof("(signed char)") - 1; 8250 if (r >= __size_ + n) 8251 { 8252 *f++ = '('; 8253 *f++ = 's'; 8254 *f++ = 'i'; 8255 *f++ = 'g'; 8256 *f++ = 'n'; 8257 *f++ = 'e'; 8258 *f++ = 'd'; 8259 *f++ = ' '; 8260 *f++ = 'c'; 8261 *f++ = 'h'; 8262 *f++ = 'a'; 8263 *f++ = 'r'; 8264 *f++ = ')'; 8265 if (*__name_ == 'n') 8266 { 8267 *f++ = '-'; 8268 strncpy(f, __name_+1, __size_-1); 8269 } 8270 else 8271 strncpy(f, __name_, __size_); 8272 } 8273 return __size_ + n; 8274 } 8275}; 8276 8277class __unsigned_char 8278 : public __node 8279{ 8280 static const size_t n = sizeof("unsigned char") - 1; 8281public: 8282 8283 virtual size_t first_size() const {return n;} 8284 virtual char* first_demangled_name(char* buf) const 8285 { 8286 strncpy(buf, "unsigned char", n); 8287 return buf + n; 8288 } 8289 virtual ptrdiff_t print_first(char* f, char* l) const 8290 { 8291 const ptrdiff_t r = l - f; 8292 if (r >= n) 8293 { 8294 *f++ = 'u'; 8295 *f++ = 'n'; 8296 *f++ = 's'; 8297 *f++ = 'i'; 8298 *f++ = 'g'; 8299 *f++ = 'n'; 8300 *f++ = 'e'; 8301 *f++ = 'd'; 8302 *f++ = ' '; 8303 *f++ = 'c'; 8304 *f++ = 'h'; 8305 *f++ = 'a'; 8306 *f = 'r'; 8307 } 8308 return n; 8309 } 8310}; 8311 8312class __unsigned_char_literal 8313 : public __node 8314{ 8315public: 8316 explicit __unsigned_char_literal(const char* __first, const char* __last) 8317 { 8318 __name_ = __first; 8319 __size_ = __last - __first; 8320 } 8321 8322 virtual size_t first_size() const 8323 { 8324 return __size_+15; 8325 } 8326 virtual char* first_demangled_name(char* buf) const 8327 { 8328 strncpy(buf, "(unsigned char)", 15); 8329 buf += 15; 8330 strncpy(buf, __name_, __size_); 8331 return buf + __size_; 8332 } 8333 virtual ptrdiff_t print_first(char* f, char* l) const 8334 { 8335 const ptrdiff_t r = l - f; 8336 const ptrdiff_t n = sizeof("(unsigned char)") - 1; 8337 if (r >= __size_ + n) 8338 { 8339 *f++ = '('; 8340 *f++ = 'u'; 8341 *f++ = 'n'; 8342 *f++ = 's'; 8343 *f++ = 'i'; 8344 *f++ = 'g'; 8345 *f++ = 'n'; 8346 *f++ = 'e'; 8347 *f++ = 'd'; 8348 *f++ = ' '; 8349 *f++ = 'c'; 8350 *f++ = 'h'; 8351 *f++ = 'a'; 8352 *f++ = 'r'; 8353 *f++ = ')'; 8354 strncpy(f, __name_, __size_); 8355 } 8356 return __size_ + n; 8357 } 8358}; 8359 8360class __short 8361 : public __node 8362{ 8363 static const size_t n = sizeof("short") - 1; 8364public: 8365 8366 virtual size_t first_size() const {return n;} 8367 virtual char* first_demangled_name(char* buf) const 8368 { 8369 strncpy(buf, "short", n); 8370 return buf + n; 8371 } 8372 virtual ptrdiff_t print_first(char* f, char* l) const 8373 { 8374 const ptrdiff_t r = l - f; 8375 if (r >= n) 8376 { 8377 *f++ = 's'; 8378 *f++ = 'h'; 8379 *f++ = 'o'; 8380 *f++ = 'r'; 8381 *f = 't'; 8382 } 8383 return n; 8384 } 8385}; 8386 8387class __short_literal 8388 : public __node 8389{ 8390public: 8391 explicit __short_literal(const char* __first, const char* __last) 8392 { 8393 __name_ = __first; 8394 __size_ = __last - __first; 8395 } 8396 8397 virtual size_t first_size() const 8398 { 8399 return __size_+7; 8400 } 8401 virtual char* first_demangled_name(char* buf) const 8402 { 8403 strncpy(buf, "(short)", 7); 8404 buf += 7; 8405 if (*__name_ == 'n') 8406 { 8407 *buf++ = '-'; 8408 strncpy(buf, __name_+1, __size_-1); 8409 buf += __size_ - 1; 8410 } 8411 else 8412 { 8413 strncpy(buf, __name_, __size_); 8414 buf += __size_; 8415 } 8416 return buf; 8417 } 8418 virtual ptrdiff_t print_first(char* f, char* l) const 8419 { 8420 const ptrdiff_t r = l - f; 8421 const ptrdiff_t n = sizeof("(short)") - 1; 8422 if (r >= __size_ + n) 8423 { 8424 *f++ = '('; 8425 *f++ = 's'; 8426 *f++ = 'h'; 8427 *f++ = 'o'; 8428 *f++ = 'r'; 8429 *f++ = 't'; 8430 *f++ = ')'; 8431 if (*__name_ == 'n') 8432 { 8433 *f++ = '-'; 8434 strncpy(f, __name_+1, __size_-1); 8435 } 8436 else 8437 strncpy(f, __name_, __size_); 8438 } 8439 return __size_ + n; 8440 } 8441}; 8442 8443class __unsigned_short 8444 : public __node 8445{ 8446 static const size_t n = sizeof("unsigned short") - 1; 8447public: 8448 8449 virtual size_t first_size() const {return n;} 8450 virtual char* first_demangled_name(char* buf) const 8451 { 8452 strncpy(buf, "unsigned short", n); 8453 return buf + n; 8454 } 8455 virtual ptrdiff_t print_first(char* f, char* l) const 8456 { 8457 const ptrdiff_t r = l - f; 8458 if (r >= n) 8459 { 8460 *f++ = 'u'; 8461 *f++ = 'n'; 8462 *f++ = 's'; 8463 *f++ = 'i'; 8464 *f++ = 'g'; 8465 *f++ = 'n'; 8466 *f++ = 'e'; 8467 *f++ = 'd'; 8468 *f++ = ' '; 8469 *f++ = 's'; 8470 *f++ = 'h'; 8471 *f++ = 'o'; 8472 *f++ = 'r'; 8473 *f = 't'; 8474 } 8475 return n; 8476 } 8477}; 8478 8479class __unsigned_short_literal 8480 : public __node 8481{ 8482public: 8483 explicit __unsigned_short_literal(const char* __first, const char* __last) 8484 { 8485 __name_ = __first; 8486 __size_ = __last - __first; 8487 } 8488 8489 virtual size_t first_size() const 8490 { 8491 return __size_+16; 8492 } 8493 virtual char* first_demangled_name(char* buf) const 8494 { 8495 strncpy(buf, "(unsigned short)", 16); 8496 buf += 16; 8497 strncpy(buf, __name_, __size_); 8498 return buf + __size_; 8499 } 8500 virtual ptrdiff_t print_first(char* f, char* l) const 8501 { 8502 const ptrdiff_t r = l - f; 8503 const ptrdiff_t n = sizeof("(unsigned short)") - 1; 8504 if (r >= __size_ + n) 8505 { 8506 *f++ = '('; 8507 *f++ = 'u'; 8508 *f++ = 'n'; 8509 *f++ = 's'; 8510 *f++ = 'i'; 8511 *f++ = 'g'; 8512 *f++ = 'n'; 8513 *f++ = 'e'; 8514 *f++ = 'd'; 8515 *f++ = ' '; 8516 *f++ = 's'; 8517 *f++ = 'h'; 8518 *f++ = 'o'; 8519 *f++ = 'r'; 8520 *f++ = 't'; 8521 *f++ = ')'; 8522 strncpy(f, __name_, __size_); 8523 } 8524 return __size_ + n; 8525 } 8526}; 8527 8528class __int 8529 : public __node 8530{ 8531 static const size_t n = sizeof("int") - 1; 8532public: 8533 8534 virtual size_t first_size() const {return n;} 8535 virtual char* first_demangled_name(char* buf) const 8536 { 8537 *buf++ = 'i'; 8538 *buf++ = 'n'; 8539 *buf++ = 't'; 8540 return buf; 8541 } 8542 virtual ptrdiff_t print_first(char* f, char* l) const 8543 { 8544 const ptrdiff_t r = l - f; 8545 if (r >= n) 8546 { 8547 *f++ = 'i'; 8548 *f++ = 'n'; 8549 *f = 't'; 8550 } 8551 return n; 8552 } 8553}; 8554 8555class __int_literal 8556 : public __node 8557{ 8558public: 8559 explicit __int_literal(const char* __first, const char* __last) 8560 { 8561 __name_ = __first; 8562 __size_ = __last - __first; 8563 } 8564 8565 virtual size_t first_size() const 8566 { 8567 return __size_; 8568 } 8569 virtual char* first_demangled_name(char* buf) const 8570 { 8571 if (*__name_ == 'n') 8572 { 8573 *buf++ = '-'; 8574 strncpy(buf, __name_+1, __size_-1); 8575 buf += __size_ - 1; 8576 } 8577 else 8578 { 8579 strncpy(buf, __name_, __size_); 8580 buf += __size_; 8581 } 8582 return buf; 8583 } 8584 virtual ptrdiff_t print_first(char* f, char* l) const 8585 { 8586 const ptrdiff_t r = l - f; 8587 if (r >= __size_) 8588 { 8589 if (*__name_ == 'n') 8590 { 8591 *f++ = '-'; 8592 strncpy(f, __name_+1, __size_-1); 8593 } 8594 else 8595 strncpy(f, __name_, __size_); 8596 } 8597 return __size_; 8598 } 8599}; 8600 8601class __unsigned_int 8602 : public __node 8603{ 8604 static const size_t n = sizeof("unsigned int") - 1; 8605public: 8606 8607 virtual size_t first_size() const {return n;} 8608 virtual char* first_demangled_name(char* buf) const 8609 { 8610 strncpy(buf, "unsigned int", n); 8611 return buf + n; 8612 } 8613 virtual ptrdiff_t print_first(char* f, char* l) const 8614 { 8615 const ptrdiff_t r = l - f; 8616 if (r >= n) 8617 { 8618 *f++ = 'u'; 8619 *f++ = 'n'; 8620 *f++ = 's'; 8621 *f++ = 'i'; 8622 *f++ = 'g'; 8623 *f++ = 'n'; 8624 *f++ = 'e'; 8625 *f++ = 'd'; 8626 *f++ = ' '; 8627 *f++ = 'i'; 8628 *f++ = 'n'; 8629 *f = 't'; 8630 } 8631 return n; 8632 } 8633}; 8634 8635class __unsigned_int_literal 8636 : public __node 8637{ 8638public: 8639 explicit __unsigned_int_literal(const char* __first, const char* __last) 8640 { 8641 __name_ = __first; 8642 __size_ = __last - __first; 8643 } 8644 8645 virtual size_t first_size() const 8646 { 8647 return __size_+1; 8648 } 8649 virtual char* first_demangled_name(char* buf) const 8650 { 8651 strncpy(buf, __name_, __size_); 8652 buf += __size_; 8653 *buf++ = 'u'; 8654 return buf; 8655 } 8656 virtual ptrdiff_t print_first(char* f, char* l) const 8657 { 8658 const ptrdiff_t r = l - f; 8659 const ptrdiff_t n = sizeof("u") - 1; 8660 if (r >= __size_ + n) 8661 { 8662 strncpy(f, __name_, __size_); 8663 f[__size_] = 'u'; 8664 } 8665 return __size_ + n; 8666 } 8667}; 8668 8669class __long 8670 : public __node 8671{ 8672 static const size_t n = sizeof("long") - 1; 8673public: 8674 8675 virtual size_t first_size() const {return n;} 8676 virtual char* first_demangled_name(char* buf) const 8677 { 8678 strncpy(buf, "long", n); 8679 return buf + n; 8680 } 8681 virtual ptrdiff_t print_first(char* f, char* l) const 8682 { 8683 const ptrdiff_t r = l - f; 8684 if (r >= n) 8685 { 8686 *f++ = 'l'; 8687 *f++ = 'o'; 8688 *f++ = 'n'; 8689 *f = 'g'; 8690 } 8691 return n; 8692 } 8693}; 8694 8695class __long_literal 8696 : public __node 8697{ 8698public: 8699 explicit __long_literal(const char* __first, const char* __last) 8700 { 8701 __name_ = __first; 8702 __size_ = __last - __first; 8703 } 8704 8705 virtual size_t first_size() const 8706 { 8707 return __size_+1; 8708 } 8709 virtual char* first_demangled_name(char* buf) const 8710 { 8711 if (*__name_ == 'n') 8712 { 8713 *buf++ = '-'; // strncpy(buf, "-", 1); 8714 strncpy(buf, __name_+1, __size_-1); 8715 buf += __size_ - 1; 8716 } 8717 else 8718 { 8719 strncpy(buf, __name_, __size_); 8720 buf += __size_; 8721 } 8722 *buf++ = 'l'; 8723 return buf; 8724 } 8725 virtual ptrdiff_t print_first(char* f, char* l) const 8726 { 8727 const ptrdiff_t r = l - f; 8728 const ptrdiff_t n = sizeof("l") - 1; 8729 if (r >= __size_ + n) 8730 { 8731 if (*__name_ == 'n') 8732 { 8733 *f++ = '-'; 8734 strncpy(f, __name_+1, __size_-1); 8735 f += __size_-1; 8736 } 8737 else 8738 { 8739 strncpy(f, __name_, __size_); 8740 f += __size_; 8741 } 8742 *f = 'l'; 8743 } 8744 return __size_ + n; 8745 } 8746}; 8747 8748class __unsigned_long 8749 : public __node 8750{ 8751 static const size_t n = sizeof("unsigned long") - 1; 8752public: 8753 8754 virtual size_t first_size() const {return n;} 8755 virtual char* first_demangled_name(char* buf) const 8756 { 8757 strncpy(buf, "unsigned long", n); 8758 return buf + n; 8759 } 8760 virtual ptrdiff_t print_first(char* f, char* l) const 8761 { 8762 const ptrdiff_t r = l - f; 8763 if (r >= n) 8764 { 8765 *f++ = 'u'; 8766 *f++ = 'n'; 8767 *f++ = 's'; 8768 *f++ = 'i'; 8769 *f++ = 'g'; 8770 *f++ = 'n'; 8771 *f++ = 'e'; 8772 *f++ = 'd'; 8773 *f++ = ' '; 8774 *f++ = 'l'; 8775 *f++ = 'o'; 8776 *f++ = 'n'; 8777 *f = 'g'; 8778 } 8779 return n; 8780 } 8781}; 8782 8783class __unsigned_long_literal 8784 : public __node 8785{ 8786public: 8787 explicit __unsigned_long_literal(const char* __first, const char* __last) 8788 { 8789 __name_ = __first; 8790 __size_ = __last - __first; 8791 } 8792 8793 virtual size_t first_size() const 8794 { 8795 return __size_+2; 8796 } 8797 virtual char* first_demangled_name(char* buf) const 8798 { 8799 strncpy(buf, __name_, __size_); 8800 buf += __size_; 8801 *buf++ = 'u'; 8802 *buf++ = 'l'; 8803 return buf; 8804 } 8805 virtual ptrdiff_t print_first(char* f, char* l) const 8806 { 8807 const ptrdiff_t r = l - f; 8808 const ptrdiff_t n = sizeof("ul") - 1; 8809 if (r >= __size_ + n) 8810 { 8811 strncpy(f, __name_, __size_); 8812 f += __size_; 8813 *f++ = 'u'; 8814 *f = 'l'; 8815 } 8816 return __size_ + n; 8817 } 8818}; 8819 8820class __long_long 8821 : public __node 8822{ 8823 static const size_t n = sizeof("long long") - 1; 8824public: 8825 8826 virtual size_t first_size() const {return n;} 8827 virtual char* first_demangled_name(char* buf) const 8828 { 8829 strncpy(buf, "long long", n); 8830 return buf + n; 8831 } 8832 virtual ptrdiff_t print_first(char* f, char* l) const 8833 { 8834 const ptrdiff_t r = l - f; 8835 if (r >= n) 8836 { 8837 *f++ = 'l'; 8838 *f++ = 'o'; 8839 *f++ = 'n'; 8840 *f++ = 'g'; 8841 *f++ = ' '; 8842 *f++ = 'l'; 8843 *f++ = 'o'; 8844 *f++ = 'n'; 8845 *f = 'g'; 8846 } 8847 return n; 8848 } 8849}; 8850 8851class __long_long_literal 8852 : public __node 8853{ 8854public: 8855 explicit __long_long_literal(const char* __first, const char* __last) 8856 { 8857 __name_ = __first; 8858 __size_ = __last - __first; 8859 } 8860 8861 virtual size_t first_size() const 8862 { 8863 return __size_+2; 8864 } 8865 virtual char* first_demangled_name(char* buf) const 8866 { 8867 if (*__name_ == 'n') 8868 { 8869 *buf++ = '-'; 8870 strncpy(buf, __name_+1, __size_-1); 8871 buf += __size_ - 1; 8872 } 8873 else 8874 { 8875 strncpy(buf, __name_, __size_); 8876 buf += __size_; 8877 } 8878 *buf++ = 'l'; 8879 *buf++ = 'l'; 8880 return buf; 8881 } 8882 virtual ptrdiff_t print_first(char* f, char* l) const 8883 { 8884 const ptrdiff_t r = l - f; 8885 const ptrdiff_t n = sizeof("ll") - 1; 8886 if (r >= __size_ + n) 8887 { 8888 if (*__name_ == 'n') 8889 { 8890 *f++ = '-'; 8891 strncpy(f, __name_+1, __size_-1); 8892 f += __size_-1; 8893 } 8894 else 8895 { 8896 strncpy(f, __name_, __size_); 8897 f += __size_; 8898 } 8899 *f++ = 'l'; 8900 *f = 'l'; 8901 } 8902 return __size_ + n; 8903 } 8904}; 8905 8906class __unsigned_long_long 8907 : public __node 8908{ 8909 static const size_t n = sizeof("unsigned long long") - 1; 8910public: 8911 8912 virtual size_t first_size() const {return n;} 8913 virtual char* first_demangled_name(char* buf) const 8914 { 8915 strncpy(buf, "unsigned long long", n); 8916 return buf + n; 8917 } 8918 virtual ptrdiff_t print_first(char* f, char* l) const 8919 { 8920 const ptrdiff_t r = l - f; 8921 if (r >= n) 8922 { 8923 *f++ = 'u'; 8924 *f++ = 'n'; 8925 *f++ = 's'; 8926 *f++ = 'i'; 8927 *f++ = 'g'; 8928 *f++ = 'n'; 8929 *f++ = 'e'; 8930 *f++ = 'd'; 8931 *f++ = ' '; 8932 *f++ = 'l'; 8933 *f++ = 'o'; 8934 *f++ = 'n'; 8935 *f++ = 'g'; 8936 *f++ = ' '; 8937 *f++ = 'l'; 8938 *f++ = 'o'; 8939 *f++ = 'n'; 8940 *f = 'g'; 8941 } 8942 return n; 8943 } 8944}; 8945 8946class __unsigned_long_long_literal 8947 : public __node 8948{ 8949public: 8950 explicit __unsigned_long_long_literal(const char* __first, const char* __last) 8951 { 8952 __name_ = __first; 8953 __size_ = __last - __first; 8954 } 8955 8956 virtual size_t first_size() const 8957 { 8958 return __size_+3; 8959 } 8960 virtual char* first_demangled_name(char* buf) const 8961 { 8962 strncpy(buf, __name_, __size_); 8963 buf += __size_; 8964 *buf++ = 'u'; 8965 *buf++ = 'l'; 8966 *buf++ = 'l'; 8967 return buf; 8968 } 8969 virtual ptrdiff_t print_first(char* f, char* l) const 8970 { 8971 const ptrdiff_t r = l - f; 8972 const ptrdiff_t n = sizeof("ull") - 1; 8973 if (r >= __size_ + n) 8974 { 8975 strncpy(f, __name_, __size_); 8976 f += __size_; 8977 *f++ = 'u'; 8978 *f++ = 'l'; 8979 *f = 'l'; 8980 } 8981 return __size_ + n; 8982 } 8983}; 8984 8985class __int128 8986 : public __node 8987{ 8988 static const size_t n = sizeof("__int128") - 1; 8989public: 8990 8991 virtual size_t first_size() const {return n;} 8992 virtual char* first_demangled_name(char* buf) const 8993 { 8994 strncpy(buf, "__int128", n); 8995 return buf + n; 8996 } 8997 virtual ptrdiff_t print_first(char* f, char* l) const 8998 { 8999 const ptrdiff_t r = l - f; 9000 if (r >= n) 9001 { 9002 *f++ = '_'; 9003 *f++ = '_'; 9004 *f++ = 'i'; 9005 *f++ = 'n'; 9006 *f++ = 't'; 9007 *f++ = '1'; 9008 *f++ = '2'; 9009 *f = '8'; 9010 } 9011 return n; 9012 } 9013}; 9014 9015class __int128_literal 9016 : public __node 9017{ 9018public: 9019 explicit __int128_literal(const char* __first, const char* __last) 9020 { 9021 __name_ = __first; 9022 __size_ = __last - __first; 9023 } 9024 9025 virtual size_t first_size() const 9026 { 9027 return __size_+10; 9028 } 9029 virtual char* first_demangled_name(char* buf) const 9030 { 9031 strncpy(buf, "(__int128)", 10); 9032 buf += 10; 9033 if (*__name_ == 'n') 9034 { 9035 *buf++ = '-'; 9036 strncpy(buf, __name_+1, __size_-1); 9037 buf += __size_ - 1; 9038 } 9039 else 9040 { 9041 strncpy(buf, __name_, __size_); 9042 buf += __size_; 9043 } 9044 return buf; 9045 } 9046 virtual ptrdiff_t print_first(char* f, char* l) const 9047 { 9048 const ptrdiff_t r = l - f; 9049 const ptrdiff_t n = sizeof("(__int128)") - 1; 9050 if (r >= __size_ + n) 9051 { 9052 *f++ = '('; 9053 *f++ = '_'; 9054 *f++ = '_'; 9055 *f++ = 'i'; 9056 *f++ = 'n'; 9057 *f++ = 't'; 9058 *f++ = '1'; 9059 *f++ = '2'; 9060 *f++ = '8'; 9061 *f = ')'; 9062 if (*__name_ == 'n') 9063 { 9064 *f++ = '-'; 9065 strncpy(f, __name_+1, __size_-1); 9066 } 9067 else 9068 strncpy(f, __name_, __size_); 9069 } 9070 return __size_ + n; 9071 } 9072}; 9073 9074class __unsigned_int128 9075 : public __node 9076{ 9077 static const size_t n = sizeof("unsigned __int128") - 1; 9078public: 9079 9080 virtual size_t first_size() const {return n;} 9081 virtual char* first_demangled_name(char* buf) const 9082 { 9083 strncpy(buf, "unsigned __int128", n); 9084 return buf + n; 9085 } 9086 virtual ptrdiff_t print_first(char* f, char* l) const 9087 { 9088 const ptrdiff_t r = l - f; 9089 if (r >= n) 9090 { 9091 *f++ = 'u'; 9092 *f++ = 'n'; 9093 *f++ = 's'; 9094 *f++ = 'i'; 9095 *f++ = 'g'; 9096 *f++ = 'n'; 9097 *f++ = 'e'; 9098 *f++ = 'd'; 9099 *f++ = ' '; 9100 *f++ = '_'; 9101 *f++ = '_'; 9102 *f++ = 'i'; 9103 *f++ = 'n'; 9104 *f++ = 't'; 9105 *f++ = '1'; 9106 *f++ = '2'; 9107 *f = '8'; 9108 } 9109 return n; 9110 } 9111}; 9112 9113class __unsigned_int128_literal 9114 : public __node 9115{ 9116public: 9117 explicit __unsigned_int128_literal(const char* __first, const char* __last) 9118 { 9119 __name_ = __first; 9120 __size_ = __last - __first; 9121 } 9122 9123 virtual size_t first_size() const 9124 { 9125 return __size_+19; 9126 } 9127 virtual char* first_demangled_name(char* buf) const 9128 { 9129 strncpy(buf, "(unsigned __int128)", 19); 9130 buf += 19; 9131 strncpy(buf, __name_, __size_); 9132 return buf + __size_; 9133 } 9134 virtual ptrdiff_t print_first(char* f, char* l) const 9135 { 9136 const ptrdiff_t r = l - f; 9137 const ptrdiff_t n = sizeof("(unsigned __int128)") - 1; 9138 if (r >= __size_ + n) 9139 { 9140 *f++ = '('; 9141 *f++ = 'u'; 9142 *f++ = 'n'; 9143 *f++ = 's'; 9144 *f++ = 'i'; 9145 *f++ = 'g'; 9146 *f++ = 'n'; 9147 *f++ = 'e'; 9148 *f++ = 'd'; 9149 *f++ = ' '; 9150 *f++ = '_'; 9151 *f++ = '_'; 9152 *f++ = 'i'; 9153 *f++ = 'n'; 9154 *f++ = 't'; 9155 *f++ = '1'; 9156 *f++ = '2'; 9157 *f++ = '8'; 9158 *f = ')'; 9159 strncpy(f, __name_, __size_); 9160 } 9161 return __size_ + n; 9162 } 9163}; 9164 9165class __float_literal 9166 : public __node 9167{ 9168public: 9169 explicit __float_literal(float value) 9170 { 9171 __value_ = value; 9172 } 9173 9174 virtual size_t first_size() const 9175 { 9176 if (__cached_size_ == -1) 9177 { 9178 char num[20] = {0}; 9179 float v = static_cast<float>(__value_); 9180 const_cast<long&>(__cached_size_) = sprintf(num, "%a", v)+1; 9181 } 9182 return __cached_size_; 9183 } 9184 virtual char* first_demangled_name(char* buf) const 9185 { 9186 char num[20] = {0}; 9187 float v = static_cast<float>(__value_); 9188 int n = sprintf(num, "%a", v); 9189 strncpy(buf, num, n); 9190 buf += n; 9191 *buf++ = 'f'; 9192 return buf; 9193 } 9194 virtual ptrdiff_t print_first(char* f, char* l) const 9195 { 9196 const ptrdiff_t r = l - f; 9197 char num[20] = {0}; 9198 float v = static_cast<float>(__value_); 9199 ptrdiff_t n = sprintf(num, "%a", v); 9200 if (r >= n+1) 9201 { 9202 strncpy(f, num, n); 9203 f[n] = 'f'; 9204 } 9205 ++n; 9206 return n; 9207 } 9208}; 9209 9210class __float 9211 : public __node 9212{ 9213 static const size_t n = sizeof("float") - 1; 9214public: 9215 9216 virtual size_t first_size() const {return n;} 9217 virtual char* first_demangled_name(char* buf) const 9218 { 9219 strncpy(buf, "float", n); 9220 return buf + n; 9221 } 9222 virtual ptrdiff_t print_first(char* f, char* l) const 9223 { 9224 const ptrdiff_t r = l - f; 9225 if (r >= n) 9226 { 9227 *f++ = 'f'; 9228 *f++ = 'l'; 9229 *f++ = 'o'; 9230 *f++ = 'a'; 9231 *f = 't'; 9232 } 9233 return n; 9234 } 9235}; 9236 9237class __double_literal 9238 : public __node 9239{ 9240public: 9241 explicit __double_literal(double value) 9242 { 9243 __value_ = value; 9244 } 9245 9246 virtual size_t first_size() const 9247 { 9248 if (__cached_size_ == -1) 9249 { 9250 char num[30] = {0}; 9251 double v = static_cast<double>(__value_); 9252 const_cast<long&>(__cached_size_) = sprintf(num, "%a", v); 9253 } 9254 return __cached_size_; 9255 } 9256 virtual char* first_demangled_name(char* buf) const 9257 { 9258 char num[30] = {0}; 9259 double v = static_cast<double>(__value_); 9260 int n = sprintf(num, "%a", v); 9261 strncpy(buf, num, n); 9262 return buf + n; 9263 } 9264 virtual ptrdiff_t print_first(char* f, char* l) const 9265 { 9266 const ptrdiff_t r = l - f; 9267 char num[30] = {0}; 9268 double v = static_cast<double>(__value_); 9269 const ptrdiff_t n = sprintf(num, "%a", v); 9270 if (r >= n) 9271 strncpy(f, num, n); 9272 return n; 9273 } 9274}; 9275 9276class __double 9277 : public __node 9278{ 9279 static const size_t n = sizeof("double") - 1; 9280public: 9281 9282 virtual size_t first_size() const {return n;} 9283 virtual char* first_demangled_name(char* buf) const 9284 { 9285 strncpy(buf, "double", n); 9286 return buf + n; 9287 } 9288 virtual ptrdiff_t print_first(char* f, char* l) const 9289 { 9290 const ptrdiff_t r = l - f; 9291 if (r >= n) 9292 { 9293 *f++ = 'd'; 9294 *f++ = 'o'; 9295 *f++ = 'u'; 9296 *f++ = 'b'; 9297 *f++ = 'l'; 9298 *f = 'e'; 9299 } 9300 return n; 9301 } 9302}; 9303 9304class __long_double 9305 : public __node 9306{ 9307 static const size_t n = sizeof("long double") - 1; 9308public: 9309 9310 virtual size_t first_size() const {return n;} 9311 virtual char* first_demangled_name(char* buf) const 9312 { 9313 strncpy(buf, "long double", n); 9314 return buf + n; 9315 } 9316 virtual ptrdiff_t print_first(char* f, char* l) const 9317 { 9318 const ptrdiff_t r = l - f; 9319 if (r >= n) 9320 { 9321 *f++ = 'l'; 9322 *f++ = 'o'; 9323 *f++ = 'n'; 9324 *f++ = 'g'; 9325 *f++ = ' '; 9326 *f++ = 'd'; 9327 *f++ = 'o'; 9328 *f++ = 'u'; 9329 *f++ = 'b'; 9330 *f++ = 'l'; 9331 *f = 'e'; 9332 } 9333 return n; 9334 } 9335}; 9336 9337class __float128 9338 : public __node 9339{ 9340 static const size_t n = sizeof("__float128") - 1; 9341public: 9342 9343 virtual size_t first_size() const {return n;} 9344 virtual char* first_demangled_name(char* buf) const 9345 { 9346 strncpy(buf, "__float128", n); 9347 return buf + n; 9348 } 9349 virtual ptrdiff_t print_first(char* f, char* l) const 9350 { 9351 const ptrdiff_t r = l - f; 9352 if (r >= n) 9353 { 9354 *f++ = '_'; 9355 *f++ = '_'; 9356 *f++ = 'f'; 9357 *f++ = 'l'; 9358 *f++ = 'o'; 9359 *f++ = 'a'; 9360 *f++ = 't'; 9361 *f++ = '1'; 9362 *f++ = '2'; 9363 *f = '8'; 9364 } 9365 return n; 9366 } 9367}; 9368 9369class __ellipsis 9370 : public __node 9371{ 9372 static const size_t n = sizeof("...") - 1; 9373public: 9374 9375 virtual size_t first_size() const {return n;} 9376 virtual char* first_demangled_name(char* buf) const 9377 { 9378 *buf++ = '.'; 9379 *buf++ = '.'; 9380 *buf++ = '.'; 9381 return buf; 9382 } 9383 virtual ptrdiff_t print_first(char* f, char* l) const 9384 { 9385 const ptrdiff_t r = l - f; 9386 if (r >= n) 9387 { 9388 *f++ = '.'; 9389 *f++ = '.'; 9390 *f = '.'; 9391 } 9392 return n; 9393 } 9394}; 9395 9396class __decimal64 9397 : public __node 9398{ 9399 static const size_t n = sizeof("decimal64") - 1; 9400public: 9401 9402 virtual size_t first_size() const {return n;} 9403 virtual char* first_demangled_name(char* buf) const 9404 { 9405 strncpy(buf, "decimal64", n); 9406 return buf + n; 9407 } 9408 virtual ptrdiff_t print_first(char* f, char* l) const 9409 { 9410 const ptrdiff_t r = l - f; 9411 if (r >= n) 9412 { 9413 *f++ = 'd'; 9414 *f++ = 'e'; 9415 *f++ = 'c'; 9416 *f++ = 'i'; 9417 *f++ = 'm'; 9418 *f++ = 'a'; 9419 *f++ = 'l'; 9420 *f++ = '6'; 9421 *f = '4'; 9422 } 9423 return n; 9424 } 9425}; 9426 9427class __decimal128 9428 : public __node 9429{ 9430 static const size_t n = sizeof("decimal128") - 1; 9431public: 9432 9433 virtual size_t first_size() const {return n;} 9434 virtual char* first_demangled_name(char* buf) const 9435 { 9436 strncpy(buf, "decimal128", n); 9437 return buf + n; 9438 } 9439 virtual ptrdiff_t print_first(char* f, char* l) const 9440 { 9441 const ptrdiff_t r = l - f; 9442 if (r >= n) 9443 { 9444 *f++ = 'd'; 9445 *f++ = 'e'; 9446 *f++ = 'c'; 9447 *f++ = 'i'; 9448 *f++ = 'm'; 9449 *f++ = 'a'; 9450 *f++ = 'l'; 9451 *f++ = '1'; 9452 *f++ = '2'; 9453 *f = '8'; 9454 } 9455 return n; 9456 } 9457}; 9458 9459class __decimal32 9460 : public __node 9461{ 9462 static const size_t n = sizeof("decimal32") - 1; 9463public: 9464 9465 virtual size_t first_size() const {return n;} 9466 virtual char* first_demangled_name(char* buf) const 9467 { 9468 strncpy(buf, "decimal32", n); 9469 return buf + n; 9470 } 9471 virtual ptrdiff_t print_first(char* f, char* l) const 9472 { 9473 const ptrdiff_t r = l - f; 9474 if (r >= n) 9475 { 9476 *f++ = 'd'; 9477 *f++ = 'e'; 9478 *f++ = 'c'; 9479 *f++ = 'i'; 9480 *f++ = 'm'; 9481 *f++ = 'a'; 9482 *f++ = 'l'; 9483 *f++ = '3'; 9484 *f = '2'; 9485 } 9486 return n; 9487 } 9488}; 9489 9490class __decimal16 9491 : public __node 9492{ 9493 static const size_t n = sizeof("decimal16") - 1; 9494public: 9495 9496 virtual size_t first_size() const {return n;} 9497 virtual char* first_demangled_name(char* buf) const 9498 { 9499 strncpy(buf, "decimal16", n); 9500 return buf + n; 9501 } 9502 virtual ptrdiff_t print_first(char* f, char* l) const 9503 { 9504 const ptrdiff_t r = l - f; 9505 if (r >= n) 9506 { 9507 *f++ = 'd'; 9508 *f++ = 'e'; 9509 *f++ = 'c'; 9510 *f++ = 'i'; 9511 *f++ = 'm'; 9512 *f++ = 'a'; 9513 *f++ = 'l'; 9514 *f++ = '1'; 9515 *f = '6'; 9516 } 9517 return n; 9518 } 9519}; 9520 9521class __d_char32_t 9522 : public __node 9523{ 9524 static const size_t n = sizeof("char32_t") - 1; 9525public: 9526 9527 virtual size_t first_size() const {return n;} 9528 virtual char* first_demangled_name(char* buf) const 9529 { 9530 strncpy(buf, "char32_t", n); 9531 return buf + n; 9532 } 9533 virtual ptrdiff_t print_first(char* f, char* l) const 9534 { 9535 const ptrdiff_t r = l - f; 9536 if (r >= n) 9537 { 9538 *f++ = 'c'; 9539 *f++ = 'h'; 9540 *f++ = 'a'; 9541 *f++ = 'r'; 9542 *f++ = '3'; 9543 *f++ = '2'; 9544 *f++ = '_'; 9545 *f = 't'; 9546 } 9547 return n; 9548 } 9549}; 9550 9551class __d_char16_t 9552 : public __node 9553{ 9554 static const size_t n = sizeof("char16_t") - 1; 9555public: 9556 9557 virtual size_t first_size() const {return n;} 9558 virtual char* first_demangled_name(char* buf) const 9559 { 9560 strncpy(buf, "char16_t", n); 9561 return buf + n; 9562 } 9563 virtual ptrdiff_t print_first(char* f, char* l) const 9564 { 9565 const ptrdiff_t r = l - f; 9566 if (r >= n) 9567 { 9568 *f++ = 'c'; 9569 *f++ = 'h'; 9570 *f++ = 'a'; 9571 *f++ = 'r'; 9572 *f++ = '1'; 9573 *f++ = '6'; 9574 *f++ = '_'; 9575 *f = 't'; 9576 } 9577 return n; 9578 } 9579}; 9580 9581class __auto 9582 : public __node 9583{ 9584 static const size_t n = sizeof("auto") - 1; 9585public: 9586 9587 virtual size_t first_size() const {return n;} 9588 virtual char* first_demangled_name(char* buf) const 9589 { 9590 strncpy(buf, "auto", n); 9591 return buf + n; 9592 } 9593 virtual ptrdiff_t print_first(char* f, char* l) const 9594 { 9595 const ptrdiff_t r = l - f; 9596 if (r >= n) 9597 { 9598 *f++ = 'a'; 9599 *f++ = 'u'; 9600 *f++ = 't'; 9601 *f = 'o'; 9602 } 9603 return n; 9604 } 9605}; 9606 9607class __nullptr_t 9608 : public __node 9609{ 9610 static const size_t n = sizeof("std::nullptr_t") - 1; 9611public: 9612 9613 virtual size_t first_size() const {return n;} 9614 virtual char* first_demangled_name(char* buf) const 9615 { 9616 strncpy(buf, "std::nullptr_t", n); 9617 return buf + n; 9618 } 9619 virtual ptrdiff_t print_first(char* f, char* l) const 9620 { 9621 const ptrdiff_t r = l - f; 9622 if (r >= n) 9623 { 9624 *f++ = 's'; 9625 *f++ = 't'; 9626 *f++ = 'd'; 9627 *f++ = ':'; 9628 *f++ = ':'; 9629 *f++ = 'n'; 9630 *f++ = 'u'; 9631 *f++ = 'l'; 9632 *f++ = 'l'; 9633 *f++ = 'p'; 9634 *f++ = 't'; 9635 *f++ = 'r'; 9636 *f++ = '_'; 9637 *f = 't'; 9638 } 9639 return n; 9640 } 9641}; 9642 9643class __array 9644 : public __node 9645{ 9646public: 9647 9648 explicit __array(__node* type) 9649 { 9650 __left_ = type; 9651 } 9652 9653 __array(__node* type, size_t dim) 9654 { 9655 __left_ = type; 9656 __size_ = dim; 9657 } 9658 9659 __array(__node* type, __node* dim) 9660 { 9661 __left_ = type; 9662 __right_ = dim; 9663 } 9664 9665 virtual size_t size() const 9666 { 9667 if (__cached_size_ == -1) 9668 { 9669 size_t r = __left_->size() + 3; 9670 if (__right_ != 0) 9671 r += __right_->size(); 9672 else if (__size_ != 0) 9673 r += snprintf(0, 0, "%ld", __size_); 9674 const_cast<long&>(__cached_size_) = r; 9675 } 9676 return __cached_size_; 9677 } 9678 9679 virtual char* get_demangled_name(char* buf) const 9680 { 9681 buf = __left_->get_demangled_name(buf); 9682 *buf++ = ' '; 9683 *buf++ = '['; 9684 if (__right_ != 0) 9685 buf = __right_->get_demangled_name(buf); 9686 else if (__size_ != 0) 9687 { 9688 size_t rs = sprintf(buf, "%ld", __size_); 9689 buf += rs; 9690 } 9691 *buf++ = ']'; 9692 return buf; 9693 } 9694 virtual ptrdiff_t print(char* f, char* l) const 9695 { 9696 const ptrdiff_t r = l - f; 9697 const ptrdiff_t n = 3; 9698 const ptrdiff_t sz1 = __left_->print(f, l); 9699 char buf[20]; 9700 ptrdiff_t sz2 = 0; 9701 if (__right_ != 0) 9702 sz2 = __right_->print(f+std::min(sz1+(n-1), r), l); 9703 else if (__size_ != 0) 9704 { 9705 sz2 = sprintf(buf, "%ld", __size_); 9706 if (r >= sz1 + sz2 + n) 9707 strncpy(f+sz1+2, buf, sz2); 9708 } 9709 if (r >= sz1 + sz2 + n) 9710 { 9711 f += sz1; 9712 *f++ = ' '; 9713 *f = '['; 9714 f += 1 + sz2; 9715 *f = ']'; 9716 } 9717 return sz1 + sz2 + n; 9718 } 9719 9720 virtual size_t first_size() const 9721 { 9722 return __left_->first_size(); 9723 } 9724 9725 virtual char* first_demangled_name(char* buf) const 9726 { 9727 return __left_->first_demangled_name(buf); 9728 } 9729 9730 virtual ptrdiff_t print_first(char* f, char* l) const 9731 { 9732 return __left_->print_first(f, l); 9733 } 9734 9735 virtual size_t second_size() const 9736 { 9737 size_t r = 2 + __left_->second_size(); 9738 if (!__left_->is_array()) 9739 ++r; 9740 if (__right_ != 0) 9741 r += __right_->size(); 9742 else if (__size_ != 0) 9743 r += snprintf(0, 0, "%ld", __size_); 9744 return r; 9745 } 9746 9747 virtual char* second_demangled_name(char* buf) const 9748 { 9749 *buf++ = ' '; 9750 *buf++ = '['; 9751 if (__right_ != 0) 9752 buf = __right_->get_demangled_name(buf); 9753 else if (__size_ != 0) 9754 { 9755 size_t off = sprintf(buf, "%ld", __size_); 9756 buf += off; 9757 } 9758 char* t = buf; 9759 buf = __left_->second_demangled_name(buf); 9760 *t = ']'; 9761 if (buf == t) 9762 ++buf; 9763 return buf; 9764 } 9765 virtual ptrdiff_t print_second(char* f, char* l) const 9766 { 9767 const ptrdiff_t r = l - f; 9768 ptrdiff_t n = 2; 9769 char buf[20]; 9770 ptrdiff_t sz2 = 0; 9771 if (__right_ != 0) 9772 sz2 = __right_->print(f+std::min(n, r), l); 9773 else if (__size_ != 0) 9774 { 9775 sz2 = sprintf(buf, "%ld", __size_); 9776 if (r >= sz2 + 3) 9777 strncpy(f+2, buf, sz2); 9778 } 9779 const ptrdiff_t sz1 = __left_->print_second(f+std::min(2+sz2, r), l); 9780 if (sz1 == 0) 9781 ++n; 9782 if (r >= sz1 + sz2 + n) 9783 { 9784 *f++ = ' '; 9785 *f = '['; 9786 f += 1 + sz2; 9787 *f = ']'; 9788 } 9789 return sz1 + sz2 + n; 9790 } 9791 virtual bool is_array() const 9792 { 9793 return true; 9794 } 9795 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 9796 { 9797 bool r = __left_->fix_forward_references(t_begin, t_end); 9798 if (__right_) 9799 r = r && __right_->fix_forward_references(t_begin, t_end); 9800 return r; 9801 } 9802}; 9803 9804class __pointer_to_member_type 9805 : public __node 9806{ 9807public: 9808 9809 __pointer_to_member_type(__node* class_type, __node* member_type) 9810 { 9811 __left_ = class_type; 9812 __right_ = member_type; 9813 } 9814 9815 virtual size_t first_size() const 9816 { 9817 if (__cached_size_ == -1) 9818 const_cast<long&>(__cached_size_) = __left_->size() + 3 + __right_->size(); 9819 return __cached_size_; 9820 } 9821 virtual char* first_demangled_name(char* buf) const 9822 { 9823 buf = __right_->first_demangled_name(buf); 9824 buf = __left_->get_demangled_name(buf); 9825 *buf++ = ':'; 9826 *buf++ = ':'; 9827 *buf++ = '*'; 9828 return __right_->second_demangled_name(buf); 9829 } 9830 virtual ptrdiff_t print_first(char* f, char* l) const 9831 { 9832 const ptrdiff_t r = l - f; 9833 const ptrdiff_t n = 3; 9834 const ptrdiff_t sz1 = __right_->print_first(f, l); 9835 const ptrdiff_t sz2 = __left_->print(f+std::min(sz1, r), l); 9836 const ptrdiff_t sz3 = __right_->print_second(f+std::min(sz1+sz2+n, r), l); 9837 if (r >= sz1 + sz2 + sz3 + n) 9838 { 9839 f += sz1 + sz2; 9840 *f++ = ':'; 9841 *f++ = ':'; 9842 *f = '*'; 9843 } 9844 return sz1 + sz2 + sz3 + n; 9845 } 9846 virtual __node* base_name() const 9847 { 9848 return __left_->base_name(); 9849 } 9850 virtual bool is_reference_or_pointer_to_function_or_array() const 9851 { 9852 return __right_->is_function(); 9853 } 9854 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 9855 { 9856 return __left_->fix_forward_references(t_begin, t_end) && 9857 __right_->fix_forward_references(t_begin, t_end); 9858 } 9859}; 9860 9861class __decltype_node 9862 : public __node 9863{ 9864public: 9865 9866 explicit __decltype_node(__node* expr) 9867 { 9868 __right_ = expr; 9869 } 9870 9871 virtual size_t first_size() const 9872 { 9873 if (__cached_size_ == -1) 9874 const_cast<long&>(__cached_size_) = 10 + __right_->size(); 9875 return __cached_size_; 9876 } 9877 9878 virtual char* first_demangled_name(char* buf) const 9879 { 9880 strncpy(buf, "decltype(", 9); 9881 buf += 9; 9882 buf = __right_->get_demangled_name(buf); 9883 *buf++ = ')'; 9884 return buf; 9885 } 9886 virtual ptrdiff_t print_first(char* f, char* l) const 9887 { 9888 const ptrdiff_t r = l - f; 9889 const ptrdiff_t n = sizeof("decltype()") - 1; 9890 const ptrdiff_t sz1 = __right_->print(f+std::min(n-1, r), l); 9891 if (r >= sz1 + n) 9892 { 9893 *f++ = 'd'; 9894 *f++ = 'e'; 9895 *f++ = 'c'; 9896 *f++ = 'l'; 9897 *f++ = 't'; 9898 *f++ = 'y'; 9899 *f++ = 'p'; 9900 *f++ = 'e'; 9901 *f = '('; 9902 f += 1 + sz1; 9903 *f = ')'; 9904 } 9905 return sz1 + n; 9906 } 9907 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 9908 { 9909 return __right_->fix_forward_references(t_begin, t_end); 9910 } 9911}; 9912 9913class __nested_delimeter 9914 : public __node 9915{ 9916public: 9917 9918 explicit __nested_delimeter(__node* prev, __node* arg) 9919 { 9920 __left_ = prev; 9921 __right_ = arg; 9922 } 9923 9924 virtual size_t first_size() const 9925 { 9926 if (__cached_size_ == -1) 9927 const_cast<long&>(__cached_size_) = __left_->size() + __right_->size() + 2; 9928 return __cached_size_; 9929 } 9930 9931 virtual char* first_demangled_name(char* buf) const 9932 { 9933 buf = __left_->get_demangled_name(buf); 9934 *buf++ = ':'; 9935 *buf++ = ':'; 9936 return __right_->get_demangled_name(buf); 9937 } 9938 virtual ptrdiff_t print_first(char* f, char* l) const 9939 { 9940 const ptrdiff_t r = l - f; 9941 const ptrdiff_t n = sizeof("::") - 1; 9942 const ptrdiff_t sz1 = __left_->print(f, l); 9943 if (r >= sz1 + n) 9944 { 9945 f += sz1; 9946 *f++ = ':'; 9947 *f++ = ':'; 9948 } 9949 const ptrdiff_t sz2 = __right_->print(f, l); 9950 return sz1 + n + sz2; 9951 } 9952 9953 virtual bool ends_with_template() const 9954 { 9955 return __right_->ends_with_template(); 9956 } 9957 virtual __node* base_name() const 9958 { 9959 return __right_->base_name(); 9960 } 9961 virtual bool is_ctor_dtor_conv() const 9962 { 9963 return __right_->is_ctor_dtor_conv(); 9964 } 9965 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 9966 { 9967 return __left_->fix_forward_references(t_begin, t_end) && 9968 __right_->fix_forward_references(t_begin, t_end); 9969 } 9970 virtual __node* extract_cv(__node*& rt) const 9971 { 9972 return __right_->extract_cv(const_cast<__node*&>(__right_)); 9973 } 9974}; 9975 9976class __unresolved_name 9977 : public __node 9978{ 9979public: 9980 9981 __unresolved_name(__node* prev, __node* arg) 9982 { 9983 __left_ = prev; 9984 __right_ = arg; 9985 } 9986 9987 __unresolved_name(bool global, __node* prev, __node* arg) 9988 { 9989 __size_ = global; 9990 __left_ = prev; 9991 __right_ = arg; 9992 } 9993 9994 virtual size_t first_size() const 9995 { 9996 if (__cached_size_ == -1) 9997 const_cast<long&>(__cached_size_) = (__left_ ? __left_->size() + 2 : 0) + 9998 __right_->size() + __size_ * 2; 9999 return __cached_size_; 10000 } 10001 10002 virtual char* first_demangled_name(char* buf) const 10003 { 10004 if (__size_) 10005 { 10006 *buf++ = ':'; 10007 *buf++ = ':'; 10008 } 10009 if (__left_) 10010 { 10011 buf = __left_->get_demangled_name(buf); 10012 *buf++ = ':'; 10013 *buf++ = ':'; 10014 } 10015 return __right_->get_demangled_name(buf); 10016 } 10017 virtual ptrdiff_t print_first(char* f, char* l) const 10018 { 10019 const ptrdiff_t r = l - f; 10020 ptrdiff_t n = 0; 10021 if (__size_) 10022 { 10023 n = 2; 10024 if (r >= n) 10025 { 10026 f[0] = ':'; 10027 f[1] = ':'; 10028 } 10029 } 10030 ptrdiff_t sz1 = 0; 10031 if (__left_) 10032 { 10033 sz1 = __left_->print(f+std::min(n, r), l); 10034 n += 2; 10035 if (r >= sz1 + n) 10036 { 10037 f[sz1 + n - 2] = ':'; 10038 f[sz1 + n - 1] = ':'; 10039 } 10040 } 10041 const ptrdiff_t sz2 = __right_->print(f+std::min(sz1+n, r), l); 10042 return sz1 + n + sz2; 10043 } 10044 10045 virtual bool ends_with_template() const 10046 { 10047 return __right_->ends_with_template(); 10048 } 10049 virtual __node* base_name() const 10050 { 10051 return __right_->base_name(); 10052 } 10053 virtual bool is_ctor_dtor_conv() const 10054 { 10055 return __right_->is_ctor_dtor_conv(); 10056 } 10057 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 10058 { 10059 bool r = true; 10060 if (__left_) 10061 r = __left_->fix_forward_references(t_begin, t_end); 10062 return r && __right_->fix_forward_references(t_begin, t_end); 10063 } 10064 virtual __node* extract_cv(__node*& rt) const 10065 { 10066 return __right_->extract_cv(const_cast<__node*&>(__right_)); 10067 } 10068}; 10069 10070class __string_literal 10071 : public __node 10072{ 10073public: 10074 10075 virtual size_t first_size() const 10076 { 10077 return 14; 10078 } 10079 10080 virtual char* first_demangled_name(char* buf) const 10081 { 10082 strncpy(buf, "string literal", 14); 10083 return buf + 14; 10084 } 10085 virtual ptrdiff_t print_first(char* f, char* l) const 10086 { 10087 const ptrdiff_t r = l - f; 10088 const ptrdiff_t n = sizeof("string literal") - 1; 10089 if (r >= n) 10090 { 10091 *f++ = 's'; 10092 *f++ = 't'; 10093 *f++ = 'r'; 10094 *f++ = 'i'; 10095 *f++ = 'n'; 10096 *f++ = 'g'; 10097 *f++ = ' '; 10098 *f++ = 'l'; 10099 *f++ = 'i'; 10100 *f++ = 't'; 10101 *f++ = 'e'; 10102 *f++ = 'r'; 10103 *f++ = 'a'; 10104 *f = 'l'; 10105 } 10106 return n; 10107 } 10108}; 10109 10110class __constructor 10111 : public __node 10112{ 10113public: 10114 10115 explicit __constructor(__node* name) 10116 { 10117 __right_ = name; 10118 } 10119 10120 virtual size_t first_size() const 10121 { 10122 if (__cached_size_ == -1) 10123 const_cast<long&>(__cached_size_) = __right_->base_size(); 10124 return __cached_size_; 10125 } 10126 10127 virtual char* first_demangled_name(char* buf) const 10128 { 10129 return __right_->get_base_name(buf); 10130 } 10131 virtual ptrdiff_t print_first(char* f, char* l) const 10132 { 10133 return __right_->print_base_name(f, l); 10134 } 10135 virtual __node* base_name() const 10136 { 10137 return __right_->base_name(); 10138 } 10139 virtual bool ends_with_template() const 10140 { 10141 return __right_->ends_with_template(); 10142 } 10143 virtual bool is_ctor_dtor_conv() const 10144 { 10145 return true; 10146 } 10147 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 10148 { 10149 return __right_->fix_forward_references(t_begin, t_end); 10150 } 10151}; 10152 10153class __destructor 10154 : public __node 10155{ 10156public: 10157 10158 explicit __destructor(__node* name) 10159 { 10160 __right_ = name; 10161 } 10162 10163 virtual size_t first_size() const 10164 { 10165 if (__cached_size_ == -1) 10166 const_cast<long&>(__cached_size_) = __right_->base_size() + 1; 10167 return __cached_size_; 10168 } 10169 10170 virtual char* first_demangled_name(char* buf) const 10171 { 10172 *buf++ = '~'; 10173 return __right_->get_base_name(buf); 10174 } 10175 virtual ptrdiff_t print_first(char* f, char* l) const 10176 { 10177 const ptrdiff_t r = l - f; 10178 const ptrdiff_t n = 1; 10179 const ptrdiff_t sz = __right_->print_base_name(f+std::min(n, r), l); 10180 if (r >= n + sz) 10181 *f = '~'; 10182 return n + sz; 10183 } 10184 virtual __node* base_name() const 10185 { 10186 return __right_->base_name(); 10187 } 10188 virtual bool is_ctor_dtor_conv() const 10189 { 10190 return true; 10191 } 10192 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 10193 { 10194 return __right_->fix_forward_references(t_begin, t_end); 10195 } 10196}; 10197 10198class __dot_suffix 10199 : public __node 10200{ 10201public: 10202 __dot_suffix(__node* name, const char* suffix, unsigned sz) 10203 { 10204 __left_ = name; 10205 __name_ = suffix; 10206 __size_ = sz; 10207 } 10208 10209 virtual size_t first_size() const 10210 { 10211 if (__cached_size_ == -1) 10212 { 10213 size_t off = __left_->size(); 10214 off += __size_ + 3; 10215 const_cast<long&>(__cached_size_) = off; 10216 } 10217 return __cached_size_; 10218 } 10219 virtual char* first_demangled_name(char* buf) const 10220 { 10221 buf = __left_->get_demangled_name(buf); 10222 *buf++ = ' '; 10223 *buf++ = '('; 10224 strncpy(buf, __name_, __size_); 10225 buf += __size_; 10226 *buf++ = ')'; 10227 return buf; 10228 } 10229 virtual ptrdiff_t print_first(char* f, char* l) const 10230 { 10231 const ptrdiff_t r = l - f; 10232 const ptrdiff_t n = 3 + __size_; 10233 const ptrdiff_t sz = __left_->print(f, l); 10234 if (r >= n + sz) 10235 { 10236 f += sz; 10237 *f++ = ' '; 10238 *f++ = '('; 10239 strncpy(f, __name_, __size_); 10240 f += __size_; 10241 *f = ')'; 10242 } 10243 return n + sz; 10244 } 10245 virtual __node* base_name() const 10246 { 10247 return __left_->base_name(); 10248 } 10249 virtual bool fix_forward_references(__node** t_begin, __node** t_end) 10250 { 10251 return __left_->fix_forward_references(t_begin, t_end); 10252 } 10253}; 10254 10255 10256enum {invalid_args = -3, invalid_mangled_name, memory_alloc_failure, success, 10257 not_yet_implemented}; 10258 10259__demangle_tree::__demangle_tree(const char* mangled_name, char* buf, size_t bs) 10260 : __mangled_name_begin_(0), __mangled_name_end_(0), 10261 __status_(invalid_mangled_name), __root_(0), 10262 __node_begin_(0), __node_end_(0), __node_cap_(0), 10263 __sub_begin_(0), __sub_end_(0), __sub_cap_(0), 10264 __t_begin_(0), __t_end_(0), __t_cap_(0), 10265 __tag_templates_(true), 10266 __fix_forward_references_(false) 10267{ 10268 size_t n = strlen(mangled_name); 10269 size_t ms = n + 2*n*sizeof(__node) + 2*n*sizeof(__node*); 10270 char* m; 10271 if (ms <= bs) 10272 { 10273 m = buf; 10274 __owns_buf_ = false; 10275 } 10276 else 10277 { 10278 m = static_cast<char*>(malloc(ms)); 10279 __owns_buf_ = true; 10280 } 10281 if (m == NULL) 10282 { 10283 __status_ = memory_alloc_failure; 10284 return; 10285 } 10286 __node_begin_ = __node_end_ = (__node*)(m); 10287 __node_cap_ = __node_begin_ + 2*n; 10288 __sub_begin_ = __sub_end_ = (__node**)(__node_cap_); 10289 __sub_cap_ = __sub_begin_ + n; 10290 __t_begin_ = __t_end_ = (__node**)(__sub_cap_); 10291 __t_cap_ = __t_begin_ + n; 10292 __mangled_name_begin_ = (const char*)(__t_cap_); 10293 __mangled_name_end_ = __mangled_name_begin_ + n; 10294 strncpy(const_cast<char*>(__mangled_name_begin_), mangled_name, n); 10295} 10296 10297__demangle_tree::~__demangle_tree() 10298{ 10299 if (__owns_buf_) 10300 free(__node_begin_); 10301} 10302 10303__demangle_tree::__demangle_tree(__demangle_tree& t) 10304 : __mangled_name_begin_(t.__mangled_name_begin_), 10305 __mangled_name_end_(t.__mangled_name_end_), 10306 __status_(t.__status_), __root_(t.__root_), 10307 __node_begin_(t.__node_begin_), __node_end_(t.__node_end_), 10308 __node_cap_(t.__node_cap_), 10309 __sub_begin_(t.__sub_begin_), __sub_end_(t.__sub_end_), 10310 __sub_cap_(t.__sub_cap_), 10311 __t_begin_(t.__t_begin_), __t_end_(t.__t_end_), 10312 __t_cap_(t.__t_cap_), 10313 __tag_templates_(t.__tag_templates_), 10314 __fix_forward_references_(t.__fix_forward_references_), 10315 __owns_buf_(t.__owns_buf_) 10316{ 10317 t.__mangled_name_begin_ = 0; 10318 t.__mangled_name_end_ = 0; 10319 t.__status_ = invalid_mangled_name; 10320 t.__root_ = 0; 10321 t.__node_begin_ = t.__node_end_ = t.__node_cap_ = 0; 10322 t.__sub_begin_ = t.__sub_end_ = t.__sub_cap_ = 0; 10323 t.__t_begin_ = t.__t_end_ = t.__t_cap_ = 0; 10324 t.__owns_buf_ = false; 10325} 10326 10327__demangle_tree::__demangle_tree(__demangle_tree_rv rv) 10328 : __mangled_name_begin_(rv.ptr_->__mangled_name_begin_), 10329 __mangled_name_end_(rv.ptr_->__mangled_name_end_), 10330 __status_(rv.ptr_->__status_), __root_(rv.ptr_->__root_), 10331 __node_begin_(rv.ptr_->__node_begin_), __node_end_(rv.ptr_->__node_end_), 10332 __node_cap_(rv.ptr_->__node_cap_), 10333 __sub_begin_(rv.ptr_->__sub_begin_), __sub_end_(rv.ptr_->__sub_end_), 10334 __sub_cap_(rv.ptr_->__sub_cap_), 10335 __t_begin_(rv.ptr_->__t_begin_), __t_end_(rv.ptr_->__t_end_), 10336 __t_cap_(rv.ptr_->__t_cap_), 10337 __tag_templates_(rv.ptr_->__tag_templates_), 10338 __fix_forward_references_(rv.ptr_->__fix_forward_references_), 10339 __owns_buf_(rv.ptr_->__owns_buf_) 10340{ 10341 rv.ptr_->__mangled_name_begin_ = 0; 10342 rv.ptr_->__mangled_name_end_ = 0; 10343 rv.ptr_->__status_ = invalid_mangled_name; 10344 rv.ptr_->__root_ = 0; 10345 rv.ptr_->__node_begin_ = rv.ptr_->__node_end_ = rv.ptr_->__node_cap_ = 0; 10346 rv.ptr_->__sub_begin_ = rv.ptr_->__sub_end_ = rv.ptr_->__sub_cap_ = 0; 10347 rv.ptr_->__t_begin_ = rv.ptr_->__t_end_ = rv.ptr_->__t_cap_ = 0; 10348 rv.ptr_->__owns_buf_ = false; 10349} 10350 10351int 10352__demangle_tree::__status() const 10353{ 10354 return __status_; 10355} 10356 10357size_t 10358__demangle_tree::size() const 10359{ 10360 return __status_ == success ? __root_->size() : 0; 10361} 10362 10363char* 10364__demangle_tree::__get_demangled_name(char* buf) const 10365{ 10366 if (__status_ == success) 10367 return __root_->get_demangled_name(buf); 10368 return 0; 10369} 10370 10371template <class _Tp> 10372bool 10373__demangle_tree::__make() 10374{ 10375 if (__node_end_ < __node_cap_) 10376 { 10377 ::new (__node_end_) _Tp(); 10378 __root_ = __node_end_; 10379 ++__node_end_; 10380 return true; 10381 } 10382 __status_ = memory_alloc_failure; 10383 return false; 10384} 10385 10386template <class _Tp, class _A0> 10387bool 10388__demangle_tree::__make(_A0 __a0) 10389{ 10390 if (__node_end_ < __node_cap_) 10391 { 10392 ::new (__node_end_) _Tp(__a0); 10393 __root_ = __node_end_; 10394 ++__node_end_; 10395 return true; 10396 } 10397 __status_ = memory_alloc_failure; 10398 return false; 10399} 10400 10401template <class _Tp, class _A0, class _A1> 10402bool 10403__demangle_tree::__make(_A0 __a0, _A1 __a1) 10404{ 10405 if (__node_end_ < __node_cap_) 10406 { 10407 ::new (__node_end_) _Tp(__a0, __a1); 10408 __root_ = __node_end_; 10409 ++__node_end_; 10410 return true; 10411 } 10412 __status_ = memory_alloc_failure; 10413 return false; 10414} 10415 10416template <class _Tp, class _A0, class _A1, class _A2> 10417bool 10418__demangle_tree::__make(_A0 __a0, _A1 __a1, _A2 __a2) 10419{ 10420 if (__node_end_ < __node_cap_) 10421 { 10422 ::new (__node_end_) _Tp(__a0, __a1, __a2); 10423 __root_ = __node_end_; 10424 ++__node_end_; 10425 return true; 10426 } 10427 __status_ = memory_alloc_failure; 10428 return false; 10429} 10430 10431template <class _Tp, class _A0, class _A1, class _A2, class _A3> 10432bool 10433__demangle_tree::__make(_A0 __a0, _A1 __a1, _A2 __a2, _A3 __a3) 10434{ 10435 if (__node_end_ < __node_cap_) 10436 { 10437 ::new (__node_end_) _Tp(__a0, __a1, __a2, __a3); 10438 __root_ = __node_end_; 10439 ++__node_end_; 10440 return true; 10441 } 10442 __status_ = memory_alloc_failure; 10443 return false; 10444} 10445 10446template <class _Tp, class _A0, class _A1, class _A2, class _A3, class _A4> 10447bool 10448__demangle_tree::__make(_A0 __a0, _A1 __a1, _A2 __a2, _A3 __a3, _A4 __a4) 10449{ 10450 if (__node_end_ < __node_cap_) 10451 { 10452 ::new (__node_end_) _Tp(__a0, __a1, __a2, __a3, __a4); 10453 __root_ = __node_end_; 10454 ++__node_end_; 10455 return true; 10456 } 10457 __status_ = memory_alloc_failure; 10458 return false; 10459} 10460 10461template <class _Tp, class _A0, class _A1, class _A2, class _A3, class _A4, 10462 class _A5> 10463bool 10464__demangle_tree::__make(_A0 __a0, _A1 __a1, _A2 __a2, _A3 __a3, _A4 __a4, 10465 _A5 __a5) 10466{ 10467 if (__node_end_ < __node_cap_) 10468 { 10469 ::new (__node_end_) _Tp(__a0, __a1, __a2, __a3, __a4, __a5); 10470 __root_ = __node_end_; 10471 ++__node_end_; 10472 return true; 10473 } 10474 __status_ = memory_alloc_failure; 10475 return false; 10476} 10477 10478// <CV-qualifiers> ::= [r] [V] [K] # restrict (C99), volatile, const 10479// [R | O] # & or && 10480 10481const char* 10482__demangle_tree::__parse_cv_qualifiers(const char* first, const char* last, 10483 unsigned& cv, bool look_for_ref_quals) 10484{ 10485 if (look_for_ref_quals) 10486 { 10487 for (; first != last; ++first) 10488 { 10489 switch (*first) 10490 { 10491 case 'r': 10492 cv |= 4; 10493 break; 10494 case 'V': 10495 cv |= 2; 10496 break; 10497 case 'K': 10498 cv |= 1; 10499 break; 10500 case 'R': 10501 cv |= 8; 10502 break; 10503 case 'O': 10504 cv |= 16; 10505 break; 10506 default: 10507 return first; 10508 } 10509 } 10510 } 10511 else 10512 { 10513 for (; first != last; ++first) 10514 { 10515 switch (*first) 10516 { 10517 case 'r': 10518 cv |= 4; 10519 break; 10520 case 'V': 10521 cv |= 2; 10522 break; 10523 case 'K': 10524 cv |= 1; 10525 break; 10526 default: 10527 return first; 10528 } 10529 } 10530 } 10531 return first; 10532} 10533 10534// <builtin-type> ::= v # void 10535// ::= w # wchar_t 10536// ::= b # bool 10537// ::= c # char 10538// ::= a # signed char 10539// ::= h # unsigned char 10540// ::= s # short 10541// ::= t # unsigned short 10542// ::= i # int 10543// ::= j # unsigned int 10544// ::= l # long 10545// ::= m # unsigned long 10546// ::= x # long long, __int64 10547// ::= y # unsigned long long, __int64 10548// ::= n # __int128 10549// ::= o # unsigned __int128 10550// ::= f # float 10551// ::= d # double 10552// ::= e # long double, __float80 10553// ::= g # __float128 10554// ::= z # ellipsis 10555// ::= Dd # IEEE 754r decimal floating point (64 bits) 10556// ::= De # IEEE 754r decimal floating point (128 bits) 10557// ::= Df # IEEE 754r decimal floating point (32 bits) 10558// ::= Dh # IEEE 754r half-precision floating point (16 bits) 10559// ::= Di # char32_t 10560// ::= Ds # char16_t 10561// ::= Da # auto (in dependent new-expressions) 10562// ::= Dn # std::nullptr_t (i.e., decltype(nullptr)) 10563// ::= u <source-name> # vendor extended type 10564 10565const char* 10566__demangle_tree::__parse_builtin_type(const char* first, const char* last) 10567{ 10568 if (first != last) 10569 { 10570 switch (*first) 10571 { 10572 case 'v': 10573 if (__make<__void>()) 10574 ++first; 10575 break; 10576 case 'w': 10577 if (__make<__wchar_t>()) 10578 ++first; 10579 break; 10580 case 'b': 10581 if (__make<__bool>()) 10582 ++first; 10583 break; 10584 case 'c': 10585 if (__make<__char>()) 10586 ++first; 10587 break; 10588 case 'a': 10589 if (__make<__signed_char>()) 10590 ++first; 10591 break; 10592 case 'h': 10593 if (__make<__unsigned_char>()) 10594 ++first; 10595 break; 10596 case 's': 10597 if (__make<__short>()) 10598 ++first; 10599 break; 10600 case 't': 10601 if (__make<__unsigned_short>()) 10602 ++first; 10603 break; 10604 case 'i': 10605 if (__make<__int>()) 10606 ++first; 10607 break; 10608 case 'j': 10609 if (__make<__unsigned_int>()) 10610 ++first; 10611 break; 10612 case 'l': 10613 if (__make<__long>()) 10614 ++first; 10615 break; 10616 case 'm': 10617 if (__make<__unsigned_long>()) 10618 ++first; 10619 break; 10620 case 'x': 10621 if (__make<__long_long>()) 10622 ++first; 10623 break; 10624 case 'y': 10625 if (__make<__unsigned_long_long>()) 10626 ++first; 10627 break; 10628 case 'n': 10629 if (__make<__int128>()) 10630 ++first; 10631 break; 10632 case 'o': 10633 if (__make<__unsigned_int128>()) 10634 ++first; 10635 break; 10636 case 'f': 10637 if (__make<__float>()) 10638 ++first; 10639 break; 10640 case 'd': 10641 if (__make<__double>()) 10642 ++first; 10643 break; 10644 case 'e': 10645 if (__make<__long_double>()) 10646 ++first; 10647 break; 10648 case 'g': 10649 if (__make<__float128>()) 10650 ++first; 10651 break; 10652 case 'z': 10653 if (__make<__ellipsis>()) 10654 ++first; 10655 break; 10656 case 'D': 10657 if (first+1 != last) 10658 { 10659 switch (first[1]) 10660 { 10661 case 'd': 10662 if (__make<__decimal64>()) 10663 first += 2; 10664 break; 10665 case 'e': 10666 if (__make<__decimal128>()) 10667 first += 2; 10668 break; 10669 case 'f': 10670 if (__make<__decimal32>()) 10671 first += 2; 10672 break; 10673 case 'h': 10674 if (__make<__decimal16>()) 10675 first += 2; 10676 break; 10677 case 'i': 10678 if (__make<__d_char32_t>()) 10679 first += 2; 10680 break; 10681 case 's': 10682 if (__make<__d_char16_t>()) 10683 first += 2; 10684 break; 10685 case 'a': 10686 if (__make<__auto>()) 10687 first += 2; 10688 break; 10689 case 'n': 10690 if (__make<__nullptr_t>()) 10691 first += 2; 10692 break; 10693 } 10694 } 10695 break; 10696 } 10697 } 10698 return first; 10699} 10700 10701// <bare-function-type> ::= <signature type>+ 10702// # types are possible return type, then parameter types 10703 10704const char* 10705__demangle_tree::__parse_bare_function_type(const char* first, const char* last) 10706{ 10707 if (first != last) 10708 { 10709 __tag_templates_ = false; 10710 const char* t = __parse_type(first, last); 10711 if (t != first && __make<__list>(__root_)) 10712 { 10713 const char* t0 = t; 10714 __node* head = __root_; 10715 __node* prev = head; 10716 while (true) 10717 { 10718 t = __parse_type(t0, last); 10719 if (t != t0) 10720 { 10721 if (__make<__list>(__root_)) 10722 { 10723 t0 = t; 10724 prev->__right_ = __root_; 10725 __root_->__size_ = prev->__size_ + 1; 10726 prev = __root_; 10727 } 10728 else 10729 break; 10730 } 10731 else 10732 { 10733 first = t; 10734 __root_ = head; 10735 break; 10736 } 10737 } 10738 } 10739 __tag_templates_ = true; 10740 } 10741 return first; 10742} 10743 10744// <function-type> ::= F [Y] <bare-function-type> E 10745 10746const char* 10747__demangle_tree::__parse_function_type(const char* first, const char* last) 10748{ 10749 if (first != last && *first == 'F') 10750 { 10751 const char* t = first+1; 10752 if (t != last) 10753 { 10754 bool externC = false; 10755 if (*t == 'Y') 10756 { 10757 externC = true; 10758 if (++t == last) 10759 return first; 10760 } 10761 const char* t1 = __parse_type(t, last); 10762 if (t1 != t) 10763 { 10764 __node* ret = __root_; 10765 t = t1; 10766 t1 = __parse_bare_function_type(t, last); 10767 if (t1 != t && t1 != last && *t1 == 'E') 10768 { 10769 if (dynamic_cast<__void*>(__root_->__left_) != NULL) 10770 __root_->__left_ = NULL; 10771 if (__make<__function_signature>(ret, __root_)) 10772 { 10773 if (__make<__function>((__node*)0, __root_)) 10774 first = t1+1; 10775 } 10776 } 10777 } 10778 } 10779 } 10780 return first; 10781} 10782 10783const char* 10784__demangle_tree::__parse_hex_number(const char* first, const char* last, unsigned long long& n) 10785{ 10786 const char* t = first; 10787 for (; t != last && isxdigit(*t); ++t) 10788 { 10789 if (t == first) 10790 n = 0; 10791 if (isdigit(*t)) 10792 n = n * 16 + *t - '0'; 10793 else if (isupper(*t)) 10794 n = n * 16 + *t - 'A' + 10; 10795 else 10796 n = n * 16 + *t - 'a' + 10; 10797 } 10798 first = t; 10799 return first; 10800} 10801 10802// <expr-primary> ::= L <type> <value number> E # integer literal 10803// ::= L <type> <value float> E # floating literal 10804// ::= L <string type> E # string literal 10805// ::= L <nullptr type> E # nullptr literal (i.e., "LDnE") 10806// ::= L <type> <real-part float> _ <imag-part float> E # complex floating point literal (C 2000) 10807// ::= L <mangled-name> E # external name 10808 10809const char* 10810__demangle_tree::__parse_expr_primary(const char* first, const char* last) 10811{ 10812 if (last - first >= 4 && *first == 'L') 10813 { 10814 switch (first[1]) 10815 { 10816 case 'w': 10817 { 10818 const char* t = __parse_number(first+2, last); 10819 if (t != first+2 && t != last && *t == 'E') 10820 { 10821 if (__make<__wchar_t_literal>(first+2, t)) 10822 first = t+1; 10823 } 10824 } 10825 break; 10826 case 'b': 10827 if (first[3] == 'E') 10828 { 10829 switch (first[2]) 10830 { 10831 case '0': 10832 if (__make<__bool_literal>("false", 5)) 10833 first += 4; 10834 break; 10835 case '1': 10836 if (__make<__bool_literal>("true", 4)) 10837 first += 4; 10838 break; 10839 } 10840 } 10841 break; 10842 case 'c': 10843 { 10844 const char* t = __parse_number(first+2, last); 10845 if (t != first+2 && t != last && *t == 'E') 10846 { 10847 if (__make<__char_literal>(first+2, t)) 10848 first = t+1; 10849 } 10850 } 10851 break; 10852 case 'a': 10853 { 10854 const char* t = __parse_number(first+2, last); 10855 if (t != first+2 && t != last && *t == 'E') 10856 { 10857 if (__make<__signed_char_literal>(first+2, t)) 10858 first = t+1; 10859 } 10860 } 10861 break; 10862 case 'h': 10863 { 10864 const char* t = __parse_number(first+2, last); 10865 if (t != first+2 && t != last && *t == 'E') 10866 { 10867 if (__make<__unsigned_char_literal>(first+2, t)) 10868 first = t+1; 10869 } 10870 } 10871 break; 10872 case 's': 10873 { 10874 const char* t = __parse_number(first+2, last); 10875 if (t != first+2 && t != last && *t == 'E') 10876 { 10877 if (__make<__short_literal>(first+2, t)) 10878 first = t+1; 10879 } 10880 } 10881 break; 10882 case 't': 10883 { 10884 const char* t = __parse_number(first+2, last); 10885 if (t != first+2 && t != last && *t == 'E') 10886 { 10887 if (__make<__unsigned_short_literal>(first+2, t)) 10888 first = t+1; 10889 } 10890 } 10891 break; 10892 case 'i': 10893 { 10894 const char* t = __parse_number(first+2, last); 10895 if (t != first+2 && t != last && *t == 'E') 10896 { 10897 if (__make<__int_literal>(first+2, t)) 10898 first = t+1; 10899 } 10900 } 10901 break; 10902 case 'j': 10903 { 10904 const char* t = __parse_number(first+2, last); 10905 if (t != first+2 && t != last && *t == 'E') 10906 { 10907 if (__make<__unsigned_int_literal>(first+2, t)) 10908 first = t+1; 10909 } 10910 } 10911 break; 10912 case 'l': 10913 { 10914 const char* t = __parse_number(first+2, last); 10915 if (t != first+2 && t != last && *t == 'E') 10916 { 10917 if (__make<__long_literal>(first+2, t)) 10918 first = t+1; 10919 } 10920 } 10921 break; 10922 case 'm': 10923 { 10924 const char* t = __parse_number(first+2, last); 10925 if (t != first+2 && t != last && *t == 'E') 10926 { 10927 if (__make<__unsigned_long_literal>(first+2, t)) 10928 first = t+1; 10929 } 10930 } 10931 break; 10932 case 'x': 10933 { 10934 const char* t = __parse_number(first+2, last); 10935 if (t != first+2 && t != last && *t == 'E') 10936 { 10937 if (__make<__long_long_literal>(first+2, t)) 10938 first = t+1; 10939 } 10940 } 10941 break; 10942 case 'y': 10943 { 10944 const char* t = __parse_number(first+2, last); 10945 if (t != first+2 && t != last && *t == 'E') 10946 { 10947 if (__make<__unsigned_long_long_literal>(first+2, t)) 10948 first = t+1; 10949 } 10950 } 10951 break; 10952 case 'n': 10953 { 10954 const char* t = __parse_number(first+2, last); 10955 if (t != first+2 && t != last && *t == 'E') 10956 { 10957 if (__make<__int128_literal>(first+2, t)) 10958 first = t+1; 10959 } 10960 } 10961 break; 10962 case 'o': 10963 { 10964 const char* t = __parse_number(first+2, last); 10965 if (t != first+2 && t != last && *t == 'E') 10966 { 10967 if (__make<__unsigned_int128_literal>(first+2, t)) 10968 first = t+1; 10969 } 10970 } 10971 break; 10972 case 'f': 10973 { 10974 if (last - (first+2) <= 8) 10975 return first; 10976 unsigned long long j; 10977 const char* t = __parse_hex_number(first+2, first+10, j); 10978 if (t != first+2 && t != last && *t == 'E') 10979 { 10980 unsigned i = static_cast<unsigned>(j); 10981 float value = *(float*)&i; 10982 if (__make<__float_literal>(value)) 10983 first = t+1; 10984 } 10985 } 10986 break; 10987 case 'd': 10988 { 10989 if (last - (first+2) <= 16) 10990 return first; 10991 unsigned long long j; 10992 const char* t = __parse_hex_number(first+2, first+18, j); 10993 if (t != first+2 && t != last && *t == 'E') 10994 { 10995 double value = *(double*)&j; 10996 if (__make<__double_literal>(value)) 10997 first = t+1; 10998 } 10999 } 11000 break; 11001 case 'e': 11002 break; 11003 case '_': 11004 if (first[2] == 'Z') 11005 { 11006 const char* t = __parse_encoding(first+3, last); 11007 if (t != first+3 && t != last && *t == 'E') 11008 first = t+1; 11009 } 11010 break; 11011 default: 11012 { 11013 // might be named type 11014 const char* t = __parse_type(first+1, last); 11015 if (t != first+1 && t != last) 11016 { 11017 if (*t != 'E') 11018 { 11019 const char* n = t; 11020 for (; n != last && isdigit(*n); ++n) 11021 ; 11022 if (n != t && n != last && *n == 'E') 11023 { 11024 if (__make<__cast_literal>(__root_, t, n)) 11025 { 11026 first = n+1; 11027 break; 11028 } 11029 } 11030 } 11031 else 11032 { 11033 first = t+1; 11034 break; 11035 } 11036 } 11037 } 11038 assert(!"case in __parse_expr_primary not implemented"); 11039 } 11040 } 11041 return first; 11042} 11043 11044const char* 11045__demangle_tree::__parse_unnamed_type_name(const char* first, const char* last) 11046{ 11047 if (first != last && *first == 'U') 11048 { 11049 assert(!"__parse_unnamed_type_name not implemented"); 11050 } 11051 return first; 11052} 11053 11054// <ctor-dtor-name> ::= C1 # complete object constructor 11055// ::= C2 # base object constructor 11056// ::= C3 # complete object allocating constructor 11057// ::= D0 # deleting destructor 11058// ::= D1 # complete object destructor 11059// ::= D2 # base object destructor 11060 11061const char* 11062__demangle_tree::__parse_ctor_dtor_name(const char* first, const char* last) 11063{ 11064 if (last-first >= 2) 11065 { 11066 switch (first[0]) 11067 { 11068 case 'C': 11069 switch (first[1]) 11070 { 11071 case '1': 11072 case '2': 11073 case '3': 11074 if (__make<__constructor>(__root_->base_name())) 11075 first += 2; 11076 break; 11077 } 11078 break; 11079 case 'D': 11080 switch (first[1]) 11081 { 11082 case '0': 11083 case '1': 11084 case '2': 11085 if (__make<__destructor>(__root_->base_name())) 11086 first += 2; 11087 break; 11088 } 11089 break; 11090 } 11091 } 11092 return first; 11093} 11094 11095const char* 11096__demangle_tree::__parse_unscoped_template_name(const char* first, const char* last) 11097{ 11098 assert(!"__parse_unscoped_template_name not implemented"); 11099} 11100 11101// <discriminator> := _ <non-negative number> # when number < 10 11102// := __ <non-negative number> _ # when number >= 10 11103// extension := decimal-digit+ 11104 11105const char* 11106__demangle_tree::__parse_discriminator(const char* first, const char* last) 11107{ 11108 // parse but ignore discriminator 11109 if (first != last) 11110 { 11111 if (*first == '_') 11112 { 11113 const char* t1 = first+1; 11114 if (t1 != last) 11115 { 11116 if (isdigit(*t1)) 11117 first = t1+1; 11118 else if (*t1 == '_') 11119 { 11120 for (++t1; t1 != last && isdigit(*t1); ++t1) 11121 ; 11122 if (t1 != last && *t1 == '_') 11123 first = t1 + 1; 11124 } 11125 } 11126 } 11127 else if (isdigit(*first)) 11128 { 11129 const char* t1 = first+1; 11130 for (; t1 != last && isdigit(*t1); ++t1) 11131 ; 11132 first = t1; 11133 } 11134 } 11135 return first; 11136} 11137 11138// <local-name> := Z <function encoding> E <entity name> [<discriminator>] 11139// := Z <function encoding> E s [<discriminator>] 11140// := Z <function encoding> Ed [ <parameter number> ] _ <entity name> 11141 11142const char* 11143__demangle_tree::__parse_local_name(const char* first, const char* last) 11144{ 11145 if (first != last && *first == 'Z') 11146 { 11147 const char* t = __parse_encoding(first+1, last); 11148 if (t != first+1 && t != last && *t == 'E' && ++t != last) 11149 { 11150 __node* encoding = __root_; 11151 switch (*t) 11152 { 11153 case 's': 11154 { 11155 const char*t1 = __parse_discriminator(t+1, last); 11156 if (__make<__string_literal>()) 11157 { 11158 if (__make<__nested_delimeter>(encoding, __root_)) 11159 first = t1; 11160 } 11161 } 11162 break; 11163 case 'd': 11164 assert(!"__parse_local_name d not implemented"); 11165 break; 11166 default: 11167 { 11168 const char*t1 = __parse_name(t, last); 11169 if (t1 != t) 11170 { 11171 // parse but ignore discriminator 11172 t1 = __parse_discriminator(t1, last); 11173 if (__make<__nested_delimeter>(encoding, __root_)) 11174 first = t1; 11175 } 11176 } 11177 break; 11178 } 11179 } 11180 } 11181 return first; 11182} 11183 11184// <destructor-name> ::= <unresolved-type> # e.g., ~T or ~decltype(f()) 11185// ::= <simple-id> # e.g., ~A<2*N> 11186 11187const char* 11188__demangle_tree::__parse_destructor_name(const char* first, const char* last) 11189{ 11190 if (first != last) 11191 { 11192 const char* t = __parse_unresolved_type(first, last); 11193 if (t == first) 11194 t = __parse_simple_id(first, last); 11195 if (t != first && __make<__destructor>(__root_)) 11196 first = t; 11197 } 11198 return first; 11199} 11200 11201// <simple-id> ::= <source-name> [ <template-args> ] 11202 11203const char* 11204__demangle_tree::__parse_simple_id(const char* first, const char* last) 11205{ 11206 if (first != last) 11207 { 11208 const char* t = __parse_source_name(first, last); 11209 if (t != first) 11210 first = __parse_template_args(t, last); 11211 else 11212 first = t; 11213 } 11214 return first; 11215} 11216 11217// <base-unresolved-name> ::= <simple-id> # unresolved name 11218// extension ::= <operator-name> # unresolved operator-function-id 11219// extension ::= <operator-name> <template-args> # unresolved operator template-id 11220// ::= on <operator-name> # unresolved operator-function-id 11221// ::= on <operator-name> <template-args> # unresolved operator template-id 11222// ::= dn <destructor-name> # destructor or pseudo-destructor; 11223// # e.g. ~X or ~X<N-1> 11224 11225const char* 11226__demangle_tree::__parse_base_unresolved_name(const char* first, const char* last) 11227{ 11228 if (last - first >= 2) 11229 { 11230 if ((first[0] == 'o' || first[0] == 'd') && first[1] == 'n') 11231 { 11232 if (first[0] == 'o') 11233 { 11234 const char* t = __parse_operator_name(first+2, last); 11235 if (t != first+2) 11236 first = __parse_template_args(t, last); 11237 else 11238 first = t; 11239 } 11240 else 11241 { 11242 const char* t = __parse_destructor_name(first+2, last); 11243 if (t != first+2) 11244 first = t; 11245 } 11246 } 11247 else 11248 { 11249 const char* t = __parse_simple_id(first, last); 11250 if (t == first) 11251 { 11252 t = __parse_operator_name(first, last); 11253 if (t != first) 11254 t = __parse_template_args(t, last); 11255 } 11256 if (t != first) 11257 first = t; 11258 } 11259 } 11260 return first; 11261} 11262 11263// <unresolved-type> ::= <template-param> 11264// ::= <decltype> 11265// ::= <substitution> 11266 11267const char* 11268__demangle_tree::__parse_unresolved_type(const char* first, const char* last) 11269{ 11270 if (first != last) 11271 { 11272 const char* t; 11273 switch (*first) 11274 { 11275 case 'T': 11276 t = __parse_template_param(first, last); 11277 if (t != first) 11278 { 11279 if (__sub_end_ == __sub_cap_) 11280 __status_ = memory_alloc_failure; 11281 else 11282 { 11283 *__sub_end_++ = __root_; 11284 first = t; 11285 } 11286 } 11287 break; 11288 case 'D': 11289 t = __parse_decltype(first, last); 11290 if (t != first) 11291 { 11292 if (__sub_end_ == __sub_cap_) 11293 __status_ = memory_alloc_failure; 11294 else 11295 { 11296 *__sub_end_++ = __root_; 11297 first = t; 11298 } 11299 } 11300 break; 11301 case 'S': 11302 t = __parse_substitution(first, last); 11303 if (t != first) 11304 first = t; 11305 break; 11306 } 11307 } 11308 return first; 11309} 11310 11311// <unresolved-qualifier-level> ::= <source-name> [ <template-args> ] 11312 11313const char* 11314__demangle_tree::__parse_unresolved_qualifier_level(const char* first, const char* last) 11315{ 11316 if (first != last) 11317 { 11318 const char* t = __parse_source_name(first, last); 11319 if (t != first) 11320 first = __parse_template_args(t, last); 11321 } 11322 return first; 11323} 11324 11325// <unresolved-name> 11326// extension ::= srN <unresolved-type> [<template-args>] <unresolved-qualifier-level>* E <base-unresolved-name> 11327// ::= [gs] <base-unresolved-name> # x or (with "gs") ::x 11328// ::= [gs] sr <unresolved-qualifier-level>+ E <base-unresolved-name> 11329// # A::x, N::y, A<T>::z; "gs" means leading "::" 11330// ::= sr <unresolved-type> <base-unresolved-name> # T::x / decltype(p)::x 11331// # T::N::x /decltype(p)::N::x 11332// (ignored) ::= srN <unresolved-type> <unresolved-qualifier-level>+ E <base-unresolved-name> 11333 11334const char* 11335__demangle_tree::__parse_unresolved_name(const char* first, const char* last) 11336{ 11337 if (last - first > 2) 11338 { 11339 const char* t = first; 11340 bool global = false; 11341 if (t[0] == 'g' && t[1] == 's') 11342 { 11343 global = true; 11344 t += 2; 11345 } 11346 const char* t2 = __parse_base_unresolved_name(t, last); 11347 if (t2 != t) 11348 { 11349 if (__make<__unresolved_name>(global, (__node*)0, __root_)) 11350 first = t2; 11351 } 11352 else if (last - t > 2 && t[0] == 's' && t[1] == 'r') 11353 { 11354 if (!global && t[2] == 'N') 11355 { 11356 t2 = __parse_unresolved_type(t+3, last); 11357 if (t2 != t+3 && t2 != last) 11358 { 11359 t = __parse_template_args(t2, last); 11360 if (t == last) 11361 return first; 11362 __node* name = __root_; 11363 while (*t != 'E') 11364 { 11365 t2 = __parse_unresolved_qualifier_level(t, last); 11366 if (t2 == t || t2 == last) 11367 return first; 11368 if (!__make<__nested_delimeter>(name, __root_)) 11369 return first; 11370 name = __root_; 11371 t = t2; 11372 } 11373 t2 = __parse_base_unresolved_name(++t, last); 11374 if (t2 != t && __make<__unresolved_name>(false, name, __root_)) 11375 first = t2; 11376 } 11377 } 11378 else 11379 { 11380 if (!global) 11381 { 11382 t2 = __parse_unresolved_type(t+2, last); 11383 if (t2 != t+2) 11384 { 11385 t = t2; 11386 __node* name = __root_; 11387 t2 = __parse_base_unresolved_name(t, last); 11388 if (t2 != t && __make<__unresolved_name>(false, name, __root_)) 11389 return t2; 11390 return first; 11391 } 11392 } 11393 t2 = __parse_unresolved_qualifier_level(t+2, last); 11394 if (t2 != t+2 && t2 != last) 11395 { 11396 __node* name = __root_; 11397 t = t2; 11398 while (*t != 'E') 11399 { 11400 t2 = __parse_unresolved_qualifier_level(t, last); 11401 if (t2 == t || t2 == last) 11402 return first; 11403 if (!__make<__nested_delimeter>(name, __root_)) 11404 return first; 11405 name = __root_; 11406 t = t2; 11407 } 11408 t2 = __parse_base_unresolved_name(++t, last); 11409 if (t2 != t && __make<__unresolved_name>(global, name, __root_)) 11410 first = t2; 11411 } 11412 } 11413 } 11414 } 11415 return first; 11416} 11417 11418// <function-param> ::= fp <top-level CV-qualifiers> _ # L == 0, first parameter 11419// ::= fp <top-level CV-qualifiers> <parameter-2 non-negative number> _ # L == 0, second and later parameters 11420// ::= fL <L-1 non-negative number> p <top-level CV-qualifiers> _ # L > 0, first parameter 11421// ::= fL <L-1 non-negative number> p <top-level CV-qualifiers> 11422 11423const char* 11424__demangle_tree::__parse_function_param(const char* first, const char* last) 11425{ 11426 if (last - first >= 3 && *first == 'f') 11427 { 11428 if (first[1] == 'p') 11429 { 11430 assert(!"__parse_function_param not implemented"); 11431 } 11432 else if (first[1] == 'L') 11433 { 11434 assert(!"__parse_function_param not implemented"); 11435 } 11436 } 11437 return first; 11438} 11439 11440// at <type> # alignof (a type) 11441 11442const char* 11443__demangle_tree::__parse_alignof_expr(const char* first, const char* last) 11444{ 11445 if (last - first >= 3 && first[0] == 'a' && first[1] == 't') 11446 { 11447 const char* t = __parse_type(first+2, last); 11448 if (t != first+2) 11449 { 11450 if (__make<__operator_alignof_expression>(__root_)) 11451 first = t; 11452 } 11453 } 11454 return first; 11455} 11456 11457// cc <type> <expression> # const_cast<type> (expression) 11458 11459const char* 11460__demangle_tree::__parse_const_cast_expr(const char* first, const char* last) 11461{ 11462 if (last - first >= 3 && first[0] == 'c' && first[1] == 'c') 11463 { 11464 const char* t = __parse_type(first+2, last); 11465 if (t != first+2) 11466 { 11467 __node* type = __root_; 11468 const char* t1 = __parse_expression(t, last); 11469 if (t1 != t) 11470 { 11471 if (__make<__const_cast>(type, __root_)) 11472 first = t1; 11473 } 11474 } 11475 } 11476 return first; 11477} 11478 11479// cl <expression>+ E # call 11480 11481const char* 11482__demangle_tree::__parse_call_expr(const char* first, const char* last) 11483{ 11484 if (last - first >= 4 && first[0] == 'c' && first[1] == 'l') 11485 { 11486 const char* t = __parse_expression(first+2, last); 11487 if (t != first+2) 11488 { 11489 if (t == last) 11490 return first; 11491 __node* name = __root_; 11492 __node* args = 0; 11493 __node* prev = 0; 11494 while (*t != 'E') 11495 { 11496 const char* t1 = __parse_expression(t, last); 11497 if (t1 == t || t1 == last) 11498 return first; 11499 if (!__make<__list>(__root_)) 11500 return first; 11501 if (args == 0) 11502 args = __root_; 11503 if (prev) 11504 { 11505 prev->__right_ = __root_; 11506 __root_->__size_ = prev->__size_ + 1; 11507 } 11508 prev = __root_; 11509 t = t1; 11510 } 11511 ++t; 11512 if (__make<__call_expr>(name, args)) 11513 first = t; 11514 } 11515 } 11516 return first; 11517} 11518 11519// cv <type> <expression> # conversion with one argument 11520// cv <type> _ <expression>* E # conversion with a different number of arguments 11521 11522const char* 11523__demangle_tree::__parse_conversion_expr(const char* first, const char* last) 11524{ 11525 if (last - first >= 3 && first[0] == 'c' && first[1] == 'v') 11526 { 11527 const char* t = __parse_type(first+2, last); 11528 if (t != first+2 && t != last) 11529 { 11530 __node* type = __root_; 11531 __node* args = 0; 11532 if (*t != '_') 11533 { 11534 const char* t1 = __parse_expression(t, last); 11535 if (t1 == t) 11536 return first; 11537 args = __root_; 11538 t = t1; 11539 } 11540 else 11541 { 11542 ++t; 11543 if (t == last) 11544 return first; 11545 __node* prev = 0; 11546 while (*t != 'E') 11547 { 11548 const char* t1 = __parse_expression(t, last); 11549 if (t1 == t || t1 == last) 11550 return first; 11551 if (!__make<__list>(__root_)) 11552 return first; 11553 if (args == 0) 11554 args = __root_; 11555 if (prev) 11556 { 11557 prev->__right_ = __root_; 11558 __root_->__size_ = prev->__size_ + 1; 11559 } 11560 prev = __root_; 11561 t = t1; 11562 } 11563 ++t; 11564 } 11565 if (__make<__operator_cast>(type, args)) 11566 first = t; 11567 } 11568 } 11569 return first; 11570} 11571 11572// [gs] da <expression> # delete[] expression 11573 11574const char* 11575__demangle_tree::__parse_delete_array_expr(const char* first, const char* last) 11576{ 11577 if (last - first >= 4) 11578 { 11579 const char* t = first; 11580 bool parsed_gs = false; 11581 if (t[0] == 'g' && t[1] == 's') 11582 { 11583 t += 2; 11584 parsed_gs = true; 11585 } 11586 if (t[0] == 'd' && t[1] == 'a') 11587 { 11588 t += 2; 11589 const char* t1 = __parse_expression(t, last); 11590 if (t1 != t) 11591 { 11592 if (__make<__delete_array_expr>(parsed_gs, __root_)) 11593 first = t1; 11594 } 11595 } 11596 } 11597 return first; 11598} 11599 11600// dc <type> <expression> # dynamic_cast<type> (expression) 11601 11602const char* 11603__demangle_tree::__parse_dynamic_cast_expr(const char* first, const char* last) 11604{ 11605 if (last - first >= 3 && first[0] == 'd' && first[1] == 'c') 11606 { 11607 const char* t = __parse_type(first+2, last); 11608 if (t != first+2) 11609 { 11610 __node* type = __root_; 11611 const char* t1 = __parse_expression(t, last); 11612 if (t1 != t) 11613 { 11614 if (__make<__dynamic_cast>(type, __root_)) 11615 first = t1; 11616 } 11617 } 11618 } 11619 return first; 11620} 11621 11622// [gs] dl <expression> # delete expression 11623 11624const char* 11625__demangle_tree::__parse_delete_expr(const char* first, const char* last) 11626{ 11627 if (last - first >= 4) 11628 { 11629 const char* t = first; 11630 bool parsed_gs = false; 11631 if (t[0] == 'g' && t[1] == 's') 11632 { 11633 t += 2; 11634 parsed_gs = true; 11635 } 11636 if (t[0] == 'd' && t[1] == 'l') 11637 { 11638 t += 2; 11639 const char* t1 = __parse_expression(t, last); 11640 if (t1 != t) 11641 { 11642 if (__make<__delete_expr>(parsed_gs, __root_)) 11643 first = t1; 11644 } 11645 } 11646 } 11647 return first; 11648} 11649 11650// ds <expression> <expression> # expr.*expr 11651 11652const char* 11653__demangle_tree::__parse_dot_star_expr(const char* first, const char* last) 11654{ 11655 if (last - first >= 3 && first[0] == 'd' && first[1] == 's') 11656 { 11657 const char* t = __parse_expression(first+2, last); 11658 if (t != first+2) 11659 { 11660 __node* expr = __root_; 11661 const char* t1 = __parse_expression(t, last); 11662 if (t1 != t) 11663 { 11664 if (__make<__dot_star_expr>(expr, __root_)) 11665 first = t1; 11666 } 11667 } 11668 } 11669 return first; 11670} 11671 11672// dt <expression> <unresolved-name> # expr.name 11673 11674const char* 11675__demangle_tree::__parse_dot_expr(const char* first, const char* last) 11676{ 11677 if (last - first >= 3 && first[0] == 'd' && first[1] == 't') 11678 { 11679 const char* t = __parse_expression(first+2, last); 11680 if (t != first+2) 11681 { 11682 __node* expr = __root_; 11683 const char* t1 = __parse_unresolved_name(t, last); 11684 if (t1 != t) 11685 { 11686 if (__make<__dot_expr>(expr, __root_)) 11687 first = t1; 11688 } 11689 } 11690 } 11691 return first; 11692} 11693 11694// mm_ <expression> # prefix -- 11695 11696const char* 11697__demangle_tree::__parse_decrement_expr(const char* first, const char* last) 11698{ 11699 if (last - first > 3 && first[0] == 'm' && first[1] == 'm' && first[2] == '_') 11700 { 11701 const char* t = __parse_expression(first+3, last); 11702 if (t != first+3) 11703 { 11704 if (__make<__operator_decrement>(true, __root_)) 11705 first = t; 11706 } 11707 } 11708 return first; 11709} 11710 11711// pp_ <expression> # prefix ++ 11712 11713const char* 11714__demangle_tree::__parse_increment_expr(const char* first, const char* last) 11715{ 11716 if (last - first > 3 && first[0] == 'p' && first[1] == 'p' && first[2] == '_') 11717 { 11718 const char* t = __parse_expression(first+3, last); 11719 if (t != first+3) 11720 { 11721 if (__make<__operator_increment>(true, __root_)) 11722 first = t; 11723 } 11724 } 11725 return first; 11726} 11727 11728// [gs] nw <expression>* _ <type> E # new (expr-list) type 11729// [gs] nw <expression>* _ <type> <initializer> # new (expr-list) type (init) 11730// [gs] na <expression>* _ <type> E # new[] (expr-list) type 11731// [gs] na <expression>* _ <type> <initializer> # new[] (expr-list) type (init) 11732// <initializer> ::= pi <expression>* E # parenthesized initialization 11733 11734const char* 11735__demangle_tree::__parse_new_expr(const char* first, const char* last) 11736{ 11737 if (last - first >= 4) 11738 { 11739 const char* t = first; 11740 bool parsed_gs = false; 11741 if (t[0] == 'g' && t[1] == 's') 11742 { 11743 t += 2; 11744 parsed_gs = true; 11745 } 11746 if (t[0] == 'n' && (t[1] == 'w' || t[1] == 'a')) 11747 { 11748 bool is_array = t[1] == 'a'; 11749 t += 2; 11750 if (t == last) 11751 return first; 11752 __node* expr = 0; 11753 __node* prev = 0; 11754 while (*t != '_') 11755 { 11756 const char* t1 = __parse_expression(t, last); 11757 if (t1 == t || t1 == last) 11758 return first; 11759 if (!__make<__list>(__root_)) 11760 return first; 11761 if (expr == 0) 11762 expr = __root_; 11763 if (prev) 11764 { 11765 prev->__right_ = __root_; 11766 __root_->__size_ = prev->__size_ + 1; 11767 } 11768 prev = __root_; 11769 t = t1; 11770 } 11771 ++t; 11772 const char* t1 = __parse_type(t, last); 11773 if (t1 == t || t1 == last) 11774 return first; 11775 t = t1; 11776 __node* type = __root_; 11777 __node* init = 0; 11778 prev = 0; 11779 bool has_init = false; 11780 if (last - t >= 3 && t[0] == 'p' && t[1] == 'i') 11781 { 11782 t += 2; 11783 has_init = true; 11784 while (*t != 'E') 11785 { 11786 t1 = __parse_expression(t, last); 11787 if (t1 == t || t1 == last) 11788 return first; 11789 if (!__make<__list>(__root_)) 11790 return first; 11791 if (init == 0) 11792 init = __root_; 11793 if (prev) 11794 { 11795 prev->__right_ = __root_; 11796 __root_->__size_ = prev->__size_ + 1; 11797 } 11798 prev = __root_; 11799 t = t1; 11800 } 11801 } 11802 if (*t != 'E') 11803 return first; 11804 if (__make<__new_expr>(parsed_gs, is_array, has_init, 11805 expr, type, init)) 11806 first = t; 11807 } 11808 } 11809 return first; 11810} 11811 11812// pt <expression> <unresolved-name> # expr->name 11813 11814const char* 11815__demangle_tree::__parse_arrow_expr(const char* first, const char* last) 11816{ 11817 if (last - first >= 3 && first[0] == 'p' && first[1] == 't') 11818 { 11819 const char* t = __parse_expression(first+2, last); 11820 if (t != first+2) 11821 { 11822 __node* expr = __root_; 11823 const char* t1 = __parse_unresolved_name(t, last); 11824 if (t1 != t) 11825 { 11826 if (__make<__arrow_expr>(expr, __root_)) 11827 first = t1; 11828 } 11829 } 11830 } 11831 return first; 11832} 11833 11834// rc <type> <expression> # reinterpret_cast<type> (expression) 11835 11836const char* 11837__demangle_tree::__parse_reinterpret_cast_expr(const char* first, const char* last) 11838{ 11839 if (last - first >= 3 && first[0] == 'r' && first[1] == 'c') 11840 { 11841 const char* t = __parse_type(first+2, last); 11842 if (t != first+2) 11843 { 11844 __node* type = __root_; 11845 const char* t1 = __parse_expression(t, last); 11846 if (t1 != t) 11847 { 11848 if (__make<__reinterpret_cast>(type, __root_)) 11849 first = t1; 11850 } 11851 } 11852 } 11853 return first; 11854} 11855 11856// sc <type> <expression> # static_cast<type> (expression) 11857 11858const char* 11859__demangle_tree::__parse_static_cast_expr(const char* first, const char* last) 11860{ 11861 if (last - first >= 3 && first[0] == 's' && first[1] == 'c') 11862 { 11863 const char* t = __parse_type(first+2, last); 11864 if (t != first+2) 11865 { 11866 __node* type = __root_; 11867 const char* t1 = __parse_expression(t, last); 11868 if (t1 != t) 11869 { 11870 if (__make<__static_cast>(type, __root_)) 11871 first = t1; 11872 } 11873 } 11874 } 11875 return first; 11876} 11877 11878// st <type> # sizeof (a type) 11879 11880const char* 11881__demangle_tree::__parse_sizeof_type_expr(const char* first, const char* last) 11882{ 11883 if (last - first >= 3 && first[0] == 's' && first[1] == 't') 11884 { 11885 const char* t = __parse_type(first+2, last); 11886 if (t != first+2) 11887 { 11888 if (__make<__operator_sizeof_expression>(__root_)) 11889 first = t; 11890 } 11891 } 11892 return first; 11893} 11894 11895// sZ <template-param> # size of a parameter pack 11896 11897const char* 11898__demangle_tree::__parse_sizeof_param_pack_expr(const char* first, const char* last) 11899{ 11900 if (last - first >= 3 && first[0] == 's' && first[1] == 'Z' && first[2] == 'T') 11901 { 11902 const char* t = __parse_template_param(first+2, last); 11903 if (t != first+2) 11904 { 11905 if (__make<__operator_sizeof_param_pack>(__root_)) 11906 first = t; 11907 } 11908 } 11909 return first; 11910} 11911 11912// sZ <function-param> # size of a function parameter pack 11913 11914const char* 11915__demangle_tree::__parse_sizeof_function_param_pack_expr(const char* first, const char* last) 11916{ 11917 if (last - first >= 3 && first[0] == 's' && first[1] == 'Z' && first[2] == 'f') 11918 { 11919 const char* t = __parse_function_param(first+2, last); 11920 if (t != first+2) 11921 { 11922 if (__make<__operator_sizeof_param_pack>(__root_)) 11923 first = t; 11924 } 11925 } 11926 return first; 11927} 11928 11929// sp <expression> # pack expansion 11930 11931const char* 11932__demangle_tree::__parse_pack_expansion(const char* first, const char* last) 11933{ 11934 if (last - first >= 3 && first[0] == 's' && first[1] == 'p') 11935 { 11936 const char* t = __parse_expression(first+2, last); 11937 if (t != first+2) 11938 { 11939 if (__make<__pack_expansion>(__root_)) 11940 first = t; 11941 } 11942 } 11943 return first; 11944} 11945 11946// te <expression> # typeid (expression) 11947// ti <type> # typeid (type) 11948 11949const char* 11950__demangle_tree::__parse_typeid_expr(const char* first, const char* last) 11951{ 11952 if (last - first >= 3 && first[0] == 't' && (first[1] == 'e' || first[1] == 'i')) 11953 { 11954 const char* t; 11955 if (first[1] == 'e') 11956 t = __parse_expression(first+2, last); 11957 else 11958 t = __parse_type(first+2, last); 11959 if (t != first+2) 11960 { 11961 if (__make<__typeid>(__root_)) 11962 first = t; 11963 } 11964 } 11965 return first; 11966} 11967 11968// tw <expression> # throw expression 11969 11970const char* 11971__demangle_tree::__parse_throw_expr(const char* first, const char* last) 11972{ 11973 if (last - first >= 3 && first[0] == 't' && first[1] == 'w') 11974 { 11975 const char* t = __parse_expression(first+2, last); 11976 if (t != first+2) 11977 { 11978 if (__make<__throw>(__root_)) 11979 first = t; 11980 } 11981 } 11982 return first; 11983} 11984 11985// <expression> ::= <unary operator-name> <expression> 11986// ::= <binary operator-name> <expression> <expression> 11987// ::= <ternary operator-name> <expression> <expression> <expression> 11988// ::= cl <expression>+ E # call 11989// ::= cv <type> <expression> # conversion with one argument 11990// ::= cv <type> _ <expression>* E # conversion with a different number of arguments 11991// ::= [gs] nw <expression>* _ <type> E # new (expr-list) type 11992// ::= [gs] nw <expression>* _ <type> <initializer> # new (expr-list) type (init) 11993// ::= [gs] na <expression>* _ <type> E # new[] (expr-list) type 11994// ::= [gs] na <expression>* _ <type> <initializer> # new[] (expr-list) type (init) 11995// ::= [gs] dl <expression> # delete expression 11996// ::= [gs] da <expression> # delete[] expression 11997// ::= pp_ <expression> # prefix ++ 11998// ::= mm_ <expression> # prefix -- 11999// ::= ti <type> # typeid (type) 12000// ::= te <expression> # typeid (expression) 12001// ::= dc <type> <expression> # dynamic_cast<type> (expression) 12002// ::= sc <type> <expression> # static_cast<type> (expression) 12003// ::= cc <type> <expression> # const_cast<type> (expression) 12004// ::= rc <type> <expression> # reinterpret_cast<type> (expression) 12005// ::= st <type> # sizeof (a type) 12006// ::= at <type> # alignof (a type) 12007// ::= <template-param> 12008// ::= <function-param> 12009// ::= dt <expression> <unresolved-name> # expr.name 12010// ::= pt <expression> <unresolved-name> # expr->name 12011// ::= ds <expression> <expression> # expr.*expr 12012// ::= sZ <template-param> # size of a parameter pack 12013// ::= sZ <function-param> # size of a function parameter pack 12014// ::= sp <expression> # pack expansion 12015// ::= tw <expression> # throw expression 12016// ::= tr # throw with no operand (rethrow) 12017// ::= <unresolved-name> # f(p), N::f(p), ::f(p), 12018// # freestanding dependent name (e.g., T::x), 12019// # objectless nonstatic member reference 12020// ::= <expr-primary> 12021 12022const char* 12023__demangle_tree::__parse_expression(const char* first, const char* last) 12024{ 12025 if (last - first >= 2) 12026 { 12027 const char* t = first; 12028 bool parsed_gs = false; 12029 if (last - first >= 4 && t[0] == 'g' && t[1] == 's') 12030 { 12031 t += 2; 12032 parsed_gs = true; 12033 } 12034 switch (*t) 12035 { 12036 case 'L': 12037 t = __parse_expr_primary(first, last); 12038 break; 12039 case 'T': 12040 t = __parse_template_param(first, last); 12041 break; 12042 case 'f': 12043 t = __parse_function_param(first, last); 12044 break; 12045 case 'a': 12046 if (t[1] == 't') 12047 t = __parse_alignof_expr(first, last); 12048 break; 12049 case 'c': 12050 switch (t[1]) 12051 { 12052 case 'c': 12053 t = __parse_const_cast_expr(first, last); 12054 break; 12055 case 'l': 12056 t = __parse_call_expr(first, last); 12057 break; 12058 case 'v': 12059 t = __parse_conversion_expr(first, last); 12060 break; 12061 } 12062 break; 12063 case 'd': 12064 switch (t[1]) 12065 { 12066 case 'a': 12067 t = __parse_delete_array_expr(first, last); 12068 break; 12069 case 'c': 12070 t = __parse_dynamic_cast_expr(first, last); 12071 break; 12072 case 'l': 12073 t = __parse_delete_expr(first, last); 12074 break; 12075 case 's': 12076 t = __parse_dot_star_expr(first, last); 12077 break; 12078 case 't': 12079 t = __parse_dot_expr(first, last); 12080 break; 12081 } 12082 break; 12083 case 'm': 12084 t = __parse_decrement_expr(first, last); 12085 break; 12086 case 'n': 12087 switch (t[1]) 12088 { 12089 case 'a': 12090 case 'w': 12091 t = __parse_new_expr(first, last); 12092 break; 12093 } 12094 break; 12095 case 'p': 12096 switch (t[1]) 12097 { 12098 case 'p': 12099 t = __parse_increment_expr(first, last); 12100 break; 12101 case 't': 12102 t = __parse_arrow_expr(first, last); 12103 break; 12104 } 12105 break; 12106 case 'r': 12107 t = __parse_reinterpret_cast_expr(first, last); 12108 break; 12109 case 's': 12110 switch (t[1]) 12111 { 12112 case 'c': 12113 t = __parse_static_cast_expr(first, last); 12114 break; 12115 case 'p': 12116 t = __parse_pack_expansion(first, last); 12117 break; 12118 case 't': 12119 t = __parse_sizeof_type_expr(first, last); 12120 break; 12121 case 'Z': 12122 if (last - t >= 3) 12123 { 12124 switch (t[2]) 12125 { 12126 case 'T': 12127 t = __parse_sizeof_param_pack_expr(first, last); 12128 break; 12129 case 'f': 12130 t = __parse_sizeof_function_param_pack_expr(first, last); 12131 break; 12132 } 12133 } 12134 break; 12135 } 12136 break; 12137 case 't': 12138 switch (t[1]) 12139 { 12140 case 'e': 12141 case 'i': 12142 t = __parse_typeid_expr(first, last); 12143 break; 12144 case 'r': 12145 if (__make<__rethrow>()) 12146 t = first +2; 12147 break; 12148 case 'w': 12149 t = __parse_throw_expr(first, last); 12150 break; 12151 } 12152 break; 12153 } 12154 if ((!parsed_gs && t == first) || (parsed_gs && t == first+2)) 12155 { 12156 int op; 12157 t = __parse_operator_name(first, last, &op); 12158 if (t == first) 12159 first = __parse_unresolved_name(first, last); 12160 else 12161 first = t; 12162 } 12163 else 12164 first = t; 12165 } 12166 return first; 12167} 12168 12169// <array-type> ::= A <positive dimension number> _ <element type> 12170// ::= A [<dimension expression>] _ <element type> 12171 12172const char* 12173__demangle_tree::__parse_array_type(const char* first, const char* last) 12174{ 12175 if (first != last && *first == 'A' && first+1 != last) 12176 { 12177 if (first[1] == '_') 12178 { 12179 const char* t = __parse_type(first+2, last); 12180 if (t != first+2) 12181 { 12182 if (__make<__array>(__root_)) 12183 first = t; 12184 } 12185 } 12186 else if ('1' <= first[1] && first[1] <= '9') 12187 { 12188 size_t dim = first[1] - '0'; 12189 const char* t = first+2; 12190 for (; t != last && isdigit(*t); ++t) 12191 dim = dim * 10 + *t - '0'; 12192 if (t != last && *t == '_') 12193 { 12194 const char* t2 = __parse_type(t+1, last); 12195 if (t2 != t+1) 12196 { 12197 if (__make<__array>(__root_, dim)) 12198 first = t2; 12199 } 12200 } 12201 } 12202 else 12203 { 12204 const char* t = __parse_expression(first+1, last); 12205 if (t != first+1 && t != last && *t == '_') 12206 { 12207 __node* dim = __root_; 12208 const char* t2 = __parse_type(++t, last); 12209 if (t2 != t) 12210 { 12211 if (__make<__array>(__root_, dim)) 12212 first = t2; 12213 } 12214 } 12215 } 12216 } 12217 return first; 12218} 12219 12220// <class-enum-type> ::= <name> 12221 12222const char* 12223__demangle_tree::__parse_class_enum_type(const char* first, const char* last) 12224{ 12225 return __parse_name(first, last); 12226} 12227 12228// <pointer-to-member-type> ::= M <class type> <member type> 12229 12230const char* 12231__demangle_tree::__parse_pointer_to_member_type(const char* first, const char* last) 12232{ 12233 if (first != last && *first == 'M') 12234 { 12235 const char* t = __parse_type(first+1, last); 12236 if (t != first+1) 12237 { 12238 __node* class_type = __root_; 12239 const char* t2 = __parse_type(t, last, true, true); 12240 if (t2 != t) 12241 { 12242 if (__make<__pointer_to_member_type>(class_type, __root_)) 12243 first = t2; 12244 } 12245 } 12246 } 12247 return first; 12248} 12249 12250// <decltype> ::= Dt <expression> E # decltype of an id-expression or class member access (C++0x) 12251// ::= DT <expression> E # decltype of an expression (C++0x) 12252 12253const char* 12254__demangle_tree::__parse_decltype(const char* first, const char* last) 12255{ 12256 if (last - first >= 4 && first[0] == 'D') 12257 { 12258 switch (first[1]) 12259 { 12260 case 't': 12261 case 'T': 12262 { 12263 const char* t = __parse_expression(first+2, last); 12264 if (t != first+2 && t != last && *t == 'E') 12265 { 12266 if (__make<__decltype_node>(__root_)) 12267 first = t+1; 12268 } 12269 } 12270 break; 12271 } 12272 } 12273 return first; 12274} 12275 12276// <template-param> ::= T_ # first template parameter 12277// ::= T <parameter-2 non-negative number> _ 12278 12279const char* 12280__demangle_tree::__parse_template_param(const char* first, const char* last) 12281{ 12282 if (last - first >= 2) 12283 { 12284 if (*first == 'T') 12285 { 12286 if (first[1] == '_') 12287 { 12288 if (__t_begin_ != __t_end_) 12289 { 12290 if (__make<__sub>(*__t_begin_)) 12291 first += 2; 12292 } 12293 else 12294 { 12295 if (__make<__sub>(size_t(0))) 12296 { 12297 first += 2; 12298 __fix_forward_references_ = true; 12299 } 12300 } 12301 } 12302 else if (isdigit(first[1])) 12303 { 12304 const char* t = first+1; 12305 size_t sub = *t - '0'; 12306 for (++t; t != last && isdigit(*t); ++t) 12307 { 12308 sub *= 10; 12309 sub += *t - '0'; 12310 } 12311 if (t == last || *t != '_') 12312 return first; 12313 ++sub; 12314 if (sub < __t_end_ - __t_begin_) 12315 { 12316 if (__make<__sub>(__t_begin_[sub])) 12317 first = t+1; 12318 } 12319 else 12320 { 12321 if (__make<__sub>(sub)) 12322 { 12323 first = t+1; 12324 __fix_forward_references_ = true; 12325 } 12326 } 12327 } 12328 } 12329 } 12330 return first; 12331} 12332 12333// <type> ::= <builtin-type> 12334// ::= <function-type> 12335// ::= <class-enum-type> 12336// ::= <array-type> 12337// ::= <pointer-to-member-type> 12338// ::= <template-param> 12339// ::= <template-template-param> <template-args> 12340// ::= <decltype> 12341// ::= <substitution> 12342// ::= <CV-qualifiers> <type> 12343// ::= P <type> # pointer-to 12344// ::= R <type> # reference-to 12345// ::= O <type> # rvalue reference-to (C++0x) 12346// ::= C <type> # complex pair (C 2000) 12347// ::= G <type> # imaginary (C 2000) 12348// ::= Dp <type> # pack expansion (C++0x) 12349// ::= U <source-name> <type> # vendor extended type qualifier 12350 12351const char* 12352__demangle_tree::__parse_type(const char* first, const char* last, 12353 bool try_to_parse_template_args, 12354 bool look_for_ref_quals) 12355{ 12356 unsigned cv = 0; 12357 const char* t = __parse_cv_qualifiers(first, last, cv, look_for_ref_quals); 12358 if (t != first) 12359 { 12360 const char* t2 = __parse_type(t, last, try_to_parse_template_args); 12361 if (t2 != t) 12362 { 12363 if (__make<__cv_qualifiers>(cv, __root_)) 12364 { 12365 if (__sub_end_ == __sub_cap_) 12366 __status_ = memory_alloc_failure; 12367 else 12368 { 12369 *__sub_end_++ = __root_; 12370 first = t2; 12371 } 12372 } 12373 } 12374 return first; 12375 } 12376 if (first != last) 12377 { 12378 switch (*first) 12379 { 12380 case 'A': 12381 t = __parse_array_type(first, last); 12382 if (t != first) 12383 { 12384 if (__sub_end_ == __sub_cap_) 12385 __status_ = memory_alloc_failure; 12386 else 12387 { 12388 *__sub_end_++ = __root_; 12389 first = t; 12390 } 12391 } 12392 break; 12393 case 'C': 12394 t = __parse_type(first+1, last, try_to_parse_template_args); 12395 if (t != first+1) 12396 { 12397 if (__make<__d_complex>(__root_)) 12398 { 12399 if (__sub_end_ == __sub_cap_) 12400 __status_ = memory_alloc_failure; 12401 else 12402 { 12403 *__sub_end_++ = __root_; 12404 first = t; 12405 } 12406 } 12407 return first; 12408 } 12409 break; 12410 case 'F': 12411 t = __parse_function_type(first, last); 12412 if (t != first) 12413 { 12414 if (__sub_end_ == __sub_cap_) 12415 __status_ = memory_alloc_failure; 12416 else 12417 { 12418 *__sub_end_++ = __root_; 12419 first = t; 12420 } 12421 } 12422 break; 12423 case 'G': 12424 t = __parse_type(first+1, last, try_to_parse_template_args); 12425 if (t != first+1) 12426 { 12427 if (__make<__imaginary>(__root_)) 12428 { 12429 if (__sub_end_ == __sub_cap_) 12430 __status_ = memory_alloc_failure; 12431 else 12432 { 12433 *__sub_end_++ = __root_; 12434 first = t; 12435 } 12436 } 12437 return first; 12438 } 12439 break; 12440 case 'M': 12441 t = __parse_pointer_to_member_type(first, last); 12442 if (t != first) 12443 { 12444 if (__sub_end_ == __sub_cap_) 12445 __status_ = memory_alloc_failure; 12446 else 12447 { 12448 *__sub_end_++ = __root_; 12449 first = t; 12450 } 12451 } 12452 break; 12453 case 'O': 12454 t = __parse_type(first+1, last, try_to_parse_template_args); 12455 if (t != first+1) 12456 { 12457 if (__make<__rvalue_reference_to>(__root_)) 12458 { 12459 if (__sub_end_ == __sub_cap_) 12460 __status_ = memory_alloc_failure; 12461 else 12462 { 12463 *__sub_end_++ = __root_; 12464 first = t; 12465 } 12466 } 12467 return first; 12468 } 12469 break; 12470 case 'P': 12471 t = __parse_type(first+1, last, try_to_parse_template_args); 12472 if (t != first+1) 12473 { 12474 if (__make<__pointer_to>(__root_)) 12475 { 12476 if (__sub_end_ == __sub_cap_) 12477 __status_ = memory_alloc_failure; 12478 else 12479 { 12480 *__sub_end_++ = __root_; 12481 first = t; 12482 } 12483 } 12484 return first; 12485 } 12486 break; 12487 case 'R': 12488 t = __parse_type(first+1, last, try_to_parse_template_args); 12489 if (t != first+1) 12490 { 12491 if (__make<__lvalue_reference_to>(__root_)) 12492 { 12493 if (__sub_end_ == __sub_cap_) 12494 __status_ = memory_alloc_failure; 12495 else 12496 { 12497 *__sub_end_++ = __root_; 12498 first = t; 12499 } 12500 } 12501 return first; 12502 } 12503 break; 12504 case 'T': 12505 t = __parse_template_param(first, last); 12506 if (t != first) 12507 { 12508 if (__sub_end_ == __sub_cap_) 12509 __status_ = memory_alloc_failure; 12510 else 12511 { 12512 *__sub_end_++ = __root_; 12513 if (try_to_parse_template_args) 12514 { 12515 __node* temp = __root_; 12516 const char* t2 = __parse_template_args(t, last); 12517 if (t2 != t) 12518 { 12519 if (__sub_end_ < __sub_cap_) 12520 { 12521 *__sub_end_++ = __root_; 12522 first = t2; 12523 } 12524 else 12525 __status_ = memory_alloc_failure; 12526 } 12527 else 12528 { 12529 first = t; 12530 } 12531 } 12532 else 12533 { 12534 first = t; 12535 } 12536 } 12537 } 12538 break; 12539 case 'U': 12540 if (first+1 != last) 12541 { 12542 t = __parse_source_name(first+1, last); 12543 if (t != first+1) 12544 { 12545 __node* name = __root_; 12546 const char* t2 = __parse_type(t, last, try_to_parse_template_args); 12547 if (t2 != t) 12548 { 12549 if (__make<__extended_qualifier>(name, __root_)) 12550 { 12551 if (__sub_end_ == __sub_cap_) 12552 __status_ = memory_alloc_failure; 12553 else 12554 { 12555 *__sub_end_++ = __root_; 12556 first = t2; 12557 } 12558 } 12559 return first; 12560 } 12561 } 12562 } 12563 break; 12564 case 'S': 12565 if (first+1 != last && first[1] == 't') 12566 { 12567 t = __parse_class_enum_type(first, last); 12568 if (t != first) 12569 { 12570 if (__sub_end_ == __sub_cap_) 12571 __status_ = memory_alloc_failure; 12572 else 12573 { 12574 *__sub_end_++ = __root_; 12575 first = t; 12576 } 12577 } 12578 } 12579 else 12580 { 12581 t = __parse_substitution(first, last); 12582 if (t != first) 12583 { 12584 first = t; 12585 // Parsed a substitution. If the substitution is a 12586 // <template-param> it might be followed by <template-args>. 12587 t = __parse_template_args(first, last); 12588 if (t != first) 12589 { 12590 // Need to create substitution for <template-template-param> <template-args> 12591 if (__sub_end_ == __sub_cap_) 12592 __status_ = memory_alloc_failure; 12593 else 12594 { 12595 *__sub_end_++ = __root_; 12596 first = t; 12597 } 12598 } 12599 } 12600 } 12601 break; 12602 case 'D': 12603 if (first+1 != last) 12604 { 12605 switch (first[1]) 12606 { 12607 case 'p': 12608 t = __parse_type(first+2, last, try_to_parse_template_args); 12609 if (t != first+1) 12610 { 12611 if (__make<__pack_expansion>(__root_)) 12612 { 12613 if (__sub_end_ == __sub_cap_) 12614 __status_ = memory_alloc_failure; 12615 else 12616 { 12617 *__sub_end_++ = __root_; 12618 first = t; 12619 } 12620 } 12621 return first; 12622 } 12623 break; 12624 case 't': 12625 case 'T': 12626 t = __parse_decltype(first, last); 12627 if (t != first) 12628 { 12629 if (__sub_end_ == __sub_cap_) 12630 __status_ = memory_alloc_failure; 12631 else 12632 { 12633 *__sub_end_++ = __root_; 12634 first = t; 12635 } 12636 return first; 12637 } 12638 break; 12639 } 12640 } 12641 // drop through 12642 default: 12643 // must check for builtin-types before class-enum-types to avoid 12644 // ambiguities with operator-names 12645 t = __parse_builtin_type(first, last); 12646 if (t != first) 12647 { 12648 first = t; 12649 } 12650 else 12651 { 12652 t = __parse_class_enum_type(first, last); 12653 if (t != first) 12654 { 12655 if (__sub_end_ == __sub_cap_) 12656 __status_ = memory_alloc_failure; 12657 else 12658 { 12659 *__sub_end_++ = __root_; 12660 first = t; 12661 } 12662 } 12663 } 12664 break; 12665 } 12666 } 12667 return first; 12668} 12669 12670// <number> ::= [n] <non-negative decimal integer> 12671 12672const char* 12673__demangle_tree::__parse_number(const char* first, const char* last) 12674{ 12675 if (first != last) 12676 { 12677 const char* t = first; 12678 if (*t == 'n') 12679 ++t; 12680 if (t != last) 12681 { 12682 if (*t == '0') 12683 { 12684 first = t+1; 12685 } 12686 else if ('1' <= *t && *t <= '9') 12687 { 12688 first = t+1; 12689 while (first != last && isdigit(*first)) 12690 ++first; 12691 } 12692 } 12693 } 12694 return first; 12695} 12696 12697// <call-offset> ::= h <nv-offset> _ 12698// ::= v <v-offset> _ 12699// 12700// <nv-offset> ::= <offset number> 12701// # non-virtual base override 12702// 12703// <v-offset> ::= <offset number> _ <virtual offset number> 12704// # virtual base override, with vcall offset 12705 12706const char* 12707__demangle_tree::__parse_call_offset(const char* first, const char* last) 12708{ 12709 if (first != last) 12710 { 12711 switch (*first) 12712 { 12713 case 'h': 12714 { 12715 const char* t = __parse_number(first + 1, last); 12716 if (t != first + 1 && t != last && *t == '_') 12717 first = t + 1; 12718 } 12719 break; 12720 case 'v': 12721 { 12722 const char* t = __parse_number(first + 1, last); 12723 if (t != first + 1 && t != last && *t == '_') 12724 { 12725 const char* t2 = __parse_number(++t, last); 12726 if (t2 != t && t2 != last && *t2 == '_') 12727 first = t2 + 1; 12728 } 12729 } 12730 break; 12731 } 12732 } 12733 return first; 12734} 12735 12736// <special-name> ::= TV <type> # virtual table 12737// ::= TT <type> # VTT structure (construction vtable index) 12738// ::= TI <type> # typeinfo structure 12739// ::= TS <type> # typeinfo name (null-terminated byte string) 12740// ::= Tc <call-offset> <call-offset> <base encoding> 12741// # base is the nominal target function of thunk 12742// # first call-offset is 'this' adjustment 12743// # second call-offset is result adjustment 12744// ::= T <call-offset> <base encoding> 12745// # base is the nominal target function of thunk 12746// ::= GV <object name> # Guard variable for one-time initialization 12747// # No <type> 12748 12749const char* 12750__demangle_tree::__parse_special_name(const char* first, const char* last) 12751{ 12752 if (last - first > 2) 12753 { 12754 const char* t; 12755 switch (*first) 12756 { 12757 case 'T': 12758 switch (first[1]) 12759 { 12760 case 'V': 12761 // TV <type> # virtual table 12762 t = __parse_type(first+2, last); 12763 if (t != first+2 && __make<__vtable>(__root_)) 12764 first = t; 12765 break; 12766 case 'T': 12767 // TT <type> # VTT structure (construction vtable index) 12768 t = __parse_type(first+2, last); 12769 if (t != first+2 && __make<__VTT>(__root_)) 12770 first = t; 12771 break; 12772 case 'I': 12773 // TI <type> # typeinfo structure 12774 t = __parse_type(first+2, last); 12775 if (t != first+2 && __make<__typeinfo>(__root_)) 12776 first = t; 12777 break; 12778 case 'S': 12779 // TS <type> # typeinfo name (null-terminated byte string) 12780 t = __parse_type(first+2, last); 12781 if (t != first+2 && __make<__typeinfo_name>(__root_)) 12782 first = t; 12783 break; 12784 case 'c': 12785 // Tc <call-offset> <call-offset> <base encoding> 12786 { 12787 const char* t0 = __parse_call_offset(first+2, last); 12788 if (t0 == first+2) 12789 break; 12790 const char* t1 = __parse_call_offset(t0, last); 12791 if (t1 == t0) 12792 break; 12793 t = __parse_encoding(t1, last); 12794 if (t != t1 && __make<__covariant_return_thunk>(__root_)) 12795 first = t; 12796 } 12797 break; 12798 default: 12799 // T <call-offset> <base encoding> 12800 { 12801 const char* t0 = __parse_call_offset(first+1, last); 12802 if (t0 == first+1) 12803 break; 12804 t = __parse_encoding(t0, last); 12805 if (t != t0) 12806 { 12807 if (first[2] == 'v') 12808 { 12809 if (__make<__virtual_thunk>(__root_)) 12810 first = t; 12811 } 12812 else 12813 { 12814 if (__make<__non_virtual_thunk>(__root_)) 12815 first = t; 12816 } 12817 } 12818 } 12819 break; 12820 } 12821 break; 12822 case 'G': 12823 if (first[1] == 'V') 12824 { 12825 // GV <object name> # Guard variable for one-time initialization 12826 t = __parse_name(first+2, last); 12827 if (t != first+2 && __make<__guard_variable>(__root_)) 12828 first = t; 12829 } 12830 break; 12831 } 12832 } 12833 return first; 12834} 12835 12836// <operator-name> 12837// ::= aa # && 12838// ::= ad # & (unary) 12839// ::= an # & 12840// ::= aN # &= 12841// ::= aS # = 12842// ::= at # alignof (a type) 12843// ::= az # alignof (an expression) 12844// ::= cl # () 12845// ::= cm # , 12846// ::= co # ~ 12847// ::= cv <type> # (cast) 12848// ::= da # delete[] 12849// ::= de # * (unary) 12850// ::= dl # delete 12851// ::= dv # / 12852// ::= dV # /= 12853// ::= eo # ^ 12854// ::= eO # ^= 12855// ::= eq # == 12856// ::= ge # >= 12857// ::= gt # > 12858// ::= ix # [] 12859// ::= le # <= 12860// ::= ls # << 12861// ::= lS # <<= 12862// ::= lt # < 12863// ::= mi # - 12864// ::= mI # -= 12865// ::= ml # * 12866// ::= mL # *= 12867// ::= mm # -- (postfix in <expression> context) 12868// ::= na # new[] 12869// ::= ne # != 12870// ::= ng # - (unary) 12871// ::= nt # ! 12872// ::= nw # new 12873// ::= oo # || 12874// ::= or # | 12875// ::= oR # |= 12876// ::= pm # ->* 12877// ::= pl # + 12878// ::= pL # += 12879// ::= pp # ++ (postfix in <expression> context) 12880// ::= ps # + (unary) 12881// ::= pt # -> 12882// ::= qu # ? 12883// ::= rm # % 12884// ::= rM # %= 12885// ::= rs # >> 12886// ::= rS # >>= 12887// ::= st # sizeof (a type) 12888// ::= sz # sizeof (an expression) 12889// ::= v <digit> <source-name> # vendor extended operator 12890 12891const char* 12892__demangle_tree::__parse_operator_name(const char* first, const char* last, int* type) 12893{ 12894 if (last - first >= 2) 12895 { 12896 switch (*first) 12897 { 12898 case 'a': 12899 switch (first[1]) 12900 { 12901 case 'a': 12902 // && 12903 if (type) 12904 { 12905 const char* t = __parse_expression(first+2, last); 12906 if (t != first+2) 12907 { 12908 __node* op1 = __root_; 12909 const char* t2 = __parse_expression(t, last); 12910 if (t != t2) 12911 { 12912 if (__make<__operator_logical_and>(op1, __root_)) 12913 { 12914 *type = 2; 12915 first = t2; 12916 } 12917 } 12918 } 12919 } 12920 else 12921 { 12922 if (__make<__operator_logical_and>()) 12923 first += 2; 12924 } 12925 break; 12926 case 'd': 12927 // & (unary) 12928 if (type) 12929 { 12930 const char* t = __parse_expression(first+2, last); 12931 if (t != first+2) 12932 { 12933 if (__make<__operator_addressof>(__root_)) 12934 { 12935 *type = 1; 12936 first = t; 12937 } 12938 } 12939 } 12940 else 12941 { 12942 if (__make<__operator_addressof>()) 12943 first += 2; 12944 } 12945 break; 12946 case 'n': 12947 // & 12948 if (type) 12949 { 12950 const char* t = __parse_expression(first+2, last); 12951 if (t != first+2) 12952 { 12953 __node* op1 = __root_; 12954 const char* t2 = __parse_expression(t, last); 12955 if (t != t2) 12956 { 12957 if (__make<__operator_bit_and>(op1, __root_)) 12958 { 12959 *type = 2; 12960 first = t2; 12961 } 12962 } 12963 } 12964 } 12965 else 12966 { 12967 if (__make<__operator_bit_and>()) 12968 first += 2; 12969 } 12970 break; 12971 case 'N': 12972 // &= 12973 if (type) 12974 { 12975 const char* t = __parse_expression(first+2, last); 12976 if (t != first+2) 12977 { 12978 __node* op1 = __root_; 12979 const char* t2 = __parse_expression(t, last); 12980 if (t != t2) 12981 { 12982 if (__make<__operator_and_equal>(op1, __root_)) 12983 { 12984 *type = 2; 12985 first = t2; 12986 } 12987 } 12988 } 12989 } 12990 else 12991 { 12992 if (__make<__operator_and_equal>()) 12993 first += 2; 12994 } 12995 break; 12996 case 'S': 12997 // = 12998 if (type) 12999 { 13000 const char* t = __parse_expression(first+2, last); 13001 if (t != first+2) 13002 { 13003 __node* op1 = __root_; 13004 const char* t2 = __parse_expression(t, last); 13005 if (t != t2) 13006 { 13007 if (__make<__operator_equal>(op1, __root_)) 13008 { 13009 *type = 2; 13010 first = t2; 13011 } 13012 } 13013 } 13014 } 13015 else 13016 { 13017 if (__make<__operator_equal>()) 13018 first += 2; 13019 } 13020 break; 13021 case 't': 13022 // alignof (a type) 13023 if (type) 13024 { 13025 const char* t = __parse_expression(first+2, last); 13026 if (t != first+2) 13027 { 13028 if (__make<__operator_alignof_type>(__root_)) 13029 { 13030 *type = -1; 13031 first = t; 13032 } 13033 } 13034 } 13035 else 13036 { 13037 if (__make<__operator_alignof_type>()) 13038 first += 2; 13039 } 13040 break; 13041 case 'z': 13042 // alignof (an expression) 13043 if (type) 13044 { 13045 const char* t = __parse_expression(first+2, last); 13046 if (t != first+2) 13047 { 13048 if (__make<__operator_alignof_expression>(__root_)) 13049 { 13050 *type = -1; 13051 first = t; 13052 } 13053 } 13054 } 13055 else 13056 { 13057 if (__make<__operator_alignof_expression>()) 13058 first += 2; 13059 } 13060 break; 13061 } 13062 break; 13063 case 'c': 13064 switch (first[1]) 13065 { 13066 case 'l': 13067 // () 13068 if (__make<__operator_paren>()) 13069 { 13070 first += 2; 13071 if (type) 13072 *type = -1; 13073 } 13074 break; 13075 case 'm': 13076 // , 13077 if (type) 13078 { 13079 const char* t = __parse_expression(first+2, last); 13080 if (t != first+2) 13081 { 13082 __node* op1 = __root_; 13083 const char* t2 = __parse_expression(t, last); 13084 if (t != t2) 13085 { 13086 if (__make<__operator_comma>(op1, __root_)) 13087 { 13088 *type = 2; 13089 first = t2; 13090 } 13091 } 13092 } 13093 } 13094 else 13095 { 13096 if (__make<__operator_comma>()) 13097 first += 2; 13098 } 13099 break; 13100 case 'o': 13101 // ~ 13102 if (type) 13103 { 13104 const char* t = __parse_expression(first+2, last); 13105 if (t != first+2) 13106 { 13107 if (__make<__operator_tilda>(__root_)) 13108 { 13109 *type = 1; 13110 first = t; 13111 } 13112 } 13113 } 13114 else 13115 { 13116 if (__make<__operator_tilda>()) 13117 first += 2; 13118 } 13119 break; 13120 case 'v': 13121 // cast <type> 13122 { 13123 const char* t = __parse_type(first+2, last, false); 13124 if (t != first+2) 13125 { 13126 __node* cast_type = __root_; 13127 if (type) 13128 { 13129 const char* t2 = __parse_expression(t, last); 13130 if (t2 != t) 13131 { 13132 if (__make<__operator_cast>(cast_type, __root_)) 13133 { 13134 *type = -1; 13135 first = t2; 13136 } 13137 } 13138 } 13139 else 13140 { 13141 if (__make<__operator_cast>(cast_type)) 13142 first = t; 13143 } 13144 } 13145 } 13146 break; 13147 } 13148 break; 13149 case 'd': 13150 switch (first[1]) 13151 { 13152 case 'a': 13153 // delete[] 13154 if (__make<__operator_delete_array>()) 13155 { 13156 first += 2; 13157 if (type) 13158 *type = -1; 13159 } 13160 break; 13161 case 'e': 13162 // * (unary) 13163 if (type) 13164 { 13165 const char* t = __parse_expression(first+2, last); 13166 if (t != first+2) 13167 { 13168 if (__make<__operator_dereference>(__root_)) 13169 { 13170 *type = 1; 13171 first = t; 13172 } 13173 } 13174 } 13175 else 13176 { 13177 if (__make<__operator_dereference>()) 13178 first += 2; 13179 } 13180 break; 13181 case 'l': 13182 // delete 13183 if (__make<__operator_delete>()) 13184 { 13185 first += 2; 13186 if (type) 13187 *type = -1; 13188 } 13189 break; 13190 case 'v': 13191 // / 13192 if (type) 13193 { 13194 const char* t = __parse_expression(first+2, last); 13195 if (t != first+2) 13196 { 13197 __node* op1 = __root_; 13198 const char* t2 = __parse_expression(t, last); 13199 if (t != t2) 13200 { 13201 if (__make<__operator_divide>(op1, __root_)) 13202 { 13203 *type = 2; 13204 first = t2; 13205 } 13206 } 13207 } 13208 } 13209 else 13210 { 13211 if (__make<__operator_divide>()) 13212 first += 2; 13213 } 13214 break; 13215 case 'V': 13216 // /= 13217 if (type) 13218 { 13219 const char* t = __parse_expression(first+2, last); 13220 if (t != first+2) 13221 { 13222 __node* op1 = __root_; 13223 const char* t2 = __parse_expression(t, last); 13224 if (t != t2) 13225 { 13226 if (__make<__operator_divide_equal>(op1, __root_)) 13227 { 13228 *type = 2; 13229 first = t2; 13230 } 13231 } 13232 } 13233 } 13234 else 13235 { 13236 if (__make<__operator_divide_equal>()) 13237 first += 2; 13238 } 13239 break; 13240 } 13241 break; 13242 case 'e': 13243 switch (first[1]) 13244 { 13245 case 'o': 13246 // ^ 13247 if (type) 13248 { 13249 const char* t = __parse_expression(first+2, last); 13250 if (t != first+2) 13251 { 13252 __node* op1 = __root_; 13253 const char* t2 = __parse_expression(t, last); 13254 if (t != t2) 13255 { 13256 if (__make<__operator_xor>(op1, __root_)) 13257 { 13258 *type = 2; 13259 first = t2; 13260 } 13261 } 13262 } 13263 } 13264 else 13265 { 13266 if (__make<__operator_xor>()) 13267 first += 2; 13268 } 13269 break; 13270 case 'O': 13271 // ^= 13272 if (type) 13273 { 13274 const char* t = __parse_expression(first+2, last); 13275 if (t != first+2) 13276 { 13277 __node* op1 = __root_; 13278 const char* t2 = __parse_expression(t, last); 13279 if (t != t2) 13280 { 13281 if (__make<__operator_xor_equal>(op1, __root_)) 13282 { 13283 *type = 2; 13284 first = t2; 13285 } 13286 } 13287 } 13288 } 13289 else 13290 { 13291 if (__make<__operator_xor_equal>()) 13292 first += 2; 13293 } 13294 break; 13295 case 'q': 13296 // == 13297 if (type) 13298 { 13299 const char* t = __parse_expression(first+2, last); 13300 if (t != first+2) 13301 { 13302 __node* op1 = __root_; 13303 const char* t2 = __parse_expression(t, last); 13304 if (t != t2) 13305 { 13306 if (__make<__operator_equality>(op1, __root_)) 13307 { 13308 *type = 2; 13309 first = t2; 13310 } 13311 } 13312 } 13313 } 13314 else 13315 { 13316 if (__make<__operator_equality>()) 13317 first += 2; 13318 } 13319 break; 13320 } 13321 break; 13322 case 'g': 13323 switch (first[1]) 13324 { 13325 case 'e': 13326 // >= 13327 if (type) 13328 { 13329 const char* t = __parse_expression(first+2, last); 13330 if (t != first+2) 13331 { 13332 __node* op1 = __root_; 13333 const char* t2 = __parse_expression(t, last); 13334 if (t != t2) 13335 { 13336 if (__make<__operator_greater_equal>(op1, __root_)) 13337 { 13338 *type = 2; 13339 first = t2; 13340 } 13341 } 13342 } 13343 } 13344 else 13345 { 13346 if (__make<__operator_greater_equal>()) 13347 first += 2; 13348 } 13349 break; 13350 case 't': 13351 // > 13352 if (type) 13353 { 13354 const char* t = __parse_expression(first+2, last); 13355 if (t != first+2) 13356 { 13357 __node* op1 = __root_; 13358 const char* t2 = __parse_expression(t, last); 13359 if (t != t2) 13360 { 13361 if (__make<__operator_greater>(op1, __root_)) 13362 { 13363 *type = 2; 13364 first = t2; 13365 } 13366 } 13367 } 13368 } 13369 else 13370 { 13371 if (__make<__operator_greater>()) 13372 first += 2; 13373 } 13374 break; 13375 } 13376 break; 13377 case 'i': 13378 // [] 13379 if (first[1] == 'x' && __make<__operator_brackets>()) 13380 { 13381 first += 2; 13382 if (type) 13383 *type = -1; 13384 } 13385 break; 13386 case 'l': 13387 switch (first[1]) 13388 { 13389 case 'e': 13390 // <= 13391 if (type) 13392 { 13393 const char* t = __parse_expression(first+2, last); 13394 if (t != first+2) 13395 { 13396 __node* op1 = __root_; 13397 const char* t2 = __parse_expression(t, last); 13398 if (t != t2) 13399 { 13400 if (__make<__operator_less_equal>(op1, __root_)) 13401 { 13402 *type = 2; 13403 first = t2; 13404 } 13405 } 13406 } 13407 } 13408 else 13409 { 13410 if (__make<__operator_less_equal>()) 13411 first += 2; 13412 } 13413 break; 13414 case 's': 13415 // << 13416 if (type) 13417 { 13418 const char* t = __parse_expression(first+2, last); 13419 if (t != first+2) 13420 { 13421 __node* op1 = __root_; 13422 const char* t2 = __parse_expression(t, last); 13423 if (t != t2) 13424 { 13425 if (__make<__operator_left_shift>(op1, __root_)) 13426 { 13427 *type = 2; 13428 first = t2; 13429 } 13430 } 13431 } 13432 } 13433 else 13434 { 13435 if (__make<__operator_left_shift>()) 13436 first += 2; 13437 } 13438 break; 13439 case 'S': 13440 // <<= 13441 if (type) 13442 { 13443 const char* t = __parse_expression(first+2, last); 13444 if (t != first+2) 13445 { 13446 __node* op1 = __root_; 13447 const char* t2 = __parse_expression(t, last); 13448 if (t != t2) 13449 { 13450 if (__make<__operator_left_shift_equal>(op1, __root_)) 13451 { 13452 *type = 2; 13453 first = t2; 13454 } 13455 } 13456 } 13457 } 13458 else 13459 { 13460 if (__make<__operator_left_shift_equal>()) 13461 first += 2; 13462 } 13463 break; 13464 case 't': 13465 // < 13466 if (type) 13467 { 13468 const char* t = __parse_expression(first+2, last); 13469 if (t != first+2) 13470 { 13471 __node* op1 = __root_; 13472 const char* t2 = __parse_expression(t, last); 13473 if (t != t2) 13474 { 13475 if (__make<__operator_less>(op1, __root_)) 13476 { 13477 *type = 2; 13478 first = t2; 13479 } 13480 } 13481 } 13482 } 13483 else 13484 { 13485 if (__make<__operator_less>()) 13486 first += 2; 13487 } 13488 break; 13489 } 13490 break; 13491 case 'm': 13492 switch (first[1]) 13493 { 13494 case 'i': 13495 // - 13496 if (type) 13497 { 13498 const char* t = __parse_expression(first+2, last); 13499 if (t != first+2) 13500 { 13501 __node* op1 = __root_; 13502 const char* t2 = __parse_expression(t, last); 13503 if (t != t2) 13504 { 13505 if (__make<__operator_minus>(op1, __root_)) 13506 { 13507 *type = 2; 13508 first = t2; 13509 } 13510 } 13511 } 13512 } 13513 else 13514 { 13515 if (__make<__operator_minus>()) 13516 first += 2; 13517 } 13518 break; 13519 case 'I': 13520 // -= 13521 if (type) 13522 { 13523 const char* t = __parse_expression(first+2, last); 13524 if (t != first+2) 13525 { 13526 __node* op1 = __root_; 13527 const char* t2 = __parse_expression(t, last); 13528 if (t != t2) 13529 { 13530 if (__make<__operator_minus_equal>(op1, __root_)) 13531 { 13532 *type = 2; 13533 first = t2; 13534 } 13535 } 13536 } 13537 } 13538 else 13539 { 13540 if (__make<__operator_minus_equal>()) 13541 first += 2; 13542 } 13543 break; 13544 case 'l': 13545 // * 13546 if (type) 13547 { 13548 const char* t = __parse_expression(first+2, last); 13549 if (t != first+2) 13550 { 13551 __node* op1 = __root_; 13552 const char* t2 = __parse_expression(t, last); 13553 if (t != t2) 13554 { 13555 if (__make<__operator_times>(op1, __root_)) 13556 { 13557 *type = 2; 13558 first = t2; 13559 } 13560 } 13561 } 13562 } 13563 else 13564 { 13565 if (__make<__operator_times>()) 13566 first += 2; 13567 } 13568 break; 13569 case 'L': 13570 // *= 13571 if (type) 13572 { 13573 const char* t = __parse_expression(first+2, last); 13574 if (t != first+2) 13575 { 13576 __node* op1 = __root_; 13577 const char* t2 = __parse_expression(t, last); 13578 if (t != t2) 13579 { 13580 if (__make<__operator_times_equal>(op1, __root_)) 13581 { 13582 *type = 2; 13583 first = t2; 13584 } 13585 } 13586 } 13587 } 13588 else 13589 { 13590 if (__make<__operator_times_equal>()) 13591 first += 2; 13592 } 13593 break; 13594 case 'm': 13595 // -- (postfix in <expression> context) 13596 if (type) 13597 { 13598 const char* t = __parse_expression(first+2, last); 13599 if (t != first+2) 13600 { 13601 if (__make<__operator_decrement>(false, __root_)) 13602 { 13603 *type = 1; 13604 first = t; 13605 } 13606 } 13607 } 13608 else 13609 { 13610 if (__make<__operator_decrement>()) 13611 first += 2; 13612 } 13613 break; 13614 } 13615 break; 13616 case 'n': 13617 switch (first[1]) 13618 { 13619 case 'a': 13620 // new[] 13621 if (__make<__operator_new_array>()) 13622 { 13623 first += 2; 13624 if (type) 13625 *type = -1; 13626 } 13627 break; 13628 case 'e': 13629 // != 13630 if (type) 13631 { 13632 const char* t = __parse_expression(first+2, last); 13633 if (t != first+2) 13634 { 13635 __node* op1 = __root_; 13636 const char* t2 = __parse_expression(t, last); 13637 if (t != t2) 13638 { 13639 if (__make<__operator_not_equal>(op1, __root_)) 13640 { 13641 *type = 2; 13642 first = t2; 13643 } 13644 } 13645 } 13646 } 13647 else 13648 { 13649 if (__make<__operator_not_equal>()) 13650 first += 2; 13651 } 13652 break; 13653 case 'g': 13654 // - (unary) 13655 if (type) 13656 { 13657 const char* t = __parse_expression(first+2, last); 13658 if (t != first+2) 13659 { 13660 if (__make<__operator_negate>(__root_)) 13661 { 13662 *type = 1; 13663 first = t; 13664 } 13665 } 13666 } 13667 else 13668 { 13669 if (__make<__operator_negate>()) 13670 first += 2; 13671 } 13672 break; 13673 case 't': 13674 // ! 13675 if (type) 13676 { 13677 const char* t = __parse_expression(first+2, last); 13678 if (t != first+2) 13679 { 13680 if (__make<__operator_logical_not>(__root_)) 13681 { 13682 *type = 1; 13683 first = t; 13684 } 13685 } 13686 } 13687 else 13688 { 13689 if (__make<__operator_logical_not>()) 13690 first += 2; 13691 } 13692 break; 13693 case 'w': 13694 // new 13695 if (__make<__operator_new>()) 13696 { 13697 first += 2; 13698 if (type) 13699 *type = -1; 13700 } 13701 break; 13702 } 13703 break; 13704 case 'o': 13705 switch (first[1]) 13706 { 13707 case 'o': 13708 // || 13709 if (type) 13710 { 13711 const char* t = __parse_expression(first+2, last); 13712 if (t != first+2) 13713 { 13714 __node* op1 = __root_; 13715 const char* t2 = __parse_expression(t, last); 13716 if (t != t2) 13717 { 13718 if (__make<__operator_logical_or>(op1, __root_)) 13719 { 13720 *type = 2; 13721 first = t2; 13722 } 13723 } 13724 } 13725 } 13726 else 13727 { 13728 if (__make<__operator_logical_or>()) 13729 first += 2; 13730 } 13731 break; 13732 case 'r': 13733 // | 13734 if (type) 13735 { 13736 const char* t = __parse_expression(first+2, last); 13737 if (t != first+2) 13738 { 13739 __node* op1 = __root_; 13740 const char* t2 = __parse_expression(t, last); 13741 if (t != t2) 13742 { 13743 if (__make<__operator_bit_or>(op1, __root_)) 13744 { 13745 *type = 2; 13746 first = t2; 13747 } 13748 } 13749 } 13750 } 13751 else 13752 { 13753 if (__make<__operator_bit_or>()) 13754 first += 2; 13755 } 13756 break; 13757 case 'R': 13758 // |= 13759 if (type) 13760 { 13761 const char* t = __parse_expression(first+2, last); 13762 if (t != first+2) 13763 { 13764 __node* op1 = __root_; 13765 const char* t2 = __parse_expression(t, last); 13766 if (t != t2) 13767 { 13768 if (__make<__operator_or_equal>(op1, __root_)) 13769 { 13770 *type = 2; 13771 first = t2; 13772 } 13773 } 13774 } 13775 } 13776 else 13777 { 13778 if (__make<__operator_or_equal>()) 13779 first += 2; 13780 } 13781 break; 13782 } 13783 break; 13784 case 'p': 13785 switch (first[1]) 13786 { 13787 case 'm': 13788 // ->* 13789 if (type) 13790 { 13791 const char* t = __parse_expression(first+2, last); 13792 if (t != first+2) 13793 { 13794 __node* op1 = __root_; 13795 const char* t2 = __parse_expression(t, last); 13796 if (t != t2) 13797 { 13798 if (__make<__operator_pointer_to_member>(op1, __root_)) 13799 { 13800 *type = 2; 13801 first = t2; 13802 } 13803 } 13804 } 13805 } 13806 else 13807 { 13808 if (__make<__operator_pointer_to_member>()) 13809 first += 2; 13810 } 13811 break; 13812 case 'l': 13813 // + 13814 if (type) 13815 { 13816 const char* t = __parse_expression(first+2, last); 13817 if (t != first+2) 13818 { 13819 __node* op1 = __root_; 13820 const char* t2 = __parse_expression(t, last); 13821 if (t != t2) 13822 { 13823 if (__make<__operator_plus>(op1, __root_)) 13824 { 13825 *type = 2; 13826 first = t2; 13827 } 13828 } 13829 } 13830 } 13831 else 13832 { 13833 if (__make<__operator_plus>()) 13834 first += 2; 13835 } 13836 break; 13837 case 'L': 13838 // += 13839 if (type) 13840 { 13841 const char* t = __parse_expression(first+2, last); 13842 if (t != first+2) 13843 { 13844 __node* op1 = __root_; 13845 const char* t2 = __parse_expression(t, last); 13846 if (t != t2) 13847 { 13848 if (__make<__operator_plus_equal>(op1, __root_)) 13849 { 13850 *type = 2; 13851 first = t2; 13852 } 13853 } 13854 } 13855 } 13856 else 13857 { 13858 if (__make<__operator_plus_equal>()) 13859 first += 2; 13860 } 13861 break; 13862 case 'p': 13863 // ++ (postfix in <expression> context) 13864 if (type) 13865 { 13866 const char* t = __parse_expression(first+2, last); 13867 if (t != first+2) 13868 { 13869 if (__make<__operator_increment>(false, __root_)) 13870 { 13871 *type = 1; 13872 first = t; 13873 } 13874 } 13875 } 13876 else 13877 { 13878 if (__make<__operator_increment>()) 13879 first += 2; 13880 } 13881 break; 13882 case 's': 13883 // + (unary) 13884 if (type) 13885 { 13886 const char* t = __parse_expression(first+2, last); 13887 if (t != first+2) 13888 { 13889 if (__make<__operator_unary_plus>(__root_)) 13890 { 13891 *type = 1; 13892 first = t; 13893 } 13894 } 13895 } 13896 else 13897 { 13898 if (__make<__operator_unary_plus>()) 13899 first += 2; 13900 } 13901 break; 13902 case 't': 13903 // -> 13904 if (type) 13905 { 13906 const char* t = __parse_expression(first+2, last); 13907 if (t != first+2) 13908 { 13909 __node* op1 = __root_; 13910 const char* t2 = __parse_expression(t, last); 13911 if (t != t2) 13912 { 13913 if (__make<__operator_arrow>(op1, __root_)) 13914 { 13915 *type = 2; 13916 first = t2; 13917 } 13918 } 13919 } 13920 } 13921 else 13922 { 13923 if (__make<__operator_arrow>()) 13924 first += 2; 13925 } 13926 break; 13927 } 13928 break; 13929 case 'q': 13930 // ? 13931 if (first[1] == 'u') 13932 { 13933 if (type) 13934 { 13935 const char* t = __parse_expression(first+2, last); 13936 if (t != first+2) 13937 { 13938 __node* op1 = __root_; 13939 const char* t2 = __parse_expression(t, last); 13940 if (t != t2) 13941 { 13942 __node* op2 = __root_; 13943 const char* t3 = __parse_expression(t2, last); 13944 if (t3 != t2) 13945 { 13946 if (__make<__operator_conditional>(op1, op2, __root_)) 13947 { 13948 *type = 3; 13949 first = t3; 13950 } 13951 } 13952 } 13953 } 13954 } 13955 else 13956 { 13957 if (__make<__operator_conditional>()) 13958 first += 2; 13959 } 13960 } 13961 break; 13962 case 'r': 13963 switch (first[1]) 13964 { 13965 case 'm': 13966 // % 13967 if (type) 13968 { 13969 const char* t = __parse_expression(first+2, last); 13970 if (t != first+2) 13971 { 13972 __node* op1 = __root_; 13973 const char* t2 = __parse_expression(t, last); 13974 if (t != t2) 13975 { 13976 if (__make<__operator_mod>(op1, __root_)) 13977 { 13978 *type = 2; 13979 first = t2; 13980 } 13981 } 13982 } 13983 } 13984 else 13985 { 13986 if (__make<__operator_mod>()) 13987 first += 2; 13988 } 13989 break; 13990 case 'M': 13991 // %= 13992 if (type) 13993 { 13994 const char* t = __parse_expression(first+2, last); 13995 if (t != first+2) 13996 { 13997 __node* op1 = __root_; 13998 const char* t2 = __parse_expression(t, last); 13999 if (t != t2) 14000 { 14001 if (__make<__operator_mod_equal>(op1, __root_)) 14002 { 14003 *type = 2; 14004 first = t2; 14005 } 14006 } 14007 } 14008 } 14009 else 14010 { 14011 if (__make<__operator_mod_equal>()) 14012 first += 2; 14013 } 14014 break; 14015 case 's': 14016 // >> 14017 if (type) 14018 { 14019 const char* t = __parse_expression(first+2, last); 14020 if (t != first+2) 14021 { 14022 __node* op1 = __root_; 14023 const char* t2 = __parse_expression(t, last); 14024 if (t != t2) 14025 { 14026 if (__make<__operator_right_shift>(op1, __root_)) 14027 { 14028 *type = 2; 14029 first = t2; 14030 } 14031 } 14032 } 14033 } 14034 else 14035 { 14036 if (__make<__operator_right_shift>()) 14037 first += 2; 14038 } 14039 break; 14040 case 'S': 14041 // >>= 14042 if (type) 14043 { 14044 const char* t = __parse_expression(first+2, last); 14045 if (t != first+2) 14046 { 14047 __node* op1 = __root_; 14048 const char* t2 = __parse_expression(t, last); 14049 if (t != t2) 14050 { 14051 if (__make<__operator_right_shift_equal>(op1, __root_)) 14052 { 14053 *type = 2; 14054 first = t2; 14055 } 14056 } 14057 } 14058 } 14059 else 14060 { 14061 if (__make<__operator_right_shift_equal>()) 14062 first += 2; 14063 } 14064 break; 14065 } 14066 break; 14067 case 's': 14068 switch (first[1]) 14069 { 14070 case 't': 14071 // sizeof (a type) 14072 if (type) 14073 { 14074 const char* t = __parse_expression(first+2, last); 14075 if (t != first+2) 14076 { 14077 if (__make<__operator_sizeof_type>(__root_)) 14078 { 14079 *type = -1; 14080 first = t; 14081 } 14082 } 14083 } 14084 else 14085 { 14086 if (__make<__operator_sizeof_type>()) 14087 first += 2; 14088 } 14089 break; 14090 case 'z': 14091 // sizeof (an expression) 14092 if (type) 14093 { 14094 const char* t = __parse_expression(first+2, last); 14095 if (t != first+2) 14096 { 14097 if (__make<__operator_sizeof_expression>(__root_)) 14098 { 14099 *type = -1; 14100 first = t; 14101 } 14102 } 14103 } 14104 else 14105 { 14106 if (__make<__operator_sizeof_expression>()) 14107 first += 2; 14108 } 14109 break; 14110 } 14111 break; 14112 } 14113 } 14114 return first; 14115} 14116 14117// <source-name> ::= <positive length number> <identifier> 14118 14119const char* 14120__demangle_tree::__parse_source_name(const char* first, const char* last) 14121{ 14122 if (first != last) 14123 { 14124 char c = *first; 14125 if ('1' <= c && c <= '9' && first+1 != last) 14126 { 14127 const char* t = first+1; 14128 size_t n = c - '0'; 14129 for (c = *t; '0' <= c && c <= '9'; c = *t) 14130 { 14131 n = n * 10 + c - '0'; 14132 if (++t == last) 14133 return first; 14134 } 14135 if (last - t >= n && __make<__source_name>(t, n)) 14136 first = t + n; 14137 } 14138 } 14139 return first; 14140} 14141 14142// <unqualified-name> ::= <operator-name> 14143// ::= <ctor-dtor-name> 14144// ::= <source-name> 14145// ::= <unnamed-type-name> 14146 14147const char* 14148__demangle_tree::__parse_unqualified_name(const char* first, const char* last) 14149{ 14150 const char* t = __parse_source_name(first, last); 14151 if (t == first) 14152 { 14153 t = __parse_ctor_dtor_name(first, last); 14154 if (t == first) 14155 { 14156 t = __parse_operator_name(first, last); 14157 if (t == first) 14158 first = __parse_unnamed_type_name(first, last); 14159 else 14160 first = t; 14161 } 14162 else 14163 first = t; 14164 } 14165 else 14166 first = t; 14167 return first; 14168} 14169 14170// <unscoped-name> ::= <unqualified-name> 14171// ::= St <unqualified-name> # ::std:: 14172// extension ::= StL<unqualified-name> 14173 14174const char* 14175__demangle_tree::__parse_unscoped_name(const char* first, const char* last) 14176{ 14177 if (last - first >= 2) 14178 { 14179 const char* t0 = first; 14180 if (first[0] == 'S' && first[1] == 't') 14181 { 14182 t0 += 2; 14183 if (t0 != last && *t0 == 'L') 14184 ++t0; 14185 } 14186 const char* t1 = __parse_unqualified_name(t0, last); 14187 if (t1 != t0) 14188 { 14189 if (t0 != first) 14190 { 14191 __node* name = __root_; 14192 if (__make<__std_qualified_name>()) 14193 { 14194 if (__make<__nested_delimeter>(__root_, name)) 14195 first = t1; 14196 } 14197 } 14198 else 14199 first = t1; 14200 } 14201 } 14202 return first; 14203} 14204 14205// <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E 14206// ::= N [<CV-qualifiers>] <template-prefix> <template-args> E 14207// 14208// <prefix> ::= <prefix> <unqualified-name> 14209// ::= <template-prefix> <template-args> 14210// ::= <template-param> 14211// ::= <decltype> 14212// ::= # empty 14213// ::= <substitution> 14214// ::= <prefix> <data-member-prefix> 14215// extension ::= L 14216// 14217// <template-prefix> ::= <prefix> <template unqualified-name> 14218// ::= <template-param> 14219// ::= <substitution> 14220 14221const char* 14222__demangle_tree::__parse_nested_name(const char* first, const char* last) 14223{ 14224 if (first != last && *first == 'N') 14225 { 14226 unsigned cv = 0; 14227 const char* t0 = __parse_cv_qualifiers(first+1, last, cv, true); 14228 __node* prev = NULL; 14229 if (last - t0 >= 2 && t0[0] == 'S' && t0[1] == 't') 14230 { 14231 t0 += 2; 14232 if (!__make<__std_qualified_name>()) 14233 return first; 14234 prev = __root_; 14235 } 14236 while (t0 != last) 14237 { 14238 bool can_sub = true; 14239 bool make_nested = true; 14240 const char* t1; 14241 switch (*t0) 14242 { 14243 case '1': 14244 case '2': 14245 case '3': 14246 case '4': 14247 case '5': 14248 case '6': 14249 case '7': 14250 case '8': 14251 case '9': 14252 t1 = __parse_source_name(t0, last); 14253 if (t1 == t0 || t1 == last) 14254 return first; 14255 if (*t1 == 'M') 14256 { 14257 // This is a data-member-prefix 14258 ++t1; 14259 } 14260 else if (*t1 == 'I') 14261 { 14262 // has following <template-args> 14263 if (prev) 14264 { 14265 if (!__make<__nested_delimeter>(prev, __root_)) 14266 return first; 14267 make_nested = false; 14268 } 14269 if (__sub_end_ == __sub_cap_) 14270 { 14271 __status_ = memory_alloc_failure; 14272 return first; 14273 } 14274 else 14275 *__sub_end_++ = __root_; 14276 const char* t2 = __parse_template_args(t1, last); 14277 if (t2 == t1) 14278 return first; 14279 t1 = t2; 14280 } 14281 break; 14282 case 'D': 14283 if (t0+1 != last && (t0[1] == 't' || t0[1] == 'T')) 14284 { 14285 t1 = __parse_decltype(t0, last); 14286 break; 14287 } 14288 // check for Dt, DT here, else drop through 14289 case 'C': 14290 t1 = __parse_ctor_dtor_name(t0, last); 14291 if (t1 == t0 || t1 == last) 14292 return first; 14293 if (*t1 == 'I') 14294 { 14295 // has following <template-args> 14296 if (prev) 14297 { 14298 if (!__make<__nested_delimeter>(prev, __root_)) 14299 return first; 14300 make_nested = false; 14301 } 14302 if (__sub_end_ == __sub_cap_) 14303 { 14304 __status_ = memory_alloc_failure; 14305 return first; 14306 } 14307 else 14308 *__sub_end_++ = __root_; 14309 const char* t2 = __parse_template_args(t1, last); 14310 if (t2 == t1) 14311 return first; 14312 t1 = t2; 14313 } 14314 break; 14315 case 'U': 14316 assert(!"__parse_nested_name U"); 14317 // could have following <template-args> 14318 break; 14319 case 'T': 14320 t1 = __parse_template_param(t0, last); 14321 if (t1 == t0 || t1 == last) 14322 return first; 14323 if (*t1 == 'I') 14324 { 14325 // has following <template-args> 14326 if (prev) 14327 { 14328 if (!__make<__nested_delimeter>(prev, __root_)) 14329 return first; 14330 make_nested = false; 14331 } 14332 if (__sub_end_ == __sub_cap_) 14333 { 14334 __status_ = memory_alloc_failure; 14335 return first; 14336 } 14337 else 14338 *__sub_end_++ = __root_; 14339 const char* t2 = __parse_template_args(t1, last); 14340 if (t2 == t1) 14341 return first; 14342 t1 = t2; 14343 } 14344 break; 14345 case 'S': 14346 t1 = __parse_substitution(t0, last); 14347 if (t1 == t0 || t1 == last) 14348 return first; 14349 if (*t1 == 'I') 14350 { 14351 const char* t2 = __parse_template_args(t1, last); 14352 if (t2 == t1) 14353 return first; 14354 t1 = t2; 14355 } 14356 else 14357 can_sub = false; 14358 break; 14359 case 'L': 14360 // extension: ignore L here 14361 ++t0; 14362 continue; 14363 default: 14364 t1 = __parse_operator_name(t0, last); 14365 if (t1 == t0 || t1 == last) 14366 return first; 14367 if (*t1 == 'I') 14368 { 14369 // has following <template-args> 14370 if (prev) 14371 { 14372 if (!__make<__nested_delimeter>(prev, __root_)) 14373 return first; 14374 make_nested = false; 14375 } 14376 if (__sub_end_ == __sub_cap_) 14377 { 14378 __status_ = memory_alloc_failure; 14379 return first; 14380 } 14381 else 14382 *__sub_end_++ = __root_; 14383 const char* t2 = __parse_template_args(t1, last); 14384 if (t2 == t1) 14385 return first; 14386 t1 = t2; 14387 } 14388 break; 14389 } 14390 if (t1 == t0 || t1 == last) 14391 return first; 14392 if (prev && make_nested) 14393 { 14394 if (!__make<__nested_delimeter>(prev, __root_)) 14395 return first; 14396 can_sub = true; 14397 } 14398 if (can_sub && *t1 != 'E') 14399 { 14400 if (__sub_end_ == __sub_cap_) 14401 { 14402 __status_ = memory_alloc_failure; 14403 return first; 14404 } 14405 else 14406 *__sub_end_++ = __root_; 14407 } 14408 if (*t1 == 'E') 14409 { 14410 if (cv != 0) 14411 { 14412 if (!__make<__cv_qualifiers>(cv, __root_)) 14413 return first; 14414 } 14415 first = t1+1; 14416 break; 14417 } 14418 prev = __root_; 14419 t0 = t1; 14420 } 14421 } 14422 return first; 14423} 14424 14425// <template-arg> ::= <type> # type or template 14426// ::= X <expression> E # expression 14427// ::= <expr-primary> # simple expressions 14428// ::= J <template-arg>* E # argument pack 14429// ::= LZ <encoding> E # extension 14430 14431const char* 14432__demangle_tree::__parse_template_arg(const char* first, const char* last) 14433{ 14434 if (first != last) 14435 { 14436 const char* t; 14437 switch (*first) 14438 { 14439 case 'X': 14440 t = __parse_expression(first+1, last); 14441 if (t != first+1) 14442 { 14443 if (t != last && *t == 'E') 14444 first = t+1; 14445 } 14446 break; 14447 case 'J': 14448 t = first+1; 14449 if (t == last) 14450 return first; 14451 if (*t == 'E') 14452 { 14453 if (__make<__list>((__node*)0)) 14454 first = t+1; 14455 } 14456 else 14457 { 14458 __node* list = NULL; 14459 __node* prev = NULL; 14460 do 14461 { 14462 const char* t2 = __parse_template_arg(t, last); 14463 if (t2 == t || !__make<__list>(__root_)) 14464 return first; 14465 if (list == 0) 14466 list = __root_; 14467 if (prev) 14468 { 14469 prev->__right_ = __root_; 14470 __root_->__size_ = prev->__size_ + 1; 14471 } 14472 prev = __root_; 14473 t = t2; 14474 } while (t != last && *t != 'E'); 14475 first = t+1; 14476 __root_ = list; 14477 } 14478 break; 14479 case 'L': 14480 // <expr-primary> or LZ <encoding> E 14481 if (first+1 != last && first[1] == 'Z') 14482 { 14483 t = __parse_encoding(first+2, last); 14484 if (t != first+2 && t != last && *t == 'E') 14485 first = t+1; 14486 } 14487 else 14488 first = __parse_expr_primary(first, last); 14489 break; 14490 default: 14491 // <type> 14492 first = __parse_type(first, last); 14493 break; 14494 } 14495 } 14496 return first; 14497} 14498 14499// <template-args> ::= I <template-arg>* E 14500// extension, the abi says <template-arg>+ 14501 14502const char* 14503__demangle_tree::__parse_template_args(const char* first, const char* last) 14504{ 14505 if (last - first >= 2 && *first == 'I') 14506 { 14507 __node* args = NULL; 14508 __node* prev = NULL; 14509 __node* name = __root_; 14510 bool prev_tag_templates = __tag_templates_; 14511 __tag_templates_ = false; 14512 if (prev_tag_templates) 14513 __t_end_ = __t_begin_; 14514 const char* t = first+1; 14515 while (*t != 'E') 14516 { 14517 const char* t2 = __parse_template_arg(t, last); 14518 if (t2 == t || t2 == last) 14519 break; 14520 if (!__make<__list>(__root_)) 14521 return first; 14522 if (args == 0) 14523 args = __root_; 14524 if (prev) 14525 { 14526 prev->__right_ = __root_; 14527 __root_->__size_ = prev->__size_ + 1; 14528 } 14529 prev = __root_; 14530 if (prev_tag_templates) 14531 { 14532 if (__t_end_ == __t_cap_) 14533 { 14534 __status_ = memory_alloc_failure; 14535 return first; 14536 } 14537 if (__root_->__left_) 14538 *__t_end_++ = __root_->__left_; 14539 else 14540 *__t_end_++ = __root_; 14541 } 14542 t = t2; 14543 } 14544 if (t != last && *t == 'E') 14545 { 14546 if (__make<__template_args>(name, args)) 14547 first = t+1; 14548 } 14549 __tag_templates_ = prev_tag_templates; 14550 } 14551 return first; 14552} 14553 14554// <substitution> ::= S <seq-id> _ 14555// ::= S_ 14556// <substitution> ::= Sa # ::std::allocator 14557// <substitution> ::= Sb # ::std::basic_string 14558// <substitution> ::= Ss # ::std::basic_string < char, 14559// ::std::char_traits<char>, 14560// ::std::allocator<char> > 14561// <substitution> ::= Si # ::std::basic_istream<char, std::char_traits<char> > 14562// <substitution> ::= So # ::std::basic_ostream<char, std::char_traits<char> > 14563// <substitution> ::= Sd # ::std::basic_iostream<char, std::char_traits<char> > 14564 14565const char* 14566__demangle_tree::__parse_substitution(const char* first, const char* last) 14567{ 14568 if (last - first >= 2) 14569 { 14570 if (*first == 'S') 14571 { 14572 switch (first[1]) 14573 { 14574 case 'a': 14575 if (__make<__sub_allocator>()) 14576 first += 2; 14577 break; 14578 case 'b': 14579 if (__make<__sub_basic_string>()) 14580 first += 2; 14581 break; 14582 case 's': 14583 if (__make<__sub_string>()) 14584 first += 2; 14585 break; 14586 case 'i': 14587 if (__make<__sub_istream>()) 14588 first += 2; 14589 break; 14590 case 'o': 14591 if (__make<__sub_ostream>()) 14592 first += 2; 14593 break; 14594 case 'd': 14595 if (__make<__sub_iostream>()) 14596 first += 2; 14597 break; 14598 case '_': 14599 if (__sub_begin_ != __sub_end_) 14600 { 14601 if (__make<__sub>(*__sub_begin_)) 14602 first += 2; 14603 } 14604 break; 14605 default: 14606 if (isdigit(first[1]) || isupper(first[1])) 14607 { 14608 size_t sub = 0; 14609 const char* t = first+1; 14610 if (isdigit(*t)) 14611 sub = *t - '0'; 14612 else 14613 sub = *t - 'A' + 10; 14614 for (++t; t != last && (isdigit(*t) || isupper(*t)); ++t) 14615 { 14616 sub *= 36; 14617 if (isdigit(*t)) 14618 sub += *t - '0'; 14619 else 14620 sub += *t - 'A' + 10; 14621 } 14622 if (t == last || *t != '_') 14623 return first; 14624 ++sub; 14625 if (sub < __sub_end_ - __sub_begin_) 14626 { 14627 if (__make<__sub>(__sub_begin_[sub])) 14628 first = t+1; 14629 } 14630 } 14631 break; 14632 } 14633 } 14634 } 14635 return first; 14636} 14637 14638// <name> ::= <nested-name> 14639// ::= <local-name> # See Scope Encoding below 14640// ::= <unscoped-template-name> <template-args> 14641// ::= <unscoped-name> 14642 14643const char* 14644__demangle_tree::__parse_name(const char* first, const char* last) 14645{ 14646 if (first != last) 14647 { 14648 const char* t0 = first; 14649 // extension: ignore L here 14650 if (*t0 == 'L') 14651 ++t0; 14652 const char* t = __parse_nested_name(t0, last); 14653 if (t == t0) 14654 { 14655 t = __parse_local_name(t0, last); 14656 if (t == t0) 14657 { 14658 // not <nested-name> nor <local-name> 14659 // Try to parse <unscoped-template-name> <template-args> or 14660 // <unscoped-name> which are nearly ambiguous. 14661 // This logic occurs nowhere else. 14662 if (last - t0 >= 2) 14663 { 14664 if (t0[0] == 'S' && (t0[1] == '_' || 14665 isdigit(t0[1]) || 14666 isupper(t0[1]) || 14667 t0[1] == 'a' || 14668 t0[1] == 'b')) 14669 { 14670 t = __parse_substitution(t0, last); 14671 if (t != t0) 14672 { 14673 const char* t2 = __parse_template_args(t, last); 14674 if (t2 != t) 14675 first = t2; 14676 } 14677 } 14678 else // Not a substitution, except maybe St 14679 { 14680 t = __parse_unscoped_name(t0, last); 14681 if (t != t0) 14682 { 14683 // unscoped-name might be <unscoped-template-name> 14684 if (t != last && *t == 'I') 14685 { 14686 if (__sub_end_ == __sub_cap_) 14687 { 14688 __status_ = memory_alloc_failure; 14689 return first; 14690 } 14691 *__sub_end_++ = __root_; 14692 const char* t2 = __parse_template_args(t, last); 14693 if (t2 != t) 14694 first = t2; 14695 } 14696 else 14697 { 14698 // <unscoped-name> 14699 first = t; 14700 } 14701 } 14702 } 14703 } 14704 } 14705 else 14706 first = t; 14707 } 14708 else 14709 first = t; 14710 } 14711 return first; 14712} 14713 14714// extension 14715// <dot-suffix> := .<anything and everything> 14716 14717const char* 14718__demangle_tree::__parse_dot_suffix(const char* first, const char* last) 14719{ 14720 if (first != last && *first == '.') 14721 { 14722 if (__make<__dot_suffix>(__root_, first, last-first)) 14723 first = last; 14724 } 14725 return first; 14726} 14727 14728// <encoding> ::= <function name> <bare-function-type> 14729// ::= <data name> 14730// ::= <special-name> 14731 14732const char* 14733__demangle_tree::__parse_encoding(const char* first, const char* last) 14734{ 14735 const char* t = __parse_name(first, last); 14736 if (t != first) 14737 { 14738 if (t != last && *t != 'E' && *t != '.') 14739 { 14740 __node* name = __root_; 14741 bool has_return = name->ends_with_template() && 14742 !name->is_ctor_dtor_conv(); 14743 __node* ret = NULL; 14744 const char* t2; 14745 __tag_templates_ = false; 14746 if (has_return) 14747 { 14748 t2 = __parse_type(t, last); 14749 if (t2 != t) 14750 { 14751 ret = __root_; 14752 t = t2; 14753 } 14754 else 14755 return first; 14756 } 14757 t2 = __parse_bare_function_type(t, last); 14758 if (t2 != t) 14759 { 14760 if (dynamic_cast<__void*>(__root_->__left_) != NULL) 14761 __root_->__left_ = NULL; 14762 if (__make<__function_signature>(ret, __root_)) 14763 { 14764 __node* cv = name->extract_cv(name); 14765 if (__make<__function>(name, __root_)) 14766 { 14767 if (cv) 14768 { 14769 cv->__left_ = __root_; 14770 cv->__size_ <<= 5; 14771 __root_ = cv; 14772 } 14773 first = t2; 14774 } 14775 } 14776 } 14777 __tag_templates_ = true; 14778 } 14779 else 14780 first = t; 14781 } 14782 else 14783 first = __parse_special_name(first, last); 14784 return first; 14785} 14786 14787// <mangled-name> ::= _Z<encoding> 14788// ::= <type> 14789 14790void 14791__demangle_tree::__parse() 14792{ 14793 if (__mangled_name_begin_ == __mangled_name_end_) 14794 { 14795 __status_ = invalid_mangled_name; 14796 return; 14797 } 14798 const char* t = NULL; 14799 if (__mangled_name_end_ - __mangled_name_begin_ >= 2 && 14800 __mangled_name_begin_[0] == '_' && 14801 __mangled_name_begin_[1] == 'Z') 14802 { 14803 t = __parse_encoding(__mangled_name_begin_+2, __mangled_name_end_); 14804 if (t != __mangled_name_begin_+2 && t != __mangled_name_end_ && *t == '.') 14805 t = __parse_dot_suffix(t, __mangled_name_end_); 14806 } 14807 else 14808 t = __parse_type(__mangled_name_begin_, __mangled_name_end_); 14809 if (t == __mangled_name_end_ && __root_) 14810 { 14811 if (__fix_forward_references_) 14812 { 14813 if (__root_->fix_forward_references(__t_begin_, __t_end_)) 14814 __status_ = success; 14815 } 14816 else 14817 __status_ = success; 14818 } 14819} 14820 14821#pragma GCC visibility pop 14822#pragma GCC visibility push(default) 14823 14824__demangle_tree 14825__demangle(const char* mangled_name, char* buf, size_t bs) 14826{ 14827 __demangle_tree t(mangled_name, buf, bs); 14828 if (t.__status() == invalid_mangled_name) 14829 t.__parse(); 14830 return t; 14831} 14832 14833__demangle_tree 14834__demangle(const char* mangled_name) 14835{ 14836 return __demangle(mangled_name, 0, 0); 14837} 14838 14839char* 14840__demangle(__demangle_tree dmg_tree, char* buf, size_t* n, int* status) 14841{ 14842 if (dmg_tree.__status() != success) 14843 { 14844 if (status) 14845 *status = dmg_tree.__status(); 14846 return NULL; 14847 } 14848#ifdef DEBUGGING 14849display(dmg_tree.__root_); 14850printf("\n"); 14851#endif 14852 const size_t bs = buf == NULL ? 0 : *n; 14853#if 0 14854 const unsigned N = 1024; 14855 char tmp[N]; 14856 char* f; 14857 char* l; 14858 if (bs < N) 14859 { 14860 f = tmp; 14861 l = f + N; 14862 } 14863 else 14864 { 14865 f = buf; 14866 l = f + bs; 14867 } 14868 const ptrdiff_t sz = dmg_tree.__root_->print(f, l-1); 14869 if (sz > l-f-1) 14870 { 14871 buf = static_cast<char*>(realloc(buf, sz+1)); 14872 if (buf == NULL) 14873 { 14874 if (status) 14875 *status = memory_alloc_failure; 14876 return NULL; 14877 } 14878 if (n) 14879 *n = sz+1; 14880 dmg_tree.__root_->print(buf, buf+sz); 14881 buf[sz] = '\0'; 14882 goto end; 14883 } 14884 f[sz] = '\0'; 14885 if (f != buf) 14886 { 14887 if (bs < sz+1) 14888 { 14889 buf = static_cast<char*>(realloc(buf, sz+1)); 14890 if (buf == NULL) 14891 { 14892 if (status) 14893 *status = memory_alloc_failure; 14894 return NULL; 14895 } 14896 if (n) 14897 *n = sz+1; 14898 } 14899 strncpy(buf, f, sz+1); 14900 } 14901#else 14902 ptrdiff_t sm = dmg_tree.__mangled_name_end_ - dmg_tree.__mangled_name_begin_; 14903 ptrdiff_t est = sm + 50 * (dmg_tree.__node_end_ - dmg_tree.__node_begin_); 14904 const unsigned N = 4096; 14905 char tmp[N]; 14906 ptrdiff_t s; 14907 if (est <= bs) 14908 { 14909 char* e = dmg_tree.__get_demangled_name(buf); 14910 *e++ = '\0'; 14911 s = e - buf; 14912 } 14913 else if (est <= N) 14914 { 14915 char* e = dmg_tree.__get_demangled_name(tmp); 14916 *e++ = '\0'; 14917 s = e - tmp; 14918 } 14919 else 14920 s = dmg_tree.size() + 1; 14921 if (s > bs) 14922 { 14923 buf = static_cast<char*>(realloc(buf, s)); 14924 if (buf == NULL) 14925 { 14926 if (status) 14927 *status = memory_alloc_failure; 14928 return NULL; 14929 } 14930 if (n) 14931 *n = s; 14932 } 14933 if (est > bs) 14934 { 14935 if (est <= N) 14936 strncpy(buf, tmp, s); 14937 else 14938 *dmg_tree.__get_demangled_name(buf) = '\0'; 14939 } 14940#endif 14941end: 14942 if (status) 14943 *status = success; 14944 return buf; 14945} 14946 14947} // __libcxxabi 14948 14949extern "C" 14950{ 14951 14952char* 14953__cxa_demangle(const char* mangled_name, char* buf, size_t* n, int* status) 14954{ 14955 if (mangled_name == NULL || (buf != NULL && n == NULL)) 14956 { 14957 if (status) 14958 *status = __libcxxabi::invalid_args; 14959 return NULL; 14960 } 14961 const size_t bs = 64 * 1024; 14962 char static_buf[bs]; 14963 14964 buf = __libcxxabi::__demangle(__libcxxabi::__demangle(mangled_name, 14965 static_buf, bs), 14966 buf, n, status); 14967 return buf; 14968} 14969 14970} // extern "C" 14971 14972} // abi 14973