libiberty/cplus-dem.c

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