OSDN Git Service

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