1 /*
2 * Demangle VC++ symbols into C function prototypes
3 *
4 * Copyright 2000 Jon Griffiths
5 * 2004 Eric Pouech
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include <assert.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <stdarg.h>
26 #include <string.h>
27 #include <ctype.h>
28
29 typedef char CHAR;
30 typedef int BOOL;
31 #define TRUE (1)
32 #define FALSE (0)
33
34 typedef void* (*malloc_func_t)(size_t);
35 typedef void (*free_func_t)(void*);
36
37 /* TODO:
38 * - document a bit (grammar + functions)
39 * - back-port this new code into tools/winedump/msmangle.c
40 */
41
42 #define UNDNAME_COMPLETE (0x0000)
43 #define UNDNAME_NO_LEADING_UNDERSCORES (0x0001) /* Don't show __ in calling convention */
44 #define UNDNAME_NO_MS_KEYWORDS (0x0002) /* Don't show calling convention at all */
45 #define UNDNAME_NO_FUNCTION_RETURNS (0x0004) /* Don't show function/method return value */
46 #define UNDNAME_NO_ALLOCATION_MODEL (0x0008)
47 #define UNDNAME_NO_ALLOCATION_LANGUAGE (0x0010)
48 #define UNDNAME_NO_MS_THISTYPE (0x0020)
49 #define UNDNAME_NO_CV_THISTYPE (0x0040)
50 #define UNDNAME_NO_THISTYPE (0x0060)
51 #define UNDNAME_NO_ACCESS_SPECIFIERS (0x0080) /* Don't show access specifier (public/protected/private) */
52 #define UNDNAME_NO_THROW_SIGNATURES (0x0100)
53 #define UNDNAME_NO_MEMBER_TYPE (0x0200) /* Don't show static/virtual specifier */
54 #define UNDNAME_NO_RETURN_UDT_MODEL (0x0400)
55 #define UNDNAME_32_BIT_DECODE (0x0800)
56 #define UNDNAME_NAME_ONLY (0x1000) /* Only report the variable/method name */
57 #define UNDNAME_NO_ARGUMENTS (0x2000) /* Don't show method arguments */
58 #define UNDNAME_NO_SPECIAL_SYMS (0x4000)
59 #define UNDNAME_NO_COMPLEX_TYPE (0x8000)
60
61 /* How data types modifiers are stored:
62 * M (in the following definitions) is defined for
63 * 'A', 'B', 'C' and 'D' as follows
64 * {<A>}: ""
65 * {<B>}: "const "
66 * {<C>}: "volatile "
67 * {<D>}: "const volatile "
68 *
69 * in arguments:
70 * P<M>x {<M>}x*
71 * Q<M>x {<M>}x* const
72 * A<M>x {<M>}x&
73 * in data fields:
74 * same as for arguments and also the following
75 * ?<M>x {<M>}x
76 *
77 */
78
79 struct array
80 {
81 unsigned start; /* first valid reference in array */
82 unsigned num; /* total number of used elts */
83 unsigned max;
84 unsigned alloc;
85 char** elts;
86 };
87
88 /* Structure holding a parsed symbol */
89 struct parsed_symbol
90 {
91 unsigned flags; /* the UNDNAME_ flags used for demangling */
92 malloc_func_t mem_alloc_ptr; /* internal allocator */
93 free_func_t mem_free_ptr; /* internal deallocator */
94
95 const char* current; /* pointer in input (mangled) string */
96 char* result; /* demangled string */
97
98 struct array names; /* array of names for back reference */
99 struct array stack; /* stack of parsed strings */
100
101 void* alloc_list; /* linked list of allocated blocks */
102 unsigned avail_in_first; /* number of available bytes in head block */
103 };
104
105 /* Type for parsing mangled types */
106 struct datatype_t
107 {
108 const char* left;
109 const char* right;
110 };
111
112 static BOOL symbol_demangle(struct parsed_symbol* sym);
113
114 /******************************************************************
115 * und_alloc
116 *
117 * Internal allocator. Uses a simple linked list of large blocks
118 * where we use a poor-man allocator. It's fast, and since all
119 * allocation is pool, memory management is easy (esp. freeing).
120 */
und_alloc(struct parsed_symbol * sym,unsigned int len)121 static void* und_alloc(struct parsed_symbol* sym, unsigned int len)
122 {
123 void* ptr;
124
125 #define BLOCK_SIZE 1024
126 #define AVAIL_SIZE (1024 - sizeof(void*))
127
128 if (len > AVAIL_SIZE)
129 {
130 /* allocate a specific block */
131 ptr = sym->mem_alloc_ptr(sizeof(void*) + len);
132 if (!ptr) return NULL;
133 *(void**)ptr = sym->alloc_list;
134 sym->alloc_list = ptr;
135 sym->avail_in_first = 0;
136 ptr = (char*)sym->alloc_list + sizeof(void*);
137 }
138 else
139 {
140 if (len > sym->avail_in_first)
141 {
142 /* add a new block */
143 ptr = sym->mem_alloc_ptr(BLOCK_SIZE);
144 if (!ptr) return NULL;
145 *(void**)ptr = sym->alloc_list;
146 sym->alloc_list = ptr;
147 sym->avail_in_first = AVAIL_SIZE;
148 }
149 /* grab memory from head block */
150 ptr = (char*)sym->alloc_list + BLOCK_SIZE - sym->avail_in_first;
151 sym->avail_in_first -= len;
152 }
153 return ptr;
154 #undef BLOCK_SIZE
155 #undef AVAIL_SIZE
156 }
157
158 /******************************************************************
159 * und_free
160 * Frees all the blocks in the list of large blocks allocated by
161 * und_alloc.
162 */
und_free_all(struct parsed_symbol * sym)163 static void und_free_all(struct parsed_symbol* sym)
164 {
165 void* next;
166
167 while (sym->alloc_list)
168 {
169 next = *(void**)sym->alloc_list;
170 if(sym->mem_free_ptr) sym->mem_free_ptr(sym->alloc_list);
171 sym->alloc_list = next;
172 }
173 sym->avail_in_first = 0;
174 }
175
176 /******************************************************************
177 * str_array_init
178 * Initialises an array of strings
179 */
str_array_init(struct array * a)180 static void str_array_init(struct array* a)
181 {
182 a->start = a->num = a->max = a->alloc = 0;
183 a->elts = NULL;
184 }
185
186 /******************************************************************
187 * str_array_push
188 * Adding a new string to an array
189 */
str_array_push(struct parsed_symbol * sym,const char * ptr,int len,struct array * a)190 static BOOL str_array_push(struct parsed_symbol* sym, const char* ptr, int len,
191 struct array* a)
192 {
193 char** new_;
194
195 assert(ptr);
196 assert(a);
197
198 if (!a->alloc)
199 {
200 new_ = (char**)und_alloc(sym, (a->alloc = 32) * sizeof(a->elts[0]));
201 if (!new_) return FALSE;
202 a->elts = new_;
203 }
204 else if (a->max >= a->alloc)
205 {
206 new_ = (char**)und_alloc(sym, (a->alloc * 2) * sizeof(a->elts[0]));
207 if (!new_) return FALSE;
208 memcpy(new_, a->elts, a->alloc * sizeof(a->elts[0]));
209 a->alloc *= 2;
210 a->elts = new_;
211 }
212 if (len == -1) len = strlen(ptr);
213 a->elts[a->num] = (char*)und_alloc(sym, len + 1);
214 assert(a->elts[a->num]);
215 memcpy(a->elts[a->num], ptr, len);
216 a->elts[a->num][len] = '\0';
217 if (++a->num >= a->max) a->max = a->num;
218 {
219 int i;
220 char c;
221
222 for (i = a->max - 1; i >= 0; i--)
223 {
224 c = '>';
225 if (i < a->start) c = '-';
226 else if (i >= a->num) c = '}';
227 //TRACE("%p\t%d%c %s\n", a, i, c, a->elts[i]);
228 // Silence unused var warning when TRACE is commented out
229 (void)c;
230 }
231 }
232
233 return TRUE;
234 }
235
236 /******************************************************************
237 * str_array_get_ref
238 * Extracts a reference from an existing array (doing proper type
239 * checking)
240 */
str_array_get_ref(struct array * cref,unsigned idx)241 static char* str_array_get_ref(struct array* cref, unsigned idx)
242 {
243 if (!cref) return NULL;
244 if (cref->start + idx >= cref->max)
245 {
246 // WARN("Out of bounds: %p %d + %d >= %d\n",
247 // cref, cref->start, idx, cref->max);
248 return NULL;
249 }
250 // TRACE("Returning %p[%d] => %s\n",
251 // cref, idx, cref->elts[cref->start + idx]);
252 return cref->elts[cref->start + idx];
253 }
254
255 /******************************************************************
256 * str_printf
257 * Helper for printf type of command (only %s and %c are implemented)
258 * while dynamically allocating the buffer
259 */
str_printf(struct parsed_symbol * sym,const char * format,...)260 static char* str_printf(struct parsed_symbol* sym, const char* format, ...)
261 {
262 va_list args;
263 unsigned int len = 1, i, sz;
264 char* tmp;
265 char* p;
266 char* t;
267
268 va_start(args, format);
269 for (i = 0; format[i]; i++)
270 {
271 if (format[i] == '%')
272 {
273 switch (format[++i])
274 {
275 case 's': t = va_arg(args, char *); if (t) len += strlen(t); break;
276 case 'c': (void)va_arg(args, int); len++; break;
277 default: i--; /* fall through */
278 case '%': len++; break;
279 }
280 }
281 else len++;
282 }
283 va_end(args);
284 if (!(tmp = (char*)und_alloc(sym, len))) return NULL;
285 va_start(args, format);
286 for (p = tmp, i = 0; format[i]; i++)
287 {
288 if (format[i] == '%')
289 {
290 switch (format[++i])
291 {
292 case 's':
293 t = va_arg(args, char*);
294 if (t)
295 {
296 sz = strlen(t);
297 memcpy(p, t, sz);
298 p += sz;
299 }
300 break;
301 case 'c':
302 *p++ = (char)va_arg(args, int);
303 break;
304 default: i--; /* fall through */
305 case '%': *p++ = '%'; break;
306 }
307 }
308 else *p++ = format[i];
309 }
310 va_end(args);
311 *p = '\0';
312 return tmp;
313 }
314
315 /* forward declaration */
316 static BOOL demangle_datatype(struct parsed_symbol* sym, struct datatype_t* ct,
317 struct array* pmt, BOOL in_args);
318
get_number(struct parsed_symbol * sym)319 static const char* get_number(struct parsed_symbol* sym)
320 {
321 char* ptr;
322 BOOL sgn = FALSE;
323
324 if (*sym->current == '?')
325 {
326 sgn = TRUE;
327 sym->current++;
328 }
329 if (*sym->current >= '0' && *sym->current <= '8')
330 {
331 ptr = (char*)und_alloc(sym, 3);
332 if (sgn) ptr[0] = '-';
333 ptr[sgn ? 1 : 0] = *sym->current + 1;
334 ptr[sgn ? 2 : 1] = '\0';
335 sym->current++;
336 }
337 else if (*sym->current == '9')
338 {
339 ptr = (char*)und_alloc(sym, 4);
340 if (sgn) ptr[0] = '-';
341 ptr[sgn ? 1 : 0] = '1';
342 ptr[sgn ? 2 : 1] = '0';
343 ptr[sgn ? 3 : 2] = '\0';
344 sym->current++;
345 }
346 else if (*sym->current >= 'A' && *sym->current <= 'P')
347 {
348 int ret = 0;
349
350 while (*sym->current >= 'A' && *sym->current <= 'P')
351 {
352 ret *= 16;
353 ret += *sym->current++ - 'A';
354 }
355 if (*sym->current != '@') return NULL;
356
357 ptr = (char*)und_alloc(sym, 17);
358 sprintf(ptr, "%s%d", sgn ? "-" : "", ret);
359 sym->current++;
360 }
361 else return NULL;
362 return ptr;
363 }
364
365 /******************************************************************
366 * get_args
367 * Parses a list of function/method arguments, creates a string corresponding
368 * to the arguments' list.
369 */
get_args(struct parsed_symbol * sym,struct array * pmt_ref,BOOL z_term,char open_char,char close_char)370 static char* get_args(struct parsed_symbol* sym, struct array* pmt_ref, BOOL z_term,
371 char open_char, char close_char)
372
373 {
374 struct datatype_t ct;
375 struct array arg_collect;
376 char* args_str = NULL;
377 char* last;
378 unsigned int i;
379
380 str_array_init(&arg_collect);
381
382 /* Now come the function arguments */
383 while (*sym->current)
384 {
385 /* Decode each data type and append it to the argument list */
386 if (*sym->current == '@')
387 {
388 sym->current++;
389 break;
390 }
391 if (!demangle_datatype(sym, &ct, pmt_ref, TRUE))
392 return NULL;
393 /* 'void' terminates an argument list in a function */
394 if (z_term && !strcmp(ct.left, "void")) break;
395 if (!str_array_push(sym, str_printf(sym, "%s%s", ct.left, ct.right), -1,
396 &arg_collect))
397 return NULL;
398 if (!strcmp(ct.left, "...")) break;
399 }
400 /* Functions are always terminated by 'Z'. If we made it this far and
401 * don't find it, we have incorrectly identified a data type.
402 */
403 if (z_term && *sym->current++ != 'Z') return NULL;
404
405 if (arg_collect.num == 0 ||
406 (arg_collect.num == 1 && !strcmp(arg_collect.elts[0], "void")))
407 return str_printf(sym, "%cvoid%c", open_char, close_char);
408 for (i = 1; i < arg_collect.num; i++)
409 {
410 args_str = str_printf(sym, "%s,%s", args_str, arg_collect.elts[i]);
411 }
412
413 last = args_str ? args_str : arg_collect.elts[0];
414 if (close_char == '>' && last[strlen(last) - 1] == '>')
415 args_str = str_printf(sym, "%c%s%s %c",
416 open_char, arg_collect.elts[0], args_str, close_char);
417 else
418 args_str = str_printf(sym, "%c%s%s%c",
419 open_char, arg_collect.elts[0], args_str, close_char);
420
421 return args_str;
422 }
423
424 /******************************************************************
425 * get_modifier
426 * Parses the type modifier. Always returns static strings.
427 */
get_modifier(struct parsed_symbol * sym,const char ** ret,const char ** ptr_modif)428 static BOOL get_modifier(struct parsed_symbol *sym, const char **ret, const char **ptr_modif)
429 {
430 *ptr_modif = NULL;
431 if (*sym->current == 'E')
432 {
433 *ptr_modif = "__ptr64";
434 sym->current++;
435 }
436 switch (*sym->current++)
437 {
438 case 'A': *ret = NULL; break;
439 case 'B': *ret = "const"; break;
440 case 'C': *ret = "volatile"; break;
441 case 'D': *ret = "const volatile"; break;
442 default: return FALSE;
443 }
444 return TRUE;
445 }
446
get_modified_type(struct datatype_t * ct,struct parsed_symbol * sym,struct array * pmt_ref,char modif,BOOL in_args)447 static BOOL get_modified_type(struct datatype_t *ct, struct parsed_symbol* sym,
448 struct array *pmt_ref, char modif, BOOL in_args)
449 {
450 const char* modifier;
451 const char* str_modif;
452 const char *ptr_modif = "";
453
454 if (*sym->current == 'E')
455 {
456 ptr_modif = " __ptr64";
457 sym->current++;
458 }
459
460 switch (modif)
461 {
462 case 'A': str_modif = str_printf(sym, " &%s", ptr_modif); break;
463 case 'B': str_modif = str_printf(sym, " &%s volatile", ptr_modif); break;
464 case 'P': str_modif = str_printf(sym, " *%s", ptr_modif); break;
465 case 'Q': str_modif = str_printf(sym, " *%s const", ptr_modif); break;
466 case 'R': str_modif = str_printf(sym, " *%s volatile", ptr_modif); break;
467 case 'S': str_modif = str_printf(sym, " *%s const volatile", ptr_modif); break;
468 case '?': str_modif = ""; break;
469 default: return FALSE;
470 }
471
472 if (get_modifier(sym, &modifier, &ptr_modif))
473 {
474 unsigned mark = sym->stack.num;
475 struct datatype_t sub_ct;
476
477 /* multidimensional arrays */
478 if (*sym->current == 'Y')
479 {
480 const char* n1;
481 int num;
482
483 sym->current++;
484 if (!(n1 = get_number(sym))) return FALSE;
485 num = atoi(n1);
486
487 if (str_modif[0] == ' ' && !modifier)
488 str_modif++;
489
490 if (modifier)
491 {
492 str_modif = str_printf(sym, " (%s%s)", modifier, str_modif);
493 modifier = NULL;
494 }
495 else
496 str_modif = str_printf(sym, " (%s)", str_modif);
497
498 while (num--)
499 str_modif = str_printf(sym, "%s[%s]", str_modif, get_number(sym));
500 }
501
502 /* Recurse to get the referred-to type */
503 if (!demangle_datatype(sym, &sub_ct, pmt_ref, FALSE))
504 return FALSE;
505 if (modifier)
506 ct->left = str_printf(sym, "%s %s%s", sub_ct.left, modifier, str_modif );
507 else
508 {
509 /* don't insert a space between duplicate '*' */
510 if (!in_args && str_modif[0] && str_modif[1] == '*' && sub_ct.left[strlen(sub_ct.left)-1] == '*')
511 str_modif++;
512 ct->left = str_printf(sym, "%s%s", sub_ct.left, str_modif );
513 }
514 ct->right = sub_ct.right;
515 sym->stack.num = mark;
516 }
517 return TRUE;
518 }
519
520 /******************************************************************
521 * get_literal_string
522 * Gets the literal name from the current position in the mangled
523 * symbol to the first '@' character. It pushes the parsed name to
524 * the symbol names stack and returns a pointer to it or NULL in
525 * case of an error.
526 */
get_literal_string(struct parsed_symbol * sym)527 static char* get_literal_string(struct parsed_symbol* sym)
528 {
529 const char *ptr = sym->current;
530
531 do {
532 if (!((*sym->current >= 'A' && *sym->current <= 'Z') ||
533 (*sym->current >= 'a' && *sym->current <= 'z') ||
534 (*sym->current >= '0' && *sym->current <= '9') ||
535 *sym->current == '_' || *sym->current == '$')) {
536 //TRACE("Failed at '%c' in %s\n", *sym->current, ptr);
537 return NULL;
538 }
539 } while (*++sym->current != '@');
540 sym->current++;
541 if (!str_array_push(sym, ptr, sym->current - 1 - ptr, &sym->names))
542 return NULL;
543
544 return str_array_get_ref(&sym->names, sym->names.num - sym->names.start - 1);
545 }
546
547 /******************************************************************
548 * get_template_name
549 * Parses a name with a template argument list and returns it as
550 * a string.
551 * In a template argument list the back reference to the names
552 * table is separately created. '0' points to the class component
553 * name with the template arguments. We use the same stack array
554 * to hold the names but save/restore the stack state before/after
555 * parsing the template argument list.
556 */
get_template_name(struct parsed_symbol * sym)557 static char* get_template_name(struct parsed_symbol* sym)
558 {
559 char *name, *args;
560 unsigned num_mark = sym->names.num;
561 unsigned start_mark = sym->names.start;
562 unsigned stack_mark = sym->stack.num;
563 struct array array_pmt;
564
565 sym->names.start = sym->names.num;
566 if (!(name = get_literal_string(sym)))
567 return FALSE;
568 str_array_init(&array_pmt);
569 args = get_args(sym, &array_pmt, FALSE, '<', '>');
570 if (args != NULL)
571 name = str_printf(sym, "%s%s", name, args);
572 sym->names.num = num_mark;
573 sym->names.start = start_mark;
574 sym->stack.num = stack_mark;
575 return name;
576 }
577
578 /******************************************************************
579 * get_class
580 * Parses class as a list of parent-classes, terminated by '@' and stores the
581 * result in 'a' array. Each parent-classes, as well as the inner element
582 * (either field/method name or class name), are represented in the mangled
583 * name by a literal name ([a-zA-Z0-9_]+ terminated by '@') or a back reference
584 * ([0-9]) or a name with template arguments ('?$' literal name followed by the
585 * template argument list). The class name components appear in the reverse
586 * order in the mangled name, e.g aaa@bbb@ccc@@ will be demangled to
587 * ccc::bbb::aaa
588 * For each of these class name components a string will be allocated in the
589 * array.
590 */
get_class(struct parsed_symbol * sym)591 static BOOL get_class(struct parsed_symbol* sym)
592 {
593 const char* name = NULL;
594
595 while (*sym->current != '@')
596 {
597 switch (*sym->current)
598 {
599 case '\0': return FALSE;
600
601 case '0': case '1': case '2': case '3':
602 case '4': case '5': case '6': case '7':
603 case '8': case '9':
604 name = str_array_get_ref(&sym->names, *sym->current++ - '0');
605 break;
606 case '?':
607 switch (*++sym->current)
608 {
609 case '$':
610 sym->current++;
611 if ((name = get_template_name(sym)) &&
612 !str_array_push(sym, name, -1, &sym->names))
613 return FALSE;
614 break;
615 case '?':
616 {
617 struct array stack = sym->stack;
618 unsigned int start = sym->names.start;
619 unsigned int num = sym->names.num;
620
621 str_array_init( &sym->stack );
622 if (symbol_demangle( sym )) name = str_printf( sym, "`%s'", sym->result );
623 sym->names.start = start;
624 sym->names.num = num;
625 sym->stack = stack;
626 }
627 break;
628 default:
629 if (!(name = get_number( sym ))) return FALSE;
630 name = str_printf( sym, "`%s'", name );
631 break;
632 }
633 break;
634 default:
635 name = get_literal_string(sym);
636 break;
637 }
638 if (!name || !str_array_push(sym, name, -1, &sym->stack))
639 return FALSE;
640 }
641 sym->current++;
642 return TRUE;
643 }
644
645 /******************************************************************
646 * get_class_string
647 * From an array collected by get_class in sym->stack, constructs the
648 * corresponding (allocated) string
649 */
get_class_string(struct parsed_symbol * sym,int start)650 static char* get_class_string(struct parsed_symbol* sym, int start)
651 {
652 int i;
653 unsigned int len, sz;
654 char* ret;
655 struct array *a = &sym->stack;
656
657 for (len = 0, i = start; i < a->num; i++)
658 {
659 assert(a->elts[i]);
660 len += 2 + strlen(a->elts[i]);
661 }
662 if (!(ret = (char*)und_alloc(sym, len - 1))) return NULL;
663 for (len = 0, i = a->num - 1; i >= start; i--)
664 {
665 sz = strlen(a->elts[i]);
666 memcpy(ret + len, a->elts[i], sz);
667 len += sz;
668 if (i > start)
669 {
670 ret[len++] = ':';
671 ret[len++] = ':';
672 }
673 }
674 ret[len] = '\0';
675 return ret;
676 }
677
678 /******************************************************************
679 * get_class_name
680 * Wrapper around get_class and get_class_string.
681 */
get_class_name(struct parsed_symbol * sym)682 static char* get_class_name(struct parsed_symbol* sym)
683 {
684 unsigned mark = sym->stack.num;
685 char* s = NULL;
686
687 if (get_class(sym))
688 s = get_class_string(sym, mark);
689 sym->stack.num = mark;
690 return s;
691 }
692
693 /******************************************************************
694 * get_calling_convention
695 * Returns a static string corresponding to the calling convention described
696 * by char 'ch'. Sets export to TRUE iff the calling convention is exported.
697 */
get_calling_convention(char ch,const char ** call_conv,const char ** exported,unsigned flags)698 static BOOL get_calling_convention(char ch, const char** call_conv,
699 const char** exported, unsigned flags)
700 {
701 *call_conv = *exported = NULL;
702
703 if (!(flags & (UNDNAME_NO_MS_KEYWORDS | UNDNAME_NO_ALLOCATION_LANGUAGE)))
704 {
705 if (flags & UNDNAME_NO_LEADING_UNDERSCORES)
706 {
707 if (((ch - 'A') % 2) == 1) *exported = "dll_export ";
708 switch (ch)
709 {
710 case 'A': case 'B': *call_conv = "cdecl"; break;
711 case 'C': case 'D': *call_conv = "pascal"; break;
712 case 'E': case 'F': *call_conv = "thiscall"; break;
713 case 'G': case 'H': *call_conv = "stdcall"; break;
714 case 'I': case 'J': *call_conv = "fastcall"; break;
715 case 'K': case 'L': break;
716 case 'M': *call_conv = "clrcall"; break;
717 default: printf("Unknown calling convention %c\n", ch); return FALSE;
718 }
719 }
720 else
721 {
722 if (((ch - 'A') % 2) == 1) *exported = "__dll_export ";
723 switch (ch)
724 {
725 case 'A': case 'B': *call_conv = "__cdecl"; break;
726 case 'C': case 'D': *call_conv = "__pascal"; break;
727 case 'E': case 'F': *call_conv = "__thiscall"; break;
728 case 'G': case 'H': *call_conv = "__stdcall"; break;
729 case 'I': case 'J': *call_conv = "__fastcall"; break;
730 case 'K': case 'L': break;
731 case 'M': *call_conv = "__clrcall"; break;
732 default: printf("Unknown calling convention %c\n", ch); return FALSE;
733 }
734 }
735 }
736 return TRUE;
737 }
738
739 /*******************************************************************
740 * get_simple_type
741 * Return a string containing an allocated string for a simple data type
742 */
get_simple_type(char c)743 static const char* get_simple_type(char c)
744 {
745 const char* type_string;
746
747 switch (c)
748 {
749 case 'C': type_string = "signed char"; break;
750 case 'D': type_string = "char"; break;
751 case 'E': type_string = "unsigned char"; break;
752 case 'F': type_string = "short"; break;
753 case 'G': type_string = "unsigned short"; break;
754 case 'H': type_string = "int"; break;
755 case 'I': type_string = "unsigned int"; break;
756 case 'J': type_string = "long"; break;
757 case 'K': type_string = "unsigned long"; break;
758 case 'M': type_string = "float"; break;
759 case 'N': type_string = "double"; break;
760 case 'O': type_string = "long double"; break;
761 case 'X': type_string = "void"; break;
762 case 'Z': type_string = "..."; break;
763 default: type_string = NULL; break;
764 }
765 return type_string;
766 }
767
768 /*******************************************************************
769 * get_extended_type
770 * Return a string containing an allocated string for a simple data type
771 */
get_extended_type(char c)772 static const char* get_extended_type(char c)
773 {
774 const char* type_string;
775
776 switch (c)
777 {
778 case 'D': type_string = "__int8"; break;
779 case 'E': type_string = "unsigned __int8"; break;
780 case 'F': type_string = "__int16"; break;
781 case 'G': type_string = "unsigned __int16"; break;
782 case 'H': type_string = "__int32"; break;
783 case 'I': type_string = "unsigned __int32"; break;
784 case 'J': type_string = "__int64"; break;
785 case 'K': type_string = "unsigned __int64"; break;
786 case 'L': type_string = "__int128"; break;
787 case 'M': type_string = "unsigned __int128"; break;
788 case 'N': type_string = "bool"; break;
789 case 'W': type_string = "wchar_t"; break;
790 default: type_string = NULL; break;
791 }
792 return type_string;
793 }
794
795 /*******************************************************************
796 * demangle_datatype
797 *
798 * Attempt to demangle a C++ data type, which may be datatype.
799 * a datatype type is made up of a number of simple types. e.g:
800 * char** = (pointer to (pointer to (char)))
801 */
demangle_datatype(struct parsed_symbol * sym,struct datatype_t * ct,struct array * pmt_ref,BOOL in_args)802 static BOOL demangle_datatype(struct parsed_symbol* sym, struct datatype_t* ct,
803 struct array* pmt_ref, BOOL in_args)
804 {
805 char dt;
806 BOOL add_pmt = TRUE;
807
808 assert(ct);
809 ct->left = ct->right = NULL;
810
811 switch (dt = *sym->current++)
812 {
813 case '_':
814 /* MS type: __int8,__int16 etc */
815 ct->left = get_extended_type(*sym->current++);
816 break;
817 case 'C': case 'D': case 'E': case 'F': case 'G':
818 case 'H': case 'I': case 'J': case 'K': case 'M':
819 case 'N': case 'O': case 'X': case 'Z':
820 /* Simple data types */
821 ct->left = get_simple_type(dt);
822 add_pmt = FALSE;
823 break;
824 case 'T': /* union */
825 case 'U': /* struct */
826 case 'V': /* class */
827 case 'Y': /* cointerface */
828 /* Class/struct/union/cointerface */
829 {
830 const char* struct_name = NULL;
831 const char* type_name = NULL;
832
833 if (!(struct_name = get_class_name(sym)))
834 goto done;
835 if (!(sym->flags & UNDNAME_NO_COMPLEX_TYPE))
836 {
837 switch (dt)
838 {
839 case 'T': type_name = "union "; break;
840 case 'U': type_name = "struct "; break;
841 case 'V': type_name = "class "; break;
842 case 'Y': type_name = "cointerface "; break;
843 }
844 }
845 ct->left = str_printf(sym, "%s%s", type_name, struct_name);
846 }
847 break;
848 case '?':
849 /* not all the time is seems */
850 if (in_args)
851 {
852 const char* ptr;
853 if (!(ptr = get_number(sym))) goto done;
854 ct->left = str_printf(sym, "`template-parameter-%s'", ptr);
855 }
856 else
857 {
858 if (!get_modified_type(ct, sym, pmt_ref, '?', in_args)) goto done;
859 }
860 break;
861 case 'A': /* reference */
862 case 'B': /* volatile reference */
863 if (!get_modified_type(ct, sym, pmt_ref, dt, in_args)) goto done;
864 break;
865 case 'Q': /* const pointer */
866 case 'R': /* volatile pointer */
867 case 'S': /* const volatile pointer */
868 if (!get_modified_type(ct, sym, pmt_ref, in_args ? dt : 'P', in_args)) goto done;
869 break;
870 case 'P': /* Pointer */
871 if (isdigit(*sym->current))
872 {
873 /* FIXME: P6 = Function pointer, others who knows.. */
874 if (*sym->current++ == '6')
875 {
876 char* args = NULL;
877 const char* call_conv;
878 const char* exported;
879 struct datatype_t sub_ct;
880 unsigned mark = sym->stack.num;
881
882 if (!get_calling_convention(*sym->current++,
883 &call_conv, &exported,
884 sym->flags & ~UNDNAME_NO_ALLOCATION_LANGUAGE) ||
885 !demangle_datatype(sym, &sub_ct, pmt_ref, FALSE))
886 goto done;
887
888 args = get_args(sym, pmt_ref, TRUE, '(', ')');
889 if (!args) goto done;
890 sym->stack.num = mark;
891
892 ct->left = str_printf(sym, "%s%s (%s*",
893 sub_ct.left, sub_ct.right, call_conv);
894 ct->right = str_printf(sym, ")%s", args);
895 }
896 else goto done;
897 }
898 else if (!get_modified_type(ct, sym, pmt_ref, 'P', in_args)) goto done;
899 break;
900 case 'W':
901 if (*sym->current == '4')
902 {
903 char* enum_name;
904 sym->current++;
905 if (!(enum_name = get_class_name(sym)))
906 goto done;
907 if (sym->flags & UNDNAME_NO_COMPLEX_TYPE)
908 ct->left = enum_name;
909 else
910 ct->left = str_printf(sym, "enum %s", enum_name);
911 }
912 else goto done;
913 break;
914 case '0': case '1': case '2': case '3': case '4':
915 case '5': case '6': case '7': case '8': case '9':
916 /* Referring back to previously parsed type */
917 /* left and right are pushed as two separate strings */
918 ct->left = str_array_get_ref(pmt_ref, (dt - '0') * 2);
919 ct->right = str_array_get_ref(pmt_ref, (dt - '0') * 2 + 1);
920 if (!ct->left) goto done;
921 add_pmt = FALSE;
922 break;
923 case '$':
924 switch (*sym->current++)
925 {
926 case '0':
927 if (!(ct->left = get_number(sym))) goto done;
928 break;
929 case 'D':
930 {
931 const char* ptr;
932 if (!(ptr = get_number(sym))) goto done;
933 ct->left = str_printf(sym, "`template-parameter%s'", ptr);
934 }
935 break;
936 case 'F':
937 {
938 const char* p1;
939 const char* p2;
940 if (!(p1 = get_number(sym))) goto done;
941 if (!(p2 = get_number(sym))) goto done;
942 ct->left = str_printf(sym, "{%s,%s}", p1, p2);
943 }
944 break;
945 case 'G':
946 {
947 const char* p1;
948 const char* p2;
949 const char* p3;
950 if (!(p1 = get_number(sym))) goto done;
951 if (!(p2 = get_number(sym))) goto done;
952 if (!(p3 = get_number(sym))) goto done;
953 ct->left = str_printf(sym, "{%s,%s,%s}", p1, p2, p3);
954 }
955 break;
956 case 'Q':
957 {
958 const char* ptr;
959 if (!(ptr = get_number(sym))) goto done;
960 ct->left = str_printf(sym, "`non-type-template-parameter%s'", ptr);
961 }
962 break;
963 case '$':
964 if (*sym->current == 'C')
965 {
966 const char *ptr, *ptr_modif;
967
968 sym->current++;
969 if (!get_modifier(sym, &ptr, &ptr_modif)) goto done;
970 if (!demangle_datatype(sym, ct, pmt_ref, in_args)) goto done;
971 ct->left = str_printf(sym, "%s %s", ct->left, ptr);
972 }
973 break;
974 }
975 break;
976 default :
977 printf("Unknown type %c\n", dt);
978 break;
979 }
980 if (add_pmt && pmt_ref && in_args)
981 {
982 /* left and right are pushed as two separate strings */
983 if (!str_array_push(sym, ct->left ? ct->left : "", -1, pmt_ref) ||
984 !str_array_push(sym, ct->right ? ct->right : "", -1, pmt_ref))
985 return FALSE;
986 }
987 done:
988
989 return ct->left != NULL;
990 }
991
992 /******************************************************************
993 * handle_data
994 * Does the final parsing and handling for a variable or a field in
995 * a class.
996 */
handle_data(struct parsed_symbol * sym)997 static BOOL handle_data(struct parsed_symbol* sym)
998 {
999 const char* access = NULL;
1000 const char* member_type = NULL;
1001 const char* modifier = NULL;
1002 const char* ptr_modif;
1003 struct datatype_t ct;
1004 char* name = NULL;
1005 BOOL ret = FALSE;
1006
1007 /* 0 private static
1008 * 1 protected static
1009 * 2 public static
1010 * 3 private non-static
1011 * 4 protected non-static
1012 * 5 public non-static
1013 * 6 ?? static
1014 * 7 ?? static
1015 */
1016
1017 if (!(sym->flags & UNDNAME_NO_ACCESS_SPECIFIERS))
1018 {
1019 /* we only print the access for static members */
1020 switch (*sym->current)
1021 {
1022 case '0': access = "private: "; break;
1023 case '1': access = "protected: "; break;
1024 case '2': access = "public: "; break;
1025 }
1026 }
1027
1028 if (!(sym->flags & UNDNAME_NO_MEMBER_TYPE))
1029 {
1030 if (*sym->current >= '0' && *sym->current <= '2')
1031 member_type = "static ";
1032 }
1033
1034 name = get_class_string(sym, 0);
1035
1036 switch (*sym->current++)
1037 {
1038 case '0': case '1': case '2':
1039 case '3': case '4': case '5':
1040 {
1041 unsigned mark = sym->stack.num;
1042 struct array pmt;
1043
1044 str_array_init(&pmt);
1045
1046 if (!demangle_datatype(sym, &ct, &pmt, FALSE)) goto done;
1047 if (!get_modifier(sym, &modifier, &ptr_modif)) goto done;
1048 if (modifier && ptr_modif) modifier = str_printf(sym, "%s %s", modifier, ptr_modif);
1049 else if (!modifier) modifier = ptr_modif;
1050 sym->stack.num = mark;
1051 }
1052 break;
1053 case '6' : /* compiler generated static */
1054 case '7' : /* compiler generated static */
1055 ct.left = ct.right = NULL;
1056 if (!get_modifier(sym, &modifier, &ptr_modif)) goto done;
1057 if (*sym->current != '@')
1058 {
1059 char* cls = NULL;
1060
1061 if (!(cls = get_class_name(sym)))
1062 goto done;
1063 ct.right = str_printf(sym, "{for `%s'}", cls);
1064 }
1065 break;
1066 case '8':
1067 case '9':
1068 modifier = ct.left = ct.right = NULL;
1069 break;
1070 default: goto done;
1071 }
1072 if (sym->flags & UNDNAME_NAME_ONLY) ct.left = ct.right = modifier = NULL;
1073
1074 sym->result = str_printf(sym, "%s%s%s%s%s%s%s%s", access,
1075 member_type, ct.left,
1076 modifier && ct.left ? " " : NULL, modifier,
1077 modifier || ct.left ? " " : NULL, name, ct.right);
1078 ret = TRUE;
1079 done:
1080 return ret;
1081 }
1082
1083 /******************************************************************
1084 * handle_method
1085 * Does the final parsing and handling for a function or a method in
1086 * a class.
1087 */
handle_method(struct parsed_symbol * sym,BOOL cast_op)1088 static BOOL handle_method(struct parsed_symbol* sym, BOOL cast_op)
1089 {
1090 char accmem;
1091 const char* access = NULL;
1092 const char* member_type = NULL;
1093 struct datatype_t ct_ret;
1094 const char* call_conv;
1095 const char* modifier = NULL;
1096 const char* exported;
1097 const char* args_str = NULL;
1098 const char* name = NULL;
1099 BOOL ret = FALSE;
1100 unsigned mark;
1101 struct array array_pmt;
1102
1103 /* FIXME: why 2 possible letters for each option?
1104 * 'A' private:
1105 * 'B' private:
1106 * 'C' private: static
1107 * 'D' private: static
1108 * 'E' private: virtual
1109 * 'F' private: virtual
1110 * 'G' private: thunk
1111 * 'H' private: thunk
1112 * 'I' protected:
1113 * 'J' protected:
1114 * 'K' protected: static
1115 * 'L' protected: static
1116 * 'M' protected: virtual
1117 * 'N' protected: virtual
1118 * 'O' protected: thunk
1119 * 'P' protected: thunk
1120 * 'Q' public:
1121 * 'R' public:
1122 * 'S' public: static
1123 * 'T' public: static
1124 * 'U' public: virtual
1125 * 'V' public: virtual
1126 * 'W' public: thunk
1127 * 'X' public: thunk
1128 * 'Y'
1129 * 'Z'
1130 */
1131 accmem = *sym->current++;
1132 if (accmem < 'A' || accmem > 'Z') goto done;
1133
1134 if (!(sym->flags & UNDNAME_NO_ACCESS_SPECIFIERS))
1135 {
1136 switch ((accmem - 'A') / 8)
1137 {
1138 case 0: access = "private: "; break;
1139 case 1: access = "protected: "; break;
1140 case 2: access = "public: "; break;
1141 }
1142 }
1143 if (!(sym->flags & UNDNAME_NO_MEMBER_TYPE))
1144 {
1145 if (accmem <= 'X')
1146 {
1147 switch ((accmem - 'A') % 8)
1148 {
1149 case 2: case 3: member_type = "static "; break;
1150 case 4: case 5: member_type = "virtual "; break;
1151 case 6: case 7:
1152 access = str_printf(sym, "[thunk]:%s", access);
1153 member_type = "virtual ";
1154 break;
1155 }
1156 }
1157 }
1158
1159 name = get_class_string(sym, 0);
1160
1161 if ((accmem - 'A') % 8 == 6 || (accmem - '8') % 8 == 7) /* a thunk */
1162 name = str_printf(sym, "%s`adjustor{%s}' ", name, get_number(sym));
1163
1164 if (accmem <= 'X')
1165 {
1166 if (((accmem - 'A') % 8) != 2 && ((accmem - 'A') % 8) != 3)
1167 {
1168 const char *ptr_modif;
1169 /* Implicit 'this' pointer */
1170 /* If there is an implicit this pointer, const modifier follows */
1171 if (!get_modifier(sym, &modifier, &ptr_modif)) goto done;
1172 if (modifier || ptr_modif) modifier = str_printf(sym, "%s %s", modifier, ptr_modif);
1173 }
1174 }
1175
1176 if (!get_calling_convention(*sym->current++, &call_conv, &exported,
1177 sym->flags))
1178 goto done;
1179
1180 str_array_init(&array_pmt);
1181
1182 /* Return type, or @ if 'void' */
1183 if (*sym->current == '@')
1184 {
1185 ct_ret.left = "void";
1186 ct_ret.right = NULL;
1187 sym->current++;
1188 }
1189 else
1190 {
1191 if (!demangle_datatype(sym, &ct_ret, &array_pmt, FALSE))
1192 goto done;
1193 }
1194 if (sym->flags & UNDNAME_NO_FUNCTION_RETURNS)
1195 ct_ret.left = ct_ret.right = NULL;
1196 if (cast_op)
1197 {
1198 name = str_printf(sym, "%s%s%s", name, ct_ret.left, ct_ret.right);
1199 ct_ret.left = ct_ret.right = NULL;
1200 }
1201
1202 mark = sym->stack.num;
1203 if (!(args_str = get_args(sym, &array_pmt, TRUE, '(', ')'))) goto done;
1204 if (sym->flags & UNDNAME_NAME_ONLY) args_str = modifier = NULL;
1205 sym->stack.num = mark;
1206
1207 /* Note: '()' after 'Z' means 'throws', but we don't care here
1208 * Yet!!! FIXME
1209 */
1210 sym->result = str_printf(sym, "%s%s%s%s%s%s%s%s%s%s%s",
1211 access, member_type, ct_ret.left,
1212 (ct_ret.left && !ct_ret.right) ? " " : NULL,
1213 call_conv, call_conv ? " " : NULL, exported,
1214 name, args_str, modifier, ct_ret.right);
1215 ret = TRUE;
1216 done:
1217 return ret;
1218 }
1219
1220 /******************************************************************
1221 * handle_template
1222 * Does the final parsing and handling for a name with templates
1223 */
handle_template(struct parsed_symbol * sym)1224 static BOOL handle_template(struct parsed_symbol* sym)
1225 {
1226 const char* name;
1227 const char* args;
1228
1229 assert(*sym->current == '$');
1230 sym->current++;
1231 if (!(name = get_literal_string(sym))) return FALSE;
1232 if (!(args = get_args(sym, NULL, FALSE, '<', '>'))) return FALSE;
1233 sym->result = str_printf(sym, "%s%s", name, args);
1234 return TRUE;
1235 }
1236
1237 /*******************************************************************
1238 * symbol_demangle
1239 * Demangle a C++ linker symbol
1240 */
symbol_demangle(struct parsed_symbol * sym)1241 static BOOL symbol_demangle(struct parsed_symbol* sym)
1242 {
1243 BOOL ret = FALSE;
1244 unsigned do_after = 0;
1245 static CHAR dashed_null[] = "--null--";
1246
1247 /* FIXME seems wrong as name, as it demangles a simple data type */
1248 if (sym->flags & UNDNAME_NO_ARGUMENTS)
1249 {
1250 struct datatype_t ct;
1251
1252 if (demangle_datatype(sym, &ct, NULL, FALSE))
1253 {
1254 sym->result = str_printf(sym, "%s%s", ct.left, ct.right);
1255 ret = TRUE;
1256 }
1257 goto done;
1258 }
1259
1260 /* MS mangled names always begin with '?' */
1261 if (*sym->current != '?') return FALSE;
1262 sym->current++;
1263
1264 /* Then function name or operator code */
1265 if (*sym->current == '?' && (sym->current[1] != '$' || sym->current[2] == '?'))
1266 {
1267 const char* function_name = NULL;
1268
1269 if (sym->current[1] == '$')
1270 {
1271 do_after = 6;
1272 sym->current += 2;
1273 }
1274
1275 /* C++ operator code (one character, or two if the first is '_') */
1276 switch (*++sym->current)
1277 {
1278 case '0': do_after = 1; break;
1279 case '1': do_after = 2; break;
1280 case '2': function_name = "operator new"; break;
1281 case '3': function_name = "operator delete"; break;
1282 case '4': function_name = "operator="; break;
1283 case '5': function_name = "operator>>"; break;
1284 case '6': function_name = "operator<<"; break;
1285 case '7': function_name = "operator!"; break;
1286 case '8': function_name = "operator=="; break;
1287 case '9': function_name = "operator!="; break;
1288 case 'A': function_name = "operator[]"; break;
1289 case 'B': function_name = "operator "; do_after = 3; break;
1290 case 'C': function_name = "operator->"; break;
1291 case 'D': function_name = "operator*"; break;
1292 case 'E': function_name = "operator++"; break;
1293 case 'F': function_name = "operator--"; break;
1294 case 'G': function_name = "operator-"; break;
1295 case 'H': function_name = "operator+"; break;
1296 case 'I': function_name = "operator&"; break;
1297 case 'J': function_name = "operator->*"; break;
1298 case 'K': function_name = "operator/"; break;
1299 case 'L': function_name = "operator%"; break;
1300 case 'M': function_name = "operator<"; break;
1301 case 'N': function_name = "operator<="; break;
1302 case 'O': function_name = "operator>"; break;
1303 case 'P': function_name = "operator>="; break;
1304 case 'Q': function_name = "operator,"; break;
1305 case 'R': function_name = "operator()"; break;
1306 case 'S': function_name = "operator~"; break;
1307 case 'T': function_name = "operator^"; break;
1308 case 'U': function_name = "operator|"; break;
1309 case 'V': function_name = "operator&&"; break;
1310 case 'W': function_name = "operator||"; break;
1311 case 'X': function_name = "operator*="; break;
1312 case 'Y': function_name = "operator+="; break;
1313 case 'Z': function_name = "operator-="; break;
1314 case '_':
1315 switch (*++sym->current)
1316 {
1317 case '0': function_name = "operator/="; break;
1318 case '1': function_name = "operator%="; break;
1319 case '2': function_name = "operator>>="; break;
1320 case '3': function_name = "operator<<="; break;
1321 case '4': function_name = "operator&="; break;
1322 case '5': function_name = "operator|="; break;
1323 case '6': function_name = "operator^="; break;
1324 case '7': function_name = "`vftable'"; break;
1325 case '8': function_name = "`vbtable'"; break;
1326 case '9': function_name = "`vcall'"; break;
1327 case 'A': function_name = "`typeof'"; break;
1328 case 'B': function_name = "`local static guard'"; break;
1329 case 'C': function_name = "`string'"; do_after = 4; break;
1330 case 'D': function_name = "`vbase destructor'"; break;
1331 case 'E': function_name = "`vector deleting destructor'"; break;
1332 case 'F': function_name = "`default constructor closure'"; break;
1333 case 'G': function_name = "`scalar deleting destructor'"; break;
1334 case 'H': function_name = "`vector constructor iterator'"; break;
1335 case 'I': function_name = "`vector destructor iterator'"; break;
1336 case 'J': function_name = "`vector vbase constructor iterator'"; break;
1337 case 'K': function_name = "`virtual displacement map'"; break;
1338 case 'L': function_name = "`eh vector constructor iterator'"; break;
1339 case 'M': function_name = "`eh vector destructor iterator'"; break;
1340 case 'N': function_name = "`eh vector vbase constructor iterator'"; break;
1341 case 'O': function_name = "`copy constructor closure'"; break;
1342 case 'R':
1343 sym->flags |= UNDNAME_NO_FUNCTION_RETURNS;
1344 switch (*++sym->current)
1345 {
1346 case '0':
1347 {
1348 struct datatype_t ct;
1349 struct array pmt;
1350
1351 sym->current++;
1352 str_array_init(&pmt);
1353 demangle_datatype(sym, &ct, &pmt, FALSE);
1354 function_name = str_printf(sym, "%s%s `RTTI Type Descriptor'",
1355 ct.left, ct.right);
1356 sym->current--;
1357 }
1358 break;
1359 case '1':
1360 {
1361 const char* n1, *n2, *n3, *n4;
1362 sym->current++;
1363 n1 = get_number(sym);
1364 n2 = get_number(sym);
1365 n3 = get_number(sym);
1366 n4 = get_number(sym);
1367 sym->current--;
1368 function_name = str_printf(sym, "`RTTI Base Class Descriptor at (%s,%s,%s,%s)'",
1369 n1, n2, n3, n4);
1370 }
1371 break;
1372 case '2': function_name = "`RTTI Base Class Array'"; break;
1373 case '3': function_name = "`RTTI Class Hierarchy Descriptor'"; break;
1374 case '4': function_name = "`RTTI Complete Object Locator'"; break;
1375 default:
1376 printf("Unknown RTTI operator: _R%c\n", *sym->current);
1377 break;
1378 }
1379 break;
1380 case 'S': function_name = "`local vftable'"; break;
1381 case 'T': function_name = "`local vftable constructor closure'"; break;
1382 case 'U': function_name = "operator new[]"; break;
1383 case 'V': function_name = "operator delete[]"; break;
1384 case 'X': function_name = "`placement delete closure'"; break;
1385 case 'Y': function_name = "`placement delete[] closure'"; break;
1386 default:
1387 printf("Unknown operator: _%c\n", *sym->current);
1388 return FALSE;
1389 }
1390 break;
1391 default:
1392 /* FIXME: Other operators */
1393 printf("Unknown operator: %c\n", *sym->current);
1394 return FALSE;
1395 }
1396 sym->current++;
1397 switch (do_after)
1398 {
1399 case 1: case 2:
1400 if (!str_array_push(sym, dashed_null, -1, &sym->stack))
1401 return FALSE;
1402 break;
1403 case 4:
1404 sym->result = (char*)function_name;
1405 ret = TRUE;
1406 goto done;
1407 case 6:
1408 {
1409 char *args;
1410 struct array array_pmt;
1411
1412 str_array_init(&array_pmt);
1413 args = get_args(sym, &array_pmt, FALSE, '<', '>');
1414 if (args != NULL) function_name = str_printf(sym, "%s%s", function_name, args);
1415 sym->names.num = 0;
1416 }
1417 /* fall through */
1418 default:
1419 if (!str_array_push(sym, function_name, -1, &sym->stack))
1420 return FALSE;
1421 break;
1422 }
1423 }
1424 else if (*sym->current == '$')
1425 {
1426 /* Strange construct, it's a name with a template argument list
1427 and that's all. */
1428 sym->current++;
1429 ret = (sym->result = get_template_name(sym)) != NULL;
1430 goto done;
1431 }
1432 else if (*sym->current == '?' && sym->current[1] == '$')
1433 do_after = 5;
1434
1435 /* Either a class name, or '@' if the symbol is not a class member */
1436 switch (*sym->current)
1437 {
1438 case '@': sym->current++; break;
1439 case '$': break;
1440 default:
1441 /* Class the function is associated with, terminated by '@@' */
1442 if (!get_class(sym)) goto done;
1443 break;
1444 }
1445
1446 switch (do_after)
1447 {
1448 case 0: default: break;
1449 case 1: case 2:
1450 /* it's time to set the member name for ctor & dtor */
1451 if (sym->stack.num <= 1) goto done;
1452 if (do_after == 1)
1453 sym->stack.elts[0] = sym->stack.elts[1];
1454 else
1455 sym->stack.elts[0] = str_printf(sym, "~%s", sym->stack.elts[1]);
1456 /* ctors and dtors don't have return type */
1457 sym->flags |= UNDNAME_NO_FUNCTION_RETURNS;
1458 break;
1459 case 3:
1460 sym->flags &= ~UNDNAME_NO_FUNCTION_RETURNS;
1461 break;
1462 case 5:
1463 sym->names.start++;
1464 break;
1465 }
1466
1467 /* Function/Data type and access level */
1468 if (*sym->current >= '0' && *sym->current <= '9')
1469 ret = handle_data(sym);
1470 else if (*sym->current >= 'A' && *sym->current <= 'Z')
1471 ret = handle_method(sym, do_after == 3);
1472 else if (*sym->current == '$')
1473 ret = handle_template(sym);
1474 else ret = FALSE;
1475 done:
1476 if (ret) assert(sym->result);
1477 // else WARN("Failed at %s\n", sym->current);
1478
1479 return ret;
1480 }
1481
1482 /*********************************************************************
1483 * __unDNameEx (MSVCRT.@)
1484 *
1485 * Demangle a C++ identifier.
1486 *
1487 * PARAMS
1488 * buffer [O] If not NULL, the place to put the demangled string
1489 * mangled [I] Mangled name of the function
1490 * buflen [I] Length of buffer
1491 * memget [I] Function to allocate memory with
1492 * memfree [I] Function to free memory with
1493 * unknown [?] Unknown, possibly a call back
1494 * flags [I] Flags determining demangled format
1495 *
1496 * RETURNS
1497 * Success: A string pointing to the unmangled name, allocated with memget.
1498 * Failure: NULL.
1499 */
__unDNameEx(char * buffer,const char * mangled,int buflen,malloc_func_t memget,free_func_t memfree,void * unknown,unsigned short int flags)1500 char * __unDNameEx(char* buffer, const char* mangled, int buflen,
1501 malloc_func_t memget, free_func_t memfree,
1502 void* unknown, unsigned short int flags)
1503 {
1504 struct parsed_symbol sym;
1505 const char* result;
1506
1507 //TRACE("(%p,%s,%d,%p,%p,%p,%x)\n",
1508 // buffer, mangled, buflen, memget, memfree, unknown, flags);
1509
1510 /* The flags details is not documented by MS. However, it looks exactly
1511 * like the UNDNAME_ manifest constants from imagehlp.h and dbghelp.h
1512 * So, we copied those (on top of the file)
1513 */
1514 memset(&sym, 0, sizeof(struct parsed_symbol));
1515 if (flags & UNDNAME_NAME_ONLY)
1516 flags |= UNDNAME_NO_FUNCTION_RETURNS | UNDNAME_NO_ACCESS_SPECIFIERS |
1517 UNDNAME_NO_MEMBER_TYPE | UNDNAME_NO_ALLOCATION_LANGUAGE |
1518 UNDNAME_NO_COMPLEX_TYPE;
1519
1520 sym.flags = flags;
1521 sym.mem_alloc_ptr = memget;
1522 sym.mem_free_ptr = memfree;
1523 sym.current = mangled;
1524 str_array_init( &sym.names );
1525 str_array_init( &sym.stack );
1526
1527 result = symbol_demangle(&sym) ? sym.result : mangled;
1528 if (buffer && buflen)
1529 {
1530 strncpy( buffer, result, buflen);
1531 }
1532 else
1533 {
1534 buffer = (char*)memget(strlen(result) + 1);
1535 if (buffer) strcpy(buffer, result);
1536 }
1537
1538 und_free_all(&sym);
1539
1540 return buffer;
1541 }
1542
1543
1544 /*********************************************************************
1545 * __unDName (MSVCRT.@)
1546 */
__unDName(char * buffer,const char * mangled,int buflen,malloc_func_t memget,free_func_t memfree,unsigned short int flags)1547 char* __unDName(char* buffer, const char* mangled, int buflen,
1548 malloc_func_t memget, free_func_t memfree,
1549 unsigned short int flags)
1550 {
1551 return __unDNameEx(buffer, mangled, buflen, memget, memfree, NULL, flags);
1552 }
1553
undname(char * buffer,char * mangled,int buflen,unsigned short int flags)1554 char *undname(char *buffer, char *mangled, int buflen, unsigned short int flags)
1555 {
1556 return __unDName(buffer, mangled, buflen, malloc, free, flags);
1557 }
1558