?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove building with NOCRYPTO option
[minix3.git] / external / bsd / libc++ / dist / libcxxrt / src / libelftc_dem_gnu3.c
blob70ef3e8e1da8a0f9fc8fa2fff5179e4a07158e09
1 /*-
2 * Copyright (c) 2007, 2008 Hyogeol Lee <hyogeollee@gmail.com>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
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.
14 *
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.
25 */
26 #include <sys/types.h>
27 #include <assert.h>
28 #include <ctype.h>
29 #include <errno.h>
30 #include <limits.h>
31 #include <stdbool.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35
36 /**
37 * @file cpp_demangle.c
38 * @brief Decode IA-64 C++ ABI style implementation.
39 *
40 * IA-64 standard ABI(Itanium C++ ABI) references.
41 *
42 * http://www.codesourcery.com/cxx-abi/abi.html#mangling \n
43 * http://www.codesourcery.com/cxx-abi/abi-mangling.html
44 */
45
46 /** @brief Dynamic vector data for string. */
47 struct vector_str {
48 /** Current size */
49 size_t size;
50 /** Total capacity */
51 size_t capacity;
52 /** String array */
53 char **container;
54 };
55
56 #define BUFFER_GROWFACTOR 1.618
57 #define VECTOR_DEF_CAPACITY 8
58 #define ELFTC_ISDIGIT(C) (isdigit((C) & 0xFF))
59
60 enum type_qualifier {
61 TYPE_PTR, TYPE_REF, TYPE_CMX, TYPE_IMG, TYPE_EXT, TYPE_RST, TYPE_VAT,
62 TYPE_CST, TYPE_VEC
63 };
64
65 struct vector_type_qualifier {
66 size_t size, capacity;
67 enum type_qualifier *q_container;
68 struct vector_str ext_name;
69 };
70
71 enum read_cmd {
72 READ_FAIL, READ_NEST, READ_TMPL, READ_EXPR, READ_EXPL, READ_LOCAL,
73 READ_TYPE, READ_FUNC, READ_PTRMEM
74 };
75
76 struct vector_read_cmd {
77 size_t size, capacity;
78 enum read_cmd *r_container;
79 };
80
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 */
93 int func_type;
94 const char *cur; /* current mangled name ptr */
95 const char *last_sname; /* last source name */
96 int push_head;
97 };
98
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
103
104 #define SIMPLE_HASH(x,y) (64 * x + y)
105
106 static size_t get_strlen_sum(const struct vector_str *v);
107 static bool vector_str_grow(struct vector_str *v);
108
109 static size_t
110 get_strlen_sum(const struct vector_str *v)
111 {
112 size_t i, len = 0;
113
114 if (v == NULL)
115 return (0);
116
117 assert(v->size > 0);
118
119 for (i = 0; i < v->size; ++i)
120 len += strlen(v->container[i]);
121
122 return (len);
123 }
124
125 /**
126 * @brief Deallocate resource in vector_str.
127 */
128 static void
129 vector_str_dest(struct vector_str *v)
130 {
131 size_t i;
132
133 if (v == NULL)
134 return;
135
136 for (i = 0; i < v->size; ++i)
137 free(v->container[i]);
138
139 free(v->container);
140 }
141
142 /**
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.
148 */
149 static int
150 vector_str_find(const struct vector_str *v, const char *o, size_t l)
151 {
152 size_t i;
153
154 if (v == NULL || o == NULL)
155 return (-1);
156
157 for (i = 0; i < v->size; ++i)
158 if (strncmp(v->container[i], o, l) == 0)
159 return (1);
160
161 return (0);
162 }
163
164 /**
165 * @brief Get new allocated flat string from vector.
166 *
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.
171 */
172 static char *
173 vector_str_get_flat(const struct vector_str *v, size_t *l)
174 {
175 ssize_t elem_pos, elem_size, rtn_size;
176 size_t i;
177 char *rtn;
178
179 if (v == NULL || v->size == 0)
180 return (NULL);
181
182 if ((rtn_size = get_strlen_sum(v)) == 0)
183 return (NULL);
184
185 if ((rtn = malloc(sizeof(char) * (rtn_size + 1))) == NULL)
186 return (NULL);
187
188 elem_pos = 0;
189 for (i = 0; i < v->size; ++i) {
190 elem_size = strlen(v->container[i]);
191
192 memcpy(rtn + elem_pos, v->container[i], elem_size);
193
194 elem_pos += elem_size;
195 }
196
197 rtn[rtn_size] = '\0';
198
199 if (l != NULL)
200 *l = rtn_size;
201
202 return (rtn);
203 }
204
205 static bool
206 vector_str_grow(struct vector_str *v)
207 {
208 size_t i, tmp_cap;
209 char **tmp_ctn;
210
211 if (v == NULL)
212 return (false);
213
214 assert(v->capacity > 0);
215
216 tmp_cap = v->capacity * BUFFER_GROWFACTOR;
217
218 assert(tmp_cap > v->capacity);
219
220 if ((tmp_ctn = malloc(sizeof(char *) * tmp_cap)) == NULL)
221 return (false);
222
223 for (i = 0; i < v->size; ++i)
224 tmp_ctn[i] = v->container[i];
225
226 free(v->container);
227
228 v->container = tmp_ctn;
229 v->capacity = tmp_cap;
230
231 return (true);
232 }
233
234 /**
235 * @brief Initialize vector_str.
236 * @return false at failed, true at success.
237 */
238 static bool
239 vector_str_init(struct vector_str *v)
240 {
241
242 if (v == NULL)
243 return (false);
244
245 v->size = 0;
246 v->capacity = VECTOR_DEF_CAPACITY;
247
248 assert(v->capacity > 0);
249
250 if ((v->container = malloc(sizeof(char *) * v->capacity)) == NULL)
251 return (false);
252
253 assert(v->container != NULL);
254
255 return (true);
256 }
257
258 /**
259 * @brief Remove last element in vector_str.
260 * @return false at failed, true at success.
261 */
262 static bool
263 vector_str_pop(struct vector_str *v)
264 {
265
266 if (v == NULL)
267 return (false);
268
269 if (v->size == 0)
270 return (true);
271
272 --v->size;
273
274 free(v->container[v->size]);
275 v->container[v->size] = NULL;
276
277 return (true);
278 }
279
280 /**
281 * @brief Push back string to vector.
282 * @return false at failed, true at success.
283 */
284 static bool
285 vector_str_push(struct vector_str *v, const char *str, size_t len)
286 {
287
288 if (v == NULL || str == NULL)
289 return (false);
290
291 if (v->size == v->capacity && vector_str_grow(v) == false)
292 return (false);
293
294 if ((v->container[v->size] = malloc(sizeof(char) * (len + 1))) == NULL)
295 return (false);
296
297 snprintf(v->container[v->size], len + 1, "%s", str);
298
299 ++v->size;
300
301 return (true);
302 }
303
304 /**
305 * @brief Push front org vector to det vector.
306 * @return false at failed, true at success.
307 */
308 static bool
309 vector_str_push_vector_head(struct vector_str *dst, struct vector_str *org)
310 {
311 size_t i, j, tmp_cap;
312 char **tmp_ctn;
313
314 if (dst == NULL || org == NULL)
315 return (false);
316
317 tmp_cap = (dst->size + org->size) * BUFFER_GROWFACTOR;
318
319 if ((tmp_ctn = malloc(sizeof(char *) * tmp_cap)) == NULL)
320 return (false);
321
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)
325 free(tmp_ctn[j]);
326
327 free(tmp_ctn);
328
329 return (false);
330 }
331
332 for (i = 0; i < dst->size; ++i)
333 tmp_ctn[i + org->size] = dst->container[i];
334
335 free(dst->container);
336
337 dst->container = tmp_ctn;
338 dst->capacity = tmp_cap;
339 dst->size += org->size;
340
341 return (true);
342 }
343
344 /**
345 * @brief Get new allocated flat string from vector between begin and end.
346 *
347 * If r_len is not NULL, string length will be returned.
348 * @return NULL at failed or NUL terminated new allocated string.
349 */
350 static char *
351 vector_str_substr(const struct vector_str *v, size_t begin, size_t end,
352 size_t *r_len)
353 {
354 size_t cur, i, len;
355 char *rtn;
356
357 if (v == NULL || begin > end)
358 return (NULL);
359
360 len = 0;
361 for (i = begin; i < end + 1; ++i)
362 len += strlen(v->container[i]);
363
364 if ((rtn = malloc(sizeof(char) * (len + 1))) == NULL)
365 return (NULL);
366
367 if (r_len != NULL)
368 *r_len = len;
369
370 cur = 0;
371 for (i = begin; i < end + 1; ++i) {
372 len = strlen(v->container[i]);
373 memcpy(rtn + cur, v->container[i], len);
374 cur += len;
375 }
376 rtn[cur] = '\0';
377
378 return (rtn);
379 }
380
381 static void cpp_demangle_data_dest(struct cpp_demangle_data *);
382 static int cpp_demangle_data_init(struct cpp_demangle_data *,
383 const char *);
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 *,
389 size_t);
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_flat(struct cpp_demangle_data *,
401 char **);
402 static int cpp_demangle_read_expression_binary(struct cpp_demangle_data *,
403 const char *, size_t);
404 static int cpp_demangle_read_expression_unary(struct cpp_demangle_data *,
405 const char *, size_t);
406 static int cpp_demangle_read_expression_trinary(struct cpp_demangle_data *,
407 const char *, size_t, const char *, size_t);
408 static int cpp_demangle_read_function(struct cpp_demangle_data *, int *,
409 struct vector_type_qualifier *);
410 static int cpp_demangle_local_source_name(struct cpp_demangle_data *ddata);
411 static int cpp_demangle_read_local_name(struct cpp_demangle_data *);
412 static int cpp_demangle_read_name(struct cpp_demangle_data *);
413 static int cpp_demangle_read_name_flat(struct cpp_demangle_data *,
414 char**);
415 static int cpp_demangle_read_nested_name(struct cpp_demangle_data *);
416 static int cpp_demangle_read_number(struct cpp_demangle_data *, long *);
417 static int cpp_demangle_read_number_as_string(struct cpp_demangle_data *,
418 char **);
419 static int cpp_demangle_read_nv_offset(struct cpp_demangle_data *);
420 static int cpp_demangle_read_offset(struct cpp_demangle_data *);
421 static int cpp_demangle_read_offset_number(struct cpp_demangle_data *);
422 static int cpp_demangle_read_pointer_to_member(struct cpp_demangle_data *);
423 static int cpp_demangle_read_sname(struct cpp_demangle_data *);
424 static int cpp_demangle_read_subst(struct cpp_demangle_data *);
425 static int cpp_demangle_read_subst_std(struct cpp_demangle_data *);
426 static int cpp_demangle_read_subst_stdtmpl(struct cpp_demangle_data *,
427 const char *, size_t);
428 static int cpp_demangle_read_tmpl_arg(struct cpp_demangle_data *);
429 static int cpp_demangle_read_tmpl_args(struct cpp_demangle_data *);
430 static int cpp_demangle_read_tmpl_param(struct cpp_demangle_data *);
431 static int cpp_demangle_read_type(struct cpp_demangle_data *, int);
432 static int cpp_demangle_read_type_flat(struct cpp_demangle_data *,
433 char **);
434 static int cpp_demangle_read_uqname(struct cpp_demangle_data *);
435 static int cpp_demangle_read_v_offset(struct cpp_demangle_data *);
436 static char *decode_fp_to_double(const char *, size_t);
437 static char *decode_fp_to_float(const char *, size_t);
438 static char *decode_fp_to_float128(const char *, size_t);
439 static char *decode_fp_to_float80(const char *, size_t);
440 static char *decode_fp_to_long_double(const char *, size_t);
441 static int hex_to_dec(char);
442 static void vector_read_cmd_dest(struct vector_read_cmd *);
443 static int vector_read_cmd_find(struct vector_read_cmd *, enum read_cmd);
444 static int vector_read_cmd_init(struct vector_read_cmd *);
445 static int vector_read_cmd_pop(struct vector_read_cmd *);
446 static int vector_read_cmd_push(struct vector_read_cmd *, enum read_cmd);
447 static void vector_type_qualifier_dest(struct vector_type_qualifier *);
448 static int vector_type_qualifier_init(struct vector_type_qualifier *);
449 static int vector_type_qualifier_push(struct vector_type_qualifier *,
450 enum type_qualifier);
451
452 /**
453 * @brief Decode the input string by IA-64 C++ ABI style.
454 *
455 * GNU GCC v3 use IA-64 standard ABI.
456 * @return New allocated demangled string or NULL if failed.
457 * @todo 1. Testing and more test case. 2. Code cleaning.
458 */
459 char *
460 __cxa_demangle_gnu3(const char *org)
461 {
462 struct cpp_demangle_data ddata;
463 ssize_t org_len;
464 unsigned int limit;
465 char *rtn = NULL;
466
467 if (org == NULL)
468 return (NULL);
469
470 org_len = strlen(org);
471 if (org_len > 11 && !strncmp(org, "_GLOBAL__I_", 11)) {
472 if ((rtn = malloc(org_len + 19)) == NULL)
473 return (NULL);
474 snprintf(rtn, org_len + 19,
475 "global constructors keyed to %s", org + 11);
476 return (rtn);
477 }
478
479 // Try demangling as a type for short encodings
480 if ((org_len < 2) || (org[0] != '_' || org[1] != 'Z' )) {
481 if (!cpp_demangle_data_init(&ddata, org))
482 return (NULL);
483 if (!cpp_demangle_read_type(&ddata, 0))
484 goto clean;
485 rtn = vector_str_get_flat(&ddata.output, (size_t *) NULL);
486 goto clean;
487 }
488
489
490 if (!cpp_demangle_data_init(&ddata, org + 2))
491 return (NULL);
492
493 rtn = NULL;
494
495 if (!cpp_demangle_read_encoding(&ddata))
496 goto clean;
497
498 limit = 0;
499 while (*ddata.cur != '\0') {
500 /*
501 * Breaking at some gcc info at tail. e.g) @@GLIBCXX_3.4
502 */
503 if (*ddata.cur == '@' && *(ddata.cur + 1) == '@')
504 break;
505 if (!cpp_demangle_read_type(&ddata, 1))
506 goto clean;
507 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
508 goto clean;
509 }
510
511 if (ddata.output.size == 0)
512 goto clean;
513 if (ddata.paren && !vector_str_push(&ddata.output, ")", 1))
514 goto clean;
515 if (ddata.mem_vat && !vector_str_push(&ddata.output, " volatile", 9))
516 goto clean;
517 if (ddata.mem_cst && !vector_str_push(&ddata.output, " const", 6))
518 goto clean;
519 if (ddata.mem_rst && !vector_str_push(&ddata.output, " restrict", 9))
520 goto clean;
521
522 rtn = vector_str_get_flat(&ddata.output, (size_t *) NULL);
523
524 clean:
525 cpp_demangle_data_dest(&ddata);
526
527 return (rtn);
528 }
529
530 static void
531 cpp_demangle_data_dest(struct cpp_demangle_data *d)
532 {
533
534 if (d == NULL)
535 return;
536
537 vector_read_cmd_dest(&d->cmd);
538 vector_str_dest(&d->class_type);
539 vector_str_dest(&d->tmpl);
540 vector_str_dest(&d->subst);
541 vector_str_dest(&d->output_tmp);
542 vector_str_dest(&d->output);
543 }
544
545 static int
546 cpp_demangle_data_init(struct cpp_demangle_data *d, const char *cur)
547 {
548
549 if (d == NULL || cur == NULL)
550 return (0);
551
552 if (!vector_str_init(&d->output))
553 return (0);
554 if (!vector_str_init(&d->output_tmp))
555 goto clean1;
556 if (!vector_str_init(&d->subst))
557 goto clean2;
558 if (!vector_str_init(&d->tmpl))
559 goto clean3;
560 if (!vector_str_init(&d->class_type))
561 goto clean4;
562 if (!vector_read_cmd_init(&d->cmd))
563 goto clean5;
564
565 assert(d->output.container != NULL);
566 assert(d->output_tmp.container != NULL);
567 assert(d->subst.container != NULL);
568 assert(d->tmpl.container != NULL);
569 assert(d->class_type.container != NULL);
570
571 d->paren = false;
572 d->pfirst = false;
573 d->mem_rst = false;
574 d->mem_vat = false;
575 d->mem_cst = false;
576 d->func_type = 0;
577 d->cur = cur;
578 d->last_sname = NULL;
579 d->push_head = 0;
580
581 return (1);
582
583 clean5:
584 vector_str_dest(&d->class_type);
585 clean4:
586 vector_str_dest(&d->tmpl);
587 clean3:
588 vector_str_dest(&d->subst);
589 clean2:
590 vector_str_dest(&d->output_tmp);
591 clean1:
592 vector_str_dest(&d->output);
593
594 return (0);
595 }
596
597 static int
598 cpp_demangle_push_fp(struct cpp_demangle_data *ddata,
599 char *(*decoder)(const char *, size_t))
600 {
601 size_t len;
602 int rtn;
603 const char *fp;
604 char *f;
605
606 if (ddata == NULL || decoder == NULL)
607 return (0);
608
609 fp = ddata->cur;
610 while (*ddata->cur != 'E')
611 ++ddata->cur;
612
613 if ((f = decoder(fp, ddata->cur - fp)) == NULL)
614 return (0);
615
616 rtn = 0;
617 if ((len = strlen(f)) > 0)
618 rtn = cpp_demangle_push_str(ddata, f, len);
619
620 free(f);
621
622 ++ddata->cur;
623
624 return (rtn);
625 }
626
627 static int
628 cpp_demangle_push_str(struct cpp_demangle_data *ddata, const char *str,
629 size_t len)
630 {
631
632 if (ddata == NULL || str == NULL || len == 0)
633 return (0);
634
635 if (ddata->push_head > 0)
636 return (vector_str_push(&ddata->output_tmp, str, len));
637
638 return (vector_str_push(&ddata->output, str, len));
639 }
640
641 static int
642 cpp_demangle_push_subst(struct cpp_demangle_data *ddata, const char *str,
643 size_t len)
644 {
645
646 if (ddata == NULL || str == NULL || len == 0)
647 return (0);
648
649 if (!vector_str_find(&ddata->subst, str, len))
650 return (vector_str_push(&ddata->subst, str, len));
651
652 return (1);
653 }
654
655 static int
656 cpp_demangle_push_subst_v(struct cpp_demangle_data *ddata, struct vector_str *v)
657 {
658 size_t str_len;
659 int rtn;
660 char *str;
661
662 if (ddata == NULL || v == NULL)
663 return (0);
664
665 if ((str = vector_str_get_flat(v, &str_len)) == NULL)
666 return (0);
667
668 rtn = cpp_demangle_push_subst(ddata, str, str_len);
669
670 free(str);
671
672 return (rtn);
673 }
674
675 static int
676 cpp_demangle_push_type_qualifier(struct cpp_demangle_data *ddata,
677 struct vector_type_qualifier *v, const char *type_str)
678 {
679 struct vector_str subst_v;
680 size_t idx, e_idx, e_len;
681 int rtn;
682 char *buf;
683
684 if (ddata == NULL || v == NULL)
685 return (0);
686
687 if ((idx = v->size) == 0)
688 return (1);
689
690 rtn = 0;
691 if (type_str != NULL) {
692 if (!vector_str_init(&subst_v))
693 return (0);
694 if (!vector_str_push(&subst_v, type_str, strlen(type_str)))
695 goto clean;
696 }
697
698 e_idx = 0;
699 while (idx > 0) {
700 switch (v->q_container[idx - 1]) {
701 case TYPE_PTR:
702 if (!cpp_demangle_push_str(ddata, "*", 1))
703 goto clean;
704 if (type_str != NULL) {
705 if (!vector_str_push(&subst_v, "*", 1))
706 goto clean;
707 if (!cpp_demangle_push_subst_v(ddata,
708 &subst_v))
709 goto clean;
710 }
711 break;
712
713 case TYPE_REF:
714 if (!cpp_demangle_push_str(ddata, "&", 1))
715 goto clean;
716 if (type_str != NULL) {
717 if (!vector_str_push(&subst_v, "&", 1))
718 goto clean;
719 if (!cpp_demangle_push_subst_v(ddata,
720 &subst_v))
721 goto clean;
722 }
723 break;
724
725 case TYPE_CMX:
726 if (!cpp_demangle_push_str(ddata, " complex", 8))
727 goto clean;
728 if (type_str != NULL) {
729 if (!vector_str_push(&subst_v, " complex", 8))
730 goto clean;
731 if (!cpp_demangle_push_subst_v(ddata,
732 &subst_v))
733 goto clean;
734 }
735 break;
736
737 case TYPE_IMG:
738 if (!cpp_demangle_push_str(ddata, " imaginary", 10))
739 goto clean;
740 if (type_str != NULL) {
741 if (!vector_str_push(&subst_v, " imaginary",
742 10))
743 goto clean;
744 if (!cpp_demangle_push_subst_v(ddata,
745 &subst_v))
746 goto clean;
747 }
748 break;
749
750 case TYPE_EXT:
751 if (v->ext_name.size == 0 ||
752 e_idx > v->ext_name.size - 1)
753 goto clean;
754 if ((e_len = strlen(v->ext_name.container[e_idx])) ==
755 0)
756 goto clean;
757 if ((buf = malloc(e_len + 2)) == NULL)
758 goto clean;
759 snprintf(buf, e_len + 2, " %s",
760 v->ext_name.container[e_idx]);
761
762 if (!cpp_demangle_push_str(ddata, buf, e_len + 1)) {
763 free(buf);
764 goto clean;
765 }
766
767 if (type_str != NULL) {
768 if (!vector_str_push(&subst_v, buf,
769 e_len + 1)) {
770 free(buf);
771 goto clean;
772 }
773 if (!cpp_demangle_push_subst_v(ddata,
774 &subst_v)) {
775 free(buf);
776 goto clean;
777 }
778 }
779 free(buf);
780 ++e_idx;
781 break;
782
783 case TYPE_RST:
784 if (!cpp_demangle_push_str(ddata, " restrict", 9))
785 goto clean;
786 if (type_str != NULL) {
787 if (!vector_str_push(&subst_v, " restrict", 9))
788 goto clean;
789 if (!cpp_demangle_push_subst_v(ddata,
790 &subst_v))
791 goto clean;
792 }
793 break;
794
795 case TYPE_VAT:
796 if (!cpp_demangle_push_str(ddata, " volatile", 9))
797 goto clean;
798 if (type_str != NULL) {
799 if (!vector_str_push(&subst_v, " volatile", 9))
800 goto clean;
801 if (!cpp_demangle_push_subst_v(ddata,
802 &subst_v))
803 goto clean;
804 }
805 break;
806
807 case TYPE_CST:
808 if (!cpp_demangle_push_str(ddata, " const", 6))
809 goto clean;
810 if (type_str != NULL) {
811 if (!vector_str_push(&subst_v, " const", 6))
812 goto clean;
813 if (!cpp_demangle_push_subst_v(ddata,
814 &subst_v))
815 goto clean;
816 }
817 break;
818
819 case TYPE_VEC:
820 if (v->ext_name.size == 0 ||
821 e_idx > v->ext_name.size - 1)
822 goto clean;
823 if ((e_len = strlen(v->ext_name.container[e_idx])) ==
824 0)
825 goto clean;
826 if ((buf = malloc(e_len + 12)) == NULL)
827 goto clean;
828 snprintf(buf, e_len + 12, " __vector(%s)",
829 v->ext_name.container[e_idx]);
830 if (!cpp_demangle_push_str(ddata, buf, e_len + 11)) {
831 free(buf);
832 goto clean;
833 }
834 if (type_str != NULL) {
835 if (!vector_str_push(&subst_v, buf,
836 e_len + 11)) {
837 free(buf);
838 goto clean;
839 }
840 if (!cpp_demangle_push_subst_v(ddata,
841 &subst_v)) {
842 free(buf);
843 goto clean;
844 }
845 }
846 free(buf);
847 ++e_idx;
848 break;
849 };
850 --idx;
851 }
852
853 rtn = 1;
854 clean:
855 if (type_str != NULL)
856 vector_str_dest(&subst_v);
857
858 return (rtn);
859 }
860
861 static int
862 cpp_demangle_get_subst(struct cpp_demangle_data *ddata, size_t idx)
863 {
864 size_t len;
865
866 if (ddata == NULL || ddata->subst.size <= idx)
867 return (0);
868 if ((len = strlen(ddata->subst.container[idx])) == 0)
869 return (0);
870 if (!cpp_demangle_push_str(ddata, ddata->subst.container[idx], len))
871 return (0);
872
873 /* skip '_' */
874 ++ddata->cur;
875
876 return (1);
877 }
878
879 static int
880 cpp_demangle_get_tmpl_param(struct cpp_demangle_data *ddata, size_t idx)
881 {
882 size_t len;
883
884 if (ddata == NULL || ddata->tmpl.size <= idx)
885 return (0);
886 if ((len = strlen(ddata->tmpl.container[idx])) == 0)
887 return (0);
888 if (!cpp_demangle_push_str(ddata, ddata->tmpl.container[idx], len))
889 return (0);
890
891 ++ddata->cur;
892
893 return (1);
894 }
895
896 static int
897 cpp_demangle_read_array(struct cpp_demangle_data *ddata)
898 {
899 size_t i, num_len, exp_len, p_idx, idx;
900 const char *num;
901 char *exp;
902
903 if (ddata == NULL || *(++ddata->cur) == '\0')
904 return (0);
905
906 if (*ddata->cur == '_') {
907 if (*(++ddata->cur) == '\0')
908 return (0);
909
910 if (!cpp_demangle_read_type(ddata, 0))
911 return (0);
912
913 if (!cpp_demangle_push_str(ddata, "[]", 2))
914 return (0);
915 } else {
916 if (ELFTC_ISDIGIT(*ddata->cur) != 0) {
917 num = ddata->cur;
918 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
919 ++ddata->cur;
920 if (*ddata->cur != '_')
921 return (0);
922 num_len = ddata->cur - num;
923 assert(num_len > 0);
924 if (*(++ddata->cur) == '\0')
925 return (0);
926 if (!cpp_demangle_read_type(ddata, 0))
927 return (0);
928 if (!cpp_demangle_push_str(ddata, "[", 1))
929 return (0);
930 if (!cpp_demangle_push_str(ddata, num, num_len))
931 return (0);
932 if (!cpp_demangle_push_str(ddata, "]", 1))
933 return (0);
934 } else {
935 p_idx = ddata->output.size;
936 if (!cpp_demangle_read_expression(ddata))
937 return (0);
938 if ((exp = vector_str_substr(&ddata->output, p_idx,
939 ddata->output.size - 1, &exp_len)) == NULL)
940 return (0);
941 idx = ddata->output.size;
942 for (i = p_idx; i < idx; ++i)
943 if (!vector_str_pop(&ddata->output)) {
944 free(exp);
945 return (0);
946 }
947 if (*ddata->cur != '_') {
948 free(exp);
949 return (0);
950 }
951 ++ddata->cur;
952 if (*ddata->cur == '\0') {
953 free(exp);
954 return (0);
955 }
956 if (!cpp_demangle_read_type(ddata, 0)) {
957 free(exp);
958 return (0);
959 }
960 if (!cpp_demangle_push_str(ddata, "[", 1)) {
961 free(exp);
962 return (0);
963 }
964 if (!cpp_demangle_push_str(ddata, exp, exp_len)) {
965 free(exp);
966 return (0);
967 }
968 if (!cpp_demangle_push_str(ddata, "]", 1)) {
969 free(exp);
970 return (0);
971 }
972 free(exp);
973 }
974 }
975
976 return (1);
977 }
978
979 static int
980 cpp_demangle_read_expr_primary(struct cpp_demangle_data *ddata)
981 {
982 const char *num;
983
984 if (ddata == NULL || *(++ddata->cur) == '\0')
985 return (0);
986
987 if (*ddata->cur == '_' && *(ddata->cur + 1) == 'Z') {
988 ddata->cur += 2;
989 if (*ddata->cur == '\0')
990 return (0);
991 if (!cpp_demangle_read_encoding(ddata))
992 return (0);
993 ++ddata->cur;
994 return (1);
995 }
996
997 switch (*ddata->cur) {
998 case 'b':
999 if (*(ddata->cur + 2) != 'E')
1000 return (0);
1001 switch (*(++ddata->cur)) {
1002 case '0':
1003 ddata->cur += 2;
1004 return (cpp_demangle_push_str(ddata, "false", 5));
1005 case '1':
1006 ddata->cur += 2;
1007 return (cpp_demangle_push_str(ddata, "true", 4));
1008 default:
1009 return (0);
1010 };
1011
1012 case 'd':
1013 ++ddata->cur;
1014 return (cpp_demangle_push_fp(ddata, decode_fp_to_double));
1015
1016 case 'e':
1017 ++ddata->cur;
1018 if (sizeof(long double) == 10)
1019 return (cpp_demangle_push_fp(ddata,
1020 decode_fp_to_double));
1021 return (cpp_demangle_push_fp(ddata, decode_fp_to_float80));
1022
1023 case 'f':
1024 ++ddata->cur;
1025 return (cpp_demangle_push_fp(ddata, decode_fp_to_float));
1026
1027 case 'g':
1028 ++ddata->cur;
1029 if (sizeof(long double) == 16)
1030 return (cpp_demangle_push_fp(ddata,
1031 decode_fp_to_double));
1032 return (cpp_demangle_push_fp(ddata, decode_fp_to_float128));
1033
1034 case 'i':
1035 case 'j':
1036 case 'l':
1037 case 'm':
1038 case 'n':
1039 case 's':
1040 case 't':
1041 case 'x':
1042 case 'y':
1043 if (*(++ddata->cur) == 'n') {
1044 if (!cpp_demangle_push_str(ddata, "-", 1))
1045 return (0);
1046 ++ddata->cur;
1047 }
1048 num = ddata->cur;
1049 while (*ddata->cur != 'E') {
1050 if (!ELFTC_ISDIGIT(*ddata->cur))
1051 return (0);
1052 ++ddata->cur;
1053 }
1054 ++ddata->cur;
1055 return (cpp_demangle_push_str(ddata, num,
1056 ddata->cur - num - 1));
1057
1058 default:
1059 return (0);
1060 };
1061 }
1062
1063 static int
1064 cpp_demangle_read_expression(struct cpp_demangle_data *ddata)
1065 {
1066
1067 if (ddata == NULL || *ddata->cur == '\0')
1068 return (0);
1069
1070 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
1071 case SIMPLE_HASH('s', 't'):
1072 ddata->cur += 2;
1073 return (cpp_demangle_read_type(ddata, 0));
1074
1075 case SIMPLE_HASH('s', 'r'):
1076 ddata->cur += 2;
1077 if (!cpp_demangle_read_type(ddata, 0))
1078 return (0);
1079 if (!cpp_demangle_read_uqname(ddata))
1080 return (0);
1081 if (*ddata->cur == 'I')
1082 return (cpp_demangle_read_tmpl_args(ddata));
1083 return (1);
1084
1085 case SIMPLE_HASH('a', 'a'):
1086 /* operator && */
1087 ddata->cur += 2;
1088 return (cpp_demangle_read_expression_binary(ddata, "&&", 2));
1089
1090 case SIMPLE_HASH('a', 'd'):
1091 /* operator & (unary) */
1092 ddata->cur += 2;
1093 return (cpp_demangle_read_expression_unary(ddata, "&", 1));
1094
1095 case SIMPLE_HASH('a', 'n'):
1096 /* operator & */
1097 ddata->cur += 2;
1098 return (cpp_demangle_read_expression_binary(ddata, "&", 1));
1099
1100 case SIMPLE_HASH('a', 'N'):
1101 /* operator &= */
1102 ddata->cur += 2;
1103 return (cpp_demangle_read_expression_binary(ddata, "&=", 2));
1104
1105 case SIMPLE_HASH('a', 'S'):
1106 /* operator = */
1107 ddata->cur += 2;
1108 return (cpp_demangle_read_expression_binary(ddata, "=", 1));
1109
1110 case SIMPLE_HASH('c', 'l'):
1111 /* operator () */
1112 ddata->cur += 2;
1113 return (cpp_demangle_read_expression_binary(ddata, "()", 2));
1114
1115 case SIMPLE_HASH('c', 'm'):
1116 /* operator , */
1117 ddata->cur += 2;
1118 return (cpp_demangle_read_expression_binary(ddata, ",", 1));
1119
1120 case SIMPLE_HASH('c', 'o'):
1121 /* operator ~ */
1122 ddata->cur += 2;
1123 return (cpp_demangle_read_expression_binary(ddata, "~", 1));
1124
1125 case SIMPLE_HASH('c', 'v'):
1126 /* operator (cast) */
1127 ddata->cur += 2;
1128 return (cpp_demangle_read_expression_binary(ddata, "(cast)", 6));
1129
1130 case SIMPLE_HASH('d', 'a'):
1131 /* operator delete [] */
1132 ddata->cur += 2;
1133 return (cpp_demangle_read_expression_unary(ddata, "delete []", 9));
1134
1135 case SIMPLE_HASH('d', 'e'):
1136 /* operator * (unary) */
1137 ddata->cur += 2;
1138 return (cpp_demangle_read_expression_unary(ddata, "*", 1));
1139
1140 case SIMPLE_HASH('d', 'l'):
1141 /* operator delete */
1142 ddata->cur += 2;
1143 return (cpp_demangle_read_expression_unary(ddata, "delete", 6));
1144
1145 case SIMPLE_HASH('d', 'v'):
1146 /* operator / */
1147 ddata->cur += 2;
1148 return (cpp_demangle_read_expression_binary(ddata, "/", 1));
1149
1150 case SIMPLE_HASH('d', 'V'):
1151 /* operator /= */
1152 ddata->cur += 2;
1153 return (cpp_demangle_read_expression_binary(ddata, "/=", 2));
1154
1155 case SIMPLE_HASH('e', 'o'):
1156 /* operator ^ */
1157 ddata->cur += 2;
1158 return (cpp_demangle_read_expression_binary(ddata, "^", 1));
1159
1160 case SIMPLE_HASH('e', 'O'):
1161 /* operator ^= */
1162 ddata->cur += 2;
1163 return (cpp_demangle_read_expression_binary(ddata, "^=", 2));
1164
1165 case SIMPLE_HASH('e', 'q'):
1166 /* operator == */
1167 ddata->cur += 2;
1168 return (cpp_demangle_read_expression_binary(ddata, "==", 2));
1169
1170 case SIMPLE_HASH('g', 'e'):
1171 /* operator >= */
1172 ddata->cur += 2;
1173 return (cpp_demangle_read_expression_binary(ddata, ">=", 2));
1174
1175 case SIMPLE_HASH('g', 't'):
1176 /* operator > */
1177 ddata->cur += 2;
1178 return (cpp_demangle_read_expression_binary(ddata, ">", 1));
1179
1180 case SIMPLE_HASH('i', 'x'):
1181 /* operator [] */
1182 ddata->cur += 2;
1183 return (cpp_demangle_read_expression_binary(ddata, "[]", 2));
1184
1185 case SIMPLE_HASH('l', 'e'):
1186 /* operator <= */
1187 ddata->cur += 2;
1188 return (cpp_demangle_read_expression_binary(ddata, "<=", 2));
1189
1190 case SIMPLE_HASH('l', 's'):
1191 /* operator << */
1192 ddata->cur += 2;
1193 return (cpp_demangle_read_expression_binary(ddata, "<<", 2));
1194
1195 case SIMPLE_HASH('l', 'S'):
1196 /* operator <<= */
1197 ddata->cur += 2;
1198 return (cpp_demangle_read_expression_binary(ddata, "<<=", 3));
1199
1200 case SIMPLE_HASH('l', 't'):
1201 /* operator < */
1202 ddata->cur += 2;
1203 return (cpp_demangle_read_expression_binary(ddata, "<", 1));
1204
1205 case SIMPLE_HASH('m', 'i'):
1206 /* operator - */
1207 ddata->cur += 2;
1208 return (cpp_demangle_read_expression_binary(ddata, "-", 1));
1209
1210 case SIMPLE_HASH('m', 'I'):
1211 /* operator -= */
1212 ddata->cur += 2;
1213 return (cpp_demangle_read_expression_binary(ddata, "-=", 2));
1214
1215 case SIMPLE_HASH('m', 'l'):
1216 /* operator * */
1217 ddata->cur += 2;
1218 return (cpp_demangle_read_expression_binary(ddata, "*", 1));
1219
1220 case SIMPLE_HASH('m', 'L'):
1221 /* operator *= */
1222 ddata->cur += 2;
1223 return (cpp_demangle_read_expression_binary(ddata, "*=", 2));
1224
1225 case SIMPLE_HASH('m', 'm'):
1226 /* operator -- */
1227 ddata->cur += 2;
1228 return (cpp_demangle_read_expression_binary(ddata, "--", 2));
1229
1230 case SIMPLE_HASH('n', 'a'):
1231 /* operator new[] */
1232 ddata->cur += 2;
1233 return (cpp_demangle_read_expression_unary(ddata, "new []", 6));
1234
1235 case SIMPLE_HASH('n', 'e'):
1236 /* operator != */
1237 ddata->cur += 2;
1238 return (cpp_demangle_read_expression_binary(ddata, "!=", 2));
1239
1240 case SIMPLE_HASH('n', 'g'):
1241 /* operator - (unary) */
1242 ddata->cur += 2;
1243 return (cpp_demangle_read_expression_unary(ddata, "-", 1));
1244
1245 case SIMPLE_HASH('n', 't'):
1246 /* operator ! */
1247 ddata->cur += 2;
1248 return (cpp_demangle_read_expression_binary(ddata, "!", 1));
1249
1250 case SIMPLE_HASH('n', 'w'):
1251 /* operator new */
1252 ddata->cur += 2;
1253 return (cpp_demangle_read_expression_unary(ddata, "new", 3));
1254
1255 case SIMPLE_HASH('o', 'o'):
1256 /* operator || */
1257 ddata->cur += 2;
1258 return (cpp_demangle_read_expression_binary(ddata, "||", 2));
1259
1260 case SIMPLE_HASH('o', 'r'):
1261 /* operator | */
1262 ddata->cur += 2;
1263 return (cpp_demangle_read_expression_binary(ddata, "|", 1));
1264
1265 case SIMPLE_HASH('o', 'R'):
1266 /* operator |= */
1267 ddata->cur += 2;
1268 return (cpp_demangle_read_expression_binary(ddata, "|=", 2));
1269
1270 case SIMPLE_HASH('p', 'l'):
1271 /* operator + */
1272 ddata->cur += 2;
1273 return (cpp_demangle_read_expression_binary(ddata, "+", 1));
1274
1275 case SIMPLE_HASH('p', 'L'):
1276 /* operator += */
1277 ddata->cur += 2;
1278 return (cpp_demangle_read_expression_binary(ddata, "+=", 2));
1279
1280 case SIMPLE_HASH('p', 'm'):
1281 /* operator ->* */
1282 ddata->cur += 2;
1283 return (cpp_demangle_read_expression_binary(ddata, "->*", 3));
1284
1285 case SIMPLE_HASH('p', 'p'):
1286 /* operator ++ */
1287 ddata->cur += 2;
1288 return (cpp_demangle_read_expression_binary(ddata, "++", 2));
1289
1290 case SIMPLE_HASH('p', 's'):
1291 /* operator + (unary) */
1292 ddata->cur += 2;
1293 return (cpp_demangle_read_expression_unary(ddata, "+", 1));
1294
1295 case SIMPLE_HASH('p', 't'):
1296 /* operator -> */
1297 ddata->cur += 2;
1298 return (cpp_demangle_read_expression_binary(ddata, "->", 2));
1299
1300 case SIMPLE_HASH('q', 'u'):
1301 /* operator ? */
1302 ddata->cur += 2;
1303 return (cpp_demangle_read_expression_trinary(ddata, "?", 1,
1304 ":", 1));
1305
1306 case SIMPLE_HASH('r', 'm'):
1307 /* operator % */
1308 ddata->cur += 2;
1309 return (cpp_demangle_read_expression_binary(ddata, "%", 1));
1310
1311 case SIMPLE_HASH('r', 'M'):
1312 /* operator %= */
1313 ddata->cur += 2;
1314 return (cpp_demangle_read_expression_binary(ddata, "%=", 2));
1315
1316 case SIMPLE_HASH('r', 's'):
1317 /* operator >> */
1318 ddata->cur += 2;
1319 return (cpp_demangle_read_expression_binary(ddata, ">>", 2));
1320
1321 case SIMPLE_HASH('r', 'S'):
1322 /* operator >>= */
1323 ddata->cur += 2;
1324 return (cpp_demangle_read_expression_binary(ddata, ">>=", 3));
1325
1326 case SIMPLE_HASH('r', 'z'):
1327 /* operator sizeof */
1328 ddata->cur += 2;
1329 return (cpp_demangle_read_expression_unary(ddata, "sizeof", 6));
1330
1331 case SIMPLE_HASH('s', 'v'):
1332 /* operator sizeof */
1333 ddata->cur += 2;
1334 return (cpp_demangle_read_expression_unary(ddata, "sizeof", 6));
1335 };
1336
1337 switch (*ddata->cur) {
1338 case 'L':
1339 return (cpp_demangle_read_expr_primary(ddata));
1340 case 'T':
1341 return (cpp_demangle_read_tmpl_param(ddata));
1342 };
1343
1344 return (0);
1345 }
1346
1347 static int
1348 cpp_demangle_read_expression_flat(struct cpp_demangle_data *ddata, char **str)
1349 {
1350 struct vector_str *output;
1351 size_t i, p_idx, idx, exp_len;
1352 char *exp;
1353
1354 output = ddata->push_head > 0 ? &ddata->output_tmp :
1355 &ddata->output;
1356
1357 p_idx = output->size;
1358
1359 if (!cpp_demangle_read_expression(ddata))
1360 return (0);
1361
1362 if ((exp = vector_str_substr(output, p_idx, output->size - 1,
1363 &exp_len)) == NULL)
1364 return (0);
1365
1366 idx = output->size;
1367 for (i = p_idx; i < idx; ++i) {
1368 if (!vector_str_pop(output)) {
1369 free(exp);
1370 return (0);
1371 }
1372 }
1373
1374 *str = exp;
1375
1376 return (1);
1377 }
1378
1379 static int
1380 cpp_demangle_read_expression_binary(struct cpp_demangle_data *ddata,
1381 const char *name, size_t len)
1382 {
1383
1384 if (ddata == NULL || name == NULL || len == 0)
1385 return (0);
1386 if (!cpp_demangle_read_expression(ddata))
1387 return (0);
1388 if (!cpp_demangle_push_str(ddata, name, len))
1389 return (0);
1390
1391 return (cpp_demangle_read_expression(ddata));
1392 }
1393
1394 static int
1395 cpp_demangle_read_expression_unary(struct cpp_demangle_data *ddata,
1396 const char *name, size_t len)
1397 {
1398
1399 if (ddata == NULL || name == NULL || len == 0)
1400 return (0);
1401 if (!cpp_demangle_read_expression(ddata))
1402 return (0);
1403
1404 return (cpp_demangle_push_str(ddata, name, len));
1405 }
1406
1407 static int
1408 cpp_demangle_read_expression_trinary(struct cpp_demangle_data *ddata,
1409 const char *name1, size_t len1, const char *name2, size_t len2)
1410 {
1411
1412 if (ddata == NULL || name1 == NULL || len1 == 0 || name2 == NULL ||
1413 len2 == 0)
1414 return (0);
1415
1416 if (!cpp_demangle_read_expression(ddata))
1417 return (0);
1418 if (!cpp_demangle_push_str(ddata, name1, len1))
1419 return (0);
1420 if (!cpp_demangle_read_expression(ddata))
1421 return (0);
1422 if (!cpp_demangle_push_str(ddata, name2, len2))
1423 return (0);
1424
1425 return (cpp_demangle_read_expression(ddata));
1426 }
1427
1428 static int
1429 cpp_demangle_read_function(struct cpp_demangle_data *ddata, int *ext_c,
1430 struct vector_type_qualifier *v)
1431 {
1432 size_t class_type_size, class_type_len, limit;
1433 const char *class_type;
1434
1435 if (ddata == NULL || *ddata->cur != 'F' || v == NULL)
1436 return (0);
1437
1438 ++ddata->cur;
1439 if (*ddata->cur == 'Y') {
1440 if (ext_c != NULL)
1441 *ext_c = 1;
1442 ++ddata->cur;
1443 }
1444 if (!cpp_demangle_read_type(ddata, 0))
1445 return (0);
1446 if (*ddata->cur != 'E') {
1447 if (!cpp_demangle_push_str(ddata, "(", 1))
1448 return (0);
1449 if (vector_read_cmd_find(&ddata->cmd, READ_PTRMEM)) {
1450 if ((class_type_size = ddata->class_type.size) == 0)
1451 return (0);
1452 class_type =
1453 ddata->class_type.container[class_type_size - 1];
1454 if (class_type == NULL)
1455 return (0);
1456 if ((class_type_len = strlen(class_type)) == 0)
1457 return (0);
1458 if (!cpp_demangle_push_str(ddata, class_type,
1459 class_type_len))
1460 return (0);
1461 if (!cpp_demangle_push_str(ddata, "::*", 3))
1462 return (0);
1463 ++ddata->func_type;
1464 } else {
1465 if (!cpp_demangle_push_type_qualifier(ddata, v,
1466 (const char *) NULL))
1467 return (0);
1468 vector_type_qualifier_dest(v);
1469 if (!vector_type_qualifier_init(v))
1470 return (0);
1471 }
1472
1473 if (!cpp_demangle_push_str(ddata, ")(", 2))
1474 return (0);
1475
1476 limit = 0;
1477 for (;;) {
1478 if (!cpp_demangle_read_type(ddata, 0))
1479 return (0);
1480 if (*ddata->cur == 'E')
1481 break;
1482 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
1483 return (0);
1484 }
1485
1486 if (vector_read_cmd_find(&ddata->cmd, READ_PTRMEM) == 1) {
1487 if (!cpp_demangle_push_type_qualifier(ddata, v,
1488 (const char *) NULL))
1489 return (0);
1490 vector_type_qualifier_dest(v);
1491 if (!vector_type_qualifier_init(v))
1492 return (0);
1493 }
1494
1495 if (!cpp_demangle_push_str(ddata, ")", 1))
1496 return (0);
1497 }
1498
1499 ++ddata->cur;
1500
1501 return (1);
1502 }
1503
1504 /* read encoding, encoding are function name, data name, special-name */
1505 static int
1506 cpp_demangle_read_encoding(struct cpp_demangle_data *ddata)
1507 {
1508 char *name, *type, *num_str;
1509 long offset;
1510 int rtn;
1511
1512 if (ddata == NULL || *ddata->cur == '\0')
1513 return (0);
1514
1515 /* special name */
1516 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
1517 case SIMPLE_HASH('G', 'A'):
1518 if (!cpp_demangle_push_str(ddata, "hidden alias for ", 17))
1519 return (0);
1520 ddata->cur += 2;
1521 if (*ddata->cur == '\0')
1522 return (0);
1523 return (cpp_demangle_read_encoding(ddata));
1524
1525 case SIMPLE_HASH('G', 'R'):
1526 if (!cpp_demangle_push_str(ddata, "reference temporary #", 21))
1527 return (0);
1528 ddata->cur += 2;
1529 if (*ddata->cur == '\0')
1530 return (0);
1531 if (!cpp_demangle_read_name_flat(ddata, &name))
1532 return (0);
1533 rtn = 0;
1534 if (!cpp_demangle_read_number_as_string(ddata, &num_str))
1535 goto clean1;
1536 if (!cpp_demangle_push_str(ddata, num_str, strlen(num_str)))
1537 goto clean2;
1538 if (!cpp_demangle_push_str(ddata, " for ", 5))
1539 goto clean2;
1540 if (!cpp_demangle_push_str(ddata, name, strlen(name)))
1541 goto clean2;
1542 rtn = 1;
1543 clean2:
1544 free(num_str);
1545 clean1:
1546 free(name);
1547 return (rtn);
1548
1549 case SIMPLE_HASH('G', 'T'):
1550 ddata->cur += 2;
1551 if (*ddata->cur == '\0')
1552 return (0);
1553 switch (*ddata->cur) {
1554 case 'n':
1555 if (!cpp_demangle_push_str(ddata,
1556 "non-transaction clone for ", 26))
1557 return (0);
1558 case 't':
1559 default:
1560 if (!cpp_demangle_push_str(ddata,
1561 "transaction clone for ", 22))
1562 return (0);
1563 }
1564 ++ddata->cur;
1565 return (cpp_demangle_read_encoding(ddata));
1566
1567 case SIMPLE_HASH('G', 'V'):
1568 /* sentry object for 1 time init */
1569 if (!cpp_demangle_push_str(ddata, "guard variable for ", 20))
1570 return (0);
1571 ddata->cur += 2;
1572 break;
1573
1574 case SIMPLE_HASH('T', 'c'):
1575 /* virtual function covariant override thunk */
1576 if (!cpp_demangle_push_str(ddata,
1577 "virtual function covariant override ", 36))
1578 return (0);
1579 ddata->cur += 2;
1580 if (*ddata->cur == '\0')
1581 return (0);
1582 if (!cpp_demangle_read_offset(ddata))
1583 return (0);
1584 if (!cpp_demangle_read_offset(ddata))
1585 return (0);
1586 return (cpp_demangle_read_encoding(ddata));
1587
1588 case SIMPLE_HASH('T', 'C'):
1589 /* construction vtable */
1590 if (!cpp_demangle_push_str(ddata, "construction vtable for ",
1591 24))
1592 return (0);
1593 ddata->cur += 2;
1594 if (*ddata->cur == '\0')
1595 return (0);
1596 if (!cpp_demangle_read_type_flat(ddata, &type))
1597 return (0);
1598 rtn = 0;
1599 if (!cpp_demangle_read_number(ddata, &offset))
1600 goto clean3;
1601 if (*ddata->cur++ != '_')
1602 goto clean3;
1603 if (!cpp_demangle_read_type(ddata, 0))
1604 goto clean3;
1605 if (!cpp_demangle_push_str(ddata, "-in-", 4))
1606 goto clean3;
1607 if (!cpp_demangle_push_str(ddata, type, strlen(type)))
1608 goto clean3;
1609 rtn = 1;
1610 clean3:
1611 free(type);
1612 return (rtn);
1613
1614 case SIMPLE_HASH('T', 'D'):
1615 /* typeinfo common proxy */
1616 break;
1617
1618 case SIMPLE_HASH('T', 'F'):
1619 /* typeinfo fn */
1620 if (!cpp_demangle_push_str(ddata, "typeinfo fn for ", 16))
1621 return (0);
1622 ddata->cur += 2;
1623 if (*ddata->cur == '\0')
1624 return (0);
1625 return (cpp_demangle_read_type(ddata, 0));
1626
1627 case SIMPLE_HASH('T', 'h'):
1628 /* virtual function non-virtual override thunk */
1629 if (!cpp_demangle_push_str(ddata,
1630 "virtual function non-virtual override ", 38))
1631 return (0);
1632 ddata->cur += 2;
1633 if (*ddata->cur == '\0')
1634 return (0);
1635 if (!cpp_demangle_read_nv_offset(ddata))
1636 return (0);
1637 return (cpp_demangle_read_encoding(ddata));
1638
1639 case SIMPLE_HASH('T', 'H'):
1640 /* TLS init function */
1641 if (!cpp_demangle_push_str(ddata, "TLS init function for ",
1642 22))
1643 return (0);
1644 ddata->cur += 2;
1645 if (*ddata->cur == '\0')
1646 return (0);
1647 break;
1648
1649 case SIMPLE_HASH('T', 'I'):
1650 /* typeinfo structure */
1651 if (!cpp_demangle_push_str(ddata, "typeinfo for ", 13))
1652 return (0);
1653 ddata->cur += 2;
1654 if (*ddata->cur == '\0')
1655 return (0);
1656 return (cpp_demangle_read_type(ddata, 0));
1657
1658 case SIMPLE_HASH('T', 'J'):
1659 /* java class */
1660 if (!cpp_demangle_push_str(ddata, "java Class for ", 15))
1661 return (0);
1662 ddata->cur += 2;
1663 if (*ddata->cur == '\0')
1664 return (0);
1665 return (cpp_demangle_read_type(ddata, 0));
1666
1667 case SIMPLE_HASH('T', 'S'):
1668 /* RTTI name (NTBS) */
1669 if (!cpp_demangle_push_str(ddata, "typeinfo name for ", 18))
1670 return (0);
1671 ddata->cur += 2;
1672 if (*ddata->cur == '\0')
1673 return (0);
1674 return (cpp_demangle_read_type(ddata, 0));
1675
1676 case SIMPLE_HASH('T', 'T'):
1677 /* VTT table */
1678 if (!cpp_demangle_push_str(ddata, "VTT for ", 8))
1679 return (0);
1680 ddata->cur += 2;
1681 if (*ddata->cur == '\0')
1682 return (0);
1683 return (cpp_demangle_read_type(ddata, 0));
1684
1685 case SIMPLE_HASH('T', 'v'):
1686 /* virtual function virtual override thunk */
1687 if (!cpp_demangle_push_str(ddata,
1688 "virtual function virtual override ", 34))
1689 return (0);
1690 ddata->cur += 2;
1691 if (*ddata->cur == '\0')
1692 return (0);
1693 if (!cpp_demangle_read_v_offset(ddata))
1694 return (0);
1695 return (cpp_demangle_read_encoding(ddata));
1696
1697 case SIMPLE_HASH('T', 'V'):
1698 /* virtual table */
1699 if (!cpp_demangle_push_str(ddata, "vtable for ", 12))
1700 return (0);
1701 ddata->cur += 2;
1702 if (*ddata->cur == '\0')
1703 return (0);
1704 return (cpp_demangle_read_type(ddata, 0));
1705
1706 case SIMPLE_HASH('T', 'W'):
1707 /* TLS wrapper function */
1708 if (!cpp_demangle_push_str(ddata, "TLS wrapper function for ",
1709 25))
1710 return (0);
1711 ddata->cur += 2;
1712 if (*ddata->cur == '\0')
1713 return (0);
1714 break;
1715 };
1716
1717 return (cpp_demangle_read_name(ddata));
1718 }
1719
1720 static int
1721 cpp_demangle_read_local_name(struct cpp_demangle_data *ddata)
1722 {
1723 size_t limit;
1724
1725 if (ddata == NULL)
1726 return (0);
1727 if (*(++ddata->cur) == '\0')
1728 return (0);
1729 if (!cpp_demangle_read_encoding(ddata))
1730 return (0);
1731
1732 limit = 0;
1733 for (;;) {
1734 if (!cpp_demangle_read_type(ddata, 1))
1735 return (0);
1736 if (*ddata->cur == 'E')
1737 break;
1738 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
1739 return (0);
1740 }
1741 if (*(++ddata->cur) == '\0')
1742 return (0);
1743 if (ddata->paren == true) {
1744 if (!cpp_demangle_push_str(ddata, ")", 1))
1745 return (0);
1746 ddata->paren = false;
1747 }
1748 if (*ddata->cur == 's')
1749 ++ddata->cur;
1750 else {
1751 if (!cpp_demangle_push_str(ddata, "::", 2))
1752 return (0);
1753 if (!cpp_demangle_read_name(ddata))
1754 return (0);
1755 }
1756 if (*ddata->cur == '_') {
1757 ++ddata->cur;
1758 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
1759 ++ddata->cur;
1760 }
1761
1762 return (1);
1763 }
1764
1765 static int
1766 cpp_demangle_read_name(struct cpp_demangle_data *ddata)
1767 {
1768 struct vector_str *output, v;
1769 size_t p_idx, subst_str_len;
1770 int rtn;
1771 char *subst_str;
1772
1773 if (ddata == NULL || *ddata->cur == '\0')
1774 return (0);
1775
1776 output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
1777
1778 subst_str = NULL;
1779
1780 switch (*ddata->cur) {
1781 case 'S':
1782 return (cpp_demangle_read_subst(ddata));
1783 case 'N':
1784 return (cpp_demangle_read_nested_name(ddata));
1785 case 'Z':
1786 return (cpp_demangle_read_local_name(ddata));
1787 };
1788
1789 if (!vector_str_init(&v))
1790 return (0);
1791
1792 p_idx = output->size;
1793 rtn = 0;
1794 if (!cpp_demangle_read_uqname(ddata))
1795 goto clean;
1796 if ((subst_str = vector_str_substr(output, p_idx, output->size - 1,
1797 &subst_str_len)) == NULL)
1798 goto clean;
1799 if (subst_str_len > 8 && strstr(subst_str, "operator") != NULL) {
1800 rtn = 1;
1801 goto clean;
1802 }
1803 if (!vector_str_push(&v, subst_str, subst_str_len))
1804 goto clean;
1805 if (!cpp_demangle_push_subst_v(ddata, &v))
1806 goto clean;
1807
1808 if (*ddata->cur == 'I') {
1809 p_idx = output->size;
1810 if (!cpp_demangle_read_tmpl_args(ddata))
1811 goto clean;
1812 free(subst_str);
1813 if ((subst_str = vector_str_substr(output, p_idx,
1814 output->size - 1, &subst_str_len)) == NULL)
1815 goto clean;
1816 if (!vector_str_push(&v, subst_str, subst_str_len))
1817 goto clean;
1818 if (!cpp_demangle_push_subst_v(ddata, &v))
1819 goto clean;
1820 }
1821
1822 rtn = 1;
1823
1824 clean:
1825 free(subst_str);
1826 vector_str_dest(&v);
1827
1828 return (rtn);
1829 }
1830
1831 static int
1832 cpp_demangle_read_name_flat(struct cpp_demangle_data *ddata, char **str)
1833 {
1834 struct vector_str *output;
1835 size_t i, p_idx, idx, name_len;
1836 char *name;
1837
1838 output = ddata->push_head > 0 ? &ddata->output_tmp :
1839 &ddata->output;
1840
1841 p_idx = output->size;
1842
1843 if (!cpp_demangle_read_name(ddata))
1844 return (0);
1845
1846 if ((name = vector_str_substr(output, p_idx, output->size - 1,
1847 &name_len)) == NULL)
1848 return (0);
1849
1850 idx = output->size;
1851 for (i = p_idx; i < idx; ++i) {
1852 if (!vector_str_pop(output)) {
1853 free(name);
1854 return (0);
1855 }
1856 }
1857
1858 *str = name;
1859
1860 return (1);
1861 }
1862
1863 static int
1864 cpp_demangle_read_nested_name(struct cpp_demangle_data *ddata)
1865 {
1866 struct vector_str *output, v;
1867 size_t limit, p_idx, subst_str_len;
1868 int rtn;
1869 char *subst_str;
1870
1871 if (ddata == NULL || *ddata->cur != 'N')
1872 return (0);
1873 if (*(++ddata->cur) == '\0')
1874 return (0);
1875
1876 while (*ddata->cur == 'r' || *ddata->cur == 'V' ||
1877 *ddata->cur == 'K') {
1878 switch (*ddata->cur) {
1879 case 'r':
1880 ddata->mem_rst = true;
1881 break;
1882 case 'V':
1883 ddata->mem_vat = true;
1884 break;
1885 case 'K':
1886 ddata->mem_cst = true;
1887 break;
1888 };
1889 ++ddata->cur;
1890 }
1891
1892 output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
1893 if (!vector_str_init(&v))
1894 return (0);
1895
1896 rtn = 0;
1897 limit = 0;
1898 for (;;) {
1899 p_idx = output->size;
1900 switch (*ddata->cur) {
1901 case 'I':
1902 if (!cpp_demangle_read_tmpl_args(ddata))
1903 goto clean;
1904 break;
1905 case 'S':
1906 if (!cpp_demangle_read_subst(ddata))
1907 goto clean;
1908 break;
1909 case 'T':
1910 if (!cpp_demangle_read_tmpl_param(ddata))
1911 goto clean;
1912 break;
1913 default:
1914 if (!cpp_demangle_read_uqname(ddata))
1915 goto clean;
1916 };
1917
1918 if ((subst_str = vector_str_substr(output, p_idx,
1919 output->size - 1, &subst_str_len)) == NULL)
1920 goto clean;
1921 if (!vector_str_push(&v, subst_str, subst_str_len)) {
1922 free(subst_str);
1923 goto clean;
1924 }
1925 free(subst_str);
1926
1927 if (!cpp_demangle_push_subst_v(ddata, &v))
1928 goto clean;
1929 if (*ddata->cur == 'E')
1930 break;
1931 else if (*ddata->cur != 'I' &&
1932 *ddata->cur != 'C' && *ddata->cur != 'D') {
1933 if (!cpp_demangle_push_str(ddata, "::", 2))
1934 goto clean;
1935 if (!vector_str_push(&v, "::", 2))
1936 goto clean;
1937 }
1938 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
1939 goto clean;
1940 }
1941
1942 ++ddata->cur;
1943 rtn = 1;
1944
1945 clean:
1946 vector_str_dest(&v);
1947
1948 return (rtn);
1949 }
1950
1951 /*
1952 * read number
1953 * number ::= [n] <decimal>
1954 */
1955 static int
1956 cpp_demangle_read_number(struct cpp_demangle_data *ddata, long *rtn)
1957 {
1958 long len, negative_factor;
1959
1960 if (ddata == NULL || rtn == NULL)
1961 return (0);
1962
1963 negative_factor = 1;
1964 if (*ddata->cur == 'n') {
1965 negative_factor = -1;
1966
1967 ++ddata->cur;
1968 }
1969 if (ELFTC_ISDIGIT(*ddata->cur) == 0)
1970 return (0);
1971
1972 errno = 0;
1973 if ((len = strtol(ddata->cur, (char **) NULL, 10)) == 0 &&
1974 errno != 0)
1975 return (0);
1976
1977 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
1978 ++ddata->cur;
1979
1980 assert(len >= 0);
1981 assert(negative_factor == 1 || negative_factor == -1);
1982
1983 *rtn = len * negative_factor;
1984
1985 return (1);
1986 }
1987
1988 static int
1989 cpp_demangle_read_number_as_string(struct cpp_demangle_data *ddata, char **str)
1990 {
1991 long n;
1992
1993 if (!cpp_demangle_read_number(ddata, &n)) {
1994 *str = NULL;
1995 return (0);
1996 }
1997
1998 if (asprintf(str, "%ld", n) < 0) {
1999 *str = NULL;
2000 return (0);
2001 }
2002
2003 return (1);
2004 }
2005
2006 static int
2007 cpp_demangle_read_nv_offset(struct cpp_demangle_data *ddata)
2008 {
2009
2010 if (ddata == NULL)
2011 return (0);
2012
2013 if (!cpp_demangle_push_str(ddata, "offset : ", 9))
2014 return (0);
2015
2016 return (cpp_demangle_read_offset_number(ddata));
2017 }
2018
2019 /* read offset, offset are nv-offset, v-offset */
2020 static int
2021 cpp_demangle_read_offset(struct cpp_demangle_data *ddata)
2022 {
2023
2024 if (ddata == NULL)
2025 return (0);
2026
2027 if (*ddata->cur == 'h') {
2028 ++ddata->cur;
2029 return (cpp_demangle_read_nv_offset(ddata));
2030 } else if (*ddata->cur == 'v') {
2031 ++ddata->cur;
2032 return (cpp_demangle_read_v_offset(ddata));
2033 }
2034
2035 return (0);
2036 }
2037
2038 static int
2039 cpp_demangle_read_offset_number(struct cpp_demangle_data *ddata)
2040 {
2041 bool negative;
2042 const char *start;
2043
2044 if (ddata == NULL || *ddata->cur == '\0')
2045 return (0);
2046
2047 /* offset could be negative */
2048 if (*ddata->cur == 'n') {
2049 negative = true;
2050 start = ddata->cur + 1;
2051 } else {
2052 negative = false;
2053 start = ddata->cur;
2054 }
2055
2056 while (*ddata->cur != '_')
2057 ++ddata->cur;
2058
2059 if (negative && !cpp_demangle_push_str(ddata, "-", 1))
2060 return (0);
2061
2062 assert(start != NULL);
2063
2064 if (!cpp_demangle_push_str(ddata, start, ddata->cur - start))
2065 return (0);
2066 if (!cpp_demangle_push_str(ddata, " ", 1))
2067 return (0);
2068
2069 ++ddata->cur;
2070
2071 return (1);
2072 }
2073
2074 static int
2075 cpp_demangle_read_pointer_to_member(struct cpp_demangle_data *ddata)
2076 {
2077 size_t class_type_len, i, idx, p_idx;
2078 int p_func_type, rtn;
2079 char *class_type;
2080
2081 if (ddata == NULL || *ddata->cur != 'M' || *(++ddata->cur) == '\0')
2082 return (0);
2083
2084 p_idx = ddata->output.size;
2085 if (!cpp_demangle_read_type(ddata, 0))
2086 return (0);
2087
2088 if ((class_type = vector_str_substr(&ddata->output, p_idx,
2089 ddata->output.size - 1, &class_type_len)) == NULL)
2090 return (0);
2091
2092 rtn = 0;
2093 idx = ddata->output.size;
2094 for (i = p_idx; i < idx; ++i)
2095 if (!vector_str_pop(&ddata->output))
2096 goto clean1;
2097
2098 if (!vector_read_cmd_push(&ddata->cmd, READ_PTRMEM))
2099 goto clean1;
2100
2101 if (!vector_str_push(&ddata->class_type, class_type, class_type_len))
2102 goto clean2;
2103
2104 p_func_type = ddata->func_type;
2105 if (!cpp_demangle_read_type(ddata, 0))
2106 goto clean3;
2107
2108 if (p_func_type == ddata->func_type) {
2109 if (!cpp_demangle_push_str(ddata, " ", 1))
2110 goto clean3;
2111 if (!cpp_demangle_push_str(ddata, class_type, class_type_len))
2112 goto clean3;
2113 if (!cpp_demangle_push_str(ddata, "::*", 3))
2114 goto clean3;
2115 }
2116
2117 rtn = 1;
2118 clean3:
2119 if (!vector_str_pop(&ddata->class_type))
2120 rtn = 0;
2121 clean2:
2122 if (!vector_read_cmd_pop(&ddata->cmd))
2123 rtn = 0;
2124 clean1:
2125 free(class_type);
2126
2127 return (rtn);
2128 }
2129
2130 /* read source-name, source-name is <len> <ID> */
2131 static int
2132 cpp_demangle_read_sname(struct cpp_demangle_data *ddata)
2133 {
2134 long len;
2135 int err;
2136
2137 if (ddata == NULL || cpp_demangle_read_number(ddata, &len) == 0 ||
2138 len <= 0)
2139 return (0);
2140
2141 if (len == 12 && (memcmp("_GLOBAL__N_1", ddata->cur, 12) == 0))
2142 err = cpp_demangle_push_str(ddata, "(anonymous namespace)", 21);
2143 else
2144 err = cpp_demangle_push_str(ddata, ddata->cur, len);
2145
2146 if (err == 0)
2147 return (0);
2148
2149 assert(ddata->output.size > 0);
2150 if (vector_read_cmd_find(&ddata->cmd, READ_TMPL) == 0)
2151 ddata->last_sname =
2152 ddata->output.container[ddata->output.size - 1];
2153
2154 ddata->cur += len;
2155
2156 return (1);
2157 }
2158
2159 static int
2160 cpp_demangle_read_subst(struct cpp_demangle_data *ddata)
2161 {
2162 long nth;
2163
2164 if (ddata == NULL || *ddata->cur == '\0')
2165 return (0);
2166
2167 /* abbreviations of the form Sx */
2168 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
2169 case SIMPLE_HASH('S', 'a'):
2170 /* std::allocator */
2171 if (cpp_demangle_push_str(ddata, "std::allocator", 14) == 0)
2172 return (0);
2173 ddata->cur += 2;
2174 if (*ddata->cur == 'I')
2175 return (cpp_demangle_read_subst_stdtmpl(ddata,
2176 "std::allocator", 14));
2177 return (1);
2178
2179 case SIMPLE_HASH('S', 'b'):
2180 /* std::basic_string */
2181 if (!cpp_demangle_push_str(ddata, "std::basic_string", 17))
2182 return (0);
2183 ddata->cur += 2;
2184 if (*ddata->cur == 'I')
2185 return (cpp_demangle_read_subst_stdtmpl(ddata,
2186 "std::basic_string", 17));
2187 return (1);
2188
2189 case SIMPLE_HASH('S', 'd'):
2190 /* std::basic_iostream<char, std::char_traits<char> > */
2191 if (!cpp_demangle_push_str(ddata, "std::iostream", 19))
2192 return (0);
2193 ddata->last_sname = "iostream";
2194 ddata->cur += 2;
2195 if (*ddata->cur == 'I')
2196 return (cpp_demangle_read_subst_stdtmpl(ddata,
2197 "std::iostream", 19));
2198 return (1);
2199
2200 case SIMPLE_HASH('S', 'i'):
2201 /* std::basic_istream<char, std::char_traits<char> > */
2202 if (!cpp_demangle_push_str(ddata, "std::istream", 18))
2203 return (0);
2204 ddata->last_sname = "istream";
2205 ddata->cur += 2;
2206 if (*ddata->cur == 'I')
2207 return (cpp_demangle_read_subst_stdtmpl(ddata,
2208 "std::istream", 18));
2209 return (1);
2210
2211 case SIMPLE_HASH('S', 'o'):
2212 /* std::basic_ostream<char, std::char_traits<char> > */
2213 if (!cpp_demangle_push_str(ddata, "std::ostream", 18))
2214 return (0);
2215 ddata->last_sname = "istream";
2216 ddata->cur += 2;
2217 if (*ddata->cur == 'I')
2218 return (cpp_demangle_read_subst_stdtmpl(ddata,
2219 "std::ostream", 18));
2220 return (1);
2221
2222 case SIMPLE_HASH('S', 's'):
2223 /*
2224 * std::basic_string<char, std::char_traits<char>,
2225 * std::allocator<char> >
2226 *
2227 * a.k.a std::string
2228 */
2229 if (!cpp_demangle_push_str(ddata, "std::string", 11))
2230 return (0);
2231 ddata->last_sname = "string";
2232 ddata->cur += 2;
2233 if (*ddata->cur == 'I')
2234 return (cpp_demangle_read_subst_stdtmpl(ddata,
2235 "std::string", 11));
2236 return (1);
2237
2238 case SIMPLE_HASH('S', 't'):
2239 /* std:: */
2240 return (cpp_demangle_read_subst_std(ddata));
2241 };
2242
2243 if (*(++ddata->cur) == '\0')
2244 return (0);
2245
2246 /* substitution */
2247 if (*ddata->cur == '_')
2248 return (cpp_demangle_get_subst(ddata, 0));
2249 else {
2250 errno = 0;
2251 /* substitution number is base 36 */
2252 if ((nth = strtol(ddata->cur, (char **) NULL, 36)) == 0 &&
2253 errno != 0)
2254 return (0);
2255
2256 /* first was '_', so increase one */
2257 ++nth;
2258
2259 while (*ddata->cur != '_')
2260 ++ddata->cur;
2261
2262 assert(nth > 0);
2263
2264 return (cpp_demangle_get_subst(ddata, nth));
2265 }
2266
2267 /* NOTREACHED */
2268 return (0);
2269 }
2270
2271 static int
2272 cpp_demangle_read_subst_std(struct cpp_demangle_data *ddata)
2273 {
2274 struct vector_str *output, v;
2275 size_t p_idx, subst_str_len;
2276 int rtn;
2277 char *subst_str;
2278
2279 if (ddata == NULL)
2280 return (0);
2281
2282 if (!vector_str_init(&v))
2283 return (0);
2284
2285 subst_str = NULL;
2286 rtn = 0;
2287 if (!cpp_demangle_push_str(ddata, "std::", 5))
2288 goto clean;
2289
2290 if (!vector_str_push(&v, "std::", 5))
2291 goto clean;
2292
2293 ddata->cur += 2;
2294
2295 output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
2296
2297 p_idx = output->size;
2298 if (!cpp_demangle_read_uqname(ddata))
2299 goto clean;
2300
2301 if ((subst_str = vector_str_substr(output, p_idx, output->size - 1,
2302 &subst_str_len)) == NULL)
2303 goto clean;
2304
2305 if (!vector_str_push(&v, subst_str, subst_str_len))
2306 goto clean;
2307
2308 if (!cpp_demangle_push_subst_v(ddata, &v))
2309 goto clean;
2310
2311 if (*ddata->cur == 'I') {
2312 p_idx = output->size;
2313 if (!cpp_demangle_read_tmpl_args(ddata))
2314 goto clean;
2315 free(subst_str);
2316 if ((subst_str = vector_str_substr(output, p_idx,
2317 output->size - 1, &subst_str_len)) == NULL)
2318 goto clean;
2319 if (!vector_str_push(&v, subst_str, subst_str_len))
2320 goto clean;
2321 if (!cpp_demangle_push_subst_v(ddata, &v))
2322 goto clean;
2323 }
2324
2325 rtn = 1;
2326 clean:
2327 free(subst_str);
2328 vector_str_dest(&v);
2329
2330 return (rtn);
2331 }
2332
2333 static int
2334 cpp_demangle_read_subst_stdtmpl(struct cpp_demangle_data *ddata,
2335 const char *str, size_t len)
2336 {
2337 struct vector_str *output;
2338 size_t p_idx, substr_len;
2339 int rtn;
2340 char *subst_str, *substr;
2341
2342 if (ddata == NULL || str == NULL || len == 0)
2343 return (0);
2344
2345 output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
2346
2347 p_idx = output->size;
2348 substr = NULL;
2349 subst_str = NULL;
2350
2351 if (!cpp_demangle_read_tmpl_args(ddata))
2352 return (0);
2353 if ((substr = vector_str_substr(output, p_idx, output->size - 1,
2354 &substr_len)) == NULL)
2355 return (0);
2356
2357 rtn = 0;
2358 if ((subst_str = malloc(sizeof(char) * (substr_len + len + 1))) ==
2359 NULL)
2360 goto clean;
2361
2362 memcpy(subst_str, str, len);
2363 memcpy(subst_str + len, substr, substr_len);
2364 subst_str[substr_len + len] = '\0';
2365
2366 if (!cpp_demangle_push_subst(ddata, subst_str, substr_len + len))
2367 goto clean;
2368
2369 rtn = 1;
2370 clean:
2371 free(subst_str);
2372 free(substr);
2373
2374 return (rtn);
2375 }
2376
2377 static int
2378 cpp_demangle_read_tmpl_arg(struct cpp_demangle_data *ddata)
2379 {
2380
2381 if (ddata == NULL || *ddata->cur == '\0')
2382 return (0);
2383
2384 switch (*ddata->cur) {
2385 case 'L':
2386 return (cpp_demangle_read_expr_primary(ddata));
2387 case 'X':
2388 return (cpp_demangle_read_expression(ddata));
2389 };
2390
2391 return (cpp_demangle_read_type(ddata, 0));
2392 }
2393
2394 static int
2395 cpp_demangle_read_tmpl_args(struct cpp_demangle_data *ddata)
2396 {
2397 struct vector_str *v;
2398 size_t arg_len, idx, limit, size;
2399 char *arg;
2400
2401 if (ddata == NULL || *ddata->cur == '\0')
2402 return (0);
2403
2404 ++ddata->cur;
2405
2406 if (!vector_read_cmd_push(&ddata->cmd, READ_TMPL))
2407 return (0);
2408
2409 if (!cpp_demangle_push_str(ddata, "<", 1))
2410 return (0);
2411
2412 limit = 0;
2413 v = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
2414 for (;;) {
2415 idx = v->size;
2416 if (!cpp_demangle_read_tmpl_arg(ddata))
2417 return (0);
2418 if ((arg = vector_str_substr(v, idx, v->size - 1, &arg_len)) ==
2419 NULL)
2420 return (0);
2421 if (!vector_str_find(&ddata->tmpl, arg, arg_len) &&
2422 !vector_str_push(&ddata->tmpl, arg, arg_len)) {
2423 free(arg);
2424 return (0);
2425 }
2426
2427 free(arg);
2428
2429 if (*ddata->cur == 'E') {
2430 ++ddata->cur;
2431 size = v->size;
2432 assert(size > 0);
2433 if (!strncmp(v->container[size - 1], ">", 1)) {
2434 if (!cpp_demangle_push_str(ddata, " >", 2))
2435 return (0);
2436 } else if (!cpp_demangle_push_str(ddata, ">", 1))
2437 return (0);
2438 break;
2439 } else if (*ddata->cur != 'I' &&
2440 !cpp_demangle_push_str(ddata, ", ", 2))
2441 return (0);
2442
2443 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
2444 return (0);
2445 }
2446
2447 return (vector_read_cmd_pop(&ddata->cmd));
2448 }
2449
2450 /*
2451 * Read template parameter that forms in 'T[number]_'.
2452 * This function much like to read_subst but only for types.
2453 */
2454 static int
2455 cpp_demangle_read_tmpl_param(struct cpp_demangle_data *ddata)
2456 {
2457 long nth;
2458
2459 if (ddata == NULL || *ddata->cur != 'T')
2460 return (0);
2461
2462 ++ddata->cur;
2463
2464 if (*ddata->cur == '_')
2465 return (cpp_demangle_get_tmpl_param(ddata, 0));
2466 else {
2467
2468 errno = 0;
2469 if ((nth = strtol(ddata->cur, (char **) NULL, 36)) == 0 &&
2470 errno != 0)
2471 return (0);
2472
2473 /* T_ is first */
2474 ++nth;
2475
2476 while (*ddata->cur != '_')
2477 ++ddata->cur;
2478
2479 assert(nth > 0);
2480
2481 return (cpp_demangle_get_tmpl_param(ddata, nth));
2482 }
2483
2484 /* NOTREACHED */
2485 return (0);
2486 }
2487
2488 static int
2489 cpp_demangle_read_type(struct cpp_demangle_data *ddata, int delimit)
2490 {
2491 struct vector_type_qualifier v;
2492 struct vector_str *output;
2493 size_t p_idx, type_str_len;
2494 int extern_c, is_builtin;
2495 long len;
2496 char *type_str, *exp_str, *num_str;
2497
2498 if (ddata == NULL)
2499 return (0);
2500
2501 output = &ddata->output;
2502 if (ddata->output.size > 0 && !strncmp(ddata->output.container[ddata->output.size - 1], ">", 1)) {
2503 ddata->push_head++;
2504 output = &ddata->output_tmp;
2505 } else if (delimit == 1) {
2506 if (ddata->paren == false) {
2507 if (!cpp_demangle_push_str(ddata, "(", 1))
2508 return (0);
2509 if (ddata->output.size < 2)
2510 return (0);
2511 ddata->paren = true;
2512 ddata->pfirst = true;
2513 /* Need pop function name */
2514 if (ddata->subst.size == 1 &&
2515 !vector_str_pop(&ddata->subst))
2516 return (0);
2517 }
2518
2519 if (ddata->pfirst)
2520 ddata->pfirst = false;
2521 else if (*ddata->cur != 'I' &&
2522 !cpp_demangle_push_str(ddata, ", ", 2))
2523 return (0);
2524 }
2525
2526 assert(output != NULL);
2527 /*
2528 * [r, V, K] [P, R, C, G, U] builtin, function, class-enum, array
2529 * pointer-to-member, template-param, template-template-param, subst
2530 */
2531
2532 if (!vector_type_qualifier_init(&v))
2533 return (0);
2534
2535 extern_c = 0;
2536 is_builtin = 1;
2537 p_idx = output->size;
2538 type_str = exp_str = num_str = NULL;
2539 again:
2540 /* builtin type */
2541 switch (*ddata->cur) {
2542 case 'a':
2543 /* signed char */
2544 if (!cpp_demangle_push_str(ddata, "signed char", 11))
2545 goto clean;
2546 ++ddata->cur;
2547 goto rtn;
2548
2549 case 'A':
2550 /* array type */
2551 if (!cpp_demangle_read_array(ddata))
2552 goto clean;
2553 is_builtin = 0;
2554 goto rtn;
2555
2556 case 'b':
2557 /* bool */
2558 if (!cpp_demangle_push_str(ddata, "bool", 4))
2559 goto clean;
2560 ++ddata->cur;
2561 goto rtn;
2562
2563 case 'C':
2564 /* complex pair */
2565 if (!vector_type_qualifier_push(&v, TYPE_CMX))
2566 goto clean;
2567 ++ddata->cur;
2568 goto again;
2569
2570 case 'c':
2571 /* char */
2572 if (!cpp_demangle_push_str(ddata, "char", 4))
2573 goto clean;
2574 ++ddata->cur;
2575 goto rtn;
2576
2577 case 'd':
2578 /* double */
2579 if (!cpp_demangle_push_str(ddata, "double", 6))
2580 goto clean;
2581 ++ddata->cur;
2582 goto rtn;
2583
2584 case 'D':
2585 ++ddata->cur;
2586 switch (*ddata->cur) {
2587 case 'd':
2588 /* IEEE 754r decimal floating point (64 bits) */
2589 if (!cpp_demangle_push_str(ddata, "decimal64", 9))
2590 goto clean;
2591 ++ddata->cur;
2592 break;
2593 case 'e':
2594 /* IEEE 754r decimal floating point (128 bits) */
2595 if (!cpp_demangle_push_str(ddata, "decimal128", 10))
2596 goto clean;
2597 ++ddata->cur;
2598 break;
2599 case 'f':
2600 /* IEEE 754r decimal floating point (32 bits) */
2601 if (!cpp_demangle_push_str(ddata, "decimal32", 9))
2602 goto clean;
2603 ++ddata->cur;
2604 break;
2605 case 'h':
2606 /* IEEE 754r half-precision floating point (16 bits) */
2607 if (!cpp_demangle_push_str(ddata, "half", 4))
2608 goto clean;
2609 ++ddata->cur;
2610 break;
2611 case 'i':
2612 /* char32_t */
2613 if (!cpp_demangle_push_str(ddata, "char32_t", 8))
2614 goto clean;
2615 ++ddata->cur;
2616 break;
2617 case 'n':
2618 /* std::nullptr_t (i.e., decltype(nullptr)) */
2619 if (!cpp_demangle_push_str(ddata, "decltype(nullptr)",
2620 17))
2621 goto clean;
2622 ++ddata->cur;
2623 break;
2624 case 's':
2625 /* char16_t */
2626 if (!cpp_demangle_push_str(ddata, "char16_t", 8))
2627 goto clean;
2628 ++ddata->cur;
2629 break;
2630 case 'v':
2631 /* gcc vector_size extension. */
2632 ++ddata->cur;
2633 if (*ddata->cur == '_') {
2634 ++ddata->cur;
2635 if (!cpp_demangle_read_expression_flat(ddata,
2636 &exp_str))
2637 goto clean;
2638 if (!vector_str_push(&v.ext_name, exp_str,
2639 strlen(exp_str)))
2640 goto clean;
2641 } else {
2642 if (!cpp_demangle_read_number_as_string(ddata,
2643 &num_str))
2644 goto clean;
2645 if (!vector_str_push(&v.ext_name, num_str,
2646 strlen(num_str)))
2647 goto clean;
2648 }
2649 if (*ddata->cur != '_')
2650 goto clean;
2651 ++ddata->cur;
2652 if (!vector_type_qualifier_push(&v, TYPE_VEC))
2653 goto clean;
2654 goto again;
2655 default:
2656 goto clean;
2657 }
2658 goto rtn;
2659
2660 case 'e':
2661 /* long double */
2662 if (!cpp_demangle_push_str(ddata, "long double", 11))
2663 goto clean;
2664 ++ddata->cur;
2665 goto rtn;
2666
2667 case 'f':
2668 /* float */
2669 if (!cpp_demangle_push_str(ddata, "float", 5))
2670 goto clean;
2671 ++ddata->cur;
2672 goto rtn;
2673
2674 case 'F':
2675 /* function */
2676 if (!cpp_demangle_read_function(ddata, &extern_c, &v))
2677 goto clean;
2678 is_builtin = 0;
2679 goto rtn;
2680
2681 case 'g':
2682 /* __float128 */
2683 if (!cpp_demangle_push_str(ddata, "__float128", 10))
2684 goto clean;
2685 ++ddata->cur;
2686 goto rtn;
2687
2688 case 'G':
2689 /* imaginary */
2690 if (!vector_type_qualifier_push(&v, TYPE_IMG))
2691 goto clean;
2692 ++ddata->cur;
2693 goto again;
2694
2695 case 'h':
2696 /* unsigned char */
2697 if (!cpp_demangle_push_str(ddata, "unsigned char", 13))
2698 goto clean;
2699 ++ddata->cur;
2700 goto rtn;
2701
2702 case 'i':
2703 /* int */
2704 if (!cpp_demangle_push_str(ddata, "int", 3))
2705 goto clean;
2706 ++ddata->cur;
2707 goto rtn;
2708
2709 case 'j':
2710 /* unsigned int */
2711 if (!cpp_demangle_push_str(ddata, "unsigned int", 12))
2712 goto clean;
2713 ++ddata->cur;
2714 goto rtn;
2715
2716 case 'K':
2717 /* const */
2718 if (!vector_type_qualifier_push(&v, TYPE_CST))
2719 goto clean;
2720 ++ddata->cur;
2721 goto again;
2722
2723 case 'l':
2724 /* long */
2725 if (!cpp_demangle_push_str(ddata, "long", 4))
2726 goto clean;
2727 ++ddata->cur;
2728 goto rtn;
2729
2730 case 'm':
2731 /* unsigned long */
2732 if (!cpp_demangle_push_str(ddata, "unsigned long", 13))
2733 goto clean;
2734
2735 ++ddata->cur;
2736
2737 goto rtn;
2738 case 'M':
2739 /* pointer to member */
2740 if (!cpp_demangle_read_pointer_to_member(ddata))
2741 goto clean;
2742 is_builtin = 0;
2743 goto rtn;
2744
2745 case 'n':
2746 /* __int128 */
2747 if (!cpp_demangle_push_str(ddata, "__int128", 8))
2748 goto clean;
2749 ++ddata->cur;
2750 goto rtn;
2751
2752 case 'o':
2753 /* unsigned __int128 */
2754 if (!cpp_demangle_push_str(ddata, "unsigned __int128", 17))
2755 goto clean;
2756 ++ddata->cur;
2757 goto rtn;
2758
2759 case 'P':
2760 /* pointer */
2761 if (!vector_type_qualifier_push(&v, TYPE_PTR))
2762 goto clean;
2763 ++ddata->cur;
2764 goto again;
2765
2766 case 'r':
2767 /* restrict */
2768 if (!vector_type_qualifier_push(&v, TYPE_RST))
2769 goto clean;
2770 ++ddata->cur;
2771 goto again;
2772
2773 case 'R':
2774 /* reference */
2775 if (!vector_type_qualifier_push(&v, TYPE_REF))
2776 goto clean;
2777 ++ddata->cur;
2778 goto again;
2779
2780 case 's':
2781 /* short, local string */
2782 if (!cpp_demangle_push_str(ddata, "short", 5))
2783 goto clean;
2784 ++ddata->cur;
2785 goto rtn;
2786
2787 case 'S':
2788 /* substitution */
2789 if (!cpp_demangle_read_subst(ddata))
2790 goto clean;
2791 is_builtin = 0;
2792 goto rtn;
2793
2794 case 't':
2795 /* unsigned short */
2796 if (!cpp_demangle_push_str(ddata, "unsigned short", 14))
2797 goto clean;
2798 ++ddata->cur;
2799 goto rtn;
2800
2801 case 'T':
2802 /* template parameter */
2803 if (!cpp_demangle_read_tmpl_param(ddata))
2804 goto clean;
2805 is_builtin = 0;
2806 goto rtn;
2807
2808 case 'u':
2809 /* vendor extended builtin */
2810 ++ddata->cur;
2811 if (!cpp_demangle_read_sname(ddata))
2812 goto clean;
2813 is_builtin = 0;
2814 goto rtn;
2815
2816 case 'U':
2817 /* vendor extended type qualifier */
2818 if (!cpp_demangle_read_number(ddata, &len))
2819 goto clean;
2820 if (len <= 0)
2821 goto clean;
2822 if (!vector_str_push(&v.ext_name, ddata->cur, len))
2823 return (0);
2824 ddata->cur += len;
2825 if (!vector_type_qualifier_push(&v, TYPE_EXT))
2826 goto clean;
2827 goto again;
2828
2829 case 'v':
2830 /* void */
2831 if (!cpp_demangle_push_str(ddata, "void", 4))
2832 goto clean;
2833 ++ddata->cur;
2834 goto rtn;
2835
2836 case 'V':
2837 /* volatile */
2838 if (!vector_type_qualifier_push(&v, TYPE_VAT))
2839 goto clean;
2840 ++ddata->cur;
2841 goto again;
2842
2843 case 'w':
2844 /* wchar_t */
2845 if (!cpp_demangle_push_str(ddata, "wchar_t", 6))
2846 goto clean;
2847 ++ddata->cur;
2848 goto rtn;
2849
2850 case 'x':
2851 /* long long */
2852 if (!cpp_demangle_push_str(ddata, "long long", 9))
2853 goto clean;
2854 ++ddata->cur;
2855 goto rtn;
2856
2857 case 'y':
2858 /* unsigned long long */
2859 if (!cpp_demangle_push_str(ddata, "unsigned long long", 18))
2860 goto clean;
2861 ++ddata->cur;
2862 goto rtn;
2863
2864 case 'z':
2865 /* ellipsis */
2866 if (!cpp_demangle_push_str(ddata, "ellipsis", 8))
2867 goto clean;
2868 ++ddata->cur;
2869 goto rtn;
2870 };
2871
2872 if (!cpp_demangle_read_name(ddata))
2873 goto clean;
2874
2875 is_builtin = 0;
2876 rtn:
2877 if ((type_str = vector_str_substr(output, p_idx, output->size - 1,
2878 &type_str_len)) == NULL)
2879 goto clean;
2880
2881 if (is_builtin == 0) {
2882 if (!vector_str_find(&ddata->subst, type_str, type_str_len) &&
2883 !vector_str_push(&ddata->subst, type_str, type_str_len))
2884 goto clean;
2885 }
2886
2887 if (!cpp_demangle_push_type_qualifier(ddata, &v, type_str))
2888 goto clean;
2889
2890 free(type_str);
2891 free(exp_str);
2892 free(num_str);
2893 vector_type_qualifier_dest(&v);
2894
2895 if (ddata->push_head > 0) {
2896 if (*ddata->cur == 'I' && cpp_demangle_read_tmpl_args(ddata)
2897 == 0)
2898 return (0);
2899
2900 if (--ddata->push_head > 0)
2901 return (1);
2902
2903 if (!vector_str_push(&ddata->output_tmp, " ", 1))
2904 return (0);
2905
2906 if (!vector_str_push_vector_head(&ddata->output,
2907 &ddata->output_tmp))
2908 return (0);
2909
2910 vector_str_dest(&ddata->output_tmp);
2911 if (!vector_str_init(&ddata->output_tmp))
2912 return (0);
2913
2914 if (!cpp_demangle_push_str(ddata, "(", 1))
2915 return (0);
2916
2917 ddata->paren = true;
2918 ddata->pfirst = true;
2919 }
2920
2921 return (1);
2922 clean:
2923 free(type_str);
2924 free(exp_str);
2925 free(num_str);
2926 vector_type_qualifier_dest(&v);
2927
2928 return (0);
2929 }
2930
2931 static int
2932 cpp_demangle_read_type_flat(struct cpp_demangle_data *ddata, char **str)
2933 {
2934 struct vector_str *output;
2935 size_t i, p_idx, idx, type_len;
2936 char *type;
2937
2938 output = ddata->push_head > 0 ? &ddata->output_tmp :
2939 &ddata->output;
2940
2941 p_idx = output->size;
2942
2943 if (!cpp_demangle_read_type(ddata, 0))
2944 return (0);
2945
2946 if ((type = vector_str_substr(output, p_idx, output->size - 1,
2947 &type_len)) == NULL)
2948 return (0);
2949
2950 idx = output->size;
2951 for (i = p_idx; i < idx; ++i) {
2952 if (!vector_str_pop(output)) {
2953 free(type);
2954 return (0);
2955 }
2956 }
2957
2958 *str = type;
2959
2960 return (1);
2961 }
2962
2963 /*
2964 * read unqualified-name, unqualified name are operator-name, ctor-dtor-name,
2965 * source-name
2966 */
2967 static int
2968 cpp_demangle_read_uqname(struct cpp_demangle_data *ddata)
2969 {
2970 size_t len;
2971
2972 if (ddata == NULL || *ddata->cur == '\0')
2973 return (0);
2974
2975 /* operator name */
2976 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
2977 case SIMPLE_HASH('a', 'a'):
2978 /* operator && */
2979 if (!cpp_demangle_push_str(ddata, "operator&&", 10))
2980 return (0);
2981 ddata->cur += 2;
2982 return (1);
2983
2984 case SIMPLE_HASH('a', 'd'):
2985 /* operator & (unary) */
2986 if (!cpp_demangle_push_str(ddata, "operator&", 9))
2987 return (0);
2988 ddata->cur += 2;
2989 return (1);
2990
2991 case SIMPLE_HASH('a', 'n'):
2992 /* operator & */
2993 if (!cpp_demangle_push_str(ddata, "operator&", 9))
2994 return (0);
2995 ddata->cur += 2;
2996 return (1);
2997
2998 case SIMPLE_HASH('a', 'N'):
2999 /* operator &= */
3000 if (!cpp_demangle_push_str(ddata, "operator&=", 10))
3001 return (0);
3002 ddata->cur += 2;
3003 return (1);
3004
3005 case SIMPLE_HASH('a', 'S'):
3006 /* operator = */
3007 if (!cpp_demangle_push_str(ddata, "operator=", 9))
3008 return (0);
3009 ddata->cur += 2;
3010 return (1);
3011
3012 case SIMPLE_HASH('c', 'l'):
3013 /* operator () */
3014 if (!cpp_demangle_push_str(ddata, "operator()", 10))
3015 return (0);
3016 ddata->cur += 2;
3017 return (1);
3018
3019 case SIMPLE_HASH('c', 'm'):
3020 /* operator , */
3021 if (!cpp_demangle_push_str(ddata, "operator,", 9))
3022 return (0);
3023 ddata->cur += 2;
3024 return (1);
3025
3026 case SIMPLE_HASH('c', 'o'):
3027 /* operator ~ */
3028 if (!cpp_demangle_push_str(ddata, "operator~", 9))
3029 return (0);
3030 ddata->cur += 2;
3031 return (1);
3032
3033 case SIMPLE_HASH('c', 'v'):
3034 /* operator (cast) */
3035 if (!cpp_demangle_push_str(ddata, "operator(cast)", 14))
3036 return (0);
3037 ddata->cur += 2;
3038 return (cpp_demangle_read_type(ddata, 1));
3039
3040 case SIMPLE_HASH('d', 'a'):
3041 /* operator delete [] */
3042 if (!cpp_demangle_push_str(ddata, "operator delete []", 18))
3043 return (0);
3044 ddata->cur += 2;
3045 return (1);
3046
3047 case SIMPLE_HASH('d', 'e'):
3048 /* operator * (unary) */
3049 if (!cpp_demangle_push_str(ddata, "operator*", 9))
3050 return (0);
3051 ddata->cur += 2;
3052 return (1);
3053
3054 case SIMPLE_HASH('d', 'l'):
3055 /* operator delete */
3056 if (!cpp_demangle_push_str(ddata, "operator delete", 15))
3057 return (0);
3058 ddata->cur += 2;
3059 return (1);
3060
3061 case SIMPLE_HASH('d', 'v'):
3062 /* operator / */
3063 if (!cpp_demangle_push_str(ddata, "operator/", 9))
3064 return (0);
3065 ddata->cur += 2;
3066 return (1);
3067
3068 case SIMPLE_HASH('d', 'V'):
3069 /* operator /= */
3070 if (!cpp_demangle_push_str(ddata, "operator/=", 10))
3071 return (0);
3072 ddata->cur += 2;
3073 return (1);
3074
3075 case SIMPLE_HASH('e', 'o'):
3076 /* operator ^ */
3077 if (!cpp_demangle_push_str(ddata, "operator^", 9))
3078 return (0);
3079 ddata->cur += 2;
3080 return (1);
3081
3082 case SIMPLE_HASH('e', 'O'):
3083 /* operator ^= */
3084 if (!cpp_demangle_push_str(ddata, "operator^=", 10))
3085 return (0);
3086 ddata->cur += 2;
3087 return (1);
3088
3089 case SIMPLE_HASH('e', 'q'):
3090 /* operator == */
3091 if (!cpp_demangle_push_str(ddata, "operator==", 10))
3092 return (0);
3093 ddata->cur += 2;
3094 return (1);
3095
3096 case SIMPLE_HASH('g', 'e'):
3097 /* operator >= */
3098 if (!cpp_demangle_push_str(ddata, "operator>=", 10))
3099 return (0);
3100 ddata->cur += 2;
3101 return (1);
3102
3103 case SIMPLE_HASH('g', 't'):
3104 /* operator > */
3105 if (!cpp_demangle_push_str(ddata, "operator>", 9))
3106 return (0);
3107 ddata->cur += 2;
3108 return (1);
3109
3110 case SIMPLE_HASH('i', 'x'):
3111 /* operator [] */
3112 if (!cpp_demangle_push_str(ddata, "operator[]", 10))
3113 return (0);
3114 ddata->cur += 2;
3115 return (1);
3116
3117 case SIMPLE_HASH('l', 'e'):
3118 /* operator <= */
3119 if (!cpp_demangle_push_str(ddata, "operator<=", 10))
3120 return (0);
3121 ddata->cur += 2;
3122 return (1);
3123
3124 case SIMPLE_HASH('l', 's'):
3125 /* operator << */
3126 if (!cpp_demangle_push_str(ddata, "operator<<", 10))
3127 return (0);
3128 ddata->cur += 2;
3129 return (1);
3130
3131 case SIMPLE_HASH('l', 'S'):
3132 /* operator <<= */
3133 if (!cpp_demangle_push_str(ddata, "operator<<=", 11))
3134 return (0);
3135 ddata->cur += 2;
3136 return (1);
3137
3138 case SIMPLE_HASH('l', 't'):
3139 /* operator < */
3140 if (!cpp_demangle_push_str(ddata, "operator<", 9))
3141 return (0);
3142 ddata->cur += 2;
3143 return (1);
3144
3145 case SIMPLE_HASH('m', 'i'):
3146 /* operator - */
3147 if (!cpp_demangle_push_str(ddata, "operator-", 9))
3148 return (0);
3149 ddata->cur += 2;
3150 return (1);
3151
3152 case SIMPLE_HASH('m', 'I'):
3153 /* operator -= */
3154 if (!cpp_demangle_push_str(ddata, "operator-=", 10))
3155 return (0);
3156 ddata->cur += 2;
3157 return (1);
3158
3159 case SIMPLE_HASH('m', 'l'):
3160 /* operator * */
3161 if (!cpp_demangle_push_str(ddata, "operator*", 9))
3162 return (0);
3163 ddata->cur += 2;
3164 return (1);
3165
3166 case SIMPLE_HASH('m', 'L'):
3167 /* operator *= */
3168 if (!cpp_demangle_push_str(ddata, "operator*=", 10))
3169 return (0);
3170 ddata->cur += 2;
3171 return (1);
3172
3173 case SIMPLE_HASH('m', 'm'):
3174 /* operator -- */
3175 if (!cpp_demangle_push_str(ddata, "operator--", 10))
3176 return (0);
3177 ddata->cur += 2;
3178 return (1);
3179
3180 case SIMPLE_HASH('n', 'a'):
3181 /* operator new[] */
3182 if (!cpp_demangle_push_str(ddata, "operator new []", 15))
3183 return (0);
3184 ddata->cur += 2;
3185 return (1);
3186
3187 case SIMPLE_HASH('n', 'e'):
3188 /* operator != */
3189 if (!cpp_demangle_push_str(ddata, "operator!=", 10))
3190 return (0);
3191 ddata->cur += 2;
3192 return (1);
3193
3194 case SIMPLE_HASH('n', 'g'):
3195 /* operator - (unary) */
3196 if (!cpp_demangle_push_str(ddata, "operator-", 9))
3197 return (0);
3198 ddata->cur += 2;
3199 return (1);
3200
3201 case SIMPLE_HASH('n', 't'):
3202 /* operator ! */
3203 if (!cpp_demangle_push_str(ddata, "operator!", 9))
3204 return (0);
3205 ddata->cur += 2;
3206 return (1);
3207
3208 case SIMPLE_HASH('n', 'w'):
3209 /* operator new */
3210 if (!cpp_demangle_push_str(ddata, "operator new", 12))
3211 return (0);
3212 ddata->cur += 2;
3213 return (1);
3214
3215 case SIMPLE_HASH('o', 'o'):
3216 /* operator || */
3217 if (!cpp_demangle_push_str(ddata, "operator||", 10))
3218 return (0);
3219 ddata->cur += 2;
3220 return (1);
3221
3222 case SIMPLE_HASH('o', 'r'):
3223 /* operator | */
3224 if (!cpp_demangle_push_str(ddata, "operator|", 9))
3225 return (0);
3226 ddata->cur += 2;
3227 return (1);
3228
3229 case SIMPLE_HASH('o', 'R'):
3230 /* operator |= */
3231 if (!cpp_demangle_push_str(ddata, "operator|=", 10))
3232 return (0);
3233 ddata->cur += 2;
3234 return (1);
3235
3236 case SIMPLE_HASH('p', 'l'):
3237 /* operator + */
3238 if (!cpp_demangle_push_str(ddata, "operator+", 9))
3239 return (0);
3240 ddata->cur += 2;
3241 return (1);
3242
3243 case SIMPLE_HASH('p', 'L'):
3244 /* operator += */
3245 if (!cpp_demangle_push_str(ddata, "operator+=", 10))
3246 return (0);
3247 ddata->cur += 2;
3248 return (1);
3249
3250 case SIMPLE_HASH('p', 'm'):
3251 /* operator ->* */
3252 if (!cpp_demangle_push_str(ddata, "operator->*", 11))
3253 return (0);
3254 ddata->cur += 2;
3255 return (1);
3256
3257 case SIMPLE_HASH('p', 'p'):
3258 /* operator ++ */
3259 if (!cpp_demangle_push_str(ddata, "operator++", 10))
3260 return (0);
3261 ddata->cur += 2;
3262 return (1);
3263
3264 case SIMPLE_HASH('p', 's'):
3265 /* operator + (unary) */
3266 if (!cpp_demangle_push_str(ddata, "operator+", 9))
3267 return (0);
3268 ddata->cur += 2;
3269 return (1);
3270
3271 case SIMPLE_HASH('p', 't'):
3272 /* operator -> */
3273 if (!cpp_demangle_push_str(ddata, "operator->", 10))
3274 return (0);
3275 ddata->cur += 2;
3276 return (1);
3277
3278 case SIMPLE_HASH('q', 'u'):
3279 /* operator ? */
3280 if (!cpp_demangle_push_str(ddata, "operator?", 9))
3281 return (0);
3282 ddata->cur += 2;
3283 return (1);
3284
3285 case SIMPLE_HASH('r', 'm'):
3286 /* operator % */
3287 if (!cpp_demangle_push_str(ddata, "operator%", 9))
3288 return (0);
3289 ddata->cur += 2;
3290 return (1);
3291
3292 case SIMPLE_HASH('r', 'M'):
3293 /* operator %= */
3294 if (!cpp_demangle_push_str(ddata, "operator%=", 10))
3295 return (0);
3296 ddata->cur += 2;
3297 return (1);
3298
3299 case SIMPLE_HASH('r', 's'):
3300 /* operator >> */
3301 if (!cpp_demangle_push_str(ddata, "operator>>", 10))
3302 return (0);
3303 ddata->cur += 2;
3304 return (1);
3305
3306 case SIMPLE_HASH('r', 'S'):
3307 /* operator >>= */
3308 if (!cpp_demangle_push_str(ddata, "operator>>=", 11))
3309 return (0);
3310 ddata->cur += 2;
3311 return (1);
3312
3313 case SIMPLE_HASH('r', 'z'):
3314 /* operator sizeof */
3315 if (!cpp_demangle_push_str(ddata, "operator sizeof ", 16))
3316 return (0);
3317 ddata->cur += 2;
3318 return (1);
3319
3320 case SIMPLE_HASH('s', 'r'):
3321 /* scope resolution operator */
3322 if (!cpp_demangle_push_str(ddata, "scope resolution operator ",
3323 26))
3324 return (0);
3325 ddata->cur += 2;
3326 return (1);
3327
3328 case SIMPLE_HASH('s', 'v'):
3329 /* operator sizeof */
3330 if (!cpp_demangle_push_str(ddata, "operator sizeof ", 16))
3331 return (0);
3332 ddata->cur += 2;
3333 return (1);
3334 };
3335
3336 /* vendor extened operator */
3337 if (*ddata->cur == 'v' && ELFTC_ISDIGIT(*(ddata->cur + 1))) {
3338 if (!cpp_demangle_push_str(ddata, "vendor extened operator ",
3339 24))
3340 return (0);
3341 if (!cpp_demangle_push_str(ddata, ddata->cur + 1, 1))
3342 return (0);
3343 ddata->cur += 2;
3344 return (cpp_demangle_read_sname(ddata));
3345 }
3346
3347 /* ctor-dtor-name */
3348 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
3349 case SIMPLE_HASH('C', '1'):
3350 /* FALLTHROUGH */
3351 case SIMPLE_HASH('C', '2'):
3352 /* FALLTHROUGH */
3353 case SIMPLE_HASH('C', '3'):
3354 if (ddata->last_sname == NULL)
3355 return (0);
3356 if ((len = strlen(ddata->last_sname)) == 0)
3357 return (0);
3358 if (!cpp_demangle_push_str(ddata, "::", 2))
3359 return (0);
3360 if (!cpp_demangle_push_str(ddata, ddata->last_sname, len))
3361 return (0);
3362 ddata->cur +=2;
3363 return (1);
3364
3365 case SIMPLE_HASH('D', '0'):
3366 /* FALLTHROUGH */
3367 case SIMPLE_HASH('D', '1'):
3368 /* FALLTHROUGH */
3369 case SIMPLE_HASH('D', '2'):
3370 if (ddata->last_sname == NULL)
3371 return (0);
3372 if ((len = strlen(ddata->last_sname)) == 0)
3373 return (0);
3374 if (!cpp_demangle_push_str(ddata, "::~", 3))
3375 return (0);
3376 if (!cpp_demangle_push_str(ddata, ddata->last_sname, len))
3377 return (0);
3378 ddata->cur +=2;
3379 return (1);
3380 };
3381
3382 /* source name */
3383 if (ELFTC_ISDIGIT(*ddata->cur) != 0)
3384 return (cpp_demangle_read_sname(ddata));
3385
3386 /* local source name */
3387 if (*ddata->cur == 'L')
3388 return (cpp_demangle_local_source_name(ddata));
3389
3390 return (1);
3391 }
3392
3393 /*
3394 * Read local source name.
3395 *
3396 * References:
3397 * http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31775
3398 * http://gcc.gnu.org/viewcvs?view=rev&revision=124467
3399 */
3400 static int
3401 cpp_demangle_local_source_name(struct cpp_demangle_data *ddata)
3402 {
3403 /* L */
3404 if (ddata == NULL || *ddata->cur != 'L')
3405 return (0);
3406 ++ddata->cur;
3407
3408 /* source name */
3409 if (!cpp_demangle_read_sname(ddata))
3410 return (0);
3411
3412 /* discriminator */
3413 if (*ddata->cur == '_') {
3414 ++ddata->cur;
3415 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
3416 ++ddata->cur;
3417 }
3418
3419 return (1);
3420 }
3421
3422 static int
3423 cpp_demangle_read_v_offset(struct cpp_demangle_data *ddata)
3424 {
3425
3426 if (ddata == NULL)
3427 return (0);
3428
3429 if (!cpp_demangle_push_str(ddata, "offset : ", 9))
3430 return (0);
3431
3432 if (!cpp_demangle_read_offset_number(ddata))
3433 return (0);
3434
3435 if (!cpp_demangle_push_str(ddata, "virtual offset : ", 17))
3436 return (0);
3437
3438 return (!cpp_demangle_read_offset_number(ddata));
3439 }
3440
3441 /*
3442 * Decode floating point representation to string
3443 * Return new allocated string or NULL
3444 *
3445 * Todo
3446 * Replace these functions to macro.
3447 */
3448 static char *
3449 decode_fp_to_double(const char *p, size_t len)
3450 {
3451 double f;
3452 size_t rtn_len, limit, i;
3453 int byte;
3454 char *rtn;
3455
3456 if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > sizeof(double))
3457 return (NULL);
3458
3459 memset(&f, 0, sizeof(double));
3460
3461 for (i = 0; i < len / 2; ++i) {
3462 byte = hex_to_dec(p[len - i * 2 - 1]) +
3463 hex_to_dec(p[len - i * 2 - 2]) * 16;
3464
3465 if (byte < 0 || byte > 255)
3466 return (NULL);
3467
3468 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3469 ((unsigned char *)&f)[i] = (unsigned char)(byte);
3470 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3471 ((unsigned char *)&f)[sizeof(double) - i - 1] =
3472 (unsigned char)(byte);
3473 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3474 }
3475
3476 rtn_len = 64;
3477 limit = 0;
3478 again:
3479 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3480 return (NULL);
3481
3482 if (snprintf(rtn, rtn_len, "%fld", f) >= (int)rtn_len) {
3483 free(rtn);
3484 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3485 return (NULL);
3486 rtn_len *= BUFFER_GROWFACTOR;
3487 goto again;
3488 }
3489
3490 return rtn;
3491 }
3492
3493 static char *
3494 decode_fp_to_float(const char *p, size_t len)
3495 {
3496 size_t i, rtn_len, limit;
3497 float f;
3498 int byte;
3499 char *rtn;
3500
3501 if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > sizeof(float))
3502 return (NULL);
3503
3504 memset(&f, 0, sizeof(float));
3505
3506 for (i = 0; i < len / 2; ++i) {
3507 byte = hex_to_dec(p[len - i * 2 - 1]) +
3508 hex_to_dec(p[len - i * 2 - 2]) * 16;
3509 if (byte < 0 || byte > 255)
3510 return (NULL);
3511 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3512 ((unsigned char *)&f)[i] = (unsigned char)(byte);
3513 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3514 ((unsigned char *)&f)[sizeof(float) - i - 1] =
3515 (unsigned char)(byte);
3516 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3517 }
3518
3519 rtn_len = 64;
3520 limit = 0;
3521 again:
3522 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3523 return (NULL);
3524
3525 if (snprintf(rtn, rtn_len, "%ff", f) >= (int)rtn_len) {
3526 free(rtn);
3527 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3528 return (NULL);
3529 rtn_len *= BUFFER_GROWFACTOR;
3530 goto again;
3531 }
3532
3533 return rtn;
3534 }
3535
3536 static char *
3537 decode_fp_to_float128(const char *p, size_t len)
3538 {
3539 long double f;
3540 size_t rtn_len, limit, i;
3541 int byte;
3542 unsigned char buf[FLOAT_QUADRUPLE_BYTES];
3543 char *rtn;
3544
3545 switch(sizeof(long double)) {
3546 case FLOAT_QUADRUPLE_BYTES:
3547 return (decode_fp_to_long_double(p, len));
3548 case FLOAT_EXTENED_BYTES:
3549 if (p == NULL || len == 0 || len % 2 != 0 ||
3550 len / 2 > FLOAT_QUADRUPLE_BYTES)
3551 return (NULL);
3552
3553 memset(buf, 0, FLOAT_QUADRUPLE_BYTES);
3554
3555 for (i = 0; i < len / 2; ++i) {
3556 byte = hex_to_dec(p[len - i * 2 - 1]) +
3557 hex_to_dec(p[len - i * 2 - 2]) * 16;
3558 if (byte < 0 || byte > 255)
3559 return (NULL);
3560 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3561 buf[i] = (unsigned char)(byte);
3562 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3563 buf[FLOAT_QUADRUPLE_BYTES - i -1] =
3564 (unsigned char)(byte);
3565 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3566 }
3567 memset(&f, 0, FLOAT_EXTENED_BYTES);
3568
3569 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3570 memcpy(&f, buf, FLOAT_EXTENED_BYTES);
3571 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3572 memcpy(&f, buf + 6, FLOAT_EXTENED_BYTES);
3573 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3574
3575 rtn_len = 256;
3576 limit = 0;
3577 again:
3578 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3579 return (NULL);
3580
3581 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
3582 free(rtn);
3583 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3584 return (NULL);
3585 rtn_len *= BUFFER_GROWFACTOR;
3586 goto again;
3587 }
3588
3589 return (rtn);
3590 default:
3591 return (NULL);
3592 }
3593 }
3594
3595 static char *
3596 decode_fp_to_float80(const char *p, size_t len)
3597 {
3598 long double f;
3599 size_t rtn_len, limit, i;
3600 int byte;
3601 unsigned char buf[FLOAT_EXTENED_BYTES];
3602 char *rtn;
3603
3604 switch(sizeof(long double)) {
3605 case FLOAT_QUADRUPLE_BYTES:
3606 if (p == NULL || len == 0 || len % 2 != 0 ||
3607 len / 2 > FLOAT_EXTENED_BYTES)
3608 return (NULL);
3609
3610 memset(buf, 0, FLOAT_EXTENED_BYTES);
3611
3612 for (i = 0; i < len / 2; ++i) {
3613 byte = hex_to_dec(p[len - i * 2 - 1]) +
3614 hex_to_dec(p[len - i * 2 - 2]) * 16;
3615
3616 if (byte < 0 || byte > 255)
3617 return (NULL);
3618
3619 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3620 buf[i] = (unsigned char)(byte);
3621 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3622 buf[FLOAT_EXTENED_BYTES - i -1] =
3623 (unsigned char)(byte);
3624 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3625 }
3626
3627 memset(&f, 0, FLOAT_QUADRUPLE_BYTES);
3628
3629 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3630 memcpy(&f, buf, FLOAT_EXTENED_BYTES);
3631 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3632 memcpy((unsigned char *)(&f) + 6, buf, FLOAT_EXTENED_BYTES);
3633 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3634
3635 rtn_len = 256;
3636 limit = 0;
3637 again:
3638 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3639 return (NULL);
3640
3641 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
3642 free(rtn);
3643 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3644 return (NULL);
3645 rtn_len *= BUFFER_GROWFACTOR;
3646 goto again;
3647 }
3648
3649 return (rtn);
3650 case FLOAT_EXTENED_BYTES:
3651 return (decode_fp_to_long_double(p, len));
3652 default:
3653 return (NULL);
3654 }
3655 }
3656
3657 static char *
3658 decode_fp_to_long_double(const char *p, size_t len)
3659 {
3660 long double f;
3661 size_t rtn_len, limit, i;
3662 int byte;
3663 char *rtn;
3664
3665 if (p == NULL || len == 0 || len % 2 != 0 ||
3666 len / 2 > sizeof(long double))
3667 return (NULL);
3668
3669 memset(&f, 0, sizeof(long double));
3670
3671 for (i = 0; i < len / 2; ++i) {
3672 byte = hex_to_dec(p[len - i * 2 - 1]) +
3673 hex_to_dec(p[len - i * 2 - 2]) * 16;
3674
3675 if (byte < 0 || byte > 255)
3676 return (NULL);
3677
3678 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3679 ((unsigned char *)&f)[i] = (unsigned char)(byte);
3680 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3681 ((unsigned char *)&f)[sizeof(long double) - i - 1] =
3682 (unsigned char)(byte);
3683 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3684 }
3685
3686 rtn_len = 256;
3687 limit = 0;
3688 again:
3689 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3690 return (NULL);
3691
3692 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
3693 free(rtn);
3694 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3695 return (NULL);
3696 rtn_len *= BUFFER_GROWFACTOR;
3697 goto again;
3698 }
3699
3700 return (rtn);
3701 }
3702
3703 /* Simple hex to integer function used by decode_to_* function. */
3704 static int
3705 hex_to_dec(char c)
3706 {
3707
3708 switch (c) {
3709 case '0':
3710 return (0);
3711 case '1':
3712 return (1);
3713 case '2':
3714 return (2);
3715 case '3':
3716 return (3);
3717 case '4':
3718 return (4);
3719 case '5':
3720 return (5);
3721 case '6':
3722 return (6);
3723 case '7':
3724 return (7);
3725 case '8':
3726 return (8);
3727 case '9':
3728 return (9);
3729 case 'a':
3730 return (10);
3731 case 'b':
3732 return (11);
3733 case 'c':
3734 return (12);
3735 case 'd':
3736 return (13);
3737 case 'e':
3738 return (14);
3739 case 'f':
3740 return (15);
3741 default:
3742 return (-1);
3743 };
3744 }
3745
3746 static void
3747 vector_read_cmd_dest(struct vector_read_cmd *v)
3748 {
3749
3750 if (v == NULL)
3751 return;
3752
3753 free(v->r_container);
3754 }
3755
3756 /* return -1 at failed, 0 at not found, 1 at found. */
3757 static int
3758 vector_read_cmd_find(struct vector_read_cmd *v, enum read_cmd dst)
3759 {
3760 size_t i;
3761
3762 if (v == NULL || dst == READ_FAIL)
3763 return (-1);
3764
3765 for (i = 0; i < v->size; ++i)
3766 if (v->r_container[i] == dst)
3767 return (1);
3768
3769 return (0);
3770 }
3771
3772 static int
3773 vector_read_cmd_init(struct vector_read_cmd *v)
3774 {
3775
3776 if (v == NULL)
3777 return (0);
3778
3779 v->size = 0;
3780 v->capacity = VECTOR_DEF_CAPACITY;
3781
3782 if ((v->r_container = malloc(sizeof(enum read_cmd) * v->capacity))
3783 == NULL)
3784 return (0);
3785
3786 return (1);
3787 }
3788
3789 static int
3790 vector_read_cmd_pop(struct vector_read_cmd *v)
3791 {
3792
3793 if (v == NULL || v->size == 0)
3794 return (0);
3795
3796 --v->size;
3797 v->r_container[v->size] = READ_FAIL;
3798
3799 return (1);
3800 }
3801
3802 static int
3803 vector_read_cmd_push(struct vector_read_cmd *v, enum read_cmd cmd)
3804 {
3805 enum read_cmd *tmp_r_ctn;
3806 size_t tmp_cap;
3807 size_t i;
3808
3809 if (v == NULL)
3810 return (0);
3811
3812 if (v->size == v->capacity) {
3813 tmp_cap = v->capacity * BUFFER_GROWFACTOR;
3814 if ((tmp_r_ctn = malloc(sizeof(enum read_cmd) * tmp_cap))
3815 == NULL)
3816 return (0);
3817 for (i = 0; i < v->size; ++i)
3818 tmp_r_ctn[i] = v->r_container[i];
3819 free(v->r_container);
3820 v->r_container = tmp_r_ctn;
3821 v->capacity = tmp_cap;
3822 }
3823
3824 v->r_container[v->size] = cmd;
3825 ++v->size;
3826
3827 return (1);
3828 }
3829
3830 static void
3831 vector_type_qualifier_dest(struct vector_type_qualifier *v)
3832 {
3833
3834 if (v == NULL)
3835 return;
3836
3837 free(v->q_container);
3838 vector_str_dest(&v->ext_name);
3839 }
3840
3841 /* size, capacity, ext_name */
3842 static int
3843 vector_type_qualifier_init(struct vector_type_qualifier *v)
3844 {
3845
3846 if (v == NULL)
3847 return (0);
3848
3849 v->size = 0;
3850 v->capacity = VECTOR_DEF_CAPACITY;
3851
3852 if ((v->q_container = malloc(sizeof(enum type_qualifier) * v->capacity))
3853 == NULL)
3854 return (0);
3855
3856 assert(v->q_container != NULL);
3857
3858 if (vector_str_init(&v->ext_name) == false) {
3859 free(v->q_container);
3860 return (0);
3861 }
3862
3863 return (1);
3864 }
3865
3866 static int
3867 vector_type_qualifier_push(struct vector_type_qualifier *v,
3868 enum type_qualifier t)
3869 {
3870 enum type_qualifier *tmp_ctn;
3871 size_t tmp_cap;
3872 size_t i;
3873
3874 if (v == NULL)
3875 return (0);
3876
3877 if (v->size == v->capacity) {
3878 tmp_cap = v->capacity * BUFFER_GROWFACTOR;
3879 if ((tmp_ctn = malloc(sizeof(enum type_qualifier) * tmp_cap))
3880 == NULL)
3881 return (0);
3882 for (i = 0; i < v->size; ++i)
3883 tmp_ctn[i] = v->q_container[i];
3884 free(v->q_container);
3885 v->q_container = tmp_ctn;
3886 v->capacity = tmp_cap;
3887 }
3888
3889 v->q_container[v->size] = t;
3890 ++v->size;
3891
3892 return (1);
3893 }
MINIX 3 (repo.or.cz mirror)