libiberty/cplus-dem.c

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