OSDN Git Service

2009-09-23 Matthew Gingell <gingell@adacore.com>
[pf3gnuchains/gcc-fork.git] / libiberty / cplus-dem.c
1 /* Demangler for GNU C++
2    Copyright 1989, 1991, 1994, 1995, 1996, 1997, 1998, 1999,
3    2000, 2001, 2002, 2003, 2004 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
7
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.
13
14 In addition to the permissions in the GNU Library General Public
15 License, the Free Software Foundation gives you unlimited permission
16 to link the compiled version of this file into combinations with other
17 programs, and to distribute those combinations without any restriction
18 coming from the use of this file.  (The Library Public License
19 restrictions do apply in other respects; for example, they cover
20 modification of the file, and distribution when not linked into a
21 combined executable.)
22
23 Libiberty is distributed in the hope that it will be useful,
24 but WITHOUT ANY WARRANTY; without even the implied warranty of
25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
26 Library General Public License for more details.
27
28 You should have received a copy of the GNU Library General Public
29 License along with libiberty; see the file COPYING.LIB.  If
30 not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
31 Boston, MA 02110-1301, USA.  */
32
33 /* This file exports two functions; cplus_mangle_opname and cplus_demangle.
34
35    This file imports xmalloc and xrealloc, which are like malloc and
36    realloc except that they generate a fatal error if there is no
37    available memory.  */
38
39 /* This file lives in both GCC and libiberty.  When making changes, please
40    try not to break either.  */
41
42 #ifdef HAVE_CONFIG_H
43 #include "config.h"
44 #endif
45
46 #include "safe-ctype.h"
47
48 #include <sys/types.h>
49 #include <string.h>
50 #include <stdio.h>
51
52 #ifdef HAVE_STDLIB_H
53 #include <stdlib.h>
54 #else
55 void * malloc ();
56 void * realloc ();
57 #endif
58
59 #include <demangle.h>
60 #undef CURRENT_DEMANGLING_STYLE
61 #define CURRENT_DEMANGLING_STYLE work->options
62
63 #include "libiberty.h"
64
65 static char *ada_demangle (const char *, int);
66
67 #define min(X,Y) (((X) < (Y)) ? (X) : (Y))
68
69 /* A value at least one greater than the maximum number of characters
70    that will be output when using the `%d' format with `printf'.  */
71 #define INTBUF_SIZE 32
72
73 extern void fancy_abort (void) ATTRIBUTE_NORETURN;
74
75 /* In order to allow a single demangler executable to demangle strings
76    using various common values of CPLUS_MARKER, as well as any specific
77    one set at compile time, we maintain a string containing all the
78    commonly used ones, and check to see if the marker we are looking for
79    is in that string.  CPLUS_MARKER is usually '$' on systems where the
80    assembler can deal with that.  Where the assembler can't, it's usually
81    '.' (but on many systems '.' is used for other things).  We put the
82    current defined CPLUS_MARKER first (which defaults to '$'), followed
83    by the next most common value, followed by an explicit '$' in case
84    the value of CPLUS_MARKER is not '$'.
85
86    We could avoid this if we could just get g++ to tell us what the actual
87    cplus marker character is as part of the debug information, perhaps by
88    ensuring that it is the character that terminates the gcc<n>_compiled
89    marker symbol (FIXME).  */
90
91 #if !defined (CPLUS_MARKER)
92 #define CPLUS_MARKER '$'
93 #endif
94
95 enum demangling_styles current_demangling_style = auto_demangling;
96
97 static char cplus_markers[] = { CPLUS_MARKER, '.', '$', '\0' };
98
99 static char char_str[2] = { '\000', '\000' };
100
101 void
102 set_cplus_marker_for_demangling (int ch)
103 {
104   cplus_markers[0] = ch;
105 }
106
107 typedef struct string           /* Beware: these aren't required to be */
108 {                               /*  '\0' terminated.  */
109   char *b;                      /* pointer to start of string */
110   char *p;                      /* pointer after last character */
111   char *e;                      /* pointer after end of allocated space */
112 } string;
113
114 /* Stuff that is shared between sub-routines.
115    Using a shared structure allows cplus_demangle to be reentrant.  */
116
117 struct work_stuff
118 {
119   int options;
120   char **typevec;
121   char **ktypevec;
122   char **btypevec;
123   int numk;
124   int numb;
125   int ksize;
126   int bsize;
127   int ntypes;
128   int typevec_size;
129   int constructor;
130   int destructor;
131   int static_type;      /* A static member function */
132   int temp_start;       /* index in demangled to start of template args */
133   int type_quals;       /* The type qualifiers.  */
134   int dllimported;      /* Symbol imported from a PE DLL */
135   char **tmpl_argvec;   /* Template function arguments. */
136   int ntmpl_args;       /* The number of template function arguments. */
137   int forgetting_types; /* Nonzero if we are not remembering the types
138                            we see.  */
139   string* previous_argument; /* The last function argument demangled.  */
140   int nrepeats;         /* The number of times to repeat the previous
141                            argument.  */
142 };
143
144 #define PRINT_ANSI_QUALIFIERS (work -> options & DMGL_ANSI)
145 #define PRINT_ARG_TYPES       (work -> options & DMGL_PARAMS)
146
147 static const struct optable
148 {
149   const char *const in;
150   const char *const out;
151   const int flags;
152 } optable[] = {
153   {"nw",          " new",       DMGL_ANSI},     /* new (1.92,    ansi) */
154   {"dl",          " delete",    DMGL_ANSI},     /* new (1.92,    ansi) */
155   {"new",         " new",       0},             /* old (1.91,    and 1.x) */
156   {"delete",      " delete",    0},             /* old (1.91,    and 1.x) */
157   {"vn",          " new []",    DMGL_ANSI},     /* GNU, pending ansi */
158   {"vd",          " delete []", DMGL_ANSI},     /* GNU, pending ansi */
159   {"as",          "=",          DMGL_ANSI},     /* ansi */
160   {"ne",          "!=",         DMGL_ANSI},     /* old, ansi */
161   {"eq",          "==",         DMGL_ANSI},     /* old, ansi */
162   {"ge",          ">=",         DMGL_ANSI},     /* old, ansi */
163   {"gt",          ">",          DMGL_ANSI},     /* old, ansi */
164   {"le",          "<=",         DMGL_ANSI},     /* old, ansi */
165   {"lt",          "<",          DMGL_ANSI},     /* old, ansi */
166   {"plus",        "+",          0},             /* old */
167   {"pl",          "+",          DMGL_ANSI},     /* ansi */
168   {"apl",         "+=",         DMGL_ANSI},     /* ansi */
169   {"minus",       "-",          0},             /* old */
170   {"mi",          "-",          DMGL_ANSI},     /* ansi */
171   {"ami",         "-=",         DMGL_ANSI},     /* ansi */
172   {"mult",        "*",          0},             /* old */
173   {"ml",          "*",          DMGL_ANSI},     /* ansi */
174   {"amu",         "*=",         DMGL_ANSI},     /* ansi (ARM/Lucid) */
175   {"aml",         "*=",         DMGL_ANSI},     /* ansi (GNU/g++) */
176   {"convert",     "+",          0},             /* old (unary +) */
177   {"negate",      "-",          0},             /* old (unary -) */
178   {"trunc_mod",   "%",          0},             /* old */
179   {"md",          "%",          DMGL_ANSI},     /* ansi */
180   {"amd",         "%=",         DMGL_ANSI},     /* ansi */
181   {"trunc_div",   "/",          0},             /* old */
182   {"dv",          "/",          DMGL_ANSI},     /* ansi */
183   {"adv",         "/=",         DMGL_ANSI},     /* ansi */
184   {"truth_andif", "&&",         0},             /* old */
185   {"aa",          "&&",         DMGL_ANSI},     /* ansi */
186   {"truth_orif",  "||",         0},             /* old */
187   {"oo",          "||",         DMGL_ANSI},     /* ansi */
188   {"truth_not",   "!",          0},             /* old */
189   {"nt",          "!",          DMGL_ANSI},     /* ansi */
190   {"postincrement","++",        0},             /* old */
191   {"pp",          "++",         DMGL_ANSI},     /* ansi */
192   {"postdecrement","--",        0},             /* old */
193   {"mm",          "--",         DMGL_ANSI},     /* ansi */
194   {"bit_ior",     "|",          0},             /* old */
195   {"or",          "|",          DMGL_ANSI},     /* ansi */
196   {"aor",         "|=",         DMGL_ANSI},     /* ansi */
197   {"bit_xor",     "^",          0},             /* old */
198   {"er",          "^",          DMGL_ANSI},     /* ansi */
199   {"aer",         "^=",         DMGL_ANSI},     /* ansi */
200   {"bit_and",     "&",          0},             /* old */
201   {"ad",          "&",          DMGL_ANSI},     /* ansi */
202   {"aad",         "&=",         DMGL_ANSI},     /* ansi */
203   {"bit_not",     "~",          0},             /* old */
204   {"co",          "~",          DMGL_ANSI},     /* ansi */
205   {"call",        "()",         0},             /* old */
206   {"cl",          "()",         DMGL_ANSI},     /* ansi */
207   {"alshift",     "<<",         0},             /* old */
208   {"ls",          "<<",         DMGL_ANSI},     /* ansi */
209   {"als",         "<<=",        DMGL_ANSI},     /* ansi */
210   {"arshift",     ">>",         0},             /* old */
211   {"rs",          ">>",         DMGL_ANSI},     /* ansi */
212   {"ars",         ">>=",        DMGL_ANSI},     /* ansi */
213   {"component",   "->",         0},             /* old */
214   {"pt",          "->",         DMGL_ANSI},     /* ansi; Lucid C++ form */
215   {"rf",          "->",         DMGL_ANSI},     /* ansi; ARM/GNU form */
216   {"indirect",    "*",          0},             /* old */
217   {"method_call",  "->()",      0},             /* old */
218   {"addr",        "&",          0},             /* old (unary &) */
219   {"array",       "[]",         0},             /* old */
220   {"vc",          "[]",         DMGL_ANSI},     /* ansi */
221   {"compound",    ", ",         0},             /* old */
222   {"cm",          ", ",         DMGL_ANSI},     /* ansi */
223   {"cond",        "?:",         0},             /* old */
224   {"cn",          "?:",         DMGL_ANSI},     /* pseudo-ansi */
225   {"max",         ">?",         0},             /* old */
226   {"mx",          ">?",         DMGL_ANSI},     /* pseudo-ansi */
227   {"min",         "<?",         0},             /* old */
228   {"mn",          "<?",         DMGL_ANSI},     /* pseudo-ansi */
229   {"nop",         "",           0},             /* old (for operator=) */
230   {"rm",          "->*",        DMGL_ANSI},     /* ansi */
231   {"sz",          "sizeof ",    DMGL_ANSI}      /* pseudo-ansi */
232 };
233
234 /* These values are used to indicate the various type varieties.
235    They are all non-zero so that they can be used as `success'
236    values.  */
237 typedef enum type_kind_t
238 {
239   tk_none,
240   tk_pointer,
241   tk_reference,
242   tk_integral,
243   tk_bool,
244   tk_char,
245   tk_real
246 } type_kind_t;
247
248 const struct demangler_engine libiberty_demanglers[] =
249 {
250   {
251     NO_DEMANGLING_STYLE_STRING,
252     no_demangling,
253     "Demangling disabled"
254   }
255   ,
256   {
257     AUTO_DEMANGLING_STYLE_STRING,
258       auto_demangling,
259       "Automatic selection based on executable"
260   }
261   ,
262   {
263     GNU_DEMANGLING_STYLE_STRING,
264       gnu_demangling,
265       "GNU (g++) style demangling"
266   }
267   ,
268   {
269     LUCID_DEMANGLING_STYLE_STRING,
270       lucid_demangling,
271       "Lucid (lcc) style demangling"
272   }
273   ,
274   {
275     ARM_DEMANGLING_STYLE_STRING,
276       arm_demangling,
277       "ARM style demangling"
278   }
279   ,
280   {
281     HP_DEMANGLING_STYLE_STRING,
282       hp_demangling,
283       "HP (aCC) style demangling"
284   }
285   ,
286   {
287     EDG_DEMANGLING_STYLE_STRING,
288       edg_demangling,
289       "EDG style demangling"
290   }
291   ,
292   {
293     GNU_V3_DEMANGLING_STYLE_STRING,
294     gnu_v3_demangling,
295     "GNU (g++) V3 ABI-style demangling"
296   }
297   ,
298   {
299     JAVA_DEMANGLING_STYLE_STRING,
300     java_demangling,
301     "Java style demangling"
302   }
303   ,
304   {
305     GNAT_DEMANGLING_STYLE_STRING,
306     gnat_demangling,
307     "GNAT style demangling"
308   }
309   ,
310   {
311     NULL, unknown_demangling, NULL
312   }
313 };
314
315 #define STRING_EMPTY(str)       ((str) -> b == (str) -> p)
316 #define APPEND_BLANK(str)       {if (!STRING_EMPTY(str)) \
317     string_append(str, " ");}
318 #define LEN_STRING(str)         ( (STRING_EMPTY(str))?0:((str)->p - (str)->b))
319
320 /* The scope separator appropriate for the language being demangled.  */
321
322 #define SCOPE_STRING(work) ((work->options & DMGL_JAVA) ? "." : "::")
323
324 #define ARM_VTABLE_STRING "__vtbl__"    /* Lucid/ARM virtual table prefix */
325 #define ARM_VTABLE_STRLEN 8             /* strlen (ARM_VTABLE_STRING) */
326
327 /* Prototypes for local functions */
328
329 static void delete_work_stuff (struct work_stuff *);
330
331 static void delete_non_B_K_work_stuff (struct work_stuff *);
332
333 static char *mop_up (struct work_stuff *, string *, int);
334
335 static void squangle_mop_up (struct work_stuff *);
336
337 static void work_stuff_copy_to_from (struct work_stuff *, struct work_stuff *);
338
339 #if 0
340 static int
341 demangle_method_args (struct work_stuff *, const char **, string *);
342 #endif
343
344 static char *
345 internal_cplus_demangle (struct work_stuff *, const char *);
346
347 static int
348 demangle_template_template_parm (struct work_stuff *work,
349                                  const char **, string *);
350
351 static int
352 demangle_template (struct work_stuff *work, const char **, string *,
353                    string *, int, int);
354
355 static int
356 arm_pt (struct work_stuff *, const char *, int, const char **,
357         const char **);
358
359 static int
360 demangle_class_name (struct work_stuff *, const char **, string *);
361
362 static int
363 demangle_qualified (struct work_stuff *, const char **, string *,
364                     int, int);
365
366 static int demangle_class (struct work_stuff *, const char **, string *);
367
368 static int demangle_fund_type (struct work_stuff *, const char **, string *);
369
370 static int demangle_signature (struct work_stuff *, const char **, string *);
371
372 static int demangle_prefix (struct work_stuff *, const char **, string *);
373
374 static int gnu_special (struct work_stuff *, const char **, string *);
375
376 static int arm_special (const char **, string *);
377
378 static void string_need (string *, int);
379
380 static void string_delete (string *);
381
382 static void
383 string_init (string *);
384
385 static void string_clear (string *);
386
387 #if 0
388 static int string_empty (string *);
389 #endif
390
391 static void string_append (string *, const char *);
392
393 static void string_appends (string *, string *);
394
395 static void string_appendn (string *, const char *, int);
396
397 static void string_prepend (string *, const char *);
398
399 static void string_prependn (string *, const char *, int);
400
401 static void string_append_template_idx (string *, int);
402
403 static int get_count (const char **, int *);
404
405 static int consume_count (const char **);
406
407 static int consume_count_with_underscores (const char**);
408
409 static int demangle_args (struct work_stuff *, const char **, string *);
410
411 static int demangle_nested_args (struct work_stuff*, const char**, string*);
412
413 static int do_type (struct work_stuff *, const char **, string *);
414
415 static int do_arg (struct work_stuff *, const char **, string *);
416
417 static int
418 demangle_function_name (struct work_stuff *, const char **, string *,
419                         const char *);
420
421 static int
422 iterate_demangle_function (struct work_stuff *,
423                            const char **, string *, const char *);
424
425 static void remember_type (struct work_stuff *, const char *, int);
426
427 static void remember_Btype (struct work_stuff *, const char *, int, int);
428
429 static int register_Btype (struct work_stuff *);
430
431 static void remember_Ktype (struct work_stuff *, const char *, int);
432
433 static void forget_types (struct work_stuff *);
434
435 static void forget_B_and_K_types (struct work_stuff *);
436
437 static void string_prepends (string *, string *);
438
439 static int
440 demangle_template_value_parm (struct work_stuff*, const char**,
441                               string*, type_kind_t);
442
443 static int
444 do_hpacc_template_const_value (struct work_stuff *, const char **, string *);
445
446 static int
447 do_hpacc_template_literal (struct work_stuff *, const char **, string *);
448
449 static int snarf_numeric_literal (const char **, string *);
450
451 /* There is a TYPE_QUAL value for each type qualifier.  They can be
452    combined by bitwise-or to form the complete set of qualifiers for a
453    type.  */
454
455 #define TYPE_UNQUALIFIED   0x0
456 #define TYPE_QUAL_CONST    0x1
457 #define TYPE_QUAL_VOLATILE 0x2
458 #define TYPE_QUAL_RESTRICT 0x4
459
460 static int code_for_qualifier (int);
461
462 static const char* qualifier_string (int);
463
464 static const char* demangle_qualifier (int);
465
466 static int demangle_expression (struct work_stuff *, const char **, string *, 
467                                 type_kind_t);
468
469 static int
470 demangle_integral_value (struct work_stuff *, const char **, string *);
471
472 static int
473 demangle_real_value (struct work_stuff *, const char **, string *);
474
475 static void
476 demangle_arm_hp_template (struct work_stuff *, const char **, int, string *);
477
478 static void
479 recursively_demangle (struct work_stuff *, const char **, string *, int);
480
481 static void grow_vect (char **, size_t *, size_t, int);
482
483 /* Translate count to integer, consuming tokens in the process.
484    Conversion terminates on the first non-digit character.
485
486    Trying to consume something that isn't a count results in no
487    consumption of input and a return of -1.
488
489    Overflow consumes the rest of the digits, and returns -1.  */
490
491 static int
492 consume_count (const char **type)
493 {
494   int count = 0;
495
496   if (! ISDIGIT ((unsigned char)**type))
497     return -1;
498
499   while (ISDIGIT ((unsigned char)**type))
500     {
501       count *= 10;
502
503       /* Check for overflow.
504          We assume that count is represented using two's-complement;
505          no power of two is divisible by ten, so if an overflow occurs
506          when multiplying by ten, the result will not be a multiple of
507          ten.  */
508       if ((count % 10) != 0)
509         {
510           while (ISDIGIT ((unsigned char) **type))
511             (*type)++;
512           return -1;
513         }
514
515       count += **type - '0';
516       (*type)++;
517     }
518
519   if (count < 0)
520     count = -1;
521
522   return (count);
523 }
524
525
526 /* Like consume_count, but for counts that are preceded and followed
527    by '_' if they are greater than 10.  Also, -1 is returned for
528    failure, since 0 can be a valid value.  */
529
530 static int
531 consume_count_with_underscores (const char **mangled)
532 {
533   int idx;
534
535   if (**mangled == '_')
536     {
537       (*mangled)++;
538       if (!ISDIGIT ((unsigned char)**mangled))
539         return -1;
540
541       idx = consume_count (mangled);
542       if (**mangled != '_')
543         /* The trailing underscore was missing. */
544         return -1;
545
546       (*mangled)++;
547     }
548   else
549     {
550       if (**mangled < '0' || **mangled > '9')
551         return -1;
552
553       idx = **mangled - '0';
554       (*mangled)++;
555     }
556
557   return idx;
558 }
559
560 /* C is the code for a type-qualifier.  Return the TYPE_QUAL
561    corresponding to this qualifier.  */
562
563 static int
564 code_for_qualifier (int c)
565 {
566   switch (c)
567     {
568     case 'C':
569       return TYPE_QUAL_CONST;
570
571     case 'V':
572       return TYPE_QUAL_VOLATILE;
573
574     case 'u':
575       return TYPE_QUAL_RESTRICT;
576
577     default:
578       break;
579     }
580
581   /* C was an invalid qualifier.  */
582   abort ();
583 }
584
585 /* Return the string corresponding to the qualifiers given by
586    TYPE_QUALS.  */
587
588 static const char*
589 qualifier_string (int type_quals)
590 {
591   switch (type_quals)
592     {
593     case TYPE_UNQUALIFIED:
594       return "";
595
596     case TYPE_QUAL_CONST:
597       return "const";
598
599     case TYPE_QUAL_VOLATILE:
600       return "volatile";
601
602     case TYPE_QUAL_RESTRICT:
603       return "__restrict";
604
605     case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE:
606       return "const volatile";
607
608     case TYPE_QUAL_CONST | TYPE_QUAL_RESTRICT:
609       return "const __restrict";
610
611     case TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT:
612       return "volatile __restrict";
613
614     case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT:
615       return "const volatile __restrict";
616
617     default:
618       break;
619     }
620
621   /* TYPE_QUALS was an invalid qualifier set.  */
622   abort ();
623 }
624
625 /* C is the code for a type-qualifier.  Return the string
626    corresponding to this qualifier.  This function should only be
627    called with a valid qualifier code.  */
628
629 static const char*
630 demangle_qualifier (int c)
631 {
632   return qualifier_string (code_for_qualifier (c));
633 }
634
635 int
636 cplus_demangle_opname (const char *opname, char *result, int options)
637 {
638   int len, len1, ret;
639   string type;
640   struct work_stuff work[1];
641   const char *tem;
642
643   len = strlen(opname);
644   result[0] = '\0';
645   ret = 0;
646   memset ((char *) work, 0, sizeof (work));
647   work->options = options;
648
649   if (opname[0] == '_' && opname[1] == '_'
650       && opname[2] == 'o' && opname[3] == 'p')
651     {
652       /* ANSI.  */
653       /* type conversion operator.  */
654       tem = opname + 4;
655       if (do_type (work, &tem, &type))
656         {
657           strcat (result, "operator ");
658           strncat (result, type.b, type.p - type.b);
659           string_delete (&type);
660           ret = 1;
661         }
662     }
663   else if (opname[0] == '_' && opname[1] == '_'
664            && ISLOWER((unsigned char)opname[2])
665            && ISLOWER((unsigned char)opname[3]))
666     {
667       if (opname[4] == '\0')
668         {
669           /* Operator.  */
670           size_t i;
671           for (i = 0; i < ARRAY_SIZE (optable); i++)
672             {
673               if (strlen (optable[i].in) == 2
674                   && memcmp (optable[i].in, opname + 2, 2) == 0)
675                 {
676                   strcat (result, "operator");
677                   strcat (result, optable[i].out);
678                   ret = 1;
679                   break;
680                 }
681             }
682         }
683       else
684         {
685           if (opname[2] == 'a' && opname[5] == '\0')
686             {
687               /* Assignment.  */
688               size_t i;
689               for (i = 0; i < ARRAY_SIZE (optable); i++)
690                 {
691                   if (strlen (optable[i].in) == 3
692                       && memcmp (optable[i].in, opname + 2, 3) == 0)
693                     {
694                       strcat (result, "operator");
695                       strcat (result, optable[i].out);
696                       ret = 1;
697                       break;
698                     }
699                 }
700             }
701         }
702     }
703   else if (len >= 3
704            && opname[0] == 'o'
705            && opname[1] == 'p'
706            && strchr (cplus_markers, opname[2]) != NULL)
707     {
708       /* see if it's an assignment expression */
709       if (len >= 10 /* op$assign_ */
710           && memcmp (opname + 3, "assign_", 7) == 0)
711         {
712           size_t i;
713           for (i = 0; i < ARRAY_SIZE (optable); i++)
714             {
715               len1 = len - 10;
716               if ((int) strlen (optable[i].in) == len1
717                   && memcmp (optable[i].in, opname + 10, len1) == 0)
718                 {
719                   strcat (result, "operator");
720                   strcat (result, optable[i].out);
721                   strcat (result, "=");
722                   ret = 1;
723                   break;
724                 }
725             }
726         }
727       else
728         {
729           size_t i;
730           for (i = 0; i < ARRAY_SIZE (optable); i++)
731             {
732               len1 = len - 3;
733               if ((int) strlen (optable[i].in) == len1
734                   && memcmp (optable[i].in, opname + 3, len1) == 0)
735                 {
736                   strcat (result, "operator");
737                   strcat (result, optable[i].out);
738                   ret = 1;
739                   break;
740                 }
741             }
742         }
743     }
744   else if (len >= 5 && memcmp (opname, "type", 4) == 0
745            && strchr (cplus_markers, opname[4]) != NULL)
746     {
747       /* type conversion operator */
748       tem = opname + 5;
749       if (do_type (work, &tem, &type))
750         {
751           strcat (result, "operator ");
752           strncat (result, type.b, type.p - type.b);
753           string_delete (&type);
754           ret = 1;
755         }
756     }
757   squangle_mop_up (work);
758   return ret;
759
760 }
761
762 /* Takes operator name as e.g. "++" and returns mangled
763    operator name (e.g. "postincrement_expr"), or NULL if not found.
764
765    If OPTIONS & DMGL_ANSI == 1, return the ANSI name;
766    if OPTIONS & DMGL_ANSI == 0, return the old GNU name.  */
767
768 const char *
769 cplus_mangle_opname (const char *opname, int options)
770 {
771   size_t i;
772   int len;
773
774   len = strlen (opname);
775   for (i = 0; i < ARRAY_SIZE (optable); i++)
776     {
777       if ((int) strlen (optable[i].out) == len
778           && (options & DMGL_ANSI) == (optable[i].flags & DMGL_ANSI)
779           && memcmp (optable[i].out, opname, len) == 0)
780         return optable[i].in;
781     }
782   return (0);
783 }
784
785 /* Add a routine to set the demangling style to be sure it is valid and
786    allow for any demangler initialization that maybe necessary. */
787
788 enum demangling_styles
789 cplus_demangle_set_style (enum demangling_styles style)
790 {
791   const struct demangler_engine *demangler = libiberty_demanglers; 
792
793   for (; demangler->demangling_style != unknown_demangling; ++demangler)
794     if (style == demangler->demangling_style)
795       {
796         current_demangling_style = style;
797         return current_demangling_style;
798       }
799
800   return unknown_demangling;
801 }
802
803 /* Do string name to style translation */
804
805 enum demangling_styles
806 cplus_demangle_name_to_style (const char *name)
807 {
808   const struct demangler_engine *demangler = libiberty_demanglers; 
809
810   for (; demangler->demangling_style != unknown_demangling; ++demangler)
811     if (strcmp (name, demangler->demangling_style_name) == 0)
812       return demangler->demangling_style;
813
814   return unknown_demangling;
815 }
816
817 /* char *cplus_demangle (const char *mangled, int options)
818
819    If MANGLED is a mangled function name produced by GNU C++, then
820    a pointer to a @code{malloc}ed string giving a C++ representation
821    of the name will be returned; otherwise NULL will be returned.
822    It is the caller's responsibility to free the string which
823    is returned.
824
825    The OPTIONS arg may contain one or more of the following bits:
826
827         DMGL_ANSI       ANSI qualifiers such as `const' and `void' are
828                         included.
829         DMGL_PARAMS     Function parameters are included.
830
831    For example,
832
833    cplus_demangle ("foo__1Ai", DMGL_PARAMS)             => "A::foo(int)"
834    cplus_demangle ("foo__1Ai", DMGL_PARAMS | DMGL_ANSI) => "A::foo(int)"
835    cplus_demangle ("foo__1Ai", 0)                       => "A::foo"
836
837    cplus_demangle ("foo__1Afe", DMGL_PARAMS)            => "A::foo(float,...)"
838    cplus_demangle ("foo__1Afe", DMGL_PARAMS | DMGL_ANSI)=> "A::foo(float,...)"
839    cplus_demangle ("foo__1Afe", 0)                      => "A::foo"
840
841    Note that any leading underscores, or other such characters prepended by
842    the compilation system, are presumed to have already been stripped from
843    MANGLED.  */
844
845 char *
846 cplus_demangle (const char *mangled, int options)
847 {
848   char *ret;
849   struct work_stuff work[1];
850
851   if (current_demangling_style == no_demangling)
852     return xstrdup (mangled);
853
854   memset ((char *) work, 0, sizeof (work));
855   work->options = options;
856   if ((work->options & DMGL_STYLE_MASK) == 0)
857     work->options |= (int) current_demangling_style & DMGL_STYLE_MASK;
858
859   /* The V3 ABI demangling is implemented elsewhere.  */
860   if (GNU_V3_DEMANGLING || AUTO_DEMANGLING)
861     {
862       ret = cplus_demangle_v3 (mangled, work->options);
863       if (ret || GNU_V3_DEMANGLING)
864         return ret;
865     }
866
867   if (JAVA_DEMANGLING)
868     {
869       ret = java_demangle_v3 (mangled);
870       if (ret)
871         return ret;
872     }
873
874   if (GNAT_DEMANGLING)
875     return ada_demangle(mangled,options);
876
877   ret = internal_cplus_demangle (work, mangled);
878   squangle_mop_up (work);
879   return (ret);
880 }
881
882
883 /* Assuming *OLD_VECT points to an array of *SIZE objects of size
884    ELEMENT_SIZE, grow it to contain at least MIN_SIZE objects,
885    updating *OLD_VECT and *SIZE as necessary.  */
886
887 static void
888 grow_vect (char **old_vect, size_t *size, size_t min_size, int element_size)
889 {
890   if (*size < min_size)
891     {
892       *size *= 2;
893       if (*size < min_size)
894         *size = min_size;
895       *old_vect = XRESIZEVAR (char, *old_vect, *size * element_size);
896     }
897 }
898
899 /* Demangle ada names:
900    1. Discard final __{DIGIT}+ or ${DIGIT}+
901    2. Convert other instances of embedded "__" to `.'.
902    3. Discard leading _ada_.
903    4. Remove everything after first ___ if it is followed by 'X'.
904    5. Put symbols that should be suppressed in <...> brackets.
905    The resulting string is valid until the next call of ada_demangle.  */
906
907 static char *
908 ada_demangle (const char *mangled, int option ATTRIBUTE_UNUSED)
909 {
910   int i, j;
911   int len0;
912   const char* p;
913   char *demangled = NULL;
914   int changed;
915   size_t demangled_size = 0;
916   
917   changed = 0;
918
919   if (strncmp (mangled, "_ada_", 5) == 0)
920     {
921       mangled += 5;
922       changed = 1;
923     }
924   
925   if (mangled[0] == '_' || mangled[0] == '<')
926     goto Suppress;
927   
928   p = strstr (mangled, "___");
929   if (p == NULL)
930     len0 = strlen (mangled);
931   else
932     {
933       if (p[3] == 'X')
934         {
935           len0 = p - mangled;
936           changed = 1;
937         }
938       else
939         goto Suppress;
940     }
941   
942   /* Make demangled big enough for possible expansion by operator name.  */
943   grow_vect (&demangled,
944              &demangled_size,  2 * len0 + 1,
945              sizeof (char));
946   
947   if (ISDIGIT ((unsigned char) mangled[len0 - 1])) {
948     for (i = len0 - 2; i >= 0 && ISDIGIT ((unsigned char) mangled[i]); i -= 1)
949       ;
950     if (i > 1 && mangled[i] == '_' && mangled[i - 1] == '_')
951       {
952         len0 = i - 1;
953         changed = 1;
954       }
955     else if (mangled[i] == '$')
956       {
957         len0 = i;
958         changed = 1;
959       }
960   }
961   
962   for (i = 0, j = 0; i < len0 && ! ISALPHA ((unsigned char)mangled[i]);
963        i += 1, j += 1)
964     demangled[j] = mangled[i];
965   
966   while (i < len0)
967     {
968       if (i < len0 - 2 && mangled[i] == '_' && mangled[i + 1] == '_')
969         {
970           demangled[j] = '.';
971           changed = 1;
972           i += 2; j += 1;
973         }
974       else
975         {
976           demangled[j] = mangled[i];
977           i += 1;  j += 1;
978         }
979     }
980   demangled[j] = '\000';
981   
982   for (i = 0; demangled[i] != '\0'; i += 1)
983     if (ISUPPER ((unsigned char)demangled[i]) || demangled[i] == ' ')
984       goto Suppress;
985
986   if (! changed)
987     {
988       free (demangled);
989       return NULL;
990     }
991   else
992     return demangled;
993   
994  Suppress:
995   grow_vect (&demangled,
996              &demangled_size,  strlen (mangled) + 3,
997              sizeof (char));
998
999   if (mangled[0] == '<')
1000      strcpy (demangled, mangled);
1001   else
1002     sprintf (demangled, "<%s>", mangled);
1003
1004   return demangled;
1005 }
1006
1007 /* This function performs most of what cplus_demangle use to do, but
1008    to be able to demangle a name with a B, K or n code, we need to
1009    have a longer term memory of what types have been seen. The original
1010    now initializes and cleans up the squangle code info, while internal
1011    calls go directly to this routine to avoid resetting that info. */
1012
1013 static char *
1014 internal_cplus_demangle (struct work_stuff *work, const char *mangled)
1015 {
1016
1017   string decl;
1018   int success = 0;
1019   char *demangled = NULL;
1020   int s1, s2, s3, s4;
1021   s1 = work->constructor;
1022   s2 = work->destructor;
1023   s3 = work->static_type;
1024   s4 = work->type_quals;
1025   work->constructor = work->destructor = 0;
1026   work->type_quals = TYPE_UNQUALIFIED;
1027   work->dllimported = 0;
1028
1029   if ((mangled != NULL) && (*mangled != '\0'))
1030     {
1031       string_init (&decl);
1032
1033       /* First check to see if gnu style demangling is active and if the
1034          string to be demangled contains a CPLUS_MARKER.  If so, attempt to
1035          recognize one of the gnu special forms rather than looking for a
1036          standard prefix.  In particular, don't worry about whether there
1037          is a "__" string in the mangled string.  Consider "_$_5__foo" for
1038          example.  */
1039
1040       if ((AUTO_DEMANGLING || GNU_DEMANGLING))
1041         {
1042           success = gnu_special (work, &mangled, &decl);
1043         }
1044       if (!success)
1045         {
1046           success = demangle_prefix (work, &mangled, &decl);
1047         }
1048       if (success && (*mangled != '\0'))
1049         {
1050           success = demangle_signature (work, &mangled, &decl);
1051         }
1052       if (work->constructor == 2)
1053         {
1054           string_prepend (&decl, "global constructors keyed to ");
1055           work->constructor = 0;
1056         }
1057       else if (work->destructor == 2)
1058         {
1059           string_prepend (&decl, "global destructors keyed to ");
1060           work->destructor = 0;
1061         }
1062       else if (work->dllimported == 1)
1063         {
1064           string_prepend (&decl, "import stub for ");
1065           work->dllimported = 0;
1066         }
1067       demangled = mop_up (work, &decl, success);
1068     }
1069   work->constructor = s1;
1070   work->destructor = s2;
1071   work->static_type = s3;
1072   work->type_quals = s4;
1073   return demangled;
1074 }
1075
1076
1077 /* Clear out and squangling related storage */
1078 static void
1079 squangle_mop_up (struct work_stuff *work)
1080 {
1081   /* clean up the B and K type mangling types. */
1082   forget_B_and_K_types (work);
1083   if (work -> btypevec != NULL)
1084     {
1085       free ((char *) work -> btypevec);
1086     }
1087   if (work -> ktypevec != NULL)
1088     {
1089       free ((char *) work -> ktypevec);
1090     }
1091 }
1092
1093
1094 /* Copy the work state and storage.  */
1095
1096 static void
1097 work_stuff_copy_to_from (struct work_stuff *to, struct work_stuff *from)
1098 {
1099   int i;
1100
1101   delete_work_stuff (to);
1102
1103   /* Shallow-copy scalars.  */
1104   memcpy (to, from, sizeof (*to));
1105
1106   /* Deep-copy dynamic storage.  */
1107   if (from->typevec_size)
1108     to->typevec = XNEWVEC (char *, from->typevec_size);
1109
1110   for (i = 0; i < from->ntypes; i++)
1111     {
1112       int len = strlen (from->typevec[i]) + 1;
1113
1114       to->typevec[i] = XNEWVEC (char, len);
1115       memcpy (to->typevec[i], from->typevec[i], len);
1116     }
1117
1118   if (from->ksize)
1119     to->ktypevec = XNEWVEC (char *, from->ksize);
1120
1121   for (i = 0; i < from->numk; i++)
1122     {
1123       int len = strlen (from->ktypevec[i]) + 1;
1124
1125       to->ktypevec[i] = XNEWVEC (char, len);
1126       memcpy (to->ktypevec[i], from->ktypevec[i], len);
1127     }
1128
1129   if (from->bsize)
1130     to->btypevec = XNEWVEC (char *, from->bsize);
1131
1132   for (i = 0; i < from->numb; i++)
1133     {
1134       int len = strlen (from->btypevec[i]) + 1;
1135
1136       to->btypevec[i] = XNEWVEC (char , len);
1137       memcpy (to->btypevec[i], from->btypevec[i], len);
1138     }
1139
1140   if (from->ntmpl_args)
1141     to->tmpl_argvec = XNEWVEC (char *, from->ntmpl_args);
1142
1143   for (i = 0; i < from->ntmpl_args; i++)
1144     {
1145       int len = strlen (from->tmpl_argvec[i]) + 1;
1146
1147       to->tmpl_argvec[i] = XNEWVEC (char, len);
1148       memcpy (to->tmpl_argvec[i], from->tmpl_argvec[i], len);
1149     }
1150
1151   if (from->previous_argument)
1152     {
1153       to->previous_argument = XNEW (string);
1154       string_init (to->previous_argument);
1155       string_appends (to->previous_argument, from->previous_argument);
1156     }
1157 }
1158
1159
1160 /* Delete dynamic stuff in work_stuff that is not to be re-used.  */
1161
1162 static void
1163 delete_non_B_K_work_stuff (struct work_stuff *work)
1164 {
1165   /* Discard the remembered types, if any.  */
1166
1167   forget_types (work);
1168   if (work -> typevec != NULL)
1169     {
1170       free ((char *) work -> typevec);
1171       work -> typevec = NULL;
1172       work -> typevec_size = 0;
1173     }
1174   if (work->tmpl_argvec)
1175     {
1176       int i;
1177
1178       for (i = 0; i < work->ntmpl_args; i++)
1179         if (work->tmpl_argvec[i])
1180           free ((char*) work->tmpl_argvec[i]);
1181
1182       free ((char*) work->tmpl_argvec);
1183       work->tmpl_argvec = NULL;
1184     }
1185   if (work->previous_argument)
1186     {
1187       string_delete (work->previous_argument);
1188       free ((char*) work->previous_argument);
1189       work->previous_argument = NULL;
1190     }
1191 }
1192
1193
1194 /* Delete all dynamic storage in work_stuff.  */
1195 static void
1196 delete_work_stuff (struct work_stuff *work)
1197 {
1198   delete_non_B_K_work_stuff (work);
1199   squangle_mop_up (work);
1200 }
1201
1202
1203 /* Clear out any mangled storage */
1204
1205 static char *
1206 mop_up (struct work_stuff *work, string *declp, int success)
1207 {
1208   char *demangled = NULL;
1209
1210   delete_non_B_K_work_stuff (work);
1211
1212   /* If demangling was successful, ensure that the demangled string is null
1213      terminated and return it.  Otherwise, free the demangling decl.  */
1214
1215   if (!success)
1216     {
1217       string_delete (declp);
1218     }
1219   else
1220     {
1221       string_appendn (declp, "", 1);
1222       demangled = declp->b;
1223     }
1224   return (demangled);
1225 }
1226
1227 /*
1228
1229 LOCAL FUNCTION
1230
1231         demangle_signature -- demangle the signature part of a mangled name
1232
1233 SYNOPSIS
1234
1235         static int
1236         demangle_signature (struct work_stuff *work, const char **mangled,
1237                             string *declp);
1238
1239 DESCRIPTION
1240
1241         Consume and demangle the signature portion of the mangled name.
1242
1243         DECLP is the string where demangled output is being built.  At
1244         entry it contains the demangled root name from the mangled name
1245         prefix.  I.E. either a demangled operator name or the root function
1246         name.  In some special cases, it may contain nothing.
1247
1248         *MANGLED points to the current unconsumed location in the mangled
1249         name.  As tokens are consumed and demangling is performed, the
1250         pointer is updated to continuously point at the next token to
1251         be consumed.
1252
1253         Demangling GNU style mangled names is nasty because there is no
1254         explicit token that marks the start of the outermost function
1255         argument list.  */
1256
1257 static int
1258 demangle_signature (struct work_stuff *work,
1259                     const char **mangled, string *declp)
1260 {
1261   int success = 1;
1262   int func_done = 0;
1263   int expect_func = 0;
1264   int expect_return_type = 0;
1265   const char *oldmangled = NULL;
1266   string trawname;
1267   string tname;
1268
1269   while (success && (**mangled != '\0'))
1270     {
1271       switch (**mangled)
1272         {
1273         case 'Q':
1274           oldmangled = *mangled;
1275           success = demangle_qualified (work, mangled, declp, 1, 0);
1276           if (success)
1277             remember_type (work, oldmangled, *mangled - oldmangled);
1278           if (AUTO_DEMANGLING || GNU_DEMANGLING)
1279             expect_func = 1;
1280           oldmangled = NULL;
1281           break;
1282
1283         case 'K':
1284           oldmangled = *mangled;
1285           success = demangle_qualified (work, mangled, declp, 1, 0);
1286           if (AUTO_DEMANGLING || GNU_DEMANGLING)
1287             {
1288               expect_func = 1;
1289             }
1290           oldmangled = NULL;
1291           break;
1292
1293         case 'S':
1294           /* Static member function */
1295           if (oldmangled == NULL)
1296             {
1297               oldmangled = *mangled;
1298             }
1299           (*mangled)++;
1300           work -> static_type = 1;
1301           break;
1302
1303         case 'C':
1304         case 'V':
1305         case 'u':
1306           work->type_quals |= code_for_qualifier (**mangled);
1307
1308           /* a qualified member function */
1309           if (oldmangled == NULL)
1310             oldmangled = *mangled;
1311           (*mangled)++;
1312           break;
1313
1314         case 'L':
1315           /* Local class name follows after "Lnnn_" */
1316           if (HP_DEMANGLING)
1317             {
1318               while (**mangled && (**mangled != '_'))
1319                 (*mangled)++;
1320               if (!**mangled)
1321                 success = 0;
1322               else
1323                 (*mangled)++;
1324             }
1325           else
1326             success = 0;
1327           break;
1328
1329         case '0': case '1': case '2': case '3': case '4':
1330         case '5': case '6': case '7': case '8': case '9':
1331           if (oldmangled == NULL)
1332             {
1333               oldmangled = *mangled;
1334             }
1335           work->temp_start = -1; /* uppermost call to demangle_class */
1336           success = demangle_class (work, mangled, declp);
1337           if (success)
1338             {
1339               remember_type (work, oldmangled, *mangled - oldmangled);
1340             }
1341           if (AUTO_DEMANGLING || GNU_DEMANGLING || EDG_DEMANGLING)
1342             {
1343               /* EDG and others will have the "F", so we let the loop cycle
1344                  if we are looking at one. */
1345               if (**mangled != 'F')
1346                  expect_func = 1;
1347             }
1348           oldmangled = NULL;
1349           break;
1350
1351         case 'B':
1352           {
1353             string s;
1354             success = do_type (work, mangled, &s);
1355             if (success)
1356               {
1357                 string_append (&s, SCOPE_STRING (work));
1358                 string_prepends (declp, &s);
1359                 string_delete (&s);
1360               }
1361             oldmangled = NULL;
1362             expect_func = 1;
1363           }
1364           break;
1365
1366         case 'F':
1367           /* Function */
1368           /* ARM/HP style demangling includes a specific 'F' character after
1369              the class name.  For GNU style, it is just implied.  So we can
1370              safely just consume any 'F' at this point and be compatible
1371              with either style.  */
1372
1373           oldmangled = NULL;
1374           func_done = 1;
1375           (*mangled)++;
1376
1377           /* For lucid/ARM/HP style we have to forget any types we might
1378              have remembered up to this point, since they were not argument
1379              types.  GNU style considers all types seen as available for
1380              back references.  See comment in demangle_args() */
1381
1382           if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
1383             {
1384               forget_types (work);
1385             }
1386           success = demangle_args (work, mangled, declp);
1387           /* After picking off the function args, we expect to either
1388              find the function return type (preceded by an '_') or the
1389              end of the string. */
1390           if (success && (AUTO_DEMANGLING || EDG_DEMANGLING) && **mangled == '_')
1391             {
1392               ++(*mangled);
1393               /* At this level, we do not care about the return type. */
1394               success = do_type (work, mangled, &tname);
1395               string_delete (&tname);
1396             }
1397
1398           break;
1399
1400         case 't':
1401           /* G++ Template */
1402           string_init(&trawname);
1403           string_init(&tname);
1404           if (oldmangled == NULL)
1405             {
1406               oldmangled = *mangled;
1407             }
1408           success = demangle_template (work, mangled, &tname,
1409                                        &trawname, 1, 1);
1410           if (success)
1411             {
1412               remember_type (work, oldmangled, *mangled - oldmangled);
1413             }
1414           string_append (&tname, SCOPE_STRING (work));
1415
1416           string_prepends(declp, &tname);
1417           if (work -> destructor & 1)
1418             {
1419               string_prepend (&trawname, "~");
1420               string_appends (declp, &trawname);
1421               work->destructor -= 1;
1422             }
1423           if ((work->constructor & 1) || (work->destructor & 1))
1424             {
1425               string_appends (declp, &trawname);
1426               work->constructor -= 1;
1427             }
1428           string_delete(&trawname);
1429           string_delete(&tname);
1430           oldmangled = NULL;
1431           expect_func = 1;
1432           break;
1433
1434         case '_':
1435           if ((AUTO_DEMANGLING || GNU_DEMANGLING) && expect_return_type)
1436             {
1437               /* Read the return type. */
1438               string return_type;
1439
1440               (*mangled)++;
1441               success = do_type (work, mangled, &return_type);
1442               APPEND_BLANK (&return_type);
1443
1444               string_prepends (declp, &return_type);
1445               string_delete (&return_type);
1446               break;
1447             }
1448           else
1449             /* At the outermost level, we cannot have a return type specified,
1450                so if we run into another '_' at this point we are dealing with
1451                a mangled name that is either bogus, or has been mangled by
1452                some algorithm we don't know how to deal with.  So just
1453                reject the entire demangling.  */
1454             /* However, "_nnn" is an expected suffix for alternate entry point
1455                numbered nnn for a function, with HP aCC, so skip over that
1456                without reporting failure. pai/1997-09-04 */
1457             if (HP_DEMANGLING)
1458               {
1459                 (*mangled)++;
1460                 while (**mangled && ISDIGIT ((unsigned char)**mangled))
1461                   (*mangled)++;
1462               }
1463             else
1464               success = 0;
1465           break;
1466
1467         case 'H':
1468           if (AUTO_DEMANGLING || GNU_DEMANGLING)
1469             {
1470               /* A G++ template function.  Read the template arguments. */
1471               success = demangle_template (work, mangled, declp, 0, 0,
1472                                            0);
1473               if (!(work->constructor & 1))
1474                 expect_return_type = 1;
1475               (*mangled)++;
1476               break;
1477             }
1478           else
1479             /* fall through */
1480             {;}
1481
1482         default:
1483           if (AUTO_DEMANGLING || GNU_DEMANGLING)
1484             {
1485               /* Assume we have stumbled onto the first outermost function
1486                  argument token, and start processing args.  */
1487               func_done = 1;
1488               success = demangle_args (work, mangled, declp);
1489             }
1490           else
1491             {
1492               /* Non-GNU demanglers use a specific token to mark the start
1493                  of the outermost function argument tokens.  Typically 'F',
1494                  for ARM/HP-demangling, for example.  So if we find something
1495                  we are not prepared for, it must be an error.  */
1496               success = 0;
1497             }
1498           break;
1499         }
1500       /*
1501         if (AUTO_DEMANGLING || GNU_DEMANGLING)
1502         */
1503       {
1504         if (success && expect_func)
1505           {
1506             func_done = 1;
1507               if (LUCID_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING)
1508                 {
1509                   forget_types (work);
1510                 }
1511             success = demangle_args (work, mangled, declp);
1512             /* Since template include the mangling of their return types,
1513                we must set expect_func to 0 so that we don't try do
1514                demangle more arguments the next time we get here.  */
1515             expect_func = 0;
1516           }
1517       }
1518     }
1519   if (success && !func_done)
1520     {
1521       if (AUTO_DEMANGLING || GNU_DEMANGLING)
1522         {
1523           /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
1524              bar__3fooi is 'foo::bar(int)'.  We get here when we find the
1525              first case, and need to ensure that the '(void)' gets added to
1526              the current declp.  Note that with ARM/HP, the first case
1527              represents the name of a static data member 'foo::bar',
1528              which is in the current declp, so we leave it alone.  */
1529           success = demangle_args (work, mangled, declp);
1530         }
1531     }
1532   if (success && PRINT_ARG_TYPES)
1533     {
1534       if (work->static_type)
1535         string_append (declp, " static");
1536       if (work->type_quals != TYPE_UNQUALIFIED)
1537         {
1538           APPEND_BLANK (declp);
1539           string_append (declp, qualifier_string (work->type_quals));
1540         }
1541     }
1542
1543   return (success);
1544 }
1545
1546 #if 0
1547
1548 static int
1549 demangle_method_args (struct work_stuff *work, const char **mangled,
1550                       string *declp)
1551 {
1552   int success = 0;
1553
1554   if (work -> static_type)
1555     {
1556       string_append (declp, *mangled + 1);
1557       *mangled += strlen (*mangled);
1558       success = 1;
1559     }
1560   else
1561     {
1562       success = demangle_args (work, mangled, declp);
1563     }
1564   return (success);
1565 }
1566
1567 #endif
1568
1569 static int
1570 demangle_template_template_parm (struct work_stuff *work,
1571                                  const char **mangled, string *tname)
1572 {
1573   int i;
1574   int r;
1575   int need_comma = 0;
1576   int success = 1;
1577   string temp;
1578
1579   string_append (tname, "template <");
1580   /* get size of template parameter list */
1581   if (get_count (mangled, &r))
1582     {
1583       for (i = 0; i < r; i++)
1584         {
1585           if (need_comma)
1586             {
1587               string_append (tname, ", ");
1588             }
1589
1590             /* Z for type parameters */
1591             if (**mangled == 'Z')
1592               {
1593                 (*mangled)++;
1594                 string_append (tname, "class");
1595               }
1596               /* z for template parameters */
1597             else if (**mangled == 'z')
1598               {
1599                 (*mangled)++;
1600                 success =
1601                   demangle_template_template_parm (work, mangled, tname);
1602                 if (!success)
1603                   {
1604                     break;
1605                   }
1606               }
1607             else
1608               {
1609                 /* temp is initialized in do_type */
1610                 success = do_type (work, mangled, &temp);
1611                 if (success)
1612                   {
1613                     string_appends (tname, &temp);
1614                   }
1615                 string_delete(&temp);
1616                 if (!success)
1617                   {
1618                     break;
1619                   }
1620               }
1621           need_comma = 1;
1622         }
1623
1624     }
1625   if (tname->p[-1] == '>')
1626     string_append (tname, " ");
1627   string_append (tname, "> class");
1628   return (success);
1629 }
1630
1631 static int
1632 demangle_expression (struct work_stuff *work, const char **mangled,
1633                      string *s, type_kind_t tk)
1634 {
1635   int need_operator = 0;
1636   int success;
1637
1638   success = 1;
1639   string_appendn (s, "(", 1);
1640   (*mangled)++;
1641   while (success && **mangled != 'W' && **mangled != '\0')
1642     {
1643       if (need_operator)
1644         {
1645           size_t i;
1646           size_t len;
1647
1648           success = 0;
1649
1650           len = strlen (*mangled);
1651
1652           for (i = 0; i < ARRAY_SIZE (optable); ++i)
1653             {
1654               size_t l = strlen (optable[i].in);
1655
1656               if (l <= len
1657                   && memcmp (optable[i].in, *mangled, l) == 0)
1658                 {
1659                   string_appendn (s, " ", 1);
1660                   string_append (s, optable[i].out);
1661                   string_appendn (s, " ", 1);
1662                   success = 1;
1663                   (*mangled) += l;
1664                   break;
1665                 }
1666             }
1667
1668           if (!success)
1669             break;
1670         }
1671       else
1672         need_operator = 1;
1673
1674       success = demangle_template_value_parm (work, mangled, s, tk);
1675     }
1676
1677   if (**mangled != 'W')
1678     success = 0;
1679   else
1680     {
1681       string_appendn (s, ")", 1);
1682       (*mangled)++;
1683     }
1684
1685   return success;
1686 }
1687
1688 static int
1689 demangle_integral_value (struct work_stuff *work,
1690                          const char **mangled, string *s)
1691 {
1692   int success;
1693
1694   if (**mangled == 'E')
1695     success = demangle_expression (work, mangled, s, tk_integral);
1696   else if (**mangled == 'Q' || **mangled == 'K')
1697     success = demangle_qualified (work, mangled, s, 0, 1);
1698   else
1699     {
1700       int value;
1701
1702       /* By default, we let the number decide whether we shall consume an
1703          underscore.  */
1704       int multidigit_without_leading_underscore = 0;
1705       int leave_following_underscore = 0;
1706
1707       success = 0;
1708
1709       if (**mangled == '_')
1710         {
1711           if (mangled[0][1] == 'm')
1712             {
1713               /* Since consume_count_with_underscores does not handle the
1714                  `m'-prefix we must do it here, using consume_count and
1715                  adjusting underscores: we have to consume the underscore
1716                  matching the prepended one.  */
1717               multidigit_without_leading_underscore = 1;
1718               string_appendn (s, "-", 1);
1719               (*mangled) += 2;
1720             }
1721           else
1722             {
1723               /* Do not consume a following underscore;
1724                  consume_count_with_underscores will consume what
1725                  should be consumed.  */
1726               leave_following_underscore = 1;
1727             }
1728         }
1729       else
1730         {
1731           /* Negative numbers are indicated with a leading `m'.  */
1732           if (**mangled == 'm')
1733           {
1734             string_appendn (s, "-", 1);
1735             (*mangled)++;
1736           }
1737           /* Since consume_count_with_underscores does not handle
1738              multi-digit numbers that do not start with an underscore,
1739              and this number can be an integer template parameter,
1740              we have to call consume_count. */
1741           multidigit_without_leading_underscore = 1;
1742           /* These multi-digit numbers never end on an underscore,
1743              so if there is one then don't eat it. */
1744           leave_following_underscore = 1;
1745         }
1746
1747       /* We must call consume_count if we expect to remove a trailing
1748          underscore, since consume_count_with_underscores expects
1749          the leading underscore (that we consumed) if it is to handle
1750          multi-digit numbers.  */
1751       if (multidigit_without_leading_underscore)
1752         value = consume_count (mangled);
1753       else
1754         value = consume_count_with_underscores (mangled);
1755
1756       if (value != -1)
1757         {
1758           char buf[INTBUF_SIZE];
1759           sprintf (buf, "%d", value);
1760           string_append (s, buf);
1761
1762           /* Numbers not otherwise delimited, might have an underscore
1763              appended as a delimeter, which we should skip.
1764
1765              ??? This used to always remove a following underscore, which
1766              is wrong.  If other (arbitrary) cases are followed by an
1767              underscore, we need to do something more radical.  */
1768
1769           if ((value > 9 || multidigit_without_leading_underscore)
1770               && ! leave_following_underscore
1771               && **mangled == '_')
1772             (*mangled)++;
1773
1774           /* All is well.  */
1775           success = 1;
1776         }
1777       }
1778
1779   return success;
1780 }
1781
1782 /* Demangle the real value in MANGLED.  */
1783
1784 static int
1785 demangle_real_value (struct work_stuff *work,
1786                      const char **mangled, string *s)
1787 {
1788   if (**mangled == 'E')
1789     return demangle_expression (work, mangled, s, tk_real);
1790
1791   if (**mangled == 'm')
1792     {
1793       string_appendn (s, "-", 1);
1794       (*mangled)++;
1795     }
1796   while (ISDIGIT ((unsigned char)**mangled))
1797     {
1798       string_appendn (s, *mangled, 1);
1799       (*mangled)++;
1800     }
1801   if (**mangled == '.') /* fraction */
1802     {
1803       string_appendn (s, ".", 1);
1804       (*mangled)++;
1805       while (ISDIGIT ((unsigned char)**mangled))
1806         {
1807           string_appendn (s, *mangled, 1);
1808           (*mangled)++;
1809         }
1810     }
1811   if (**mangled == 'e') /* exponent */
1812     {
1813       string_appendn (s, "e", 1);
1814       (*mangled)++;
1815       while (ISDIGIT ((unsigned char)**mangled))
1816         {
1817           string_appendn (s, *mangled, 1);
1818           (*mangled)++;
1819         }
1820     }
1821
1822   return 1;
1823 }
1824
1825 static int
1826 demangle_template_value_parm (struct work_stuff *work, const char **mangled,
1827                               string *s, type_kind_t tk)
1828 {
1829   int success = 1;
1830
1831   if (**mangled == 'Y')
1832     {
1833       /* The next argument is a template parameter. */
1834       int idx;
1835
1836       (*mangled)++;
1837       idx = consume_count_with_underscores (mangled);
1838       if (idx == -1
1839           || (work->tmpl_argvec && idx >= work->ntmpl_args)
1840           || consume_count_with_underscores (mangled) == -1)
1841         return -1;
1842       if (work->tmpl_argvec)
1843         string_append (s, work->tmpl_argvec[idx]);
1844       else
1845         string_append_template_idx (s, idx);
1846     }
1847   else if (tk == tk_integral)
1848     success = demangle_integral_value (work, mangled, s);
1849   else if (tk == tk_char)
1850     {
1851       char tmp[2];
1852       int val;
1853       if (**mangled == 'm')
1854         {
1855           string_appendn (s, "-", 1);
1856           (*mangled)++;
1857         }
1858       string_appendn (s, "'", 1);
1859       val = consume_count(mangled);
1860       if (val <= 0)
1861         success = 0;
1862       else
1863         {
1864           tmp[0] = (char)val;
1865           tmp[1] = '\0';
1866           string_appendn (s, &tmp[0], 1);
1867           string_appendn (s, "'", 1);
1868         }
1869     }
1870   else if (tk == tk_bool)
1871     {
1872       int val = consume_count (mangled);
1873       if (val == 0)
1874         string_appendn (s, "false", 5);
1875       else if (val == 1)
1876         string_appendn (s, "true", 4);
1877       else
1878         success = 0;
1879     }
1880   else if (tk == tk_real)
1881     success = demangle_real_value (work, mangled, s);
1882   else if (tk == tk_pointer || tk == tk_reference)
1883     {
1884       if (**mangled == 'Q')
1885         success = demangle_qualified (work, mangled, s,
1886                                       /*isfuncname=*/0, 
1887                                       /*append=*/1);
1888       else
1889         {
1890           int symbol_len  = consume_count (mangled);
1891           if (symbol_len == -1)
1892             return -1;
1893           if (symbol_len == 0)
1894             string_appendn (s, "0", 1);
1895           else
1896             {
1897               char *p = XNEWVEC (char, symbol_len + 1), *q;
1898               strncpy (p, *mangled, symbol_len);
1899               p [symbol_len] = '\0';
1900               /* We use cplus_demangle here, rather than
1901                  internal_cplus_demangle, because the name of the entity
1902                  mangled here does not make use of any of the squangling
1903                  or type-code information we have built up thus far; it is
1904                  mangled independently.  */
1905               q = cplus_demangle (p, work->options);
1906               if (tk == tk_pointer)
1907                 string_appendn (s, "&", 1);
1908               /* FIXME: Pointer-to-member constants should get a
1909                  qualifying class name here.  */
1910               if (q)
1911                 {
1912                   string_append (s, q);
1913                   free (q);
1914                 }
1915               else
1916                 string_append (s, p);
1917               free (p);
1918             }
1919           *mangled += symbol_len;
1920         }
1921     }
1922
1923   return success;
1924 }
1925
1926 /* Demangle the template name in MANGLED.  The full name of the
1927    template (e.g., S<int>) is placed in TNAME.  The name without the
1928    template parameters (e.g. S) is placed in TRAWNAME if TRAWNAME is
1929    non-NULL.  If IS_TYPE is nonzero, this template is a type template,
1930    not a function template.  If both IS_TYPE and REMEMBER are nonzero,
1931    the template is remembered in the list of back-referenceable
1932    types.  */
1933
1934 static int
1935 demangle_template (struct work_stuff *work, const char **mangled,
1936                    string *tname, string *trawname,
1937                    int is_type, int remember)
1938 {
1939   int i;
1940   int r;
1941   int need_comma = 0;
1942   int success = 0;
1943   int is_java_array = 0;
1944   string temp;
1945
1946   (*mangled)++;
1947   if (is_type)
1948     {
1949       /* get template name */
1950       if (**mangled == 'z')
1951         {
1952           int idx;
1953           (*mangled)++;
1954           (*mangled)++;
1955
1956           idx = consume_count_with_underscores (mangled);
1957           if (idx == -1
1958               || (work->tmpl_argvec && idx >= work->ntmpl_args)
1959               || consume_count_with_underscores (mangled) == -1)
1960             return (0);
1961
1962           if (work->tmpl_argvec)
1963             {
1964               string_append (tname, work->tmpl_argvec[idx]);
1965               if (trawname)
1966                 string_append (trawname, work->tmpl_argvec[idx]);
1967             }
1968           else
1969             {
1970               string_append_template_idx (tname, idx);
1971               if (trawname)
1972                 string_append_template_idx (trawname, idx);
1973             }
1974         }
1975       else
1976         {
1977           if ((r = consume_count (mangled)) <= 0
1978               || (int) strlen (*mangled) < r)
1979             {
1980               return (0);
1981             }
1982           is_java_array = (work -> options & DMGL_JAVA)
1983             && strncmp (*mangled, "JArray1Z", 8) == 0;
1984           if (! is_java_array)
1985             {
1986               string_appendn (tname, *mangled, r);
1987             }
1988           if (trawname)
1989             string_appendn (trawname, *mangled, r);
1990           *mangled += r;
1991         }
1992     }
1993   if (!is_java_array)
1994     string_append (tname, "<");
1995   /* get size of template parameter list */
1996   if (!get_count (mangled, &r))
1997     {
1998       return (0);
1999     }
2000   if (!is_type)
2001     {
2002       /* Create an array for saving the template argument values. */
2003       work->tmpl_argvec = XNEWVEC (char *, r);
2004       work->ntmpl_args = r;
2005       for (i = 0; i < r; i++)
2006         work->tmpl_argvec[i] = 0;
2007     }
2008   for (i = 0; i < r; i++)
2009     {
2010       if (need_comma)
2011         {
2012           string_append (tname, ", ");
2013         }
2014       /* Z for type parameters */
2015       if (**mangled == 'Z')
2016         {
2017           (*mangled)++;
2018           /* temp is initialized in do_type */
2019           success = do_type (work, mangled, &temp);
2020           if (success)
2021             {
2022               string_appends (tname, &temp);
2023
2024               if (!is_type)
2025                 {
2026                   /* Save the template argument. */
2027                   int len = temp.p - temp.b;
2028                   work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
2029                   memcpy (work->tmpl_argvec[i], temp.b, len);
2030                   work->tmpl_argvec[i][len] = '\0';
2031                 }
2032             }
2033           string_delete(&temp);
2034           if (!success)
2035             {
2036               break;
2037             }
2038         }
2039       /* z for template parameters */
2040       else if (**mangled == 'z')
2041         {
2042           int r2;
2043           (*mangled)++;
2044           success = demangle_template_template_parm (work, mangled, tname);
2045
2046           if (success
2047               && (r2 = consume_count (mangled)) > 0
2048               && (int) strlen (*mangled) >= r2)
2049             {
2050               string_append (tname, " ");
2051               string_appendn (tname, *mangled, r2);
2052               if (!is_type)
2053                 {
2054                   /* Save the template argument. */
2055                   int len = r2;
2056                   work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
2057                   memcpy (work->tmpl_argvec[i], *mangled, len);
2058                   work->tmpl_argvec[i][len] = '\0';
2059                 }
2060               *mangled += r2;
2061             }
2062           if (!success)
2063             {
2064               break;
2065             }
2066         }
2067       else
2068         {
2069           string  param;
2070           string* s;
2071
2072           /* otherwise, value parameter */
2073
2074           /* temp is initialized in do_type */
2075           success = do_type (work, mangled, &temp);
2076           string_delete(&temp);
2077           if (!success)
2078             break;
2079
2080           if (!is_type)
2081             {
2082               s = &param;
2083               string_init (s);
2084             }
2085           else
2086             s = tname;
2087
2088           success = demangle_template_value_parm (work, mangled, s,
2089                                                   (type_kind_t) success);
2090
2091           if (!success)
2092             {
2093               if (!is_type)
2094                 string_delete (s);
2095               success = 0;
2096               break;
2097             }
2098
2099           if (!is_type)
2100             {
2101               int len = s->p - s->b;
2102               work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
2103               memcpy (work->tmpl_argvec[i], s->b, len);
2104               work->tmpl_argvec[i][len] = '\0';
2105
2106               string_appends (tname, s);
2107               string_delete (s);
2108             }
2109         }
2110       need_comma = 1;
2111     }
2112   if (is_java_array)
2113     {
2114       string_append (tname, "[]");
2115     }
2116   else
2117     {
2118       if (tname->p[-1] == '>')
2119         string_append (tname, " ");
2120       string_append (tname, ">");
2121     }
2122
2123   if (is_type && remember)
2124     {
2125       const int bindex = register_Btype (work);
2126       remember_Btype (work, tname->b, LEN_STRING (tname), bindex);
2127     }
2128
2129   /*
2130     if (work -> static_type)
2131     {
2132     string_append (declp, *mangled + 1);
2133     *mangled += strlen (*mangled);
2134     success = 1;
2135     }
2136     else
2137     {
2138     success = demangle_args (work, mangled, declp);
2139     }
2140     }
2141     */
2142   return (success);
2143 }
2144
2145 static int
2146 arm_pt (struct work_stuff *work, const char *mangled,
2147         int n, const char **anchor, const char **args)
2148 {
2149   /* Check if ARM template with "__pt__" in it ("parameterized type") */
2150   /* Allow HP also here, because HP's cfront compiler follows ARM to some extent */
2151   if ((ARM_DEMANGLING || HP_DEMANGLING) && (*anchor = strstr (mangled, "__pt__")))
2152     {
2153       int len;
2154       *args = *anchor + 6;
2155       len = consume_count (args);
2156       if (len == -1)
2157         return 0;
2158       if (*args + len == mangled + n && **args == '_')
2159         {
2160           ++*args;
2161           return 1;
2162         }
2163     }
2164   if (AUTO_DEMANGLING || EDG_DEMANGLING)
2165     {
2166       if ((*anchor = strstr (mangled, "__tm__"))
2167           || (*anchor = strstr (mangled, "__ps__"))
2168           || (*anchor = strstr (mangled, "__pt__")))
2169         {
2170           int len;
2171           *args = *anchor + 6;
2172           len = consume_count (args);
2173           if (len == -1)
2174             return 0;
2175           if (*args + len == mangled + n && **args == '_')
2176             {
2177               ++*args;
2178               return 1;
2179             }
2180         }
2181       else if ((*anchor = strstr (mangled, "__S")))
2182         {
2183           int len;
2184           *args = *anchor + 3;
2185           len = consume_count (args);
2186           if (len == -1)
2187             return 0;
2188           if (*args + len == mangled + n && **args == '_')
2189             {
2190               ++*args;
2191               return 1;
2192             }
2193         }
2194     }
2195
2196   return 0;
2197 }
2198
2199 static void
2200 demangle_arm_hp_template (struct work_stuff *work, const char **mangled,
2201                           int n, string *declp)
2202 {
2203   const char *p;
2204   const char *args;
2205   const char *e = *mangled + n;
2206   string arg;
2207
2208   /* Check for HP aCC template spec: classXt1t2 where t1, t2 are
2209      template args */
2210   if (HP_DEMANGLING && ((*mangled)[n] == 'X'))
2211     {
2212       char *start_spec_args = NULL;
2213       int hold_options;
2214
2215       /* First check for and omit template specialization pseudo-arguments,
2216          such as in "Spec<#1,#1.*>" */
2217       start_spec_args = strchr (*mangled, '<');
2218       if (start_spec_args && (start_spec_args - *mangled < n))
2219         string_appendn (declp, *mangled, start_spec_args - *mangled);
2220       else
2221         string_appendn (declp, *mangled, n);
2222       (*mangled) += n + 1;
2223       string_init (&arg);
2224       if (work->temp_start == -1) /* non-recursive call */
2225         work->temp_start = declp->p - declp->b;
2226
2227       /* We want to unconditionally demangle parameter types in
2228          template parameters.  */
2229       hold_options = work->options;
2230       work->options |= DMGL_PARAMS;
2231
2232       string_append (declp, "<");
2233       while (1)
2234         {
2235           string_delete (&arg);
2236           switch (**mangled)
2237             {
2238               case 'T':
2239                 /* 'T' signals a type parameter */
2240                 (*mangled)++;
2241                 if (!do_type (work, mangled, &arg))
2242                   goto hpacc_template_args_done;
2243                 break;
2244
2245               case 'U':
2246               case 'S':
2247                 /* 'U' or 'S' signals an integral value */
2248                 if (!do_hpacc_template_const_value (work, mangled, &arg))
2249                   goto hpacc_template_args_done;
2250                 break;
2251
2252               case 'A':
2253                 /* 'A' signals a named constant expression (literal) */
2254                 if (!do_hpacc_template_literal (work, mangled, &arg))
2255                   goto hpacc_template_args_done;
2256                 break;
2257
2258               default:
2259                 /* Today, 1997-09-03, we have only the above types
2260                    of template parameters */
2261                 /* FIXME: maybe this should fail and return null */
2262                 goto hpacc_template_args_done;
2263             }
2264           string_appends (declp, &arg);
2265          /* Check if we're at the end of template args.
2266              0 if at end of static member of template class,
2267              _ if done with template args for a function */
2268           if ((**mangled == '\000') || (**mangled == '_'))
2269             break;
2270           else
2271             string_append (declp, ",");
2272         }
2273     hpacc_template_args_done:
2274       string_append (declp, ">");
2275       string_delete (&arg);
2276       if (**mangled == '_')
2277         (*mangled)++;
2278       work->options = hold_options;
2279       return;
2280     }
2281   /* ARM template? (Also handles HP cfront extensions) */
2282   else if (arm_pt (work, *mangled, n, &p, &args))
2283     {
2284       int hold_options;
2285       string type_str;
2286
2287       string_init (&arg);
2288       string_appendn (declp, *mangled, p - *mangled);
2289       if (work->temp_start == -1)  /* non-recursive call */
2290         work->temp_start = declp->p - declp->b;
2291
2292       /* We want to unconditionally demangle parameter types in
2293          template parameters.  */
2294       hold_options = work->options;
2295       work->options |= DMGL_PARAMS;
2296
2297       string_append (declp, "<");
2298       /* should do error checking here */
2299       while (args < e) {
2300         string_delete (&arg);
2301
2302         /* Check for type or literal here */
2303         switch (*args)
2304           {
2305             /* HP cfront extensions to ARM for template args */
2306             /* spec: Xt1Lv1 where t1 is a type, v1 is a literal value */
2307             /* FIXME: We handle only numeric literals for HP cfront */
2308           case 'X':
2309             /* A typed constant value follows */
2310             args++;
2311             if (!do_type (work, &args, &type_str))
2312               goto cfront_template_args_done;
2313             string_append (&arg, "(");
2314             string_appends (&arg, &type_str);
2315             string_delete (&type_str);
2316             string_append (&arg, ")");
2317             if (*args != 'L')
2318               goto cfront_template_args_done;
2319             args++;
2320             /* Now snarf a literal value following 'L' */
2321             if (!snarf_numeric_literal (&args, &arg))
2322               goto cfront_template_args_done;
2323             break;
2324
2325           case 'L':
2326             /* Snarf a literal following 'L' */
2327             args++;
2328             if (!snarf_numeric_literal (&args, &arg))
2329               goto cfront_template_args_done;
2330             break;
2331           default:
2332             /* Not handling other HP cfront stuff */
2333             {
2334               const char* old_args = args;
2335               if (!do_type (work, &args, &arg))
2336                 goto cfront_template_args_done;
2337
2338               /* Fail if we didn't make any progress: prevent infinite loop. */
2339               if (args == old_args)
2340                 {
2341                   work->options = hold_options;
2342                   return;
2343                 }
2344             }
2345           }
2346         string_appends (declp, &arg);
2347         string_append (declp, ",");
2348       }
2349     cfront_template_args_done:
2350       string_delete (&arg);
2351       if (args >= e)
2352         --declp->p; /* remove extra comma */
2353       string_append (declp, ">");
2354       work->options = hold_options;
2355     }
2356   else if (n>10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
2357            && (*mangled)[9] == 'N'
2358            && (*mangled)[8] == (*mangled)[10]
2359            && strchr (cplus_markers, (*mangled)[8]))
2360     {
2361       /* A member of the anonymous namespace.  */
2362       string_append (declp, "{anonymous}");
2363     }
2364   else
2365     {
2366       if (work->temp_start == -1) /* non-recursive call only */
2367         work->temp_start = 0;     /* disable in recursive calls */
2368       string_appendn (declp, *mangled, n);
2369     }
2370   *mangled += n;
2371 }
2372
2373 /* Extract a class name, possibly a template with arguments, from the
2374    mangled string; qualifiers, local class indicators, etc. have
2375    already been dealt with */
2376
2377 static int
2378 demangle_class_name (struct work_stuff *work, const char **mangled,
2379                      string *declp)
2380 {
2381   int n;
2382   int success = 0;
2383
2384   n = consume_count (mangled);
2385   if (n == -1)
2386     return 0;
2387   if ((int) strlen (*mangled) >= n)
2388     {
2389       demangle_arm_hp_template (work, mangled, n, declp);
2390       success = 1;
2391     }
2392
2393   return (success);
2394 }
2395
2396 /*
2397
2398 LOCAL FUNCTION
2399
2400         demangle_class -- demangle a mangled class sequence
2401
2402 SYNOPSIS
2403
2404         static int
2405         demangle_class (struct work_stuff *work, const char **mangled,
2406                         strint *declp)
2407
2408 DESCRIPTION
2409
2410         DECLP points to the buffer into which demangling is being done.
2411
2412         *MANGLED points to the current token to be demangled.  On input,
2413         it points to a mangled class (I.E. "3foo", "13verylongclass", etc.)
2414         On exit, it points to the next token after the mangled class on
2415         success, or the first unconsumed token on failure.
2416
2417         If the CONSTRUCTOR or DESTRUCTOR flags are set in WORK, then
2418         we are demangling a constructor or destructor.  In this case
2419         we prepend "class::class" or "class::~class" to DECLP.
2420
2421         Otherwise, we prepend "class::" to the current DECLP.
2422
2423         Reset the constructor/destructor flags once they have been
2424         "consumed".  This allows demangle_class to be called later during
2425         the same demangling, to do normal class demangling.
2426
2427         Returns 1 if demangling is successful, 0 otherwise.
2428
2429 */
2430
2431 static int
2432 demangle_class (struct work_stuff *work, const char **mangled, string *declp)
2433 {
2434   int success = 0;
2435   int btype;
2436   string class_name;
2437   char *save_class_name_end = 0;
2438
2439   string_init (&class_name);
2440   btype = register_Btype (work);
2441   if (demangle_class_name (work, mangled, &class_name))
2442     {
2443       save_class_name_end = class_name.p;
2444       if ((work->constructor & 1) || (work->destructor & 1))
2445         {
2446           /* adjust so we don't include template args */
2447           if (work->temp_start && (work->temp_start != -1))
2448             {
2449               class_name.p = class_name.b + work->temp_start;
2450             }
2451           string_prepends (declp, &class_name);
2452           if (work -> destructor & 1)
2453             {
2454               string_prepend (declp, "~");
2455               work -> destructor -= 1;
2456             }
2457           else
2458             {
2459               work -> constructor -= 1;
2460             }
2461         }
2462       class_name.p = save_class_name_end;
2463       remember_Ktype (work, class_name.b, LEN_STRING(&class_name));
2464       remember_Btype (work, class_name.b, LEN_STRING(&class_name), btype);
2465       string_prepend (declp, SCOPE_STRING (work));
2466       string_prepends (declp, &class_name);
2467       success = 1;
2468     }
2469   string_delete (&class_name);
2470   return (success);
2471 }
2472
2473
2474 /* Called when there's a "__" in the mangled name, with `scan' pointing to
2475    the rightmost guess.
2476
2477    Find the correct "__"-sequence where the function name ends and the
2478    signature starts, which is ambiguous with GNU mangling.
2479    Call demangle_signature here, so we can make sure we found the right
2480    one; *mangled will be consumed so caller will not make further calls to
2481    demangle_signature.  */
2482
2483 static int
2484 iterate_demangle_function (struct work_stuff *work, const char **mangled,
2485                            string *declp, const char *scan)
2486 {
2487   const char *mangle_init = *mangled;
2488   int success = 0;
2489   string decl_init;
2490   struct work_stuff work_init;
2491
2492   if (*(scan + 2) == '\0')
2493     return 0;
2494
2495   /* Do not iterate for some demangling modes, or if there's only one
2496      "__"-sequence.  This is the normal case.  */
2497   if (ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING
2498       || strstr (scan + 2, "__") == NULL)
2499     return demangle_function_name (work, mangled, declp, scan);
2500
2501   /* Save state so we can restart if the guess at the correct "__" was
2502      wrong.  */
2503   string_init (&decl_init);
2504   string_appends (&decl_init, declp);
2505   memset (&work_init, 0, sizeof work_init);
2506   work_stuff_copy_to_from (&work_init, work);
2507
2508   /* Iterate over occurrences of __, allowing names and types to have a
2509      "__" sequence in them.  We must start with the first (not the last)
2510      occurrence, since "__" most often occur between independent mangled
2511      parts, hence starting at the last occurence inside a signature
2512      might get us a "successful" demangling of the signature.  */
2513
2514   while (scan[2])
2515     {
2516       if (demangle_function_name (work, mangled, declp, scan))
2517         {
2518           success = demangle_signature (work, mangled, declp);
2519           if (success)
2520             break;
2521         }
2522
2523       /* Reset demangle state for the next round.  */
2524       *mangled = mangle_init;
2525       string_clear (declp);
2526       string_appends (declp, &decl_init);
2527       work_stuff_copy_to_from (work, &work_init);
2528
2529       /* Leave this underscore-sequence.  */
2530       scan += 2;
2531
2532       /* Scan for the next "__" sequence.  */
2533       while (*scan && (scan[0] != '_' || scan[1] != '_'))
2534         scan++;
2535
2536       /* Move to last "__" in this sequence.  */
2537       while (*scan && *scan == '_')
2538         scan++;
2539       scan -= 2;
2540     }
2541
2542   /* Delete saved state.  */
2543   delete_work_stuff (&work_init);
2544   string_delete (&decl_init);
2545
2546   return success;
2547 }
2548
2549 /*
2550
2551 LOCAL FUNCTION
2552
2553         demangle_prefix -- consume the mangled name prefix and find signature
2554
2555 SYNOPSIS
2556
2557         static int
2558         demangle_prefix (struct work_stuff *work, const char **mangled,
2559                          string *declp);
2560
2561 DESCRIPTION
2562
2563         Consume and demangle the prefix of the mangled name.
2564         While processing the function name root, arrange to call
2565         demangle_signature if the root is ambiguous.
2566
2567         DECLP points to the string buffer into which demangled output is
2568         placed.  On entry, the buffer is empty.  On exit it contains
2569         the root function name, the demangled operator name, or in some
2570         special cases either nothing or the completely demangled result.
2571
2572         MANGLED points to the current pointer into the mangled name.  As each
2573         token of the mangled name is consumed, it is updated.  Upon entry
2574         the current mangled name pointer points to the first character of
2575         the mangled name.  Upon exit, it should point to the first character
2576         of the signature if demangling was successful, or to the first
2577         unconsumed character if demangling of the prefix was unsuccessful.
2578
2579         Returns 1 on success, 0 otherwise.
2580  */
2581
2582 static int
2583 demangle_prefix (struct work_stuff *work, const char **mangled,
2584                  string *declp)
2585 {
2586   int success = 1;
2587   const char *scan;
2588   int i;
2589
2590   if (strlen(*mangled) > 6
2591       && (strncmp(*mangled, "_imp__", 6) == 0
2592           || strncmp(*mangled, "__imp_", 6) == 0))
2593     {
2594       /* it's a symbol imported from a PE dynamic library. Check for both
2595          new style prefix _imp__ and legacy __imp_ used by older versions
2596          of dlltool. */
2597       (*mangled) += 6;
2598       work->dllimported = 1;
2599     }
2600   else if (strlen(*mangled) >= 11 && strncmp(*mangled, "_GLOBAL_", 8) == 0)
2601     {
2602       char *marker = strchr (cplus_markers, (*mangled)[8]);
2603       if (marker != NULL && *marker == (*mangled)[10])
2604         {
2605           if ((*mangled)[9] == 'D')
2606             {
2607               /* it's a GNU global destructor to be executed at program exit */
2608               (*mangled) += 11;
2609               work->destructor = 2;
2610               if (gnu_special (work, mangled, declp))
2611                 return success;
2612             }
2613           else if ((*mangled)[9] == 'I')
2614             {
2615               /* it's a GNU global constructor to be executed at program init */
2616               (*mangled) += 11;
2617               work->constructor = 2;
2618               if (gnu_special (work, mangled, declp))
2619                 return success;
2620             }
2621         }
2622     }
2623   else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__std__", 7) == 0)
2624     {
2625       /* it's a ARM global destructor to be executed at program exit */
2626       (*mangled) += 7;
2627       work->destructor = 2;
2628     }
2629   else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__sti__", 7) == 0)
2630     {
2631       /* it's a ARM global constructor to be executed at program initial */
2632       (*mangled) += 7;
2633       work->constructor = 2;
2634     }
2635
2636   /*  This block of code is a reduction in strength time optimization
2637       of:
2638       scan = strstr (*mangled, "__"); */
2639
2640   {
2641     scan = *mangled;
2642
2643     do {
2644       scan = strchr (scan, '_');
2645     } while (scan != NULL && *++scan != '_');
2646
2647     if (scan != NULL) --scan;
2648   }
2649
2650   if (scan != NULL)
2651     {
2652       /* We found a sequence of two or more '_', ensure that we start at
2653          the last pair in the sequence.  */
2654       i = strspn (scan, "_");
2655       if (i > 2)
2656         {
2657           scan += (i - 2);
2658         }
2659     }
2660
2661   if (scan == NULL)
2662     {
2663       success = 0;
2664     }
2665   else if (work -> static_type)
2666     {
2667       if (!ISDIGIT ((unsigned char)scan[0]) && (scan[0] != 't'))
2668         {
2669           success = 0;
2670         }
2671     }
2672   else if ((scan == *mangled)
2673            && (ISDIGIT ((unsigned char)scan[2]) || (scan[2] == 'Q')
2674                || (scan[2] == 't') || (scan[2] == 'K') || (scan[2] == 'H')))
2675     {
2676       /* The ARM says nothing about the mangling of local variables.
2677          But cfront mangles local variables by prepending __<nesting_level>
2678          to them. As an extension to ARM demangling we handle this case.  */
2679       if ((LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING)
2680           && ISDIGIT ((unsigned char)scan[2]))
2681         {
2682           *mangled = scan + 2;
2683           consume_count (mangled);
2684           string_append (declp, *mangled);
2685           *mangled += strlen (*mangled);
2686           success = 1;
2687         }
2688       else
2689         {
2690           /* A GNU style constructor starts with __[0-9Qt].  But cfront uses
2691              names like __Q2_3foo3bar for nested type names.  So don't accept
2692              this style of constructor for cfront demangling.  A GNU
2693              style member-template constructor starts with 'H'. */
2694           if (!(LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING))
2695             work -> constructor += 1;
2696           *mangled = scan + 2;
2697         }
2698     }
2699   else if (ARM_DEMANGLING && scan[2] == 'p' && scan[3] == 't')
2700     {
2701       /* Cfront-style parameterized type.  Handled later as a signature. */
2702       success = 1;
2703
2704       /* ARM template? */
2705       demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
2706     }
2707   else if (EDG_DEMANGLING && ((scan[2] == 't' && scan[3] == 'm')
2708                               || (scan[2] == 'p' && scan[3] == 's')
2709                               || (scan[2] == 'p' && scan[3] == 't')))
2710     {
2711       /* EDG-style parameterized type.  Handled later as a signature. */
2712       success = 1;
2713
2714       /* EDG template? */
2715       demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
2716     }
2717   else if ((scan == *mangled) && !ISDIGIT ((unsigned char)scan[2])
2718            && (scan[2] != 't'))
2719     {
2720       /* Mangled name starts with "__".  Skip over any leading '_' characters,
2721          then find the next "__" that separates the prefix from the signature.
2722          */
2723       if (!(ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
2724           || (arm_special (mangled, declp) == 0))
2725         {
2726           while (*scan == '_')
2727             {
2728               scan++;
2729             }
2730           if ((scan = strstr (scan, "__")) == NULL || (*(scan + 2) == '\0'))
2731             {
2732               /* No separator (I.E. "__not_mangled"), or empty signature
2733                  (I.E. "__not_mangled_either__") */
2734               success = 0;
2735             }
2736           else
2737             return iterate_demangle_function (work, mangled, declp, scan);
2738         }
2739     }
2740   else if (*(scan + 2) != '\0')
2741     {
2742       /* Mangled name does not start with "__" but does have one somewhere
2743          in there with non empty stuff after it.  Looks like a global
2744          function name.  Iterate over all "__":s until the right
2745          one is found.  */
2746       return iterate_demangle_function (work, mangled, declp, scan);
2747     }
2748   else
2749     {
2750       /* Doesn't look like a mangled name */
2751       success = 0;
2752     }
2753
2754   if (!success && (work->constructor == 2 || work->destructor == 2))
2755     {
2756       string_append (declp, *mangled);
2757       *mangled += strlen (*mangled);
2758       success = 1;
2759     }
2760   return (success);
2761 }
2762
2763 /*
2764
2765 LOCAL FUNCTION
2766
2767         gnu_special -- special handling of gnu mangled strings
2768
2769 SYNOPSIS
2770
2771         static int
2772         gnu_special (struct work_stuff *work, const char **mangled,
2773                      string *declp);
2774
2775
2776 DESCRIPTION
2777
2778         Process some special GNU style mangling forms that don't fit
2779         the normal pattern.  For example:
2780
2781                 _$_3foo         (destructor for class foo)
2782                 _vt$foo         (foo virtual table)
2783                 _vt$foo$bar     (foo::bar virtual table)
2784                 __vt_foo        (foo virtual table, new style with thunks)
2785                 _3foo$varname   (static data member)
2786                 _Q22rs2tu$vw    (static data member)
2787                 __t6vector1Zii  (constructor with template)
2788                 __thunk_4__$_7ostream (virtual function thunk)
2789  */
2790
2791 static int
2792 gnu_special (struct work_stuff *work, const char **mangled, string *declp)
2793 {
2794   int n;
2795   int success = 1;
2796   const char *p;
2797
2798   if ((*mangled)[0] == '_'
2799       && strchr (cplus_markers, (*mangled)[1]) != NULL
2800       && (*mangled)[2] == '_')
2801     {
2802       /* Found a GNU style destructor, get past "_<CPLUS_MARKER>_" */
2803       (*mangled) += 3;
2804       work -> destructor += 1;
2805     }
2806   else if ((*mangled)[0] == '_'
2807            && (((*mangled)[1] == '_'
2808                 && (*mangled)[2] == 'v'
2809                 && (*mangled)[3] == 't'
2810                 && (*mangled)[4] == '_')
2811                || ((*mangled)[1] == 'v'
2812                    && (*mangled)[2] == 't'
2813                    && strchr (cplus_markers, (*mangled)[3]) != NULL)))
2814     {
2815       /* Found a GNU style virtual table, get past "_vt<CPLUS_MARKER>"
2816          and create the decl.  Note that we consume the entire mangled
2817          input string, which means that demangle_signature has no work
2818          to do.  */
2819       if ((*mangled)[2] == 'v')
2820         (*mangled) += 5; /* New style, with thunks: "__vt_" */
2821       else
2822         (*mangled) += 4; /* Old style, no thunks: "_vt<CPLUS_MARKER>" */
2823       while (**mangled != '\0')
2824         {
2825           switch (**mangled)
2826             {
2827             case 'Q':
2828             case 'K':
2829               success = demangle_qualified (work, mangled, declp, 0, 1);
2830               break;
2831             case 't':
2832               success = demangle_template (work, mangled, declp, 0, 1,
2833                                            1);
2834               break;
2835             default:
2836               if (ISDIGIT((unsigned char)*mangled[0]))
2837                 {
2838                   n = consume_count(mangled);
2839                   /* We may be seeing a too-large size, or else a
2840                      ".<digits>" indicating a static local symbol.  In
2841                      any case, declare victory and move on; *don't* try
2842                      to use n to allocate.  */
2843                   if (n > (int) strlen (*mangled))
2844                     {
2845                       success = 1;
2846                       break;
2847                     }
2848                 }
2849               else
2850                 {
2851                   n = strcspn (*mangled, cplus_markers);
2852                 }
2853               string_appendn (declp, *mangled, n);
2854               (*mangled) += n;
2855             }
2856
2857           p = strpbrk (*mangled, cplus_markers);
2858           if (success && ((p == NULL) || (p == *mangled)))
2859             {
2860               if (p != NULL)
2861                 {
2862                   string_append (declp, SCOPE_STRING (work));
2863                   (*mangled)++;
2864                 }
2865             }
2866           else
2867             {
2868               success = 0;
2869               break;
2870             }
2871         }
2872       if (success)
2873         string_append (declp, " virtual table");
2874     }
2875   else if ((*mangled)[0] == '_'
2876            && (strchr("0123456789Qt", (*mangled)[1]) != NULL)
2877            && (p = strpbrk (*mangled, cplus_markers)) != NULL)
2878     {
2879       /* static data member, "_3foo$varname" for example */
2880       (*mangled)++;
2881       switch (**mangled)
2882         {
2883         case 'Q':
2884         case 'K':
2885           success = demangle_qualified (work, mangled, declp, 0, 1);
2886           break;
2887         case 't':
2888           success = demangle_template (work, mangled, declp, 0, 1, 1);
2889           break;
2890         default:
2891           n = consume_count (mangled);
2892           if (n < 0 || n > (long) strlen (*mangled))
2893             {
2894               success = 0;
2895               break;
2896             }
2897
2898           if (n > 10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
2899               && (*mangled)[9] == 'N'
2900               && (*mangled)[8] == (*mangled)[10]
2901               && strchr (cplus_markers, (*mangled)[8]))
2902             {
2903               /* A member of the anonymous namespace.  There's information
2904                  about what identifier or filename it was keyed to, but
2905                  it's just there to make the mangled name unique; we just
2906                  step over it.  */
2907               string_append (declp, "{anonymous}");
2908               (*mangled) += n;
2909
2910               /* Now p points to the marker before the N, so we need to
2911                  update it to the first marker after what we consumed.  */
2912               p = strpbrk (*mangled, cplus_markers);
2913               break;
2914             }
2915
2916           string_appendn (declp, *mangled, n);
2917           (*mangled) += n;
2918         }
2919       if (success && (p == *mangled))
2920         {
2921           /* Consumed everything up to the cplus_marker, append the
2922              variable name.  */
2923           (*mangled)++;
2924           string_append (declp, SCOPE_STRING (work));
2925           n = strlen (*mangled);
2926           string_appendn (declp, *mangled, n);
2927           (*mangled) += n;
2928         }
2929       else
2930         {
2931           success = 0;
2932         }
2933     }
2934   else if (strncmp (*mangled, "__thunk_", 8) == 0)
2935     {
2936       int delta;
2937
2938       (*mangled) += 8;
2939       delta = consume_count (mangled);
2940       if (delta == -1)
2941         success = 0;
2942       else
2943         {
2944           char *method = internal_cplus_demangle (work, ++*mangled);
2945
2946           if (method)
2947             {
2948               char buf[50];
2949               sprintf (buf, "virtual function thunk (delta:%d) for ", -delta);
2950               string_append (declp, buf);
2951               string_append (declp, method);
2952               free (method);
2953               n = strlen (*mangled);
2954               (*mangled) += n;
2955             }
2956           else
2957             {
2958               success = 0;
2959             }
2960         }
2961     }
2962   else if (strncmp (*mangled, "__t", 3) == 0
2963            && ((*mangled)[3] == 'i' || (*mangled)[3] == 'f'))
2964     {
2965       p = (*mangled)[3] == 'i' ? " type_info node" : " type_info function";
2966       (*mangled) += 4;
2967       switch (**mangled)
2968         {
2969         case 'Q':
2970         case 'K':
2971           success = demangle_qualified (work, mangled, declp, 0, 1);
2972           break;
2973         case 't':
2974           success = demangle_template (work, mangled, declp, 0, 1, 1);
2975           break;
2976         default:
2977           success = do_type (work, mangled, declp);
2978           break;
2979         }
2980       if (success && **mangled != '\0')
2981         success = 0;
2982       if (success)
2983         string_append (declp, p);
2984     }
2985   else
2986     {
2987       success = 0;
2988     }
2989   return (success);
2990 }
2991
2992 static void
2993 recursively_demangle(struct work_stuff *work, const char **mangled,
2994                      string *result, int namelength)
2995 {
2996   char * recurse = (char *)NULL;
2997   char * recurse_dem = (char *)NULL;
2998
2999   recurse = XNEWVEC (char, namelength + 1);
3000   memcpy (recurse, *mangled, namelength);
3001   recurse[namelength] = '\000';
3002
3003   recurse_dem = cplus_demangle (recurse, work->options);
3004
3005   if (recurse_dem)
3006     {
3007       string_append (result, recurse_dem);
3008       free (recurse_dem);
3009     }
3010   else
3011     {
3012       string_appendn (result, *mangled, namelength);
3013     }
3014   free (recurse);
3015   *mangled += namelength;
3016 }
3017
3018 /*
3019
3020 LOCAL FUNCTION
3021
3022         arm_special -- special handling of ARM/lucid mangled strings
3023
3024 SYNOPSIS
3025
3026         static int
3027         arm_special (const char **mangled,
3028                      string *declp);
3029
3030
3031 DESCRIPTION
3032
3033         Process some special ARM style mangling forms that don't fit
3034         the normal pattern.  For example:
3035
3036                 __vtbl__3foo            (foo virtual table)
3037                 __vtbl__3foo__3bar      (bar::foo virtual table)
3038
3039  */
3040
3041 static int
3042 arm_special (const char **mangled, string *declp)
3043 {
3044   int n;
3045   int success = 1;
3046   const char *scan;
3047
3048   if (strncmp (*mangled, ARM_VTABLE_STRING, ARM_VTABLE_STRLEN) == 0)
3049     {
3050       /* Found a ARM style virtual table, get past ARM_VTABLE_STRING
3051          and create the decl.  Note that we consume the entire mangled
3052          input string, which means that demangle_signature has no work
3053          to do.  */
3054       scan = *mangled + ARM_VTABLE_STRLEN;
3055       while (*scan != '\0')        /* first check it can be demangled */
3056         {
3057           n = consume_count (&scan);
3058           if (n == -1)
3059             {
3060               return (0);           /* no good */
3061             }
3062           scan += n;
3063           if (scan[0] == '_' && scan[1] == '_')
3064             {
3065               scan += 2;
3066             }
3067         }
3068       (*mangled) += ARM_VTABLE_STRLEN;
3069       while (**mangled != '\0')
3070         {
3071           n = consume_count (mangled);
3072           if (n == -1
3073               || n > (long) strlen (*mangled))
3074             return 0;
3075           string_prependn (declp, *mangled, n);
3076           (*mangled) += n;
3077           if ((*mangled)[0] == '_' && (*mangled)[1] == '_')
3078             {
3079               string_prepend (declp, "::");
3080               (*mangled) += 2;
3081             }
3082         }
3083       string_append (declp, " virtual table");
3084     }
3085   else
3086     {
3087       success = 0;
3088     }
3089   return (success);
3090 }
3091
3092 /*
3093
3094 LOCAL FUNCTION
3095
3096         demangle_qualified -- demangle 'Q' qualified name strings
3097
3098 SYNOPSIS
3099
3100         static int
3101         demangle_qualified (struct work_stuff *, const char *mangled,
3102                             string *result, int isfuncname, int append);
3103
3104 DESCRIPTION
3105
3106         Demangle a qualified name, such as "Q25Outer5Inner" which is
3107         the mangled form of "Outer::Inner".  The demangled output is
3108         prepended or appended to the result string according to the
3109         state of the append flag.
3110
3111         If isfuncname is nonzero, then the qualified name we are building
3112         is going to be used as a member function name, so if it is a
3113         constructor or destructor function, append an appropriate
3114         constructor or destructor name.  I.E. for the above example,
3115         the result for use as a constructor is "Outer::Inner::Inner"
3116         and the result for use as a destructor is "Outer::Inner::~Inner".
3117
3118 BUGS
3119
3120         Numeric conversion is ASCII dependent (FIXME).
3121
3122  */
3123
3124 static int
3125 demangle_qualified (struct work_stuff *work, const char **mangled,
3126                     string *result, int isfuncname, int append)
3127 {
3128   int qualifiers = 0;
3129   int success = 1;
3130   char num[2];
3131   string temp;
3132   string last_name;
3133   int bindex = register_Btype (work);
3134
3135   /* We only make use of ISFUNCNAME if the entity is a constructor or
3136      destructor.  */
3137   isfuncname = (isfuncname
3138                 && ((work->constructor & 1) || (work->destructor & 1)));
3139
3140   string_init (&temp);
3141   string_init (&last_name);
3142
3143   if ((*mangled)[0] == 'K')
3144     {
3145     /* Squangling qualified name reuse */
3146       int idx;
3147       (*mangled)++;
3148       idx = consume_count_with_underscores (mangled);
3149       if (idx == -1 || idx >= work -> numk)
3150         success = 0;
3151       else
3152         string_append (&temp, work -> ktypevec[idx]);
3153     }
3154   else
3155     switch ((*mangled)[1])
3156     {
3157     case '_':
3158       /* GNU mangled name with more than 9 classes.  The count is preceded
3159          by an underscore (to distinguish it from the <= 9 case) and followed
3160          by an underscore.  */
3161       (*mangled)++;
3162       qualifiers = consume_count_with_underscores (mangled);
3163       if (qualifiers == -1)
3164         success = 0;
3165       break;
3166
3167     case '1':
3168     case '2':
3169     case '3':
3170     case '4':
3171     case '5':
3172     case '6':
3173     case '7':
3174     case '8':
3175     case '9':
3176       /* The count is in a single digit.  */
3177       num[0] = (*mangled)[1];
3178       num[1] = '\0';
3179       qualifiers = atoi (num);
3180
3181       /* If there is an underscore after the digit, skip it.  This is
3182          said to be for ARM-qualified names, but the ARM makes no
3183          mention of such an underscore.  Perhaps cfront uses one.  */
3184       if ((*mangled)[2] == '_')
3185         {
3186           (*mangled)++;
3187         }
3188       (*mangled) += 2;
3189       break;
3190
3191     case '0':
3192     default:
3193       success = 0;
3194     }
3195
3196   if (!success)
3197     return success;
3198
3199   /* Pick off the names and collect them in the temp buffer in the order
3200      in which they are found, separated by '::'.  */
3201
3202   while (qualifiers-- > 0)
3203     {
3204       int remember_K = 1;
3205       string_clear (&last_name);
3206
3207       if (*mangled[0] == '_')
3208         (*mangled)++;
3209
3210       if (*mangled[0] == 't')
3211         {
3212           /* Here we always append to TEMP since we will want to use
3213              the template name without the template parameters as a
3214              constructor or destructor name.  The appropriate
3215              (parameter-less) value is returned by demangle_template
3216              in LAST_NAME.  We do not remember the template type here,
3217              in order to match the G++ mangling algorithm.  */
3218           success = demangle_template(work, mangled, &temp,
3219                                       &last_name, 1, 0);
3220           if (!success)
3221             break;
3222         }
3223       else if (*mangled[0] == 'K')
3224         {
3225           int idx;
3226           (*mangled)++;
3227           idx = consume_count_with_underscores (mangled);
3228           if (idx == -1 || idx >= work->numk)
3229             success = 0;
3230           else
3231             string_append (&temp, work->ktypevec[idx]);
3232           remember_K = 0;
3233
3234           if (!success) break;
3235         }
3236       else
3237         {
3238           if (EDG_DEMANGLING)
3239             {
3240               int namelength;
3241               /* Now recursively demangle the qualifier
3242                * This is necessary to deal with templates in
3243                * mangling styles like EDG */
3244               namelength = consume_count (mangled);
3245               if (namelength == -1)
3246                 {
3247                   success = 0;
3248                   break;
3249                 }
3250               recursively_demangle(work, mangled, &temp, namelength);
3251             }
3252           else
3253             {
3254               string_delete (&last_name);
3255               success = do_type (work, mangled, &last_name);
3256               if (!success)
3257                 break;
3258               string_appends (&temp, &last_name);
3259             }
3260         }
3261
3262       if (remember_K)
3263         remember_Ktype (work, temp.b, LEN_STRING (&temp));
3264
3265       if (qualifiers > 0)
3266         string_append (&temp, SCOPE_STRING (work));
3267     }
3268
3269   remember_Btype (work, temp.b, LEN_STRING (&temp), bindex);
3270
3271   /* If we are using the result as a function name, we need to append
3272      the appropriate '::' separated constructor or destructor name.
3273      We do this here because this is the most convenient place, where
3274      we already have a pointer to the name and the length of the name.  */
3275
3276   if (isfuncname)
3277     {
3278       string_append (&temp, SCOPE_STRING (work));
3279       if (work -> destructor & 1)
3280         string_append (&temp, "~");
3281       string_appends (&temp, &last_name);
3282     }
3283
3284   /* Now either prepend the temp buffer to the result, or append it,
3285      depending upon the state of the append flag.  */
3286
3287   if (append)
3288     string_appends (result, &temp);
3289   else
3290     {
3291       if (!STRING_EMPTY (result))
3292         string_append (&temp, SCOPE_STRING (work));
3293       string_prepends (result, &temp);
3294     }
3295
3296   string_delete (&last_name);
3297   string_delete (&temp);
3298   return (success);
3299 }
3300
3301 /*
3302
3303 LOCAL FUNCTION
3304
3305         get_count -- convert an ascii count to integer, consuming tokens
3306
3307 SYNOPSIS
3308
3309         static int
3310         get_count (const char **type, int *count)
3311
3312 DESCRIPTION
3313
3314         Assume that *type points at a count in a mangled name; set
3315         *count to its value, and set *type to the next character after
3316         the count.  There are some weird rules in effect here.
3317
3318         If *type does not point at a string of digits, return zero.
3319
3320         If *type points at a string of digits followed by an
3321         underscore, set *count to their value as an integer, advance
3322         *type to point *after the underscore, and return 1.
3323
3324         If *type points at a string of digits not followed by an
3325         underscore, consume only the first digit.  Set *count to its
3326         value as an integer, leave *type pointing after that digit,
3327         and return 1.
3328
3329         The excuse for this odd behavior: in the ARM and HP demangling
3330         styles, a type can be followed by a repeat count of the form
3331         `Nxy', where:
3332
3333         `x' is a single digit specifying how many additional copies
3334             of the type to append to the argument list, and
3335
3336         `y' is one or more digits, specifying the zero-based index of
3337             the first repeated argument in the list.  Yes, as you're
3338             unmangling the name you can figure this out yourself, but
3339             it's there anyway.
3340
3341         So, for example, in `bar__3fooFPiN51', the first argument is a
3342         pointer to an integer (`Pi'), and then the next five arguments
3343         are the same (`N5'), and the first repeat is the function's
3344         second argument (`1').
3345 */
3346
3347 static int
3348 get_count (const char **type, int *count)
3349 {
3350   const char *p;
3351   int n;
3352
3353   if (!ISDIGIT ((unsigned char)**type))
3354     return (0);
3355   else
3356     {
3357       *count = **type - '0';
3358       (*type)++;
3359       if (ISDIGIT ((unsigned char)**type))
3360         {
3361           p = *type;
3362           n = *count;
3363           do
3364             {
3365               n *= 10;
3366               n += *p - '0';
3367               p++;
3368             }
3369           while (ISDIGIT ((unsigned char)*p));
3370           if (*p == '_')
3371             {
3372               *type = p + 1;
3373               *count = n;
3374             }
3375         }
3376     }
3377   return (1);
3378 }
3379
3380 /* RESULT will be initialised here; it will be freed on failure.  The
3381    value returned is really a type_kind_t.  */
3382
3383 static int
3384 do_type (struct work_stuff *work, const char **mangled, string *result)
3385 {
3386   int n;
3387   int done;
3388   int success;
3389   string decl;
3390   const char *remembered_type;
3391   int type_quals;
3392   type_kind_t tk = tk_none;
3393
3394   string_init (&decl);
3395   string_init (result);
3396
3397   done = 0;
3398   success = 1;
3399   while (success && !done)
3400     {
3401       int member;
3402       switch (**mangled)
3403         {
3404
3405           /* A pointer type */
3406         case 'P':
3407         case 'p':
3408           (*mangled)++;
3409           if (! (work -> options & DMGL_JAVA))
3410             string_prepend (&decl, "*");
3411           if (tk == tk_none)
3412             tk = tk_pointer;
3413           break;
3414
3415           /* A reference type */
3416         case 'R':
3417           (*mangled)++;
3418           string_prepend (&decl, "&");
3419           if (tk == tk_none)
3420             tk = tk_reference;
3421           break;
3422
3423           /* An array */
3424         case 'A':
3425           {
3426             ++(*mangled);
3427             if (!STRING_EMPTY (&decl)
3428                 && (decl.b[0] == '*' || decl.b[0] == '&'))
3429               {
3430                 string_prepend (&decl, "(");
3431                 string_append (&decl, ")");
3432               }
3433             string_append (&decl, "[");
3434             if (**mangled != '_')