libelftc_dem_gnu2.c (302408) | libelftc_dem_gnu2.c (317623) |
---|---|
1/*- 2 * Copyright (c) 2008 Hyogeol Lee <hyogeollee@gmail.com> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright --- 23 unchanged lines hidden (view full) --- 32#include <limits.h> 33#include <stdbool.h> 34#include <stdio.h> 35#include <stdlib.h> 36#include <string.h> 37 38#include "_libelftc.h" 39 | 1/*- 2 * Copyright (c) 2008 Hyogeol Lee <hyogeollee@gmail.com> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright --- 23 unchanged lines hidden (view full) --- 32#include <limits.h> 33#include <stdbool.h> 34#include <stdio.h> 35#include <stdlib.h> 36#include <string.h> 37 38#include "_libelftc.h" 39 |
40ELFTC_VCSID("$Id: libelftc_dem_gnu2.c 3447 2016-05-03 13:32:23Z emaste $"); | 40ELFTC_VCSID("$Id: libelftc_dem_gnu2.c 3513 2016-12-29 07:04:22Z kaiwang27 $"); |
41 42/** 43 * @file cpp_demangle_gnu2.c 44 * @brief Decode function name encoding in GNU 2. 45 * 46 * Function name encoding in GNU 2 based on ARM style. 47 */ 48 --- 12 unchanged lines hidden (view full) --- 61 struct cstring array_str; 62 const char *p; 63 enum encode_type type; 64 struct vector_str vec; 65 struct vector_str arg; 66}; 67 68#define SIMPLE_HASH(x,y) (64 * x + y) | 41 42/** 43 * @file cpp_demangle_gnu2.c 44 * @brief Decode function name encoding in GNU 2. 45 * 46 * Function name encoding in GNU 2 based on ARM style. 47 */ 48 --- 12 unchanged lines hidden (view full) --- 61 struct cstring array_str; 62 const char *p; 63 enum encode_type type; 64 struct vector_str vec; 65 struct vector_str arg; 66}; 67 68#define SIMPLE_HASH(x,y) (64 * x + y) |
69#define VEC_PUSH_STR(d,s) vector_str_push((d), (s), strlen((s))) |
|
69#define CPP_DEMANGLE_GNU2_TRY 128 70 71static void dest_cstring(struct cstring *); 72static void dest_demangle_data(struct demangle_data *); 73static bool init_cstring(struct cstring *, size_t); 74static bool init_demangle_data(struct demangle_data *); 75static bool push_CTDT(const char *, size_t, struct vector_str *); 76static bool read_array(struct demangle_data *); --- 44 unchanged lines hidden (view full) --- 121 if (push_CTDT("::", 2, &d.vec) == false) 122 goto clean; 123 124 break; 125 case ENCODE_OP_DT : 126 if (push_CTDT("::~", 3, &d.vec) == false) 127 goto clean; 128 | 70#define CPP_DEMANGLE_GNU2_TRY 128 71 72static void dest_cstring(struct cstring *); 73static void dest_demangle_data(struct demangle_data *); 74static bool init_cstring(struct cstring *, size_t); 75static bool init_demangle_data(struct demangle_data *); 76static bool push_CTDT(const char *, size_t, struct vector_str *); 77static bool read_array(struct demangle_data *); --- 44 unchanged lines hidden (view full) --- 122 if (push_CTDT("::", 2, &d.vec) == false) 123 goto clean; 124 125 break; 126 case ENCODE_OP_DT : 127 if (push_CTDT("::~", 3, &d.vec) == false) 128 goto clean; 129 |
129 if (vector_str_push(&d.vec, "(void)", 6) == false) | 130 if (VEC_PUSH_STR(&d.vec, "(void)") == false) |
130 goto clean; 131 132 goto flat; 133 case ENCODE_OP_USER : 134 case ENCODE_OP_TF : 135 case ENCODE_OP_TI : 136 case ENCODE_OP_VT : 137 goto flat; 138 } 139 140 if (*d.p == 'F') 141 ++d.p; 142 else if (*d.p == '\0') { 143 if (d.class_name == true) { | 131 goto clean; 132 133 goto flat; 134 case ENCODE_OP_USER : 135 case ENCODE_OP_TF : 136 case ENCODE_OP_TI : 137 case ENCODE_OP_VT : 138 goto flat; 139 } 140 141 if (*d.p == 'F') 142 ++d.p; 143 else if (*d.p == '\0') { 144 if (d.class_name == true) { |
144 if (vector_str_push(&d.vec, "(void)", 6) == false) | 145 if (VEC_PUSH_STR(&d.vec, "(void)") == false) |
145 goto clean; 146 147 goto flat; 148 } else 149 goto clean; 150 } 151 152 /* start argument types */ | 146 goto clean; 147 148 goto flat; 149 } else 150 goto clean; 151 } 152 153 /* start argument types */ |
153 if (vector_str_push(&d.vec, "(", 1) == false) | 154 if (VEC_PUSH_STR(&d.vec, "(") == false) |
154 goto clean; 155 156 for (;;) { 157 if (*d.p == 'T') { 158 const int rtn_subst = read_subst(&d); 159 160 if (rtn_subst == -1) 161 goto clean; --- 15 unchanged lines hidden (view full) --- 177 } 178 179 arg_begin = d.vec.size; 180 181 if (read_type(&d) == false) 182 goto clean; 183 184 if (d.ptr == true) { | 155 goto clean; 156 157 for (;;) { 158 if (*d.p == 'T') { 159 const int rtn_subst = read_subst(&d); 160 161 if (rtn_subst == -1) 162 goto clean; --- 15 unchanged lines hidden (view full) --- 178 } 179 180 arg_begin = d.vec.size; 181 182 if (read_type(&d) == false) 183 goto clean; 184 185 if (d.ptr == true) { |
185 if (vector_str_push(&d.vec, "*", 1) == false) | 186 if (VEC_PUSH_STR(&d.vec, "*") == false) |
186 goto clean; 187 188 d.ptr = false; 189 } 190 191 if (d.ref == true) { | 187 goto clean; 188 189 d.ptr = false; 190 } 191 192 if (d.ref == true) { |
192 if (vector_str_push(&d.vec, "&", 1) == false) | 193 if (VEC_PUSH_STR(&d.vec, "&") == false) |
193 goto clean; 194 195 d.ref = false; 196 } 197 198 if (d.cnst == true) { | 194 goto clean; 195 196 d.ref = false; 197 } 198 199 if (d.cnst == true) { |
199 if (vector_str_push(&d.vec, " const", 6) == false) | 200 if (VEC_PUSH_STR(&d.vec, " const") == false) |
200 goto clean; 201 202 d.cnst = false; 203 } 204 205 if (d.array == true) { 206 if (vector_str_push(&d.vec, d.array_str.buf, 207 d.array_str.size) == false) --- 10 unchanged lines hidden (view full) --- 218 &arg_len)) == NULL) 219 goto clean; 220 221 if (vector_str_push(&d.arg, arg, arg_len) == false) 222 goto clean; 223 224 free(arg); 225 | 201 goto clean; 202 203 d.cnst = false; 204 } 205 206 if (d.array == true) { 207 if (vector_str_push(&d.vec, d.array_str.buf, 208 d.array_str.size) == false) --- 10 unchanged lines hidden (view full) --- 219 &arg_len)) == NULL) 220 goto clean; 221 222 if (vector_str_push(&d.arg, arg, arg_len) == false) 223 goto clean; 224 225 free(arg); 226 |
226 if (vector_str_push(&d.vec, ", ", 2) == false) | 227 if (VEC_PUSH_STR(&d.vec, ", ") == false) |
227 goto clean; 228 229 if (++try > CPP_DEMANGLE_GNU2_TRY) 230 goto clean; 231 } 232 233 /* end argument types */ | 228 goto clean; 229 230 if (++try > CPP_DEMANGLE_GNU2_TRY) 231 goto clean; 232 } 233 234 /* end argument types */ |
234 if (vector_str_push(&d.vec, ")", 1) == false) | 235 if (VEC_PUSH_STR(&d.vec, ")") == false) |
235 goto clean; 236flat: | 236 goto clean; 237flat: |
237 if (d.cnst_fn == true && vector_str_push(&d.vec, " const", 6) == false) | 238 if (d.cnst_fn == true && VEC_PUSH_STR(&d.vec, " const") == false) |
238 goto clean; 239 240 rtn = vector_str_get_flat(&d.vec, NULL); 241clean: 242 dest_demangle_data(&d); 243 244 return (rtn); 245} --- 159 unchanged lines hidden (view full) --- 405 if (s == NULL || l == 0 || v == NULL) 406 return (false); 407 408 if (vector_str_push(v, s, l) == false) 409 return (false); 410 411 assert(v->size > 1); 412 | 239 goto clean; 240 241 rtn = vector_str_get_flat(&d.vec, NULL); 242clean: 243 dest_demangle_data(&d); 244 245 return (rtn); 246} --- 159 unchanged lines hidden (view full) --- 406 if (s == NULL || l == 0 || v == NULL) 407 return (false); 408 409 if (vector_str_push(v, s, l) == false) 410 return (false); 411 412 assert(v->size > 1); 413 |
413 return (vector_str_push(v, v->container[v->size - 2], 414 strlen(v->container[v->size - 2]))); | 414 return (VEC_PUSH_STR(v, v->container[v->size - 2])); |
415} 416 417static bool 418read_array(struct demangle_data *d) 419{ 420 size_t len; 421 const char *end; 422 --- 90 unchanged lines hidden (view full) --- 513 ++d->p; 514 515 if (read_qual_name(d) == false) 516 return (false); 517 } else if (ELFTC_ISDIGIT(*d->p)) { 518 if (read_class(d) == false) 519 return (false); 520 | 415} 416 417static bool 418read_array(struct demangle_data *d) 419{ 420 size_t len; 421 const char *end; 422 --- 90 unchanged lines hidden (view full) --- 513 ++d->p; 514 515 if (read_qual_name(d) == false) 516 return (false); 517 } else if (ELFTC_ISDIGIT(*d->p)) { 518 if (read_class(d) == false) 519 return (false); 520 |
521 if (vector_str_push(&d->vec, "::", 2) == false) | 521 if (VEC_PUSH_STR(&d->vec, "::") == false) |
522 return (false); 523 } 524 525 return (vector_str_push(&d->vec, name, len)); 526} 527 528static bool 529read_func_name(struct demangle_data *d) --- 28 unchanged lines hidden (view full) --- 558 return (read_class(d)); 559 } 560 561 d->type = ENCODE_OP; 562 if (read_op(d) == false) { 563 /* not good condition, start function name with '__' */ 564 d->type = ENCODE_FUNC; 565 | 522 return (false); 523 } 524 525 return (vector_str_push(&d->vec, name, len)); 526} 527 528static bool 529read_func_name(struct demangle_data *d) --- 28 unchanged lines hidden (view full) --- 558 return (read_class(d)); 559 } 560 561 d->type = ENCODE_OP; 562 if (read_op(d) == false) { 563 /* not good condition, start function name with '__' */ 564 d->type = ENCODE_FUNC; 565 |
566 if (vector_str_push(&d->vec, "__", 2) == false) | 566 if (VEC_PUSH_STR(&d->vec, "__") == false) |
567 return (false); 568 569 return (read_func(d)); 570 } 571 572 if (d->type == ENCODE_OP_USER || 573 d->type == ENCODE_OP_TF || 574 d->type == ENCODE_OP_TI) --- 21 unchanged lines hidden (view full) --- 596 597 snprintf(op_name, len + 1, "%s", 598 d->vec.container[d->vec.size - 1]); 599 vector_str_pop(&d->vec); 600 601 if (read_qual_name(d) == false) 602 goto clean; 603 | 567 return (false); 568 569 return (read_func(d)); 570 } 571 572 if (d->type == ENCODE_OP_USER || 573 d->type == ENCODE_OP_TF || 574 d->type == ENCODE_OP_TI) --- 21 unchanged lines hidden (view full) --- 596 597 snprintf(op_name, len + 1, "%s", 598 d->vec.container[d->vec.size - 1]); 599 vector_str_pop(&d->vec); 600 601 if (read_qual_name(d) == false) 602 goto clean; 603 |
604 if (vector_str_push(&d->vec, "::", 2) == false) | 604 if (VEC_PUSH_STR(&d->vec, "::") == false) |
605 goto clean; 606 607 if (vector_str_push(&d->vec, op_name, len) == false) 608 goto clean; 609 610 rtn = true; 611 } else if (ELFTC_ISDIGIT(*d->p)) { 612 assert(d->vec.size > 0); --- 5 unchanged lines hidden (view full) --- 618 619 snprintf(op_name, len + 1, "%s", 620 d->vec.container[d->vec.size - 1]); 621 vector_str_pop(&d->vec); 622 623 if (read_class(d) == false) 624 goto clean; 625 | 605 goto clean; 606 607 if (vector_str_push(&d->vec, op_name, len) == false) 608 goto clean; 609 610 rtn = true; 611 } else if (ELFTC_ISDIGIT(*d->p)) { 612 assert(d->vec.size > 0); --- 5 unchanged lines hidden (view full) --- 618 619 snprintf(op_name, len + 1, "%s", 620 d->vec.container[d->vec.size - 1]); 621 vector_str_pop(&d->vec); 622 623 if (read_class(d) == false) 624 goto clean; 625 |
626 if (vector_str_push(&d->vec, "::", 2) == false) | 626 if (VEC_PUSH_STR(&d->vec, "::") == false) |
627 goto clean; 628 629 if (vector_str_push(&d->vec, op_name, len) == false) 630 goto clean; 631 632 rtn = true; 633 } 634 } else if (memcmp(d->p, "_$_", 3) == 0) { --- 25 unchanged lines hidden (view full) --- 660 661 if (vector_str_pop(&d->vec) == false) 662 return (false); 663 } else if (ELFTC_ISDIGIT(*d->p)) { 664 if (read_class(d) == false) 665 return (false); 666 } 667 | 627 goto clean; 628 629 if (vector_str_push(&d->vec, op_name, len) == false) 630 goto clean; 631 632 rtn = true; 633 } 634 } else if (memcmp(d->p, "_$_", 3) == 0) { --- 25 unchanged lines hidden (view full) --- 660 661 if (vector_str_pop(&d->vec) == false) 662 return (false); 663 } else if (ELFTC_ISDIGIT(*d->p)) { 664 if (read_class(d) == false) 665 return (false); 666 } 667 |
668 return (vector_str_push(&d->vec, " virtual table", 14)); | 668 return (VEC_PUSH_STR(&d->vec, " virtual table")); |
669 } else 670 return (read_func(d)); 671clean: 672 free(op_name); 673 674 return (rtn); 675} 676 --- 20 unchanged lines hidden (view full) --- 697 for (;;) { 698 if (read_type(&fptr) == false) { 699 dest_demangle_data(&fptr); 700 701 return (false); 702 } 703 704 if (fptr.ptr == true) { | 669 } else 670 return (read_func(d)); 671clean: 672 free(op_name); 673 674 return (rtn); 675} 676 --- 20 unchanged lines hidden (view full) --- 697 for (;;) { 698 if (read_type(&fptr) == false) { 699 dest_demangle_data(&fptr); 700 701 return (false); 702 } 703 704 if (fptr.ptr == true) { |
705 if (vector_str_push(&fptr.vec, "*", 1) == false) { | 705 if (VEC_PUSH_STR(&fptr.vec, "*") == false) { |
706 dest_demangle_data(&fptr); 707 708 return (false); 709 } 710 711 fptr.ptr = false; 712 } 713 714 if (fptr.ref == true) { | 706 dest_demangle_data(&fptr); 707 708 return (false); 709 } 710 711 fptr.ptr = false; 712 } 713 714 if (fptr.ref == true) { |
715 if (vector_str_push(&fptr.vec, "&", 1) == false) { | 715 if (VEC_PUSH_STR(&fptr.vec, "&") == false) { |
716 dest_demangle_data(&fptr); 717 718 return (false); 719 } 720 721 fptr.ref = false; 722 } 723 724 if (fptr.cnst == true) { | 716 dest_demangle_data(&fptr); 717 718 return (false); 719 } 720 721 fptr.ref = false; 722 } 723 724 if (fptr.cnst == true) { |
725 if (vector_str_push(&fptr.vec, " const", 6) == false) { | 725 if (VEC_PUSH_STR(&fptr.vec, " const") == false) { |
726 dest_demangle_data(&fptr); 727 728 return (false); 729 } 730 731 fptr.cnst = false; 732 } 733 734 if (*fptr.p == '_') 735 break; 736 | 726 dest_demangle_data(&fptr); 727 728 return (false); 729 } 730 731 fptr.cnst = false; 732 } 733 734 if (*fptr.p == '_') 735 break; 736 |
737 if (vector_str_push(&fptr.vec, ", ", 2) == false) { | 737 if (VEC_PUSH_STR(&fptr.vec, ", ") == false) { |
738 dest_demangle_data(&fptr); 739 740 return (false); 741 } 742 743 if (++lim > CPP_DEMANGLE_GNU2_TRY) { 744 745 dest_demangle_data(&fptr); --- 34 unchanged lines hidden (view full) --- 780 free(rtn_type); 781 free(arg_type); 782 783 return (false); 784 } 785 786 free(rtn_type); 787 | 738 dest_demangle_data(&fptr); 739 740 return (false); 741 } 742 743 if (++lim > CPP_DEMANGLE_GNU2_TRY) { 744 745 dest_demangle_data(&fptr); --- 34 unchanged lines hidden (view full) --- 780 free(rtn_type); 781 free(arg_type); 782 783 return (false); 784 } 785 786 free(rtn_type); 787 |
788 if (vector_str_push(&d->vec, " (*)(", 5) == false) { | 788 if (VEC_PUSH_STR(&d->vec, " (*)(") == false) { |
789 free(arg_type); 790 791 return (false); 792 } 793 794 if (vector_str_push(&d->vec, arg_type, arg_len) == false) { 795 free(arg_type); 796 797 return (false); 798 } 799 800 free(arg_type); 801 | 789 free(arg_type); 790 791 return (false); 792 } 793 794 if (vector_str_push(&d->vec, arg_type, arg_len) == false) { 795 free(arg_type); 796 797 return (false); 798 } 799 800 free(arg_type); 801 |
802 return (vector_str_push(&d->vec, ")", 1)); | 802 return (VEC_PUSH_STR(&d->vec, ")")); |
803} 804 805static bool 806read_memptr(struct demangle_data *d) 807{ 808 struct demangle_data mptr; 809 size_t len; 810 bool rtn; --- 20 unchanged lines hidden (view full) --- 831 d->p = mptr.p; 832 833 if ((mptr_str = vector_str_get_flat(&mptr.vec, &len)) == NULL) 834 goto clean; 835 836 if (vector_str_push(&d->vec, mptr_str, len) == false) 837 goto clean; 838 | 803} 804 805static bool 806read_memptr(struct demangle_data *d) 807{ 808 struct demangle_data mptr; 809 size_t len; 810 bool rtn; --- 20 unchanged lines hidden (view full) --- 831 d->p = mptr.p; 832 833 if ((mptr_str = vector_str_get_flat(&mptr.vec, &len)) == NULL) 834 goto clean; 835 836 if (vector_str_push(&d->vec, mptr_str, len) == false) 837 goto clean; 838 |
839 if (vector_str_push(&d->vec, "::*", 3) == false) | 839 if (VEC_PUSH_STR(&d->vec, "::*") == false) |
840 goto clean; 841 842 rtn = true; 843clean: 844 free(mptr_str); 845 dest_demangle_data(&mptr); 846 847 return (rtn); --- 6 unchanged lines hidden (view full) --- 854 if (d == NULL) 855 return (false); 856 857 assert(d->p != NULL && "d->p (org str) is NULL"); 858 859 switch (SIMPLE_HASH(*(d->p), *(d->p+1))) { 860 case SIMPLE_HASH('m', 'l') : 861 d->p += 2; | 840 goto clean; 841 842 rtn = true; 843clean: 844 free(mptr_str); 845 dest_demangle_data(&mptr); 846 847 return (rtn); --- 6 unchanged lines hidden (view full) --- 854 if (d == NULL) 855 return (false); 856 857 assert(d->p != NULL && "d->p (org str) is NULL"); 858 859 switch (SIMPLE_HASH(*(d->p), *(d->p+1))) { 860 case SIMPLE_HASH('m', 'l') : 861 d->p += 2; |
862 return (vector_str_push(&d->vec, "operator*", 9)); | 862 return (VEC_PUSH_STR(&d->vec, "operator*")); |
863 case SIMPLE_HASH('d', 'v') : 864 d->p += 2; | 863 case SIMPLE_HASH('d', 'v') : 864 d->p += 2; |
865 return (vector_str_push(&d->vec, "operator/", 9)); | 865 return (VEC_PUSH_STR(&d->vec, "operator/")); |
866 case SIMPLE_HASH('m', 'd') : 867 d->p += 2; | 866 case SIMPLE_HASH('m', 'd') : 867 d->p += 2; |
868 return (vector_str_push(&d->vec, "operator%", 9)); | 868 return (VEC_PUSH_STR(&d->vec, "operator%")); |
869 case SIMPLE_HASH('p', 'l') : 870 d->p += 2; | 869 case SIMPLE_HASH('p', 'l') : 870 d->p += 2; |
871 return (vector_str_push(&d->vec, "operator+", 9)); | 871 return (VEC_PUSH_STR(&d->vec, "operator+")); |
872 case SIMPLE_HASH('m', 'i') : 873 d->p += 2; | 872 case SIMPLE_HASH('m', 'i') : 873 d->p += 2; |
874 return (vector_str_push(&d->vec, "operator-", 9)); | 874 return (VEC_PUSH_STR(&d->vec, "operator-")); |
875 case SIMPLE_HASH('l', 's') : 876 d->p += 2; | 875 case SIMPLE_HASH('l', 's') : 876 d->p += 2; |
877 return (vector_str_push(&d->vec, "operator<<", 10)); | 877 return (VEC_PUSH_STR(&d->vec, "operator<<")); |
878 case SIMPLE_HASH('r', 's') : 879 d->p += 2; | 878 case SIMPLE_HASH('r', 's') : 879 d->p += 2; |
880 return (vector_str_push(&d->vec, "operator>>", 10)); | 880 return (VEC_PUSH_STR(&d->vec, "operator>>")); |
881 case SIMPLE_HASH('e', 'q') : 882 d->p += 2; | 881 case SIMPLE_HASH('e', 'q') : 882 d->p += 2; |
883 return (vector_str_push(&d->vec, "operator==", 10)); | 883 return (VEC_PUSH_STR(&d->vec, "operator==")); |
884 case SIMPLE_HASH('n', 'e') : 885 d->p += 2; | 884 case SIMPLE_HASH('n', 'e') : 885 d->p += 2; |
886 return (vector_str_push(&d->vec, "operator!=", 10)); | 886 return (VEC_PUSH_STR(&d->vec, "operator!=")); |
887 case SIMPLE_HASH('l', 't') : 888 d->p += 2; | 887 case SIMPLE_HASH('l', 't') : 888 d->p += 2; |
889 return (vector_str_push(&d->vec, "operator<", 9)); | 889 return (VEC_PUSH_STR(&d->vec, "operator<")); |
890 case SIMPLE_HASH('g', 't') : 891 d->p += 2; | 890 case SIMPLE_HASH('g', 't') : 891 d->p += 2; |
892 return (vector_str_push(&d->vec, "operator>", 9)); | 892 return (VEC_PUSH_STR(&d->vec, "operator>")); |
893 case SIMPLE_HASH('l', 'e') : 894 d->p += 2; | 893 case SIMPLE_HASH('l', 'e') : 894 d->p += 2; |
895 return (vector_str_push(&d->vec, "operator<=", 10)); | 895 return (VEC_PUSH_STR(&d->vec, "operator<=")); |
896 case SIMPLE_HASH('g', 'e') : 897 d->p += 2; | 896 case SIMPLE_HASH('g', 'e') : 897 d->p += 2; |
898 return (vector_str_push(&d->vec, "operator>=", 10)); | 898 return (VEC_PUSH_STR(&d->vec, "operator>=")); |
899 case SIMPLE_HASH('a', 'd') : 900 d->p += 2; 901 if (*d->p == 'v') { 902 ++d->p; | 899 case SIMPLE_HASH('a', 'd') : 900 d->p += 2; 901 if (*d->p == 'v') { 902 ++d->p; |
903 return (vector_str_push(&d->vec, "operator/=", 904 10)); | 903 return (VEC_PUSH_STR(&d->vec, "operator/=")); |
905 } else | 904 } else |
906 return (vector_str_push(&d->vec, "operator&", 9)); | 905 return (VEC_PUSH_STR(&d->vec, "operator&")); |
907 case SIMPLE_HASH('o', 'r') : 908 d->p += 2; | 906 case SIMPLE_HASH('o', 'r') : 907 d->p += 2; |
909 return (vector_str_push(&d->vec, "operator|", 9)); | 908 return (VEC_PUSH_STR(&d->vec, "operator|")); |
910 case SIMPLE_HASH('e', 'r') : 911 d->p += 2; | 909 case SIMPLE_HASH('e', 'r') : 910 d->p += 2; |
912 return (vector_str_push(&d->vec, "operator^", 9)); | 911 return (VEC_PUSH_STR(&d->vec, "operator^")); |
913 case SIMPLE_HASH('a', 'a') : 914 d->p += 2; 915 if (*d->p == 'd') { 916 ++d->p; | 912 case SIMPLE_HASH('a', 'a') : 913 d->p += 2; 914 if (*d->p == 'd') { 915 ++d->p; |
917 return (vector_str_push(&d->vec, "operator&=", 918 10)); | 916 return (VEC_PUSH_STR(&d->vec, "operator&=")); |
919 } else | 917 } else |
920 return (vector_str_push(&d->vec, "operator&&", 921 10)); | 918 return (VEC_PUSH_STR(&d->vec, "operator&&")); |
922 case SIMPLE_HASH('o', 'o') : 923 d->p += 2; | 919 case SIMPLE_HASH('o', 'o') : 920 d->p += 2; |
924 return (vector_str_push(&d->vec, "operator||", 10)); | 921 return (VEC_PUSH_STR(&d->vec, "operator||")); |
925 case SIMPLE_HASH('n', 't') : 926 d->p += 2; | 922 case SIMPLE_HASH('n', 't') : 923 d->p += 2; |
927 return (vector_str_push(&d->vec, "operator!", 9)); | 924 return (VEC_PUSH_STR(&d->vec, "operator!")); |
928 case SIMPLE_HASH('c', 'o') : 929 d->p += 2; | 925 case SIMPLE_HASH('c', 'o') : 926 d->p += 2; |
930 return (vector_str_push(&d->vec, "operator~", 9)); | 927 return (VEC_PUSH_STR(&d->vec, "operator~")); |
931 case SIMPLE_HASH('p', 'p') : 932 d->p += 2; | 928 case SIMPLE_HASH('p', 'p') : 929 d->p += 2; |
933 return (vector_str_push(&d->vec, "operator++", 10)); | 930 return (VEC_PUSH_STR(&d->vec, "operator++")); |
934 case SIMPLE_HASH('m', 'm') : 935 d->p += 2; | 931 case SIMPLE_HASH('m', 'm') : 932 d->p += 2; |
936 return (vector_str_push(&d->vec, "operator--", 10)); | 933 return (VEC_PUSH_STR(&d->vec, "operator--")); |
937 case SIMPLE_HASH('a', 's') : 938 d->p += 2; | 934 case SIMPLE_HASH('a', 's') : 935 d->p += 2; |
939 return (vector_str_push(&d->vec, "operator=", 9)); | 936 return (VEC_PUSH_STR(&d->vec, "operator=")); |
940 case SIMPLE_HASH('r', 'f') : 941 d->p += 2; | 937 case SIMPLE_HASH('r', 'f') : 938 d->p += 2; |
942 return (vector_str_push(&d->vec, "operator->", 10)); | 939 return (VEC_PUSH_STR(&d->vec, "operator->")); |
943 case SIMPLE_HASH('a', 'p') : 944 /* apl */ 945 if (*(d->p + 2) != 'l') 946 return (false); 947 948 d->p += 3; | 940 case SIMPLE_HASH('a', 'p') : 941 /* apl */ 942 if (*(d->p + 2) != 'l') 943 return (false); 944 945 d->p += 3; |
949 return (vector_str_push(&d->vec, "operator+=", 10)); | 946 return (VEC_PUSH_STR(&d->vec, "operator+=")); |
950 case SIMPLE_HASH('a', 'm') : 951 d->p += 2; 952 if (*d->p == 'i') { 953 ++d->p; | 947 case SIMPLE_HASH('a', 'm') : 948 d->p += 2; 949 if (*d->p == 'i') { 950 ++d->p; |
954 return (vector_str_push(&d->vec, "operator-=", 955 10)); | 951 return (VEC_PUSH_STR(&d->vec, "operator-=")); |
956 } else if (*d->p == 'u') { 957 ++d->p; | 952 } else if (*d->p == 'u') { 953 ++d->p; |
958 return (vector_str_push(&d->vec, "operator*=", 959 10)); | 954 return (VEC_PUSH_STR(&d->vec, "operator*=")); |
960 } else if (*d->p == 'd') { 961 ++d->p; | 955 } else if (*d->p == 'd') { 956 ++d->p; |
962 return (vector_str_push(&d->vec, "operator%=", 963 10)); | 957 return (VEC_PUSH_STR(&d->vec, "operator%=")); |
964 } 965 966 return (false); 967 case SIMPLE_HASH('a', 'l') : 968 /* als */ 969 if (*(d->p + 2) != 's') 970 return (false); 971 972 d->p += 3; | 958 } 959 960 return (false); 961 case SIMPLE_HASH('a', 'l') : 962 /* als */ 963 if (*(d->p + 2) != 's') 964 return (false); 965 966 d->p += 3; |
973 return (vector_str_push(&d->vec, "operator<<=", 11)); | 967 return (VEC_PUSH_STR(&d->vec, "operator<<=")); |
974 case SIMPLE_HASH('a', 'r') : 975 /* ars */ 976 if (*(d->p + 2) != 's') 977 return (false); 978 979 d->p += 3; | 968 case SIMPLE_HASH('a', 'r') : 969 /* ars */ 970 if (*(d->p + 2) != 's') 971 return (false); 972 973 d->p += 3; |
980 return (vector_str_push(&d->vec, "operator>>=", 11)); | 974 return (VEC_PUSH_STR(&d->vec, "operator>>=")); |
981 case SIMPLE_HASH('a', 'o') : 982 /* aor */ 983 if (*(d->p + 2) != 'r') 984 return (false); 985 986 d->p += 3; | 975 case SIMPLE_HASH('a', 'o') : 976 /* aor */ 977 if (*(d->p + 2) != 'r') 978 return (false); 979 980 d->p += 3; |
987 return (vector_str_push(&d->vec, "operator|=", 10)); | 981 return (VEC_PUSH_STR(&d->vec, "operator|=")); |
988 case SIMPLE_HASH('a', 'e') : 989 /* aer */ 990 if (*(d->p + 2) != 'r') 991 return (false); 992 993 d->p += 3; | 982 case SIMPLE_HASH('a', 'e') : 983 /* aer */ 984 if (*(d->p + 2) != 'r') 985 return (false); 986 987 d->p += 3; |
994 return (vector_str_push(&d->vec, "operator^=", 10)); | 988 return (VEC_PUSH_STR(&d->vec, "operator^=")); |
995 case SIMPLE_HASH('c', 'm') : 996 d->p += 2; | 989 case SIMPLE_HASH('c', 'm') : 990 d->p += 2; |
997 return (vector_str_push(&d->vec, "operator,", 9)); | 991 return (VEC_PUSH_STR(&d->vec, "operator,")); |
998 case SIMPLE_HASH('r', 'm') : 999 d->p += 2; | 992 case SIMPLE_HASH('r', 'm') : 993 d->p += 2; |
1000 return (vector_str_push(&d->vec, "operator->*", 11)); | 994 return (VEC_PUSH_STR(&d->vec, "operator->*")); |
1001 case SIMPLE_HASH('c', 'l') : 1002 d->p += 2; | 995 case SIMPLE_HASH('c', 'l') : 996 d->p += 2; |
1003 return (vector_str_push(&d->vec, "()", 2)); | 997 return (VEC_PUSH_STR(&d->vec, "()")); |
1004 case SIMPLE_HASH('v', 'c') : 1005 d->p += 2; | 998 case SIMPLE_HASH('v', 'c') : 999 d->p += 2; |
1006 return (vector_str_push(&d->vec, "[]", 2)); | 1000 return (VEC_PUSH_STR(&d->vec, "[]")); |
1007 case SIMPLE_HASH('n', 'w') : 1008 d->p += 2; | 1001 case SIMPLE_HASH('n', 'w') : 1002 d->p += 2; |
1009 return (vector_str_push(&d->vec, "operator new()", 14)); | 1003 return (VEC_PUSH_STR(&d->vec, "operator new()")); |
1010 case SIMPLE_HASH('d', 'l') : 1011 d->p += 2; | 1004 case SIMPLE_HASH('d', 'l') : 1005 d->p += 2; |
1012 return (vector_str_push(&d->vec, "operator delete()", 1013 17)); | 1006 return (VEC_PUSH_STR(&d->vec, "operator delete()")); |
1014 case SIMPLE_HASH('o', 'p') : 1015 /* __op<TO_TYPE>__<FROM_TYPE> */ 1016 d->p += 2; 1017 1018 d->type = ENCODE_OP_USER; 1019 1020 return (read_op_user(d)); 1021 case SIMPLE_HASH('t', 'f') : 1022 d->p += 2; 1023 d->type = ENCODE_OP_TF; 1024 1025 if (read_type(d) == false) 1026 return (false); 1027 | 1007 case SIMPLE_HASH('o', 'p') : 1008 /* __op<TO_TYPE>__<FROM_TYPE> */ 1009 d->p += 2; 1010 1011 d->type = ENCODE_OP_USER; 1012 1013 return (read_op_user(d)); 1014 case SIMPLE_HASH('t', 'f') : 1015 d->p += 2; 1016 d->type = ENCODE_OP_TF; 1017 1018 if (read_type(d) == false) 1019 return (false); 1020 |
1028 return (vector_str_push(&d->vec, " type_info function", 19)); | 1021 return (VEC_PUSH_STR(&d->vec, " type_info function")); |
1029 case SIMPLE_HASH('t', 'i') : 1030 d->p += 2; 1031 d->type = ENCODE_OP_TI; 1032 1033 if (read_type(d) == false) 1034 return (false); 1035 | 1022 case SIMPLE_HASH('t', 'i') : 1023 d->p += 2; 1024 d->type = ENCODE_OP_TI; 1025 1026 if (read_type(d) == false) 1027 return (false); 1028 |
1036 return (vector_str_push(&d->vec, " type_info node", 15)); | 1029 return (VEC_PUSH_STR(&d->vec, " type_info node")); |
1037 default : 1038 return (false); 1039 }; 1040} 1041 1042static bool 1043read_op_user(struct demangle_data *d) 1044{ --- 49 unchanged lines hidden (view full) --- 1094 goto clean; 1095 1096 if ((from_str = vector_str_get_flat(&from.vec, &from_len)) == NULL) 1097 goto clean; 1098 1099 if (vector_str_push(&d->vec, from_str, from_len) == false) 1100 goto clean; 1101 | 1030 default : 1031 return (false); 1032 }; 1033} 1034 1035static bool 1036read_op_user(struct demangle_data *d) 1037{ --- 49 unchanged lines hidden (view full) --- 1087 goto clean; 1088 1089 if ((from_str = vector_str_get_flat(&from.vec, &from_len)) == NULL) 1090 goto clean; 1091 1092 if (vector_str_push(&d->vec, from_str, from_len) == false) 1093 goto clean; 1094 |
1102 if (vector_str_push(&d->vec, "::operator ", 11) == false) | 1095 if (VEC_PUSH_STR(&d->vec, "::operator ") == false) |
1103 goto clean; 1104 1105 if (vector_str_push(&d->vec, to_str, to_len) == false) 1106 goto clean; 1107 | 1096 goto clean; 1097 1098 if (vector_str_push(&d->vec, to_str, to_len) == false) 1099 goto clean; 1100 |
1108 rtn = vector_str_push(&d->vec, "()", 2); | 1101 rtn = VEC_PUSH_STR(&d->vec, "()"); |
1109clean: 1110 free(to_str); 1111 free(from_str); 1112 dest_demangle_data(&to); 1113 dest_demangle_data(&from); 1114 1115 return (rtn); 1116} --- 15 unchanged lines hidden (view full) --- 1132 1133 assert(num > 0); 1134 1135 ++d->p; 1136 for (i = 0; i < num ; ++i) { 1137 if (read_class(d) == false) 1138 return (false); 1139 | 1102clean: 1103 free(to_str); 1104 free(from_str); 1105 dest_demangle_data(&to); 1106 dest_demangle_data(&from); 1107 1108 return (rtn); 1109} --- 15 unchanged lines hidden (view full) --- 1125 1126 assert(num > 0); 1127 1128 ++d->p; 1129 for (i = 0; i < num ; ++i) { 1130 if (read_class(d) == false) 1131 return (false); 1132 |
1140 if (vector_str_push(&d->vec, "::", 2) == false) | 1133 if (VEC_PUSH_STR(&d->vec, "::") == false) |
1141 return (false); 1142 } 1143 1144 if (*d->p != '\0') 1145 d->p = d->p + 2; 1146 1147 return (true); 1148} --- 12 unchanged lines hidden (view full) --- 1161 if (idx == 0 && (errno == EINVAL || errno == ERANGE)) 1162 return (-1); 1163 1164 assert(idx > 0); 1165 assert(str != NULL); 1166 1167 d->p = str; 1168 | 1134 return (false); 1135 } 1136 1137 if (*d->p != '\0') 1138 d->p = d->p + 2; 1139 1140 return (true); 1141} --- 12 unchanged lines hidden (view full) --- 1154 if (idx == 0 && (errno == EINVAL || errno == ERANGE)) 1155 return (-1); 1156 1157 assert(idx > 0); 1158 assert(str != NULL); 1159 1160 d->p = str; 1161 |
1169 if (vector_str_push(&d->vec, d->arg.container[idx - 1], 1170 strlen(d->arg.container[idx - 1])) == false) | 1162 if (VEC_PUSH_STR(&d->vec, d->arg.container[idx - 1]) == false) |
1171 return (-1); 1172 | 1163 return (-1); 1164 |
1173 if (vector_str_push(&d->arg, d->arg.container[idx - 1], 1174 strlen(d->arg.container[idx - 1])) == false) | 1165 if (VEC_PUSH_STR(&d->arg, d->arg.container[idx - 1]) == false) |
1175 return (-1); 1176 1177 if (*d->p == '\0') 1178 return (1); 1179 1180 return (0); 1181} 1182 --- 22 unchanged lines hidden (view full) --- 1205 return (-1); 1206 1207 assert(idx > 0); 1208 assert(str != NULL); 1209 1210 d->p = str; 1211 1212 for (i = 0; i < repeat ; ++i) { | 1166 return (-1); 1167 1168 if (*d->p == '\0') 1169 return (1); 1170 1171 return (0); 1172} 1173 --- 22 unchanged lines hidden (view full) --- 1196 return (-1); 1197 1198 assert(idx > 0); 1199 assert(str != NULL); 1200 1201 d->p = str; 1202 1203 for (i = 0; i < repeat ; ++i) { |
1213 if (vector_str_push(&d->vec, d->arg.container[idx - 1], 1214 strlen(d->arg.container[idx - 1])) == false) | 1204 if (VEC_PUSH_STR(&d->vec, d->arg.container[idx - 1]) == false) |
1215 return (-1); 1216 | 1205 return (-1); 1206 |
1217 if (vector_str_push(&d->arg, d->arg.container[idx - 1], 1218 strlen(d->arg.container[idx - 1])) == false) | 1207 if (VEC_PUSH_STR(&d->arg, d->arg.container[idx - 1]) == false) |
1219 return (-1); 1220 1221 if (i != repeat - 1 && | 1208 return (-1); 1209 1210 if (i != repeat - 1 && |
1222 vector_str_push(&d->vec, ", ", 2) == false) | 1211 VEC_PUSH_STR(&d->vec, ", ") == false) |
1223 return (-1); 1224 } 1225 1226 if (*d->p == '\0') 1227 return (1); 1228 1229 return (0); 1230} --- 9 unchanged lines hidden (view full) --- 1240 1241 while (*d->p == 'U' || *d->p == 'C' || *d->p == 'V' || *d->p == 'S' || 1242 *d->p == 'P' || *d->p == 'R' || *d->p == 'A' || *d->p == 'F' || 1243 *d->p == 'M') { 1244 switch (*d->p) { 1245 case 'U' : 1246 ++d->p; 1247 | 1212 return (-1); 1213 } 1214 1215 if (*d->p == '\0') 1216 return (1); 1217 1218 return (0); 1219} --- 9 unchanged lines hidden (view full) --- 1229 1230 while (*d->p == 'U' || *d->p == 'C' || *d->p == 'V' || *d->p == 'S' || 1231 *d->p == 'P' || *d->p == 'R' || *d->p == 'A' || *d->p == 'F' || 1232 *d->p == 'M') { 1233 switch (*d->p) { 1234 case 'U' : 1235 ++d->p; 1236 |
1248 if (vector_str_push(&d->vec, "unsigned ", 9) == false) | 1237 if (VEC_PUSH_STR(&d->vec, "unsigned ") == false) |
1249 return (false); 1250 1251 break; 1252 case 'C' : 1253 ++d->p; 1254 1255 if (*d->p == 'P') 1256 d->cnst = true; 1257 else { | 1238 return (false); 1239 1240 break; 1241 case 'C' : 1242 ++d->p; 1243 1244 if (*d->p == 'P') 1245 d->cnst = true; 1246 else { |
1258 if (vector_str_push(&d->vec, "const ", 6) == | 1247 if (VEC_PUSH_STR(&d->vec, "const ") == |
1259 false) 1260 return (false); 1261 } 1262 1263 break; 1264 case 'V' : 1265 ++d->p; 1266 | 1248 false) 1249 return (false); 1250 } 1251 1252 break; 1253 case 'V' : 1254 ++d->p; 1255 |
1267 if (vector_str_push(&d->vec, "volatile ", 9) == false) | 1256 if (VEC_PUSH_STR(&d->vec, "volatile ") == false) |
1268 return (false); 1269 1270 break; 1271 case 'S' : 1272 ++d->p; 1273 | 1257 return (false); 1258 1259 break; 1260 case 'S' : 1261 ++d->p; 1262 |
1274 if (vector_str_push(&d->vec, "signed ", 7) == false) | 1263 if (VEC_PUSH_STR(&d->vec, "signed ") == false) |
1275 return (false); 1276 1277 break; 1278 case 'P' : 1279 ++d->p; 1280 1281 if (*d->p == 'F') 1282 return (read_func_ptr(d)); --- 34 unchanged lines hidden (view full) --- 1317 switch (*d->p) { 1318 case 'Q' : 1319 ++d->p; 1320 1321 return (read_qual_name(d)); 1322 case 'v' : 1323 ++d->p; 1324 | 1264 return (false); 1265 1266 break; 1267 case 'P' : 1268 ++d->p; 1269 1270 if (*d->p == 'F') 1271 return (read_func_ptr(d)); --- 34 unchanged lines hidden (view full) --- 1306 switch (*d->p) { 1307 case 'Q' : 1308 ++d->p; 1309 1310 return (read_qual_name(d)); 1311 case 'v' : 1312 ++d->p; 1313 |
1325 return (vector_str_push(&d->vec, "void", 4)); | 1314 return (VEC_PUSH_STR(&d->vec, "void")); |
1326 case 'b': 1327 ++d->p; 1328 | 1315 case 'b': 1316 ++d->p; 1317 |
1329 return(vector_str_push(&d->vec, "bool", 4)); | 1318 return(VEC_PUSH_STR(&d->vec, "bool")); |
1330 case 'c' : 1331 ++d->p; 1332 | 1319 case 'c' : 1320 ++d->p; 1321 |
1333 return (vector_str_push(&d->vec, "char", 4)); | 1322 return (VEC_PUSH_STR(&d->vec, "char")); |
1334 case 's' : 1335 ++d->p; 1336 | 1323 case 's' : 1324 ++d->p; 1325 |
1337 return (vector_str_push(&d->vec, "short", 5)); | 1326 return (VEC_PUSH_STR(&d->vec, "short")); |
1338 case 'i' : 1339 ++d->p; 1340 | 1327 case 'i' : 1328 ++d->p; 1329 |
1341 return (vector_str_push(&d->vec, "int", 3)); | 1330 return (VEC_PUSH_STR(&d->vec, "int")); |
1342 case 'l' : 1343 ++d->p; 1344 | 1331 case 'l' : 1332 ++d->p; 1333 |
1345 return (vector_str_push(&d->vec, "long", 4)); | 1334 return (VEC_PUSH_STR(&d->vec, "long")); |
1346 case 'f' : 1347 ++d->p; 1348 | 1335 case 'f' : 1336 ++d->p; 1337 |
1349 return (vector_str_push(&d->vec, "float", 5)); | 1338 return (VEC_PUSH_STR(&d->vec, "float")); |
1350 case 'd': 1351 ++d->p; 1352 | 1339 case 'd': 1340 ++d->p; 1341 |
1353 return (vector_str_push(&d->vec, "double", 6)); | 1342 return (VEC_PUSH_STR(&d->vec, "double")); |
1354 case 'r': 1355 ++d->p; 1356 | 1343 case 'r': 1344 ++d->p; 1345 |
1357 return (vector_str_push(&d->vec, "long double", 11)); | 1346 return (VEC_PUSH_STR(&d->vec, "long double")); |
1358 case 'e': 1359 ++d->p; 1360 | 1347 case 'e': 1348 ++d->p; 1349 |
1361 return (vector_str_push(&d->vec, "...", 3)); | 1350 return (VEC_PUSH_STR(&d->vec, "...")); |
1362 case 'w': 1363 ++d->p; 1364 | 1351 case 'w': 1352 ++d->p; 1353 |
1365 return (vector_str_push(&d->vec, "wchar_t", 7)); | 1354 return (VEC_PUSH_STR(&d->vec, "wchar_t")); |
1366 case 'x': 1367 ++d->p; 1368 | 1355 case 'x': 1356 ++d->p; 1357 |
1369 return (vector_str_push(&d->vec, "long long", 9)); | 1358 return (VEC_PUSH_STR(&d->vec, "long long")); |
1370 default: 1371 return (false); 1372 }; 1373 1374 /* NOTREACHED */ 1375 return (false); 1376} | 1359 default: 1360 return (false); 1361 }; 1362 1363 /* NOTREACHED */ 1364 return (false); 1365} |