OSDN Git Service

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