libiberty/cplus-dem.c

   1 /* Demangler for GNU C++
   2    Copyright 1989, 1991, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   4    Written by James Clark (jjc@jclark.uucp)
   5    Rewritten by Fred Fish (fnf@cygnus.com) for ARM and Lucid demangling
   6    Modified by Satish Pai (pai@apollo.hp.com) for HP demangling
   7
   8 This file is part of the libiberty library.
   9 Libiberty is free software; you can redistribute it and/or
  10 modify it under the terms of the GNU Library General Public
  11 License as published by the Free Software Foundation; either
  12 version 2 of the License, or (at your option) any later version.
  13
  14 In addition to the permissions in the GNU Library General Public
  15 License, the Free Software Foundation gives you unlimited permission
  16 to link the compiled version of this file into combinations with other
  17 programs, and to distribute those combinations without any restriction
  18 coming from the use of this file.  (The Library Public License
  19 restrictions do apply in other respects; for example, they cover
  20 modification of the file, and distribution when not linked into a
  21 combined executable.)
  22
  23 Libiberty is distributed in the hope that it will be useful,
  24 but WITHOUT ANY WARRANTY; without even the implied warranty of
  25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  26 Library General Public License for more details.
  27
  28 You should have received a copy of the GNU Library General Public
  29 License along with libiberty; see the file COPYING.LIB.  If
  30 not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
  31 Boston, MA 02110-1301, USA.  */
  32
  33 /* This file exports two functions; cplus_mangle_opname and cplus_demangle.
  34
  35    This file imports xmalloc and xrealloc, which are like malloc and
  36    realloc except that they generate a fatal error if there is no
  37    available memory.  */
  38
  39 /* This file lives in both GCC and libiberty.  When making changes, please
  40    try not to break either.  */
  41
  42 #ifdef HAVE_CONFIG_H
  43 #include "config.h"
  44 #endif
  45
  46 #include "safe-ctype.h"
  47
  48 #include <sys/types.h>
  49 #include <string.h>
  50 #include <stdio.h>
  51
  52 #ifdef HAVE_STDLIB_H
  53 #include <stdlib.h>
  54 #else
  55 void * malloc ();
  56 void * realloc ();
  57 #endif
  58
  59 #include <demangle.h>
  60 #undef CURRENT_DEMANGLING_STYLE
  61 #define CURRENT_DEMANGLING_STYLE work->options
  62
  63 #include "libiberty.h"
  64
  65 static char *ada_demangle (const char *, int);
  66
  67 #define min(X,Y) (((X) < (Y)) ? (X) : (Y))
  68
  69 /* A value at least one greater than the maximum number of characters
  70    that will be output when using the `%d' format with `printf'.  */
  71 #define INTBUF_SIZE 32
  72
  73 extern void fancy_abort (void) ATTRIBUTE_NORETURN;
  74
  75 /* In order to allow a single demangler executable to demangle strings
  76    using various common values of CPLUS_MARKER, as well as any specific
  77    one set at compile time, we maintain a string containing all the
  78    commonly used ones, and check to see if the marker we are looking for
  79    is in that string.  CPLUS_MARKER is usually '$' on systems where the
  80    assembler can deal with that.  Where the assembler can't, it's usually
  81    '.' (but on many systems '.' is used for other things).  We put the
  82    current defined CPLUS_MARKER first (which defaults to '$'), followed
  83    by the next most common value, followed by an explicit '$' in case
  84    the value of CPLUS_MARKER is not '$'.
  85
  86    We could avoid this if we could just get g++ to tell us what the actual
  87    cplus marker character is as part of the debug information, perhaps by
  88    ensuring that it is the character that terminates the gcc<n>_compiled
  89    marker symbol (FIXME).  */
  90
  91 #if !defined (CPLUS_MARKER)
  92 #define CPLUS_MARKER '$'
  93 #endif
  94
  95 enum demangling_styles current_demangling_style = auto_demangling;
  96
  97 static char cplus_markers[] = { CPLUS_MARKER, '.', '$', '\0' };
  98
  99 static char char_str[2] = { '\000', '\000' };
 100
 101 void
 102 set_cplus_marker_for_demangling (int ch)
 103 {
 104   cplus_markers[0] = ch;
 105 }
 106
 107 typedef struct string           /* Beware: these aren't required to be */
 108 {                               /*  '\0' terminated.  */
 109   char *b;                      /* pointer to start of string */
 110   char *p;                      /* pointer after last character */
 111   char *e;                      /* pointer after end of allocated space */
 112 } string;
 113
 114 /* Stuff that is shared between sub-routines.
 115    Using a shared structure allows cplus_demangle to be reentrant.  */
 116
 117 struct work_stuff
 118 {
 119   int options;
 120   char **typevec;
 121   char **ktypevec;
 122   char **btypevec;
 123   int numk;
 124   int numb;
 125   int ksize;
 126   int bsize;
 127   int ntypes;
 128   int typevec_size;
 129   int constructor;
 130   int destructor;
 131   int static_type;      /* A static member function */
 132   int temp_start;       /* index in demangled to start of template args */
 133   int type_quals;       /* The type qualifiers.  */
 134   int dllimported;      /* Symbol imported from a PE DLL */
 135   char **tmpl_argvec;   /* Template function arguments. */
 136   int ntmpl_args;       /* The number of template function arguments. */
 137   int forgetting_types; /* Nonzero if we are not remembering the types
 138                            we see.  */
 139   string* previous_argument; /* The last function argument demangled.  */
 140   int nrepeats;         /* The number of times to repeat the previous
 141                            argument.  */
 142 };
 143
 144 #define PRINT_ANSI_QUALIFIERS (work -> options & DMGL_ANSI)
 145 #define PRINT_ARG_TYPES       (work -> options & DMGL_PARAMS)
 146
 147 static const struct optable
 148 {
 149   const char *const in;
 150   const char *const out;
 151   const int flags;
 152 } optable[] = {
 153   {"nw",          " new",       DMGL_ANSI},     /* new (1.92,    ansi) */
 154   {"dl",          " delete",    DMGL_ANSI},     /* new (1.92,    ansi) */
 155   {"new",         " new",       0},             /* old (1.91,    and 1.x) */
 156   {"delete",      " delete",    0},             /* old (1.91,    and 1.x) */
 157   {"vn",          " new []",    DMGL_ANSI},     /* GNU, pending ansi */
 158   {"vd",          " delete []", DMGL_ANSI},     /* GNU, pending ansi */
 159   {"as",          "=",          DMGL_ANSI},     /* ansi */
 160   {"ne",          "!=",         DMGL_ANSI},     /* old, ansi */
 161   {"eq",          "==",         DMGL_ANSI},     /* old, ansi */
 162   {"ge",          ">=",         DMGL_ANSI},     /* old, ansi */
 163   {"gt",          ">",          DMGL_ANSI},     /* old, ansi */
 164   {"le",          "<=",         DMGL_ANSI},     /* old, ansi */
 165   {"lt",          "<",          DMGL_ANSI},     /* old, ansi */
 166   {"plus",        "+",          0},             /* old */
 167   {"pl",          "+",          DMGL_ANSI},     /* ansi */
 168   {"apl",         "+=",         DMGL_ANSI},     /* ansi */
 169   {"minus",       "-",          0},             /* old */
 170   {"mi",          "-",          DMGL_ANSI},     /* ansi */
 171   {"ami",         "-=",         DMGL_ANSI},     /* ansi */
 172   {"mult",        "*",          0},             /* old */
 173   {"ml",          "*",          DMGL_ANSI},     /* ansi */
 174   {"amu",         "*=",         DMGL_ANSI},     /* ansi (ARM/Lucid) */
 175   {"aml",         "*=",         DMGL_ANSI},     /* ansi (GNU/g++) */
 176   {"convert",     "+",          0},             /* old (unary +) */
 177   {"negate",      "-",          0},             /* old (unary -) */
 178   {"trunc_mod",   "%",          0},             /* old */
 179   {"md",          "%",          DMGL_ANSI},     /* ansi */
 180   {"amd",         "%=",         DMGL_ANSI},     /* ansi */
 181   {"trunc_div",   "/",          0},             /* old */
 182   {"dv",          "/",          DMGL_ANSI},     /* ansi */
 183   {"adv",         "/=",         DMGL_ANSI},     /* ansi */
 184   {"truth_andif", "&&",         0},             /* old */
 185   {"aa",          "&&",         DMGL_ANSI},     /* ansi */
 186   {"truth_orif",  "||",         0},             /* old */
 187   {"oo",          "||",         DMGL_ANSI},     /* ansi */
 188   {"truth_not",   "!",          0},             /* old */
 189   {"nt",          "!",          DMGL_ANSI},     /* ansi */
 190   {"postincrement","++",        0},             /* old */
 191   {"pp",          "++",         DMGL_ANSI},     /* ansi */
 192   {"postdecrement","--",        0},             /* old */
 193   {"mm",          "--",         DMGL_ANSI},     /* ansi */
 194   {"bit_ior",     "|",          0},             /* old */
 195   {"or",          "|",          DMGL_ANSI},     /* ansi */
 196   {"aor",         "|=",         DMGL_ANSI},     /* ansi */
 197   {"bit_xor",     "^",          0},             /* old */
 198   {"er",          "^",          DMGL_ANSI},     /* ansi */
 199   {"aer",         "^=",         DMGL_ANSI},     /* ansi */
 200   {"bit_and",     "&",          0},             /* old */
 201   {"ad",          "&",          DMGL_ANSI},     /* ansi */
 202   {"aad",         "&=",         DMGL_ANSI},     /* ansi */
 203   {"bit_not",     "~",          0},             /* old */
 204   {"co",          "~",          DMGL_ANSI},     /* ansi */
 205   {"call",        "()",         0},             /* old */
 206   {"cl",          "()",         DMGL_ANSI},     /* ansi */
 207   {"alshift",     "<<",         0},             /* old */
 208   {"ls",          "<<",         DMGL_ANSI},     /* ansi */
 209   {"als",         "<<=",        DMGL_ANSI},     /* ansi */
 210   {"arshift",     ">>",         0},             /* old */
 211   {"rs",          ">>",         DMGL_ANSI},     /* ansi */
 212   {"ars",         ">>=",        DMGL_ANSI},     /* ansi */
 213   {"component",   "->",         0},             /* old */
 214   {"pt",          "->",         DMGL_ANSI},     /* ansi; Lucid C++ form */
 215   {"rf",          "->",         DMGL_ANSI},     /* ansi; ARM/GNU form */
 216   {"indirect",    "*",          0},             /* old */
 217   {"method_call",  "->()",      0},             /* old */
 218   {"addr",        "&",          0},             /* old (unary &) */
 219   {"array",       "[]",         0},             /* old */
 220   {"vc",          "[]",         DMGL_ANSI},     /* ansi */
 221   {"compound",    ", ",         0},             /* old */
 222   {"cm",          ", ",         DMGL_ANSI},     /* ansi */
 223   {"cond",        "?:",         0},             /* old */
 224   {"cn",          "?:",         DMGL_ANSI},     /* pseudo-ansi */
 225   {"max",         ">?",         0},             /* old */
 226   {"mx",          ">?",         DMGL_ANSI},     /* pseudo-ansi */
 227   {"min",         "<?",         0},             /* old */
 228   {"mn",          "<?",         DMGL_ANSI},     /* pseudo-ansi */
 229   {"nop",         "",           0},             /* old (for operator=) */
 230   {"rm",          "->*",        DMGL_ANSI},     /* ansi */
 231   {"sz",          "sizeof ",    DMGL_ANSI}      /* pseudo-ansi */
 232 };
 233
 234 /* These values are used to indicate the various type varieties.
 235    They are all non-zero so that they can be used as `success'
 236    values.  */
 237 typedef enum type_kind_t
 238 {
 239   tk_none,
 240   tk_pointer,
 241   tk_reference,
 242   tk_integral,
 243   tk_bool,
 244   tk_char,
 245   tk_real
 246 } type_kind_t;
 247
 248 const struct demangler_engine libiberty_demanglers[] =
 249 {
 250   {
 251     NO_DEMANGLING_STYLE_STRING,
 252     no_demangling,
 253     "Demangling disabled"
 254   }
 255   ,
 256   {
 257     AUTO_DEMANGLING_STYLE_STRING,
 258       auto_demangling,
 259       "Automatic selection based on executable"
 260   }
 261   ,
 262   {
 263     GNU_DEMANGLING_STYLE_STRING,
 264       gnu_demangling,
 265       "GNU (g++) style demangling"
 266   }
 267   ,
 268   {
 269     LUCID_DEMANGLING_STYLE_STRING,
 270       lucid_demangling,
 271       "Lucid (lcc) style demangling"
 272   }
 273   ,
 274   {
 275     ARM_DEMANGLING_STYLE_STRING,
 276       arm_demangling,
 277       "ARM style demangling"
 278   }
 279   ,
 280   {
 281     HP_DEMANGLING_STYLE_STRING,
 282       hp_demangling,
 283       "HP (aCC) style demangling"
 284   }
 285   ,
 286   {
 287     EDG_DEMANGLING_STYLE_STRING,
 288       edg_demangling,
 289       "EDG style demangling"
 290   }
 291   ,
 292   {
 293     GNU_V3_DEMANGLING_STYLE_STRING,
 294     gnu_v3_demangling,
 295     "GNU (g++) V3 ABI-style demangling"
 296   }
 297   ,
 298   {
 299     JAVA_DEMANGLING_STYLE_STRING,
 300     java_demangling,
 301     "Java style demangling"
 302   }
 303   ,
 304   {
 305     GNAT_DEMANGLING_STYLE_STRING,
 306     gnat_demangling,
 307     "GNAT style demangling"
 308   }
 309   ,
 310   {
 311     NULL, unknown_demangling, NULL
 312   }
 313 };
 314
 315 #define STRING_EMPTY(str)       ((str) -> b == (str) -> p)
 316 #define APPEND_BLANK(str)       {if (!STRING_EMPTY(str)) \
 317     string_append(str, " ");}
 318 #define LEN_STRING(str)         ( (STRING_EMPTY(str))?0:((str)->p - (str)->b))
 319
 320 /* The scope separator appropriate for the language being demangled.  */
 321
 322 #define SCOPE_STRING(work) ((work->options & DMGL_JAVA) ? "." : "::")
 323
 324 #define ARM_VTABLE_STRING "__vtbl__"    /* Lucid/ARM virtual table prefix */
 325 #define ARM_VTABLE_STRLEN 8             /* strlen (ARM_VTABLE_STRING) */
 326
 327 /* Prototypes for local functions */
 328
 329 static void delete_work_stuff (struct work_stuff *);
 330
 331 static void delete_non_B_K_work_stuff (struct work_stuff *);
 332
 333 static char *mop_up (struct work_stuff *, string *, int);
 334
 335 static void squangle_mop_up (struct work_stuff *);
 336
 337 static void work_stuff_copy_to_from (struct work_stuff *, struct work_stuff *);
 338
 339 #if 0
 340 static int
 341 demangle_method_args (struct work_stuff *, const char **, string *);
 342 #endif
 343
 344 static char *
 345 internal_cplus_demangle (struct work_stuff *, const char *);
 346
 347 static int
 348 demangle_template_template_parm (struct work_stuff *work,
 349                                  const char **, string *);
 350
 351 static int
 352 demangle_template (struct work_stuff *work, const char **, string *,
 353                    string *, int, int);
 354
 355 static int
 356 arm_pt (struct work_stuff *, const char *, int, const char **,
 357         const char **);
 358
 359 static int
 360 demangle_class_name (struct work_stuff *, const char **, string *);
 361
 362 static int
 363 demangle_qualified (struct work_stuff *, const char **, string *,
 364                     int, int);
 365
 366 static int demangle_class (struct work_stuff *, const char **, string *);
 367
 368 static int demangle_fund_type (struct work_stuff *, const char **, string *);
 369
 370 static int demangle_signature (struct work_stuff *, const char **, string *);
 371
 372 static int demangle_prefix (struct work_stuff *, const char **, string *);
 373
 374 static int gnu_special (struct work_stuff *, const char **, string *);
 375
 376 static int arm_special (const char **, string *);
 377
 378 static void string_need (string *, int);
 379
 380 static void string_delete (string *);
 381
 382 static void
 383 string_init (string *);
 384
 385 static void string_clear (string *);
 386
 387 #if 0
 388 static int string_empty (string *);
 389 #endif
 390
 391 static void string_append (string *, const char *);
 392
 393 static void string_appends (string *, string *);
 394
 395 static void string_appendn (string *, const char *, int);
 396
 397 static void string_prepend (string *, const char *);
 398
 399 static void string_prependn (string *, const char *, int);
 400
 401 static void string_append_template_idx (string *, int);
 402
 403 static int get_count (const char **, int *);
 404
 405 static int consume_count (const char **);
 406
 407 static int consume_count_with_underscores (const char**);
 408
 409 static int demangle_args (struct work_stuff *, const char **, string *);
 410
 411 static int demangle_nested_args (struct work_stuff*, const char**, string*);
 412
 413 static int do_type (struct work_stuff *, const char **, string *);
 414
 415 static int do_arg (struct work_stuff *, const char **, string *);
 416
 417 static int
 418 demangle_function_name (struct work_stuff *, const char **, string *,
 419                         const char *);
 420
 421 static int
 422 iterate_demangle_function (struct work_stuff *,
 423                            const char **, string *, const char *);
 424
 425 static void remember_type (struct work_stuff *, const char *, int);
 426
 427 static void remember_Btype (struct work_stuff *, const char *, int, int);
 428
 429 static int register_Btype (struct work_stuff *);
 430
 431 static void remember_Ktype (struct work_stuff *, const char *, int);
 432
 433 static void forget_types (struct work_stuff *);
 434
 435 static void forget_B_and_K_types (struct work_stuff *);
 436
 437 static void string_prepends (string *, string *);
 438
 439 static int
 440 demangle_template_value_parm (struct work_stuff*, const char**,
 441                               string*, type_kind_t);
 442
 443 static int
 444 do_hpacc_template_const_value (struct work_stuff *, const char **, string *);
 445
 446 static int
 447 do_hpacc_template_literal (struct work_stuff *, const char **, string *);
 448
 449 static int snarf_numeric_literal (const char **, string *);
 450
 451 /* There is a TYPE_QUAL value for each type qualifier.  They can be
 452    combined by bitwise-or to form the complete set of qualifiers for a
 453    type.  */
 454
 455 #define TYPE_UNQUALIFIED   0x0
 456 #define TYPE_QUAL_CONST    0x1
 457 #define TYPE_QUAL_VOLATILE 0x2
 458 #define TYPE_QUAL_RESTRICT 0x4
 459
 460 static int code_for_qualifier (int);
 461
 462 static const char* qualifier_string (int);
 463
 464 static const char* demangle_qualifier (int);
 465
 466 static int demangle_expression (struct work_stuff *, const char **, string *,
 467                                 type_kind_t);
 468
 469 static int
 470 demangle_integral_value (struct work_stuff *, const char **, string *);
 471
 472 static int
 473 demangle_real_value (struct work_stuff *, const char **, string *);
 474
 475 static void
 476 demangle_arm_hp_template (struct work_stuff *, const char **, int, string *);
 477
 478 static void
 479 recursively_demangle (struct work_stuff *, const char **, string *, int);
 480
 481 static void grow_vect (char **, size_t *, size_t, int);
 482
 483 /* Translate count to integer, consuming tokens in the process.
 484    Conversion terminates on the first non-digit character.
 485
 486    Trying to consume something that isn't a count results in no
 487    consumption of input and a return of -1.
 488
 489    Overflow consumes the rest of the digits, and returns -1.  */
 490
 491 static int
 492 consume_count (const char **type)
 493 {
 494   int count = 0;
 495
 496   if (! ISDIGIT ((unsigned char)**type))
 497     return -1;
 498
 499   while (ISDIGIT ((unsigned char)**type))
 500     {
 501       count *= 10;
 502
 503       /* Check for overflow.
 504          We assume that count is represented using two's-complement;
 505          no power of two is divisible by ten, so if an overflow occurs
 506          when multiplying by ten, the result will not be a multiple of
 507          ten.  */
 508       if ((count % 10) != 0)
 509         {
 510           while (ISDIGIT ((unsigned char) **type))
 511             (*type)++;
 512           return -1;
 513         }
 514
 515       count += **type - '0';
 516       (*type)++;
 517     }
 518
 519   if (count < 0)
 520     count = -1;
 521
 522   return (count);
 523 }
 524
 525
 526 /* Like consume_count, but for counts that are preceded and followed
 527    by '_' if they are greater than 10.  Also, -1 is returned for
 528    failure, since 0 can be a valid value.  */
 529
 530 static int
 531 consume_count_with_underscores (const char **mangled)
 532 {
 533   int idx;
 534
 535   if (**mangled == '_')
 536     {
 537       (*mangled)++;
 538       if (!ISDIGIT ((unsigned char)**mangled))
 539         return -1;
 540
 541       idx = consume_count (mangled);
 542       if (**mangled != '_')
 543         /* The trailing underscore was missing. */
 544         return -1;
 545
 546       (*mangled)++;
 547     }
 548   else
 549     {
 550       if (**mangled < '0' || **mangled > '9')
 551         return -1;
 552
 553       idx = **mangled - '0';
 554       (*mangled)++;
 555     }
 556
 557   return idx;
 558 }
 559
 560 /* C is the code for a type-qualifier.  Return the TYPE_QUAL
 561    corresponding to this qualifier.  */
 562
 563 static int
 564 code_for_qualifier (int c)
 565 {
 566   switch (c)
 567     {
 568     case 'C':
 569       return TYPE_QUAL_CONST;
 570
 571     case 'V':
 572       return TYPE_QUAL_VOLATILE;
 573
 574     case 'u':
 575       return TYPE_QUAL_RESTRICT;
 576
 577     default:
 578       break;
 579     }
 580
 581   /* C was an invalid qualifier.  */
 582   abort ();
 583 }
 584
 585 /* Return the string corresponding to the qualifiers given by
 586    TYPE_QUALS.  */
 587
 588 static const char*
 589 qualifier_string (int type_quals)
 590 {
 591   switch (type_quals)
 592     {
 593     case TYPE_UNQUALIFIED:
 594       return "";
 595
 596     case TYPE_QUAL_CONST:
 597       return "const";
 598
 599     case TYPE_QUAL_VOLATILE:
 600       return "volatile";
 601
 602     case TYPE_QUAL_RESTRICT:
 603       return "__restrict";
 604
 605     case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE:
 606       return "const volatile";
 607
 608     case TYPE_QUAL_CONST | TYPE_QUAL_RESTRICT:
 609       return "const __restrict";
 610
 611     case TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT:
 612       return "volatile __restrict";
 613
 614     case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT:
 615       return "const volatile __restrict";
 616
 617     default:
 618       break;
 619     }
 620
 621   /* TYPE_QUALS was an invalid qualifier set.  */
 622   abort ();
 623 }
 624
 625 /* C is the code for a type-qualifier.  Return the string
 626    corresponding to this qualifier.  This function should only be
 627    called with a valid qualifier code.  */
 628
 629 static const char*
 630 demangle_qualifier (int c)
 631 {
 632   return qualifier_string (code_for_qualifier (c));
 633 }
 634
 635 int
 636 cplus_demangle_opname (const char *opname, char *result, int options)
 637 {
 638   int len, len1, ret;
 639   string type;
 640   struct work_stuff work[1];
 641   const char *tem;
 642
 643   len = strlen(opname);
 644   result[0] = '\0';
 645   ret = 0;
 646   memset ((char *) work, 0, sizeof (work));
 647   work->options = options;
 648
 649   if (opname[0] == '_' && opname[1] == '_'
 650       && opname[2] == 'o' && opname[3] == 'p')
 651     {
 652       /* ANSI.  */
 653       /* type conversion operator.  */
 654       tem = opname + 4;
 655       if (do_type (work, &tem, &type))
 656         {
 657           strcat (result, "operator ");
 658           strncat (result, type.b, type.p - type.b);
 659           string_delete (&type);
 660           ret = 1;
 661         }
 662     }
 663   else if (opname[0] == '_' && opname[1] == '_'
 664            && ISLOWER((unsigned char)opname[2])
 665            && ISLOWER((unsigned char)opname[3]))
 666     {
 667       if (opname[4] == '\0')
 668         {
 669           /* Operator.  */
 670           size_t i;
 671           for (i = 0; i < ARRAY_SIZE (optable); i++)
 672             {
 673               if (strlen (optable[i].in) == 2
 674                   && memcmp (optable[i].in, opname + 2, 2) == 0)
 675                 {
 676                   strcat (result, "operator");
 677                   strcat (result, optable[i].out);
 678                   ret = 1;
 679                   break;
 680                 }
 681             }
 682         }
 683       else
 684         {
 685           if (opname[2] == 'a' && opname[5] == '\0')
 686             {
 687               /* Assignment.  */
 688               size_t i;
 689               for (i = 0; i < ARRAY_SIZE (optable); i++)
 690                 {
 691                   if (strlen (optable[i].in) == 3
 692                       && memcmp (optable[i].in, opname + 2, 3) == 0)
 693                     {
 694                       strcat (result, "operator");
 695                       strcat (result, optable[i].out);
 696                       ret = 1;
 697                       break;
 698                     }
 699                 }
 700             }
 701         }
 702     }
 703   else if (len >= 3
 704            && opname[0] == 'o'
 705            && opname[1] == 'p'
 706            && strchr (cplus_markers, opname[2]) != NULL)
 707     {
 708       /* see if it's an assignment expression */
 709       if (len >= 10 /* op$assign_ */
 710           && memcmp (opname + 3, "assign_", 7) == 0)
 711         {
 712           size_t i;
 713           for (i = 0; i < ARRAY_SIZE (optable); i++)
 714             {
 715               len1 = len - 10;
 716               if ((int) strlen (optable[i].in) == len1
 717                   && memcmp (optable[i].in, opname + 10, len1) == 0)
 718                 {
 719                   strcat (result, "operator");
 720                   strcat (result, optable[i].out);
 721                   strcat (result, "=");
 722                   ret = 1;
 723                   break;
 724                 }
 725             }
 726         }
 727       else
 728         {
 729           size_t i;
 730           for (i = 0; i < ARRAY_SIZE (optable); i++)
 731             {
 732               len1 = len - 3;
 733               if ((int) strlen (optable[i].in) == len1
 734                   && memcmp (optable[i].in, opname + 3, len1) == 0)
 735                 {
 736                   strcat (result, "operator");
 737                   strcat (result, optable[i].out);
 738                   ret = 1;
 739                   break;
 740                 }
 741             }
 742         }
 743     }
 744   else if (len >= 5 && memcmp (opname, "type", 4) == 0
 745            && strchr (cplus_markers, opname[4]) != NULL)
 746     {
 747       /* type conversion operator */
 748       tem = opname + 5;
 749       if (do_type (work, &tem, &type))
 750         {
 751           strcat (result, "operator ");
 752           strncat (result, type.b, type.p - type.b);
 753           string_delete (&type);
 754           ret = 1;
 755         }
 756     }
 757   squangle_mop_up (work);
 758   return ret;
 759
 760 }
 761
 762 /* Takes operator name as e.g. "++" and returns mangled
 763    operator name (e.g. "postincrement_expr"), or NULL if not found.
 764
 765    If OPTIONS & DMGL_ANSI == 1, return the ANSI name;
 766    if OPTIONS & DMGL_ANSI == 0, return the old GNU name.  */
 767
 768 const char *
 769 cplus_mangle_opname (const char *opname, int options)
 770 {
 771   size_t i;
 772   int len;
 773
 774   len = strlen (opname);
 775   for (i = 0; i < ARRAY_SIZE (optable); i++)
 776     {
 777       if ((int) strlen (optable[i].out) == len
 778           && (options & DMGL_ANSI) == (optable[i].flags & DMGL_ANSI)
 779           && memcmp (optable[i].out, opname, len) == 0)
 780         return optable[i].in;
 781     }
 782   return (0);
 783 }
 784
 785 /* Add a routine to set the demangling style to be sure it is valid and
 786    allow for any demangler initialization that maybe necessary. */
 787
 788 enum demangling_styles
 789 cplus_demangle_set_style (enum demangling_styles style)
 790 {
 791   const struct demangler_engine *demangler = libiberty_demanglers;
 792
 793   for (; demangler->demangling_style != unknown_demangling; ++demangler)
 794     if (style == demangler->demangling_style)
 795       {
 796         current_demangling_style = style;
 797         return current_demangling_style;
 798       }
 799
 800   return unknown_demangling;
 801 }
 802
 803 /* Do string name to style translation */
 804
 805 enum demangling_styles
 806 cplus_demangle_name_to_style (const char *name)
 807 {
 808   const struct demangler_engine *demangler = libiberty_demanglers;
 809
 810   for (; demangler->demangling_style != unknown_demangling; ++demangler)
 811     if (strcmp (name, demangler->demangling_style_name) == 0)
 812       return demangler->demangling_style;
 813
 814   return unknown_demangling;
 815 }
 816
 817 /* char *cplus_demangle (const char *mangled, int options)
 818
 819    If MANGLED is a mangled function name produced by GNU C++, then
 820    a pointer to a @code{malloc}ed string giving a C++ representation
 821    of the name will be returned; otherwise NULL will be returned.
 822    It is the caller's responsibility to free the string which
 823    is returned.
 824
 825    The OPTIONS arg may contain one or more of the following bits:
 826
 827         DMGL_ANSI       ANSI qualifiers such as `const' and `void' are
 828                         included.
 829         DMGL_PARAMS     Function parameters are included.
 830
 831    For example,
 832
 833    cplus_demangle ("foo__1Ai", DMGL_PARAMS)             => "A::foo(int)"
 834    cplus_demangle ("foo__1Ai", DMGL_PARAMS | DMGL_ANSI) => "A::foo(int)"
 835    cplus_demangle ("foo__1Ai", 0)                       => "A::foo"
 836
 837    cplus_demangle ("foo__1Afe", DMGL_PARAMS)            => "A::foo(float,...)"
 838    cplus_demangle ("foo__1Afe", DMGL_PARAMS | DMGL_ANSI)=> "A::foo(float,...)"
 839    cplus_demangle ("foo__1Afe", 0)                      => "A::foo"
 840
 841    Note that any leading underscores, or other such characters prepended by
 842    the compilation system, are presumed to have already been stripped from
 843    MANGLED.  */
 844
 845 char *
 846 cplus_demangle (const char *mangled, int options)
 847 {
 848   char *ret;
 849   struct work_stuff work[1];
 850
 851   if (current_demangling_style == no_demangling)
 852     return xstrdup (mangled);
 853
 854   memset ((char *) work, 0, sizeof (work));
 855   work->options = options;
 856   if ((work->options & DMGL_STYLE_MASK) == 0)
 857     work->options |= (int) current_demangling_style & DMGL_STYLE_MASK;
 858
 859   /* The V3 ABI demangling is implemented elsewhere.  */
 860   if (GNU_V3_DEMANGLING || AUTO_DEMANGLING)
 861     {
 862       ret = cplus_demangle_v3 (mangled, work->options);
 863       if (ret || GNU_V3_DEMANGLING)
 864         return ret;
 865     }
 866
 867   if (JAVA_DEMANGLING)
 868     {
 869       ret = java_demangle_v3 (mangled);
 870       if (ret)
 871         return ret;
 872     }
 873
 874   if (GNAT_DEMANGLING)
 875     return ada_demangle(mangled,options);
 876
 877   ret = internal_cplus_demangle (work, mangled);
 878   squangle_mop_up (work);
 879   return (ret);
 880 }
 881
 882
 883 /* Assuming *OLD_VECT points to an array of *SIZE objects of size
 884    ELEMENT_SIZE, grow it to contain at least MIN_SIZE objects,
 885    updating *OLD_VECT and *SIZE as necessary.  */
 886
 887 static void
 888 grow_vect (char **old_vect, size_t *size, size_t min_size, int element_size)
 889 {
 890   if (*size < min_size)
 891     {
 892       *size *= 2;
 893       if (*size < min_size)
 894         *size = min_size;
 895       *old_vect = XRESIZEVAR (char, *old_vect, *size * element_size);
 896     }
 897 }
 898
 899 /* Demangle ada names:
 900    1. Discard final __{DIGIT}+ or ${DIGIT}+
 901    2. Convert other instances of embedded "__" to `.'.
 902    3. Discard leading _ada_.
 903    4. Remove everything after first ___ if it is followed by 'X'.
 904    5. Put symbols that should be suppressed in <...> brackets.
 905    The resulting string is valid until the next call of ada_demangle.  */
 906
 907 static char *
 908 ada_demangle (const char *mangled, int option ATTRIBUTE_UNUSED)
 909 {
 910   int i, j;
 911   int len0;
 912   const char* p;
 913   char *demangled = NULL;
 914   int changed;
 915   size_t demangled_size = 0;
 916
 917   changed = 0;
 918
 919   if (strncmp (mangled, "_ada_", 5) == 0)
 920     {
 921       mangled += 5;
 922       changed = 1;
 923     }
 924
 925   if (mangled[0] == '_' || mangled[0] == '<')
 926     goto Suppress;
 927
 928   p = strstr (mangled, "___");
 929   if (p == NULL)
 930     len0 = strlen (mangled);
 931   else
 932     {
 933       if (p[3] == 'X')
 934         {
 935           len0 = p - mangled;
 936           changed = 1;
 937         }
 938       else
 939         goto Suppress;
 940     }
 941
 942   /* Make demangled big enough for possible expansion by operator name.  */
 943   grow_vect (&demangled,
 944              &demangled_size,  2 * len0 + 1,
 945              sizeof (char));
 946
 947   if (ISDIGIT ((unsigned char) mangled[len0 - 1])) {
 948     for (i = len0 - 2; i >= 0 && ISDIGIT ((unsigned char) mangled[i]); i -= 1)
 949       ;
 950     if (i > 1 && mangled[i] == '_' && mangled[i - 1] == '_')
 951       {
 952         len0 = i - 1;
 953         changed = 1;
 954       }
 955     else if (mangled[i] == '$')
 956       {
 957         len0 = i;
 958         changed = 1;
 959       }
 960   }
 961
 962   for (i = 0, j = 0; i < len0 && ! ISALPHA ((unsigned char)mangled[i]);
 963        i += 1, j += 1)
 964     demangled[j] = mangled[i];
 965
 966   while (i < len0)
 967     {
 968       if (i < len0 - 2 && mangled[i] == '_' && mangled[i + 1] == '_')
 969         {
 970           demangled[j] = '.';
 971           changed = 1;
 972           i += 2; j += 1;
 973         }
 974       else
 975         {
 976           demangled[j] = mangled[i];
 977           i += 1;  j += 1;
 978         }
 979     }
 980   demangled[j] = '\000';
 981
 982   for (i = 0; demangled[i] != '\0'; i += 1)
 983     if (ISUPPER ((unsigned char)demangled[i]) || demangled[i] == ' ')
 984       goto Suppress;
 985
 986   if (! changed)
 987     return NULL;
 988   else
 989     return demangled;
 990
 991  Suppress:
 992   grow_vect (&demangled,
 993              &demangled_size,  strlen (mangled) + 3,
 994              sizeof (char));
 995
 996   if (mangled[0] == '<')
 997      strcpy (demangled, mangled);
 998   else
 999     sprintf (demangled, "<%s>", mangled);
1000
1001   return demangled;
1002 }
1003
1004 /* This function performs most of what cplus_demangle use to do, but
1005    to be able to demangle a name with a B, K or n code, we need to
1006    have a longer term memory of what types have been seen. The original
1007    now initializes and cleans up the squangle code info, while internal
1008    calls go directly to this routine to avoid resetting that info. */
1009
1010 static char *
1011 internal_cplus_demangle (struct work_stuff *work, const char *mangled)
1012 {
1013
1014   string decl;
1015   int success = 0;
1016   char *demangled = NULL;
1017   int s1, s2, s3, s4;
1018   s1 = work->constructor;
1019   s2 = work->destructor;
1020   s3 = work->static_type;
1021   s4 = work->type_quals;
1022   work->constructor = work->destructor = 0;
1023   work->type_quals = TYPE_UNQUALIFIED;
1024   work->dllimported = 0;
1025
1026   if ((mangled != NULL) && (*mangled != '\0'))
1027     {
1028       string_init (&decl);
1029
1030       /* First check to see if gnu style demangling is active and if the
1031          string to be demangled contains a CPLUS_MARKER.  If so, attempt to
1032          recognize one of the gnu special forms rather than looking for a
1033          standard prefix.  In particular, don't worry about whether there
1034          is a "__" string in the mangled string.  Consider "_$_5__foo" for
1035          example.  */
1036
1037       if ((AUTO_DEMANGLING || GNU_DEMANGLING))
1038         {
1039           success = gnu_special (work, &mangled, &decl);
1040         }
1041       if (!success)
1042         {
1043           success = demangle_prefix (work, &mangled, &decl);
1044         }
1045       if (success && (*mangled != '\0'))
1046         {
1047           success = demangle_signature (work, &mangled, &decl);
1048         }
1049       if (work->constructor == 2)
1050         {
1051           string_prepend (&decl, "global constructors keyed to ");
1052           work->constructor = 0;
1053         }
1054       else if (work->destructor == 2)
1055         {
1056           string_prepend (&decl, "global destructors keyed to ");
1057           work->destructor = 0;
1058         }
1059       else if (work->dllimported == 1)
1060         {
1061           string_prepend (&decl, "import stub for ");
1062           work->dllimported = 0;
1063         }
1064       demangled = mop_up (work, &decl, success);
1065     }
1066   work->constructor = s1;
1067   work->destructor = s2;
1068   work->static_type = s3;
1069   work->type_quals = s4;
1070   return demangled;
1071 }
1072
1073
1074 /* Clear out and squangling related storage */
1075 static void
1076 squangle_mop_up (struct work_stuff *work)
1077 {
1078   /* clean up the B and K type mangling types. */
1079   forget_B_and_K_types (work);
1080   if (work -> btypevec != NULL)
1081     {
1082       free ((char *) work -> btypevec);
1083     }
1084   if (work -> ktypevec != NULL)
1085     {
1086       free ((char *) work -> ktypevec);
1087     }
1088 }
1089
1090
1091 /* Copy the work state and storage.  */
1092
1093 static void
1094 work_stuff_copy_to_from (struct work_stuff *to, struct work_stuff *from)
1095 {
1096   int i;
1097
1098   delete_work_stuff (to);
1099
1100   /* Shallow-copy scalars.  */
1101   memcpy (to, from, sizeof (*to));
1102
1103   /* Deep-copy dynamic storage.  */
1104   if (from->typevec_size)
1105     to->typevec = XNEWVEC (char *, from->typevec_size);
1106
1107   for (i = 0; i < from->ntypes; i++)
1108     {
1109       int len = strlen (from->typevec[i]) + 1;
1110
1111       to->typevec[i] = XNEWVEC (char, len);
1112       memcpy (to->typevec[i], from->typevec[i], len);
1113     }
1114
1115   if (from->ksize)
1116     to->ktypevec = XNEWVEC (char *, from->ksize);
1117
1118   for (i = 0; i < from->numk; i++)
1119     {
1120       int len = strlen (from->ktypevec[i]) + 1;
1121
1122       to->ktypevec[i] = XNEWVEC (char, len);
1123       memcpy (to->ktypevec[i], from->ktypevec[i], len);
1124     }
1125
1126   if (from->bsize)
1127     to->btypevec = XNEWVEC (char *, from->bsize);
1128
1129   for (i = 0; i < from->numb; i++)
1130     {
1131       int len = strlen (from->btypevec[i]) + 1;
1132
1133       to->btypevec[i] = XNEWVEC (char , len);
1134       memcpy (to->btypevec[i], from->btypevec[i], len);
1135     }
1136
1137   if (from->ntmpl_args)
1138     to->tmpl_argvec = XNEWVEC (char *, from->ntmpl_args);
1139
1140   for (i = 0; i < from->ntmpl_args; i++)
1141     {
1142       int len = strlen (from->tmpl_argvec[i]) + 1;
1143
1144       to->tmpl_argvec[i] = XNEWVEC (char, len);
1145       memcpy (to->tmpl_argvec[i], from->tmpl_argvec[i], len);
1146     }
1147
1148   if (from->previous_argument)
1149     {
1150       to->previous_argument = XNEW (string);
1151       string_init (to->previous_argument);
1152       string_appends (to->previous_argument, from->previous_argument);
1153     }
1154 }
1155
1156
1157 /* Delete dynamic stuff in work_stuff that is not to be re-used.  */
1158
1159 static void
1160 delete_non_B_K_work_stuff (struct work_stuff *work)
1161 {
1162   /* Discard the remembered types, if any.  */
1163
1164   forget_types (work);
1165   if (work -> typevec != NULL)
1166     {
1167       free ((char *) work -> typevec);
1168       work -> typevec = NULL;
1169       work -> typevec_size = 0;
1170     }
1171   if (work->tmpl_argvec)
1172     {
1173       int i;
1174
1175       for (i = 0; i < work->ntmpl_args; i++)
1176         if (work->tmpl_argvec[i])
1177           free ((char*) work->tmpl_argvec[i]);
1178
1179       free ((char*) work->tmpl_argvec);
1180       work->tmpl_argvec = NULL;
1181     }
1182   if (work->previous_argument)
1183     {
1184       string_delete (work->previous_argument);
1185       free ((char*) work->previous_argument);
1186       work->previous_argument = NULL;
1187     }
1188 }
1189
1190
1191 /* Delete all dynamic storage in work_stuff.  */
1192 static void
1193 delete_work_stuff (struct work_stuff *work)
1194 {
1195   delete_non_B_K_work_stuff (work);
1196   squangle_mop_up (work);
1197 }
1198
1199
1200 /* Clear out any mangled storage */
1201
1202 static char *
1203 mop_up (struct work_stuff *work, string *declp, int success)
1204 {
1205   char *demangled = NULL;
1206
1207   delete_non_B_K_work_stuff (work);
1208
1209   /* If demangling was successful, ensure that the demangled string is null
1210      terminated and return it.  Otherwise, free the demangling decl.  */
1211
1212   if (!success)
1213     {
1214       string_delete (declp);
1215     }
1216   else
1217     {
1218       string_appendn (declp, "", 1);
1219       demangled = declp->b;
1220     }
1221   return (demangled);
1222 }
1223
1224 /*
1225
1226 LOCAL FUNCTION
1227
1228         demangle_signature -- demangle the signature part of a mangled name
1229
1230 SYNOPSIS
1231
1232         static int
1233         demangle_signature (struct work_stuff *work, const char **mangled,
1234                             string *declp);
1235
1236 DESCRIPTION
1237
1238         Consume and demangle the signature portion of the mangled name.
1239
1240         DECLP is the string where demangled output is being built.  At
1241         entry it contains the demangled root name from the mangled name
1242         prefix.  I.E. either a demangled operator name or the root function
1243         name.  In some special cases, it may contain nothing.
1244
1245         *MANGLED points to the current unconsumed location in the mangled
1246         name.  As tokens are consumed and demangling is performed, the
1247         pointer is updated to continuously point at the next token to
1248         be consumed.
1249
1250         Demangling GNU style mangled names is nasty because there is no
1251         explicit token that marks the start of the outermost function
1252         argument list.  */
1253
1254 static int
1255 demangle_signature (struct work_stuff *work,
1256                     const char **mangled, string *declp)
1257 {
1258   int success = 1;
1259   int func_done = 0;
1260   int expect_func = 0;
1261   int expect_return_type = 0;
1262   const char *oldmangled = NULL;
1263   string trawname;
1264   string tname;
1265
1266   while (success && (**mangled != '\0'))
1267     {
1268       switch (**mangled)
1269         {
1270         case 'Q':
1271           oldmangled = *mangled;
1272           success = demangle_qualified (work, mangled, declp, 1, 0);
1273           if (success)
1274             remember_type (work, oldmangled, *mangled - oldmangled);
1275           if (AUTO_DEMANGLING || GNU_DEMANGLING)
1276             expect_func = 1;
1277           oldmangled = NULL;
1278           break;
1279
1280         case 'K':
1281           oldmangled = *mangled;
1282           success = demangle_qualified (work, mangled, declp, 1, 0);
1283           if (AUTO_DEMANGLING || GNU_DEMANGLING)
1284             {
1285               expect_func = 1;
1286             }
1287           oldmangled = NULL;
1288           break;
1289
1290         case 'S':
1291           /* Static member function */
1292           if (oldmangled == NULL)
1293             {
1294               oldmangled = *mangled;
1295             }
1296           (*mangled)++;
1297           work -> static_type = 1;
1298           break;
1299
1300         case 'C':
1301         case 'V':
1302         case 'u':
1303           work->type_quals |= code_for_qualifier (**mangled);
1304
1305           /* a qualified member function */
1306           if (oldmangled == NULL)
1307             oldmangled = *mangled;
1308           (*mangled)++;
1309           break;
1310
1311         case 'L':
1312           /* Local class name follows after "Lnnn_" */
1313           if (HP_DEMANGLING)
1314             {
1315               while (**mangled && (**mangled != '_'))
1316                 (*mangled)++;
1317               if (!**mangled)
1318                 success = 0;
1319               else
1320                 (*mangled)++;
1321             }
1322           else
1323             success = 0;
1324           break;
1325
1326         case '0': case '1': case '2': case '3': case '4':
1327         case '5': case '6': case '7': case '8': case '9':
1328           if (oldmangled == NULL)
1329             {
1330               oldmangled = *mangled;
1331             }
1332           work->temp_start = -1; /* uppermost call to demangle_class */
1333           success = demangle_class (work, mangled, declp);
1334           if (success)
1335             {
1336               remember_type (work, oldmangled, *mangled - oldmangled);
1337             }
1338           if (AUTO_DEMANGLING || GNU_DEMANGLING || EDG_DEMANGLING)
1339             {
1340               /* EDG and others will have the "F", so we let the loop cycle
1341                  if we are looking at one. */
1342               if (**mangled != 'F')
1343                  expect_func = 1;
1344             }
1345           oldmangled = NULL;
1346           break;
1347
1348         case 'B':
1349           {
1350             string s;
1351             success = do_type (work, mangled, &s);
1352             if (success)
1353               {
1354                 string_append (&s, SCOPE_STRING (work));
1355                 string_prepends (declp, &s);
1356                 string_delete (&s);
1357               }
1358             oldmangled = NULL;
1359             expect_func = 1;
1360           }
1361           break;
1362
1363         case 'F':
1364           /* Function */
1365           /* ARM/HP style demangling includes a specific 'F' character after
1366              the class name.  For GNU style, it is just implied.  So we can
1367              safely just consume any 'F' at this point and be compatible
1368              with either style.  */
1369
1370           oldmangled = NULL;
1371           func_done = 1;
1372           (*mangled)++;
1373
1374           /* For lucid/ARM/HP style we have to forget any types we might
1375              have remembered up to this point, since they were not argument
1376              types.  GNU style considers all types seen as available for
1377              back references.  See comment in demangle_args() */
1378
1379           if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
1380             {
1381               forget_types (work);
1382             }
1383           success = demangle_args (work, mangled, declp);
1384           /* After picking off the function args, we expect to either
1385              find the function return type (preceded by an '_') or the
1386              end of the string. */
1387           if (success && (AUTO_DEMANGLING || EDG_DEMANGLING) && **mangled == '_')
1388             {
1389               ++(*mangled);
1390               /* At this level, we do not care about the return type. */
1391               success = do_type (work, mangled, &tname);
1392               string_delete (&tname);
1393             }
1394
1395           break;
1396
1397         case 't':
1398           /* G++ Template */
1399           string_init(&trawname);
1400           string_init(&tname);
1401           if (oldmangled == NULL)
1402             {
1403               oldmangled = *mangled;
1404             }
1405           success = demangle_template (work, mangled, &tname,
1406                                        &trawname, 1, 1);
1407           if (success)
1408             {
1409               remember_type (work, oldmangled, *mangled - oldmangled);
1410             }
1411           string_append (&tname, SCOPE_STRING (work));
1412
1413           string_prepends(declp, &tname);
1414           if (work -> destructor & 1)
1415             {
1416               string_prepend (&trawname, "~");
1417               string_appends (declp, &trawname);
1418               work->destructor -= 1;
1419             }
1420           if ((work->constructor & 1) || (work->destructor & 1))
1421             {
1422               string_appends (declp, &trawname);
1423               work->constructor -= 1;
1424             }
1425           string_delete(&trawname);
1426           string_delete(&tname);
1427           oldmangled = NULL;
1428           expect_func = 1;
1429           break;
1430
1431         case '_':
1432           if ((AUTO_DEMANGLING || GNU_DEMANGLING) && expect_return_type)
1433             {
1434               /* Read the return type. */
1435               string return_type;
1436
1437               (*mangled)++;
1438               success = do_type (work, mangled, &return_type);
1439               APPEND_BLANK (&return_type);
1440
1441               string_prepends (declp, &return_type);
1442               string_delete (&return_type);
1443               break;
1444             }
1445           else
1446             /* At the outermost level, we cannot have a return type specified,
1447                so if we run into another '_' at this point we are dealing with
1448                a mangled name that is either bogus, or has been mangled by
1449                some algorithm we don't know how to deal with.  So just
1450                reject the entire demangling.  */
1451             /* However, "_nnn" is an expected suffix for alternate entry point
1452                numbered nnn for a function, with HP aCC, so skip over that
1453                without reporting failure. pai/1997-09-04 */
1454             if (HP_DEMANGLING)
1455               {
1456                 (*mangled)++;
1457                 while (**mangled && ISDIGIT ((unsigned char)**mangled))
1458                   (*mangled)++;
1459               }
1460             else
1461               success = 0;
1462           break;
1463
1464         case 'H':
1465           if (AUTO_DEMANGLING || GNU_DEMANGLING)
1466             {
1467               /* A G++ template function.  Read the template arguments. */
1468               success = demangle_template (work, mangled, declp, 0, 0,
1469                                            0);
1470               if (!(work->constructor & 1))
1471                 expect_return_type = 1;
1472               (*mangled)++;
1473               break;
1474             }
1475           else
1476             /* fall through */
1477             {;}
1478
1479         default:
1480           if (AUTO_DEMANGLING || GNU_DEMANGLING)
1481             {
1482               /* Assume we have stumbled onto the first outermost function
1483                  argument token, and start processing args.  */
1484               func_done = 1;
1485               success = demangle_args (work, mangled, declp);
1486             }
1487           else
1488             {
1489               /* Non-GNU demanglers use a specific token to mark the start
1490                  of the outermost function argument tokens.  Typically 'F',
1491                  for ARM/HP-demangling, for example.  So if we find something
1492                  we are not prepared for, it must be an error.  */
1493               success = 0;
1494             }
1495           break;
1496         }
1497       /*
1498         if (AUTO_DEMANGLING || GNU_DEMANGLING)
1499         */
1500       {
1501         if (success && expect_func)
1502           {
1503             func_done = 1;
1504               if (LUCID_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING)
1505                 {
1506                   forget_types (work);
1507                 }
1508             success = demangle_args (work, mangled, declp);
1509             /* Since template include the mangling of their return types,
1510                we must set expect_func to 0 so that we don't try do
1511                demangle more arguments the next time we get here.  */
1512             expect_func = 0;
1513           }
1514       }
1515     }
1516   if (success && !func_done)
1517     {
1518       if (AUTO_DEMANGLING || GNU_DEMANGLING)
1519         {
1520           /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
1521              bar__3fooi is 'foo::bar(int)'.  We get here when we find the
1522              first case, and need to ensure that the '(void)' gets added to
1523              the current declp.  Note that with ARM/HP, the first case
1524              represents the name of a static data member 'foo::bar',
1525              which is in the current declp, so we leave it alone.  */
1526           success = demangle_args (work, mangled, declp);
1527         }
1528     }
1529   if (success && PRINT_ARG_TYPES)
1530     {
1531       if (work->static_type)
1532         string_append (declp, " static");
1533       if (work->type_quals != TYPE_UNQUALIFIED)
1534         {
1535           APPEND_BLANK (declp);
1536           string_append (declp, qualifier_string (work->type_quals));
1537         }
1538     }
1539
1540   return (success);
1541 }
1542
1543 #if 0
1544
1545 static int
1546 demangle_method_args (struct work_stuff *work, const char **mangled,
1547                       string *declp)
1548 {
1549   int success = 0;
1550
1551   if (work -> static_type)
1552     {
1553       string_append (declp, *mangled + 1);
1554       *mangled += strlen (*mangled);
1555       success = 1;
1556     }
1557   else
1558     {
1559       success = demangle_args (work, mangled, declp);
1560     }
1561   return (success);
1562 }
1563
1564 #endif
1565
1566 static int
1567 demangle_template_template_parm (struct work_stuff *work,
1568                                  const char **mangled, string *tname)
1569 {
1570   int i;
1571   int r;
1572   int need_comma = 0;
1573   int success = 1;
1574   string temp;
1575
1576   string_append (tname, "template <");
1577   /* get size of template parameter list */
1578   if (get_count (mangled, &r))
1579     {
1580       for (i = 0; i < r; i++)
1581         {
1582           if (need_comma)
1583             {
1584               string_append (tname, ", ");
1585             }
1586
1587             /* Z for type parameters */
1588             if (**mangled == 'Z')
1589               {
1590                 (*mangled)++;
1591                 string_append (tname, "class");
1592               }
1593               /* z for template parameters */
1594             else if (**mangled == 'z')
1595               {
1596                 (*mangled)++;
1597                 success =
1598                   demangle_template_template_parm (work, mangled, tname);
1599                 if (!success)
1600                   {
1601                     break;
1602                   }
1603               }
1604             else
1605               {
1606                 /* temp is initialized in do_type */
1607                 success = do_type (work, mangled, &temp);
1608                 if (success)
1609                   {
1610                     string_appends (tname, &temp);
1611                   }
1612                 string_delete(&temp);
1613                 if (!success)
1614                   {
1615                     break;
1616                   }
1617               }
1618           need_comma = 1;
1619         }
1620
1621     }
1622   if (tname->p[-1] == '>')
1623     string_append (tname, " ");
1624   string_append (tname, "> class");
1625   return (success);
1626 }
1627
1628 static int
1629 demangle_expression (struct work_stuff *work, const char **mangled,
1630                      string *s, type_kind_t tk)
1631 {
1632   int need_operator = 0;
1633   int success;
1634
1635   success = 1;
1636   string_appendn (s, "(", 1);
1637   (*mangled)++;
1638   while (success && **mangled != 'W' && **mangled != '\0')
1639     {
1640       if (need_operator)
1641         {
1642           size_t i;
1643           size_t len;
1644
1645           success = 0;
1646
1647           len = strlen (*mangled);
1648
1649           for (i = 0; i < ARRAY_SIZE (optable); ++i)
1650             {
1651               size_t l = strlen (optable[i].in);
1652
1653               if (l <= len
1654                   && memcmp (optable[i].in, *mangled, l) == 0)
1655                 {
1656                   string_appendn (s, " ", 1);
1657                   string_append (s, optable[i].out);
1658                   string_appendn (s, " ", 1);
1659                   success = 1;
1660                   (*mangled) += l;
1661                   break;
1662                 }
1663             }
1664
1665           if (!success)
1666             break;
1667         }
1668       else
1669         need_operator = 1;
1670
1671       success = demangle_template_value_parm (work, mangled, s, tk);
1672     }
1673
1674   if (**mangled != 'W')
1675     success = 0;
1676   else
1677     {
1678       string_appendn (s, ")", 1);
1679       (*mangled)++;
1680     }
1681
1682   return success;
1683 }
1684
1685 static int
1686 demangle_integral_value (struct work_stuff *work,
1687                          const char **mangled, string *s)
1688 {
1689   int success;
1690
1691   if (**mangled == 'E')
1692     success = demangle_expression (work, mangled, s, tk_integral);
1693   else if (**mangled == 'Q' || **mangled == 'K')
1694     success = demangle_qualified (work, mangled, s, 0, 1);
1695   else
1696     {
1697       int value;
1698
1699       /* By default, we let the number decide whether we shall consume an
1700          underscore.  */
1701       int multidigit_without_leading_underscore = 0;
1702       int leave_following_underscore = 0;
1703
1704       success = 0;
1705
1706       if (**mangled == '_')
1707         {
1708           if (mangled[0][1] == 'm')
1709             {
1710               /* Since consume_count_with_underscores does not handle the
1711                  `m'-prefix we must do it here, using consume_count and
1712                  adjusting underscores: we have to consume the underscore
1713                  matching the prepended one.  */
1714               multidigit_without_leading_underscore = 1;
1715               string_appendn (s, "-", 1);
1716               (*mangled) += 2;
1717             }
1718           else
1719             {
1720               /* Do not consume a following underscore;
1721                  consume_count_with_underscores will consume what
1722                  should be consumed.  */
1723               leave_following_underscore = 1;
1724             }
1725         }
1726       else
1727         {
1728           /* Negative numbers are indicated with a leading `m'.  */
1729           if (**mangled == 'm')
1730           {
1731             string_appendn (s, "-", 1);
1732             (*mangled)++;
1733           }
1734           /* Since consume_count_with_underscores does not handle
1735              multi-digit numbers that do not start with an underscore,
1736              and this number can be an integer template parameter,
1737              we have to call consume_count. */
1738           multidigit_without_leading_underscore = 1;
1739           /* These multi-digit numbers never end on an underscore,
1740              so if there is one then don't eat it. */
1741           leave_following_underscore = 1;
1742         }
1743
1744       /* We must call consume_count if we expect to remove a trailing
1745          underscore, since consume_count_with_underscores expects
1746          the leading underscore (that we consumed) if it is to handle
1747          multi-digit numbers.  */
1748       if (multidigit_without_leading_underscore)
1749         value = consume_count (mangled);
1750       else
1751         value = consume_count_with_underscores (mangled);
1752
1753       if (value != -1)
1754         {
1755           char buf[INTBUF_SIZE];
1756           sprintf (buf, "%d", value);
1757           string_append (s, buf);
1758
1759           /* Numbers not otherwise delimited, might have an underscore
1760              appended as a delimeter, which we should skip.
1761
1762              ??? This used to always remove a following underscore, which
1763              is wrong.  If other (arbitrary) cases are followed by an
1764              underscore, we need to do something more radical.  */
1765
1766           if ((value > 9 || multidigit_without_leading_underscore)
1767               && ! leave_following_underscore
1768               && **mangled == '_')
1769             (*mangled)++;
1770
1771           /* All is well.  */
1772           success = 1;
1773         }
1774       }
1775
1776   return success;
1777 }
1778
1779 /* Demangle the real value in MANGLED.  */
1780
1781 static int
1782 demangle_real_value (struct work_stuff *work,
1783                      const char **mangled, string *s)
1784 {
1785   if (**mangled == 'E')
1786     return demangle_expression (work, mangled, s, tk_real);
1787
1788   if (**mangled == 'm')
1789     {
1790       string_appendn (s, "-", 1);
1791       (*mangled)++;
1792     }
1793   while (ISDIGIT ((unsigned char)**mangled))
1794     {
1795       string_appendn (s, *mangled, 1);
1796       (*mangled)++;
1797     }
1798   if (**mangled == '.') /* fraction */
1799     {
1800       string_appendn (s, ".", 1);
1801       (*mangled)++;
1802       while (ISDIGIT ((unsigned char)**mangled))
1803         {
1804           string_appendn (s, *mangled, 1);
1805           (*mangled)++;
1806         }
1807     }
1808   if (**mangled == 'e') /* exponent */
1809     {
1810       string_appendn (s, "e", 1);
1811       (*mangled)++;
1812       while (ISDIGIT ((unsigned char)**mangled))
1813         {
1814           string_appendn (s, *mangled, 1);
1815           (*mangled)++;
1816         }
1817     }
1818
1819   return 1;
1820 }
1821
1822 static int
1823 demangle_template_value_parm (struct work_stuff *work, const char **mangled,
1824                               string *s, type_kind_t tk)
1825 {
1826   int success = 1;
1827
1828   if (**mangled == 'Y')
1829     {
1830       /* The next argument is a template parameter. */
1831       int idx;
1832
1833       (*mangled)++;
1834       idx = consume_count_with_underscores (mangled);
1835       if (idx == -1
1836           || (work->tmpl_argvec && idx >= work->ntmpl_args)
1837           || consume_count_with_underscores (mangled) == -1)
1838         return -1;
1839       if (work->tmpl_argvec)
1840         string_append (s, work->tmpl_argvec[idx]);
1841       else
1842         string_append_template_idx (s, idx);
1843     }
1844   else if (tk == tk_integral)
1845     success = demangle_integral_value (work, mangled, s);
1846   else if (tk == tk_char)
1847     {
1848       char tmp[2];
1849       int val;
1850       if (**mangled == 'm')
1851         {
1852           string_appendn (s, "-", 1);
1853           (*mangled)++;
1854         }
1855       string_appendn (s, "'", 1);
1856       val = consume_count(mangled);
1857       if (val <= 0)
1858         success = 0;
1859       else
1860         {
1861           tmp[0] = (char)val;
1862           tmp[1] = '\0';
1863           string_appendn (s, &tmp[0], 1);
1864           string_appendn (s, "'", 1);
1865         }
1866     }
1867   else if (tk == tk_bool)
1868     {
1869       int val = consume_count (mangled);
1870       if (val == 0)
1871         string_appendn (s, "false", 5);
1872       else if (val == 1)
1873         string_appendn (s, "true", 4);
1874       else
1875         success = 0;
1876     }
1877   else if (tk == tk_real)
1878     success = demangle_real_value (work, mangled, s);
1879   else if (tk == tk_pointer || tk == tk_reference)
1880     {
1881       if (**mangled == 'Q')
1882         success = demangle_qualified (work, mangled, s,
1883                                       /*isfuncname=*/0,
1884                                       /*append=*/1);
1885       else
1886         {
1887           int symbol_len  = consume_count (mangled);
1888           if (symbol_len == -1)
1889             return -1;
1890           if (symbol_len == 0)
1891             string_appendn (s, "0", 1);
1892           else
1893             {
1894               char *p = XNEWVEC (char, symbol_len + 1), *q;
1895               strncpy (p, *mangled, symbol_len);
1896               p [symbol_len] = '\0';
1897               /* We use cplus_demangle here, rather than
1898                  internal_cplus_demangle, because the name of the entity
1899                  mangled here does not make use of any of the squangling
1900                  or type-code information we have built up thus far; it is
1901                  mangled independently.  */
1902               q = cplus_demangle (p, work->options);
1903               if (tk == tk_pointer)
1904                 string_appendn (s, "&", 1);
1905               /* FIXME: Pointer-to-member constants should get a
1906                  qualifying class name here.  */
1907               if (q)
1908                 {
1909                   string_append (s, q);
1910                   free (q);
1911                 }
1912               else
1913                 string_append (s, p);
1914               free (p);
1915             }
1916           *mangled += symbol_len;
1917         }
1918     }
1919
1920   return success;
1921 }
1922
1923 /* Demangle the template name in MANGLED.  The full name of the
1924    template (e.g., S<int>) is placed in TNAME.  The name without the
1925    template parameters (e.g. S) is placed in TRAWNAME if TRAWNAME is
1926    non-NULL.  If IS_TYPE is nonzero, this template is a type template,
1927    not a function template.  If both IS_TYPE and REMEMBER are nonzero,
1928    the template is remembered in the list of back-referenceable
1929    types.  */
1930
1931 static int
1932 demangle_template (struct work_stuff *work, const char **mangled,
1933                    string *tname, string *trawname,
1934                    int is_type, int remember)
1935 {
1936   int i;
1937   int r;
1938   int need_comma = 0;
1939   int success = 0;
1940   int is_java_array = 0;
1941   string temp;
1942
1943   (*mangled)++;
1944   if (is_type)
1945     {
1946       /* get template name */
1947       if (**mangled == 'z')
1948         {
1949           int idx;
1950           (*mangled)++;
1951           (*mangled)++;
1952
1953           idx = consume_count_with_underscores (mangled);
1954           if (idx == -1
1955               || (work->tmpl_argvec && idx >= work->ntmpl_args)
1956               || consume_count_with_underscores (mangled) == -1)
1957             return (0);
1958
1959           if (work->tmpl_argvec)
1960             {
1961               string_append (tname, work->tmpl_argvec[idx]);
1962               if (trawname)
1963                 string_append (trawname, work->tmpl_argvec[idx]);
1964             }
1965           else
1966             {
1967               string_append_template_idx (tname, idx);
1968               if (trawname)
1969                 string_append_template_idx (trawname, idx);
1970             }
1971         }
1972       else
1973         {
1974           if ((r = consume_count (mangled)) <= 0
1975               || (int) strlen (*mangled) < r)
1976             {
1977               return (0);
1978             }
1979           is_java_array = (work -> options & DMGL_JAVA)
1980             && strncmp (*mangled, "JArray1Z", 8) == 0;
1981           if (! is_java_array)
1982             {
1983               string_appendn (tname, *mangled, r);
1984             }
1985           if (trawname)
1986             string_appendn (trawname, *mangled, r);
1987           *mangled += r;
1988         }
1989     }
1990   if (!is_java_array)
1991     string_append (tname, "<");
1992   /* get size of template parameter list */
1993   if (!get_count (mangled, &r))
1994     {
1995       return (0);
1996     }
1997   if (!is_type)
1998     {
1999       /* Create an array for saving the template argument values. */
2000       work->tmpl_argvec = XNEWVEC (char *, r);
2001       work->ntmpl_args = r;
2002       for (i = 0; i < r; i++)
2003         work->tmpl_argvec[i] = 0;
2004     }
2005   for (i = 0; i < r; i++)
2006     {
2007       if (need_comma)
2008         {
2009           string_append (tname, ", ");
2010         }
2011       /* Z for type parameters */
2012       if (**mangled == 'Z')
2013         {
2014           (*mangled)++;
2015           /* temp is initialized in do_type */
2016           success = do_type (work, mangled, &temp);
2017           if (success)
2018             {
2019               string_appends (tname, &temp);
2020
2021               if (!is_type)
2022                 {
2023                   /* Save the template argument. */
2024                   int len = temp.p - temp.b;
2025                   work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
2026                   memcpy (work->tmpl_argvec[i], temp.b, len);
2027                   work->tmpl_argvec[i][len] = '\0';
2028                 }
2029             }
2030           string_delete(&temp);
2031           if (!success)
2032             {
2033               break;
2034             }
2035         }
2036       /* z for template parameters */
2037       else if (**mangled == 'z')
2038         {
2039           int r2;
2040           (*mangled)++;
2041           success = demangle_template_template_parm (work, mangled, tname);
2042
2043           if (success
2044               && (r2 = consume_count (mangled)) > 0
2045               && (int) strlen (*mangled) >= r2)
2046             {
2047               string_append (tname, " ");
2048               string_appendn (tname, *mangled, r2);
2049               if (!is_type)
2050                 {
2051                   /* Save the template argument. */
2052                   int len = r2;
2053                   work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
2054                   memcpy (work->tmpl_argvec[i], *mangled, len);
2055                   work->tmpl_argvec[i][len] = '\0';
2056                 }
2057               *mangled += r2;
2058             }
2059           if (!success)
2060             {
2061               break;
2062             }
2063         }
2064       else
2065         {
2066           string  param;
2067           string* s;
2068
2069           /* otherwise, value parameter */
2070
2071           /* temp is initialized in do_type */
2072           success = do_type (work, mangled, &temp);
2073           string_delete(&temp);
2074           if (!success)
2075             break;
2076
2077           if (!is_type)
2078             {
2079               s = &param;
2080               string_init (s);
2081             }
2082           else
2083             s = tname;
2084
2085           success = demangle_template_value_parm (work, mangled, s,
2086                                                   (type_kind_t) success);
2087
2088           if (!success)
2089             {
2090               if (!is_type)
2091                 string_delete (s);
2092               success = 0;
2093               break;
2094             }
2095
2096           if (!is_type)
2097             {
2098               int len = s->p - s->b;
2099               work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
2100               memcpy (work->tmpl_argvec[i], s->b, len);
2101               work->tmpl_argvec[i][len] = '\0';
2102
2103               string_appends (tname, s);
2104               string_delete (s);
2105             }
2106         }
2107       need_comma = 1;
2108     }
2109   if (is_java_array)
2110     {
2111       string_append (tname, "[]");
2112     }
2113   else
2114     {
2115       if (tname->p[-1] == '>')
2116         string_append (tname, " ");
2117       string_append (tname, ">");
2118     }
2119
2120   if (is_type && remember)
2121     {
2122       const int bindex = register_Btype (work);
2123       remember_Btype (work, tname->b, LEN_STRING (tname), bindex);
2124     }
2125
2126   /*
2127     if (work -> static_type)
2128     {
2129     string_append (declp, *mangled + 1);
2130     *mangled += strlen (*mangled);
2131     success = 1;
2132     }
2133     else
2134     {
2135     success = demangle_args (work, mangled, declp);
2136     }
2137     }
2138     */
2139   return (success);
2140 }
2141
2142 static int
2143 arm_pt (struct work_stuff *work, const char *mangled,
2144         int n, const char **anchor, const char **args)
2145 {
2146   /* Check if ARM template with "__pt__" in it ("parameterized type") */
2147   /* Allow HP also here, because HP's cfront compiler follows ARM to some extent */
2148   if ((ARM_DEMANGLING || HP_DEMANGLING) && (*anchor = strstr (mangled, "__pt__")))
2149     {
2150       int len;
2151       *args = *anchor + 6;
2152       len = consume_count (args);
2153       if (len == -1)
2154         return 0;
2155       if (*args + len == mangled + n && **args == '_')
2156         {
2157           ++*args;
2158           return 1;
2159         }
2160     }
2161   if (AUTO_DEMANGLING || EDG_DEMANGLING)
2162     {
2163       if ((*anchor = strstr (mangled, "__tm__"))
2164           || (*anchor = strstr (mangled, "__ps__"))
2165           || (*anchor = strstr (mangled, "__pt__")))
2166         {
2167           int len;
2168           *args = *anchor + 6;
2169           len = consume_count (args);
2170           if (len == -1)
2171             return 0;
2172           if (*args + len == mangled + n && **args == '_')
2173             {
2174               ++*args;
2175               return 1;
2176             }
2177         }
2178       else if ((*anchor = strstr (mangled, "__S")))
2179         {
2180           int len;
2181           *args = *anchor + 3;
2182           len = consume_count (args);
2183           if (len == -1)
2184             return 0;
2185           if (*args + len == mangled + n && **args == '_')
2186             {
2187               ++*args;
2188               return 1;
2189             }
2190         }
2191     }
2192
2193   return 0;
2194 }
2195
2196 static void
2197 demangle_arm_hp_template (struct work_stuff *work, const char **mangled,
2198                           int n, string *declp)
2199 {
2200   const char *p;
2201   const char *args;
2202   const char *e = *mangled + n;
2203   string arg;
2204
2205   /* Check for HP aCC template spec: classXt1t2 where t1, t2 are
2206      template args */
2207   if (HP_DEMANGLING && ((*mangled)[n] == 'X'))
2208     {
2209       char *start_spec_args = NULL;
2210       int hold_options;
2211
2212       /* First check for and omit template specialization pseudo-arguments,
2213          such as in "Spec<#1,#1.*>" */
2214       start_spec_args = strchr (*mangled, '<');
2215       if (start_spec_args && (start_spec_args - *mangled < n))
2216         string_appendn (declp, *mangled, start_spec_args - *mangled);
2217       else
2218         string_appendn (declp, *mangled, n);
2219       (*mangled) += n + 1;
2220       string_init (&arg);
2221       if (work->temp_start == -1) /* non-recursive call */
2222         work->temp_start = declp->p - declp->b;
2223
2224       /* We want to unconditionally demangle parameter types in
2225          template parameters.  */
2226       hold_options = work->options;
2227       work->options |= DMGL_PARAMS;
2228
2229       string_append (declp, "<");
2230       while (1)
2231         {
2232           string_delete (&arg);
2233           switch (**mangled)
2234             {
2235               case 'T':
2236                 /* 'T' signals a type parameter */
2237                 (*mangled)++;
2238                 if (!do_type (work, mangled, &arg))
2239                   goto hpacc_template_args_done;
2240                 break;
2241
2242               case 'U':
2243               case 'S':
2244                 /* 'U' or 'S' signals an integral value */
2245                 if (!do_hpacc_template_const_value (work, mangled, &arg))
2246                   goto hpacc_template_args_done;
2247                 break;
2248
2249               case 'A':
2250                 /* 'A' signals a named constant expression (literal) */
2251                 if (!do_hpacc_template_literal (work, mangled, &arg))
2252                   goto hpacc_template_args_done;
2253                 break;
2254
2255               default:
2256                 /* Today, 1997-09-03, we have only the above types
2257                    of template parameters */
2258                 /* FIXME: maybe this should fail and return null */
2259                 goto hpacc_template_args_done;
2260             }
2261           string_appends (declp, &arg);
2262          /* Check if we're at the end of template args.
2263              0 if at end of static member of template class,
2264              _ if done with template args for a function */
2265           if ((**mangled == '\000') || (**mangled == '_'))
2266             break;
2267           else
2268             string_append (declp, ",");
2269         }
2270     hpacc_template_args_done:
2271       string_append (declp, ">");
2272       string_delete (&arg);
2273       if (**mangled == '_')
2274         (*mangled)++;
2275       work->options = hold_options;
2276       return;
2277     }
2278   /* ARM template? (Also handles HP cfront extensions) */
2279   else if (arm_pt (work, *mangled, n, &p, &args))
2280     {
2281       int hold_options;
2282       string type_str;
2283
2284       string_init (&arg);
2285       string_appendn (declp, *mangled, p - *mangled);
2286       if (work->temp_start == -1)  /* non-recursive call */
2287         work->temp_start = declp->p - declp->b;
2288
2289       /* We want to unconditionally demangle parameter types in
2290          template parameters.  */
2291       hold_options = work->options;
2292       work->options |= DMGL_PARAMS;
2293
2294       string_append (declp, "<");
2295       /* should do error checking here */
2296       while (args < e) {
2297         string_delete (&arg);
2298
2299         /* Check for type or literal here */
2300         switch (*args)
2301           {
2302             /* HP cfront extensions to ARM for template args */
2303             /* spec: Xt1Lv1 where t1 is a type, v1 is a literal value */
2304             /* FIXME: We handle only numeric literals for HP cfront */
2305           case 'X':
2306             /* A typed constant value follows */
2307             args++;
2308             if (!do_type (work, &args, &type_str))
2309               goto cfront_template_args_done;
2310             string_append (&arg, "(");
2311             string_appends (&arg, &type_str);
2312             string_delete (&type_str);
2313             string_append (&arg, ")");
2314             if (*args != 'L')
2315               goto cfront_template_args_done;
2316             args++;
2317             /* Now snarf a literal value following 'L' */
2318             if (!snarf_numeric_literal (&args, &arg))
2319               goto cfront_template_args_done;
2320             break;
2321
2322           case 'L':
2323             /* Snarf a literal following 'L' */
2324             args++;
2325             if (!snarf_numeric_literal (&args, &arg))
2326               goto cfront_template_args_done;
2327             break;
2328           default:
2329             /* Not handling other HP cfront stuff */
2330             {
2331               const char* old_args = args;
2332               if (!do_type (work, &args, &arg))
2333                 goto cfront_template_args_done;
2334
2335               /* Fail if we didn't make any progress: prevent infinite loop. */
2336               if (args == old_args)
2337                 {
2338                   work->options = hold_options;
2339                   return;
2340                 }
2341             }
2342           }
2343         string_appends (declp, &arg);
2344         string_append (declp, ",");
2345       }
2346     cfront_template_args_done:
2347       string_delete (&arg);
2348       if (args >= e)
2349         --declp->p; /* remove extra comma */
2350       string_append (declp, ">");
2351       work->options = hold_options;
2352     }
2353   else if (n>10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
2354            && (*mangled)[9] == 'N'
2355            && (*mangled)[8] == (*mangled)[10]
2356            && strchr (cplus_markers, (*mangled)[8]))
2357     {
2358       /* A member of the anonymous namespace.  */
2359       string_append (declp, "{anonymous}");
2360     }
2361   else
2362     {
2363       if (work->temp_start == -1) /* non-recursive call only */
2364         work->temp_start = 0;     /* disable in recursive calls */
2365       string_appendn (declp, *mangled, n);
2366     }
2367   *mangled += n;
2368 }
2369
2370 /* Extract a class name, possibly a template with arguments, from the
2371    mangled string; qualifiers, local class indicators, etc. have
2372    already been dealt with */
2373
2374 static int
2375 demangle_class_name (struct work_stuff *work, const char **mangled,
2376                      string *declp)
2377 {
2378   int n;
2379   int success = 0;
2380
2381   n = consume_count (mangled);
2382   if (n == -1)
2383     return 0;
2384   if ((int) strlen (*mangled) >= n)
2385     {
2386       demangle_arm_hp_template (work, mangled, n, declp);
2387       success = 1;
2388     }
2389
2390   return (success);
2391 }
2392
2393 /*
2394
2395 LOCAL FUNCTION
2396
2397         demangle_class -- demangle a mangled class sequence
2398
2399 SYNOPSIS
2400
2401         static int
2402         demangle_class (struct work_stuff *work, const char **mangled,
2403                         strint *declp)
2404
2405 DESCRIPTION
2406
2407         DECLP points to the buffer into which demangling is being done.
2408
2409         *MANGLED points to the current token to be demangled.  On input,
2410         it points to a mangled class (I.E. "3foo", "13verylongclass", etc.)
2411         On exit, it points to the next token after the mangled class on
2412         success, or the first unconsumed token on failure.
2413
2414         If the CONSTRUCTOR or DESTRUCTOR flags are set in WORK, then
2415         we are demangling a constructor or destructor.  In this case
2416         we prepend "class::class" or "class::~class" to DECLP.
2417
2418         Otherwise, we prepend "class::" to the current DECLP.
2419
2420         Reset the constructor/destructor flags once they have been
2421         "consumed".  This allows demangle_class to be called later during
2422         the same demangling, to do normal class demangling.
2423
2424         Returns 1 if demangling is successful, 0 otherwise.
2425
2426 */
2427
2428 static int
2429 demangle_class (struct work_stuff *work, const char **mangled, string *declp)
2430 {
2431   int success = 0;
2432   int btype;
2433   string class_name;
2434   char *save_class_name_end = 0;
2435
2436   string_init (&class_name);
2437   btype = register_Btype (work);
2438   if (demangle_class_name (work, mangled, &class_name))
2439     {
2440       save_class_name_end = class_name.p;
2441       if ((work->constructor & 1) || (work->destructor & 1))
2442         {
2443           /* adjust so we don't include template args */
2444           if (work->temp_start && (work->temp_start != -1))
2445             {
2446               class_name.p = class_name.b + work->temp_start;
2447             }
2448           string_prepends (declp, &class_name);
2449           if (work -> destructor & 1)
2450             {
2451               string_prepend (declp, "~");
2452               work -> destructor -= 1;
2453             }
2454           else
2455             {
2456               work -> constructor -= 1;
2457             }
2458         }
2459       class_name.p = save_class_name_end;
2460       remember_Ktype (work, class_name.b, LEN_STRING(&class_name));
2461       remember_Btype (work, class_name.b, LEN_STRING(&class_name), btype);
2462       string_prepend (declp, SCOPE_STRING (work));
2463       string_prepends (declp, &class_name);
2464       success = 1;
2465     }
2466   string_delete (&class_name);
2467   return (success);
2468 }
2469
2470
2471 /* Called when there's a "__" in the mangled name, with `scan' pointing to
2472    the rightmost guess.
2473
2474    Find the correct "__"-sequence where the function name ends and the
2475    signature starts, which is ambiguous with GNU mangling.
2476    Call demangle_signature here, so we can make sure we found the right
2477    one; *mangled will be consumed so caller will not make further calls to
2478    demangle_signature.  */
2479
2480 static int
2481 iterate_demangle_function (struct work_stuff *work, const char **mangled,
2482                            string *declp, const char *scan)
2483 {
2484   const char *mangle_init = *mangled;
2485   int success = 0;
2486   string decl_init;
2487   struct work_stuff work_init;
2488
2489   if (*(scan + 2) == '\0')
2490     return 0;
2491
2492   /* Do not iterate for some demangling modes, or if there's only one
2493      "__"-sequence.  This is the normal case.  */
2494   if (ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING
2495       || strstr (scan + 2, "__") == NULL)
2496     return demangle_function_name (work, mangled, declp, scan);
2497
2498   /* Save state so we can restart if the guess at the correct "__" was
2499      wrong.  */
2500   string_init (&decl_init);
2501   string_appends (&decl_init, declp);
2502   memset (&work_init, 0, sizeof work_init);
2503   work_stuff_copy_to_from (&work_init, work);
2504
2505   /* Iterate over occurrences of __, allowing names and types to have a
2506      "__" sequence in them.  We must start with the first (not the last)
2507      occurrence, since "__" most often occur between independent mangled
2508      parts, hence starting at the last occurence inside a signature
2509      might get us a "successful" demangling of the signature.  */
2510
2511   while (scan[2])
2512     {
2513       if (demangle_function_name (work, mangled, declp, scan))
2514         {
2515           success = demangle_signature (work, mangled, declp);
2516           if (success)
2517             break;
2518         }
2519
2520       /* Reset demangle state for the next round.  */
2521       *mangled = mangle_init;
2522       string_clear (declp);
2523       string_appends (declp, &decl_init);
2524       work_stuff_copy_to_from (work, &work_init);
2525
2526       /* Leave this underscore-sequence.  */
2527       scan += 2;
2528
2529       /* Scan for the next "__" sequence.  */
2530       while (*scan && (scan[0] != '_' || scan[1] != '_'))
2531         scan++;
2532
2533       /* Move to last "__" in this sequence.  */
2534       while (*scan && *scan == '_')
2535         scan++;
2536       scan -= 2;
2537     }
2538
2539   /* Delete saved state.  */
2540   delete_work_stuff (&work_init);
2541   string_delete (&decl_init);
2542
2543   return success;
2544 }
2545
2546 /*
2547
2548 LOCAL FUNCTION
2549
2550         demangle_prefix -- consume the mangled name prefix and find signature
2551
2552 SYNOPSIS
2553
2554         static int
2555         demangle_prefix (struct work_stuff *work, const char **mangled,
2556                          string *declp);
2557
2558 DESCRIPTION
2559
2560         Consume and demangle the prefix of the mangled name.
2561         While processing the function name root, arrange to call
2562         demangle_signature if the root is ambiguous.
2563
2564         DECLP points to the string buffer into which demangled output is
2565         placed.  On entry, the buffer is empty.  On exit it contains
2566         the root function name, the demangled operator name, or in some
2567         special cases either nothing or the completely demangled result.
2568
2569         MANGLED points to the current pointer into the mangled name.  As each
2570         token of the mangled name is consumed, it is updated.  Upon entry
2571         the current mangled name pointer points to the first character of
2572         the mangled name.  Upon exit, it should point to the first character
2573         of the signature if demangling was successful, or to the first
2574         unconsumed character if demangling of the prefix was unsuccessful.
2575
2576         Returns 1 on success, 0 otherwise.
2577  */
2578
2579 static int
2580 demangle_prefix (struct work_stuff *work, const char **mangled,
2581                  string *declp)
2582 {
2583   int success = 1;
2584   const char *scan;
2585   int i;
2586
2587   if (strlen(*mangled) > 6
2588       && (strncmp(*mangled, "_imp__", 6) == 0
2589           || strncmp(*mangled, "__imp_", 6) == 0))
2590     {
2591       /* it's a symbol imported from a PE dynamic library. Check for both
2592          new style prefix _imp__ and legacy __imp_ used by older versions
2593          of dlltool. */
2594       (*mangled) += 6;
2595       work->dllimported = 1;
2596     }
2597   else if (strlen(*mangled) >= 11 && strncmp(*mangled, "_GLOBAL_", 8) == 0)
2598     {
2599       char *marker = strchr (cplus_markers, (*mangled)[8]);
2600       if (marker != NULL && *marker == (*mangled)[10])
2601         {
2602           if ((*mangled)[9] == 'D')
2603             {
2604               /* it's a GNU global destructor to be executed at program exit */
2605               (*mangled) += 11;
2606               work->destructor = 2;
2607               if (gnu_special (work, mangled, declp))
2608                 return success;
2609             }
2610           else if ((*mangled)[9] == 'I')
2611             {
2612               /* it's a GNU global constructor to be executed at program init */
2613               (*mangled) += 11;
2614               work->constructor = 2;
2615               if (gnu_special (work, mangled, declp))
2616                 return success;
2617             }
2618         }
2619     }
2620   else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__std__", 7) == 0)
2621     {
2622       /* it's a ARM global destructor to be executed at program exit */
2623       (*mangled) += 7;
2624       work->destructor = 2;
2625     }
2626   else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__sti__", 7) == 0)
2627     {
2628       /* it's a ARM global constructor to be executed at program initial */
2629       (*mangled) += 7;
2630       work->constructor = 2;
2631     }
2632
2633   /*  This block of code is a reduction in strength time optimization
2634       of:
2635       scan = strstr (*mangled, "__"); */
2636
2637   {
2638     scan = *mangled;
2639
2640     do {
2641       scan = strchr (scan, '_');
2642     } while (scan != NULL && *++scan != '_');
2643
2644     if (scan != NULL) --scan;
2645   }
2646
2647   if (scan != NULL)
2648     {
2649       /* We found a sequence of two or more '_', ensure that we start at
2650          the last pair in the sequence.  */
2651       i = strspn (scan, "_");
2652       if (i > 2)
2653         {
2654           scan += (i - 2);
2655         }
2656     }
2657
2658   if (scan == NULL)
2659     {
2660       success = 0;
2661     }
2662   else if (work -> static_type)
2663     {
2664       if (!ISDIGIT ((unsigned char)scan[0]) && (scan[0] != 't'))
2665         {
2666           success = 0;
2667         }
2668     }
2669   else if ((scan == *mangled)
2670            && (ISDIGIT ((unsigned char)scan[2]) || (scan[2] == 'Q')
2671                || (scan[2] == 't') || (scan[2] == 'K') || (scan[2] == 'H')))
2672     {
2673       /* The ARM says nothing about the mangling of local variables.
2674          But cfront mangles local variables by prepending __<nesting_level>
2675          to them. As an extension to ARM demangling we handle this case.  */
2676       if ((LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING)
2677           && ISDIGIT ((unsigned char)scan[2]))
2678         {
2679           *mangled = scan + 2;
2680           consume_count (mangled);
2681           string_append (declp, *mangled);
2682           *mangled += strlen (*mangled);
2683           success = 1;
2684         }
2685       else
2686         {
2687           /* A GNU style constructor starts with __[0-9Qt].  But cfront uses
2688              names like __Q2_3foo3bar for nested type names.  So don't accept
2689              this style of constructor for cfront demangling.  A GNU
2690              style member-template constructor starts with 'H'. */
2691           if (!(LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING))
2692             work -> constructor += 1;
2693           *mangled = scan + 2;
2694         }
2695     }
2696   else if (ARM_DEMANGLING && scan[2] == 'p' && scan[3] == 't')
2697     {
2698       /* Cfront-style parameterized type.  Handled later as a signature. */
2699       success = 1;
2700
2701       /* ARM template? */
2702       demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
2703     }
2704   else if (EDG_DEMANGLING && ((scan[2] == 't' && scan[3] == 'm')
2705                               || (scan[2] == 'p' && scan[3] == 's')
2706                               || (scan[2] == 'p' && scan[3] == 't')))
2707     {
2708       /* EDG-style parameterized type.  Handled later as a signature. */
2709       success = 1;
2710
2711       /* EDG template? */
2712       demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
2713     }
2714   else if ((scan == *mangled) && !ISDIGIT ((unsigned char)scan[2])
2715            && (scan[2] != 't'))
2716     {
2717       /* Mangled name starts with "__".  Skip over any leading '_' characters,
2718          then find the next "__" that separates the prefix from the signature.
2719          */
2720       if (!(ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
2721           || (arm_special (mangled, declp) == 0))
2722         {
2723           while (*scan == '_')
2724             {
2725               scan++;
2726             }
2727           if ((scan = strstr (scan, "__")) == NULL || (*(scan + 2) == '\0'))
2728             {
2729               /* No separator (I.E. "__not_mangled"), or empty signature
2730                  (I.E. "__not_mangled_either__") */
2731               success = 0;
2732             }
2733           else
2734             return iterate_demangle_function (work, mangled, declp, scan);
2735         }
2736     }
2737   else if (*(scan + 2) != '\0')
2738     {
2739       /* Mangled name does not start with "__" but does have one somewhere
2740          in there with non empty stuff after it.  Looks like a global
2741          function name.  Iterate over all "__":s until the right
2742          one is found.  */
2743       return iterate_demangle_function (work, mangled, declp, scan);
2744     }
2745   else
2746     {
2747       /* Doesn't look like a mangled name */
2748       success = 0;
2749     }
2750
2751   if (!success && (work->constructor == 2 || work->destructor == 2))
2752     {
2753       string_append (declp, *mangled);
2754       *mangled += strlen (*mangled);
2755       success = 1;
2756     }
2757   return (success);
2758 }
2759
2760 /*
2761
2762 LOCAL FUNCTION
2763
2764         gnu_special -- special handling of gnu mangled strings
2765
2766 SYNOPSIS
2767
2768         static int
2769         gnu_special (struct work_stuff *work, const char **mangled,
2770                      string *declp);
2771
2772
2773 DESCRIPTION
2774
2775         Process some special GNU style mangling forms that don't fit
2776         the normal pattern.  For example:
2777
2778                 _$_3foo         (destructor for class foo)
2779                 _vt$foo         (foo virtual table)
2780                 _vt$foo$bar     (foo::bar virtual table)
2781                 __vt_foo        (foo virtual table, new style with thunks)
2782                 _3foo$varname   (static data member)
2783                 _Q22rs2tu$vw    (static data member)
2784                 __t6vector1Zii  (constructor with template)
2785                 __thunk_4__$_7ostream (virtual function thunk)
2786  */
2787
2788 static int
2789 gnu_special (struct work_stuff *work, const char **mangled, string *declp)
2790 {
2791   int n;
2792   int success = 1;
2793   const char *p;
2794
2795   if ((*mangled)[0] == '_'
2796       && strchr (cplus_markers, (*mangled)[1]) != NULL
2797       && (*mangled)[2] == '_')
2798     {
2799       /* Found a GNU style destructor, get past "_<CPLUS_MARKER>_" */
2800       (*mangled) += 3;
2801       work -> destructor += 1;
2802     }
2803   else if ((*mangled)[0] == '_'
2804            && (((*mangled)[1] == '_'
2805                 && (*mangled)[2] == 'v'
2806                 && (*mangled)[3] == 't'
2807                 && (*mangled)[4] == '_')
2808                || ((*mangled)[1] == 'v'
2809                    && (*mangled)[2] == 't'
2810                    && strchr (cplus_markers, (*mangled)[3]) != NULL)))
2811     {
2812       /* Found a GNU style virtual table, get past "_vt<CPLUS_MARKER>"
2813          and create the decl.  Note that we consume the entire mangled
2814          input string, which means that demangle_signature has no work
2815          to do.  */
2816       if ((*mangled)[2] == 'v')
2817         (*mangled) += 5; /* New style, with thunks: "__vt_" */
2818       else
2819         (*mangled) += 4; /* Old style, no thunks: "_vt<CPLUS_MARKER>" */
2820       while (**mangled != '\0')
2821         {
2822           switch (**mangled)
2823             {
2824             case 'Q':
2825             case 'K':
2826               success = demangle_qualified (work, mangled, declp, 0, 1);
2827               break;
2828             case 't':
2829               success = demangle_template (work, mangled, declp, 0, 1,
2830                                            1);
2831               break;
2832             default:
2833               if (ISDIGIT((unsigned char)*mangled[0]))
2834                 {
2835                   n = consume_count(mangled);
2836                   /* We may be seeing a too-large size, or else a
2837                      ".<digits>" indicating a static local symbol.  In
2838                      any case, declare victory and move on; *don't* try
2839                      to use n to allocate.  */
2840                   if (n > (int) strlen (*mangled))
2841                     {
2842                       success = 1;
2843                       break;
2844                     }
2845                 }
2846               else
2847                 {
2848                   n = strcspn (*mangled, cplus_markers);
2849                 }
2850               string_appendn (declp, *mangled, n);
2851               (*mangled) += n;
2852             }
2853
2854           p = strpbrk (*mangled, cplus_markers);
2855           if (success && ((p == NULL) || (p == *mangled)))
2856             {
2857               if (p != NULL)
2858                 {
2859                   string_append (declp, SCOPE_STRING (work));
2860                   (*mangled)++;
2861                 }
2862             }
2863           else
2864             {
2865               success = 0;
2866               break;
2867             }
2868         }
2869       if (success)
2870         string_append (declp, " virtual table");
2871     }
2872   else if ((*mangled)[0] == '_'
2873            && (strchr("0123456789Qt", (*mangled)[1]) != NULL)
2874            && (p = strpbrk (*mangled, cplus_markers)) != NULL)
2875     {
2876       /* static data member, "_3foo$varname" for example */
2877       (*mangled)++;
2878       switch (**mangled)
2879         {
2880         case 'Q':
2881         case 'K':
2882           success = demangle_qualified (work, mangled, declp, 0, 1);
2883           break;
2884         case 't':
2885           success = demangle_template (work, mangled, declp, 0, 1, 1);
2886           break;
2887         default:
2888           n = consume_count (mangled);
2889           if (n < 0 || n > (long) strlen (*mangled))
2890             {
2891               success = 0;
2892               break;
2893             }
2894
2895           if (n > 10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
2896               && (*mangled)[9] == 'N'
2897               && (*mangled)[8] == (*mangled)[10]
2898               && strchr (cplus_markers, (*mangled)[8]))
2899             {
2900               /* A member of the anonymous namespace.  There's information
2901                  about what identifier or filename it was keyed to, but
2902                  it's just there to make the mangled name unique; we just
2903                  step over it.  */
2904               string_append (declp, "{anonymous}");
2905               (*mangled) += n;
2906
2907               /* Now p points to the marker before the N, so we need to
2908                  update it to the first marker after what we consumed.  */
2909               p = strpbrk (*mangled, cplus_markers);
2910               break;
2911             }
2912
2913           string_appendn (declp, *mangled, n);
2914           (*mangled) += n;
2915         }
2916       if (success && (p == *mangled))
2917         {
2918           /* Consumed everything up to the cplus_marker, append the
2919              variable name.  */
2920           (*mangled)++;
2921           string_append (declp, SCOPE_STRING (work));
2922           n = strlen (*mangled);
2923           string_appendn (declp, *mangled, n);
2924           (*mangled) += n;
2925         }
2926       else
2927         {
2928           success = 0;
2929         }
2930     }
2931   else if (strncmp (*mangled, "__thunk_", 8) == 0)
2932     {
2933       int delta;
2934
2935       (*mangled) += 8;
2936       delta = consume_count (mangled);
2937       if (delta == -1)
2938         success = 0;
2939       else
2940         {
2941           char *method = internal_cplus_demangle (work, ++*mangled);
2942
2943           if (method)
2944             {
2945               char buf[50];
2946               sprintf (buf, "virtual function thunk (delta:%d) for ", -delta);
2947               string_append (declp, buf);
2948               string_append (declp, method);
2949               free (method);
2950               n = strlen (*mangled);
2951               (*mangled) += n;
2952             }
2953           else
2954             {
2955               success = 0;
2956             }
2957         }
2958     }
2959   else if (strncmp (*mangled, "__t", 3) == 0
2960            && ((*mangled)[3] == 'i' || (*mangled)[3] == 'f'))
2961     {
2962       p = (*mangled)[3] == 'i' ? " type_info node" : " type_info function";
2963       (*mangled) += 4;
2964       switch (**mangled)
2965         {
2966         case 'Q':
2967         case 'K':
2968           success = demangle_qualified (work, mangled, declp, 0, 1);
2969           break;
2970         case 't':
2971           success = demangle_template (work, mangled, declp, 0, 1, 1);
2972           break;
2973         default:
2974           success = do_type (work, mangled, declp);
2975           break;
2976         }
2977       if (success && **mangled != '\0')
2978         success = 0;
2979       if (success)
2980         string_append (declp, p);
2981     }
2982   else
2983     {
2984       success = 0;
2985     }
2986   return (success);
2987 }
2988
2989 static void
2990 recursively_demangle(struct work_stuff *work, const char **mangled,
2991                      string *result, int namelength)
2992 {
2993   char * recurse = (char *)NULL;
2994   char * recurse_dem = (char *)NULL;
2995
2996   recurse = XNEWVEC (char, namelength + 1);
2997   memcpy (recurse, *mangled, namelength);
2998   recurse[namelength] = '\000';
2999
3000   recurse_dem = cplus_demangle (recurse, work->options);
3001
3002   if (recurse_dem)
3003     {
3004       string_append (result, recurse_dem);
3005       free (recurse_dem);
3006     }
3007   else
3008     {
3009       string_appendn (result, *mangled, namelength);
3010     }
3011   free (recurse);
3012   *mangled += namelength;
3013 }
3014
3015 /*
3016
3017 LOCAL FUNCTION
3018
3019         arm_special -- special handling of ARM/lucid mangled strings
3020
3021 SYNOPSIS
3022
3023         static int
3024         arm_special (const char **mangled,
3025                      string *declp);
3026
3027
3028 DESCRIPTION
3029
3030         Process some special ARM style mangling forms that don't fit
3031         the normal pattern.  For example:
3032
3033                 __vtbl__3foo            (foo virtual table)
3034                 __vtbl__3foo__3bar      (bar::foo virtual table)
3035
3036  */
3037
3038 static int
3039 arm_special (const char **mangled, string *declp)
3040 {
3041   int n;
3042   int success = 1;
3043   const char *scan;
3044
3045   if (strncmp (*mangled, ARM_VTABLE_STRING, ARM_VTABLE_STRLEN) == 0)
3046     {
3047       /* Found a ARM style virtual table, get past ARM_VTABLE_STRING
3048          and create the decl.  Note that we consume the entire mangled
3049          input string, which means that demangle_signature has no work
3050          to do.  */
3051       scan = *mangled + ARM_VTABLE_STRLEN;
3052       while (*scan != '\0')        /* first check it can be demangled */
3053         {
3054           n = consume_count (&scan);
3055           if (n == -1)
3056             {
3057               return (0);           /* no good */
3058             }
3059           scan += n;
3060           if (scan[0] == '_' && scan[1] == '_')
3061             {
3062               scan += 2;
3063             }
3064         }
3065       (*mangled) += ARM_VTABLE_STRLEN;
3066       while (**mangled != '\0')
3067         {
3068           n = consume_count (mangled);
3069           if (n == -1
3070               || n > (long) strlen (*mangled))
3071             return 0;
3072           string_prependn (declp, *mangled, n);
3073           (*mangled) += n;
3074           if ((*mangled)[0] == '_' && (*mangled)[1] == '_')
3075             {
3076               string_prepend (declp, "::");
3077               (*mangled) += 2;
3078             }
3079         }
3080       string_append (declp, " virtual table");
3081     }
3082   else
3083     {
3084       success = 0;
3085     }
3086   return (success);
3087 }
3088
3089 /*
3090
3091 LOCAL FUNCTION
3092
3093         demangle_qualified -- demangle 'Q' qualified name strings
3094
3095 SYNOPSIS
3096
3097         static int
3098         demangle_qualified (struct work_stuff *, const char *mangled,
3099                             string *result, int isfuncname, int append);
3100
3101 DESCRIPTION
3102
3103         Demangle a qualified name, such as "Q25Outer5Inner" which is
3104         the mangled form of "Outer::Inner".  The demangled output is
3105         prepended or appended to the result string according to the
3106         state of the append flag.
3107
3108         If isfuncname is nonzero, then the qualified name we are building
3109         is going to be used as a member function name, so if it is a
3110         constructor or destructor function, append an appropriate
3111         constructor or destructor name.  I.E. for the above example,
3112         the result for use as a constructor is "Outer::Inner::Inner"
3113         and the result for use as a destructor is "Outer::Inner::~Inner".
3114
3115 BUGS
3116
3117         Numeric conversion is ASCII dependent (FIXME).
3118
3119  */
3120
3121 static int
3122 demangle_qualified (struct work_stuff *work, const char **mangled,
3123                     string *result, int isfuncname, int append)
3124 {
3125   int qualifiers = 0;
3126   int success = 1;
3127   char num[2];
3128   string temp;
3129   string last_name;
3130   int bindex = register_Btype (work);
3131
3132   /* We only make use of ISFUNCNAME if the entity is a constructor or
3133      destructor.  */
3134   isfuncname = (isfuncname
3135                 && ((work->constructor & 1) || (work->destructor & 1)));
3136
3137   string_init (&temp);
3138   string_init (&last_name);
3139
3140   if ((*mangled)[0] == 'K')
3141     {
3142     /* Squangling qualified name reuse */
3143       int idx;
3144       (*mangled)++;
3145       idx = consume_count_with_underscores (mangled);
3146       if (idx == -1 || idx >= work -> numk)
3147         success = 0;
3148       else
3149         string_append (&temp, work -> ktypevec[idx]);
3150     }
3151   else
3152     switch ((*mangled)[1])
3153     {
3154     case '_':
3155       /* GNU mangled name with more than 9 classes.  The count is preceded
3156          by an underscore (to distinguish it from the <= 9 case) and followed
3157          by an underscore.  */
3158       (*mangled)++;
3159       qualifiers = consume_count_with_underscores (mangled);
3160       if (qualifiers == -1)
3161         success = 0;
3162       break;
3163
3164     case '1':
3165     case '2':
3166     case '3':
3167     case '4':
3168     case '5':
3169     case '6':
3170     case '7':
3171     case '8':
3172     case '9':
3173       /* The count is in a single digit.  */
3174       num[0] = (*mangled)[1];
3175       num[1] = '\0';
3176       qualifiers = atoi (num);
3177
3178       /* If there is an underscore after the digit, skip it.  This is
3179          said to be for ARM-qualified names, but the ARM makes no
3180          mention of such an underscore.  Perhaps cfront uses one.  */
3181       if ((*mangled)[2] == '_')
3182         {
3183           (*mangled)++;
3184         }
3185       (*mangled) += 2;
3186       break;
3187
3188     case '0':
3189     default:
3190       success = 0;
3191     }
3192
3193   if (!success)
3194     return success;
3195
3196   /* Pick off the names and collect them in the temp buffer in the order
3197      in which they are found, separated by '::'.  */
3198
3199   while (qualifiers-- > 0)
3200     {
3201       int remember_K = 1;
3202       string_clear (&last_name);
3203
3204       if (*mangled[0] == '_')
3205         (*mangled)++;
3206
3207       if (*mangled[0] == 't')
3208         {
3209           /* Here we always append to TEMP since we will want to use
3210              the template name without the template parameters as a
3211              constructor or destructor name.  The appropriate
3212              (parameter-less) value is returned by demangle_template
3213              in LAST_NAME.  We do not remember the template type here,
3214              in order to match the G++ mangling algorithm.  */
3215           success = demangle_template(work, mangled, &temp,
3216                                       &last_name, 1, 0);
3217           if (!success)
3218             break;
3219         }
3220       else if (*mangled[0] == 'K')
3221         {
3222           int idx;
3223           (*mangled)++;
3224           idx = consume_count_with_underscores (mangled);
3225           if (idx == -1 || idx >= work->numk)
3226             success = 0;
3227           else
3228             string_append (&temp, work->ktypevec[idx]);
3229           remember_K = 0;
3230
3231           if (!success) break;
3232         }
3233       else
3234         {
3235           if (EDG_DEMANGLING)
3236             {
3237               int namelength;
3238               /* Now recursively demangle the qualifier
3239                * This is necessary to deal with templates in
3240                * mangling styles like EDG */
3241               namelength = consume_count (mangled);
3242               if (namelength == -1)
3243                 {
3244                   success = 0;
3245                   break;
3246                 }
3247               recursively_demangle(work, mangled, &temp, namelength);
3248             }
3249           else
3250             {
3251               string_delete (&last_name);
3252               success = do_type (work, mangled, &last_name);
3253               if (!success)
3254                 break;
3255               string_appends (&temp, &last_name);
3256             }
3257         }
3258
3259       if (remember_K)
3260         remember_Ktype (work, temp.b, LEN_STRING (&temp));
3261
3262       if (qualifiers > 0)
3263         string_append (&temp, SCOPE_STRING (work));
3264     }
3265
3266   remember_Btype (work, temp.b, LEN_STRING (&temp), bindex);
3267
3268   /* If we are using the result as a function name, we need to append
3269      the appropriate '::' separated constructor or destructor name.
3270      We do this here because this is the most convenient place, where
3271      we already have a pointer to the name and the length of the name.  */
3272
3273   if (isfuncname)
3274     {
3275       string_append (&temp, SCOPE_STRING (work));
3276       if (work -> destructor & 1)
3277         string_append (&temp, "~");
3278       string_appends (&temp, &last_name);
3279     }
3280
3281   /* Now either prepend the temp buffer to the result, or append it,
3282      depending upon the state of the append flag.  */
3283
3284   if (append)
3285     string_appends (result, &temp);
3286   else
3287     {
3288       if (!STRING_EMPTY (result))
3289         string_append (&temp, SCOPE_STRING (work));
3290       string_prepends (result, &temp);
3291     }
3292
3293   string_delete (&last_name);
3294   string_delete (&temp);
3295   return (success);
3296 }
3297
3298 /*
3299
3300 LOCAL FUNCTION
3301
3302         get_count -- convert an ascii count to integer, consuming tokens
3303
3304 SYNOPSIS
3305
3306         static int
3307         get_count (const char **type, int *count)
3308
3309 DESCRIPTION
3310
3311         Assume that *type points at a count in a mangled name; set
3312         *count to its value, and set *type to the next character after
3313         the count.  There are some weird rules in effect here.
3314
3315         If *type does not point at a string of digits, return zero.
3316
3317         If *type points at a string of digits followed by an
3318         underscore, set *count to their value as an integer, advance
3319         *type to point *after the underscore, and return 1.
3320
3321         If *type points at a string of digits not followed by an
3322         underscore, consume only the first digit.  Set *count to its
3323         value as an integer, leave *type pointing after that digit,
3324         and return 1.
3325
3326         The excuse for this odd behavior: in the ARM and HP demangling
3327         styles, a type can be followed by a repeat count of the form
3328         `Nxy', where:
3329
3330         `x' is a single digit specifying how many additional copies
3331             of the type to append to the argument list, and
3332
3333         `y' is one or more digits, specifying the zero-based index of
3334             the first repeated argument in the list.  Yes, as you're
3335             unmangling the name you can figure this out yourself, but
3336             it's there anyway.
3337
3338         So, for example, in `bar__3fooFPiN51', the first argument is a
3339         pointer to an integer (`Pi'), and then the next five arguments
3340         are the same (`N5'), and the first repeat is the function's
3341         second argument (`1').
3342 */
3343
3344 static int
3345 get_count (const char **type, int *count)
3346 {
3347   const char *p;
3348   int n;
3349
3350   if (!ISDIGIT ((unsigned char)**type))
3351     return (0);
3352   else
3353     {
3354       *count = **type - '0';
3355       (*type)++;
3356       if (ISDIGIT ((unsigned char)**type))
3357         {
3358           p = *type;
3359           n = *count;
3360           do
3361             {
3362               n *= 10;
3363               n += *p - '0';
3364               p++;
3365             }
3366           while (ISDIGIT ((unsigned char)*p));
3367           if (*p == '_')
3368             {
3369               *type = p + 1;
3370               *count = n;
3371             }
3372         }
3373     }
3374   return (1);
3375 }
3376
3377 /* RESULT will be initialised here; it will be freed on failure.  The
3378    value returned is really a type_kind_t.  */
3379
3380 static int
3381 do_type (struct work_stuff *work, const char **mangled, string *result)
3382 {
3383   int n;
3384   int done;
3385   int success;
3386   string decl;
3387   const char *remembered_type;
3388   int type_quals;
3389   type_kind_t tk = tk_none;
3390
3391   string_init (&decl);
3392   string_init (result);
3393
3394   done = 0;
3395   success = 1;
3396   while (success && !done)
3397     {
3398       int member;
3399       switch (**mangled)
3400         {
3401
3402           /* A pointer type */
3403         case 'P':
3404         case 'p':
3405           (*mangled)++;
3406           if (! (work -> options & DMGL_JAVA))
3407             string_prepend (&decl, "*");
3408           if (tk == tk_none)
3409             tk = tk_pointer;
3410           break;
3411
3412           /* A reference type */
3413         case 'R':
3414           (*mangled)++;
3415           string_prepend (&decl, "&");
3416           if (tk == tk_none)
3417             tk = tk_reference;
3418           break;
3419
3420           /* An array */
3421         case 'A':
3422           {
3423             ++(*mangled);
3424             if (!STRING_EMPTY (&decl)
3425                 && (decl.b[0] == '*' || decl.b[0] == '&'))
3426               {
3427                 string_prepend (&decl, "(");
3428                 string_append (&decl, ")");
3429               }
3430             string_append (&decl, "[");
3431             if (**mangled != '_')
3432               success = demangle_template_value_parm (work, mangled, &decl,
3433                                                       tk_integral);
3434             if (**mangled == '_')
3435               ++(*mangled);
3436             string_append (&decl, "]");
3437             break;
3438           }
3439
3440         /* A back reference to a previously seen type */
3441         case 'T':
3442           (*mangled)++;
3443           if (!get_count (mangled, &n) || n >= work -> ntypes)
3444             {
3445               success = 0;
3446             }
3447           else
3448             {
3449               remembered_type = work -> typevec[n];
3450               mangled = &remembered_type;
3451             }
3452           break;
3453
3454           /* A function */
3455         case 'F':
3456           (*mangled)++;
3457             if (!STRING_EMPTY (&decl)
3458                 && (decl.b[0] == '*' || decl.b[0] == '&'))
3459             {
3460               string_prepend (&decl, "(");
3461               string_append (&decl, ")");
3462             }
3463           /* After picking off the function args, we expect to either find the
3464              function return type (preceded by an '_') or the end of the
3465              string.  */
3466           if (!demangle_nested_args (work, mangled, &decl)
3467               || (**mangled != '_' && **mangled != '\0'))
3468             {
3469               success = 0;
3470               break;
3471             }
3472           if (success && (**mangled == '_'))
3473             (*mangled)++;
3474           break;
3475
3476         case 'M':
3477         case 'O':
3478           {
3479             type_quals = TYPE_UNQUALIFIED;
3480
3481             member = **mangled == 'M';
3482             (*mangled)++;
3483
3484             string_append (&decl, ")");
3485
3486             /* We don't need to prepend `::' for a qualified name;
3487                demangle_qualified will do that for us.  */
3488             if (**mangled != 'Q')
3489               string_prepend (&decl, SCOPE_STRING (work));
3490
3491             if (ISDIGIT ((unsigned char)**mangled))
3492               {
3493                 n = consume_count (mangled);
3494                 if (n == -1
3495                     || (int) strlen (*mangled) < n)
3496                   {
3497                     success = 0;
3498                     break;
3499                   }
3500                 string_prependn (&decl, *mangled, n);
3501                 *mangled += n;
3502               }
3503             else if (**mangled == 'X' || **mangled == 'Y')
3504               {
3505                 string temp;
3506                 do_type (work, mangled, &temp);
3507                 string_prepends (&decl, &temp);
3508                 string_delete (&temp);
3509               }
3510             else if (**mangled == 't')
3511               {
3512                 string temp;
3513                 string_init (&temp);
3514                 success = demangle_template (work, mangled, &temp,
3515                                              NULL, 1, 1);
3516                 if (success)
3517                   {
3518                     string_prependn (&decl, temp.b, temp.p - temp.b);
3519                     string_delete (&temp);
3520                   }
3521                 else
3522                   break;
3523               }
3524             else if (**mangled == 'Q')
3525               {
3526                 success = demangle_qualified (work, mangled, &decl,
3527                                               /*isfuncnam=*/0,
3528                                               /*append=*/0);
3529                 if (!success)
3530                   break;
3531               }
3532             else
3533               {
3534                 success = 0;
3535                 break;
3536               }
3537
3538             string_prepend (&decl, "(");
3539             if (member)
3540               {
3541                 switch (**mangled)
3542                   {
3543                   case 'C':
3544                   case 'V':
3545                   case 'u':
3546                     type_quals |= code_for_qualifier (**mangled);
3547                     (*mangled)++;
3548                     break;
3549
3550                   default:
3551                     break;
3552                   }
3553
3554                 if (*(*mangled)++ != 'F')
3555                   {
3556                     success = 0;
3557                     break;
3558                   }
3559               }
3560             if ((member && !demangle_nested_args (work, mangled, &decl))
3561                 || **mangled != '_')
3562               {
3563                 success = 0;
3564                 break;
3565               }
3566             (*mangled)++;
3567             if (! PRINT_ANSI_QUALIFIERS)
3568               {
3569                 break;
3570               }
3571             if (type_quals != TYPE_UNQUALIFIED)
3572               {
3573                 APPEND_BLANK (&decl);
3574                 string_append (&decl, qualifier_string (type_quals));
3575               }
3576             break;
3577           }
3578         case 'G':
3579           (*mangled)++;
3580           break;
3581
3582         case 'C':
3583         case 'V':
3584         case 'u':
3585           if (PRINT_ANSI_QUALIFIERS)
3586             {
3587               if (!STRING_EMPTY (&decl))
3588                 string_prepend (&decl, " ");
3589
3590               string_prepend (&decl, demangle_qualifier (**mangled));
3591             }
3592           (*mangled)++;
3593           break;
3594           /*
3595             }
3596             */
3597
3598           /* fall through */
3599         default:
3600           done = 1;
3601           break;
3602         }
3603     }
3604
3605   if (success) switch (**mangled)
3606     {
3607       /* A qualified name, such as "Outer::Inner".  */
3608     case 'Q':
3609     case 'K':
3610       {
3611         success = demangle_qualified (work, mangled, result, 0, 1);
3612         break;
3613       }
3614
3615     /* A back reference to a previously seen squangled type */
3616     case 'B':
3617       (*mangled)++;
3618       if (!get_count (mangled, &n) || n >= work -> numb)
3619         success = 0;
3620       else
3621         string_append (result, work->btypevec[n]);
3622       break;
3623
3624     case 'X':
3625     case 'Y':
3626       /* A template parm.  We substitute the corresponding argument. */
3627       {
3628         int idx;
3629
3630         (*mangled)++;
3631         idx = consume_count_with_underscores (mangled);
3632
3633         if (idx == -1
3634             || (work->tmpl_argvec && idx >= work->ntmpl_args)
3635             || consume_count_with_underscores (mangled) == -1)
3636           {
3637             success = 0;
3638             break;
3639           }
3640
3641         if (work->tmpl_argvec)
3642           string_append (result, work->tmpl_argvec[idx]);
3643         else
3644           string_append_template_idx (result, idx);
3645
3646         success = 1;
3647       }
3648     break;
3649
3650     default:
3651       success = demangle_fund_type (work, mangled, result);
3652       if (tk == tk_none)
3653         tk = (type_kind_t) success;
3654       break;
3655     }
3656
3657   if (success)
3658     {
3659       if (!STRING_EMPTY (&decl))
3660         {
3661           string_append (result, " ");
3662           string_appends (result, &decl);
3663         }
3664     }
3665   else
3666     string_delete (result);
3667   string_delete (&decl);
3668
3669   if (success)
3670     /* Assume an integral type, if we're not sure.  */
3671     return (int) ((tk == tk_none) ? tk_integral : tk);
3672   else
3673     return 0;
3674 }
3675
3676 /* Given a pointer to a type string that represents a fundamental type
3677    argument (int, long, unsigned int, etc) in TYPE, a pointer to the
3678    string in which the demangled output is being built in RESULT, and
3679    the WORK structure, decode the types and add them to the result.
3680
3681    For example:
3682
3683         "Ci"    =>      "const int"
3684         "Sl"    =>      "signed long"
3685         "CUs"   =>      "const unsigned short"
3686
3687    The value returned is really a type_kind_t.  */
3688
3689 static int
3690 demangle_fund_type (struct work_stuff *work,
3691                     const char **mangled, string *result)
3692 {
3693   int done = 0;
3694   int success = 1;
3695   char buf[INTBUF_SIZE + 5 /* 'int%u_t' */];
3696   unsigned int dec = 0;
3697   type_kind_t tk = tk_integral;
3698
3699   /* First pick off any type qualifiers.  There can be more than one.  */
3700
3701   while (!done)
3702     {
3703       switch (**mangled)
3704         {
3705         case 'C':
3706         case 'V':
3707         case 'u':
3708           if (PRINT_ANSI_QUALIFIERS)
3709             {
3710               if (!STRING_EMPTY (result))
3711                 string_prepend (result, " ");
3712               string_prepend (result, demangle_qualifier (**mangled));
3713             }
3714           (*mangled)++;
3715           break;
3716         case 'U':
3717           (*mangled)++;
3718           APPEND_BLANK (result);
3719           string_append (result, "unsigned");
3720           break;
3721         case 'S': /* signed char only */
3722           (*mangled)++;
3723           APPEND_BLANK (result);
3724           string_append (result, "signed");
3725           break;
3726         case 'J':
3727           (*mangled)++;
3728           APPEND_BLANK (result);
3729           string_append (result, "__complex");
3730           break;
3731         default:
3732           done = 1;
3733           break;
3734         }
3735     }
3736
3737   /* Now pick off the fundamental type.  There can be only one.  */
3738
3739   switch (**mangled)
3740     {
3741     case '\0':
3742     case '_':
3743       break;
3744     case 'v':
3745       (*mangled)++;
3746       APPEND_BLANK (result);
3747       string_append (result, "void");
3748       break;
3749     case 'x':
3750       (*mangled)++;
3751       APPEND_BLANK (result);
3752       string_append (result, "long long");
3753       break;
3754     case 'l':
3755       (*mangled)++;
3756       APPEND_BLANK (result);
3757       string_append (result, "long");
3758       break;
3759     case 'i':
3760       (*mangled)++;
3761       APPEND_BLANK (result);
3762       string_append (result, "int");
3763       break;
3764     case 's':
3765       (*mangled)++;
3766       APPEND_BLANK (result);
3767       string_append (result, "short");
3768       break;
3769     case 'b':
3770       (*mangled)++;
3771       APPEND_BLANK (result);
3772       string_append (result, "bool");
3773       tk = tk_bool;
3774       break;
3775     case 'c':
3776       (*mangled)++;
3777       APPEND_BLANK (result);
3778       string_append (result, "char");
3779       tk = tk_char;
3780       break;
3781     case 'w':
3782       (*mangled)++;
3783       APPEND_BLANK (result);
3784       string_append (result, "wchar_t");
3785       tk = tk_char;
3786       break;
3787     case 'r':
3788       (*mangled)++;
3789       APPEND_BLANK (result);
3790       string_append (result, "long double");
3791       tk = tk_real;
3792       break;
3793     case 'd':
3794       (*mangled)++;
3795       APPEND_BLANK (result);
3796       string_append (result, "double");
3797       tk = tk_real;
3798       break;
3799     case 'f':
3800       (*mangled)++;
3801       APPEND_BLANK (result);
3802       string_append (result, "float");
3803       tk = tk_real;
3804       break;
3805     case 'G':
3806       (*mangled)++;
3807       if (!ISDIGIT ((unsigned char)**mangled))
3808         {
3809           success = 0;
3810           break;
3811         }
3812     case 'I':
3813       (*mangled)++;
3814       if (**mangled == '_')
3815         {
3816           int i;
3817           (*mangled)++;
3818           for (i = 0;
3819                i < (long) sizeof (buf) - 1 && **mangled && **mangled != '_';
3820                (*mangled)++, i++)
3821             buf[i] = **mangled;
3822           if (**mangled != '_')
3823             {
3824               success = 0;
3825               break;
3826             }
3827           buf[i] = '\0';
3828           (*mangled)++;
3829         }
3830       else
3831         {
3832           strncpy (buf, *mangled, 2);
3833           buf[2] = '\0';
3834           *mangled += min (strlen (*mangled), 2);
3835         }
3836       sscanf (buf, "%x", &dec);
3837       sprintf (buf, "int%u_t", dec);
3838       APPEND_BLANK (result);
3839       string_append (result, buf);
3840       break;
3841
3842       /* fall through */
3843       /* An explicit type, such as "6mytype" or "7integer" */
3844     case '0':
3845     case '1':
3846     case '2':
3847     case '3':
3848     case '4':
3849     case '5':
3850     case '6':
3851     case '7':
3852     case '8':
3853     case '9':
3854       {
3855         int bindex = register_Btype (work);
3856         string btype;
3857         string_init (&btype);
3858         if (demangle_class_name (work, mangled, &btype)) {
3859           remember_Btype (work, btype.b, LEN_STRING (&btype), bindex);
3860           APPEND_BLANK (result);
3861           string_appends (result, &btype);
3862         }
3863         else
3864           success = 0;
3865         string_delete (&btype);
3866         break;
3867       }
3868     case 't':
3869       {
3870         string btype;
3871         string_init (&btype);
3872         success = demangle_template (work, mangled, &btype, 0, 1, 1);
3873         string_appends (result, &btype);
3874         string_delete (&btype);
3875         break;
3876       }
3877     default:
3878       success = 0;
3879       break;
3880     }
3881
3882   return success ? ((int) tk) : 0;
3883 }
3884
3885
3886 /* Handle a template's value parameter for HP aCC (extension from ARM)
3887    **mangled points to 'S' or 'U' */
3888
3889 static int
3890 do_hpacc_template_const_value (struct work_stuff *work ATTRIBUTE_UNUSED,
3891                                const char **mangled, string *result)
3892 {
3893   int unsigned_const;
3894
3895   if (**mangled != 'U' && **mangled != 'S')
3896     return 0;
3897
3898   unsigned_const = (**mangled == 'U');
3899
3900   (*mangled)++;
3901
3902   switch (**mangled)
3903     {
3904       case 'N':
3905         string_append (result, "-");
3906         /* fall through */
3907       case 'P':
3908         (*mangled)++;
3909         break;
3910       case 'M':
3911         /* special case for -2^31 */
3912         string_append (result, "-2147483648");
3913         (*mangled)++;
3914         return 1;
3915       default:
3916         return 0;
3917     }
3918
3919   /* We have to be looking at an integer now */
3920   if (!(ISDIGIT ((unsigned char)**mangled)))
3921     return 0;
3922
3923   /* We only deal with integral values for template
3924      parameters -- so it's OK to look only for digits */
3925   while (ISDIGIT ((unsigned char)**mangled))
3926     {
3927       char_str[0] = **mangled;
3928       string_append (result, char_str);
3929       (*mangled)++;
3930     }
3931
3932   if (unsigned_const)
3933     string_append (result, "U");
3934
3935   /* FIXME? Some day we may have 64-bit (or larger :-) ) constants
3936      with L or LL suffixes. pai/1997-09-03 */
3937
3938   return 1; /* success */
3939 }
3940
3941 /* Handle a template's literal parameter for HP aCC (extension from ARM)
3942    **mangled is pointing to the 'A' */
3943
3944 static int
3945 do_hpacc_template_literal (struct work_stuff *work, const char **mangled,
3946                            string *result)
3947 {
3948   int literal_len = 0;
3949   char * recurse;
3950   char * recurse_dem;
3951
3952   if (**mangled != 'A')
3953     return 0;
3954
3955   (*mangled)++;
3956
3957   literal_len = consume_count (mangled);
3958
3959   if (literal_len <= 0)
3960     return 0;
3961
3962   /* Literal parameters are names of arrays, functions, etc.  and the
3963      canonical representation uses the address operator */
3964   string_append (result, "&");
3965
3966   /* Now recursively demangle the literal name */
3967   recurse = XNEWVEC (char, literal_len + 1);
3968   memcpy (recurse, *mangled, literal_len);
3969   recurse[literal_len] = '\000';
3970
3971   recurse_dem = cplus_demangle (recurse, work->options);
3972
3973   if (recurse_dem)
3974     {
3975       string_append (result, recurse_dem);
3976       free (recurse_dem);
3977     }
3978   else
3979     {
3980       string_appendn (result, *mangled, literal_len);
3981     }
3982   (*mangled) += literal_len;
3983   free (recurse);
3984
3985   return 1;
3986 }
3987
3988 static int
3989 snarf_numeric_literal (const char **args, string *arg)
3990 {
3991   if (**args == '-')
3992     {
3993       char_str[0] = '-';
3994       string_append (arg, char_str);
3995       (*args)++;
3996     }
3997   else if (**args == '+')
3998     (*args)++;
3999
4000   if (!ISDIGIT ((unsigned char)**args))
4001     return 0;
4002
4003   while (ISDIGIT ((unsigned char)**args))
4004     {
4005       char_str[0] = **args;
4006       string_append (arg, char_str);
4007       (*args)++;
4008     }
4009
4010   return 1;
4011 }
4012
4013 /* Demangle the next argument, given by MANGLED into RESULT, which
4014    *should be an uninitialized* string.  It will be initialized here,
4015    and free'd should anything go wrong.  */
4016
4017 static int
4018 do_arg (struct work_stuff *work, const char **mangled, string *result)
4019 {
4020   /* Remember where we started so that we can record the type, for
4021      non-squangling type remembering.  */
4022   const char *start = *mangled;
4023
4024   string_init (result);
4025
4026   if (work->nrepeats > 0)
4027     {
4028       --work->nrepeats;
4029
4030       if (work->previous_argument == 0)
4031         return 0;
4032
4033       /* We want to reissue the previous type in this argument list.  */
4034       string_appends (result, work->previous_argument);
4035       return 1;
4036     }
4037
4038   if (**mangled == 'n')
4039     {
4040       /* A squangling-style repeat.  */
4041       (*mangled)++;
4042       work->nrepeats = consume_count(mangled);
4043
4044       if (work->nrepeats <= 0)
4045         /* This was not a repeat count after all.  */
4046         return 0;
4047
4048       if (work->nrepeats > 9)
4049         {
4050           if (**mangled != '_')
4051             /* The repeat count should be followed by an '_' in this
4052                case.  */
4053             return 0;
4054           else
4055             (*mangled)++;
4056         }
4057
4058       /* Now, the repeat is all set up.  */
4059       return do_arg (work, mangled, result);
4060     }
4061
4062   /* Save the result in WORK->previous_argument so that we can find it
4063      if it's repeated.  Note that saving START is not good enough: we
4064      do not want to add additional types to the back-referenceable
4065      type vector when processing a repeated type.  */
4066   if (work->previous_argument)
4067     string_delete (work->previous_argument);
4068   else
4069     work->previous_argument = XNEW (string);
4070
4071   if (!do_type (work, mangled, work->previous_argument))
4072     return 0;
4073
4074   string_appends (result, work->previous_argument);
4075
4076   remember_type (work, start, *mangled - start);
4077   return 1;
4078 }
4079
4080 static void
4081 remember_type (struct work_stuff *work, const char *start, int len)
4082 {
4083   char *tem;
4084
4085   if (work->forgetting_types)
4086     return;
4087
4088   if (work -> ntypes >= work -> typevec_size)
4089     {
4090       if (work -> typevec_size == 0)
4091         {
4092           work -> typevec_size = 3;
4093           work -> typevec = XNEWVEC (char *, work->typevec_size);
4094         }
4095       else
4096         {
4097           work -> typevec_size *= 2;
4098           work -> typevec
4099             = XRESIZEVEC (char *, work->typevec, work->typevec_size);
4100         }
4101     }
4102   tem = XNEWVEC (char, len + 1);
4103   memcpy (tem, start, len);
4104   tem[len] = '\0';
4105   work -> typevec[work -> ntypes++] = tem;
4106 }
4107
4108
4109 /* Remember a K type class qualifier. */
4110 static void
4111 remember_Ktype (struct work_stuff *work, const char *start, int len)
4112 {
4113   char *tem;
4114
4115   if (work -> numk >= work -> ksize)
4116     {
4117       if (work -> ksize == 0)
4118         {
4119           work -> ksize = 5;
4120           work -> ktypevec = XNEWVEC (char *, work->ksize);
4121         }
4122       else
4123         {
4124           work -> ksize *= 2;
4125           work -> ktypevec
4126             = XRESIZEVEC (char *, work->ktypevec, work->ksize);
4127         }
4128     }
4129   tem = XNEWVEC (char, len + 1);
4130   memcpy (tem, start, len);
4131   tem[len] = '\0';
4132   work -> ktypevec[work -> numk++] = tem;
4133 }
4134
4135 /* Register a B code, and get an index for it. B codes are registered
4136    as they are seen, rather than as they are completed, so map<temp<char> >
4137    registers map<temp<char> > as B0, and temp<char> as B1 */
4138
4139 static int
4140 register_Btype (struct work_stuff *work)
4141 {
4142   int ret;
4143
4144   if (work -> numb >= work -> bsize)
4145     {
4146       if (work -> bsize == 0)
4147         {
4148           work -> bsize = 5;
4149           work -> btypevec = XNEWVEC (char *, work->bsize);
4150         }
4151       else
4152         {
4153           work -> bsize *= 2;
4154           work -> btypevec
4155             = XRESIZEVEC (char *, work->btypevec, work->bsize);
4156         }
4157     }
4158   ret = work -> numb++;
4159   work -> btypevec[ret] = NULL;
4160   return(ret);
4161 }
4162
4163 /* Store a value into a previously registered B code type. */
4164
4165 static void
4166 remember_Btype (struct work_stuff *work, const char *start,
4167                 int len, int index)
4168 {
4169   char *tem;
4170
4171   tem = XNEWVEC (char, len + 1);
4172   memcpy (tem, start, len);
4173   tem[len] = '\0';
4174   work -> btypevec[index] = tem;
4175 }
4176
4177 /* Lose all the info related to B and K type codes. */
4178 static void
4179 forget_B_and_K_types (struct work_stuff *work)
4180 {
4181   int i;
4182
4183   while (work -> numk > 0)
4184     {
4185       i = --(work -> numk);
4186       if (work -> ktypevec[i] != NULL)
4187         {
4188           free (work -> ktypevec[i]);
4189           work -> ktypevec[i] = NULL;
4190         }
4191     }
4192
4193   while (work -> numb > 0)
4194     {
4195       i = --(work -> numb);
4196       if (work -> btypevec[i] != NULL)
4197         {
4198           free (work -> btypevec[i]);
4199           work -> btypevec[i] = NULL;
4200         }
4201     }
4202 }
4203 /* Forget the remembered types, but not the type vector itself.  */
4204
4205 static void
4206 forget_types (struct work_stuff *work)
4207 {
4208   int i;
4209
4210   while (work -> ntypes > 0)
4211     {
4212       i = --(work -> ntypes);
4213       if (work -> typevec[i] != NULL)
4214         {
4215           free (work -> typevec[i]);
4216           work -> typevec[i] = NULL;
4217         }
4218     }
4219 }
4220
4221 /* Process the argument list part of the signature, after any class spec
4222    has been consumed, as well as the first 'F' character (if any).  For
4223    example:
4224
4225    "__als__3fooRT0"             =>      process "RT0"
4226    "complexfunc5__FPFPc_PFl_i"  =>      process "PFPc_PFl_i"
4227
4228    DECLP must be already initialised, usually non-empty.  It won't be freed
4229    on failure.
4230
4231    Note that g++ differs significantly from ARM and lucid style mangling
4232    with regards to references to previously seen types.  For example, given
4233    the source fragment:
4234
4235      class foo {
4236        public:
4237        foo::foo (int, foo &ia, int, foo &ib, int, foo &ic);
4238      };
4239
4240      foo::foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
4241      void foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
4242
4243    g++ produces the names:
4244
4245      __3fooiRT0iT2iT2
4246      foo__FiR3fooiT1iT1
4247
4248    while lcc (and presumably other ARM style compilers as well) produces:
4249
4250      foo__FiR3fooT1T2T1T2
4251      __ct__3fooFiR3fooT1T2T1T2
4252
4253    Note that g++ bases its type numbers starting at zero and counts all
4254    previously seen types, while lucid/ARM bases its type numbers starting
4255    at one and only considers types after it has seen the 'F' character
4256    indicating the start of the function args.  For lucid/ARM style, we
4257    account for this difference by discarding any previously seen types when
4258    we see the 'F' character, and subtracting one from the type number
4259    reference.
4260
4261  */
4262
4263 static int
4264 demangle_args (struct work_stuff *work, const char **mangled,
4265                string *declp)
4266 {
4267   string arg;
4268   int need_comma = 0;
4269   int r;
4270   int t;
4271   const char *tem;
4272   char temptype;
4273
4274   if (PRINT_ARG_TYPES)
4275     {
4276       string_append (declp, "(");
4277       if (**mangled == '\0')
4278         {
4279           string_append (declp, "void");
4280         }
4281     }
4282
4283   while ((**mangled != '_' && **mangled != '\0' && **mangled != 'e')
4284          || work->nrepeats > 0)
4285     {
4286       if ((**mangled == 'N') || (**mangled == 'T'))
4287         {
4288           temptype = *(*mangled)++;
4289
4290           if (temptype == 'N')
4291             {
4292               if (!get_count (mangled, &r))
4293                 {
4294                   return (0);
4295                 }
4296             }
4297           else
4298             {
4299               r = 1;
4300             }
4301           if ((HP_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING) && work -> ntypes >= 10)
4302             {
4303               /* If we have 10 or more types we might have more than a 1 digit
4304                  index so we'll have to consume the whole count here. This
4305                  will lose if the next thing is a type name preceded by a
4306                  count but it's impossible to demangle that case properly
4307                  anyway. Eg if we already have 12 types is T12Pc "(..., type1,
4308                  Pc, ...)"  or "(..., type12, char *, ...)" */
4309               if ((t = consume_count(mangled)) <= 0)
4310                 {
4311                   return (0);
4312                 }
4313             }
4314           else
4315             {
4316               if (!get_count (mangled, &t))
4317                 {
4318                   return (0);
4319                 }
4320             }
4321           if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
4322             {
4323               t--;
4324             }
4325           /* Validate the type index.  Protect against illegal indices from
4326              malformed type strings.  */
4327           if ((t < 0) || (t >= work -> ntypes))
4328             {
4329               return (0);
4330             }
4331           while (work->nrepeats > 0 || --r >= 0)
4332             {
4333               tem = work -> typevec[t];
4334               if (need_comma && PRINT_ARG_TYPES)
4335                 {
4336                   string_append (declp, ", ");
4337                 }
4338               if (!do_arg (work, &tem, &arg))
4339                 {
4340                   return (0);
4341                 }
4342               if (PRINT_ARG_TYPES)
4343                 {
4344                   string_appends (declp, &arg);
4345                 }
4346               string_delete (&arg);
4347               need_comma = 1;
4348             }
4349         }
4350       else
4351         {
4352           if (need_comma && PRINT_ARG_TYPES)
4353             string_append (declp, ", ");
4354           if (!do_arg (work, mangled, &arg))
4355             return (0);
4356           if (PRINT_ARG_TYPES)
4357             string_appends (declp, &arg);
4358           string_delete (&arg);
4359           need_comma = 1;
4360         }
4361     }
4362
4363   if (**mangled == 'e')
4364     {
4365       (*mangled)++;
4366       if (PRINT_ARG_TYPES)
4367         {
4368           if (need_comma)
4369             {
4370               string_append (declp, ",");
4371             }
4372           string_append (declp, "...");
4373         }
4374     }
4375
4376   if (PRINT_ARG_TYPES)
4377     {
4378       string_append (declp, ")");
4379     }
4380   return (1);
4381 }
4382
4383 /* Like demangle_args, but for demangling the argument lists of function
4384    and method pointers or references, not top-level declarations.  */
4385
4386 static int
4387 demangle_nested_args (struct work_stuff *work, const char **mangled,
4388                       string *declp)
4389 {
4390   string* saved_previous_argument;
4391   int result;
4392   int saved_nrepeats;
4393
4394   /* The G++ name-mangling algorithm does not remember types on nested
4395      argument lists, unless -fsquangling is used, and in that case the
4396      type vector updated by remember_type is not used.  So, we turn
4397      off remembering of types here.  */
4398   ++work->forgetting_types;
4399
4400   /* For the repeat codes used with -fsquangling, we must keep track of
4401      the last argument.  */
4402   saved_previous_argument = work->previous_argument;
4403   saved_nrepeats = work->nrepeats;
4404   work->previous_argument = 0;
4405   work->nrepeats = 0;
4406
4407   /* Actually demangle the arguments.  */
4408   result = demangle_args (work, mangled, declp);
4409
4410   /* Restore the previous_argument field.  */
4411   if (work->previous_argument)
4412     {
4413       string_delete (work->previous_argument);
4414       free ((char *) work->previous_argument);
4415     }
4416   work->previous_argument = saved_previous_argument;
4417   --work->forgetting_types;
4418   work->nrepeats = saved_nrepeats;
4419
4420   return result;
4421 }
4422
4423 /* Returns 1 if a valid function name was found or 0 otherwise.  */
4424
4425 static int
4426 demangle_function_name (struct work_stuff *work, const char **mangled,
4427                         string *declp, const char *scan)
4428 {
4429   size_t i;
4430   string type;
4431   const char *tem;
4432
4433   string_appendn (declp, (*mangled), scan - (*mangled));
4434   string_need (declp, 1);
4435   *(declp -> p) = '\0';
4436
4437   /* Consume the function name, including the "__" separating the name
4438      from the signature.  We are guaranteed that SCAN points to the
4439      separator.  */
4440
4441   (*mangled) = scan + 2;
4442   /* We may be looking at an instantiation of a template function:
4443      foo__Xt1t2_Ft3t4, where t1, t2, ... are template arguments and a
4444      following _F marks the start of the function arguments.  Handle
4445      the template arguments first. */
4446
4447   if (HP_DEMANGLING && (**mangled == 'X'))
4448     {
4449       demangle_arm_hp_template (work, mangled, 0, declp);
4450       /* This leaves MANGLED pointing to the 'F' marking func args */
4451     }
4452
4453   if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
4454     {
4455
4456       /* See if we have an ARM style constructor or destructor operator.
4457          If so, then just record it, clear the decl, and return.
4458          We can't build the actual constructor/destructor decl until later,
4459          when we recover the class name from the signature.  */
4460
4461       if (strcmp (declp -> b, "__ct") == 0)
4462         {
4463           work -> constructor += 1;
4464           string_clear (declp);
4465           return 1;
4466         }
4467       else if (strcmp (declp -> b, "__dt") == 0)
4468         {
4469           work -> destructor += 1;
4470           string_clear (declp);
4471           return 1;
4472         }
4473     }
4474
4475   if (declp->p - declp->b >= 3
4476       && declp->b[0] == 'o'
4477       && declp->b[1] == 'p'
4478       && strchr (cplus_markers, declp->b[2]) != NULL)
4479     {
4480       /* see if it's an assignment expression */
4481       if (declp->p - declp->b >= 10 /* op$assign_ */
4482           && memcmp (declp->b + 3, "assign_", 7) == 0)
4483         {
4484           for (i = 0; i < ARRAY_SIZE (optable); i++)
4485             {
4486               int len = declp->p - declp->b - 10;
4487               if ((int) strlen (optable[i].in) == len
4488                   && memcmp (optable[i].in, declp->b + 10, len) == 0)
4489                 {
4490                   string_clear (declp);
4491                   string_append (declp, "operator");
4492                   string_append (declp, optable[i].out);
4493                   string_append (declp, "=");
4494                   break;
4495                 }
4496             }
4497         }
4498       else
4499         {
4500           for (i = 0; i < ARRAY_SIZE (optable); i++)
4501             {
4502               int len = declp->p - declp->b - 3;
4503               if ((int) strlen (optable[i].in) == len
4504                   && memcmp (optable[i].in, declp->b + 3, len) == 0)
4505                 {
4506                   string_clear (declp);
4507                   string_append (declp, "operator");
4508                   string_append (declp, optable[i].out);
4509                   break;
4510                 }
4511             }
4512         }
4513     }
4514   else if (declp->p - declp->b >= 5 && memcmp (declp->b, "type", 4) == 0
4515            && strchr (cplus_markers, declp->b[4]) != NULL)
4516     {
4517       /* type conversion operator */
4518       tem = declp->b + 5;
4519       if (do_type (work, &tem, &type))
4520         {
4521           string_clear (declp);
4522           string_append (declp, "operator ");
4523           string_appends (declp, &type);
4524           string_delete (&type);
4525         }
4526     }
4527   else if (declp->b[0] == '_' && declp->b[1] == '_'
4528            && declp->b[2] == 'o' && declp->b[3] == 'p')
4529     {
4530       /* ANSI.  */
4531       /* type conversion operator.  */
4532       tem = declp->b + 4;
4533       if (do_type (work, &tem, &type))
4534         {
4535           string_clear (declp);
4536           string_append (declp, "operator ");
4537           string_appends (declp, &type);
4538           string_delete (&type);
4539         }
4540     }
4541   else if (declp->b[0] == '_' && declp->b[1] == '_'
4542            && ISLOWER((unsigned char)declp->b[2])
4543            && ISLOWER((unsigned char)declp->b[3]))
4544     {
4545       if (declp->b[4] == '\0')
4546         {
4547           /* Operator.  */
4548           for (i = 0; i < ARRAY_SIZE (optable); i++)
4549             {
4550               if (strlen (optable[i].in) == 2
4551                   && memcmp (optable[i].in, declp->b + 2, 2) == 0)
4552                 {
4553                   string_clear (declp);
4554                   string_append (declp, "operator");
4555                   string_append (declp, optable[i].out);
4556                   break;
4557                 }
4558             }
4559         }
4560       else
4561         {
4562           if (declp->b[2] == 'a' && declp->b[5] == '\0')
4563             {
4564               /* Assignment.  */
4565               for (i = 0; i < ARRAY_SIZE (optable); i++)
4566                 {
4567                   if (strlen (optable[i].in) == 3
4568                       && memcmp (optable[i].in, declp->b + 2, 3) == 0)
4569                     {
4570                       string_clear (declp);
4571                       string_append (declp, "operator");
4572                       string_append (declp, optable[i].out);
4573                       break;
4574                     }
4575                 }
4576             }
4577         }
4578     }
4579
4580   /* If a function name was obtained but it's not valid, we were not
4581      successful.  */
4582   if (LEN_STRING (declp) == 1 && declp->b[0] == '.')
4583     return 0;
4584   else
4585     return 1;
4586 }
4587
4588 /* a mini string-handling package */
4589
4590 static void
4591 string_need (string *s, int n)
4592 {
4593   int tem;
4594
4595   if (s->b == NULL)
4596     {
4597       if (n < 32)
4598         {
4599           n = 32;
4600         }
4601       s->p = s->b = XNEWVEC (char, n);
4602       s->e = s->b + n;
4603     }
4604   else if (s->e - s->p < n)
4605     {
4606       tem = s->p - s->b;
4607       n += tem;
4608       n *= 2;
4609       s->b = XRESIZEVEC (char, s->b, n);
4610       s->p = s->b + tem;
4611       s->e = s->b + n;
4612     }
4613 }
4614
4615 static void
4616 string_delete (string *s)
4617 {
4618   if (s->b != NULL)
4619     {
4620       free (s->b);
4621       s->b = s->e = s->p = NULL;
4622     }
4623 }
4624
4625 static void
4626 string_init (string *s)
4627 {
4628   s->b = s->p = s->e = NULL;
4629 }
4630
4631 static void
4632 string_clear (string *s)
4633 {
4634   s->p = s->b;
4635 }
4636
4637 #if 0
4638
4639 static int
4640 string_empty (string *s)
4641 {
4642   return (s->b == s->p);
4643 }
4644
4645 #endif
4646
4647 static void
4648 string_append (string *p, const char *s)
4649 {
4650   int n;
4651   if (s == NULL || *s == '\0')
4652     return;
4653   n = strlen (s);
4654   string_need (p, n);
4655   memcpy (p->p, s, n);
4656   p->p += n;
4657 }
4658
4659 static void
4660 string_appends (string *p, string *s)
4661 {
4662   int n;
4663
4664   if (s->b != s->p)
4665     {
4666       n = s->p - s->b;
4667       string_need (p, n);
4668       memcpy (p->p, s->b, n);
4669       p->p += n;
4670     }
4671 }
4672
4673 static void
4674 string_appendn (string *p, const char *s, int n)
4675 {
4676   if (n != 0)
4677     {
4678       string_need (p, n);
4679       memcpy (p->p, s, n);
4680       p->p += n;
4681     }
4682 }
4683
4684 static void
4685 string_prepend (string *p, const char *s)
4686 {
4687   if (s != NULL && *s != '\0')
4688     {
4689       string_prependn (p, s, strlen (s));
4690     }
4691 }
4692
4693 static void
4694 string_prepends (string *p, string *s)
4695 {
4696   if (s->b != s->p)
4697     {
4698       string_prependn (p, s->b, s->p - s->b);
4699     }
4700 }
4701
4702 static void
4703 string_prependn (string *p, const char *s, int n)
4704 {
4705   char *q;
4706
4707   if (n != 0)
4708     {
4709       string_need (p, n);
4710       for (q = p->p - 1; q >= p->b; q--)
4711         {
4712           q[n] = q[0];
4713         }
4714       memcpy (p->b, s, n);
4715       p->p += n;
4716     }
4717 }
4718
4719 static void
4720 string_append_template_idx (string *s, int idx)
4721 {
4722   char buf[INTBUF_SIZE + 1 /* 'T' */];
4723   sprintf(buf, "T%d", idx);
4724   string_append (s, buf);
4725 }