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 char * malloc ();
  56 char * 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 void
 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     {
2497       demangle_function_name (work, mangled, declp, scan);
2498       return 1;
2499     }
2500
2501   /* Save state so we can restart if the guess at the correct "__" was
2502      wrong.  */
2503   string_init (&decl_init);
2504   string_appends (&decl_init, declp);
2505   memset (&work_init, 0, sizeof work_init);
2506   work_stuff_copy_to_from (&work_init, work);
2507
2508   /* Iterate over occurrences of __, allowing names and types to have a
2509      "__" sequence in them.  We must start with the first (not the last)
2510      occurrence, since "__" most often occur between independent mangled
2511      parts, hence starting at the last occurence inside a signature
2512      might get us a "successful" demangling of the signature.  */
2513
2514   while (scan[2])
2515     {
2516       demangle_function_name (work, mangled, declp, scan);
2517       success = demangle_signature (work, mangled, declp);
2518       if (success)
2519         break;
2520
2521       /* Reset demangle state for the next round.  */
2522       *mangled = mangle_init;
2523       string_clear (declp);
2524       string_appends (declp, &decl_init);
2525       work_stuff_copy_to_from (work, &work_init);
2526
2527       /* Leave this underscore-sequence.  */
2528       scan += 2;
2529
2530       /* Scan for the next "__" sequence.  */
2531       while (*scan && (scan[0] != '_' || scan[1] != '_'))
2532         scan++;
2533
2534       /* Move to last "__" in this sequence.  */
2535       while (*scan && *scan == '_')
2536         scan++;
2537       scan -= 2;
2538     }
2539
2540   /* Delete saved state.  */
2541   delete_work_stuff (&work_init);
2542   string_delete (&decl_init);
2543
2544   return success;
2545 }
2546
2547 /*
2548
2549 LOCAL FUNCTION
2550
2551         demangle_prefix -- consume the mangled name prefix and find signature
2552
2553 SYNOPSIS
2554
2555         static int
2556         demangle_prefix (struct work_stuff *work, const char **mangled,
2557                          string *declp);
2558
2559 DESCRIPTION
2560
2561         Consume and demangle the prefix of the mangled name.
2562         While processing the function name root, arrange to call
2563         demangle_signature if the root is ambiguous.
2564
2565         DECLP points to the string buffer into which demangled output is
2566         placed.  On entry, the buffer is empty.  On exit it contains
2567         the root function name, the demangled operator name, or in some
2568         special cases either nothing or the completely demangled result.
2569
2570         MANGLED points to the current pointer into the mangled name.  As each
2571         token of the mangled name is consumed, it is updated.  Upon entry
2572         the current mangled name pointer points to the first character of
2573         the mangled name.  Upon exit, it should point to the first character
2574         of the signature if demangling was successful, or to the first
2575         unconsumed character if demangling of the prefix was unsuccessful.
2576
2577         Returns 1 on success, 0 otherwise.
2578  */
2579
2580 static int
2581 demangle_prefix (struct work_stuff *work, const char **mangled,
2582                  string *declp)
2583 {
2584   int success = 1;
2585   const char *scan;
2586   int i;
2587
2588   if (strlen(*mangled) > 6
2589       && (strncmp(*mangled, "_imp__", 6) == 0
2590           || strncmp(*mangled, "__imp_", 6) == 0))
2591     {
2592       /* it's a symbol imported from a PE dynamic library. Check for both
2593          new style prefix _imp__ and legacy __imp_ used by older versions
2594          of dlltool. */
2595       (*mangled) += 6;
2596       work->dllimported = 1;
2597     }
2598   else if (strlen(*mangled) >= 11 && strncmp(*mangled, "_GLOBAL_", 8) == 0)
2599     {
2600       char *marker = strchr (cplus_markers, (*mangled)[8]);
2601       if (marker != NULL && *marker == (*mangled)[10])
2602         {
2603           if ((*mangled)[9] == 'D')
2604             {
2605               /* it's a GNU global destructor to be executed at program exit */
2606               (*mangled) += 11;
2607               work->destructor = 2;
2608               if (gnu_special (work, mangled, declp))
2609                 return success;
2610             }
2611           else if ((*mangled)[9] == 'I')
2612             {
2613               /* it's a GNU global constructor to be executed at program init */
2614               (*mangled) += 11;
2615               work->constructor = 2;
2616               if (gnu_special (work, mangled, declp))
2617                 return success;
2618             }
2619         }
2620     }
2621   else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__std__", 7) == 0)
2622     {
2623       /* it's a ARM global destructor to be executed at program exit */
2624       (*mangled) += 7;
2625       work->destructor = 2;
2626     }
2627   else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__sti__", 7) == 0)
2628     {
2629       /* it's a ARM global constructor to be executed at program initial */
2630       (*mangled) += 7;
2631       work->constructor = 2;
2632     }
2633
2634   /*  This block of code is a reduction in strength time optimization
2635       of:
2636       scan = strstr (*mangled, "__"); */
2637
2638   {
2639     scan = *mangled;
2640
2641     do {
2642       scan = strchr (scan, '_');
2643     } while (scan != NULL && *++scan != '_');
2644
2645     if (scan != NULL) --scan;
2646   }
2647
2648   if (scan != NULL)
2649     {
2650       /* We found a sequence of two or more '_', ensure that we start at
2651          the last pair in the sequence.  */
2652       i = strspn (scan, "_");
2653       if (i > 2)
2654         {
2655           scan += (i - 2);
2656         }
2657     }
2658
2659   if (scan == NULL)
2660     {
2661       success = 0;
2662     }
2663   else if (work -> static_type)
2664     {
2665       if (!ISDIGIT ((unsigned char)scan[0]) && (scan[0] != 't'))
2666         {
2667           success = 0;
2668         }
2669     }
2670   else if ((scan == *mangled)
2671            && (ISDIGIT ((unsigned char)scan[2]) || (scan[2] == 'Q')
2672                || (scan[2] == 't') || (scan[2] == 'K') || (scan[2] == 'H')))
2673     {
2674       /* The ARM says nothing about the mangling of local variables.
2675          But cfront mangles local variables by prepending __<nesting_level>
2676          to them. As an extension to ARM demangling we handle this case.  */
2677       if ((LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING)
2678           && ISDIGIT ((unsigned char)scan[2]))
2679         {
2680           *mangled = scan + 2;
2681           consume_count (mangled);
2682           string_append (declp, *mangled);
2683           *mangled += strlen (*mangled);
2684           success = 1;
2685         }
2686       else
2687         {
2688           /* A GNU style constructor starts with __[0-9Qt].  But cfront uses
2689              names like __Q2_3foo3bar for nested type names.  So don't accept
2690              this style of constructor for cfront demangling.  A GNU
2691              style member-template constructor starts with 'H'. */
2692           if (!(LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING))
2693             work -> constructor += 1;
2694           *mangled = scan + 2;
2695         }
2696     }
2697   else if (ARM_DEMANGLING && scan[2] == 'p' && scan[3] == 't')
2698     {
2699       /* Cfront-style parameterized type.  Handled later as a signature. */
2700       success = 1;
2701
2702       /* ARM template? */
2703       demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
2704     }
2705   else if (EDG_DEMANGLING && ((scan[2] == 't' && scan[3] == 'm')
2706                               || (scan[2] == 'p' && scan[3] == 's')
2707                               || (scan[2] == 'p' && scan[3] == 't')))
2708     {
2709       /* EDG-style parameterized type.  Handled later as a signature. */
2710       success = 1;
2711
2712       /* EDG template? */
2713       demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
2714     }
2715   else if ((scan == *mangled) && !ISDIGIT ((unsigned char)scan[2])
2716            && (scan[2] != 't'))
2717     {
2718       /* Mangled name starts with "__".  Skip over any leading '_' characters,
2719          then find the next "__" that separates the prefix from the signature.
2720          */
2721       if (!(ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
2722           || (arm_special (mangled, declp) == 0))
2723         {
2724           while (*scan == '_')
2725             {
2726               scan++;
2727             }
2728           if ((scan = strstr (scan, "__")) == NULL || (*(scan + 2) == '\0'))
2729             {
2730               /* No separator (I.E. "__not_mangled"), or empty signature
2731                  (I.E. "__not_mangled_either__") */
2732               success = 0;
2733             }
2734           else
2735             return iterate_demangle_function (work, mangled, declp, scan);
2736         }
2737     }
2738   else if (*(scan + 2) != '\0')
2739     {
2740       /* Mangled name does not start with "__" but does have one somewhere
2741          in there with non empty stuff after it.  Looks like a global
2742          function name.  Iterate over all "__":s until the right
2743          one is found.  */
2744       return iterate_demangle_function (work, mangled, declp, scan);
2745     }
2746   else
2747     {
2748       /* Doesn't look like a mangled name */
2749       success = 0;
2750     }
2751
2752   if (!success && (work->constructor == 2 || work->destructor == 2))
2753     {
2754       string_append (declp, *mangled);
2755       *mangled += strlen (*mangled);
2756       success = 1;
2757     }
2758   return (success);
2759 }
2760
2761 /*
2762
2763 LOCAL FUNCTION
2764
2765         gnu_special -- special handling of gnu mangled strings
2766
2767 SYNOPSIS
2768
2769         static int
2770         gnu_special (struct work_stuff *work, const char **mangled,
2771                      string *declp);
2772
2773
2774 DESCRIPTION
2775
2776         Process some special GNU style mangling forms that don't fit
2777         the normal pattern.  For example:
2778
2779                 _$_3foo         (destructor for class foo)
2780                 _vt$foo         (foo virtual table)
2781                 _vt$foo$bar     (foo::bar virtual table)
2782                 __vt_foo        (foo virtual table, new style with thunks)
2783                 _3foo$varname   (static data member)
2784                 _Q22rs2tu$vw    (static data member)
2785                 __t6vector1Zii  (constructor with template)
2786                 __thunk_4__$_7ostream (virtual function thunk)
2787  */
2788
2789 static int
2790 gnu_special (struct work_stuff *work, const char **mangled, string *declp)
2791 {
2792   int n;
2793   int success = 1;
2794   const char *p;
2795
2796   if ((*mangled)[0] == '_'
2797       && strchr (cplus_markers, (*mangled)[1]) != NULL
2798       && (*mangled)[2] == '_')
2799     {
2800       /* Found a GNU style destructor, get past "_<CPLUS_MARKER>_" */
2801       (*mangled) += 3;
2802       work -> destructor += 1;
2803     }
2804   else if ((*mangled)[0] == '_'
2805            && (((*mangled)[1] == '_'
2806                 && (*mangled)[2] == 'v'
2807                 && (*mangled)[3] == 't'
2808                 && (*mangled)[4] == '_')
2809                || ((*mangled)[1] == 'v'
2810                    && (*mangled)[2] == 't'
2811                    && strchr (cplus_markers, (*mangled)[3]) != NULL)))
2812     {
2813       /* Found a GNU style virtual table, get past "_vt<CPLUS_MARKER>"
2814          and create the decl.  Note that we consume the entire mangled
2815          input string, which means that demangle_signature has no work
2816          to do.  */
2817       if ((*mangled)[2] == 'v')
2818         (*mangled) += 5; /* New style, with thunks: "__vt_" */
2819       else
2820         (*mangled) += 4; /* Old style, no thunks: "_vt<CPLUS_MARKER>" */
2821       while (**mangled != '\0')
2822         {
2823           switch (**mangled)
2824             {
2825             case 'Q':
2826             case 'K':
2827               success = demangle_qualified (work, mangled, declp, 0, 1);
2828               break;
2829             case 't':
2830               success = demangle_template (work, mangled, declp, 0, 1,
2831                                            1);
2832               break;
2833             default:
2834               if (ISDIGIT((unsigned char)*mangled[0]))
2835                 {
2836                   n = consume_count(mangled);
2837                   /* We may be seeing a too-large size, or else a
2838                      ".<digits>" indicating a static local symbol.  In
2839                      any case, declare victory and move on; *don't* try
2840                      to use n to allocate.  */
2841                   if (n > (int) strlen (*mangled))
2842                     {
2843                       success = 1;
2844                       break;
2845                     }
2846                 }
2847               else
2848                 {
2849                   n = strcspn (*mangled, cplus_markers);
2850                 }
2851               string_appendn (declp, *mangled, n);
2852               (*mangled) += n;
2853             }
2854
2855           p = strpbrk (*mangled, cplus_markers);
2856           if (success && ((p == NULL) || (p == *mangled)))
2857             {
2858               if (p != NULL)
2859                 {
2860                   string_append (declp, SCOPE_STRING (work));
2861                   (*mangled)++;
2862                 }
2863             }
2864           else
2865             {
2866               success = 0;
2867               break;
2868             }
2869         }
2870       if (success)
2871         string_append (declp, " virtual table");
2872     }
2873   else if ((*mangled)[0] == '_'
2874            && (strchr("0123456789Qt", (*mangled)[1]) != NULL)
2875            && (p = strpbrk (*mangled, cplus_markers)) != NULL)
2876     {
2877       /* static data member, "_3foo$varname" for example */
2878       (*mangled)++;
2879       switch (**mangled)
2880         {
2881         case 'Q':
2882         case 'K':
2883           success = demangle_qualified (work, mangled, declp, 0, 1);
2884           break;
2885         case 't':
2886           success = demangle_template (work, mangled, declp, 0, 1, 1);
2887           break;
2888         default:
2889           n = consume_count (mangled);
2890           if (n < 0 || n > (long) strlen (*mangled))
2891             {
2892               success = 0;
2893               break;
2894             }
2895
2896           if (n > 10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
2897               && (*mangled)[9] == 'N'
2898               && (*mangled)[8] == (*mangled)[10]
2899               && strchr (cplus_markers, (*mangled)[8]))
2900             {
2901               /* A member of the anonymous namespace.  There's information
2902                  about what identifier or filename it was keyed to, but
2903                  it's just there to make the mangled name unique; we just
2904                  step over it.  */
2905               string_append (declp, "{anonymous}");
2906               (*mangled) += n;
2907
2908               /* Now p points to the marker before the N, so we need to
2909                  update it to the first marker after what we consumed.  */
2910               p = strpbrk (*mangled, cplus_markers);
2911               break;
2912             }
2913
2914           string_appendn (declp, *mangled, n);
2915           (*mangled) += n;
2916         }
2917       if (success && (p == *mangled))
2918         {
2919           /* Consumed everything up to the cplus_marker, append the
2920              variable name.  */
2921           (*mangled)++;
2922           string_append (declp, SCOPE_STRING (work));
2923           n = strlen (*mangled);
2924           string_appendn (declp, *mangled, n);
2925           (*mangled) += n;
2926         }
2927       else
2928         {
2929           success = 0;
2930         }
2931     }
2932   else if (strncmp (*mangled, "__thunk_", 8) == 0)
2933     {
2934       int delta;
2935
2936       (*mangled) += 8;
2937       delta = consume_count (mangled);
2938       if (delta == -1)
2939         success = 0;
2940       else
2941         {
2942           char *method = internal_cplus_demangle (work, ++*mangled);
2943
2944           if (method)
2945             {
2946               char buf[50];
2947               sprintf (buf, "virtual function thunk (delta:%d) for ", -delta);
2948               string_append (declp, buf);
2949               string_append (declp, method);
2950               free (method);
2951               n = strlen (*mangled);
2952               (*mangled) += n;
2953             }
2954           else
2955             {
2956               success = 0;
2957             }
2958         }
2959     }
2960   else if (strncmp (*mangled, "__t", 3) == 0
2961            && ((*mangled)[3] == 'i' || (*mangled)[3] == 'f'))
2962     {
2963       p = (*mangled)[3] == 'i' ? " type_info node" : " type_info function";
2964       (*mangled) += 4;
2965       switch (**mangled)
2966         {
2967         case 'Q':
2968         case 'K':
2969           success = demangle_qualified (work, mangled, declp, 0, 1);
2970           break;
2971         case 't':
2972           success = demangle_template (work, mangled, declp, 0, 1, 1);
2973           break;
2974         default:
2975           success = do_type (work, mangled, declp);
2976           break;
2977         }
2978       if (success && **mangled != '\0')
2979         success = 0;
2980       if (success)
2981         string_append (declp, p);
2982     }
2983   else
2984     {
2985       success = 0;
2986     }
2987   return (success);
2988 }
2989
2990 static void
2991 recursively_demangle(struct work_stuff *work, const char **mangled,
2992                      string *result, int namelength)
2993 {
2994   char * recurse = (char *)NULL;
2995   char * recurse_dem = (char *)NULL;
2996
2997   recurse = XNEWVEC (char, namelength + 1);
2998   memcpy (recurse, *mangled, namelength);
2999   recurse[namelength] = '\000';
3000
3001   recurse_dem = cplus_demangle (recurse, work->options);
3002
3003   if (recurse_dem)
3004     {
3005       string_append (result, recurse_dem);
3006       free (recurse_dem);
3007     }
3008   else
3009     {
3010       string_appendn (result, *mangled, namelength);
3011     }
3012   free (recurse);
3013   *mangled += namelength;
3014 }
3015
3016 /*
3017
3018 LOCAL FUNCTION
3019
3020         arm_special -- special handling of ARM/lucid mangled strings
3021
3022 SYNOPSIS
3023
3024         static int
3025         arm_special (const char **mangled,
3026                      string *declp);
3027
3028
3029 DESCRIPTION
3030
3031         Process some special ARM style mangling forms that don't fit
3032         the normal pattern.  For example:
3033
3034                 __vtbl__3foo            (foo virtual table)
3035                 __vtbl__3foo__3bar      (bar::foo virtual table)
3036
3037  */
3038
3039 static int
3040 arm_special (const char **mangled, string *declp)
3041 {
3042   int n;
3043   int success = 1;
3044   const char *scan;
3045
3046   if (strncmp (*mangled, ARM_VTABLE_STRING, ARM_VTABLE_STRLEN) == 0)
3047     {
3048       /* Found a ARM style virtual table, get past ARM_VTABLE_STRING
3049          and create the decl.  Note that we consume the entire mangled
3050          input string, which means that demangle_signature has no work
3051          to do.  */
3052       scan = *mangled + ARM_VTABLE_STRLEN;
3053       while (*scan != '\0')        /* first check it can be demangled */
3054         {
3055           n = consume_count (&scan);
3056           if (n == -1)
3057             {
3058               return (0);           /* no good */
3059             }
3060           scan += n;
3061           if (scan[0] == '_' && scan[1] == '_')
3062             {
3063               scan += 2;
3064             }
3065         }
3066       (*mangled) += ARM_VTABLE_STRLEN;
3067       while (**mangled != '\0')
3068         {
3069           n = consume_count (mangled);
3070           if (n == -1
3071               || n > (long) strlen (*mangled))
3072             return 0;
3073           string_prependn (declp, *mangled, n);
3074           (*mangled) += n;
3075           if ((*mangled)[0] == '_' && (*mangled)[1] == '_')
3076             {
3077               string_prepend (declp, "::");
3078               (*mangled) += 2;
3079             }
3080         }
3081       string_append (declp, " virtual table");
3082     }
3083   else
3084     {
3085       success = 0;
3086     }
3087   return (success);
3088 }
3089
3090 /*
3091
3092 LOCAL FUNCTION
3093
3094         demangle_qualified -- demangle 'Q' qualified name strings
3095
3096 SYNOPSIS
3097
3098         static int
3099         demangle_qualified (struct work_stuff *, const char *mangled,
3100                             string *result, int isfuncname, int append);
3101
3102 DESCRIPTION
3103
3104         Demangle a qualified name, such as "Q25Outer5Inner" which is
3105         the mangled form of "Outer::Inner".  The demangled output is
3106         prepended or appended to the result string according to the
3107         state of the append flag.
3108
3109         If isfuncname is nonzero, then the qualified name we are building
3110         is going to be used as a member function name, so if it is a
3111         constructor or destructor function, append an appropriate
3112         constructor or destructor name.  I.E. for the above example,
3113         the result for use as a constructor is "Outer::Inner::Inner"
3114         and the result for use as a destructor is "Outer::Inner::~Inner".
3115
3116 BUGS
3117
3118         Numeric conversion is ASCII dependent (FIXME).
3119
3120  */
3121
3122 static int
3123 demangle_qualified (struct work_stuff *work, const char **mangled,
3124                     string *result, int isfuncname, int append)
3125 {
3126   int qualifiers = 0;
3127   int success = 1;
3128   char num[2];
3129   string temp;
3130   string last_name;
3131   int bindex = register_Btype (work);
3132
3133   /* We only make use of ISFUNCNAME if the entity is a constructor or
3134      destructor.  */
3135   isfuncname = (isfuncname
3136                 && ((work->constructor & 1) || (work->destructor & 1)));
3137
3138   string_init (&temp);
3139   string_init (&last_name);
3140
3141   if ((*mangled)[0] == 'K')
3142     {
3143     /* Squangling qualified name reuse */
3144       int idx;
3145       (*mangled)++;
3146       idx = consume_count_with_underscores (mangled);
3147       if (idx == -1 || idx >= work -> numk)
3148         success = 0;
3149       else
3150         string_append (&temp, work -> ktypevec[idx]);
3151     }
3152   else
3153     switch ((*mangled)[1])
3154     {
3155     case '_':
3156       /* GNU mangled name with more than 9 classes.  The count is preceded
3157          by an underscore (to distinguish it from the <= 9 case) and followed
3158          by an underscore.  */
3159       (*mangled)++;
3160       qualifiers = consume_count_with_underscores (mangled);
3161       if (qualifiers == -1)
3162         success = 0;
3163       break;
3164
3165     case '1':
3166     case '2':
3167     case '3':
3168     case '4':
3169     case '5':
3170     case '6':
3171     case '7':
3172     case '8':
3173     case '9':
3174       /* The count is in a single digit.  */
3175       num[0] = (*mangled)[1];
3176       num[1] = '\0';
3177       qualifiers = atoi (num);
3178
3179       /* If there is an underscore after the digit, skip it.  This is
3180          said to be for ARM-qualified names, but the ARM makes no
3181          mention of such an underscore.  Perhaps cfront uses one.  */
3182       if ((*mangled)[2] == '_')
3183         {
3184           (*mangled)++;
3185         }
3186       (*mangled) += 2;
3187       break;
3188
3189     case '0':
3190     default:
3191       success = 0;
3192     }
3193
3194   if (!success)
3195     return success;
3196
3197   /* Pick off the names and collect them in the temp buffer in the order
3198      in which they are found, separated by '::'.  */
3199
3200   while (qualifiers-- > 0)
3201     {
3202       int remember_K = 1;
3203       string_clear (&last_name);
3204
3205       if (*mangled[0] == '_')
3206         (*mangled)++;
3207
3208       if (*mangled[0] == 't')
3209         {
3210           /* Here we always append to TEMP since we will want to use
3211              the template name without the template parameters as a
3212              constructor or destructor name.  The appropriate
3213              (parameter-less) value is returned by demangle_template
3214              in LAST_NAME.  We do not remember the template type here,
3215              in order to match the G++ mangling algorithm.  */
3216           success = demangle_template(work, mangled, &temp,
3217                                       &last_name, 1, 0);
3218           if (!success)
3219             break;
3220         }
3221       else if (*mangled[0] == 'K')
3222         {
3223           int idx;
3224           (*mangled)++;
3225           idx = consume_count_with_underscores (mangled);
3226           if (idx == -1 || idx >= work->numk)
3227             success = 0;
3228           else
3229             string_append (&temp, work->ktypevec[idx]);
3230           remember_K = 0;
3231
3232           if (!success) break;
3233         }
3234       else
3235         {
3236           if (EDG_DEMANGLING)
3237             {
3238               int namelength;
3239               /* Now recursively demangle the qualifier
3240                * This is necessary to deal with templates in
3241                * mangling styles like EDG */
3242               namelength = consume_count (mangled);
3243               if (namelength == -1)
3244                 {
3245                   success = 0;
3246                   break;
3247                 }
3248               recursively_demangle(work, mangled, &temp, namelength);
3249             }
3250           else
3251             {
3252               string_delete (&last_name);
3253               success = do_type (work, mangled, &last_name);
3254               if (!success)
3255                 break;
3256               string_appends (&temp, &last_name);
3257             }
3258         }
3259
3260       if (remember_K)
3261         remember_Ktype (work, temp.b, LEN_STRING (&temp));
3262
3263       if (qualifiers > 0)
3264         string_append (&temp, SCOPE_STRING (work));
3265     }
3266
3267   remember_Btype (work, temp.b, LEN_STRING (&temp), bindex);
3268
3269   /* If we are using the result as a function name, we need to append
3270      the appropriate '::' separated constructor or destructor name.
3271      We do this here because this is the most convenient place, where
3272      we already have a pointer to the name and the length of the name.  */
3273
3274   if (isfuncname)
3275     {
3276       string_append (&temp, SCOPE_STRING (work));
3277       if (work -> destructor & 1)
3278         string_append (&temp, "~");
3279       string_appends (&temp, &last_name);
3280     }
3281
3282   /* Now either prepend the temp buffer to the result, or append it,
3283      depending upon the state of the append flag.  */
3284
3285   if (append)
3286     string_appends (result, &temp);
3287   else
3288     {
3289       if (!STRING_EMPTY (result))
3290         string_append (&temp, SCOPE_STRING (work));
3291       string_prepends (result, &temp);
3292     }
3293
3294   string_delete (&last_name);
3295   string_delete (&temp);
3296   return (success);
3297 }
3298
3299 /*
3300
3301 LOCAL FUNCTION
3302
3303         get_count -- convert an ascii count to integer, consuming tokens
3304
3305 SYNOPSIS
3306
3307         static int
3308         get_count (const char **type, int *count)
3309
3310 DESCRIPTION
3311
3312         Assume that *type points at a count in a mangled name; set
3313         *count to its value, and set *type to the next character after
3314         the count.  There are some weird rules in effect here.
3315
3316         If *type does not point at a string of digits, return zero.
3317
3318         If *type points at a string of digits followed by an
3319         underscore, set *count to their value as an integer, advance
3320         *type to point *after the underscore, and return 1.
3321
3322         If *type points at a string of digits not followed by an
3323         underscore, consume only the first digit.  Set *count to its
3324         value as an integer, leave *type pointing after that digit,
3325         and return 1.
3326
3327         The excuse for this odd behavior: in the ARM and HP demangling
3328         styles, a type can be followed by a repeat count of the form
3329         `Nxy', where:
3330
3331         `x' is a single digit specifying how many additional copies
3332             of the type to append to the argument list, and
3333
3334         `y' is one or more digits, specifying the zero-based index of
3335             the first repeated argument in the list.  Yes, as you're
3336             unmangling the name you can figure this out yourself, but
3337             it's there anyway.
3338
3339         So, for example, in `bar__3fooFPiN51', the first argument is a
3340         pointer to an integer (`Pi'), and then the next five arguments
3341         are the same (`N5'), and the first repeat is the function's
3342         second argument (`1').
3343 */
3344
3345 static int
3346 get_count (const char **type, int *count)
3347 {
3348   const char *p;
3349   int n;
3350
3351   if (!ISDIGIT ((unsigned char)**type))
3352     return (0);
3353   else
3354     {
3355       *count = **type - '0';
3356       (*type)++;
3357       if (ISDIGIT ((unsigned char)**type))
3358         {
3359           p = *type;
3360           n = *count;
3361           do
3362             {
3363               n *= 10;
3364               n += *p - '0';
3365               p++;
3366             }
3367           while (ISDIGIT ((unsigned char)*p));
3368           if (*p == '_')
3369             {
3370               *type = p + 1;
3371               *count = n;
3372             }
3373         }
3374     }
3375   return (1);
3376 }
3377
3378 /* RESULT will be initialised here; it will be freed on failure.  The
3379    value returned is really a type_kind_t.  */
3380
3381 static int
3382 do_type (struct work_stuff *work, const char **mangled, string *result)
3383 {
3384   int n;
3385   int done;
3386   int success;
3387   string decl;
3388   const char *remembered_type;
3389   int type_quals;
3390   type_kind_t tk = tk_none;
3391
3392   string_init (&decl);
3393   string_init (result);
3394
3395   done = 0;
3396   success = 1;
3397   while (success && !done)
3398     {
3399       int member;
3400       switch (**mangled)
3401         {
3402
3403           /* A pointer type */
3404         case 'P':
3405         case 'p':
3406           (*mangled)++;
3407           if (! (work -> options & DMGL_JAVA))
3408             string_prepend (&decl, "*");
3409           if (tk == tk_none)
3410             tk = tk_pointer;
3411           break;
3412
3413           /* A reference type */
3414         case 'R':
3415           (*mangled)++;
3416           string_prepend (&decl, "&");
3417           if (tk == tk_none)
3418             tk = tk_reference;
3419           break;
3420
3421           /* An array */
3422         case 'A':
3423           {
3424             ++(*mangled);
3425             if (!STRING_EMPTY (&decl)
3426                 && (decl.b[0] == '*' || decl.b[0] == '&'))
3427               {
3428                 string_prepend (&decl, "(");
3429                 string_append (&decl, ")");
3430               }
3431             string_append (&decl, "[");
3432             if (**mangled != '_')
3433               success = demangle_template_value_parm (work, mangled, &decl,
3434                                                       tk_integral);
3435             if (**mangled == '_')
3436               ++(*mangled);
3437             string_append (&decl, "]");
3438             break;
3439           }
3440
3441         /* A back reference to a previously seen type */
3442         case 'T':
3443           (*mangled)++;
3444           if (!get_count (mangled, &n) || n >= work -> ntypes)
3445             {
3446               success = 0;
3447             }
3448           else
3449             {
3450               remembered_type = work -> typevec[n];
3451               mangled = &remembered_type;
3452             }
3453           break;
3454
3455           /* A function */
3456         case 'F':
3457           (*mangled)++;
3458             if (!STRING_EMPTY (&decl)
3459                 && (decl.b[0] == '*' || decl.b[0] == '&'))
3460             {
3461               string_prepend (&decl, "(");
3462               string_append (&decl, ")");
3463             }
3464           /* After picking off the function args, we expect to either find the
3465              function return type (preceded by an '_') or the end of the
3466              string.  */
3467           if (!demangle_nested_args (work, mangled, &decl)
3468               || (**mangled != '_' && **mangled != '\0'))
3469             {
3470               success = 0;
3471               break;
3472             }
3473           if (success && (**mangled == '_'))
3474             (*mangled)++;
3475           break;
3476
3477         case 'M':
3478         case 'O':
3479           {
3480             type_quals = TYPE_UNQUALIFIED;
3481
3482             member = **mangled == 'M';
3483             (*mangled)++;
3484
3485             string_append (&decl, ")");
3486
3487             /* We don't need to prepend `::' for a qualified name;
3488                demangle_qualified will do that for us.  */
3489             if (**mangled != 'Q')
3490               string_prepend (&decl, SCOPE_STRING (work));
3491
3492             if (ISDIGIT ((unsigned char)**mangled))
3493               {
3494                 n = consume_count (mangled);
3495                 if (n == -1
3496                     || (int) strlen (*mangled) < n)
3497                   {
3498                     success = 0;
3499                     break;
3500                   }
3501                 string_prependn (&decl, *mangled, n);
3502                 *mangled += n;
3503               }
3504             else if (**mangled == 'X' || **mangled == 'Y')
3505               {
3506                 string temp;
3507                 do_type (work, mangled, &temp);
3508                 string_prepends (&decl, &temp);
3509                 string_delete (&temp);
3510               }
3511             else if (**mangled == 't')
3512               {
3513                 string temp;
3514                 string_init (&temp);
3515                 success = demangle_template (work, mangled, &temp,
3516                                              NULL, 1, 1);
3517                 if (success)
3518                   {
3519                     string_prependn (&decl, temp.b, temp.p - temp.b);
3520                     string_delete (&temp);
3521                   }
3522                 else
3523                   break;
3524               }
3525             else if (**mangled == 'Q')
3526               {
3527                 success = demangle_qualified (work, mangled, &decl,
3528                                               /*isfuncnam=*/0,
3529                                               /*append=*/0);
3530                 if (!success)
3531                   break;
3532               }
3533             else
3534               {
3535                 success = 0;
3536                 break;
3537               }
3538
3539             string_prepend (&decl, "(");
3540             if (member)
3541               {
3542                 switch (**mangled)
3543                   {
3544                   case 'C':
3545                   case 'V':
3546                   case 'u':
3547                     type_quals |= code_for_qualifier (**mangled);
3548                     (*mangled)++;
3549                     break;
3550
3551                   default:
3552                     break;
3553                   }
3554
3555                 if (*(*mangled)++ != 'F')
3556                   {
3557                     success = 0;
3558                     break;
3559                   }
3560               }
3561             if ((member && !demangle_nested_args (work, mangled, &decl))
3562                 || **mangled != '_')
3563               {
3564                 success = 0;
3565                 break;
3566               }
3567             (*mangled)++;
3568             if (! PRINT_ANSI_QUALIFIERS)
3569               {
3570                 break;
3571               }
3572             if (type_quals != TYPE_UNQUALIFIED)
3573               {
3574                 APPEND_BLANK (&decl);
3575                 string_append (&decl, qualifier_string (type_quals));
3576               }
3577             break;
3578           }
3579         case 'G':
3580           (*mangled)++;
3581           break;
3582
3583         case 'C':
3584         case 'V':
3585         case 'u':
3586           if (PRINT_ANSI_QUALIFIERS)
3587             {
3588               if (!STRING_EMPTY (&decl))
3589                 string_prepend (&decl, " ");
3590
3591               string_prepend (&decl, demangle_qualifier (**mangled));
3592             }
3593           (*mangled)++;
3594           break;
3595           /*
3596             }
3597             */
3598
3599           /* fall through */
3600         default:
3601           done = 1;
3602           break;
3603         }
3604     }
3605
3606   if (success) switch (**mangled)
3607     {
3608       /* A qualified name, such as "Outer::Inner".  */
3609     case 'Q':
3610     case 'K':
3611       {
3612         success = demangle_qualified (work, mangled, result, 0, 1);
3613         break;
3614       }
3615
3616     /* A back reference to a previously seen squangled type */
3617     case 'B':
3618       (*mangled)++;
3619       if (!get_count (mangled, &n) || n >= work -> numb)
3620         success = 0;
3621       else
3622         string_append (result, work->btypevec[n]);
3623       break;
3624
3625     case 'X':
3626     case 'Y':
3627       /* A template parm.  We substitute the corresponding argument. */
3628       {
3629         int idx;
3630
3631         (*mangled)++;
3632         idx = consume_count_with_underscores (mangled);
3633
3634         if (idx == -1
3635             || (work->tmpl_argvec && idx >= work->ntmpl_args)
3636             || consume_count_with_underscores (mangled) == -1)
3637           {
3638             success = 0;
3639             break;
3640           }
3641
3642         if (work->tmpl_argvec)
3643           string_append (result, work->tmpl_argvec[idx]);
3644         else
3645           string_append_template_idx (result, idx);
3646
3647         success = 1;
3648       }
3649     break;
3650
3651     default:
3652       success = demangle_fund_type (work, mangled, result);
3653       if (tk == tk_none)
3654         tk = (type_kind_t) success;
3655       break;
3656     }
3657
3658   if (success)
3659     {
3660       if (!STRING_EMPTY (&decl))
3661         {
3662           string_append (result, " ");
3663           string_appends (result, &decl);
3664         }
3665     }
3666   else
3667     string_delete (result);
3668   string_delete (&decl);
3669
3670   if (success)
3671     /* Assume an integral type, if we're not sure.  */
3672     return (int) ((tk == tk_none) ? tk_integral : tk);
3673   else
3674     return 0;
3675 }
3676
3677 /* Given a pointer to a type string that represents a fundamental type
3678    argument (int, long, unsigned int, etc) in TYPE, a pointer to the
3679    string in which the demangled output is being built in RESULT, and
3680    the WORK structure, decode the types and add them to the result.
3681
3682    For example:
3683
3684         "Ci"    =>      "const int"
3685         "Sl"    =>      "signed long"
3686         "CUs"   =>      "const unsigned short"
3687
3688    The value returned is really a type_kind_t.  */
3689
3690 static int
3691 demangle_fund_type (struct work_stuff *work,
3692                     const char **mangled, string *result)
3693 {
3694   int done = 0;
3695   int success = 1;
3696   char buf[10];
3697   unsigned int dec = 0;
3698   type_kind_t tk = tk_integral;
3699
3700   /* First pick off any type qualifiers.  There can be more than one.  */
3701
3702   while (!done)
3703     {
3704       switch (**mangled)
3705         {
3706         case 'C':
3707         case 'V':
3708         case 'u':
3709           if (PRINT_ANSI_QUALIFIERS)
3710             {
3711               if (!STRING_EMPTY (result))
3712                 string_prepend (result, " ");
3713               string_prepend (result, demangle_qualifier (**mangled));
3714             }
3715           (*mangled)++;
3716           break;
3717         case 'U':
3718           (*mangled)++;
3719           APPEND_BLANK (result);
3720           string_append (result, "unsigned");
3721           break;
3722         case 'S': /* signed char only */
3723           (*mangled)++;
3724           APPEND_BLANK (result);
3725           string_append (result, "signed");
3726           break;
3727         case 'J':
3728           (*mangled)++;
3729           APPEND_BLANK (result);
3730           string_append (result, "__complex");
3731           break;
3732         default:
3733           done = 1;
3734           break;
3735         }
3736     }
3737
3738   /* Now pick off the fundamental type.  There can be only one.  */
3739
3740   switch (**mangled)
3741     {
3742     case '\0':
3743     case '_':
3744       break;
3745     case 'v':
3746       (*mangled)++;
3747       APPEND_BLANK (result);
3748       string_append (result, "void");
3749       break;
3750     case 'x':
3751       (*mangled)++;
3752       APPEND_BLANK (result);
3753       string_append (result, "long long");
3754       break;
3755     case 'l':
3756       (*mangled)++;
3757       APPEND_BLANK (result);
3758       string_append (result, "long");
3759       break;
3760     case 'i':
3761       (*mangled)++;
3762       APPEND_BLANK (result);
3763       string_append (result, "int");
3764       break;
3765     case 's':
3766       (*mangled)++;
3767       APPEND_BLANK (result);
3768       string_append (result, "short");
3769       break;
3770     case 'b':
3771       (*mangled)++;
3772       APPEND_BLANK (result);
3773       string_append (result, "bool");
3774       tk = tk_bool;
3775       break;
3776     case 'c':
3777       (*mangled)++;
3778       APPEND_BLANK (result);
3779       string_append (result, "char");
3780       tk = tk_char;
3781       break;
3782     case 'w':
3783       (*mangled)++;
3784       APPEND_BLANK (result);
3785       string_append (result, "wchar_t");
3786       tk = tk_char;
3787       break;
3788     case 'r':
3789       (*mangled)++;
3790       APPEND_BLANK (result);
3791       string_append (result, "long double");
3792       tk = tk_real;
3793       break;
3794     case 'd':
3795       (*mangled)++;
3796       APPEND_BLANK (result);
3797       string_append (result, "double");
3798       tk = tk_real;
3799       break;
3800     case 'f':
3801       (*mangled)++;
3802       APPEND_BLANK (result);
3803       string_append (result, "float");
3804       tk = tk_real;
3805       break;
3806     case 'G':
3807       (*mangled)++;
3808       if (!ISDIGIT ((unsigned char)**mangled))
3809         {
3810           success = 0;
3811           break;
3812         }
3813     case 'I':
3814       (*mangled)++;
3815       if (**mangled == '_')
3816         {
3817           int i;
3818           (*mangled)++;
3819           for (i = 0;
3820                i < (long) sizeof (buf) - 1 && **mangled && **mangled != '_';
3821                (*mangled)++, i++)
3822             buf[i] = **mangled;
3823           if (**mangled != '_')
3824             {
3825               success = 0;
3826               break;
3827             }
3828           buf[i] = '\0';
3829           (*mangled)++;
3830         }
3831       else
3832         {
3833           strncpy (buf, *mangled, 2);
3834           buf[2] = '\0';
3835           *mangled += min (strlen (*mangled), 2);
3836         }
3837       sscanf (buf, "%x", &dec);
3838       sprintf (buf, "int%u_t", dec);
3839       APPEND_BLANK (result);
3840       string_append (result, buf);
3841       break;
3842
3843       /* fall through */
3844       /* An explicit type, such as "6mytype" or "7integer" */
3845     case '0':
3846     case '1':
3847     case '2':
3848     case '3':
3849     case '4':
3850     case '5':
3851     case '6':
3852     case '7':
3853     case '8':
3854     case '9':
3855       {
3856         int bindex = register_Btype (work);
3857         string btype;
3858         string_init (&btype);
3859         if (demangle_class_name (work, mangled, &btype)) {
3860           remember_Btype (work, btype.b, LEN_STRING (&btype), bindex);
3861           APPEND_BLANK (result);
3862           string_appends (result, &btype);
3863         }
3864         else
3865           success = 0;
3866         string_delete (&btype);
3867         break;
3868       }
3869     case 't':
3870       {
3871         string btype;
3872         string_init (&btype);
3873         success = demangle_template (work, mangled, &btype, 0, 1, 1);
3874         string_appends (result, &btype);
3875         string_delete (&btype);
3876         break;
3877       }
3878     default:
3879       success = 0;
3880       break;
3881     }
3882
3883   return success ? ((int) tk) : 0;
3884 }
3885
3886
3887 /* Handle a template's value parameter for HP aCC (extension from ARM)
3888    **mangled points to 'S' or 'U' */
3889
3890 static int
3891 do_hpacc_template_const_value (struct work_stuff *work ATTRIBUTE_UNUSED,
3892                                const char **mangled, string *result)
3893 {
3894   int unsigned_const;
3895
3896   if (**mangled != 'U' && **mangled != 'S')
3897     return 0;
3898
3899   unsigned_const = (**mangled == 'U');
3900
3901   (*mangled)++;
3902
3903   switch (**mangled)
3904     {
3905       case 'N':
3906         string_append (result, "-");
3907         /* fall through */
3908       case 'P':
3909         (*mangled)++;
3910         break;
3911       case 'M':
3912         /* special case for -2^31 */
3913         string_append (result, "-2147483648");
3914         (*mangled)++;
3915         return 1;
3916       default:
3917         return 0;
3918     }
3919
3920   /* We have to be looking at an integer now */
3921   if (!(ISDIGIT ((unsigned char)**mangled)))
3922     return 0;
3923
3924   /* We only deal with integral values for template
3925      parameters -- so it's OK to look only for digits */
3926   while (ISDIGIT ((unsigned char)**mangled))
3927     {
3928       char_str[0] = **mangled;
3929       string_append (result, char_str);
3930       (*mangled)++;
3931     }
3932
3933   if (unsigned_const)
3934     string_append (result, "U");
3935
3936   /* FIXME? Some day we may have 64-bit (or larger :-) ) constants
3937      with L or LL suffixes. pai/1997-09-03 */
3938
3939   return 1; /* success */
3940 }
3941
3942 /* Handle a template's literal parameter for HP aCC (extension from ARM)
3943    **mangled is pointing to the 'A' */
3944
3945 static int
3946 do_hpacc_template_literal (struct work_stuff *work, const char **mangled,
3947                            string *result)
3948 {
3949   int literal_len = 0;
3950   char * recurse;
3951   char * recurse_dem;
3952
3953   if (**mangled != 'A')
3954     return 0;
3955
3956   (*mangled)++;
3957
3958   literal_len = consume_count (mangled);
3959
3960   if (literal_len <= 0)
3961     return 0;
3962
3963   /* Literal parameters are names of arrays, functions, etc.  and the
3964      canonical representation uses the address operator */
3965   string_append (result, "&");
3966
3967   /* Now recursively demangle the literal name */
3968   recurse = XNEWVEC (char, literal_len + 1);
3969   memcpy (recurse, *mangled, literal_len);
3970   recurse[literal_len] = '\000';
3971
3972   recurse_dem = cplus_demangle (recurse, work->options);
3973
3974   if (recurse_dem)
3975     {
3976       string_append (result, recurse_dem);
3977       free (recurse_dem);
3978     }
3979   else
3980     {
3981       string_appendn (result, *mangled, literal_len);
3982     }
3983   (*mangled) += literal_len;
3984   free (recurse);
3985
3986   return 1;
3987 }
3988
3989 static int
3990 snarf_numeric_literal (const char **args, string *arg)
3991 {
3992   if (**args == '-')
3993     {
3994       char_str[0] = '-';
3995       string_append (arg, char_str);
3996       (*args)++;
3997     }
3998   else if (**args == '+')
3999     (*args)++;
4000
4001   if (!ISDIGIT ((unsigned char)**args))
4002     return 0;
4003
4004   while (ISDIGIT ((unsigned char)**args))
4005     {
4006       char_str[0] = **args;
4007       string_append (arg, char_str);
4008       (*args)++;
4009     }
4010
4011   return 1;
4012 }
4013
4014 /* Demangle the next argument, given by MANGLED into RESULT, which
4015    *should be an uninitialized* string.  It will be initialized here,
4016    and free'd should anything go wrong.  */
4017
4018 static int
4019 do_arg (struct work_stuff *work, const char **mangled, string *result)
4020 {
4021   /* Remember where we started so that we can record the type, for
4022      non-squangling type remembering.  */
4023   const char *start = *mangled;
4024
4025   string_init (result);
4026
4027   if (work->nrepeats > 0)
4028     {
4029       --work->nrepeats;
4030
4031       if (work->previous_argument == 0)
4032         return 0;
4033
4034       /* We want to reissue the previous type in this argument list.  */
4035       string_appends (result, work->previous_argument);
4036       return 1;
4037     }
4038
4039   if (**mangled == 'n')
4040     {
4041       /* A squangling-style repeat.  */
4042       (*mangled)++;
4043       work->nrepeats = consume_count(mangled);
4044
4045       if (work->nrepeats <= 0)
4046         /* This was not a repeat count after all.  */
4047         return 0;
4048
4049       if (work->nrepeats > 9)
4050         {
4051           if (**mangled != '_')
4052             /* The repeat count should be followed by an '_' in this
4053                case.  */
4054             return 0;
4055           else
4056             (*mangled)++;
4057         }
4058
4059       /* Now, the repeat is all set up.  */
4060       return do_arg (work, mangled, result);
4061     }
4062
4063   /* Save the result in WORK->previous_argument so that we can find it
4064      if it's repeated.  Note that saving START is not good enough: we
4065      do not want to add additional types to the back-referenceable
4066      type vector when processing a repeated type.  */
4067   if (work->previous_argument)
4068     string_delete (work->previous_argument);
4069   else
4070     work->previous_argument = XNEW (string);
4071
4072   if (!do_type (work, mangled, work->previous_argument))
4073     return 0;
4074
4075   string_appends (result, work->previous_argument);
4076
4077   remember_type (work, start, *mangled - start);
4078   return 1;
4079 }
4080
4081 static void
4082 remember_type (struct work_stuff *work, const char *start, int len)
4083 {
4084   char *tem;
4085
4086   if (work->forgetting_types)
4087     return;
4088
4089   if (work -> ntypes >= work -> typevec_size)
4090     {
4091       if (work -> typevec_size == 0)
4092         {
4093           work -> typevec_size = 3;
4094           work -> typevec = XNEWVEC (char *, work->typevec_size);
4095         }
4096       else
4097         {
4098           work -> typevec_size *= 2;
4099           work -> typevec
4100             = XRESIZEVEC (char *, work->typevec, work->typevec_size);
4101         }
4102     }
4103   tem = XNEWVEC (char, len + 1);
4104   memcpy (tem, start, len);
4105   tem[len] = '\0';
4106   work -> typevec[work -> ntypes++] = tem;
4107 }
4108
4109
4110 /* Remember a K type class qualifier. */
4111 static void
4112 remember_Ktype (struct work_stuff *work, const char *start, int len)
4113 {
4114   char *tem;
4115
4116   if (work -> numk >= work -> ksize)
4117     {
4118       if (work -> ksize == 0)
4119         {
4120           work -> ksize = 5;
4121           work -> ktypevec = XNEWVEC (char *, work->ksize);
4122         }
4123       else
4124         {
4125           work -> ksize *= 2;
4126           work -> ktypevec
4127             = XRESIZEVEC (char *, work->ktypevec, work->ksize);
4128         }
4129     }
4130   tem = XNEWVEC (char, len + 1);
4131   memcpy (tem, start, len);
4132   tem[len] = '\0';
4133   work -> ktypevec[work -> numk++] = tem;
4134 }
4135
4136 /* Register a B code, and get an index for it. B codes are registered
4137    as they are seen, rather than as they are completed, so map<temp<char> >
4138    registers map<temp<char> > as B0, and temp<char> as B1 */
4139
4140 static int
4141 register_Btype (struct work_stuff *work)
4142 {
4143   int ret;
4144
4145   if (work -> numb >= work -> bsize)
4146     {
4147       if (work -> bsize == 0)
4148         {
4149           work -> bsize = 5;
4150           work -> btypevec = XNEWVEC (char *, work->bsize);
4151         }
4152       else
4153         {
4154           work -> bsize *= 2;
4155           work -> btypevec
4156             = XRESIZEVEC (char *, work->btypevec, work->bsize);
4157         }
4158     }
4159   ret = work -> numb++;
4160   work -> btypevec[ret] = NULL;
4161   return(ret);
4162 }
4163
4164 /* Store a value into a previously registered B code type. */
4165
4166 static void
4167 remember_Btype (struct work_stuff *work, const char *start,
4168                 int len, int index)
4169 {
4170   char *tem;
4171
4172   tem = XNEWVEC (char, len + 1);
4173   memcpy (tem, start, len);
4174   tem[len] = '\0';
4175   work -> btypevec[index] = tem;
4176 }
4177
4178 /* Lose all the info related to B and K type codes. */
4179 static void
4180 forget_B_and_K_types (struct work_stuff *work)
4181 {
4182   int i;
4183
4184   while (work -> numk > 0)
4185     {
4186       i = --(work -> numk);
4187       if (work -> ktypevec[i] != NULL)
4188         {
4189           free (work -> ktypevec[i]);
4190           work -> ktypevec[i] = NULL;
4191         }
4192     }
4193
4194   while (work -> numb > 0)
4195     {
4196       i = --(work -> numb);
4197       if (work -> btypevec[i] != NULL)
4198         {
4199           free (work -> btypevec[i]);
4200           work -> btypevec[i] = NULL;
4201         }
4202     }
4203 }
4204 /* Forget the remembered types, but not the type vector itself.  */
4205
4206 static void
4207 forget_types (struct work_stuff *work)
4208 {
4209   int i;
4210
4211   while (work -> ntypes > 0)
4212     {
4213       i = --(work -> ntypes);
4214       if (work -> typevec[i] != NULL)
4215         {
4216           free (work -> typevec[i]);
4217           work -> typevec[i] = NULL;
4218         }
4219     }
4220 }
4221
4222 /* Process the argument list part of the signature, after any class spec
4223    has been consumed, as well as the first 'F' character (if any).  For
4224    example:
4225
4226    "__als__3fooRT0"             =>      process "RT0"
4227    "complexfunc5__FPFPc_PFl_i"  =>      process "PFPc_PFl_i"
4228
4229    DECLP must be already initialised, usually non-empty.  It won't be freed
4230    on failure.
4231
4232    Note that g++ differs significantly from ARM and lucid style mangling
4233    with regards to references to previously seen types.  For example, given
4234    the source fragment:
4235
4236      class foo {
4237        public:
4238        foo::foo (int, foo &ia, int, foo &ib, int, foo &ic);
4239      };
4240
4241      foo::foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
4242      void foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
4243
4244    g++ produces the names:
4245
4246      __3fooiRT0iT2iT2
4247      foo__FiR3fooiT1iT1
4248
4249    while lcc (and presumably other ARM style compilers as well) produces:
4250
4251      foo__FiR3fooT1T2T1T2
4252      __ct__3fooFiR3fooT1T2T1T2
4253
4254    Note that g++ bases its type numbers starting at zero and counts all
4255    previously seen types, while lucid/ARM bases its type numbers starting
4256    at one and only considers types after it has seen the 'F' character
4257    indicating the start of the function args.  For lucid/ARM style, we
4258    account for this difference by discarding any previously seen types when
4259    we see the 'F' character, and subtracting one from the type number
4260    reference.
4261
4262  */
4263
4264 static int
4265 demangle_args (struct work_stuff *work, const char **mangled,
4266                string *declp)
4267 {
4268   string arg;
4269   int need_comma = 0;
4270   int r;
4271   int t;
4272   const char *tem;
4273   char temptype;
4274
4275   if (PRINT_ARG_TYPES)
4276     {
4277       string_append (declp, "(");
4278       if (**mangled == '\0')
4279         {
4280           string_append (declp, "void");
4281         }
4282     }
4283
4284   while ((**mangled != '_' && **mangled != '\0' && **mangled != 'e')
4285          || work->nrepeats > 0)
4286     {
4287       if ((**mangled == 'N') || (**mangled == 'T'))
4288         {
4289           temptype = *(*mangled)++;
4290
4291           if (temptype == 'N')
4292             {
4293               if (!get_count (mangled, &r))
4294                 {
4295                   return (0);
4296                 }
4297             }
4298           else
4299             {
4300               r = 1;
4301             }
4302           if ((HP_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING) && work -> ntypes >= 10)
4303             {
4304               /* If we have 10 or more types we might have more than a 1 digit
4305                  index so we'll have to consume the whole count here. This
4306                  will lose if the next thing is a type name preceded by a
4307                  count but it's impossible to demangle that case properly
4308                  anyway. Eg if we already have 12 types is T12Pc "(..., type1,
4309                  Pc, ...)"  or "(..., type12, char *, ...)" */
4310               if ((t = consume_count(mangled)) <= 0)
4311                 {
4312                   return (0);
4313                 }
4314             }
4315           else
4316             {
4317               if (!get_count (mangled, &t))
4318                 {
4319                   return (0);
4320                 }
4321             }
4322           if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
4323             {
4324               t--;
4325             }
4326           /* Validate the type index.  Protect against illegal indices from
4327              malformed type strings.  */
4328           if ((t < 0) || (t >= work -> ntypes))
4329             {
4330               return (0);
4331             }
4332           while (work->nrepeats > 0 || --r >= 0)
4333             {
4334               tem = work -> typevec[t];
4335               if (need_comma && PRINT_ARG_TYPES)
4336                 {
4337                   string_append (declp, ", ");
4338                 }
4339               if (!do_arg (work, &tem, &arg))
4340                 {
4341                   return (0);
4342                 }
4343               if (PRINT_ARG_TYPES)
4344                 {
4345                   string_appends (declp, &arg);
4346                 }
4347               string_delete (&arg);
4348               need_comma = 1;
4349             }
4350         }
4351       else
4352         {
4353           if (need_comma && PRINT_ARG_TYPES)
4354             string_append (declp, ", ");
4355           if (!do_arg (work, mangled, &arg))
4356             return (0);
4357           if (PRINT_ARG_TYPES)
4358             string_appends (declp, &arg);
4359           string_delete (&arg);
4360           need_comma = 1;
4361         }
4362     }
4363
4364   if (**mangled == 'e')
4365     {
4366       (*mangled)++;
4367       if (PRINT_ARG_TYPES)
4368         {
4369           if (need_comma)
4370             {
4371               string_append (declp, ",");
4372             }
4373           string_append (declp, "...");
4374         }
4375     }
4376
4377   if (PRINT_ARG_TYPES)
4378     {
4379       string_append (declp, ")");
4380     }
4381   return (1);
4382 }
4383
4384 /* Like demangle_args, but for demangling the argument lists of function
4385    and method pointers or references, not top-level declarations.  */
4386
4387 static int
4388 demangle_nested_args (struct work_stuff *work, const char **mangled,
4389                       string *declp)
4390 {
4391   string* saved_previous_argument;
4392   int result;
4393   int saved_nrepeats;
4394
4395   /* The G++ name-mangling algorithm does not remember types on nested
4396      argument lists, unless -fsquangling is used, and in that case the
4397      type vector updated by remember_type is not used.  So, we turn
4398      off remembering of types here.  */
4399   ++work->forgetting_types;
4400
4401   /* For the repeat codes used with -fsquangling, we must keep track of
4402      the last argument.  */
4403   saved_previous_argument = work->previous_argument;
4404   saved_nrepeats = work->nrepeats;
4405   work->previous_argument = 0;
4406   work->nrepeats = 0;
4407
4408   /* Actually demangle the arguments.  */
4409   result = demangle_args (work, mangled, declp);
4410
4411   /* Restore the previous_argument field.  */
4412   if (work->previous_argument)
4413     {
4414       string_delete (work->previous_argument);
4415       free ((char *) work->previous_argument);
4416     }
4417   work->previous_argument = saved_previous_argument;
4418   --work->forgetting_types;
4419   work->nrepeats = saved_nrepeats;
4420
4421   return result;
4422 }
4423
4424 static void
4425 demangle_function_name (struct work_stuff *work, const char **mangled,
4426                         string *declp, const char *scan)
4427 {
4428   size_t i;
4429   string type;
4430   const char *tem;
4431
4432   string_appendn (declp, (*mangled), scan - (*mangled));
4433   string_need (declp, 1);
4434   *(declp -> p) = '\0';
4435
4436   /* Consume the function name, including the "__" separating the name
4437      from the signature.  We are guaranteed that SCAN points to the
4438      separator.  */
4439
4440   (*mangled) = scan + 2;
4441   /* We may be looking at an instantiation of a template function:
4442      foo__Xt1t2_Ft3t4, where t1, t2, ... are template arguments and a
4443      following _F marks the start of the function arguments.  Handle
4444      the template arguments first. */
4445
4446   if (HP_DEMANGLING && (**mangled == 'X'))
4447     {
4448       demangle_arm_hp_template (work, mangled, 0, declp);
4449       /* This leaves MANGLED pointing to the 'F' marking func args */
4450     }
4451
4452   if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
4453     {
4454
4455       /* See if we have an ARM style constructor or destructor operator.
4456          If so, then just record it, clear the decl, and return.
4457          We can't build the actual constructor/destructor decl until later,
4458          when we recover the class name from the signature.  */
4459
4460       if (strcmp (declp -> b, "__ct") == 0)
4461         {
4462           work -> constructor += 1;
4463           string_clear (declp);
4464           return;
4465         }
4466       else if (strcmp (declp -> b, "__dt") == 0)
4467         {
4468           work -> destructor += 1;
4469           string_clear (declp);
4470           return;
4471         }
4472     }
4473
4474   if (declp->p - declp->b >= 3
4475       && declp->b[0] == 'o'
4476       && declp->b[1] == 'p'
4477       && strchr (cplus_markers, declp->b[2]) != NULL)
4478     {
4479       /* see if it's an assignment expression */
4480       if (declp->p - declp->b >= 10 /* op$assign_ */
4481           && memcmp (declp->b + 3, "assign_", 7) == 0)
4482         {
4483           for (i = 0; i < ARRAY_SIZE (optable); i++)
4484             {
4485               int len = declp->p - declp->b - 10;
4486               if ((int) strlen (optable[i].in) == len
4487                   && memcmp (optable[i].in, declp->b + 10, len) == 0)
4488                 {
4489                   string_clear (declp);
4490                   string_append (declp, "operator");
4491                   string_append (declp, optable[i].out);
4492                   string_append (declp, "=");
4493                   break;
4494                 }
4495             }
4496         }
4497       else
4498         {
4499           for (i = 0; i < ARRAY_SIZE (optable); i++)
4500             {
4501               int len = declp->p - declp->b - 3;
4502               if ((int) strlen (optable[i].in) == len
4503                   && memcmp (optable[i].in, declp->b + 3, len) == 0)
4504                 {
4505                   string_clear (declp);
4506                   string_append (declp, "operator");
4507                   string_append (declp, optable[i].out);
4508                   break;
4509                 }
4510             }
4511         }
4512     }
4513   else if (declp->p - declp->b >= 5 && memcmp (declp->b, "type", 4) == 0
4514            && strchr (cplus_markers, declp->b[4]) != NULL)
4515     {
4516       /* type conversion operator */
4517       tem = declp->b + 5;
4518       if (do_type (work, &tem, &type))
4519         {
4520           string_clear (declp);
4521           string_append (declp, "operator ");
4522           string_appends (declp, &type);
4523           string_delete (&type);
4524         }
4525     }
4526   else if (declp->b[0] == '_' && declp->b[1] == '_'
4527            && declp->b[2] == 'o' && declp->b[3] == 'p')
4528     {
4529       /* ANSI.  */
4530       /* type conversion operator.  */
4531       tem = declp->b + 4;
4532       if (do_type (work, &tem, &type))
4533         {
4534           string_clear (declp);
4535           string_append (declp, "operator ");
4536           string_appends (declp, &type);
4537           string_delete (&type);
4538         }
4539     }
4540   else if (declp->b[0] == '_' && declp->b[1] == '_'
4541            && ISLOWER((unsigned char)declp->b[2])
4542            && ISLOWER((unsigned char)declp->b[3]))
4543     {
4544       if (declp->b[4] == '\0')
4545         {
4546           /* Operator.  */
4547           for (i = 0; i < ARRAY_SIZE (optable); i++)
4548             {
4549               if (strlen (optable[i].in) == 2
4550                   && memcmp (optable[i].in, declp->b + 2, 2) == 0)
4551                 {
4552                   string_clear (declp);
4553                   string_append (declp, "operator");
4554                   string_append (declp, optable[i].out);
4555                   break;
4556                 }
4557             }
4558         }
4559       else
4560         {
4561           if (declp->b[2] == 'a' && declp->b[5] == '\0')
4562             {
4563               /* Assignment.  */
4564               for (i = 0; i < ARRAY_SIZE (optable); i++)
4565                 {
4566                   if (strlen (optable[i].in) == 3
4567                       && memcmp (optable[i].in, declp->b + 2, 3) == 0)
4568                     {
4569                       string_clear (declp);
4570                       string_append (declp, "operator");
4571                       string_append (declp, optable[i].out);
4572                       break;
4573                     }
4574                 }
4575             }
4576         }
4577     }
4578 }
4579
4580 /* a mini string-handling package */
4581
4582 static void
4583 string_need (string *s, int n)
4584 {
4585   int tem;
4586
4587   if (s->b == NULL)
4588     {
4589       if (n < 32)
4590         {
4591           n = 32;
4592         }
4593       s->p = s->b = XNEWVEC (char, n);
4594       s->e = s->b + n;
4595     }
4596   else if (s->e - s->p < n)
4597     {
4598       tem = s->p - s->b;
4599       n += tem;
4600       n *= 2;
4601       s->b = XRESIZEVEC (char, s->b, n);
4602       s->p = s->b + tem;
4603       s->e = s->b + n;
4604     }
4605 }
4606
4607 static void
4608 string_delete (string *s)
4609 {
4610   if (s->b != NULL)
4611     {
4612       free (s->b);
4613       s->b = s->e = s->p = NULL;
4614     }
4615 }
4616
4617 static void
4618 string_init (string *s)
4619 {
4620   s->b = s->p = s->e = NULL;
4621 }
4622
4623 static void
4624 string_clear (string *s)
4625 {
4626   s->p = s->b;
4627 }
4628
4629 #if 0
4630
4631 static int
4632 string_empty (string *s)
4633 {
4634   return (s->b == s->p);
4635 }
4636
4637 #endif
4638
4639 static void
4640 string_append (string *p, const char *s)
4641 {
4642   int n;
4643   if (s == NULL || *s == '\0')
4644     return;
4645   n = strlen (s);
4646   string_need (p, n);
4647   memcpy (p->p, s, n);
4648   p->p += n;
4649 }
4650
4651 static void
4652 string_appends (string *p, string *s)
4653 {
4654   int n;
4655
4656   if (s->b != s->p)
4657     {
4658       n = s->p - s->b;
4659       string_need (p, n);
4660       memcpy (p->p, s->b, n);
4661       p->p += n;
4662     }
4663 }
4664
4665 static void
4666 string_appendn (string *p, const char *s, int n)
4667 {
4668   if (n != 0)
4669     {
4670       string_need (p, n);
4671       memcpy (p->p, s, n);
4672       p->p += n;
4673     }
4674 }
4675
4676 static void
4677 string_prepend (string *p, const char *s)
4678 {
4679   if (s != NULL && *s != '\0')
4680     {
4681       string_prependn (p, s, strlen (s));
4682     }
4683 }
4684
4685 static void
4686 string_prepends (string *p, string *s)
4687 {
4688   if (s->b != s->p)
4689     {
4690       string_prependn (p, s->b, s->p - s->b);
4691     }
4692 }
4693
4694 static void
4695 string_prependn (string *p, const char *s, int n)
4696 {
4697   char *q;
4698
4699   if (n != 0)
4700     {
4701       string_need (p, n);
4702       for (q = p->p - 1; q >= p->b; q--)
4703         {
4704           q[n] = q[0];
4705         }
4706       memcpy (p->b, s, n);
4707       p->p += n;
4708     }
4709 }
4710
4711 static void
4712 string_append_template_idx (string *s, int idx)
4713 {
4714   char buf[INTBUF_SIZE + 1 /* 'T' */];
4715   sprintf(buf, "T%d", idx);
4716   string_append (s, buf);
4717 }