![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cplus-dem.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / debug / gdb / libiberty|
Return to cplus-dem.c CVS log | Up to [Apple XNU] / GNUtools / debug / gdb / libiberty |
1.1 root 1: /* Demangler for GNU C++
2: Copyright 1989, 1991 Free Software Foundation, Inc.
3: Written by James Clark ([email protected])
4: Rewritten by Fred Fish ([email protected]) for ARM and Lucid demangling
5:
6: This file is part of the libiberty library.
7: Libiberty is free software; you can redistribute it and/or
8: modify it under the terms of the GNU Library General Public
9: License as published by the Free Software Foundation; either
10: version 2 of the License, or (at your option) any later version.
11:
12: Libiberty 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: Library General Public License for more details.
16:
17: You should have received a copy of the GNU Library General Public
18: License along with libiberty; see the file COPYING.LIB. If
19: not, write to the Free Software Foundation, Inc., 675 Mass Ave,
20: Cambridge, MA 02139, USA. */
21:
22: /* This is for g++ 1.95.03 (November 13 version). */
23:
24: /* This file exports two functions; cplus_mangle_opname and cplus_demangle.
25:
26: This file imports xmalloc and xrealloc, which are like malloc and
27: realloc except that they generate a fatal error if there is no
28: available memory. */
29:
30: #ifdef NeXT
31: #define xmalloc(l) malloc(l)
32: #define xrealloc(p, l) realloc(p, l)
33: #endif /* NeXT */
34:
35: #include <demangle.h>
36: #undef CURRENT_DEMANGLING_STYLE
37: #define CURRENT_DEMANGLING_STYLE work->options
38: #include <ctype.h>
39: #include <string.h>
40: #include <stdio.h>
41:
42: /* In order to allow a single demangler executable to demangle strings
43: using various common values of CPLUS_MARKER, as well as any specific
44: one set at compile time, we maintain a string containing all the
45: commonly used ones, and check to see if the marker we are looking for
46: is in that string. CPLUS_MARKER is usually '$' on systems where the
47: assembler can deal with that. Where the assembler can't, it's usually
48: '.' (but on many systems '.' is used for other things). We put the
49: current defined CPLUS_MARKER first (which defaults to '$'), followed
50: by the next most common value, followed by an explicit '$' in case
51: the value of CPLUS_MARKER is not '$'.
52:
53: We could avoid this if we could just get g++ to tell us what the actual
54: cplus marker character is as part of the debug information, perhaps by
55: ensuring that it is the character that terminates the gcc<n>_compiled
56: marker symbol (FIXME). */
57:
58: #if !defined (CPLUS_MARKER)
59: #define CPLUS_MARKER '$'
60: #endif
61:
62: enum demangling_styles current_demangling_style = gnu_demangling;
63:
64: static char cplus_markers[] = { CPLUS_MARKER, '.', '$', '\0' };
65:
66: void
67: set_cplus_marker_for_demangling (ch)
68: int ch;
69: {
70: cplus_markers[0] = ch;
71: }
72:
73: /* Stuff that is shared between sub-routines.
74: * Using a shared structure allows cplus_demangle to be reentrant. */
75:
76: struct work_stuff
77: {
78: int options;
79: char **typevec;
80: int ntypes;
81: int typevec_size;
82: int constructor;
83: int destructor;
84: int static_type; /* A static member function */
85: int const_type; /* A const member function */
86: };
87:
88: #define PRINT_ANSI_QUALIFIERS (work -> options & DMGL_ANSI)
89: #define PRINT_ARG_TYPES (work -> options & DMGL_PARAMS)
90:
91: static CONST struct optable
92: {
93: CONST char *in;
94: CONST char *out;
95: int flags;
96: } optable[] = {
97: "nw", " new", DMGL_ANSI, /* new (1.92, ansi) */
98: "dl", " delete", DMGL_ANSI, /* new (1.92, ansi) */
99: "new", " new", 0, /* old (1.91, and 1.x) */
100: "delete", " delete", 0, /* old (1.91, and 1.x) */
101: "as", "=", DMGL_ANSI, /* ansi */
102: "ne", "!=", DMGL_ANSI, /* old, ansi */
103: "eq", "==", DMGL_ANSI, /* old, ansi */
104: "ge", ">=", DMGL_ANSI, /* old, ansi */
105: "gt", ">", DMGL_ANSI, /* old, ansi */
106: "le", "<=", DMGL_ANSI, /* old, ansi */
107: "lt", "<", DMGL_ANSI, /* old, ansi */
108: "plus", "+", 0, /* old */
109: "pl", "+", DMGL_ANSI, /* ansi */
110: "apl", "+=", DMGL_ANSI, /* ansi */
111: "minus", "-", 0, /* old */
112: "mi", "-", DMGL_ANSI, /* ansi */
113: "ami", "-=", DMGL_ANSI, /* ansi */
114: "mult", "*", 0, /* old */
115: "ml", "*", DMGL_ANSI, /* ansi */
116: "amu", "*=", DMGL_ANSI, /* ansi (ARM/Lucid) */
117: "aml", "*=", DMGL_ANSI, /* ansi (GNU/g++) */
118: "convert", "+", 0, /* old (unary +) */
119: "negate", "-", 0, /* old (unary -) */
120: "trunc_mod", "%", 0, /* old */
121: "md", "%", DMGL_ANSI, /* ansi */
122: "amd", "%=", DMGL_ANSI, /* ansi */
123: "trunc_div", "/", 0, /* old */
124: "dv", "/", DMGL_ANSI, /* ansi */
125: "adv", "/=", DMGL_ANSI, /* ansi */
126: "truth_andif", "&&", 0, /* old */
127: "aa", "&&", DMGL_ANSI, /* ansi */
128: "truth_orif", "||", 0, /* old */
129: "oo", "||", DMGL_ANSI, /* ansi */
130: "truth_not", "!", 0, /* old */
131: "nt", "!", DMGL_ANSI, /* ansi */
132: "postincrement","++", 0, /* old */
133: "pp", "++", DMGL_ANSI, /* ansi */
134: "postdecrement","--", 0, /* old */
135: "mm", "--", DMGL_ANSI, /* ansi */
136: "bit_ior", "|", 0, /* old */
137: "or", "|", DMGL_ANSI, /* ansi */
138: "aor", "|=", DMGL_ANSI, /* ansi */
139: "bit_xor", "^", 0, /* old */
140: "er", "^", DMGL_ANSI, /* ansi */
141: "aer", "^=", DMGL_ANSI, /* ansi */
142: "bit_and", "&", 0, /* old */
143: "ad", "&", DMGL_ANSI, /* ansi */
144: "aad", "&=", DMGL_ANSI, /* ansi */
145: "bit_not", "~", 0, /* old */
146: "co", "~", DMGL_ANSI, /* ansi */
147: "call", "()", 0, /* old */
148: "cl", "()", DMGL_ANSI, /* ansi */
149: "alshift", "<<", 0, /* old */
150: "ls", "<<", DMGL_ANSI, /* ansi */
151: "als", "<<=", DMGL_ANSI, /* ansi */
152: "arshift", ">>", 0, /* old */
153: "rs", ">>", DMGL_ANSI, /* ansi */
154: "ars", ">>=", DMGL_ANSI, /* ansi */
155: "component", "->", 0, /* old */
156: "pt", "->", DMGL_ANSI, /* ansi; Lucid C++ form */
157: "rf", "->", DMGL_ANSI, /* ansi; ARM/GNU form */
158: "indirect", "*", 0, /* old */
159: "method_call", "->()", 0, /* old */
160: "addr", "&", 0, /* old (unary &) */
161: "array", "[]", 0, /* old */
162: "vc", "[]", DMGL_ANSI, /* ansi */
163: "compound", ", ", 0, /* old */
164: "cm", ", ", DMGL_ANSI, /* ansi */
165: "cond", "?:", 0, /* old */
166: "cn", "?:", DMGL_ANSI, /* psuedo-ansi */
167: "max", ">?", 0, /* old */
168: "mx", ">?", DMGL_ANSI, /* psuedo-ansi */
169: "min", "<?", 0, /* old */
170: "mn", "<?", DMGL_ANSI, /* psuedo-ansi */
171: "nop", "", 0, /* old (for operator=) */
172: "rm", "->*", DMGL_ANSI, /* ansi */
173: };
174:
175:
176: typedef struct string /* Beware: these aren't required to be */
177: { /* '\0' terminated. */
178: char *b; /* pointer to start of string */
179: char *p; /* pointer after last character */
180: char *e; /* pointer after end of allocated space */
181: } string;
182:
183: #define STRING_EMPTY(str) ((str) -> b == (str) -> p)
184: #define PREPEND_BLANK(str) {if (!STRING_EMPTY(str)) \
185: string_prepend(str, " ");}
186: #define APPEND_BLANK(str) {if (!STRING_EMPTY(str)) \
187: string_append(str, " ");}
188:
189: #define ARM_VTABLE_STRING "__vtbl__" /* Lucid/cfront virtual table prefix */
190: #define ARM_VTABLE_STRLEN 8 /* strlen (ARM_VTABLE_STRING) */
191:
192: /* Prototypes for local functions */
193:
194: static char *
195: mop_up PARAMS ((struct work_stuff *, string *, int));
196:
197: #if 0
198: static int
199: demangle_method_args PARAMS ((struct work_stuff *work, CONST char **, string *));
200: #endif
201:
202: static int
203: demangle_template PARAMS ((struct work_stuff *work, CONST char **, string *));
204:
205: static int
206: demangle_qualified PARAMS ((struct work_stuff *, CONST char **, string *,
207: int));
208:
209: static int
210: demangle_class PARAMS ((struct work_stuff *, CONST char **, string *));
211:
212: static int
213: demangle_fund_type PARAMS ((struct work_stuff *, CONST char **, string *));
214:
215: static int
216: demangle_signature PARAMS ((struct work_stuff *, CONST char **, string *));
217:
218: static int
219: demangle_prefix PARAMS ((struct work_stuff *, CONST char **, string *));
220:
221: static int
222: gnu_special PARAMS ((struct work_stuff *, CONST char **, string *));
223:
224: static int
225: cfront_special PARAMS ((struct work_stuff *, CONST char **, string *));
226:
227: static void
228: string_need PARAMS ((string *, int));
229:
230: static void
231: string_delete PARAMS ((string *));
232:
233: static void
234: string_init PARAMS ((string *));
235:
236: static void
237: string_clear PARAMS ((string *));
238:
239: #if 0
240: static int
241: string_empty PARAMS ((string *));
242: #endif
243:
244: static void
245: string_append PARAMS ((string *, CONST char *));
246:
247: static void
248: string_appends PARAMS ((string *, string *));
249:
250: static void
251: string_appendn PARAMS ((string *, CONST char *, int));
252:
253: static void
254: string_prepend PARAMS ((string *, CONST char *));
255:
256: static void
257: string_prependn PARAMS ((string *, CONST char *, int));
258:
259: static int
260: get_count PARAMS ((CONST char **, int *));
261:
262: static int
263: consume_count PARAMS ((CONST char **));
264:
265: static int
266: demangle_args PARAMS ((struct work_stuff *, CONST char **, string *));
267:
268: static int
269: do_type PARAMS ((struct work_stuff *, CONST char **, string *));
270:
271: static int
272: do_arg PARAMS ((struct work_stuff *, CONST char **, string *));
273:
274: static void
275: demangle_function_name PARAMS ((struct work_stuff *, CONST char **, string *,
276: CONST char *));
277:
278: static void
279: remember_type PARAMS ((struct work_stuff *, CONST char *, int));
280:
281: static void
282: forget_types PARAMS ((struct work_stuff *));
283:
284: static void
285: string_prepends PARAMS ((string *, string *));
286:
287: /* Translate count to integer, consuming tokens in the process.
288: Conversion terminates on the first non-digit character. */
289:
290: static int
291: consume_count (type)
292: CONST char **type;
293: {
294: int count = 0;
295:
296: do
297: {
298: count *= 10;
299: count += **type - '0';
300: (*type)++;
301: } while (isdigit (**type));
302: return (count);
303: }
304:
305: /* Takes operator name as e.g. "++" and returns mangled
306: operator name (e.g. "postincrement_expr"), or NULL if not found.
307:
308: If OPTIONS & DMGL_ANSI == 1, return the ANSI name;
309: if OPTIONS & DMGL_ANSI == 0, return the old GNU name. */
310:
311: char *
312: cplus_mangle_opname (opname, options)
313: char *opname;
314: int options;
315: {
316: int i;
317: int len;
318:
319: len = strlen (opname);
320: for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++)
321: {
322: if (strlen (optable[i].out) == len
323: && (options & DMGL_ANSI) == (optable[i].flags & DMGL_ANSI)
324: && memcmp (optable[i].out, opname, len) == 0)
325: return ((char *)optable[i].in);
326: }
327: return (0);
328: }
329:
330: /* check to see whether MANGLED can match TEXT in the first TEXT_LEN
331: characters. */
332:
333: int cplus_match (mangled, text, text_len)
334: CONST char *mangled;
335: char *text;
336: int text_len;
337: {
338: if (strncmp (mangled, text, text_len) != 0) {
339: return(0); /* cannot match either */
340: } else {
341: return(1); /* matches mangled, may match demangled */
342: }
343: }
344:
345: /* char *cplus_demangle (const char *name, int options)
346:
347: If NAME is a mangled function name produced by GNU C++, then
348: a pointer to a malloced string giving a C++ representation
349: of the name will be returned; otherwise NULL will be returned.
350: It is the caller's responsibility to free the string which
351: is returned.
352:
353: The OPTIONS arg may contain one or more of the following bits:
354:
355: DMGL_ANSI ANSI qualifiers such as `const' and `void' are
356: included.
357: DMGL_PARAMS Function parameters are included.
358:
359: For example,
360:
361: cplus_demangle ("foo__1Ai", DMGL_PARAMS) => "A::foo(int)"
362: cplus_demangle ("foo__1Ai", DMGL_PARAMS | DMGL_ANSI) => "A::foo(int)"
363: cplus_demangle ("foo__1Ai", 0) => "A::foo"
364:
365: cplus_demangle ("foo__1Afe", DMGL_PARAMS) => "A::foo(float,...)"
366: cplus_demangle ("foo__1Afe", DMGL_PARAMS | DMGL_ANSI)=> "A::foo(float,...)"
367: cplus_demangle ("foo__1Afe", 0) => "A::foo"
368:
369: Note that any leading underscores, or other such characters prepended by
370: the compilation system, are presumed to have already been stripped from
371: TYPE. */
372:
373: char *
374: cplus_demangle (mangled, options)
375: CONST char *mangled;
376: int options;
377: {
378: string decl;
379: int success = 0;
380: struct work_stuff work[1];
381: char *demangled = NULL;
382:
383: if ((mangled != NULL) && (*mangled != '\0'))
384: {
385: memset ((char *) work, 0, sizeof (work));
386: work -> options = options;
387: if ((work->options & DMGL_STYLE_MASK) == 0)
388: work->options |= (int)current_demangling_style & DMGL_STYLE_MASK;
389:
390: string_init (&decl);
391:
392: /* First check to see if gnu style demangling is active and if the
393: string to be demangled contains a CPLUS_MARKER. If so, attempt to
394: recognize one of the gnu special forms rather than looking for a
395: standard prefix. In particular, don't worry about whether there
396: is a "__" string in the mangled string. Consider "_$_5__foo" for
397: example. */
398:
399: if ((AUTO_DEMANGLING || GNU_DEMANGLING))
400: {
401: success = gnu_special (work, &mangled, &decl);
402: }
403: if (!success)
404: {
405: success = demangle_prefix (work, &mangled, &decl);
406: }
407: if (success && (*mangled != '\0'))
408: {
409: success = demangle_signature (work, &mangled, &decl);
410: }
411: demangled = mop_up (work, &decl, success);
412: }
413: return (demangled);
414: }
415:
416: static char *
417: mop_up (work, declp, success)
418: struct work_stuff *work;
419: string *declp;
420: int success;
421: {
422: int i;
423: char *demangled = NULL;
424:
425: /* Discard the remembered types, if any. */
426:
427: forget_types (work);
428: if (work -> typevec != NULL)
429: {
430: free ((char *) work -> typevec);
431: }
432:
433: /* If demangling was successful, ensure that the demangled string is null
434: terminated and return it. Otherwise, free the demangling decl. */
435:
436: if (!success)
437: {
438: string_delete (declp);
439: }
440: else
441: {
442: string_appendn (declp, "", 1);
443: demangled = declp -> b;
444: }
445: return (demangled);
446: }
447:
448: /*
449:
450: LOCAL FUNCTION
451:
452: demangle_signature -- demangle the signature part of a mangled name
453:
454: SYNOPSIS
455:
456: static int
457: demangle_signature (struct work_stuff *work, const char **mangled,
458: string *declp);
459:
460: DESCRIPTION
461:
462: Consume and demangle the signature portion of the mangled name.
463:
464: DECLP is the string where demangled output is being built. At
465: entry it contains the demangled root name from the mangled name
466: prefix. I.E. either a demangled operator name or the root function
467: name. In some special cases, it may contain nothing.
468:
469: *MANGLED points to the current unconsumed location in the mangled
470: name. As tokens are consumed and demangling is performed, the
471: pointer is updated to continuously point at the next token to
472: be consumed.
473:
474: Demangling GNU style mangled names is nasty because there is no
475: explicit token that marks the start of the outermost function
476: argument list.
477: */
478:
479: static int
480: demangle_signature (work, mangled, declp)
481: struct work_stuff *work;
482: CONST char **mangled;
483: string *declp;
484: {
485: int success = 1;
486: int func_done = 0;
487: int expect_func = 0;
488: CONST char *oldmangled;
489:
490: while (success && (**mangled != '\0'))
491: {
492: switch (**mangled)
493: {
494: case 'Q':
495: oldmangled = *mangled;
496: success = demangle_qualified (work, mangled, declp, 1);
497: if (success)
498: {
499: remember_type (work, oldmangled, *mangled - oldmangled);
500: }
501: if (AUTO_DEMANGLING || GNU_DEMANGLING)
502: {
503: expect_func = 1;
504: }
505: break;
506:
507: case 'S':
508: /* Static member function */
509: (*mangled)++;
510: work -> static_type = 1;
511: break;
512:
513: case 'C':
514: /* a const member function */
515: (*mangled)++;
516: work -> const_type = 1;
517: break;
518:
519: case '0': case '1': case '2': case '3': case '4':
520: case '5': case '6': case '7': case '8': case '9':
521: oldmangled = *mangled;
522: success = demangle_class (work, mangled, declp);
523: if (success)
524: {
525: remember_type (work, oldmangled, *mangled - oldmangled);
526: }
527: if (AUTO_DEMANGLING || GNU_DEMANGLING)
528: {
529: expect_func = 1;
530: }
531: break;
532:
533: case 'F':
534: /* Function */
535: /* ARM style demangling includes a specific 'F' character after
536: the class name. For GNU style, it is just implied. So we can
537: safely just consume any 'F' at this point and be compatible
538: with either style. */
539:
540: func_done = 1;
541: (*mangled)++;
542:
543: /* For lucid/cfront style we have to forget any types we might
544: have remembered up to this point, since they were not argument
545: types. GNU style considers all types seen as available for
546: back references. See comment in demangle_args() */
547:
548: if (LUCID_DEMANGLING || CFRONT_DEMANGLING)
549: {
550: forget_types (work);
551: }
552: success = demangle_args (work, mangled, declp);
553: break;
554:
555: case 't':
556: /* Template */
557: success = demangle_template (work, mangled, declp);
558: break;
559:
560: case '_':
561: /* At the outermost level, we cannot have a return type specified,
562: so if we run into another '_' at this point we are dealing with
563: a mangled name that is either bogus, or has been mangled by
564: some algorithm we don't know how to deal with. So just
565: reject the entire demangling. */
566: success = 0;
567: break;
568:
569: default:
570: if (AUTO_DEMANGLING || GNU_DEMANGLING)
571: {
572: /* Assume we have stumbled onto the first outermost function
573: argument token, and start processing args. */
574: func_done = 1;
575: success = demangle_args (work, mangled, declp);
576: }
577: else
578: {
579: /* Non-GNU demanglers use a specific token to mark the start
580: of the outermost function argument tokens. Typically 'F',
581: for ARM-demangling, for example. So if we find something
582: we are not prepared for, it must be an error. */
583: success = 0;
584: }
585: break;
586: }
587: if (AUTO_DEMANGLING || GNU_DEMANGLING)
588: {
589: if (success && expect_func)
590: {
591: func_done = 1;
592: success = demangle_args (work, mangled, declp);
593: }
594: }
595: }
596: if (success && !func_done)
597: {
598: if (AUTO_DEMANGLING || GNU_DEMANGLING)
599: {
600: /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
601: bar__3fooi is 'foo::bar(int)'. We get here when we find the
602: first case, and need to ensure that the '(void)' gets added to
603: the current declp. Note that with ARM, the first case
604: represents the name of a static data member 'foo::bar',
605: which is in the current declp, so we leave it alone. */
606: success = demangle_args (work, mangled, declp);
607: }
608: }
609: if (success && work -> static_type && PRINT_ARG_TYPES)
610: {
611: string_append (declp, " static");
612: }
613: if (success && work -> const_type && PRINT_ARG_TYPES)
614: {
615: string_append (declp, " const");
616: }
617: return (success);
618: }
619:
620: #if 0
621:
622: static int
623: demangle_method_args (work, mangled, declp)
624: struct work_stuff *work;
625: CONST char **mangled;
626: string *declp;
627: {
628: int success = 0;
629:
630: if (work -> static_type)
631: {
632: string_append (declp, *mangled + 1);
633: *mangled += strlen (*mangled);
634: success = 1;
635: }
636: else
637: {
638: success = demangle_args (work, mangled, declp);
639: }
640: return (success);
641: }
642:
643: #endif
644:
645: static int
646: demangle_template (work, mangled, declp)
647: struct work_stuff *work;
648: CONST char **mangled;
649: string *declp;
650: {
651: int i;
652: string tname;
653: string trawname;
654: int is_pointer;
655: int is_real;
656: int is_integral;
657: int r;
658: int need_comma = 0;
659: int success = 0;
660: int done;
661: CONST char *old_p;
662: int symbol_len;
663: string temp;
664:
665: (*mangled)++;
666: string_init (&tname);
667: string_init (&trawname);
668: /* get template name */
669: if (!get_count (mangled, &r))
670: {
671: return (0);
672: }
673: string_appendn (&tname, *mangled, r);
674: string_appendn (&trawname, *mangled, r);
675: #ifndef NeXT
676: string_appendn (&trawname, "", 1);
677: #endif /* NeXT */
678: *mangled += r;
679: string_append (&tname, "<");
680: /* get size of template parameter list */
681: if (!get_count (mangled, &r))
682: {
683: return (0);
684: }
685: for (i = 0; i < r; i++)
686: {
687: if (need_comma)
688: {
689: string_append (&tname, ", ");
690: }
691: /* Z for type parameters */
692: if (**mangled == 'Z')
693: {
694: (*mangled)++;
695: success = do_type (work, mangled, &temp);
696: #ifndef NeXT
697: string_appendn (&temp, "", 1);
698: #endif /* !NeXT */
699: if (success)
700: {
701: #ifdef NeXT
702: string_appends (&tname, &temp);
703: #else
704: string_append (&tname, temp.b);
705: #endif /* NeXT */
706: }
707: string_delete(&temp);
708: if (!success)
709: {
710: break;
711: }
712: }
713: else
714: {
715: /* otherwise, value parameter */
716: old_p = *mangled;
717: is_pointer = 0;
718: is_real = 0;
719: is_integral = 0;
720: done = 0;
721: success = do_type (work, mangled, &temp);
722: #ifndef NeXT
723: string_appendn (&temp, "", 1);
724: #endif /* !NeXT */
725: if (success)
726: {
727: #ifdef NeXT
728: string_appends (&tname, &temp);
729: #else
730: string_append (&tname, temp.b);
731: #endif /* NeXT */
732: }
733: string_delete(&temp);
734: if (!success)
735: {
736: break;
737: }
738: string_append (&tname, "=");
739: while (*old_p && !done)
740: {
741: switch (*old_p)
742: {
743: case 'P':
744: case 'R':
745: done = is_pointer = 1;
746: break;
747: case 'C': /* const */
748: case 'S': /* explicitly signed [char] */
749: case 'U': /* unsigned */
750: case 'V': /* volatile */
751: case 'F': /* function */
752: case 'M': /* member function */
753: case 'O': /* ??? */
754: old_p++;
755: continue;
756: case 'Q': /* repetition of following */
757: case 'T': /* remembered type */
758: abort ();
759: break;
760: case 'v': /* void */
761: abort ();
762: break;
763: case 'x': /* long long */
764: case 'l': /* long */
765: case 'i': /* int */
766: case 's': /* short */
767: case 'c': /* char */
768: done = is_integral = 1;
769: break;
770: case 'r': /* long double */
771: case 'd': /* double */
772: case 'f': /* float */
773: done = is_real = 1;
774: break;
775: default:
776: abort ();
777: }
778: }
779: if (is_integral)
780: {
781: if (**mangled == 'm')
782: {
783: string_appendn (&tname, "-", 1);
784: (*mangled)++;
785: }
786: while (isdigit (**mangled))
787: {
788: string_appendn (&tname, *mangled, 1);
789: (*mangled)++;
790: }
791: }
792: else if (is_real)
793: {
794: if (**mangled == 'm')
795: {
796: string_appendn (&tname, "-", 1);
797: (*mangled)++;
798: }
799: while (isdigit (**mangled))
800: {
801: string_appendn (&tname, *mangled, 1);
802: (*mangled)++;
803: }
804: if (**mangled == '.') /* fraction */
805: {
806: string_appendn (&tname, ".", 1);
807: (*mangled)++;
808: while (isdigit (**mangled))
809: {
810: string_appendn (&tname, *mangled, 1);
811: (*mangled)++;
812: }
813: }
814: if (**mangled == 'e') /* exponent */
815: {
816: string_appendn (&tname, "e", 1);
817: (*mangled)++;
818: while (isdigit (**mangled))
819: {
820: string_appendn (&tname, *mangled, 1);
821: (*mangled)++;
822: }
823: }
824: }
825: else if (is_pointer)
826: {
827: if (!get_count (mangled, &symbol_len))
828: {
829: success = 0;
830: break;
831: }
832: string_appendn (&tname, *mangled, symbol_len);
833: *mangled += symbol_len;
834: }
835: }
836: need_comma = 1;
837: }
838: string_append (&tname, ">::");
839: if (work -> destructor)
840: {
841: string_append (&tname, "~");
842: }
843: if (work -> constructor || work -> destructor)
844: {
845: #ifdef NeXT
846: string_appends (&tname, &temp);
847: #else
848: string_append (&tname, trawname.b);
849: #endif /* NeXT */
850: }
851: #ifdef NeXT
852: {
853: char buf[16];
854: sprintf(buf, "%d", trawname.p - trawname.b);
855: string_prepend(&trawname, buf);
856: remember_type(work, trawname.b, trawname.p - trawname.b);
857: }
858: #endif /* NeXT */
859: string_delete(&trawname);
860:
861: if (!success)
862: {
863: string_delete(&tname);
864: }
865: else
866: {
867: #ifdef NeXT
868: string_prepends (declp, &tname);
869: #else
870: string_prepend (declp, tname.b);
871: #endif /* NeXT */
872: string_delete (&tname);
873:
874: if (work -> static_type)
875: {
876: string_append (declp, *mangled + 1);
877: *mangled += strlen (*mangled);
878: #ifndef NeXT
879: success = 1;
880: #endif /* !NeXT */
881: }
882: #ifdef NeXT
883: success = 1;
884: #else
885: else
886: {
887: success = demangle_args (work, mangled, declp);
888: }
889: #endif /* NeXT */
890: }
891: return (success);
892: }
893:
894: /*
895:
896: LOCAL FUNCTION
897:
898: demangle_class -- demangle a mangled class sequence
899:
900: SYNOPSIS
901:
902: static int
903: demangle_class (struct work_stuff *work, const char **mangled,
904: strint *declp)
905:
906: DESCRIPTION
907:
908: DECLP points to the buffer into which demangling is being done.
909:
910: *MANGLED points to the current token to be demangled. On input,
911: it points to a mangled class (I.E. "3foo", "13verylongclass", etc.)
912: On exit, it points to the next token after the mangled class on
913: success, or the first unconsumed token on failure.
914:
915: If the CONSTRUCTOR or DESTRUCTOR flags are set in WORK, then
916: we are demangling a constructor or destructor. In this case
917: we prepend "class::class" or "class::~class" to DECLP.
918:
919: Otherwise, we prepend "class::" to the current DECLP.
920:
921: Reset the constructor/destructor flags once they have been
922: "consumed". This allows demangle_class to be called later during
923: the same demangling, to do normal class demangling.
924:
925: Returns 1 if demangling is successful, 0 otherwise.
926:
927: */
928:
929: static int
930: demangle_class (work, mangled, declp)
931: struct work_stuff *work;
932: CONST char **mangled;
933: string *declp;
934: {
935: int n;
936: int success = 0;
937:
938: n = consume_count (mangled);
939: if (strlen (*mangled) >= n)
940: {
941: if (work -> constructor || work -> destructor)
942: {
943: string_prependn (declp, *mangled, n);
944: if (work -> destructor)
945: {
946: string_prepend (declp, "~");
947: }
948: work -> constructor = work -> destructor = 0;
949: }
950: string_prepend (declp, "::");
951: string_prependn (declp, *mangled, n);
952: *mangled += n;
953: success = 1;
954: }
955: return (success);
956: }
957:
958: /*
959:
960: LOCAL FUNCTION
961:
962: demangle_prefix -- consume the mangled name prefix and find signature
963:
964: SYNOPSIS
965:
966: static int
967: demangle_prefix (struct work_stuff *work, const char **mangled,
968: string *declp);
969:
970: DESCRIPTION
971:
972: Consume and demangle the prefix of the mangled name.
973:
974: DECLP points to the string buffer into which demangled output is
975: placed. On entry, the buffer is empty. On exit it contains
976: the root function name, the demangled operator name, or in some
977: special cases either nothing or the completely demangled result.
978:
979: MANGLED points to the current pointer into the mangled name. As each
980: token of the mangled name is consumed, it is updated. Upon entry
981: the current mangled name pointer points to the first character of
982: the mangled name. Upon exit, it should point to the first character
983: of the signature if demangling was successful, or to the first
984: unconsumed character if demangling of the prefix was unsuccessful.
985:
986: Returns 1 on success, 0 otherwise.
987: */
988:
989: static int
990: demangle_prefix (work, mangled, declp)
991: struct work_stuff *work;
992: CONST char **mangled;
993: string *declp;
994: {
995: int success = 1;
996: CONST char *scan;
997: int i;
998:
999: /* This block of code is a reduction in strength time optimization
1000: of:
1001: scan = strstr (*mangled, "__"); */
1002:
1003: {
1004: scan = *mangled;
1005:
1006: do {
1007: scan = strchr (scan, '_');
1008: } while (scan != NULL && *++scan != '_');
1009:
1010: if (scan != NULL) --scan;
1011: }
1012:
1013: if (scan != NULL)
1014: {
1015: /* We found a sequence of two or more '_', ensure that we start at
1016: the last pair in the sequence. */
1017: i = strspn (scan, "_");
1018: if (i > 2)
1019: {
1020: scan += (i - 2);
1021: }
1022: }
1023:
1024: if (scan == NULL)
1025: {
1026: success = 0;
1027: }
1028: else if (work -> static_type)
1029: {
1030: if (!isdigit (scan[0]) && (scan[0] != 't'))
1031: {
1032: success = 0;
1033: }
1034: }
1035: #ifdef NeXT
1036: else if ((scan == *mangled) && (isdigit (scan[2]) || (scan[2] == 't')))
1037: {
1038: /* A GNU style constructor starts with "__<digit>" or "__t". */
1039: #else
1040: else if ((scan == *mangled) && (isdigit (scan[2]) || (scan[2] == 'Q')))
1041: {
1042: /* A GNU style constructor starts with "__<digit>" or "__Q". */
1043: #endif /* NeXT */
1044: work -> constructor = 1;
1045: *mangled = scan + 2;
1046: }
1047: else if ((scan == *mangled) && !isdigit (scan[2]) && (scan[2] != 't'))
1048: {
1049: /* Mangled name starts with "__". Skip over any leading '_' characters,
1050: then find the next "__" that separates the prefix from the signature.
1051: */
1052: if (!(CFRONT_DEMANGLING || LUCID_DEMANGLING)
1053: || (cfront_special (work, mangled, declp) == 0))
1054: {
1055: while (*scan == '_')
1056: {
1057: scan++;
1058: }
1059: if ((scan = strstr (scan, "__")) == NULL || (*(scan + 2) == '\0'))
1060: {
1061: /* No separator (I.E. "__not_mangled"), or empty signature
1062: (I.E. "__not_mangled_either__") */
1063: success = 0;
1064: }
1065: else
1066: {
1067: demangle_function_name (work, mangled, declp, scan);
1068: }
1069: }
1070: }
1071: else if (*(scan + 2) != '\0')
1072: {
1073: /* Mangled name does not start with "__" but does have one somewhere
1074: in there with non empty stuff after it. Looks like a global
1075: function name. */
1076: demangle_function_name (work, mangled, declp, scan);
1077: }
1078: else
1079: {
1080: /* Doesn't look like a mangled name */
1081: success = 0;
1082: }
1083: return (success);
1084: }
1085:
1086: /*
1087:
1088: LOCAL FUNCTION
1089:
1090: gnu_special -- special handling of gnu mangled strings
1091:
1092: SYNOPSIS
1093:
1094: static int
1095: gnu_special (struct work_stuff *work, const char **mangled,
1096: string *declp);
1097:
1098:
1099: DESCRIPTION
1100:
1101: Process some special GNU style mangling forms that don't fit
1102: the normal pattern. For example:
1103:
1104: _$_3foo (destructor for class foo)
1105: _vt$foo (foo virtual table)
1106: _vt$foo$bar (foo::bar virtual table)
1107: _3foo$varname (static data member)
1108: */
1109:
1110: static int
1111: gnu_special (work, mangled, declp)
1112: struct work_stuff *work;
1113: CONST char **mangled;
1114: string *declp;
1115: {
1116: int n;
1117: int success = 1;
1118: CONST char *p;
1119:
1120: if ((*mangled)[0] == '_'
1121: && strchr (cplus_markers, (*mangled)[1]) != NULL
1122: && (*mangled)[2] == '_')
1123: {
1124: /* Found a GNU style destructor, get past "_<CPLUS_MARKER>_" */
1125: (*mangled) += 3;
1126: work -> destructor = 1;
1127: }
1128: else if ((*mangled)[0] == '_'
1129: && (*mangled)[1] == 'v'
1130: && (*mangled)[2] == 't'
1131: && strchr (cplus_markers, (*mangled)[3]) != NULL)
1132: {
1133: /* Found a GNU style virtual table, get past "_vt<CPLUS_MARKER>"
1134: and create the decl. Note that we consume the entire mangled
1135: input string, which means that demangle_signature has no work
1136: to do. */
1137: (*mangled) += 4;
1138: while (**mangled != '\0')
1139: {
1140: n = strcspn (*mangled, cplus_markers);
1141: string_appendn (declp, *mangled, n);
1142: (*mangled) += n;
1143: if (**mangled != '\0')
1144: {
1145: string_append (declp, "::");
1146: (*mangled)++;
1147: }
1148: }
1149: string_append (declp, " virtual table");
1150: }
1151: else if ((*mangled)[0] == '_'
1152: && isdigit ((*mangled)[1])
1153: && (p = strpbrk (*mangled, cplus_markers)) != NULL)
1154: {
1155: /* static data member, "_3foo$varname" for example */
1156: (*mangled)++;
1157: p++;
1158: n = consume_count (mangled);
1159: string_appendn (declp, *mangled, n);
1160: string_append (declp, "::");
1161: n = strlen (p);
1162: string_appendn (declp, p, n);
1163: (*mangled) = p + n;
1164: }
1165: else
1166: {
1167: success = 0;
1168: }
1169: return (success);
1170: }
1171:
1172: /*
1173:
1174: LOCAL FUNCTION
1175:
1176: cfront_special -- special handling of cfront/lucid mangled strings
1177:
1178: SYNOPSIS
1179:
1180: static int
1181: cfront_special (struct work_stuff *work, const char **mangled,
1182: string *declp);
1183:
1184:
1185: DESCRIPTION
1186:
1187: Process some special cfront style mangling forms that don't fit
1188: the normal pattern. For example:
1189:
1190: __vtbl__3foo (foo virtual table)
1191: __vtbl__3foo__3bar (bar::foo virtual table)
1192:
1193: */
1194:
1195: static int
1196: cfront_special (work, mangled, declp)
1197: struct work_stuff *work;
1198: CONST char **mangled;
1199: string *declp;
1200: {
1201: int n;
1202: int i;
1203: int success = 1;
1204: CONST char *p;
1205:
1206: if (strncmp (*mangled, ARM_VTABLE_STRING, ARM_VTABLE_STRLEN) == 0)
1207: {
1208: /* Found a cfront style virtual table, get past ARM_VTABLE_STRING
1209: and create the decl. Note that we consume the entire mangled
1210: input string, which means that demangle_signature has no work
1211: to do. */
1212: (*mangled) += ARM_VTABLE_STRLEN;
1213: while (**mangled != '\0')
1214: {
1215: n = consume_count (mangled);
1216: string_prependn (declp, *mangled, n);
1217: (*mangled) += n;
1218: if ((*mangled)[0] == '_' && (*mangled)[1] == '_')
1219: {
1220: string_prepend (declp, "::");
1221: (*mangled) += 2;
1222: }
1223: }
1224: string_append (declp, " virtual table");
1225: }
1226: else
1227: {
1228: success = 0;
1229: }
1230: return (success);
1231: }
1232:
1233: /*
1234:
1235: LOCAL FUNCTION
1236:
1237: demangle_qualified -- demangle 'Q' qualified name strings
1238:
1239: SYNOPSIS
1240:
1241: static int
1242: demangle_qualified (struct work_stuff *, const char *mangled,
1243: string *result, int isfuncname);
1244:
1245: DESCRIPTION
1246:
1247: Demangle a qualified name, such as "Q25Outer5Inner" which is
1248: the mangled form of "Outer::Inner". The demangled output is
1249: appended to the result string.
1250:
1251: If isfuncname is nonzero, then the qualified name we are building
1252: is going to be used as a member function name, so if it is a
1253: constructor or destructor function, append an appropriate
1254: constructor or destructor name. I.E. for the above example,
1255: the result for use as a constructor is "Outer::Inner::Inner"
1256: and the result for use as a destructor is "Outer::Inner::~Inner".
1257:
1258: BUGS
1259:
1260: Numeric conversion is ASCII dependent (FIXME).
1261:
1262: */
1263:
1264: static int
1265: demangle_qualified (work, mangled, result, isfuncname)
1266: struct work_stuff *work;
1267: CONST char **mangled;
1268: string *result;
1269: int isfuncname;
1270: {
1271: int qualifiers;
1272: int namelength;
1273: int success = 0;
1274:
1275: qualifiers = (*mangled)[1] - '0';
1276: if (qualifiers > 0 && qualifiers < 10)
1277: {
1278: /* Assume success until we discover otherwise. Skip over the 'Q', the
1279: qualifier count, and any '_' between the qualifier count and the
1280: first name (cfront qualified names). */
1281:
1282: success = 1;
1283: if ((*mangled)[2] == '_')
1284: {
1285: (*mangled)++;
1286: }
1287: (*mangled) += 2;
1288:
1289:
1290: /* Pick off the names and append them to the result string as they
1291: are found, separated by '::'. */
1292:
1293: while (qualifiers-- > 0)
1294: {
1295: namelength = consume_count (mangled);
1296: if (strlen (*mangled) < namelength)
1297: {
1298: /* Simple sanity check failed */
1299: success = 0;
1300: break;
1301: }
1302: string_appendn (result, *mangled, namelength);
1303: if (qualifiers > 0)
1304: {
1305: string_appendn (result, "::", 2);
1306: }
1307: *mangled += namelength;
1308: }
1309:
1310: /* If we are using the result as a function name, we need to append
1311: the appropriate '::' separated constructor or destructor name.
1312: We do this here because this is the most convenient place, where
1313: we already have a pointer to the name and the length of the name. */
1314:
1315: if (isfuncname && (work -> constructor || work -> destructor))
1316: {
1317: string_appendn (result, "::", 2);
1318: if (work -> destructor)
1319: {
1320: string_append (result, "~");
1321: }
1322: string_appendn (result, (*mangled) - namelength, namelength);
1323: }
1324: }
1325: return (success);
1326: }
1327:
1328: /*
1329:
1330: LOCAL FUNCTION
1331:
1332: get_count -- convert an ascii count to integer, consuming tokens
1333:
1334: SYNOPSIS
1335:
1336: static int
1337: get_count (const char **type, int *count)
1338:
1339: DESCRIPTION
1340:
1341: Return 0 if no conversion is performed, 1 if a string is converted.
1342: */
1343:
1344: static int
1345: get_count (type, count)
1346: CONST char **type;
1347: int *count;
1348: {
1349: CONST char *p;
1350: int n;
1351:
1352: if (!isdigit (**type))
1353: {
1354: return (0);
1355: }
1356: else
1357: {
1358: *count = **type - '0';
1359: (*type)++;
1360: if (isdigit (**type))
1361: {
1362: p = *type;
1363: n = *count;
1364: do
1365: {
1366: n *= 10;
1367: n += *p - '0';
1368: p++;
1369: }
1370: while (isdigit (*p));
1371: if (*p == '_')
1372: {
1373: *type = p + 1;
1374: *count = n;
1375: }
1376: }
1377: }
1378: return (1);
1379: }
1380:
1381: /* result will be initialised here; it will be freed on failure */
1382:
1383: static int
1384: do_type (work, mangled, result)
1385: struct work_stuff *work;
1386: CONST char **mangled;
1387: string *result;
1388: {
1389: int n;
1390: int done;
1391: int success;
1392: string decl;
1393: CONST char *remembered_type;
1394: int constp;
1395: int volatilep;
1396:
1397: string_init (&decl);
1398: string_init (result);
1399:
1400: done = 0;
1401: success = 1;
1402: while (success && !done)
1403: {
1404: int member;
1405: switch (**mangled)
1406: {
1407:
1408: /* A pointer type */
1409: case 'P':
1410: (*mangled)++;
1411: string_prepend (&decl, "*");
1412: break;
1413:
1414: /* A reference type */
1415: case 'R':
1416: (*mangled)++;
1417: string_prepend (&decl, "&");
1418: break;
1419:
1420: /* A back reference to a previously seen type */
1421: case 'T':
1422: (*mangled)++;
1423: if (!get_count (mangled, &n) || n >= work -> ntypes)
1424: {
1425: success = 0;
1426: }
1427: else
1428: {
1429: remembered_type = work -> typevec[n];
1430: mangled = &remembered_type;
1431: }
1432: break;
1433:
1434: /* A function */
1435: case 'F':
1436: (*mangled)++;
1437: if (!STRING_EMPTY (&decl) && decl.b[0] == '*')
1438: {
1439: string_prepend (&decl, "(");
1440: string_append (&decl, ")");
1441: }
1442: /* After picking off the function args, we expect to either find the
1443: function return type (preceded by an '_') or the end of the
1444: string. */
1445: if (!demangle_args (work, mangled, &decl)
1446: || (**mangled != '_' && **mangled != '\0'))
1447: {
1448: success = 0;
1449: }
1450: if (success && (**mangled == '_'))
1451: {
1452: (*mangled)++;
1453: }
1454: break;
1455:
1456: case 'M':
1457: case 'O':
1458: {
1459: constp = 0;
1460: volatilep = 0;
1461:
1462: member = **mangled == 'M';
1463: (*mangled)++;
1464: if (!isdigit (**mangled))
1465: {
1466: success = 0;
1467: break;
1468: }
1469: n = consume_count (mangled);
1470: if (strlen (*mangled) < n)
1471: {
1472: success = 0;
1473: break;
1474: }
1475: string_append (&decl, ")");
1476: string_prepend (&decl, "::");
1477: string_prependn (&decl, *mangled, n);
1478: string_prepend (&decl, "(");
1479: *mangled += n;
1480: if (member)
1481: {
1482: if (**mangled == 'C')
1483: {
1484: (*mangled)++;
1485: constp = 1;
1486: }
1487: if (**mangled == 'V')
1488: {
1489: (*mangled)++;
1490: volatilep = 1;
1491: }
1492: if (*(*mangled)++ != 'F')
1493: {
1494: success = 0;
1495: break;
1496: }
1497: }
1498: if ((member && !demangle_args (work, mangled, &decl))
1499: || **mangled != '_')
1500: {
1501: success = 0;
1502: break;
1503: }
1504: (*mangled)++;
1505: if (! PRINT_ANSI_QUALIFIERS)
1506: {
1507: break;
1508: }
1509: if (constp)
1510: {
1511: APPEND_BLANK (&decl);
1512: string_append (&decl, "const");
1513: }
1514: if (volatilep)
1515: {
1516: APPEND_BLANK (&decl);
1517: string_append (&decl, "volatile");
1518: }
1519: break;
1520: }
1521:
1522: case 'C':
1523: if ((*mangled)[1] == 'P')
1524: {
1525: (*mangled)++;
1526: if (PRINT_ANSI_QUALIFIERS)
1527: {
1528: if (!STRING_EMPTY (&decl))
1529: {
1530: string_prepend (&decl, " ");
1531: }
1532: string_prepend (&decl, "const");
1533: }
1534: break;
1535: }
1536:
1537: /* fall through */
1538: default:
1539: done = 1;
1540: break;
1541: }
1542: }
1543:
1544: switch (**mangled)
1545: {
1546: /* A qualified name, such as "Outer::Inner". */
1547: case 'Q':
1548: success = demangle_qualified (work, mangled, result, 0);
1549: break;
1550:
1551: default:
1552: success = demangle_fund_type (work, mangled, result);
1553: break;
1554: }
1555:
1556: if (success)
1557: {
1558: if (!STRING_EMPTY (&decl))
1559: {
1560: string_append (result, " ");
1561: string_appends (result, &decl);
1562: }
1563: }
1564: else
1565: {
1566: string_delete (result);
1567: }
1568: string_delete (&decl);
1569: return (success);
1570: }
1571:
1572: /* Given a pointer to a type string that represents a fundamental type
1573: argument (int, long, unsigned int, etc) in TYPE, a pointer to the
1574: string in which the demangled output is being built in RESULT, and
1575: the WORK structure, decode the types and add them to the result.
1576:
1577: For example:
1578:
1579: "Ci" => "const int"
1580: "Sl" => "signed long"
1581: "CUs" => "const unsigned short"
1582:
1583: */
1584:
1585: static int
1586: demangle_fund_type (work, mangled, result)
1587: struct work_stuff *work;
1588: CONST char **mangled;
1589: string *result;
1590: {
1591: int done = 0;
1592: int success = 1;
1593: int n;
1594:
1595: /* First pick off any type qualifiers. There can be more than one. */
1596:
1597: while (!done)
1598: {
1599: switch (**mangled)
1600: {
1601: case 'C':
1602: (*mangled)++;
1603: if (PRINT_ANSI_QUALIFIERS)
1604: {
1605: APPEND_BLANK (result);
1606: string_append (result, "const");
1607: }
1608: break;
1609: case 'U':
1610: (*mangled)++;
1611: APPEND_BLANK (result);
1612: string_append (result, "unsigned");
1613: break;
1614: case 'S': /* signed char only */
1615: (*mangled)++;
1616: APPEND_BLANK (result);
1617: string_append (result, "signed");
1618: break;
1619: case 'V':
1620: (*mangled)++;
1621: if (PRINT_ANSI_QUALIFIERS)
1622: {
1623: APPEND_BLANK (result);
1624: string_append (result, "volatile");
1625: }
1626: break;
1627: default:
1628: done = 1;
1629: break;
1630: }
1631: }
1632:
1633: /* Now pick off the fundamental type. There can be only one. */
1634:
1635: switch (**mangled)
1636: {
1637: case '\0':
1638: case '_':
1639: break;
1640: case 'v':
1641: (*mangled)++;
1642: APPEND_BLANK (result);
1643: string_append (result, "void");
1644: break;
1645: case 'x':
1646: (*mangled)++;
1647: APPEND_BLANK (result);
1648: string_append (result, "long long");
1649: break;
1650: case 'l':
1651: (*mangled)++;
1652: APPEND_BLANK (result);
1653: string_append (result, "long");
1654: break;
1655: case 'i':
1656: (*mangled)++;
1657: APPEND_BLANK (result);
1658: string_append (result, "int");
1659: break;
1660: case 's':
1661: (*mangled)++;
1662: APPEND_BLANK (result);
1663: string_append (result, "short");
1664: break;
1665: case 'c':
1666: (*mangled)++;
1667: APPEND_BLANK (result);
1668: string_append (result, "char");
1669: break;
1670: case 'r':
1671: (*mangled)++;
1672: APPEND_BLANK (result);
1673: string_append (result, "long double");
1674: break;
1675: case 'd':
1676: (*mangled)++;
1677: APPEND_BLANK (result);
1678: string_append (result, "double");
1679: break;
1680: case 'f':
1681: (*mangled)++;
1682: APPEND_BLANK (result);
1683: string_append (result, "float");
1684: break;
1685: case 'G':
1686: (*mangled)++;
1687: if (!isdigit (**mangled))
1688: {
1689: success = 0;
1690: break;
1691: }
1692: /* fall through */
1693: /* An explicit type, such as "6mytype" or "7integer" */
1694: case '0':
1695: case '1':
1696: case '2':
1697: case '3':
1698: case '4':
1699: case '5':
1700: case '6':
1701: case '7':
1702: case '8':
1703: case '9':
1704: n = consume_count (mangled);
1705: if (strlen (*mangled) < n)
1706: {
1707: success = 0;
1708: break;
1709: }
1710: APPEND_BLANK (result);
1711: string_appendn (result, *mangled, n);
1712: *mangled += n;
1713: break;
1714: default:
1715: success = 0;
1716: break;
1717: }
1718:
1719: return (success);
1720: }
1721:
1722: /* `result' will be initialized in do_type; it will be freed on failure */
1723:
1724: static int
1725: do_arg (work, mangled, result)
1726: struct work_stuff *work;
1727: CONST char **mangled;
1728: string *result;
1729: {
1730: CONST char *start = *mangled;
1731:
1732: if (!do_type (work, mangled, result))
1733: {
1734: return (0);
1735: }
1736: else
1737: {
1738: remember_type (work, start, *mangled - start);
1739: return (1);
1740: }
1741: }
1742:
1743: static void
1744: remember_type (work, start, len)
1745: struct work_stuff *work;
1746: CONST char *start;
1747: int len;
1748: {
1749: char *tem;
1750:
1751: if (work -> ntypes >= work -> typevec_size)
1752: {
1753: if (work -> typevec_size == 0)
1754: {
1755: work -> typevec_size = 3;
1756: work -> typevec =
1757: (char **) xmalloc (sizeof (char *) * work -> typevec_size);
1758: }
1759: else
1760: {
1761: work -> typevec_size *= 2;
1762: work -> typevec =
1763: (char **) xrealloc ((char *)work -> typevec,
1764: sizeof (char *) * work -> typevec_size);
1765: }
1766: }
1767: tem = (char *) xmalloc (len + 1);
1768: memcpy (tem, start, len);
1769: tem[len] = '\0';
1770: work -> typevec[work -> ntypes++] = tem;
1771: }
1772:
1773: /* Forget the remembered types, but not the type vector itself. */
1774:
1775: static void
1776: forget_types (work)
1777: struct work_stuff *work;
1778: {
1779: int i;
1780:
1781: while (work -> ntypes > 0)
1782: {
1783: i = --(work -> ntypes);
1784: if (work -> typevec[i] != NULL)
1785: {
1786: free (work -> typevec[i]);
1787: work -> typevec[i] = NULL;
1788: }
1789: }
1790: }
1791:
1792: /* Process the argument list part of the signature, after any class spec
1793: has been consumed, as well as the first 'F' character (if any). For
1794: example:
1795:
1796: "__als__3fooRT0" => process "RT0"
1797: "complexfunc5__FPFPc_PFl_i" => process "PFPc_PFl_i"
1798:
1799: DECLP must be already initialised, usually non-empty. It won't be freed
1800: on failure.
1801:
1802: Note that g++ differs significantly from cfront and lucid style mangling
1803: with regards to references to previously seen types. For example, given
1804: the source fragment:
1805:
1806: class foo {
1807: public:
1808: foo::foo (int, foo &ia, int, foo &ib, int, foo &ic);
1809: };
1810:
1811: foo::foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
1812: void foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
1813:
1814: g++ produces the names:
1815:
1816: __3fooiRT0iT2iT2
1817: foo__FiR3fooiT1iT1
1818:
1819: while lcc (and presumably cfront as well) produces:
1820:
1821: foo__FiR3fooT1T2T1T2
1822: __ct__3fooFiR3fooT1T2T1T2
1823:
1824: Note that g++ bases it's type numbers starting at zero and counts all
1825: previously seen types, while lucid/cfront bases it's type numbers starting
1826: at one and only considers types after it has seen the 'F' character
1827: indicating the start of the function args. For lucid/cfront style, we
1828: account for this difference by discarding any previously seen types when
1829: we see the 'F' character, and subtracting one from the type number
1830: reference.
1831:
1832: */
1833:
1834: static int
1835: demangle_args (work, mangled, declp)
1836: struct work_stuff *work;
1837: CONST char **mangled;
1838: string *declp;
1839: {
1840: string arg;
1841: int need_comma = 0;
1842: int r;
1843: int t;
1844: CONST char *tem;
1845: char temptype;
1846:
1847: if (PRINT_ARG_TYPES)
1848: {
1849: string_append (declp, "(");
1850: if (**mangled == '\0')
1851: {
1852: string_append (declp, "void");
1853: }
1854: }
1855:
1856: while (**mangled != '_' && **mangled != '\0' && **mangled != 'e')
1857: {
1858: if ((**mangled == 'N') || (**mangled == 'T'))
1859: {
1860: temptype = *(*mangled)++;
1861:
1862: if (temptype == 'N')
1863: {
1864: if (!get_count (mangled, &r))
1865: {
1866: return (0);
1867: }
1868: }
1869: else
1870: {
1871: r = 1;
1872: }
1873: if (!get_count (mangled, &t))
1874: {
1875: return (0);
1876: }
1877: if (LUCID_DEMANGLING || CFRONT_DEMANGLING)
1878: {
1879: t--;
1880: }
1881: /* Validate the type index. Protect against illegal indices from
1882: malformed type strings. */
1883: if ((t < 0) || (t >= work -> ntypes))
1884: {
1885: return (0);
1886: }
1887: while (--r >= 0)
1888: {
1889: tem = work -> typevec[t];
1890: if (need_comma && PRINT_ARG_TYPES)
1891: {
1892: string_append (declp, ", ");
1893: }
1894: if (!do_arg (work, &tem, &arg))
1895: {
1896: return (0);
1897: }
1898: if (PRINT_ARG_TYPES)
1899: {
1900: string_appends (declp, &arg);
1901: }
1902: string_delete (&arg);
1903: need_comma = 1;
1904: }
1905: }
1906: else
1907: {
1908: if (need_comma & PRINT_ARG_TYPES)
1909: {
1910: string_append (declp, ", ");
1911: }
1912: if (!do_arg (work, mangled, &arg))
1913: {
1914: return (0);
1915: }
1916: if (PRINT_ARG_TYPES)
1917: {
1918: string_appends (declp, &arg);
1919: }
1920: string_delete (&arg);
1921: need_comma = 1;
1922: }
1923: }
1924:
1925: if (**mangled == 'e')
1926: {
1927: (*mangled)++;
1928: if (PRINT_ARG_TYPES)
1929: {
1930: if (need_comma)
1931: {
1932: string_append (declp, ",");
1933: }
1934: string_append (declp, "...");
1935: }
1936: }
1937:
1938: if (PRINT_ARG_TYPES)
1939: {
1940: string_append (declp, ")");
1941: }
1942: return (1);
1943: }
1944:
1945: static void
1946: demangle_function_name (work, mangled, declp, scan)
1947: struct work_stuff *work;
1948: CONST char **mangled;
1949: string *declp;
1950: CONST char *scan;
1951: {
1952: int i;
1953: int len;
1954: string type;
1955: CONST char *tem;
1956:
1957: string_appendn (declp, (*mangled), scan - (*mangled));
1958: string_need (declp, 1);
1959: *(declp -> p) = '\0';
1960:
1961: /* Consume the function name, including the "__" separating the name
1962: from the signature. We are guaranteed that SCAN points to the
1963: separator. */
1964:
1965: (*mangled) = scan + 2;
1966:
1967: if (LUCID_DEMANGLING || CFRONT_DEMANGLING)
1968: {
1969:
1970: /* See if we have an ARM style constructor or destructor operator.
1971: If so, then just record it, clear the decl, and return.
1972: We can't build the actual constructor/destructor decl until later,
1973: when we recover the class name from the signature. */
1974:
1975: if (strcmp (declp -> b, "__ct") == 0)
1976: {
1977: work -> constructor = 1;
1978: string_clear (declp);
1979: return;
1980: }
1981: else if (strcmp (declp -> b, "__dt") == 0)
1982: {
1983: work -> destructor = 1;
1984: string_clear (declp);
1985: return;
1986: }
1987: }
1988:
1989: if (declp->p - declp->b >= 3
1990: && declp->b[0] == 'o'
1991: && declp->b[1] == 'p'
1992: && strchr (cplus_markers, declp->b[2]) != NULL)
1993: {
1994: /* see if it's an assignment expression */
1995: if (declp->p - declp->b >= 10 /* op$assign_ */
1996: && memcmp (declp->b + 3, "assign_", 7) == 0)
1997: {
1998: for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++)
1999: {
2000: len = declp->p - declp->b - 10;
2001: if (strlen (optable[i].in) == len
2002: && memcmp (optable[i].in, declp->b + 10, len) == 0)
2003: {
2004: string_clear (declp);
2005: string_append (declp, "operator");
2006: string_append (declp, optable[i].out);
2007: string_append (declp, "=");
2008: break;
2009: }
2010: }
2011: }
2012: else
2013: {
2014: for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++)
2015: {
2016: int len = declp->p - declp->b - 3;
2017: if (strlen (optable[i].in) == len
2018: && memcmp (optable[i].in, declp->b + 3, len) == 0)
2019: {
2020: string_clear (declp);
2021: string_append (declp, "operator");
2022: string_append (declp, optable[i].out);
2023: break;
2024: }
2025: }
2026: }
2027: }
2028: else if (declp->p - declp->b >= 5 && memcmp (declp->b, "type$", 5) == 0)
2029: {
2030: /* type conversion operator */
2031: tem = declp->b + 5;
2032: if (do_type (work, &tem, &type))
2033: {
2034: string_clear (declp);
2035: string_append (declp, "operator ");
2036: string_appends (declp, &type);
2037: string_delete (&type);
2038: }
2039: }
2040: else if (declp->b[2] == 'o' && declp->b[3] == 'p')
2041: {
2042: /* ANSI. */
2043: /* type conversion operator. */
2044: tem = declp->b + 4;
2045: if (do_type (work, &tem, &type))
2046: {
2047: string_clear (declp);
2048: string_append (declp, "operator ");
2049: string_appends (declp, &type);
2050: string_delete (&type);
2051: }
2052: }
2053: else if (declp->b[0] == '_' && declp->b[1] == '_'
2054: && declp->b[2] >= 'a' && declp->b[2] <= 'z'
2055: && declp->b[3] >= 'a' && declp->b[3] <= 'z')
2056: {
2057: if (declp->b[4] == '\0')
2058: {
2059: /* Operator. */
2060: for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++)
2061: {
2062: if (strlen (optable[i].in) == 2
2063: && memcmp (optable[i].in, declp->b + 2, 2) == 0)
2064: {
2065: string_clear (declp);
2066: string_append (declp, "operator");
2067: string_append (declp, optable[i].out);
2068: break;
2069: }
2070: }
2071: }
2072: else
2073: {
2074: if (declp->b[2] == 'a' && declp->b[5] == '\0')
2075: {
2076: /* Assignment. */
2077: for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++)
2078: {
2079: if (strlen (optable[i].in) == 3
2080: && memcmp (optable[i].in, declp->b + 2, 3) == 0)
2081: {
2082: string_clear (declp);
2083: string_append (declp, "operator");
2084: string_append (declp, optable[i].out);
2085: break;
2086: }
2087: }
2088: }
2089: }
2090: }
2091: }
2092:
2093: /* a mini string-handling package */
2094:
2095: static void
2096: string_need (s, n)
2097: string *s;
2098: int n;
2099: {
2100: int tem;
2101:
2102: if (s->b == NULL)
2103: {
2104: if (n < 32)
2105: {
2106: n = 32;
2107: }
2108: s->p = s->b = (char *) xmalloc (n);
2109: s->e = s->b + n;
2110: }
2111: else if (s->e - s->p < n)
2112: {
2113: tem = s->p - s->b;
2114: n += tem;
2115: n *= 2;
2116: s->b = (char *) xrealloc (s->b, n);
2117: s->p = s->b + tem;
2118: s->e = s->b + n;
2119: }
2120: }
2121:
2122: static void
2123: string_delete (s)
2124: string *s;
2125: {
2126: if (s->b != NULL)
2127: {
2128: free (s->b);
2129: s->b = s->e = s->p = NULL;
2130: }
2131: }
2132:
2133: static void
2134: string_init (s)
2135: string *s;
2136: {
2137: s->b = s->p = s->e = NULL;
2138: }
2139:
2140: static void
2141: string_clear (s)
2142: string *s;
2143: {
2144: s->p = s->b;
2145: }
2146:
2147: #if 0
2148:
2149: static int
2150: string_empty (s)
2151: string *s;
2152: {
2153: return (s->b == s->p);
2154: }
2155:
2156: #endif
2157:
2158: static void
2159: string_append (p, s)
2160: string *p;
2161: CONST char *s;
2162: {
2163: int n;
2164: if (s == NULL || *s == '\0')
2165: return;
2166: n = strlen (s);
2167: string_need (p, n);
2168: memcpy (p->p, s, n);
2169: p->p += n;
2170: }
2171:
2172: static void
2173: string_appends (p, s)
2174: string *p, *s;
2175: {
2176: int n;
2177:
2178: if (s->b != s->p)
2179: {
2180: n = s->p - s->b;
2181: string_need (p, n);
2182: memcpy (p->p, s->b, n);
2183: p->p += n;
2184: }
2185: }
2186:
2187: static void
2188: string_appendn (p, s, n)
2189: string *p;
2190: CONST char *s;
2191: int n;
2192: {
2193: if (n != 0)
2194: {
2195: string_need (p, n);
2196: memcpy (p->p, s, n);
2197: p->p += n;
2198: }
2199: }
2200:
2201: static void
2202: string_prepend (p, s)
2203: string *p;
2204: CONST char *s;
2205: {
2206: if (s != NULL && *s != '\0')
2207: {
2208: string_prependn (p, s, strlen (s));
2209: }
2210: }
2211:
2212: static void
2213: string_prepends (p, s)
2214: string *p, *s;
2215: {
2216: if (s->b != s->p)
2217: {
2218: string_prependn (p, s->b, s->p - s->b);
2219: }
2220: }
2221:
2222: static void
2223: string_prependn (p, s, n)
2224: string *p;
2225: CONST char *s;
2226: int n;
2227: {
2228: char *q;
2229:
2230: if (n != 0)
2231: {
2232: string_need (p, n);
2233: for (q = p->p - 1; q >= p->b; q--)
2234: {
2235: q[n] = q[0];
2236: }
2237: memcpy (p->b, s, n);
2238: p->p += n;
2239: }
2240: }
2241:
2242: /* To generate a standalone demangler program for testing purposes, just
2243: compile and link this file with -DMAIN. When run, it demangles each
2244: command line arg, or each stdin string, and prints the result on stdout. */
2245:
2246: #ifdef MAIN
2247:
2248: static void
2249: demangle_it (mangled_name)
2250: char *mangled_name;
2251: {
2252: char *result;
2253:
2254: result = cplus_demangle (mangled_name, DMGL_PARAMS | DMGL_ANSI);
2255: if (result == NULL)
2256: {
2257: printf ("%s\n", mangled_name);
2258: }
2259: else
2260: {
2261: printf ("%s\n", result);
2262: free (result);
2263: }
2264: }
2265:
2266: PTR
2267: xmalloc (size)
2268: long size;
2269: {
2270: PTR newmem;
2271:
2272: if ((newmem = malloc ((int) size)) == NULL)
2273: {
2274: fprintf (stderr, "\nCan't allocate %u bytes\n", size);
2275: exit (1);
2276: }
2277: return (newmem);
2278: }
2279:
2280: PTR
2281: xrealloc (oldmem, size)
2282: PTR oldmem;
2283: long size;
2284: {
2285: PTR newmem;
2286:
2287: if ((newmem = realloc ((char *) oldmem, (int) size)) == NULL)
2288: {
2289: fprintf (stderr, "\nCan't reallocate %u bytes\n", size);
2290: exit (1);
2291: }
2292: return (newmem);
2293: }
2294:
2295: main (argc, argv)
2296: int argc;
2297: char **argv;
2298: {
2299: char mangled_name[128];
2300: char *result;
2301: int c;
2302: extern char *optarg;
2303: extern int optind;
2304:
2305: while ((c = getopt (argc, argv, "s:?")) != EOF)
2306: {
2307: switch (c)
2308: {
2309: case '?':
2310: fprintf (stderr, "usage: demangle [-s style] [arg1 [arg2]] ...\n");
2311: fprintf (stderr, "style = { gnu, lucid, cfront }\n");
2312: fprintf (stderr, "reads args from stdin if none supplied\n");
2313: exit (0);
2314: break;
2315: case 's':
2316: if (strcmp (optarg, "gnu") == 0)
2317: {
2318: current_demangling_style = gnu_demangling;
2319: }
2320: else if (strcmp (optarg, "lucid") == 0)
2321: {
2322: current_demangling_style = lucid_demangling;
2323: }
2324: else if (strcmp (optarg, "cfront") == 0)
2325: {
2326: current_demangling_style = cfront_demangling;
2327: }
2328: else
2329: {
2330: fprintf (stderr, "unknown demangling style `%s'\n", optarg);
2331: exit (1);
2332: }
2333: break;
2334: }
2335: }
2336: if (optind < argc)
2337: {
2338: for ( ; optind < argc; optind++)
2339: {
2340: demangle_it (argv[optind]);
2341: }
2342: }
2343: else
2344: {
2345: while (gets (mangled_name))
2346: {
2347: demangle_it (mangled_name);
2348: }
2349: }
2350: }
2351:
2352: #endif /* main */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.