OSDN Git Service

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