2 * Copyright (c) 2007 Hyogeol Lee <hyogeollee@gmail.com>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer
10 * in this position and unchanged.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 #include <sys/types.h>
37 #include "_libelftc.h"
39 ELFTC_VCSID("$Id: libelftc_dem_gnu3.c 2179 2011-11-18 03:05:47Z jkoshy $");
42 * @file cpp_demangle.c
43 * @brief Decode IA-64 C++ ABI style implementation.
45 * IA-64 standard ABI(Itanium C++ ABI) references.
47 * http://www.codesourcery.com/cxx-abi/abi.html#mangling \n
48 * http://www.codesourcery.com/cxx-abi/abi-mangling.html
52 TYPE_PTR, TYPE_REF, TYPE_CMX, TYPE_IMG, TYPE_EXT, TYPE_RST, TYPE_VAT,
56 struct vector_type_qualifier {
57 size_t size, capacity;
58 enum type_qualifier *q_container;
59 struct vector_str ext_name;
63 READ_FAIL, READ_NEST, READ_TMPL, READ_EXPR, READ_EXPL, READ_LOCAL,
64 READ_TYPE, READ_FUNC, READ_PTRMEM
67 struct vector_read_cmd {
68 size_t size, capacity;
69 enum read_cmd *r_container;
72 struct cpp_demangle_data {
73 struct vector_str output; /* output string vector */
74 struct vector_str output_tmp;
75 struct vector_str subst; /* substitution string vector */
76 struct vector_str tmpl;
77 struct vector_str class_type;
78 struct vector_read_cmd cmd;
79 bool paren; /* parenthesis opened */
80 bool pfirst; /* first element of parameter */
81 bool mem_rst; /* restrict member function */
82 bool mem_vat; /* volatile member function */
83 bool mem_cst; /* const member function */
85 const char *cur; /* current mangled name ptr */
86 const char *last_sname; /* last source name */
89 #define CPP_DEMANGLE_TRY_LIMIT 128
90 #define FLOAT_SPRINTF_TRY_LIMIT 5
91 #define FLOAT_QUADRUPLE_BYTES 16
92 #define FLOAT_EXTENED_BYTES 10
94 #define SIMPLE_HASH(x,y) (64 * x + y)
96 static void cpp_demangle_data_dest(struct cpp_demangle_data *);
97 static int cpp_demangle_data_init(struct cpp_demangle_data *,
99 static int cpp_demangle_get_subst(struct cpp_demangle_data *, size_t);
100 static int cpp_demangle_get_tmpl_param(struct cpp_demangle_data *, size_t);
101 static int cpp_demangle_push_fp(struct cpp_demangle_data *,
102 char *(*)(const char *, size_t));
103 static int cpp_demangle_push_str(struct cpp_demangle_data *, const char *,
105 static int cpp_demangle_push_subst(struct cpp_demangle_data *,
106 const char *, size_t);
107 static int cpp_demangle_push_subst_v(struct cpp_demangle_data *,
108 struct vector_str *);
109 static int cpp_demangle_push_type_qualifier(struct cpp_demangle_data *,
110 struct vector_type_qualifier *, const char *);
111 static int cpp_demangle_read_array(struct cpp_demangle_data *);
112 static int cpp_demangle_read_encoding(struct cpp_demangle_data *);
113 static int cpp_demangle_read_expr_primary(struct cpp_demangle_data *);
114 static int cpp_demangle_read_expression(struct cpp_demangle_data *);
115 static int cpp_demangle_read_expression_binary(struct cpp_demangle_data *,
116 const char *, size_t);
117 static int cpp_demangle_read_expression_unary(struct cpp_demangle_data *,
118 const char *, size_t);
119 static int cpp_demangle_read_expression_trinary(struct cpp_demangle_data *,
120 const char *, size_t, const char *, size_t);
121 static int cpp_demangle_read_function(struct cpp_demangle_data *, int *,
122 struct vector_type_qualifier *);
123 static int cpp_demangle_local_source_name(struct cpp_demangle_data *ddata);
124 static int cpp_demangle_read_local_name(struct cpp_demangle_data *);
125 static int cpp_demangle_read_name(struct cpp_demangle_data *);
126 static int cpp_demangle_read_nested_name(struct cpp_demangle_data *);
127 static int cpp_demangle_read_number(struct cpp_demangle_data *, long *);
128 static int cpp_demangle_read_nv_offset(struct cpp_demangle_data *);
129 static int cpp_demangle_read_offset(struct cpp_demangle_data *);
130 static int cpp_demangle_read_offset_number(struct cpp_demangle_data *);
131 static int cpp_demangle_read_pointer_to_member(struct cpp_demangle_data *);
132 static int cpp_demangle_read_sname(struct cpp_demangle_data *);
133 static int cpp_demangle_read_subst(struct cpp_demangle_data *);
134 static int cpp_demangle_read_subst_std(struct cpp_demangle_data *);
135 static int cpp_demangle_read_subst_stdtmpl(struct cpp_demangle_data *,
136 const char *, size_t);
137 static int cpp_demangle_read_tmpl_arg(struct cpp_demangle_data *);
138 static int cpp_demangle_read_tmpl_args(struct cpp_demangle_data *);
139 static int cpp_demangle_read_tmpl_param(struct cpp_demangle_data *);
140 static int cpp_demangle_read_type(struct cpp_demangle_data *, int);
141 static int cpp_demangle_read_uqname(struct cpp_demangle_data *);
142 static int cpp_demangle_read_v_offset(struct cpp_demangle_data *);
143 static char *decode_fp_to_double(const char *, size_t);
144 static char *decode_fp_to_float(const char *, size_t);
145 static char *decode_fp_to_float128(const char *, size_t);
146 static char *decode_fp_to_float80(const char *, size_t);
147 static char *decode_fp_to_long_double(const char *, size_t);
148 static int hex_to_dec(char);
149 static void vector_read_cmd_dest(struct vector_read_cmd *);
150 static int vector_read_cmd_find(struct vector_read_cmd *, enum read_cmd);
151 static int vector_read_cmd_init(struct vector_read_cmd *);
152 static int vector_read_cmd_pop(struct vector_read_cmd *);
153 static int vector_read_cmd_push(struct vector_read_cmd *, enum read_cmd);
154 static void vector_type_qualifier_dest(struct vector_type_qualifier *);
155 static int vector_type_qualifier_init(struct vector_type_qualifier *);
156 static int vector_type_qualifier_push(struct vector_type_qualifier *,
157 enum type_qualifier);
159 static int cpp_demangle_gnu3_push_head;
162 * @brief Decode the input string by IA-64 C++ ABI style.
164 * GNU GCC v3 use IA-64 standard ABI.
165 * @return New allocated demangled string or NULL if failed.
166 * @todo 1. Testing and more test case. 2. Code cleaning.
169 cpp_demangle_gnu3(const char *org)
171 struct cpp_demangle_data ddata;
176 if (org == NULL || (org_len = strlen(org)) < 2)
179 if (org_len > 11 && !strncmp(org, "_GLOBAL__I_", 11)) {
180 if ((rtn = malloc(org_len + 19)) == NULL)
182 snprintf(rtn, org_len + 19,
183 "global constructors keyed to %s", org + 11);
187 if (org[0] != '_' || org[1] != 'Z')
190 if (!cpp_demangle_data_init(&ddata, org + 2))
193 cpp_demangle_gnu3_push_head = 0;
196 if (!cpp_demangle_read_encoding(&ddata))
200 while (*ddata.cur != '\0') {
202 * Breaking at some gcc info at tail. e.g) @@GLIBCXX_3.4
204 if (*ddata.cur == '@' && *(ddata.cur + 1) == '@')
206 if (!cpp_demangle_read_type(&ddata, 1))
208 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
212 if (ddata.output.size == 0)
214 if (ddata.paren && !vector_str_push(&ddata.output, ")", 1))
216 if (ddata.mem_vat && !vector_str_push(&ddata.output, " volatile", 9))
218 if (ddata.mem_cst && !vector_str_push(&ddata.output, " const", 6))
220 if (ddata.mem_rst && !vector_str_push(&ddata.output, " restrict", 9))
223 rtn = vector_str_get_flat(&ddata.output, (size_t *) NULL);
226 cpp_demangle_data_dest(&ddata);
232 cpp_demangle_data_dest(struct cpp_demangle_data *d)
238 vector_read_cmd_dest(&d->cmd);
239 vector_str_dest(&d->class_type);
240 vector_str_dest(&d->tmpl);
241 vector_str_dest(&d->subst);
242 vector_str_dest(&d->output_tmp);
243 vector_str_dest(&d->output);
247 cpp_demangle_data_init(struct cpp_demangle_data *d, const char *cur)
250 if (d == NULL || cur == NULL)
253 if (!vector_str_init(&d->output))
255 if (!vector_str_init(&d->output_tmp))
257 if (!vector_str_init(&d->subst))
259 if (!vector_str_init(&d->tmpl))
261 if (!vector_str_init(&d->class_type))
263 if (!vector_read_cmd_init(&d->cmd))
266 assert(d->output.container != NULL);
267 assert(d->output_tmp.container != NULL);
268 assert(d->subst.container != NULL);
269 assert(d->tmpl.container != NULL);
270 assert(d->class_type.container != NULL);
279 d->last_sname = NULL;
284 vector_str_dest(&d->class_type);
286 vector_str_dest(&d->tmpl);
288 vector_str_dest(&d->subst);
290 vector_str_dest(&d->output_tmp);
292 vector_str_dest(&d->output);
298 cpp_demangle_push_fp(struct cpp_demangle_data *ddata,
299 char *(*decoder)(const char *, size_t))
306 if (ddata == NULL || decoder == NULL)
310 while (*ddata->cur != 'E')
314 if ((f = decoder(fp, ddata->cur - fp)) == NULL)
318 if ((len = strlen(f)) > 0)
319 rtn = cpp_demangle_push_str(ddata, f, len);
327 cpp_demangle_push_str(struct cpp_demangle_data *ddata, const char *str,
331 if (ddata == NULL || str == NULL || len == 0)
334 if (cpp_demangle_gnu3_push_head > 0)
335 return (vector_str_push(&ddata->output_tmp, str, len));
337 return (vector_str_push(&ddata->output, str, len));
341 cpp_demangle_push_subst(struct cpp_demangle_data *ddata, const char *str,
345 if (ddata == NULL || str == NULL || len == 0)
348 if (!vector_str_find(&ddata->subst, str, len))
349 return (vector_str_push(&ddata->subst, str, len));
355 cpp_demangle_push_subst_v(struct cpp_demangle_data *ddata, struct vector_str *v)
361 if (ddata == NULL || v == NULL)
364 if ((str = vector_str_get_flat(v, &str_len)) == NULL)
367 rtn = cpp_demangle_push_subst(ddata, str, str_len);
375 cpp_demangle_push_type_qualifier(struct cpp_demangle_data *ddata,
376 struct vector_type_qualifier *v, const char *type_str)
378 struct vector_str subst_v;
379 size_t idx, e_idx, e_len;
383 if (ddata == NULL || v == NULL)
386 if ((idx = v->size) == 0)
390 if (type_str != NULL) {
391 if (!vector_str_init(&subst_v))
393 if (!vector_str_push(&subst_v, type_str, strlen(type_str)))
399 switch (v->q_container[idx - 1]) {
401 if (!cpp_demangle_push_str(ddata, "*", 1))
403 if (type_str != NULL) {
404 if (!vector_str_push(&subst_v, "*", 1))
406 if (!cpp_demangle_push_subst_v(ddata, &subst_v))
412 if (!cpp_demangle_push_str(ddata, "&", 1))
414 if (type_str != NULL) {
415 if (!vector_str_push(&subst_v, "&", 1))
417 if (!cpp_demangle_push_subst_v(ddata, &subst_v))
423 if (!cpp_demangle_push_str(ddata, " complex", 8))
425 if (type_str != NULL) {
426 if (!vector_str_push(&subst_v, " complex", 8))
428 if (!cpp_demangle_push_subst_v(ddata, &subst_v))
434 if (!cpp_demangle_push_str(ddata, " imaginary", 10))
436 if (type_str != NULL) {
437 if (!vector_str_push(&subst_v, " imaginary", 10))
439 if (!cpp_demangle_push_subst_v(ddata, &subst_v))
445 if (e_idx > v->ext_name.size - 1)
447 if ((e_len = strlen(v->ext_name.container[e_idx])) == 0)
449 if ((buf = malloc(sizeof(char) * (e_len + 1))) == NULL)
453 memcpy(buf + 1, v->ext_name.container[e_idx], e_len);
455 if (!cpp_demangle_push_str(ddata, buf, e_len + 1)) {
460 if (type_str != NULL) {
461 if (!vector_str_push(&subst_v, buf,
466 if (!cpp_demangle_push_subst_v(ddata, &subst_v)) {
476 if (!cpp_demangle_push_str(ddata, " restrict", 9))
478 if (type_str != NULL) {
479 if (!vector_str_push(&subst_v, " restrict", 9))
481 if (!cpp_demangle_push_subst_v(ddata, &subst_v))
487 if (!cpp_demangle_push_str(ddata, " volatile", 9))
489 if (type_str != NULL) {
490 if (!vector_str_push(&subst_v, " volatile", 9))
492 if (!cpp_demangle_push_subst_v(ddata, &subst_v))
498 if (!cpp_demangle_push_str(ddata, " const", 6))
500 if (type_str != NULL) {
501 if (!vector_str_push(&subst_v, " const", 6))
503 if (!cpp_demangle_push_subst_v(ddata, &subst_v))
514 if (type_str != NULL)
515 vector_str_dest(&subst_v);
521 cpp_demangle_get_subst(struct cpp_demangle_data *ddata, size_t idx)
525 if (ddata == NULL || ddata->subst.size <= idx)
527 if ((len = strlen(ddata->subst.container[idx])) == 0)
529 if (!cpp_demangle_push_str(ddata, ddata->subst.container[idx], len))
539 cpp_demangle_get_tmpl_param(struct cpp_demangle_data *ddata, size_t idx)
543 if (ddata == NULL || ddata->tmpl.size <= idx)
545 if ((len = strlen(ddata->tmpl.container[idx])) == 0)
547 if (!cpp_demangle_push_str(ddata, ddata->tmpl.container[idx], len))
556 cpp_demangle_read_array(struct cpp_demangle_data *ddata)
558 size_t i, num_len, exp_len, p_idx, idx;
562 if (ddata == NULL || *(++ddata->cur) == '\0')
565 if (*ddata->cur == '_') {
566 if (*(++ddata->cur) == '\0')
569 if (!cpp_demangle_read_type(ddata, 0))
572 if (!cpp_demangle_push_str(ddata, "[]", 2))
575 if (ELFTC_ISDIGIT(*ddata->cur) != 0) {
577 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
579 if (*ddata->cur != '_')
581 num_len = ddata->cur - num;
583 if (*(++ddata->cur) == '\0')
585 if (!cpp_demangle_read_type(ddata, 0))
587 if (!cpp_demangle_push_str(ddata, "[", 1))
589 if (!cpp_demangle_push_str(ddata, num, num_len))
591 if (!cpp_demangle_push_str(ddata, "]", 1))
594 p_idx = ddata->output.size;
595 if (!cpp_demangle_read_expression(ddata))
597 if ((exp = vector_str_substr(&ddata->output, p_idx,
598 ddata->output.size - 1, &exp_len)) == NULL)
600 idx = ddata->output.size;
601 for (i = p_idx; i < idx; ++i)
602 if (!vector_str_pop(&ddata->output)) {
606 if (*ddata->cur != '_') {
611 if (*ddata->cur == '\0') {
615 if (!cpp_demangle_read_type(ddata, 0)) {
619 if (!cpp_demangle_push_str(ddata, "[", 1)) {
623 if (!cpp_demangle_push_str(ddata, exp, exp_len)) {
627 if (!cpp_demangle_push_str(ddata, "]", 1)) {
639 cpp_demangle_read_expr_primary(struct cpp_demangle_data *ddata)
643 if (ddata == NULL || *(++ddata->cur) == '\0')
646 if (*ddata->cur == '_' && *(ddata->cur + 1) == 'Z') {
648 if (*ddata->cur == '\0')
650 if (!cpp_demangle_read_encoding(ddata))
656 switch (*ddata->cur) {
658 switch (*(++ddata->cur)) {
660 return (cpp_demangle_push_str(ddata, "false", 5));
662 return (cpp_demangle_push_str(ddata, "true", 4));
669 return (cpp_demangle_push_fp(ddata, decode_fp_to_double));
673 if (sizeof(long double) == 10)
674 return (cpp_demangle_push_fp(ddata,
675 decode_fp_to_double));
676 return (cpp_demangle_push_fp(ddata, decode_fp_to_float80));
680 return (cpp_demangle_push_fp(ddata, decode_fp_to_float));
684 if (sizeof(long double) == 16)
685 return (cpp_demangle_push_fp(ddata,
686 decode_fp_to_double));
687 return (cpp_demangle_push_fp(ddata, decode_fp_to_float128));
698 if (*(++ddata->cur) == 'n') {
699 if (!cpp_demangle_push_str(ddata, "-", 1))
704 while (*ddata->cur != 'E') {
705 if (!ELFTC_ISDIGIT(*ddata->cur))
710 return (cpp_demangle_push_str(ddata, num, ddata->cur - num));
718 cpp_demangle_read_expression(struct cpp_demangle_data *ddata)
721 if (ddata == NULL || *ddata->cur == '\0')
724 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
725 case SIMPLE_HASH('s', 't'):
727 return (cpp_demangle_read_type(ddata, 0));
729 case SIMPLE_HASH('s', 'r'):
731 if (!cpp_demangle_read_type(ddata, 0))
733 if (!cpp_demangle_read_uqname(ddata))
735 if (*ddata->cur == 'I')
736 return (cpp_demangle_read_tmpl_args(ddata));
739 case SIMPLE_HASH('a', 'a'):
742 return (cpp_demangle_read_expression_binary(ddata, "&&", 2));
744 case SIMPLE_HASH('a', 'd'):
745 /* operator & (unary) */
747 return (cpp_demangle_read_expression_unary(ddata, "&", 1));
749 case SIMPLE_HASH('a', 'n'):
752 return (cpp_demangle_read_expression_binary(ddata, "&", 1));
754 case SIMPLE_HASH('a', 'N'):
757 return (cpp_demangle_read_expression_binary(ddata, "&=", 2));
759 case SIMPLE_HASH('a', 'S'):
762 return (cpp_demangle_read_expression_binary(ddata, "=", 1));
764 case SIMPLE_HASH('c', 'l'):
767 return (cpp_demangle_read_expression_binary(ddata, "()", 2));
769 case SIMPLE_HASH('c', 'm'):
772 return (cpp_demangle_read_expression_binary(ddata, ",", 1));
774 case SIMPLE_HASH('c', 'o'):
777 return (cpp_demangle_read_expression_binary(ddata, "~", 1));
779 case SIMPLE_HASH('c', 'v'):
780 /* operator (cast) */
782 return (cpp_demangle_read_expression_binary(ddata, "(cast)", 6));
784 case SIMPLE_HASH('d', 'a'):
785 /* operator delete [] */
787 return (cpp_demangle_read_expression_unary(ddata, "delete []", 9));
789 case SIMPLE_HASH('d', 'e'):
790 /* operator * (unary) */
792 return (cpp_demangle_read_expression_unary(ddata, "*", 1));
794 case SIMPLE_HASH('d', 'l'):
795 /* operator delete */
797 return (cpp_demangle_read_expression_unary(ddata, "delete", 6));
799 case SIMPLE_HASH('d', 'v'):
802 return (cpp_demangle_read_expression_binary(ddata, "/", 1));
804 case SIMPLE_HASH('d', 'V'):
807 return (cpp_demangle_read_expression_binary(ddata, "/=", 2));
809 case SIMPLE_HASH('e', 'o'):
812 return (cpp_demangle_read_expression_binary(ddata, "^", 1));
814 case SIMPLE_HASH('e', 'O'):
817 return (cpp_demangle_read_expression_binary(ddata, "^=", 2));
819 case SIMPLE_HASH('e', 'q'):
822 return (cpp_demangle_read_expression_binary(ddata, "==", 2));
824 case SIMPLE_HASH('g', 'e'):
827 return (cpp_demangle_read_expression_binary(ddata, ">=", 2));
829 case SIMPLE_HASH('g', 't'):
832 return (cpp_demangle_read_expression_binary(ddata, ">", 1));
834 case SIMPLE_HASH('i', 'x'):
837 return (cpp_demangle_read_expression_binary(ddata, "[]", 2));
839 case SIMPLE_HASH('l', 'e'):
842 return (cpp_demangle_read_expression_binary(ddata, "<=", 2));
844 case SIMPLE_HASH('l', 's'):
847 return (cpp_demangle_read_expression_binary(ddata, "<<", 2));
849 case SIMPLE_HASH('l', 'S'):
852 return (cpp_demangle_read_expression_binary(ddata, "<<=", 3));
854 case SIMPLE_HASH('l', 't'):
857 return (cpp_demangle_read_expression_binary(ddata, "<", 1));
859 case SIMPLE_HASH('m', 'i'):
862 return (cpp_demangle_read_expression_binary(ddata, "-", 1));
864 case SIMPLE_HASH('m', 'I'):
867 return (cpp_demangle_read_expression_binary(ddata, "-=", 2));
869 case SIMPLE_HASH('m', 'l'):
872 return (cpp_demangle_read_expression_binary(ddata, "*", 1));
874 case SIMPLE_HASH('m', 'L'):
877 return (cpp_demangle_read_expression_binary(ddata, "*=", 2));
879 case SIMPLE_HASH('m', 'm'):
882 return (cpp_demangle_read_expression_binary(ddata, "--", 2));
884 case SIMPLE_HASH('n', 'a'):
887 return (cpp_demangle_read_expression_unary(ddata, "new []", 6));
889 case SIMPLE_HASH('n', 'e'):
892 return (cpp_demangle_read_expression_binary(ddata, "!=", 2));
894 case SIMPLE_HASH('n', 'g'):
895 /* operator - (unary) */
897 return (cpp_demangle_read_expression_unary(ddata, "-", 1));
899 case SIMPLE_HASH('n', 't'):
902 return (cpp_demangle_read_expression_binary(ddata, "!", 1));
904 case SIMPLE_HASH('n', 'w'):
907 return (cpp_demangle_read_expression_unary(ddata, "new", 3));
909 case SIMPLE_HASH('o', 'o'):
912 return (cpp_demangle_read_expression_binary(ddata, "||", 2));
914 case SIMPLE_HASH('o', 'r'):
917 return (cpp_demangle_read_expression_binary(ddata, "|", 1));
919 case SIMPLE_HASH('o', 'R'):
922 return (cpp_demangle_read_expression_binary(ddata, "|=", 2));
924 case SIMPLE_HASH('p', 'l'):
927 return (cpp_demangle_read_expression_binary(ddata, "+", 1));
929 case SIMPLE_HASH('p', 'L'):
932 return (cpp_demangle_read_expression_binary(ddata, "+=", 2));
934 case SIMPLE_HASH('p', 'm'):
937 return (cpp_demangle_read_expression_binary(ddata, "->*", 3));
939 case SIMPLE_HASH('p', 'p'):
942 return (cpp_demangle_read_expression_binary(ddata, "++", 2));
944 case SIMPLE_HASH('p', 's'):
945 /* operator + (unary) */
947 return (cpp_demangle_read_expression_unary(ddata, "+", 1));
949 case SIMPLE_HASH('p', 't'):
952 return (cpp_demangle_read_expression_binary(ddata, "->", 2));
954 case SIMPLE_HASH('q', 'u'):
957 return (cpp_demangle_read_expression_trinary(ddata, "?", 1,
960 case SIMPLE_HASH('r', 'm'):
963 return (cpp_demangle_read_expression_binary(ddata, "%", 1));
965 case SIMPLE_HASH('r', 'M'):
968 return (cpp_demangle_read_expression_binary(ddata, "%=", 2));
970 case SIMPLE_HASH('r', 's'):
973 return (cpp_demangle_read_expression_binary(ddata, ">>", 2));
975 case SIMPLE_HASH('r', 'S'):
978 return (cpp_demangle_read_expression_binary(ddata, ">>=", 3));
980 case SIMPLE_HASH('r', 'z'):
981 /* operator sizeof */
983 return (cpp_demangle_read_expression_unary(ddata, "sizeof", 6));
985 case SIMPLE_HASH('s', 'v'):
986 /* operator sizeof */
988 return (cpp_demangle_read_expression_unary(ddata, "sizeof", 6));
991 switch (*ddata->cur) {
993 return (cpp_demangle_read_expr_primary(ddata));
995 return (cpp_demangle_read_tmpl_param(ddata));
1002 cpp_demangle_read_expression_binary(struct cpp_demangle_data *ddata,
1003 const char *name, size_t len)
1006 if (ddata == NULL || name == NULL || len == 0)
1008 if (!cpp_demangle_read_expression(ddata))
1010 if (!cpp_demangle_push_str(ddata, name, len))
1013 return (cpp_demangle_read_expression(ddata));
1017 cpp_demangle_read_expression_unary(struct cpp_demangle_data *ddata,
1018 const char *name, size_t len)
1021 if (ddata == NULL || name == NULL || len == 0)
1023 if (!cpp_demangle_read_expression(ddata))
1026 return (cpp_demangle_push_str(ddata, name, len));
1030 cpp_demangle_read_expression_trinary(struct cpp_demangle_data *ddata,
1031 const char *name1, size_t len1, const char *name2, size_t len2)
1034 if (ddata == NULL || name1 == NULL || len1 == 0 || name2 == NULL ||
1038 if (!cpp_demangle_read_expression(ddata))
1040 if (!cpp_demangle_push_str(ddata, name1, len1))
1042 if (!cpp_demangle_read_expression(ddata))
1044 if (!cpp_demangle_push_str(ddata, name2, len2))
1047 return (cpp_demangle_read_expression(ddata));
1051 cpp_demangle_read_function(struct cpp_demangle_data *ddata, int *ext_c,
1052 struct vector_type_qualifier *v)
1054 size_t class_type_size, class_type_len, limit;
1055 const char *class_type;
1057 if (ddata == NULL || *ddata->cur != 'F' || v == NULL)
1061 if (*ddata->cur == 'Y') {
1066 if (!cpp_demangle_read_type(ddata, 0))
1068 if (*ddata->cur != 'E') {
1069 if (!cpp_demangle_push_str(ddata, "(", 1))
1071 if (vector_read_cmd_find(&ddata->cmd, READ_PTRMEM)) {
1072 if ((class_type_size = ddata->class_type.size) == 0)
1075 ddata->class_type.container[class_type_size - 1];
1076 if (class_type == NULL)
1078 if ((class_type_len = strlen(class_type)) == 0)
1080 if (!cpp_demangle_push_str(ddata, class_type,
1083 if (!cpp_demangle_push_str(ddata, "::*", 3))
1087 if (!cpp_demangle_push_type_qualifier(ddata, v,
1088 (const char *) NULL))
1090 vector_type_qualifier_dest(v);
1091 if (!vector_type_qualifier_init(v))
1095 if (!cpp_demangle_push_str(ddata, ")(", 2))
1100 if (!cpp_demangle_read_type(ddata, 0))
1102 if (*ddata->cur == 'E')
1104 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
1108 if (vector_read_cmd_find(&ddata->cmd, READ_PTRMEM) == 1) {
1109 if (!cpp_demangle_push_type_qualifier(ddata, v,
1110 (const char *) NULL))
1112 vector_type_qualifier_dest(v);
1113 if (!vector_type_qualifier_init(v))
1117 if (!cpp_demangle_push_str(ddata, ")", 1))
1126 /* read encoding, encoding are function name, data name, special-name */
1128 cpp_demangle_read_encoding(struct cpp_demangle_data *ddata)
1131 if (ddata == NULL || *ddata->cur == '\0')
1135 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
1136 case SIMPLE_HASH('G', 'V'):
1137 /* sentry object for 1 time init */
1138 if (!cpp_demangle_push_str(ddata, "guard variable for ", 20))
1143 case SIMPLE_HASH('T', 'c'):
1144 /* virtual function covariant override thunk */
1145 if (!cpp_demangle_push_str(ddata,
1146 "virtual function covariant override ", 36))
1149 if (*ddata->cur == '\0')
1151 if (!cpp_demangle_read_offset(ddata))
1153 if (!cpp_demangle_read_offset(ddata))
1155 return (cpp_demangle_read_encoding(ddata));
1157 case SIMPLE_HASH('T', 'D'):
1158 /* typeinfo common proxy */
1161 case SIMPLE_HASH('T', 'h'):
1162 /* virtual function non-virtual override thunk */
1163 if (cpp_demangle_push_str(ddata,
1164 "virtual function non-virtual override ", 38) == 0)
1167 if (*ddata->cur == '\0')
1169 if (!cpp_demangle_read_nv_offset(ddata))
1171 return (cpp_demangle_read_encoding(ddata));
1173 case SIMPLE_HASH('T', 'I'):
1174 /* typeinfo structure */
1176 case SIMPLE_HASH('T', 'S'):
1177 /* RTTI name (NTBS) */
1178 if (!cpp_demangle_push_str(ddata, "typeinfo for ", 14))
1181 if (*ddata->cur == '\0')
1183 return (cpp_demangle_read_type(ddata, 1));
1185 case SIMPLE_HASH('T', 'T'):
1187 if (!cpp_demangle_push_str(ddata, "VTT for ", 8))
1190 return (cpp_demangle_read_type(ddata, 1));
1192 case SIMPLE_HASH('T', 'v'):
1193 /* virtual function virtual override thunk */
1194 if (!cpp_demangle_push_str(ddata,
1195 "virtual function virtual override ", 34))
1198 if (*ddata->cur == '\0')
1200 if (!cpp_demangle_read_v_offset(ddata))
1202 return (cpp_demangle_read_encoding(ddata));
1204 case SIMPLE_HASH('T', 'V'):
1206 if (!cpp_demangle_push_str(ddata, "vtable for ", 12))
1209 if (*ddata->cur == '\0')
1211 return (cpp_demangle_read_type(ddata, 1));
1214 return (cpp_demangle_read_name(ddata));
1218 cpp_demangle_read_local_name(struct cpp_demangle_data *ddata)
1224 if (*(++ddata->cur) == '\0')
1226 if (!cpp_demangle_read_encoding(ddata))
1231 if (!cpp_demangle_read_type(ddata, 1))
1233 if (*ddata->cur == 'E')
1235 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
1238 if (*(++ddata->cur) == '\0')
1240 if (ddata->paren == true) {
1241 if (!cpp_demangle_push_str(ddata, ")", 1))
1243 ddata->paren = false;
1245 if (*ddata->cur == 's')
1248 if (!cpp_demangle_push_str(ddata, "::", 2))
1250 if (!cpp_demangle_read_name(ddata))
1253 if (*ddata->cur == '_') {
1255 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
1263 cpp_demangle_read_name(struct cpp_demangle_data *ddata)
1265 struct vector_str *output, v;
1266 size_t p_idx, subst_str_len;
1270 if (ddata == NULL || *ddata->cur == '\0')
1273 output = cpp_demangle_gnu3_push_head > 0 ?
1274 &ddata->output_tmp : &ddata->output;
1278 switch (*ddata->cur) {
1280 return (cpp_demangle_read_subst(ddata));
1282 return (cpp_demangle_read_nested_name(ddata));
1284 return (cpp_demangle_read_local_name(ddata));
1287 if (!vector_str_init(&v))
1290 p_idx = output->size;
1292 if (!cpp_demangle_read_uqname(ddata))
1294 if ((subst_str = vector_str_substr(output, p_idx, output->size - 1,
1295 &subst_str_len)) == NULL)
1297 if (subst_str_len > 8 && strstr(subst_str, "operator") != NULL) {
1301 if (!vector_str_push(&v, subst_str, subst_str_len))
1303 if (!cpp_demangle_push_subst_v(ddata, &v))
1306 if (*ddata->cur == 'I') {
1307 p_idx = output->size;
1308 if (!cpp_demangle_read_tmpl_args(ddata))
1311 if ((subst_str = vector_str_substr(output, p_idx,
1312 output->size - 1, &subst_str_len)) == NULL)
1314 if (!vector_str_push(&v, subst_str, subst_str_len))
1316 if (!cpp_demangle_push_subst_v(ddata, &v))
1324 vector_str_dest(&v);
1330 cpp_demangle_read_nested_name(struct cpp_demangle_data *ddata)
1332 struct vector_str *output, v;
1333 size_t limit, p_idx, subst_str_len;
1337 if (ddata == NULL || *ddata->cur != 'N')
1339 if (*(++ddata->cur) == '\0')
1342 while (*ddata->cur == 'r' || *ddata->cur == 'V' ||
1343 *ddata->cur == 'K') {
1344 switch (*ddata->cur) {
1346 ddata->mem_rst = true;
1349 ddata->mem_vat = true;
1352 ddata->mem_cst = true;
1358 output = cpp_demangle_gnu3_push_head > 0 ?
1359 &ddata->output_tmp : &ddata->output;
1360 if (!vector_str_init(&v))
1366 p_idx = output->size;
1367 switch (*ddata->cur) {
1369 if (!cpp_demangle_read_tmpl_args(ddata))
1373 if (!cpp_demangle_read_subst(ddata))
1377 if (!cpp_demangle_read_tmpl_param(ddata))
1381 if (!cpp_demangle_read_uqname(ddata))
1385 if ((subst_str = vector_str_substr(output, p_idx,
1386 output->size - 1, &subst_str_len)) == NULL)
1388 if (!vector_str_push(&v, subst_str, subst_str_len)) {
1394 if (!cpp_demangle_push_subst_v(ddata, &v))
1396 if (*ddata->cur == 'E')
1398 else if (*ddata->cur != 'I' &&
1399 *ddata->cur != 'C' && *ddata->cur != 'D') {
1400 if (!cpp_demangle_push_str(ddata, "::", 2))
1402 if (!vector_str_push(&v, "::", 2))
1405 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
1413 vector_str_dest(&v);
1420 * number ::= [n] <decimal>
1423 cpp_demangle_read_number(struct cpp_demangle_data *ddata, long *rtn)
1425 long len, negative_factor;
1427 if (ddata == NULL || rtn == NULL)
1430 negative_factor = 1;
1431 if (*ddata->cur == 'n') {
1432 negative_factor = -1;
1436 if (ELFTC_ISDIGIT(*ddata->cur) == 0)
1440 if ((len = strtol(ddata->cur, (char **) NULL, 10)) == 0 &&
1444 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
1448 assert(negative_factor == 1 || negative_factor == -1);
1450 *rtn = len * negative_factor;
1456 cpp_demangle_read_nv_offset(struct cpp_demangle_data *ddata)
1462 if (!cpp_demangle_push_str(ddata, "offset : ", 9))
1465 return (cpp_demangle_read_offset_number(ddata));
1468 /* read offset, offset are nv-offset, v-offset */
1470 cpp_demangle_read_offset(struct cpp_demangle_data *ddata)
1476 if (*ddata->cur == 'h') {
1478 return (cpp_demangle_read_nv_offset(ddata));
1479 } else if (*ddata->cur == 'v') {
1481 return (cpp_demangle_read_v_offset(ddata));
1488 cpp_demangle_read_offset_number(struct cpp_demangle_data *ddata)
1493 if (ddata == NULL || *ddata->cur == '\0')
1496 /* offset could be negative */
1497 if (*ddata->cur == 'n') {
1499 start = ddata->cur + 1;
1505 while (*ddata->cur != '_')
1508 if (negative && !cpp_demangle_push_str(ddata, "-", 1))
1511 assert(start != NULL);
1513 if (!cpp_demangle_push_str(ddata, start, ddata->cur - start))
1515 if (!cpp_demangle_push_str(ddata, " ", 1))
1524 cpp_demangle_read_pointer_to_member(struct cpp_demangle_data *ddata)
1526 size_t class_type_len, i, idx, p_idx;
1527 int p_func_type, rtn;
1530 if (ddata == NULL || *ddata->cur != 'M' || *(++ddata->cur) == '\0')
1533 p_idx = ddata->output.size;
1534 if (!cpp_demangle_read_type(ddata, 0))
1537 if ((class_type = vector_str_substr(&ddata->output, p_idx,
1538 ddata->output.size - 1, &class_type_len)) == NULL)
1542 idx = ddata->output.size;
1543 for (i = p_idx; i < idx; ++i)
1544 if (!vector_str_pop(&ddata->output))
1547 if (!vector_read_cmd_push(&ddata->cmd, READ_PTRMEM))
1550 if (!vector_str_push(&ddata->class_type, class_type, class_type_len))
1553 p_func_type = ddata->func_type;
1554 if (!cpp_demangle_read_type(ddata, 0))
1557 if (p_func_type == ddata->func_type) {
1558 if (!cpp_demangle_push_str(ddata, " ", 1))
1560 if (!cpp_demangle_push_str(ddata, class_type, class_type_len))
1562 if (!cpp_demangle_push_str(ddata, "::*", 3))
1568 if (!vector_str_pop(&ddata->class_type))
1571 if (!vector_read_cmd_pop(&ddata->cmd))
1579 /* read source-name, source-name is <len> <ID> */
1581 cpp_demangle_read_sname(struct cpp_demangle_data *ddata)
1585 if (ddata == NULL || cpp_demangle_read_number(ddata, &len) == 0 ||
1586 len <= 0 || cpp_demangle_push_str(ddata, ddata->cur, len) == 0)
1589 assert(ddata->output.size > 0);
1590 if (vector_read_cmd_find(&ddata->cmd, READ_TMPL) == 0)
1592 ddata->output.container[ddata->output.size - 1];
1600 cpp_demangle_read_subst(struct cpp_demangle_data *ddata)
1604 if (ddata == NULL || *ddata->cur == '\0')
1607 /* abbreviations of the form Sx */
1608 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
1609 case SIMPLE_HASH('S', 'a'):
1610 /* std::allocator */
1611 if (cpp_demangle_push_str(ddata, "std::allocator", 14) == 0)
1614 if (*ddata->cur == 'I')
1615 return (cpp_demangle_read_subst_stdtmpl(ddata,
1616 "std::allocator", 14));
1619 case SIMPLE_HASH('S', 'b'):
1620 /* std::basic_string */
1621 if (!cpp_demangle_push_str(ddata, "std::basic_string", 17))
1624 if (*ddata->cur == 'I')
1625 return (cpp_demangle_read_subst_stdtmpl(ddata,
1626 "std::basic_string", 17));
1629 case SIMPLE_HASH('S', 'd'):
1630 /* std::basic_iostream<char, std::char_traits<char> > */
1631 if (!cpp_demangle_push_str(ddata, "std::iostream", 19))
1633 ddata->last_sname = "iostream";
1635 if (*ddata->cur == 'I')
1636 return (cpp_demangle_read_subst_stdtmpl(ddata,
1637 "std::iostream", 19));
1640 case SIMPLE_HASH('S', 'i'):
1641 /* std::basic_istream<char, std::char_traits<char> > */
1642 if (!cpp_demangle_push_str(ddata, "std::istream", 18))
1644 ddata->last_sname = "istream";
1646 if (*ddata->cur == 'I')
1647 return (cpp_demangle_read_subst_stdtmpl(ddata,
1648 "std::istream", 18));
1651 case SIMPLE_HASH('S', 'o'):
1652 /* std::basic_ostream<char, std::char_traits<char> > */
1653 if (!cpp_demangle_push_str(ddata, "std::ostream", 18))
1655 ddata->last_sname = "istream";
1657 if (*ddata->cur == 'I')
1658 return (cpp_demangle_read_subst_stdtmpl(ddata,
1659 "std::ostream", 18));
1662 case SIMPLE_HASH('S', 's'):
1664 * std::basic_string<char, std::char_traits<char>,
1665 * std::allocator<char> >
1669 if (!cpp_demangle_push_str(ddata, "std::string", 11))
1671 ddata->last_sname = "string";
1673 if (*ddata->cur == 'I')
1674 return (cpp_demangle_read_subst_stdtmpl(ddata,
1675 "std::string", 11));
1678 case SIMPLE_HASH('S', 't'):
1680 return (cpp_demangle_read_subst_std(ddata));
1683 if (*(++ddata->cur) == '\0')
1687 if (*ddata->cur == '_')
1688 return (cpp_demangle_get_subst(ddata, 0));
1691 /* substitution number is base 36 */
1692 if ((nth = strtol(ddata->cur, (char **) NULL, 36)) == 0 &&
1696 /* first was '_', so increase one */
1699 while (*ddata->cur != '_')
1704 return (cpp_demangle_get_subst(ddata, nth));
1712 cpp_demangle_read_subst_std(struct cpp_demangle_data *ddata)
1714 struct vector_str *output, v;
1715 size_t p_idx, subst_str_len;
1722 if (!vector_str_init(&v))
1727 if (!cpp_demangle_push_str(ddata, "std::", 5))
1730 if (!vector_str_push(&v, "std::", 5))
1735 output = cpp_demangle_gnu3_push_head > 0 ?
1736 &ddata->output_tmp : &ddata->output;
1738 p_idx = output->size;
1739 if (!cpp_demangle_read_uqname(ddata))
1742 if ((subst_str = vector_str_substr(output, p_idx, output->size - 1,
1743 &subst_str_len)) == NULL)
1746 if (!vector_str_push(&v, subst_str, subst_str_len))
1749 if (!cpp_demangle_push_subst_v(ddata, &v))
1752 if (*ddata->cur == 'I') {
1753 p_idx = output->size;
1754 if (!cpp_demangle_read_tmpl_args(ddata))
1757 if ((subst_str = vector_str_substr(output, p_idx,
1758 output->size - 1, &subst_str_len)) == NULL)
1760 if (!vector_str_push(&v, subst_str, subst_str_len))
1762 if (!cpp_demangle_push_subst_v(ddata, &v))
1769 vector_str_dest(&v);
1775 cpp_demangle_read_subst_stdtmpl(struct cpp_demangle_data *ddata,
1776 const char *str, size_t len)
1778 struct vector_str *output;
1779 size_t p_idx, substr_len;
1781 char *subst_str, *substr;
1783 if (ddata == NULL || str == NULL || len == 0)
1786 output = cpp_demangle_gnu3_push_head > 0 ? &ddata->output_tmp :
1789 p_idx = output->size;
1793 if (!cpp_demangle_read_tmpl_args(ddata))
1795 if ((substr = vector_str_substr(output, p_idx, output->size - 1,
1796 &substr_len)) == NULL)
1800 if ((subst_str = malloc(sizeof(char) * (substr_len + len + 1))) ==
1804 memcpy(subst_str, str, len);
1805 memcpy(subst_str + len, substr, substr_len);
1806 subst_str[substr_len + len] = '\0';
1808 if (!cpp_demangle_push_subst(ddata, subst_str, substr_len + len))
1820 cpp_demangle_read_tmpl_arg(struct cpp_demangle_data *ddata)
1823 if (ddata == NULL || *ddata->cur == '\0')
1826 switch (*ddata->cur) {
1828 return (cpp_demangle_read_expr_primary(ddata));
1830 return (cpp_demangle_read_expression(ddata));
1833 return (cpp_demangle_read_type(ddata, 0));
1837 cpp_demangle_read_tmpl_args(struct cpp_demangle_data *ddata)
1839 struct vector_str *v;
1840 size_t arg_len, idx, limit, size;
1843 if (ddata == NULL || *ddata->cur == '\0')
1848 if (!vector_read_cmd_push(&ddata->cmd, READ_TMPL))
1851 if (!cpp_demangle_push_str(ddata, "<", 1))
1855 v = cpp_demangle_gnu3_push_head > 0 ?
1856 &ddata->output_tmp : &ddata->output;
1859 if (!cpp_demangle_read_tmpl_arg(ddata))
1861 if ((arg = vector_str_substr(v, idx, v->size - 1, &arg_len)) ==
1864 if (!vector_str_find(&ddata->tmpl, arg, arg_len) &&
1865 !vector_str_push(&ddata->tmpl, arg, arg_len)) {
1872 if (*ddata->cur == 'E') {
1876 if (!strncmp(v->container[size - 1], ">", 1)) {
1877 if (!cpp_demangle_push_str(ddata, " >", 2))
1879 } else if (!cpp_demangle_push_str(ddata, ">", 1))
1882 } else if (*ddata->cur != 'I' &&
1883 !cpp_demangle_push_str(ddata, ", ", 2))
1886 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
1890 return (vector_read_cmd_pop(&ddata->cmd));
1894 * Read template parameter that forms in 'T[number]_'.
1895 * This function much like to read_subst but only for types.
1898 cpp_demangle_read_tmpl_param(struct cpp_demangle_data *ddata)
1902 if (ddata == NULL || *ddata->cur != 'T')
1907 if (*ddata->cur == '_')
1908 return (cpp_demangle_get_tmpl_param(ddata, 0));
1912 if ((nth = strtol(ddata->cur, (char **) NULL, 36)) == 0 &&
1919 while (*ddata->cur != '_')
1924 return (cpp_demangle_get_tmpl_param(ddata, nth));
1932 cpp_demangle_read_type(struct cpp_demangle_data *ddata, int delimit)
1934 struct vector_type_qualifier v;
1935 struct vector_str *output;
1936 size_t p_idx, type_str_len;
1937 int extern_c, is_builtin;
1944 output = &ddata->output;
1945 if (!strncmp(ddata->output.container[ddata->output.size - 1], ">", 1)) {
1946 cpp_demangle_gnu3_push_head++;
1947 output = &ddata->output_tmp;
1948 } else if (delimit == 1) {
1949 if (ddata->paren == false) {
1950 if (!cpp_demangle_push_str(ddata, "(", 1))
1952 if (ddata->output.size < 2)
1954 ddata->paren = true;
1955 ddata->pfirst = true;
1956 /* Need pop function name */
1957 if (ddata->subst.size == 1 &&
1958 !vector_str_pop(&ddata->subst))
1963 ddata->pfirst = false;
1964 else if (*ddata->cur != 'I' &&
1965 !cpp_demangle_push_str(ddata, ", ", 2))
1969 assert(output != NULL);
1971 * [r, V, K] [P, R, C, G, U] builtin, function, class-enum, array
1972 * pointer-to-member, template-param, template-template-param, subst
1975 if (!vector_type_qualifier_init(&v))
1980 p_idx = output->size;
1984 switch (*ddata->cur) {
1987 if (!cpp_demangle_push_str(ddata, "signed char", 11))
1994 if (!cpp_demangle_read_array(ddata))
2001 if (!cpp_demangle_push_str(ddata, "bool", 4))
2008 if (!vector_type_qualifier_push(&v, TYPE_CMX))
2015 if (!cpp_demangle_push_str(ddata, "char", 4))
2022 if (!cpp_demangle_push_str(ddata, "double", 6))
2029 if (!cpp_demangle_push_str(ddata, "long double", 11))
2036 if (!cpp_demangle_push_str(ddata, "float", 5))
2043 if (!cpp_demangle_read_function(ddata, &extern_c, &v))
2050 if (!cpp_demangle_push_str(ddata, "__float128", 10))
2057 if (!vector_type_qualifier_push(&v, TYPE_IMG))
2064 if (!cpp_demangle_push_str(ddata, "unsigned char", 13))
2071 if (!cpp_demangle_push_str(ddata, "int", 3))
2078 if (!cpp_demangle_push_str(ddata, "unsigned int", 12))
2085 if (!vector_type_qualifier_push(&v, TYPE_CST))
2092 if (!cpp_demangle_push_str(ddata, "long", 4))
2099 if (!cpp_demangle_push_str(ddata, "unsigned long", 13))
2106 /* pointer to member */
2107 if (!cpp_demangle_read_pointer_to_member(ddata))
2114 if (!cpp_demangle_push_str(ddata, "__int128", 8))
2120 /* unsigned __int128 */
2121 if (!cpp_demangle_push_str(ddata, "unsigned _;int128", 17))
2128 if (!vector_type_qualifier_push(&v, TYPE_PTR))
2135 if (!vector_type_qualifier_push(&v, TYPE_RST))
2142 if (!vector_type_qualifier_push(&v, TYPE_REF))
2148 /* short, local string */
2149 if (!cpp_demangle_push_str(ddata, "short", 5))
2156 if (!cpp_demangle_read_subst(ddata))
2162 /* unsigned short */
2163 if (!cpp_demangle_push_str(ddata, "unsigned short", 14))
2169 /* template parameter */
2170 if (!cpp_demangle_read_tmpl_param(ddata))
2176 /* vendor extended builtin */
2178 if (!cpp_demangle_read_sname(ddata))
2184 /* vendor extended type qualifier */
2185 if (!cpp_demangle_read_number(ddata, &len))
2189 if (!vector_str_push(&v.ext_name, ddata->cur, len))
2196 if (!cpp_demangle_push_str(ddata, "void", 4))
2203 if (!vector_type_qualifier_push(&v, TYPE_VAT))
2210 if (!cpp_demangle_push_str(ddata, "wchar_t", 6))
2217 if (!cpp_demangle_push_str(ddata, "long long", 9))
2223 /* unsigned long long */
2224 if (!cpp_demangle_push_str(ddata, "unsigned long long", 18))
2231 if (!cpp_demangle_push_str(ddata, "ellipsis", 8))
2237 if (!cpp_demangle_read_name(ddata))
2242 if ((type_str = vector_str_substr(output, p_idx, output->size - 1,
2243 &type_str_len)) == NULL)
2246 if (is_builtin == 0) {
2247 if (!vector_str_find(&ddata->subst, type_str, type_str_len) &&
2248 !vector_str_push(&ddata->subst, type_str, type_str_len))
2252 if (!cpp_demangle_push_type_qualifier(ddata, &v, type_str))
2256 vector_type_qualifier_dest(&v);
2258 if (cpp_demangle_gnu3_push_head > 0) {
2259 if (*ddata->cur == 'I' && cpp_demangle_read_tmpl_args(ddata)
2263 if (--cpp_demangle_gnu3_push_head > 0)
2266 if (!vector_str_push(&ddata->output_tmp, " ", 1))
2269 if (!vector_str_push_vector_head(&ddata->output,
2270 &ddata->output_tmp))
2273 vector_str_dest(&ddata->output_tmp);
2274 if (!vector_str_init(&ddata->output_tmp))
2277 if (!cpp_demangle_push_str(ddata, "(", 1))
2280 ddata->paren = true;
2281 ddata->pfirst = true;
2287 vector_type_qualifier_dest(&v);
2293 * read unqualified-name, unqualified name are operator-name, ctor-dtor-name,
2297 cpp_demangle_read_uqname(struct cpp_demangle_data *ddata)
2301 if (ddata == NULL || *ddata->cur == '\0')
2305 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
2306 case SIMPLE_HASH('a', 'a'):
2308 if (!cpp_demangle_push_str(ddata, "operator&&", 10))
2313 case SIMPLE_HASH('a', 'd'):
2314 /* operator & (unary) */
2315 if (!cpp_demangle_push_str(ddata, "operator&", 9))
2320 case SIMPLE_HASH('a', 'n'):
2322 if (!cpp_demangle_push_str(ddata, "operator&", 9))
2327 case SIMPLE_HASH('a', 'N'):
2329 if (!cpp_demangle_push_str(ddata, "operator&=", 10))
2334 case SIMPLE_HASH('a', 'S'):
2336 if (!cpp_demangle_push_str(ddata, "operator=", 9))
2341 case SIMPLE_HASH('c', 'l'):
2343 if (!cpp_demangle_push_str(ddata, "operator()", 10))
2348 case SIMPLE_HASH('c', 'm'):
2350 if (!cpp_demangle_push_str(ddata, "operator,", 9))
2355 case SIMPLE_HASH('c', 'o'):
2357 if (!cpp_demangle_push_str(ddata, "operator~", 9))
2362 case SIMPLE_HASH('c', 'v'):
2363 /* operator (cast) */
2364 if (!cpp_demangle_push_str(ddata, "operator(cast)", 14))
2367 return (cpp_demangle_read_type(ddata, 1));
2369 case SIMPLE_HASH('d', 'a'):
2370 /* operator delete [] */
2371 if (!cpp_demangle_push_str(ddata, "operator delete []", 18))
2376 case SIMPLE_HASH('d', 'e'):
2377 /* operator * (unary) */
2378 if (!cpp_demangle_push_str(ddata, "operator*", 9))
2383 case SIMPLE_HASH('d', 'l'):
2384 /* operator delete */
2385 if (!cpp_demangle_push_str(ddata, "operator delete", 15))
2390 case SIMPLE_HASH('d', 'v'):
2392 if (!cpp_demangle_push_str(ddata, "operator/", 9))
2397 case SIMPLE_HASH('d', 'V'):
2399 if (!cpp_demangle_push_str(ddata, "operator/=", 10))
2404 case SIMPLE_HASH('e', 'o'):
2406 if (!cpp_demangle_push_str(ddata, "operator^", 9))
2411 case SIMPLE_HASH('e', 'O'):
2413 if (!cpp_demangle_push_str(ddata, "operator^=", 10))
2418 case SIMPLE_HASH('e', 'q'):
2420 if (!cpp_demangle_push_str(ddata, "operator==", 10))
2425 case SIMPLE_HASH('g', 'e'):
2427 if (!cpp_demangle_push_str(ddata, "operator>=", 10))
2432 case SIMPLE_HASH('g', 't'):
2434 if (!cpp_demangle_push_str(ddata, "operator>", 9))
2439 case SIMPLE_HASH('i', 'x'):
2441 if (!cpp_demangle_push_str(ddata, "operator[]", 10))
2446 case SIMPLE_HASH('l', 'e'):
2448 if (!cpp_demangle_push_str(ddata, "operator<=", 10))
2453 case SIMPLE_HASH('l', 's'):
2455 if (!cpp_demangle_push_str(ddata, "operator<<", 10))
2460 case SIMPLE_HASH('l', 'S'):
2462 if (!cpp_demangle_push_str(ddata, "operator<<=", 11))
2467 case SIMPLE_HASH('l', 't'):
2469 if (!cpp_demangle_push_str(ddata, "operator<", 9))
2474 case SIMPLE_HASH('m', 'i'):
2476 if (!cpp_demangle_push_str(ddata, "operator-", 9))
2481 case SIMPLE_HASH('m', 'I'):
2483 if (!cpp_demangle_push_str(ddata, "operator-=", 10))
2488 case SIMPLE_HASH('m', 'l'):
2490 if (!cpp_demangle_push_str(ddata, "operator*", 9))
2495 case SIMPLE_HASH('m', 'L'):
2497 if (!cpp_demangle_push_str(ddata, "operator*=", 10))
2502 case SIMPLE_HASH('m', 'm'):
2504 if (!cpp_demangle_push_str(ddata, "operator--", 10))
2509 case SIMPLE_HASH('n', 'a'):
2510 /* operator new[] */
2511 if (!cpp_demangle_push_str(ddata, "operator new []", 15))
2516 case SIMPLE_HASH('n', 'e'):
2518 if (!cpp_demangle_push_str(ddata, "operator!=", 10))
2523 case SIMPLE_HASH('n', 'g'):
2524 /* operator - (unary) */
2525 if (!cpp_demangle_push_str(ddata, "operator-", 9))
2530 case SIMPLE_HASH('n', 't'):
2532 if (!cpp_demangle_push_str(ddata, "operator!", 9))
2537 case SIMPLE_HASH('n', 'w'):
2539 if (!cpp_demangle_push_str(ddata, "operator new", 12))
2544 case SIMPLE_HASH('o', 'o'):
2546 if (!cpp_demangle_push_str(ddata, "operator||", 10))
2551 case SIMPLE_HASH('o', 'r'):
2553 if (!cpp_demangle_push_str(ddata, "operator|", 9))
2558 case SIMPLE_HASH('o', 'R'):
2560 if (!cpp_demangle_push_str(ddata, "operator|=", 10))
2565 case SIMPLE_HASH('p', 'l'):
2567 if (!cpp_demangle_push_str(ddata, "operator+", 9))
2572 case SIMPLE_HASH('p', 'L'):
2574 if (!cpp_demangle_push_str(ddata, "operator+=", 10))
2579 case SIMPLE_HASH('p', 'm'):
2581 if (!cpp_demangle_push_str(ddata, "operator->*", 11))
2586 case SIMPLE_HASH('p', 'p'):
2588 if (!cpp_demangle_push_str(ddata, "operator++", 10))
2593 case SIMPLE_HASH('p', 's'):
2594 /* operator + (unary) */
2595 if (!cpp_demangle_push_str(ddata, "operator+", 9))
2600 case SIMPLE_HASH('p', 't'):
2602 if (!cpp_demangle_push_str(ddata, "operator->", 10))
2607 case SIMPLE_HASH('q', 'u'):
2609 if (!cpp_demangle_push_str(ddata, "operator?", 9))
2614 case SIMPLE_HASH('r', 'm'):
2616 if (!cpp_demangle_push_str(ddata, "operator%", 9))
2621 case SIMPLE_HASH('r', 'M'):
2623 if (!cpp_demangle_push_str(ddata, "operator%=", 10))
2628 case SIMPLE_HASH('r', 's'):
2630 if (!cpp_demangle_push_str(ddata, "operator>>", 10))
2635 case SIMPLE_HASH('r', 'S'):
2637 if (!cpp_demangle_push_str(ddata, "operator>>=", 11))
2642 case SIMPLE_HASH('r', 'z'):
2643 /* operator sizeof */
2644 if (!cpp_demangle_push_str(ddata, "operator sizeof ", 16))
2649 case SIMPLE_HASH('s', 'r'):
2650 /* scope resolution operator */
2651 if (!cpp_demangle_push_str(ddata, "scope resolution operator ",
2657 case SIMPLE_HASH('s', 'v'):
2658 /* operator sizeof */
2659 if (!cpp_demangle_push_str(ddata, "operator sizeof ", 16))
2665 /* vendor extened operator */
2666 if (*ddata->cur == 'v' && ELFTC_ISDIGIT(*(ddata->cur + 1))) {
2667 if (!cpp_demangle_push_str(ddata, "vendor extened operator ",
2670 if (!cpp_demangle_push_str(ddata, ddata->cur + 1, 1))
2673 return (cpp_demangle_read_sname(ddata));
2676 /* ctor-dtor-name */
2677 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
2678 case SIMPLE_HASH('C', '1'):
2680 case SIMPLE_HASH('C', '2'):
2682 case SIMPLE_HASH('C', '3'):
2683 if (ddata->last_sname == NULL)
2685 if ((len = strlen(ddata->last_sname)) == 0)
2687 if (!cpp_demangle_push_str(ddata, "::", 2))
2689 if (!cpp_demangle_push_str(ddata, ddata->last_sname, len))
2694 case SIMPLE_HASH('D', '0'):
2696 case SIMPLE_HASH('D', '1'):
2698 case SIMPLE_HASH('D', '2'):
2699 if (ddata->last_sname == NULL)
2701 if ((len = strlen(ddata->last_sname)) == 0)
2703 if (!cpp_demangle_push_str(ddata, "::~", 3))
2705 if (!cpp_demangle_push_str(ddata, ddata->last_sname, len))
2712 if (ELFTC_ISDIGIT(*ddata->cur) != 0)
2713 return (cpp_demangle_read_sname(ddata));
2715 /* local source name */
2716 if (*ddata->cur == 'L')
2717 return (cpp_demangle_local_source_name(ddata));
2723 * Read local source name.
2726 * http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31775
2727 * http://gcc.gnu.org/viewcvs?view=rev&revision=124467
2730 cpp_demangle_local_source_name(struct cpp_demangle_data *ddata)
2733 if (ddata == NULL || *ddata->cur != 'L')
2738 if (!cpp_demangle_read_sname(ddata))
2742 if (*ddata->cur == '_') {
2744 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
2752 cpp_demangle_read_v_offset(struct cpp_demangle_data *ddata)
2758 if (!cpp_demangle_push_str(ddata, "offset : ", 9))
2761 if (!cpp_demangle_read_offset_number(ddata))
2764 if (!cpp_demangle_push_str(ddata, "virtual offset : ", 17))
2767 return (!cpp_demangle_read_offset_number(ddata));
2771 * Decode floating point representation to string
2772 * Return new allocated string or NULL
2775 * Replace these functions to macro.
2778 decode_fp_to_double(const char *p, size_t len)
2781 size_t rtn_len, limit, i;
2785 if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > sizeof(double))
2788 memset(&f, 0, sizeof(double));
2790 for (i = 0; i < len / 2; ++i) {
2791 byte = hex_to_dec(p[len - i * 2 - 1]) +
2792 hex_to_dec(p[len - i * 2 - 2]) * 16;
2794 if (byte < 0 || byte > 255)
2797 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
2798 ((unsigned char *)&f)[i] = (unsigned char)(byte);
2799 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
2800 ((unsigned char *)&f)[sizeof(double) - i - 1] =
2801 (unsigned char)(byte);
2802 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
2808 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
2811 if (snprintf(rtn, rtn_len, "%fld", f) >= (int)rtn_len) {
2813 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
2815 rtn_len *= BUFFER_GROWFACTOR;
2823 decode_fp_to_float(const char *p, size_t len)
2825 size_t i, rtn_len, limit;
2830 if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > sizeof(float))
2833 memset(&f, 0, sizeof(float));
2835 for (i = 0; i < len / 2; ++i) {
2836 byte = hex_to_dec(p[len - i * 2 - 1]) +
2837 hex_to_dec(p[len - i * 2 - 2]) * 16;
2838 if (byte < 0 || byte > 255)
2840 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
2841 ((unsigned char *)&f)[i] = (unsigned char)(byte);
2842 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
2843 ((unsigned char *)&f)[sizeof(float) - i - 1] =
2844 (unsigned char)(byte);
2845 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
2851 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
2854 if (snprintf(rtn, rtn_len, "%ff", f) >= (int)rtn_len) {
2856 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
2858 rtn_len *= BUFFER_GROWFACTOR;
2866 decode_fp_to_float128(const char *p, size_t len)
2869 size_t rtn_len, limit, i;
2871 unsigned char buf[FLOAT_QUADRUPLE_BYTES];
2874 switch(sizeof(long double)) {
2875 case FLOAT_QUADRUPLE_BYTES:
2876 return (decode_fp_to_long_double(p, len));
2877 case FLOAT_EXTENED_BYTES:
2878 if (p == NULL || len == 0 || len % 2 != 0 ||
2879 len / 2 > FLOAT_QUADRUPLE_BYTES)
2882 memset(buf, 0, FLOAT_QUADRUPLE_BYTES);
2884 for (i = 0; i < len / 2; ++i) {
2885 byte = hex_to_dec(p[len - i * 2 - 1]) +
2886 hex_to_dec(p[len - i * 2 - 2]) * 16;
2887 if (byte < 0 || byte > 255)
2889 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
2890 buf[i] = (unsigned char)(byte);
2891 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
2892 buf[FLOAT_QUADRUPLE_BYTES - i -1] =
2893 (unsigned char)(byte);
2894 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
2896 memset(&f, 0, FLOAT_EXTENED_BYTES);
2898 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
2899 memcpy(&f, buf, FLOAT_EXTENED_BYTES);
2900 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
2901 memcpy(&f, buf + 6, FLOAT_EXTENED_BYTES);
2902 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
2907 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
2910 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
2912 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
2914 rtn_len *= BUFFER_GROWFACTOR;
2925 decode_fp_to_float80(const char *p, size_t len)
2928 size_t rtn_len, limit, i;
2930 unsigned char buf[FLOAT_EXTENED_BYTES];
2933 switch(sizeof(long double)) {
2934 case FLOAT_QUADRUPLE_BYTES:
2935 if (p == NULL || len == 0 || len % 2 != 0 ||
2936 len / 2 > FLOAT_EXTENED_BYTES)
2939 memset(buf, 0, FLOAT_EXTENED_BYTES);
2941 for (i = 0; i < len / 2; ++i) {
2942 byte = hex_to_dec(p[len - i * 2 - 1]) +
2943 hex_to_dec(p[len - i * 2 - 2]) * 16;
2945 if (byte < 0 || byte > 255)
2948 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
2949 buf[i] = (unsigned char)(byte);
2950 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
2951 buf[FLOAT_EXTENED_BYTES - i -1] =
2952 (unsigned char)(byte);
2953 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
2956 memset(&f, 0, FLOAT_QUADRUPLE_BYTES);
2958 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
2959 memcpy(&f, buf, FLOAT_EXTENED_BYTES);
2960 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
2961 memcpy((unsigned char *)(&f) + 6, buf, FLOAT_EXTENED_BYTES);
2962 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
2967 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
2970 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
2972 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
2974 rtn_len *= BUFFER_GROWFACTOR;
2979 case FLOAT_EXTENED_BYTES:
2980 return (decode_fp_to_long_double(p, len));
2987 decode_fp_to_long_double(const char *p, size_t len)
2990 size_t rtn_len, limit, i;
2994 if (p == NULL || len == 0 || len % 2 != 0 ||
2995 len / 2 > sizeof(long double))
2998 memset(&f, 0, sizeof(long double));
3000 for (i = 0; i < len / 2; ++i) {
3001 byte = hex_to_dec(p[len - i * 2 - 1]) +
3002 hex_to_dec(p[len - i * 2 - 2]) * 16;
3004 if (byte < 0 || byte > 255)
3007 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3008 ((unsigned char *)&f)[i] = (unsigned char)(byte);
3009 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3010 ((unsigned char *)&f)[sizeof(long double) - i - 1] =
3011 (unsigned char)(byte);
3012 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3018 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3021 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
3023 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3025 rtn_len *= BUFFER_GROWFACTOR;
3032 /* Simple hex to integer function used by decode_to_* function. */
3076 * @brief Test input string is mangled by IA-64 C++ ABI style.
3078 * Test string heads with "_Z" or "_GLOBAL__I_".
3079 * @return Return 0 at false.
3082 is_cpp_mangled_gnu3(const char *org)
3087 return ((len > 2 && *org == '_' && *(org + 1) == 'Z') ||
3088 (len > 11 && !strncmp(org, "_GLOBAL__I_", 11)));
3092 vector_read_cmd_dest(struct vector_read_cmd *v)
3098 free(v->r_container);
3101 /* return -1 at failed, 0 at not found, 1 at found. */
3103 vector_read_cmd_find(struct vector_read_cmd *v, enum read_cmd dst)
3107 if (v == NULL || dst == READ_FAIL)
3110 for (i = 0; i < v->size; ++i)
3111 if (v->r_container[i] == dst)
3118 vector_read_cmd_init(struct vector_read_cmd *v)
3125 v->capacity = VECTOR_DEF_CAPACITY;
3127 if ((v->r_container = malloc(sizeof(enum read_cmd) * v->capacity))
3135 vector_read_cmd_pop(struct vector_read_cmd *v)
3138 if (v == NULL || v->size == 0)
3142 v->r_container[v->size] = READ_FAIL;
3148 vector_read_cmd_push(struct vector_read_cmd *v, enum read_cmd cmd)
3150 enum read_cmd *tmp_r_ctn;
3157 if (v->size == v->capacity) {
3158 tmp_cap = v->capacity * BUFFER_GROWFACTOR;
3159 if ((tmp_r_ctn = malloc(sizeof(enum read_cmd) * tmp_cap))
3162 for (i = 0; i < v->size; ++i)
3163 tmp_r_ctn[i] = v->r_container[i];
3164 free(v->r_container);
3165 v->r_container = tmp_r_ctn;
3166 v->capacity = tmp_cap;
3169 v->r_container[v->size] = cmd;
3176 vector_type_qualifier_dest(struct vector_type_qualifier *v)
3182 free(v->q_container);
3183 vector_str_dest(&v->ext_name);
3186 /* size, capacity, ext_name */
3188 vector_type_qualifier_init(struct vector_type_qualifier *v)
3195 v->capacity = VECTOR_DEF_CAPACITY;
3197 if ((v->q_container = malloc(sizeof(enum type_qualifier) * v->capacity))
3201 assert(v->q_container != NULL);
3203 if (vector_str_init(&v->ext_name) == false) {
3204 free(v->q_container);
3212 vector_type_qualifier_push(struct vector_type_qualifier *v,
3213 enum type_qualifier t)
3215 enum type_qualifier *tmp_ctn;
3222 if (v->size == v->capacity) {
3223 tmp_cap = v->capacity * BUFFER_GROWFACTOR;
3224 if ((tmp_ctn = malloc(sizeof(enum type_qualifier) * tmp_cap))
3227 for (i = 0; i < v->size; ++i)
3228 tmp_ctn[i] = v->q_container[i];
3229 free(v->q_container);
3230 v->q_container = tmp_ctn;
3231 v->capacity = tmp_cap;
3234 v->q_container[v->size] = t;