1/*-
2 * Copyright (c) 2008 Hyogeol Lee <hyogeollee@gmail.com>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
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
27#include <sys/types.h>
28#include <assert.h>
29#include <ctype.h>
30#include <errno.h>
31#include <libelftc.h>
32#include <limits.h>
33#include <stdbool.h>
34#include <stdio.h>
35#include <stdlib.h>
36#include <string.h>
37
38#include "_libelftc.h"
39
| 1/*-
2 * Copyright (c) 2008 Hyogeol Lee <hyogeollee@gmail.com>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
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
27#include <sys/types.h>
28#include <assert.h>
29#include <ctype.h>
30#include <errno.h>
31#include <libelftc.h>
32#include <limits.h>
33#include <stdbool.h>
34#include <stdio.h>
35#include <stdlib.h>
36#include <string.h>
37
38#include "_libelftc.h"
39
|
40ELFTC_VCSID("$Id: libelftc_dem_gnu2.c 3447 2016-05-03 13:32:23Z emaste $");
| 40ELFTC_VCSID("$Id: libelftc_dem_gnu2.c 3513 2016-12-29 07:04:22Z kaiwang27 $");
|
41
42/**
43 * @file cpp_demangle_gnu2.c
44 * @brief Decode function name encoding in GNU 2.
45 *
46 * Function name encoding in GNU 2 based on ARM style.
47 */
48
49enum encode_type {
50 ENCODE_FUNC, ENCODE_OP, ENCODE_OP_CT, ENCODE_OP_DT, ENCODE_OP_USER,
51 ENCODE_OP_TF, ENCODE_OP_TI, ENCODE_OP_VT
52};
53
54struct cstring {
55 char *buf;
56 size_t size;
57};
58
59struct demangle_data {
60 bool ptr, ref, cnst, array, cnst_fn, class_name;
61 struct cstring array_str;
62 const char *p;
63 enum encode_type type;
64 struct vector_str vec;
65 struct vector_str arg;
66};
67
68#define SIMPLE_HASH(x,y) (64 * x + y)
| 41
42/**
43 * @file cpp_demangle_gnu2.c
44 * @brief Decode function name encoding in GNU 2.
45 *
46 * Function name encoding in GNU 2 based on ARM style.
47 */
48
49enum encode_type {
50 ENCODE_FUNC, ENCODE_OP, ENCODE_OP_CT, ENCODE_OP_DT, ENCODE_OP_USER,
51 ENCODE_OP_TF, ENCODE_OP_TI, ENCODE_OP_VT
52};
53
54struct cstring {
55 char *buf;
56 size_t size;
57};
58
59struct demangle_data {
60 bool ptr, ref, cnst, array, cnst_fn, class_name;
61 struct cstring array_str;
62 const char *p;
63 enum encode_type type;
64 struct vector_str vec;
65 struct vector_str arg;
66};
67
68#define SIMPLE_HASH(x,y) (64 * x + y)
|
| 69#define VEC_PUSH_STR(d,s) vector_str_push((d), (s), strlen((s)))
|
69#define CPP_DEMANGLE_GNU2_TRY 128
70
71static void dest_cstring(struct cstring *);
72static void dest_demangle_data(struct demangle_data *);
73static bool init_cstring(struct cstring *, size_t);
74static bool init_demangle_data(struct demangle_data *);
75static bool push_CTDT(const char *, size_t, struct vector_str *);
76static bool read_array(struct demangle_data *);
77static bool read_class(struct demangle_data *);
78static bool read_func(struct demangle_data *);
79static bool read_func_name(struct demangle_data *);
80static bool read_func_ptr(struct demangle_data *);
81static bool read_memptr(struct demangle_data *);
82static bool read_op(struct demangle_data *);
83static bool read_op_user(struct demangle_data *);
84static bool read_qual_name(struct demangle_data *);
85static int read_subst(struct demangle_data *);
86static int read_subst_iter(struct demangle_data *);
87static bool read_type(struct demangle_data *);
88
89/**
90 * @brief Decode the input string by the GNU 2 style.
91 *
92 * @return New allocated demangled string or NULL if failed.
93 */
94char *
95cpp_demangle_gnu2(const char *org)
96{
97 struct demangle_data d;
98 size_t arg_begin, arg_len;
99 unsigned int try;
100 char *rtn, *arg;
101
102 if (org == NULL)
103 return (NULL);
104
105 if (init_demangle_data(&d) == false)
106 return (NULL);
107
108 try = 0;
109 rtn = NULL;
110
111 d.p = org;
112 if (read_func_name(&d) == false)
113 goto clean;
114
115 switch (d.type) {
116 case ENCODE_FUNC :
117 case ENCODE_OP :
118 break;
119
120 case ENCODE_OP_CT :
121 if (push_CTDT("::", 2, &d.vec) == false)
122 goto clean;
123
124 break;
125 case ENCODE_OP_DT :
126 if (push_CTDT("::~", 3, &d.vec) == false)
127 goto clean;
128
| 70#define CPP_DEMANGLE_GNU2_TRY 128
71
72static void dest_cstring(struct cstring *);
73static void dest_demangle_data(struct demangle_data *);
74static bool init_cstring(struct cstring *, size_t);
75static bool init_demangle_data(struct demangle_data *);
76static bool push_CTDT(const char *, size_t, struct vector_str *);
77static bool read_array(struct demangle_data *);
78static bool read_class(struct demangle_data *);
79static bool read_func(struct demangle_data *);
80static bool read_func_name(struct demangle_data *);
81static bool read_func_ptr(struct demangle_data *);
82static bool read_memptr(struct demangle_data *);
83static bool read_op(struct demangle_data *);
84static bool read_op_user(struct demangle_data *);
85static bool read_qual_name(struct demangle_data *);
86static int read_subst(struct demangle_data *);
87static int read_subst_iter(struct demangle_data *);
88static bool read_type(struct demangle_data *);
89
90/**
91 * @brief Decode the input string by the GNU 2 style.
92 *
93 * @return New allocated demangled string or NULL if failed.
94 */
95char *
96cpp_demangle_gnu2(const char *org)
97{
98 struct demangle_data d;
99 size_t arg_begin, arg_len;
100 unsigned int try;
101 char *rtn, *arg;
102
103 if (org == NULL)
104 return (NULL);
105
106 if (init_demangle_data(&d) == false)
107 return (NULL);
108
109 try = 0;
110 rtn = NULL;
111
112 d.p = org;
113 if (read_func_name(&d) == false)
114 goto clean;
115
116 switch (d.type) {
117 case ENCODE_FUNC :
118 case ENCODE_OP :
119 break;
120
121 case ENCODE_OP_CT :
122 if (push_CTDT("::", 2, &d.vec) == false)
123 goto clean;
124
125 break;
126 case ENCODE_OP_DT :
127 if (push_CTDT("::~", 3, &d.vec) == false)
128 goto clean;
129
|
129 if (vector_str_push(&d.vec, "(void)", 6) == false)
| 130 if (VEC_PUSH_STR(&d.vec, "(void)") == false)
|
130 goto clean;
131
132 goto flat;
133 case ENCODE_OP_USER :
134 case ENCODE_OP_TF :
135 case ENCODE_OP_TI :
136 case ENCODE_OP_VT :
137 goto flat;
138 }
139
140 if (*d.p == 'F')
141 ++d.p;
142 else if (*d.p == '\0') {
143 if (d.class_name == true) {
| 131 goto clean;
132
133 goto flat;
134 case ENCODE_OP_USER :
135 case ENCODE_OP_TF :
136 case ENCODE_OP_TI :
137 case ENCODE_OP_VT :
138 goto flat;
139 }
140
141 if (*d.p == 'F')
142 ++d.p;
143 else if (*d.p == '\0') {
144 if (d.class_name == true) {
|
144 if (vector_str_push(&d.vec, "(void)", 6) == false)
| 145 if (VEC_PUSH_STR(&d.vec, "(void)") == false)
|
145 goto clean;
146
147 goto flat;
148 } else
149 goto clean;
150 }
151
152 /* start argument types */
| 146 goto clean;
147
148 goto flat;
149 } else
150 goto clean;
151 }
152
153 /* start argument types */
|
153 if (vector_str_push(&d.vec, "(", 1) == false)
| 154 if (VEC_PUSH_STR(&d.vec, "(") == false)
|
154 goto clean;
155
156 for (;;) {
157 if (*d.p == 'T') {
158 const int rtn_subst = read_subst(&d);
159
160 if (rtn_subst == -1)
161 goto clean;
162 else if (rtn_subst == 1)
163 break;
164
165 continue;
166 }
167
168 if (*d.p == 'N') {
169 const int rtn_subst_iter = read_subst_iter(&d);
170
171 if (rtn_subst_iter == -1)
172 goto clean;
173 else if(rtn_subst_iter == 1)
174 break;
175
176 continue;
177 }
178
179 arg_begin = d.vec.size;
180
181 if (read_type(&d) == false)
182 goto clean;
183
184 if (d.ptr == true) {
| 155 goto clean;
156
157 for (;;) {
158 if (*d.p == 'T') {
159 const int rtn_subst = read_subst(&d);
160
161 if (rtn_subst == -1)
162 goto clean;
163 else if (rtn_subst == 1)
164 break;
165
166 continue;
167 }
168
169 if (*d.p == 'N') {
170 const int rtn_subst_iter = read_subst_iter(&d);
171
172 if (rtn_subst_iter == -1)
173 goto clean;
174 else if(rtn_subst_iter == 1)
175 break;
176
177 continue;
178 }
179
180 arg_begin = d.vec.size;
181
182 if (read_type(&d) == false)
183 goto clean;
184
185 if (d.ptr == true) {
|
185 if (vector_str_push(&d.vec, "*", 1) == false)
| 186 if (VEC_PUSH_STR(&d.vec, "*") == false)
|
186 goto clean;
187
188 d.ptr = false;
189 }
190
191 if (d.ref == true) {
| 187 goto clean;
188
189 d.ptr = false;
190 }
191
192 if (d.ref == true) {
|
192 if (vector_str_push(&d.vec, "&", 1) == false)
| 193 if (VEC_PUSH_STR(&d.vec, "&") == false)
|
193 goto clean;
194
195 d.ref = false;
196 }
197
198 if (d.cnst == true) {
| 194 goto clean;
195
196 d.ref = false;
197 }
198
199 if (d.cnst == true) {
|
199 if (vector_str_push(&d.vec, " const", 6) == false)
| 200 if (VEC_PUSH_STR(&d.vec, " const") == false)
|
200 goto clean;
201
202 d.cnst = false;
203 }
204
205 if (d.array == true) {
206 if (vector_str_push(&d.vec, d.array_str.buf,
207 d.array_str.size) == false)
208 goto clean;
209
210 dest_cstring(&d.array_str);
211 d.array = false;
212 }
213
214 if (*d.p == '\0')
215 break;
216
217 if ((arg = vector_str_substr(&d.vec, arg_begin, d.vec.size - 1,
218 &arg_len)) == NULL)
219 goto clean;
220
221 if (vector_str_push(&d.arg, arg, arg_len) == false)
222 goto clean;
223
224 free(arg);
225
| 201 goto clean;
202
203 d.cnst = false;
204 }
205
206 if (d.array == true) {
207 if (vector_str_push(&d.vec, d.array_str.buf,
208 d.array_str.size) == false)
209 goto clean;
210
211 dest_cstring(&d.array_str);
212 d.array = false;
213 }
214
215 if (*d.p == '\0')
216 break;
217
218 if ((arg = vector_str_substr(&d.vec, arg_begin, d.vec.size - 1,
219 &arg_len)) == NULL)
220 goto clean;
221
222 if (vector_str_push(&d.arg, arg, arg_len) == false)
223 goto clean;
224
225 free(arg);
226
|
226 if (vector_str_push(&d.vec, ", ", 2) == false)
| 227 if (VEC_PUSH_STR(&d.vec, ", ") == false)
|
227 goto clean;
228
229 if (++try > CPP_DEMANGLE_GNU2_TRY)
230 goto clean;
231 }
232
233 /* end argument types */
| 228 goto clean;
229
230 if (++try > CPP_DEMANGLE_GNU2_TRY)
231 goto clean;
232 }
233
234 /* end argument types */
|
234 if (vector_str_push(&d.vec, ")", 1) == false)
| 235 if (VEC_PUSH_STR(&d.vec, ")") == false)
|
235 goto clean;
236flat:
| 236 goto clean;
237flat:
|
237 if (d.cnst_fn == true && vector_str_push(&d.vec, " const", 6) == false)
| 238 if (d.cnst_fn == true && VEC_PUSH_STR(&d.vec, " const") == false)
|
238 goto clean;
239
240 rtn = vector_str_get_flat(&d.vec, NULL);
241clean:
242 dest_demangle_data(&d);
243
244 return (rtn);
245}
246
247/**
248 * @brief Test input string is encoded by the GNU 2 style.
249 *
250 * @return True if input string is encoded by the GNU 2 style.
251 */
252bool
253is_cpp_mangled_gnu2(const char *org)
254{
255 char *str;
256 bool rtn = false;
257
258 if (org == NULL)
259 return (false);
260
261 /* search valid text to end */
262 str = strstr(org, "__");
263 while (str != NULL) {
264 if (*(str + 2) != '\0') {
265 if (*(str + 2) == 'C' ||
266 *(str + 2) == 'F' ||
267 *(str + 2) == 'Q' ||
268 ELFTC_ISDIGIT(*(str + 2))) {
269 rtn |= true;
270
271 break;
272 }
273
274 if (*(str + 3) != '\0') {
275 switch (SIMPLE_HASH(*(str + 2), *(str + 3))) {
276 case SIMPLE_HASH('m', 'l') :
277 case SIMPLE_HASH('d', 'v') :
278 case SIMPLE_HASH('m', 'd') :
279 case SIMPLE_HASH('p', 'l') :
280 case SIMPLE_HASH('m', 'i') :
281 case SIMPLE_HASH('l', 's') :
282 case SIMPLE_HASH('r', 's') :
283 case SIMPLE_HASH('e', 'q') :
284 case SIMPLE_HASH('n', 'e') :
285 case SIMPLE_HASH('l', 't') :
286 case SIMPLE_HASH('g', 't') :
287 case SIMPLE_HASH('l', 'e') :
288 case SIMPLE_HASH('g', 'e') :
289 case SIMPLE_HASH('a', 'd') :
290 case SIMPLE_HASH('o', 'r') :
291 case SIMPLE_HASH('e', 'r') :
292 case SIMPLE_HASH('a', 'a') :
293 case SIMPLE_HASH('o', 'o') :
294 case SIMPLE_HASH('n', 't') :
295 case SIMPLE_HASH('c', 'o') :
296 case SIMPLE_HASH('p', 'p') :
297 case SIMPLE_HASH('m', 'm') :
298 case SIMPLE_HASH('a', 's') :
299 case SIMPLE_HASH('r', 'f') :
300 case SIMPLE_HASH('a', 'p') :
301 case SIMPLE_HASH('a', 'm') :
302 case SIMPLE_HASH('a', 'l') :
303 case SIMPLE_HASH('a', 'r') :
304 case SIMPLE_HASH('a', 'o') :
305 case SIMPLE_HASH('a', 'e') :
306 case SIMPLE_HASH('c', 'm') :
307 case SIMPLE_HASH('r', 'm') :
308 case SIMPLE_HASH('c', 'l') :
309 case SIMPLE_HASH('v', 'c') :
310 case SIMPLE_HASH('n', 'w') :
311 case SIMPLE_HASH('d', 'l') :
312 case SIMPLE_HASH('o', 'p') :
313 case SIMPLE_HASH('t', 'f') :
314 case SIMPLE_HASH('t', 'i') :
315 rtn |= true;
316
317 break;
318 }
319 }
320 }
321
322 str = strstr(str + 2, "__");
323 }
324
325 rtn |= strstr(org, "_$_") != NULL;
326 rtn |= strstr(org, "_vt$") != NULL;
327
328 return (rtn);
329}
330
331static void
332dest_cstring(struct cstring *s)
333{
334
335 if (s == NULL)
336 return;
337
338 free(s->buf);
339 s->buf = NULL;
340 s->size = 0;
341}
342
343static void
344dest_demangle_data(struct demangle_data *d)
345{
346
347 if (d != NULL) {
348 vector_str_dest(&d->arg);
349 vector_str_dest(&d->vec);
350
351 dest_cstring(&d->array_str);
352 }
353}
354
355static bool
356init_cstring(struct cstring *s, size_t len)
357{
358
359 if (s == NULL || len <= 1)
360 return (false);
361
362 if ((s->buf = malloc(sizeof(char) * len)) == NULL)
363 return (false);
364
365 s->size = len - 1;
366
367 return (true);
368}
369
370static bool
371init_demangle_data(struct demangle_data *d)
372{
373
374 if (d == NULL)
375 return (false);
376
377 d->ptr = false;
378 d->ref = false;
379 d->cnst = false;
380 d->array = false;
381 d->cnst_fn = false;
382 d->class_name = false;
383
384 d->array_str.buf = NULL;
385 d->array_str.size = 0;
386
387 d->type = ENCODE_FUNC;
388
389 if (vector_str_init(&d->vec) == false)
390 return (false);
391
392 if (vector_str_init(&d->arg) == false) {
393 vector_str_dest(&d->vec);
394
395 return (false);
396 }
397
398 return (true);
399}
400
401static bool
402push_CTDT(const char *s, size_t l, struct vector_str *v)
403{
404
405 if (s == NULL || l == 0 || v == NULL)
406 return (false);
407
408 if (vector_str_push(v, s, l) == false)
409 return (false);
410
411 assert(v->size > 1);
412
| 239 goto clean;
240
241 rtn = vector_str_get_flat(&d.vec, NULL);
242clean:
243 dest_demangle_data(&d);
244
245 return (rtn);
246}
247
248/**
249 * @brief Test input string is encoded by the GNU 2 style.
250 *
251 * @return True if input string is encoded by the GNU 2 style.
252 */
253bool
254is_cpp_mangled_gnu2(const char *org)
255{
256 char *str;
257 bool rtn = false;
258
259 if (org == NULL)
260 return (false);
261
262 /* search valid text to end */
263 str = strstr(org, "__");
264 while (str != NULL) {
265 if (*(str + 2) != '\0') {
266 if (*(str + 2) == 'C' ||
267 *(str + 2) == 'F' ||
268 *(str + 2) == 'Q' ||
269 ELFTC_ISDIGIT(*(str + 2))) {
270 rtn |= true;
271
272 break;
273 }
274
275 if (*(str + 3) != '\0') {
276 switch (SIMPLE_HASH(*(str + 2), *(str + 3))) {
277 case SIMPLE_HASH('m', 'l') :
278 case SIMPLE_HASH('d', 'v') :
279 case SIMPLE_HASH('m', 'd') :
280 case SIMPLE_HASH('p', 'l') :
281 case SIMPLE_HASH('m', 'i') :
282 case SIMPLE_HASH('l', 's') :
283 case SIMPLE_HASH('r', 's') :
284 case SIMPLE_HASH('e', 'q') :
285 case SIMPLE_HASH('n', 'e') :
286 case SIMPLE_HASH('l', 't') :
287 case SIMPLE_HASH('g', 't') :
288 case SIMPLE_HASH('l', 'e') :
289 case SIMPLE_HASH('g', 'e') :
290 case SIMPLE_HASH('a', 'd') :
291 case SIMPLE_HASH('o', 'r') :
292 case SIMPLE_HASH('e', 'r') :
293 case SIMPLE_HASH('a', 'a') :
294 case SIMPLE_HASH('o', 'o') :
295 case SIMPLE_HASH('n', 't') :
296 case SIMPLE_HASH('c', 'o') :
297 case SIMPLE_HASH('p', 'p') :
298 case SIMPLE_HASH('m', 'm') :
299 case SIMPLE_HASH('a', 's') :
300 case SIMPLE_HASH('r', 'f') :
301 case SIMPLE_HASH('a', 'p') :
302 case SIMPLE_HASH('a', 'm') :
303 case SIMPLE_HASH('a', 'l') :
304 case SIMPLE_HASH('a', 'r') :
305 case SIMPLE_HASH('a', 'o') :
306 case SIMPLE_HASH('a', 'e') :
307 case SIMPLE_HASH('c', 'm') :
308 case SIMPLE_HASH('r', 'm') :
309 case SIMPLE_HASH('c', 'l') :
310 case SIMPLE_HASH('v', 'c') :
311 case SIMPLE_HASH('n', 'w') :
312 case SIMPLE_HASH('d', 'l') :
313 case SIMPLE_HASH('o', 'p') :
314 case SIMPLE_HASH('t', 'f') :
315 case SIMPLE_HASH('t', 'i') :
316 rtn |= true;
317
318 break;
319 }
320 }
321 }
322
323 str = strstr(str + 2, "__");
324 }
325
326 rtn |= strstr(org, "_$_") != NULL;
327 rtn |= strstr(org, "_vt$") != NULL;
328
329 return (rtn);
330}
331
332static void
333dest_cstring(struct cstring *s)
334{
335
336 if (s == NULL)
337 return;
338
339 free(s->buf);
340 s->buf = NULL;
341 s->size = 0;
342}
343
344static void
345dest_demangle_data(struct demangle_data *d)
346{
347
348 if (d != NULL) {
349 vector_str_dest(&d->arg);
350 vector_str_dest(&d->vec);
351
352 dest_cstring(&d->array_str);
353 }
354}
355
356static bool
357init_cstring(struct cstring *s, size_t len)
358{
359
360 if (s == NULL || len <= 1)
361 return (false);
362
363 if ((s->buf = malloc(sizeof(char) * len)) == NULL)
364 return (false);
365
366 s->size = len - 1;
367
368 return (true);
369}
370
371static bool
372init_demangle_data(struct demangle_data *d)
373{
374
375 if (d == NULL)
376 return (false);
377
378 d->ptr = false;
379 d->ref = false;
380 d->cnst = false;
381 d->array = false;
382 d->cnst_fn = false;
383 d->class_name = false;
384
385 d->array_str.buf = NULL;
386 d->array_str.size = 0;
387
388 d->type = ENCODE_FUNC;
389
390 if (vector_str_init(&d->vec) == false)
391 return (false);
392
393 if (vector_str_init(&d->arg) == false) {
394 vector_str_dest(&d->vec);
395
396 return (false);
397 }
398
399 return (true);
400}
401
402static bool
403push_CTDT(const char *s, size_t l, struct vector_str *v)
404{
405
406 if (s == NULL || l == 0 || v == NULL)
407 return (false);
408
409 if (vector_str_push(v, s, l) == false)
410 return (false);
411
412 assert(v->size > 1);
413
|
413 return (vector_str_push(v, v->container[v->size - 2],
414 strlen(v->container[v->size - 2])));
| 414 return (VEC_PUSH_STR(v, v->container[v->size - 2]));
|
415}
416
417static bool
418read_array(struct demangle_data *d)
419{
420 size_t len;
421 const char *end;
422
423 if (d == NULL || d->p == NULL)
424 return (false);
425
426 end = d->p;
427 assert(end != NULL);
428
429 for (;;) {
430 if (*end == '\0')
431 return (false);
432
433 if (ELFTC_ISDIGIT(*end) == 0)
434 break;
435
436 ++end;
437 }
438
439 if (*end != '_')
440 return (false);
441
442 len = end - d->p;
443 assert(len > 0);
444
445 dest_cstring(&d->array_str);
446 if (init_cstring(&d->array_str, len + 3) == false)
447 return (false);
448
449 strncpy(d->array_str.buf + 1, d->p, len);
450 *d->array_str.buf = '[';
451 *(d->array_str.buf + len + 1) = ']';
452
453 d->array = true;
454 d->p = end + 1;
455
456 return (true);
457}
458
459static bool
460read_class(struct demangle_data *d)
461{
462 size_t len;
463 char *str;
464
465 if (d == NULL)
466 return (false);
467
468 len = strtol(d->p, &str, 10);
469 if (len == 0 && (errno == EINVAL || errno == ERANGE))
470 return (false);
471
472 assert(len > 0);
473 assert(str != NULL);
474
475 if (vector_str_push(&d->vec, str, len) == false)
476 return (false);
477
478 d->p = str + len;
479
480 d->class_name = true;
481
482 return (true);
483}
484
485static bool
486read_func(struct demangle_data *d)
487{
488 size_t len;
489 const char *name;
490 char *delim;
491
492 if (d == NULL)
493 return (false);
494
495 assert(d->p != NULL && "d->p (org str) is NULL");
496 if ((delim = strstr(d->p, "__")) == NULL)
497 return (false);
498
499 len = delim - d->p;
500 assert(len != 0);
501
502 name = d->p;
503
504 d->p = delim + 2;
505
506 if (*d->p == 'C') {
507 ++d->p;
508
509 d->cnst_fn = true;
510 }
511
512 if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) {
513 ++d->p;
514
515 if (read_qual_name(d) == false)
516 return (false);
517 } else if (ELFTC_ISDIGIT(*d->p)) {
518 if (read_class(d) == false)
519 return (false);
520
| 415}
416
417static bool
418read_array(struct demangle_data *d)
419{
420 size_t len;
421 const char *end;
422
423 if (d == NULL || d->p == NULL)
424 return (false);
425
426 end = d->p;
427 assert(end != NULL);
428
429 for (;;) {
430 if (*end == '\0')
431 return (false);
432
433 if (ELFTC_ISDIGIT(*end) == 0)
434 break;
435
436 ++end;
437 }
438
439 if (*end != '_')
440 return (false);
441
442 len = end - d->p;
443 assert(len > 0);
444
445 dest_cstring(&d->array_str);
446 if (init_cstring(&d->array_str, len + 3) == false)
447 return (false);
448
449 strncpy(d->array_str.buf + 1, d->p, len);
450 *d->array_str.buf = '[';
451 *(d->array_str.buf + len + 1) = ']';
452
453 d->array = true;
454 d->p = end + 1;
455
456 return (true);
457}
458
459static bool
460read_class(struct demangle_data *d)
461{
462 size_t len;
463 char *str;
464
465 if (d == NULL)
466 return (false);
467
468 len = strtol(d->p, &str, 10);
469 if (len == 0 && (errno == EINVAL || errno == ERANGE))
470 return (false);
471
472 assert(len > 0);
473 assert(str != NULL);
474
475 if (vector_str_push(&d->vec, str, len) == false)
476 return (false);
477
478 d->p = str + len;
479
480 d->class_name = true;
481
482 return (true);
483}
484
485static bool
486read_func(struct demangle_data *d)
487{
488 size_t len;
489 const char *name;
490 char *delim;
491
492 if (d == NULL)
493 return (false);
494
495 assert(d->p != NULL && "d->p (org str) is NULL");
496 if ((delim = strstr(d->p, "__")) == NULL)
497 return (false);
498
499 len = delim - d->p;
500 assert(len != 0);
501
502 name = d->p;
503
504 d->p = delim + 2;
505
506 if (*d->p == 'C') {
507 ++d->p;
508
509 d->cnst_fn = true;
510 }
511
512 if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) {
513 ++d->p;
514
515 if (read_qual_name(d) == false)
516 return (false);
517 } else if (ELFTC_ISDIGIT(*d->p)) {
518 if (read_class(d) == false)
519 return (false);
520
|
521 if (vector_str_push(&d->vec, "::", 2) == false)
| 521 if (VEC_PUSH_STR(&d->vec, "::") == false)
|
522 return (false);
523 }
524
525 return (vector_str_push(&d->vec, name, len));
526}
527
528static bool
529read_func_name(struct demangle_data *d)
530{
531 size_t len;
532 bool rtn;
533 char *op_name;
534
535 if (d == NULL)
536 return (false);
537
538 rtn = false;
539 op_name = NULL;
540
541 assert(d->p != NULL && "d->p (org str) is NULL");
542
543 if (*d->p == '_' && *(d->p + 1) == '_') {
544 d->p += 2;
545
546 /* CTOR */
547 if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) {
548 ++d->p;
549 d->type = ENCODE_OP_CT;
550
551 if (read_qual_name(d) == false)
552 return (false);
553
554 return (vector_str_pop(&d->vec));
555 } else if (ELFTC_ISDIGIT(*d->p)) {
556 d->type = ENCODE_OP_CT;
557
558 return (read_class(d));
559 }
560
561 d->type = ENCODE_OP;
562 if (read_op(d) == false) {
563 /* not good condition, start function name with '__' */
564 d->type = ENCODE_FUNC;
565
| 522 return (false);
523 }
524
525 return (vector_str_push(&d->vec, name, len));
526}
527
528static bool
529read_func_name(struct demangle_data *d)
530{
531 size_t len;
532 bool rtn;
533 char *op_name;
534
535 if (d == NULL)
536 return (false);
537
538 rtn = false;
539 op_name = NULL;
540
541 assert(d->p != NULL && "d->p (org str) is NULL");
542
543 if (*d->p == '_' && *(d->p + 1) == '_') {
544 d->p += 2;
545
546 /* CTOR */
547 if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) {
548 ++d->p;
549 d->type = ENCODE_OP_CT;
550
551 if (read_qual_name(d) == false)
552 return (false);
553
554 return (vector_str_pop(&d->vec));
555 } else if (ELFTC_ISDIGIT(*d->p)) {
556 d->type = ENCODE_OP_CT;
557
558 return (read_class(d));
559 }
560
561 d->type = ENCODE_OP;
562 if (read_op(d) == false) {
563 /* not good condition, start function name with '__' */
564 d->type = ENCODE_FUNC;
565
|
566 if (vector_str_push(&d->vec, "__", 2) == false)
| 566 if (VEC_PUSH_STR(&d->vec, "__") == false)
|
567 return (false);
568
569 return (read_func(d));
570 }
571
572 if (d->type == ENCODE_OP_USER ||
573 d->type == ENCODE_OP_TF ||
574 d->type == ENCODE_OP_TI)
575 return (true);
576
577 /* skip "__" */
578 d->p += 2;
579
580 if (*d->p == 'C') {
581 ++d->p;
582
583 d->cnst_fn = true;
584 }
585
586 /* assume delimiter is removed */
587 if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) {
588 ++d->p;
589
590 assert(d->vec.size > 0);
591
592 len = strlen(d->vec.container[d->vec.size - 1]);
593 if ((op_name = malloc(sizeof(char) * (len + 1)))
594 == NULL)
595 return (false);
596
597 snprintf(op_name, len + 1, "%s",
598 d->vec.container[d->vec.size - 1]);
599 vector_str_pop(&d->vec);
600
601 if (read_qual_name(d) == false)
602 goto clean;
603
| 567 return (false);
568
569 return (read_func(d));
570 }
571
572 if (d->type == ENCODE_OP_USER ||
573 d->type == ENCODE_OP_TF ||
574 d->type == ENCODE_OP_TI)
575 return (true);
576
577 /* skip "__" */
578 d->p += 2;
579
580 if (*d->p == 'C') {
581 ++d->p;
582
583 d->cnst_fn = true;
584 }
585
586 /* assume delimiter is removed */
587 if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) {
588 ++d->p;
589
590 assert(d->vec.size > 0);
591
592 len = strlen(d->vec.container[d->vec.size - 1]);
593 if ((op_name = malloc(sizeof(char) * (len + 1)))
594 == NULL)
595 return (false);
596
597 snprintf(op_name, len + 1, "%s",
598 d->vec.container[d->vec.size - 1]);
599 vector_str_pop(&d->vec);
600
601 if (read_qual_name(d) == false)
602 goto clean;
603
|
604 if (vector_str_push(&d->vec, "::", 2) == false)
| 604 if (VEC_PUSH_STR(&d->vec, "::") == false)
|
605 goto clean;
606
607 if (vector_str_push(&d->vec, op_name, len) == false)
608 goto clean;
609
610 rtn = true;
611 } else if (ELFTC_ISDIGIT(*d->p)) {
612 assert(d->vec.size > 0);
613
614 len = strlen(d->vec.container[d->vec.size - 1]);
615 if ((op_name = malloc(sizeof(char) * (len + 1)))
616 == NULL)
617 return (false);
618
619 snprintf(op_name, len + 1, "%s",
620 d->vec.container[d->vec.size - 1]);
621 vector_str_pop(&d->vec);
622
623 if (read_class(d) == false)
624 goto clean;
625
| 605 goto clean;
606
607 if (vector_str_push(&d->vec, op_name, len) == false)
608 goto clean;
609
610 rtn = true;
611 } else if (ELFTC_ISDIGIT(*d->p)) {
612 assert(d->vec.size > 0);
613
614 len = strlen(d->vec.container[d->vec.size - 1]);
615 if ((op_name = malloc(sizeof(char) * (len + 1)))
616 == NULL)
617 return (false);
618
619 snprintf(op_name, len + 1, "%s",
620 d->vec.container[d->vec.size - 1]);
621 vector_str_pop(&d->vec);
622
623 if (read_class(d) == false)
624 goto clean;
625
|
626 if (vector_str_push(&d->vec, "::", 2) == false)
| 626 if (VEC_PUSH_STR(&d->vec, "::") == false)
|
627 goto clean;
628
629 if (vector_str_push(&d->vec, op_name, len) == false)
630 goto clean;
631
632 rtn = true;
633 }
634 } else if (memcmp(d->p, "_$_", 3) == 0) {
635 /* DTOR */
636 d->p += 3;
637 d->type = ENCODE_OP_DT;
638
639 if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) {
640 ++d->p;
641
642 if (read_qual_name(d) == false)
643 return (false);
644
645 return (vector_str_pop(&d->vec));
646 } else if (ELFTC_ISDIGIT(*d->p))
647 return (read_class(d));
648
649 return (false);
650 } else if (memcmp(d->p, "_vt$", 4) == 0) {
651 /* vtable */
652 d->p += 4;
653 d->type = ENCODE_OP_VT;
654
655 if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) {
656 ++d->p;
657
658 if (read_qual_name(d) == false)
659 return (false);
660
661 if (vector_str_pop(&d->vec) == false)
662 return (false);
663 } else if (ELFTC_ISDIGIT(*d->p)) {
664 if (read_class(d) == false)
665 return (false);
666 }
667
| 627 goto clean;
628
629 if (vector_str_push(&d->vec, op_name, len) == false)
630 goto clean;
631
632 rtn = true;
633 }
634 } else if (memcmp(d->p, "_$_", 3) == 0) {
635 /* DTOR */
636 d->p += 3;
637 d->type = ENCODE_OP_DT;
638
639 if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) {
640 ++d->p;
641
642 if (read_qual_name(d) == false)
643 return (false);
644
645 return (vector_str_pop(&d->vec));
646 } else if (ELFTC_ISDIGIT(*d->p))
647 return (read_class(d));
648
649 return (false);
650 } else if (memcmp(d->p, "_vt$", 4) == 0) {
651 /* vtable */
652 d->p += 4;
653 d->type = ENCODE_OP_VT;
654
655 if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) {
656 ++d->p;
657
658 if (read_qual_name(d) == false)
659 return (false);
660
661 if (vector_str_pop(&d->vec) == false)
662 return (false);
663 } else if (ELFTC_ISDIGIT(*d->p)) {
664 if (read_class(d) == false)
665 return (false);
666 }
667
|
668 return (vector_str_push(&d->vec, " virtual table", 14));
| 668 return (VEC_PUSH_STR(&d->vec, " virtual table"));
|
669 } else
670 return (read_func(d));
671clean:
672 free(op_name);
673
674 return (rtn);
675}
676
677/* Read function ptr type */
678static bool
679read_func_ptr(struct demangle_data *d)
680{
681 struct demangle_data fptr;
682 size_t arg_len, rtn_len;
683 char *arg_type, *rtn_type;
684 int lim;
685
686 if (d == NULL)
687 return (false);
688
689 if (init_demangle_data(&fptr) == false)
690 return (false);
691
692 fptr.p = d->p + 1;
693 lim = 0;
694 arg_type = NULL;
695 rtn_type = NULL;
696
697 for (;;) {
698 if (read_type(&fptr) == false) {
699 dest_demangle_data(&fptr);
700
701 return (false);
702 }
703
704 if (fptr.ptr == true) {
| 669 } else
670 return (read_func(d));
671clean:
672 free(op_name);
673
674 return (rtn);
675}
676
677/* Read function ptr type */
678static bool
679read_func_ptr(struct demangle_data *d)
680{
681 struct demangle_data fptr;
682 size_t arg_len, rtn_len;
683 char *arg_type, *rtn_type;
684 int lim;
685
686 if (d == NULL)
687 return (false);
688
689 if (init_demangle_data(&fptr) == false)
690 return (false);
691
692 fptr.p = d->p + 1;
693 lim = 0;
694 arg_type = NULL;
695 rtn_type = NULL;
696
697 for (;;) {
698 if (read_type(&fptr) == false) {
699 dest_demangle_data(&fptr);
700
701 return (false);
702 }
703
704 if (fptr.ptr == true) {
|
705 if (vector_str_push(&fptr.vec, "*", 1) == false) {
| 705 if (VEC_PUSH_STR(&fptr.vec, "*") == false) {
|
706 dest_demangle_data(&fptr);
707
708 return (false);
709 }
710
711 fptr.ptr = false;
712 }
713
714 if (fptr.ref == true) {
| 706 dest_demangle_data(&fptr);
707
708 return (false);
709 }
710
711 fptr.ptr = false;
712 }
713
714 if (fptr.ref == true) {
|
715 if (vector_str_push(&fptr.vec, "&", 1) == false) {
| 715 if (VEC_PUSH_STR(&fptr.vec, "&") == false) {
|
716 dest_demangle_data(&fptr);
717
718 return (false);
719 }
720
721 fptr.ref = false;
722 }
723
724 if (fptr.cnst == true) {
| 716 dest_demangle_data(&fptr);
717
718 return (false);
719 }
720
721 fptr.ref = false;
722 }
723
724 if (fptr.cnst == true) {
|
725 if (vector_str_push(&fptr.vec, " const", 6) == false) {
| 725 if (VEC_PUSH_STR(&fptr.vec, " const") == false) {
|
726 dest_demangle_data(&fptr);
727
728 return (false);
729 }
730
731 fptr.cnst = false;
732 }
733
734 if (*fptr.p == '_')
735 break;
736
| 726 dest_demangle_data(&fptr);
727
728 return (false);
729 }
730
731 fptr.cnst = false;
732 }
733
734 if (*fptr.p == '_')
735 break;
736
|
737 if (vector_str_push(&fptr.vec, ", ", 2) == false) {
| 737 if (VEC_PUSH_STR(&fptr.vec, ", ") == false) {
|
738 dest_demangle_data(&fptr);
739
740 return (false);
741 }
742
743 if (++lim > CPP_DEMANGLE_GNU2_TRY) {
744
745 dest_demangle_data(&fptr);
746
747 return (false);
748 }
749 }
750
751 arg_type = vector_str_get_flat(&fptr.vec, &arg_len);
752 /* skip '_' */
753 d->p = fptr.p + 1;
754
755 dest_demangle_data(&fptr);
756
757 if (init_demangle_data(&fptr) == false) {
758 free(arg_type);
759
760 return (false);
761 }
762
763 fptr.p = d->p;
764 lim = 0;
765
766 if (read_type(&fptr) == false) {
767 free(arg_type);
768 dest_demangle_data(&fptr);
769
770 return (false);
771 }
772
773 rtn_type = vector_str_get_flat(&fptr.vec, &rtn_len);
774 d->p = fptr.p;
775
776
777 dest_demangle_data(&fptr);
778
779 if (vector_str_push(&d->vec, rtn_type, rtn_len) == false) {
780 free(rtn_type);
781 free(arg_type);
782
783 return (false);
784 }
785
786 free(rtn_type);
787
| 738 dest_demangle_data(&fptr);
739
740 return (false);
741 }
742
743 if (++lim > CPP_DEMANGLE_GNU2_TRY) {
744
745 dest_demangle_data(&fptr);
746
747 return (false);
748 }
749 }
750
751 arg_type = vector_str_get_flat(&fptr.vec, &arg_len);
752 /* skip '_' */
753 d->p = fptr.p + 1;
754
755 dest_demangle_data(&fptr);
756
757 if (init_demangle_data(&fptr) == false) {
758 free(arg_type);
759
760 return (false);
761 }
762
763 fptr.p = d->p;
764 lim = 0;
765
766 if (read_type(&fptr) == false) {
767 free(arg_type);
768 dest_demangle_data(&fptr);
769
770 return (false);
771 }
772
773 rtn_type = vector_str_get_flat(&fptr.vec, &rtn_len);
774 d->p = fptr.p;
775
776
777 dest_demangle_data(&fptr);
778
779 if (vector_str_push(&d->vec, rtn_type, rtn_len) == false) {
780 free(rtn_type);
781 free(arg_type);
782
783 return (false);
784 }
785
786 free(rtn_type);
787
|
788 if (vector_str_push(&d->vec, " (*)(", 5) == false) {
| 788 if (VEC_PUSH_STR(&d->vec, " (*)(") == false) {
|
789 free(arg_type);
790
791 return (false);
792 }
793
794 if (vector_str_push(&d->vec, arg_type, arg_len) == false) {
795 free(arg_type);
796
797 return (false);
798 }
799
800 free(arg_type);
801
| 789 free(arg_type);
790
791 return (false);
792 }
793
794 if (vector_str_push(&d->vec, arg_type, arg_len) == false) {
795 free(arg_type);
796
797 return (false);
798 }
799
800 free(arg_type);
801
|
802 return (vector_str_push(&d->vec, ")", 1));
| 802 return (VEC_PUSH_STR(&d->vec, ")"));
|
803}
804
805static bool
806read_memptr(struct demangle_data *d)
807{
808 struct demangle_data mptr;
809 size_t len;
810 bool rtn;
811 char *mptr_str;
812
813 if (d == NULL || d->p == NULL)
814 return (false);
815
816 if (init_demangle_data(&mptr) == false)
817 return (false);
818
819 rtn = false;
820 mptr_str = NULL;
821
822 mptr.p = d->p;
823 if (*mptr.p == 'Q') {
824 ++mptr.p;
825
826 if (read_qual_name(&mptr) == false)
827 goto clean;
828 } else if (read_class(&mptr) == false)
829 goto clean;
830
831 d->p = mptr.p;
832
833 if ((mptr_str = vector_str_get_flat(&mptr.vec, &len)) == NULL)
834 goto clean;
835
836 if (vector_str_push(&d->vec, mptr_str, len) == false)
837 goto clean;
838
| 803}
804
805static bool
806read_memptr(struct demangle_data *d)
807{
808 struct demangle_data mptr;
809 size_t len;
810 bool rtn;
811 char *mptr_str;
812
813 if (d == NULL || d->p == NULL)
814 return (false);
815
816 if (init_demangle_data(&mptr) == false)
817 return (false);
818
819 rtn = false;
820 mptr_str = NULL;
821
822 mptr.p = d->p;
823 if (*mptr.p == 'Q') {
824 ++mptr.p;
825
826 if (read_qual_name(&mptr) == false)
827 goto clean;
828 } else if (read_class(&mptr) == false)
829 goto clean;
830
831 d->p = mptr.p;
832
833 if ((mptr_str = vector_str_get_flat(&mptr.vec, &len)) == NULL)
834 goto clean;
835
836 if (vector_str_push(&d->vec, mptr_str, len) == false)
837 goto clean;
838
|
839 if (vector_str_push(&d->vec, "::*", 3) == false)
| 839 if (VEC_PUSH_STR(&d->vec, "::*") == false)
|
840 goto clean;
841
842 rtn = true;
843clean:
844 free(mptr_str);
845 dest_demangle_data(&mptr);
846
847 return (rtn);
848}
849
850static bool
851read_op(struct demangle_data *d)
852{
853
854 if (d == NULL)
855 return (false);
856
857 assert(d->p != NULL && "d->p (org str) is NULL");
858
859 switch (SIMPLE_HASH(*(d->p), *(d->p+1))) {
860 case SIMPLE_HASH('m', 'l') :
861 d->p += 2;
| 840 goto clean;
841
842 rtn = true;
843clean:
844 free(mptr_str);
845 dest_demangle_data(&mptr);
846
847 return (rtn);
848}
849
850static bool
851read_op(struct demangle_data *d)
852{
853
854 if (d == NULL)
855 return (false);
856
857 assert(d->p != NULL && "d->p (org str) is NULL");
858
859 switch (SIMPLE_HASH(*(d->p), *(d->p+1))) {
860 case SIMPLE_HASH('m', 'l') :
861 d->p += 2;
|
862 return (vector_str_push(&d->vec, "operator*", 9));
| 862 return (VEC_PUSH_STR(&d->vec, "operator*"));
|
863 case SIMPLE_HASH('d', 'v') :
864 d->p += 2;
| 863 case SIMPLE_HASH('d', 'v') :
864 d->p += 2;
|
865 return (vector_str_push(&d->vec, "operator/", 9));
| 865 return (VEC_PUSH_STR(&d->vec, "operator/"));
|
866 case SIMPLE_HASH('m', 'd') :
867 d->p += 2;
| 866 case SIMPLE_HASH('m', 'd') :
867 d->p += 2;
|
868 return (vector_str_push(&d->vec, "operator%", 9));
| 868 return (VEC_PUSH_STR(&d->vec, "operator%"));
|
869 case SIMPLE_HASH('p', 'l') :
870 d->p += 2;
| 869 case SIMPLE_HASH('p', 'l') :
870 d->p += 2;
|
871 return (vector_str_push(&d->vec, "operator+", 9));
| 871 return (VEC_PUSH_STR(&d->vec, "operator+"));
|
872 case SIMPLE_HASH('m', 'i') :
873 d->p += 2;
| 872 case SIMPLE_HASH('m', 'i') :
873 d->p += 2;
|
874 return (vector_str_push(&d->vec, "operator-", 9));
| 874 return (VEC_PUSH_STR(&d->vec, "operator-"));
|
875 case SIMPLE_HASH('l', 's') :
876 d->p += 2;
| 875 case SIMPLE_HASH('l', 's') :
876 d->p += 2;
|
877 return (vector_str_push(&d->vec, "operator<<", 10));
| 877 return (VEC_PUSH_STR(&d->vec, "operator<<"));
|
878 case SIMPLE_HASH('r', 's') :
879 d->p += 2;
| 878 case SIMPLE_HASH('r', 's') :
879 d->p += 2;
|
880 return (vector_str_push(&d->vec, "operator>>", 10));
| 880 return (VEC_PUSH_STR(&d->vec, "operator>>"));
|
881 case SIMPLE_HASH('e', 'q') :
882 d->p += 2;
| 881 case SIMPLE_HASH('e', 'q') :
882 d->p += 2;
|
883 return (vector_str_push(&d->vec, "operator==", 10));
| 883 return (VEC_PUSH_STR(&d->vec, "operator=="));
|
884 case SIMPLE_HASH('n', 'e') :
885 d->p += 2;
| 884 case SIMPLE_HASH('n', 'e') :
885 d->p += 2;
|
886 return (vector_str_push(&d->vec, "operator!=", 10));
| 886 return (VEC_PUSH_STR(&d->vec, "operator!="));
|
887 case SIMPLE_HASH('l', 't') :
888 d->p += 2;
| 887 case SIMPLE_HASH('l', 't') :
888 d->p += 2;
|
889 return (vector_str_push(&d->vec, "operator<", 9));
| 889 return (VEC_PUSH_STR(&d->vec, "operator<"));
|
890 case SIMPLE_HASH('g', 't') :
891 d->p += 2;
| 890 case SIMPLE_HASH('g', 't') :
891 d->p += 2;
|
892 return (vector_str_push(&d->vec, "operator>", 9));
| 892 return (VEC_PUSH_STR(&d->vec, "operator>"));
|
893 case SIMPLE_HASH('l', 'e') :
894 d->p += 2;
| 893 case SIMPLE_HASH('l', 'e') :
894 d->p += 2;
|
895 return (vector_str_push(&d->vec, "operator<=", 10));
| 895 return (VEC_PUSH_STR(&d->vec, "operator<="));
|
896 case SIMPLE_HASH('g', 'e') :
897 d->p += 2;
| 896 case SIMPLE_HASH('g', 'e') :
897 d->p += 2;
|
898 return (vector_str_push(&d->vec, "operator>=", 10));
| 898 return (VEC_PUSH_STR(&d->vec, "operator>="));
|
899 case SIMPLE_HASH('a', 'd') :
900 d->p += 2;
901 if (*d->p == 'v') {
902 ++d->p;
| 899 case SIMPLE_HASH('a', 'd') :
900 d->p += 2;
901 if (*d->p == 'v') {
902 ++d->p;
|
903 return (vector_str_push(&d->vec, "operator/=",
904 10));
| 903 return (VEC_PUSH_STR(&d->vec, "operator/="));
|
905 } else
| 904 } else
|
906 return (vector_str_push(&d->vec, "operator&", 9));
| 905 return (VEC_PUSH_STR(&d->vec, "operator&"));
|
907 case SIMPLE_HASH('o', 'r') :
908 d->p += 2;
| 906 case SIMPLE_HASH('o', 'r') :
907 d->p += 2;
|
909 return (vector_str_push(&d->vec, "operator|", 9));
| 908 return (VEC_PUSH_STR(&d->vec, "operator|"));
|
910 case SIMPLE_HASH('e', 'r') :
911 d->p += 2;
| 909 case SIMPLE_HASH('e', 'r') :
910 d->p += 2;
|
912 return (vector_str_push(&d->vec, "operator^", 9));
| 911 return (VEC_PUSH_STR(&d->vec, "operator^"));
|
913 case SIMPLE_HASH('a', 'a') :
914 d->p += 2;
915 if (*d->p == 'd') {
916 ++d->p;
| 912 case SIMPLE_HASH('a', 'a') :
913 d->p += 2;
914 if (*d->p == 'd') {
915 ++d->p;
|
917 return (vector_str_push(&d->vec, "operator&=",
918 10));
| 916 return (VEC_PUSH_STR(&d->vec, "operator&="));
|
919 } else
| 917 } else
|
920 return (vector_str_push(&d->vec, "operator&&",
921 10));
| 918 return (VEC_PUSH_STR(&d->vec, "operator&&"));
|
922 case SIMPLE_HASH('o', 'o') :
923 d->p += 2;
| 919 case SIMPLE_HASH('o', 'o') :
920 d->p += 2;
|
924 return (vector_str_push(&d->vec, "operator||", 10));
| 921 return (VEC_PUSH_STR(&d->vec, "operator||"));
|
925 case SIMPLE_HASH('n', 't') :
926 d->p += 2;
| 922 case SIMPLE_HASH('n', 't') :
923 d->p += 2;
|
927 return (vector_str_push(&d->vec, "operator!", 9));
| 924 return (VEC_PUSH_STR(&d->vec, "operator!"));
|
928 case SIMPLE_HASH('c', 'o') :
929 d->p += 2;
| 925 case SIMPLE_HASH('c', 'o') :
926 d->p += 2;
|
930 return (vector_str_push(&d->vec, "operator~", 9));
| 927 return (VEC_PUSH_STR(&d->vec, "operator~"));
|
931 case SIMPLE_HASH('p', 'p') :
932 d->p += 2;
| 928 case SIMPLE_HASH('p', 'p') :
929 d->p += 2;
|
933 return (vector_str_push(&d->vec, "operator++", 10));
| 930 return (VEC_PUSH_STR(&d->vec, "operator++"));
|
934 case SIMPLE_HASH('m', 'm') :
935 d->p += 2;
| 931 case SIMPLE_HASH('m', 'm') :
932 d->p += 2;
|
936 return (vector_str_push(&d->vec, "operator--", 10));
| 933 return (VEC_PUSH_STR(&d->vec, "operator--"));
|
937 case SIMPLE_HASH('a', 's') :
938 d->p += 2;
| 934 case SIMPLE_HASH('a', 's') :
935 d->p += 2;
|
939 return (vector_str_push(&d->vec, "operator=", 9));
| 936 return (VEC_PUSH_STR(&d->vec, "operator="));
|
940 case SIMPLE_HASH('r', 'f') :
941 d->p += 2;
| 937 case SIMPLE_HASH('r', 'f') :
938 d->p += 2;
|
942 return (vector_str_push(&d->vec, "operator->", 10));
| 939 return (VEC_PUSH_STR(&d->vec, "operator->"));
|
943 case SIMPLE_HASH('a', 'p') :
944 /* apl */
945 if (*(d->p + 2) != 'l')
946 return (false);
947
948 d->p += 3;
| 940 case SIMPLE_HASH('a', 'p') :
941 /* apl */
942 if (*(d->p + 2) != 'l')
943 return (false);
944
945 d->p += 3;
|
949 return (vector_str_push(&d->vec, "operator+=", 10));
| 946 return (VEC_PUSH_STR(&d->vec, "operator+="));
|
950 case SIMPLE_HASH('a', 'm') :
951 d->p += 2;
952 if (*d->p == 'i') {
953 ++d->p;
| 947 case SIMPLE_HASH('a', 'm') :
948 d->p += 2;
949 if (*d->p == 'i') {
950 ++d->p;
|
954 return (vector_str_push(&d->vec, "operator-=",
955 10));
| 951 return (VEC_PUSH_STR(&d->vec, "operator-="));
|
956 } else if (*d->p == 'u') {
957 ++d->p;
| 952 } else if (*d->p == 'u') {
953 ++d->p;
|
958 return (vector_str_push(&d->vec, "operator*=",
959 10));
| 954 return (VEC_PUSH_STR(&d->vec, "operator*="));
|
960 } else if (*d->p == 'd') {
961 ++d->p;
| 955 } else if (*d->p == 'd') {
956 ++d->p;
|
962 return (vector_str_push(&d->vec, "operator%=",
963 10));
| 957 return (VEC_PUSH_STR(&d->vec, "operator%="));
|
964 }
965
966 return (false);
967 case SIMPLE_HASH('a', 'l') :
968 /* als */
969 if (*(d->p + 2) != 's')
970 return (false);
971
972 d->p += 3;
| 958 }
959
960 return (false);
961 case SIMPLE_HASH('a', 'l') :
962 /* als */
963 if (*(d->p + 2) != 's')
964 return (false);
965
966 d->p += 3;
|
973 return (vector_str_push(&d->vec, "operator<<=", 11));
| 967 return (VEC_PUSH_STR(&d->vec, "operator<<="));
|
974 case SIMPLE_HASH('a', 'r') :
975 /* ars */
976 if (*(d->p + 2) != 's')
977 return (false);
978
979 d->p += 3;
| 968 case SIMPLE_HASH('a', 'r') :
969 /* ars */
970 if (*(d->p + 2) != 's')
971 return (false);
972
973 d->p += 3;
|
980 return (vector_str_push(&d->vec, "operator>>=", 11));
| 974 return (VEC_PUSH_STR(&d->vec, "operator>>="));
|
981 case SIMPLE_HASH('a', 'o') :
982 /* aor */
983 if (*(d->p + 2) != 'r')
984 return (false);
985
986 d->p += 3;
| 975 case SIMPLE_HASH('a', 'o') :
976 /* aor */
977 if (*(d->p + 2) != 'r')
978 return (false);
979
980 d->p += 3;
|
987 return (vector_str_push(&d->vec, "operator|=", 10));
| 981 return (VEC_PUSH_STR(&d->vec, "operator|="));
|
988 case SIMPLE_HASH('a', 'e') :
989 /* aer */
990 if (*(d->p + 2) != 'r')
991 return (false);
992
993 d->p += 3;
| 982 case SIMPLE_HASH('a', 'e') :
983 /* aer */
984 if (*(d->p + 2) != 'r')
985 return (false);
986
987 d->p += 3;
|
994 return (vector_str_push(&d->vec, "operator^=", 10));
| 988 return (VEC_PUSH_STR(&d->vec, "operator^="));
|
995 case SIMPLE_HASH('c', 'm') :
996 d->p += 2;
| 989 case SIMPLE_HASH('c', 'm') :
990 d->p += 2;
|
997 return (vector_str_push(&d->vec, "operator,", 9));
| 991 return (VEC_PUSH_STR(&d->vec, "operator,"));
|
998 case SIMPLE_HASH('r', 'm') :
999 d->p += 2;
| 992 case SIMPLE_HASH('r', 'm') :
993 d->p += 2;
|
1000 return (vector_str_push(&d->vec, "operator->*", 11));
| 994 return (VEC_PUSH_STR(&d->vec, "operator->*"));
|
1001 case SIMPLE_HASH('c', 'l') :
1002 d->p += 2;
| 995 case SIMPLE_HASH('c', 'l') :
996 d->p += 2;
|
1003 return (vector_str_push(&d->vec, "()", 2));
| 997 return (VEC_PUSH_STR(&d->vec, "()"));
|
1004 case SIMPLE_HASH('v', 'c') :
1005 d->p += 2;
| 998 case SIMPLE_HASH('v', 'c') :
999 d->p += 2;
|
1006 return (vector_str_push(&d->vec, "[]", 2));
| 1000 return (VEC_PUSH_STR(&d->vec, "[]"));
|
1007 case SIMPLE_HASH('n', 'w') :
1008 d->p += 2;
| 1001 case SIMPLE_HASH('n', 'w') :
1002 d->p += 2;
|
1009 return (vector_str_push(&d->vec, "operator new()", 14));
| 1003 return (VEC_PUSH_STR(&d->vec, "operator new()"));
|
1010 case SIMPLE_HASH('d', 'l') :
1011 d->p += 2;
| 1004 case SIMPLE_HASH('d', 'l') :
1005 d->p += 2;
|
1012 return (vector_str_push(&d->vec, "operator delete()",
1013 17));
| 1006 return (VEC_PUSH_STR(&d->vec, "operator delete()"));
|
1014 case SIMPLE_HASH('o', 'p') :
1015 /* __op<TO_TYPE>__<FROM_TYPE> */
1016 d->p += 2;
1017
1018 d->type = ENCODE_OP_USER;
1019
1020 return (read_op_user(d));
1021 case SIMPLE_HASH('t', 'f') :
1022 d->p += 2;
1023 d->type = ENCODE_OP_TF;
1024
1025 if (read_type(d) == false)
1026 return (false);
1027
| 1007 case SIMPLE_HASH('o', 'p') :
1008 /* __op<TO_TYPE>__<FROM_TYPE> */
1009 d->p += 2;
1010
1011 d->type = ENCODE_OP_USER;
1012
1013 return (read_op_user(d));
1014 case SIMPLE_HASH('t', 'f') :
1015 d->p += 2;
1016 d->type = ENCODE_OP_TF;
1017
1018 if (read_type(d) == false)
1019 return (false);
1020
|
1028 return (vector_str_push(&d->vec, " type_info function", 19));
| 1021 return (VEC_PUSH_STR(&d->vec, " type_info function"));
|
1029 case SIMPLE_HASH('t', 'i') :
1030 d->p += 2;
1031 d->type = ENCODE_OP_TI;
1032
1033 if (read_type(d) == false)
1034 return (false);
1035
| 1022 case SIMPLE_HASH('t', 'i') :
1023 d->p += 2;
1024 d->type = ENCODE_OP_TI;
1025
1026 if (read_type(d) == false)
1027 return (false);
1028
|
1036 return (vector_str_push(&d->vec, " type_info node", 15));
| 1029 return (VEC_PUSH_STR(&d->vec, " type_info node"));
|
1037 default :
1038 return (false);
1039 };
1040}
1041
1042static bool
1043read_op_user(struct demangle_data *d)
1044{
1045 struct demangle_data from, to;
1046 size_t from_len, to_len;
1047 bool rtn;
1048 char *from_str, *to_str;
1049
1050 if (d == NULL)
1051 return (false);
1052
1053 if (init_demangle_data(&from) == false)
1054 return (false);
1055
1056 rtn = false;
1057 from_str = NULL;
1058 to_str = NULL;
1059 if (init_demangle_data(&to) == false)
1060 goto clean;
1061
1062 to.p = d->p;
1063 if (*to.p == 'Q') {
1064 ++to.p;
1065
1066 if (read_qual_name(&to) == false)
1067 goto clean;
1068
1069 /* pop last '::' */
1070 if (vector_str_pop(&to.vec) == false)
1071 goto clean;
1072 } else {
1073 if (read_class(&to) == false)
1074 goto clean;
1075
1076 /* skip '__' */
1077 to.p += 2;
1078 }
1079
1080 if ((to_str = vector_str_get_flat(&to.vec, &to_len)) == NULL)
1081 goto clean;
1082
1083 from.p = to.p;
1084 if (*from.p == 'Q') {
1085 ++from.p;
1086
1087 if (read_qual_name(&from) == false)
1088 goto clean;
1089
1090 /* pop last '::' */
1091 if (vector_str_pop(&from.vec) == false)
1092 goto clean;
1093 } else if (read_class(&from) == false)
1094 goto clean;
1095
1096 if ((from_str = vector_str_get_flat(&from.vec, &from_len)) == NULL)
1097 goto clean;
1098
1099 if (vector_str_push(&d->vec, from_str, from_len) == false)
1100 goto clean;
1101
| 1030 default :
1031 return (false);
1032 };
1033}
1034
1035static bool
1036read_op_user(struct demangle_data *d)
1037{
1038 struct demangle_data from, to;
1039 size_t from_len, to_len;
1040 bool rtn;
1041 char *from_str, *to_str;
1042
1043 if (d == NULL)
1044 return (false);
1045
1046 if (init_demangle_data(&from) == false)
1047 return (false);
1048
1049 rtn = false;
1050 from_str = NULL;
1051 to_str = NULL;
1052 if (init_demangle_data(&to) == false)
1053 goto clean;
1054
1055 to.p = d->p;
1056 if (*to.p == 'Q') {
1057 ++to.p;
1058
1059 if (read_qual_name(&to) == false)
1060 goto clean;
1061
1062 /* pop last '::' */
1063 if (vector_str_pop(&to.vec) == false)
1064 goto clean;
1065 } else {
1066 if (read_class(&to) == false)
1067 goto clean;
1068
1069 /* skip '__' */
1070 to.p += 2;
1071 }
1072
1073 if ((to_str = vector_str_get_flat(&to.vec, &to_len)) == NULL)
1074 goto clean;
1075
1076 from.p = to.p;
1077 if (*from.p == 'Q') {
1078 ++from.p;
1079
1080 if (read_qual_name(&from) == false)
1081 goto clean;
1082
1083 /* pop last '::' */
1084 if (vector_str_pop(&from.vec) == false)
1085 goto clean;
1086 } else if (read_class(&from) == false)
1087 goto clean;
1088
1089 if ((from_str = vector_str_get_flat(&from.vec, &from_len)) == NULL)
1090 goto clean;
1091
1092 if (vector_str_push(&d->vec, from_str, from_len) == false)
1093 goto clean;
1094
|
1102 if (vector_str_push(&d->vec, "::operator ", 11) == false)
| 1095 if (VEC_PUSH_STR(&d->vec, "::operator ") == false)
|
1103 goto clean;
1104
1105 if (vector_str_push(&d->vec, to_str, to_len) == false)
1106 goto clean;
1107
| 1096 goto clean;
1097
1098 if (vector_str_push(&d->vec, to_str, to_len) == false)
1099 goto clean;
1100
|
1108 rtn = vector_str_push(&d->vec, "()", 2);
| 1101 rtn = VEC_PUSH_STR(&d->vec, "()");
|
1109clean:
1110 free(to_str);
1111 free(from_str);
1112 dest_demangle_data(&to);
1113 dest_demangle_data(&from);
1114
1115 return (rtn);
1116}
1117
1118/* single digit + class names */
1119static bool
1120read_qual_name(struct demangle_data *d)
1121{
1122 int i;
1123 char num;
1124
1125 if (d == NULL)
1126 return (false);
1127
1128 assert(d->p != NULL && "d->p (org str) is NULL");
1129 assert(*d->p > 48 && *d->p < 58 && "*d->p not in ASCII numeric range");
1130
1131 num = *d->p - 48;
1132
1133 assert(num > 0);
1134
1135 ++d->p;
1136 for (i = 0; i < num ; ++i) {
1137 if (read_class(d) == false)
1138 return (false);
1139
| 1102clean:
1103 free(to_str);
1104 free(from_str);
1105 dest_demangle_data(&to);
1106 dest_demangle_data(&from);
1107
1108 return (rtn);
1109}
1110
1111/* single digit + class names */
1112static bool
1113read_qual_name(struct demangle_data *d)
1114{
1115 int i;
1116 char num;
1117
1118 if (d == NULL)
1119 return (false);
1120
1121 assert(d->p != NULL && "d->p (org str) is NULL");
1122 assert(*d->p > 48 && *d->p < 58 && "*d->p not in ASCII numeric range");
1123
1124 num = *d->p - 48;
1125
1126 assert(num > 0);
1127
1128 ++d->p;
1129 for (i = 0; i < num ; ++i) {
1130 if (read_class(d) == false)
1131 return (false);
1132
|
1140 if (vector_str_push(&d->vec, "::", 2) == false)
| 1133 if (VEC_PUSH_STR(&d->vec, "::") == false)
|
1141 return (false);
1142 }
1143
1144 if (*d->p != '\0')
1145 d->p = d->p + 2;
1146
1147 return (true);
1148}
1149
1150/* Return -1 at fail, 0 at success, and 1 at end */
1151static int
1152read_subst(struct demangle_data *d)
1153{
1154 size_t idx;
1155 char *str;
1156
1157 if (d == NULL)
1158 return (-1);
1159
1160 idx = strtol(d->p + 1, &str, 10);
1161 if (idx == 0 && (errno == EINVAL || errno == ERANGE))
1162 return (-1);
1163
1164 assert(idx > 0);
1165 assert(str != NULL);
1166
1167 d->p = str;
1168
| 1134 return (false);
1135 }
1136
1137 if (*d->p != '\0')
1138 d->p = d->p + 2;
1139
1140 return (true);
1141}
1142
1143/* Return -1 at fail, 0 at success, and 1 at end */
1144static int
1145read_subst(struct demangle_data *d)
1146{
1147 size_t idx;
1148 char *str;
1149
1150 if (d == NULL)
1151 return (-1);
1152
1153 idx = strtol(d->p + 1, &str, 10);
1154 if (idx == 0 && (errno == EINVAL || errno == ERANGE))
1155 return (-1);
1156
1157 assert(idx > 0);
1158 assert(str != NULL);
1159
1160 d->p = str;
1161
|
1169 if (vector_str_push(&d->vec, d->arg.container[idx - 1],
1170 strlen(d->arg.container[idx - 1])) == false)
| 1162 if (VEC_PUSH_STR(&d->vec, d->arg.container[idx - 1]) == false)
|
1171 return (-1);
1172
| 1163 return (-1);
1164
|
1173 if (vector_str_push(&d->arg, d->arg.container[idx - 1],
1174 strlen(d->arg.container[idx - 1])) == false)
| 1165 if (VEC_PUSH_STR(&d->arg, d->arg.container[idx - 1]) == false)
|
1175 return (-1);
1176
1177 if (*d->p == '\0')
1178 return (1);
1179
1180 return (0);
1181}
1182
1183static int
1184read_subst_iter(struct demangle_data *d)
1185{
1186 int i;
1187 size_t idx;
1188 char repeat;
1189 char *str;
1190
1191 if (d == NULL)
1192 return (-1);
1193
1194 ++d->p;
1195 assert(*d->p > 48 && *d->p < 58 && "*d->p not in ASCII numeric range");
1196
1197 repeat = *d->p - 48;
1198
1199 assert(repeat > 1);
1200
1201 ++d->p;
1202
1203 idx = strtol(d->p, &str, 10);
1204 if (idx == 0 && (errno == EINVAL || errno == ERANGE))
1205 return (-1);
1206
1207 assert(idx > 0);
1208 assert(str != NULL);
1209
1210 d->p = str;
1211
1212 for (i = 0; i < repeat ; ++i) {
| 1166 return (-1);
1167
1168 if (*d->p == '\0')
1169 return (1);
1170
1171 return (0);
1172}
1173
1174static int
1175read_subst_iter(struct demangle_data *d)
1176{
1177 int i;
1178 size_t idx;
1179 char repeat;
1180 char *str;
1181
1182 if (d == NULL)
1183 return (-1);
1184
1185 ++d->p;
1186 assert(*d->p > 48 && *d->p < 58 && "*d->p not in ASCII numeric range");
1187
1188 repeat = *d->p - 48;
1189
1190 assert(repeat > 1);
1191
1192 ++d->p;
1193
1194 idx = strtol(d->p, &str, 10);
1195 if (idx == 0 && (errno == EINVAL || errno == ERANGE))
1196 return (-1);
1197
1198 assert(idx > 0);
1199 assert(str != NULL);
1200
1201 d->p = str;
1202
1203 for (i = 0; i < repeat ; ++i) {
|
1213 if (vector_str_push(&d->vec, d->arg.container[idx - 1],
1214 strlen(d->arg.container[idx - 1])) == false)
| 1204 if (VEC_PUSH_STR(&d->vec, d->arg.container[idx - 1]) == false)
|
1215 return (-1);
1216
| 1205 return (-1);
1206
|
1217 if (vector_str_push(&d->arg, d->arg.container[idx - 1],
1218 strlen(d->arg.container[idx - 1])) == false)
| 1207 if (VEC_PUSH_STR(&d->arg, d->arg.container[idx - 1]) == false)
|
1219 return (-1);
1220
1221 if (i != repeat - 1 &&
| 1208 return (-1);
1209
1210 if (i != repeat - 1 &&
|
1222 vector_str_push(&d->vec, ", ", 2) == false)
| 1211 VEC_PUSH_STR(&d->vec, ", ") == false)
|
1223 return (-1);
1224 }
1225
1226 if (*d->p == '\0')
1227 return (1);
1228
1229 return (0);
1230}
1231
1232static bool
1233read_type(struct demangle_data *d)
1234{
1235
1236 if (d == NULL)
1237 return (false);
1238
1239 assert(d->p != NULL && "d->p (org str) is NULL");
1240
1241 while (*d->p == 'U' || *d->p == 'C' || *d->p == 'V' || *d->p == 'S' ||
1242 *d->p == 'P' || *d->p == 'R' || *d->p == 'A' || *d->p == 'F' ||
1243 *d->p == 'M') {
1244 switch (*d->p) {
1245 case 'U' :
1246 ++d->p;
1247
| 1212 return (-1);
1213 }
1214
1215 if (*d->p == '\0')
1216 return (1);
1217
1218 return (0);
1219}
1220
1221static bool
1222read_type(struct demangle_data *d)
1223{
1224
1225 if (d == NULL)
1226 return (false);
1227
1228 assert(d->p != NULL && "d->p (org str) is NULL");
1229
1230 while (*d->p == 'U' || *d->p == 'C' || *d->p == 'V' || *d->p == 'S' ||
1231 *d->p == 'P' || *d->p == 'R' || *d->p == 'A' || *d->p == 'F' ||
1232 *d->p == 'M') {
1233 switch (*d->p) {
1234 case 'U' :
1235 ++d->p;
1236
|
1248 if (vector_str_push(&d->vec, "unsigned ", 9) == false)
| 1237 if (VEC_PUSH_STR(&d->vec, "unsigned ") == false)
|
1249 return (false);
1250
1251 break;
1252 case 'C' :
1253 ++d->p;
1254
1255 if (*d->p == 'P')
1256 d->cnst = true;
1257 else {
| 1238 return (false);
1239
1240 break;
1241 case 'C' :
1242 ++d->p;
1243
1244 if (*d->p == 'P')
1245 d->cnst = true;
1246 else {
|
1258 if (vector_str_push(&d->vec, "const ", 6) ==
| 1247 if (VEC_PUSH_STR(&d->vec, "const ") ==
|
1259 false)
1260 return (false);
1261 }
1262
1263 break;
1264 case 'V' :
1265 ++d->p;
1266
| 1248 false)
1249 return (false);
1250 }
1251
1252 break;
1253 case 'V' :
1254 ++d->p;
1255
|
1267 if (vector_str_push(&d->vec, "volatile ", 9) == false)
| 1256 if (VEC_PUSH_STR(&d->vec, "volatile ") == false)
|
1268 return (false);
1269
1270 break;
1271 case 'S' :
1272 ++d->p;
1273
| 1257 return (false);
1258
1259 break;
1260 case 'S' :
1261 ++d->p;
1262
|
1274 if (vector_str_push(&d->vec, "signed ", 7) == false)
| 1263 if (VEC_PUSH_STR(&d->vec, "signed ") == false)
|
1275 return (false);
1276
1277 break;
1278 case 'P' :
1279 ++d->p;
1280
1281 if (*d->p == 'F')
1282 return (read_func_ptr(d));
1283 else
1284 d->ptr = true;
1285
1286 break;
1287 case 'R' :
1288 ++d->p;
1289
1290 d->ref = true;
1291
1292 break;
1293 case 'F' :
1294 break;
1295 case 'A' :
1296 ++d->p;
1297
1298 if (read_array(d) == false)
1299 return (false);
1300
1301 break;
1302 case 'M' :
1303 ++d->p;
1304
1305 if (read_memptr(d) == false)
1306 return (false);
1307
1308 break;
1309 default :
1310 break;
1311 }
1312 }
1313
1314 if (ELFTC_ISDIGIT(*d->p))
1315 return (read_class(d));
1316
1317 switch (*d->p) {
1318 case 'Q' :
1319 ++d->p;
1320
1321 return (read_qual_name(d));
1322 case 'v' :
1323 ++d->p;
1324
| 1264 return (false);
1265
1266 break;
1267 case 'P' :
1268 ++d->p;
1269
1270 if (*d->p == 'F')
1271 return (read_func_ptr(d));
1272 else
1273 d->ptr = true;
1274
1275 break;
1276 case 'R' :
1277 ++d->p;
1278
1279 d->ref = true;
1280
1281 break;
1282 case 'F' :
1283 break;
1284 case 'A' :
1285 ++d->p;
1286
1287 if (read_array(d) == false)
1288 return (false);
1289
1290 break;
1291 case 'M' :
1292 ++d->p;
1293
1294 if (read_memptr(d) == false)
1295 return (false);
1296
1297 break;
1298 default :
1299 break;
1300 }
1301 }
1302
1303 if (ELFTC_ISDIGIT(*d->p))
1304 return (read_class(d));
1305
1306 switch (*d->p) {
1307 case 'Q' :
1308 ++d->p;
1309
1310 return (read_qual_name(d));
1311 case 'v' :
1312 ++d->p;
1313
|
1325 return (vector_str_push(&d->vec, "void", 4));
| 1314 return (VEC_PUSH_STR(&d->vec, "void"));
|
1326 case 'b':
1327 ++d->p;
1328
| 1315 case 'b':
1316 ++d->p;
1317
|
1329 return(vector_str_push(&d->vec, "bool", 4));
| 1318 return(VEC_PUSH_STR(&d->vec, "bool"));
|
1330 case 'c' :
1331 ++d->p;
1332
| 1319 case 'c' :
1320 ++d->p;
1321
|
1333 return (vector_str_push(&d->vec, "char", 4));
| 1322 return (VEC_PUSH_STR(&d->vec, "char"));
|
1334 case 's' :
1335 ++d->p;
1336
| 1323 case 's' :
1324 ++d->p;
1325
|
1337 return (vector_str_push(&d->vec, "short", 5));
| 1326 return (VEC_PUSH_STR(&d->vec, "short"));
|
1338 case 'i' :
1339 ++d->p;
1340
| 1327 case 'i' :
1328 ++d->p;
1329
|
1341 return (vector_str_push(&d->vec, "int", 3));
| 1330 return (VEC_PUSH_STR(&d->vec, "int"));
|
1342 case 'l' :
1343 ++d->p;
1344
| 1331 case 'l' :
1332 ++d->p;
1333
|
1345 return (vector_str_push(&d->vec, "long", 4));
| 1334 return (VEC_PUSH_STR(&d->vec, "long"));
|
1346 case 'f' :
1347 ++d->p;
1348
| 1335 case 'f' :
1336 ++d->p;
1337
|
1349 return (vector_str_push(&d->vec, "float", 5));
| 1338 return (VEC_PUSH_STR(&d->vec, "float"));
|
1350 case 'd':
1351 ++d->p;
1352
| 1339 case 'd':
1340 ++d->p;
1341
|
1353 return (vector_str_push(&d->vec, "double", 6));
| 1342 return (VEC_PUSH_STR(&d->vec, "double"));
|
1354 case 'r':
1355 ++d->p;
1356
| 1343 case 'r':
1344 ++d->p;
1345
|
1357 return (vector_str_push(&d->vec, "long double", 11));
| 1346 return (VEC_PUSH_STR(&d->vec, "long double"));
|
1358 case 'e':
1359 ++d->p;
1360
| 1347 case 'e':
1348 ++d->p;
1349
|
1361 return (vector_str_push(&d->vec, "...", 3));
| 1350 return (VEC_PUSH_STR(&d->vec, "..."));
|
1362 case 'w':
1363 ++d->p;
1364
| 1351 case 'w':
1352 ++d->p;
1353
|
1365 return (vector_str_push(&d->vec, "wchar_t", 7));
| 1354 return (VEC_PUSH_STR(&d->vec, "wchar_t"));
|
1366 case 'x':
1367 ++d->p;
1368
| 1355 case 'x':
1356 ++d->p;
1357
|
1369 return (vector_str_push(&d->vec, "long long", 9));
| 1358 return (VEC_PUSH_STR(&d->vec, "long long"));
|
1370 default:
1371 return (false);
1372 };
1373
1374 /* NOTREACHED */
1375 return (false);
1376}
| 1359 default:
1360 return (false);
1361 };
1362
1363 /* NOTREACHED */
1364 return (false);
1365}
|