1 /* Demangler for GNU C++
2 Copyright 1989, 1991, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001 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 Libiberty is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 Library General Public License for more details.
19 You should have received a copy of the GNU Library General Public
20 License along with libiberty; see the file COPYING.LIB. If
21 not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* This file exports two functions; cplus_mangle_opname and cplus_demangle.
26 This file imports xmalloc and xrealloc, which are like malloc and
27 realloc except that they generate a fatal error if there is no
30 /* This file lives in both GCC and libiberty. When making changes, please
31 try not to break either. */
37 #include "safe-ctype.h"
39 #include <sys/types.h>
51 #undef CURRENT_DEMANGLING_STYLE
52 #define CURRENT_DEMANGLING_STYLE work->options
54 #include "libiberty.h"
56 static char *ada_demangle
PARAMS ((const char *, int));
58 #define min(X,Y) (((X) < (Y)) ? (X) : (Y))
60 /* A value at least one greater than the maximum number of characters
61 that will be output when using the `%d' format with `printf'. */
62 #define INTBUF_SIZE 32
64 extern void fancy_abort
PARAMS ((void)) ATTRIBUTE_NORETURN
;
66 static const char *mystrstr
PARAMS ((const char *, const char *));
72 register const char *p
= s1
;
73 register int len
= strlen (s2
);
75 for (; (p
= strchr (p
, *s2
)) != 0; p
++)
77 if (strncmp (p
, s2
, len
) == 0)
85 /* In order to allow a single demangler executable to demangle strings
86 using various common values of CPLUS_MARKER, as well as any specific
87 one set at compile time, we maintain a string containing all the
88 commonly used ones, and check to see if the marker we are looking for
89 is in that string. CPLUS_MARKER is usually '$' on systems where the
90 assembler can deal with that. Where the assembler can't, it's usually
91 '.' (but on many systems '.' is used for other things). We put the
92 current defined CPLUS_MARKER first (which defaults to '$'), followed
93 by the next most common value, followed by an explicit '$' in case
94 the value of CPLUS_MARKER is not '$'.
96 We could avoid this if we could just get g++ to tell us what the actual
97 cplus marker character is as part of the debug information, perhaps by
98 ensuring that it is the character that terminates the gcc<n>_compiled
99 marker symbol (FIXME). */
101 #if !defined (CPLUS_MARKER)
102 #define CPLUS_MARKER '$'
105 enum demangling_styles current_demangling_style
= auto_demangling
;
107 static char cplus_markers
[] = { CPLUS_MARKER
, '.', '$', '\0' };
109 static char char_str
[2] = { '\000', '\000' };
112 set_cplus_marker_for_demangling (ch
)
115 cplus_markers
[0] = ch
;
118 typedef struct string
/* Beware: these aren't required to be */
119 { /* '\0' terminated. */
120 char *b
; /* pointer to start of string */
121 char *p
; /* pointer after last character */
122 char *e
; /* pointer after end of allocated space */
125 /* Stuff that is shared between sub-routines.
126 Using a shared structure allows cplus_demangle to be reentrant. */
142 int static_type
; /* A static member function */
143 int temp_start
; /* index in demangled to start of template args */
144 int type_quals
; /* The type qualifiers. */
145 int dllimported
; /* Symbol imported from a PE DLL */
146 char **tmpl_argvec
; /* Template function arguments. */
147 int ntmpl_args
; /* The number of template function arguments. */
148 int forgetting_types
; /* Nonzero if we are not remembering the types
150 string
* previous_argument
; /* The last function argument demangled. */
151 int nrepeats
; /* The number of times to repeat the previous
155 #define PRINT_ANSI_QUALIFIERS (work -> options & DMGL_ANSI)
156 #define PRINT_ARG_TYPES (work -> options & DMGL_PARAMS)
158 static const struct optable
160 const char *const in
;
161 const char *const out
;
164 {"nw", " new", DMGL_ANSI
}, /* new (1.92, ansi) */
165 {"dl", " delete", DMGL_ANSI
}, /* new (1.92, ansi) */
166 {"new", " new", 0}, /* old (1.91, and 1.x) */
167 {"delete", " delete", 0}, /* old (1.91, and 1.x) */
168 {"vn", " new []", DMGL_ANSI
}, /* GNU, pending ansi */
169 {"vd", " delete []", DMGL_ANSI
}, /* GNU, pending ansi */
170 {"as", "=", DMGL_ANSI
}, /* ansi */
171 {"ne", "!=", DMGL_ANSI
}, /* old, ansi */
172 {"eq", "==", DMGL_ANSI
}, /* old, ansi */
173 {"ge", ">=", DMGL_ANSI
}, /* old, ansi */
174 {"gt", ">", DMGL_ANSI
}, /* old, ansi */
175 {"le", "<=", DMGL_ANSI
}, /* old, ansi */
176 {"lt", "<", DMGL_ANSI
}, /* old, ansi */
177 {"plus", "+", 0}, /* old */
178 {"pl", "+", DMGL_ANSI
}, /* ansi */
179 {"apl", "+=", DMGL_ANSI
}, /* ansi */
180 {"minus", "-", 0}, /* old */
181 {"mi", "-", DMGL_ANSI
}, /* ansi */
182 {"ami", "-=", DMGL_ANSI
}, /* ansi */
183 {"mult", "*", 0}, /* old */
184 {"ml", "*", DMGL_ANSI
}, /* ansi */
185 {"amu", "*=", DMGL_ANSI
}, /* ansi (ARM/Lucid) */
186 {"aml", "*=", DMGL_ANSI
}, /* ansi (GNU/g++) */
187 {"convert", "+", 0}, /* old (unary +) */
188 {"negate", "-", 0}, /* old (unary -) */
189 {"trunc_mod", "%", 0}, /* old */
190 {"md", "%", DMGL_ANSI
}, /* ansi */
191 {"amd", "%=", DMGL_ANSI
}, /* ansi */
192 {"trunc_div", "/", 0}, /* old */
193 {"dv", "/", DMGL_ANSI
}, /* ansi */
194 {"adv", "/=", DMGL_ANSI
}, /* ansi */
195 {"truth_andif", "&&", 0}, /* old */
196 {"aa", "&&", DMGL_ANSI
}, /* ansi */
197 {"truth_orif", "||", 0}, /* old */
198 {"oo", "||", DMGL_ANSI
}, /* ansi */
199 {"truth_not", "!", 0}, /* old */
200 {"nt", "!", DMGL_ANSI
}, /* ansi */
201 {"postincrement","++", 0}, /* old */
202 {"pp", "++", DMGL_ANSI
}, /* ansi */
203 {"postdecrement","--", 0}, /* old */
204 {"mm", "--", DMGL_ANSI
}, /* ansi */
205 {"bit_ior", "|", 0}, /* old */
206 {"or", "|", DMGL_ANSI
}, /* ansi */
207 {"aor", "|=", DMGL_ANSI
}, /* ansi */
208 {"bit_xor", "^", 0}, /* old */
209 {"er", "^", DMGL_ANSI
}, /* ansi */
210 {"aer", "^=", DMGL_ANSI
}, /* ansi */
211 {"bit_and", "&", 0}, /* old */
212 {"ad", "&", DMGL_ANSI
}, /* ansi */
213 {"aad", "&=", DMGL_ANSI
}, /* ansi */
214 {"bit_not", "~", 0}, /* old */
215 {"co", "~", DMGL_ANSI
}, /* ansi */
216 {"call", "()", 0}, /* old */
217 {"cl", "()", DMGL_ANSI
}, /* ansi */
218 {"alshift", "<<", 0}, /* old */
219 {"ls", "<<", DMGL_ANSI
}, /* ansi */
220 {"als", "<<=", DMGL_ANSI
}, /* ansi */
221 {"arshift", ">>", 0}, /* old */
222 {"rs", ">>", DMGL_ANSI
}, /* ansi */
223 {"ars", ">>=", DMGL_ANSI
}, /* ansi */
224 {"component", "->", 0}, /* old */
225 {"pt", "->", DMGL_ANSI
}, /* ansi; Lucid C++ form */
226 {"rf", "->", DMGL_ANSI
}, /* ansi; ARM/GNU form */
227 {"indirect", "*", 0}, /* old */
228 {"method_call", "->()", 0}, /* old */
229 {"addr", "&", 0}, /* old (unary &) */
230 {"array", "[]", 0}, /* old */
231 {"vc", "[]", DMGL_ANSI
}, /* ansi */
232 {"compound", ", ", 0}, /* old */
233 {"cm", ", ", DMGL_ANSI
}, /* ansi */
234 {"cond", "?:", 0}, /* old */
235 {"cn", "?:", DMGL_ANSI
}, /* pseudo-ansi */
236 {"max", ">?", 0}, /* old */
237 {"mx", ">?", DMGL_ANSI
}, /* pseudo-ansi */
238 {"min", "<?", 0}, /* old */
239 {"mn", "<?", DMGL_ANSI
}, /* pseudo-ansi */
240 {"nop", "", 0}, /* old (for operator=) */
241 {"rm", "->*", DMGL_ANSI
}, /* ansi */
242 {"sz", "sizeof ", DMGL_ANSI
} /* pseudo-ansi */
245 /* These values are used to indicate the various type varieties.
246 They are all non-zero so that they can be used as `success'
248 typedef enum type_kind_t
259 const struct demangler_engine libiberty_demanglers
[] =
262 NO_DEMANGLING_STYLE_STRING
,
264 "Demangling disabled"
268 AUTO_DEMANGLING_STYLE_STRING
,
270 "Automatic selection based on executable"
274 GNU_DEMANGLING_STYLE_STRING
,
276 "GNU (g++) style demangling"
280 LUCID_DEMANGLING_STYLE_STRING
,
282 "Lucid (lcc) style demangling"
286 ARM_DEMANGLING_STYLE_STRING
,
288 "ARM style demangling"
292 HP_DEMANGLING_STYLE_STRING
,
294 "HP (aCC) style demangling"
298 EDG_DEMANGLING_STYLE_STRING
,
300 "EDG style demangling"
304 GNU_V3_DEMANGLING_STYLE_STRING
,
306 "GNU (g++) V3 ABI-style demangling"
310 JAVA_DEMANGLING_STYLE_STRING
,
312 "Java style demangling"
316 GNAT_DEMANGLING_STYLE_STRING
,
318 "GNAT style demangling"
322 NULL
, unknown_demangling
, NULL
326 #define STRING_EMPTY(str) ((str) -> b == (str) -> p)
327 #define PREPEND_BLANK(str) {if (!STRING_EMPTY(str)) \
328 string_prepend(str, " ");}
329 #define APPEND_BLANK(str) {if (!STRING_EMPTY(str)) \
330 string_append(str, " ");}
331 #define LEN_STRING(str) ( (STRING_EMPTY(str))?0:((str)->p - (str)->b))
333 /* The scope separator appropriate for the language being demangled. */
335 #define SCOPE_STRING(work) ((work->options & DMGL_JAVA) ? "." : "::")
337 #define ARM_VTABLE_STRING "__vtbl__" /* Lucid/ARM virtual table prefix */
338 #define ARM_VTABLE_STRLEN 8 /* strlen (ARM_VTABLE_STRING) */
340 /* Prototypes for local functions */
343 delete_work_stuff
PARAMS ((struct work_stuff
*));
346 delete_non_B_K_work_stuff
PARAMS ((struct work_stuff
*));
349 mop_up
PARAMS ((struct work_stuff
*, string
*, int));
352 squangle_mop_up
PARAMS ((struct work_stuff
*));
355 work_stuff_copy_to_from
PARAMS ((struct work_stuff
*, struct work_stuff
*));
359 demangle_method_args
PARAMS ((struct work_stuff
*, const char **, string
*));
363 internal_cplus_demangle
PARAMS ((struct work_stuff
*, const char *));
366 demangle_template_template_parm
PARAMS ((struct work_stuff
*work
,
367 const char **, string
*));
370 demangle_template
PARAMS ((struct work_stuff
*work
, const char **, string
*,
371 string
*, int, int));
374 arm_pt
PARAMS ((struct work_stuff
*, const char *, int, const char **,
378 demangle_class_name
PARAMS ((struct work_stuff
*, const char **, string
*));
381 demangle_qualified
PARAMS ((struct work_stuff
*, const char **, string
*,
385 demangle_class
PARAMS ((struct work_stuff
*, const char **, string
*));
388 demangle_fund_type
PARAMS ((struct work_stuff
*, const char **, string
*));
391 demangle_signature
PARAMS ((struct work_stuff
*, const char **, string
*));
394 demangle_prefix
PARAMS ((struct work_stuff
*, const char **, string
*));
397 gnu_special
PARAMS ((struct work_stuff
*, const char **, string
*));
400 arm_special
PARAMS ((const char **, string
*));
403 string_need
PARAMS ((string
*, int));
406 string_delete
PARAMS ((string
*));
409 string_init
PARAMS ((string
*));
412 string_clear
PARAMS ((string
*));
416 string_empty
PARAMS ((string
*));
420 string_append
PARAMS ((string
*, const char *));
423 string_appends
PARAMS ((string
*, string
*));
426 string_appendn
PARAMS ((string
*, const char *, int));
429 string_prepend
PARAMS ((string
*, const char *));
432 string_prependn
PARAMS ((string
*, const char *, int));
435 string_append_template_idx
PARAMS ((string
*, int));
438 get_count
PARAMS ((const char **, int *));
441 consume_count
PARAMS ((const char **));
444 consume_count_with_underscores
PARAMS ((const char**));
447 demangle_args
PARAMS ((struct work_stuff
*, const char **, string
*));
450 demangle_nested_args
PARAMS ((struct work_stuff
*, const char**, string
*));
453 do_type
PARAMS ((struct work_stuff
*, const char **, string
*));
456 do_arg
PARAMS ((struct work_stuff
*, const char **, string
*));
459 demangle_function_name
PARAMS ((struct work_stuff
*, const char **, string
*,
463 iterate_demangle_function
PARAMS ((struct work_stuff
*,
464 const char **, string
*, const char *));
467 remember_type
PARAMS ((struct work_stuff
*, const char *, int));
470 remember_Btype
PARAMS ((struct work_stuff
*, const char *, int, int));
473 register_Btype
PARAMS ((struct work_stuff
*));
476 remember_Ktype
PARAMS ((struct work_stuff
*, const char *, int));
479 forget_types
PARAMS ((struct work_stuff
*));
482 forget_B_and_K_types
PARAMS ((struct work_stuff
*));
485 string_prepends
PARAMS ((string
*, string
*));
488 demangle_template_value_parm
PARAMS ((struct work_stuff
*, const char**,
489 string
*, type_kind_t
));
492 do_hpacc_template_const_value
PARAMS ((struct work_stuff
*, const char **, string
*));
495 do_hpacc_template_literal
PARAMS ((struct work_stuff
*, const char **, string
*));
498 snarf_numeric_literal
PARAMS ((const char **, string
*));
500 /* There is a TYPE_QUAL value for each type qualifier. They can be
501 combined by bitwise-or to form the complete set of qualifiers for a
504 #define TYPE_UNQUALIFIED 0x0
505 #define TYPE_QUAL_CONST 0x1
506 #define TYPE_QUAL_VOLATILE 0x2
507 #define TYPE_QUAL_RESTRICT 0x4
510 code_for_qualifier
PARAMS ((int));
513 qualifier_string
PARAMS ((int));
516 demangle_qualifier
PARAMS ((int));
519 demangle_expression
PARAMS ((struct work_stuff
*, const char **, string
*,
523 demangle_integral_value
PARAMS ((struct work_stuff
*, const char **,
527 demangle_real_value
PARAMS ((struct work_stuff
*, const char **, string
*));
530 demangle_arm_hp_template
PARAMS ((struct work_stuff
*, const char **, int,
534 recursively_demangle
PARAMS ((struct work_stuff
*, const char **, string
*,
538 grow_vect
PARAMS ((void **, size_t *, size_t, int));
540 /* Translate count to integer, consuming tokens in the process.
541 Conversion terminates on the first non-digit character.
543 Trying to consume something that isn't a count results in no
544 consumption of input and a return of -1.
546 Overflow consumes the rest of the digits, and returns -1. */
554 if (! ISDIGIT ((unsigned char)**type
))
557 while (ISDIGIT ((unsigned char)**type
))
561 /* Check for overflow.
562 We assume that count is represented using two's-complement;
563 no power of two is divisible by ten, so if an overflow occurs
564 when multiplying by ten, the result will not be a multiple of
566 if ((count
% 10) != 0)
568 while (ISDIGIT ((unsigned char) **type
))
573 count
+= **type
- '0';
584 /* Like consume_count, but for counts that are preceded and followed
585 by '_' if they are greater than 10. Also, -1 is returned for
586 failure, since 0 can be a valid value. */
589 consume_count_with_underscores (mangled
)
590 const char **mangled
;
594 if (**mangled
== '_')
597 if (!ISDIGIT ((unsigned char)**mangled
))
600 idx
= consume_count (mangled
);
601 if (**mangled
!= '_')
602 /* The trailing underscore was missing. */
609 if (**mangled
< '0' || **mangled
> '9')
612 idx
= **mangled
- '0';
619 /* C is the code for a type-qualifier. Return the TYPE_QUAL
620 corresponding to this qualifier. */
623 code_for_qualifier (c
)
629 return TYPE_QUAL_CONST
;
632 return TYPE_QUAL_VOLATILE
;
635 return TYPE_QUAL_RESTRICT
;
641 /* C was an invalid qualifier. */
645 /* Return the string corresponding to the qualifiers given by
649 qualifier_string (type_quals
)
654 case TYPE_UNQUALIFIED
:
657 case TYPE_QUAL_CONST
:
660 case TYPE_QUAL_VOLATILE
:
663 case TYPE_QUAL_RESTRICT
:
666 case TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
:
667 return "const volatile";
669 case TYPE_QUAL_CONST
| TYPE_QUAL_RESTRICT
:
670 return "const __restrict";
672 case TYPE_QUAL_VOLATILE
| TYPE_QUAL_RESTRICT
:
673 return "volatile __restrict";
675 case TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
| TYPE_QUAL_RESTRICT
:
676 return "const volatile __restrict";
682 /* TYPE_QUALS was an invalid qualifier set. */
686 /* C is the code for a type-qualifier. Return the string
687 corresponding to this qualifier. This function should only be
688 called with a valid qualifier code. */
691 demangle_qualifier (c
)
694 return qualifier_string (code_for_qualifier (c
));
698 cplus_demangle_opname (opname
, result
, options
)
705 struct work_stuff work
[1];
708 len
= strlen(opname
);
711 memset ((char *) work
, 0, sizeof (work
));
712 work
->options
= options
;
714 if (opname
[0] == '_' && opname
[1] == '_'
715 && opname
[2] == 'o' && opname
[3] == 'p')
718 /* type conversion operator. */
720 if (do_type (work
, &tem
, &type
))
722 strcat (result
, "operator ");
723 strncat (result
, type
.b
, type
.p
- type
.b
);
724 string_delete (&type
);
728 else if (opname
[0] == '_' && opname
[1] == '_'
729 && ISLOWER((unsigned char)opname
[2])
730 && ISLOWER((unsigned char)opname
[3]))
732 if (opname
[4] == '\0')
736 for (i
= 0; i
< ARRAY_SIZE (optable
); i
++)
738 if (strlen (optable
[i
].in
) == 2
739 && memcmp (optable
[i
].in
, opname
+ 2, 2) == 0)
741 strcat (result
, "operator");
742 strcat (result
, optable
[i
].out
);
750 if (opname
[2] == 'a' && opname
[5] == '\0')
754 for (i
= 0; i
< ARRAY_SIZE (optable
); i
++)
756 if (strlen (optable
[i
].in
) == 3
757 && memcmp (optable
[i
].in
, opname
+ 2, 3) == 0)
759 strcat (result
, "operator");
760 strcat (result
, optable
[i
].out
);
771 && strchr (cplus_markers
, opname
[2]) != NULL
)
773 /* see if it's an assignment expression */
774 if (len
>= 10 /* op$assign_ */
775 && memcmp (opname
+ 3, "assign_", 7) == 0)
778 for (i
= 0; i
< ARRAY_SIZE (optable
); i
++)
781 if ((int) strlen (optable
[i
].in
) == len1
782 && memcmp (optable
[i
].in
, opname
+ 10, len1
) == 0)
784 strcat (result
, "operator");
785 strcat (result
, optable
[i
].out
);
786 strcat (result
, "=");
795 for (i
= 0; i
< ARRAY_SIZE (optable
); i
++)
798 if ((int) strlen (optable
[i
].in
) == len1
799 && memcmp (optable
[i
].in
, opname
+ 3, len1
) == 0)
801 strcat (result
, "operator");
802 strcat (result
, optable
[i
].out
);
809 else if (len
>= 5 && memcmp (opname
, "type", 4) == 0
810 && strchr (cplus_markers
, opname
[4]) != NULL
)
812 /* type conversion operator */
814 if (do_type (work
, &tem
, &type
))
816 strcat (result
, "operator ");
817 strncat (result
, type
.b
, type
.p
- type
.b
);
818 string_delete (&type
);
822 squangle_mop_up (work
);
827 /* Takes operator name as e.g. "++" and returns mangled
828 operator name (e.g. "postincrement_expr"), or NULL if not found.
830 If OPTIONS & DMGL_ANSI == 1, return the ANSI name;
831 if OPTIONS & DMGL_ANSI == 0, return the old GNU name. */
834 cplus_mangle_opname (opname
, options
)
841 len
= strlen (opname
);
842 for (i
= 0; i
< ARRAY_SIZE (optable
); i
++)
844 if ((int) strlen (optable
[i
].out
) == len
845 && (options
& DMGL_ANSI
) == (optable
[i
].flags
& DMGL_ANSI
)
846 && memcmp (optable
[i
].out
, opname
, len
) == 0)
847 return optable
[i
].in
;
852 /* Add a routine to set the demangling style to be sure it is valid and
853 allow for any demangler initialization that maybe necessary. */
855 enum demangling_styles
856 cplus_demangle_set_style (style
)
857 enum demangling_styles style
;
859 const struct demangler_engine
*demangler
= libiberty_demanglers
;
861 for (; demangler
->demangling_style
!= unknown_demangling
; ++demangler
)
862 if (style
== demangler
->demangling_style
)
864 current_demangling_style
= style
;
865 return current_demangling_style
;
868 return unknown_demangling
;
871 /* Do string name to style translation */
873 enum demangling_styles
874 cplus_demangle_name_to_style (name
)
877 const struct demangler_engine
*demangler
= libiberty_demanglers
;
879 for (; demangler
->demangling_style
!= unknown_demangling
; ++demangler
)
880 if (strcmp (name
, demangler
->demangling_style_name
) == 0)
881 return demangler
->demangling_style
;
883 return unknown_demangling
;
886 /* char *cplus_demangle (const char *mangled, int options)
888 If MANGLED is a mangled function name produced by GNU C++, then
889 a pointer to a @code{malloc}ed string giving a C++ representation
890 of the name will be returned; otherwise NULL will be returned.
891 It is the caller's responsibility to free the string which
894 The OPTIONS arg may contain one or more of the following bits:
896 DMGL_ANSI ANSI qualifiers such as `const' and `void' are
898 DMGL_PARAMS Function parameters are included.
902 cplus_demangle ("foo__1Ai", DMGL_PARAMS) => "A::foo(int)"
903 cplus_demangle ("foo__1Ai", DMGL_PARAMS | DMGL_ANSI) => "A::foo(int)"
904 cplus_demangle ("foo__1Ai", 0) => "A::foo"
906 cplus_demangle ("foo__1Afe", DMGL_PARAMS) => "A::foo(float,...)"
907 cplus_demangle ("foo__1Afe", DMGL_PARAMS | DMGL_ANSI)=> "A::foo(float,...)"
908 cplus_demangle ("foo__1Afe", 0) => "A::foo"
910 Note that any leading underscores, or other such characters prepended by
911 the compilation system, are presumed to have already been stripped from
915 cplus_demangle (mangled
, options
)
920 struct work_stuff work
[1];
922 if (current_demangling_style
== no_demangling
)
923 return xstrdup (mangled
);
925 memset ((char *) work
, 0, sizeof (work
));
926 work
->options
= options
;
927 if ((work
->options
& DMGL_STYLE_MASK
) == 0)
928 work
->options
|= (int) current_demangling_style
& DMGL_STYLE_MASK
;
930 /* The V3 ABI demangling is implemented elsewhere. */
931 if (GNU_V3_DEMANGLING
|| AUTO_DEMANGLING
)
933 ret
= cplus_demangle_v3 (mangled
);
934 if (ret
|| GNU_V3_DEMANGLING
)
940 ret
= java_demangle_v3 (mangled
);
946 return ada_demangle(mangled
,options
);
948 ret
= internal_cplus_demangle (work
, mangled
);
949 squangle_mop_up (work
);
954 /* Assuming *OLD_VECT points to an array of *SIZE objects of size
955 ELEMENT_SIZE, grow it to contain at least MIN_SIZE objects,
956 updating *OLD_VECT and *SIZE as necessary. */
959 grow_vect (old_vect
, size
, min_size
, element_size
)
965 if (*size
< min_size
)
968 if (*size
< min_size
)
970 *old_vect
= xrealloc (*old_vect
, *size
* element_size
);
974 /* Demangle ada names:
975 1. Discard final __{DIGIT}+ or ${DIGIT}+
976 2. Convert other instances of embedded "__" to `.'.
977 3. Discard leading _ada_.
978 4. Remove everything after first ___ if it is followed by 'X'.
979 5. Put symbols that should be suppressed in <...> brackets.
980 The resulting string is valid until the next call of ada_demangle. */
983 ada_demangle (mangled
, option
)
985 int option ATTRIBUTE_UNUSED
;
990 char *demangled
= NULL
;
993 char *demangling_buffer
= NULL
;
994 size_t demangling_buffer_size
= 0;
998 if (strncmp (mangled
, "_ada_", 5) == 0)
1004 if (mangled
[0] == '_' || mangled
[0] == '<')
1007 p
= strstr (mangled
, "___");
1009 len0
= strlen (mangled
);
1021 /* Make demangled big enough for possible expansion by operator name. */
1022 grow_vect ((void **) &(demangling_buffer
),
1023 &demangling_buffer_size
, 2 * len0
+ 1,
1025 demangled
= demangling_buffer
;
1027 if (ISDIGIT ((unsigned char) mangled
[len0
- 1])) {
1028 for (i
= len0
- 2; i
>= 0 && ISDIGIT ((unsigned char) mangled
[i
]); i
-= 1)
1030 if (i
> 1 && mangled
[i
] == '_' && mangled
[i
- 1] == '_')
1035 else if (mangled
[i
] == '$')
1042 for (i
= 0, j
= 0; i
< len0
&& ! ISALPHA ((unsigned char)mangled
[i
]);
1044 demangled
[j
] = mangled
[i
];
1051 if (i
< len0
- 2 && mangled
[i
] == '_' && mangled
[i
+ 1] == '_')
1054 changed
= at_start_name
= 1;
1059 demangled
[j
] = mangled
[i
];
1063 demangled
[j
] = '\000';
1065 for (i
= 0; demangled
[i
] != '\0'; i
+= 1)
1066 if (ISUPPER ((unsigned char)demangled
[i
]) || demangled
[i
] == ' ')
1075 grow_vect ((void **) &(demangling_buffer
),
1076 &demangling_buffer_size
, strlen (mangled
) + 3,
1078 demangled
= demangling_buffer
;
1079 if (mangled
[0] == '<')
1080 strcpy (demangled
, mangled
);
1082 sprintf (demangled
, "<%s>", mangled
);
1087 /* This function performs most of what cplus_demangle use to do, but
1088 to be able to demangle a name with a B, K or n code, we need to
1089 have a longer term memory of what types have been seen. The original
1090 now intializes and cleans up the squangle code info, while internal
1091 calls go directly to this routine to avoid resetting that info. */
1094 internal_cplus_demangle (work
, mangled
)
1095 struct work_stuff
*work
;
1096 const char *mangled
;
1101 char *demangled
= NULL
;
1103 s1
= work
->constructor
;
1104 s2
= work
->destructor
;
1105 s3
= work
->static_type
;
1106 s4
= work
->type_quals
;
1107 work
->constructor
= work
->destructor
= 0;
1108 work
->type_quals
= TYPE_UNQUALIFIED
;
1109 work
->dllimported
= 0;
1111 if ((mangled
!= NULL
) && (*mangled
!= '\0'))
1113 string_init (&decl
);
1115 /* First check to see if gnu style demangling is active and if the
1116 string to be demangled contains a CPLUS_MARKER. If so, attempt to
1117 recognize one of the gnu special forms rather than looking for a
1118 standard prefix. In particular, don't worry about whether there
1119 is a "__" string in the mangled string. Consider "_$_5__foo" for
1122 if ((AUTO_DEMANGLING
|| GNU_DEMANGLING
))
1124 success
= gnu_special (work
, &mangled
, &decl
);
1128 success
= demangle_prefix (work
, &mangled
, &decl
);
1130 if (success
&& (*mangled
!= '\0'))
1132 success
= demangle_signature (work
, &mangled
, &decl
);
1134 if (work
->constructor
== 2)
1136 string_prepend (&decl
, "global constructors keyed to ");
1137 work
->constructor
= 0;
1139 else if (work
->destructor
== 2)
1141 string_prepend (&decl
, "global destructors keyed to ");
1142 work
->destructor
= 0;
1144 else if (work
->dllimported
== 1)
1146 string_prepend (&decl
, "import stub for ");
1147 work
->dllimported
= 0;
1149 demangled
= mop_up (work
, &decl
, success
);
1151 work
->constructor
= s1
;
1152 work
->destructor
= s2
;
1153 work
->static_type
= s3
;
1154 work
->type_quals
= s4
;
1159 /* Clear out and squangling related storage */
1161 squangle_mop_up (work
)
1162 struct work_stuff
*work
;
1164 /* clean up the B and K type mangling types. */
1165 forget_B_and_K_types (work
);
1166 if (work
-> btypevec
!= NULL
)
1168 free ((char *) work
-> btypevec
);
1170 if (work
-> ktypevec
!= NULL
)
1172 free ((char *) work
-> ktypevec
);
1177 /* Copy the work state and storage. */
1180 work_stuff_copy_to_from (to
, from
)
1181 struct work_stuff
*to
;
1182 struct work_stuff
*from
;
1186 delete_work_stuff (to
);
1188 /* Shallow-copy scalars. */
1189 memcpy (to
, from
, sizeof (*to
));
1191 /* Deep-copy dynamic storage. */
1192 if (from
->typevec_size
)
1194 = (char **) xmalloc (from
->typevec_size
* sizeof (to
->typevec
[0]));
1196 for (i
= 0; i
< from
->ntypes
; i
++)
1198 int len
= strlen (from
->typevec
[i
]) + 1;
1200 to
->typevec
[i
] = xmalloc (len
);
1201 memcpy (to
->typevec
[i
], from
->typevec
[i
], len
);
1206 = (char **) xmalloc (from
->ksize
* sizeof (to
->ktypevec
[0]));
1208 for (i
= 0; i
< from
->numk
; i
++)
1210 int len
= strlen (from
->ktypevec
[i
]) + 1;
1212 to
->ktypevec
[i
] = xmalloc (len
);
1213 memcpy (to
->ktypevec
[i
], from
->ktypevec
[i
], len
);
1218 = (char **) xmalloc (from
->bsize
* sizeof (to
->btypevec
[0]));
1220 for (i
= 0; i
< from
->numb
; i
++)
1222 int len
= strlen (from
->btypevec
[i
]) + 1;
1224 to
->btypevec
[i
] = xmalloc (len
);
1225 memcpy (to
->btypevec
[i
], from
->btypevec
[i
], len
);
1228 if (from
->ntmpl_args
)
1230 = xmalloc (from
->ntmpl_args
* sizeof (to
->tmpl_argvec
[0]));
1232 for (i
= 0; i
< from
->ntmpl_args
; i
++)
1234 int len
= strlen (from
->tmpl_argvec
[i
]) + 1;
1236 to
->tmpl_argvec
[i
] = xmalloc (len
);
1237 memcpy (to
->tmpl_argvec
[i
], from
->tmpl_argvec
[i
], len
);
1240 if (from
->previous_argument
)
1242 to
->previous_argument
= (string
*) xmalloc (sizeof (string
));
1243 string_init (to
->previous_argument
);
1244 string_appends (to
->previous_argument
, from
->previous_argument
);
1249 /* Delete dynamic stuff in work_stuff that is not to be re-used. */
1252 delete_non_B_K_work_stuff (work
)
1253 struct work_stuff
*work
;
1255 /* Discard the remembered types, if any. */
1257 forget_types (work
);
1258 if (work
-> typevec
!= NULL
)
1260 free ((char *) work
-> typevec
);
1261 work
-> typevec
= NULL
;
1262 work
-> typevec_size
= 0;
1264 if (work
->tmpl_argvec
)
1268 for (i
= 0; i
< work
->ntmpl_args
; i
++)
1269 if (work
->tmpl_argvec
[i
])
1270 free ((char*) work
->tmpl_argvec
[i
]);
1272 free ((char*) work
->tmpl_argvec
);
1273 work
->tmpl_argvec
= NULL
;
1275 if (work
->previous_argument
)
1277 string_delete (work
->previous_argument
);
1278 free ((char*) work
->previous_argument
);
1279 work
->previous_argument
= NULL
;
1284 /* Delete all dynamic storage in work_stuff. */
1286 delete_work_stuff (work
)
1287 struct work_stuff
*work
;
1289 delete_non_B_K_work_stuff (work
);
1290 squangle_mop_up (work
);
1294 /* Clear out any mangled storage */
1297 mop_up (work
, declp
, success
)
1298 struct work_stuff
*work
;
1302 char *demangled
= NULL
;
1304 delete_non_B_K_work_stuff (work
);
1306 /* If demangling was successful, ensure that the demangled string is null
1307 terminated and return it. Otherwise, free the demangling decl. */
1311 string_delete (declp
);
1315 string_appendn (declp
, "", 1);
1316 demangled
= declp
->b
;
1325 demangle_signature -- demangle the signature part of a mangled name
1330 demangle_signature (struct work_stuff *work, const char **mangled,
1335 Consume and demangle the signature portion of the mangled name.
1337 DECLP is the string where demangled output is being built. At
1338 entry it contains the demangled root name from the mangled name
1339 prefix. I.E. either a demangled operator name or the root function
1340 name. In some special cases, it may contain nothing.
1342 *MANGLED points to the current unconsumed location in the mangled
1343 name. As tokens are consumed and demangling is performed, the
1344 pointer is updated to continuously point at the next token to
1347 Demangling GNU style mangled names is nasty because there is no
1348 explicit token that marks the start of the outermost function
1352 demangle_signature (work
, mangled
, declp
)
1353 struct work_stuff
*work
;
1354 const char **mangled
;
1359 int expect_func
= 0;
1360 int expect_return_type
= 0;
1361 const char *oldmangled
= NULL
;
1365 while (success
&& (**mangled
!= '\0'))
1370 oldmangled
= *mangled
;
1371 success
= demangle_qualified (work
, mangled
, declp
, 1, 0);
1373 remember_type (work
, oldmangled
, *mangled
- oldmangled
);
1374 if (AUTO_DEMANGLING
|| GNU_DEMANGLING
)
1380 oldmangled
= *mangled
;
1381 success
= demangle_qualified (work
, mangled
, declp
, 1, 0);
1382 if (AUTO_DEMANGLING
|| GNU_DEMANGLING
)
1390 /* Static member function */
1391 if (oldmangled
== NULL
)
1393 oldmangled
= *mangled
;
1396 work
-> static_type
= 1;
1402 work
->type_quals
|= code_for_qualifier (**mangled
);
1404 /* a qualified member function */
1405 if (oldmangled
== NULL
)
1406 oldmangled
= *mangled
;
1411 /* Local class name follows after "Lnnn_" */
1414 while (**mangled
&& (**mangled
!= '_'))
1425 case '0': case '1': case '2': case '3': case '4':
1426 case '5': case '6': case '7': case '8': case '9':
1427 if (oldmangled
== NULL
)
1429 oldmangled
= *mangled
;
1431 work
->temp_start
= -1; /* uppermost call to demangle_class */
1432 success
= demangle_class (work
, mangled
, declp
);
1435 remember_type (work
, oldmangled
, *mangled
- oldmangled
);
1437 if (AUTO_DEMANGLING
|| GNU_DEMANGLING
|| EDG_DEMANGLING
)
1439 /* EDG and others will have the "F", so we let the loop cycle
1440 if we are looking at one. */
1441 if (**mangled
!= 'F')
1450 success
= do_type (work
, mangled
, &s
);
1453 string_append (&s
, SCOPE_STRING (work
));
1454 string_prepends (declp
, &s
);
1463 /* ARM/HP style demangling includes a specific 'F' character after
1464 the class name. For GNU style, it is just implied. So we can
1465 safely just consume any 'F' at this point and be compatible
1466 with either style. */
1472 /* For lucid/ARM/HP style we have to forget any types we might
1473 have remembered up to this point, since they were not argument
1474 types. GNU style considers all types seen as available for
1475 back references. See comment in demangle_args() */
1477 if (LUCID_DEMANGLING
|| ARM_DEMANGLING
|| HP_DEMANGLING
|| EDG_DEMANGLING
)
1479 forget_types (work
);
1481 success
= demangle_args (work
, mangled
, declp
);
1482 /* After picking off the function args, we expect to either
1483 find the function return type (preceded by an '_') or the
1484 end of the string. */
1485 if (success
&& (AUTO_DEMANGLING
|| EDG_DEMANGLING
) && **mangled
== '_')
1488 /* At this level, we do not care about the return type. */
1489 success
= do_type (work
, mangled
, &tname
);
1490 string_delete (&tname
);
1497 string_init(&trawname
);
1498 string_init(&tname
);
1499 if (oldmangled
== NULL
)
1501 oldmangled
= *mangled
;
1503 success
= demangle_template (work
, mangled
, &tname
,
1507 remember_type (work
, oldmangled
, *mangled
- oldmangled
);
1509 string_append (&tname
, SCOPE_STRING (work
));
1511 string_prepends(declp
, &tname
);
1512 if (work
-> destructor
& 1)
1514 string_prepend (&trawname
, "~");
1515 string_appends (declp
, &trawname
);
1516 work
->destructor
-= 1;
1518 if ((work
->constructor
& 1) || (work
->destructor
& 1))
1520 string_appends (declp
, &trawname
);
1521 work
->constructor
-= 1;
1523 string_delete(&trawname
);
1524 string_delete(&tname
);
1530 if ((AUTO_DEMANGLING
|| GNU_DEMANGLING
) && expect_return_type
)
1532 /* Read the return type. */
1534 string_init (&return_type
);
1537 success
= do_type (work
, mangled
, &return_type
);
1538 APPEND_BLANK (&return_type
);
1540 string_prepends (declp
, &return_type
);
1541 string_delete (&return_type
);
1545 /* At the outermost level, we cannot have a return type specified,
1546 so if we run into another '_' at this point we are dealing with
1547 a mangled name that is either bogus, or has been mangled by
1548 some algorithm we don't know how to deal with. So just
1549 reject the entire demangling. */
1550 /* However, "_nnn" is an expected suffix for alternate entry point
1551 numbered nnn for a function, with HP aCC, so skip over that
1552 without reporting failure. pai/1997-09-04 */
1556 while (**mangled
&& ISDIGIT ((unsigned char)**mangled
))
1564 if (AUTO_DEMANGLING
|| GNU_DEMANGLING
)
1566 /* A G++ template function. Read the template arguments. */
1567 success
= demangle_template (work
, mangled
, declp
, 0, 0,
1569 if (!(work
->constructor
& 1))
1570 expect_return_type
= 1;
1579 if (AUTO_DEMANGLING
|| GNU_DEMANGLING
)
1581 /* Assume we have stumbled onto the first outermost function
1582 argument token, and start processing args. */
1584 success
= demangle_args (work
, mangled
, declp
);
1588 /* Non-GNU demanglers use a specific token to mark the start
1589 of the outermost function argument tokens. Typically 'F',
1590 for ARM/HP-demangling, for example. So if we find something
1591 we are not prepared for, it must be an error. */
1597 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1600 if (success
&& expect_func
)
1603 if (LUCID_DEMANGLING
|| ARM_DEMANGLING
|| EDG_DEMANGLING
)
1605 forget_types (work
);
1607 success
= demangle_args (work
, mangled
, declp
);
1608 /* Since template include the mangling of their return types,
1609 we must set expect_func to 0 so that we don't try do
1610 demangle more arguments the next time we get here. */
1615 if (success
&& !func_done
)
1617 if (AUTO_DEMANGLING
|| GNU_DEMANGLING
)
1619 /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
1620 bar__3fooi is 'foo::bar(int)'. We get here when we find the
1621 first case, and need to ensure that the '(void)' gets added to
1622 the current declp. Note that with ARM/HP, the first case
1623 represents the name of a static data member 'foo::bar',
1624 which is in the current declp, so we leave it alone. */
1625 success
= demangle_args (work
, mangled
, declp
);
1628 if (success
&& PRINT_ARG_TYPES
)
1630 if (work
->static_type
)
1631 string_append (declp
, " static");
1632 if (work
->type_quals
!= TYPE_UNQUALIFIED
)
1634 APPEND_BLANK (declp
);
1635 string_append (declp
, qualifier_string (work
->type_quals
));
1645 demangle_method_args (work
, mangled
, declp
)
1646 struct work_stuff
*work
;
1647 const char **mangled
;
1652 if (work
-> static_type
)
1654 string_append (declp
, *mangled
+ 1);
1655 *mangled
+= strlen (*mangled
);
1660 success
= demangle_args (work
, mangled
, declp
);
1668 demangle_template_template_parm (work
, mangled
, tname
)
1669 struct work_stuff
*work
;
1670 const char **mangled
;
1679 string_append (tname
, "template <");
1680 /* get size of template parameter list */
1681 if (get_count (mangled
, &r
))
1683 for (i
= 0; i
< r
; i
++)
1687 string_append (tname
, ", ");
1690 /* Z for type parameters */
1691 if (**mangled
== 'Z')
1694 string_append (tname
, "class");
1696 /* z for template parameters */
1697 else if (**mangled
== 'z')
1701 demangle_template_template_parm (work
, mangled
, tname
);
1709 /* temp is initialized in do_type */
1710 success
= do_type (work
, mangled
, &temp
);
1713 string_appends (tname
, &temp
);
1715 string_delete(&temp
);
1725 if (tname
->p
[-1] == '>')
1726 string_append (tname
, " ");
1727 string_append (tname
, "> class");
1732 demangle_expression (work
, mangled
, s
, tk
)
1733 struct work_stuff
*work
;
1734 const char** mangled
;
1738 int need_operator
= 0;
1742 string_appendn (s
, "(", 1);
1744 while (success
&& **mangled
!= 'W' && **mangled
!= '\0')
1753 len
= strlen (*mangled
);
1755 for (i
= 0; i
< ARRAY_SIZE (optable
); ++i
)
1757 size_t l
= strlen (optable
[i
].in
);
1760 && memcmp (optable
[i
].in
, *mangled
, l
) == 0)
1762 string_appendn (s
, " ", 1);
1763 string_append (s
, optable
[i
].out
);
1764 string_appendn (s
, " ", 1);
1777 success
= demangle_template_value_parm (work
, mangled
, s
, tk
);
1780 if (**mangled
!= 'W')
1784 string_appendn (s
, ")", 1);
1792 demangle_integral_value (work
, mangled
, s
)
1793 struct work_stuff
*work
;
1794 const char** mangled
;
1799 if (**mangled
== 'E')
1800 success
= demangle_expression (work
, mangled
, s
, tk_integral
);
1801 else if (**mangled
== 'Q' || **mangled
== 'K')
1802 success
= demangle_qualified (work
, mangled
, s
, 0, 1);
1807 /* By default, we let the number decide whether we shall consume an
1809 int consume_following_underscore
= 0;
1810 int leave_following_underscore
= 0;
1814 /* Negative numbers are indicated with a leading `m'. */
1815 if (**mangled
== 'm')
1817 string_appendn (s
, "-", 1);
1820 else if (mangled
[0][0] == '_' && mangled
[0][1] == 'm')
1822 /* Since consume_count_with_underscores does not handle the
1823 `m'-prefix we must do it here, using consume_count and
1824 adjusting underscores: we have to consume the underscore
1825 matching the prepended one. */
1826 consume_following_underscore
= 1;
1827 string_appendn (s
, "-", 1);
1830 else if (**mangled
== '_')
1832 /* Do not consume a following underscore;
1833 consume_following_underscore will consume what should be
1835 leave_following_underscore
= 1;
1838 /* We must call consume_count if we expect to remove a trailing
1839 underscore, since consume_count_with_underscores expects
1840 the leading underscore (that we consumed) if it is to handle
1841 multi-digit numbers. */
1842 if (consume_following_underscore
)
1843 value
= consume_count (mangled
);
1845 value
= consume_count_with_underscores (mangled
);
1849 char buf
[INTBUF_SIZE
];
1850 sprintf (buf
, "%d", value
);
1851 string_append (s
, buf
);
1853 /* Numbers not otherwise delimited, might have an underscore
1854 appended as a delimeter, which we should skip.
1856 ??? This used to always remove a following underscore, which
1857 is wrong. If other (arbitrary) cases are followed by an
1858 underscore, we need to do something more radical. */
1860 if ((value
> 9 || consume_following_underscore
)
1861 && ! leave_following_underscore
1862 && **mangled
== '_')
1873 /* Demangle the real value in MANGLED. */
1876 demangle_real_value (work
, mangled
, s
)
1877 struct work_stuff
*work
;
1878 const char **mangled
;
1881 if (**mangled
== 'E')
1882 return demangle_expression (work
, mangled
, s
, tk_real
);
1884 if (**mangled
== 'm')
1886 string_appendn (s
, "-", 1);
1889 while (ISDIGIT ((unsigned char)**mangled
))
1891 string_appendn (s
, *mangled
, 1);
1894 if (**mangled
== '.') /* fraction */
1896 string_appendn (s
, ".", 1);
1898 while (ISDIGIT ((unsigned char)**mangled
))
1900 string_appendn (s
, *mangled
, 1);
1904 if (**mangled
== 'e') /* exponent */
1906 string_appendn (s
, "e", 1);
1908 while (ISDIGIT ((unsigned char)**mangled
))
1910 string_appendn (s
, *mangled
, 1);
1919 demangle_template_value_parm (work
, mangled
, s
, tk
)
1920 struct work_stuff
*work
;
1921 const char **mangled
;
1927 if (**mangled
== 'Y')
1929 /* The next argument is a template parameter. */
1933 idx
= consume_count_with_underscores (mangled
);
1935 || (work
->tmpl_argvec
&& idx
>= work
->ntmpl_args
)
1936 || consume_count_with_underscores (mangled
) == -1)
1938 if (work
->tmpl_argvec
)
1939 string_append (s
, work
->tmpl_argvec
[idx
]);
1941 string_append_template_idx (s
, idx
);
1943 else if (tk
== tk_integral
)
1944 success
= demangle_integral_value (work
, mangled
, s
);
1945 else if (tk
== tk_char
)
1949 if (**mangled
== 'm')
1951 string_appendn (s
, "-", 1);
1954 string_appendn (s
, "'", 1);
1955 val
= consume_count(mangled
);
1962 string_appendn (s
, &tmp
[0], 1);
1963 string_appendn (s
, "'", 1);
1966 else if (tk
== tk_bool
)
1968 int val
= consume_count (mangled
);
1970 string_appendn (s
, "false", 5);
1972 string_appendn (s
, "true", 4);
1976 else if (tk
== tk_real
)
1977 success
= demangle_real_value (work
, mangled
, s
);
1978 else if (tk
== tk_pointer
|| tk
== tk_reference
)
1980 if (**mangled
== 'Q')
1981 success
= demangle_qualified (work
, mangled
, s
,
1986 int symbol_len
= consume_count (mangled
);
1987 if (symbol_len
== -1)
1989 if (symbol_len
== 0)
1990 string_appendn (s
, "0", 1);
1993 char *p
= xmalloc (symbol_len
+ 1), *q
;
1994 strncpy (p
, *mangled
, symbol_len
);
1995 p
[symbol_len
] = '\0';
1996 /* We use cplus_demangle here, rather than
1997 internal_cplus_demangle, because the name of the entity
1998 mangled here does not make use of any of the squangling
1999 or type-code information we have built up thus far; it is
2000 mangled independently. */
2001 q
= cplus_demangle (p
, work
->options
);
2002 if (tk
== tk_pointer
)
2003 string_appendn (s
, "&", 1);
2004 /* FIXME: Pointer-to-member constants should get a
2005 qualifying class name here. */
2008 string_append (s
, q
);
2012 string_append (s
, p
);
2015 *mangled
+= symbol_len
;
2022 /* Demangle the template name in MANGLED. The full name of the
2023 template (e.g., S<int>) is placed in TNAME. The name without the
2024 template parameters (e.g. S) is placed in TRAWNAME if TRAWNAME is
2025 non-NULL. If IS_TYPE is nonzero, this template is a type template,
2026 not a function template. If both IS_TYPE and REMEMBER are nonzero,
2027 the template is remembered in the list of back-referenceable
2031 demangle_template (work
, mangled
, tname
, trawname
, is_type
, remember
)
2032 struct work_stuff
*work
;
2033 const char **mangled
;
2044 int is_java_array
= 0;
2052 bindex
= register_Btype (work
);
2054 /* get template name */
2055 if (**mangled
== 'z')
2061 idx
= consume_count_with_underscores (mangled
);
2063 || (work
->tmpl_argvec
&& idx
>= work
->ntmpl_args
)
2064 || consume_count_with_underscores (mangled
) == -1)
2067 if (work
->tmpl_argvec
)
2069 string_append (tname
, work
->tmpl_argvec
[idx
]);
2071 string_append (trawname
, work
->tmpl_argvec
[idx
]);
2075 string_append_template_idx (tname
, idx
);
2077 string_append_template_idx (trawname
, idx
);
2082 if ((r
= consume_count (mangled
)) <= 0
2083 || (int) strlen (*mangled
) < r
)
2087 is_java_array
= (work
-> options
& DMGL_JAVA
)
2088 && strncmp (*mangled
, "JArray1Z", 8) == 0;
2089 if (! is_java_array
)
2091 string_appendn (tname
, *mangled
, r
);
2094 string_appendn (trawname
, *mangled
, r
);
2099 string_append (tname
, "<");
2100 /* get size of template parameter list */
2101 if (!get_count (mangled
, &r
))
2107 /* Create an array for saving the template argument values. */
2108 work
->tmpl_argvec
= (char**) xmalloc (r
* sizeof (char *));
2109 work
->ntmpl_args
= r
;
2110 for (i
= 0; i
< r
; i
++)
2111 work
->tmpl_argvec
[i
] = 0;
2113 for (i
= 0; i
< r
; i
++)
2117 string_append (tname
, ", ");
2119 /* Z for type parameters */
2120 if (**mangled
== 'Z')
2123 /* temp is initialized in do_type */
2124 success
= do_type (work
, mangled
, &temp
);
2127 string_appends (tname
, &temp
);
2131 /* Save the template argument. */
2132 int len
= temp
.p
- temp
.b
;
2133 work
->tmpl_argvec
[i
] = xmalloc (len
+ 1);
2134 memcpy (work
->tmpl_argvec
[i
], temp
.b
, len
);
2135 work
->tmpl_argvec
[i
][len
] = '\0';
2138 string_delete(&temp
);
2144 /* z for template parameters */
2145 else if (**mangled
== 'z')
2149 success
= demangle_template_template_parm (work
, mangled
, tname
);
2152 && (r2
= consume_count (mangled
)) > 0
2153 && (int) strlen (*mangled
) >= r2
)
2155 string_append (tname
, " ");
2156 string_appendn (tname
, *mangled
, r2
);
2159 /* Save the template argument. */
2161 work
->tmpl_argvec
[i
] = xmalloc (len
+ 1);
2162 memcpy (work
->tmpl_argvec
[i
], *mangled
, len
);
2163 work
->tmpl_argvec
[i
][len
] = '\0';
2177 /* otherwise, value parameter */
2179 /* temp is initialized in do_type */
2180 success
= do_type (work
, mangled
, &temp
);
2181 string_delete(&temp
);
2193 success
= demangle_template_value_parm (work
, mangled
, s
,
2194 (type_kind_t
) success
);
2206 int len
= s
->p
- s
->b
;
2207 work
->tmpl_argvec
[i
] = xmalloc (len
+ 1);
2208 memcpy (work
->tmpl_argvec
[i
], s
->b
, len
);
2209 work
->tmpl_argvec
[i
][len
] = '\0';
2211 string_appends (tname
, s
);
2219 string_append (tname
, "[]");
2223 if (tname
->p
[-1] == '>')
2224 string_append (tname
, " ");
2225 string_append (tname
, ">");
2228 if (is_type
&& remember
)
2229 remember_Btype (work
, tname
->b
, LEN_STRING (tname
), bindex
);
2232 if (work -> static_type)
2234 string_append (declp, *mangled + 1);
2235 *mangled += strlen (*mangled);
2240 success = demangle_args (work, mangled, declp);
2248 arm_pt (work
, mangled
, n
, anchor
, args
)
2249 struct work_stuff
*work
;
2250 const char *mangled
;
2252 const char **anchor
, **args
;
2254 /* Check if ARM template with "__pt__" in it ("parameterized type") */
2255 /* Allow HP also here, because HP's cfront compiler follows ARM to some extent */
2256 if ((ARM_DEMANGLING
|| HP_DEMANGLING
) && (*anchor
= mystrstr (mangled
, "__pt__")))
2259 *args
= *anchor
+ 6;
2260 len
= consume_count (args
);
2263 if (*args
+ len
== mangled
+ n
&& **args
== '_')
2269 if (AUTO_DEMANGLING
|| EDG_DEMANGLING
)
2271 if ((*anchor
= mystrstr (mangled
, "__tm__"))
2272 || (*anchor
= mystrstr (mangled
, "__ps__"))
2273 || (*anchor
= mystrstr (mangled
, "__pt__")))
2276 *args
= *anchor
+ 6;
2277 len
= consume_count (args
);
2280 if (*args
+ len
== mangled
+ n
&& **args
== '_')
2286 else if ((*anchor
= mystrstr (mangled
, "__S")))
2289 *args
= *anchor
+ 3;
2290 len
= consume_count (args
);
2293 if (*args
+ len
== mangled
+ n
&& **args
== '_')
2305 demangle_arm_hp_template (work
, mangled
, n
, declp
)
2306 struct work_stuff
*work
;
2307 const char **mangled
;
2313 const char *e
= *mangled
+ n
;
2316 /* Check for HP aCC template spec: classXt1t2 where t1, t2 are
2318 if (HP_DEMANGLING
&& ((*mangled
)[n
] == 'X'))
2320 char *start_spec_args
= NULL
;
2322 /* First check for and omit template specialization pseudo-arguments,
2323 such as in "Spec<#1,#1.*>" */
2324 start_spec_args
= strchr (*mangled
, '<');
2325 if (start_spec_args
&& (start_spec_args
- *mangled
< n
))
2326 string_appendn (declp
, *mangled
, start_spec_args
- *mangled
);
2328 string_appendn (declp
, *mangled
, n
);
2329 (*mangled
) += n
+ 1;
2331 if (work
->temp_start
== -1) /* non-recursive call */
2332 work
->temp_start
= declp
->p
- declp
->b
;
2333 string_append (declp
, "<");
2336 string_clear (&arg
);
2340 /* 'T' signals a type parameter */
2342 if (!do_type (work
, mangled
, &arg
))
2343 goto hpacc_template_args_done
;
2348 /* 'U' or 'S' signals an integral value */
2349 if (!do_hpacc_template_const_value (work
, mangled
, &arg
))
2350 goto hpacc_template_args_done
;
2354 /* 'A' signals a named constant expression (literal) */
2355 if (!do_hpacc_template_literal (work
, mangled
, &arg
))
2356 goto hpacc_template_args_done
;
2360 /* Today, 1997-09-03, we have only the above types
2361 of template parameters */
2362 /* FIXME: maybe this should fail and return null */
2363 goto hpacc_template_args_done
;
2365 string_appends (declp
, &arg
);
2366 /* Check if we're at the end of template args.
2367 0 if at end of static member of template class,
2368 _ if done with template args for a function */
2369 if ((**mangled
== '\000') || (**mangled
== '_'))
2372 string_append (declp
, ",");
2374 hpacc_template_args_done
:
2375 string_append (declp
, ">");
2376 string_delete (&arg
);
2377 if (**mangled
== '_')
2381 /* ARM template? (Also handles HP cfront extensions) */
2382 else if (arm_pt (work
, *mangled
, n
, &p
, &args
))
2387 string_appendn (declp
, *mangled
, p
- *mangled
);
2388 if (work
->temp_start
== -1) /* non-recursive call */
2389 work
->temp_start
= declp
->p
- declp
->b
;
2390 string_append (declp
, "<");
2391 /* should do error checking here */
2393 string_clear (&arg
);
2395 /* Check for type or literal here */
2398 /* HP cfront extensions to ARM for template args */
2399 /* spec: Xt1Lv1 where t1 is a type, v1 is a literal value */
2400 /* FIXME: We handle only numeric literals for HP cfront */
2402 /* A typed constant value follows */
2404 if (!do_type (work
, &args
, &type_str
))
2405 goto cfront_template_args_done
;
2406 string_append (&arg
, "(");
2407 string_appends (&arg
, &type_str
);
2408 string_append (&arg
, ")");
2410 goto cfront_template_args_done
;
2412 /* Now snarf a literal value following 'L' */
2413 if (!snarf_numeric_literal (&args
, &arg
))
2414 goto cfront_template_args_done
;
2418 /* Snarf a literal following 'L' */
2420 if (!snarf_numeric_literal (&args
, &arg
))
2421 goto cfront_template_args_done
;
2424 /* Not handling other HP cfront stuff */
2425 if (!do_type (work
, &args
, &arg
))
2426 goto cfront_template_args_done
;
2428 string_appends (declp
, &arg
);
2429 string_append (declp
, ",");
2431 cfront_template_args_done
:
2432 string_delete (&arg
);
2434 --declp
->p
; /* remove extra comma */
2435 string_append (declp
, ">");
2437 else if (n
>10 && strncmp (*mangled
, "_GLOBAL_", 8) == 0
2438 && (*mangled
)[9] == 'N'
2439 && (*mangled
)[8] == (*mangled
)[10]
2440 && strchr (cplus_markers
, (*mangled
)[8]))
2442 /* A member of the anonymous namespace. */
2443 string_append (declp
, "{anonymous}");
2447 if (work
->temp_start
== -1) /* non-recursive call only */
2448 work
->temp_start
= 0; /* disable in recursive calls */
2449 string_appendn (declp
, *mangled
, n
);
2454 /* Extract a class name, possibly a template with arguments, from the
2455 mangled string; qualifiers, local class indicators, etc. have
2456 already been dealt with */
2459 demangle_class_name (work
, mangled
, declp
)
2460 struct work_stuff
*work
;
2461 const char **mangled
;
2467 n
= consume_count (mangled
);
2470 if ((int) strlen (*mangled
) >= n
)
2472 demangle_arm_hp_template (work
, mangled
, n
, declp
);
2483 demangle_class -- demangle a mangled class sequence
2488 demangle_class (struct work_stuff *work, const char **mangled,
2493 DECLP points to the buffer into which demangling is being done.
2495 *MANGLED points to the current token to be demangled. On input,
2496 it points to a mangled class (I.E. "3foo", "13verylongclass", etc.)
2497 On exit, it points to the next token after the mangled class on
2498 success, or the first unconsumed token on failure.
2500 If the CONSTRUCTOR or DESTRUCTOR flags are set in WORK, then
2501 we are demangling a constructor or destructor. In this case
2502 we prepend "class::class" or "class::~class" to DECLP.
2504 Otherwise, we prepend "class::" to the current DECLP.
2506 Reset the constructor/destructor flags once they have been
2507 "consumed". This allows demangle_class to be called later during
2508 the same demangling, to do normal class demangling.
2510 Returns 1 if demangling is successful, 0 otherwise.
2515 demangle_class (work
, mangled
, declp
)
2516 struct work_stuff
*work
;
2517 const char **mangled
;
2523 char *save_class_name_end
= 0;
2525 string_init (&class_name
);
2526 btype
= register_Btype (work
);
2527 if (demangle_class_name (work
, mangled
, &class_name
))
2529 save_class_name_end
= class_name
.p
;
2530 if ((work
->constructor
& 1) || (work
->destructor
& 1))
2532 /* adjust so we don't include template args */
2533 if (work
->temp_start
&& (work
->temp_start
!= -1))
2535 class_name
.p
= class_name
.b
+ work
->temp_start
;
2537 string_prepends (declp
, &class_name
);
2538 if (work
-> destructor
& 1)
2540 string_prepend (declp
, "~");
2541 work
-> destructor
-= 1;
2545 work
-> constructor
-= 1;
2548 class_name
.p
= save_class_name_end
;
2549 remember_Ktype (work
, class_name
.b
, LEN_STRING(&class_name
));
2550 remember_Btype (work
, class_name
.b
, LEN_STRING(&class_name
), btype
);
2551 string_prepend (declp
, SCOPE_STRING (work
));
2552 string_prepends (declp
, &class_name
);
2555 string_delete (&class_name
);
2560 /* Called when there's a "__" in the mangled name, with `scan' pointing to
2561 the rightmost guess.
2563 Find the correct "__"-sequence where the function name ends and the
2564 signature starts, which is ambiguous with GNU mangling.
2565 Call demangle_signature here, so we can make sure we found the right
2566 one; *mangled will be consumed so caller will not make further calls to
2567 demangle_signature. */
2570 iterate_demangle_function (work
, mangled
, declp
, scan
)
2571 struct work_stuff
*work
;
2572 const char **mangled
;
2576 const char *mangle_init
= *mangled
;
2579 struct work_stuff work_init
;
2581 if (*(scan
+ 2) == '\0')
2584 /* Do not iterate for some demangling modes, or if there's only one
2585 "__"-sequence. This is the normal case. */
2586 if (ARM_DEMANGLING
|| LUCID_DEMANGLING
|| HP_DEMANGLING
|| EDG_DEMANGLING
2587 || mystrstr (scan
+ 2, "__") == NULL
)
2589 demangle_function_name (work
, mangled
, declp
, scan
);
2593 /* Save state so we can restart if the guess at the correct "__" was
2595 string_init (&decl_init
);
2596 string_appends (&decl_init
, declp
);
2597 memset (&work_init
, 0, sizeof work_init
);
2598 work_stuff_copy_to_from (&work_init
, work
);
2600 /* Iterate over occurrences of __, allowing names and types to have a
2601 "__" sequence in them. We must start with the first (not the last)
2602 occurrence, since "__" most often occur between independent mangled
2603 parts, hence starting at the last occurence inside a signature
2604 might get us a "successful" demangling of the signature. */
2608 demangle_function_name (work
, mangled
, declp
, scan
);
2609 success
= demangle_signature (work
, mangled
, declp
);
2613 /* Reset demangle state for the next round. */
2614 *mangled
= mangle_init
;
2615 string_clear (declp
);
2616 string_appends (declp
, &decl_init
);
2617 work_stuff_copy_to_from (work
, &work_init
);
2619 /* Leave this underscore-sequence. */
2622 /* Scan for the next "__" sequence. */
2623 while (*scan
&& (scan
[0] != '_' || scan
[1] != '_'))
2626 /* Move to last "__" in this sequence. */
2627 while (*scan
&& *scan
== '_')
2632 /* Delete saved state. */
2633 delete_work_stuff (&work_init
);
2634 string_delete (&decl_init
);
2643 demangle_prefix -- consume the mangled name prefix and find signature
2648 demangle_prefix (struct work_stuff *work, const char **mangled,
2653 Consume and demangle the prefix of the mangled name.
2654 While processing the function name root, arrange to call
2655 demangle_signature if the root is ambiguous.
2657 DECLP points to the string buffer into which demangled output is
2658 placed. On entry, the buffer is empty. On exit it contains
2659 the root function name, the demangled operator name, or in some
2660 special cases either nothing or the completely demangled result.
2662 MANGLED points to the current pointer into the mangled name. As each
2663 token of the mangled name is consumed, it is updated. Upon entry
2664 the current mangled name pointer points to the first character of
2665 the mangled name. Upon exit, it should point to the first character
2666 of the signature if demangling was successful, or to the first
2667 unconsumed character if demangling of the prefix was unsuccessful.
2669 Returns 1 on success, 0 otherwise.
2673 demangle_prefix (work
, mangled
, declp
)
2674 struct work_stuff
*work
;
2675 const char **mangled
;
2682 if (strlen(*mangled
) > 6
2683 && (strncmp(*mangled
, "_imp__", 6) == 0
2684 || strncmp(*mangled
, "__imp_", 6) == 0))
2686 /* it's a symbol imported from a PE dynamic library. Check for both
2687 new style prefix _imp__ and legacy __imp_ used by older versions
2690 work
->dllimported
= 1;
2692 else if (strlen(*mangled
) >= 11 && strncmp(*mangled
, "_GLOBAL_", 8) == 0)
2694 char *marker
= strchr (cplus_markers
, (*mangled
)[8]);
2695 if (marker
!= NULL
&& *marker
== (*mangled
)[10])
2697 if ((*mangled
)[9] == 'D')
2699 /* it's a GNU global destructor to be executed at program exit */
2701 work
->destructor
= 2;
2702 if (gnu_special (work
, mangled
, declp
))
2705 else if ((*mangled
)[9] == 'I')
2707 /* it's a GNU global constructor to be executed at program init */
2709 work
->constructor
= 2;
2710 if (gnu_special (work
, mangled
, declp
))
2715 else if ((ARM_DEMANGLING
|| HP_DEMANGLING
|| EDG_DEMANGLING
) && strncmp(*mangled
, "__std__", 7) == 0)
2717 /* it's a ARM global destructor to be executed at program exit */
2719 work
->destructor
= 2;
2721 else if ((ARM_DEMANGLING
|| HP_DEMANGLING
|| EDG_DEMANGLING
) && strncmp(*mangled
, "__sti__", 7) == 0)
2723 /* it's a ARM global constructor to be executed at program initial */
2725 work
->constructor
= 2;
2728 /* This block of code is a reduction in strength time optimization
2730 scan = mystrstr (*mangled, "__"); */
2736 scan
= strchr (scan
, '_');
2737 } while (scan
!= NULL
&& *++scan
!= '_');
2739 if (scan
!= NULL
) --scan
;
2744 /* We found a sequence of two or more '_', ensure that we start at
2745 the last pair in the sequence. */
2746 i
= strspn (scan
, "_");
2757 else if (work
-> static_type
)
2759 if (!ISDIGIT ((unsigned char)scan
[0]) && (scan
[0] != 't'))
2764 else if ((scan
== *mangled
)
2765 && (ISDIGIT ((unsigned char)scan
[2]) || (scan
[2] == 'Q')
2766 || (scan
[2] == 't') || (scan
[2] == 'K') || (scan
[2] == 'H')))
2768 /* The ARM says nothing about the mangling of local variables.
2769 But cfront mangles local variables by prepending __<nesting_level>
2770 to them. As an extension to ARM demangling we handle this case. */
2771 if ((LUCID_DEMANGLING
|| ARM_DEMANGLING
|| HP_DEMANGLING
)
2772 && ISDIGIT ((unsigned char)scan
[2]))
2774 *mangled
= scan
+ 2;
2775 consume_count (mangled
);
2776 string_append (declp
, *mangled
);
2777 *mangled
+= strlen (*mangled
);
2782 /* A GNU style constructor starts with __[0-9Qt]. But cfront uses
2783 names like __Q2_3foo3bar for nested type names. So don't accept
2784 this style of constructor for cfront demangling. A GNU
2785 style member-template constructor starts with 'H'. */
2786 if (!(LUCID_DEMANGLING
|| ARM_DEMANGLING
|| HP_DEMANGLING
|| EDG_DEMANGLING
))
2787 work
-> constructor
+= 1;
2788 *mangled
= scan
+ 2;
2791 else if (ARM_DEMANGLING
&& scan
[2] == 'p' && scan
[3] == 't')
2793 /* Cfront-style parameterized type. Handled later as a signature. */
2797 demangle_arm_hp_template (work
, mangled
, strlen (*mangled
), declp
);
2799 else if (EDG_DEMANGLING
&& ((scan
[2] == 't' && scan
[3] == 'm')
2800 || (scan
[2] == 'p' && scan
[3] == 's')
2801 || (scan
[2] == 'p' && scan
[3] == 't')))
2803 /* EDG-style parameterized type. Handled later as a signature. */
2807 demangle_arm_hp_template (work
, mangled
, strlen (*mangled
), declp
);
2809 else if ((scan
== *mangled
) && !ISDIGIT ((unsigned char)scan
[2])
2810 && (scan
[2] != 't'))
2812 /* Mangled name starts with "__". Skip over any leading '_' characters,
2813 then find the next "__" that separates the prefix from the signature.
2815 if (!(ARM_DEMANGLING
|| LUCID_DEMANGLING
|| HP_DEMANGLING
|| EDG_DEMANGLING
)
2816 || (arm_special (mangled
, declp
) == 0))
2818 while (*scan
== '_')
2822 if ((scan
= mystrstr (scan
, "__")) == NULL
|| (*(scan
+ 2) == '\0'))
2824 /* No separator (I.E. "__not_mangled"), or empty signature
2825 (I.E. "__not_mangled_either__") */
2829 return iterate_demangle_function (work
, mangled
, declp
, scan
);
2832 else if (*(scan
+ 2) != '\0')
2834 /* Mangled name does not start with "__" but does have one somewhere
2835 in there with non empty stuff after it. Looks like a global
2836 function name. Iterate over all "__":s until the right
2838 return iterate_demangle_function (work
, mangled
, declp
, scan
);
2842 /* Doesn't look like a mangled name */
2846 if (!success
&& (work
->constructor
== 2 || work
->destructor
== 2))
2848 string_append (declp
, *mangled
);
2849 *mangled
+= strlen (*mangled
);
2859 gnu_special -- special handling of gnu mangled strings
2864 gnu_special (struct work_stuff *work, const char **mangled,
2870 Process some special GNU style mangling forms that don't fit
2871 the normal pattern. For example:
2873 _$_3foo (destructor for class foo)
2874 _vt$foo (foo virtual table)
2875 _vt$foo$bar (foo::bar virtual table)
2876 __vt_foo (foo virtual table, new style with thunks)
2877 _3foo$varname (static data member)
2878 _Q22rs2tu$vw (static data member)
2879 __t6vector1Zii (constructor with template)
2880 __thunk_4__$_7ostream (virtual function thunk)
2884 gnu_special (work
, mangled
, declp
)
2885 struct work_stuff
*work
;
2886 const char **mangled
;
2893 if ((*mangled
)[0] == '_'
2894 && strchr (cplus_markers
, (*mangled
)[1]) != NULL
2895 && (*mangled
)[2] == '_')
2897 /* Found a GNU style destructor, get past "_<CPLUS_MARKER>_" */
2899 work
-> destructor
+= 1;
2901 else if ((*mangled
)[0] == '_'
2902 && (((*mangled
)[1] == '_'
2903 && (*mangled
)[2] == 'v'
2904 && (*mangled
)[3] == 't'
2905 && (*mangled
)[4] == '_')
2906 || ((*mangled
)[1] == 'v'
2907 && (*mangled
)[2] == 't'
2908 && strchr (cplus_markers
, (*mangled
)[3]) != NULL
)))
2910 /* Found a GNU style virtual table, get past "_vt<CPLUS_MARKER>"
2911 and create the decl. Note that we consume the entire mangled
2912 input string, which means that demangle_signature has no work
2914 if ((*mangled
)[2] == 'v')
2915 (*mangled
) += 5; /* New style, with thunks: "__vt_" */
2917 (*mangled
) += 4; /* Old style, no thunks: "_vt<CPLUS_MARKER>" */
2918 while (**mangled
!= '\0')
2924 success
= demangle_qualified (work
, mangled
, declp
, 0, 1);
2927 success
= demangle_template (work
, mangled
, declp
, 0, 1,
2931 if (ISDIGIT((unsigned char)*mangled
[0]))
2933 n
= consume_count(mangled
);
2934 /* We may be seeing a too-large size, or else a
2935 ".<digits>" indicating a static local symbol. In
2936 any case, declare victory and move on; *don't* try
2937 to use n to allocate. */
2938 if (n
> (int) strlen (*mangled
))
2946 n
= strcspn (*mangled
, cplus_markers
);
2948 string_appendn (declp
, *mangled
, n
);
2952 p
= strpbrk (*mangled
, cplus_markers
);
2953 if (success
&& ((p
== NULL
) || (p
== *mangled
)))
2957 string_append (declp
, SCOPE_STRING (work
));
2968 string_append (declp
, " virtual table");
2970 else if ((*mangled
)[0] == '_'
2971 && (strchr("0123456789Qt", (*mangled
)[1]) != NULL
)
2972 && (p
= strpbrk (*mangled
, cplus_markers
)) != NULL
)
2974 /* static data member, "_3foo$varname" for example */
2980 success
= demangle_qualified (work
, mangled
, declp
, 0, 1);
2983 success
= demangle_template (work
, mangled
, declp
, 0, 1, 1);
2986 n
= consume_count (mangled
);
2987 if (n
< 0 || n
> (long) strlen (*mangled
))
2993 if (n
> 10 && strncmp (*mangled
, "_GLOBAL_", 8) == 0
2994 && (*mangled
)[9] == 'N'
2995 && (*mangled
)[8] == (*mangled
)[10]
2996 && strchr (cplus_markers
, (*mangled
)[8]))
2998 /* A member of the anonymous namespace. There's information
2999 about what identifier or filename it was keyed to, but
3000 it's just there to make the mangled name unique; we just
3002 string_append (declp
, "{anonymous}");
3005 /* Now p points to the marker before the N, so we need to
3006 update it to the first marker after what we consumed. */
3007 p
= strpbrk (*mangled
, cplus_markers
);
3011 string_appendn (declp
, *mangled
, n
);
3014 if (success
&& (p
== *mangled
))
3016 /* Consumed everything up to the cplus_marker, append the
3019 string_append (declp
, SCOPE_STRING (work
));
3020 n
= strlen (*mangled
);
3021 string_appendn (declp
, *mangled
, n
);
3029 else if (strncmp (*mangled
, "__thunk_", 8) == 0)
3034 delta
= consume_count (mangled
);
3039 char *method
= internal_cplus_demangle (work
, ++*mangled
);
3044 sprintf (buf
, "virtual function thunk (delta:%d) for ", -delta
);
3045 string_append (declp
, buf
);
3046 string_append (declp
, method
);
3048 n
= strlen (*mangled
);
3057 else if (strncmp (*mangled
, "__t", 3) == 0
3058 && ((*mangled
)[3] == 'i' || (*mangled
)[3] == 'f'))
3060 p
= (*mangled
)[3] == 'i' ? " type_info node" : " type_info function";
3066 success
= demangle_qualified (work
, mangled
, declp
, 0, 1);
3069 success
= demangle_template (work
, mangled
, declp
, 0, 1, 1);
3072 success
= do_type (work
, mangled
, declp
);
3075 if (success
&& **mangled
!= '\0')
3078 string_append (declp
, p
);
3088 recursively_demangle(work
, mangled
, result
, namelength
)
3089 struct work_stuff
*work
;
3090 const char **mangled
;
3094 char * recurse
= (char *)NULL
;
3095 char * recurse_dem
= (char *)NULL
;
3097 recurse
= (char *) xmalloc (namelength
+ 1);
3098 memcpy (recurse
, *mangled
, namelength
);
3099 recurse
[namelength
] = '\000';
3101 recurse_dem
= cplus_demangle (recurse
, work
->options
);
3105 string_append (result
, recurse_dem
);
3110 string_appendn (result
, *mangled
, namelength
);
3113 *mangled
+= namelength
;
3120 arm_special -- special handling of ARM/lucid mangled strings
3125 arm_special (const char **mangled,
3131 Process some special ARM style mangling forms that don't fit
3132 the normal pattern. For example:
3134 __vtbl__3foo (foo virtual table)
3135 __vtbl__3foo__3bar (bar::foo virtual table)
3140 arm_special (mangled
, declp
)
3141 const char **mangled
;
3148 if (strncmp (*mangled
, ARM_VTABLE_STRING
, ARM_VTABLE_STRLEN
) == 0)
3150 /* Found a ARM style virtual table, get past ARM_VTABLE_STRING
3151 and create the decl. Note that we consume the entire mangled
3152 input string, which means that demangle_signature has no work
3154 scan
= *mangled
+ ARM_VTABLE_STRLEN
;
3155 while (*scan
!= '\0') /* first check it can be demangled */
3157 n
= consume_count (&scan
);
3160 return (0); /* no good */
3163 if (scan
[0] == '_' && scan
[1] == '_')
3168 (*mangled
) += ARM_VTABLE_STRLEN
;
3169 while (**mangled
!= '\0')
3171 n
= consume_count (mangled
);
3173 || n
> (long) strlen (*mangled
))
3175 string_prependn (declp
, *mangled
, n
);
3177 if ((*mangled
)[0] == '_' && (*mangled
)[1] == '_')
3179 string_prepend (declp
, "::");
3183 string_append (declp
, " virtual table");
3196 demangle_qualified -- demangle 'Q' qualified name strings
3201 demangle_qualified (struct work_stuff *, const char *mangled,
3202 string *result, int isfuncname, int append);
3206 Demangle a qualified name, such as "Q25Outer5Inner" which is
3207 the mangled form of "Outer::Inner". The demangled output is
3208 prepended or appended to the result string according to the
3209 state of the append flag.
3211 If isfuncname is nonzero, then the qualified name we are building
3212 is going to be used as a member function name, so if it is a
3213 constructor or destructor function, append an appropriate
3214 constructor or destructor name. I.E. for the above example,
3215 the result for use as a constructor is "Outer::Inner::Inner"
3216 and the result for use as a destructor is "Outer::Inner::~Inner".
3220 Numeric conversion is ASCII dependent (FIXME).
3225 demangle_qualified (work
, mangled
, result
, isfuncname
, append
)
3226 struct work_stuff
*work
;
3227 const char **mangled
;
3237 int bindex
= register_Btype (work
);
3239 /* We only make use of ISFUNCNAME if the entity is a constructor or
3241 isfuncname
= (isfuncname
3242 && ((work
->constructor
& 1) || (work
->destructor
& 1)));
3244 string_init (&temp
);
3245 string_init (&last_name
);
3247 if ((*mangled
)[0] == 'K')
3249 /* Squangling qualified name reuse */
3252 idx
= consume_count_with_underscores (mangled
);
3253 if (idx
== -1 || idx
>= work
-> numk
)
3256 string_append (&temp
, work
-> ktypevec
[idx
]);
3259 switch ((*mangled
)[1])
3262 /* GNU mangled name with more than 9 classes. The count is preceded
3263 by an underscore (to distinguish it from the <= 9 case) and followed
3264 by an underscore. */
3266 qualifiers
= consume_count_with_underscores (mangled
);
3267 if (qualifiers
== -1)
3280 /* The count is in a single digit. */
3281 num
[0] = (*mangled
)[1];
3283 qualifiers
= atoi (num
);
3285 /* If there is an underscore after the digit, skip it. This is
3286 said to be for ARM-qualified names, but the ARM makes no
3287 mention of such an underscore. Perhaps cfront uses one. */
3288 if ((*mangled
)[2] == '_')
3303 /* Pick off the names and collect them in the temp buffer in the order
3304 in which they are found, separated by '::'. */
3306 while (qualifiers
-- > 0)
3309 string_clear (&last_name
);
3311 if (*mangled
[0] == '_')
3314 if (*mangled
[0] == 't')
3316 /* Here we always append to TEMP since we will want to use
3317 the template name without the template parameters as a
3318 constructor or destructor name. The appropriate
3319 (parameter-less) value is returned by demangle_template
3320 in LAST_NAME. We do not remember the template type here,
3321 in order to match the G++ mangling algorithm. */
3322 success
= demangle_template(work
, mangled
, &temp
,
3327 else if (*mangled
[0] == 'K')
3331 idx
= consume_count_with_underscores (mangled
);
3332 if (idx
== -1 || idx
>= work
->numk
)
3335 string_append (&temp
, work
->ktypevec
[idx
]);
3338 if (!success
) break;
3345 /* Now recursively demangle the qualifier
3346 * This is necessary to deal with templates in
3347 * mangling styles like EDG */
3348 namelength
= consume_count (mangled
);
3349 if (namelength
== -1)
3354 recursively_demangle(work
, mangled
, &temp
, namelength
);
3358 success
= do_type (work
, mangled
, &last_name
);
3361 string_appends (&temp
, &last_name
);
3366 remember_Ktype (work
, temp
.b
, LEN_STRING (&temp
));
3369 string_append (&temp
, SCOPE_STRING (work
));
3372 remember_Btype (work
, temp
.b
, LEN_STRING (&temp
), bindex
);
3374 /* If we are using the result as a function name, we need to append
3375 the appropriate '::' separated constructor or destructor name.
3376 We do this here because this is the most convenient place, where
3377 we already have a pointer to the name and the length of the name. */
3381 string_append (&temp
, SCOPE_STRING (work
));
3382 if (work
-> destructor
& 1)
3383 string_append (&temp
, "~");
3384 string_appends (&temp
, &last_name
);
3387 /* Now either prepend the temp buffer to the result, or append it,
3388 depending upon the state of the append flag. */
3391 string_appends (result
, &temp
);
3394 if (!STRING_EMPTY (result
))
3395 string_append (&temp
, SCOPE_STRING (work
));
3396 string_prepends (result
, &temp
);
3399 string_delete (&last_name
);
3400 string_delete (&temp
);
3408 get_count -- convert an ascii count to integer, consuming tokens
3413 get_count (const char **type, int *count)
3417 Assume that *type points at a count in a mangled name; set
3418 *count to its value, and set *type to the next character after
3419 the count. There are some weird rules in effect here.
3421 If *type does not point at a string of digits, return zero.
3423 If *type points at a string of digits followed by an
3424 underscore, set *count to their value as an integer, advance
3425 *type to point *after the underscore, and return 1.
3427 If *type points at a string of digits not followed by an
3428 underscore, consume only the first digit. Set *count to its
3429 value as an integer, leave *type pointing after that digit,
3432 The excuse for this odd behavior: in the ARM and HP demangling
3433 styles, a type can be followed by a repeat count of the form
3436 `x' is a single digit specifying how many additional copies
3437 of the type to append to the argument list, and
3439 `y' is one or more digits, specifying the zero-based index of
3440 the first repeated argument in the list. Yes, as you're
3441 unmangling the name you can figure this out yourself, but
3444 So, for example, in `bar__3fooFPiN51', the first argument is a
3445 pointer to an integer (`Pi'), and then the next five arguments
3446 are the same (`N5'), and the first repeat is the function's
3447 second argument (`1').
3451 get_count (type
, count
)
3458 if (!ISDIGIT ((unsigned char)**type
))
3462 *count
= **type
- '0';
3464 if (ISDIGIT ((unsigned char)**type
))
3474 while (ISDIGIT ((unsigned char)*p
));
3485 /* RESULT will be initialised here; it will be freed on failure. The
3486 value returned is really a type_kind_t. */
3489 do_type (work
, mangled
, result
)
3490 struct work_stuff
*work
;
3491 const char **mangled
;
3498 const char *remembered_type
;
3501 type_kind_t tk
= tk_none
;
3503 string_init (&btype
);
3504 string_init (&decl
);
3505 string_init (result
);
3509 while (success
&& !done
)
3515 /* A pointer type */
3519 if (! (work
-> options
& DMGL_JAVA
))
3520 string_prepend (&decl
, "*");
3525 /* A reference type */
3528 string_prepend (&decl
, "&");
3537 if (!STRING_EMPTY (&decl
)
3538 && (decl
.b
[0] == '*' || decl
.b
[0] == '&'))
3540 string_prepend (&decl
, "(");
3541 string_append (&decl
, ")");
3543 string_append (&decl
, "[");
3544 if (**mangled
!= '_')
3545 success
= demangle_template_value_parm (work
, mangled
, &decl
,
3547 if (**mangled
== '_')
3549 string_append (&decl
, "]");
3553 /* A back reference to a previously seen type */
3556 if (!get_count (mangled
, &n
) || n
>= work
-> ntypes
)
3562 remembered_type
= work
-> typevec
[n
];
3563 mangled
= &remembered_type
;
3570 if (!STRING_EMPTY (&decl
)
3571 && (decl
.b
[0] == '*' || decl
.b
[0] == '&'))
3573 string_prepend (&decl
, "(");
3574 string_append (&decl
, ")");
3576 /* After picking off the function args, we expect to either find the
3577 function return type (preceded by an '_') or the end of the
3579 if (!demangle_nested_args (work
, mangled
, &decl
)
3580 || (**mangled
!= '_' && **mangled
!= '\0'))
3585 if (success
&& (**mangled
== '_'))
3592 type_quals
= TYPE_UNQUALIFIED
;
3594 member
= **mangled
== 'M';
3597 string_append (&decl
, ")");
3599 /* We don't need to prepend `::' for a qualified name;
3600 demangle_qualified will do that for us. */
3601 if (**mangled
!= 'Q')
3602 string_prepend (&decl
, SCOPE_STRING (work
));
3604 if (ISDIGIT ((unsigned char)**mangled
))
3606 n
= consume_count (mangled
);
3608 || (int) strlen (*mangled
) < n
)
3613 string_prependn (&decl
, *mangled
, n
);
3616 else if (**mangled
== 'X' || **mangled
== 'Y')
3619 do_type (work
, mangled
, &temp
);
3620 string_prepends (&decl
, &temp
);
3622 else if (**mangled
== 't')
3625 string_init (&temp
);
3626 success
= demangle_template (work
, mangled
, &temp
,
3630 string_prependn (&decl
, temp
.b
, temp
.p
- temp
.b
);
3631 string_clear (&temp
);
3636 else if (**mangled
== 'Q')
3638 success
= demangle_qualified (work
, mangled
, &decl
,
3650 string_prepend (&decl
, "(");
3658 type_quals
|= code_for_qualifier (**mangled
);
3666 if (*(*mangled
)++ != 'F')
3672 if ((member
&& !demangle_nested_args (work
, mangled
, &decl
))
3673 || **mangled
!= '_')
3679 if (! PRINT_ANSI_QUALIFIERS
)
3683 if (type_quals
!= TYPE_UNQUALIFIED
)
3685 APPEND_BLANK (&decl
);
3686 string_append (&decl
, qualifier_string (type_quals
));
3697 if (PRINT_ANSI_QUALIFIERS
)
3699 if (!STRING_EMPTY (&decl
))
3700 string_prepend (&decl
, " ");
3702 string_prepend (&decl
, demangle_qualifier (**mangled
));
3717 if (success
) switch (**mangled
)
3719 /* A qualified name, such as "Outer::Inner". */
3723 success
= demangle_qualified (work
, mangled
, result
, 0, 1);
3727 /* A back reference to a previously seen squangled type */
3730 if (!get_count (mangled
, &n
) || n
>= work
-> numb
)
3733 string_append (result
, work
->btypevec
[n
]);
3738 /* A template parm. We substitute the corresponding argument. */
3743 idx
= consume_count_with_underscores (mangled
);
3746 || (work
->tmpl_argvec
&& idx
>= work
->ntmpl_args
)
3747 || consume_count_with_underscores (mangled
) == -1)
3753 if (work
->tmpl_argvec
)
3754 string_append (result
, work
->tmpl_argvec
[idx
]);
3756 string_append_template_idx (result
, idx
);
3763 success
= demangle_fund_type (work
, mangled
, result
);
3765 tk
= (type_kind_t
) success
;
3771 if (!STRING_EMPTY (&decl
))
3773 string_append (result
, " ");
3774 string_appends (result
, &decl
);
3778 string_delete (result
);
3779 string_delete (&decl
);
3782 /* Assume an integral type, if we're not sure. */
3783 return (int) ((tk
== tk_none
) ? tk_integral
: tk
);
3788 /* Given a pointer to a type string that represents a fundamental type
3789 argument (int, long, unsigned int, etc) in TYPE, a pointer to the
3790 string in which the demangled output is being built in RESULT, and
3791 the WORK structure, decode the types and add them to the result.
3796 "Sl" => "signed long"
3797 "CUs" => "const unsigned short"
3799 The value returned is really a type_kind_t. */
3802 demangle_fund_type (work
, mangled
, result
)
3803 struct work_stuff
*work
;
3804 const char **mangled
;
3810 unsigned int dec
= 0;
3812 type_kind_t tk
= tk_integral
;
3814 string_init (&btype
);
3816 /* First pick off any type qualifiers. There can be more than one. */
3825 if (PRINT_ANSI_QUALIFIERS
)
3827 if (!STRING_EMPTY (result
))
3828 string_prepend (result
, " ");
3829 string_prepend (result
, demangle_qualifier (**mangled
));
3835 APPEND_BLANK (result
);
3836 string_append (result
, "unsigned");
3838 case 'S': /* signed char only */
3840 APPEND_BLANK (result
);
3841 string_append (result
, "signed");
3845 APPEND_BLANK (result
);
3846 string_append (result
, "__complex");
3854 /* Now pick off the fundamental type. There can be only one. */
3863 APPEND_BLANK (result
);
3864 string_append (result
, "void");
3868 APPEND_BLANK (result
);
3869 string_append (result
, "long long");
3873 APPEND_BLANK (result
);
3874 string_append (result
, "long");
3878 APPEND_BLANK (result
);
3879 string_append (result
, "int");
3883 APPEND_BLANK (result
);
3884 string_append (result
, "short");
3888 APPEND_BLANK (result
);
3889 string_append (result
, "bool");
3894 APPEND_BLANK (result
);
3895 string_append (result
, "char");
3900 APPEND_BLANK (result
);
3901 string_append (result
, "wchar_t");
3906 APPEND_BLANK (result
);
3907 string_append (result
, "long double");
3912 APPEND_BLANK (result
);
3913 string_append (result
, "double");
3918 APPEND_BLANK (result
);
3919 string_append (result
, "float");
3924 if (!ISDIGIT ((unsigned char)**mangled
))
3931 if (**mangled
== '_')
3936 i
< (long) sizeof (buf
) - 1 && **mangled
&& **mangled
!= '_';
3939 if (**mangled
!= '_')
3949 strncpy (buf
, *mangled
, 2);
3951 *mangled
+= min (strlen (*mangled
), 2);
3953 sscanf (buf
, "%x", &dec
);
3954 sprintf (buf
, "int%u_t", dec
);
3955 APPEND_BLANK (result
);
3956 string_append (result
, buf
);
3960 /* An explicit type, such as "6mytype" or "7integer" */
3972 int bindex
= register_Btype (work
);
3974 string_init (&btype
);
3975 if (demangle_class_name (work
, mangled
, &btype
)) {
3976 remember_Btype (work
, btype
.b
, LEN_STRING (&btype
), bindex
);
3977 APPEND_BLANK (result
);
3978 string_appends (result
, &btype
);
3982 string_delete (&btype
);
3987 success
= demangle_template (work
, mangled
, &btype
, 0, 1, 1);
3988 string_appends (result
, &btype
);
3996 return success
? ((int) tk
) : 0;
4000 /* Handle a template's value parameter for HP aCC (extension from ARM)
4001 **mangled points to 'S' or 'U' */
4004 do_hpacc_template_const_value (work
, mangled
, result
)
4005 struct work_stuff
*work ATTRIBUTE_UNUSED
;
4006 const char **mangled
;
4011 if (**mangled
!= 'U' && **mangled
!= 'S')
4014 unsigned_const
= (**mangled
== 'U');
4021 string_append (result
, "-");
4027 /* special case for -2^31 */
4028 string_append (result
, "-2147483648");
4035 /* We have to be looking at an integer now */
4036 if (!(ISDIGIT ((unsigned char)**mangled
)))
4039 /* We only deal with integral values for template
4040 parameters -- so it's OK to look only for digits */
4041 while (ISDIGIT ((unsigned char)**mangled
))
4043 char_str
[0] = **mangled
;
4044 string_append (result
, char_str
);
4049 string_append (result
, "U");
4051 /* FIXME? Some day we may have 64-bit (or larger :-) ) constants
4052 with L or LL suffixes. pai/1997-09-03 */
4054 return 1; /* success */
4057 /* Handle a template's literal parameter for HP aCC (extension from ARM)
4058 **mangled is pointing to the 'A' */
4061 do_hpacc_template_literal (work
, mangled
, result
)
4062 struct work_stuff
*work
;
4063 const char **mangled
;
4066 int literal_len
= 0;
4070 if (**mangled
!= 'A')
4075 literal_len
= consume_count (mangled
);
4077 if (literal_len
<= 0)
4080 /* Literal parameters are names of arrays, functions, etc. and the
4081 canonical representation uses the address operator */
4082 string_append (result
, "&");
4084 /* Now recursively demangle the literal name */
4085 recurse
= (char *) xmalloc (literal_len
+ 1);
4086 memcpy (recurse
, *mangled
, literal_len
);
4087 recurse
[literal_len
] = '\000';
4089 recurse_dem
= cplus_demangle (recurse
, work
->options
);
4093 string_append (result
, recurse_dem
);
4098 string_appendn (result
, *mangled
, literal_len
);
4100 (*mangled
) += literal_len
;
4107 snarf_numeric_literal (args
, arg
)
4114 string_append (arg
, char_str
);
4117 else if (**args
== '+')
4120 if (!ISDIGIT ((unsigned char)**args
))
4123 while (ISDIGIT ((unsigned char)**args
))
4125 char_str
[0] = **args
;
4126 string_append (arg
, char_str
);
4133 /* Demangle the next argument, given by MANGLED into RESULT, which
4134 *should be an uninitialized* string. It will be initialized here,
4135 and free'd should anything go wrong. */
4138 do_arg (work
, mangled
, result
)
4139 struct work_stuff
*work
;
4140 const char **mangled
;
4143 /* Remember where we started so that we can record the type, for
4144 non-squangling type remembering. */
4145 const char *start
= *mangled
;
4147 string_init (result
);
4149 if (work
->nrepeats
> 0)
4153 if (work
->previous_argument
== 0)
4156 /* We want to reissue the previous type in this argument list. */
4157 string_appends (result
, work
->previous_argument
);
4161 if (**mangled
== 'n')
4163 /* A squangling-style repeat. */
4165 work
->nrepeats
= consume_count(mangled
);
4167 if (work
->nrepeats
<= 0)
4168 /* This was not a repeat count after all. */
4171 if (work
->nrepeats
> 9)
4173 if (**mangled
!= '_')
4174 /* The repeat count should be followed by an '_' in this
4181 /* Now, the repeat is all set up. */
4182 return do_arg (work
, mangled
, result
);
4185 /* Save the result in WORK->previous_argument so that we can find it
4186 if it's repeated. Note that saving START is not good enough: we
4187 do not want to add additional types to the back-referenceable
4188 type vector when processing a repeated type. */
4189 if (work
->previous_argument
)
4190 string_clear (work
->previous_argument
);
4193 work
->previous_argument
= (string
*) xmalloc (sizeof (string
));
4194 string_init (work
->previous_argument
);
4197 if (!do_type (work
, mangled
, work
->previous_argument
))
4200 string_appends (result
, work
->previous_argument
);
4202 remember_type (work
, start
, *mangled
- start
);
4207 remember_type (work
, start
, len
)
4208 struct work_stuff
*work
;
4214 if (work
->forgetting_types
)
4217 if (work
-> ntypes
>= work
-> typevec_size
)
4219 if (work
-> typevec_size
== 0)
4221 work
-> typevec_size
= 3;
4223 = (char **) xmalloc (sizeof (char *) * work
-> typevec_size
);
4227 work
-> typevec_size
*= 2;
4229 = (char **) xrealloc ((char *)work
-> typevec
,
4230 sizeof (char *) * work
-> typevec_size
);
4233 tem
= xmalloc (len
+ 1);
4234 memcpy (tem
, start
, len
);
4236 work
-> typevec
[work
-> ntypes
++] = tem
;
4240 /* Remember a K type class qualifier. */
4242 remember_Ktype (work
, start
, len
)
4243 struct work_stuff
*work
;
4249 if (work
-> numk
>= work
-> ksize
)
4251 if (work
-> ksize
== 0)
4255 = (char **) xmalloc (sizeof (char *) * work
-> ksize
);
4261 = (char **) xrealloc ((char *)work
-> ktypevec
,
4262 sizeof (char *) * work
-> ksize
);
4265 tem
= xmalloc (len
+ 1);
4266 memcpy (tem
, start
, len
);
4268 work
-> ktypevec
[work
-> numk
++] = tem
;
4271 /* Register a B code, and get an index for it. B codes are registered
4272 as they are seen, rather than as they are completed, so map<temp<char> >
4273 registers map<temp<char> > as B0, and temp<char> as B1 */
4276 register_Btype (work
)
4277 struct work_stuff
*work
;
4281 if (work
-> numb
>= work
-> bsize
)
4283 if (work
-> bsize
== 0)
4287 = (char **) xmalloc (sizeof (char *) * work
-> bsize
);
4293 = (char **) xrealloc ((char *)work
-> btypevec
,
4294 sizeof (char *) * work
-> bsize
);
4297 ret
= work
-> numb
++;
4298 work
-> btypevec
[ret
] = NULL
;
4302 /* Store a value into a previously registered B code type. */
4305 remember_Btype (work
, start
, len
, index
)
4306 struct work_stuff
*work
;
4312 tem
= xmalloc (len
+ 1);
4313 memcpy (tem
, start
, len
);
4315 work
-> btypevec
[index
] = tem
;
4318 /* Lose all the info related to B and K type codes. */
4320 forget_B_and_K_types (work
)
4321 struct work_stuff
*work
;
4325 while (work
-> numk
> 0)
4327 i
= --(work
-> numk
);
4328 if (work
-> ktypevec
[i
] != NULL
)
4330 free (work
-> ktypevec
[i
]);
4331 work
-> ktypevec
[i
] = NULL
;
4335 while (work
-> numb
> 0)
4337 i
= --(work
-> numb
);
4338 if (work
-> btypevec
[i
] != NULL
)
4340 free (work
-> btypevec
[i
]);
4341 work
-> btypevec
[i
] = NULL
;
4345 /* Forget the remembered types, but not the type vector itself. */
4349 struct work_stuff
*work
;
4353 while (work
-> ntypes
> 0)
4355 i
= --(work
-> ntypes
);
4356 if (work
-> typevec
[i
] != NULL
)
4358 free (work
-> typevec
[i
]);
4359 work
-> typevec
[i
] = NULL
;
4364 /* Process the argument list part of the signature, after any class spec
4365 has been consumed, as well as the first 'F' character (if any). For
4368 "__als__3fooRT0" => process "RT0"
4369 "complexfunc5__FPFPc_PFl_i" => process "PFPc_PFl_i"
4371 DECLP must be already initialised, usually non-empty. It won't be freed
4374 Note that g++ differs significantly from ARM and lucid style mangling
4375 with regards to references to previously seen types. For example, given
4376 the source fragment:
4380 foo::foo (int, foo &ia, int, foo &ib, int, foo &ic);
4383 foo::foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
4384 void foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
4386 g++ produces the names:
4391 while lcc (and presumably other ARM style compilers as well) produces:
4393 foo__FiR3fooT1T2T1T2
4394 __ct__3fooFiR3fooT1T2T1T2
4396 Note that g++ bases its type numbers starting at zero and counts all
4397 previously seen types, while lucid/ARM bases its type numbers starting
4398 at one and only considers types after it has seen the 'F' character
4399 indicating the start of the function args. For lucid/ARM style, we
4400 account for this difference by discarding any previously seen types when
4401 we see the 'F' character, and subtracting one from the type number
4407 demangle_args (work
, mangled
, declp
)
4408 struct work_stuff
*work
;
4409 const char **mangled
;
4419 if (PRINT_ARG_TYPES
)
4421 string_append (declp
, "(");
4422 if (**mangled
== '\0')
4424 string_append (declp
, "void");
4428 while ((**mangled
!= '_' && **mangled
!= '\0' && **mangled
!= 'e')
4429 || work
->nrepeats
> 0)
4431 if ((**mangled
== 'N') || (**mangled
== 'T'))
4433 temptype
= *(*mangled
)++;
4435 if (temptype
== 'N')
4437 if (!get_count (mangled
, &r
))
4446 if ((HP_DEMANGLING
|| ARM_DEMANGLING
|| EDG_DEMANGLING
) && work
-> ntypes
>= 10)
4448 /* If we have 10 or more types we might have more than a 1 digit
4449 index so we'll have to consume the whole count here. This
4450 will lose if the next thing is a type name preceded by a
4451 count but it's impossible to demangle that case properly
4452 anyway. Eg if we already have 12 types is T12Pc "(..., type1,
4453 Pc, ...)" or "(..., type12, char *, ...)" */
4454 if ((t
= consume_count(mangled
)) <= 0)
4461 if (!get_count (mangled
, &t
))
4466 if (LUCID_DEMANGLING
|| ARM_DEMANGLING
|| HP_DEMANGLING
|| EDG_DEMANGLING
)
4470 /* Validate the type index. Protect against illegal indices from
4471 malformed type strings. */
4472 if ((t
< 0) || (t
>= work
-> ntypes
))
4476 while (work
->nrepeats
> 0 || --r
>= 0)
4478 tem
= work
-> typevec
[t
];
4479 if (need_comma
&& PRINT_ARG_TYPES
)
4481 string_append (declp
, ", ");
4483 if (!do_arg (work
, &tem
, &arg
))
4487 if (PRINT_ARG_TYPES
)
4489 string_appends (declp
, &arg
);
4491 string_delete (&arg
);
4497 if (need_comma
&& PRINT_ARG_TYPES
)
4498 string_append (declp
, ", ");
4499 if (!do_arg (work
, mangled
, &arg
))
4501 if (PRINT_ARG_TYPES
)
4502 string_appends (declp
, &arg
);
4503 string_delete (&arg
);
4508 if (**mangled
== 'e')
4511 if (PRINT_ARG_TYPES
)
4515 string_append (declp
, ",");
4517 string_append (declp
, "...");
4521 if (PRINT_ARG_TYPES
)
4523 string_append (declp
, ")");
4528 /* Like demangle_args, but for demangling the argument lists of function
4529 and method pointers or references, not top-level declarations. */
4532 demangle_nested_args (work
, mangled
, declp
)
4533 struct work_stuff
*work
;
4534 const char **mangled
;
4537 string
* saved_previous_argument
;
4541 /* The G++ name-mangling algorithm does not remember types on nested
4542 argument lists, unless -fsquangling is used, and in that case the
4543 type vector updated by remember_type is not used. So, we turn
4544 off remembering of types here. */
4545 ++work
->forgetting_types
;
4547 /* For the repeat codes used with -fsquangling, we must keep track of
4548 the last argument. */
4549 saved_previous_argument
= work
->previous_argument
;
4550 saved_nrepeats
= work
->nrepeats
;
4551 work
->previous_argument
= 0;
4554 /* Actually demangle the arguments. */
4555 result
= demangle_args (work
, mangled
, declp
);
4557 /* Restore the previous_argument field. */
4558 if (work
->previous_argument
)
4559 string_delete (work
->previous_argument
);
4560 work
->previous_argument
= saved_previous_argument
;
4561 --work
->forgetting_types
;
4562 work
->nrepeats
= saved_nrepeats
;
4568 demangle_function_name (work
, mangled
, declp
, scan
)
4569 struct work_stuff
*work
;
4570 const char **mangled
;
4578 string_appendn (declp
, (*mangled
), scan
- (*mangled
));
4579 string_need (declp
, 1);
4580 *(declp
-> p
) = '\0';
4582 /* Consume the function name, including the "__" separating the name
4583 from the signature. We are guaranteed that SCAN points to the
4586 (*mangled
) = scan
+ 2;
4587 /* We may be looking at an instantiation of a template function:
4588 foo__Xt1t2_Ft3t4, where t1, t2, ... are template arguments and a
4589 following _F marks the start of the function arguments. Handle
4590 the template arguments first. */
4592 if (HP_DEMANGLING
&& (**mangled
== 'X'))
4594 demangle_arm_hp_template (work
, mangled
, 0, declp
);
4595 /* This leaves MANGLED pointing to the 'F' marking func args */
4598 if (LUCID_DEMANGLING
|| ARM_DEMANGLING
|| HP_DEMANGLING
|| EDG_DEMANGLING
)
4601 /* See if we have an ARM style constructor or destructor operator.
4602 If so, then just record it, clear the decl, and return.
4603 We can't build the actual constructor/destructor decl until later,
4604 when we recover the class name from the signature. */
4606 if (strcmp (declp
-> b
, "__ct") == 0)
4608 work
-> constructor
+= 1;
4609 string_clear (declp
);
4612 else if (strcmp (declp
-> b
, "__dt") == 0)
4614 work
-> destructor
+= 1;
4615 string_clear (declp
);
4620 if (declp
->p
- declp
->b
>= 3
4621 && declp
->b
[0] == 'o'
4622 && declp
->b
[1] == 'p'
4623 && strchr (cplus_markers
, declp
->b
[2]) != NULL
)
4625 /* see if it's an assignment expression */
4626 if (declp
->p
- declp
->b
>= 10 /* op$assign_ */
4627 && memcmp (declp
->b
+ 3, "assign_", 7) == 0)
4629 for (i
= 0; i
< ARRAY_SIZE (optable
); i
++)
4631 int len
= declp
->p
- declp
->b
- 10;
4632 if ((int) strlen (optable
[i
].in
) == len
4633 && memcmp (optable
[i
].in
, declp
->b
+ 10, len
) == 0)
4635 string_clear (declp
);
4636 string_append (declp
, "operator");
4637 string_append (declp
, optable
[i
].out
);
4638 string_append (declp
, "=");
4645 for (i
= 0; i
< ARRAY_SIZE (optable
); i
++)
4647 int len
= declp
->p
- declp
->b
- 3;
4648 if ((int) strlen (optable
[i
].in
) == len
4649 && memcmp (optable
[i
].in
, declp
->b
+ 3, len
) == 0)
4651 string_clear (declp
);
4652 string_append (declp
, "operator");
4653 string_append (declp
, optable
[i
].out
);
4659 else if (declp
->p
- declp
->b
>= 5 && memcmp (declp
->b
, "type", 4) == 0
4660 && strchr (cplus_markers
, declp
->b
[4]) != NULL
)
4662 /* type conversion operator */
4664 if (do_type (work
, &tem
, &type
))
4666 string_clear (declp
);
4667 string_append (declp
, "operator ");
4668 string_appends (declp
, &type
);
4669 string_delete (&type
);
4672 else if (declp
->b
[0] == '_' && declp
->b
[1] == '_'
4673 && declp
->b
[2] == 'o' && declp
->b
[3] == 'p')
4676 /* type conversion operator. */
4678 if (do_type (work
, &tem
, &type
))
4680 string_clear (declp
);
4681 string_append (declp
, "operator ");
4682 string_appends (declp
, &type
);
4683 string_delete (&type
);
4686 else if (declp
->b
[0] == '_' && declp
->b
[1] == '_'
4687 && ISLOWER((unsigned char)declp
->b
[2])
4688 && ISLOWER((unsigned char)declp
->b
[3]))
4690 if (declp
->b
[4] == '\0')
4693 for (i
= 0; i
< ARRAY_SIZE (optable
); i
++)
4695 if (strlen (optable
[i
].in
) == 2
4696 && memcmp (optable
[i
].in
, declp
->b
+ 2, 2) == 0)
4698 string_clear (declp
);
4699 string_append (declp
, "operator");
4700 string_append (declp
, optable
[i
].out
);
4707 if (declp
->b
[2] == 'a' && declp
->b
[5] == '\0')
4710 for (i
= 0; i
< ARRAY_SIZE (optable
); i
++)
4712 if (strlen (optable
[i
].in
) == 3
4713 && memcmp (optable
[i
].in
, declp
->b
+ 2, 3) == 0)
4715 string_clear (declp
);
4716 string_append (declp
, "operator");
4717 string_append (declp
, optable
[i
].out
);
4726 /* a mini string-handling package */
4741 s
->p
= s
->b
= xmalloc (n
);
4744 else if (s
->e
- s
->p
< n
)
4749 s
->b
= xrealloc (s
->b
, n
);
4762 s
->b
= s
->e
= s
->p
= NULL
;
4770 s
->b
= s
->p
= s
->e
= NULL
;
4786 return (s
->b
== s
->p
);
4792 string_append (p
, s
)
4797 if (s
== NULL
|| *s
== '\0')
4801 memcpy (p
->p
, s
, n
);
4806 string_appends (p
, s
)
4815 memcpy (p
->p
, s
->b
, n
);
4821 string_appendn (p
, s
, n
)
4829 memcpy (p
->p
, s
, n
);
4835 string_prepend (p
, s
)
4839 if (s
!= NULL
&& *s
!= '\0')
4841 string_prependn (p
, s
, strlen (s
));
4846 string_prepends (p
, s
)
4851 string_prependn (p
, s
->b
, s
->p
- s
->b
);
4856 string_prependn (p
, s
, n
)
4866 for (q
= p
->p
- 1; q
>= p
->b
; q
--)
4870 memcpy (p
->b
, s
, n
);
4876 string_append_template_idx (s
, idx
)
4880 char buf
[INTBUF_SIZE
+ 1 /* 'T' */];
4881 sprintf(buf
, "T%d", idx
);
4882 string_append (s
, buf
);
4885 /* To generate a standalone demangler program for testing purposes,
4886 just compile and link this file with -DMAIN and libiberty.a. When
4887 run, it demangles each command line arg, or each stdin string, and
4888 prints the result on stdout. */
4894 static const char *program_name
;
4895 static const char *program_version
= VERSION
;
4896 static int flags
= DMGL_PARAMS
| DMGL_ANSI
;
4898 static void demangle_it
PARAMS ((char *));
4899 static void usage
PARAMS ((FILE *, int)) ATTRIBUTE_NORETURN
;
4900 static void fatal
PARAMS ((const char *)) ATTRIBUTE_NORETURN
;
4901 static void print_demangler_list
PARAMS ((FILE *));
4904 demangle_it (mangled_name
)
4909 result
= cplus_demangle (mangled_name
, flags
);
4912 printf ("%s\n", mangled_name
);
4916 printf ("%s\n", result
);
4922 print_demangler_list (stream
)
4925 const struct demangler_engine
*demangler
;
4927 fprintf (stream
, "{%s", libiberty_demanglers
->demangling_style_name
);
4929 for (demangler
= libiberty_demanglers
+ 1;
4930 demangler
->demangling_style
!= unknown_demangling
;
4932 fprintf (stream
, ",%s", demangler
->demangling_style_name
);
4934 fprintf (stream
, "}");
4938 usage (stream
, status
)
4943 Usage: %s [-_] [-n] [--strip-underscores] [--no-strip-underscores] \n",
4948 print_demangler_list (stream
);
4949 fprintf (stream
, "]\n");
4953 print_demangler_list (stream
);
4954 fprintf (stream
, "]\n");
4957 [--help] [--version] [arg...]\n");
4961 #define MBUF_SIZE 32767
4962 char mbuffer
[MBUF_SIZE
];
4964 /* Defined in the automatically-generated underscore.c. */
4965 extern int prepends_underscore
;
4967 int strip_underscore
= 0;
4969 static struct option long_options
[] = {
4970 {"strip-underscores", no_argument
, 0, '_'},
4971 {"format", required_argument
, 0, 's'},
4972 {"help", no_argument
, 0, 'h'},
4973 {"no-strip-underscores", no_argument
, 0, 'n'},
4974 {"version", no_argument
, 0, 'v'},
4975 {0, no_argument
, 0, 0}
4978 /* More 'friendly' abort that prints the line and file.
4979 config.h can #define abort fancy_abort if you like that sort of thing. */
4984 fatal ("Internal gcc abort.");
4989 standard_symbol_characters
PARAMS ((void));
4992 hp_symbol_characters
PARAMS ((void));
4995 gnu_v3_symbol_characters
PARAMS ((void));
4997 /* Return the string of non-alnum characters that may occur
4998 as a valid symbol component, in the standard assembler symbol
5002 standard_symbol_characters ()
5008 /* Return the string of non-alnum characters that may occur
5009 as a valid symbol name component in an HP object file.
5011 Note that, since HP's compiler generates object code straight from
5012 C++ source, without going through an assembler, its mangled
5013 identifiers can use all sorts of characters that no assembler would
5014 tolerate, so the alphabet this function creates is a little odd.
5015 Here are some sample mangled identifiers offered by HP:
5017 typeid*__XT24AddressIndExpClassMember_
5018 [Vftptr]key:__dt__32OrdinaryCompareIndExpClassMemberFv
5019 __ct__Q2_9Elf64_Dyn18{unnamed.union.#1}Fv
5021 This still seems really weird to me, since nowhere else in this
5022 file is there anything to recognize curly brackets, parens, etc.
5023 I've talked with Srikanth <srikanth@cup.hp.com>, and he assures me
5024 this is right, but I still strongly suspect that there's a
5025 misunderstanding here.
5027 If we decide it's better for c++filt to use HP's assembler syntax
5028 to scrape identifiers out of its input, here's the definition of
5029 the symbol name syntax from the HP assembler manual:
5031 Symbols are composed of uppercase and lowercase letters, decimal
5032 digits, dollar symbol, period (.), ampersand (&), pound sign(#) and
5033 underscore (_). A symbol can begin with a letter, digit underscore or
5034 dollar sign. If a symbol begins with a digit, it must contain a
5035 non-digit character.
5039 hp_symbol_characters ()
5041 return "_$.<>#,*&[]:(){}";
5045 /* Return the string of non-alnum characters that may occur
5046 as a valid symbol component in the GNU C++ V3 ABI mangling
5050 gnu_v3_symbol_characters ()
5056 extern int main
PARAMS ((int, char **));
5065 const char *valid_symbols
;
5066 enum demangling_styles style
= auto_demangling
;
5068 program_name
= argv
[0];
5070 strip_underscore
= prepends_underscore
;
5072 while ((c
= getopt_long (argc
, argv
, "_ns:", long_options
, (int *) 0)) != EOF
)
5082 strip_underscore
= 0;
5085 printf ("GNU %s (C++ demangler), version %s\n", program_name
, program_version
);
5088 strip_underscore
= 1;
5092 style
= cplus_demangle_name_to_style (optarg
);
5093 if (style
== unknown_demangling
)
5095 fprintf (stderr
, "%s: unknown demangling style `%s'\n",
5096 program_name
, optarg
);
5100 cplus_demangle_set_style (style
);
5108 for ( ; optind
< argc
; optind
++)
5110 demangle_it (argv
[optind
]);
5115 switch (current_demangling_style
)
5117 case gnu_demangling
:
5118 case lucid_demangling
:
5119 case arm_demangling
:
5120 case java_demangling
:
5121 case edg_demangling
:
5122 case gnat_demangling
:
5123 case auto_demangling
:
5124 valid_symbols
= standard_symbol_characters ();
5127 valid_symbols
= hp_symbol_characters ();
5129 case gnu_v3_demangling
:
5130 valid_symbols
= gnu_v3_symbol_characters ();
5133 /* Folks should explicitly indicate the appropriate alphabet for
5134 each demangling. Providing a default would allow the
5135 question to go unconsidered. */
5143 /* Try to read a label. */
5144 while (c
!= EOF
&& (ISALNUM (c
) || strchr (valid_symbols
, c
)))
5146 if (i
>= MBUF_SIZE
-1)
5155 if (mbuffer
[0] == '.' || mbuffer
[0] == '$')
5157 if (strip_underscore
&& mbuffer
[skip_first
] == '_')
5164 flags
|= (int) style
;
5165 result
= cplus_demangle (mbuffer
+ skip_first
, flags
);
5168 if (mbuffer
[0] == '.')
5170 fputs (result
, stdout
);
5174 fputs (mbuffer
, stdout
);
5192 fprintf (stderr
, "%s: %s\n", program_name
, str
);
5200 register PTR value
= (PTR
) malloc (size
);
5202 fatal ("virtual memory exhausted");
5207 xrealloc (ptr
, size
)
5211 register PTR value
= (PTR
) realloc (ptr
, size
);
5213 fatal ("virtual memory exhausted");