* demangle.h (no_demangling): New.
[official-gcc.git] / libiberty / cplus-dem.c
bloba35ff14624e65d58e949c6bb2e8982bbb952e8b5
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
28 available memory. */
30 /* This file lives in both GCC and libiberty. When making changes, please
31 try not to break either. */
33 #ifdef HAVE_CONFIG_H
34 #include "config.h"
35 #endif
37 #include "safe-ctype.h"
39 #include <sys/types.h>
40 #include <string.h>
41 #include <stdio.h>
43 #ifdef HAVE_STDLIB_H
44 #include <stdlib.h>
45 #else
46 char * malloc ();
47 char * realloc ();
48 #endif
50 #include <demangle.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 *));
68 static const char *
69 mystrstr (s1, s2)
70 const char *s1, *s2;
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)
79 return (p);
82 return (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 '$'
103 #endif
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' };
111 void
112 set_cplus_marker_for_demangling (ch)
113 int 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 */
123 } string;
125 /* Stuff that is shared between sub-routines.
126 Using a shared structure allows cplus_demangle to be reentrant. */
128 struct work_stuff
130 int options;
131 char **typevec;
132 char **ktypevec;
133 char **btypevec;
134 int numk;
135 int numb;
136 int ksize;
137 int bsize;
138 int ntypes;
139 int typevec_size;
140 int constructor;
141 int destructor;
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
149 we see. */
150 string* previous_argument; /* The last function argument demangled. */
151 int nrepeats; /* The number of times to repeat the previous
152 argument. */
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;
162 const int flags;
163 } optable[] = {
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'
247 values. */
248 typedef enum type_kind_t
250 tk_none,
251 tk_pointer,
252 tk_reference,
253 tk_integral,
254 tk_bool,
255 tk_char,
256 tk_real
257 } type_kind_t;
259 const struct demangler_engine libiberty_demanglers[] =
262 NO_DEMANGLING_STYLE_STRING,
263 no_demangling,
264 "Demangling disabled"
268 AUTO_DEMANGLING_STYLE_STRING,
269 auto_demangling,
270 "Automatic selection based on executable"
274 GNU_DEMANGLING_STYLE_STRING,
275 gnu_demangling,
276 "GNU (g++) style demangling"
280 LUCID_DEMANGLING_STYLE_STRING,
281 lucid_demangling,
282 "Lucid (lcc) style demangling"
286 ARM_DEMANGLING_STYLE_STRING,
287 arm_demangling,
288 "ARM style demangling"
292 HP_DEMANGLING_STYLE_STRING,
293 hp_demangling,
294 "HP (aCC) style demangling"
298 EDG_DEMANGLING_STYLE_STRING,
299 edg_demangling,
300 "EDG style demangling"
304 GNU_V3_DEMANGLING_STYLE_STRING,
305 gnu_v3_demangling,
306 "GNU (g++) V3 ABI-style demangling"
310 JAVA_DEMANGLING_STYLE_STRING,
311 java_demangling,
312 "Java style demangling"
316 GNAT_DEMANGLING_STYLE_STRING,
317 gnat_demangling,
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 */
342 static void
343 delete_work_stuff PARAMS ((struct work_stuff *));
345 static void
346 delete_non_B_K_work_stuff PARAMS ((struct work_stuff *));
348 static char *
349 mop_up PARAMS ((struct work_stuff *, string *, int));
351 static void
352 squangle_mop_up PARAMS ((struct work_stuff *));
354 static void
355 work_stuff_copy_to_from PARAMS ((struct work_stuff *, struct work_stuff *));
357 #if 0
358 static int
359 demangle_method_args PARAMS ((struct work_stuff *, const char **, string *));
360 #endif
362 static char *
363 internal_cplus_demangle PARAMS ((struct work_stuff *, const char *));
365 static int
366 demangle_template_template_parm PARAMS ((struct work_stuff *work,
367 const char **, string *));
369 static int
370 demangle_template PARAMS ((struct work_stuff *work, const char **, string *,
371 string *, int, int));
373 static int
374 arm_pt PARAMS ((struct work_stuff *, const char *, int, const char **,
375 const char **));
377 static int
378 demangle_class_name PARAMS ((struct work_stuff *, const char **, string *));
380 static int
381 demangle_qualified PARAMS ((struct work_stuff *, const char **, string *,
382 int, int));
384 static int
385 demangle_class PARAMS ((struct work_stuff *, const char **, string *));
387 static int
388 demangle_fund_type PARAMS ((struct work_stuff *, const char **, string *));
390 static int
391 demangle_signature PARAMS ((struct work_stuff *, const char **, string *));
393 static int
394 demangle_prefix PARAMS ((struct work_stuff *, const char **, string *));
396 static int
397 gnu_special PARAMS ((struct work_stuff *, const char **, string *));
399 static int
400 arm_special PARAMS ((const char **, string *));
402 static void
403 string_need PARAMS ((string *, int));
405 static void
406 string_delete PARAMS ((string *));
408 static void
409 string_init PARAMS ((string *));
411 static void
412 string_clear PARAMS ((string *));
414 #if 0
415 static int
416 string_empty PARAMS ((string *));
417 #endif
419 static void
420 string_append PARAMS ((string *, const char *));
422 static void
423 string_appends PARAMS ((string *, string *));
425 static void
426 string_appendn PARAMS ((string *, const char *, int));
428 static void
429 string_prepend PARAMS ((string *, const char *));
431 static void
432 string_prependn PARAMS ((string *, const char *, int));
434 static void
435 string_append_template_idx PARAMS ((string *, int));
437 static int
438 get_count PARAMS ((const char **, int *));
440 static int
441 consume_count PARAMS ((const char **));
443 static int
444 consume_count_with_underscores PARAMS ((const char**));
446 static int
447 demangle_args PARAMS ((struct work_stuff *, const char **, string *));
449 static int
450 demangle_nested_args PARAMS ((struct work_stuff*, const char**, string*));
452 static int
453 do_type PARAMS ((struct work_stuff *, const char **, string *));
455 static int
456 do_arg PARAMS ((struct work_stuff *, const char **, string *));
458 static void
459 demangle_function_name PARAMS ((struct work_stuff *, const char **, string *,
460 const char *));
462 static int
463 iterate_demangle_function PARAMS ((struct work_stuff *,
464 const char **, string *, const char *));
466 static void
467 remember_type PARAMS ((struct work_stuff *, const char *, int));
469 static void
470 remember_Btype PARAMS ((struct work_stuff *, const char *, int, int));
472 static int
473 register_Btype PARAMS ((struct work_stuff *));
475 static void
476 remember_Ktype PARAMS ((struct work_stuff *, const char *, int));
478 static void
479 forget_types PARAMS ((struct work_stuff *));
481 static void
482 forget_B_and_K_types PARAMS ((struct work_stuff *));
484 static void
485 string_prepends PARAMS ((string *, string *));
487 static int
488 demangle_template_value_parm PARAMS ((struct work_stuff*, const char**,
489 string*, type_kind_t));
491 static int
492 do_hpacc_template_const_value PARAMS ((struct work_stuff *, const char **, string *));
494 static int
495 do_hpacc_template_literal PARAMS ((struct work_stuff *, const char **, string *));
497 static int
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
502 type. */
504 #define TYPE_UNQUALIFIED 0x0
505 #define TYPE_QUAL_CONST 0x1
506 #define TYPE_QUAL_VOLATILE 0x2
507 #define TYPE_QUAL_RESTRICT 0x4
509 static int
510 code_for_qualifier PARAMS ((int));
512 static const char*
513 qualifier_string PARAMS ((int));
515 static const char*
516 demangle_qualifier PARAMS ((int));
518 static int
519 demangle_expression PARAMS ((struct work_stuff *, const char **, string *,
520 type_kind_t));
522 static int
523 demangle_integral_value PARAMS ((struct work_stuff *, const char **,
524 string *));
526 static int
527 demangle_real_value PARAMS ((struct work_stuff *, const char **, string *));
529 static void
530 demangle_arm_hp_template PARAMS ((struct work_stuff *, const char **, int,
531 string *));
533 static void
534 recursively_demangle PARAMS ((struct work_stuff *, const char **, string *,
535 int));
537 static void
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. */
548 static int
549 consume_count (type)
550 const char **type;
552 int count = 0;
554 if (! ISDIGIT ((unsigned char)**type))
555 return -1;
557 while (ISDIGIT ((unsigned char)**type))
559 count *= 10;
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
565 ten. */
566 if ((count % 10) != 0)
568 while (ISDIGIT ((unsigned char) **type))
569 (*type)++;
570 return -1;
573 count += **type - '0';
574 (*type)++;
577 return (count);
581 /* Like consume_count, but for counts that are preceded and followed
582 by '_' if they are greater than 10. Also, -1 is returned for
583 failure, since 0 can be a valid value. */
585 static int
586 consume_count_with_underscores (mangled)
587 const char **mangled;
589 int idx;
591 if (**mangled == '_')
593 (*mangled)++;
594 if (!ISDIGIT ((unsigned char)**mangled))
595 return -1;
597 idx = consume_count (mangled);
598 if (**mangled != '_')
599 /* The trailing underscore was missing. */
600 return -1;
602 (*mangled)++;
604 else
606 if (**mangled < '0' || **mangled > '9')
607 return -1;
609 idx = **mangled - '0';
610 (*mangled)++;
613 return idx;
616 /* C is the code for a type-qualifier. Return the TYPE_QUAL
617 corresponding to this qualifier. */
619 static int
620 code_for_qualifier (c)
621 int c;
623 switch (c)
625 case 'C':
626 return TYPE_QUAL_CONST;
628 case 'V':
629 return TYPE_QUAL_VOLATILE;
631 case 'u':
632 return TYPE_QUAL_RESTRICT;
634 default:
635 break;
638 /* C was an invalid qualifier. */
639 abort ();
642 /* Return the string corresponding to the qualifiers given by
643 TYPE_QUALS. */
645 static const char*
646 qualifier_string (type_quals)
647 int type_quals;
649 switch (type_quals)
651 case TYPE_UNQUALIFIED:
652 return "";
654 case TYPE_QUAL_CONST:
655 return "const";
657 case TYPE_QUAL_VOLATILE:
658 return "volatile";
660 case TYPE_QUAL_RESTRICT:
661 return "__restrict";
663 case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE:
664 return "const volatile";
666 case TYPE_QUAL_CONST | TYPE_QUAL_RESTRICT:
667 return "const __restrict";
669 case TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT:
670 return "volatile __restrict";
672 case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT:
673 return "const volatile __restrict";
675 default:
676 break;
679 /* TYPE_QUALS was an invalid qualifier set. */
680 abort ();
683 /* C is the code for a type-qualifier. Return the string
684 corresponding to this qualifier. This function should only be
685 called with a valid qualifier code. */
687 static const char*
688 demangle_qualifier (c)
689 int c;
691 return qualifier_string (code_for_qualifier (c));
695 cplus_demangle_opname (opname, result, options)
696 const char *opname;
697 char *result;
698 int options;
700 int len, len1, ret;
701 string type;
702 struct work_stuff work[1];
703 const char *tem;
705 len = strlen(opname);
706 result[0] = '\0';
707 ret = 0;
708 memset ((char *) work, 0, sizeof (work));
709 work->options = options;
711 if (opname[0] == '_' && opname[1] == '_'
712 && opname[2] == 'o' && opname[3] == 'p')
714 /* ANSI. */
715 /* type conversion operator. */
716 tem = opname + 4;
717 if (do_type (work, &tem, &type))
719 strcat (result, "operator ");
720 strncat (result, type.b, type.p - type.b);
721 string_delete (&type);
722 ret = 1;
725 else if (opname[0] == '_' && opname[1] == '_'
726 && ISLOWER((unsigned char)opname[2])
727 && ISLOWER((unsigned char)opname[3]))
729 if (opname[4] == '\0')
731 /* Operator. */
732 size_t i;
733 for (i = 0; i < ARRAY_SIZE (optable); i++)
735 if (strlen (optable[i].in) == 2
736 && memcmp (optable[i].in, opname + 2, 2) == 0)
738 strcat (result, "operator");
739 strcat (result, optable[i].out);
740 ret = 1;
741 break;
745 else
747 if (opname[2] == 'a' && opname[5] == '\0')
749 /* Assignment. */
750 size_t i;
751 for (i = 0; i < ARRAY_SIZE (optable); i++)
753 if (strlen (optable[i].in) == 3
754 && memcmp (optable[i].in, opname + 2, 3) == 0)
756 strcat (result, "operator");
757 strcat (result, optable[i].out);
758 ret = 1;
759 break;
765 else if (len >= 3
766 && opname[0] == 'o'
767 && opname[1] == 'p'
768 && strchr (cplus_markers, opname[2]) != NULL)
770 /* see if it's an assignment expression */
771 if (len >= 10 /* op$assign_ */
772 && memcmp (opname + 3, "assign_", 7) == 0)
774 size_t i;
775 for (i = 0; i < ARRAY_SIZE (optable); i++)
777 len1 = len - 10;
778 if ((int) strlen (optable[i].in) == len1
779 && memcmp (optable[i].in, opname + 10, len1) == 0)
781 strcat (result, "operator");
782 strcat (result, optable[i].out);
783 strcat (result, "=");
784 ret = 1;
785 break;
789 else
791 size_t i;
792 for (i = 0; i < ARRAY_SIZE (optable); i++)
794 len1 = len - 3;
795 if ((int) strlen (optable[i].in) == len1
796 && memcmp (optable[i].in, opname + 3, len1) == 0)
798 strcat (result, "operator");
799 strcat (result, optable[i].out);
800 ret = 1;
801 break;
806 else if (len >= 5 && memcmp (opname, "type", 4) == 0
807 && strchr (cplus_markers, opname[4]) != NULL)
809 /* type conversion operator */
810 tem = opname + 5;
811 if (do_type (work, &tem, &type))
813 strcat (result, "operator ");
814 strncat (result, type.b, type.p - type.b);
815 string_delete (&type);
816 ret = 1;
819 squangle_mop_up (work);
820 return ret;
824 /* Takes operator name as e.g. "++" and returns mangled
825 operator name (e.g. "postincrement_expr"), or NULL if not found.
827 If OPTIONS & DMGL_ANSI == 1, return the ANSI name;
828 if OPTIONS & DMGL_ANSI == 0, return the old GNU name. */
830 const char *
831 cplus_mangle_opname (opname, options)
832 const char *opname;
833 int options;
835 size_t i;
836 int len;
838 len = strlen (opname);
839 for (i = 0; i < ARRAY_SIZE (optable); i++)
841 if ((int) strlen (optable[i].out) == len
842 && (options & DMGL_ANSI) == (optable[i].flags & DMGL_ANSI)
843 && memcmp (optable[i].out, opname, len) == 0)
844 return optable[i].in;
846 return (0);
849 /* Add a routine to set the demangling style to be sure it is valid and
850 allow for any demangler initialization that maybe necessary. */
852 enum demangling_styles
853 cplus_demangle_set_style (style)
854 enum demangling_styles style;
856 const struct demangler_engine *demangler = libiberty_demanglers;
858 for (; demangler->demangling_style != unknown_demangling; ++demangler)
859 if (style == demangler->demangling_style)
861 current_demangling_style = style;
862 return current_demangling_style;
865 return unknown_demangling;
868 /* Do string name to style translation */
870 enum demangling_styles
871 cplus_demangle_name_to_style (name)
872 const char *name;
874 const struct demangler_engine *demangler = libiberty_demanglers;
876 for (; demangler->demangling_style != unknown_demangling; ++demangler)
877 if (strcmp (name, demangler->demangling_style_name) == 0)
878 return demangler->demangling_style;
880 return unknown_demangling;
883 /* char *cplus_demangle (const char *mangled, int options)
885 If MANGLED is a mangled function name produced by GNU C++, then
886 a pointer to a @code{malloc}ed string giving a C++ representation
887 of the name will be returned; otherwise NULL will be returned.
888 It is the caller's responsibility to free the string which
889 is returned.
891 The OPTIONS arg may contain one or more of the following bits:
893 DMGL_ANSI ANSI qualifiers such as `const' and `void' are
894 included.
895 DMGL_PARAMS Function parameters are included.
897 For example,
899 cplus_demangle ("foo__1Ai", DMGL_PARAMS) => "A::foo(int)"
900 cplus_demangle ("foo__1Ai", DMGL_PARAMS | DMGL_ANSI) => "A::foo(int)"
901 cplus_demangle ("foo__1Ai", 0) => "A::foo"
903 cplus_demangle ("foo__1Afe", DMGL_PARAMS) => "A::foo(float,...)"
904 cplus_demangle ("foo__1Afe", DMGL_PARAMS | DMGL_ANSI)=> "A::foo(float,...)"
905 cplus_demangle ("foo__1Afe", 0) => "A::foo"
907 Note that any leading underscores, or other such characters prepended by
908 the compilation system, are presumed to have already been stripped from
909 MANGLED. */
911 char *
912 cplus_demangle (mangled, options)
913 const char *mangled;
914 int options;
916 char *ret;
917 struct work_stuff work[1];
919 if (current_demangling_style == no_demangling)
920 return xstrdup (mangled);
922 memset ((char *) work, 0, sizeof (work));
923 work->options = options;
924 if ((work->options & DMGL_STYLE_MASK) == 0)
925 work->options |= (int) current_demangling_style & DMGL_STYLE_MASK;
927 /* The V3 ABI demangling is implemented elsewhere. */
928 if (GNU_V3_DEMANGLING || AUTO_DEMANGLING)
930 ret = cplus_demangle_v3 (mangled);
931 if (ret || GNU_V3_DEMANGLING)
932 return ret;
935 if (JAVA_DEMANGLING)
937 ret = java_demangle_v3 (mangled);
938 if (ret)
939 return ret;
942 if (GNAT_DEMANGLING)
943 return ada_demangle(mangled,options);
945 ret = internal_cplus_demangle (work, mangled);
946 squangle_mop_up (work);
947 return (ret);
951 /* Assuming *OLD_VECT points to an array of *SIZE objects of size
952 ELEMENT_SIZE, grow it to contain at least MIN_SIZE objects,
953 updating *OLD_VECT and *SIZE as necessary. */
955 static void
956 grow_vect (old_vect, size, min_size, element_size)
957 void **old_vect;
958 size_t *size;
959 size_t min_size;
960 int element_size;
962 if (*size < min_size)
964 *size *= 2;
965 if (*size < min_size)
966 *size = min_size;
967 *old_vect = xrealloc (*old_vect, *size * element_size);
971 /* Demangle ada names:
972 1. Discard final __{DIGIT}+ or ${DIGIT}+
973 2. Convert other instances of embedded "__" to `.'.
974 3. Discard leading _ada_.
975 4. Remove everything after first ___ if it is followed by 'X'.
976 5. Put symbols that should be suppressed in <...> brackets.
977 The resulting string is valid until the next call of ada_demangle. */
979 static char *
980 ada_demangle (mangled, option)
981 const char *mangled;
982 int option ATTRIBUTE_UNUSED;
984 int i, j;
985 int len0;
986 const char* p;
987 char *demangled = NULL;
988 int at_start_name;
989 int changed;
990 char *demangling_buffer = NULL;
991 size_t demangling_buffer_size = 0;
993 changed = 0;
995 if (strncmp (mangled, "_ada_", 5) == 0)
997 mangled += 5;
998 changed = 1;
1001 if (mangled[0] == '_' || mangled[0] == '<')
1002 goto Suppress;
1004 p = strstr (mangled, "___");
1005 if (p == NULL)
1006 len0 = strlen (mangled);
1007 else
1009 if (p[3] == 'X')
1011 len0 = p - mangled;
1012 changed = 1;
1014 else
1015 goto Suppress;
1018 /* Make demangled big enough for possible expansion by operator name. */
1019 grow_vect ((void **) &(demangling_buffer),
1020 &demangling_buffer_size, 2 * len0 + 1,
1021 sizeof (char));
1022 demangled = demangling_buffer;
1024 if (ISDIGIT ((unsigned char) mangled[len0 - 1])) {
1025 for (i = len0 - 2; i >= 0 && ISDIGIT ((unsigned char) mangled[i]); i -= 1)
1027 if (i > 1 && mangled[i] == '_' && mangled[i - 1] == '_')
1029 len0 = i - 1;
1030 changed = 1;
1032 else if (mangled[i] == '$')
1034 len0 = i;
1035 changed = 1;
1039 for (i = 0, j = 0; i < len0 && ! ISALPHA ((unsigned char)mangled[i]);
1040 i += 1, j += 1)
1041 demangled[j] = mangled[i];
1043 at_start_name = 1;
1044 while (i < len0)
1046 at_start_name = 0;
1048 if (i < len0 - 2 && mangled[i] == '_' && mangled[i + 1] == '_')
1050 demangled[j] = '.';
1051 changed = at_start_name = 1;
1052 i += 2; j += 1;
1054 else
1056 demangled[j] = mangled[i];
1057 i += 1; j += 1;
1060 demangled[j] = '\000';
1062 for (i = 0; demangled[i] != '\0'; i += 1)
1063 if (ISUPPER ((unsigned char)demangled[i]) || demangled[i] == ' ')
1064 goto Suppress;
1066 if (! changed)
1067 return NULL;
1068 else
1069 return demangled;
1071 Suppress:
1072 grow_vect ((void **) &(demangling_buffer),
1073 &demangling_buffer_size, strlen (mangled) + 3,
1074 sizeof (char));
1075 demangled = demangling_buffer;
1076 if (mangled[0] == '<')
1077 strcpy (demangled, mangled);
1078 else
1079 sprintf (demangled, "<%s>", mangled);
1081 return demangled;
1084 /* This function performs most of what cplus_demangle use to do, but
1085 to be able to demangle a name with a B, K or n code, we need to
1086 have a longer term memory of what types have been seen. The original
1087 now intializes and cleans up the squangle code info, while internal
1088 calls go directly to this routine to avoid resetting that info. */
1090 static char *
1091 internal_cplus_demangle (work, mangled)
1092 struct work_stuff *work;
1093 const char *mangled;
1096 string decl;
1097 int success = 0;
1098 char *demangled = NULL;
1099 int s1, s2, s3, s4;
1100 s1 = work->constructor;
1101 s2 = work->destructor;
1102 s3 = work->static_type;
1103 s4 = work->type_quals;
1104 work->constructor = work->destructor = 0;
1105 work->type_quals = TYPE_UNQUALIFIED;
1106 work->dllimported = 0;
1108 if ((mangled != NULL) && (*mangled != '\0'))
1110 string_init (&decl);
1112 /* First check to see if gnu style demangling is active and if the
1113 string to be demangled contains a CPLUS_MARKER. If so, attempt to
1114 recognize one of the gnu special forms rather than looking for a
1115 standard prefix. In particular, don't worry about whether there
1116 is a "__" string in the mangled string. Consider "_$_5__foo" for
1117 example. */
1119 if ((AUTO_DEMANGLING || GNU_DEMANGLING))
1121 success = gnu_special (work, &mangled, &decl);
1123 if (!success)
1125 success = demangle_prefix (work, &mangled, &decl);
1127 if (success && (*mangled != '\0'))
1129 success = demangle_signature (work, &mangled, &decl);
1131 if (work->constructor == 2)
1133 string_prepend (&decl, "global constructors keyed to ");
1134 work->constructor = 0;
1136 else if (work->destructor == 2)
1138 string_prepend (&decl, "global destructors keyed to ");
1139 work->destructor = 0;
1141 else if (work->dllimported == 1)
1143 string_prepend (&decl, "import stub for ");
1144 work->dllimported = 0;
1146 demangled = mop_up (work, &decl, success);
1148 work->constructor = s1;
1149 work->destructor = s2;
1150 work->static_type = s3;
1151 work->type_quals = s4;
1152 return demangled;
1156 /* Clear out and squangling related storage */
1157 static void
1158 squangle_mop_up (work)
1159 struct work_stuff *work;
1161 /* clean up the B and K type mangling types. */
1162 forget_B_and_K_types (work);
1163 if (work -> btypevec != NULL)
1165 free ((char *) work -> btypevec);
1167 if (work -> ktypevec != NULL)
1169 free ((char *) work -> ktypevec);
1174 /* Copy the work state and storage. */
1176 static void
1177 work_stuff_copy_to_from (to, from)
1178 struct work_stuff *to;
1179 struct work_stuff *from;
1181 int i;
1183 delete_work_stuff (to);
1185 /* Shallow-copy scalars. */
1186 memcpy (to, from, sizeof (*to));
1188 /* Deep-copy dynamic storage. */
1189 if (from->typevec_size)
1190 to->typevec
1191 = (char **) xmalloc (from->typevec_size * sizeof (to->typevec[0]));
1193 for (i = 0; i < from->ntypes; i++)
1195 int len = strlen (from->typevec[i]) + 1;
1197 to->typevec[i] = xmalloc (len);
1198 memcpy (to->typevec[i], from->typevec[i], len);
1201 if (from->ksize)
1202 to->ktypevec
1203 = (char **) xmalloc (from->ksize * sizeof (to->ktypevec[0]));
1205 for (i = 0; i < from->numk; i++)
1207 int len = strlen (from->ktypevec[i]) + 1;
1209 to->ktypevec[i] = xmalloc (len);
1210 memcpy (to->ktypevec[i], from->ktypevec[i], len);
1213 if (from->bsize)
1214 to->btypevec
1215 = (char **) xmalloc (from->bsize * sizeof (to->btypevec[0]));
1217 for (i = 0; i < from->numb; i++)
1219 int len = strlen (from->btypevec[i]) + 1;
1221 to->btypevec[i] = xmalloc (len);
1222 memcpy (to->btypevec[i], from->btypevec[i], len);
1225 if (from->ntmpl_args)
1226 to->tmpl_argvec
1227 = xmalloc (from->ntmpl_args * sizeof (to->tmpl_argvec[0]));
1229 for (i = 0; i < from->ntmpl_args; i++)
1231 int len = strlen (from->tmpl_argvec[i]) + 1;
1233 to->tmpl_argvec[i] = xmalloc (len);
1234 memcpy (to->tmpl_argvec[i], from->tmpl_argvec[i], len);
1237 if (from->previous_argument)
1239 to->previous_argument = (string*) xmalloc (sizeof (string));
1240 string_init (to->previous_argument);
1241 string_appends (to->previous_argument, from->previous_argument);
1246 /* Delete dynamic stuff in work_stuff that is not to be re-used. */
1248 static void
1249 delete_non_B_K_work_stuff (work)
1250 struct work_stuff *work;
1252 /* Discard the remembered types, if any. */
1254 forget_types (work);
1255 if (work -> typevec != NULL)
1257 free ((char *) work -> typevec);
1258 work -> typevec = NULL;
1259 work -> typevec_size = 0;
1261 if (work->tmpl_argvec)
1263 int i;
1265 for (i = 0; i < work->ntmpl_args; i++)
1266 if (work->tmpl_argvec[i])
1267 free ((char*) work->tmpl_argvec[i]);
1269 free ((char*) work->tmpl_argvec);
1270 work->tmpl_argvec = NULL;
1272 if (work->previous_argument)
1274 string_delete (work->previous_argument);
1275 free ((char*) work->previous_argument);
1276 work->previous_argument = NULL;
1281 /* Delete all dynamic storage in work_stuff. */
1282 static void
1283 delete_work_stuff (work)
1284 struct work_stuff *work;
1286 delete_non_B_K_work_stuff (work);
1287 squangle_mop_up (work);
1291 /* Clear out any mangled storage */
1293 static char *
1294 mop_up (work, declp, success)
1295 struct work_stuff *work;
1296 string *declp;
1297 int success;
1299 char *demangled = NULL;
1301 delete_non_B_K_work_stuff (work);
1303 /* If demangling was successful, ensure that the demangled string is null
1304 terminated and return it. Otherwise, free the demangling decl. */
1306 if (!success)
1308 string_delete (declp);
1310 else
1312 string_appendn (declp, "", 1);
1313 demangled = declp->b;
1315 return (demangled);
1320 LOCAL FUNCTION
1322 demangle_signature -- demangle the signature part of a mangled name
1324 SYNOPSIS
1326 static int
1327 demangle_signature (struct work_stuff *work, const char **mangled,
1328 string *declp);
1330 DESCRIPTION
1332 Consume and demangle the signature portion of the mangled name.
1334 DECLP is the string where demangled output is being built. At
1335 entry it contains the demangled root name from the mangled name
1336 prefix. I.E. either a demangled operator name or the root function
1337 name. In some special cases, it may contain nothing.
1339 *MANGLED points to the current unconsumed location in the mangled
1340 name. As tokens are consumed and demangling is performed, the
1341 pointer is updated to continuously point at the next token to
1342 be consumed.
1344 Demangling GNU style mangled names is nasty because there is no
1345 explicit token that marks the start of the outermost function
1346 argument list. */
1348 static int
1349 demangle_signature (work, mangled, declp)
1350 struct work_stuff *work;
1351 const char **mangled;
1352 string *declp;
1354 int success = 1;
1355 int func_done = 0;
1356 int expect_func = 0;
1357 int expect_return_type = 0;
1358 const char *oldmangled = NULL;
1359 string trawname;
1360 string tname;
1362 while (success && (**mangled != '\0'))
1364 switch (**mangled)
1366 case 'Q':
1367 oldmangled = *mangled;
1368 success = demangle_qualified (work, mangled, declp, 1, 0);
1369 if (success)
1370 remember_type (work, oldmangled, *mangled - oldmangled);
1371 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1372 expect_func = 1;
1373 oldmangled = NULL;
1374 break;
1376 case 'K':
1377 oldmangled = *mangled;
1378 success = demangle_qualified (work, mangled, declp, 1, 0);
1379 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1381 expect_func = 1;
1383 oldmangled = NULL;
1384 break;
1386 case 'S':
1387 /* Static member function */
1388 if (oldmangled == NULL)
1390 oldmangled = *mangled;
1392 (*mangled)++;
1393 work -> static_type = 1;
1394 break;
1396 case 'C':
1397 case 'V':
1398 case 'u':
1399 work->type_quals |= code_for_qualifier (**mangled);
1401 /* a qualified member function */
1402 if (oldmangled == NULL)
1403 oldmangled = *mangled;
1404 (*mangled)++;
1405 break;
1407 case 'L':
1408 /* Local class name follows after "Lnnn_" */
1409 if (HP_DEMANGLING)
1411 while (**mangled && (**mangled != '_'))
1412 (*mangled)++;
1413 if (!**mangled)
1414 success = 0;
1415 else
1416 (*mangled)++;
1418 else
1419 success = 0;
1420 break;
1422 case '0': case '1': case '2': case '3': case '4':
1423 case '5': case '6': case '7': case '8': case '9':
1424 if (oldmangled == NULL)
1426 oldmangled = *mangled;
1428 work->temp_start = -1; /* uppermost call to demangle_class */
1429 success = demangle_class (work, mangled, declp);
1430 if (success)
1432 remember_type (work, oldmangled, *mangled - oldmangled);
1434 if (AUTO_DEMANGLING || GNU_DEMANGLING || EDG_DEMANGLING)
1436 /* EDG and others will have the "F", so we let the loop cycle
1437 if we are looking at one. */
1438 if (**mangled != 'F')
1439 expect_func = 1;
1441 oldmangled = NULL;
1442 break;
1444 case 'B':
1446 string s;
1447 success = do_type (work, mangled, &s);
1448 if (success)
1450 string_append (&s, SCOPE_STRING (work));
1451 string_prepends (declp, &s);
1453 oldmangled = NULL;
1454 expect_func = 1;
1456 break;
1458 case 'F':
1459 /* Function */
1460 /* ARM/HP style demangling includes a specific 'F' character after
1461 the class name. For GNU style, it is just implied. So we can
1462 safely just consume any 'F' at this point and be compatible
1463 with either style. */
1465 oldmangled = NULL;
1466 func_done = 1;
1467 (*mangled)++;
1469 /* For lucid/ARM/HP style we have to forget any types we might
1470 have remembered up to this point, since they were not argument
1471 types. GNU style considers all types seen as available for
1472 back references. See comment in demangle_args() */
1474 if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
1476 forget_types (work);
1478 success = demangle_args (work, mangled, declp);
1479 /* After picking off the function args, we expect to either
1480 find the function return type (preceded by an '_') or the
1481 end of the string. */
1482 if (success && (AUTO_DEMANGLING || EDG_DEMANGLING) && **mangled == '_')
1484 ++(*mangled);
1485 /* At this level, we do not care about the return type. */
1486 success = do_type (work, mangled, &tname);
1487 string_delete (&tname);
1490 break;
1492 case 't':
1493 /* G++ Template */
1494 string_init(&trawname);
1495 string_init(&tname);
1496 if (oldmangled == NULL)
1498 oldmangled = *mangled;
1500 success = demangle_template (work, mangled, &tname,
1501 &trawname, 1, 1);
1502 if (success)
1504 remember_type (work, oldmangled, *mangled - oldmangled);
1506 string_append (&tname, SCOPE_STRING (work));
1508 string_prepends(declp, &tname);
1509 if (work -> destructor & 1)
1511 string_prepend (&trawname, "~");
1512 string_appends (declp, &trawname);
1513 work->destructor -= 1;
1515 if ((work->constructor & 1) || (work->destructor & 1))
1517 string_appends (declp, &trawname);
1518 work->constructor -= 1;
1520 string_delete(&trawname);
1521 string_delete(&tname);
1522 oldmangled = NULL;
1523 expect_func = 1;
1524 break;
1526 case '_':
1527 if ((AUTO_DEMANGLING || GNU_DEMANGLING) && expect_return_type)
1529 /* Read the return type. */
1530 string return_type;
1531 string_init (&return_type);
1533 (*mangled)++;
1534 success = do_type (work, mangled, &return_type);
1535 APPEND_BLANK (&return_type);
1537 string_prepends (declp, &return_type);
1538 string_delete (&return_type);
1539 break;
1541 else
1542 /* At the outermost level, we cannot have a return type specified,
1543 so if we run into another '_' at this point we are dealing with
1544 a mangled name that is either bogus, or has been mangled by
1545 some algorithm we don't know how to deal with. So just
1546 reject the entire demangling. */
1547 /* However, "_nnn" is an expected suffix for alternate entry point
1548 numbered nnn for a function, with HP aCC, so skip over that
1549 without reporting failure. pai/1997-09-04 */
1550 if (HP_DEMANGLING)
1552 (*mangled)++;
1553 while (**mangled && ISDIGIT ((unsigned char)**mangled))
1554 (*mangled)++;
1556 else
1557 success = 0;
1558 break;
1560 case 'H':
1561 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1563 /* A G++ template function. Read the template arguments. */
1564 success = demangle_template (work, mangled, declp, 0, 0,
1566 if (!(work->constructor & 1))
1567 expect_return_type = 1;
1568 (*mangled)++;
1569 break;
1571 else
1572 /* fall through */
1575 default:
1576 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1578 /* Assume we have stumbled onto the first outermost function
1579 argument token, and start processing args. */
1580 func_done = 1;
1581 success = demangle_args (work, mangled, declp);
1583 else
1585 /* Non-GNU demanglers use a specific token to mark the start
1586 of the outermost function argument tokens. Typically 'F',
1587 for ARM/HP-demangling, for example. So if we find something
1588 we are not prepared for, it must be an error. */
1589 success = 0;
1591 break;
1594 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1597 if (success && expect_func)
1599 func_done = 1;
1600 if (LUCID_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING)
1602 forget_types (work);
1604 success = demangle_args (work, mangled, declp);
1605 /* Since template include the mangling of their return types,
1606 we must set expect_func to 0 so that we don't try do
1607 demangle more arguments the next time we get here. */
1608 expect_func = 0;
1612 if (success && !func_done)
1614 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1616 /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
1617 bar__3fooi is 'foo::bar(int)'. We get here when we find the
1618 first case, and need to ensure that the '(void)' gets added to
1619 the current declp. Note that with ARM/HP, the first case
1620 represents the name of a static data member 'foo::bar',
1621 which is in the current declp, so we leave it alone. */
1622 success = demangle_args (work, mangled, declp);
1625 if (success && PRINT_ARG_TYPES)
1627 if (work->static_type)
1628 string_append (declp, " static");
1629 if (work->type_quals != TYPE_UNQUALIFIED)
1631 APPEND_BLANK (declp);
1632 string_append (declp, qualifier_string (work->type_quals));
1636 return (success);
1639 #if 0
1641 static int
1642 demangle_method_args (work, mangled, declp)
1643 struct work_stuff *work;
1644 const char **mangled;
1645 string *declp;
1647 int success = 0;
1649 if (work -> static_type)
1651 string_append (declp, *mangled + 1);
1652 *mangled += strlen (*mangled);
1653 success = 1;
1655 else
1657 success = demangle_args (work, mangled, declp);
1659 return (success);
1662 #endif
1664 static int
1665 demangle_template_template_parm (work, mangled, tname)
1666 struct work_stuff *work;
1667 const char **mangled;
1668 string *tname;
1670 int i;
1671 int r;
1672 int need_comma = 0;
1673 int success = 1;
1674 string temp;
1676 string_append (tname, "template <");
1677 /* get size of template parameter list */
1678 if (get_count (mangled, &r))
1680 for (i = 0; i < r; i++)
1682 if (need_comma)
1684 string_append (tname, ", ");
1687 /* Z for type parameters */
1688 if (**mangled == 'Z')
1690 (*mangled)++;
1691 string_append (tname, "class");
1693 /* z for template parameters */
1694 else if (**mangled == 'z')
1696 (*mangled)++;
1697 success =
1698 demangle_template_template_parm (work, mangled, tname);
1699 if (!success)
1701 break;
1704 else
1706 /* temp is initialized in do_type */
1707 success = do_type (work, mangled, &temp);
1708 if (success)
1710 string_appends (tname, &temp);
1712 string_delete(&temp);
1713 if (!success)
1715 break;
1718 need_comma = 1;
1722 if (tname->p[-1] == '>')
1723 string_append (tname, " ");
1724 string_append (tname, "> class");
1725 return (success);
1728 static int
1729 demangle_expression (work, mangled, s, tk)
1730 struct work_stuff *work;
1731 const char** mangled;
1732 string* s;
1733 type_kind_t tk;
1735 int need_operator = 0;
1736 int success;
1738 success = 1;
1739 string_appendn (s, "(", 1);
1740 (*mangled)++;
1741 while (success && **mangled != 'W' && **mangled != '\0')
1743 if (need_operator)
1745 size_t i;
1746 size_t len;
1748 success = 0;
1750 len = strlen (*mangled);
1752 for (i = 0; i < ARRAY_SIZE (optable); ++i)
1754 size_t l = strlen (optable[i].in);
1756 if (l <= len
1757 && memcmp (optable[i].in, *mangled, l) == 0)
1759 string_appendn (s, " ", 1);
1760 string_append (s, optable[i].out);
1761 string_appendn (s, " ", 1);
1762 success = 1;
1763 (*mangled) += l;
1764 break;
1768 if (!success)
1769 break;
1771 else
1772 need_operator = 1;
1774 success = demangle_template_value_parm (work, mangled, s, tk);
1777 if (**mangled != 'W')
1778 success = 0;
1779 else
1781 string_appendn (s, ")", 1);
1782 (*mangled)++;
1785 return success;
1788 static int
1789 demangle_integral_value (work, mangled, s)
1790 struct work_stuff *work;
1791 const char** mangled;
1792 string* s;
1794 int success;
1796 if (**mangled == 'E')
1797 success = demangle_expression (work, mangled, s, tk_integral);
1798 else if (**mangled == 'Q' || **mangled == 'K')
1799 success = demangle_qualified (work, mangled, s, 0, 1);
1800 else
1802 int value;
1804 /* By default, we let the number decide whether we shall consume an
1805 underscore. */
1806 int consume_following_underscore = 0;
1807 int leave_following_underscore = 0;
1809 success = 0;
1811 /* Negative numbers are indicated with a leading `m'. */
1812 if (**mangled == 'm')
1814 string_appendn (s, "-", 1);
1815 (*mangled)++;
1817 else if (mangled[0][0] == '_' && mangled[0][1] == 'm')
1819 /* Since consume_count_with_underscores does not handle the
1820 `m'-prefix we must do it here, using consume_count and
1821 adjusting underscores: we have to consume the underscore
1822 matching the prepended one. */
1823 consume_following_underscore = 1;
1824 string_appendn (s, "-", 1);
1825 (*mangled) += 2;
1827 else if (**mangled == '_')
1829 /* Do not consume a following underscore;
1830 consume_following_underscore will consume what should be
1831 consumed. */
1832 leave_following_underscore = 1;
1835 /* We must call consume_count if we expect to remove a trailing
1836 underscore, since consume_count_with_underscores expects
1837 the leading underscore (that we consumed) if it is to handle
1838 multi-digit numbers. */
1839 if (consume_following_underscore)
1840 value = consume_count (mangled);
1841 else
1842 value = consume_count_with_underscores (mangled);
1844 if (value != -1)
1846 char buf[INTBUF_SIZE];
1847 sprintf (buf, "%d", value);
1848 string_append (s, buf);
1850 /* Numbers not otherwise delimited, might have an underscore
1851 appended as a delimeter, which we should skip.
1853 ??? This used to always remove a following underscore, which
1854 is wrong. If other (arbitrary) cases are followed by an
1855 underscore, we need to do something more radical. */
1857 if ((value > 9 || consume_following_underscore)
1858 && ! leave_following_underscore
1859 && **mangled == '_')
1860 (*mangled)++;
1862 /* All is well. */
1863 success = 1;
1867 return success;
1870 /* Demangle the real value in MANGLED. */
1872 static int
1873 demangle_real_value (work, mangled, s)
1874 struct work_stuff *work;
1875 const char **mangled;
1876 string* s;
1878 if (**mangled == 'E')
1879 return demangle_expression (work, mangled, s, tk_real);
1881 if (**mangled == 'm')
1883 string_appendn (s, "-", 1);
1884 (*mangled)++;
1886 while (ISDIGIT ((unsigned char)**mangled))
1888 string_appendn (s, *mangled, 1);
1889 (*mangled)++;
1891 if (**mangled == '.') /* fraction */
1893 string_appendn (s, ".", 1);
1894 (*mangled)++;
1895 while (ISDIGIT ((unsigned char)**mangled))
1897 string_appendn (s, *mangled, 1);
1898 (*mangled)++;
1901 if (**mangled == 'e') /* exponent */
1903 string_appendn (s, "e", 1);
1904 (*mangled)++;
1905 while (ISDIGIT ((unsigned char)**mangled))
1907 string_appendn (s, *mangled, 1);
1908 (*mangled)++;
1912 return 1;
1915 static int
1916 demangle_template_value_parm (work, mangled, s, tk)
1917 struct work_stuff *work;
1918 const char **mangled;
1919 string* s;
1920 type_kind_t tk;
1922 int success = 1;
1924 if (**mangled == 'Y')
1926 /* The next argument is a template parameter. */
1927 int idx;
1929 (*mangled)++;
1930 idx = consume_count_with_underscores (mangled);
1931 if (idx == -1
1932 || (work->tmpl_argvec && idx >= work->ntmpl_args)
1933 || consume_count_with_underscores (mangled) == -1)
1934 return -1;
1935 if (work->tmpl_argvec)
1936 string_append (s, work->tmpl_argvec[idx]);
1937 else
1938 string_append_template_idx (s, idx);
1940 else if (tk == tk_integral)
1941 success = demangle_integral_value (work, mangled, s);
1942 else if (tk == tk_char)
1944 char tmp[2];
1945 int val;
1946 if (**mangled == 'm')
1948 string_appendn (s, "-", 1);
1949 (*mangled)++;
1951 string_appendn (s, "'", 1);
1952 val = consume_count(mangled);
1953 if (val <= 0)
1954 success = 0;
1955 else
1957 tmp[0] = (char)val;
1958 tmp[1] = '\0';
1959 string_appendn (s, &tmp[0], 1);
1960 string_appendn (s, "'", 1);
1963 else if (tk == tk_bool)
1965 int val = consume_count (mangled);
1966 if (val == 0)
1967 string_appendn (s, "false", 5);
1968 else if (val == 1)
1969 string_appendn (s, "true", 4);
1970 else
1971 success = 0;
1973 else if (tk == tk_real)
1974 success = demangle_real_value (work, mangled, s);
1975 else if (tk == tk_pointer || tk == tk_reference)
1977 if (**mangled == 'Q')
1978 success = demangle_qualified (work, mangled, s,
1979 /*isfuncname=*/0,
1980 /*append=*/1);
1981 else
1983 int symbol_len = consume_count (mangled);
1984 if (symbol_len == -1)
1985 return -1;
1986 if (symbol_len == 0)
1987 string_appendn (s, "0", 1);
1988 else
1990 char *p = xmalloc (symbol_len + 1), *q;
1991 strncpy (p, *mangled, symbol_len);
1992 p [symbol_len] = '\0';
1993 /* We use cplus_demangle here, rather than
1994 internal_cplus_demangle, because the name of the entity
1995 mangled here does not make use of any of the squangling
1996 or type-code information we have built up thus far; it is
1997 mangled independently. */
1998 q = cplus_demangle (p, work->options);
1999 if (tk == tk_pointer)
2000 string_appendn (s, "&", 1);
2001 /* FIXME: Pointer-to-member constants should get a
2002 qualifying class name here. */
2003 if (q)
2005 string_append (s, q);
2006 free (q);
2008 else
2009 string_append (s, p);
2010 free (p);
2012 *mangled += symbol_len;
2016 return success;
2019 /* Demangle the template name in MANGLED. The full name of the
2020 template (e.g., S<int>) is placed in TNAME. The name without the
2021 template parameters (e.g. S) is placed in TRAWNAME if TRAWNAME is
2022 non-NULL. If IS_TYPE is nonzero, this template is a type template,
2023 not a function template. If both IS_TYPE and REMEMBER are nonzero,
2024 the template is remembered in the list of back-referenceable
2025 types. */
2027 static int
2028 demangle_template (work, mangled, tname, trawname, is_type, remember)
2029 struct work_stuff *work;
2030 const char **mangled;
2031 string *tname;
2032 string *trawname;
2033 int is_type;
2034 int remember;
2036 int i;
2037 int r;
2038 int need_comma = 0;
2039 int success = 0;
2040 const char *start;
2041 int is_java_array = 0;
2042 string temp;
2043 int bindex = 0;
2045 (*mangled)++;
2046 if (is_type)
2048 if (remember)
2049 bindex = register_Btype (work);
2050 start = *mangled;
2051 /* get template name */
2052 if (**mangled == 'z')
2054 int idx;
2055 (*mangled)++;
2056 (*mangled)++;
2058 idx = consume_count_with_underscores (mangled);
2059 if (idx == -1
2060 || (work->tmpl_argvec && idx >= work->ntmpl_args)
2061 || consume_count_with_underscores (mangled) == -1)
2062 return (0);
2064 if (work->tmpl_argvec)
2066 string_append (tname, work->tmpl_argvec[idx]);
2067 if (trawname)
2068 string_append (trawname, work->tmpl_argvec[idx]);
2070 else
2072 string_append_template_idx (tname, idx);
2073 if (trawname)
2074 string_append_template_idx (trawname, idx);
2077 else
2079 if ((r = consume_count (mangled)) <= 0
2080 || (int) strlen (*mangled) < r)
2082 return (0);
2084 is_java_array = (work -> options & DMGL_JAVA)
2085 && strncmp (*mangled, "JArray1Z", 8) == 0;
2086 if (! is_java_array)
2088 string_appendn (tname, *mangled, r);
2090 if (trawname)
2091 string_appendn (trawname, *mangled, r);
2092 *mangled += r;
2095 if (!is_java_array)
2096 string_append (tname, "<");
2097 /* get size of template parameter list */
2098 if (!get_count (mangled, &r))
2100 return (0);
2102 if (!is_type)
2104 /* Create an array for saving the template argument values. */
2105 work->tmpl_argvec = (char**) xmalloc (r * sizeof (char *));
2106 work->ntmpl_args = r;
2107 for (i = 0; i < r; i++)
2108 work->tmpl_argvec[i] = 0;
2110 for (i = 0; i < r; i++)
2112 if (need_comma)
2114 string_append (tname, ", ");
2116 /* Z for type parameters */
2117 if (**mangled == 'Z')
2119 (*mangled)++;
2120 /* temp is initialized in do_type */
2121 success = do_type (work, mangled, &temp);
2122 if (success)
2124 string_appends (tname, &temp);
2126 if (!is_type)
2128 /* Save the template argument. */
2129 int len = temp.p - temp.b;
2130 work->tmpl_argvec[i] = xmalloc (len + 1);
2131 memcpy (work->tmpl_argvec[i], temp.b, len);
2132 work->tmpl_argvec[i][len] = '\0';
2135 string_delete(&temp);
2136 if (!success)
2138 break;
2141 /* z for template parameters */
2142 else if (**mangled == 'z')
2144 int r2;
2145 (*mangled)++;
2146 success = demangle_template_template_parm (work, mangled, tname);
2148 if (success
2149 && (r2 = consume_count (mangled)) > 0
2150 && (int) strlen (*mangled) >= r2)
2152 string_append (tname, " ");
2153 string_appendn (tname, *mangled, r2);
2154 if (!is_type)
2156 /* Save the template argument. */
2157 int len = r2;
2158 work->tmpl_argvec[i] = xmalloc (len + 1);
2159 memcpy (work->tmpl_argvec[i], *mangled, len);
2160 work->tmpl_argvec[i][len] = '\0';
2162 *mangled += r2;
2164 if (!success)
2166 break;
2169 else
2171 string param;
2172 string* s;
2174 /* otherwise, value parameter */
2176 /* temp is initialized in do_type */
2177 success = do_type (work, mangled, &temp);
2178 string_delete(&temp);
2179 if (!success)
2180 break;
2182 if (!is_type)
2184 s = &param;
2185 string_init (s);
2187 else
2188 s = tname;
2190 success = demangle_template_value_parm (work, mangled, s,
2191 (type_kind_t) success);
2193 if (!success)
2195 if (!is_type)
2196 string_delete (s);
2197 success = 0;
2198 break;
2201 if (!is_type)
2203 int len = s->p - s->b;
2204 work->tmpl_argvec[i] = xmalloc (len + 1);
2205 memcpy (work->tmpl_argvec[i], s->b, len);
2206 work->tmpl_argvec[i][len] = '\0';
2208 string_appends (tname, s);
2209 string_delete (s);
2212 need_comma = 1;
2214 if (is_java_array)
2216 string_append (tname, "[]");
2218 else
2220 if (tname->p[-1] == '>')
2221 string_append (tname, " ");
2222 string_append (tname, ">");
2225 if (is_type && remember)
2226 remember_Btype (work, tname->b, LEN_STRING (tname), bindex);
2229 if (work -> static_type)
2231 string_append (declp, *mangled + 1);
2232 *mangled += strlen (*mangled);
2233 success = 1;
2235 else
2237 success = demangle_args (work, mangled, declp);
2241 return (success);
2244 static int
2245 arm_pt (work, mangled, n, anchor, args)
2246 struct work_stuff *work;
2247 const char *mangled;
2248 int n;
2249 const char **anchor, **args;
2251 /* Check if ARM template with "__pt__" in it ("parameterized type") */
2252 /* Allow HP also here, because HP's cfront compiler follows ARM to some extent */
2253 if ((ARM_DEMANGLING || HP_DEMANGLING) && (*anchor = mystrstr (mangled, "__pt__")))
2255 int len;
2256 *args = *anchor + 6;
2257 len = consume_count (args);
2258 if (len == -1)
2259 return 0;
2260 if (*args + len == mangled + n && **args == '_')
2262 ++*args;
2263 return 1;
2266 if (AUTO_DEMANGLING || EDG_DEMANGLING)
2268 if ((*anchor = mystrstr (mangled, "__tm__"))
2269 || (*anchor = mystrstr (mangled, "__ps__"))
2270 || (*anchor = mystrstr (mangled, "__pt__")))
2272 int len;
2273 *args = *anchor + 6;
2274 len = consume_count (args);
2275 if (len == -1)
2276 return 0;
2277 if (*args + len == mangled + n && **args == '_')
2279 ++*args;
2280 return 1;
2283 else if ((*anchor = mystrstr (mangled, "__S")))
2285 int len;
2286 *args = *anchor + 3;
2287 len = consume_count (args);
2288 if (len == -1)
2289 return 0;
2290 if (*args + len == mangled + n && **args == '_')
2292 ++*args;
2293 return 1;
2298 return 0;
2301 static void
2302 demangle_arm_hp_template (work, mangled, n, declp)
2303 struct work_stuff *work;
2304 const char **mangled;
2305 int n;
2306 string *declp;
2308 const char *p;
2309 const char *args;
2310 const char *e = *mangled + n;
2311 string arg;
2313 /* Check for HP aCC template spec: classXt1t2 where t1, t2 are
2314 template args */
2315 if (HP_DEMANGLING && ((*mangled)[n] == 'X'))
2317 char *start_spec_args = NULL;
2319 /* First check for and omit template specialization pseudo-arguments,
2320 such as in "Spec<#1,#1.*>" */
2321 start_spec_args = strchr (*mangled, '<');
2322 if (start_spec_args && (start_spec_args - *mangled < n))
2323 string_appendn (declp, *mangled, start_spec_args - *mangled);
2324 else
2325 string_appendn (declp, *mangled, n);
2326 (*mangled) += n + 1;
2327 string_init (&arg);
2328 if (work->temp_start == -1) /* non-recursive call */
2329 work->temp_start = declp->p - declp->b;
2330 string_append (declp, "<");
2331 while (1)
2333 string_clear (&arg);
2334 switch (**mangled)
2336 case 'T':
2337 /* 'T' signals a type parameter */
2338 (*mangled)++;
2339 if (!do_type (work, mangled, &arg))
2340 goto hpacc_template_args_done;
2341 break;
2343 case 'U':
2344 case 'S':
2345 /* 'U' or 'S' signals an integral value */
2346 if (!do_hpacc_template_const_value (work, mangled, &arg))
2347 goto hpacc_template_args_done;
2348 break;
2350 case 'A':
2351 /* 'A' signals a named constant expression (literal) */
2352 if (!do_hpacc_template_literal (work, mangled, &arg))
2353 goto hpacc_template_args_done;
2354 break;
2356 default:
2357 /* Today, 1997-09-03, we have only the above types
2358 of template parameters */
2359 /* FIXME: maybe this should fail and return null */
2360 goto hpacc_template_args_done;
2362 string_appends (declp, &arg);
2363 /* Check if we're at the end of template args.
2364 0 if at end of static member of template class,
2365 _ if done with template args for a function */
2366 if ((**mangled == '\000') || (**mangled == '_'))
2367 break;
2368 else
2369 string_append (declp, ",");
2371 hpacc_template_args_done:
2372 string_append (declp, ">");
2373 string_delete (&arg);
2374 if (**mangled == '_')
2375 (*mangled)++;
2376 return;
2378 /* ARM template? (Also handles HP cfront extensions) */
2379 else if (arm_pt (work, *mangled, n, &p, &args))
2381 string type_str;
2383 string_init (&arg);
2384 string_appendn (declp, *mangled, p - *mangled);
2385 if (work->temp_start == -1) /* non-recursive call */
2386 work->temp_start = declp->p - declp->b;
2387 string_append (declp, "<");
2388 /* should do error checking here */
2389 while (args < e) {
2390 string_clear (&arg);
2392 /* Check for type or literal here */
2393 switch (*args)
2395 /* HP cfront extensions to ARM for template args */
2396 /* spec: Xt1Lv1 where t1 is a type, v1 is a literal value */
2397 /* FIXME: We handle only numeric literals for HP cfront */
2398 case 'X':
2399 /* A typed constant value follows */
2400 args++;
2401 if (!do_type (work, &args, &type_str))
2402 goto cfront_template_args_done;
2403 string_append (&arg, "(");
2404 string_appends (&arg, &type_str);
2405 string_append (&arg, ")");
2406 if (*args != 'L')
2407 goto cfront_template_args_done;
2408 args++;
2409 /* Now snarf a literal value following 'L' */
2410 if (!snarf_numeric_literal (&args, &arg))
2411 goto cfront_template_args_done;
2412 break;
2414 case 'L':
2415 /* Snarf a literal following 'L' */
2416 args++;
2417 if (!snarf_numeric_literal (&args, &arg))
2418 goto cfront_template_args_done;
2419 break;
2420 default:
2421 /* Not handling other HP cfront stuff */
2422 if (!do_type (work, &args, &arg))
2423 goto cfront_template_args_done;
2425 string_appends (declp, &arg);
2426 string_append (declp, ",");
2428 cfront_template_args_done:
2429 string_delete (&arg);
2430 if (args >= e)
2431 --declp->p; /* remove extra comma */
2432 string_append (declp, ">");
2434 else if (n>10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
2435 && (*mangled)[9] == 'N'
2436 && (*mangled)[8] == (*mangled)[10]
2437 && strchr (cplus_markers, (*mangled)[8]))
2439 /* A member of the anonymous namespace. */
2440 string_append (declp, "{anonymous}");
2442 else
2444 if (work->temp_start == -1) /* non-recursive call only */
2445 work->temp_start = 0; /* disable in recursive calls */
2446 string_appendn (declp, *mangled, n);
2448 *mangled += n;
2451 /* Extract a class name, possibly a template with arguments, from the
2452 mangled string; qualifiers, local class indicators, etc. have
2453 already been dealt with */
2455 static int
2456 demangle_class_name (work, mangled, declp)
2457 struct work_stuff *work;
2458 const char **mangled;
2459 string *declp;
2461 int n;
2462 int success = 0;
2464 n = consume_count (mangled);
2465 if (n == -1)
2466 return 0;
2467 if ((int) strlen (*mangled) >= n)
2469 demangle_arm_hp_template (work, mangled, n, declp);
2470 success = 1;
2473 return (success);
2478 LOCAL FUNCTION
2480 demangle_class -- demangle a mangled class sequence
2482 SYNOPSIS
2484 static int
2485 demangle_class (struct work_stuff *work, const char **mangled,
2486 strint *declp)
2488 DESCRIPTION
2490 DECLP points to the buffer into which demangling is being done.
2492 *MANGLED points to the current token to be demangled. On input,
2493 it points to a mangled class (I.E. "3foo", "13verylongclass", etc.)
2494 On exit, it points to the next token after the mangled class on
2495 success, or the first unconsumed token on failure.
2497 If the CONSTRUCTOR or DESTRUCTOR flags are set in WORK, then
2498 we are demangling a constructor or destructor. In this case
2499 we prepend "class::class" or "class::~class" to DECLP.
2501 Otherwise, we prepend "class::" to the current DECLP.
2503 Reset the constructor/destructor flags once they have been
2504 "consumed". This allows demangle_class to be called later during
2505 the same demangling, to do normal class demangling.
2507 Returns 1 if demangling is successful, 0 otherwise.
2511 static int
2512 demangle_class (work, mangled, declp)
2513 struct work_stuff *work;
2514 const char **mangled;
2515 string *declp;
2517 int success = 0;
2518 int btype;
2519 string class_name;
2520 char *save_class_name_end = 0;
2522 string_init (&class_name);
2523 btype = register_Btype (work);
2524 if (demangle_class_name (work, mangled, &class_name))
2526 save_class_name_end = class_name.p;
2527 if ((work->constructor & 1) || (work->destructor & 1))
2529 /* adjust so we don't include template args */
2530 if (work->temp_start && (work->temp_start != -1))
2532 class_name.p = class_name.b + work->temp_start;
2534 string_prepends (declp, &class_name);
2535 if (work -> destructor & 1)
2537 string_prepend (declp, "~");
2538 work -> destructor -= 1;
2540 else
2542 work -> constructor -= 1;
2545 class_name.p = save_class_name_end;
2546 remember_Ktype (work, class_name.b, LEN_STRING(&class_name));
2547 remember_Btype (work, class_name.b, LEN_STRING(&class_name), btype);
2548 string_prepend (declp, SCOPE_STRING (work));
2549 string_prepends (declp, &class_name);
2550 success = 1;
2552 string_delete (&class_name);
2553 return (success);
2557 /* Called when there's a "__" in the mangled name, with `scan' pointing to
2558 the rightmost guess.
2560 Find the correct "__"-sequence where the function name ends and the
2561 signature starts, which is ambiguous with GNU mangling.
2562 Call demangle_signature here, so we can make sure we found the right
2563 one; *mangled will be consumed so caller will not make further calls to
2564 demangle_signature. */
2566 static int
2567 iterate_demangle_function (work, mangled, declp, scan)
2568 struct work_stuff *work;
2569 const char **mangled;
2570 string *declp;
2571 const char *scan;
2573 const char *mangle_init = *mangled;
2574 int success = 0;
2575 string decl_init;
2576 struct work_stuff work_init;
2578 if (*(scan + 2) == '\0')
2579 return 0;
2581 /* Do not iterate for some demangling modes, or if there's only one
2582 "__"-sequence. This is the normal case. */
2583 if (ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING
2584 || mystrstr (scan + 2, "__") == NULL)
2586 demangle_function_name (work, mangled, declp, scan);
2587 return 1;
2590 /* Save state so we can restart if the guess at the correct "__" was
2591 wrong. */
2592 string_init (&decl_init);
2593 string_appends (&decl_init, declp);
2594 memset (&work_init, 0, sizeof work_init);
2595 work_stuff_copy_to_from (&work_init, work);
2597 /* Iterate over occurrences of __, allowing names and types to have a
2598 "__" sequence in them. We must start with the first (not the last)
2599 occurrence, since "__" most often occur between independent mangled
2600 parts, hence starting at the last occurence inside a signature
2601 might get us a "successful" demangling of the signature. */
2603 while (scan[2])
2605 demangle_function_name (work, mangled, declp, scan);
2606 success = demangle_signature (work, mangled, declp);
2607 if (success)
2608 break;
2610 /* Reset demangle state for the next round. */
2611 *mangled = mangle_init;
2612 string_clear (declp);
2613 string_appends (declp, &decl_init);
2614 work_stuff_copy_to_from (work, &work_init);
2616 /* Leave this underscore-sequence. */
2617 scan += 2;
2619 /* Scan for the next "__" sequence. */
2620 while (*scan && (scan[0] != '_' || scan[1] != '_'))
2621 scan++;
2623 /* Move to last "__" in this sequence. */
2624 while (*scan && *scan == '_')
2625 scan++;
2626 scan -= 2;
2629 /* Delete saved state. */
2630 delete_work_stuff (&work_init);
2631 string_delete (&decl_init);
2633 return success;
2638 LOCAL FUNCTION
2640 demangle_prefix -- consume the mangled name prefix and find signature
2642 SYNOPSIS
2644 static int
2645 demangle_prefix (struct work_stuff *work, const char **mangled,
2646 string *declp);
2648 DESCRIPTION
2650 Consume and demangle the prefix of the mangled name.
2651 While processing the function name root, arrange to call
2652 demangle_signature if the root is ambiguous.
2654 DECLP points to the string buffer into which demangled output is
2655 placed. On entry, the buffer is empty. On exit it contains
2656 the root function name, the demangled operator name, or in some
2657 special cases either nothing or the completely demangled result.
2659 MANGLED points to the current pointer into the mangled name. As each
2660 token of the mangled name is consumed, it is updated. Upon entry
2661 the current mangled name pointer points to the first character of
2662 the mangled name. Upon exit, it should point to the first character
2663 of the signature if demangling was successful, or to the first
2664 unconsumed character if demangling of the prefix was unsuccessful.
2666 Returns 1 on success, 0 otherwise.
2669 static int
2670 demangle_prefix (work, mangled, declp)
2671 struct work_stuff *work;
2672 const char **mangled;
2673 string *declp;
2675 int success = 1;
2676 const char *scan;
2677 int i;
2679 if (strlen(*mangled) > 6
2680 && (strncmp(*mangled, "_imp__", 6) == 0
2681 || strncmp(*mangled, "__imp_", 6) == 0))
2683 /* it's a symbol imported from a PE dynamic library. Check for both
2684 new style prefix _imp__ and legacy __imp_ used by older versions
2685 of dlltool. */
2686 (*mangled) += 6;
2687 work->dllimported = 1;
2689 else if (strlen(*mangled) >= 11 && strncmp(*mangled, "_GLOBAL_", 8) == 0)
2691 char *marker = strchr (cplus_markers, (*mangled)[8]);
2692 if (marker != NULL && *marker == (*mangled)[10])
2694 if ((*mangled)[9] == 'D')
2696 /* it's a GNU global destructor to be executed at program exit */
2697 (*mangled) += 11;
2698 work->destructor = 2;
2699 if (gnu_special (work, mangled, declp))
2700 return success;
2702 else if ((*mangled)[9] == 'I')
2704 /* it's a GNU global constructor to be executed at program init */
2705 (*mangled) += 11;
2706 work->constructor = 2;
2707 if (gnu_special (work, mangled, declp))
2708 return success;
2712 else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__std__", 7) == 0)
2714 /* it's a ARM global destructor to be executed at program exit */
2715 (*mangled) += 7;
2716 work->destructor = 2;
2718 else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__sti__", 7) == 0)
2720 /* it's a ARM global constructor to be executed at program initial */
2721 (*mangled) += 7;
2722 work->constructor = 2;
2725 /* This block of code is a reduction in strength time optimization
2727 scan = mystrstr (*mangled, "__"); */
2730 scan = *mangled;
2732 do {
2733 scan = strchr (scan, '_');
2734 } while (scan != NULL && *++scan != '_');
2736 if (scan != NULL) --scan;
2739 if (scan != NULL)
2741 /* We found a sequence of two or more '_', ensure that we start at
2742 the last pair in the sequence. */
2743 i = strspn (scan, "_");
2744 if (i > 2)
2746 scan += (i - 2);
2750 if (scan == NULL)
2752 success = 0;
2754 else if (work -> static_type)
2756 if (!ISDIGIT ((unsigned char)scan[0]) && (scan[0] != 't'))
2758 success = 0;
2761 else if ((scan == *mangled)
2762 && (ISDIGIT ((unsigned char)scan[2]) || (scan[2] == 'Q')
2763 || (scan[2] == 't') || (scan[2] == 'K') || (scan[2] == 'H')))
2765 /* The ARM says nothing about the mangling of local variables.
2766 But cfront mangles local variables by prepending __<nesting_level>
2767 to them. As an extension to ARM demangling we handle this case. */
2768 if ((LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING)
2769 && ISDIGIT ((unsigned char)scan[2]))
2771 *mangled = scan + 2;
2772 consume_count (mangled);
2773 string_append (declp, *mangled);
2774 *mangled += strlen (*mangled);
2775 success = 1;
2777 else
2779 /* A GNU style constructor starts with __[0-9Qt]. But cfront uses
2780 names like __Q2_3foo3bar for nested type names. So don't accept
2781 this style of constructor for cfront demangling. A GNU
2782 style member-template constructor starts with 'H'. */
2783 if (!(LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING))
2784 work -> constructor += 1;
2785 *mangled = scan + 2;
2788 else if (ARM_DEMANGLING && scan[2] == 'p' && scan[3] == 't')
2790 /* Cfront-style parameterized type. Handled later as a signature. */
2791 success = 1;
2793 /* ARM template? */
2794 demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
2796 else if (EDG_DEMANGLING && ((scan[2] == 't' && scan[3] == 'm')
2797 || (scan[2] == 'p' && scan[3] == 's')
2798 || (scan[2] == 'p' && scan[3] == 't')))
2800 /* EDG-style parameterized type. Handled later as a signature. */
2801 success = 1;
2803 /* EDG template? */
2804 demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
2806 else if ((scan == *mangled) && !ISDIGIT ((unsigned char)scan[2])
2807 && (scan[2] != 't'))
2809 /* Mangled name starts with "__". Skip over any leading '_' characters,
2810 then find the next "__" that separates the prefix from the signature.
2812 if (!(ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
2813 || (arm_special (mangled, declp) == 0))
2815 while (*scan == '_')
2817 scan++;
2819 if ((scan = mystrstr (scan, "__")) == NULL || (*(scan + 2) == '\0'))
2821 /* No separator (I.E. "__not_mangled"), or empty signature
2822 (I.E. "__not_mangled_either__") */
2823 success = 0;
2825 else
2826 return iterate_demangle_function (work, mangled, declp, scan);
2829 else if (*(scan + 2) != '\0')
2831 /* Mangled name does not start with "__" but does have one somewhere
2832 in there with non empty stuff after it. Looks like a global
2833 function name. Iterate over all "__":s until the right
2834 one is found. */
2835 return iterate_demangle_function (work, mangled, declp, scan);
2837 else
2839 /* Doesn't look like a mangled name */
2840 success = 0;
2843 if (!success && (work->constructor == 2 || work->destructor == 2))
2845 string_append (declp, *mangled);
2846 *mangled += strlen (*mangled);
2847 success = 1;
2849 return (success);
2854 LOCAL FUNCTION
2856 gnu_special -- special handling of gnu mangled strings
2858 SYNOPSIS
2860 static int
2861 gnu_special (struct work_stuff *work, const char **mangled,
2862 string *declp);
2865 DESCRIPTION
2867 Process some special GNU style mangling forms that don't fit
2868 the normal pattern. For example:
2870 _$_3foo (destructor for class foo)
2871 _vt$foo (foo virtual table)
2872 _vt$foo$bar (foo::bar virtual table)
2873 __vt_foo (foo virtual table, new style with thunks)
2874 _3foo$varname (static data member)
2875 _Q22rs2tu$vw (static data member)
2876 __t6vector1Zii (constructor with template)
2877 __thunk_4__$_7ostream (virtual function thunk)
2880 static int
2881 gnu_special (work, mangled, declp)
2882 struct work_stuff *work;
2883 const char **mangled;
2884 string *declp;
2886 int n;
2887 int success = 1;
2888 const char *p;
2890 if ((*mangled)[0] == '_'
2891 && strchr (cplus_markers, (*mangled)[1]) != NULL
2892 && (*mangled)[2] == '_')
2894 /* Found a GNU style destructor, get past "_<CPLUS_MARKER>_" */
2895 (*mangled) += 3;
2896 work -> destructor += 1;
2898 else if ((*mangled)[0] == '_'
2899 && (((*mangled)[1] == '_'
2900 && (*mangled)[2] == 'v'
2901 && (*mangled)[3] == 't'
2902 && (*mangled)[4] == '_')
2903 || ((*mangled)[1] == 'v'
2904 && (*mangled)[2] == 't'
2905 && strchr (cplus_markers, (*mangled)[3]) != NULL)))
2907 /* Found a GNU style virtual table, get past "_vt<CPLUS_MARKER>"
2908 and create the decl. Note that we consume the entire mangled
2909 input string, which means that demangle_signature has no work
2910 to do. */
2911 if ((*mangled)[2] == 'v')
2912 (*mangled) += 5; /* New style, with thunks: "__vt_" */
2913 else
2914 (*mangled) += 4; /* Old style, no thunks: "_vt<CPLUS_MARKER>" */
2915 while (**mangled != '\0')
2917 switch (**mangled)
2919 case 'Q':
2920 case 'K':
2921 success = demangle_qualified (work, mangled, declp, 0, 1);
2922 break;
2923 case 't':
2924 success = demangle_template (work, mangled, declp, 0, 1,
2926 break;
2927 default:
2928 if (ISDIGIT((unsigned char)*mangled[0]))
2930 n = consume_count(mangled);
2931 /* We may be seeing a too-large size, or else a
2932 ".<digits>" indicating a static local symbol. In
2933 any case, declare victory and move on; *don't* try
2934 to use n to allocate. */
2935 if (n > (int) strlen (*mangled))
2937 success = 1;
2938 break;
2941 else
2943 n = strcspn (*mangled, cplus_markers);
2945 string_appendn (declp, *mangled, n);
2946 (*mangled) += n;
2949 p = strpbrk (*mangled, cplus_markers);
2950 if (success && ((p == NULL) || (p == *mangled)))
2952 if (p != NULL)
2954 string_append (declp, SCOPE_STRING (work));
2955 (*mangled)++;
2958 else
2960 success = 0;
2961 break;
2964 if (success)
2965 string_append (declp, " virtual table");
2967 else if ((*mangled)[0] == '_'
2968 && (strchr("0123456789Qt", (*mangled)[1]) != NULL)
2969 && (p = strpbrk (*mangled, cplus_markers)) != NULL)
2971 /* static data member, "_3foo$varname" for example */
2972 (*mangled)++;
2973 switch (**mangled)
2975 case 'Q':
2976 case 'K':
2977 success = demangle_qualified (work, mangled, declp, 0, 1);
2978 break;
2979 case 't':
2980 success = demangle_template (work, mangled, declp, 0, 1, 1);
2981 break;
2982 default:
2983 n = consume_count (mangled);
2984 if (n < 0 || n > (long) strlen (*mangled))
2986 success = 0;
2987 break;
2990 if (n > 10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
2991 && (*mangled)[9] == 'N'
2992 && (*mangled)[8] == (*mangled)[10]
2993 && strchr (cplus_markers, (*mangled)[8]))
2995 /* A member of the anonymous namespace. There's information
2996 about what identifier or filename it was keyed to, but
2997 it's just there to make the mangled name unique; we just
2998 step over it. */
2999 string_append (declp, "{anonymous}");
3000 (*mangled) += n;
3002 /* Now p points to the marker before the N, so we need to
3003 update it to the first marker after what we consumed. */
3004 p = strpbrk (*mangled, cplus_markers);
3005 break;
3008 string_appendn (declp, *mangled, n);
3009 (*mangled) += n;
3011 if (success && (p == *mangled))
3013 /* Consumed everything up to the cplus_marker, append the
3014 variable name. */
3015 (*mangled)++;
3016 string_append (declp, SCOPE_STRING (work));
3017 n = strlen (*mangled);
3018 string_appendn (declp, *mangled, n);
3019 (*mangled) += n;
3021 else
3023 success = 0;
3026 else if (strncmp (*mangled, "__thunk_", 8) == 0)
3028 int delta;
3030 (*mangled) += 8;
3031 delta = consume_count (mangled);
3032 if (delta == -1)
3033 success = 0;
3034 else
3036 char *method = internal_cplus_demangle (work, ++*mangled);
3038 if (method)
3040 char buf[50];
3041 sprintf (buf, "virtual function thunk (delta:%d) for ", -delta);
3042 string_append (declp, buf);
3043 string_append (declp, method);
3044 free (method);
3045 n = strlen (*mangled);
3046 (*mangled) += n;
3048 else
3050 success = 0;
3054 else if (strncmp (*mangled, "__t", 3) == 0
3055 && ((*mangled)[3] == 'i' || (*mangled)[3] == 'f'))
3057 p = (*mangled)[3] == 'i' ? " type_info node" : " type_info function";
3058 (*mangled) += 4;
3059 switch (**mangled)
3061 case 'Q':
3062 case 'K':
3063 success = demangle_qualified (work, mangled, declp, 0, 1);
3064 break;
3065 case 't':
3066 success = demangle_template (work, mangled, declp, 0, 1, 1);
3067 break;
3068 default:
3069 success = do_type (work, mangled, declp);
3070 break;
3072 if (success && **mangled != '\0')
3073 success = 0;
3074 if (success)
3075 string_append (declp, p);
3077 else
3079 success = 0;
3081 return (success);
3084 static void
3085 recursively_demangle(work, mangled, result, namelength)
3086 struct work_stuff *work;
3087 const char **mangled;
3088 string *result;
3089 int namelength;
3091 char * recurse = (char *)NULL;
3092 char * recurse_dem = (char *)NULL;
3094 recurse = (char *) xmalloc (namelength + 1);
3095 memcpy (recurse, *mangled, namelength);
3096 recurse[namelength] = '\000';
3098 recurse_dem = cplus_demangle (recurse, work->options);
3100 if (recurse_dem)
3102 string_append (result, recurse_dem);
3103 free (recurse_dem);
3105 else
3107 string_appendn (result, *mangled, namelength);
3109 free (recurse);
3110 *mangled += namelength;
3115 LOCAL FUNCTION
3117 arm_special -- special handling of ARM/lucid mangled strings
3119 SYNOPSIS
3121 static int
3122 arm_special (const char **mangled,
3123 string *declp);
3126 DESCRIPTION
3128 Process some special ARM style mangling forms that don't fit
3129 the normal pattern. For example:
3131 __vtbl__3foo (foo virtual table)
3132 __vtbl__3foo__3bar (bar::foo virtual table)
3136 static int
3137 arm_special (mangled, declp)
3138 const char **mangled;
3139 string *declp;
3141 int n;
3142 int success = 1;
3143 const char *scan;
3145 if (strncmp (*mangled, ARM_VTABLE_STRING, ARM_VTABLE_STRLEN) == 0)
3147 /* Found a ARM style virtual table, get past ARM_VTABLE_STRING
3148 and create the decl. Note that we consume the entire mangled
3149 input string, which means that demangle_signature has no work
3150 to do. */
3151 scan = *mangled + ARM_VTABLE_STRLEN;
3152 while (*scan != '\0') /* first check it can be demangled */
3154 n = consume_count (&scan);
3155 if (n == -1)
3157 return (0); /* no good */
3159 scan += n;
3160 if (scan[0] == '_' && scan[1] == '_')
3162 scan += 2;
3165 (*mangled) += ARM_VTABLE_STRLEN;
3166 while (**mangled != '\0')
3168 n = consume_count (mangled);
3169 if (n == -1
3170 || n > (long) strlen (*mangled))
3171 return 0;
3172 string_prependn (declp, *mangled, n);
3173 (*mangled) += n;
3174 if ((*mangled)[0] == '_' && (*mangled)[1] == '_')
3176 string_prepend (declp, "::");
3177 (*mangled) += 2;
3180 string_append (declp, " virtual table");
3182 else
3184 success = 0;
3186 return (success);
3191 LOCAL FUNCTION
3193 demangle_qualified -- demangle 'Q' qualified name strings
3195 SYNOPSIS
3197 static int
3198 demangle_qualified (struct work_stuff *, const char *mangled,
3199 string *result, int isfuncname, int append);
3201 DESCRIPTION
3203 Demangle a qualified name, such as "Q25Outer5Inner" which is
3204 the mangled form of "Outer::Inner". The demangled output is
3205 prepended or appended to the result string according to the
3206 state of the append flag.
3208 If isfuncname is nonzero, then the qualified name we are building
3209 is going to be used as a member function name, so if it is a
3210 constructor or destructor function, append an appropriate
3211 constructor or destructor name. I.E. for the above example,
3212 the result for use as a constructor is "Outer::Inner::Inner"
3213 and the result for use as a destructor is "Outer::Inner::~Inner".
3215 BUGS
3217 Numeric conversion is ASCII dependent (FIXME).
3221 static int
3222 demangle_qualified (work, mangled, result, isfuncname, append)
3223 struct work_stuff *work;
3224 const char **mangled;
3225 string *result;
3226 int isfuncname;
3227 int append;
3229 int qualifiers = 0;
3230 int success = 1;
3231 char num[2];
3232 string temp;
3233 string last_name;
3234 int bindex = register_Btype (work);
3236 /* We only make use of ISFUNCNAME if the entity is a constructor or
3237 destructor. */
3238 isfuncname = (isfuncname
3239 && ((work->constructor & 1) || (work->destructor & 1)));
3241 string_init (&temp);
3242 string_init (&last_name);
3244 if ((*mangled)[0] == 'K')
3246 /* Squangling qualified name reuse */
3247 int idx;
3248 (*mangled)++;
3249 idx = consume_count_with_underscores (mangled);
3250 if (idx == -1 || idx >= work -> numk)
3251 success = 0;
3252 else
3253 string_append (&temp, work -> ktypevec[idx]);
3255 else
3256 switch ((*mangled)[1])
3258 case '_':
3259 /* GNU mangled name with more than 9 classes. The count is preceded
3260 by an underscore (to distinguish it from the <= 9 case) and followed
3261 by an underscore. */
3262 (*mangled)++;
3263 qualifiers = consume_count_with_underscores (mangled);
3264 if (qualifiers == -1)
3265 success = 0;
3266 break;
3268 case '1':
3269 case '2':
3270 case '3':
3271 case '4':
3272 case '5':
3273 case '6':
3274 case '7':
3275 case '8':
3276 case '9':
3277 /* The count is in a single digit. */
3278 num[0] = (*mangled)[1];
3279 num[1] = '\0';
3280 qualifiers = atoi (num);
3282 /* If there is an underscore after the digit, skip it. This is
3283 said to be for ARM-qualified names, but the ARM makes no
3284 mention of such an underscore. Perhaps cfront uses one. */
3285 if ((*mangled)[2] == '_')
3287 (*mangled)++;
3289 (*mangled) += 2;
3290 break;
3292 case '0':
3293 default:
3294 success = 0;
3297 if (!success)
3298 return success;
3300 /* Pick off the names and collect them in the temp buffer in the order
3301 in which they are found, separated by '::'. */
3303 while (qualifiers-- > 0)
3305 int remember_K = 1;
3306 string_clear (&last_name);
3308 if (*mangled[0] == '_')
3309 (*mangled)++;
3311 if (*mangled[0] == 't')
3313 /* Here we always append to TEMP since we will want to use
3314 the template name without the template parameters as a
3315 constructor or destructor name. The appropriate
3316 (parameter-less) value is returned by demangle_template
3317 in LAST_NAME. We do not remember the template type here,
3318 in order to match the G++ mangling algorithm. */
3319 success = demangle_template(work, mangled, &temp,
3320 &last_name, 1, 0);
3321 if (!success)
3322 break;
3324 else if (*mangled[0] == 'K')
3326 int idx;
3327 (*mangled)++;
3328 idx = consume_count_with_underscores (mangled);
3329 if (idx == -1 || idx >= work->numk)
3330 success = 0;
3331 else
3332 string_append (&temp, work->ktypevec[idx]);
3333 remember_K = 0;
3335 if (!success) break;
3337 else
3339 if (EDG_DEMANGLING)
3341 int namelength;
3342 /* Now recursively demangle the qualifier
3343 * This is necessary to deal with templates in
3344 * mangling styles like EDG */
3345 namelength = consume_count (mangled);
3346 if (namelength == -1)
3348 success = 0;
3349 break;
3351 recursively_demangle(work, mangled, &temp, namelength);
3353 else
3355 success = do_type (work, mangled, &last_name);
3356 if (!success)
3357 break;
3358 string_appends (&temp, &last_name);
3362 if (remember_K)
3363 remember_Ktype (work, temp.b, LEN_STRING (&temp));
3365 if (qualifiers > 0)
3366 string_append (&temp, SCOPE_STRING (work));
3369 remember_Btype (work, temp.b, LEN_STRING (&temp), bindex);
3371 /* If we are using the result as a function name, we need to append
3372 the appropriate '::' separated constructor or destructor name.
3373 We do this here because this is the most convenient place, where
3374 we already have a pointer to the name and the length of the name. */
3376 if (isfuncname)
3378 string_append (&temp, SCOPE_STRING (work));
3379 if (work -> destructor & 1)
3380 string_append (&temp, "~");
3381 string_appends (&temp, &last_name);
3384 /* Now either prepend the temp buffer to the result, or append it,
3385 depending upon the state of the append flag. */
3387 if (append)
3388 string_appends (result, &temp);
3389 else
3391 if (!STRING_EMPTY (result))
3392 string_append (&temp, SCOPE_STRING (work));
3393 string_prepends (result, &temp);
3396 string_delete (&last_name);
3397 string_delete (&temp);
3398 return (success);
3403 LOCAL FUNCTION
3405 get_count -- convert an ascii count to integer, consuming tokens
3407 SYNOPSIS
3409 static int
3410 get_count (const char **type, int *count)
3412 DESCRIPTION
3414 Assume that *type points at a count in a mangled name; set
3415 *count to its value, and set *type to the next character after
3416 the count. There are some weird rules in effect here.
3418 If *type does not point at a string of digits, return zero.
3420 If *type points at a string of digits followed by an
3421 underscore, set *count to their value as an integer, advance
3422 *type to point *after the underscore, and return 1.
3424 If *type points at a string of digits not followed by an
3425 underscore, consume only the first digit. Set *count to its
3426 value as an integer, leave *type pointing after that digit,
3427 and return 1.
3429 The excuse for this odd behavior: in the ARM and HP demangling
3430 styles, a type can be followed by a repeat count of the form
3431 `Nxy', where:
3433 `x' is a single digit specifying how many additional copies
3434 of the type to append to the argument list, and
3436 `y' is one or more digits, specifying the zero-based index of
3437 the first repeated argument in the list. Yes, as you're
3438 unmangling the name you can figure this out yourself, but
3439 it's there anyway.
3441 So, for example, in `bar__3fooFPiN51', the first argument is a
3442 pointer to an integer (`Pi'), and then the next five arguments
3443 are the same (`N5'), and the first repeat is the function's
3444 second argument (`1').
3447 static int
3448 get_count (type, count)
3449 const char **type;
3450 int *count;
3452 const char *p;
3453 int n;
3455 if (!ISDIGIT ((unsigned char)**type))
3456 return (0);
3457 else
3459 *count = **type - '0';
3460 (*type)++;
3461 if (ISDIGIT ((unsigned char)**type))
3463 p = *type;
3464 n = *count;
3467 n *= 10;
3468 n += *p - '0';
3469 p++;
3471 while (ISDIGIT ((unsigned char)*p));
3472 if (*p == '_')
3474 *type = p + 1;
3475 *count = n;
3479 return (1);
3482 /* RESULT will be initialised here; it will be freed on failure. The
3483 value returned is really a type_kind_t. */
3485 static int
3486 do_type (work, mangled, result)
3487 struct work_stuff *work;
3488 const char **mangled;
3489 string *result;
3491 int n;
3492 int done;
3493 int success;
3494 string decl;
3495 const char *remembered_type;
3496 int type_quals;
3497 string btype;
3498 type_kind_t tk = tk_none;
3500 string_init (&btype);
3501 string_init (&decl);
3502 string_init (result);
3504 done = 0;
3505 success = 1;
3506 while (success && !done)
3508 int member;
3509 switch (**mangled)
3512 /* A pointer type */
3513 case 'P':
3514 case 'p':
3515 (*mangled)++;
3516 if (! (work -> options & DMGL_JAVA))
3517 string_prepend (&decl, "*");
3518 if (tk == tk_none)
3519 tk = tk_pointer;
3520 break;
3522 /* A reference type */
3523 case 'R':
3524 (*mangled)++;
3525 string_prepend (&decl, "&");
3526 if (tk == tk_none)
3527 tk = tk_reference;
3528 break;
3530 /* An array */
3531 case 'A':
3533 ++(*mangled);
3534 if (!STRING_EMPTY (&decl)
3535 && (decl.b[0] == '*' || decl.b[0] == '&'))
3537 string_prepend (&decl, "(");
3538 string_append (&decl, ")");
3540 string_append (&decl, "[");
3541 if (**mangled != '_')
3542 success = demangle_template_value_parm (work, mangled, &decl,
3543 tk_integral);
3544 if (**mangled == '_')
3545 ++(*mangled);
3546 string_append (&decl, "]");
3547 break;
3550 /* A back reference to a previously seen type */
3551 case 'T':
3552 (*mangled)++;
3553 if (!get_count (mangled, &n) || n >= work -> ntypes)
3555 success = 0;
3557 else
3559 remembered_type = work -> typevec[n];
3560 mangled = &remembered_type;
3562 break;
3564 /* A function */
3565 case 'F':
3566 (*mangled)++;
3567 if (!STRING_EMPTY (&decl)
3568 && (decl.b[0] == '*' || decl.b[0] == '&'))
3570 string_prepend (&decl, "(");
3571 string_append (&decl, ")");
3573 /* After picking off the function args, we expect to either find the
3574 function return type (preceded by an '_') or the end of the
3575 string. */
3576 if (!demangle_nested_args (work, mangled, &decl)
3577 || (**mangled != '_' && **mangled != '\0'))
3579 success = 0;
3580 break;
3582 if (success && (**mangled == '_'))
3583 (*mangled)++;
3584 break;
3586 case 'M':
3587 case 'O':
3589 type_quals = TYPE_UNQUALIFIED;
3591 member = **mangled == 'M';
3592 (*mangled)++;
3594 string_append (&decl, ")");
3596 /* We don't need to prepend `::' for a qualified name;
3597 demangle_qualified will do that for us. */
3598 if (**mangled != 'Q')
3599 string_prepend (&decl, SCOPE_STRING (work));
3601 if (ISDIGIT ((unsigned char)**mangled))
3603 n = consume_count (mangled);
3604 if (n == -1
3605 || (int) strlen (*mangled) < n)
3607 success = 0;
3608 break;
3610 string_prependn (&decl, *mangled, n);
3611 *mangled += n;
3613 else if (**mangled == 'X' || **mangled == 'Y')
3615 string temp;
3616 do_type (work, mangled, &temp);
3617 string_prepends (&decl, &temp);
3619 else if (**mangled == 't')
3621 string temp;
3622 string_init (&temp);
3623 success = demangle_template (work, mangled, &temp,
3624 NULL, 1, 1);
3625 if (success)
3627 string_prependn (&decl, temp.b, temp.p - temp.b);
3628 string_clear (&temp);
3630 else
3631 break;
3633 else if (**mangled == 'Q')
3635 success = demangle_qualified (work, mangled, &decl,
3636 /*isfuncnam=*/0,
3637 /*append=*/0);
3638 if (!success)
3639 break;
3641 else
3643 success = 0;
3644 break;
3647 string_prepend (&decl, "(");
3648 if (member)
3650 switch (**mangled)
3652 case 'C':
3653 case 'V':
3654 case 'u':
3655 type_quals |= code_for_qualifier (**mangled);
3656 (*mangled)++;
3657 break;
3659 default:
3660 break;
3663 if (*(*mangled)++ != 'F')
3665 success = 0;
3666 break;
3669 if ((member && !demangle_nested_args (work, mangled, &decl))
3670 || **mangled != '_')
3672 success = 0;
3673 break;
3675 (*mangled)++;
3676 if (! PRINT_ANSI_QUALIFIERS)
3678 break;
3680 if (type_quals != TYPE_UNQUALIFIED)
3682 APPEND_BLANK (&decl);
3683 string_append (&decl, qualifier_string (type_quals));
3685 break;
3687 case 'G':
3688 (*mangled)++;
3689 break;
3691 case 'C':
3692 case 'V':
3693 case 'u':
3694 if (PRINT_ANSI_QUALIFIERS)
3696 if (!STRING_EMPTY (&decl))
3697 string_prepend (&decl, " ");
3699 string_prepend (&decl, demangle_qualifier (**mangled));
3701 (*mangled)++;
3702 break;
3707 /* fall through */
3708 default:
3709 done = 1;
3710 break;
3714 if (success) switch (**mangled)
3716 /* A qualified name, such as "Outer::Inner". */
3717 case 'Q':
3718 case 'K':
3720 success = demangle_qualified (work, mangled, result, 0, 1);
3721 break;
3724 /* A back reference to a previously seen squangled type */
3725 case 'B':
3726 (*mangled)++;
3727 if (!get_count (mangled, &n) || n >= work -> numb)
3728 success = 0;
3729 else
3730 string_append (result, work->btypevec[n]);
3731 break;
3733 case 'X':
3734 case 'Y':
3735 /* A template parm. We substitute the corresponding argument. */
3737 int idx;
3739 (*mangled)++;
3740 idx = consume_count_with_underscores (mangled);
3742 if (idx == -1
3743 || (work->tmpl_argvec && idx >= work->ntmpl_args)
3744 || consume_count_with_underscores (mangled) == -1)
3746 success = 0;
3747 break;
3750 if (work->tmpl_argvec)
3751 string_append (result, work->tmpl_argvec[idx]);
3752 else
3753 string_append_template_idx (result, idx);
3755 success = 1;
3757 break;
3759 default:
3760 success = demangle_fund_type (work, mangled, result);
3761 if (tk == tk_none)
3762 tk = (type_kind_t) success;
3763 break;
3766 if (success)
3768 if (!STRING_EMPTY (&decl))
3770 string_append (result, " ");
3771 string_appends (result, &decl);
3774 else
3775 string_delete (result);
3776 string_delete (&decl);
3778 if (success)
3779 /* Assume an integral type, if we're not sure. */
3780 return (int) ((tk == tk_none) ? tk_integral : tk);
3781 else
3782 return 0;
3785 /* Given a pointer to a type string that represents a fundamental type
3786 argument (int, long, unsigned int, etc) in TYPE, a pointer to the
3787 string in which the demangled output is being built in RESULT, and
3788 the WORK structure, decode the types and add them to the result.
3790 For example:
3792 "Ci" => "const int"
3793 "Sl" => "signed long"
3794 "CUs" => "const unsigned short"
3796 The value returned is really a type_kind_t. */
3798 static int
3799 demangle_fund_type (work, mangled, result)
3800 struct work_stuff *work;
3801 const char **mangled;
3802 string *result;
3804 int done = 0;
3805 int success = 1;
3806 char buf[10];
3807 unsigned int dec = 0;
3808 string btype;
3809 type_kind_t tk = tk_integral;
3811 string_init (&btype);
3813 /* First pick off any type qualifiers. There can be more than one. */
3815 while (!done)
3817 switch (**mangled)
3819 case 'C':
3820 case 'V':
3821 case 'u':
3822 if (PRINT_ANSI_QUALIFIERS)
3824 if (!STRING_EMPTY (result))
3825 string_prepend (result, " ");
3826 string_prepend (result, demangle_qualifier (**mangled));
3828 (*mangled)++;
3829 break;
3830 case 'U':
3831 (*mangled)++;
3832 APPEND_BLANK (result);
3833 string_append (result, "unsigned");
3834 break;
3835 case 'S': /* signed char only */
3836 (*mangled)++;
3837 APPEND_BLANK (result);
3838 string_append (result, "signed");
3839 break;
3840 case 'J':
3841 (*mangled)++;
3842 APPEND_BLANK (result);
3843 string_append (result, "__complex");
3844 break;
3845 default:
3846 done = 1;
3847 break;
3851 /* Now pick off the fundamental type. There can be only one. */
3853 switch (**mangled)
3855 case '\0':
3856 case '_':
3857 break;
3858 case 'v':
3859 (*mangled)++;
3860 APPEND_BLANK (result);
3861 string_append (result, "void");
3862 break;
3863 case 'x':
3864 (*mangled)++;
3865 APPEND_BLANK (result);
3866 string_append (result, "long long");
3867 break;
3868 case 'l':
3869 (*mangled)++;
3870 APPEND_BLANK (result);
3871 string_append (result, "long");
3872 break;
3873 case 'i':
3874 (*mangled)++;
3875 APPEND_BLANK (result);
3876 string_append (result, "int");
3877 break;
3878 case 's':
3879 (*mangled)++;
3880 APPEND_BLANK (result);
3881 string_append (result, "short");
3882 break;
3883 case 'b':
3884 (*mangled)++;
3885 APPEND_BLANK (result);
3886 string_append (result, "bool");
3887 tk = tk_bool;
3888 break;
3889 case 'c':
3890 (*mangled)++;
3891 APPEND_BLANK (result);
3892 string_append (result, "char");
3893 tk = tk_char;
3894 break;
3895 case 'w':
3896 (*mangled)++;
3897 APPEND_BLANK (result);
3898 string_append (result, "wchar_t");
3899 tk = tk_char;
3900 break;
3901 case 'r':
3902 (*mangled)++;
3903 APPEND_BLANK (result);
3904 string_append (result, "long double");
3905 tk = tk_real;
3906 break;
3907 case 'd':
3908 (*mangled)++;
3909 APPEND_BLANK (result);
3910 string_append (result, "double");
3911 tk = tk_real;
3912 break;
3913 case 'f':
3914 (*mangled)++;
3915 APPEND_BLANK (result);
3916 string_append (result, "float");
3917 tk = tk_real;
3918 break;
3919 case 'G':
3920 (*mangled)++;
3921 if (!ISDIGIT ((unsigned char)**mangled))
3923 success = 0;
3924 break;
3926 case 'I':
3927 (*mangled)++;
3928 if (**mangled == '_')
3930 int i;
3931 (*mangled)++;
3932 for (i = 0;
3933 i < (long) sizeof (buf) - 1 && **mangled && **mangled != '_';
3934 (*mangled)++, i++)
3935 buf[i] = **mangled;
3936 if (**mangled != '_')
3938 success = 0;
3939 break;
3941 buf[i] = '\0';
3942 (*mangled)++;
3944 else
3946 strncpy (buf, *mangled, 2);
3947 buf[2] = '\0';
3948 *mangled += min (strlen (*mangled), 2);
3950 sscanf (buf, "%x", &dec);
3951 sprintf (buf, "int%u_t", dec);
3952 APPEND_BLANK (result);
3953 string_append (result, buf);
3954 break;
3956 /* fall through */
3957 /* An explicit type, such as "6mytype" or "7integer" */
3958 case '0':
3959 case '1':
3960 case '2':
3961 case '3':
3962 case '4':
3963 case '5':
3964 case '6':
3965 case '7':
3966 case '8':
3967 case '9':
3969 int bindex = register_Btype (work);
3970 string btype;
3971 string_init (&btype);
3972 if (demangle_class_name (work, mangled, &btype)) {
3973 remember_Btype (work, btype.b, LEN_STRING (&btype), bindex);
3974 APPEND_BLANK (result);
3975 string_appends (result, &btype);
3977 else
3978 success = 0;
3979 string_delete (&btype);
3980 break;
3982 case 't':
3984 success = demangle_template (work, mangled, &btype, 0, 1, 1);
3985 string_appends (result, &btype);
3986 break;
3988 default:
3989 success = 0;
3990 break;
3993 return success ? ((int) tk) : 0;
3997 /* Handle a template's value parameter for HP aCC (extension from ARM)
3998 **mangled points to 'S' or 'U' */
4000 static int
4001 do_hpacc_template_const_value (work, mangled, result)
4002 struct work_stuff *work ATTRIBUTE_UNUSED;
4003 const char **mangled;
4004 string *result;
4006 int unsigned_const;
4008 if (**mangled != 'U' && **mangled != 'S')
4009 return 0;
4011 unsigned_const = (**mangled == 'U');
4013 (*mangled)++;
4015 switch (**mangled)
4017 case 'N':
4018 string_append (result, "-");
4019 /* fall through */
4020 case 'P':
4021 (*mangled)++;
4022 break;
4023 case 'M':
4024 /* special case for -2^31 */
4025 string_append (result, "-2147483648");
4026 (*mangled)++;
4027 return 1;
4028 default:
4029 return 0;
4032 /* We have to be looking at an integer now */
4033 if (!(ISDIGIT ((unsigned char)**mangled)))
4034 return 0;
4036 /* We only deal with integral values for template
4037 parameters -- so it's OK to look only for digits */
4038 while (ISDIGIT ((unsigned char)**mangled))
4040 char_str[0] = **mangled;
4041 string_append (result, char_str);
4042 (*mangled)++;
4045 if (unsigned_const)
4046 string_append (result, "U");
4048 /* FIXME? Some day we may have 64-bit (or larger :-) ) constants
4049 with L or LL suffixes. pai/1997-09-03 */
4051 return 1; /* success */
4054 /* Handle a template's literal parameter for HP aCC (extension from ARM)
4055 **mangled is pointing to the 'A' */
4057 static int
4058 do_hpacc_template_literal (work, mangled, result)
4059 struct work_stuff *work;
4060 const char **mangled;
4061 string *result;
4063 int literal_len = 0;
4064 char * recurse;
4065 char * recurse_dem;
4067 if (**mangled != 'A')
4068 return 0;
4070 (*mangled)++;
4072 literal_len = consume_count (mangled);
4074 if (literal_len <= 0)
4075 return 0;
4077 /* Literal parameters are names of arrays, functions, etc. and the
4078 canonical representation uses the address operator */
4079 string_append (result, "&");
4081 /* Now recursively demangle the literal name */
4082 recurse = (char *) xmalloc (literal_len + 1);
4083 memcpy (recurse, *mangled, literal_len);
4084 recurse[literal_len] = '\000';
4086 recurse_dem = cplus_demangle (recurse, work->options);
4088 if (recurse_dem)
4090 string_append (result, recurse_dem);
4091 free (recurse_dem);
4093 else
4095 string_appendn (result, *mangled, literal_len);
4097 (*mangled) += literal_len;
4098 free (recurse);
4100 return 1;
4103 static int
4104 snarf_numeric_literal (args, arg)
4105 const char ** args;
4106 string * arg;
4108 if (**args == '-')
4110 char_str[0] = '-';
4111 string_append (arg, char_str);
4112 (*args)++;
4114 else if (**args == '+')
4115 (*args)++;
4117 if (!ISDIGIT ((unsigned char)**args))
4118 return 0;
4120 while (ISDIGIT ((unsigned char)**args))
4122 char_str[0] = **args;
4123 string_append (arg, char_str);
4124 (*args)++;
4127 return 1;
4130 /* Demangle the next argument, given by MANGLED into RESULT, which
4131 *should be an uninitialized* string. It will be initialized here,
4132 and free'd should anything go wrong. */
4134 static int
4135 do_arg (work, mangled, result)
4136 struct work_stuff *work;
4137 const char **mangled;
4138 string *result;
4140 /* Remember where we started so that we can record the type, for
4141 non-squangling type remembering. */
4142 const char *start = *mangled;
4144 string_init (result);
4146 if (work->nrepeats > 0)
4148 --work->nrepeats;
4150 if (work->previous_argument == 0)
4151 return 0;
4153 /* We want to reissue the previous type in this argument list. */
4154 string_appends (result, work->previous_argument);
4155 return 1;
4158 if (**mangled == 'n')
4160 /* A squangling-style repeat. */
4161 (*mangled)++;
4162 work->nrepeats = consume_count(mangled);
4164 if (work->nrepeats <= 0)
4165 /* This was not a repeat count after all. */
4166 return 0;
4168 if (work->nrepeats > 9)
4170 if (**mangled != '_')
4171 /* The repeat count should be followed by an '_' in this
4172 case. */
4173 return 0;
4174 else
4175 (*mangled)++;
4178 /* Now, the repeat is all set up. */
4179 return do_arg (work, mangled, result);
4182 /* Save the result in WORK->previous_argument so that we can find it
4183 if it's repeated. Note that saving START is not good enough: we
4184 do not want to add additional types to the back-referenceable
4185 type vector when processing a repeated type. */
4186 if (work->previous_argument)
4187 string_clear (work->previous_argument);
4188 else
4190 work->previous_argument = (string*) xmalloc (sizeof (string));
4191 string_init (work->previous_argument);
4194 if (!do_type (work, mangled, work->previous_argument))
4195 return 0;
4197 string_appends (result, work->previous_argument);
4199 remember_type (work, start, *mangled - start);
4200 return 1;
4203 static void
4204 remember_type (work, start, len)
4205 struct work_stuff *work;
4206 const char *start;
4207 int len;
4209 char *tem;
4211 if (work->forgetting_types)
4212 return;
4214 if (work -> ntypes >= work -> typevec_size)
4216 if (work -> typevec_size == 0)
4218 work -> typevec_size = 3;
4219 work -> typevec
4220 = (char **) xmalloc (sizeof (char *) * work -> typevec_size);
4222 else
4224 work -> typevec_size *= 2;
4225 work -> typevec
4226 = (char **) xrealloc ((char *)work -> typevec,
4227 sizeof (char *) * work -> typevec_size);
4230 tem = xmalloc (len + 1);
4231 memcpy (tem, start, len);
4232 tem[len] = '\0';
4233 work -> typevec[work -> ntypes++] = tem;
4237 /* Remember a K type class qualifier. */
4238 static void
4239 remember_Ktype (work, start, len)
4240 struct work_stuff *work;
4241 const char *start;
4242 int len;
4244 char *tem;
4246 if (work -> numk >= work -> ksize)
4248 if (work -> ksize == 0)
4250 work -> ksize = 5;
4251 work -> ktypevec
4252 = (char **) xmalloc (sizeof (char *) * work -> ksize);
4254 else
4256 work -> ksize *= 2;
4257 work -> ktypevec
4258 = (char **) xrealloc ((char *)work -> ktypevec,
4259 sizeof (char *) * work -> ksize);
4262 tem = xmalloc (len + 1);
4263 memcpy (tem, start, len);
4264 tem[len] = '\0';
4265 work -> ktypevec[work -> numk++] = tem;
4268 /* Register a B code, and get an index for it. B codes are registered
4269 as they are seen, rather than as they are completed, so map<temp<char> >
4270 registers map<temp<char> > as B0, and temp<char> as B1 */
4272 static int
4273 register_Btype (work)
4274 struct work_stuff *work;
4276 int ret;
4278 if (work -> numb >= work -> bsize)
4280 if (work -> bsize == 0)
4282 work -> bsize = 5;
4283 work -> btypevec
4284 = (char **) xmalloc (sizeof (char *) * work -> bsize);
4286 else
4288 work -> bsize *= 2;
4289 work -> btypevec
4290 = (char **) xrealloc ((char *)work -> btypevec,
4291 sizeof (char *) * work -> bsize);
4294 ret = work -> numb++;
4295 work -> btypevec[ret] = NULL;
4296 return(ret);
4299 /* Store a value into a previously registered B code type. */
4301 static void
4302 remember_Btype (work, start, len, index)
4303 struct work_stuff *work;
4304 const char *start;
4305 int len, index;
4307 char *tem;
4309 tem = xmalloc (len + 1);
4310 memcpy (tem, start, len);
4311 tem[len] = '\0';
4312 work -> btypevec[index] = tem;
4315 /* Lose all the info related to B and K type codes. */
4316 static void
4317 forget_B_and_K_types (work)
4318 struct work_stuff *work;
4320 int i;
4322 while (work -> numk > 0)
4324 i = --(work -> numk);
4325 if (work -> ktypevec[i] != NULL)
4327 free (work -> ktypevec[i]);
4328 work -> ktypevec[i] = NULL;
4332 while (work -> numb > 0)
4334 i = --(work -> numb);
4335 if (work -> btypevec[i] != NULL)
4337 free (work -> btypevec[i]);
4338 work -> btypevec[i] = NULL;
4342 /* Forget the remembered types, but not the type vector itself. */
4344 static void
4345 forget_types (work)
4346 struct work_stuff *work;
4348 int i;
4350 while (work -> ntypes > 0)
4352 i = --(work -> ntypes);
4353 if (work -> typevec[i] != NULL)
4355 free (work -> typevec[i]);
4356 work -> typevec[i] = NULL;
4361 /* Process the argument list part of the signature, after any class spec
4362 has been consumed, as well as the first 'F' character (if any). For
4363 example:
4365 "__als__3fooRT0" => process "RT0"
4366 "complexfunc5__FPFPc_PFl_i" => process "PFPc_PFl_i"
4368 DECLP must be already initialised, usually non-empty. It won't be freed
4369 on failure.
4371 Note that g++ differs significantly from ARM and lucid style mangling
4372 with regards to references to previously seen types. For example, given
4373 the source fragment:
4375 class foo {
4376 public:
4377 foo::foo (int, foo &ia, int, foo &ib, int, foo &ic);
4380 foo::foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
4381 void foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
4383 g++ produces the names:
4385 __3fooiRT0iT2iT2
4386 foo__FiR3fooiT1iT1
4388 while lcc (and presumably other ARM style compilers as well) produces:
4390 foo__FiR3fooT1T2T1T2
4391 __ct__3fooFiR3fooT1T2T1T2
4393 Note that g++ bases its type numbers starting at zero and counts all
4394 previously seen types, while lucid/ARM bases its type numbers starting
4395 at one and only considers types after it has seen the 'F' character
4396 indicating the start of the function args. For lucid/ARM style, we
4397 account for this difference by discarding any previously seen types when
4398 we see the 'F' character, and subtracting one from the type number
4399 reference.
4403 static int
4404 demangle_args (work, mangled, declp)
4405 struct work_stuff *work;
4406 const char **mangled;
4407 string *declp;
4409 string arg;
4410 int need_comma = 0;
4411 int r;
4412 int t;
4413 const char *tem;
4414 char temptype;
4416 if (PRINT_ARG_TYPES)
4418 string_append (declp, "(");
4419 if (**mangled == '\0')
4421 string_append (declp, "void");
4425 while ((**mangled != '_' && **mangled != '\0' && **mangled != 'e')
4426 || work->nrepeats > 0)
4428 if ((**mangled == 'N') || (**mangled == 'T'))
4430 temptype = *(*mangled)++;
4432 if (temptype == 'N')
4434 if (!get_count (mangled, &r))
4436 return (0);
4439 else
4441 r = 1;
4443 if ((HP_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING) && work -> ntypes >= 10)
4445 /* If we have 10 or more types we might have more than a 1 digit
4446 index so we'll have to consume the whole count here. This
4447 will lose if the next thing is a type name preceded by a
4448 count but it's impossible to demangle that case properly
4449 anyway. Eg if we already have 12 types is T12Pc "(..., type1,
4450 Pc, ...)" or "(..., type12, char *, ...)" */
4451 if ((t = consume_count(mangled)) <= 0)
4453 return (0);
4456 else
4458 if (!get_count (mangled, &t))
4460 return (0);
4463 if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
4465 t--;
4467 /* Validate the type index. Protect against illegal indices from
4468 malformed type strings. */
4469 if ((t < 0) || (t >= work -> ntypes))
4471 return (0);
4473 while (work->nrepeats > 0 || --r >= 0)
4475 tem = work -> typevec[t];
4476 if (need_comma && PRINT_ARG_TYPES)
4478 string_append (declp, ", ");
4480 if (!do_arg (work, &tem, &arg))
4482 return (0);
4484 if (PRINT_ARG_TYPES)
4486 string_appends (declp, &arg);
4488 string_delete (&arg);
4489 need_comma = 1;
4492 else
4494 if (need_comma && PRINT_ARG_TYPES)
4495 string_append (declp, ", ");
4496 if (!do_arg (work, mangled, &arg))
4497 return (0);
4498 if (PRINT_ARG_TYPES)
4499 string_appends (declp, &arg);
4500 string_delete (&arg);
4501 need_comma = 1;
4505 if (**mangled == 'e')
4507 (*mangled)++;
4508 if (PRINT_ARG_TYPES)
4510 if (need_comma)
4512 string_append (declp, ",");
4514 string_append (declp, "...");
4518 if (PRINT_ARG_TYPES)
4520 string_append (declp, ")");
4522 return (1);
4525 /* Like demangle_args, but for demangling the argument lists of function
4526 and method pointers or references, not top-level declarations. */
4528 static int
4529 demangle_nested_args (work, mangled, declp)
4530 struct work_stuff *work;
4531 const char **mangled;
4532 string *declp;
4534 string* saved_previous_argument;
4535 int result;
4536 int saved_nrepeats;
4538 /* The G++ name-mangling algorithm does not remember types on nested
4539 argument lists, unless -fsquangling is used, and in that case the
4540 type vector updated by remember_type is not used. So, we turn
4541 off remembering of types here. */
4542 ++work->forgetting_types;
4544 /* For the repeat codes used with -fsquangling, we must keep track of
4545 the last argument. */
4546 saved_previous_argument = work->previous_argument;
4547 saved_nrepeats = work->nrepeats;
4548 work->previous_argument = 0;
4549 work->nrepeats = 0;
4551 /* Actually demangle the arguments. */
4552 result = demangle_args (work, mangled, declp);
4554 /* Restore the previous_argument field. */
4555 if (work->previous_argument)
4556 string_delete (work->previous_argument);
4557 work->previous_argument = saved_previous_argument;
4558 --work->forgetting_types;
4559 work->nrepeats = saved_nrepeats;
4561 return result;
4564 static void
4565 demangle_function_name (work, mangled, declp, scan)
4566 struct work_stuff *work;
4567 const char **mangled;
4568 string *declp;
4569 const char *scan;
4571 size_t i;
4572 string type;
4573 const char *tem;
4575 string_appendn (declp, (*mangled), scan - (*mangled));
4576 string_need (declp, 1);
4577 *(declp -> p) = '\0';
4579 /* Consume the function name, including the "__" separating the name
4580 from the signature. We are guaranteed that SCAN points to the
4581 separator. */
4583 (*mangled) = scan + 2;
4584 /* We may be looking at an instantiation of a template function:
4585 foo__Xt1t2_Ft3t4, where t1, t2, ... are template arguments and a
4586 following _F marks the start of the function arguments. Handle
4587 the template arguments first. */
4589 if (HP_DEMANGLING && (**mangled == 'X'))
4591 demangle_arm_hp_template (work, mangled, 0, declp);
4592 /* This leaves MANGLED pointing to the 'F' marking func args */
4595 if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
4598 /* See if we have an ARM style constructor or destructor operator.
4599 If so, then just record it, clear the decl, and return.
4600 We can't build the actual constructor/destructor decl until later,
4601 when we recover the class name from the signature. */
4603 if (strcmp (declp -> b, "__ct") == 0)
4605 work -> constructor += 1;
4606 string_clear (declp);
4607 return;
4609 else if (strcmp (declp -> b, "__dt") == 0)
4611 work -> destructor += 1;
4612 string_clear (declp);
4613 return;
4617 if (declp->p - declp->b >= 3
4618 && declp->b[0] == 'o'
4619 && declp->b[1] == 'p'
4620 && strchr (cplus_markers, declp->b[2]) != NULL)
4622 /* see if it's an assignment expression */
4623 if (declp->p - declp->b >= 10 /* op$assign_ */
4624 && memcmp (declp->b + 3, "assign_", 7) == 0)
4626 for (i = 0; i < ARRAY_SIZE (optable); i++)
4628 int len = declp->p - declp->b - 10;
4629 if ((int) strlen (optable[i].in) == len
4630 && memcmp (optable[i].in, declp->b + 10, len) == 0)
4632 string_clear (declp);
4633 string_append (declp, "operator");
4634 string_append (declp, optable[i].out);
4635 string_append (declp, "=");
4636 break;
4640 else
4642 for (i = 0; i < ARRAY_SIZE (optable); i++)
4644 int len = declp->p - declp->b - 3;
4645 if ((int) strlen (optable[i].in) == len
4646 && memcmp (optable[i].in, declp->b + 3, len) == 0)
4648 string_clear (declp);
4649 string_append (declp, "operator");
4650 string_append (declp, optable[i].out);
4651 break;
4656 else if (declp->p - declp->b >= 5 && memcmp (declp->b, "type", 4) == 0
4657 && strchr (cplus_markers, declp->b[4]) != NULL)
4659 /* type conversion operator */
4660 tem = declp->b + 5;
4661 if (do_type (work, &tem, &type))
4663 string_clear (declp);
4664 string_append (declp, "operator ");
4665 string_appends (declp, &type);
4666 string_delete (&type);
4669 else if (declp->b[0] == '_' && declp->b[1] == '_'
4670 && declp->b[2] == 'o' && declp->b[3] == 'p')
4672 /* ANSI. */
4673 /* type conversion operator. */
4674 tem = declp->b + 4;
4675 if (do_type (work, &tem, &type))
4677 string_clear (declp);
4678 string_append (declp, "operator ");
4679 string_appends (declp, &type);
4680 string_delete (&type);
4683 else if (declp->b[0] == '_' && declp->b[1] == '_'
4684 && ISLOWER((unsigned char)declp->b[2])
4685 && ISLOWER((unsigned char)declp->b[3]))
4687 if (declp->b[4] == '\0')
4689 /* Operator. */
4690 for (i = 0; i < ARRAY_SIZE (optable); i++)
4692 if (strlen (optable[i].in) == 2
4693 && memcmp (optable[i].in, declp->b + 2, 2) == 0)
4695 string_clear (declp);
4696 string_append (declp, "operator");
4697 string_append (declp, optable[i].out);
4698 break;
4702 else
4704 if (declp->b[2] == 'a' && declp->b[5] == '\0')
4706 /* Assignment. */
4707 for (i = 0; i < ARRAY_SIZE (optable); i++)
4709 if (strlen (optable[i].in) == 3
4710 && memcmp (optable[i].in, declp->b + 2, 3) == 0)
4712 string_clear (declp);
4713 string_append (declp, "operator");
4714 string_append (declp, optable[i].out);
4715 break;
4723 /* a mini string-handling package */
4725 static void
4726 string_need (s, n)
4727 string *s;
4728 int n;
4730 int tem;
4732 if (s->b == NULL)
4734 if (n < 32)
4736 n = 32;
4738 s->p = s->b = xmalloc (n);
4739 s->e = s->b + n;
4741 else if (s->e - s->p < n)
4743 tem = s->p - s->b;
4744 n += tem;
4745 n *= 2;
4746 s->b = xrealloc (s->b, n);
4747 s->p = s->b + tem;
4748 s->e = s->b + n;
4752 static void
4753 string_delete (s)
4754 string *s;
4756 if (s->b != NULL)
4758 free (s->b);
4759 s->b = s->e = s->p = NULL;
4763 static void
4764 string_init (s)
4765 string *s;
4767 s->b = s->p = s->e = NULL;
4770 static void
4771 string_clear (s)
4772 string *s;
4774 s->p = s->b;
4777 #if 0
4779 static int
4780 string_empty (s)
4781 string *s;
4783 return (s->b == s->p);
4786 #endif
4788 static void
4789 string_append (p, s)
4790 string *p;
4791 const char *s;
4793 int n;
4794 if (s == NULL || *s == '\0')
4795 return;
4796 n = strlen (s);
4797 string_need (p, n);
4798 memcpy (p->p, s, n);
4799 p->p += n;
4802 static void
4803 string_appends (p, s)
4804 string *p, *s;
4806 int n;
4808 if (s->b != s->p)
4810 n = s->p - s->b;
4811 string_need (p, n);
4812 memcpy (p->p, s->b, n);
4813 p->p += n;
4817 static void
4818 string_appendn (p, s, n)
4819 string *p;
4820 const char *s;
4821 int n;
4823 if (n != 0)
4825 string_need (p, n);
4826 memcpy (p->p, s, n);
4827 p->p += n;
4831 static void
4832 string_prepend (p, s)
4833 string *p;
4834 const char *s;
4836 if (s != NULL && *s != '\0')
4838 string_prependn (p, s, strlen (s));
4842 static void
4843 string_prepends (p, s)
4844 string *p, *s;
4846 if (s->b != s->p)
4848 string_prependn (p, s->b, s->p - s->b);
4852 static void
4853 string_prependn (p, s, n)
4854 string *p;
4855 const char *s;
4856 int n;
4858 char *q;
4860 if (n != 0)
4862 string_need (p, n);
4863 for (q = p->p - 1; q >= p->b; q--)
4865 q[n] = q[0];
4867 memcpy (p->b, s, n);
4868 p->p += n;
4872 static void
4873 string_append_template_idx (s, idx)
4874 string *s;
4875 int idx;
4877 char buf[INTBUF_SIZE + 1 /* 'T' */];
4878 sprintf(buf, "T%d", idx);
4879 string_append (s, buf);
4882 /* To generate a standalone demangler program for testing purposes,
4883 just compile and link this file with -DMAIN and libiberty.a. When
4884 run, it demangles each command line arg, or each stdin string, and
4885 prints the result on stdout. */
4887 #ifdef MAIN
4889 #include "getopt.h"
4891 static const char *program_name;
4892 static const char *program_version = VERSION;
4893 static int flags = DMGL_PARAMS | DMGL_ANSI;
4895 static void demangle_it PARAMS ((char *));
4896 static void usage PARAMS ((FILE *, int)) ATTRIBUTE_NORETURN;
4897 static void fatal PARAMS ((const char *)) ATTRIBUTE_NORETURN;
4898 static void print_demangler_list PARAMS ((FILE *));
4900 static void
4901 demangle_it (mangled_name)
4902 char *mangled_name;
4904 char *result;
4906 result = cplus_demangle (mangled_name, flags);
4907 if (result == NULL)
4909 printf ("%s\n", mangled_name);
4911 else
4913 printf ("%s\n", result);
4914 free (result);
4918 static void
4919 print_demangler_list (stream)
4920 FILE *stream;
4922 const struct demangler_engine *demangler;
4924 fprintf (stream, "{%s", libiberty_demanglers->demangling_style_name);
4926 for (demangler = libiberty_demanglers + 1;
4927 demangler->demangling_style != unknown_demangling;
4928 ++demangler)
4929 fprintf (stream, ",%s", demangler->demangling_style_name);
4931 fprintf (stream, "}");
4934 static void
4935 usage (stream, status)
4936 FILE *stream;
4937 int status;
4939 fprintf (stream, "\
4940 Usage: %s [-_] [-n] [--strip-underscores] [--no-strip-underscores] \n",
4941 program_name);
4943 fprintf (stream, "\
4944 [-s ");
4945 print_demangler_list (stream);
4946 fprintf (stream, "]\n");
4948 fprintf (stream, "\
4949 [--format ");
4950 print_demangler_list (stream);
4951 fprintf (stream, "]\n");
4953 fprintf (stream, "\
4954 [--help] [--version] [arg...]\n");
4955 exit (status);
4958 #define MBUF_SIZE 32767
4959 char mbuffer[MBUF_SIZE];
4961 /* Defined in the automatically-generated underscore.c. */
4962 extern int prepends_underscore;
4964 int strip_underscore = 0;
4966 static struct option long_options[] = {
4967 {"strip-underscores", no_argument, 0, '_'},
4968 {"format", required_argument, 0, 's'},
4969 {"help", no_argument, 0, 'h'},
4970 {"no-strip-underscores", no_argument, 0, 'n'},
4971 {"version", no_argument, 0, 'v'},
4972 {0, no_argument, 0, 0}
4975 /* More 'friendly' abort that prints the line and file.
4976 config.h can #define abort fancy_abort if you like that sort of thing. */
4978 void
4979 fancy_abort ()
4981 fatal ("Internal gcc abort.");
4985 static const char *
4986 standard_symbol_characters PARAMS ((void));
4988 static const char *
4989 hp_symbol_characters PARAMS ((void));
4991 static const char *
4992 gnu_v3_symbol_characters PARAMS ((void));
4994 /* Return the string of non-alnum characters that may occur
4995 as a valid symbol component, in the standard assembler symbol
4996 syntax. */
4998 static const char *
4999 standard_symbol_characters ()
5001 return "_$.";
5005 /* Return the string of non-alnum characters that may occur
5006 as a valid symbol name component in an HP object file.
5008 Note that, since HP's compiler generates object code straight from
5009 C++ source, without going through an assembler, its mangled
5010 identifiers can use all sorts of characters that no assembler would
5011 tolerate, so the alphabet this function creates is a little odd.
5012 Here are some sample mangled identifiers offered by HP:
5014 typeid*__XT24AddressIndExpClassMember_
5015 [Vftptr]key:__dt__32OrdinaryCompareIndExpClassMemberFv
5016 __ct__Q2_9Elf64_Dyn18{unnamed.union.#1}Fv
5018 This still seems really weird to me, since nowhere else in this
5019 file is there anything to recognize curly brackets, parens, etc.
5020 I've talked with Srikanth <srikanth@cup.hp.com>, and he assures me
5021 this is right, but I still strongly suspect that there's a
5022 misunderstanding here.
5024 If we decide it's better for c++filt to use HP's assembler syntax
5025 to scrape identifiers out of its input, here's the definition of
5026 the symbol name syntax from the HP assembler manual:
5028 Symbols are composed of uppercase and lowercase letters, decimal
5029 digits, dollar symbol, period (.), ampersand (&), pound sign(#) and
5030 underscore (_). A symbol can begin with a letter, digit underscore or
5031 dollar sign. If a symbol begins with a digit, it must contain a
5032 non-digit character.
5034 So have fun. */
5035 static const char *
5036 hp_symbol_characters ()
5038 return "_$.<>#,*&[]:(){}";
5042 /* Return the string of non-alnum characters that may occur
5043 as a valid symbol component in the GNU C++ V3 ABI mangling
5044 scheme. */
5046 static const char *
5047 gnu_v3_symbol_characters ()
5049 return "_$.";
5053 extern int main PARAMS ((int, char **));
5056 main (argc, argv)
5057 int argc;
5058 char **argv;
5060 char *result;
5061 int c;
5062 const char *valid_symbols;
5063 enum demangling_styles style = auto_demangling;
5065 program_name = argv[0];
5067 strip_underscore = prepends_underscore;
5069 while ((c = getopt_long (argc, argv, "_ns:", long_options, (int *) 0)) != EOF)
5071 switch (c)
5073 case '?':
5074 usage (stderr, 1);
5075 break;
5076 case 'h':
5077 usage (stdout, 0);
5078 case 'n':
5079 strip_underscore = 0;
5080 break;
5081 case 'v':
5082 printf ("GNU %s (C++ demangler), version %s\n", program_name, program_version);
5083 return (0);
5084 case '_':
5085 strip_underscore = 1;
5086 break;
5087 case 's':
5089 style = cplus_demangle_name_to_style (optarg);
5090 if (style == unknown_demangling)
5092 fprintf (stderr, "%s: unknown demangling style `%s'\n",
5093 program_name, optarg);
5094 return (1);
5096 else
5097 cplus_demangle_set_style (style);
5099 break;
5103 if (optind < argc)
5105 for ( ; optind < argc; optind++)
5107 demangle_it (argv[optind]);
5110 else
5112 switch (current_demangling_style)
5114 case gnu_demangling:
5115 case lucid_demangling:
5116 case arm_demangling:
5117 case java_demangling:
5118 case edg_demangling:
5119 case gnat_demangling:
5120 case auto_demangling:
5121 valid_symbols = standard_symbol_characters ();
5122 break;
5123 case hp_demangling:
5124 valid_symbols = hp_symbol_characters ();
5125 break;
5126 case gnu_v3_demangling:
5127 valid_symbols = gnu_v3_symbol_characters ();
5128 break;
5129 default:
5130 /* Folks should explicitly indicate the appropriate alphabet for
5131 each demangling. Providing a default would allow the
5132 question to go unconsidered. */
5133 abort ();
5136 for (;;)
5138 int i = 0;
5139 c = getchar ();
5140 /* Try to read a label. */
5141 while (c != EOF && (ISALNUM (c) || strchr (valid_symbols, c)))
5143 if (i >= MBUF_SIZE-1)
5144 break;
5145 mbuffer[i++] = c;
5146 c = getchar ();
5148 if (i > 0)
5150 int skip_first = 0;
5152 if (mbuffer[0] == '.' || mbuffer[0] == '$')
5153 ++skip_first;
5154 if (strip_underscore && mbuffer[skip_first] == '_')
5155 ++skip_first;
5157 if (skip_first > i)
5158 skip_first = i;
5160 mbuffer[i] = 0;
5161 flags |= (int) style;
5162 result = cplus_demangle (mbuffer + skip_first, flags);
5163 if (result)
5165 if (mbuffer[0] == '.')
5166 putc ('.', stdout);
5167 fputs (result, stdout);
5168 free (result);
5170 else
5171 fputs (mbuffer, stdout);
5173 fflush (stdout);
5175 if (c == EOF)
5176 break;
5177 putchar (c);
5178 fflush (stdout);
5182 return (0);
5185 static void
5186 fatal (str)
5187 const char *str;
5189 fprintf (stderr, "%s: %s\n", program_name, str);
5190 exit (1);
5194 xmalloc (size)
5195 size_t size;
5197 register PTR value = (PTR) malloc (size);
5198 if (value == 0)
5199 fatal ("virtual memory exhausted");
5200 return value;
5204 xrealloc (ptr, size)
5205 PTR ptr;
5206 size_t size;
5208 register PTR value = (PTR) realloc (ptr, size);
5209 if (value == 0)
5210 fatal ("virtual memory exhausted");
5211 return value;
5213 #endif /* main */