2 * Copyright (c) 2007, 2008 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 * @file cpp_demangle.c
38 * @brief Decode IA-64 C++ ABI style implementation.
40 * IA-64 standard ABI(Itanium C++ ABI) references.
42 * http://www.codesourcery.com/cxx-abi/abi.html#mangling \n
43 * http://www.codesourcery.com/cxx-abi/abi-mangling.html
46 /** @brief Dynamic vector data for string. */
56 #define BUFFER_GROWFACTOR 1.618
57 #define VECTOR_DEF_CAPACITY 8
58 #define ELFTC_ISDIGIT(C) (isdigit((C) & 0xFF))
61 TYPE_PTR, TYPE_REF, TYPE_CMX, TYPE_IMG, TYPE_EXT, TYPE_RST, TYPE_VAT,
65 struct vector_type_qualifier {
66 size_t size, capacity;
67 enum type_qualifier *q_container;
68 struct vector_str ext_name;
72 READ_FAIL, READ_NEST, READ_TMPL, READ_EXPR, READ_EXPL, READ_LOCAL,
73 READ_TYPE, READ_FUNC, READ_PTRMEM
76 struct vector_read_cmd {
77 size_t size, capacity;
78 enum read_cmd *r_container;
81 struct cpp_demangle_data {
82 struct vector_str output; /* output string vector */
83 struct vector_str output_tmp;
84 struct vector_str subst; /* substitution string vector */
85 struct vector_str tmpl;
86 struct vector_str class_type;
87 struct vector_read_cmd cmd;
88 bool paren; /* parenthesis opened */
89 bool pfirst; /* first element of parameter */
90 bool mem_rst; /* restrict member function */
91 bool mem_vat; /* volatile member function */
92 bool mem_cst; /* const member function */
94 const char *cur; /* current mangled name ptr */
95 const char *last_sname; /* last source name */
99 #define CPP_DEMANGLE_TRY_LIMIT 128
100 #define FLOAT_SPRINTF_TRY_LIMIT 5
101 #define FLOAT_QUADRUPLE_BYTES 16
102 #define FLOAT_EXTENED_BYTES 10
104 #define SIMPLE_HASH(x,y) (64 * x + y)
106 static size_t get_strlen_sum(const struct vector_str *v);
107 static bool vector_str_grow(struct vector_str *v);
110 get_strlen_sum(const struct vector_str *v)
119 for (i = 0; i < v->size; ++i)
120 len += strlen(v->container[i]);
126 * @brief Deallocate resource in vector_str.
129 vector_str_dest(struct vector_str *v)
136 for (i = 0; i < v->size; ++i)
137 free(v->container[i]);
143 * @brief Find string in vector_str.
144 * @param v Destination vector.
145 * @param o String to find.
146 * @param l Length of the string.
147 * @return -1 at failed, 0 at not found, 1 at found.
150 vector_str_find(const struct vector_str *v, const char *o, size_t l)
154 if (v == NULL || o == NULL)
157 for (i = 0; i < v->size; ++i)
158 if (strncmp(v->container[i], o, l) == 0)
165 * @brief Get new allocated flat string from vector.
167 * If l is not NULL, return length of the string.
168 * @param v Destination vector.
169 * @param l Length of the string.
170 * @return NULL at failed or NUL terminated new allocated string.
173 vector_str_get_flat(const struct vector_str *v, size_t *l)
175 ssize_t elem_pos, elem_size, rtn_size;
179 if (v == NULL || v->size == 0)
182 if ((rtn_size = get_strlen_sum(v)) == 0)
185 if ((rtn = malloc(sizeof(char) * (rtn_size + 1))) == NULL)
189 for (i = 0; i < v->size; ++i) {
190 elem_size = strlen(v->container[i]);
192 memcpy(rtn + elem_pos, v->container[i], elem_size);
194 elem_pos += elem_size;
197 rtn[rtn_size] = '\0';
206 vector_str_grow(struct vector_str *v)
214 assert(v->capacity > 0);
216 tmp_cap = v->capacity * BUFFER_GROWFACTOR;
218 assert(tmp_cap > v->capacity);
220 if ((tmp_ctn = malloc(sizeof(char *) * tmp_cap)) == NULL)
223 for (i = 0; i < v->size; ++i)
224 tmp_ctn[i] = v->container[i];
228 v->container = tmp_ctn;
229 v->capacity = tmp_cap;
235 * @brief Initialize vector_str.
236 * @return false at failed, true at success.
239 vector_str_init(struct vector_str *v)
246 v->capacity = VECTOR_DEF_CAPACITY;
248 assert(v->capacity > 0);
250 if ((v->container = malloc(sizeof(char *) * v->capacity)) == NULL)
253 assert(v->container != NULL);
259 * @brief Remove last element in vector_str.
260 * @return false at failed, true at success.
263 vector_str_pop(struct vector_str *v)
274 free(v->container[v->size]);
275 v->container[v->size] = NULL;
281 * @brief Push back string to vector.
282 * @return false at failed, true at success.
285 vector_str_push(struct vector_str *v, const char *str, size_t len)
288 if (v == NULL || str == NULL)
291 if (v->size == v->capacity && vector_str_grow(v) == false)
294 if ((v->container[v->size] = malloc(sizeof(char) * (len + 1))) == NULL)
297 snprintf(v->container[v->size], len + 1, "%s", str);
305 * @brief Push front org vector to det vector.
306 * @return false at failed, true at success.
309 vector_str_push_vector_head(struct vector_str *dst, struct vector_str *org)
311 size_t i, j, tmp_cap;
314 if (dst == NULL || org == NULL)
317 tmp_cap = (dst->size + org->size) * BUFFER_GROWFACTOR;
319 if ((tmp_ctn = malloc(sizeof(char *) * tmp_cap)) == NULL)
322 for (i = 0; i < org->size; ++i)
323 if ((tmp_ctn[i] = strdup(org->container[i])) == NULL) {
324 for (j = 0; j < i; ++j)
332 for (i = 0; i < dst->size; ++i)
333 tmp_ctn[i + org->size] = dst->container[i];
335 free(dst->container);
337 dst->container = tmp_ctn;
338 dst->capacity = tmp_cap;
339 dst->size += org->size;
345 * @brief Get new allocated flat string from vector between begin and end.
347 * If r_len is not NULL, string length will be returned.
348 * @return NULL at failed or NUL terminated new allocated string.
351 vector_str_substr(const struct vector_str *v, size_t begin, size_t end,
357 if (v == NULL || begin > end)
361 for (i = begin; i < end + 1; ++i)
362 len += strlen(v->container[i]);
364 if ((rtn = malloc(sizeof(char) * (len + 1))) == NULL)
371 for (i = begin; i < end + 1; ++i) {
372 len = strlen(v->container[i]);
373 memcpy(rtn + cur, v->container[i], len);
381 static void cpp_demangle_data_dest(struct cpp_demangle_data *);
382 static int cpp_demangle_data_init(struct cpp_demangle_data *,
384 static int cpp_demangle_get_subst(struct cpp_demangle_data *, size_t);
385 static int cpp_demangle_get_tmpl_param(struct cpp_demangle_data *, size_t);
386 static int cpp_demangle_push_fp(struct cpp_demangle_data *,
387 char *(*)(const char *, size_t));
388 static int cpp_demangle_push_str(struct cpp_demangle_data *, const char *,
390 static int cpp_demangle_push_subst(struct cpp_demangle_data *,
391 const char *, size_t);
392 static int cpp_demangle_push_subst_v(struct cpp_demangle_data *,
393 struct vector_str *);
394 static int cpp_demangle_push_type_qualifier(struct cpp_demangle_data *,
395 struct vector_type_qualifier *, const char *);
396 static int cpp_demangle_read_array(struct cpp_demangle_data *);
397 static int cpp_demangle_read_encoding(struct cpp_demangle_data *);
398 static int cpp_demangle_read_expr_primary(struct cpp_demangle_data *);
399 static int cpp_demangle_read_expression(struct cpp_demangle_data *);
400 static int cpp_demangle_read_expression_binary(struct cpp_demangle_data *,
401 const char *, size_t);
402 static int cpp_demangle_read_expression_unary(struct cpp_demangle_data *,
403 const char *, size_t);
404 static int cpp_demangle_read_expression_trinary(struct cpp_demangle_data *,
405 const char *, size_t, const char *, size_t);
406 static int cpp_demangle_read_function(struct cpp_demangle_data *, int *,
407 struct vector_type_qualifier *);
408 static int cpp_demangle_local_source_name(struct cpp_demangle_data *ddata);
409 static int cpp_demangle_read_local_name(struct cpp_demangle_data *);
410 static int cpp_demangle_read_name(struct cpp_demangle_data *);
411 static int cpp_demangle_read_nested_name(struct cpp_demangle_data *);
412 static int cpp_demangle_read_number(struct cpp_demangle_data *, long *);
413 static int cpp_demangle_read_nv_offset(struct cpp_demangle_data *);
414 static int cpp_demangle_read_offset(struct cpp_demangle_data *);
415 static int cpp_demangle_read_offset_number(struct cpp_demangle_data *);
416 static int cpp_demangle_read_pointer_to_member(struct cpp_demangle_data *);
417 static int cpp_demangle_read_sname(struct cpp_demangle_data *);
418 static int cpp_demangle_read_subst(struct cpp_demangle_data *);
419 static int cpp_demangle_read_subst_std(struct cpp_demangle_data *);
420 static int cpp_demangle_read_subst_stdtmpl(struct cpp_demangle_data *,
421 const char *, size_t);
422 static int cpp_demangle_read_tmpl_arg(struct cpp_demangle_data *);
423 static int cpp_demangle_read_tmpl_args(struct cpp_demangle_data *);
424 static int cpp_demangle_read_tmpl_param(struct cpp_demangle_data *);
425 static int cpp_demangle_read_type(struct cpp_demangle_data *, int);
426 static int cpp_demangle_read_uqname(struct cpp_demangle_data *);
427 static int cpp_demangle_read_v_offset(struct cpp_demangle_data *);
428 static char *decode_fp_to_double(const char *, size_t);
429 static char *decode_fp_to_float(const char *, size_t);
430 static char *decode_fp_to_float128(const char *, size_t);
431 static char *decode_fp_to_float80(const char *, size_t);
432 static char *decode_fp_to_long_double(const char *, size_t);
433 static int hex_to_dec(char);
434 static void vector_read_cmd_dest(struct vector_read_cmd *);
435 static int vector_read_cmd_find(struct vector_read_cmd *, enum read_cmd);
436 static int vector_read_cmd_init(struct vector_read_cmd *);
437 static int vector_read_cmd_pop(struct vector_read_cmd *);
438 static int vector_read_cmd_push(struct vector_read_cmd *, enum read_cmd);
439 static void vector_type_qualifier_dest(struct vector_type_qualifier *);
440 static int vector_type_qualifier_init(struct vector_type_qualifier *);
441 static int vector_type_qualifier_push(struct vector_type_qualifier *,
442 enum type_qualifier);
445 * @brief Decode the input string by IA-64 C++ ABI style.
447 * GNU GCC v3 use IA-64 standard ABI.
448 * @return New allocated demangled string or NULL if failed.
449 * @todo 1. Testing and more test case. 2. Code cleaning.
452 __cxa_demangle_gnu3(const char *org)
454 struct cpp_demangle_data ddata;
462 org_len = strlen(org);
463 if (org_len > 11 && !strncmp(org, "_GLOBAL__I_", 11)) {
464 if ((rtn = malloc(org_len + 19)) == NULL)
466 snprintf(rtn, org_len + 19,
467 "global constructors keyed to %s", org + 11);
471 // Try demangling as a type for short encodings
472 if ((org_len < 2) || (org[0] != '_' || org[1] != 'Z' )) {
473 if (!cpp_demangle_data_init(&ddata, org))
475 if (!cpp_demangle_read_type(&ddata, 0))
477 rtn = vector_str_get_flat(&ddata.output, (size_t *) NULL);
482 if (!cpp_demangle_data_init(&ddata, org + 2))
487 if (!cpp_demangle_read_encoding(&ddata))
491 while (*ddata.cur != '\0') {
493 * Breaking at some gcc info at tail. e.g) @@GLIBCXX_3.4
495 if (*ddata.cur == '@' && *(ddata.cur + 1) == '@')
497 if (!cpp_demangle_read_type(&ddata, 1))
499 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
503 if (ddata.output.size == 0)
505 if (ddata.paren && !vector_str_push(&ddata.output, ")", 1))
507 if (ddata.mem_vat && !vector_str_push(&ddata.output, " volatile", 9))
509 if (ddata.mem_cst && !vector_str_push(&ddata.output, " const", 6))
511 if (ddata.mem_rst && !vector_str_push(&ddata.output, " restrict", 9))
514 rtn = vector_str_get_flat(&ddata.output, (size_t *) NULL);
517 cpp_demangle_data_dest(&ddata);
523 cpp_demangle_data_dest(struct cpp_demangle_data *d)
529 vector_read_cmd_dest(&d->cmd);
530 vector_str_dest(&d->class_type);
531 vector_str_dest(&d->tmpl);
532 vector_str_dest(&d->subst);
533 vector_str_dest(&d->output_tmp);
534 vector_str_dest(&d->output);
538 cpp_demangle_data_init(struct cpp_demangle_data *d, const char *cur)
541 if (d == NULL || cur == NULL)
544 if (!vector_str_init(&d->output))
546 if (!vector_str_init(&d->output_tmp))
548 if (!vector_str_init(&d->subst))
550 if (!vector_str_init(&d->tmpl))
552 if (!vector_str_init(&d->class_type))
554 if (!vector_read_cmd_init(&d->cmd))
557 assert(d->output.container != NULL);
558 assert(d->output_tmp.container != NULL);
559 assert(d->subst.container != NULL);
560 assert(d->tmpl.container != NULL);
561 assert(d->class_type.container != NULL);
570 d->last_sname = NULL;
576 vector_str_dest(&d->class_type);
578 vector_str_dest(&d->tmpl);
580 vector_str_dest(&d->subst);
582 vector_str_dest(&d->output_tmp);
584 vector_str_dest(&d->output);
590 cpp_demangle_push_fp(struct cpp_demangle_data *ddata,
591 char *(*decoder)(const char *, size_t))
598 if (ddata == NULL || decoder == NULL)
602 while (*ddata->cur != 'E')
606 if ((f = decoder(fp, ddata->cur - fp)) == NULL)
610 if ((len = strlen(f)) > 0)
611 rtn = cpp_demangle_push_str(ddata, f, len);
619 cpp_demangle_push_str(struct cpp_demangle_data *ddata, const char *str,
623 if (ddata == NULL || str == NULL || len == 0)
626 if (ddata->push_head > 0)
627 return (vector_str_push(&ddata->output_tmp, str, len));
629 return (vector_str_push(&ddata->output, str, len));
633 cpp_demangle_push_subst(struct cpp_demangle_data *ddata, const char *str,
637 if (ddata == NULL || str == NULL || len == 0)
640 if (!vector_str_find(&ddata->subst, str, len))
641 return (vector_str_push(&ddata->subst, str, len));
647 cpp_demangle_push_subst_v(struct cpp_demangle_data *ddata, struct vector_str *v)
653 if (ddata == NULL || v == NULL)
656 if ((str = vector_str_get_flat(v, &str_len)) == NULL)
659 rtn = cpp_demangle_push_subst(ddata, str, str_len);
667 cpp_demangle_push_type_qualifier(struct cpp_demangle_data *ddata,
668 struct vector_type_qualifier *v, const char *type_str)
670 struct vector_str subst_v;
671 size_t idx, e_idx, e_len;
675 if (ddata == NULL || v == NULL)
678 if ((idx = v->size) == 0)
682 if (type_str != NULL) {
683 if (!vector_str_init(&subst_v))
685 if (!vector_str_push(&subst_v, type_str, strlen(type_str)))
691 switch (v->q_container[idx - 1]) {
693 if (!cpp_demangle_push_str(ddata, "*", 1))
695 if (type_str != NULL) {
696 if (!vector_str_push(&subst_v, "*", 1))
698 if (!cpp_demangle_push_subst_v(ddata, &subst_v))
704 if (!cpp_demangle_push_str(ddata, "&", 1))
706 if (type_str != NULL) {
707 if (!vector_str_push(&subst_v, "&", 1))
709 if (!cpp_demangle_push_subst_v(ddata, &subst_v))
715 if (!cpp_demangle_push_str(ddata, " complex", 8))
717 if (type_str != NULL) {
718 if (!vector_str_push(&subst_v, " complex", 8))
720 if (!cpp_demangle_push_subst_v(ddata, &subst_v))
726 if (!cpp_demangle_push_str(ddata, " imaginary", 10))
728 if (type_str != NULL) {
729 if (!vector_str_push(&subst_v, " imaginary", 10))
731 if (!cpp_demangle_push_subst_v(ddata, &subst_v))
737 if (e_idx > v->ext_name.size - 1)
739 if ((e_len = strlen(v->ext_name.container[e_idx])) == 0)
741 if ((buf = malloc(sizeof(char) * (e_len + 1))) == NULL)
745 memcpy(buf + 1, v->ext_name.container[e_idx], e_len);
747 if (!cpp_demangle_push_str(ddata, buf, e_len + 1)) {
752 if (type_str != NULL) {
753 if (!vector_str_push(&subst_v, buf,
758 if (!cpp_demangle_push_subst_v(ddata, &subst_v)) {
768 if (!cpp_demangle_push_str(ddata, " restrict", 9))
770 if (type_str != NULL) {
771 if (!vector_str_push(&subst_v, " restrict", 9))
773 if (!cpp_demangle_push_subst_v(ddata, &subst_v))
779 if (!cpp_demangle_push_str(ddata, " volatile", 9))
781 if (type_str != NULL) {
782 if (!vector_str_push(&subst_v, " volatile", 9))
784 if (!cpp_demangle_push_subst_v(ddata, &subst_v))
790 if (!cpp_demangle_push_str(ddata, " const", 6))
792 if (type_str != NULL) {
793 if (!vector_str_push(&subst_v, " const", 6))
795 if (!cpp_demangle_push_subst_v(ddata, &subst_v))
806 if (type_str != NULL)
807 vector_str_dest(&subst_v);
813 cpp_demangle_get_subst(struct cpp_demangle_data *ddata, size_t idx)
817 if (ddata == NULL || ddata->subst.size <= idx)
819 if ((len = strlen(ddata->subst.container[idx])) == 0)
821 if (!cpp_demangle_push_str(ddata, ddata->subst.container[idx], len))
831 cpp_demangle_get_tmpl_param(struct cpp_demangle_data *ddata, size_t idx)
835 if (ddata == NULL || ddata->tmpl.size <= idx)
837 if ((len = strlen(ddata->tmpl.container[idx])) == 0)
839 if (!cpp_demangle_push_str(ddata, ddata->tmpl.container[idx], len))
848 cpp_demangle_read_array(struct cpp_demangle_data *ddata)
850 size_t i, num_len, exp_len, p_idx, idx;
854 if (ddata == NULL || *(++ddata->cur) == '\0')
857 if (*ddata->cur == '_') {
858 if (*(++ddata->cur) == '\0')
861 if (!cpp_demangle_read_type(ddata, 0))
864 if (!cpp_demangle_push_str(ddata, "[]", 2))
867 if (ELFTC_ISDIGIT(*ddata->cur) != 0) {
869 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
871 if (*ddata->cur != '_')
873 num_len = ddata->cur - num;
875 if (*(++ddata->cur) == '\0')
877 if (!cpp_demangle_read_type(ddata, 0))
879 if (!cpp_demangle_push_str(ddata, "[", 1))
881 if (!cpp_demangle_push_str(ddata, num, num_len))
883 if (!cpp_demangle_push_str(ddata, "]", 1))
886 p_idx = ddata->output.size;
887 if (!cpp_demangle_read_expression(ddata))
889 if ((exp = vector_str_substr(&ddata->output, p_idx,
890 ddata->output.size - 1, &exp_len)) == NULL)
892 idx = ddata->output.size;
893 for (i = p_idx; i < idx; ++i)
894 if (!vector_str_pop(&ddata->output)) {
898 if (*ddata->cur != '_') {
903 if (*ddata->cur == '\0') {
907 if (!cpp_demangle_read_type(ddata, 0)) {
911 if (!cpp_demangle_push_str(ddata, "[", 1)) {
915 if (!cpp_demangle_push_str(ddata, exp, exp_len)) {
919 if (!cpp_demangle_push_str(ddata, "]", 1)) {
931 cpp_demangle_read_expr_primary(struct cpp_demangle_data *ddata)
935 if (ddata == NULL || *(++ddata->cur) == '\0')
938 if (*ddata->cur == '_' && *(ddata->cur + 1) == 'Z') {
940 if (*ddata->cur == '\0')
942 if (!cpp_demangle_read_encoding(ddata))
948 switch (*ddata->cur) {
950 switch (*(++ddata->cur)) {
952 return (cpp_demangle_push_str(ddata, "false", 5));
954 return (cpp_demangle_push_str(ddata, "true", 4));
961 return (cpp_demangle_push_fp(ddata, decode_fp_to_double));
965 if (sizeof(long double) == 10)
966 return (cpp_demangle_push_fp(ddata,
967 decode_fp_to_double));
968 return (cpp_demangle_push_fp(ddata, decode_fp_to_float80));
972 return (cpp_demangle_push_fp(ddata, decode_fp_to_float));
976 if (sizeof(long double) == 16)
977 return (cpp_demangle_push_fp(ddata,
978 decode_fp_to_double));
979 return (cpp_demangle_push_fp(ddata, decode_fp_to_float128));
990 if (*(++ddata->cur) == 'n') {
991 if (!cpp_demangle_push_str(ddata, "-", 1))
996 while (*ddata->cur != 'E') {
997 if (!ELFTC_ISDIGIT(*ddata->cur))
1002 return (cpp_demangle_push_str(ddata, num, ddata->cur - num));
1010 cpp_demangle_read_expression(struct cpp_demangle_data *ddata)
1013 if (ddata == NULL || *ddata->cur == '\0')
1016 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
1017 case SIMPLE_HASH('s', 't'):
1019 return (cpp_demangle_read_type(ddata, 0));
1021 case SIMPLE_HASH('s', 'r'):
1023 if (!cpp_demangle_read_type(ddata, 0))
1025 if (!cpp_demangle_read_uqname(ddata))
1027 if (*ddata->cur == 'I')
1028 return (cpp_demangle_read_tmpl_args(ddata));
1031 case SIMPLE_HASH('a', 'a'):
1034 return (cpp_demangle_read_expression_binary(ddata, "&&", 2));
1036 case SIMPLE_HASH('a', 'd'):
1037 /* operator & (unary) */
1039 return (cpp_demangle_read_expression_unary(ddata, "&", 1));
1041 case SIMPLE_HASH('a', 'n'):
1044 return (cpp_demangle_read_expression_binary(ddata, "&", 1));
1046 case SIMPLE_HASH('a', 'N'):
1049 return (cpp_demangle_read_expression_binary(ddata, "&=", 2));
1051 case SIMPLE_HASH('a', 'S'):
1054 return (cpp_demangle_read_expression_binary(ddata, "=", 1));
1056 case SIMPLE_HASH('c', 'l'):
1059 return (cpp_demangle_read_expression_binary(ddata, "()", 2));
1061 case SIMPLE_HASH('c', 'm'):
1064 return (cpp_demangle_read_expression_binary(ddata, ",", 1));
1066 case SIMPLE_HASH('c', 'o'):
1069 return (cpp_demangle_read_expression_binary(ddata, "~", 1));
1071 case SIMPLE_HASH('c', 'v'):
1072 /* operator (cast) */
1074 return (cpp_demangle_read_expression_binary(ddata, "(cast)", 6));
1076 case SIMPLE_HASH('d', 'a'):
1077 /* operator delete [] */
1079 return (cpp_demangle_read_expression_unary(ddata, "delete []", 9));
1081 case SIMPLE_HASH('d', 'e'):
1082 /* operator * (unary) */
1084 return (cpp_demangle_read_expression_unary(ddata, "*", 1));
1086 case SIMPLE_HASH('d', 'l'):
1087 /* operator delete */
1089 return (cpp_demangle_read_expression_unary(ddata, "delete", 6));
1091 case SIMPLE_HASH('d', 'v'):
1094 return (cpp_demangle_read_expression_binary(ddata, "/", 1));
1096 case SIMPLE_HASH('d', 'V'):
1099 return (cpp_demangle_read_expression_binary(ddata, "/=", 2));
1101 case SIMPLE_HASH('e', 'o'):
1104 return (cpp_demangle_read_expression_binary(ddata, "^", 1));
1106 case SIMPLE_HASH('e', 'O'):
1109 return (cpp_demangle_read_expression_binary(ddata, "^=", 2));
1111 case SIMPLE_HASH('e', 'q'):
1114 return (cpp_demangle_read_expression_binary(ddata, "==", 2));
1116 case SIMPLE_HASH('g', 'e'):
1119 return (cpp_demangle_read_expression_binary(ddata, ">=", 2));
1121 case SIMPLE_HASH('g', 't'):
1124 return (cpp_demangle_read_expression_binary(ddata, ">", 1));
1126 case SIMPLE_HASH('i', 'x'):
1129 return (cpp_demangle_read_expression_binary(ddata, "[]", 2));
1131 case SIMPLE_HASH('l', 'e'):
1134 return (cpp_demangle_read_expression_binary(ddata, "<=", 2));
1136 case SIMPLE_HASH('l', 's'):
1139 return (cpp_demangle_read_expression_binary(ddata, "<<", 2));
1141 case SIMPLE_HASH('l', 'S'):
1144 return (cpp_demangle_read_expression_binary(ddata, "<<=", 3));
1146 case SIMPLE_HASH('l', 't'):
1149 return (cpp_demangle_read_expression_binary(ddata, "<", 1));
1151 case SIMPLE_HASH('m', 'i'):
1154 return (cpp_demangle_read_expression_binary(ddata, "-", 1));
1156 case SIMPLE_HASH('m', 'I'):
1159 return (cpp_demangle_read_expression_binary(ddata, "-=", 2));
1161 case SIMPLE_HASH('m', 'l'):
1164 return (cpp_demangle_read_expression_binary(ddata, "*", 1));
1166 case SIMPLE_HASH('m', 'L'):
1169 return (cpp_demangle_read_expression_binary(ddata, "*=", 2));
1171 case SIMPLE_HASH('m', 'm'):
1174 return (cpp_demangle_read_expression_binary(ddata, "--", 2));
1176 case SIMPLE_HASH('n', 'a'):
1177 /* operator new[] */
1179 return (cpp_demangle_read_expression_unary(ddata, "new []", 6));
1181 case SIMPLE_HASH('n', 'e'):
1184 return (cpp_demangle_read_expression_binary(ddata, "!=", 2));
1186 case SIMPLE_HASH('n', 'g'):
1187 /* operator - (unary) */
1189 return (cpp_demangle_read_expression_unary(ddata, "-", 1));
1191 case SIMPLE_HASH('n', 't'):
1194 return (cpp_demangle_read_expression_binary(ddata, "!", 1));
1196 case SIMPLE_HASH('n', 'w'):
1199 return (cpp_demangle_read_expression_unary(ddata, "new", 3));
1201 case SIMPLE_HASH('o', 'o'):
1204 return (cpp_demangle_read_expression_binary(ddata, "||", 2));
1206 case SIMPLE_HASH('o', 'r'):
1209 return (cpp_demangle_read_expression_binary(ddata, "|", 1));
1211 case SIMPLE_HASH('o', 'R'):
1214 return (cpp_demangle_read_expression_binary(ddata, "|=", 2));
1216 case SIMPLE_HASH('p', 'l'):
1219 return (cpp_demangle_read_expression_binary(ddata, "+", 1));
1221 case SIMPLE_HASH('p', 'L'):
1224 return (cpp_demangle_read_expression_binary(ddata, "+=", 2));
1226 case SIMPLE_HASH('p', 'm'):
1229 return (cpp_demangle_read_expression_binary(ddata, "->*", 3));
1231 case SIMPLE_HASH('p', 'p'):
1234 return (cpp_demangle_read_expression_binary(ddata, "++", 2));
1236 case SIMPLE_HASH('p', 's'):
1237 /* operator + (unary) */
1239 return (cpp_demangle_read_expression_unary(ddata, "+", 1));
1241 case SIMPLE_HASH('p', 't'):
1244 return (cpp_demangle_read_expression_binary(ddata, "->", 2));
1246 case SIMPLE_HASH('q', 'u'):
1249 return (cpp_demangle_read_expression_trinary(ddata, "?", 1,
1252 case SIMPLE_HASH('r', 'm'):
1255 return (cpp_demangle_read_expression_binary(ddata, "%", 1));
1257 case SIMPLE_HASH('r', 'M'):
1260 return (cpp_demangle_read_expression_binary(ddata, "%=", 2));
1262 case SIMPLE_HASH('r', 's'):
1265 return (cpp_demangle_read_expression_binary(ddata, ">>", 2));
1267 case SIMPLE_HASH('r', 'S'):
1270 return (cpp_demangle_read_expression_binary(ddata, ">>=", 3));
1272 case SIMPLE_HASH('r', 'z'):
1273 /* operator sizeof */
1275 return (cpp_demangle_read_expression_unary(ddata, "sizeof", 6));
1277 case SIMPLE_HASH('s', 'v'):
1278 /* operator sizeof */
1280 return (cpp_demangle_read_expression_unary(ddata, "sizeof", 6));
1283 switch (*ddata->cur) {
1285 return (cpp_demangle_read_expr_primary(ddata));
1287 return (cpp_demangle_read_tmpl_param(ddata));
1294 cpp_demangle_read_expression_binary(struct cpp_demangle_data *ddata,
1295 const char *name, size_t len)
1298 if (ddata == NULL || name == NULL || len == 0)
1300 if (!cpp_demangle_read_expression(ddata))
1302 if (!cpp_demangle_push_str(ddata, name, len))
1305 return (cpp_demangle_read_expression(ddata));
1309 cpp_demangle_read_expression_unary(struct cpp_demangle_data *ddata,
1310 const char *name, size_t len)
1313 if (ddata == NULL || name == NULL || len == 0)
1315 if (!cpp_demangle_read_expression(ddata))
1318 return (cpp_demangle_push_str(ddata, name, len));
1322 cpp_demangle_read_expression_trinary(struct cpp_demangle_data *ddata,
1323 const char *name1, size_t len1, const char *name2, size_t len2)
1326 if (ddata == NULL || name1 == NULL || len1 == 0 || name2 == NULL ||
1330 if (!cpp_demangle_read_expression(ddata))
1332 if (!cpp_demangle_push_str(ddata, name1, len1))
1334 if (!cpp_demangle_read_expression(ddata))
1336 if (!cpp_demangle_push_str(ddata, name2, len2))
1339 return (cpp_demangle_read_expression(ddata));
1343 cpp_demangle_read_function(struct cpp_demangle_data *ddata, int *ext_c,
1344 struct vector_type_qualifier *v)
1346 size_t class_type_size, class_type_len, limit;
1347 const char *class_type;
1349 if (ddata == NULL || *ddata->cur != 'F' || v == NULL)
1353 if (*ddata->cur == 'Y') {
1358 if (!cpp_demangle_read_type(ddata, 0))
1360 if (*ddata->cur != 'E') {
1361 if (!cpp_demangle_push_str(ddata, "(", 1))
1363 if (vector_read_cmd_find(&ddata->cmd, READ_PTRMEM)) {
1364 if ((class_type_size = ddata->class_type.size) == 0)
1367 ddata->class_type.container[class_type_size - 1];
1368 if (class_type == NULL)
1370 if ((class_type_len = strlen(class_type)) == 0)
1372 if (!cpp_demangle_push_str(ddata, class_type,
1375 if (!cpp_demangle_push_str(ddata, "::*", 3))
1379 if (!cpp_demangle_push_type_qualifier(ddata, v,
1380 (const char *) NULL))
1382 vector_type_qualifier_dest(v);
1383 if (!vector_type_qualifier_init(v))
1387 if (!cpp_demangle_push_str(ddata, ")(", 2))
1392 if (!cpp_demangle_read_type(ddata, 0))
1394 if (*ddata->cur == 'E')
1396 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
1400 if (vector_read_cmd_find(&ddata->cmd, READ_PTRMEM) == 1) {
1401 if (!cpp_demangle_push_type_qualifier(ddata, v,
1402 (const char *) NULL))
1404 vector_type_qualifier_dest(v);
1405 if (!vector_type_qualifier_init(v))
1409 if (!cpp_demangle_push_str(ddata, ")", 1))
1418 /* read encoding, encoding are function name, data name, special-name */
1420 cpp_demangle_read_encoding(struct cpp_demangle_data *ddata)
1423 if (ddata == NULL || *ddata->cur == '\0')
1427 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
1428 case SIMPLE_HASH('G', 'V'):
1429 /* sentry object for 1 time init */
1430 if (!cpp_demangle_push_str(ddata, "guard variable for ", 20))
1435 case SIMPLE_HASH('T', 'c'):
1436 /* virtual function covariant override thunk */
1437 if (!cpp_demangle_push_str(ddata,
1438 "virtual function covariant override ", 36))
1441 if (*ddata->cur == '\0')
1443 if (!cpp_demangle_read_offset(ddata))
1445 if (!cpp_demangle_read_offset(ddata))
1447 return (cpp_demangle_read_encoding(ddata));
1449 case SIMPLE_HASH('T', 'D'):
1450 /* typeinfo common proxy */
1453 case SIMPLE_HASH('T', 'h'):
1454 /* virtual function non-virtual override thunk */
1455 if (cpp_demangle_push_str(ddata,
1456 "virtual function non-virtual override ", 38) == 0)
1459 if (*ddata->cur == '\0')
1461 if (!cpp_demangle_read_nv_offset(ddata))
1463 return (cpp_demangle_read_encoding(ddata));
1465 case SIMPLE_HASH('T', 'I'):
1466 /* typeinfo structure */
1468 case SIMPLE_HASH('T', 'S'):
1469 /* RTTI name (NTBS) */
1470 if (!cpp_demangle_push_str(ddata, "typeinfo for ", 14))
1473 if (*ddata->cur == '\0')
1475 return (cpp_demangle_read_type(ddata, 1));
1477 case SIMPLE_HASH('T', 'T'):
1479 if (!cpp_demangle_push_str(ddata, "VTT for ", 8))
1482 return (cpp_demangle_read_type(ddata, 1));
1484 case SIMPLE_HASH('T', 'v'):
1485 /* virtual function virtual override thunk */
1486 if (!cpp_demangle_push_str(ddata,
1487 "virtual function virtual override ", 34))
1490 if (*ddata->cur == '\0')
1492 if (!cpp_demangle_read_v_offset(ddata))
1494 return (cpp_demangle_read_encoding(ddata));
1496 case SIMPLE_HASH('T', 'V'):
1498 if (!cpp_demangle_push_str(ddata, "vtable for ", 12))
1501 if (*ddata->cur == '\0')
1503 return (cpp_demangle_read_type(ddata, 1));
1506 return (cpp_demangle_read_name(ddata));
1510 cpp_demangle_read_local_name(struct cpp_demangle_data *ddata)
1516 if (*(++ddata->cur) == '\0')
1518 if (!cpp_demangle_read_encoding(ddata))
1523 if (!cpp_demangle_read_type(ddata, 1))
1525 if (*ddata->cur == 'E')
1527 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
1530 if (*(++ddata->cur) == '\0')
1532 if (ddata->paren == true) {
1533 if (!cpp_demangle_push_str(ddata, ")", 1))
1535 ddata->paren = false;
1537 if (*ddata->cur == 's')
1540 if (!cpp_demangle_push_str(ddata, "::", 2))
1542 if (!cpp_demangle_read_name(ddata))
1545 if (*ddata->cur == '_') {
1547 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
1555 cpp_demangle_read_name(struct cpp_demangle_data *ddata)
1557 struct vector_str *output, v;
1558 size_t p_idx, subst_str_len;
1562 if (ddata == NULL || *ddata->cur == '\0')
1565 output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
1569 switch (*ddata->cur) {
1571 return (cpp_demangle_read_subst(ddata));
1573 return (cpp_demangle_read_nested_name(ddata));
1575 return (cpp_demangle_read_local_name(ddata));
1578 if (!vector_str_init(&v))
1581 p_idx = output->size;
1583 if (!cpp_demangle_read_uqname(ddata))
1585 if ((subst_str = vector_str_substr(output, p_idx, output->size - 1,
1586 &subst_str_len)) == NULL)
1588 if (subst_str_len > 8 && strstr(subst_str, "operator") != NULL) {
1592 if (!vector_str_push(&v, subst_str, subst_str_len))
1594 if (!cpp_demangle_push_subst_v(ddata, &v))
1597 if (*ddata->cur == 'I') {
1598 p_idx = output->size;
1599 if (!cpp_demangle_read_tmpl_args(ddata))
1602 if ((subst_str = vector_str_substr(output, p_idx,
1603 output->size - 1, &subst_str_len)) == NULL)
1605 if (!vector_str_push(&v, subst_str, subst_str_len))
1607 if (!cpp_demangle_push_subst_v(ddata, &v))
1615 vector_str_dest(&v);
1621 cpp_demangle_read_nested_name(struct cpp_demangle_data *ddata)
1623 struct vector_str *output, v;
1624 size_t limit, p_idx, subst_str_len;
1628 if (ddata == NULL || *ddata->cur != 'N')
1630 if (*(++ddata->cur) == '\0')
1633 while (*ddata->cur == 'r' || *ddata->cur == 'V' ||
1634 *ddata->cur == 'K') {
1635 switch (*ddata->cur) {
1637 ddata->mem_rst = true;
1640 ddata->mem_vat = true;
1643 ddata->mem_cst = true;
1649 output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
1650 if (!vector_str_init(&v))
1656 p_idx = output->size;
1657 switch (*ddata->cur) {
1659 if (!cpp_demangle_read_tmpl_args(ddata))
1663 if (!cpp_demangle_read_subst(ddata))
1667 if (!cpp_demangle_read_tmpl_param(ddata))
1671 if (!cpp_demangle_read_uqname(ddata))
1675 if ((subst_str = vector_str_substr(output, p_idx,
1676 output->size - 1, &subst_str_len)) == NULL)
1678 if (!vector_str_push(&v, subst_str, subst_str_len)) {
1684 if (!cpp_demangle_push_subst_v(ddata, &v))
1686 if (*ddata->cur == 'E')
1688 else if (*ddata->cur != 'I' &&
1689 *ddata->cur != 'C' && *ddata->cur != 'D') {
1690 if (!cpp_demangle_push_str(ddata, "::", 2))
1692 if (!vector_str_push(&v, "::", 2))
1695 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
1703 vector_str_dest(&v);
1710 * number ::= [n] <decimal>
1713 cpp_demangle_read_number(struct cpp_demangle_data *ddata, long *rtn)
1715 long len, negative_factor;
1717 if (ddata == NULL || rtn == NULL)
1720 negative_factor = 1;
1721 if (*ddata->cur == 'n') {
1722 negative_factor = -1;
1726 if (ELFTC_ISDIGIT(*ddata->cur) == 0)
1730 if ((len = strtol(ddata->cur, (char **) NULL, 10)) == 0 &&
1734 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
1738 assert(negative_factor == 1 || negative_factor == -1);
1740 *rtn = len * negative_factor;
1746 cpp_demangle_read_nv_offset(struct cpp_demangle_data *ddata)
1752 if (!cpp_demangle_push_str(ddata, "offset : ", 9))
1755 return (cpp_demangle_read_offset_number(ddata));
1758 /* read offset, offset are nv-offset, v-offset */
1760 cpp_demangle_read_offset(struct cpp_demangle_data *ddata)
1766 if (*ddata->cur == 'h') {
1768 return (cpp_demangle_read_nv_offset(ddata));
1769 } else if (*ddata->cur == 'v') {
1771 return (cpp_demangle_read_v_offset(ddata));
1778 cpp_demangle_read_offset_number(struct cpp_demangle_data *ddata)
1783 if (ddata == NULL || *ddata->cur == '\0')
1786 /* offset could be negative */
1787 if (*ddata->cur == 'n') {
1789 start = ddata->cur + 1;
1795 while (*ddata->cur != '_')
1798 if (negative && !cpp_demangle_push_str(ddata, "-", 1))
1801 assert(start != NULL);
1803 if (!cpp_demangle_push_str(ddata, start, ddata->cur - start))
1805 if (!cpp_demangle_push_str(ddata, " ", 1))
1814 cpp_demangle_read_pointer_to_member(struct cpp_demangle_data *ddata)
1816 size_t class_type_len, i, idx, p_idx;
1817 int p_func_type, rtn;
1820 if (ddata == NULL || *ddata->cur != 'M' || *(++ddata->cur) == '\0')
1823 p_idx = ddata->output.size;
1824 if (!cpp_demangle_read_type(ddata, 0))
1827 if ((class_type = vector_str_substr(&ddata->output, p_idx,
1828 ddata->output.size - 1, &class_type_len)) == NULL)
1832 idx = ddata->output.size;
1833 for (i = p_idx; i < idx; ++i)
1834 if (!vector_str_pop(&ddata->output))
1837 if (!vector_read_cmd_push(&ddata->cmd, READ_PTRMEM))
1840 if (!vector_str_push(&ddata->class_type, class_type, class_type_len))
1843 p_func_type = ddata->func_type;
1844 if (!cpp_demangle_read_type(ddata, 0))
1847 if (p_func_type == ddata->func_type) {
1848 if (!cpp_demangle_push_str(ddata, " ", 1))
1850 if (!cpp_demangle_push_str(ddata, class_type, class_type_len))
1852 if (!cpp_demangle_push_str(ddata, "::*", 3))
1858 if (!vector_str_pop(&ddata->class_type))
1861 if (!vector_read_cmd_pop(&ddata->cmd))
1869 /* read source-name, source-name is <len> <ID> */
1871 cpp_demangle_read_sname(struct cpp_demangle_data *ddata)
1876 if (ddata == NULL || cpp_demangle_read_number(ddata, &len) == 0 ||
1880 if (len == 12 && (memcmp("_GLOBAL__N_1", ddata->cur, 12) == 0))
1881 err = cpp_demangle_push_str(ddata, "(anonymous namespace)", 21);
1883 err = cpp_demangle_push_str(ddata, ddata->cur, len);
1888 assert(ddata->output.size > 0);
1889 if (vector_read_cmd_find(&ddata->cmd, READ_TMPL) == 0)
1891 ddata->output.container[ddata->output.size - 1];
1899 cpp_demangle_read_subst(struct cpp_demangle_data *ddata)
1903 if (ddata == NULL || *ddata->cur == '\0')
1906 /* abbreviations of the form Sx */
1907 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
1908 case SIMPLE_HASH('S', 'a'):
1909 /* std::allocator */
1910 if (cpp_demangle_push_str(ddata, "std::allocator", 14) == 0)
1913 if (*ddata->cur == 'I')
1914 return (cpp_demangle_read_subst_stdtmpl(ddata,
1915 "std::allocator", 14));
1918 case SIMPLE_HASH('S', 'b'):
1919 /* std::basic_string */
1920 if (!cpp_demangle_push_str(ddata, "std::basic_string", 17))
1923 if (*ddata->cur == 'I')
1924 return (cpp_demangle_read_subst_stdtmpl(ddata,
1925 "std::basic_string", 17));
1928 case SIMPLE_HASH('S', 'd'):
1929 /* std::basic_iostream<char, std::char_traits<char> > */
1930 if (!cpp_demangle_push_str(ddata, "std::iostream", 19))
1932 ddata->last_sname = "iostream";
1934 if (*ddata->cur == 'I')
1935 return (cpp_demangle_read_subst_stdtmpl(ddata,
1936 "std::iostream", 19));
1939 case SIMPLE_HASH('S', 'i'):
1940 /* std::basic_istream<char, std::char_traits<char> > */
1941 if (!cpp_demangle_push_str(ddata, "std::istream", 18))
1943 ddata->last_sname = "istream";
1945 if (*ddata->cur == 'I')
1946 return (cpp_demangle_read_subst_stdtmpl(ddata,
1947 "std::istream", 18));
1950 case SIMPLE_HASH('S', 'o'):
1951 /* std::basic_ostream<char, std::char_traits<char> > */
1952 if (!cpp_demangle_push_str(ddata, "std::ostream", 18))
1954 ddata->last_sname = "istream";
1956 if (*ddata->cur == 'I')
1957 return (cpp_demangle_read_subst_stdtmpl(ddata,
1958 "std::ostream", 18));
1961 case SIMPLE_HASH('S', 's'):
1963 * std::basic_string<char, std::char_traits<char>,
1964 * std::allocator<char> >
1968 if (!cpp_demangle_push_str(ddata, "std::string", 11))
1970 ddata->last_sname = "string";
1972 if (*ddata->cur == 'I')
1973 return (cpp_demangle_read_subst_stdtmpl(ddata,
1974 "std::string", 11));
1977 case SIMPLE_HASH('S', 't'):
1979 return (cpp_demangle_read_subst_std(ddata));
1982 if (*(++ddata->cur) == '\0')
1986 if (*ddata->cur == '_')
1987 return (cpp_demangle_get_subst(ddata, 0));
1990 /* substitution number is base 36 */
1991 if ((nth = strtol(ddata->cur, (char **) NULL, 36)) == 0 &&
1995 /* first was '_', so increase one */
1998 while (*ddata->cur != '_')
2003 return (cpp_demangle_get_subst(ddata, nth));
2011 cpp_demangle_read_subst_std(struct cpp_demangle_data *ddata)
2013 struct vector_str *output, v;
2014 size_t p_idx, subst_str_len;
2021 if (!vector_str_init(&v))
2026 if (!cpp_demangle_push_str(ddata, "std::", 5))
2029 if (!vector_str_push(&v, "std::", 5))
2034 output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
2036 p_idx = output->size;
2037 if (!cpp_demangle_read_uqname(ddata))
2040 if ((subst_str = vector_str_substr(output, p_idx, output->size - 1,
2041 &subst_str_len)) == NULL)
2044 if (!vector_str_push(&v, subst_str, subst_str_len))
2047 if (!cpp_demangle_push_subst_v(ddata, &v))
2050 if (*ddata->cur == 'I') {
2051 p_idx = output->size;
2052 if (!cpp_demangle_read_tmpl_args(ddata))
2055 if ((subst_str = vector_str_substr(output, p_idx,
2056 output->size - 1, &subst_str_len)) == NULL)
2058 if (!vector_str_push(&v, subst_str, subst_str_len))
2060 if (!cpp_demangle_push_subst_v(ddata, &v))
2067 vector_str_dest(&v);
2073 cpp_demangle_read_subst_stdtmpl(struct cpp_demangle_data *ddata,
2074 const char *str, size_t len)
2076 struct vector_str *output;
2077 size_t p_idx, substr_len;
2079 char *subst_str, *substr;
2081 if (ddata == NULL || str == NULL || len == 0)
2084 output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
2086 p_idx = output->size;
2090 if (!cpp_demangle_read_tmpl_args(ddata))
2092 if ((substr = vector_str_substr(output, p_idx, output->size - 1,
2093 &substr_len)) == NULL)
2097 if ((subst_str = malloc(sizeof(char) * (substr_len + len + 1))) ==
2101 memcpy(subst_str, str, len);
2102 memcpy(subst_str + len, substr, substr_len);
2103 subst_str[substr_len + len] = '\0';
2105 if (!cpp_demangle_push_subst(ddata, subst_str, substr_len + len))
2117 cpp_demangle_read_tmpl_arg(struct cpp_demangle_data *ddata)
2120 if (ddata == NULL || *ddata->cur == '\0')
2123 switch (*ddata->cur) {
2125 return (cpp_demangle_read_expr_primary(ddata));
2127 return (cpp_demangle_read_expression(ddata));
2130 return (cpp_demangle_read_type(ddata, 0));
2134 cpp_demangle_read_tmpl_args(struct cpp_demangle_data *ddata)
2136 struct vector_str *v;
2137 size_t arg_len, idx, limit, size;
2140 if (ddata == NULL || *ddata->cur == '\0')
2145 if (!vector_read_cmd_push(&ddata->cmd, READ_TMPL))
2148 if (!cpp_demangle_push_str(ddata, "<", 1))
2152 v = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
2155 if (!cpp_demangle_read_tmpl_arg(ddata))
2157 if ((arg = vector_str_substr(v, idx, v->size - 1, &arg_len)) ==
2160 if (!vector_str_find(&ddata->tmpl, arg, arg_len) &&
2161 !vector_str_push(&ddata->tmpl, arg, arg_len)) {
2168 if (*ddata->cur == 'E') {
2172 if (!strncmp(v->container[size - 1], ">", 1)) {
2173 if (!cpp_demangle_push_str(ddata, " >", 2))
2175 } else if (!cpp_demangle_push_str(ddata, ">", 1))
2178 } else if (*ddata->cur != 'I' &&
2179 !cpp_demangle_push_str(ddata, ", ", 2))
2182 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
2186 return (vector_read_cmd_pop(&ddata->cmd));
2190 * Read template parameter that forms in 'T[number]_'.
2191 * This function much like to read_subst but only for types.
2194 cpp_demangle_read_tmpl_param(struct cpp_demangle_data *ddata)
2198 if (ddata == NULL || *ddata->cur != 'T')
2203 if (*ddata->cur == '_')
2204 return (cpp_demangle_get_tmpl_param(ddata, 0));
2208 if ((nth = strtol(ddata->cur, (char **) NULL, 36)) == 0 &&
2215 while (*ddata->cur != '_')
2220 return (cpp_demangle_get_tmpl_param(ddata, nth));
2228 cpp_demangle_read_type(struct cpp_demangle_data *ddata, int delimit)
2230 struct vector_type_qualifier v;
2231 struct vector_str *output;
2232 size_t p_idx, type_str_len;
2233 int extern_c, is_builtin;
2240 output = &ddata->output;
2241 if (ddata->output.size > 0 && !strncmp(ddata->output.container[ddata->output.size - 1], ">", 1)) {
2243 output = &ddata->output_tmp;
2244 } else if (delimit == 1) {
2245 if (ddata->paren == false) {
2246 if (!cpp_demangle_push_str(ddata, "(", 1))
2248 if (ddata->output.size < 2)
2250 ddata->paren = true;
2251 ddata->pfirst = true;
2252 /* Need pop function name */
2253 if (ddata->subst.size == 1 &&
2254 !vector_str_pop(&ddata->subst))
2259 ddata->pfirst = false;
2260 else if (*ddata->cur != 'I' &&
2261 !cpp_demangle_push_str(ddata, ", ", 2))
2265 assert(output != NULL);
2267 * [r, V, K] [P, R, C, G, U] builtin, function, class-enum, array
2268 * pointer-to-member, template-param, template-template-param, subst
2271 if (!vector_type_qualifier_init(&v))
2276 p_idx = output->size;
2280 switch (*ddata->cur) {
2283 if (!cpp_demangle_push_str(ddata, "signed char", 11))
2290 if (!cpp_demangle_read_array(ddata))
2297 if (!cpp_demangle_push_str(ddata, "bool", 4))
2304 if (!vector_type_qualifier_push(&v, TYPE_CMX))
2311 if (!cpp_demangle_push_str(ddata, "char", 4))
2318 if (!cpp_demangle_push_str(ddata, "double", 6))
2325 if (!cpp_demangle_push_str(ddata, "long double", 11))
2332 if (!cpp_demangle_push_str(ddata, "float", 5))
2339 if (!cpp_demangle_read_function(ddata, &extern_c, &v))
2346 if (!cpp_demangle_push_str(ddata, "__float128", 10))
2353 if (!vector_type_qualifier_push(&v, TYPE_IMG))
2360 if (!cpp_demangle_push_str(ddata, "unsigned char", 13))
2367 if (!cpp_demangle_push_str(ddata, "int", 3))
2374 if (!cpp_demangle_push_str(ddata, "unsigned int", 12))
2381 if (!vector_type_qualifier_push(&v, TYPE_CST))
2388 if (!cpp_demangle_push_str(ddata, "long", 4))
2395 if (!cpp_demangle_push_str(ddata, "unsigned long", 13))
2402 /* pointer to member */
2403 if (!cpp_demangle_read_pointer_to_member(ddata))
2410 if (!cpp_demangle_push_str(ddata, "__int128", 8))
2416 /* unsigned __int128 */
2417 if (!cpp_demangle_push_str(ddata, "unsigned _;int128", 17))
2424 if (!vector_type_qualifier_push(&v, TYPE_PTR))
2431 if (!vector_type_qualifier_push(&v, TYPE_RST))
2438 if (!vector_type_qualifier_push(&v, TYPE_REF))
2444 /* short, local string */
2445 if (!cpp_demangle_push_str(ddata, "short", 5))
2452 if (!cpp_demangle_read_subst(ddata))
2458 /* unsigned short */
2459 if (!cpp_demangle_push_str(ddata, "unsigned short", 14))
2465 /* template parameter */
2466 if (!cpp_demangle_read_tmpl_param(ddata))
2472 /* vendor extended builtin */
2474 if (!cpp_demangle_read_sname(ddata))
2480 /* vendor extended type qualifier */
2481 if (!cpp_demangle_read_number(ddata, &len))
2485 if (!vector_str_push(&v.ext_name, ddata->cur, len))
2492 if (!cpp_demangle_push_str(ddata, "void", 4))
2499 if (!vector_type_qualifier_push(&v, TYPE_VAT))
2506 if (!cpp_demangle_push_str(ddata, "wchar_t", 6))
2513 if (!cpp_demangle_push_str(ddata, "long long", 9))
2519 /* unsigned long long */
2520 if (!cpp_demangle_push_str(ddata, "unsigned long long", 18))
2527 if (!cpp_demangle_push_str(ddata, "ellipsis", 8))
2533 if (!cpp_demangle_read_name(ddata))
2538 if ((type_str = vector_str_substr(output, p_idx, output->size - 1,
2539 &type_str_len)) == NULL)
2542 if (is_builtin == 0) {
2543 if (!vector_str_find(&ddata->subst, type_str, type_str_len) &&
2544 !vector_str_push(&ddata->subst, type_str, type_str_len))
2548 if (!cpp_demangle_push_type_qualifier(ddata, &v, type_str))
2552 vector_type_qualifier_dest(&v);
2554 if (ddata->push_head > 0) {
2555 if (*ddata->cur == 'I' && cpp_demangle_read_tmpl_args(ddata)
2559 if (--ddata->push_head > 0)
2562 if (!vector_str_push(&ddata->output_tmp, " ", 1))
2565 if (!vector_str_push_vector_head(&ddata->output,
2566 &ddata->output_tmp))
2569 vector_str_dest(&ddata->output_tmp);
2570 if (!vector_str_init(&ddata->output_tmp))
2573 if (!cpp_demangle_push_str(ddata, "(", 1))
2576 ddata->paren = true;
2577 ddata->pfirst = true;
2583 vector_type_qualifier_dest(&v);
2589 * read unqualified-name, unqualified name are operator-name, ctor-dtor-name,
2593 cpp_demangle_read_uqname(struct cpp_demangle_data *ddata)
2597 if (ddata == NULL || *ddata->cur == '\0')
2601 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
2602 case SIMPLE_HASH('a', 'a'):
2604 if (!cpp_demangle_push_str(ddata, "operator&&", 10))
2609 case SIMPLE_HASH('a', 'd'):
2610 /* operator & (unary) */
2611 if (!cpp_demangle_push_str(ddata, "operator&", 9))
2616 case SIMPLE_HASH('a', 'n'):
2618 if (!cpp_demangle_push_str(ddata, "operator&", 9))
2623 case SIMPLE_HASH('a', 'N'):
2625 if (!cpp_demangle_push_str(ddata, "operator&=", 10))
2630 case SIMPLE_HASH('a', 'S'):
2632 if (!cpp_demangle_push_str(ddata, "operator=", 9))
2637 case SIMPLE_HASH('c', 'l'):
2639 if (!cpp_demangle_push_str(ddata, "operator()", 10))
2644 case SIMPLE_HASH('c', 'm'):
2646 if (!cpp_demangle_push_str(ddata, "operator,", 9))
2651 case SIMPLE_HASH('c', 'o'):
2653 if (!cpp_demangle_push_str(ddata, "operator~", 9))
2658 case SIMPLE_HASH('c', 'v'):
2659 /* operator (cast) */
2660 if (!cpp_demangle_push_str(ddata, "operator(cast)", 14))
2663 return (cpp_demangle_read_type(ddata, 1));
2665 case SIMPLE_HASH('d', 'a'):
2666 /* operator delete [] */
2667 if (!cpp_demangle_push_str(ddata, "operator delete []", 18))
2672 case SIMPLE_HASH('d', 'e'):
2673 /* operator * (unary) */
2674 if (!cpp_demangle_push_str(ddata, "operator*", 9))
2679 case SIMPLE_HASH('d', 'l'):
2680 /* operator delete */
2681 if (!cpp_demangle_push_str(ddata, "operator delete", 15))
2686 case SIMPLE_HASH('d', 'v'):
2688 if (!cpp_demangle_push_str(ddata, "operator/", 9))
2693 case SIMPLE_HASH('d', 'V'):
2695 if (!cpp_demangle_push_str(ddata, "operator/=", 10))
2700 case SIMPLE_HASH('e', 'o'):
2702 if (!cpp_demangle_push_str(ddata, "operator^", 9))
2707 case SIMPLE_HASH('e', 'O'):
2709 if (!cpp_demangle_push_str(ddata, "operator^=", 10))
2714 case SIMPLE_HASH('e', 'q'):
2716 if (!cpp_demangle_push_str(ddata, "operator==", 10))
2721 case SIMPLE_HASH('g', 'e'):
2723 if (!cpp_demangle_push_str(ddata, "operator>=", 10))
2728 case SIMPLE_HASH('g', 't'):
2730 if (!cpp_demangle_push_str(ddata, "operator>", 9))
2735 case SIMPLE_HASH('i', 'x'):
2737 if (!cpp_demangle_push_str(ddata, "operator[]", 10))
2742 case SIMPLE_HASH('l', 'e'):
2744 if (!cpp_demangle_push_str(ddata, "operator<=", 10))
2749 case SIMPLE_HASH('l', 's'):
2751 if (!cpp_demangle_push_str(ddata, "operator<<", 10))
2756 case SIMPLE_HASH('l', 'S'):
2758 if (!cpp_demangle_push_str(ddata, "operator<<=", 11))
2763 case SIMPLE_HASH('l', 't'):
2765 if (!cpp_demangle_push_str(ddata, "operator<", 9))
2770 case SIMPLE_HASH('m', 'i'):
2772 if (!cpp_demangle_push_str(ddata, "operator-", 9))
2777 case SIMPLE_HASH('m', 'I'):
2779 if (!cpp_demangle_push_str(ddata, "operator-=", 10))
2784 case SIMPLE_HASH('m', 'l'):
2786 if (!cpp_demangle_push_str(ddata, "operator*", 9))
2791 case SIMPLE_HASH('m', 'L'):
2793 if (!cpp_demangle_push_str(ddata, "operator*=", 10))
2798 case SIMPLE_HASH('m', 'm'):
2800 if (!cpp_demangle_push_str(ddata, "operator--", 10))
2805 case SIMPLE_HASH('n', 'a'):
2806 /* operator new[] */
2807 if (!cpp_demangle_push_str(ddata, "operator new []", 15))
2812 case SIMPLE_HASH('n', 'e'):
2814 if (!cpp_demangle_push_str(ddata, "operator!=", 10))
2819 case SIMPLE_HASH('n', 'g'):
2820 /* operator - (unary) */
2821 if (!cpp_demangle_push_str(ddata, "operator-", 9))
2826 case SIMPLE_HASH('n', 't'):
2828 if (!cpp_demangle_push_str(ddata, "operator!", 9))
2833 case SIMPLE_HASH('n', 'w'):
2835 if (!cpp_demangle_push_str(ddata, "operator new", 12))
2840 case SIMPLE_HASH('o', 'o'):
2842 if (!cpp_demangle_push_str(ddata, "operator||", 10))
2847 case SIMPLE_HASH('o', 'r'):
2849 if (!cpp_demangle_push_str(ddata, "operator|", 9))
2854 case SIMPLE_HASH('o', 'R'):
2856 if (!cpp_demangle_push_str(ddata, "operator|=", 10))
2861 case SIMPLE_HASH('p', 'l'):
2863 if (!cpp_demangle_push_str(ddata, "operator+", 9))
2868 case SIMPLE_HASH('p', 'L'):
2870 if (!cpp_demangle_push_str(ddata, "operator+=", 10))
2875 case SIMPLE_HASH('p', 'm'):
2877 if (!cpp_demangle_push_str(ddata, "operator->*", 11))
2882 case SIMPLE_HASH('p', 'p'):
2884 if (!cpp_demangle_push_str(ddata, "operator++", 10))
2889 case SIMPLE_HASH('p', 's'):
2890 /* operator + (unary) */
2891 if (!cpp_demangle_push_str(ddata, "operator+", 9))
2896 case SIMPLE_HASH('p', 't'):
2898 if (!cpp_demangle_push_str(ddata, "operator->", 10))
2903 case SIMPLE_HASH('q', 'u'):
2905 if (!cpp_demangle_push_str(ddata, "operator?", 9))
2910 case SIMPLE_HASH('r', 'm'):
2912 if (!cpp_demangle_push_str(ddata, "operator%", 9))
2917 case SIMPLE_HASH('r', 'M'):
2919 if (!cpp_demangle_push_str(ddata, "operator%=", 10))
2924 case SIMPLE_HASH('r', 's'):
2926 if (!cpp_demangle_push_str(ddata, "operator>>", 10))
2931 case SIMPLE_HASH('r', 'S'):
2933 if (!cpp_demangle_push_str(ddata, "operator>>=", 11))
2938 case SIMPLE_HASH('r', 'z'):
2939 /* operator sizeof */
2940 if (!cpp_demangle_push_str(ddata, "operator sizeof ", 16))
2945 case SIMPLE_HASH('s', 'r'):
2946 /* scope resolution operator */
2947 if (!cpp_demangle_push_str(ddata, "scope resolution operator ",
2953 case SIMPLE_HASH('s', 'v'):
2954 /* operator sizeof */
2955 if (!cpp_demangle_push_str(ddata, "operator sizeof ", 16))
2961 /* vendor extened operator */
2962 if (*ddata->cur == 'v' && ELFTC_ISDIGIT(*(ddata->cur + 1))) {
2963 if (!cpp_demangle_push_str(ddata, "vendor extened operator ",
2966 if (!cpp_demangle_push_str(ddata, ddata->cur + 1, 1))
2969 return (cpp_demangle_read_sname(ddata));
2972 /* ctor-dtor-name */
2973 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
2974 case SIMPLE_HASH('C', '1'):
2976 case SIMPLE_HASH('C', '2'):
2978 case SIMPLE_HASH('C', '3'):
2979 if (ddata->last_sname == NULL)
2981 if ((len = strlen(ddata->last_sname)) == 0)
2983 if (!cpp_demangle_push_str(ddata, "::", 2))
2985 if (!cpp_demangle_push_str(ddata, ddata->last_sname, len))
2990 case SIMPLE_HASH('D', '0'):
2992 case SIMPLE_HASH('D', '1'):
2994 case SIMPLE_HASH('D', '2'):
2995 if (ddata->last_sname == NULL)
2997 if ((len = strlen(ddata->last_sname)) == 0)
2999 if (!cpp_demangle_push_str(ddata, "::~", 3))
3001 if (!cpp_demangle_push_str(ddata, ddata->last_sname, len))
3008 if (ELFTC_ISDIGIT(*ddata->cur) != 0)
3009 return (cpp_demangle_read_sname(ddata));
3012 /* local source name */
3013 if (*ddata->cur == 'L')
3014 return (cpp_demangle_local_source_name(ddata));
3020 * Read local source name.
3023 * http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31775
3024 * http://gcc.gnu.org/viewcvs?view=rev&revision=124467
3027 cpp_demangle_local_source_name(struct cpp_demangle_data *ddata)
3030 if (ddata == NULL || *ddata->cur != 'L')
3035 if (!cpp_demangle_read_sname(ddata))
3039 if (*ddata->cur == '_') {
3041 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
3049 cpp_demangle_read_v_offset(struct cpp_demangle_data *ddata)
3055 if (!cpp_demangle_push_str(ddata, "offset : ", 9))
3058 if (!cpp_demangle_read_offset_number(ddata))
3061 if (!cpp_demangle_push_str(ddata, "virtual offset : ", 17))
3064 return (!cpp_demangle_read_offset_number(ddata));
3068 * Decode floating point representation to string
3069 * Return new allocated string or NULL
3072 * Replace these functions to macro.
3075 decode_fp_to_double(const char *p, size_t len)
3078 size_t rtn_len, limit, i;
3082 if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > sizeof(double))
3085 memset(&f, 0, sizeof(double));
3087 for (i = 0; i < len / 2; ++i) {
3088 byte = hex_to_dec(p[len - i * 2 - 1]) +
3089 hex_to_dec(p[len - i * 2 - 2]) * 16;
3091 if (byte < 0 || byte > 255)
3094 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3095 ((unsigned char *)&f)[i] = (unsigned char)(byte);
3096 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3097 ((unsigned char *)&f)[sizeof(double) - i - 1] =
3098 (unsigned char)(byte);
3099 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3105 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3108 if (snprintf(rtn, rtn_len, "%fld", f) >= (int)rtn_len) {
3110 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3112 rtn_len *= BUFFER_GROWFACTOR;
3120 decode_fp_to_float(const char *p, size_t len)
3122 size_t i, rtn_len, limit;
3127 if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > sizeof(float))
3130 memset(&f, 0, sizeof(float));
3132 for (i = 0; i < len / 2; ++i) {
3133 byte = hex_to_dec(p[len - i * 2 - 1]) +
3134 hex_to_dec(p[len - i * 2 - 2]) * 16;
3135 if (byte < 0 || byte > 255)
3137 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3138 ((unsigned char *)&f)[i] = (unsigned char)(byte);
3139 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3140 ((unsigned char *)&f)[sizeof(float) - i - 1] =
3141 (unsigned char)(byte);
3142 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3148 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3151 if (snprintf(rtn, rtn_len, "%ff", f) >= (int)rtn_len) {
3153 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3155 rtn_len *= BUFFER_GROWFACTOR;
3163 decode_fp_to_float128(const char *p, size_t len)
3166 size_t rtn_len, limit, i;
3168 unsigned char buf[FLOAT_QUADRUPLE_BYTES];
3171 switch(sizeof(long double)) {
3172 case FLOAT_QUADRUPLE_BYTES:
3173 return (decode_fp_to_long_double(p, len));
3174 case FLOAT_EXTENED_BYTES:
3175 if (p == NULL || len == 0 || len % 2 != 0 ||
3176 len / 2 > FLOAT_QUADRUPLE_BYTES)
3179 memset(buf, 0, FLOAT_QUADRUPLE_BYTES);
3181 for (i = 0; i < len / 2; ++i) {
3182 byte = hex_to_dec(p[len - i * 2 - 1]) +
3183 hex_to_dec(p[len - i * 2 - 2]) * 16;
3184 if (byte < 0 || byte > 255)
3186 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3187 buf[i] = (unsigned char)(byte);
3188 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3189 buf[FLOAT_QUADRUPLE_BYTES - i -1] =
3190 (unsigned char)(byte);
3191 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3193 memset(&f, 0, FLOAT_EXTENED_BYTES);
3195 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3196 memcpy(&f, buf, FLOAT_EXTENED_BYTES);
3197 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3198 memcpy(&f, buf + 6, FLOAT_EXTENED_BYTES);
3199 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3204 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3207 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
3209 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3211 rtn_len *= BUFFER_GROWFACTOR;
3222 decode_fp_to_float80(const char *p, size_t len)
3225 size_t rtn_len, limit, i;
3227 unsigned char buf[FLOAT_EXTENED_BYTES];
3230 switch(sizeof(long double)) {
3231 case FLOAT_QUADRUPLE_BYTES:
3232 if (p == NULL || len == 0 || len % 2 != 0 ||
3233 len / 2 > FLOAT_EXTENED_BYTES)
3236 memset(buf, 0, FLOAT_EXTENED_BYTES);
3238 for (i = 0; i < len / 2; ++i) {
3239 byte = hex_to_dec(p[len - i * 2 - 1]) +
3240 hex_to_dec(p[len - i * 2 - 2]) * 16;
3242 if (byte < 0 || byte > 255)
3245 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3246 buf[i] = (unsigned char)(byte);
3247 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3248 buf[FLOAT_EXTENED_BYTES - i -1] =
3249 (unsigned char)(byte);
3250 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3253 memset(&f, 0, FLOAT_QUADRUPLE_BYTES);
3255 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3256 memcpy(&f, buf, FLOAT_EXTENED_BYTES);
3257 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3258 memcpy((unsigned char *)(&f) + 6, buf, FLOAT_EXTENED_BYTES);
3259 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3264 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3267 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
3269 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3271 rtn_len *= BUFFER_GROWFACTOR;
3276 case FLOAT_EXTENED_BYTES:
3277 return (decode_fp_to_long_double(p, len));
3284 decode_fp_to_long_double(const char *p, size_t len)
3287 size_t rtn_len, limit, i;
3291 if (p == NULL || len == 0 || len % 2 != 0 ||
3292 len / 2 > sizeof(long double))
3295 memset(&f, 0, sizeof(long double));
3297 for (i = 0; i < len / 2; ++i) {
3298 byte = hex_to_dec(p[len - i * 2 - 1]) +
3299 hex_to_dec(p[len - i * 2 - 2]) * 16;
3301 if (byte < 0 || byte > 255)
3304 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3305 ((unsigned char *)&f)[i] = (unsigned char)(byte);
3306 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3307 ((unsigned char *)&f)[sizeof(long double) - i - 1] =
3308 (unsigned char)(byte);
3309 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3315 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3318 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
3320 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3322 rtn_len *= BUFFER_GROWFACTOR;
3329 /* Simple hex to integer function used by decode_to_* function. */
3373 vector_read_cmd_dest(struct vector_read_cmd *v)
3379 free(v->r_container);
3382 /* return -1 at failed, 0 at not found, 1 at found. */
3384 vector_read_cmd_find(struct vector_read_cmd *v, enum read_cmd dst)
3388 if (v == NULL || dst == READ_FAIL)
3391 for (i = 0; i < v->size; ++i)
3392 if (v->r_container[i] == dst)
3399 vector_read_cmd_init(struct vector_read_cmd *v)
3406 v->capacity = VECTOR_DEF_CAPACITY;
3408 if ((v->r_container = malloc(sizeof(enum read_cmd) * v->capacity))
3416 vector_read_cmd_pop(struct vector_read_cmd *v)
3419 if (v == NULL || v->size == 0)
3423 v->r_container[v->size] = READ_FAIL;
3429 vector_read_cmd_push(struct vector_read_cmd *v, enum read_cmd cmd)
3431 enum read_cmd *tmp_r_ctn;
3438 if (v->size == v->capacity) {
3439 tmp_cap = v->capacity * BUFFER_GROWFACTOR;
3440 if ((tmp_r_ctn = malloc(sizeof(enum read_cmd) * tmp_cap))
3443 for (i = 0; i < v->size; ++i)
3444 tmp_r_ctn[i] = v->r_container[i];
3445 free(v->r_container);
3446 v->r_container = tmp_r_ctn;
3447 v->capacity = tmp_cap;
3450 v->r_container[v->size] = cmd;
3457 vector_type_qualifier_dest(struct vector_type_qualifier *v)
3463 free(v->q_container);
3464 vector_str_dest(&v->ext_name);
3467 /* size, capacity, ext_name */
3469 vector_type_qualifier_init(struct vector_type_qualifier *v)
3476 v->capacity = VECTOR_DEF_CAPACITY;
3478 if ((v->q_container = malloc(sizeof(enum type_qualifier) * v->capacity))
3482 assert(v->q_container != NULL);
3484 if (vector_str_init(&v->ext_name) == false) {
3485 free(v->q_container);
3493 vector_type_qualifier_push(struct vector_type_qualifier *v,
3494 enum type_qualifier t)
3496 enum type_qualifier *tmp_ctn;
3503 if (v->size == v->capacity) {
3504 tmp_cap = v->capacity * BUFFER_GROWFACTOR;
3505 if ((tmp_ctn = malloc(sizeof(enum type_qualifier) * tmp_cap))
3508 for (i = 0; i < v->size; ++i)
3509 tmp_ctn[i] = v->q_container[i];
3510 free(v->q_container);
3511 v->q_container = tmp_ctn;
3512 v->capacity = tmp_cap;
3515 v->q_container[v->size] = t;