libiberty/cplus-dem.c

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