pr54920.c: Add "-fno-common" option on hppa*-*-hpux*.
[official-gcc.git] / libiberty / cplus-dem.c
blobe94848767e780847ca9e4bd6f879906c72d99fcf
1 /* Demangler for GNU C++
2 Copyright 1989, 1991, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2010 Free Software Foundation, Inc.
4 Written by James Clark (jjc@jclark.uucp)
5 Rewritten by Fred Fish (fnf@cygnus.com) for ARM and Lucid demangling
6 Modified by Satish Pai (pai@apollo.hp.com) for HP demangling
8 This file is part of the libiberty library.
9 Libiberty is free software; you can redistribute it and/or
10 modify it under the terms of the GNU Library General Public
11 License as published by the Free Software Foundation; either
12 version 2 of the License, or (at your option) any later version.
14 In addition to the permissions in the GNU Library General Public
15 License, the Free Software Foundation gives you unlimited permission
16 to link the compiled version of this file into combinations with other
17 programs, and to distribute those combinations without any restriction
18 coming from the use of this file. (The Library Public License
19 restrictions do apply in other respects; for example, they cover
20 modification of the file, and distribution when not linked into a
21 combined executable.)
23 Libiberty is distributed in the hope that it will be useful,
24 but WITHOUT ANY WARRANTY; without even the implied warranty of
25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
26 Library General Public License for more details.
28 You should have received a copy of the GNU Library General Public
29 License along with libiberty; see the file COPYING.LIB. If
30 not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
31 Boston, MA 02110-1301, USA. */
33 /* This file exports two functions; cplus_mangle_opname and cplus_demangle.
35 This file imports xmalloc and xrealloc, which are like malloc and
36 realloc except that they generate a fatal error if there is no
37 available memory. */
39 /* This file lives in both GCC and libiberty. When making changes, please
40 try not to break either. */
42 #ifdef HAVE_CONFIG_H
43 #include "config.h"
44 #endif
46 #include "safe-ctype.h"
48 #include <sys/types.h>
49 #include <string.h>
50 #include <stdio.h>
52 #ifdef HAVE_STDLIB_H
53 #include <stdlib.h>
54 #else
55 void * malloc ();
56 void * realloc ();
57 #endif
59 #include <demangle.h>
60 #undef CURRENT_DEMANGLING_STYLE
61 #define CURRENT_DEMANGLING_STYLE work->options
63 #include "libiberty.h"
65 #define min(X,Y) (((X) < (Y)) ? (X) : (Y))
67 /* A value at least one greater than the maximum number of characters
68 that will be output when using the `%d' format with `printf'. */
69 #define INTBUF_SIZE 32
71 extern void fancy_abort (void) ATTRIBUTE_NORETURN;
73 /* In order to allow a single demangler executable to demangle strings
74 using various common values of CPLUS_MARKER, as well as any specific
75 one set at compile time, we maintain a string containing all the
76 commonly used ones, and check to see if the marker we are looking for
77 is in that string. CPLUS_MARKER is usually '$' on systems where the
78 assembler can deal with that. Where the assembler can't, it's usually
79 '.' (but on many systems '.' is used for other things). We put the
80 current defined CPLUS_MARKER first (which defaults to '$'), followed
81 by the next most common value, followed by an explicit '$' in case
82 the value of CPLUS_MARKER is not '$'.
84 We could avoid this if we could just get g++ to tell us what the actual
85 cplus marker character is as part of the debug information, perhaps by
86 ensuring that it is the character that terminates the gcc<n>_compiled
87 marker symbol (FIXME). */
89 #if !defined (CPLUS_MARKER)
90 #define CPLUS_MARKER '$'
91 #endif
93 enum demangling_styles current_demangling_style = auto_demangling;
95 static char cplus_markers[] = { CPLUS_MARKER, '.', '$', '\0' };
97 static char char_str[2] = { '\000', '\000' };
99 void
100 set_cplus_marker_for_demangling (int ch)
102 cplus_markers[0] = ch;
105 typedef struct string /* Beware: these aren't required to be */
106 { /* '\0' terminated. */
107 char *b; /* pointer to start of string */
108 char *p; /* pointer after last character */
109 char *e; /* pointer after end of allocated space */
110 } string;
112 /* Stuff that is shared between sub-routines.
113 Using a shared structure allows cplus_demangle to be reentrant. */
115 struct work_stuff
117 int options;
118 char **typevec;
119 char **ktypevec;
120 char **btypevec;
121 int numk;
122 int numb;
123 int ksize;
124 int bsize;
125 int ntypes;
126 int typevec_size;
127 int constructor;
128 int destructor;
129 int static_type; /* A static member function */
130 int temp_start; /* index in demangled to start of template args */
131 int type_quals; /* The type qualifiers. */
132 int dllimported; /* Symbol imported from a PE DLL */
133 char **tmpl_argvec; /* Template function arguments. */
134 int ntmpl_args; /* The number of template function arguments. */
135 int forgetting_types; /* Nonzero if we are not remembering the types
136 we see. */
137 string* previous_argument; /* The last function argument demangled. */
138 int nrepeats; /* The number of times to repeat the previous
139 argument. */
142 #define PRINT_ANSI_QUALIFIERS (work -> options & DMGL_ANSI)
143 #define PRINT_ARG_TYPES (work -> options & DMGL_PARAMS)
145 static const struct optable
147 const char *const in;
148 const char *const out;
149 const int flags;
150 } optable[] = {
151 {"nw", " new", DMGL_ANSI}, /* new (1.92, ansi) */
152 {"dl", " delete", DMGL_ANSI}, /* new (1.92, ansi) */
153 {"new", " new", 0}, /* old (1.91, and 1.x) */
154 {"delete", " delete", 0}, /* old (1.91, and 1.x) */
155 {"vn", " new []", DMGL_ANSI}, /* GNU, pending ansi */
156 {"vd", " delete []", DMGL_ANSI}, /* GNU, pending ansi */
157 {"as", "=", DMGL_ANSI}, /* ansi */
158 {"ne", "!=", DMGL_ANSI}, /* old, ansi */
159 {"eq", "==", DMGL_ANSI}, /* old, ansi */
160 {"ge", ">=", DMGL_ANSI}, /* old, ansi */
161 {"gt", ">", DMGL_ANSI}, /* old, ansi */
162 {"le", "<=", DMGL_ANSI}, /* old, ansi */
163 {"lt", "<", DMGL_ANSI}, /* old, ansi */
164 {"plus", "+", 0}, /* old */
165 {"pl", "+", DMGL_ANSI}, /* ansi */
166 {"apl", "+=", DMGL_ANSI}, /* ansi */
167 {"minus", "-", 0}, /* old */
168 {"mi", "-", DMGL_ANSI}, /* ansi */
169 {"ami", "-=", DMGL_ANSI}, /* ansi */
170 {"mult", "*", 0}, /* old */
171 {"ml", "*", DMGL_ANSI}, /* ansi */
172 {"amu", "*=", DMGL_ANSI}, /* ansi (ARM/Lucid) */
173 {"aml", "*=", DMGL_ANSI}, /* ansi (GNU/g++) */
174 {"convert", "+", 0}, /* old (unary +) */
175 {"negate", "-", 0}, /* old (unary -) */
176 {"trunc_mod", "%", 0}, /* old */
177 {"md", "%", DMGL_ANSI}, /* ansi */
178 {"amd", "%=", DMGL_ANSI}, /* ansi */
179 {"trunc_div", "/", 0}, /* old */
180 {"dv", "/", DMGL_ANSI}, /* ansi */
181 {"adv", "/=", DMGL_ANSI}, /* ansi */
182 {"truth_andif", "&&", 0}, /* old */
183 {"aa", "&&", DMGL_ANSI}, /* ansi */
184 {"truth_orif", "||", 0}, /* old */
185 {"oo", "||", DMGL_ANSI}, /* ansi */
186 {"truth_not", "!", 0}, /* old */
187 {"nt", "!", DMGL_ANSI}, /* ansi */
188 {"postincrement","++", 0}, /* old */
189 {"pp", "++", DMGL_ANSI}, /* ansi */
190 {"postdecrement","--", 0}, /* old */
191 {"mm", "--", DMGL_ANSI}, /* ansi */
192 {"bit_ior", "|", 0}, /* old */
193 {"or", "|", DMGL_ANSI}, /* ansi */
194 {"aor", "|=", DMGL_ANSI}, /* ansi */
195 {"bit_xor", "^", 0}, /* old */
196 {"er", "^", DMGL_ANSI}, /* ansi */
197 {"aer", "^=", DMGL_ANSI}, /* ansi */
198 {"bit_and", "&", 0}, /* old */
199 {"ad", "&", DMGL_ANSI}, /* ansi */
200 {"aad", "&=", DMGL_ANSI}, /* ansi */
201 {"bit_not", "~", 0}, /* old */
202 {"co", "~", DMGL_ANSI}, /* ansi */
203 {"call", "()", 0}, /* old */
204 {"cl", "()", DMGL_ANSI}, /* ansi */
205 {"alshift", "<<", 0}, /* old */
206 {"ls", "<<", DMGL_ANSI}, /* ansi */
207 {"als", "<<=", DMGL_ANSI}, /* ansi */
208 {"arshift", ">>", 0}, /* old */
209 {"rs", ">>", DMGL_ANSI}, /* ansi */
210 {"ars", ">>=", DMGL_ANSI}, /* ansi */
211 {"component", "->", 0}, /* old */
212 {"pt", "->", DMGL_ANSI}, /* ansi; Lucid C++ form */
213 {"rf", "->", DMGL_ANSI}, /* ansi; ARM/GNU form */
214 {"indirect", "*", 0}, /* old */
215 {"method_call", "->()", 0}, /* old */
216 {"addr", "&", 0}, /* old (unary &) */
217 {"array", "[]", 0}, /* old */
218 {"vc", "[]", DMGL_ANSI}, /* ansi */
219 {"compound", ", ", 0}, /* old */
220 {"cm", ", ", DMGL_ANSI}, /* ansi */
221 {"cond", "?:", 0}, /* old */
222 {"cn", "?:", DMGL_ANSI}, /* pseudo-ansi */
223 {"max", ">?", 0}, /* old */
224 {"mx", ">?", DMGL_ANSI}, /* pseudo-ansi */
225 {"min", "<?", 0}, /* old */
226 {"mn", "<?", DMGL_ANSI}, /* pseudo-ansi */
227 {"nop", "", 0}, /* old (for operator=) */
228 {"rm", "->*", DMGL_ANSI}, /* ansi */
229 {"sz", "sizeof ", DMGL_ANSI} /* pseudo-ansi */
232 /* These values are used to indicate the various type varieties.
233 They are all non-zero so that they can be used as `success'
234 values. */
235 typedef enum type_kind_t
237 tk_none,
238 tk_pointer,
239 tk_reference,
240 tk_integral,
241 tk_bool,
242 tk_char,
243 tk_real
244 } type_kind_t;
246 const struct demangler_engine libiberty_demanglers[] =
249 NO_DEMANGLING_STYLE_STRING,
250 no_demangling,
251 "Demangling disabled"
255 AUTO_DEMANGLING_STYLE_STRING,
256 auto_demangling,
257 "Automatic selection based on executable"
261 GNU_DEMANGLING_STYLE_STRING,
262 gnu_demangling,
263 "GNU (g++) style demangling"
267 LUCID_DEMANGLING_STYLE_STRING,
268 lucid_demangling,
269 "Lucid (lcc) style demangling"
273 ARM_DEMANGLING_STYLE_STRING,
274 arm_demangling,
275 "ARM style demangling"
279 HP_DEMANGLING_STYLE_STRING,
280 hp_demangling,
281 "HP (aCC) style demangling"
285 EDG_DEMANGLING_STYLE_STRING,
286 edg_demangling,
287 "EDG style demangling"
291 GNU_V3_DEMANGLING_STYLE_STRING,
292 gnu_v3_demangling,
293 "GNU (g++) V3 ABI-style demangling"
297 JAVA_DEMANGLING_STYLE_STRING,
298 java_demangling,
299 "Java style demangling"
303 GNAT_DEMANGLING_STYLE_STRING,
304 gnat_demangling,
305 "GNAT style demangling"
309 NULL, unknown_demangling, NULL
313 #define STRING_EMPTY(str) ((str) -> b == (str) -> p)
314 #define APPEND_BLANK(str) {if (!STRING_EMPTY(str)) \
315 string_append(str, " ");}
316 #define LEN_STRING(str) ( (STRING_EMPTY(str))?0:((str)->p - (str)->b))
318 /* The scope separator appropriate for the language being demangled. */
320 #define SCOPE_STRING(work) ((work->options & DMGL_JAVA) ? "." : "::")
322 #define ARM_VTABLE_STRING "__vtbl__" /* Lucid/ARM virtual table prefix */
323 #define ARM_VTABLE_STRLEN 8 /* strlen (ARM_VTABLE_STRING) */
325 /* Prototypes for local functions */
327 static void delete_work_stuff (struct work_stuff *);
329 static void delete_non_B_K_work_stuff (struct work_stuff *);
331 static char *mop_up (struct work_stuff *, string *, int);
333 static void squangle_mop_up (struct work_stuff *);
335 static void work_stuff_copy_to_from (struct work_stuff *, struct work_stuff *);
337 #if 0
338 static int
339 demangle_method_args (struct work_stuff *, const char **, string *);
340 #endif
342 static char *
343 internal_cplus_demangle (struct work_stuff *, const char *);
345 static int
346 demangle_template_template_parm (struct work_stuff *work,
347 const char **, string *);
349 static int
350 demangle_template (struct work_stuff *work, const char **, string *,
351 string *, int, int);
353 static int
354 arm_pt (struct work_stuff *, const char *, int, const char **,
355 const char **);
357 static int
358 demangle_class_name (struct work_stuff *, const char **, string *);
360 static int
361 demangle_qualified (struct work_stuff *, const char **, string *,
362 int, int);
364 static int demangle_class (struct work_stuff *, const char **, string *);
366 static int demangle_fund_type (struct work_stuff *, const char **, string *);
368 static int demangle_signature (struct work_stuff *, const char **, string *);
370 static int demangle_prefix (struct work_stuff *, const char **, string *);
372 static int gnu_special (struct work_stuff *, const char **, string *);
374 static int arm_special (const char **, string *);
376 static void string_need (string *, int);
378 static void string_delete (string *);
380 static void
381 string_init (string *);
383 static void string_clear (string *);
385 #if 0
386 static int string_empty (string *);
387 #endif
389 static void string_append (string *, const char *);
391 static void string_appends (string *, string *);
393 static void string_appendn (string *, const char *, int);
395 static void string_prepend (string *, const char *);
397 static void string_prependn (string *, const char *, int);
399 static void string_append_template_idx (string *, int);
401 static int get_count (const char **, int *);
403 static int consume_count (const char **);
405 static int consume_count_with_underscores (const char**);
407 static int demangle_args (struct work_stuff *, const char **, string *);
409 static int demangle_nested_args (struct work_stuff*, const char**, string*);
411 static int do_type (struct work_stuff *, const char **, string *);
413 static int do_arg (struct work_stuff *, const char **, string *);
415 static int
416 demangle_function_name (struct work_stuff *, const char **, string *,
417 const char *);
419 static int
420 iterate_demangle_function (struct work_stuff *,
421 const char **, string *, const char *);
423 static void remember_type (struct work_stuff *, const char *, int);
425 static void remember_Btype (struct work_stuff *, const char *, int, int);
427 static int register_Btype (struct work_stuff *);
429 static void remember_Ktype (struct work_stuff *, const char *, int);
431 static void forget_types (struct work_stuff *);
433 static void forget_B_and_K_types (struct work_stuff *);
435 static void string_prepends (string *, string *);
437 static int
438 demangle_template_value_parm (struct work_stuff*, const char**,
439 string*, type_kind_t);
441 static int
442 do_hpacc_template_const_value (struct work_stuff *, const char **, string *);
444 static int
445 do_hpacc_template_literal (struct work_stuff *, const char **, string *);
447 static int snarf_numeric_literal (const char **, string *);
449 /* There is a TYPE_QUAL value for each type qualifier. They can be
450 combined by bitwise-or to form the complete set of qualifiers for a
451 type. */
453 #define TYPE_UNQUALIFIED 0x0
454 #define TYPE_QUAL_CONST 0x1
455 #define TYPE_QUAL_VOLATILE 0x2
456 #define TYPE_QUAL_RESTRICT 0x4
458 static int code_for_qualifier (int);
460 static const char* qualifier_string (int);
462 static const char* demangle_qualifier (int);
464 static int demangle_expression (struct work_stuff *, const char **, string *,
465 type_kind_t);
467 static int
468 demangle_integral_value (struct work_stuff *, const char **, string *);
470 static int
471 demangle_real_value (struct work_stuff *, const char **, string *);
473 static void
474 demangle_arm_hp_template (struct work_stuff *, const char **, int, string *);
476 static void
477 recursively_demangle (struct work_stuff *, const char **, string *, int);
479 /* Translate count to integer, consuming tokens in the process.
480 Conversion terminates on the first non-digit character.
482 Trying to consume something that isn't a count results in no
483 consumption of input and a return of -1.
485 Overflow consumes the rest of the digits, and returns -1. */
487 static int
488 consume_count (const char **type)
490 int count = 0;
492 if (! ISDIGIT ((unsigned char)**type))
493 return -1;
495 while (ISDIGIT ((unsigned char)**type))
497 count *= 10;
499 /* Check for overflow.
500 We assume that count is represented using two's-complement;
501 no power of two is divisible by ten, so if an overflow occurs
502 when multiplying by ten, the result will not be a multiple of
503 ten. */
504 if ((count % 10) != 0)
506 while (ISDIGIT ((unsigned char) **type))
507 (*type)++;
508 return -1;
511 count += **type - '0';
512 (*type)++;
515 if (count < 0)
516 count = -1;
518 return (count);
522 /* Like consume_count, but for counts that are preceded and followed
523 by '_' if they are greater than 10. Also, -1 is returned for
524 failure, since 0 can be a valid value. */
526 static int
527 consume_count_with_underscores (const char **mangled)
529 int idx;
531 if (**mangled == '_')
533 (*mangled)++;
534 if (!ISDIGIT ((unsigned char)**mangled))
535 return -1;
537 idx = consume_count (mangled);
538 if (**mangled != '_')
539 /* The trailing underscore was missing. */
540 return -1;
542 (*mangled)++;
544 else
546 if (**mangled < '0' || **mangled > '9')
547 return -1;
549 idx = **mangled - '0';
550 (*mangled)++;
553 return idx;
556 /* C is the code for a type-qualifier. Return the TYPE_QUAL
557 corresponding to this qualifier. */
559 static int
560 code_for_qualifier (int c)
562 switch (c)
564 case 'C':
565 return TYPE_QUAL_CONST;
567 case 'V':
568 return TYPE_QUAL_VOLATILE;
570 case 'u':
571 return TYPE_QUAL_RESTRICT;
573 default:
574 break;
577 /* C was an invalid qualifier. */
578 abort ();
581 /* Return the string corresponding to the qualifiers given by
582 TYPE_QUALS. */
584 static const char*
585 qualifier_string (int type_quals)
587 switch (type_quals)
589 case TYPE_UNQUALIFIED:
590 return "";
592 case TYPE_QUAL_CONST:
593 return "const";
595 case TYPE_QUAL_VOLATILE:
596 return "volatile";
598 case TYPE_QUAL_RESTRICT:
599 return "__restrict";
601 case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE:
602 return "const volatile";
604 case TYPE_QUAL_CONST | TYPE_QUAL_RESTRICT:
605 return "const __restrict";
607 case TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT:
608 return "volatile __restrict";
610 case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT:
611 return "const volatile __restrict";
613 default:
614 break;
617 /* TYPE_QUALS was an invalid qualifier set. */
618 abort ();
621 /* C is the code for a type-qualifier. Return the string
622 corresponding to this qualifier. This function should only be
623 called with a valid qualifier code. */
625 static const char*
626 demangle_qualifier (int c)
628 return qualifier_string (code_for_qualifier (c));
632 cplus_demangle_opname (const char *opname, char *result, int options)
634 int len, len1, ret;
635 string type;
636 struct work_stuff work[1];
637 const char *tem;
639 len = strlen(opname);
640 result[0] = '\0';
641 ret = 0;
642 memset ((char *) work, 0, sizeof (work));
643 work->options = options;
645 if (opname[0] == '_' && opname[1] == '_'
646 && opname[2] == 'o' && opname[3] == 'p')
648 /* ANSI. */
649 /* type conversion operator. */
650 tem = opname + 4;
651 if (do_type (work, &tem, &type))
653 strcat (result, "operator ");
654 strncat (result, type.b, type.p - type.b);
655 string_delete (&type);
656 ret = 1;
659 else if (opname[0] == '_' && opname[1] == '_'
660 && ISLOWER((unsigned char)opname[2])
661 && ISLOWER((unsigned char)opname[3]))
663 if (opname[4] == '\0')
665 /* Operator. */
666 size_t i;
667 for (i = 0; i < ARRAY_SIZE (optable); i++)
669 if (strlen (optable[i].in) == 2
670 && memcmp (optable[i].in, opname + 2, 2) == 0)
672 strcat (result, "operator");
673 strcat (result, optable[i].out);
674 ret = 1;
675 break;
679 else
681 if (opname[2] == 'a' && opname[5] == '\0')
683 /* Assignment. */
684 size_t i;
685 for (i = 0; i < ARRAY_SIZE (optable); i++)
687 if (strlen (optable[i].in) == 3
688 && memcmp (optable[i].in, opname + 2, 3) == 0)
690 strcat (result, "operator");
691 strcat (result, optable[i].out);
692 ret = 1;
693 break;
699 else if (len >= 3
700 && opname[0] == 'o'
701 && opname[1] == 'p'
702 && strchr (cplus_markers, opname[2]) != NULL)
704 /* see if it's an assignment expression */
705 if (len >= 10 /* op$assign_ */
706 && memcmp (opname + 3, "assign_", 7) == 0)
708 size_t i;
709 for (i = 0; i < ARRAY_SIZE (optable); i++)
711 len1 = len - 10;
712 if ((int) strlen (optable[i].in) == len1
713 && memcmp (optable[i].in, opname + 10, len1) == 0)
715 strcat (result, "operator");
716 strcat (result, optable[i].out);
717 strcat (result, "=");
718 ret = 1;
719 break;
723 else
725 size_t i;
726 for (i = 0; i < ARRAY_SIZE (optable); i++)
728 len1 = len - 3;
729 if ((int) strlen (optable[i].in) == len1
730 && memcmp (optable[i].in, opname + 3, len1) == 0)
732 strcat (result, "operator");
733 strcat (result, optable[i].out);
734 ret = 1;
735 break;
740 else if (len >= 5 && memcmp (opname, "type", 4) == 0
741 && strchr (cplus_markers, opname[4]) != NULL)
743 /* type conversion operator */
744 tem = opname + 5;
745 if (do_type (work, &tem, &type))
747 strcat (result, "operator ");
748 strncat (result, type.b, type.p - type.b);
749 string_delete (&type);
750 ret = 1;
753 squangle_mop_up (work);
754 return ret;
758 /* Takes operator name as e.g. "++" and returns mangled
759 operator name (e.g. "postincrement_expr"), or NULL if not found.
761 If OPTIONS & DMGL_ANSI == 1, return the ANSI name;
762 if OPTIONS & DMGL_ANSI == 0, return the old GNU name. */
764 const char *
765 cplus_mangle_opname (const char *opname, int options)
767 size_t i;
768 int len;
770 len = strlen (opname);
771 for (i = 0; i < ARRAY_SIZE (optable); i++)
773 if ((int) strlen (optable[i].out) == len
774 && (options & DMGL_ANSI) == (optable[i].flags & DMGL_ANSI)
775 && memcmp (optable[i].out, opname, len) == 0)
776 return optable[i].in;
778 return (0);
781 /* Add a routine to set the demangling style to be sure it is valid and
782 allow for any demangler initialization that maybe necessary. */
784 enum demangling_styles
785 cplus_demangle_set_style (enum demangling_styles style)
787 const struct demangler_engine *demangler = libiberty_demanglers;
789 for (; demangler->demangling_style != unknown_demangling; ++demangler)
790 if (style == demangler->demangling_style)
792 current_demangling_style = style;
793 return current_demangling_style;
796 return unknown_demangling;
799 /* Do string name to style translation */
801 enum demangling_styles
802 cplus_demangle_name_to_style (const char *name)
804 const struct demangler_engine *demangler = libiberty_demanglers;
806 for (; demangler->demangling_style != unknown_demangling; ++demangler)
807 if (strcmp (name, demangler->demangling_style_name) == 0)
808 return demangler->demangling_style;
810 return unknown_demangling;
813 /* char *cplus_demangle (const char *mangled, int options)
815 If MANGLED is a mangled function name produced by GNU C++, then
816 a pointer to a @code{malloc}ed string giving a C++ representation
817 of the name will be returned; otherwise NULL will be returned.
818 It is the caller's responsibility to free the string which
819 is returned.
821 The OPTIONS arg may contain one or more of the following bits:
823 DMGL_ANSI ANSI qualifiers such as `const' and `void' are
824 included.
825 DMGL_PARAMS Function parameters are included.
827 For example,
829 cplus_demangle ("foo__1Ai", DMGL_PARAMS) => "A::foo(int)"
830 cplus_demangle ("foo__1Ai", DMGL_PARAMS | DMGL_ANSI) => "A::foo(int)"
831 cplus_demangle ("foo__1Ai", 0) => "A::foo"
833 cplus_demangle ("foo__1Afe", DMGL_PARAMS) => "A::foo(float,...)"
834 cplus_demangle ("foo__1Afe", DMGL_PARAMS | DMGL_ANSI)=> "A::foo(float,...)"
835 cplus_demangle ("foo__1Afe", 0) => "A::foo"
837 Note that any leading underscores, or other such characters prepended by
838 the compilation system, are presumed to have already been stripped from
839 MANGLED. */
841 char *
842 cplus_demangle (const char *mangled, int options)
844 char *ret;
845 struct work_stuff work[1];
847 if (current_demangling_style == no_demangling)
848 return xstrdup (mangled);
850 memset ((char *) work, 0, sizeof (work));
851 work->options = options;
852 if ((work->options & DMGL_STYLE_MASK) == 0)
853 work->options |= (int) current_demangling_style & DMGL_STYLE_MASK;
855 /* The V3 ABI demangling is implemented elsewhere. */
856 if (GNU_V3_DEMANGLING || AUTO_DEMANGLING)
858 ret = cplus_demangle_v3 (mangled, work->options);
859 if (ret || GNU_V3_DEMANGLING)
860 return ret;
863 if (JAVA_DEMANGLING)
865 ret = java_demangle_v3 (mangled);
866 if (ret)
867 return ret;
870 if (GNAT_DEMANGLING)
871 return ada_demangle (mangled, options);
873 ret = internal_cplus_demangle (work, mangled);
874 squangle_mop_up (work);
875 return (ret);
878 /* Demangle ada names. The encoding is documented in gcc/ada/exp_dbug.ads. */
880 char *
881 ada_demangle (const char *mangled, int option ATTRIBUTE_UNUSED)
883 int len0;
884 const char* p;
885 char *d;
886 char *demangled;
888 /* Discard leading _ada_, which is used for library level subprograms. */
889 if (strncmp (mangled, "_ada_", 5) == 0)
890 mangled += 5;
892 /* All ada unit names are lower-case. */
893 if (!ISLOWER (mangled[0]))
894 goto unknown;
896 /* Most of the demangling will trivially remove chars. Operator names
897 may add one char but because they are always preceeded by '__' which is
898 replaced by '.', they eventually never expand the size.
899 A few special names such as '___elabs' add a few chars (at most 7), but
900 they occur only once. */
901 len0 = strlen (mangled) + 7 + 1;
902 demangled = XNEWVEC (char, len0);
904 d = demangled;
905 p = mangled;
906 while (1)
908 /* An entity names is expected. */
909 if (ISLOWER (*p))
911 /* An identifier, which is always lower case. */
913 *d++ = *p++;
914 while (ISLOWER(*p) || ISDIGIT (*p)
915 || (p[0] == '_' && (ISLOWER (p[1]) || ISDIGIT (p[1]))));
917 else if (p[0] == 'O')
919 /* An operator name. */
920 static const char * const operators[][2] =
921 {{"Oabs", "abs"}, {"Oand", "and"}, {"Omod", "mod"},
922 {"Onot", "not"}, {"Oor", "or"}, {"Orem", "rem"},
923 {"Oxor", "xor"}, {"Oeq", "="}, {"One", "/="},
924 {"Olt", "<"}, {"Ole", "<="}, {"Ogt", ">"},
925 {"Oge", ">="}, {"Oadd", "+"}, {"Osubtract", "-"},
926 {"Oconcat", "&"}, {"Omultiply", "*"}, {"Odivide", "/"},
927 {"Oexpon", "**"}, {NULL, NULL}};
928 int k;
930 for (k = 0; operators[k][0] != NULL; k++)
932 size_t slen = strlen (operators[k][0]);
933 if (strncmp (p, operators[k][0], slen) == 0)
935 p += slen;
936 slen = strlen (operators[k][1]);
937 *d++ = '"';
938 memcpy (d, operators[k][1], slen);
939 d += slen;
940 *d++ = '"';
941 break;
944 /* Operator not found. */
945 if (operators[k][0] == NULL)
946 goto unknown;
948 else
950 /* Not a GNAT encoding. */
951 goto unknown;
954 /* The name can be directly followed by some uppercase letters. */
955 if (p[0] == 'T' && p[1] == 'K')
957 /* Task stuff. */
958 if (p[2] == 'B' && p[3] == 0)
960 /* Subprogram for task body. */
961 break;
963 else if (p[2] == '_' && p[3] == '_')
965 /* Inner declarations in a task. */
966 p += 4;
967 *d++ = '.';
968 continue;
970 else
971 goto unknown;
973 if (p[0] == 'E' && p[1] == 0)
975 /* Exception name. */
976 goto unknown;
978 if ((p[0] == 'P' || p[0] == 'N') && p[1] == 0)
980 /* Protected type subprogram. */
981 break;
983 if ((*p == 'N' || *p == 'S') && p[1] == 0)
985 /* Enumerated type name table. */
986 goto unknown;
988 if (p[0] == 'X')
990 /* Body nested. */
991 p++;
992 while (p[0] == 'n' || p[0] == 'b')
993 p++;
995 if (p[0] == 'S' && p[1] != 0 && (p[2] == '_' || p[2] == 0))
997 /* Stream operations. */
998 const char *name;
999 switch (p[1])
1001 case 'R':
1002 name = "'Read";
1003 break;
1004 case 'W':
1005 name = "'Write";
1006 break;
1007 case 'I':
1008 name = "'Input";
1009 break;
1010 case 'O':
1011 name = "'Output";
1012 break;
1013 default:
1014 goto unknown;
1016 p += 2;
1017 strcpy (d, name);
1018 d += strlen (name);
1020 else if (p[0] == 'D')
1022 /* Controlled type operation. */
1023 const char *name;
1024 switch (p[1])
1026 case 'F':
1027 name = ".Finalize";
1028 break;
1029 case 'A':
1030 name = ".Adjust";
1031 break;
1032 default:
1033 goto unknown;
1035 strcpy (d, name);
1036 d += strlen (name);
1037 break;
1040 if (p[0] == '_')
1042 /* Separator. */
1043 if (p[1] == '_')
1045 /* Standard separator. Handled first. */
1046 p += 2;
1048 if (ISDIGIT (*p))
1050 /* Overloading number. */
1052 p++;
1053 while (ISDIGIT (*p) || (p[0] == '_' && ISDIGIT (p[1])));
1054 if (*p == 'X')
1056 p++;
1057 while (p[0] == 'n' || p[0] == 'b')
1058 p++;
1061 else if (p[0] == '_' && p[1] != '_')
1063 /* Special names. */
1064 static const char * const special[][2] = {
1065 { "_elabb", "'Elab_Body" },
1066 { "_elabs", "'Elab_Spec" },
1067 { "_size", "'Size" },
1068 { "_alignment", "'Alignment" },
1069 { "_assign", ".\":=\"" },
1070 { NULL, NULL }
1072 int k;
1074 for (k = 0; special[k][0] != NULL; k++)
1076 size_t slen = strlen (special[k][0]);
1077 if (strncmp (p, special[k][0], slen) == 0)
1079 p += slen;
1080 slen = strlen (special[k][1]);
1081 memcpy (d, special[k][1], slen);
1082 d += slen;
1083 break;
1086 if (special[k][0] != NULL)
1087 break;
1088 else
1089 goto unknown;
1091 else
1093 *d++ = '.';
1094 continue;
1097 else if (p[1] == 'B' || p[1] == 'E')
1099 /* Entry Body or barrier Evaluation. */
1100 p += 2;
1101 while (ISDIGIT (*p))
1102 p++;
1103 if (p[0] == 's' && p[1] == 0)
1104 break;
1105 else
1106 goto unknown;
1108 else
1109 goto unknown;
1112 if (p[0] == '.' && ISDIGIT (p[1]))
1114 /* Nested subprogram. */
1115 p += 2;
1116 while (ISDIGIT (*p))
1117 p++;
1119 if (*p == 0)
1121 /* End of mangled name. */
1122 break;
1124 else
1125 goto unknown;
1127 *d = 0;
1128 return demangled;
1130 unknown:
1131 len0 = strlen (mangled);
1132 demangled = XNEWVEC (char, len0 + 3);
1134 if (mangled[0] == '<')
1135 strcpy (demangled, mangled);
1136 else
1137 sprintf (demangled, "<%s>", mangled);
1139 return demangled;
1142 /* This function performs most of what cplus_demangle use to do, but
1143 to be able to demangle a name with a B, K or n code, we need to
1144 have a longer term memory of what types have been seen. The original
1145 now initializes and cleans up the squangle code info, while internal
1146 calls go directly to this routine to avoid resetting that info. */
1148 static char *
1149 internal_cplus_demangle (struct work_stuff *work, const char *mangled)
1152 string decl;
1153 int success = 0;
1154 char *demangled = NULL;
1155 int s1, s2, s3, s4;
1156 s1 = work->constructor;
1157 s2 = work->destructor;
1158 s3 = work->static_type;
1159 s4 = work->type_quals;
1160 work->constructor = work->destructor = 0;
1161 work->type_quals = TYPE_UNQUALIFIED;
1162 work->dllimported = 0;
1164 if ((mangled != NULL) && (*mangled != '\0'))
1166 string_init (&decl);
1168 /* First check to see if gnu style demangling is active and if the
1169 string to be demangled contains a CPLUS_MARKER. If so, attempt to
1170 recognize one of the gnu special forms rather than looking for a
1171 standard prefix. In particular, don't worry about whether there
1172 is a "__" string in the mangled string. Consider "_$_5__foo" for
1173 example. */
1175 if ((AUTO_DEMANGLING || GNU_DEMANGLING))
1177 success = gnu_special (work, &mangled, &decl);
1179 if (!success)
1181 success = demangle_prefix (work, &mangled, &decl);
1183 if (success && (*mangled != '\0'))
1185 success = demangle_signature (work, &mangled, &decl);
1187 if (work->constructor == 2)
1189 string_prepend (&decl, "global constructors keyed to ");
1190 work->constructor = 0;
1192 else if (work->destructor == 2)
1194 string_prepend (&decl, "global destructors keyed to ");
1195 work->destructor = 0;
1197 else if (work->dllimported == 1)
1199 string_prepend (&decl, "import stub for ");
1200 work->dllimported = 0;
1202 demangled = mop_up (work, &decl, success);
1204 work->constructor = s1;
1205 work->destructor = s2;
1206 work->static_type = s3;
1207 work->type_quals = s4;
1208 return demangled;
1212 /* Clear out and squangling related storage */
1213 static void
1214 squangle_mop_up (struct work_stuff *work)
1216 /* clean up the B and K type mangling types. */
1217 forget_B_and_K_types (work);
1218 if (work -> btypevec != NULL)
1220 free ((char *) work -> btypevec);
1222 if (work -> ktypevec != NULL)
1224 free ((char *) work -> ktypevec);
1229 /* Copy the work state and storage. */
1231 static void
1232 work_stuff_copy_to_from (struct work_stuff *to, struct work_stuff *from)
1234 int i;
1236 delete_work_stuff (to);
1238 /* Shallow-copy scalars. */
1239 memcpy (to, from, sizeof (*to));
1241 /* Deep-copy dynamic storage. */
1242 if (from->typevec_size)
1243 to->typevec = XNEWVEC (char *, from->typevec_size);
1245 for (i = 0; i < from->ntypes; i++)
1247 int len = strlen (from->typevec[i]) + 1;
1249 to->typevec[i] = XNEWVEC (char, len);
1250 memcpy (to->typevec[i], from->typevec[i], len);
1253 if (from->ksize)
1254 to->ktypevec = XNEWVEC (char *, from->ksize);
1256 for (i = 0; i < from->numk; i++)
1258 int len = strlen (from->ktypevec[i]) + 1;
1260 to->ktypevec[i] = XNEWVEC (char, len);
1261 memcpy (to->ktypevec[i], from->ktypevec[i], len);
1264 if (from->bsize)
1265 to->btypevec = XNEWVEC (char *, from->bsize);
1267 for (i = 0; i < from->numb; i++)
1269 int len = strlen (from->btypevec[i]) + 1;
1271 to->btypevec[i] = XNEWVEC (char , len);
1272 memcpy (to->btypevec[i], from->btypevec[i], len);
1275 if (from->ntmpl_args)
1276 to->tmpl_argvec = XNEWVEC (char *, from->ntmpl_args);
1278 for (i = 0; i < from->ntmpl_args; i++)
1280 int len = strlen (from->tmpl_argvec[i]) + 1;
1282 to->tmpl_argvec[i] = XNEWVEC (char, len);
1283 memcpy (to->tmpl_argvec[i], from->tmpl_argvec[i], len);
1286 if (from->previous_argument)
1288 to->previous_argument = XNEW (string);
1289 string_init (to->previous_argument);
1290 string_appends (to->previous_argument, from->previous_argument);
1295 /* Delete dynamic stuff in work_stuff that is not to be re-used. */
1297 static void
1298 delete_non_B_K_work_stuff (struct work_stuff *work)
1300 /* Discard the remembered types, if any. */
1302 forget_types (work);
1303 if (work -> typevec != NULL)
1305 free ((char *) work -> typevec);
1306 work -> typevec = NULL;
1307 work -> typevec_size = 0;
1309 if (work->tmpl_argvec)
1311 int i;
1313 for (i = 0; i < work->ntmpl_args; i++)
1314 free ((char*) work->tmpl_argvec[i]);
1316 free ((char*) work->tmpl_argvec);
1317 work->tmpl_argvec = NULL;
1319 if (work->previous_argument)
1321 string_delete (work->previous_argument);
1322 free ((char*) work->previous_argument);
1323 work->previous_argument = NULL;
1328 /* Delete all dynamic storage in work_stuff. */
1329 static void
1330 delete_work_stuff (struct work_stuff *work)
1332 delete_non_B_K_work_stuff (work);
1333 squangle_mop_up (work);
1337 /* Clear out any mangled storage */
1339 static char *
1340 mop_up (struct work_stuff *work, string *declp, int success)
1342 char *demangled = NULL;
1344 delete_non_B_K_work_stuff (work);
1346 /* If demangling was successful, ensure that the demangled string is null
1347 terminated and return it. Otherwise, free the demangling decl. */
1349 if (!success)
1351 string_delete (declp);
1353 else
1355 string_appendn (declp, "", 1);
1356 demangled = declp->b;
1358 return (demangled);
1363 LOCAL FUNCTION
1365 demangle_signature -- demangle the signature part of a mangled name
1367 SYNOPSIS
1369 static int
1370 demangle_signature (struct work_stuff *work, const char **mangled,
1371 string *declp);
1373 DESCRIPTION
1375 Consume and demangle the signature portion of the mangled name.
1377 DECLP is the string where demangled output is being built. At
1378 entry it contains the demangled root name from the mangled name
1379 prefix. I.E. either a demangled operator name or the root function
1380 name. In some special cases, it may contain nothing.
1382 *MANGLED points to the current unconsumed location in the mangled
1383 name. As tokens are consumed and demangling is performed, the
1384 pointer is updated to continuously point at the next token to
1385 be consumed.
1387 Demangling GNU style mangled names is nasty because there is no
1388 explicit token that marks the start of the outermost function
1389 argument list. */
1391 static int
1392 demangle_signature (struct work_stuff *work,
1393 const char **mangled, string *declp)
1395 int success = 1;
1396 int func_done = 0;
1397 int expect_func = 0;
1398 int expect_return_type = 0;
1399 const char *oldmangled = NULL;
1400 string trawname;
1401 string tname;
1403 while (success && (**mangled != '\0'))
1405 switch (**mangled)
1407 case 'Q':
1408 oldmangled = *mangled;
1409 success = demangle_qualified (work, mangled, declp, 1, 0);
1410 if (success)
1411 remember_type (work, oldmangled, *mangled - oldmangled);
1412 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1413 expect_func = 1;
1414 oldmangled = NULL;
1415 break;
1417 case 'K':
1418 oldmangled = *mangled;
1419 success = demangle_qualified (work, mangled, declp, 1, 0);
1420 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1422 expect_func = 1;
1424 oldmangled = NULL;
1425 break;
1427 case 'S':
1428 /* Static member function */
1429 if (oldmangled == NULL)
1431 oldmangled = *mangled;
1433 (*mangled)++;
1434 work -> static_type = 1;
1435 break;
1437 case 'C':
1438 case 'V':
1439 case 'u':
1440 work->type_quals |= code_for_qualifier (**mangled);
1442 /* a qualified member function */
1443 if (oldmangled == NULL)
1444 oldmangled = *mangled;
1445 (*mangled)++;
1446 break;
1448 case 'L':
1449 /* Local class name follows after "Lnnn_" */
1450 if (HP_DEMANGLING)
1452 while (**mangled && (**mangled != '_'))
1453 (*mangled)++;
1454 if (!**mangled)
1455 success = 0;
1456 else
1457 (*mangled)++;
1459 else
1460 success = 0;
1461 break;
1463 case '0': case '1': case '2': case '3': case '4':
1464 case '5': case '6': case '7': case '8': case '9':
1465 if (oldmangled == NULL)
1467 oldmangled = *mangled;
1469 work->temp_start = -1; /* uppermost call to demangle_class */
1470 success = demangle_class (work, mangled, declp);
1471 if (success)
1473 remember_type (work, oldmangled, *mangled - oldmangled);
1475 if (AUTO_DEMANGLING || GNU_DEMANGLING || EDG_DEMANGLING)
1477 /* EDG and others will have the "F", so we let the loop cycle
1478 if we are looking at one. */
1479 if (**mangled != 'F')
1480 expect_func = 1;
1482 oldmangled = NULL;
1483 break;
1485 case 'B':
1487 string s;
1488 success = do_type (work, mangled, &s);
1489 if (success)
1491 string_append (&s, SCOPE_STRING (work));
1492 string_prepends (declp, &s);
1493 string_delete (&s);
1495 oldmangled = NULL;
1496 expect_func = 1;
1498 break;
1500 case 'F':
1501 /* Function */
1502 /* ARM/HP style demangling includes a specific 'F' character after
1503 the class name. For GNU style, it is just implied. So we can
1504 safely just consume any 'F' at this point and be compatible
1505 with either style. */
1507 oldmangled = NULL;
1508 func_done = 1;
1509 (*mangled)++;
1511 /* For lucid/ARM/HP style we have to forget any types we might
1512 have remembered up to this point, since they were not argument
1513 types. GNU style considers all types seen as available for
1514 back references. See comment in demangle_args() */
1516 if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
1518 forget_types (work);
1520 success = demangle_args (work, mangled, declp);
1521 /* After picking off the function args, we expect to either
1522 find the function return type (preceded by an '_') or the
1523 end of the string. */
1524 if (success && (AUTO_DEMANGLING || EDG_DEMANGLING) && **mangled == '_')
1526 ++(*mangled);
1527 /* At this level, we do not care about the return type. */
1528 success = do_type (work, mangled, &tname);
1529 string_delete (&tname);
1532 break;
1534 case 't':
1535 /* G++ Template */
1536 string_init(&trawname);
1537 string_init(&tname);
1538 if (oldmangled == NULL)
1540 oldmangled = *mangled;
1542 success = demangle_template (work, mangled, &tname,
1543 &trawname, 1, 1);
1544 if (success)
1546 remember_type (work, oldmangled, *mangled - oldmangled);
1548 string_append (&tname, SCOPE_STRING (work));
1550 string_prepends(declp, &tname);
1551 if (work -> destructor & 1)
1553 string_prepend (&trawname, "~");
1554 string_appends (declp, &trawname);
1555 work->destructor -= 1;
1557 if ((work->constructor & 1) || (work->destructor & 1))
1559 string_appends (declp, &trawname);
1560 work->constructor -= 1;
1562 string_delete(&trawname);
1563 string_delete(&tname);
1564 oldmangled = NULL;
1565 expect_func = 1;
1566 break;
1568 case '_':
1569 if ((AUTO_DEMANGLING || GNU_DEMANGLING) && expect_return_type)
1571 /* Read the return type. */
1572 string return_type;
1574 (*mangled)++;
1575 success = do_type (work, mangled, &return_type);
1576 APPEND_BLANK (&return_type);
1578 string_prepends (declp, &return_type);
1579 string_delete (&return_type);
1580 break;
1582 else
1583 /* At the outermost level, we cannot have a return type specified,
1584 so if we run into another '_' at this point we are dealing with
1585 a mangled name that is either bogus, or has been mangled by
1586 some algorithm we don't know how to deal with. So just
1587 reject the entire demangling. */
1588 /* However, "_nnn" is an expected suffix for alternate entry point
1589 numbered nnn for a function, with HP aCC, so skip over that
1590 without reporting failure. pai/1997-09-04 */
1591 if (HP_DEMANGLING)
1593 (*mangled)++;
1594 while (**mangled && ISDIGIT ((unsigned char)**mangled))
1595 (*mangled)++;
1597 else
1598 success = 0;
1599 break;
1601 case 'H':
1602 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1604 /* A G++ template function. Read the template arguments. */
1605 success = demangle_template (work, mangled, declp, 0, 0,
1607 if (!(work->constructor & 1))
1608 expect_return_type = 1;
1609 (*mangled)++;
1610 break;
1612 else
1613 /* fall through */
1616 default:
1617 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1619 /* Assume we have stumbled onto the first outermost function
1620 argument token, and start processing args. */
1621 func_done = 1;
1622 success = demangle_args (work, mangled, declp);
1624 else
1626 /* Non-GNU demanglers use a specific token to mark the start
1627 of the outermost function argument tokens. Typically 'F',
1628 for ARM/HP-demangling, for example. So if we find something
1629 we are not prepared for, it must be an error. */
1630 success = 0;
1632 break;
1635 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1638 if (success && expect_func)
1640 func_done = 1;
1641 if (LUCID_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING)
1643 forget_types (work);
1645 success = demangle_args (work, mangled, declp);
1646 /* Since template include the mangling of their return types,
1647 we must set expect_func to 0 so that we don't try do
1648 demangle more arguments the next time we get here. */
1649 expect_func = 0;
1653 if (success && !func_done)
1655 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1657 /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
1658 bar__3fooi is 'foo::bar(int)'. We get here when we find the
1659 first case, and need to ensure that the '(void)' gets added to
1660 the current declp. Note that with ARM/HP, the first case
1661 represents the name of a static data member 'foo::bar',
1662 which is in the current declp, so we leave it alone. */
1663 success = demangle_args (work, mangled, declp);
1666 if (success && PRINT_ARG_TYPES)
1668 if (work->static_type)
1669 string_append (declp, " static");
1670 if (work->type_quals != TYPE_UNQUALIFIED)
1672 APPEND_BLANK (declp);
1673 string_append (declp, qualifier_string (work->type_quals));
1677 return (success);
1680 #if 0
1682 static int
1683 demangle_method_args (struct work_stuff *work, const char **mangled,
1684 string *declp)
1686 int success = 0;
1688 if (work -> static_type)
1690 string_append (declp, *mangled + 1);
1691 *mangled += strlen (*mangled);
1692 success = 1;
1694 else
1696 success = demangle_args (work, mangled, declp);
1698 return (success);
1701 #endif
1703 static int
1704 demangle_template_template_parm (struct work_stuff *work,
1705 const char **mangled, string *tname)
1707 int i;
1708 int r;
1709 int need_comma = 0;
1710 int success = 1;
1711 string temp;
1713 string_append (tname, "template <");
1714 /* get size of template parameter list */
1715 if (get_count (mangled, &r))
1717 for (i = 0; i < r; i++)
1719 if (need_comma)
1721 string_append (tname, ", ");
1724 /* Z for type parameters */
1725 if (**mangled == 'Z')
1727 (*mangled)++;
1728 string_append (tname, "class");
1730 /* z for template parameters */
1731 else if (**mangled == 'z')
1733 (*mangled)++;
1734 success =
1735 demangle_template_template_parm (work, mangled, tname);
1736 if (!success)
1738 break;
1741 else
1743 /* temp is initialized in do_type */
1744 success = do_type (work, mangled, &temp);
1745 if (success)
1747 string_appends (tname, &temp);
1749 string_delete(&temp);
1750 if (!success)
1752 break;
1755 need_comma = 1;
1759 if (tname->p[-1] == '>')
1760 string_append (tname, " ");
1761 string_append (tname, "> class");
1762 return (success);
1765 static int
1766 demangle_expression (struct work_stuff *work, const char **mangled,
1767 string *s, type_kind_t tk)
1769 int need_operator = 0;
1770 int success;
1772 success = 1;
1773 string_appendn (s, "(", 1);
1774 (*mangled)++;
1775 while (success && **mangled != 'W' && **mangled != '\0')
1777 if (need_operator)
1779 size_t i;
1780 size_t len;
1782 success = 0;
1784 len = strlen (*mangled);
1786 for (i = 0; i < ARRAY_SIZE (optable); ++i)
1788 size_t l = strlen (optable[i].in);
1790 if (l <= len
1791 && memcmp (optable[i].in, *mangled, l) == 0)
1793 string_appendn (s, " ", 1);
1794 string_append (s, optable[i].out);
1795 string_appendn (s, " ", 1);
1796 success = 1;
1797 (*mangled) += l;
1798 break;
1802 if (!success)
1803 break;
1805 else
1806 need_operator = 1;
1808 success = demangle_template_value_parm (work, mangled, s, tk);
1811 if (**mangled != 'W')
1812 success = 0;
1813 else
1815 string_appendn (s, ")", 1);
1816 (*mangled)++;
1819 return success;
1822 static int
1823 demangle_integral_value (struct work_stuff *work,
1824 const char **mangled, string *s)
1826 int success;
1828 if (**mangled == 'E')
1829 success = demangle_expression (work, mangled, s, tk_integral);
1830 else if (**mangled == 'Q' || **mangled == 'K')
1831 success = demangle_qualified (work, mangled, s, 0, 1);
1832 else
1834 int value;
1836 /* By default, we let the number decide whether we shall consume an
1837 underscore. */
1838 int multidigit_without_leading_underscore = 0;
1839 int leave_following_underscore = 0;
1841 success = 0;
1843 if (**mangled == '_')
1845 if (mangled[0][1] == 'm')
1847 /* Since consume_count_with_underscores does not handle the
1848 `m'-prefix we must do it here, using consume_count and
1849 adjusting underscores: we have to consume the underscore
1850 matching the prepended one. */
1851 multidigit_without_leading_underscore = 1;
1852 string_appendn (s, "-", 1);
1853 (*mangled) += 2;
1855 else
1857 /* Do not consume a following underscore;
1858 consume_count_with_underscores will consume what
1859 should be consumed. */
1860 leave_following_underscore = 1;
1863 else
1865 /* Negative numbers are indicated with a leading `m'. */
1866 if (**mangled == 'm')
1868 string_appendn (s, "-", 1);
1869 (*mangled)++;
1871 /* Since consume_count_with_underscores does not handle
1872 multi-digit numbers that do not start with an underscore,
1873 and this number can be an integer template parameter,
1874 we have to call consume_count. */
1875 multidigit_without_leading_underscore = 1;
1876 /* These multi-digit numbers never end on an underscore,
1877 so if there is one then don't eat it. */
1878 leave_following_underscore = 1;
1881 /* We must call consume_count if we expect to remove a trailing
1882 underscore, since consume_count_with_underscores expects
1883 the leading underscore (that we consumed) if it is to handle
1884 multi-digit numbers. */
1885 if (multidigit_without_leading_underscore)
1886 value = consume_count (mangled);
1887 else
1888 value = consume_count_with_underscores (mangled);
1890 if (value != -1)
1892 char buf[INTBUF_SIZE];
1893 sprintf (buf, "%d", value);
1894 string_append (s, buf);
1896 /* Numbers not otherwise delimited, might have an underscore
1897 appended as a delimeter, which we should skip.
1899 ??? This used to always remove a following underscore, which
1900 is wrong. If other (arbitrary) cases are followed by an
1901 underscore, we need to do something more radical. */
1903 if ((value > 9 || multidigit_without_leading_underscore)
1904 && ! leave_following_underscore
1905 && **mangled == '_')
1906 (*mangled)++;
1908 /* All is well. */
1909 success = 1;
1913 return success;
1916 /* Demangle the real value in MANGLED. */
1918 static int
1919 demangle_real_value (struct work_stuff *work,
1920 const char **mangled, string *s)
1922 if (**mangled == 'E')
1923 return demangle_expression (work, mangled, s, tk_real);
1925 if (**mangled == 'm')
1927 string_appendn (s, "-", 1);
1928 (*mangled)++;
1930 while (ISDIGIT ((unsigned char)**mangled))
1932 string_appendn (s, *mangled, 1);
1933 (*mangled)++;
1935 if (**mangled == '.') /* fraction */
1937 string_appendn (s, ".", 1);
1938 (*mangled)++;
1939 while (ISDIGIT ((unsigned char)**mangled))
1941 string_appendn (s, *mangled, 1);
1942 (*mangled)++;
1945 if (**mangled == 'e') /* exponent */
1947 string_appendn (s, "e", 1);
1948 (*mangled)++;
1949 while (ISDIGIT ((unsigned char)**mangled))
1951 string_appendn (s, *mangled, 1);
1952 (*mangled)++;
1956 return 1;
1959 static int
1960 demangle_template_value_parm (struct work_stuff *work, const char **mangled,
1961 string *s, type_kind_t tk)
1963 int success = 1;
1965 if (**mangled == 'Y')
1967 /* The next argument is a template parameter. */
1968 int idx;
1970 (*mangled)++;
1971 idx = consume_count_with_underscores (mangled);
1972 if (idx == -1
1973 || (work->tmpl_argvec && idx >= work->ntmpl_args)
1974 || consume_count_with_underscores (mangled) == -1)
1975 return -1;
1976 if (work->tmpl_argvec)
1977 string_append (s, work->tmpl_argvec[idx]);
1978 else
1979 string_append_template_idx (s, idx);
1981 else if (tk == tk_integral)
1982 success = demangle_integral_value (work, mangled, s);
1983 else if (tk == tk_char)
1985 char tmp[2];
1986 int val;
1987 if (**mangled == 'm')
1989 string_appendn (s, "-", 1);
1990 (*mangled)++;
1992 string_appendn (s, "'", 1);
1993 val = consume_count(mangled);
1994 if (val <= 0)
1995 success = 0;
1996 else
1998 tmp[0] = (char)val;
1999 tmp[1] = '\0';
2000 string_appendn (s, &tmp[0], 1);
2001 string_appendn (s, "'", 1);
2004 else if (tk == tk_bool)
2006 int val = consume_count (mangled);
2007 if (val == 0)
2008 string_appendn (s, "false", 5);
2009 else if (val == 1)
2010 string_appendn (s, "true", 4);
2011 else
2012 success = 0;
2014 else if (tk == tk_real)
2015 success = demangle_real_value (work, mangled, s);
2016 else if (tk == tk_pointer || tk == tk_reference)
2018 if (**mangled == 'Q')
2019 success = demangle_qualified (work, mangled, s,
2020 /*isfuncname=*/0,
2021 /*append=*/1);
2022 else
2024 int symbol_len = consume_count (mangled);
2025 if (symbol_len == -1)
2026 return -1;
2027 if (symbol_len == 0)
2028 string_appendn (s, "0", 1);
2029 else
2031 char *p = XNEWVEC (char, symbol_len + 1), *q;
2032 strncpy (p, *mangled, symbol_len);
2033 p [symbol_len] = '\0';
2034 /* We use cplus_demangle here, rather than
2035 internal_cplus_demangle, because the name of the entity
2036 mangled here does not make use of any of the squangling
2037 or type-code information we have built up thus far; it is
2038 mangled independently. */
2039 q = cplus_demangle (p, work->options);
2040 if (tk == tk_pointer)
2041 string_appendn (s, "&", 1);
2042 /* FIXME: Pointer-to-member constants should get a
2043 qualifying class name here. */
2044 if (q)
2046 string_append (s, q);
2047 free (q);
2049 else
2050 string_append (s, p);
2051 free (p);
2053 *mangled += symbol_len;
2057 return success;
2060 /* Demangle the template name in MANGLED. The full name of the
2061 template (e.g., S<int>) is placed in TNAME. The name without the
2062 template parameters (e.g. S) is placed in TRAWNAME if TRAWNAME is
2063 non-NULL. If IS_TYPE is nonzero, this template is a type template,
2064 not a function template. If both IS_TYPE and REMEMBER are nonzero,
2065 the template is remembered in the list of back-referenceable
2066 types. */
2068 static int
2069 demangle_template (struct work_stuff *work, const char **mangled,
2070 string *tname, string *trawname,
2071 int is_type, int remember)
2073 int i;
2074 int r;
2075 int need_comma = 0;
2076 int success = 0;
2077 int is_java_array = 0;
2078 string temp;
2080 (*mangled)++;
2081 if (is_type)
2083 /* get template name */
2084 if (**mangled == 'z')
2086 int idx;
2087 (*mangled)++;
2088 (*mangled)++;
2090 idx = consume_count_with_underscores (mangled);
2091 if (idx == -1
2092 || (work->tmpl_argvec && idx >= work->ntmpl_args)
2093 || consume_count_with_underscores (mangled) == -1)
2094 return (0);
2096 if (work->tmpl_argvec)
2098 string_append (tname, work->tmpl_argvec[idx]);
2099 if (trawname)
2100 string_append (trawname, work->tmpl_argvec[idx]);
2102 else
2104 string_append_template_idx (tname, idx);
2105 if (trawname)
2106 string_append_template_idx (trawname, idx);
2109 else
2111 if ((r = consume_count (mangled)) <= 0
2112 || (int) strlen (*mangled) < r)
2114 return (0);
2116 is_java_array = (work -> options & DMGL_JAVA)
2117 && strncmp (*mangled, "JArray1Z", 8) == 0;
2118 if (! is_java_array)
2120 string_appendn (tname, *mangled, r);
2122 if (trawname)
2123 string_appendn (trawname, *mangled, r);
2124 *mangled += r;
2127 if (!is_java_array)
2128 string_append (tname, "<");
2129 /* get size of template parameter list */
2130 if (!get_count (mangled, &r))
2132 return (0);
2134 if (!is_type)
2136 /* Create an array for saving the template argument values. */
2137 work->tmpl_argvec = XNEWVEC (char *, r);
2138 work->ntmpl_args = r;
2139 for (i = 0; i < r; i++)
2140 work->tmpl_argvec[i] = 0;
2142 for (i = 0; i < r; i++)
2144 if (need_comma)
2146 string_append (tname, ", ");
2148 /* Z for type parameters */
2149 if (**mangled == 'Z')
2151 (*mangled)++;
2152 /* temp is initialized in do_type */
2153 success = do_type (work, mangled, &temp);
2154 if (success)
2156 string_appends (tname, &temp);
2158 if (!is_type)
2160 /* Save the template argument. */
2161 int len = temp.p - temp.b;
2162 work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
2163 memcpy (work->tmpl_argvec[i], temp.b, len);
2164 work->tmpl_argvec[i][len] = '\0';
2167 string_delete(&temp);
2168 if (!success)
2170 break;
2173 /* z for template parameters */
2174 else if (**mangled == 'z')
2176 int r2;
2177 (*mangled)++;
2178 success = demangle_template_template_parm (work, mangled, tname);
2180 if (success
2181 && (r2 = consume_count (mangled)) > 0
2182 && (int) strlen (*mangled) >= r2)
2184 string_append (tname, " ");
2185 string_appendn (tname, *mangled, r2);
2186 if (!is_type)
2188 /* Save the template argument. */
2189 int len = r2;
2190 work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
2191 memcpy (work->tmpl_argvec[i], *mangled, len);
2192 work->tmpl_argvec[i][len] = '\0';
2194 *mangled += r2;
2196 if (!success)
2198 break;
2201 else
2203 string param;
2204 string* s;
2206 /* otherwise, value parameter */
2208 /* temp is initialized in do_type */
2209 success = do_type (work, mangled, &temp);
2210 string_delete(&temp);
2211 if (!success)
2212 break;
2214 if (!is_type)
2216 s = &param;
2217 string_init (s);
2219 else
2220 s = tname;
2222 success = demangle_template_value_parm (work, mangled, s,
2223 (type_kind_t) success);
2225 if (!success)
2227 if (!is_type)
2228 string_delete (s);
2229 success = 0;
2230 break;
2233 if (!is_type)
2235 int len = s->p - s->b;
2236 work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
2237 memcpy (work->tmpl_argvec[i], s->b, len);
2238 work->tmpl_argvec[i][len] = '\0';
2240 string_appends (tname, s);
2241 string_delete (s);
2244 need_comma = 1;
2246 if (is_java_array)
2248 string_append (tname, "[]");
2250 else
2252 if (tname->p[-1] == '>')
2253 string_append (tname, " ");
2254 string_append (tname, ">");
2257 if (is_type && remember)
2259 const int bindex = register_Btype (work);
2260 remember_Btype (work, tname->b, LEN_STRING (tname), bindex);
2264 if (work -> static_type)
2266 string_append (declp, *mangled + 1);
2267 *mangled += strlen (*mangled);
2268 success = 1;
2270 else
2272 success = demangle_args (work, mangled, declp);
2276 return (success);
2279 static int
2280 arm_pt (struct work_stuff *work, const char *mangled,
2281 int n, const char **anchor, const char **args)
2283 /* Check if ARM template with "__pt__" in it ("parameterized type") */
2284 /* Allow HP also here, because HP's cfront compiler follows ARM to some extent */
2285 if ((ARM_DEMANGLING || HP_DEMANGLING) && (*anchor = strstr (mangled, "__pt__")))
2287 int len;
2288 *args = *anchor + 6;
2289 len = consume_count (args);
2290 if (len == -1)
2291 return 0;
2292 if (*args + len == mangled + n && **args == '_')
2294 ++*args;
2295 return 1;
2298 if (AUTO_DEMANGLING || EDG_DEMANGLING)
2300 if ((*anchor = strstr (mangled, "__tm__"))
2301 || (*anchor = strstr (mangled, "__ps__"))
2302 || (*anchor = strstr (mangled, "__pt__")))
2304 int len;
2305 *args = *anchor + 6;
2306 len = consume_count (args);
2307 if (len == -1)
2308 return 0;
2309 if (*args + len == mangled + n && **args == '_')
2311 ++*args;
2312 return 1;
2315 else if ((*anchor = strstr (mangled, "__S")))
2317 int len;
2318 *args = *anchor + 3;
2319 len = consume_count (args);
2320 if (len == -1)
2321 return 0;
2322 if (*args + len == mangled + n && **args == '_')
2324 ++*args;
2325 return 1;
2330 return 0;
2333 static void
2334 demangle_arm_hp_template (struct work_stuff *work, const char **mangled,
2335 int n, string *declp)
2337 const char *p;
2338 const char *args;
2339 const char *e = *mangled + n;
2340 string arg;
2342 /* Check for HP aCC template spec: classXt1t2 where t1, t2 are
2343 template args */
2344 if (HP_DEMANGLING && ((*mangled)[n] == 'X'))
2346 char *start_spec_args = NULL;
2347 int hold_options;
2349 /* First check for and omit template specialization pseudo-arguments,
2350 such as in "Spec<#1,#1.*>" */
2351 start_spec_args = strchr (*mangled, '<');
2352 if (start_spec_args && (start_spec_args - *mangled < n))
2353 string_appendn (declp, *mangled, start_spec_args - *mangled);
2354 else
2355 string_appendn (declp, *mangled, n);
2356 (*mangled) += n + 1;
2357 string_init (&arg);
2358 if (work->temp_start == -1) /* non-recursive call */
2359 work->temp_start = declp->p - declp->b;
2361 /* We want to unconditionally demangle parameter types in
2362 template parameters. */
2363 hold_options = work->options;
2364 work->options |= DMGL_PARAMS;
2366 string_append (declp, "<");
2367 while (1)
2369 string_delete (&arg);
2370 switch (**mangled)
2372 case 'T':
2373 /* 'T' signals a type parameter */
2374 (*mangled)++;
2375 if (!do_type (work, mangled, &arg))
2376 goto hpacc_template_args_done;
2377 break;
2379 case 'U':
2380 case 'S':
2381 /* 'U' or 'S' signals an integral value */
2382 if (!do_hpacc_template_const_value (work, mangled, &arg))
2383 goto hpacc_template_args_done;
2384 break;
2386 case 'A':
2387 /* 'A' signals a named constant expression (literal) */
2388 if (!do_hpacc_template_literal (work, mangled, &arg))
2389 goto hpacc_template_args_done;
2390 break;
2392 default:
2393 /* Today, 1997-09-03, we have only the above types
2394 of template parameters */
2395 /* FIXME: maybe this should fail and return null */
2396 goto hpacc_template_args_done;
2398 string_appends (declp, &arg);
2399 /* Check if we're at the end of template args.
2400 0 if at end of static member of template class,
2401 _ if done with template args for a function */
2402 if ((**mangled == '\000') || (**mangled == '_'))
2403 break;
2404 else
2405 string_append (declp, ",");
2407 hpacc_template_args_done:
2408 string_append (declp, ">");
2409 string_delete (&arg);
2410 if (**mangled == '_')
2411 (*mangled)++;
2412 work->options = hold_options;
2413 return;
2415 /* ARM template? (Also handles HP cfront extensions) */
2416 else if (arm_pt (work, *mangled, n, &p, &args))
2418 int hold_options;
2419 string type_str;
2421 string_init (&arg);
2422 string_appendn (declp, *mangled, p - *mangled);
2423 if (work->temp_start == -1) /* non-recursive call */
2424 work->temp_start = declp->p - declp->b;
2426 /* We want to unconditionally demangle parameter types in
2427 template parameters. */
2428 hold_options = work->options;
2429 work->options |= DMGL_PARAMS;
2431 string_append (declp, "<");
2432 /* should do error checking here */
2433 while (args < e) {
2434 string_delete (&arg);
2436 /* Check for type or literal here */
2437 switch (*args)
2439 /* HP cfront extensions to ARM for template args */
2440 /* spec: Xt1Lv1 where t1 is a type, v1 is a literal value */
2441 /* FIXME: We handle only numeric literals for HP cfront */
2442 case 'X':
2443 /* A typed constant value follows */
2444 args++;
2445 if (!do_type (work, &args, &type_str))
2446 goto cfront_template_args_done;
2447 string_append (&arg, "(");
2448 string_appends (&arg, &type_str);
2449 string_delete (&type_str);
2450 string_append (&arg, ")");
2451 if (*args != 'L')
2452 goto cfront_template_args_done;
2453 args++;
2454 /* Now snarf a literal value following 'L' */
2455 if (!snarf_numeric_literal (&args, &arg))
2456 goto cfront_template_args_done;
2457 break;
2459 case 'L':
2460 /* Snarf a literal following 'L' */
2461 args++;
2462 if (!snarf_numeric_literal (&args, &arg))
2463 goto cfront_template_args_done;
2464 break;
2465 default:
2466 /* Not handling other HP cfront stuff */
2468 const char* old_args = args;
2469 if (!do_type (work, &args, &arg))
2470 goto cfront_template_args_done;
2472 /* Fail if we didn't make any progress: prevent infinite loop. */
2473 if (args == old_args)
2475 work->options = hold_options;
2476 return;
2480 string_appends (declp, &arg);
2481 string_append (declp, ",");
2483 cfront_template_args_done:
2484 string_delete (&arg);
2485 if (args >= e)
2486 --declp->p; /* remove extra comma */
2487 string_append (declp, ">");
2488 work->options = hold_options;
2490 else if (n>10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
2491 && (*mangled)[9] == 'N'
2492 && (*mangled)[8] == (*mangled)[10]
2493 && strchr (cplus_markers, (*mangled)[8]))
2495 /* A member of the anonymous namespace. */
2496 string_append (declp, "{anonymous}");
2498 else
2500 if (work->temp_start == -1) /* non-recursive call only */
2501 work->temp_start = 0; /* disable in recursive calls */
2502 string_appendn (declp, *mangled, n);
2504 *mangled += n;
2507 /* Extract a class name, possibly a template with arguments, from the
2508 mangled string; qualifiers, local class indicators, etc. have
2509 already been dealt with */
2511 static int
2512 demangle_class_name (struct work_stuff *work, const char **mangled,
2513 string *declp)
2515 int n;
2516 int success = 0;
2518 n = consume_count (mangled);
2519 if (n == -1)
2520 return 0;
2521 if ((int) strlen (*mangled) >= n)
2523 demangle_arm_hp_template (work, mangled, n, declp);
2524 success = 1;
2527 return (success);
2532 LOCAL FUNCTION
2534 demangle_class -- demangle a mangled class sequence
2536 SYNOPSIS
2538 static int
2539 demangle_class (struct work_stuff *work, const char **mangled,
2540 strint *declp)
2542 DESCRIPTION
2544 DECLP points to the buffer into which demangling is being done.
2546 *MANGLED points to the current token to be demangled. On input,
2547 it points to a mangled class (I.E. "3foo", "13verylongclass", etc.)
2548 On exit, it points to the next token after the mangled class on
2549 success, or the first unconsumed token on failure.
2551 If the CONSTRUCTOR or DESTRUCTOR flags are set in WORK, then
2552 we are demangling a constructor or destructor. In this case
2553 we prepend "class::class" or "class::~class" to DECLP.
2555 Otherwise, we prepend "class::" to the current DECLP.
2557 Reset the constructor/destructor flags once they have been
2558 "consumed". This allows demangle_class to be called later during
2559 the same demangling, to do normal class demangling.
2561 Returns 1 if demangling is successful, 0 otherwise.
2565 static int
2566 demangle_class (struct work_stuff *work, const char **mangled, string *declp)
2568 int success = 0;
2569 int btype;
2570 string class_name;
2571 char *save_class_name_end = 0;
2573 string_init (&class_name);
2574 btype = register_Btype (work);
2575 if (demangle_class_name (work, mangled, &class_name))
2577 save_class_name_end = class_name.p;
2578 if ((work->constructor & 1) || (work->destructor & 1))
2580 /* adjust so we don't include template args */
2581 if (work->temp_start && (work->temp_start != -1))
2583 class_name.p = class_name.b + work->temp_start;
2585 string_prepends (declp, &class_name);
2586 if (work -> destructor & 1)
2588 string_prepend (declp, "~");
2589 work -> destructor -= 1;
2591 else
2593 work -> constructor -= 1;
2596 class_name.p = save_class_name_end;
2597 remember_Ktype (work, class_name.b, LEN_STRING(&class_name));
2598 remember_Btype (work, class_name.b, LEN_STRING(&class_name), btype);
2599 string_prepend (declp, SCOPE_STRING (work));
2600 string_prepends (declp, &class_name);
2601 success = 1;
2603 string_delete (&class_name);
2604 return (success);
2608 /* Called when there's a "__" in the mangled name, with `scan' pointing to
2609 the rightmost guess.
2611 Find the correct "__"-sequence where the function name ends and the
2612 signature starts, which is ambiguous with GNU mangling.
2613 Call demangle_signature here, so we can make sure we found the right
2614 one; *mangled will be consumed so caller will not make further calls to
2615 demangle_signature. */
2617 static int
2618 iterate_demangle_function (struct work_stuff *work, const char **mangled,
2619 string *declp, const char *scan)
2621 const char *mangle_init = *mangled;
2622 int success = 0;
2623 string decl_init;
2624 struct work_stuff work_init;
2626 if (*(scan + 2) == '\0')
2627 return 0;
2629 /* Do not iterate for some demangling modes, or if there's only one
2630 "__"-sequence. This is the normal case. */
2631 if (ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING
2632 || strstr (scan + 2, "__") == NULL)
2633 return demangle_function_name (work, mangled, declp, scan);
2635 /* Save state so we can restart if the guess at the correct "__" was
2636 wrong. */
2637 string_init (&decl_init);
2638 string_appends (&decl_init, declp);
2639 memset (&work_init, 0, sizeof work_init);
2640 work_stuff_copy_to_from (&work_init, work);
2642 /* Iterate over occurrences of __, allowing names and types to have a
2643 "__" sequence in them. We must start with the first (not the last)
2644 occurrence, since "__" most often occur between independent mangled
2645 parts, hence starting at the last occurence inside a signature
2646 might get us a "successful" demangling of the signature. */
2648 while (scan[2])
2650 if (demangle_function_name (work, mangled, declp, scan))
2652 success = demangle_signature (work, mangled, declp);
2653 if (success)
2654 break;
2657 /* Reset demangle state for the next round. */
2658 *mangled = mangle_init;
2659 string_clear (declp);
2660 string_appends (declp, &decl_init);
2661 work_stuff_copy_to_from (work, &work_init);
2663 /* Leave this underscore-sequence. */
2664 scan += 2;
2666 /* Scan for the next "__" sequence. */
2667 while (*scan && (scan[0] != '_' || scan[1] != '_'))
2668 scan++;
2670 /* Move to last "__" in this sequence. */
2671 while (*scan && *scan == '_')
2672 scan++;
2673 scan -= 2;
2676 /* Delete saved state. */
2677 delete_work_stuff (&work_init);
2678 string_delete (&decl_init);
2680 return success;
2685 LOCAL FUNCTION
2687 demangle_prefix -- consume the mangled name prefix and find signature
2689 SYNOPSIS
2691 static int
2692 demangle_prefix (struct work_stuff *work, const char **mangled,
2693 string *declp);
2695 DESCRIPTION
2697 Consume and demangle the prefix of the mangled name.
2698 While processing the function name root, arrange to call
2699 demangle_signature if the root is ambiguous.
2701 DECLP points to the string buffer into which demangled output is
2702 placed. On entry, the buffer is empty. On exit it contains
2703 the root function name, the demangled operator name, or in some
2704 special cases either nothing or the completely demangled result.
2706 MANGLED points to the current pointer into the mangled name. As each
2707 token of the mangled name is consumed, it is updated. Upon entry
2708 the current mangled name pointer points to the first character of
2709 the mangled name. Upon exit, it should point to the first character
2710 of the signature if demangling was successful, or to the first
2711 unconsumed character if demangling of the prefix was unsuccessful.
2713 Returns 1 on success, 0 otherwise.
2716 static int
2717 demangle_prefix (struct work_stuff *work, const char **mangled,
2718 string *declp)
2720 int success = 1;
2721 const char *scan;
2722 int i;
2724 if (strlen(*mangled) > 6
2725 && (strncmp(*mangled, "_imp__", 6) == 0
2726 || strncmp(*mangled, "__imp_", 6) == 0))
2728 /* it's a symbol imported from a PE dynamic library. Check for both
2729 new style prefix _imp__ and legacy __imp_ used by older versions
2730 of dlltool. */
2731 (*mangled) += 6;
2732 work->dllimported = 1;
2734 else if (strlen(*mangled) >= 11 && strncmp(*mangled, "_GLOBAL_", 8) == 0)
2736 char *marker = strchr (cplus_markers, (*mangled)[8]);
2737 if (marker != NULL && *marker == (*mangled)[10])
2739 if ((*mangled)[9] == 'D')
2741 /* it's a GNU global destructor to be executed at program exit */
2742 (*mangled) += 11;
2743 work->destructor = 2;
2744 if (gnu_special (work, mangled, declp))
2745 return success;
2747 else if ((*mangled)[9] == 'I')
2749 /* it's a GNU global constructor to be executed at program init */
2750 (*mangled) += 11;
2751 work->constructor = 2;
2752 if (gnu_special (work, mangled, declp))
2753 return success;
2757 else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__std__", 7) == 0)
2759 /* it's a ARM global destructor to be executed at program exit */
2760 (*mangled) += 7;
2761 work->destructor = 2;
2763 else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__sti__", 7) == 0)
2765 /* it's a ARM global constructor to be executed at program initial */
2766 (*mangled) += 7;
2767 work->constructor = 2;
2770 /* This block of code is a reduction in strength time optimization
2772 scan = strstr (*mangled, "__"); */
2775 scan = *mangled;
2777 do {
2778 scan = strchr (scan, '_');
2779 } while (scan != NULL && *++scan != '_');
2781 if (scan != NULL) --scan;
2784 if (scan != NULL)
2786 /* We found a sequence of two or more '_', ensure that we start at
2787 the last pair in the sequence. */
2788 i = strspn (scan, "_");
2789 if (i > 2)
2791 scan += (i - 2);
2795 if (scan == NULL)
2797 success = 0;
2799 else if (work -> static_type)
2801 if (!ISDIGIT ((unsigned char)scan[0]) && (scan[0] != 't'))
2803 success = 0;
2806 else if ((scan == *mangled)
2807 && (ISDIGIT ((unsigned char)scan[2]) || (scan[2] == 'Q')
2808 || (scan[2] == 't') || (scan[2] == 'K') || (scan[2] == 'H')))
2810 /* The ARM says nothing about the mangling of local variables.
2811 But cfront mangles local variables by prepending __<nesting_level>
2812 to them. As an extension to ARM demangling we handle this case. */
2813 if ((LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING)
2814 && ISDIGIT ((unsigned char)scan[2]))
2816 *mangled = scan + 2;
2817 consume_count (mangled);
2818 string_append (declp, *mangled);
2819 *mangled += strlen (*mangled);
2820 success = 1;
2822 else
2824 /* A GNU style constructor starts with __[0-9Qt]. But cfront uses
2825 names like __Q2_3foo3bar for nested type names. So don't accept
2826 this style of constructor for cfront demangling. A GNU
2827 style member-template constructor starts with 'H'. */
2828 if (!(LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING))
2829 work -> constructor += 1;
2830 *mangled = scan + 2;
2833 else if (ARM_DEMANGLING && scan[2] == 'p' && scan[3] == 't')
2835 /* Cfront-style parameterized type. Handled later as a signature. */
2836 success = 1;
2838 /* ARM template? */
2839 demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
2841 else if (EDG_DEMANGLING && ((scan[2] == 't' && scan[3] == 'm')
2842 || (scan[2] == 'p' && scan[3] == 's')
2843 || (scan[2] == 'p' && scan[3] == 't')))
2845 /* EDG-style parameterized type. Handled later as a signature. */
2846 success = 1;
2848 /* EDG template? */
2849 demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
2851 else if ((scan == *mangled) && !ISDIGIT ((unsigned char)scan[2])
2852 && (scan[2] != 't'))
2854 /* Mangled name starts with "__". Skip over any leading '_' characters,
2855 then find the next "__" that separates the prefix from the signature.
2857 if (!(ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
2858 || (arm_special (mangled, declp) == 0))
2860 while (*scan == '_')
2862 scan++;
2864 if ((scan = strstr (scan, "__")) == NULL || (*(scan + 2) == '\0'))
2866 /* No separator (I.E. "__not_mangled"), or empty signature
2867 (I.E. "__not_mangled_either__") */
2868 success = 0;
2870 else
2871 return iterate_demangle_function (work, mangled, declp, scan);
2874 else if (*(scan + 2) != '\0')
2876 /* Mangled name does not start with "__" but does have one somewhere
2877 in there with non empty stuff after it. Looks like a global
2878 function name. Iterate over all "__":s until the right
2879 one is found. */
2880 return iterate_demangle_function (work, mangled, declp, scan);
2882 else
2884 /* Doesn't look like a mangled name */
2885 success = 0;
2888 if (!success && (work->constructor == 2 || work->destructor == 2))
2890 string_append (declp, *mangled);
2891 *mangled += strlen (*mangled);
2892 success = 1;
2894 return (success);
2899 LOCAL FUNCTION
2901 gnu_special -- special handling of gnu mangled strings
2903 SYNOPSIS
2905 static int
2906 gnu_special (struct work_stuff *work, const char **mangled,
2907 string *declp);
2910 DESCRIPTION
2912 Process some special GNU style mangling forms that don't fit
2913 the normal pattern. For example:
2915 _$_3foo (destructor for class foo)
2916 _vt$foo (foo virtual table)
2917 _vt$foo$bar (foo::bar virtual table)
2918 __vt_foo (foo virtual table, new style with thunks)
2919 _3foo$varname (static data member)
2920 _Q22rs2tu$vw (static data member)
2921 __t6vector1Zii (constructor with template)
2922 __thunk_4__$_7ostream (virtual function thunk)
2925 static int
2926 gnu_special (struct work_stuff *work, const char **mangled, string *declp)
2928 int n;
2929 int success = 1;
2930 const char *p;
2932 if ((*mangled)[0] == '_'
2933 && strchr (cplus_markers, (*mangled)[1]) != NULL
2934 && (*mangled)[2] == '_')
2936 /* Found a GNU style destructor, get past "_<CPLUS_MARKER>_" */
2937 (*mangled) += 3;
2938 work -> destructor += 1;
2940 else if ((*mangled)[0] == '_'
2941 && (((*mangled)[1] == '_'
2942 && (*mangled)[2] == 'v'
2943 && (*mangled)[3] == 't'
2944 && (*mangled)[4] == '_')
2945 || ((*mangled)[1] == 'v'
2946 && (*mangled)[2] == 't'
2947 && strchr (cplus_markers, (*mangled)[3]) != NULL)))
2949 /* Found a GNU style virtual table, get past "_vt<CPLUS_MARKER>"
2950 and create the decl. Note that we consume the entire mangled
2951 input string, which means that demangle_signature has no work
2952 to do. */
2953 if ((*mangled)[2] == 'v')
2954 (*mangled) += 5; /* New style, with thunks: "__vt_" */
2955 else
2956 (*mangled) += 4; /* Old style, no thunks: "_vt<CPLUS_MARKER>" */
2957 while (**mangled != '\0')
2959 switch (**mangled)
2961 case 'Q':
2962 case 'K':
2963 success = demangle_qualified (work, mangled, declp, 0, 1);
2964 break;
2965 case 't':
2966 success = demangle_template (work, mangled, declp, 0, 1,
2968 break;
2969 default:
2970 if (ISDIGIT((unsigned char)*mangled[0]))
2972 n = consume_count(mangled);
2973 /* We may be seeing a too-large size, or else a
2974 ".<digits>" indicating a static local symbol. In
2975 any case, declare victory and move on; *don't* try
2976 to use n to allocate. */
2977 if (n > (int) strlen (*mangled))
2979 success = 1;
2980 break;
2983 else
2985 n = strcspn (*mangled, cplus_markers);
2987 string_appendn (declp, *mangled, n);
2988 (*mangled) += n;
2991 p = strpbrk (*mangled, cplus_markers);
2992 if (success && ((p == NULL) || (p == *mangled)))
2994 if (p != NULL)
2996 string_append (declp, SCOPE_STRING (work));
2997 (*mangled)++;
3000 else
3002 success = 0;
3003 break;
3006 if (success)
3007 string_append (declp, " virtual table");
3009 else if ((*mangled)[0] == '_'
3010 && (strchr("0123456789Qt", (*mangled)[1]) != NULL)
3011 && (p = strpbrk (*mangled, cplus_markers)) != NULL)
3013 /* static data member, "_3foo$varname" for example */
3014 (*mangled)++;
3015 switch (**mangled)
3017 case 'Q':
3018 case 'K':
3019 success = demangle_qualified (work, mangled, declp, 0, 1);
3020 break;
3021 case 't':
3022 success = demangle_template (work, mangled, declp, 0, 1, 1);
3023 break;
3024 default:
3025 n = consume_count (mangled);
3026 if (n < 0 || n > (long) strlen (*mangled))
3028 success = 0;
3029 break;
3032 if (n > 10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
3033 && (*mangled)[9] == 'N'
3034 && (*mangled)[8] == (*mangled)[10]
3035 && strchr (cplus_markers, (*mangled)[8]))
3037 /* A member of the anonymous namespace. There's information
3038 about what identifier or filename it was keyed to, but
3039 it's just there to make the mangled name unique; we just
3040 step over it. */
3041 string_append (declp, "{anonymous}");
3042 (*mangled) += n;
3044 /* Now p points to the marker before the N, so we need to
3045 update it to the first marker after what we consumed. */
3046 p = strpbrk (*mangled, cplus_markers);
3047 break;
3050 string_appendn (declp, *mangled, n);
3051 (*mangled) += n;
3053 if (success && (p == *mangled))
3055 /* Consumed everything up to the cplus_marker, append the
3056 variable name. */
3057 (*mangled)++;
3058 string_append (declp, SCOPE_STRING (work));
3059 n = strlen (*mangled);
3060 string_appendn (declp, *mangled, n);
3061 (*mangled) += n;
3063 else
3065 success = 0;
3068 else if (strncmp (*mangled, "__thunk_", 8) == 0)
3070 int delta;
3072 (*mangled) += 8;
3073 delta = consume_count (mangled);
3074 if (delta == -1)
3075 success = 0;
3076 else
3078 char *method = internal_cplus_demangle (work, ++*mangled);
3080 if (method)
3082 char buf[50];
3083 sprintf (buf, "virtual function thunk (delta:%d) for ", -delta);
3084 string_append (declp, buf);
3085 string_append (declp, method);
3086 free (method);
3087 n = strlen (*mangled);
3088 (*mangled) += n;
3090 else
3092 success = 0;
3096 else if (strncmp (*mangled, "__t", 3) == 0
3097 && ((*mangled)[3] == 'i' || (*mangled)[3] == 'f'))
3099 p = (*mangled)[3] == 'i' ? " type_info node" : " type_info function";
3100 (*mangled) += 4;
3101 switch (**mangled)
3103 case 'Q':
3104 case 'K':
3105 success = demangle_qualified (work, mangled, declp, 0, 1);
3106 break;
3107 case 't':
3108 success = demangle_template (work, mangled, declp, 0, 1, 1);
3109 break;
3110 default:
3111 success = do_type (work, mangled, declp);
3112 break;
3114 if (success && **mangled != '\0')
3115 success = 0;
3116 if (success)
3117 string_append (declp, p);
3119 else
3121 success = 0;
3123 return (success);
3126 static void
3127 recursively_demangle(struct work_stuff *work, const char **mangled,
3128 string *result, int namelength)
3130 char * recurse = (char *)NULL;
3131 char * recurse_dem = (char *)NULL;
3133 recurse = XNEWVEC (char, namelength + 1);
3134 memcpy (recurse, *mangled, namelength);
3135 recurse[namelength] = '\000';
3137 recurse_dem = cplus_demangle (recurse, work->options);
3139 if (recurse_dem)
3141 string_append (result, recurse_dem);
3142 free (recurse_dem);
3144 else
3146 string_appendn (result, *mangled, namelength);
3148 free (recurse);
3149 *mangled += namelength;
3154 LOCAL FUNCTION
3156 arm_special -- special handling of ARM/lucid mangled strings
3158 SYNOPSIS
3160 static int
3161 arm_special (const char **mangled,
3162 string *declp);
3165 DESCRIPTION
3167 Process some special ARM style mangling forms that don't fit
3168 the normal pattern. For example:
3170 __vtbl__3foo (foo virtual table)
3171 __vtbl__3foo__3bar (bar::foo virtual table)
3175 static int
3176 arm_special (const char **mangled, string *declp)
3178 int n;
3179 int success = 1;
3180 const char *scan;
3182 if (strncmp (*mangled, ARM_VTABLE_STRING, ARM_VTABLE_STRLEN) == 0)
3184 /* Found a ARM style virtual table, get past ARM_VTABLE_STRING
3185 and create the decl. Note that we consume the entire mangled
3186 input string, which means that demangle_signature has no work
3187 to do. */
3188 scan = *mangled + ARM_VTABLE_STRLEN;
3189 while (*scan != '\0') /* first check it can be demangled */
3191 n = consume_count (&scan);
3192 if (n == -1)
3194 return (0); /* no good */
3196 scan += n;
3197 if (scan[0] == '_' && scan[1] == '_')
3199 scan += 2;
3202 (*mangled) += ARM_VTABLE_STRLEN;
3203 while (**mangled != '\0')
3205 n = consume_count (mangled);
3206 if (n == -1
3207 || n > (long) strlen (*mangled))
3208 return 0;
3209 string_prependn (declp, *mangled, n);
3210 (*mangled) += n;
3211 if ((*mangled)[0] == '_' && (*mangled)[1] == '_')
3213 string_prepend (declp, "::");
3214 (*mangled) += 2;
3217 string_append (declp, " virtual table");
3219 else
3221 success = 0;
3223 return (success);
3228 LOCAL FUNCTION
3230 demangle_qualified -- demangle 'Q' qualified name strings
3232 SYNOPSIS
3234 static int
3235 demangle_qualified (struct work_stuff *, const char *mangled,
3236 string *result, int isfuncname, int append);
3238 DESCRIPTION
3240 Demangle a qualified name, such as "Q25Outer5Inner" which is
3241 the mangled form of "Outer::Inner". The demangled output is
3242 prepended or appended to the result string according to the
3243 state of the append flag.
3245 If isfuncname is nonzero, then the qualified name we are building
3246 is going to be used as a member function name, so if it is a
3247 constructor or destructor function, append an appropriate
3248 constructor or destructor name. I.E. for the above example,
3249 the result for use as a constructor is "Outer::Inner::Inner"
3250 and the result for use as a destructor is "Outer::Inner::~Inner".
3252 BUGS
3254 Numeric conversion is ASCII dependent (FIXME).
3258 static int
3259 demangle_qualified (struct work_stuff *work, const char **mangled,
3260 string *result, int isfuncname, int append)
3262 int qualifiers = 0;
3263 int success = 1;
3264 char num[2];
3265 string temp;
3266 string last_name;
3267 int bindex = register_Btype (work);
3269 /* We only make use of ISFUNCNAME if the entity is a constructor or
3270 destructor. */
3271 isfuncname = (isfuncname
3272 && ((work->constructor & 1) || (work->destructor & 1)));
3274 string_init (&temp);
3275 string_init (&last_name);
3277 if ((*mangled)[0] == 'K')
3279 /* Squangling qualified name reuse */
3280 int idx;
3281 (*mangled)++;
3282 idx = consume_count_with_underscores (mangled);
3283 if (idx == -1 || idx >= work -> numk)
3284 success = 0;
3285 else
3286 string_append (&temp, work -> ktypevec[idx]);
3288 else
3289 switch ((*mangled)[1])
3291 case '_':
3292 /* GNU mangled name with more than 9 classes. The count is preceded
3293 by an underscore (to distinguish it from the <= 9 case) and followed
3294 by an underscore. */
3295 (*mangled)++;
3296 qualifiers = consume_count_with_underscores (mangled);
3297 if (qualifiers == -1)
3298 success = 0;
3299 break;
3301 case '1':
3302 case '2':
3303 case '3':
3304 case '4':
3305 case '5':
3306 case '6':
3307 case '7':
3308 case '8':
3309 case '9':
3310 /* The count is in a single digit. */
3311 num[0] = (*mangled)[1];
3312 num[1] = '\0';
3313 qualifiers = atoi (num);
3315 /* If there is an underscore after the digit, skip it. This is
3316 said to be for ARM-qualified names, but the ARM makes no
3317 mention of such an underscore. Perhaps cfront uses one. */
3318 if ((*mangled)[2] == '_')
3320 (*mangled)++;
3322 (*mangled) += 2;
3323 break;
3325 case '0':
3326 default:
3327 success = 0;
3330 if (!success)
3331 return success;
3333 /* Pick off the names and collect them in the temp buffer in the order
3334 in which they are found, separated by '::'. */
3336 while (qualifiers-- > 0)
3338 int remember_K = 1;
3339 string_clear (&last_name);
3341 if (*mangled[0] == '_')
3342 (*mangled)++;
3344 if (*mangled[0] == 't')
3346 /* Here we always append to TEMP since we will want to use
3347 the template name without the template parameters as a
3348 constructor or destructor name. The appropriate
3349 (parameter-less) value is returned by demangle_template
3350 in LAST_NAME. We do not remember the template type here,
3351 in order to match the G++ mangling algorithm. */
3352 success = demangle_template(work, mangled, &temp,
3353 &last_name, 1, 0);
3354 if (!success)
3355 break;
3357 else if (*mangled[0] == 'K')
3359 int idx;
3360 (*mangled)++;
3361 idx = consume_count_with_underscores (mangled);
3362 if (idx == -1 || idx >= work->numk)
3363 success = 0;
3364 else
3365 string_append (&temp, work->ktypevec[idx]);
3366 remember_K = 0;
3368 if (!success) break;
3370 else
3372 if (EDG_DEMANGLING)
3374 int namelength;
3375 /* Now recursively demangle the qualifier
3376 * This is necessary to deal with templates in
3377 * mangling styles like EDG */
3378 namelength = consume_count (mangled);
3379 if (namelength == -1)
3381 success = 0;
3382 break;
3384 recursively_demangle(work, mangled, &temp, namelength);
3386 else
3388 string_delete (&last_name);
3389 success = do_type (work, mangled, &last_name);
3390 if (!success)
3391 break;
3392 string_appends (&temp, &last_name);
3396 if (remember_K)
3397 remember_Ktype (work, temp.b, LEN_STRING (&temp));
3399 if (qualifiers > 0)
3400 string_append (&temp, SCOPE_STRING (work));
3403 remember_Btype (work, temp.b, LEN_STRING (&temp), bindex);
3405 /* If we are using the result as a function name, we need to append
3406 the appropriate '::' separated constructor or destructor name.
3407 We do this here because this is the most convenient place, where
3408 we already have a pointer to the name and the length of the name. */
3410 if (isfuncname)
3412 string_append (&temp, SCOPE_STRING (work));
3413 if (work -> destructor & 1)
3414 string_append (&temp, "~");
3415 string_appends (&temp, &last_name);
3418 /* Now either prepend the temp buffer to the result, or append it,
3419 depending upon the state of the append flag. */
3421 if (append)
3422 string_appends (result, &temp);
3423 else
3425 if (!STRING_EMPTY (result))
3426 string_append (&temp, SCOPE_STRING (work));
3427 string_prepends (result, &temp);
3430 string_delete (&last_name);
3431 string_delete (&temp);
3432 return (success);
3437 LOCAL FUNCTION
3439 get_count -- convert an ascii count to integer, consuming tokens
3441 SYNOPSIS
3443 static int
3444 get_count (const char **type, int *count)
3446 DESCRIPTION
3448 Assume that *type points at a count in a mangled name; set
3449 *count to its value, and set *type to the next character after
3450 the count. There are some weird rules in effect here.
3452 If *type does not point at a string of digits, return zero.
3454 If *type points at a string of digits followed by an
3455 underscore, set *count to their value as an integer, advance
3456 *type to point *after the underscore, and return 1.
3458 If *type points at a string of digits not followed by an
3459 underscore, consume only the first digit. Set *count to its
3460 value as an integer, leave *type pointing after that digit,
3461 and return 1.
3463 The excuse for this odd behavior: in the ARM and HP demangling
3464 styles, a type can be followed by a repeat count of the form
3465 `Nxy', where:
3467 `x' is a single digit specifying how many additional copies
3468 of the type to append to the argument list, and
3470 `y' is one or more digits, specifying the zero-based index of
3471 the first repeated argument in the list. Yes, as you're
3472 unmangling the name you can figure this out yourself, but
3473 it's there anyway.
3475 So, for example, in `bar__3fooFPiN51', the first argument is a
3476 pointer to an integer (`Pi'), and then the next five arguments
3477 are the same (`N5'), and the first repeat is the function's
3478 second argument (`1').
3481 static int
3482 get_count (const char **type, int *count)
3484 const char *p;
3485 int n;
3487 if (!ISDIGIT ((unsigned char)**type))
3488 return (0);
3489 else
3491 *count = **type - '0';
3492 (*type)++;
3493 if (ISDIGIT ((unsigned char)**type))
3495 p = *type;
3496 n = *count;
3499 n *= 10;
3500 n += *p - '0';
3501 p++;
3503 while (ISDIGIT ((unsigned char)*p));
3504 if (*p == '_')
3506 *type = p + 1;
3507 *count = n;
3511 return (1);
3514 /* RESULT will be initialised here; it will be freed on failure. The
3515 value returned is really a type_kind_t. */
3517 static int
3518 do_type (struct work_stuff *work, const char **mangled, string *result)
3520 int n;
3521 int done;
3522 int success;
3523 string decl;
3524 const char *remembered_type;
3525 int type_quals;
3526 type_kind_t tk = tk_none;
3528 string_init (&decl);
3529 string_init (result);
3531 done = 0;
3532 success = 1;
3533 while (success && !done)
3535 int member;
3536 switch (**mangled)
3539 /* A pointer type */
3540 case 'P':
3541 case 'p':
3542 (*mangled)++;
3543 if (! (work -> options & DMGL_JAVA))
3544 string_prepend (&decl, "*");
3545 if (tk == tk_none)
3546 tk = tk_pointer;
3547 break;
3549 /* A reference type */
3550 case 'R':
3551 (*mangled)++;
3552 string_prepend (&decl, "&");
3553 if (tk == tk_none)
3554 tk = tk_reference;
3555 break;
3557 /* An array */
3558 case 'A':
3560 ++(*mangled);
3561 if (!STRING_EMPTY (&decl)
3562 && (decl.b[0] == '*' || decl.b[0] == '&'))
3564 string_prepend (&decl, "(");
3565 string_append (&decl, ")");
3567 string_append (&decl, "[");
3568 if (**mangled != '_')
3569 success = demangle_template_value_parm (work, mangled, &decl,
3570 tk_integral);
3571 if (**mangled == '_')
3572 ++(*mangled);
3573 string_append (&decl, "]");
3574 break;
3577 /* A back reference to a previously seen type */
3578 case 'T':
3579 (*mangled)++;
3580 if (!get_count (mangled, &n) || n >= work -> ntypes)
3582 success = 0;
3584 else
3586 remembered_type = work -> typevec[n];
3587 mangled = &remembered_type;
3589 break;
3591 /* A function */
3592 case 'F':
3593 (*mangled)++;
3594 if (!STRING_EMPTY (&decl)
3595 && (decl.b[0] == '*' || decl.b[0] == '&'))
3597 string_prepend (&decl, "(");
3598 string_append (&decl, ")");
3600 /* After picking off the function args, we expect to either find the
3601 function return type (preceded by an '_') or the end of the
3602 string. */
3603 if (!demangle_nested_args (work, mangled, &decl)
3604 || (**mangled != '_' && **mangled != '\0'))
3606 success = 0;
3607 break;
3609 if (success && (**mangled == '_'))
3610 (*mangled)++;
3611 break;
3613 case 'M':
3614 case 'O':
3616 type_quals = TYPE_UNQUALIFIED;
3618 member = **mangled == 'M';
3619 (*mangled)++;
3621 string_append (&decl, ")");
3623 /* We don't need to prepend `::' for a qualified name;
3624 demangle_qualified will do that for us. */
3625 if (**mangled != 'Q')
3626 string_prepend (&decl, SCOPE_STRING (work));
3628 if (ISDIGIT ((unsigned char)**mangled))
3630 n = consume_count (mangled);
3631 if (n == -1
3632 || (int) strlen (*mangled) < n)
3634 success = 0;
3635 break;
3637 string_prependn (&decl, *mangled, n);
3638 *mangled += n;
3640 else if (**mangled == 'X' || **mangled == 'Y')
3642 string temp;
3643 do_type (work, mangled, &temp);
3644 string_prepends (&decl, &temp);
3645 string_delete (&temp);
3647 else if (**mangled == 't')
3649 string temp;
3650 string_init (&temp);
3651 success = demangle_template (work, mangled, &temp,
3652 NULL, 1, 1);
3653 if (success)
3655 string_prependn (&decl, temp.b, temp.p - temp.b);
3656 string_delete (&temp);
3658 else
3659 break;
3661 else if (**mangled == 'Q')
3663 success = demangle_qualified (work, mangled, &decl,
3664 /*isfuncnam=*/0,
3665 /*append=*/0);
3666 if (!success)
3667 break;
3669 else
3671 success = 0;
3672 break;
3675 string_prepend (&decl, "(");
3676 if (member)
3678 switch (**mangled)
3680 case 'C':
3681 case 'V':
3682 case 'u':
3683 type_quals |= code_for_qualifier (**mangled);
3684 (*mangled)++;
3685 break;
3687 default:
3688 break;
3691 if (*(*mangled)++ != 'F')
3693 success = 0;
3694 break;
3697 if ((member && !demangle_nested_args (work, mangled, &decl))
3698 || **mangled != '_')
3700 success = 0;
3701 break;
3703 (*mangled)++;
3704 if (! PRINT_ANSI_QUALIFIERS)
3706 break;
3708 if (type_quals != TYPE_UNQUALIFIED)
3710 APPEND_BLANK (&decl);
3711 string_append (&decl, qualifier_string (type_quals));
3713 break;
3715 case 'G':
3716 (*mangled)++;
3717 break;
3719 case 'C':
3720 case 'V':
3721 case 'u':
3722 if (PRINT_ANSI_QUALIFIERS)
3724 if (!STRING_EMPTY (&decl))
3725 string_prepend (&decl, " ");
3727 string_prepend (&decl, demangle_qualifier (**mangled));
3729 (*mangled)++;
3730 break;
3735 /* fall through */
3736 default:
3737 done = 1;
3738 break;
3742 if (success) switch (**mangled)
3744 /* A qualified name, such as "Outer::Inner". */
3745 case 'Q':
3746 case 'K':
3748 success = demangle_qualified (work, mangled, result, 0, 1);
3749 break;
3752 /* A back reference to a previously seen squangled type */
3753 case 'B':
3754 (*mangled)++;
3755 if (!get_count (mangled, &n) || n >= work -> numb)
3756 success = 0;
3757 else
3758 string_append (result, work->btypevec[n]);
3759 break;
3761 case 'X':
3762 case 'Y':
3763 /* A template parm. We substitute the corresponding argument. */
3765 int idx;
3767 (*mangled)++;
3768 idx = consume_count_with_underscores (mangled);
3770 if (idx == -1
3771 || (work->tmpl_argvec && idx >= work->ntmpl_args)
3772 || consume_count_with_underscores (mangled) == -1)
3774 success = 0;
3775 break;
3778 if (work->tmpl_argvec)
3779 string_append (result, work->tmpl_argvec[idx]);
3780 else
3781 string_append_template_idx (result, idx);
3783 success = 1;
3785 break;
3787 default:
3788 success = demangle_fund_type (work, mangled, result);
3789 if (tk == tk_none)
3790 tk = (type_kind_t) success;
3791 break;
3794 if (success)
3796 if (!STRING_EMPTY (&decl))
3798 string_append (result, " ");
3799 string_appends (result, &decl);
3802 else
3803 string_delete (result);
3804 string_delete (&decl);
3806 if (success)
3807 /* Assume an integral type, if we're not sure. */
3808 return (int) ((tk == tk_none) ? tk_integral : tk);
3809 else
3810 return 0;
3813 /* Given a pointer to a type string that represents a fundamental type
3814 argument (int, long, unsigned int, etc) in TYPE, a pointer to the
3815 string in which the demangled output is being built in RESULT, and
3816 the WORK structure, decode the types and add them to the result.
3818 For example:
3820 "Ci" => "const int"
3821 "Sl" => "signed long"
3822 "CUs" => "const unsigned short"
3824 The value returned is really a type_kind_t. */
3826 static int
3827 demangle_fund_type (struct work_stuff *work,
3828 const char **mangled, string *result)
3830 int done = 0;
3831 int success = 1;
3832 char buf[INTBUF_SIZE + 5 /* 'int%u_t' */];
3833 unsigned int dec = 0;
3834 type_kind_t tk = tk_integral;
3836 /* First pick off any type qualifiers. There can be more than one. */
3838 while (!done)
3840 switch (**mangled)
3842 case 'C':
3843 case 'V':
3844 case 'u':
3845 if (PRINT_ANSI_QUALIFIERS)
3847 if (!STRING_EMPTY (result))
3848 string_prepend (result, " ");
3849 string_prepend (result, demangle_qualifier (**mangled));
3851 (*mangled)++;
3852 break;
3853 case 'U':
3854 (*mangled)++;
3855 APPEND_BLANK (result);
3856 string_append (result, "unsigned");
3857 break;
3858 case 'S': /* signed char only */
3859 (*mangled)++;
3860 APPEND_BLANK (result);
3861 string_append (result, "signed");
3862 break;
3863 case 'J':
3864 (*mangled)++;
3865 APPEND_BLANK (result);
3866 string_append (result, "__complex");
3867 break;
3868 default:
3869 done = 1;
3870 break;
3874 /* Now pick off the fundamental type. There can be only one. */
3876 switch (**mangled)
3878 case '\0':
3879 case '_':
3880 break;
3881 case 'v':
3882 (*mangled)++;
3883 APPEND_BLANK (result);
3884 string_append (result, "void");
3885 break;
3886 case 'x':
3887 (*mangled)++;
3888 APPEND_BLANK (result);
3889 string_append (result, "long long");
3890 break;
3891 case 'l':
3892 (*mangled)++;
3893 APPEND_BLANK (result);
3894 string_append (result, "long");
3895 break;
3896 case 'i':
3897 (*mangled)++;
3898 APPEND_BLANK (result);
3899 string_append (result, "int");
3900 break;
3901 case 's':
3902 (*mangled)++;
3903 APPEND_BLANK (result);
3904 string_append (result, "short");
3905 break;
3906 case 'b':
3907 (*mangled)++;
3908 APPEND_BLANK (result);
3909 string_append (result, "bool");
3910 tk = tk_bool;
3911 break;
3912 case 'c':
3913 (*mangled)++;
3914 APPEND_BLANK (result);
3915 string_append (result, "char");
3916 tk = tk_char;
3917 break;
3918 case 'w':
3919 (*mangled)++;
3920 APPEND_BLANK (result);
3921 string_append (result, "wchar_t");
3922 tk = tk_char;
3923 break;
3924 case 'r':
3925 (*mangled)++;
3926 APPEND_BLANK (result);
3927 string_append (result, "long double");
3928 tk = tk_real;
3929 break;
3930 case 'd':
3931 (*mangled)++;
3932 APPEND_BLANK (result);
3933 string_append (result, "double");
3934 tk = tk_real;
3935 break;
3936 case 'f':
3937 (*mangled)++;
3938 APPEND_BLANK (result);
3939 string_append (result, "float");
3940 tk = tk_real;
3941 break;
3942 case 'G':
3943 (*mangled)++;
3944 if (!ISDIGIT ((unsigned char)**mangled))
3946 success = 0;
3947 break;
3949 case 'I':
3950 (*mangled)++;
3951 if (**mangled == '_')
3953 int i;
3954 (*mangled)++;
3955 for (i = 0;
3956 i < (long) sizeof (buf) - 1 && **mangled && **mangled != '_';
3957 (*mangled)++, i++)
3958 buf[i] = **mangled;
3959 if (**mangled != '_')
3961 success = 0;
3962 break;
3964 buf[i] = '\0';
3965 (*mangled)++;
3967 else
3969 strncpy (buf, *mangled, 2);
3970 buf[2] = '\0';
3971 *mangled += min (strlen (*mangled), 2);
3973 sscanf (buf, "%x", &dec);
3974 sprintf (buf, "int%u_t", dec);
3975 APPEND_BLANK (result);
3976 string_append (result, buf);
3977 break;
3979 /* fall through */
3980 /* An explicit type, such as "6mytype" or "7integer" */
3981 case '0':
3982 case '1':
3983 case '2':
3984 case '3':
3985 case '4':
3986 case '5':
3987 case '6':
3988 case '7':
3989 case '8':
3990 case '9':
3992 int bindex = register_Btype (work);
3993 string btype;
3994 string_init (&btype);
3995 if (demangle_class_name (work, mangled, &btype)) {
3996 remember_Btype (work, btype.b, LEN_STRING (&btype), bindex);
3997 APPEND_BLANK (result);
3998 string_appends (result, &btype);
4000 else
4001 success = 0;
4002 string_delete (&btype);
4003 break;
4005 case 't':
4007 string btype;
4008 string_init (&btype);
4009 success = demangle_template (work, mangled, &btype, 0, 1, 1);
4010 string_appends (result, &btype);
4011 string_delete (&btype);
4012 break;
4014 default:
4015 success = 0;
4016 break;
4019 return success ? ((int) tk) : 0;
4023 /* Handle a template's value parameter for HP aCC (extension from ARM)
4024 **mangled points to 'S' or 'U' */
4026 static int
4027 do_hpacc_template_const_value (struct work_stuff *work ATTRIBUTE_UNUSED,
4028 const char **mangled, string *result)
4030 int unsigned_const;
4032 if (**mangled != 'U' && **mangled != 'S')
4033 return 0;
4035 unsigned_const = (**mangled == 'U');
4037 (*mangled)++;
4039 switch (**mangled)
4041 case 'N':
4042 string_append (result, "-");
4043 /* fall through */
4044 case 'P':
4045 (*mangled)++;
4046 break;
4047 case 'M':
4048 /* special case for -2^31 */
4049 string_append (result, "-2147483648");
4050 (*mangled)++;
4051 return 1;
4052 default:
4053 return 0;
4056 /* We have to be looking at an integer now */
4057 if (!(ISDIGIT ((unsigned char)**mangled)))
4058 return 0;
4060 /* We only deal with integral values for template
4061 parameters -- so it's OK to look only for digits */
4062 while (ISDIGIT ((unsigned char)**mangled))
4064 char_str[0] = **mangled;
4065 string_append (result, char_str);
4066 (*mangled)++;
4069 if (unsigned_const)
4070 string_append (result, "U");
4072 /* FIXME? Some day we may have 64-bit (or larger :-) ) constants
4073 with L or LL suffixes. pai/1997-09-03 */
4075 return 1; /* success */
4078 /* Handle a template's literal parameter for HP aCC (extension from ARM)
4079 **mangled is pointing to the 'A' */
4081 static int
4082 do_hpacc_template_literal (struct work_stuff *work, const char **mangled,
4083 string *result)
4085 int literal_len = 0;
4086 char * recurse;
4087 char * recurse_dem;
4089 if (**mangled != 'A')
4090 return 0;
4092 (*mangled)++;
4094 literal_len = consume_count (mangled);
4096 if (literal_len <= 0)
4097 return 0;
4099 /* Literal parameters are names of arrays, functions, etc. and the
4100 canonical representation uses the address operator */
4101 string_append (result, "&");
4103 /* Now recursively demangle the literal name */
4104 recurse = XNEWVEC (char, literal_len + 1);
4105 memcpy (recurse, *mangled, literal_len);
4106 recurse[literal_len] = '\000';
4108 recurse_dem = cplus_demangle (recurse, work->options);
4110 if (recurse_dem)
4112 string_append (result, recurse_dem);
4113 free (recurse_dem);
4115 else
4117 string_appendn (result, *mangled, literal_len);
4119 (*mangled) += literal_len;
4120 free (recurse);
4122 return 1;
4125 static int
4126 snarf_numeric_literal (const char **args, string *arg)
4128 if (**args == '-')
4130 char_str[0] = '-';
4131 string_append (arg, char_str);
4132 (*args)++;
4134 else if (**args == '+')
4135 (*args)++;
4137 if (!ISDIGIT ((unsigned char)**args))
4138 return 0;
4140 while (ISDIGIT ((unsigned char)**args))
4142 char_str[0] = **args;
4143 string_append (arg, char_str);
4144 (*args)++;
4147 return 1;
4150 /* Demangle the next argument, given by MANGLED into RESULT, which
4151 *should be an uninitialized* string. It will be initialized here,
4152 and free'd should anything go wrong. */
4154 static int
4155 do_arg (struct work_stuff *work, const char **mangled, string *result)
4157 /* Remember where we started so that we can record the type, for
4158 non-squangling type remembering. */
4159 const char *start = *mangled;
4161 string_init (result);
4163 if (work->nrepeats > 0)
4165 --work->nrepeats;
4167 if (work->previous_argument == 0)
4168 return 0;
4170 /* We want to reissue the previous type in this argument list. */
4171 string_appends (result, work->previous_argument);
4172 return 1;
4175 if (**mangled == 'n')
4177 /* A squangling-style repeat. */
4178 (*mangled)++;
4179 work->nrepeats = consume_count(mangled);
4181 if (work->nrepeats <= 0)
4182 /* This was not a repeat count after all. */
4183 return 0;
4185 if (work->nrepeats > 9)
4187 if (**mangled != '_')
4188 /* The repeat count should be followed by an '_' in this
4189 case. */
4190 return 0;
4191 else
4192 (*mangled)++;
4195 /* Now, the repeat is all set up. */
4196 return do_arg (work, mangled, result);
4199 /* Save the result in WORK->previous_argument so that we can find it
4200 if it's repeated. Note that saving START is not good enough: we
4201 do not want to add additional types to the back-referenceable
4202 type vector when processing a repeated type. */
4203 if (work->previous_argument)
4204 string_delete (work->previous_argument);
4205 else
4206 work->previous_argument = XNEW (string);
4208 if (!do_type (work, mangled, work->previous_argument))
4209 return 0;
4211 string_appends (result, work->previous_argument);
4213 remember_type (work, start, *mangled - start);
4214 return 1;
4217 static void
4218 remember_type (struct work_stuff *work, const char *start, int len)
4220 char *tem;
4222 if (work->forgetting_types)
4223 return;
4225 if (work -> ntypes >= work -> typevec_size)
4227 if (work -> typevec_size == 0)
4229 work -> typevec_size = 3;
4230 work -> typevec = XNEWVEC (char *, work->typevec_size);
4232 else
4234 work -> typevec_size *= 2;
4235 work -> typevec
4236 = XRESIZEVEC (char *, work->typevec, work->typevec_size);
4239 tem = XNEWVEC (char, len + 1);
4240 memcpy (tem, start, len);
4241 tem[len] = '\0';
4242 work -> typevec[work -> ntypes++] = tem;
4246 /* Remember a K type class qualifier. */
4247 static void
4248 remember_Ktype (struct work_stuff *work, const char *start, int len)
4250 char *tem;
4252 if (work -> numk >= work -> ksize)
4254 if (work -> ksize == 0)
4256 work -> ksize = 5;
4257 work -> ktypevec = XNEWVEC (char *, work->ksize);
4259 else
4261 work -> ksize *= 2;
4262 work -> ktypevec
4263 = XRESIZEVEC (char *, work->ktypevec, work->ksize);
4266 tem = XNEWVEC (char, len + 1);
4267 memcpy (tem, start, len);
4268 tem[len] = '\0';
4269 work -> ktypevec[work -> numk++] = tem;
4272 /* Register a B code, and get an index for it. B codes are registered
4273 as they are seen, rather than as they are completed, so map<temp<char> >
4274 registers map<temp<char> > as B0, and temp<char> as B1 */
4276 static int
4277 register_Btype (struct work_stuff *work)
4279 int ret;
4281 if (work -> numb >= work -> bsize)
4283 if (work -> bsize == 0)
4285 work -> bsize = 5;
4286 work -> btypevec = XNEWVEC (char *, work->bsize);
4288 else
4290 work -> bsize *= 2;
4291 work -> btypevec
4292 = XRESIZEVEC (char *, work->btypevec, work->bsize);
4295 ret = work -> numb++;
4296 work -> btypevec[ret] = NULL;
4297 return(ret);
4300 /* Store a value into a previously registered B code type. */
4302 static void
4303 remember_Btype (struct work_stuff *work, const char *start,
4304 int len, int index)
4306 char *tem;
4308 tem = XNEWVEC (char, len + 1);
4309 memcpy (tem, start, len);
4310 tem[len] = '\0';
4311 work -> btypevec[index] = tem;
4314 /* Lose all the info related to B and K type codes. */
4315 static void
4316 forget_B_and_K_types (struct work_stuff *work)
4318 int i;
4320 while (work -> numk > 0)
4322 i = --(work -> numk);
4323 if (work -> ktypevec[i] != NULL)
4325 free (work -> ktypevec[i]);
4326 work -> ktypevec[i] = NULL;
4330 while (work -> numb > 0)
4332 i = --(work -> numb);
4333 if (work -> btypevec[i] != NULL)
4335 free (work -> btypevec[i]);
4336 work -> btypevec[i] = NULL;
4340 /* Forget the remembered types, but not the type vector itself. */
4342 static void
4343 forget_types (struct work_stuff *work)
4345 int i;
4347 while (work -> ntypes > 0)
4349 i = --(work -> ntypes);
4350 if (work -> typevec[i] != NULL)
4352 free (work -> typevec[i]);
4353 work -> typevec[i] = NULL;
4358 /* Process the argument list part of the signature, after any class spec
4359 has been consumed, as well as the first 'F' character (if any). For
4360 example:
4362 "__als__3fooRT0" => process "RT0"
4363 "complexfunc5__FPFPc_PFl_i" => process "PFPc_PFl_i"
4365 DECLP must be already initialised, usually non-empty. It won't be freed
4366 on failure.
4368 Note that g++ differs significantly from ARM and lucid style mangling
4369 with regards to references to previously seen types. For example, given
4370 the source fragment:
4372 class foo {
4373 public:
4374 foo::foo (int, foo &ia, int, foo &ib, int, foo &ic);
4377 foo::foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
4378 void foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
4380 g++ produces the names:
4382 __3fooiRT0iT2iT2
4383 foo__FiR3fooiT1iT1
4385 while lcc (and presumably other ARM style compilers as well) produces:
4387 foo__FiR3fooT1T2T1T2
4388 __ct__3fooFiR3fooT1T2T1T2
4390 Note that g++ bases its type numbers starting at zero and counts all
4391 previously seen types, while lucid/ARM bases its type numbers starting
4392 at one and only considers types after it has seen the 'F' character
4393 indicating the start of the function args. For lucid/ARM style, we
4394 account for this difference by discarding any previously seen types when
4395 we see the 'F' character, and subtracting one from the type number
4396 reference.
4400 static int
4401 demangle_args (struct work_stuff *work, const char **mangled,
4402 string *declp)
4404 string arg;
4405 int need_comma = 0;
4406 int r;
4407 int t;
4408 const char *tem;
4409 char temptype;
4411 if (PRINT_ARG_TYPES)
4413 string_append (declp, "(");
4414 if (**mangled == '\0')
4416 string_append (declp, "void");
4420 while ((**mangled != '_' && **mangled != '\0' && **mangled != 'e')
4421 || work->nrepeats > 0)
4423 if ((**mangled == 'N') || (**mangled == 'T'))
4425 temptype = *(*mangled)++;
4427 if (temptype == 'N')
4429 if (!get_count (mangled, &r))
4431 return (0);
4434 else
4436 r = 1;
4438 if ((HP_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING) && work -> ntypes >= 10)
4440 /* If we have 10 or more types we might have more than a 1 digit
4441 index so we'll have to consume the whole count here. This
4442 will lose if the next thing is a type name preceded by a
4443 count but it's impossible to demangle that case properly
4444 anyway. Eg if we already have 12 types is T12Pc "(..., type1,
4445 Pc, ...)" or "(..., type12, char *, ...)" */
4446 if ((t = consume_count(mangled)) <= 0)
4448 return (0);
4451 else
4453 if (!get_count (mangled, &t))
4455 return (0);
4458 if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
4460 t--;
4462 /* Validate the type index. Protect against illegal indices from
4463 malformed type strings. */
4464 if ((t < 0) || (t >= work -> ntypes))
4466 return (0);
4468 while (work->nrepeats > 0 || --r >= 0)
4470 tem = work -> typevec[t];
4471 if (need_comma && PRINT_ARG_TYPES)
4473 string_append (declp, ", ");
4475 if (!do_arg (work, &tem, &arg))
4477 return (0);
4479 if (PRINT_ARG_TYPES)
4481 string_appends (declp, &arg);
4483 string_delete (&arg);
4484 need_comma = 1;
4487 else
4489 if (need_comma && PRINT_ARG_TYPES)
4490 string_append (declp, ", ");
4491 if (!do_arg (work, mangled, &arg))
4492 return (0);
4493 if (PRINT_ARG_TYPES)
4494 string_appends (declp, &arg);
4495 string_delete (&arg);
4496 need_comma = 1;
4500 if (**mangled == 'e')
4502 (*mangled)++;
4503 if (PRINT_ARG_TYPES)
4505 if (need_comma)
4507 string_append (declp, ",");
4509 string_append (declp, "...");
4513 if (PRINT_ARG_TYPES)
4515 string_append (declp, ")");
4517 return (1);
4520 /* Like demangle_args, but for demangling the argument lists of function
4521 and method pointers or references, not top-level declarations. */
4523 static int
4524 demangle_nested_args (struct work_stuff *work, const char **mangled,
4525 string *declp)
4527 string* saved_previous_argument;
4528 int result;
4529 int saved_nrepeats;
4531 /* The G++ name-mangling algorithm does not remember types on nested
4532 argument lists, unless -fsquangling is used, and in that case the
4533 type vector updated by remember_type is not used. So, we turn
4534 off remembering of types here. */
4535 ++work->forgetting_types;
4537 /* For the repeat codes used with -fsquangling, we must keep track of
4538 the last argument. */
4539 saved_previous_argument = work->previous_argument;
4540 saved_nrepeats = work->nrepeats;
4541 work->previous_argument = 0;
4542 work->nrepeats = 0;
4544 /* Actually demangle the arguments. */
4545 result = demangle_args (work, mangled, declp);
4547 /* Restore the previous_argument field. */
4548 if (work->previous_argument)
4550 string_delete (work->previous_argument);
4551 free ((char *) work->previous_argument);
4553 work->previous_argument = saved_previous_argument;
4554 --work->forgetting_types;
4555 work->nrepeats = saved_nrepeats;
4557 return result;
4560 /* Returns 1 if a valid function name was found or 0 otherwise. */
4562 static int
4563 demangle_function_name (struct work_stuff *work, const char **mangled,
4564 string *declp, const char *scan)
4566 size_t i;
4567 string type;
4568 const char *tem;
4570 string_appendn (declp, (*mangled), scan - (*mangled));
4571 string_need (declp, 1);
4572 *(declp -> p) = '\0';
4574 /* Consume the function name, including the "__" separating the name
4575 from the signature. We are guaranteed that SCAN points to the
4576 separator. */
4578 (*mangled) = scan + 2;
4579 /* We may be looking at an instantiation of a template function:
4580 foo__Xt1t2_Ft3t4, where t1, t2, ... are template arguments and a
4581 following _F marks the start of the function arguments. Handle
4582 the template arguments first. */
4584 if (HP_DEMANGLING && (**mangled == 'X'))
4586 demangle_arm_hp_template (work, mangled, 0, declp);
4587 /* This leaves MANGLED pointing to the 'F' marking func args */
4590 if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
4593 /* See if we have an ARM style constructor or destructor operator.
4594 If so, then just record it, clear the decl, and return.
4595 We can't build the actual constructor/destructor decl until later,
4596 when we recover the class name from the signature. */
4598 if (strcmp (declp -> b, "__ct") == 0)
4600 work -> constructor += 1;
4601 string_clear (declp);
4602 return 1;
4604 else if (strcmp (declp -> b, "__dt") == 0)
4606 work -> destructor += 1;
4607 string_clear (declp);
4608 return 1;
4612 if (declp->p - declp->b >= 3
4613 && declp->b[0] == 'o'
4614 && declp->b[1] == 'p'
4615 && strchr (cplus_markers, declp->b[2]) != NULL)
4617 /* see if it's an assignment expression */
4618 if (declp->p - declp->b >= 10 /* op$assign_ */
4619 && memcmp (declp->b + 3, "assign_", 7) == 0)
4621 for (i = 0; i < ARRAY_SIZE (optable); i++)
4623 int len = declp->p - declp->b - 10;
4624 if ((int) strlen (optable[i].in) == len
4625 && memcmp (optable[i].in, declp->b + 10, len) == 0)
4627 string_clear (declp);
4628 string_append (declp, "operator");
4629 string_append (declp, optable[i].out);
4630 string_append (declp, "=");
4631 break;
4635 else
4637 for (i = 0; i < ARRAY_SIZE (optable); i++)
4639 int len = declp->p - declp->b - 3;
4640 if ((int) strlen (optable[i].in) == len
4641 && memcmp (optable[i].in, declp->b + 3, len) == 0)
4643 string_clear (declp);
4644 string_append (declp, "operator");
4645 string_append (declp, optable[i].out);
4646 break;
4651 else if (declp->p - declp->b >= 5 && memcmp (declp->b, "type", 4) == 0
4652 && strchr (cplus_markers, declp->b[4]) != NULL)
4654 /* type conversion operator */
4655 tem = declp->b + 5;
4656 if (do_type (work, &tem, &type))
4658 string_clear (declp);
4659 string_append (declp, "operator ");
4660 string_appends (declp, &type);
4661 string_delete (&type);
4664 else if (declp->b[0] == '_' && declp->b[1] == '_'
4665 && declp->b[2] == 'o' && declp->b[3] == 'p')
4667 /* ANSI. */
4668 /* type conversion operator. */
4669 tem = declp->b + 4;
4670 if (do_type (work, &tem, &type))
4672 string_clear (declp);
4673 string_append (declp, "operator ");
4674 string_appends (declp, &type);
4675 string_delete (&type);
4678 else if (declp->b[0] == '_' && declp->b[1] == '_'
4679 && ISLOWER((unsigned char)declp->b[2])
4680 && ISLOWER((unsigned char)declp->b[3]))
4682 if (declp->b[4] == '\0')
4684 /* Operator. */
4685 for (i = 0; i < ARRAY_SIZE (optable); i++)
4687 if (strlen (optable[i].in) == 2
4688 && memcmp (optable[i].in, declp->b + 2, 2) == 0)
4690 string_clear (declp);
4691 string_append (declp, "operator");
4692 string_append (declp, optable[i].out);
4693 break;
4697 else
4699 if (declp->b[2] == 'a' && declp->b[5] == '\0')
4701 /* Assignment. */
4702 for (i = 0; i < ARRAY_SIZE (optable); i++)
4704 if (strlen (optable[i].in) == 3
4705 && memcmp (optable[i].in, declp->b + 2, 3) == 0)
4707 string_clear (declp);
4708 string_append (declp, "operator");
4709 string_append (declp, optable[i].out);
4710 break;
4717 /* If a function name was obtained but it's not valid, we were not
4718 successful. */
4719 if (LEN_STRING (declp) == 1 && declp->b[0] == '.')
4720 return 0;
4721 else
4722 return 1;
4725 /* a mini string-handling package */
4727 static void
4728 string_need (string *s, int n)
4730 int tem;
4732 if (s->b == NULL)
4734 if (n < 32)
4736 n = 32;
4738 s->p = s->b = XNEWVEC (char, n);
4739 s->e = s->b + n;
4741 else if (s->e - s->p < n)
4743 tem = s->p - s->b;
4744 n += tem;
4745 n *= 2;
4746 s->b = XRESIZEVEC (char, s->b, n);
4747 s->p = s->b + tem;
4748 s->e = s->b + n;
4752 static void
4753 string_delete (string *s)
4755 if (s->b != NULL)
4757 free (s->b);
4758 s->b = s->e = s->p = NULL;
4762 static void
4763 string_init (string *s)
4765 s->b = s->p = s->e = NULL;
4768 static void
4769 string_clear (string *s)
4771 s->p = s->b;
4774 #if 0
4776 static int
4777 string_empty (string *s)
4779 return (s->b == s->p);
4782 #endif
4784 static void
4785 string_append (string *p, const char *s)
4787 int n;
4788 if (s == NULL || *s == '\0')
4789 return;
4790 n = strlen (s);
4791 string_need (p, n);
4792 memcpy (p->p, s, n);
4793 p->p += n;
4796 static void
4797 string_appends (string *p, string *s)
4799 int n;
4801 if (s->b != s->p)
4803 n = s->p - s->b;
4804 string_need (p, n);
4805 memcpy (p->p, s->b, n);
4806 p->p += n;
4810 static void
4811 string_appendn (string *p, const char *s, int n)
4813 if (n != 0)
4815 string_need (p, n);
4816 memcpy (p->p, s, n);
4817 p->p += n;
4821 static void
4822 string_prepend (string *p, const char *s)
4824 if (s != NULL && *s != '\0')
4826 string_prependn (p, s, strlen (s));
4830 static void
4831 string_prepends (string *p, string *s)
4833 if (s->b != s->p)
4835 string_prependn (p, s->b, s->p - s->b);
4839 static void
4840 string_prependn (string *p, const char *s, int n)
4842 char *q;
4844 if (n != 0)
4846 string_need (p, n);
4847 for (q = p->p - 1; q >= p->b; q--)
4849 q[n] = q[0];
4851 memcpy (p->b, s, n);
4852 p->p += n;
4856 static void
4857 string_append_template_idx (string *s, int idx)
4859 char buf[INTBUF_SIZE + 1 /* 'T' */];
4860 sprintf(buf, "T%d", idx);
4861 string_append (s, buf);