daily update
[binutils.git] / libiberty / cplus-dem.c
blobf42d6181d403b2e06a4d180d769a5a3003c9fc54
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 /* In order to allow a single demangler executable to demangle strings
67 using various common values of CPLUS_MARKER, as well as any specific
68 one set at compile time, we maintain a string containing all the
69 commonly used ones, and check to see if the marker we are looking for
70 is in that string. CPLUS_MARKER is usually '$' on systems where the
71 assembler can deal with that. Where the assembler can't, it's usually
72 '.' (but on many systems '.' is used for other things). We put the
73 current defined CPLUS_MARKER first (which defaults to '$'), followed
74 by the next most common value, followed by an explicit '$' in case
75 the value of CPLUS_MARKER is not '$'.
77 We could avoid this if we could just get g++ to tell us what the actual
78 cplus marker character is as part of the debug information, perhaps by
79 ensuring that it is the character that terminates the gcc<n>_compiled
80 marker symbol (FIXME). */
82 #if !defined (CPLUS_MARKER)
83 #define CPLUS_MARKER '$'
84 #endif
86 enum demangling_styles current_demangling_style = auto_demangling;
88 static char cplus_markers[] = { CPLUS_MARKER, '.', '$', '\0' };
90 static char char_str[2] = { '\000', '\000' };
92 void
93 set_cplus_marker_for_demangling (ch)
94 int ch;
96 cplus_markers[0] = ch;
99 typedef struct string /* Beware: these aren't required to be */
100 { /* '\0' terminated. */
101 char *b; /* pointer to start of string */
102 char *p; /* pointer after last character */
103 char *e; /* pointer after end of allocated space */
104 } string;
106 /* Stuff that is shared between sub-routines.
107 Using a shared structure allows cplus_demangle to be reentrant. */
109 struct work_stuff
111 int options;
112 char **typevec;
113 char **ktypevec;
114 char **btypevec;
115 int numk;
116 int numb;
117 int ksize;
118 int bsize;
119 int ntypes;
120 int typevec_size;
121 int constructor;
122 int destructor;
123 int static_type; /* A static member function */
124 int temp_start; /* index in demangled to start of template args */
125 int type_quals; /* The type qualifiers. */
126 int dllimported; /* Symbol imported from a PE DLL */
127 char **tmpl_argvec; /* Template function arguments. */
128 int ntmpl_args; /* The number of template function arguments. */
129 int forgetting_types; /* Nonzero if we are not remembering the types
130 we see. */
131 string* previous_argument; /* The last function argument demangled. */
132 int nrepeats; /* The number of times to repeat the previous
133 argument. */
136 #define PRINT_ANSI_QUALIFIERS (work -> options & DMGL_ANSI)
137 #define PRINT_ARG_TYPES (work -> options & DMGL_PARAMS)
139 static const struct optable
141 const char *const in;
142 const char *const out;
143 const int flags;
144 } optable[] = {
145 {"nw", " new", DMGL_ANSI}, /* new (1.92, ansi) */
146 {"dl", " delete", DMGL_ANSI}, /* new (1.92, ansi) */
147 {"new", " new", 0}, /* old (1.91, and 1.x) */
148 {"delete", " delete", 0}, /* old (1.91, and 1.x) */
149 {"vn", " new []", DMGL_ANSI}, /* GNU, pending ansi */
150 {"vd", " delete []", DMGL_ANSI}, /* GNU, pending ansi */
151 {"as", "=", DMGL_ANSI}, /* ansi */
152 {"ne", "!=", DMGL_ANSI}, /* old, ansi */
153 {"eq", "==", DMGL_ANSI}, /* old, ansi */
154 {"ge", ">=", DMGL_ANSI}, /* old, ansi */
155 {"gt", ">", DMGL_ANSI}, /* old, ansi */
156 {"le", "<=", DMGL_ANSI}, /* old, ansi */
157 {"lt", "<", DMGL_ANSI}, /* old, ansi */
158 {"plus", "+", 0}, /* old */
159 {"pl", "+", DMGL_ANSI}, /* ansi */
160 {"apl", "+=", DMGL_ANSI}, /* ansi */
161 {"minus", "-", 0}, /* old */
162 {"mi", "-", DMGL_ANSI}, /* ansi */
163 {"ami", "-=", DMGL_ANSI}, /* ansi */
164 {"mult", "*", 0}, /* old */
165 {"ml", "*", DMGL_ANSI}, /* ansi */
166 {"amu", "*=", DMGL_ANSI}, /* ansi (ARM/Lucid) */
167 {"aml", "*=", DMGL_ANSI}, /* ansi (GNU/g++) */
168 {"convert", "+", 0}, /* old (unary +) */
169 {"negate", "-", 0}, /* old (unary -) */
170 {"trunc_mod", "%", 0}, /* old */
171 {"md", "%", DMGL_ANSI}, /* ansi */
172 {"amd", "%=", DMGL_ANSI}, /* ansi */
173 {"trunc_div", "/", 0}, /* old */
174 {"dv", "/", DMGL_ANSI}, /* ansi */
175 {"adv", "/=", DMGL_ANSI}, /* ansi */
176 {"truth_andif", "&&", 0}, /* old */
177 {"aa", "&&", DMGL_ANSI}, /* ansi */
178 {"truth_orif", "||", 0}, /* old */
179 {"oo", "||", DMGL_ANSI}, /* ansi */
180 {"truth_not", "!", 0}, /* old */
181 {"nt", "!", DMGL_ANSI}, /* ansi */
182 {"postincrement","++", 0}, /* old */
183 {"pp", "++", DMGL_ANSI}, /* ansi */
184 {"postdecrement","--", 0}, /* old */
185 {"mm", "--", DMGL_ANSI}, /* ansi */
186 {"bit_ior", "|", 0}, /* old */
187 {"or", "|", DMGL_ANSI}, /* ansi */
188 {"aor", "|=", DMGL_ANSI}, /* ansi */
189 {"bit_xor", "^", 0}, /* old */
190 {"er", "^", DMGL_ANSI}, /* ansi */
191 {"aer", "^=", DMGL_ANSI}, /* ansi */
192 {"bit_and", "&", 0}, /* old */
193 {"ad", "&", DMGL_ANSI}, /* ansi */
194 {"aad", "&=", DMGL_ANSI}, /* ansi */
195 {"bit_not", "~", 0}, /* old */
196 {"co", "~", DMGL_ANSI}, /* ansi */
197 {"call", "()", 0}, /* old */
198 {"cl", "()", DMGL_ANSI}, /* ansi */
199 {"alshift", "<<", 0}, /* old */
200 {"ls", "<<", DMGL_ANSI}, /* ansi */
201 {"als", "<<=", DMGL_ANSI}, /* ansi */
202 {"arshift", ">>", 0}, /* old */
203 {"rs", ">>", DMGL_ANSI}, /* ansi */
204 {"ars", ">>=", DMGL_ANSI}, /* ansi */
205 {"component", "->", 0}, /* old */
206 {"pt", "->", DMGL_ANSI}, /* ansi; Lucid C++ form */
207 {"rf", "->", DMGL_ANSI}, /* ansi; ARM/GNU form */
208 {"indirect", "*", 0}, /* old */
209 {"method_call", "->()", 0}, /* old */
210 {"addr", "&", 0}, /* old (unary &) */
211 {"array", "[]", 0}, /* old */
212 {"vc", "[]", DMGL_ANSI}, /* ansi */
213 {"compound", ", ", 0}, /* old */
214 {"cm", ", ", DMGL_ANSI}, /* ansi */
215 {"cond", "?:", 0}, /* old */
216 {"cn", "?:", DMGL_ANSI}, /* pseudo-ansi */
217 {"max", ">?", 0}, /* old */
218 {"mx", ">?", DMGL_ANSI}, /* pseudo-ansi */
219 {"min", "<?", 0}, /* old */
220 {"mn", "<?", DMGL_ANSI}, /* pseudo-ansi */
221 {"nop", "", 0}, /* old (for operator=) */
222 {"rm", "->*", DMGL_ANSI}, /* ansi */
223 {"sz", "sizeof ", DMGL_ANSI} /* pseudo-ansi */
226 /* These values are used to indicate the various type varieties.
227 They are all non-zero so that they can be used as `success'
228 values. */
229 typedef enum type_kind_t
231 tk_none,
232 tk_pointer,
233 tk_reference,
234 tk_integral,
235 tk_bool,
236 tk_char,
237 tk_real
238 } type_kind_t;
240 const struct demangler_engine libiberty_demanglers[] =
243 NO_DEMANGLING_STYLE_STRING,
244 no_demangling,
245 "Demangling disabled"
249 AUTO_DEMANGLING_STYLE_STRING,
250 auto_demangling,
251 "Automatic selection based on executable"
255 GNU_DEMANGLING_STYLE_STRING,
256 gnu_demangling,
257 "GNU (g++) style demangling"
261 LUCID_DEMANGLING_STYLE_STRING,
262 lucid_demangling,
263 "Lucid (lcc) style demangling"
267 ARM_DEMANGLING_STYLE_STRING,
268 arm_demangling,
269 "ARM style demangling"
273 HP_DEMANGLING_STYLE_STRING,
274 hp_demangling,
275 "HP (aCC) style demangling"
279 EDG_DEMANGLING_STYLE_STRING,
280 edg_demangling,
281 "EDG style demangling"
285 GNU_V3_DEMANGLING_STYLE_STRING,
286 gnu_v3_demangling,
287 "GNU (g++) V3 ABI-style demangling"
291 JAVA_DEMANGLING_STYLE_STRING,
292 java_demangling,
293 "Java style demangling"
297 GNAT_DEMANGLING_STYLE_STRING,
298 gnat_demangling,
299 "GNAT style demangling"
303 NULL, unknown_demangling, NULL
307 #define STRING_EMPTY(str) ((str) -> b == (str) -> p)
308 #define APPEND_BLANK(str) {if (!STRING_EMPTY(str)) \
309 string_append(str, " ");}
310 #define LEN_STRING(str) ( (STRING_EMPTY(str))?0:((str)->p - (str)->b))
312 /* The scope separator appropriate for the language being demangled. */
314 #define SCOPE_STRING(work) ((work->options & DMGL_JAVA) ? "." : "::")
316 #define ARM_VTABLE_STRING "__vtbl__" /* Lucid/ARM virtual table prefix */
317 #define ARM_VTABLE_STRLEN 8 /* strlen (ARM_VTABLE_STRING) */
319 /* Prototypes for local functions */
321 static void
322 delete_work_stuff PARAMS ((struct work_stuff *));
324 static void
325 delete_non_B_K_work_stuff PARAMS ((struct work_stuff *));
327 static char *
328 mop_up PARAMS ((struct work_stuff *, string *, int));
330 static void
331 squangle_mop_up PARAMS ((struct work_stuff *));
333 static void
334 work_stuff_copy_to_from PARAMS ((struct work_stuff *, struct work_stuff *));
336 #if 0
337 static int
338 demangle_method_args PARAMS ((struct work_stuff *, const char **, string *));
339 #endif
341 static char *
342 internal_cplus_demangle PARAMS ((struct work_stuff *, const char *));
344 static int
345 demangle_template_template_parm PARAMS ((struct work_stuff *work,
346 const char **, string *));
348 static int
349 demangle_template PARAMS ((struct work_stuff *work, const char **, string *,
350 string *, int, int));
352 static int
353 arm_pt PARAMS ((struct work_stuff *, const char *, int, const char **,
354 const char **));
356 static int
357 demangle_class_name PARAMS ((struct work_stuff *, const char **, string *));
359 static int
360 demangle_qualified PARAMS ((struct work_stuff *, const char **, string *,
361 int, int));
363 static int
364 demangle_class PARAMS ((struct work_stuff *, const char **, string *));
366 static int
367 demangle_fund_type PARAMS ((struct work_stuff *, const char **, string *));
369 static int
370 demangle_signature PARAMS ((struct work_stuff *, const char **, string *));
372 static int
373 demangle_prefix PARAMS ((struct work_stuff *, const char **, string *));
375 static int
376 gnu_special PARAMS ((struct work_stuff *, const char **, string *));
378 static int
379 arm_special PARAMS ((const char **, string *));
381 static void
382 string_need PARAMS ((string *, int));
384 static void
385 string_delete PARAMS ((string *));
387 static void
388 string_init PARAMS ((string *));
390 static void
391 string_clear PARAMS ((string *));
393 #if 0
394 static int
395 string_empty PARAMS ((string *));
396 #endif
398 static void
399 string_append PARAMS ((string *, const char *));
401 static void
402 string_appends PARAMS ((string *, string *));
404 static void
405 string_appendn PARAMS ((string *, const char *, int));
407 static void
408 string_prepend PARAMS ((string *, const char *));
410 static void
411 string_prependn PARAMS ((string *, const char *, int));
413 static void
414 string_append_template_idx PARAMS ((string *, int));
416 static int
417 get_count PARAMS ((const char **, int *));
419 static int
420 consume_count PARAMS ((const char **));
422 static int
423 consume_count_with_underscores PARAMS ((const char**));
425 static int
426 demangle_args PARAMS ((struct work_stuff *, const char **, string *));
428 static int
429 demangle_nested_args PARAMS ((struct work_stuff*, const char**, string*));
431 static int
432 do_type PARAMS ((struct work_stuff *, const char **, string *));
434 static int
435 do_arg PARAMS ((struct work_stuff *, const char **, string *));
437 static void
438 demangle_function_name PARAMS ((struct work_stuff *, const char **, string *,
439 const char *));
441 static int
442 iterate_demangle_function PARAMS ((struct work_stuff *,
443 const char **, string *, const char *));
445 static void
446 remember_type PARAMS ((struct work_stuff *, const char *, int));
448 static void
449 remember_Btype PARAMS ((struct work_stuff *, const char *, int, int));
451 static int
452 register_Btype PARAMS ((struct work_stuff *));
454 static void
455 remember_Ktype PARAMS ((struct work_stuff *, const char *, int));
457 static void
458 forget_types PARAMS ((struct work_stuff *));
460 static void
461 forget_B_and_K_types PARAMS ((struct work_stuff *));
463 static void
464 string_prepends PARAMS ((string *, string *));
466 static int
467 demangle_template_value_parm PARAMS ((struct work_stuff*, const char**,
468 string*, type_kind_t));
470 static int
471 do_hpacc_template_const_value PARAMS ((struct work_stuff *, const char **, string *));
473 static int
474 do_hpacc_template_literal PARAMS ((struct work_stuff *, const char **, string *));
476 static int
477 snarf_numeric_literal PARAMS ((const char **, string *));
479 /* There is a TYPE_QUAL value for each type qualifier. They can be
480 combined by bitwise-or to form the complete set of qualifiers for a
481 type. */
483 #define TYPE_UNQUALIFIED 0x0
484 #define TYPE_QUAL_CONST 0x1
485 #define TYPE_QUAL_VOLATILE 0x2
486 #define TYPE_QUAL_RESTRICT 0x4
488 static int
489 code_for_qualifier PARAMS ((int));
491 static const char*
492 qualifier_string PARAMS ((int));
494 static const char*
495 demangle_qualifier PARAMS ((int));
497 static int
498 demangle_expression PARAMS ((struct work_stuff *, const char **, string *,
499 type_kind_t));
501 static int
502 demangle_integral_value PARAMS ((struct work_stuff *, const char **,
503 string *));
505 static int
506 demangle_real_value PARAMS ((struct work_stuff *, const char **, string *));
508 static void
509 demangle_arm_hp_template PARAMS ((struct work_stuff *, const char **, int,
510 string *));
512 static void
513 recursively_demangle PARAMS ((struct work_stuff *, const char **, string *,
514 int));
516 static void
517 grow_vect PARAMS ((char **, size_t *, size_t, int));
519 /* Translate count to integer, consuming tokens in the process.
520 Conversion terminates on the first non-digit character.
522 Trying to consume something that isn't a count results in no
523 consumption of input and a return of -1.
525 Overflow consumes the rest of the digits, and returns -1. */
527 static int
528 consume_count (type)
529 const char **type;
531 int count = 0;
533 if (! ISDIGIT ((unsigned char)**type))
534 return -1;
536 while (ISDIGIT ((unsigned char)**type))
538 count *= 10;
540 /* Check for overflow.
541 We assume that count is represented using two's-complement;
542 no power of two is divisible by ten, so if an overflow occurs
543 when multiplying by ten, the result will not be a multiple of
544 ten. */
545 if ((count % 10) != 0)
547 while (ISDIGIT ((unsigned char) **type))
548 (*type)++;
549 return -1;
552 count += **type - '0';
553 (*type)++;
556 if (count < 0)
557 count = -1;
559 return (count);
563 /* Like consume_count, but for counts that are preceded and followed
564 by '_' if they are greater than 10. Also, -1 is returned for
565 failure, since 0 can be a valid value. */
567 static int
568 consume_count_with_underscores (mangled)
569 const char **mangled;
571 int idx;
573 if (**mangled == '_')
575 (*mangled)++;
576 if (!ISDIGIT ((unsigned char)**mangled))
577 return -1;
579 idx = consume_count (mangled);
580 if (**mangled != '_')
581 /* The trailing underscore was missing. */
582 return -1;
584 (*mangled)++;
586 else
588 if (**mangled < '0' || **mangled > '9')
589 return -1;
591 idx = **mangled - '0';
592 (*mangled)++;
595 return idx;
598 /* C is the code for a type-qualifier. Return the TYPE_QUAL
599 corresponding to this qualifier. */
601 static int
602 code_for_qualifier (c)
603 int c;
605 switch (c)
607 case 'C':
608 return TYPE_QUAL_CONST;
610 case 'V':
611 return TYPE_QUAL_VOLATILE;
613 case 'u':
614 return TYPE_QUAL_RESTRICT;
616 default:
617 break;
620 /* C was an invalid qualifier. */
621 abort ();
624 /* Return the string corresponding to the qualifiers given by
625 TYPE_QUALS. */
627 static const char*
628 qualifier_string (type_quals)
629 int type_quals;
631 switch (type_quals)
633 case TYPE_UNQUALIFIED:
634 return "";
636 case TYPE_QUAL_CONST:
637 return "const";
639 case TYPE_QUAL_VOLATILE:
640 return "volatile";
642 case TYPE_QUAL_RESTRICT:
643 return "__restrict";
645 case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE:
646 return "const volatile";
648 case TYPE_QUAL_CONST | TYPE_QUAL_RESTRICT:
649 return "const __restrict";
651 case TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT:
652 return "volatile __restrict";
654 case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT:
655 return "const volatile __restrict";
657 default:
658 break;
661 /* TYPE_QUALS was an invalid qualifier set. */
662 abort ();
665 /* C is the code for a type-qualifier. Return the string
666 corresponding to this qualifier. This function should only be
667 called with a valid qualifier code. */
669 static const char*
670 demangle_qualifier (c)
671 int c;
673 return qualifier_string (code_for_qualifier (c));
677 cplus_demangle_opname (opname, result, options)
678 const char *opname;
679 char *result;
680 int options;
682 int len, len1, ret;
683 string type;
684 struct work_stuff work[1];
685 const char *tem;
687 len = strlen(opname);
688 result[0] = '\0';
689 ret = 0;
690 memset ((char *) work, 0, sizeof (work));
691 work->options = options;
693 if (opname[0] == '_' && opname[1] == '_'
694 && opname[2] == 'o' && opname[3] == 'p')
696 /* ANSI. */
697 /* type conversion operator. */
698 tem = opname + 4;
699 if (do_type (work, &tem, &type))
701 strcat (result, "operator ");
702 strncat (result, type.b, type.p - type.b);
703 string_delete (&type);
704 ret = 1;
707 else if (opname[0] == '_' && opname[1] == '_'
708 && ISLOWER((unsigned char)opname[2])
709 && ISLOWER((unsigned char)opname[3]))
711 if (opname[4] == '\0')
713 /* Operator. */
714 size_t i;
715 for (i = 0; i < ARRAY_SIZE (optable); i++)
717 if (strlen (optable[i].in) == 2
718 && memcmp (optable[i].in, opname + 2, 2) == 0)
720 strcat (result, "operator");
721 strcat (result, optable[i].out);
722 ret = 1;
723 break;
727 else
729 if (opname[2] == 'a' && opname[5] == '\0')
731 /* Assignment. */
732 size_t i;
733 for (i = 0; i < ARRAY_SIZE (optable); i++)
735 if (strlen (optable[i].in) == 3
736 && memcmp (optable[i].in, opname + 2, 3) == 0)
738 strcat (result, "operator");
739 strcat (result, optable[i].out);
740 ret = 1;
741 break;
747 else if (len >= 3
748 && opname[0] == 'o'
749 && opname[1] == 'p'
750 && strchr (cplus_markers, opname[2]) != NULL)
752 /* see if it's an assignment expression */
753 if (len >= 10 /* op$assign_ */
754 && memcmp (opname + 3, "assign_", 7) == 0)
756 size_t i;
757 for (i = 0; i < ARRAY_SIZE (optable); i++)
759 len1 = len - 10;
760 if ((int) strlen (optable[i].in) == len1
761 && memcmp (optable[i].in, opname + 10, len1) == 0)
763 strcat (result, "operator");
764 strcat (result, optable[i].out);
765 strcat (result, "=");
766 ret = 1;
767 break;
771 else
773 size_t i;
774 for (i = 0; i < ARRAY_SIZE (optable); i++)
776 len1 = len - 3;
777 if ((int) strlen (optable[i].in) == len1
778 && memcmp (optable[i].in, opname + 3, len1) == 0)
780 strcat (result, "operator");
781 strcat (result, optable[i].out);
782 ret = 1;
783 break;
788 else if (len >= 5 && memcmp (opname, "type", 4) == 0
789 && strchr (cplus_markers, opname[4]) != NULL)
791 /* type conversion operator */
792 tem = opname + 5;
793 if (do_type (work, &tem, &type))
795 strcat (result, "operator ");
796 strncat (result, type.b, type.p - type.b);
797 string_delete (&type);
798 ret = 1;
801 squangle_mop_up (work);
802 return ret;
806 /* Takes operator name as e.g. "++" and returns mangled
807 operator name (e.g. "postincrement_expr"), or NULL if not found.
809 If OPTIONS & DMGL_ANSI == 1, return the ANSI name;
810 if OPTIONS & DMGL_ANSI == 0, return the old GNU name. */
812 const char *
813 cplus_mangle_opname (opname, options)
814 const char *opname;
815 int options;
817 size_t i;
818 int len;
820 len = strlen (opname);
821 for (i = 0; i < ARRAY_SIZE (optable); i++)
823 if ((int) strlen (optable[i].out) == len
824 && (options & DMGL_ANSI) == (optable[i].flags & DMGL_ANSI)
825 && memcmp (optable[i].out, opname, len) == 0)
826 return optable[i].in;
828 return (0);
831 /* Add a routine to set the demangling style to be sure it is valid and
832 allow for any demangler initialization that maybe necessary. */
834 enum demangling_styles
835 cplus_demangle_set_style (style)
836 enum demangling_styles style;
838 const struct demangler_engine *demangler = libiberty_demanglers;
840 for (; demangler->demangling_style != unknown_demangling; ++demangler)
841 if (style == demangler->demangling_style)
843 current_demangling_style = style;
844 return current_demangling_style;
847 return unknown_demangling;
850 /* Do string name to style translation */
852 enum demangling_styles
853 cplus_demangle_name_to_style (name)
854 const char *name;
856 const struct demangler_engine *demangler = libiberty_demanglers;
858 for (; demangler->demangling_style != unknown_demangling; ++demangler)
859 if (strcmp (name, demangler->demangling_style_name) == 0)
860 return demangler->demangling_style;
862 return unknown_demangling;
865 /* char *cplus_demangle (const char *mangled, int options)
867 If MANGLED is a mangled function name produced by GNU C++, then
868 a pointer to a @code{malloc}ed string giving a C++ representation
869 of the name will be returned; otherwise NULL will be returned.
870 It is the caller's responsibility to free the string which
871 is returned.
873 The OPTIONS arg may contain one or more of the following bits:
875 DMGL_ANSI ANSI qualifiers such as `const' and `void' are
876 included.
877 DMGL_PARAMS Function parameters are included.
879 For example,
881 cplus_demangle ("foo__1Ai", DMGL_PARAMS) => "A::foo(int)"
882 cplus_demangle ("foo__1Ai", DMGL_PARAMS | DMGL_ANSI) => "A::foo(int)"
883 cplus_demangle ("foo__1Ai", 0) => "A::foo"
885 cplus_demangle ("foo__1Afe", DMGL_PARAMS) => "A::foo(float,...)"
886 cplus_demangle ("foo__1Afe", DMGL_PARAMS | DMGL_ANSI)=> "A::foo(float,...)"
887 cplus_demangle ("foo__1Afe", 0) => "A::foo"
889 Note that any leading underscores, or other such characters prepended by
890 the compilation system, are presumed to have already been stripped from
891 MANGLED. */
893 char *
894 cplus_demangle (mangled, options)
895 const char *mangled;
896 int options;
898 char *ret;
899 struct work_stuff work[1];
901 if (current_demangling_style == no_demangling)
902 return xstrdup (mangled);
904 memset ((char *) work, 0, sizeof (work));
905 work->options = options;
906 if ((work->options & DMGL_STYLE_MASK) == 0)
907 work->options |= (int) current_demangling_style & DMGL_STYLE_MASK;
909 /* The V3 ABI demangling is implemented elsewhere. */
910 if (GNU_V3_DEMANGLING || AUTO_DEMANGLING)
912 ret = cplus_demangle_v3 (mangled, work->options);
913 if (ret || GNU_V3_DEMANGLING)
914 return ret;
917 if (JAVA_DEMANGLING)
919 ret = java_demangle_v3 (mangled);
920 if (ret)
921 return ret;
924 if (GNAT_DEMANGLING)
925 return ada_demangle(mangled,options);
927 ret = internal_cplus_demangle (work, mangled);
928 squangle_mop_up (work);
929 return (ret);
933 /* Assuming *OLD_VECT points to an array of *SIZE objects of size
934 ELEMENT_SIZE, grow it to contain at least MIN_SIZE objects,
935 updating *OLD_VECT and *SIZE as necessary. */
937 static void
938 grow_vect (old_vect, size, min_size, element_size)
939 char **old_vect;
940 size_t *size;
941 size_t min_size;
942 int element_size;
944 if (*size < min_size)
946 *size *= 2;
947 if (*size < min_size)
948 *size = min_size;
949 *old_vect = (void *) xrealloc (*old_vect, *size * element_size);
953 /* Demangle ada names:
954 1. Discard final __{DIGIT}+ or ${DIGIT}+
955 2. Convert other instances of embedded "__" to `.'.
956 3. Discard leading _ada_.
957 4. Remove everything after first ___ if it is followed by 'X'.
958 5. Put symbols that should be suppressed in <...> brackets.
959 The resulting string is valid until the next call of ada_demangle. */
961 static char *
962 ada_demangle (mangled, option)
963 const char *mangled;
964 int option ATTRIBUTE_UNUSED;
966 int i, j;
967 int len0;
968 const char* p;
969 char *demangled = NULL;
970 int at_start_name;
971 int changed;
972 size_t demangled_size = 0;
974 changed = 0;
976 if (strncmp (mangled, "_ada_", 5) == 0)
978 mangled += 5;
979 changed = 1;
982 if (mangled[0] == '_' || mangled[0] == '<')
983 goto Suppress;
985 p = strstr (mangled, "___");
986 if (p == NULL)
987 len0 = strlen (mangled);
988 else
990 if (p[3] == 'X')
992 len0 = p - mangled;
993 changed = 1;
995 else
996 goto Suppress;
999 /* Make demangled big enough for possible expansion by operator name. */
1000 grow_vect (&demangled,
1001 &demangled_size, 2 * len0 + 1,
1002 sizeof (char));
1004 if (ISDIGIT ((unsigned char) mangled[len0 - 1])) {
1005 for (i = len0 - 2; i >= 0 && ISDIGIT ((unsigned char) mangled[i]); i -= 1)
1007 if (i > 1 && mangled[i] == '_' && mangled[i - 1] == '_')
1009 len0 = i - 1;
1010 changed = 1;
1012 else if (mangled[i] == '$')
1014 len0 = i;
1015 changed = 1;
1019 for (i = 0, j = 0; i < len0 && ! ISALPHA ((unsigned char)mangled[i]);
1020 i += 1, j += 1)
1021 demangled[j] = mangled[i];
1023 at_start_name = 1;
1024 while (i < len0)
1026 at_start_name = 0;
1028 if (i < len0 - 2 && mangled[i] == '_' && mangled[i + 1] == '_')
1030 demangled[j] = '.';
1031 changed = at_start_name = 1;
1032 i += 2; j += 1;
1034 else
1036 demangled[j] = mangled[i];
1037 i += 1; j += 1;
1040 demangled[j] = '\000';
1042 for (i = 0; demangled[i] != '\0'; i += 1)
1043 if (ISUPPER ((unsigned char)demangled[i]) || demangled[i] == ' ')
1044 goto Suppress;
1046 if (! changed)
1047 return NULL;
1048 else
1049 return demangled;
1051 Suppress:
1052 grow_vect (&demangled,
1053 &demangled_size, strlen (mangled) + 3,
1054 sizeof (char));
1056 if (mangled[0] == '<')
1057 strcpy (demangled, mangled);
1058 else
1059 sprintf (demangled, "<%s>", mangled);
1061 return demangled;
1064 /* This function performs most of what cplus_demangle use to do, but
1065 to be able to demangle a name with a B, K or n code, we need to
1066 have a longer term memory of what types have been seen. The original
1067 now intializes and cleans up the squangle code info, while internal
1068 calls go directly to this routine to avoid resetting that info. */
1070 static char *
1071 internal_cplus_demangle (work, mangled)
1072 struct work_stuff *work;
1073 const char *mangled;
1076 string decl;
1077 int success = 0;
1078 char *demangled = NULL;
1079 int s1, s2, s3, s4;
1080 s1 = work->constructor;
1081 s2 = work->destructor;
1082 s3 = work->static_type;
1083 s4 = work->type_quals;
1084 work->constructor = work->destructor = 0;
1085 work->type_quals = TYPE_UNQUALIFIED;
1086 work->dllimported = 0;
1088 if ((mangled != NULL) && (*mangled != '\0'))
1090 string_init (&decl);
1092 /* First check to see if gnu style demangling is active and if the
1093 string to be demangled contains a CPLUS_MARKER. If so, attempt to
1094 recognize one of the gnu special forms rather than looking for a
1095 standard prefix. In particular, don't worry about whether there
1096 is a "__" string in the mangled string. Consider "_$_5__foo" for
1097 example. */
1099 if ((AUTO_DEMANGLING || GNU_DEMANGLING))
1101 success = gnu_special (work, &mangled, &decl);
1103 if (!success)
1105 success = demangle_prefix (work, &mangled, &decl);
1107 if (success && (*mangled != '\0'))
1109 success = demangle_signature (work, &mangled, &decl);
1111 if (work->constructor == 2)
1113 string_prepend (&decl, "global constructors keyed to ");
1114 work->constructor = 0;
1116 else if (work->destructor == 2)
1118 string_prepend (&decl, "global destructors keyed to ");
1119 work->destructor = 0;
1121 else if (work->dllimported == 1)
1123 string_prepend (&decl, "import stub for ");
1124 work->dllimported = 0;
1126 demangled = mop_up (work, &decl, success);
1128 work->constructor = s1;
1129 work->destructor = s2;
1130 work->static_type = s3;
1131 work->type_quals = s4;
1132 return demangled;
1136 /* Clear out and squangling related storage */
1137 static void
1138 squangle_mop_up (work)
1139 struct work_stuff *work;
1141 /* clean up the B and K type mangling types. */
1142 forget_B_and_K_types (work);
1143 if (work -> btypevec != NULL)
1145 free ((char *) work -> btypevec);
1147 if (work -> ktypevec != NULL)
1149 free ((char *) work -> ktypevec);
1154 /* Copy the work state and storage. */
1156 static void
1157 work_stuff_copy_to_from (to, from)
1158 struct work_stuff *to;
1159 struct work_stuff *from;
1161 int i;
1163 delete_work_stuff (to);
1165 /* Shallow-copy scalars. */
1166 memcpy (to, from, sizeof (*to));
1168 /* Deep-copy dynamic storage. */
1169 if (from->typevec_size)
1170 to->typevec
1171 = (char **) xmalloc (from->typevec_size * sizeof (to->typevec[0]));
1173 for (i = 0; i < from->ntypes; i++)
1175 int len = strlen (from->typevec[i]) + 1;
1177 to->typevec[i] = xmalloc (len);
1178 memcpy (to->typevec[i], from->typevec[i], len);
1181 if (from->ksize)
1182 to->ktypevec
1183 = (char **) xmalloc (from->ksize * sizeof (to->ktypevec[0]));
1185 for (i = 0; i < from->numk; i++)
1187 int len = strlen (from->ktypevec[i]) + 1;
1189 to->ktypevec[i] = xmalloc (len);
1190 memcpy (to->ktypevec[i], from->ktypevec[i], len);
1193 if (from->bsize)
1194 to->btypevec
1195 = (char **) xmalloc (from->bsize * sizeof (to->btypevec[0]));
1197 for (i = 0; i < from->numb; i++)
1199 int len = strlen (from->btypevec[i]) + 1;
1201 to->btypevec[i] = xmalloc (len);
1202 memcpy (to->btypevec[i], from->btypevec[i], len);
1205 if (from->ntmpl_args)
1206 to->tmpl_argvec
1207 = (char **) xmalloc (from->ntmpl_args * sizeof (to->tmpl_argvec[0]));
1209 for (i = 0; i < from->ntmpl_args; i++)
1211 int len = strlen (from->tmpl_argvec[i]) + 1;
1213 to->tmpl_argvec[i] = xmalloc (len);
1214 memcpy (to->tmpl_argvec[i], from->tmpl_argvec[i], len);
1217 if (from->previous_argument)
1219 to->previous_argument = (string*) xmalloc (sizeof (string));
1220 string_init (to->previous_argument);
1221 string_appends (to->previous_argument, from->previous_argument);
1226 /* Delete dynamic stuff in work_stuff that is not to be re-used. */
1228 static void
1229 delete_non_B_K_work_stuff (work)
1230 struct work_stuff *work;
1232 /* Discard the remembered types, if any. */
1234 forget_types (work);
1235 if (work -> typevec != NULL)
1237 free ((char *) work -> typevec);
1238 work -> typevec = NULL;
1239 work -> typevec_size = 0;
1241 if (work->tmpl_argvec)
1243 int i;
1245 for (i = 0; i < work->ntmpl_args; i++)
1246 if (work->tmpl_argvec[i])
1247 free ((char*) work->tmpl_argvec[i]);
1249 free ((char*) work->tmpl_argvec);
1250 work->tmpl_argvec = NULL;
1252 if (work->previous_argument)
1254 string_delete (work->previous_argument);
1255 free ((char*) work->previous_argument);
1256 work->previous_argument = NULL;
1261 /* Delete all dynamic storage in work_stuff. */
1262 static void
1263 delete_work_stuff (work)
1264 struct work_stuff *work;
1266 delete_non_B_K_work_stuff (work);
1267 squangle_mop_up (work);
1271 /* Clear out any mangled storage */
1273 static char *
1274 mop_up (work, declp, success)
1275 struct work_stuff *work;
1276 string *declp;
1277 int success;
1279 char *demangled = NULL;
1281 delete_non_B_K_work_stuff (work);
1283 /* If demangling was successful, ensure that the demangled string is null
1284 terminated and return it. Otherwise, free the demangling decl. */
1286 if (!success)
1288 string_delete (declp);
1290 else
1292 string_appendn (declp, "", 1);
1293 demangled = declp->b;
1295 return (demangled);
1300 LOCAL FUNCTION
1302 demangle_signature -- demangle the signature part of a mangled name
1304 SYNOPSIS
1306 static int
1307 demangle_signature (struct work_stuff *work, const char **mangled,
1308 string *declp);
1310 DESCRIPTION
1312 Consume and demangle the signature portion of the mangled name.
1314 DECLP is the string where demangled output is being built. At
1315 entry it contains the demangled root name from the mangled name
1316 prefix. I.E. either a demangled operator name or the root function
1317 name. In some special cases, it may contain nothing.
1319 *MANGLED points to the current unconsumed location in the mangled
1320 name. As tokens are consumed and demangling is performed, the
1321 pointer is updated to continuously point at the next token to
1322 be consumed.
1324 Demangling GNU style mangled names is nasty because there is no
1325 explicit token that marks the start of the outermost function
1326 argument list. */
1328 static int
1329 demangle_signature (work, mangled, declp)
1330 struct work_stuff *work;
1331 const char **mangled;
1332 string *declp;
1334 int success = 1;
1335 int func_done = 0;
1336 int expect_func = 0;
1337 int expect_return_type = 0;
1338 const char *oldmangled = NULL;
1339 string trawname;
1340 string tname;
1342 while (success && (**mangled != '\0'))
1344 switch (**mangled)
1346 case 'Q':
1347 oldmangled = *mangled;
1348 success = demangle_qualified (work, mangled, declp, 1, 0);
1349 if (success)
1350 remember_type (work, oldmangled, *mangled - oldmangled);
1351 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1352 expect_func = 1;
1353 oldmangled = NULL;
1354 break;
1356 case 'K':
1357 oldmangled = *mangled;
1358 success = demangle_qualified (work, mangled, declp, 1, 0);
1359 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1361 expect_func = 1;
1363 oldmangled = NULL;
1364 break;
1366 case 'S':
1367 /* Static member function */
1368 if (oldmangled == NULL)
1370 oldmangled = *mangled;
1372 (*mangled)++;
1373 work -> static_type = 1;
1374 break;
1376 case 'C':
1377 case 'V':
1378 case 'u':
1379 work->type_quals |= code_for_qualifier (**mangled);
1381 /* a qualified member function */
1382 if (oldmangled == NULL)
1383 oldmangled = *mangled;
1384 (*mangled)++;
1385 break;
1387 case 'L':
1388 /* Local class name follows after "Lnnn_" */
1389 if (HP_DEMANGLING)
1391 while (**mangled && (**mangled != '_'))
1392 (*mangled)++;
1393 if (!**mangled)
1394 success = 0;
1395 else
1396 (*mangled)++;
1398 else
1399 success = 0;
1400 break;
1402 case '0': case '1': case '2': case '3': case '4':
1403 case '5': case '6': case '7': case '8': case '9':
1404 if (oldmangled == NULL)
1406 oldmangled = *mangled;
1408 work->temp_start = -1; /* uppermost call to demangle_class */
1409 success = demangle_class (work, mangled, declp);
1410 if (success)
1412 remember_type (work, oldmangled, *mangled - oldmangled);
1414 if (AUTO_DEMANGLING || GNU_DEMANGLING || EDG_DEMANGLING)
1416 /* EDG and others will have the "F", so we let the loop cycle
1417 if we are looking at one. */
1418 if (**mangled != 'F')
1419 expect_func = 1;
1421 oldmangled = NULL;
1422 break;
1424 case 'B':
1426 string s;
1427 success = do_type (work, mangled, &s);
1428 if (success)
1430 string_append (&s, SCOPE_STRING (work));
1431 string_prepends (declp, &s);
1433 oldmangled = NULL;
1434 expect_func = 1;
1436 break;
1438 case 'F':
1439 /* Function */
1440 /* ARM/HP style demangling includes a specific 'F' character after
1441 the class name. For GNU style, it is just implied. So we can
1442 safely just consume any 'F' at this point and be compatible
1443 with either style. */
1445 oldmangled = NULL;
1446 func_done = 1;
1447 (*mangled)++;
1449 /* For lucid/ARM/HP style we have to forget any types we might
1450 have remembered up to this point, since they were not argument
1451 types. GNU style considers all types seen as available for
1452 back references. See comment in demangle_args() */
1454 if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
1456 forget_types (work);
1458 success = demangle_args (work, mangled, declp);
1459 /* After picking off the function args, we expect to either
1460 find the function return type (preceded by an '_') or the
1461 end of the string. */
1462 if (success && (AUTO_DEMANGLING || EDG_DEMANGLING) && **mangled == '_')
1464 ++(*mangled);
1465 /* At this level, we do not care about the return type. */
1466 success = do_type (work, mangled, &tname);
1467 string_delete (&tname);
1470 break;
1472 case 't':
1473 /* G++ Template */
1474 string_init(&trawname);
1475 string_init(&tname);
1476 if (oldmangled == NULL)
1478 oldmangled = *mangled;
1480 success = demangle_template (work, mangled, &tname,
1481 &trawname, 1, 1);
1482 if (success)
1484 remember_type (work, oldmangled, *mangled - oldmangled);
1486 string_append (&tname, SCOPE_STRING (work));
1488 string_prepends(declp, &tname);
1489 if (work -> destructor & 1)
1491 string_prepend (&trawname, "~");
1492 string_appends (declp, &trawname);
1493 work->destructor -= 1;
1495 if ((work->constructor & 1) || (work->destructor & 1))
1497 string_appends (declp, &trawname);
1498 work->constructor -= 1;
1500 string_delete(&trawname);
1501 string_delete(&tname);
1502 oldmangled = NULL;
1503 expect_func = 1;
1504 break;
1506 case '_':
1507 if ((AUTO_DEMANGLING || GNU_DEMANGLING) && expect_return_type)
1509 /* Read the return type. */
1510 string return_type;
1511 string_init (&return_type);
1513 (*mangled)++;
1514 success = do_type (work, mangled, &return_type);
1515 APPEND_BLANK (&return_type);
1517 string_prepends (declp, &return_type);
1518 string_delete (&return_type);
1519 break;
1521 else
1522 /* At the outermost level, we cannot have a return type specified,
1523 so if we run into another '_' at this point we are dealing with
1524 a mangled name that is either bogus, or has been mangled by
1525 some algorithm we don't know how to deal with. So just
1526 reject the entire demangling. */
1527 /* However, "_nnn" is an expected suffix for alternate entry point
1528 numbered nnn for a function, with HP aCC, so skip over that
1529 without reporting failure. pai/1997-09-04 */
1530 if (HP_DEMANGLING)
1532 (*mangled)++;
1533 while (**mangled && ISDIGIT ((unsigned char)**mangled))
1534 (*mangled)++;
1536 else
1537 success = 0;
1538 break;
1540 case 'H':
1541 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1543 /* A G++ template function. Read the template arguments. */
1544 success = demangle_template (work, mangled, declp, 0, 0,
1546 if (!(work->constructor & 1))
1547 expect_return_type = 1;
1548 (*mangled)++;
1549 break;
1551 else
1552 /* fall through */
1555 default:
1556 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1558 /* Assume we have stumbled onto the first outermost function
1559 argument token, and start processing args. */
1560 func_done = 1;
1561 success = demangle_args (work, mangled, declp);
1563 else
1565 /* Non-GNU demanglers use a specific token to mark the start
1566 of the outermost function argument tokens. Typically 'F',
1567 for ARM/HP-demangling, for example. So if we find something
1568 we are not prepared for, it must be an error. */
1569 success = 0;
1571 break;
1574 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1577 if (success && expect_func)
1579 func_done = 1;
1580 if (LUCID_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING)
1582 forget_types (work);
1584 success = demangle_args (work, mangled, declp);
1585 /* Since template include the mangling of their return types,
1586 we must set expect_func to 0 so that we don't try do
1587 demangle more arguments the next time we get here. */
1588 expect_func = 0;
1592 if (success && !func_done)
1594 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1596 /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
1597 bar__3fooi is 'foo::bar(int)'. We get here when we find the
1598 first case, and need to ensure that the '(void)' gets added to
1599 the current declp. Note that with ARM/HP, the first case
1600 represents the name of a static data member 'foo::bar',
1601 which is in the current declp, so we leave it alone. */
1602 success = demangle_args (work, mangled, declp);
1605 if (success && PRINT_ARG_TYPES)
1607 if (work->static_type)
1608 string_append (declp, " static");
1609 if (work->type_quals != TYPE_UNQUALIFIED)
1611 APPEND_BLANK (declp);
1612 string_append (declp, qualifier_string (work->type_quals));
1616 return (success);
1619 #if 0
1621 static int
1622 demangle_method_args (work, mangled, declp)
1623 struct work_stuff *work;
1624 const char **mangled;
1625 string *declp;
1627 int success = 0;
1629 if (work -> static_type)
1631 string_append (declp, *mangled + 1);
1632 *mangled += strlen (*mangled);
1633 success = 1;
1635 else
1637 success = demangle_args (work, mangled, declp);
1639 return (success);
1642 #endif
1644 static int
1645 demangle_template_template_parm (work, mangled, tname)
1646 struct work_stuff *work;
1647 const char **mangled;
1648 string *tname;
1650 int i;
1651 int r;
1652 int need_comma = 0;
1653 int success = 1;
1654 string temp;
1656 string_append (tname, "template <");
1657 /* get size of template parameter list */
1658 if (get_count (mangled, &r))
1660 for (i = 0; i < r; i++)
1662 if (need_comma)
1664 string_append (tname, ", ");
1667 /* Z for type parameters */
1668 if (**mangled == 'Z')
1670 (*mangled)++;
1671 string_append (tname, "class");
1673 /* z for template parameters */
1674 else if (**mangled == 'z')
1676 (*mangled)++;
1677 success =
1678 demangle_template_template_parm (work, mangled, tname);
1679 if (!success)
1681 break;
1684 else
1686 /* temp is initialized in do_type */
1687 success = do_type (work, mangled, &temp);
1688 if (success)
1690 string_appends (tname, &temp);
1692 string_delete(&temp);
1693 if (!success)
1695 break;
1698 need_comma = 1;
1702 if (tname->p[-1] == '>')
1703 string_append (tname, " ");
1704 string_append (tname, "> class");
1705 return (success);
1708 static int
1709 demangle_expression (work, mangled, s, tk)
1710 struct work_stuff *work;
1711 const char** mangled;
1712 string* s;
1713 type_kind_t tk;
1715 int need_operator = 0;
1716 int success;
1718 success = 1;
1719 string_appendn (s, "(", 1);
1720 (*mangled)++;
1721 while (success && **mangled != 'W' && **mangled != '\0')
1723 if (need_operator)
1725 size_t i;
1726 size_t len;
1728 success = 0;
1730 len = strlen (*mangled);
1732 for (i = 0; i < ARRAY_SIZE (optable); ++i)
1734 size_t l = strlen (optable[i].in);
1736 if (l <= len
1737 && memcmp (optable[i].in, *mangled, l) == 0)
1739 string_appendn (s, " ", 1);
1740 string_append (s, optable[i].out);
1741 string_appendn (s, " ", 1);
1742 success = 1;
1743 (*mangled) += l;
1744 break;
1748 if (!success)
1749 break;
1751 else
1752 need_operator = 1;
1754 success = demangle_template_value_parm (work, mangled, s, tk);
1757 if (**mangled != 'W')
1758 success = 0;
1759 else
1761 string_appendn (s, ")", 1);
1762 (*mangled)++;
1765 return success;
1768 static int
1769 demangle_integral_value (work, mangled, s)
1770 struct work_stuff *work;
1771 const char** mangled;
1772 string* s;
1774 int success;
1776 if (**mangled == 'E')
1777 success = demangle_expression (work, mangled, s, tk_integral);
1778 else if (**mangled == 'Q' || **mangled == 'K')
1779 success = demangle_qualified (work, mangled, s, 0, 1);
1780 else
1782 int value;
1784 /* By default, we let the number decide whether we shall consume an
1785 underscore. */
1786 int multidigit_without_leading_underscore = 0;
1787 int leave_following_underscore = 0;
1789 success = 0;
1791 /* Negative numbers are indicated with a leading `m'. */
1792 if (**mangled == 'm')
1794 string_appendn (s, "-", 1);
1795 (*mangled)++;
1797 else if (mangled[0][0] == '_' && mangled[0][1] == 'm')
1799 /* Since consume_count_with_underscores does not handle the
1800 `m'-prefix we must do it here, using consume_count and
1801 adjusting underscores: we have to consume the underscore
1802 matching the prepended one. */
1803 multidigit_without_leading_underscore = 1;
1804 string_appendn (s, "-", 1);
1805 (*mangled) += 2;
1807 else if (**mangled == '_')
1809 /* Do not consume a following underscore;
1810 multidigit_without_leading_underscore will consume what should be
1811 consumed. */
1812 leave_following_underscore = 1;
1814 else
1816 /* Since consume_count_with_underscores does not handle
1817 multi-digit numbers that do not start with an underscore,
1818 and this number can be an integer template parameter,
1819 we have to call consume_count. */
1820 multidigit_without_leading_underscore = 1;
1821 /* These multi-digit numbers never end on an underscore,
1822 so if there is one then don't eat it. */
1823 leave_following_underscore = 1;
1826 /* We must call consume_count if we expect to remove a trailing
1827 underscore, since consume_count_with_underscores expects
1828 the leading underscore (that we consumed) if it is to handle
1829 multi-digit numbers. */
1830 if (multidigit_without_leading_underscore)
1831 value = consume_count (mangled);
1832 else
1833 value = consume_count_with_underscores (mangled);
1835 if (value != -1)
1837 char buf[INTBUF_SIZE];
1838 sprintf (buf, "%d", value);
1839 string_append (s, buf);
1841 /* Numbers not otherwise delimited, might have an underscore
1842 appended as a delimeter, which we should skip.
1844 ??? This used to always remove a following underscore, which
1845 is wrong. If other (arbitrary) cases are followed by an
1846 underscore, we need to do something more radical. */
1848 if ((value > 9 || multidigit_without_leading_underscore)
1849 && ! leave_following_underscore
1850 && **mangled == '_')
1851 (*mangled)++;
1853 /* All is well. */
1854 success = 1;
1858 return success;
1861 /* Demangle the real value in MANGLED. */
1863 static int
1864 demangle_real_value (work, mangled, s)
1865 struct work_stuff *work;
1866 const char **mangled;
1867 string* s;
1869 if (**mangled == 'E')
1870 return demangle_expression (work, mangled, s, tk_real);
1872 if (**mangled == 'm')
1874 string_appendn (s, "-", 1);
1875 (*mangled)++;
1877 while (ISDIGIT ((unsigned char)**mangled))
1879 string_appendn (s, *mangled, 1);
1880 (*mangled)++;
1882 if (**mangled == '.') /* fraction */
1884 string_appendn (s, ".", 1);
1885 (*mangled)++;
1886 while (ISDIGIT ((unsigned char)**mangled))
1888 string_appendn (s, *mangled, 1);
1889 (*mangled)++;
1892 if (**mangled == 'e') /* exponent */
1894 string_appendn (s, "e", 1);
1895 (*mangled)++;
1896 while (ISDIGIT ((unsigned char)**mangled))
1898 string_appendn (s, *mangled, 1);
1899 (*mangled)++;
1903 return 1;
1906 static int
1907 demangle_template_value_parm (work, mangled, s, tk)
1908 struct work_stuff *work;
1909 const char **mangled;
1910 string* s;
1911 type_kind_t tk;
1913 int success = 1;
1915 if (**mangled == 'Y')
1917 /* The next argument is a template parameter. */
1918 int idx;
1920 (*mangled)++;
1921 idx = consume_count_with_underscores (mangled);
1922 if (idx == -1
1923 || (work->tmpl_argvec && idx >= work->ntmpl_args)
1924 || consume_count_with_underscores (mangled) == -1)
1925 return -1;
1926 if (work->tmpl_argvec)
1927 string_append (s, work->tmpl_argvec[idx]);
1928 else
1929 string_append_template_idx (s, idx);
1931 else if (tk == tk_integral)
1932 success = demangle_integral_value (work, mangled, s);
1933 else if (tk == tk_char)
1935 char tmp[2];
1936 int val;
1937 if (**mangled == 'm')
1939 string_appendn (s, "-", 1);
1940 (*mangled)++;
1942 string_appendn (s, "'", 1);
1943 val = consume_count(mangled);
1944 if (val <= 0)
1945 success = 0;
1946 else
1948 tmp[0] = (char)val;
1949 tmp[1] = '\0';
1950 string_appendn (s, &tmp[0], 1);
1951 string_appendn (s, "'", 1);
1954 else if (tk == tk_bool)
1956 int val = consume_count (mangled);
1957 if (val == 0)
1958 string_appendn (s, "false", 5);
1959 else if (val == 1)
1960 string_appendn (s, "true", 4);
1961 else
1962 success = 0;
1964 else if (tk == tk_real)
1965 success = demangle_real_value (work, mangled, s);
1966 else if (tk == tk_pointer || tk == tk_reference)
1968 if (**mangled == 'Q')
1969 success = demangle_qualified (work, mangled, s,
1970 /*isfuncname=*/0,
1971 /*append=*/1);
1972 else
1974 int symbol_len = consume_count (mangled);
1975 if (symbol_len == -1)
1976 return -1;
1977 if (symbol_len == 0)
1978 string_appendn (s, "0", 1);
1979 else
1981 char *p = xmalloc (symbol_len + 1), *q;
1982 strncpy (p, *mangled, symbol_len);
1983 p [symbol_len] = '\0';
1984 /* We use cplus_demangle here, rather than
1985 internal_cplus_demangle, because the name of the entity
1986 mangled here does not make use of any of the squangling
1987 or type-code information we have built up thus far; it is
1988 mangled independently. */
1989 q = cplus_demangle (p, work->options);
1990 if (tk == tk_pointer)
1991 string_appendn (s, "&", 1);
1992 /* FIXME: Pointer-to-member constants should get a
1993 qualifying class name here. */
1994 if (q)
1996 string_append (s, q);
1997 free (q);
1999 else
2000 string_append (s, p);
2001 free (p);
2003 *mangled += symbol_len;
2007 return success;
2010 /* Demangle the template name in MANGLED. The full name of the
2011 template (e.g., S<int>) is placed in TNAME. The name without the
2012 template parameters (e.g. S) is placed in TRAWNAME if TRAWNAME is
2013 non-NULL. If IS_TYPE is nonzero, this template is a type template,
2014 not a function template. If both IS_TYPE and REMEMBER are nonzero,
2015 the template is remembered in the list of back-referenceable
2016 types. */
2018 static int
2019 demangle_template (work, mangled, tname, trawname, is_type, remember)
2020 struct work_stuff *work;
2021 const char **mangled;
2022 string *tname;
2023 string *trawname;
2024 int is_type;
2025 int remember;
2027 int i;
2028 int r;
2029 int need_comma = 0;
2030 int success = 0;
2031 const char *start;
2032 int is_java_array = 0;
2033 string temp;
2034 int bindex = 0;
2036 (*mangled)++;
2037 if (is_type)
2039 if (remember)
2040 bindex = register_Btype (work);
2041 start = *mangled;
2042 /* get template name */
2043 if (**mangled == 'z')
2045 int idx;
2046 (*mangled)++;
2047 (*mangled)++;
2049 idx = consume_count_with_underscores (mangled);
2050 if (idx == -1
2051 || (work->tmpl_argvec && idx >= work->ntmpl_args)
2052 || consume_count_with_underscores (mangled) == -1)
2053 return (0);
2055 if (work->tmpl_argvec)
2057 string_append (tname, work->tmpl_argvec[idx]);
2058 if (trawname)
2059 string_append (trawname, work->tmpl_argvec[idx]);
2061 else
2063 string_append_template_idx (tname, idx);
2064 if (trawname)
2065 string_append_template_idx (trawname, idx);
2068 else
2070 if ((r = consume_count (mangled)) <= 0
2071 || (int) strlen (*mangled) < r)
2073 return (0);
2075 is_java_array = (work -> options & DMGL_JAVA)
2076 && strncmp (*mangled, "JArray1Z", 8) == 0;
2077 if (! is_java_array)
2079 string_appendn (tname, *mangled, r);
2081 if (trawname)
2082 string_appendn (trawname, *mangled, r);
2083 *mangled += r;
2086 if (!is_java_array)
2087 string_append (tname, "<");
2088 /* get size of template parameter list */
2089 if (!get_count (mangled, &r))
2091 return (0);
2093 if (!is_type)
2095 /* Create an array for saving the template argument values. */
2096 work->tmpl_argvec = (char**) xmalloc (r * sizeof (char *));
2097 work->ntmpl_args = r;
2098 for (i = 0; i < r; i++)
2099 work->tmpl_argvec[i] = 0;
2101 for (i = 0; i < r; i++)
2103 if (need_comma)
2105 string_append (tname, ", ");
2107 /* Z for type parameters */
2108 if (**mangled == 'Z')
2110 (*mangled)++;
2111 /* temp is initialized in do_type */
2112 success = do_type (work, mangled, &temp);
2113 if (success)
2115 string_appends (tname, &temp);
2117 if (!is_type)
2119 /* Save the template argument. */
2120 int len = temp.p - temp.b;
2121 work->tmpl_argvec[i] = xmalloc (len + 1);
2122 memcpy (work->tmpl_argvec[i], temp.b, len);
2123 work->tmpl_argvec[i][len] = '\0';
2126 string_delete(&temp);
2127 if (!success)
2129 break;
2132 /* z for template parameters */
2133 else if (**mangled == 'z')
2135 int r2;
2136 (*mangled)++;
2137 success = demangle_template_template_parm (work, mangled, tname);
2139 if (success
2140 && (r2 = consume_count (mangled)) > 0
2141 && (int) strlen (*mangled) >= r2)
2143 string_append (tname, " ");
2144 string_appendn (tname, *mangled, r2);
2145 if (!is_type)
2147 /* Save the template argument. */
2148 int len = r2;
2149 work->tmpl_argvec[i] = xmalloc (len + 1);
2150 memcpy (work->tmpl_argvec[i], *mangled, len);
2151 work->tmpl_argvec[i][len] = '\0';
2153 *mangled += r2;
2155 if (!success)
2157 break;
2160 else
2162 string param;
2163 string* s;
2165 /* otherwise, value parameter */
2167 /* temp is initialized in do_type */
2168 success = do_type (work, mangled, &temp);
2169 string_delete(&temp);
2170 if (!success)
2171 break;
2173 if (!is_type)
2175 s = &param;
2176 string_init (s);
2178 else
2179 s = tname;
2181 success = demangle_template_value_parm (work, mangled, s,
2182 (type_kind_t) success);
2184 if (!success)
2186 if (!is_type)
2187 string_delete (s);
2188 success = 0;
2189 break;
2192 if (!is_type)
2194 int len = s->p - s->b;
2195 work->tmpl_argvec[i] = xmalloc (len + 1);
2196 memcpy (work->tmpl_argvec[i], s->b, len);
2197 work->tmpl_argvec[i][len] = '\0';
2199 string_appends (tname, s);
2200 string_delete (s);
2203 need_comma = 1;
2205 if (is_java_array)
2207 string_append (tname, "[]");
2209 else
2211 if (tname->p[-1] == '>')
2212 string_append (tname, " ");
2213 string_append (tname, ">");
2216 if (is_type && remember)
2217 remember_Btype (work, tname->b, LEN_STRING (tname), bindex);
2220 if (work -> static_type)
2222 string_append (declp, *mangled + 1);
2223 *mangled += strlen (*mangled);
2224 success = 1;
2226 else
2228 success = demangle_args (work, mangled, declp);
2232 return (success);
2235 static int
2236 arm_pt (work, mangled, n, anchor, args)
2237 struct work_stuff *work;
2238 const char *mangled;
2239 int n;
2240 const char **anchor, **args;
2242 /* Check if ARM template with "__pt__" in it ("parameterized type") */
2243 /* Allow HP also here, because HP's cfront compiler follows ARM to some extent */
2244 if ((ARM_DEMANGLING || HP_DEMANGLING) && (*anchor = strstr (mangled, "__pt__")))
2246 int len;
2247 *args = *anchor + 6;
2248 len = consume_count (args);
2249 if (len == -1)
2250 return 0;
2251 if (*args + len == mangled + n && **args == '_')
2253 ++*args;
2254 return 1;
2257 if (AUTO_DEMANGLING || EDG_DEMANGLING)
2259 if ((*anchor = strstr (mangled, "__tm__"))
2260 || (*anchor = strstr (mangled, "__ps__"))
2261 || (*anchor = strstr (mangled, "__pt__")))
2263 int len;
2264 *args = *anchor + 6;
2265 len = consume_count (args);
2266 if (len == -1)
2267 return 0;
2268 if (*args + len == mangled + n && **args == '_')
2270 ++*args;
2271 return 1;
2274 else if ((*anchor = strstr (mangled, "__S")))
2276 int len;
2277 *args = *anchor + 3;
2278 len = consume_count (args);
2279 if (len == -1)
2280 return 0;
2281 if (*args + len == mangled + n && **args == '_')
2283 ++*args;
2284 return 1;
2289 return 0;
2292 static void
2293 demangle_arm_hp_template (work, mangled, n, declp)
2294 struct work_stuff *work;
2295 const char **mangled;
2296 int n;
2297 string *declp;
2299 const char *p;
2300 const char *args;
2301 const char *e = *mangled + n;
2302 string arg;
2304 /* Check for HP aCC template spec: classXt1t2 where t1, t2 are
2305 template args */
2306 if (HP_DEMANGLING && ((*mangled)[n] == 'X'))
2308 char *start_spec_args = NULL;
2310 /* First check for and omit template specialization pseudo-arguments,
2311 such as in "Spec<#1,#1.*>" */
2312 start_spec_args = strchr (*mangled, '<');
2313 if (start_spec_args && (start_spec_args - *mangled < n))
2314 string_appendn (declp, *mangled, start_spec_args - *mangled);
2315 else
2316 string_appendn (declp, *mangled, n);
2317 (*mangled) += n + 1;
2318 string_init (&arg);
2319 if (work->temp_start == -1) /* non-recursive call */
2320 work->temp_start = declp->p - declp->b;
2321 string_append (declp, "<");
2322 while (1)
2324 string_clear (&arg);
2325 switch (**mangled)
2327 case 'T':
2328 /* 'T' signals a type parameter */
2329 (*mangled)++;
2330 if (!do_type (work, mangled, &arg))
2331 goto hpacc_template_args_done;
2332 break;
2334 case 'U':
2335 case 'S':
2336 /* 'U' or 'S' signals an integral value */
2337 if (!do_hpacc_template_const_value (work, mangled, &arg))
2338 goto hpacc_template_args_done;
2339 break;
2341 case 'A':
2342 /* 'A' signals a named constant expression (literal) */
2343 if (!do_hpacc_template_literal (work, mangled, &arg))
2344 goto hpacc_template_args_done;
2345 break;
2347 default:
2348 /* Today, 1997-09-03, we have only the above types
2349 of template parameters */
2350 /* FIXME: maybe this should fail and return null */
2351 goto hpacc_template_args_done;
2353 string_appends (declp, &arg);
2354 /* Check if we're at the end of template args.
2355 0 if at end of static member of template class,
2356 _ if done with template args for a function */
2357 if ((**mangled == '\000') || (**mangled == '_'))
2358 break;
2359 else
2360 string_append (declp, ",");
2362 hpacc_template_args_done:
2363 string_append (declp, ">");
2364 string_delete (&arg);
2365 if (**mangled == '_')
2366 (*mangled)++;
2367 return;
2369 /* ARM template? (Also handles HP cfront extensions) */
2370 else if (arm_pt (work, *mangled, n, &p, &args))
2372 string type_str;
2374 string_init (&arg);
2375 string_appendn (declp, *mangled, p - *mangled);
2376 if (work->temp_start == -1) /* non-recursive call */
2377 work->temp_start = declp->p - declp->b;
2378 string_append (declp, "<");
2379 /* should do error checking here */
2380 while (args < e) {
2381 string_clear (&arg);
2383 /* Check for type or literal here */
2384 switch (*args)
2386 /* HP cfront extensions to ARM for template args */
2387 /* spec: Xt1Lv1 where t1 is a type, v1 is a literal value */
2388 /* FIXME: We handle only numeric literals for HP cfront */
2389 case 'X':
2390 /* A typed constant value follows */
2391 args++;
2392 if (!do_type (work, &args, &type_str))
2393 goto cfront_template_args_done;
2394 string_append (&arg, "(");
2395 string_appends (&arg, &type_str);
2396 string_append (&arg, ")");
2397 if (*args != 'L')
2398 goto cfront_template_args_done;
2399 args++;
2400 /* Now snarf a literal value following 'L' */
2401 if (!snarf_numeric_literal (&args, &arg))
2402 goto cfront_template_args_done;
2403 break;
2405 case 'L':
2406 /* Snarf a literal following 'L' */
2407 args++;
2408 if (!snarf_numeric_literal (&args, &arg))
2409 goto cfront_template_args_done;
2410 break;
2411 default:
2412 /* Not handling other HP cfront stuff */
2414 const char* old_args = args;
2415 if (!do_type (work, &args, &arg))
2416 goto cfront_template_args_done;
2418 /* Fail if we didn't make any progress: prevent infinite loop. */
2419 if (args == old_args)
2420 return;
2423 string_appends (declp, &arg);
2424 string_append (declp, ",");
2426 cfront_template_args_done:
2427 string_delete (&arg);
2428 if (args >= e)
2429 --declp->p; /* remove extra comma */
2430 string_append (declp, ">");
2432 else if (n>10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
2433 && (*mangled)[9] == 'N'
2434 && (*mangled)[8] == (*mangled)[10]
2435 && strchr (cplus_markers, (*mangled)[8]))
2437 /* A member of the anonymous namespace. */
2438 string_append (declp, "{anonymous}");
2440 else
2442 if (work->temp_start == -1) /* non-recursive call only */
2443 work->temp_start = 0; /* disable in recursive calls */
2444 string_appendn (declp, *mangled, n);
2446 *mangled += n;
2449 /* Extract a class name, possibly a template with arguments, from the
2450 mangled string; qualifiers, local class indicators, etc. have
2451 already been dealt with */
2453 static int
2454 demangle_class_name (work, mangled, declp)
2455 struct work_stuff *work;
2456 const char **mangled;
2457 string *declp;
2459 int n;
2460 int success = 0;
2462 n = consume_count (mangled);
2463 if (n == -1)
2464 return 0;
2465 if ((int) strlen (*mangled) >= n)
2467 demangle_arm_hp_template (work, mangled, n, declp);
2468 success = 1;
2471 return (success);
2476 LOCAL FUNCTION
2478 demangle_class -- demangle a mangled class sequence
2480 SYNOPSIS
2482 static int
2483 demangle_class (struct work_stuff *work, const char **mangled,
2484 strint *declp)
2486 DESCRIPTION
2488 DECLP points to the buffer into which demangling is being done.
2490 *MANGLED points to the current token to be demangled. On input,
2491 it points to a mangled class (I.E. "3foo", "13verylongclass", etc.)
2492 On exit, it points to the next token after the mangled class on
2493 success, or the first unconsumed token on failure.
2495 If the CONSTRUCTOR or DESTRUCTOR flags are set in WORK, then
2496 we are demangling a constructor or destructor. In this case
2497 we prepend "class::class" or "class::~class" to DECLP.
2499 Otherwise, we prepend "class::" to the current DECLP.
2501 Reset the constructor/destructor flags once they have been
2502 "consumed". This allows demangle_class to be called later during
2503 the same demangling, to do normal class demangling.
2505 Returns 1 if demangling is successful, 0 otherwise.
2509 static int
2510 demangle_class (work, mangled, declp)
2511 struct work_stuff *work;
2512 const char **mangled;
2513 string *declp;
2515 int success = 0;
2516 int btype;
2517 string class_name;
2518 char *save_class_name_end = 0;
2520 string_init (&class_name);
2521 btype = register_Btype (work);
2522 if (demangle_class_name (work, mangled, &class_name))
2524 save_class_name_end = class_name.p;
2525 if ((work->constructor & 1) || (work->destructor & 1))
2527 /* adjust so we don't include template args */
2528 if (work->temp_start && (work->temp_start != -1))
2530 class_name.p = class_name.b + work->temp_start;
2532 string_prepends (declp, &class_name);
2533 if (work -> destructor & 1)
2535 string_prepend (declp, "~");
2536 work -> destructor -= 1;
2538 else
2540 work -> constructor -= 1;
2543 class_name.p = save_class_name_end;
2544 remember_Ktype (work, class_name.b, LEN_STRING(&class_name));
2545 remember_Btype (work, class_name.b, LEN_STRING(&class_name), btype);
2546 string_prepend (declp, SCOPE_STRING (work));
2547 string_prepends (declp, &class_name);
2548 success = 1;
2550 string_delete (&class_name);
2551 return (success);
2555 /* Called when there's a "__" in the mangled name, with `scan' pointing to
2556 the rightmost guess.
2558 Find the correct "__"-sequence where the function name ends and the
2559 signature starts, which is ambiguous with GNU mangling.
2560 Call demangle_signature here, so we can make sure we found the right
2561 one; *mangled will be consumed so caller will not make further calls to
2562 demangle_signature. */
2564 static int
2565 iterate_demangle_function (work, mangled, declp, scan)
2566 struct work_stuff *work;
2567 const char **mangled;
2568 string *declp;
2569 const char *scan;
2571 const char *mangle_init = *mangled;
2572 int success = 0;
2573 string decl_init;
2574 struct work_stuff work_init;
2576 if (*(scan + 2) == '\0')
2577 return 0;
2579 /* Do not iterate for some demangling modes, or if there's only one
2580 "__"-sequence. This is the normal case. */
2581 if (ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING
2582 || strstr (scan + 2, "__") == NULL)
2584 demangle_function_name (work, mangled, declp, scan);
2585 return 1;
2588 /* Save state so we can restart if the guess at the correct "__" was
2589 wrong. */
2590 string_init (&decl_init);
2591 string_appends (&decl_init, declp);
2592 memset (&work_init, 0, sizeof work_init);
2593 work_stuff_copy_to_from (&work_init, work);
2595 /* Iterate over occurrences of __, allowing names and types to have a
2596 "__" sequence in them. We must start with the first (not the last)
2597 occurrence, since "__" most often occur between independent mangled
2598 parts, hence starting at the last occurence inside a signature
2599 might get us a "successful" demangling of the signature. */
2601 while (scan[2])
2603 demangle_function_name (work, mangled, declp, scan);
2604 success = demangle_signature (work, mangled, declp);
2605 if (success)
2606 break;
2608 /* Reset demangle state for the next round. */
2609 *mangled = mangle_init;
2610 string_clear (declp);
2611 string_appends (declp, &decl_init);
2612 work_stuff_copy_to_from (work, &work_init);
2614 /* Leave this underscore-sequence. */
2615 scan += 2;
2617 /* Scan for the next "__" sequence. */
2618 while (*scan && (scan[0] != '_' || scan[1] != '_'))
2619 scan++;
2621 /* Move to last "__" in this sequence. */
2622 while (*scan && *scan == '_')
2623 scan++;
2624 scan -= 2;
2627 /* Delete saved state. */
2628 delete_work_stuff (&work_init);
2629 string_delete (&decl_init);
2631 return success;
2636 LOCAL FUNCTION
2638 demangle_prefix -- consume the mangled name prefix and find signature
2640 SYNOPSIS
2642 static int
2643 demangle_prefix (struct work_stuff *work, const char **mangled,
2644 string *declp);
2646 DESCRIPTION
2648 Consume and demangle the prefix of the mangled name.
2649 While processing the function name root, arrange to call
2650 demangle_signature if the root is ambiguous.
2652 DECLP points to the string buffer into which demangled output is
2653 placed. On entry, the buffer is empty. On exit it contains
2654 the root function name, the demangled operator name, or in some
2655 special cases either nothing or the completely demangled result.
2657 MANGLED points to the current pointer into the mangled name. As each
2658 token of the mangled name is consumed, it is updated. Upon entry
2659 the current mangled name pointer points to the first character of
2660 the mangled name. Upon exit, it should point to the first character
2661 of the signature if demangling was successful, or to the first
2662 unconsumed character if demangling of the prefix was unsuccessful.
2664 Returns 1 on success, 0 otherwise.
2667 static int
2668 demangle_prefix (work, mangled, declp)
2669 struct work_stuff *work;
2670 const char **mangled;
2671 string *declp;
2673 int success = 1;
2674 const char *scan;
2675 int i;
2677 if (strlen(*mangled) > 6
2678 && (strncmp(*mangled, "_imp__", 6) == 0
2679 || strncmp(*mangled, "__imp_", 6) == 0))
2681 /* it's a symbol imported from a PE dynamic library. Check for both
2682 new style prefix _imp__ and legacy __imp_ used by older versions
2683 of dlltool. */
2684 (*mangled) += 6;
2685 work->dllimported = 1;
2687 else if (strlen(*mangled) >= 11 && strncmp(*mangled, "_GLOBAL_", 8) == 0)
2689 char *marker = strchr (cplus_markers, (*mangled)[8]);
2690 if (marker != NULL && *marker == (*mangled)[10])
2692 if ((*mangled)[9] == 'D')
2694 /* it's a GNU global destructor to be executed at program exit */
2695 (*mangled) += 11;
2696 work->destructor = 2;
2697 if (gnu_special (work, mangled, declp))
2698 return success;
2700 else if ((*mangled)[9] == 'I')
2702 /* it's a GNU global constructor to be executed at program init */
2703 (*mangled) += 11;
2704 work->constructor = 2;
2705 if (gnu_special (work, mangled, declp))
2706 return success;
2710 else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__std__", 7) == 0)
2712 /* it's a ARM global destructor to be executed at program exit */
2713 (*mangled) += 7;
2714 work->destructor = 2;
2716 else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__sti__", 7) == 0)
2718 /* it's a ARM global constructor to be executed at program initial */
2719 (*mangled) += 7;
2720 work->constructor = 2;
2723 /* This block of code is a reduction in strength time optimization
2725 scan = strstr (*mangled, "__"); */
2728 scan = *mangled;
2730 do {
2731 scan = strchr (scan, '_');
2732 } while (scan != NULL && *++scan != '_');
2734 if (scan != NULL) --scan;
2737 if (scan != NULL)
2739 /* We found a sequence of two or more '_', ensure that we start at
2740 the last pair in the sequence. */
2741 i = strspn (scan, "_");
2742 if (i > 2)
2744 scan += (i - 2);
2748 if (scan == NULL)
2750 success = 0;
2752 else if (work -> static_type)
2754 if (!ISDIGIT ((unsigned char)scan[0]) && (scan[0] != 't'))
2756 success = 0;
2759 else if ((scan == *mangled)
2760 && (ISDIGIT ((unsigned char)scan[2]) || (scan[2] == 'Q')
2761 || (scan[2] == 't') || (scan[2] == 'K') || (scan[2] == 'H')))
2763 /* The ARM says nothing about the mangling of local variables.
2764 But cfront mangles local variables by prepending __<nesting_level>
2765 to them. As an extension to ARM demangling we handle this case. */
2766 if ((LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING)
2767 && ISDIGIT ((unsigned char)scan[2]))
2769 *mangled = scan + 2;
2770 consume_count (mangled);
2771 string_append (declp, *mangled);
2772 *mangled += strlen (*mangled);
2773 success = 1;
2775 else
2777 /* A GNU style constructor starts with __[0-9Qt]. But cfront uses
2778 names like __Q2_3foo3bar for nested type names. So don't accept
2779 this style of constructor for cfront demangling. A GNU
2780 style member-template constructor starts with 'H'. */
2781 if (!(LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING))
2782 work -> constructor += 1;
2783 *mangled = scan + 2;
2786 else if (ARM_DEMANGLING && scan[2] == 'p' && scan[3] == 't')
2788 /* Cfront-style parameterized type. Handled later as a signature. */
2789 success = 1;
2791 /* ARM template? */
2792 demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
2794 else if (EDG_DEMANGLING && ((scan[2] == 't' && scan[3] == 'm')
2795 || (scan[2] == 'p' && scan[3] == 's')
2796 || (scan[2] == 'p' && scan[3] == 't')))
2798 /* EDG-style parameterized type. Handled later as a signature. */
2799 success = 1;
2801 /* EDG template? */
2802 demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
2804 else if ((scan == *mangled) && !ISDIGIT ((unsigned char)scan[2])
2805 && (scan[2] != 't'))
2807 /* Mangled name starts with "__". Skip over any leading '_' characters,
2808 then find the next "__" that separates the prefix from the signature.
2810 if (!(ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
2811 || (arm_special (mangled, declp) == 0))
2813 while (*scan == '_')
2815 scan++;
2817 if ((scan = strstr (scan, "__")) == NULL || (*(scan + 2) == '\0'))
2819 /* No separator (I.E. "__not_mangled"), or empty signature
2820 (I.E. "__not_mangled_either__") */
2821 success = 0;
2823 else
2824 return iterate_demangle_function (work, mangled, declp, scan);
2827 else if (*(scan + 2) != '\0')
2829 /* Mangled name does not start with "__" but does have one somewhere
2830 in there with non empty stuff after it. Looks like a global
2831 function name. Iterate over all "__":s until the right
2832 one is found. */
2833 return iterate_demangle_function (work, mangled, declp, scan);
2835 else
2837 /* Doesn't look like a mangled name */
2838 success = 0;
2841 if (!success && (work->constructor == 2 || work->destructor == 2))
2843 string_append (declp, *mangled);
2844 *mangled += strlen (*mangled);
2845 success = 1;
2847 return (success);
2852 LOCAL FUNCTION
2854 gnu_special -- special handling of gnu mangled strings
2856 SYNOPSIS
2858 static int
2859 gnu_special (struct work_stuff *work, const char **mangled,
2860 string *declp);
2863 DESCRIPTION
2865 Process some special GNU style mangling forms that don't fit
2866 the normal pattern. For example:
2868 _$_3foo (destructor for class foo)
2869 _vt$foo (foo virtual table)
2870 _vt$foo$bar (foo::bar virtual table)
2871 __vt_foo (foo virtual table, new style with thunks)
2872 _3foo$varname (static data member)
2873 _Q22rs2tu$vw (static data member)
2874 __t6vector1Zii (constructor with template)
2875 __thunk_4__$_7ostream (virtual function thunk)
2878 static int
2879 gnu_special (work, mangled, declp)
2880 struct work_stuff *work;
2881 const char **mangled;
2882 string *declp;
2884 int n;
2885 int success = 1;
2886 const char *p;
2888 if ((*mangled)[0] == '_'
2889 && strchr (cplus_markers, (*mangled)[1]) != NULL
2890 && (*mangled)[2] == '_')
2892 /* Found a GNU style destructor, get past "_<CPLUS_MARKER>_" */
2893 (*mangled) += 3;
2894 work -> destructor += 1;
2896 else if ((*mangled)[0] == '_'
2897 && (((*mangled)[1] == '_'
2898 && (*mangled)[2] == 'v'
2899 && (*mangled)[3] == 't'
2900 && (*mangled)[4] == '_')
2901 || ((*mangled)[1] == 'v'
2902 && (*mangled)[2] == 't'
2903 && strchr (cplus_markers, (*mangled)[3]) != NULL)))
2905 /* Found a GNU style virtual table, get past "_vt<CPLUS_MARKER>"
2906 and create the decl. Note that we consume the entire mangled
2907 input string, which means that demangle_signature has no work
2908 to do. */
2909 if ((*mangled)[2] == 'v')
2910 (*mangled) += 5; /* New style, with thunks: "__vt_" */
2911 else
2912 (*mangled) += 4; /* Old style, no thunks: "_vt<CPLUS_MARKER>" */
2913 while (**mangled != '\0')
2915 switch (**mangled)
2917 case 'Q':
2918 case 'K':
2919 success = demangle_qualified (work, mangled, declp, 0, 1);
2920 break;
2921 case 't':
2922 success = demangle_template (work, mangled, declp, 0, 1,
2924 break;
2925 default:
2926 if (ISDIGIT((unsigned char)*mangled[0]))
2928 n = consume_count(mangled);
2929 /* We may be seeing a too-large size, or else a
2930 ".<digits>" indicating a static local symbol. In
2931 any case, declare victory and move on; *don't* try
2932 to use n to allocate. */
2933 if (n > (int) strlen (*mangled))
2935 success = 1;
2936 break;
2939 else
2941 n = strcspn (*mangled, cplus_markers);
2943 string_appendn (declp, *mangled, n);
2944 (*mangled) += n;
2947 p = strpbrk (*mangled, cplus_markers);
2948 if (success && ((p == NULL) || (p == *mangled)))
2950 if (p != NULL)
2952 string_append (declp, SCOPE_STRING (work));
2953 (*mangled)++;
2956 else
2958 success = 0;
2959 break;
2962 if (success)
2963 string_append (declp, " virtual table");
2965 else if ((*mangled)[0] == '_'
2966 && (strchr("0123456789Qt", (*mangled)[1]) != NULL)
2967 && (p = strpbrk (*mangled, cplus_markers)) != NULL)
2969 /* static data member, "_3foo$varname" for example */
2970 (*mangled)++;
2971 switch (**mangled)
2973 case 'Q':
2974 case 'K':
2975 success = demangle_qualified (work, mangled, declp, 0, 1);
2976 break;
2977 case 't':
2978 success = demangle_template (work, mangled, declp, 0, 1, 1);
2979 break;
2980 default:
2981 n = consume_count (mangled);
2982 if (n < 0 || n > (long) strlen (*mangled))
2984 success = 0;
2985 break;
2988 if (n > 10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
2989 && (*mangled)[9] == 'N'
2990 && (*mangled)[8] == (*mangled)[10]
2991 && strchr (cplus_markers, (*mangled)[8]))
2993 /* A member of the anonymous namespace. There's information
2994 about what identifier or filename it was keyed to, but
2995 it's just there to make the mangled name unique; we just
2996 step over it. */
2997 string_append (declp, "{anonymous}");
2998 (*mangled) += n;
3000 /* Now p points to the marker before the N, so we need to
3001 update it to the first marker after what we consumed. */
3002 p = strpbrk (*mangled, cplus_markers);
3003 break;
3006 string_appendn (declp, *mangled, n);
3007 (*mangled) += n;
3009 if (success && (p == *mangled))
3011 /* Consumed everything up to the cplus_marker, append the
3012 variable name. */
3013 (*mangled)++;
3014 string_append (declp, SCOPE_STRING (work));
3015 n = strlen (*mangled);
3016 string_appendn (declp, *mangled, n);
3017 (*mangled) += n;
3019 else
3021 success = 0;
3024 else if (strncmp (*mangled, "__thunk_", 8) == 0)
3026 int delta;
3028 (*mangled) += 8;
3029 delta = consume_count (mangled);
3030 if (delta == -1)
3031 success = 0;
3032 else
3034 char *method = internal_cplus_demangle (work, ++*mangled);
3036 if (method)
3038 char buf[50];
3039 sprintf (buf, "virtual function thunk (delta:%d) for ", -delta);
3040 string_append (declp, buf);
3041 string_append (declp, method);
3042 free (method);
3043 n = strlen (*mangled);
3044 (*mangled) += n;
3046 else
3048 success = 0;
3052 else if (strncmp (*mangled, "__t", 3) == 0
3053 && ((*mangled)[3] == 'i' || (*mangled)[3] == 'f'))
3055 p = (*mangled)[3] == 'i' ? " type_info node" : " type_info function";
3056 (*mangled) += 4;
3057 switch (**mangled)
3059 case 'Q':
3060 case 'K':
3061 success = demangle_qualified (work, mangled, declp, 0, 1);
3062 break;
3063 case 't':
3064 success = demangle_template (work, mangled, declp, 0, 1, 1);
3065 break;
3066 default:
3067 success = do_type (work, mangled, declp);
3068 break;
3070 if (success && **mangled != '\0')
3071 success = 0;
3072 if (success)
3073 string_append (declp, p);
3075 else
3077 success = 0;
3079 return (success);
3082 static void
3083 recursively_demangle(work, mangled, result, namelength)
3084 struct work_stuff *work;
3085 const char **mangled;
3086 string *result;
3087 int namelength;
3089 char * recurse = (char *)NULL;
3090 char * recurse_dem = (char *)NULL;
3092 recurse = (char *) xmalloc (namelength + 1);
3093 memcpy (recurse, *mangled, namelength);
3094 recurse[namelength] = '\000';
3096 recurse_dem = cplus_demangle (recurse, work->options);
3098 if (recurse_dem)
3100 string_append (result, recurse_dem);
3101 free (recurse_dem);
3103 else
3105 string_appendn (result, *mangled, namelength);
3107 free (recurse);
3108 *mangled += namelength;
3113 LOCAL FUNCTION
3115 arm_special -- special handling of ARM/lucid mangled strings
3117 SYNOPSIS
3119 static int
3120 arm_special (const char **mangled,
3121 string *declp);
3124 DESCRIPTION
3126 Process some special ARM style mangling forms that don't fit
3127 the normal pattern. For example:
3129 __vtbl__3foo (foo virtual table)
3130 __vtbl__3foo__3bar (bar::foo virtual table)
3134 static int
3135 arm_special (mangled, declp)
3136 const char **mangled;
3137 string *declp;
3139 int n;
3140 int success = 1;
3141 const char *scan;
3143 if (strncmp (*mangled, ARM_VTABLE_STRING, ARM_VTABLE_STRLEN) == 0)
3145 /* Found a ARM style virtual table, get past ARM_VTABLE_STRING
3146 and create the decl. Note that we consume the entire mangled
3147 input string, which means that demangle_signature has no work
3148 to do. */
3149 scan = *mangled + ARM_VTABLE_STRLEN;
3150 while (*scan != '\0') /* first check it can be demangled */
3152 n = consume_count (&scan);
3153 if (n == -1)
3155 return (0); /* no good */
3157 scan += n;
3158 if (scan[0] == '_' && scan[1] == '_')
3160 scan += 2;
3163 (*mangled) += ARM_VTABLE_STRLEN;
3164 while (**mangled != '\0')
3166 n = consume_count (mangled);
3167 if (n == -1
3168 || n > (long) strlen (*mangled))
3169 return 0;
3170 string_prependn (declp, *mangled, n);
3171 (*mangled) += n;
3172 if ((*mangled)[0] == '_' && (*mangled)[1] == '_')
3174 string_prepend (declp, "::");
3175 (*mangled) += 2;
3178 string_append (declp, " virtual table");
3180 else
3182 success = 0;
3184 return (success);
3189 LOCAL FUNCTION
3191 demangle_qualified -- demangle 'Q' qualified name strings
3193 SYNOPSIS
3195 static int
3196 demangle_qualified (struct work_stuff *, const char *mangled,
3197 string *result, int isfuncname, int append);
3199 DESCRIPTION
3201 Demangle a qualified name, such as "Q25Outer5Inner" which is
3202 the mangled form of "Outer::Inner". The demangled output is
3203 prepended or appended to the result string according to the
3204 state of the append flag.
3206 If isfuncname is nonzero, then the qualified name we are building
3207 is going to be used as a member function name, so if it is a
3208 constructor or destructor function, append an appropriate
3209 constructor or destructor name. I.E. for the above example,
3210 the result for use as a constructor is "Outer::Inner::Inner"
3211 and the result for use as a destructor is "Outer::Inner::~Inner".
3213 BUGS
3215 Numeric conversion is ASCII dependent (FIXME).
3219 static int
3220 demangle_qualified (work, mangled, result, isfuncname, append)
3221 struct work_stuff *work;
3222 const char **mangled;
3223 string *result;
3224 int isfuncname;
3225 int append;
3227 int qualifiers = 0;
3228 int success = 1;
3229 char num[2];
3230 string temp;
3231 string last_name;
3232 int bindex = register_Btype (work);
3234 /* We only make use of ISFUNCNAME if the entity is a constructor or
3235 destructor. */
3236 isfuncname = (isfuncname
3237 && ((work->constructor & 1) || (work->destructor & 1)));
3239 string_init (&temp);
3240 string_init (&last_name);
3242 if ((*mangled)[0] == 'K')
3244 /* Squangling qualified name reuse */
3245 int idx;
3246 (*mangled)++;
3247 idx = consume_count_with_underscores (mangled);
3248 if (idx == -1 || idx >= work -> numk)
3249 success = 0;
3250 else
3251 string_append (&temp, work -> ktypevec[idx]);
3253 else
3254 switch ((*mangled)[1])
3256 case '_':
3257 /* GNU mangled name with more than 9 classes. The count is preceded
3258 by an underscore (to distinguish it from the <= 9 case) and followed
3259 by an underscore. */
3260 (*mangled)++;
3261 qualifiers = consume_count_with_underscores (mangled);
3262 if (qualifiers == -1)
3263 success = 0;
3264 break;
3266 case '1':
3267 case '2':
3268 case '3':
3269 case '4':
3270 case '5':
3271 case '6':
3272 case '7':
3273 case '8':
3274 case '9':
3275 /* The count is in a single digit. */
3276 num[0] = (*mangled)[1];
3277 num[1] = '\0';
3278 qualifiers = atoi (num);
3280 /* If there is an underscore after the digit, skip it. This is
3281 said to be for ARM-qualified names, but the ARM makes no
3282 mention of such an underscore. Perhaps cfront uses one. */
3283 if ((*mangled)[2] == '_')
3285 (*mangled)++;
3287 (*mangled) += 2;
3288 break;
3290 case '0':
3291 default:
3292 success = 0;
3295 if (!success)
3296 return success;
3298 /* Pick off the names and collect them in the temp buffer in the order
3299 in which they are found, separated by '::'. */
3301 while (qualifiers-- > 0)
3303 int remember_K = 1;
3304 string_clear (&last_name);
3306 if (*mangled[0] == '_')
3307 (*mangled)++;
3309 if (*mangled[0] == 't')
3311 /* Here we always append to TEMP since we will want to use
3312 the template name without the template parameters as a
3313 constructor or destructor name. The appropriate
3314 (parameter-less) value is returned by demangle_template
3315 in LAST_NAME. We do not remember the template type here,
3316 in order to match the G++ mangling algorithm. */
3317 success = demangle_template(work, mangled, &temp,
3318 &last_name, 1, 0);
3319 if (!success)
3320 break;
3322 else if (*mangled[0] == 'K')
3324 int idx;
3325 (*mangled)++;
3326 idx = consume_count_with_underscores (mangled);
3327 if (idx == -1 || idx >= work->numk)
3328 success = 0;
3329 else
3330 string_append (&temp, work->ktypevec[idx]);
3331 remember_K = 0;
3333 if (!success) break;
3335 else
3337 if (EDG_DEMANGLING)
3339 int namelength;
3340 /* Now recursively demangle the qualifier
3341 * This is necessary to deal with templates in
3342 * mangling styles like EDG */
3343 namelength = consume_count (mangled);
3344 if (namelength == -1)
3346 success = 0;
3347 break;
3349 recursively_demangle(work, mangled, &temp, namelength);
3351 else
3353 success = do_type (work, mangled, &last_name);
3354 if (!success)
3355 break;
3356 string_appends (&temp, &last_name);
3360 if (remember_K)
3361 remember_Ktype (work, temp.b, LEN_STRING (&temp));
3363 if (qualifiers > 0)
3364 string_append (&temp, SCOPE_STRING (work));
3367 remember_Btype (work, temp.b, LEN_STRING (&temp), bindex);
3369 /* If we are using the result as a function name, we need to append
3370 the appropriate '::' separated constructor or destructor name.
3371 We do this here because this is the most convenient place, where
3372 we already have a pointer to the name and the length of the name. */
3374 if (isfuncname)
3376 string_append (&temp, SCOPE_STRING (work));
3377 if (work -> destructor & 1)
3378 string_append (&temp, "~");
3379 string_appends (&temp, &last_name);
3382 /* Now either prepend the temp buffer to the result, or append it,
3383 depending upon the state of the append flag. */
3385 if (append)
3386 string_appends (result, &temp);
3387 else
3389 if (!STRING_EMPTY (result))
3390 string_append (&temp, SCOPE_STRING (work));
3391 string_prepends (result, &temp);
3394 string_delete (&last_name);
3395 string_delete (&temp);
3396 return (success);
3401 LOCAL FUNCTION
3403 get_count -- convert an ascii count to integer, consuming tokens
3405 SYNOPSIS
3407 static int
3408 get_count (const char **type, int *count)
3410 DESCRIPTION
3412 Assume that *type points at a count in a mangled name; set
3413 *count to its value, and set *type to the next character after
3414 the count. There are some weird rules in effect here.
3416 If *type does not point at a string of digits, return zero.
3418 If *type points at a string of digits followed by an
3419 underscore, set *count to their value as an integer, advance
3420 *type to point *after the underscore, and return 1.
3422 If *type points at a string of digits not followed by an
3423 underscore, consume only the first digit. Set *count to its
3424 value as an integer, leave *type pointing after that digit,
3425 and return 1.
3427 The excuse for this odd behavior: in the ARM and HP demangling
3428 styles, a type can be followed by a repeat count of the form
3429 `Nxy', where:
3431 `x' is a single digit specifying how many additional copies
3432 of the type to append to the argument list, and
3434 `y' is one or more digits, specifying the zero-based index of
3435 the first repeated argument in the list. Yes, as you're
3436 unmangling the name you can figure this out yourself, but
3437 it's there anyway.
3439 So, for example, in `bar__3fooFPiN51', the first argument is a
3440 pointer to an integer (`Pi'), and then the next five arguments
3441 are the same (`N5'), and the first repeat is the function's
3442 second argument (`1').
3445 static int
3446 get_count (type, count)
3447 const char **type;
3448 int *count;
3450 const char *p;
3451 int n;
3453 if (!ISDIGIT ((unsigned char)**type))
3454 return (0);
3455 else
3457 *count = **type - '0';
3458 (*type)++;
3459 if (ISDIGIT ((unsigned char)**type))
3461 p = *type;
3462 n = *count;
3465 n *= 10;
3466 n += *p - '0';
3467 p++;
3469 while (ISDIGIT ((unsigned char)*p));
3470 if (*p == '_')
3472 *type = p + 1;
3473 *count = n;
3477 return (1);
3480 /* RESULT will be initialised here; it will be freed on failure. The
3481 value returned is really a type_kind_t. */
3483 static int
3484 do_type (work, mangled, result)
3485 struct work_stuff *work;
3486 const char **mangled;
3487 string *result;
3489 int n;
3490 int done;
3491 int success;
3492 string decl;
3493 const char *remembered_type;
3494 int type_quals;
3495 string btype;
3496 type_kind_t tk = tk_none;
3498 string_init (&btype);
3499 string_init (&decl);
3500 string_init (result);
3502 done = 0;
3503 success = 1;
3504 while (success && !done)
3506 int member;
3507 switch (**mangled)
3510 /* A pointer type */
3511 case 'P':
3512 case 'p':
3513 (*mangled)++;
3514 if (! (work -> options & DMGL_JAVA))
3515 string_prepend (&decl, "*");
3516 if (tk == tk_none)
3517 tk = tk_pointer;
3518 break;
3520 /* A reference type */
3521 case 'R':
3522 (*mangled)++;
3523 string_prepend (&decl, "&");
3524 if (tk == tk_none)
3525 tk = tk_reference;
3526 break;
3528 /* An array */
3529 case 'A':
3531 ++(*mangled);
3532 if (!STRING_EMPTY (&decl)
3533 && (decl.b[0] == '*' || decl.b[0] == '&'))
3535 string_prepend (&decl, "(");
3536 string_append (&decl, ")");
3538 string_append (&decl, "[");
3539 if (**mangled != '_')
3540 success = demangle_template_value_parm (work, mangled, &decl,
3541 tk_integral);
3542 if (**mangled == '_')
3543 ++(*mangled);
3544 string_append (&decl, "]");
3545 break;
3548 /* A back reference to a previously seen type */
3549 case 'T':
3550 (*mangled)++;
3551 if (!get_count (mangled, &n) || n >= work -> ntypes)
3553 success = 0;
3555 else
3557 remembered_type = work -> typevec[n];
3558 mangled = &remembered_type;
3560 break;
3562 /* A function */
3563 case 'F':
3564 (*mangled)++;
3565 if (!STRING_EMPTY (&decl)
3566 && (decl.b[0] == '*' || decl.b[0] == '&'))
3568 string_prepend (&decl, "(");
3569 string_append (&decl, ")");
3571 /* After picking off the function args, we expect to either find the
3572 function return type (preceded by an '_') or the end of the
3573 string. */
3574 if (!demangle_nested_args (work, mangled, &decl)
3575 || (**mangled != '_' && **mangled != '\0'))
3577 success = 0;
3578 break;
3580 if (success && (**mangled == '_'))
3581 (*mangled)++;
3582 break;
3584 case 'M':
3585 case 'O':
3587 type_quals = TYPE_UNQUALIFIED;
3589 member = **mangled == 'M';
3590 (*mangled)++;
3592 string_append (&decl, ")");
3594 /* We don't need to prepend `::' for a qualified name;
3595 demangle_qualified will do that for us. */
3596 if (**mangled != 'Q')
3597 string_prepend (&decl, SCOPE_STRING (work));
3599 if (ISDIGIT ((unsigned char)**mangled))
3601 n = consume_count (mangled);
3602 if (n == -1
3603 || (int) strlen (*mangled) < n)
3605 success = 0;
3606 break;
3608 string_prependn (&decl, *mangled, n);
3609 *mangled += n;
3611 else if (**mangled == 'X' || **mangled == 'Y')
3613 string temp;
3614 do_type (work, mangled, &temp);
3615 string_prepends (&decl, &temp);
3617 else if (**mangled == 't')
3619 string temp;
3620 string_init (&temp);
3621 success = demangle_template (work, mangled, &temp,
3622 NULL, 1, 1);
3623 if (success)
3625 string_prependn (&decl, temp.b, temp.p - temp.b);
3626 string_clear (&temp);
3628 else
3629 break;
3631 else if (**mangled == 'Q')
3633 success = demangle_qualified (work, mangled, &decl,
3634 /*isfuncnam=*/0,
3635 /*append=*/0);
3636 if (!success)
3637 break;
3639 else
3641 success = 0;
3642 break;
3645 string_prepend (&decl, "(");
3646 if (member)
3648 switch (**mangled)
3650 case 'C':
3651 case 'V':
3652 case 'u':
3653 type_quals |= code_for_qualifier (**mangled);
3654 (*mangled)++;
3655 break;
3657 default:
3658 break;
3661 if (*(*mangled)++ != 'F')
3663 success = 0;
3664 break;
3667 if ((member && !demangle_nested_args (work, mangled, &decl))
3668 || **mangled != '_')
3670 success = 0;
3671 break;
3673 (*mangled)++;
3674 if (! PRINT_ANSI_QUALIFIERS)
3676 break;
3678 if (type_quals != TYPE_UNQUALIFIED)
3680 APPEND_BLANK (&decl);
3681 string_append (&decl, qualifier_string (type_quals));
3683 break;
3685 case 'G':
3686 (*mangled)++;
3687 break;
3689 case 'C':
3690 case 'V':
3691 case 'u':
3692 if (PRINT_ANSI_QUALIFIERS)
3694 if (!STRING_EMPTY (&decl))
3695 string_prepend (&decl, " ");
3697 string_prepend (&decl, demangle_qualifier (**mangled));
3699 (*mangled)++;
3700 break;
3705 /* fall through */
3706 default:
3707 done = 1;
3708 break;
3712 if (success) switch (**mangled)
3714 /* A qualified name, such as "Outer::Inner". */
3715 case 'Q':
3716 case 'K':
3718 success = demangle_qualified (work, mangled, result, 0, 1);
3719 break;
3722 /* A back reference to a previously seen squangled type */
3723 case 'B':
3724 (*mangled)++;
3725 if (!get_count (mangled, &n) || n >= work -> numb)
3726 success = 0;
3727 else
3728 string_append (result, work->btypevec[n]);
3729 break;
3731 case 'X':
3732 case 'Y':
3733 /* A template parm. We substitute the corresponding argument. */
3735 int idx;
3737 (*mangled)++;
3738 idx = consume_count_with_underscores (mangled);
3740 if (idx == -1
3741 || (work->tmpl_argvec && idx >= work->ntmpl_args)
3742 || consume_count_with_underscores (mangled) == -1)
3744 success = 0;
3745 break;
3748 if (work->tmpl_argvec)
3749 string_append (result, work->tmpl_argvec[idx]);
3750 else
3751 string_append_template_idx (result, idx);
3753 success = 1;
3755 break;
3757 default:
3758 success = demangle_fund_type (work, mangled, result);
3759 if (tk == tk_none)
3760 tk = (type_kind_t) success;
3761 break;
3764 if (success)
3766 if (!STRING_EMPTY (&decl))
3768 string_append (result, " ");
3769 string_appends (result, &decl);
3772 else
3773 string_delete (result);
3774 string_delete (&decl);
3776 if (success)
3777 /* Assume an integral type, if we're not sure. */
3778 return (int) ((tk == tk_none) ? tk_integral : tk);
3779 else
3780 return 0;
3783 /* Given a pointer to a type string that represents a fundamental type
3784 argument (int, long, unsigned int, etc) in TYPE, a pointer to the
3785 string in which the demangled output is being built in RESULT, and
3786 the WORK structure, decode the types and add them to the result.
3788 For example:
3790 "Ci" => "const int"
3791 "Sl" => "signed long"
3792 "CUs" => "const unsigned short"
3794 The value returned is really a type_kind_t. */
3796 static int
3797 demangle_fund_type (work, mangled, result)
3798 struct work_stuff *work;
3799 const char **mangled;
3800 string *result;
3802 int done = 0;
3803 int success = 1;
3804 char buf[10];
3805 unsigned int dec = 0;
3806 string btype;
3807 type_kind_t tk = tk_integral;
3809 string_init (&btype);
3811 /* First pick off any type qualifiers. There can be more than one. */
3813 while (!done)
3815 switch (**mangled)
3817 case 'C':
3818 case 'V':
3819 case 'u':
3820 if (PRINT_ANSI_QUALIFIERS)
3822 if (!STRING_EMPTY (result))
3823 string_prepend (result, " ");
3824 string_prepend (result, demangle_qualifier (**mangled));
3826 (*mangled)++;
3827 break;
3828 case 'U':
3829 (*mangled)++;
3830 APPEND_BLANK (result);
3831 string_append (result, "unsigned");
3832 break;
3833 case 'S': /* signed char only */
3834 (*mangled)++;
3835 APPEND_BLANK (result);
3836 string_append (result, "signed");
3837 break;
3838 case 'J':
3839 (*mangled)++;
3840 APPEND_BLANK (result);
3841 string_append (result, "__complex");
3842 break;
3843 default:
3844 done = 1;
3845 break;
3849 /* Now pick off the fundamental type. There can be only one. */
3851 switch (**mangled)
3853 case '\0':
3854 case '_':
3855 break;
3856 case 'v':
3857 (*mangled)++;
3858 APPEND_BLANK (result);
3859 string_append (result, "void");
3860 break;
3861 case 'x':
3862 (*mangled)++;
3863 APPEND_BLANK (result);
3864 string_append (result, "long long");
3865 break;
3866 case 'l':
3867 (*mangled)++;
3868 APPEND_BLANK (result);
3869 string_append (result, "long");
3870 break;
3871 case 'i':
3872 (*mangled)++;
3873 APPEND_BLANK (result);
3874 string_append (result, "int");
3875 break;
3876 case 's':
3877 (*mangled)++;
3878 APPEND_BLANK (result);
3879 string_append (result, "short");
3880 break;
3881 case 'b':
3882 (*mangled)++;
3883 APPEND_BLANK (result);
3884 string_append (result, "bool");
3885 tk = tk_bool;
3886 break;
3887 case 'c':
3888 (*mangled)++;
3889 APPEND_BLANK (result);
3890 string_append (result, "char");
3891 tk = tk_char;
3892 break;
3893 case 'w':
3894 (*mangled)++;
3895 APPEND_BLANK (result);
3896 string_append (result, "wchar_t");
3897 tk = tk_char;
3898 break;
3899 case 'r':
3900 (*mangled)++;
3901 APPEND_BLANK (result);
3902 string_append (result, "long double");
3903 tk = tk_real;
3904 break;
3905 case 'd':
3906 (*mangled)++;
3907 APPEND_BLANK (result);
3908 string_append (result, "double");
3909 tk = tk_real;
3910 break;
3911 case 'f':
3912 (*mangled)++;
3913 APPEND_BLANK (result);
3914 string_append (result, "float");
3915 tk = tk_real;
3916 break;
3917 case 'G':
3918 (*mangled)++;
3919 if (!ISDIGIT ((unsigned char)**mangled))
3921 success = 0;
3922 break;
3924 case 'I':
3925 (*mangled)++;
3926 if (**mangled == '_')
3928 int i;
3929 (*mangled)++;
3930 for (i = 0;
3931 i < (long) sizeof (buf) - 1 && **mangled && **mangled != '_';
3932 (*mangled)++, i++)
3933 buf[i] = **mangled;
3934 if (**mangled != '_')
3936 success = 0;
3937 break;
3939 buf[i] = '\0';
3940 (*mangled)++;
3942 else
3944 strncpy (buf, *mangled, 2);
3945 buf[2] = '\0';
3946 *mangled += min (strlen (*mangled), 2);
3948 sscanf (buf, "%x", &dec);
3949 sprintf (buf, "int%u_t", dec);
3950 APPEND_BLANK (result);
3951 string_append (result, buf);
3952 break;
3954 /* fall through */
3955 /* An explicit type, such as "6mytype" or "7integer" */
3956 case '0':
3957 case '1':
3958 case '2':
3959 case '3':
3960 case '4':
3961 case '5':
3962 case '6':
3963 case '7':
3964 case '8':
3965 case '9':
3967 int bindex = register_Btype (work);
3968 string btype;
3969 string_init (&btype);
3970 if (demangle_class_name (work, mangled, &btype)) {
3971 remember_Btype (work, btype.b, LEN_STRING (&btype), bindex);
3972 APPEND_BLANK (result);
3973 string_appends (result, &btype);
3975 else
3976 success = 0;
3977 string_delete (&btype);
3978 break;
3980 case 't':
3982 success = demangle_template (work, mangled, &btype, 0, 1, 1);
3983 string_appends (result, &btype);
3984 break;
3986 default:
3987 success = 0;
3988 break;
3991 return success ? ((int) tk) : 0;
3995 /* Handle a template's value parameter for HP aCC (extension from ARM)
3996 **mangled points to 'S' or 'U' */
3998 static int
3999 do_hpacc_template_const_value (work, mangled, result)
4000 struct work_stuff *work ATTRIBUTE_UNUSED;
4001 const char **mangled;
4002 string *result;
4004 int unsigned_const;
4006 if (**mangled != 'U' && **mangled != 'S')
4007 return 0;
4009 unsigned_const = (**mangled == 'U');
4011 (*mangled)++;
4013 switch (**mangled)
4015 case 'N':
4016 string_append (result, "-");
4017 /* fall through */
4018 case 'P':
4019 (*mangled)++;
4020 break;
4021 case 'M':
4022 /* special case for -2^31 */
4023 string_append (result, "-2147483648");
4024 (*mangled)++;
4025 return 1;
4026 default:
4027 return 0;
4030 /* We have to be looking at an integer now */
4031 if (!(ISDIGIT ((unsigned char)**mangled)))
4032 return 0;
4034 /* We only deal with integral values for template
4035 parameters -- so it's OK to look only for digits */
4036 while (ISDIGIT ((unsigned char)**mangled))
4038 char_str[0] = **mangled;
4039 string_append (result, char_str);
4040 (*mangled)++;
4043 if (unsigned_const)
4044 string_append (result, "U");
4046 /* FIXME? Some day we may have 64-bit (or larger :-) ) constants
4047 with L or LL suffixes. pai/1997-09-03 */
4049 return 1; /* success */
4052 /* Handle a template's literal parameter for HP aCC (extension from ARM)
4053 **mangled is pointing to the 'A' */
4055 static int
4056 do_hpacc_template_literal (work, mangled, result)
4057 struct work_stuff *work;
4058 const char **mangled;
4059 string *result;
4061 int literal_len = 0;
4062 char * recurse;
4063 char * recurse_dem;
4065 if (**mangled != 'A')
4066 return 0;
4068 (*mangled)++;
4070 literal_len = consume_count (mangled);
4072 if (literal_len <= 0)
4073 return 0;
4075 /* Literal parameters are names of arrays, functions, etc. and the
4076 canonical representation uses the address operator */
4077 string_append (result, "&");
4079 /* Now recursively demangle the literal name */
4080 recurse = (char *) xmalloc (literal_len + 1);
4081 memcpy (recurse, *mangled, literal_len);
4082 recurse[literal_len] = '\000';
4084 recurse_dem = cplus_demangle (recurse, work->options);
4086 if (recurse_dem)
4088 string_append (result, recurse_dem);
4089 free (recurse_dem);
4091 else
4093 string_appendn (result, *mangled, literal_len);
4095 (*mangled) += literal_len;
4096 free (recurse);
4098 return 1;
4101 static int
4102 snarf_numeric_literal (args, arg)
4103 const char ** args;
4104 string * arg;
4106 if (**args == '-')
4108 char_str[0] = '-';
4109 string_append (arg, char_str);
4110 (*args)++;
4112 else if (**args == '+')
4113 (*args)++;
4115 if (!ISDIGIT ((unsigned char)**args))
4116 return 0;
4118 while (ISDIGIT ((unsigned char)**args))
4120 char_str[0] = **args;
4121 string_append (arg, char_str);
4122 (*args)++;
4125 return 1;
4128 /* Demangle the next argument, given by MANGLED into RESULT, which
4129 *should be an uninitialized* string. It will be initialized here,
4130 and free'd should anything go wrong. */
4132 static int
4133 do_arg (work, mangled, result)
4134 struct work_stuff *work;
4135 const char **mangled;
4136 string *result;
4138 /* Remember where we started so that we can record the type, for
4139 non-squangling type remembering. */
4140 const char *start = *mangled;
4142 string_init (result);
4144 if (work->nrepeats > 0)
4146 --work->nrepeats;
4148 if (work->previous_argument == 0)
4149 return 0;
4151 /* We want to reissue the previous type in this argument list. */
4152 string_appends (result, work->previous_argument);
4153 return 1;
4156 if (**mangled == 'n')
4158 /* A squangling-style repeat. */
4159 (*mangled)++;
4160 work->nrepeats = consume_count(mangled);
4162 if (work->nrepeats <= 0)
4163 /* This was not a repeat count after all. */
4164 return 0;
4166 if (work->nrepeats > 9)
4168 if (**mangled != '_')
4169 /* The repeat count should be followed by an '_' in this
4170 case. */
4171 return 0;
4172 else
4173 (*mangled)++;
4176 /* Now, the repeat is all set up. */
4177 return do_arg (work, mangled, result);
4180 /* Save the result in WORK->previous_argument so that we can find it
4181 if it's repeated. Note that saving START is not good enough: we
4182 do not want to add additional types to the back-referenceable
4183 type vector when processing a repeated type. */
4184 if (work->previous_argument)
4185 string_clear (work->previous_argument);
4186 else
4188 work->previous_argument = (string*) xmalloc (sizeof (string));
4189 string_init (work->previous_argument);
4192 if (!do_type (work, mangled, work->previous_argument))
4193 return 0;
4195 string_appends (result, work->previous_argument);
4197 remember_type (work, start, *mangled - start);
4198 return 1;
4201 static void
4202 remember_type (work, start, len)
4203 struct work_stuff *work;
4204 const char *start;
4205 int len;
4207 char *tem;
4209 if (work->forgetting_types)
4210 return;
4212 if (work -> ntypes >= work -> typevec_size)
4214 if (work -> typevec_size == 0)
4216 work -> typevec_size = 3;
4217 work -> typevec
4218 = (char **) xmalloc (sizeof (char *) * work -> typevec_size);
4220 else
4222 work -> typevec_size *= 2;
4223 work -> typevec
4224 = (char **) xrealloc ((char *)work -> typevec,
4225 sizeof (char *) * work -> typevec_size);
4228 tem = xmalloc (len + 1);
4229 memcpy (tem, start, len);
4230 tem[len] = '\0';
4231 work -> typevec[work -> ntypes++] = tem;
4235 /* Remember a K type class qualifier. */
4236 static void
4237 remember_Ktype (work, start, len)
4238 struct work_stuff *work;
4239 const char *start;
4240 int len;
4242 char *tem;
4244 if (work -> numk >= work -> ksize)
4246 if (work -> ksize == 0)
4248 work -> ksize = 5;
4249 work -> ktypevec
4250 = (char **) xmalloc (sizeof (char *) * work -> ksize);
4252 else
4254 work -> ksize *= 2;
4255 work -> ktypevec
4256 = (char **) xrealloc ((char *)work -> ktypevec,
4257 sizeof (char *) * work -> ksize);
4260 tem = xmalloc (len + 1);
4261 memcpy (tem, start, len);
4262 tem[len] = '\0';
4263 work -> ktypevec[work -> numk++] = tem;
4266 /* Register a B code, and get an index for it. B codes are registered
4267 as they are seen, rather than as they are completed, so map<temp<char> >
4268 registers map<temp<char> > as B0, and temp<char> as B1 */
4270 static int
4271 register_Btype (work)
4272 struct work_stuff *work;
4274 int ret;
4276 if (work -> numb >= work -> bsize)
4278 if (work -> bsize == 0)
4280 work -> bsize = 5;
4281 work -> btypevec
4282 = (char **) xmalloc (sizeof (char *) * work -> bsize);
4284 else
4286 work -> bsize *= 2;
4287 work -> btypevec
4288 = (char **) xrealloc ((char *)work -> btypevec,
4289 sizeof (char *) * work -> bsize);
4292 ret = work -> numb++;
4293 work -> btypevec[ret] = NULL;
4294 return(ret);
4297 /* Store a value into a previously registered B code type. */
4299 static void
4300 remember_Btype (work, start, len, index)
4301 struct work_stuff *work;
4302 const char *start;
4303 int len, index;
4305 char *tem;
4307 tem = xmalloc (len + 1);
4308 memcpy (tem, start, len);
4309 tem[len] = '\0';
4310 work -> btypevec[index] = tem;
4313 /* Lose all the info related to B and K type codes. */
4314 static void
4315 forget_B_and_K_types (work)
4316 struct work_stuff *work;
4318 int i;
4320 while (work -> numk > 0)
4322 i = --(work -> numk);
4323 if (work -> ktypevec[i] != NULL)
4325 free (work -> ktypevec[i]);
4326 work -> ktypevec[i] = NULL;
4330 while (work -> numb > 0)
4332 i = --(work -> numb);
4333 if (work -> btypevec[i] != NULL)
4335 free (work -> btypevec[i]);
4336 work -> btypevec[i] = NULL;
4340 /* Forget the remembered types, but not the type vector itself. */
4342 static void
4343 forget_types (work)
4344 struct work_stuff *work;
4346 int i;
4348 while (work -> ntypes > 0)
4350 i = --(work -> ntypes);
4351 if (work -> typevec[i] != NULL)
4353 free (work -> typevec[i]);
4354 work -> typevec[i] = NULL;
4359 /* Process the argument list part of the signature, after any class spec
4360 has been consumed, as well as the first 'F' character (if any). For
4361 example:
4363 "__als__3fooRT0" => process "RT0"
4364 "complexfunc5__FPFPc_PFl_i" => process "PFPc_PFl_i"
4366 DECLP must be already initialised, usually non-empty. It won't be freed
4367 on failure.
4369 Note that g++ differs significantly from ARM and lucid style mangling
4370 with regards to references to previously seen types. For example, given
4371 the source fragment:
4373 class foo {
4374 public:
4375 foo::foo (int, foo &ia, int, foo &ib, int, foo &ic);
4378 foo::foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
4379 void foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
4381 g++ produces the names:
4383 __3fooiRT0iT2iT2
4384 foo__FiR3fooiT1iT1
4386 while lcc (and presumably other ARM style compilers as well) produces:
4388 foo__FiR3fooT1T2T1T2
4389 __ct__3fooFiR3fooT1T2T1T2
4391 Note that g++ bases its type numbers starting at zero and counts all
4392 previously seen types, while lucid/ARM bases its type numbers starting
4393 at one and only considers types after it has seen the 'F' character
4394 indicating the start of the function args. For lucid/ARM style, we
4395 account for this difference by discarding any previously seen types when
4396 we see the 'F' character, and subtracting one from the type number
4397 reference.
4401 static int
4402 demangle_args (work, mangled, declp)
4403 struct work_stuff *work;
4404 const char **mangled;
4405 string *declp;
4407 string arg;
4408 int need_comma = 0;
4409 int r;
4410 int t;
4411 const char *tem;
4412 char temptype;
4414 if (PRINT_ARG_TYPES)
4416 string_append (declp, "(");
4417 if (**mangled == '\0')
4419 string_append (declp, "void");
4423 while ((**mangled != '_' && **mangled != '\0' && **mangled != 'e')
4424 || work->nrepeats > 0)
4426 if ((**mangled == 'N') || (**mangled == 'T'))
4428 temptype = *(*mangled)++;
4430 if (temptype == 'N')
4432 if (!get_count (mangled, &r))
4434 return (0);
4437 else
4439 r = 1;
4441 if ((HP_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING) && work -> ntypes >= 10)
4443 /* If we have 10 or more types we might have more than a 1 digit
4444 index so we'll have to consume the whole count here. This
4445 will lose if the next thing is a type name preceded by a
4446 count but it's impossible to demangle that case properly
4447 anyway. Eg if we already have 12 types is T12Pc "(..., type1,
4448 Pc, ...)" or "(..., type12, char *, ...)" */
4449 if ((t = consume_count(mangled)) <= 0)
4451 return (0);
4454 else
4456 if (!get_count (mangled, &t))
4458 return (0);
4461 if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
4463 t--;
4465 /* Validate the type index. Protect against illegal indices from
4466 malformed type strings. */
4467 if ((t < 0) || (t >= work -> ntypes))
4469 return (0);
4471 while (work->nrepeats > 0 || --r >= 0)
4473 tem = work -> typevec[t];
4474 if (need_comma && PRINT_ARG_TYPES)
4476 string_append (declp, ", ");
4478 if (!do_arg (work, &tem, &arg))
4480 return (0);
4482 if (PRINT_ARG_TYPES)
4484 string_appends (declp, &arg);
4486 string_delete (&arg);
4487 need_comma = 1;
4490 else
4492 if (need_comma && PRINT_ARG_TYPES)
4493 string_append (declp, ", ");
4494 if (!do_arg (work, mangled, &arg))
4495 return (0);
4496 if (PRINT_ARG_TYPES)
4497 string_appends (declp, &arg);
4498 string_delete (&arg);
4499 need_comma = 1;
4503 if (**mangled == 'e')
4505 (*mangled)++;
4506 if (PRINT_ARG_TYPES)
4508 if (need_comma)
4510 string_append (declp, ",");
4512 string_append (declp, "...");
4516 if (PRINT_ARG_TYPES)
4518 string_append (declp, ")");
4520 return (1);
4523 /* Like demangle_args, but for demangling the argument lists of function
4524 and method pointers or references, not top-level declarations. */
4526 static int
4527 demangle_nested_args (work, mangled, declp)
4528 struct work_stuff *work;
4529 const char **mangled;
4530 string *declp;
4532 string* saved_previous_argument;
4533 int result;
4534 int saved_nrepeats;
4536 /* The G++ name-mangling algorithm does not remember types on nested
4537 argument lists, unless -fsquangling is used, and in that case the
4538 type vector updated by remember_type is not used. So, we turn
4539 off remembering of types here. */
4540 ++work->forgetting_types;
4542 /* For the repeat codes used with -fsquangling, we must keep track of
4543 the last argument. */
4544 saved_previous_argument = work->previous_argument;
4545 saved_nrepeats = work->nrepeats;
4546 work->previous_argument = 0;
4547 work->nrepeats = 0;
4549 /* Actually demangle the arguments. */
4550 result = demangle_args (work, mangled, declp);
4552 /* Restore the previous_argument field. */
4553 if (work->previous_argument)
4554 string_delete (work->previous_argument);
4555 work->previous_argument = saved_previous_argument;
4556 --work->forgetting_types;
4557 work->nrepeats = saved_nrepeats;
4559 return result;
4562 static void
4563 demangle_function_name (work, mangled, declp, scan)
4564 struct work_stuff *work;
4565 const char **mangled;
4566 string *declp;
4567 const char *scan;
4569 size_t i;
4570 string type;
4571 const char *tem;
4573 string_appendn (declp, (*mangled), scan - (*mangled));
4574 string_need (declp, 1);
4575 *(declp -> p) = '\0';
4577 /* Consume the function name, including the "__" separating the name
4578 from the signature. We are guaranteed that SCAN points to the
4579 separator. */
4581 (*mangled) = scan + 2;
4582 /* We may be looking at an instantiation of a template function:
4583 foo__Xt1t2_Ft3t4, where t1, t2, ... are template arguments and a
4584 following _F marks the start of the function arguments. Handle
4585 the template arguments first. */
4587 if (HP_DEMANGLING && (**mangled == 'X'))
4589 demangle_arm_hp_template (work, mangled, 0, declp);
4590 /* This leaves MANGLED pointing to the 'F' marking func args */
4593 if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
4596 /* See if we have an ARM style constructor or destructor operator.
4597 If so, then just record it, clear the decl, and return.
4598 We can't build the actual constructor/destructor decl until later,
4599 when we recover the class name from the signature. */
4601 if (strcmp (declp -> b, "__ct") == 0)
4603 work -> constructor += 1;
4604 string_clear (declp);
4605 return;
4607 else if (strcmp (declp -> b, "__dt") == 0)
4609 work -> destructor += 1;
4610 string_clear (declp);
4611 return;
4615 if (declp->p - declp->b >= 3
4616 && declp->b[0] == 'o'
4617 && declp->b[1] == 'p'
4618 && strchr (cplus_markers, declp->b[2]) != NULL)
4620 /* see if it's an assignment expression */
4621 if (declp->p - declp->b >= 10 /* op$assign_ */
4622 && memcmp (declp->b + 3, "assign_", 7) == 0)
4624 for (i = 0; i < ARRAY_SIZE (optable); i++)
4626 int len = declp->p - declp->b - 10;
4627 if ((int) strlen (optable[i].in) == len
4628 && memcmp (optable[i].in, declp->b + 10, len) == 0)
4630 string_clear (declp);
4631 string_append (declp, "operator");
4632 string_append (declp, optable[i].out);
4633 string_append (declp, "=");
4634 break;
4638 else
4640 for (i = 0; i < ARRAY_SIZE (optable); i++)
4642 int len = declp->p - declp->b - 3;
4643 if ((int) strlen (optable[i].in) == len
4644 && memcmp (optable[i].in, declp->b + 3, len) == 0)
4646 string_clear (declp);
4647 string_append (declp, "operator");
4648 string_append (declp, optable[i].out);
4649 break;
4654 else if (declp->p - declp->b >= 5 && memcmp (declp->b, "type", 4) == 0
4655 && strchr (cplus_markers, declp->b[4]) != NULL)
4657 /* type conversion operator */
4658 tem = declp->b + 5;
4659 if (do_type (work, &tem, &type))
4661 string_clear (declp);
4662 string_append (declp, "operator ");
4663 string_appends (declp, &type);
4664 string_delete (&type);
4667 else if (declp->b[0] == '_' && declp->b[1] == '_'
4668 && declp->b[2] == 'o' && declp->b[3] == 'p')
4670 /* ANSI. */
4671 /* type conversion operator. */
4672 tem = declp->b + 4;
4673 if (do_type (work, &tem, &type))
4675 string_clear (declp);
4676 string_append (declp, "operator ");
4677 string_appends (declp, &type);
4678 string_delete (&type);
4681 else if (declp->b[0] == '_' && declp->b[1] == '_'
4682 && ISLOWER((unsigned char)declp->b[2])
4683 && ISLOWER((unsigned char)declp->b[3]))
4685 if (declp->b[4] == '\0')
4687 /* Operator. */
4688 for (i = 0; i < ARRAY_SIZE (optable); i++)
4690 if (strlen (optable[i].in) == 2
4691 && memcmp (optable[i].in, declp->b + 2, 2) == 0)
4693 string_clear (declp);
4694 string_append (declp, "operator");
4695 string_append (declp, optable[i].out);
4696 break;
4700 else
4702 if (declp->b[2] == 'a' && declp->b[5] == '\0')
4704 /* Assignment. */
4705 for (i = 0; i < ARRAY_SIZE (optable); i++)
4707 if (strlen (optable[i].in) == 3
4708 && memcmp (optable[i].in, declp->b + 2, 3) == 0)
4710 string_clear (declp);
4711 string_append (declp, "operator");
4712 string_append (declp, optable[i].out);
4713 break;
4721 /* a mini string-handling package */
4723 static void
4724 string_need (s, n)
4725 string *s;
4726 int n;
4728 int tem;
4730 if (s->b == NULL)
4732 if (n < 32)
4734 n = 32;
4736 s->p = s->b = xmalloc (n);
4737 s->e = s->b + n;
4739 else if (s->e - s->p < n)
4741 tem = s->p - s->b;
4742 n += tem;
4743 n *= 2;
4744 s->b = xrealloc (s->b, n);
4745 s->p = s->b + tem;
4746 s->e = s->b + n;
4750 static void
4751 string_delete (s)
4752 string *s;
4754 if (s->b != NULL)
4756 free (s->b);
4757 s->b = s->e = s->p = NULL;
4761 static void
4762 string_init (s)
4763 string *s;
4765 s->b = s->p = s->e = NULL;
4768 static void
4769 string_clear (s)
4770 string *s;
4772 s->p = s->b;
4775 #if 0
4777 static int
4778 string_empty (s)
4779 string *s;
4781 return (s->b == s->p);
4784 #endif
4786 static void
4787 string_append (p, s)
4788 string *p;
4789 const char *s;
4791 int n;
4792 if (s == NULL || *s == '\0')
4793 return;
4794 n = strlen (s);
4795 string_need (p, n);
4796 memcpy (p->p, s, n);
4797 p->p += n;
4800 static void
4801 string_appends (p, s)
4802 string *p, *s;
4804 int n;
4806 if (s->b != s->p)
4808 n = s->p - s->b;
4809 string_need (p, n);
4810 memcpy (p->p, s->b, n);
4811 p->p += n;
4815 static void
4816 string_appendn (p, s, n)
4817 string *p;
4818 const char *s;
4819 int n;
4821 if (n != 0)
4823 string_need (p, n);
4824 memcpy (p->p, s, n);
4825 p->p += n;
4829 static void
4830 string_prepend (p, s)
4831 string *p;
4832 const char *s;
4834 if (s != NULL && *s != '\0')
4836 string_prependn (p, s, strlen (s));
4840 static void
4841 string_prepends (p, s)
4842 string *p, *s;
4844 if (s->b != s->p)
4846 string_prependn (p, s->b, s->p - s->b);
4850 static void
4851 string_prependn (p, s, n)
4852 string *p;
4853 const char *s;
4854 int n;
4856 char *q;
4858 if (n != 0)
4860 string_need (p, n);
4861 for (q = p->p - 1; q >= p->b; q--)
4863 q[n] = q[0];
4865 memcpy (p->b, s, n);
4866 p->p += n;
4870 static void
4871 string_append_template_idx (s, idx)
4872 string *s;
4873 int idx;
4875 char buf[INTBUF_SIZE + 1 /* 'T' */];
4876 sprintf(buf, "T%d", idx);
4877 string_append (s, buf);