contrib/binutils-2.22/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         free ((char*) work->tmpl_argvec[i]);
1315
1316       free ((char*) work->tmpl_argvec);
1317       work->tmpl_argvec = NULL;
1318     }
1319   if (work->previous_argument)
1320     {
1321       string_delete (work->previous_argument);
1322       free ((char*) work->previous_argument);
1323       work->previous_argument = NULL;
1324     }
1325 }
1326
1327
1328 /* Delete all dynamic storage in work_stuff.  */
1329 static void
1330 delete_work_stuff (struct work_stuff *work)
1331 {
1332   delete_non_B_K_work_stuff (work);
1333   squangle_mop_up (work);
1334 }
1335
1336
1337 /* Clear out any mangled storage */
1338
1339 static char *
1340 mop_up (struct work_stuff *work, string *declp, int success)
1341 {
1342   char *demangled = NULL;
1343
1344   delete_non_B_K_work_stuff (work);
1345
1346   /* If demangling was successful, ensure that the demangled string is null
1347      terminated and return it.  Otherwise, free the demangling decl.  */
1348
1349   if (!success)
1350     {
1351       string_delete (declp);
1352     }
1353   else
1354     {
1355       string_appendn (declp, "", 1);
1356       demangled = declp->b;
1357     }
1358   return (demangled);
1359 }
1360
1361 /*
1362
1363 LOCAL FUNCTION
1364
1365         demangle_signature -- demangle the signature part of a mangled name
1366
1367 SYNOPSIS
1368
1369         static int
1370         demangle_signature (struct work_stuff *work, const char **mangled,
1371                             string *declp);
1372
1373 DESCRIPTION
1374
1375         Consume and demangle the signature portion of the mangled name.
1376
1377         DECLP is the string where demangled output is being built.  At
1378         entry it contains the demangled root name from the mangled name
1379         prefix.  I.E. either a demangled operator name or the root function
1380         name.  In some special cases, it may contain nothing.
1381
1382         *MANGLED points to the current unconsumed location in the mangled
1383         name.  As tokens are consumed and demangling is performed, the
1384         pointer is updated to continuously point at the next token to
1385         be consumed.
1386
1387         Demangling GNU style mangled names is nasty because there is no
1388         explicit token that marks the start of the outermost function
1389         argument list.  */
1390
1391 static int
1392 demangle_signature (struct work_stuff *work,
1393                     const char **mangled, string *declp)
1394 {
1395   int success = 1;
1396   int func_done = 0;
1397   int expect_func = 0;
1398   int expect_return_type = 0;
1399   const char *oldmangled = NULL;
1400   string trawname;
1401   string tname;
1402
1403   while (success && (**mangled != '\0'))
1404     {
1405       switch (**mangled)
1406         {
1407         case 'Q':
1408           oldmangled = *mangled;
1409           success = demangle_qualified (work, mangled, declp, 1, 0);
1410           if (success)
1411             remember_type (work, oldmangled, *mangled - oldmangled);
1412           if (AUTO_DEMANGLING || GNU_DEMANGLING)
1413             expect_func = 1;
1414           oldmangled = NULL;
1415           break;
1416
1417         case 'K':
1418           oldmangled = *mangled;
1419           success = demangle_qualified (work, mangled, declp, 1, 0);
1420           if (AUTO_DEMANGLING || GNU_DEMANGLING)
1421             {
1422               expect_func = 1;
1423             }
1424           oldmangled = NULL;
1425           break;
1426
1427         case 'S':
1428           /* Static member function */
1429           if (oldmangled == NULL)
1430             {
1431               oldmangled = *mangled;
1432             }
1433           (*mangled)++;
1434           work -> static_type = 1;
1435           break;
1436
1437         case 'C':
1438         case 'V':
1439         case 'u':
1440           work->type_quals |= code_for_qualifier (**mangled);
1441
1442           /* a qualified member function */
1443           if (oldmangled == NULL)
1444             oldmangled = *mangled;
1445           (*mangled)++;
1446           break;
1447
1448         case 'L':
1449           /* Local class name follows after "Lnnn_" */
1450           if (HP_DEMANGLING)
1451             {
1452               while (**mangled && (**mangled != '_'))
1453                 (*mangled)++;
1454               if (!**mangled)
1455                 success = 0;
1456               else
1457                 (*mangled)++;
1458             }
1459           else
1460             success = 0;
1461           break;
1462
1463         case '0': case '1': case '2': case '3': case '4':
1464         case '5': case '6': case '7': case '8': case '9':
1465           if (oldmangled == NULL)
1466             {
1467               oldmangled = *mangled;
1468             }
1469           work->temp_start = -1; /* uppermost call to demangle_class */
1470           success = demangle_class (work, mangled, declp);
1471           if (success)
1472             {
1473               remember_type (work, oldmangled, *mangled - oldmangled);
1474             }
1475           if (AUTO_DEMANGLING || GNU_DEMANGLING || EDG_DEMANGLING)
1476             {
1477               /* EDG and others will have the "F", so we let the loop cycle
1478                  if we are looking at one. */
1479               if (**mangled != 'F')
1480                  expect_func = 1;
1481             }
1482           oldmangled = NULL;
1483           break;
1484
1485         case 'B':
1486           {
1487             string s;
1488             success = do_type (work, mangled, &s);
1489             if (success)
1490               {
1491                 string_append (&s, SCOPE_STRING (work));
1492                 string_prepends (declp, &s);
1493                 string_delete (&s);
1494               }
1495             oldmangled = NULL;
1496             expect_func = 1;
1497           }
1498           break;
1499
1500         case 'F':
1501           /* Function */
1502           /* ARM/HP style demangling includes a specific 'F' character after
1503              the class name.  For GNU style, it is just implied.  So we can
1504              safely just consume any 'F' at this point and be compatible
1505              with either style.  */
1506
1507           oldmangled = NULL;
1508           func_done = 1;
1509           (*mangled)++;
1510
1511           /* For lucid/ARM/HP style we have to forget any types we might
1512              have remembered up to this point, since they were not argument
1513              types.  GNU style considers all types seen as available for
1514              back references.  See comment in demangle_args() */
1515
1516           if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
1517             {
1518               forget_types (work);
1519             }
1520           success = demangle_args (work, mangled, declp);
1521           /* After picking off the function args, we expect to either
1522              find the function return type (preceded by an '_') or the
1523              end of the string. */
1524           if (success && (AUTO_DEMANGLING || EDG_DEMANGLING) && **mangled == '_')
1525             {
1526               ++(*mangled);
1527               /* At this level, we do not care about the return type. */
1528               success = do_type (work, mangled, &tname);
1529               string_delete (&tname);
1530             }
1531
1532           break;
1533
1534         case 't':
1535           /* G++ Template */
1536           string_init(&trawname);
1537           string_init(&tname);
1538           if (oldmangled == NULL)
1539             {
1540               oldmangled = *mangled;
1541             }
1542           success = demangle_template (work, mangled, &tname,
1543                                        &trawname, 1, 1);
1544           if (success)
1545             {
1546               remember_type (work, oldmangled, *mangled - oldmangled);
1547             }
1548           string_append (&tname, SCOPE_STRING (work));
1549
1550           string_prepends(declp, &tname);
1551           if (work -> destructor & 1)
1552             {
1553               string_prepend (&trawname, "~");
1554               string_appends (declp, &trawname);
1555               work->destructor -= 1;
1556             }
1557           if ((work->constructor & 1) || (work->destructor & 1))
1558             {
1559               string_appends (declp, &trawname);
1560               work->constructor -= 1;
1561             }
1562           string_delete(&trawname);
1563           string_delete(&tname);
1564           oldmangled = NULL;
1565           expect_func = 1;
1566           break;
1567
1568         case '_':
1569           if ((AUTO_DEMANGLING || GNU_DEMANGLING) && expect_return_type)
1570             {
1571               /* Read the return type. */
1572               string return_type;
1573
1574               (*mangled)++;
1575               success = do_type (work, mangled, &return_type);
1576               APPEND_BLANK (&return_type);
1577
1578               string_prepends (declp, &return_type);
1579               string_delete (&return_type);
1580               break;
1581             }
1582           else
1583             /* At the outermost level, we cannot have a return type specified,
1584                so if we run into another '_' at this point we are dealing with
1585                a mangled name that is either bogus, or has been mangled by
1586                some algorithm we don't know how to deal with.  So just
1587                reject the entire demangling.  */
1588             /* However, "_nnn" is an expected suffix for alternate entry point
1589                numbered nnn for a function, with HP aCC, so skip over that
1590                without reporting failure. pai/1997-09-04 */
1591             if (HP_DEMANGLING)
1592               {
1593                 (*mangled)++;
1594                 while (**mangled && ISDIGIT ((unsigned char)**mangled))
1595                   (*mangled)++;
1596               }
1597             else
1598               success = 0;
1599           break;
1600
1601         case 'H':
1602           if (AUTO_DEMANGLING || GNU_DEMANGLING)
1603             {
1604               /* A G++ template function.  Read the template arguments. */
1605               success = demangle_template (work, mangled, declp, 0, 0,
1606                                            0);
1607               if (!(work->constructor & 1))
1608                 expect_return_type = 1;
1609               (*mangled)++;
1610               break;
1611             }
1612           else
1613             /* fall through */
1614             {;}
1615
1616         default:
1617           if (AUTO_DEMANGLING || GNU_DEMANGLING)
1618             {
1619               /* Assume we have stumbled onto the first outermost function
1620                  argument token, and start processing args.  */
1621               func_done = 1;
1622               success = demangle_args (work, mangled, declp);
1623             }
1624           else
1625             {
1626               /* Non-GNU demanglers use a specific token to mark the start
1627                  of the outermost function argument tokens.  Typically 'F',
1628                  for ARM/HP-demangling, for example.  So if we find something
1629                  we are not prepared for, it must be an error.  */
1630               success = 0;
1631             }
1632           break;
1633         }
1634       /*
1635         if (AUTO_DEMANGLING || GNU_DEMANGLING)
1636         */
1637       {
1638         if (success && expect_func)
1639           {
1640             func_done = 1;
1641               if (LUCID_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING)
1642                 {
1643                   forget_types (work);
1644                 }
1645             success = demangle_args (work, mangled, declp);
1646             /* Since template include the mangling of their return types,
1647                we must set expect_func to 0 so that we don't try do
1648                demangle more arguments the next time we get here.  */
1649             expect_func = 0;
1650           }
1651       }
1652     }
1653   if (success && !func_done)
1654     {
1655       if (AUTO_DEMANGLING || GNU_DEMANGLING)
1656         {
1657           /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
1658              bar__3fooi is 'foo::bar(int)'.  We get here when we find the
1659              first case, and need to ensure that the '(void)' gets added to
1660              the current declp.  Note that with ARM/HP, the first case
1661              represents the name of a static data member 'foo::bar',
1662              which is in the current declp, so we leave it alone.  */
1663           success = demangle_args (work, mangled, declp);
1664         }
1665     }
1666   if (success && PRINT_ARG_TYPES)
1667     {
1668       if (work->static_type)
1669         string_append (declp, " static");
1670       if (work->type_quals != TYPE_UNQUALIFIED)
1671         {
1672           APPEND_BLANK (declp);
1673           string_append (declp, qualifier_string (work->type_quals));
1674         }
1675     }
1676
1677   return (success);
1678 }
1679
1680 #if 0
1681
1682 static int
1683 demangle_method_args (struct work_stuff *work, const char **mangled,
1684                       string *declp)
1685 {
1686   int success = 0;
1687
1688   if (work -> static_type)
1689     {
1690       string_append (declp, *mangled + 1);
1691       *mangled += strlen (*mangled);
1692       success = 1;
1693     }
1694   else
1695     {
1696       success = demangle_args (work, mangled, declp);
1697     }
1698   return (success);
1699 }
1700
1701 #endif
1702
1703 static int
1704 demangle_template_template_parm (struct work_stuff *work,
1705                                  const char **mangled, string *tname)
1706 {
1707   int i;
1708   int r;
1709   int need_comma = 0;
1710   int success = 1;
1711   string temp;
1712
1713   string_append (tname, "template <");
1714   /* get size of template parameter list */
1715   if (get_count (mangled, &r))
1716     {
1717       for (i = 0; i < r; i++)
1718         {
1719           if (need_comma)
1720             {
1721               string_append (tname, ", ");
1722             }
1723
1724             /* Z for type parameters */
1725             if (**mangled == 'Z')
1726               {
1727                 (*mangled)++;
1728                 string_append (tname, "class");
1729               }
1730               /* z for template parameters */
1731             else if (**mangled == 'z')
1732               {
1733                 (*mangled)++;
1734                 success =
1735                   demangle_template_template_parm (work, mangled, tname);
1736                 if (!success)
1737                   {
1738                     break;
1739                   }
1740               }
1741             else
1742               {
1743                 /* temp is initialized in do_type */
1744                 success = do_type (work, mangled, &temp);
1745                 if (success)
1746                   {
1747                     string_appends (tname, &temp);
1748                   }
1749                 string_delete(&temp);
1750                 if (!success)
1751                   {
1752                     break;
1753                   }
1754               }
1755           need_comma = 1;
1756         }
1757
1758     }
1759   if (tname->p[-1] == '>')
1760     string_append (tname, " ");
1761   string_append (tname, "> class");
1762   return (success);
1763 }
1764
1765 static int
1766 demangle_expression (struct work_stuff *work, const char **mangled,
1767                      string *s, type_kind_t tk)
1768 {
1769   int need_operator = 0;
1770   int success;
1771
1772   success = 1;
1773   string_appendn (s, "(", 1);
1774   (*mangled)++;
1775   while (success && **mangled != 'W' && **mangled != '\0')
1776     {
1777       if (need_operator)
1778         {
1779           size_t i;
1780           size_t len;
1781
1782           success = 0;
1783
1784           len = strlen (*mangled);
1785
1786           for (i = 0; i < ARRAY_SIZE (optable); ++i)
1787             {
1788               size_t l = strlen (optable[i].in);
1789
1790               if (l <= len
1791                   && memcmp (optable[i].in, *mangled, l) == 0)
1792                 {
1793                   string_appendn (s, " ", 1);
1794                   string_append (s, optable[i].out);
1795                   string_appendn (s, " ", 1);
1796                   success = 1;
1797                   (*mangled) += l;
1798                   break;
1799                 }
1800             }
1801
1802           if (!success)
1803             break;
1804         }
1805       else
1806         need_operator = 1;
1807
1808       success = demangle_template_value_parm (work, mangled, s, tk);
1809     }
1810
1811   if (**mangled != 'W')
1812     success = 0;
1813   else
1814     {
1815       string_appendn (s, ")", 1);
1816       (*mangled)++;
1817     }
1818
1819   return success;
1820 }
1821
1822 static int
1823 demangle_integral_value (struct work_stuff *work,
1824                          const char **mangled, string *s)
1825 {
1826   int success;
1827
1828   if (**mangled == 'E')
1829     success = demangle_expression (work, mangled, s, tk_integral);
1830   else if (**mangled == 'Q' || **mangled == 'K')
1831     success = demangle_qualified (work, mangled, s, 0, 1);
1832   else
1833     {
1834       int value;
1835
1836       /* By default, we let the number decide whether we shall consume an
1837          underscore.  */
1838       int multidigit_without_leading_underscore = 0;
1839       int leave_following_underscore = 0;
1840
1841       success = 0;
1842
1843       if (**mangled == '_')
1844         {
1845           if (mangled[0][1] == 'm')
1846             {
1847               /* Since consume_count_with_underscores does not handle the
1848                  `m'-prefix we must do it here, using consume_count and
1849                  adjusting underscores: we have to consume the underscore
1850                  matching the prepended one.  */
1851               multidigit_without_leading_underscore = 1;
1852               string_appendn (s, "-", 1);
1853               (*mangled) += 2;
1854             }
1855           else
1856             {
1857               /* Do not consume a following underscore;
1858                  consume_count_with_underscores will consume what
1859                  should be consumed.  */
1860               leave_following_underscore = 1;
1861             }
1862         }
1863       else
1864         {
1865           /* Negative numbers are indicated with a leading `m'.  */
1866           if (**mangled == 'm')
1867           {
1868             string_appendn (s, "-", 1);
1869             (*mangled)++;
1870           }
1871           /* Since consume_count_with_underscores does not handle
1872              multi-digit numbers that do not start with an underscore,
1873              and this number can be an integer template parameter,
1874              we have to call consume_count. */
1875           multidigit_without_leading_underscore = 1;
1876           /* These multi-digit numbers never end on an underscore,
1877              so if there is one then don't eat it. */
1878           leave_following_underscore = 1;
1879         }
1880
1881       /* We must call consume_count if we expect to remove a trailing
1882          underscore, since consume_count_with_underscores expects
1883          the leading underscore (that we consumed) if it is to handle
1884          multi-digit numbers.  */
1885       if (multidigit_without_leading_underscore)
1886         value = consume_count (mangled);
1887       else
1888         value = consume_count_with_underscores (mangled);
1889
1890       if (value != -1)
1891         {
1892           char buf[INTBUF_SIZE];
1893           sprintf (buf, "%d", value);
1894           string_append (s, buf);
1895
1896           /* Numbers not otherwise delimited, might have an underscore
1897              appended as a delimeter, which we should skip.
1898
1899              ??? This used to always remove a following underscore, which
1900              is wrong.  If other (arbitrary) cases are followed by an
1901              underscore, we need to do something more radical.  */
1902
1903           if ((value > 9 || multidigit_without_leading_underscore)
1904               && ! leave_following_underscore
1905               && **mangled == '_')
1906             (*mangled)++;
1907
1908           /* All is well.  */
1909           success = 1;
1910         }
1911       }
1912
1913   return success;
1914 }
1915
1916 /* Demangle the real value in MANGLED.  */
1917
1918 static int
1919 demangle_real_value (struct work_stuff *work,
1920                      const char **mangled, string *s)
1921 {
1922   if (**mangled == 'E')
1923     return demangle_expression (work, mangled, s, tk_real);
1924
1925   if (**mangled == 'm')
1926     {
1927       string_appendn (s, "-", 1);
1928       (*mangled)++;
1929     }
1930   while (ISDIGIT ((unsigned char)**mangled))
1931     {
1932       string_appendn (s, *mangled, 1);
1933       (*mangled)++;
1934     }
1935   if (**mangled == '.') /* fraction */
1936     {
1937       string_appendn (s, ".", 1);
1938       (*mangled)++;
1939       while (ISDIGIT ((unsigned char)**mangled))
1940         {
1941           string_appendn (s, *mangled, 1);
1942           (*mangled)++;
1943         }
1944     }
1945   if (**mangled == 'e') /* exponent */
1946     {
1947       string_appendn (s, "e", 1);
1948       (*mangled)++;
1949       while (ISDIGIT ((unsigned char)**mangled))
1950         {
1951           string_appendn (s, *mangled, 1);
1952           (*mangled)++;
1953         }
1954     }
1955
1956   return 1;
1957 }
1958
1959 static int
1960 demangle_template_value_parm (struct work_stuff *work, const char **mangled,
1961                               string *s, type_kind_t tk)
1962 {
1963   int success = 1;
1964
1965   if (**mangled == 'Y')
1966     {
1967       /* The next argument is a template parameter. */
1968       int idx;
1969
1970       (*mangled)++;
1971       idx = consume_count_with_underscores (mangled);
1972       if (idx == -1
1973           || (work->tmpl_argvec && idx >= work->ntmpl_args)
1974           || consume_count_with_underscores (mangled) == -1)
1975         return -1;
1976       if (work->tmpl_argvec)
1977         string_append (s, work->tmpl_argvec[idx]);
1978       else
1979         string_append_template_idx (s, idx);
1980     }
1981   else if (tk == tk_integral)
1982     success = demangle_integral_value (work, mangled, s);
1983   else if (tk == tk_char)
1984     {
1985       char tmp[2];
1986       int val;
1987       if (**mangled == 'm')
1988         {
1989           string_appendn (s, "-", 1);
1990           (*mangled)++;
1991         }
1992       string_appendn (s, "'", 1);
1993       val = consume_count(mangled);
1994       if (val <= 0)
1995         success = 0;
1996       else
1997         {
1998           tmp[0] = (char)val;
1999           tmp[1] = '\0';
2000           string_appendn (s, &tmp[0], 1);
2001           string_appendn (s, "'", 1);
2002         }
2003     }
2004   else if (tk == tk_bool)
2005     {
2006       int val = consume_count (mangled);
2007       if (val == 0)
2008         string_appendn (s, "false", 5);
2009       else if (val == 1)
2010         string_appendn (s, "true", 4);
2011       else
2012         success = 0;
2013     }
2014   else if (tk == tk_real)
2015     success = demangle_real_value (work, mangled, s);
2016   else if (tk == tk_pointer || tk == tk_reference)
2017     {
2018       if (**mangled == 'Q')
2019         success = demangle_qualified (work, mangled, s,
2020                                       /*isfuncname=*/0,
2021                                       /*append=*/1);
2022       else
2023         {
2024           int symbol_len  = consume_count (mangled);
2025           if (symbol_len == -1)
2026             return -1;
2027           if (symbol_len == 0)
2028             string_appendn (s, "0", 1);
2029           else
2030             {
2031               char *p = XNEWVEC (char, symbol_len + 1), *q;
2032               strncpy (p, *mangled, symbol_len);
2033               p [symbol_len] = '\0';
2034               /* We use cplus_demangle here, rather than
2035                  internal_cplus_demangle, because the name of the entity
2036                  mangled here does not make use of any of the squangling
2037                  or type-code information we have built up thus far; it is
2038                  mangled independently.  */
2039               q = cplus_demangle (p, work->options);
2040               if (tk == tk_pointer)
2041                 string_appendn (s, "&", 1);
2042               /* FIXME: Pointer-to-member constants should get a
2043                  qualifying class name here.  */
2044               if (q)
2045                 {
2046                   string_append (s, q);
2047                   free (q);
2048                 }
2049               else
2050                 string_append (s, p);
2051               free (p);
2052             }
2053           *mangled += symbol_len;
2054         }
2055     }
2056
2057   return success;
2058 }
2059
2060 /* Demangle the template name in MANGLED.  The full name of the
2061    template (e.g., S<int>) is placed in TNAME.  The name without the
2062    template parameters (e.g. S) is placed in TRAWNAME if TRAWNAME is
2063    non-NULL.  If IS_TYPE is nonzero, this template is a type template,
2064    not a function template.  If both IS_TYPE and REMEMBER are nonzero,
2065    the template is remembered in the list of back-referenceable
2066    types.  */
2067
2068 static int
2069 demangle_template (struct work_stuff *work, const char **mangled,
2070                    string *tname, string *trawname,
2071                    int is_type, int remember)
2072 {
2073   int i;
2074   int r;
2075   int need_comma = 0;
2076   int success = 0;
2077   int is_java_array = 0;
2078   string temp;
2079
2080   (*mangled)++;
2081   if (is_type)
2082     {
2083       /* get template name */
2084       if (**mangled == 'z')
2085         {
2086           int idx;
2087           (*mangled)++;
2088           (*mangled)++;
2089
2090           idx = consume_count_with_underscores (mangled);
2091           if (idx == -1
2092               || (work->tmpl_argvec && idx >= work->ntmpl_args)
2093               || consume_count_with_underscores (mangled) == -1)
2094             return (0);
2095
2096           if (work->tmpl_argvec)
2097             {
2098               string_append (tname, work->tmpl_argvec[idx]);
2099               if (trawname)
2100                 string_append (trawname, work->tmpl_argvec[idx]);
2101             }
2102           else
2103             {
2104               string_append_template_idx (tname, idx);
2105               if (trawname)
2106                 string_append_template_idx (trawname, idx);
2107             }
2108         }
2109       else
2110         {
2111           if ((r = consume_count (mangled)) <= 0
2112               || (int) strlen (*mangled) < r)
2113             {
2114               return (0);
2115             }
2116           is_java_array = (work -> options & DMGL_JAVA)
2117             && strncmp (*mangled, "JArray1Z", 8) == 0;
2118           if (! is_java_array)
2119             {
2120               string_appendn (tname, *mangled, r);
2121             }
2122           if (trawname)
2123             string_appendn (trawname, *mangled, r);
2124           *mangled += r;
2125         }
2126     }
2127   if (!is_java_array)
2128     string_append (tname, "<");
2129   /* get size of template parameter list */
2130   if (!get_count (mangled, &r))
2131     {
2132       return (0);
2133     }
2134   if (!is_type)
2135     {
2136       /* Create an array for saving the template argument values. */
2137       work->tmpl_argvec = XNEWVEC (char *, r);
2138       work->ntmpl_args = r;
2139       for (i = 0; i < r; i++)
2140         work->tmpl_argvec[i] = 0;
2141     }
2142   for (i = 0; i < r; i++)
2143     {
2144       if (need_comma)
2145         {
2146           string_append (tname, ", ");
2147         }
2148       /* Z for type parameters */
2149       if (**mangled == 'Z')
2150         {
2151           (*mangled)++;
2152           /* temp is initialized in do_type */
2153           success = do_type (work, mangled, &temp);
2154           if (success)
2155             {
2156               string_appends (tname, &temp);
2157
2158               if (!is_type)
2159                 {
2160                   /* Save the template argument. */
2161                   int len = temp.p - temp.b;
2162                   work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
2163                   memcpy (work->tmpl_argvec[i], temp.b, len);
2164                   work->tmpl_argvec[i][len] = '\0';
2165                 }
2166             }
2167           string_delete(&temp);
2168           if (!success)
2169             {
2170               break;
2171             }
2172         }
2173       /* z for template parameters */
2174       else if (**mangled == 'z')
2175         {
2176           int r2;
2177           (*mangled)++;
2178           success = demangle_template_template_parm (work, mangled, tname);
2179
2180           if (success
2181               && (r2 = consume_count (mangled)) > 0
2182               && (int) strlen (*mangled) >= r2)
2183             {
2184               string_append (tname, " ");
2185               string_appendn (tname, *mangled, r2);
2186               if (!is_type)
2187                 {
2188                   /* Save the template argument. */
2189                   int len = r2;
2190                   work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
2191                   memcpy (work->tmpl_argvec[i], *mangled, len);
2192                   work->tmpl_argvec[i][len] = '\0';
2193                 }
2194               *mangled += r2;
2195             }
2196           if (!success)
2197             {
2198               break;
2199             }
2200         }
2201       else
2202         {
2203           string  param;
2204           string* s;
2205
2206           /* otherwise, value parameter */
2207
2208           /* temp is initialized in do_type */
2209           success = do_type (work, mangled, &temp);
2210           string_delete(&temp);
2211           if (!success)
2212             break;
2213
2214           if (!is_type)
2215             {
2216               s = &param;
2217               string_init (s);
2218             }
2219           else
2220             s = tname;
2221
2222           success = demangle_template_value_parm (work, mangled, s,
2223                                                   (type_kind_t) success);
2224
2225           if (!success)
2226             {
2227               if (!is_type)
2228                 string_delete (s);
2229               success = 0;
2230               break;
2231             }
2232
2233           if (!is_type)
2234             {
2235               int len = s->p - s->b;
2236               work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
2237               memcpy (work->tmpl_argvec[i], s->b, len);
2238               work->tmpl_argvec[i][len] = '\0';
2239
2240               string_appends (tname, s);
2241               string_delete (s);
2242             }
2243         }
2244       need_comma = 1;
2245     }
2246   if (is_java_array)
2247     {
2248       string_append (tname, "[]");
2249     }
2250   else
2251     {
2252       if (tname->p[-1] == '>')
2253         string_append (tname, " ");
2254       string_append (tname, ">");
2255     }
2256
2257   if (is_type && remember)
2258     {
2259       const int bindex = register_Btype (work);
2260       remember_Btype (work, tname->b, LEN_STRING (tname), bindex);
2261     }
2262
2263   /*
2264     if (work -> static_type)
2265     {
2266     string_append (declp, *mangled + 1);
2267     *mangled += strlen (*mangled);
2268     success = 1;
2269     }
2270     else
2271     {
2272     success = demangle_args (work, mangled, declp);
2273     }
2274     }
2275     */
2276   return (success);
2277 }
2278
2279 static int
2280 arm_pt (struct work_stuff *work, const char *mangled,
2281         int n, const char **anchor, const char **args)
2282 {
2283   /* Check if ARM template with "__pt__" in it ("parameterized type") */
2284   /* Allow HP also here, because HP's cfront compiler follows ARM to some extent */
2285   if ((ARM_DEMANGLING || HP_DEMANGLING) && (*anchor = strstr (mangled, "__pt__")))
2286     {
2287       int len;
2288       *args = *anchor + 6;
2289       len = consume_count (args);
2290       if (len == -1)
2291         return 0;
2292       if (*args + len == mangled + n && **args == '_')
2293         {
2294           ++*args;
2295           return 1;
2296         }
2297     }
2298   if (AUTO_DEMANGLING || EDG_DEMANGLING)
2299     {
2300       if ((*anchor = strstr (mangled, "__tm__"))
2301           || (*anchor = strstr (mangled, "__ps__"))
2302           || (*anchor = strstr (mangled, "__pt__")))
2303         {
2304           int len;
2305           *args = *anchor + 6;
2306           len = consume_count (args);
2307           if (len == -1)
2308             return 0;
2309           if (*args + len == mangled + n && **args == '_')
2310             {
2311               ++*args;
2312               return 1;
2313             }
2314         }
2315       else if ((*anchor = strstr (mangled, "__S")))
2316         {
2317           int len;
2318           *args = *anchor + 3;
2319           len = consume_count (args);
2320           if (len == -1)
2321             return 0;
2322           if (*args + len == mangled + n && **args == '_')
2323             {
2324               ++*args;
2325               return 1;
2326             }
2327         }
2328     }
2329
2330   return 0;
2331 }
2332
2333 static void
2334 demangle_arm_hp_template (struct work_stuff *work, const char **mangled,
2335                           int n, string *declp)
2336 {
2337   const char *p;
2338   const char *args;
2339   const char *e = *mangled + n;
2340   string arg;
2341
2342   /* Check for HP aCC template spec: classXt1t2 where t1, t2 are
2343      template args */
2344   if (HP_DEMANGLING && ((*mangled)[n] == 'X'))
2345     {
2346       char *start_spec_args = NULL;
2347       int hold_options;
2348
2349       /* First check for and omit template specialization pseudo-arguments,
2350          such as in "Spec<#1,#1.*>" */
2351       start_spec_args = strchr (*mangled, '<');
2352       if (start_spec_args && (start_spec_args - *mangled < n))
2353         string_appendn (declp, *mangled, start_spec_args - *mangled);
2354       else
2355         string_appendn (declp, *mangled, n);
2356       (*mangled) += n + 1;
2357       string_init (&arg);
2358       if (work->temp_start == -1) /* non-recursive call */
2359         work->temp_start = declp->p - declp->b;
2360
2361       /* We want to unconditionally demangle parameter types in
2362          template parameters.  */
2363       hold_options = work->options;
2364       work->options |= DMGL_PARAMS;
2365
2366       string_append (declp, "<");
2367       while (1)
2368         {
2369           string_delete (&arg);
2370           switch (**mangled)
2371             {
2372               case 'T':
2373                 /* 'T' signals a type parameter */
2374                 (*mangled)++;
2375                 if (!do_type (work, mangled, &arg))
2376                   goto hpacc_template_args_done;
2377                 break;
2378
2379               case 'U':
2380               case 'S':
2381                 /* 'U' or 'S' signals an integral value */
2382                 if (!do_hpacc_template_const_value (work, mangled, &arg))
2383                   goto hpacc_template_args_done;
2384                 break;
2385
2386               case 'A':
2387                 /* 'A' signals a named constant expression (literal) */
2388                 if (!do_hpacc_template_literal (work, mangled, &arg))
2389                   goto hpacc_template_args_done;
2390                 break;
2391
2392               default:
2393                 /* Today, 1997-09-03, we have only the above types
2394                    of template parameters */
2395                 /* FIXME: maybe this should fail and return null */
2396                 goto hpacc_template_args_done;
2397             }
2398           string_appends (declp, &arg);
2399          /* Check if we're at the end of template args.
2400              0 if at end of static member of template class,
2401              _ if done with template args for a function */
2402           if ((**mangled == '\000') || (**mangled == '_'))
2403             break;
2404           else
2405             string_append (declp, ",");
2406         }
2407     hpacc_template_args_done:
2408       string_append (declp, ">");
2409       string_delete (&arg);
2410       if (**mangled == '_')
2411         (*mangled)++;
2412       work->options = hold_options;
2413       return;
2414     }
2415   /* ARM template? (Also handles HP cfront extensions) */
2416   else if (arm_pt (work, *mangled, n, &p, &args))
2417     {
2418       int hold_options;
2419       string type_str;
2420
2421       string_init (&arg);
2422       string_appendn (declp, *mangled, p - *mangled);
2423       if (work->temp_start == -1)  /* non-recursive call */
2424         work->temp_start = declp->p - declp->b;
2425
2426       /* We want to unconditionally demangle parameter types in
2427          template parameters.  */
2428       hold_options = work->options;
2429       work->options |= DMGL_PARAMS;
2430
2431       string_append (declp, "<");
2432       /* should do error checking here */
2433       while (args < e) {
2434         string_delete (&arg);
2435
2436         /* Check for type or literal here */
2437         switch (*args)
2438           {
2439             /* HP cfront extensions to ARM for template args */
2440             /* spec: Xt1Lv1 where t1 is a type, v1 is a literal value */
2441             /* FIXME: We handle only numeric literals for HP cfront */
2442           case 'X':
2443             /* A typed constant value follows */
2444             args++;
2445             if (!do_type (work, &args, &type_str))
2446               goto cfront_template_args_done;
2447             string_append (&arg, "(");
2448             string_appends (&arg, &type_str);
2449             string_delete (&type_str);
2450             string_append (&arg, ")");
2451             if (*args != 'L')
2452               goto cfront_template_args_done;
2453             args++;
2454             /* Now snarf a literal value following 'L' */
2455             if (!snarf_numeric_literal (&args, &arg))
2456               goto cfront_template_args_done;
2457             break;
2458
2459           case 'L':
2460             /* Snarf a literal following 'L' */
2461             args++;
2462             if (!snarf_numeric_literal (&args, &arg))
2463               goto cfront_template_args_done;
2464             break;
2465           default:
2466             /* Not handling other HP cfront stuff */
2467             {
2468               const char* old_args = args;
2469               if (!do_type (work, &args, &arg))
2470                 goto cfront_template_args_done;
2471
2472               /* Fail if we didn't make any progress: prevent infinite loop. */
2473               if (args == old_args)
2474                 {
2475                   work->options = hold_options;
2476                   return;
2477                 }
2478             }
2479           }
2480         string_appends (declp, &arg);
2481         string_append (declp, ",");
2482       }
2483     cfront_template_args_done:
2484       string_delete (&arg);
2485       if (args >= e)
2486         --declp->p; /* remove extra comma */
2487       string_append (declp, ">");
2488       work->options = hold_options;
2489     }
2490   else if (n>10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
2491            && (*mangled)[9] == 'N'
2492            && (*mangled)[8] == (*mangled)[10]
2493            && strchr (cplus_markers, (*mangled)[8]))
2494     {
2495       /* A member of the anonymous namespace.  */
2496       string_append (declp, "{anonymous}");
2497     }
2498   else
2499     {
2500       if (work->temp_start == -1) /* non-recursive call only */
2501         work->temp_start = 0;     /* disable in recursive calls */
2502       string_appendn (declp, *mangled, n);
2503     }
2504   *mangled += n;
2505 }
2506
2507 /* Extract a class name, possibly a template with arguments, from the
2508    mangled string; qualifiers, local class indicators, etc. have
2509    already been dealt with */
2510
2511 static int
2512 demangle_class_name (struct work_stuff *work, const char **mangled,
2513                      string *declp)
2514 {
2515   int n;
2516   int success = 0;
2517
2518   n = consume_count (mangled);
2519   if (n == -1)
2520     return 0;
2521   if ((int) strlen (*mangled) >= n)
2522     {
2523       demangle_arm_hp_template (work, mangled, n, declp);
2524       success = 1;
2525     }
2526
2527   return (success);
2528 }
2529
2530 /*
2531
2532 LOCAL FUNCTION
2533
2534         demangle_class -- demangle a mangled class sequence
2535
2536 SYNOPSIS
2537
2538         static int
2539         demangle_class (struct work_stuff *work, const char **mangled,
2540                         strint *declp)
2541
2542 DESCRIPTION
2543
2544         DECLP points to the buffer into which demangling is being done.
2545
2546         *MANGLED points to the current token to be demangled.  On input,
2547         it points to a mangled class (I.E. "3foo", "13verylongclass", etc.)
2548         On exit, it points to the next token after the mangled class on
2549         success, or the first unconsumed token on failure.
2550
2551         If the CONSTRUCTOR or DESTRUCTOR flags are set in WORK, then
2552         we are demangling a constructor or destructor.  In this case
2553         we prepend "class::class" or "class::~class" to DECLP.
2554
2555         Otherwise, we prepend "class::" to the current DECLP.
2556
2557         Reset the constructor/destructor flags once they have been
2558         "consumed".  This allows demangle_class to be called later during
2559         the same demangling, to do normal class demangling.
2560
2561         Returns 1 if demangling is successful, 0 otherwise.
2562
2563 */
2564
2565 static int
2566 demangle_class (struct work_stuff *work, const char **mangled, string *declp)
2567 {
2568   int success = 0;
2569   int btype;
2570   string class_name;
2571   char *save_class_name_end = 0;
2572
2573   string_init (&class_name);
2574   btype = register_Btype (work);
2575   if (demangle_class_name (work, mangled, &class_name))
2576     {
2577       save_class_name_end = class_name.p;
2578       if ((work->constructor & 1) || (work->destructor & 1))
2579         {
2580           /* adjust so we don't include template args */
2581           if (work->temp_start && (work->temp_start != -1))
2582             {
2583               class_name.p = class_name.b + work->temp_start;
2584             }
2585           string_prepends (declp, &class_name);
2586           if (work -> destructor & 1)
2587             {
2588               string_prepend (declp, "~");
2589               work -> destructor -= 1;
2590             }
2591           else
2592             {
2593               work -> constructor -= 1;
2594             }
2595         }
2596       class_name.p = save_class_name_end;
2597       remember_Ktype (work, class_name.b, LEN_STRING(&class_name));
2598       remember_Btype (work, class_name.b, LEN_STRING(&class_name), btype);
2599       string_prepend (declp, SCOPE_STRING (work));
2600       string_prepends (declp, &class_name);
2601       success = 1;
2602     }
2603   string_delete (&class_name);
2604   return (success);
2605 }
2606
2607
2608 /* Called when there's a "__" in the mangled name, with `scan' pointing to
2609    the rightmost guess.
2610
2611    Find the correct "__"-sequence where the function name ends and the
2612    signature starts, which is ambiguous with GNU mangling.
2613    Call demangle_signature here, so we can make sure we found the right
2614    one; *mangled will be consumed so caller will not make further calls to
2615    demangle_signature.  */
2616
2617 static int
2618 iterate_demangle_function (struct work_stuff *work, const char **mangled,
2619                            string *declp, const char *scan)
2620 {
2621   const char *mangle_init = *mangled;
2622   int success = 0;
2623   string decl_init;
2624   struct work_stuff work_init;
2625
2626   if (*(scan + 2) == '\0')
2627     return 0;
2628
2629   /* Do not iterate for some demangling modes, or if there's only one
2630      "__"-sequence.  This is the normal case.  */
2631   if (ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING
2632       || strstr (scan + 2, "__") == NULL)
2633     return demangle_function_name (work, mangled, declp, scan);
2634
2635   /* Save state so we can restart if the guess at the correct "__" was
2636      wrong.  */
2637   string_init (&decl_init);
2638   string_appends (&decl_init, declp);
2639   memset (&work_init, 0, sizeof work_init);
2640   work_stuff_copy_to_from (&work_init, work);
2641
2642   /* Iterate over occurrences of __, allowing names and types to have a
2643      "__" sequence in them.  We must start with the first (not the last)
2644      occurrence, since "__" most often occur between independent mangled
2645      parts, hence starting at the last occurence inside a signature
2646      might get us a "successful" demangling of the signature.  */
2647
2648   while (scan[2])
2649     {
2650       if (demangle_function_name (work, mangled, declp, scan))
2651         {
2652           success = demangle_signature (work, mangled, declp);
2653           if (success)
2654             break;
2655         }
2656
2657       /* Reset demangle state for the next round.  */
2658       *mangled = mangle_init;
2659       string_clear (declp);
2660       string_appends (declp, &decl_init);
2661       work_stuff_copy_to_from (work, &work_init);
2662
2663       /* Leave this underscore-sequence.  */
2664       scan += 2;
2665
2666       /* Scan for the next "__" sequence.  */
2667       while (*scan && (scan[0] != '_' || scan[1] != '_'))
2668         scan++;
2669
2670       /* Move to last "__" in this sequence.  */
2671       while (*scan && *scan == '_')
2672         scan++;
2673       scan -= 2;
2674     }
2675
2676   /* Delete saved state.  */
2677   delete_work_stuff (&work_init);
2678   string_delete (&decl_init);
2679
2680   return success;
2681 }
2682
2683 /*
2684
2685 LOCAL FUNCTION
2686
2687         demangle_prefix -- consume the mangled name prefix and find signature
2688
2689 SYNOPSIS
2690
2691         static int
2692         demangle_prefix (struct work_stuff *work, const char **mangled,
2693                          string *declp);
2694
2695 DESCRIPTION
2696
2697         Consume and demangle the prefix of the mangled name.
2698         While processing the function name root, arrange to call
2699         demangle_signature if the root is ambiguous.
2700
2701         DECLP points to the string buffer into which demangled output is
2702         placed.  On entry, the buffer is empty.  On exit it contains
2703         the root function name, the demangled operator name, or in some
2704         special cases either nothing or the completely demangled result.
2705
2706         MANGLED points to the current pointer into the mangled name.  As each
2707         token of the mangled name is consumed, it is updated.  Upon entry
2708         the current mangled name pointer points to the first character of
2709         the mangled name.  Upon exit, it should point to the first character
2710         of the signature if demangling was successful, or to the first
2711         unconsumed character if demangling of the prefix was unsuccessful.
2712
2713         Returns 1 on success, 0 otherwise.
2714  */
2715
2716 static int
2717 demangle_prefix (struct work_stuff *work, const char **mangled,
2718                  string *declp)
2719 {
2720   int success = 1;
2721   const char *scan;
2722   int i;
2723
2724   if (strlen(*mangled) > 6
2725       && (strncmp(*mangled, "_imp__", 6) == 0
2726           || strncmp(*mangled, "__imp_", 6) == 0))
2727     {
2728       /* it's a symbol imported from a PE dynamic library. Check for both
2729          new style prefix _imp__ and legacy __imp_ used by older versions
2730          of dlltool. */
2731       (*mangled) += 6;
2732       work->dllimported = 1;
2733     }
2734   else if (strlen(*mangled) >= 11 && strncmp(*mangled, "_GLOBAL_", 8) == 0)
2735     {
2736       char *marker = strchr (cplus_markers, (*mangled)[8]);
2737       if (marker != NULL && *marker == (*mangled)[10])
2738         {
2739           if ((*mangled)[9] == 'D')
2740             {
2741               /* it's a GNU global destructor to be executed at program exit */
2742               (*mangled) += 11;
2743               work->destructor = 2;
2744               if (gnu_special (work, mangled, declp))
2745                 return success;
2746             }
2747           else if ((*mangled)[9] == 'I')
2748             {
2749               /* it's a GNU global constructor to be executed at program init */
2750               (*mangled) += 11;
2751               work->constructor = 2;
2752               if (gnu_special (work, mangled, declp))
2753                 return success;
2754             }
2755         }
2756     }
2757   else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__std__", 7) == 0)
2758     {
2759       /* it's a ARM global destructor to be executed at program exit */
2760       (*mangled) += 7;
2761       work->destructor = 2;
2762     }
2763   else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__sti__", 7) == 0)
2764     {
2765       /* it's a ARM global constructor to be executed at program initial */
2766       (*mangled) += 7;
2767       work->constructor = 2;
2768     }
2769
2770   /*  This block of code is a reduction in strength time optimization
2771       of:
2772       scan = strstr (*mangled, "__"); */
2773
2774   {
2775     scan = *mangled;
2776
2777     do {
2778       scan = strchr (scan, '_');
2779     } while (scan != NULL && *++scan != '_');
2780
2781     if (scan != NULL) --scan;
2782   }
2783
2784   if (scan != NULL)
2785     {
2786       /* We found a sequence of two or more '_', ensure that we start at
2787          the last pair in the sequence.  */
2788       i = strspn (scan, "_");
2789       if (i > 2)
2790         {
2791           scan += (i - 2);
2792         }
2793     }
2794
2795   if (scan == NULL)
2796     {
2797       success = 0;
2798     }
2799   else if (work -> static_type)
2800     {
2801       if (!ISDIGIT ((unsigned char)scan[0]) && (scan[0] != 't'))
2802         {
2803           success = 0;
2804         }
2805     }
2806   else if ((scan == *mangled)
2807            && (ISDIGIT ((unsigned char)scan[2]) || (scan[2] == 'Q')
2808                || (scan[2] == 't') || (scan[2] == 'K') || (scan[2] == 'H')))
2809     {
2810       /* The ARM says nothing about the mangling of local variables.
2811          But cfront mangles local variables by prepending __<nesting_level>
2812          to them. As an extension to ARM demangling we handle this case.  */
2813       if ((LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING)
2814           && ISDIGIT ((unsigned char)scan[2]))
2815         {
2816           *mangled = scan + 2;
2817           consume_count (mangled);
2818           string_append (declp, *mangled);
2819           *mangled += strlen (*mangled);
2820           success = 1;
2821         }
2822       else
2823         {
2824           /* A GNU style constructor starts with __[0-9Qt].  But cfront uses
2825              names like __Q2_3foo3bar for nested type names.  So don't accept
2826              this style of constructor for cfront demangling.  A GNU
2827              style member-template constructor starts with 'H'. */
2828           if (!(LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING))
2829             work -> constructor += 1;
2830           *mangled = scan + 2;
2831         }
2832     }
2833   else if (ARM_DEMANGLING && scan[2] == 'p' && scan[3] == 't')
2834     {
2835       /* Cfront-style parameterized type.  Handled later as a signature. */
2836       success = 1;
2837
2838       /* ARM template? */
2839       demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
2840     }
2841   else if (EDG_DEMANGLING && ((scan[2] == 't' && scan[3] == 'm')
2842                               || (scan[2] == 'p' && scan[3] == 's')
2843                               || (scan[2] == 'p' && scan[3] == 't')))
2844     {
2845       /* EDG-style parameterized type.  Handled later as a signature. */
2846       success = 1;
2847
2848       /* EDG template? */
2849       demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
2850     }
2851   else if ((scan == *mangled) && !ISDIGIT ((unsigned char)scan[2])
2852            && (scan[2] != 't'))
2853     {
2854       /* Mangled name starts with "__".  Skip over any leading '_' characters,
2855          then find the next "__" that separates the prefix from the signature.
2856          */
2857       if (!(ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
2858           || (arm_special (mangled, declp) == 0))
2859         {
2860           while (*scan == '_')
2861             {
2862               scan++;
2863             }
2864           if ((scan = strstr (scan, "__")) == NULL || (*(scan + 2) == '\0'))
2865             {
2866               /* No separator (I.E. "__not_mangled"), or empty signature
2867                  (I.E. "__not_mangled_either__") */
2868               success = 0;
2869             }
2870           else
2871             return iterate_demangle_function (work, mangled, declp, scan);
2872         }
2873     }
2874   else if (*(scan + 2) != '\0')
2875     {
2876       /* Mangled name does not start with "__" but does have one somewhere
2877          in there with non empty stuff after it.  Looks like a global
2878          function name.  Iterate over all "__":s until the right
2879          one is found.  */
2880       return iterate_demangle_function (work, mangled, declp, scan);
2881     }
2882   else
2883     {
2884       /* Doesn't look like a mangled name */
2885       success = 0;
2886     }
2887
2888   if (!success && (work->constructor == 2 || work->destructor == 2))
2889     {
2890       string_append (declp, *mangled);
2891       *mangled += strlen (*mangled);
2892       success = 1;
2893     }
2894   return (success);
2895 }
2896
2897 /*
2898
2899 LOCAL FUNCTION
2900
2901         gnu_special -- special handling of gnu mangled strings
2902
2903 SYNOPSIS
2904
2905         static int
2906         gnu_special (struct work_stuff *work, const char **mangled,
2907                      string *declp);
2908
2909
2910 DESCRIPTION
2911
2912         Process some special GNU style mangling forms that don't fit
2913         the normal pattern.  For example:
2914
2915                 _$_3foo         (destructor for class foo)
2916                 _vt$foo         (foo virtual table)
2917                 _vt$foo$bar     (foo::bar virtual table)
2918                 __vt_foo        (foo virtual table, new style with thunks)
2919                 _3foo$varname   (static data member)
2920                 _Q22rs2tu$vw    (static data member)
2921                 __t6vector1Zii  (constructor with template)
2922                 __thunk_4__$_7ostream (virtual function thunk)
2923  */
2924
2925 static int
2926 gnu_special (struct work_stuff *work, const char **mangled, string *declp)
2927 {
2928   int n;
2929   int success = 1;
2930   const char *p;
2931
2932   if ((*mangled)[0] == '_'
2933       && strchr (cplus_markers, (*mangled)[1]) != NULL
2934       && (*mangled)[2] == '_')
2935     {
2936       /* Found a GNU style destructor, get past "_<CPLUS_MARKER>_" */
2937       (*mangled) += 3;
2938       work -> destructor += 1;
2939     }
2940   else if ((*mangled)[0] == '_'
2941            && (((*mangled)[1] == '_'
2942                 && (*mangled)[2] == 'v'
2943                 && (*mangled)[3] == 't'
2944                 && (*mangled)[4] == '_')
2945                || ((*mangled)[1] == 'v'
2946                    && (*mangled)[2] == 't'
2947                    && strchr (cplus_markers, (*mangled)[3]) != NULL)))
2948     {
2949       /* Found a GNU style virtual table, get past "_vt<CPLUS_MARKER>"
2950          and create the decl.  Note that we consume the entire mangled
2951          input string, which means that demangle_signature has no work
2952          to do.  */
2953       if ((*mangled)[2] == 'v')
2954         (*mangled) += 5; /* New style, with thunks: "__vt_" */
2955       else
2956         (*mangled) += 4; /* Old style, no thunks: "_vt<CPLUS_MARKER>" */
2957       while (**mangled != '\0')
2958         {
2959           switch (**mangled)
2960             {
2961             case 'Q':
2962             case 'K':
2963               success = demangle_qualified (work, mangled, declp, 0, 1);
2964               break;
2965             case 't':
2966               success = demangle_template (work, mangled, declp, 0, 1,
2967                                            1);
2968               break;
2969             default:
2970               if (ISDIGIT((unsigned char)*mangled[0]))
2971                 {
2972                   n = consume_count(mangled);
2973                   /* We may be seeing a too-large size, or else a
2974                      ".<digits>" indicating a static local symbol.  In
2975                      any case, declare victory and move on; *don't* try
2976                      to use n to allocate.  */
2977                   if (n > (int) strlen (*mangled))
2978                     {
2979                       success = 1;
2980                       break;
2981                     }
2982                 }
2983               else
2984                 {
2985                   n = strcspn (*mangled, cplus_markers);
2986                 }
2987               string_appendn (declp, *mangled, n);
2988               (*mangled) += n;
2989             }
2990
2991           p = strpbrk (*mangled, cplus_markers);
2992           if (success && ((p == NULL) || (p == *mangled)))
2993             {
2994               if (p != NULL)
2995                 {
2996                   string_append (declp, SCOPE_STRING (work));
2997                   (*mangled)++;
2998                 }
2999             }
3000           else
3001             {
3002               success = 0;
3003               break;
3004             }
3005         }
3006       if (success)
3007         string_append (declp, " virtual table");
3008     }
3009   else if ((*mangled)[0] == '_'
3010            && (strchr("0123456789Qt", (*mangled)[1]) != NULL)
3011            && (p = strpbrk (*mangled, cplus_markers)) != NULL)
3012     {
3013       /* static data member, "_3foo$varname" for example */
3014       (*mangled)++;
3015       switch (**mangled)
3016         {
3017         case 'Q':
3018         case 'K':
3019           success = demangle_qualified (work, mangled, declp, 0, 1);
3020           break;
3021         case 't':
3022           success = demangle_template (work, mangled, declp, 0, 1, 1);
3023           break;
3024         default:
3025           n = consume_count (mangled);
3026           if (n < 0 || n > (long) strlen (*mangled))
3027             {
3028               success = 0;
3029               break;
3030             }
3031
3032           if (n > 10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
3033               && (*mangled)[9] == 'N'
3034               && (*mangled)[8] == (*mangled)[10]
3035               && strchr (cplus_markers, (*mangled)[8]))
3036             {
3037               /* A member of the anonymous namespace.  There's information
3038                  about what identifier or filename it was keyed to, but
3039                  it's just there to make the mangled name unique; we just
3040                  step over it.  */
3041               string_append (declp, "{anonymous}");
3042               (*mangled) += n;
3043
3044               /* Now p points to the marker before the N, so we need to
3045                  update it to the first marker after what we consumed.  */
3046               p = strpbrk (*mangled, cplus_markers);
3047               break;
3048             }
3049
3050           string_appendn (declp, *mangled, n);
3051           (*mangled) += n;
3052         }
3053       if (success && (p == *mangled))
3054         {
3055           /* Consumed everything up to the cplus_marker, append the
3056              variable name.  */
3057           (*mangled)++;
3058           string_append (declp, SCOPE_STRING (work));
3059           n = strlen (*mangled);
3060           string_appendn (declp, *mangled, n);
3061           (*mangled) += n;
3062         }
3063       else
3064         {
3065           success = 0;
3066         }
3067     }
3068   else if (strncmp (*mangled, "__thunk_", 8) == 0)
3069     {
3070       int delta;
3071
3072       (*mangled) += 8;
3073       delta = consume_count (mangled);
3074       if (delta == -1)
3075         success = 0;
3076       else
3077         {
3078           char *method = internal_cplus_demangle (work, ++*mangled);
3079
3080           if (method)
3081             {
3082               char buf[50];
3083               sprintf (buf, "virtual function thunk (delta:%d) for ", -delta);
3084               string_append (declp, buf);
3085               string_append (declp, method);
3086               free (method);
3087               n = strlen (*mangled);
3088               (*mangled) += n;
3089             }
3090           else
3091             {
3092               success = 0;
3093             }
3094         }
3095     }
3096   else if (strncmp (*mangled, "__t", 3) == 0
3097            && ((*mangled)[3] == 'i' || (*mangled)[3] == 'f'))
3098     {
3099       p = (*mangled)[3] == 'i' ? " type_info node" : " type_info function";
3100       (*mangled) += 4;
3101       switch (**mangled)
3102         {
3103         case 'Q':
3104         case 'K':
3105           success = demangle_qualified (work, mangled, declp, 0, 1);
3106           break;
3107         case 't':
3108           success = demangle_template (work, mangled, declp, 0, 1, 1);
3109           break;
3110         default:
3111           success = do_type (work, mangled, declp);
3112           break;
3113         }
3114       if (success && **mangled != '\0')
3115         success = 0;
3116       if (success)
3117         string_append (declp, p);
3118     }
3119   else
3120     {
3121       success = 0;
3122     }
3123   return (success);
3124 }
3125
3126 static void
3127 recursively_demangle(struct work_stuff *work, const char **mangled,
3128                      string *result, int namelength)
3129 {
3130   char * recurse = (char *)NULL;
3131   char * recurse_dem = (char *)NULL;
3132
3133   recurse = XNEWVEC (char, namelength + 1);
3134   memcpy (recurse, *mangled, namelength);
3135   recurse[namelength] = '\000';
3136
3137   recurse_dem = cplus_demangle (recurse, work->options);
3138
3139   if (recurse_dem)
3140     {
3141       string_append (result, recurse_dem);
3142       free (recurse_dem);
3143     }
3144   else
3145     {
3146       string_appendn (result, *mangled, namelength);
3147     }
3148   free (recurse);
3149   *mangled += namelength;
3150 }
3151
3152 /*
3153
3154 LOCAL FUNCTION
3155
3156         arm_special -- special handling of ARM/lucid mangled strings
3157
3158 SYNOPSIS
3159
3160         static int
3161         arm_special (const char **mangled,
3162                      string *declp);
3163
3164
3165 DESCRIPTION
3166
3167         Process some special ARM style mangling forms that don't fit
3168         the normal pattern.  For example:
3169
3170                 __vtbl__3foo            (foo virtual table)
3171                 __vtbl__3foo__3bar      (bar::foo virtual table)
3172
3173  */
3174
3175 static int
3176 arm_special (const char **mangled, string *declp)
3177 {
3178   int n;
3179   int success = 1;
3180   const char *scan;
3181
3182   if (strncmp (*mangled, ARM_VTABLE_STRING, ARM_VTABLE_STRLEN) == 0)
3183     {
3184       /* Found a ARM style virtual table, get past ARM_VTABLE_STRING
3185          and create the decl.  Note that we consume the entire mangled
3186          input string, which means that demangle_signature has no work
3187          to do.  */
3188       scan = *mangled + ARM_VTABLE_STRLEN;
3189       while (*scan != '\0')        /* first check it can be demangled */
3190         {
3191           n = consume_count (&scan);
3192           if (n == -1)
3193             {
3194               return (0);           /* no good */
3195             }
3196           scan += n;
3197           if (scan[0] == '_' && scan[1] == '_')
3198             {
3199               scan += 2;
3200             }
3201         }
3202       (*mangled) += ARM_VTABLE_STRLEN;
3203       while (**mangled != '\0')
3204         {
3205           n = consume_count (mangled);
3206           if (n == -1
3207               || n > (long) strlen (*mangled))
3208             return 0;
3209           string_prependn (declp, *mangled, n);
3210           (*mangled) += n;
3211           if ((*mangled)[0] == '_' && (*mangled)[1] == '_')
3212             {
3213               string_prepend (declp, "::");
3214               (*mangled) += 2;
3215             }
3216         }
3217       string_append (declp, " virtual table");
3218     }
3219   else
3220     {
3221       success = 0;
3222     }
3223   return (success);
3224 }
3225
3226 /*
3227
3228 LOCAL FUNCTION
3229
3230         demangle_qualified -- demangle 'Q' qualified name strings
3231
3232 SYNOPSIS
3233
3234         static int
3235         demangle_qualified (struct work_stuff *, const char *mangled,
3236                             string *result, int isfuncname, int append);
3237
3238 DESCRIPTION
3239
3240         Demangle a qualified name, such as "Q25Outer5Inner" which is
3241         the mangled form of "Outer::Inner".  The demangled output is
3242         prepended or appended to the result string according to the
3243         state of the append flag.
3244
3245         If isfuncname is nonzero, then the qualified name we are building
3246         is going to be used as a member function name, so if it is a
3247         constructor or destructor function, append an appropriate
3248         constructor or destructor name.  I.E. for the above example,
3249         the result for use as a constructor is "Outer::Inner::Inner"
3250         and the result for use as a destructor is "Outer::Inner::~Inner".
3251
3252 BUGS
3253
3254         Numeric conversion is ASCII dependent (FIXME).
3255
3256  */
3257
3258 static int
3259 demangle_qualified (struct work_stuff *work, const char **mangled,
3260                     string *result, int isfuncname, int append)
3261 {
3262   int qualifiers = 0;
3263   int success = 1;
3264   char num[2];
3265   string temp;
3266   string last_name;
3267   int bindex = register_Btype (work);
3268
3269   /* We only make use of ISFUNCNAME if the entity is a constructor or
3270      destructor.  */
3271   isfuncname = (isfuncname
3272                 && ((work->constructor & 1) || (work->destructor & 1)));
3273
3274   string_init (&temp);
3275   string_init (&last_name);
3276
3277   if ((*mangled)[0] == 'K')
3278     {
3279     /* Squangling qualified name reuse */
3280       int idx;
3281       (*mangled)++;
3282       idx = consume_count_with_underscores (mangled);
3283       if (idx == -1 || idx >= work -> numk)
3284         success = 0;
3285       else
3286         string_append (&temp, work -> ktypevec[idx]);
3287     }
3288   else
3289     switch ((*mangled)[1])
3290     {
3291     case '_':
3292       /* GNU mangled name with more than 9 classes.  The count is preceded
3293          by an underscore (to distinguish it from the <= 9 case) and followed
3294          by an underscore.  */
3295       (*mangled)++;
3296       qualifiers = consume_count_with_underscores (mangled);
3297       if (qualifiers == -1)
3298         success = 0;
3299       break;
3300
3301     case '1':
3302     case '2':
3303     case '3':
3304     case '4':
3305     case '5':
3306     case '6':
3307     case '7':
3308     case '8':
3309     case '9':
3310       /* The count is in a single digit.  */
3311       num[0] = (*mangled)[1];
3312       num[1] = '\0';
3313       qualifiers = atoi (num);
3314
3315       /* If there is an underscore after the digit, skip it.  This is
3316          said to be for ARM-qualified names, but the ARM makes no
3317          mention of such an underscore.  Perhaps cfront uses one.  */
3318       if ((*mangled)[2] == '_')
3319         {
3320           (*mangled)++;
3321         }
3322       (*mangled) += 2;
3323       break;
3324
3325     case '0':
3326     default:
3327       success = 0;
3328     }
3329
3330   if (!success)
3331     return success;
3332
3333   /* Pick off the names and collect them in the temp buffer in the order
3334      in which they are found, separated by '::'.  */
3335
3336   while (qualifiers-- > 0)
3337     {
3338       int remember_K = 1;
3339       string_clear (&last_name);
3340
3341       if (*mangled[0] == '_')
3342         (*mangled)++;
3343
3344       if (*mangled[0] == 't')
3345         {
3346           /* Here we always append to TEMP since we will want to use
3347              the template name without the template parameters as a
3348              constructor or destructor name.  The appropriate
3349              (parameter-less) value is returned by demangle_template
3350              in LAST_NAME.  We do not remember the template type here,
3351              in order to match the G++ mangling algorithm.  */
3352           success = demangle_template(work, mangled, &temp,
3353                                       &last_name, 1, 0);
3354           if (!success)
3355             break;
3356         }
3357       else if (*mangled[0] == 'K')
3358         {
3359           int idx;
3360           (*mangled)++;
3361           idx = consume_count_with_underscores (mangled);
3362           if (idx == -1 || idx >= work->numk)
3363             success = 0;
3364           else
3365             string_append (&temp, work->ktypevec[idx]);
3366           remember_K = 0;
3367
3368           if (!success) break;
3369         }
3370       else
3371         {
3372           if (EDG_DEMANGLING)
3373             {
3374               int namelength;
3375               /* Now recursively demangle the qualifier
3376                * This is necessary to deal with templates in
3377                * mangling styles like EDG */
3378               namelength = consume_count (mangled);
3379               if (namelength == -1)
3380                 {
3381                   success = 0;
3382                   break;
3383                 }
3384               recursively_demangle(work, mangled, &temp, namelength);
3385             }
3386           else
3387             {
3388               string_delete (&last_name);
3389               success = do_type (work, mangled, &last_name);
3390               if (!success)
3391                 break;
3392               string_appends (&temp, &last_name);
3393             }
3394         }
3395
3396       if (remember_K)
3397         remember_Ktype (work, temp.b, LEN_STRING (&temp));
3398
3399       if (qualifiers > 0)
3400         string_append (&temp, SCOPE_STRING (work));
3401     }
3402
3403   remember_Btype (work, temp.b, LEN_STRING (&temp), bindex);
3404
3405   /* If we are using the result as a function name, we need to append
3406      the appropriate '::' separated constructor or destructor name.
3407      We do this here because this is the most convenient place, where
3408      we already have a pointer to the name and the length of the name.  */
3409
3410   if (isfuncname)
3411     {
3412       string_append (&temp, SCOPE_STRING (work));
3413       if (work -> destructor & 1)
3414         string_append (&temp, "~");
3415       string_appends (&temp, &last_name);
3416     }
3417
3418   /* Now either prepend the temp buffer to the result, or append it,
3419      depending upon the state of the append flag.  */
3420
3421   if (append)
3422     string_appends (result, &temp);
3423   else
3424     {
3425       if (!STRING_EMPTY (result))
3426         string_append (&temp, SCOPE_STRING (work));
3427       string_prepends (result, &temp);
3428     }
3429
3430   string_delete (&last_name);
3431   string_delete (&temp);
3432   return (success);
3433 }
3434
3435 /*
3436
3437 LOCAL FUNCTION
3438
3439         get_count -- convert an ascii count to integer, consuming tokens
3440
3441 SYNOPSIS
3442
3443         static int
3444         get_count (const char **type, int *count)
3445
3446 DESCRIPTION
3447
3448         Assume that *type points at a count in a mangled name; set
3449         *count to its value, and set *type to the next character after
3450         the count.  There are some weird rules in effect here.
3451
3452         If *type does not point at a string of digits, return zero.
3453
3454         If *type points at a string of digits followed by an
3455         underscore, set *count to their value as an integer, advance
3456         *type to point *after the underscore, and return 1.
3457
3458         If *type points at a string of digits not followed by an
3459         underscore, consume only the first digit.  Set *count to its
3460         value as an integer, leave *type pointing after that digit,
3461         and return 1.
3462
3463         The excuse for this odd behavior: in the ARM and HP demangling
3464         styles, a type can be followed by a repeat count of the form
3465         `Nxy', where:
3466
3467         `x' is a single digit specifying how many additional copies
3468             of the type to append to the argument list, and
3469
3470         `y' is one or more digits, specifying the zero-based index of
3471             the first repeated argument in the list.  Yes, as you're
3472             unmangling the name you can figure this out yourself, but
3473             it's there anyway.
3474
3475         So, for example, in `bar__3fooFPiN51', the first argument is a
3476         pointer to an integer (`Pi'), and then the next five arguments
3477         are the same (`N5'), and the first repeat is the function's
3478         second argument (`1').
3479 */
3480
3481 static int
3482 get_count (const char **type, int *count)
3483 {
3484   const char *p;
3485   int n;
3486
3487   if (!ISDIGIT ((unsigned char)**type))
3488     return (0);
3489   else
3490     {
3491       *count = **type - '0';
3492       (*type)++;
3493       if (ISDIGIT ((unsigned char)**type))
3494         {
3495           p = *type;
3496           n = *count;
3497           do
3498             {
3499               n *= 10;
3500               n += *p - '0';
3501               p++;
3502             }
3503           while (ISDIGIT ((unsigned char)*p));
3504           if (*p == '_')
3505             {
3506               *type = p + 1;
3507               *count = n;
3508             }
3509         }
3510     }
3511   return (1);
3512 }
3513
3514 /* RESULT will be initialised here; it will be freed on failure.  The
3515    value returned is really a type_kind_t.  */
3516
3517 static int
3518 do_type (struct work_stuff *work, const char **mangled, string *result)
3519 {
3520   int n;
3521   int done;
3522   int success;
3523   string decl;
3524   const char *remembered_type;
3525   int type_quals;
3526   type_kind_t tk = tk_none;
3527
3528   string_init (&decl);
3529   string_init (result);
3530
3531   done = 0;
3532   success = 1;
3533   while (success && !done)
3534     {
3535       int member;
3536       switch (**mangled)
3537         {
3538
3539           /* A pointer type */
3540         case 'P':
3541         case 'p':
3542           (*mangled)++;
3543           if (! (work -> options & DMGL_JAVA))
3544             string_prepend (&decl, "*");
3545           if (tk == tk_none)
3546             tk = tk_pointer;
3547           break;
3548
3549           /* A reference type */
3550         case 'R':
3551           (*mangled)++;
3552           string_prepend (&decl, "&");
3553           if (tk == tk_none)
3554             tk = tk_reference;
3555           break;
3556
3557           /* An array */
3558         case 'A':
3559           {
3560             ++(*mangled);
3561             if (!STRING_EMPTY (&decl)
3562                 && (decl.b[0] == '*' || decl.b[0] == '&'))
3563               {
3564                 string_prepend (&decl, "(");
3565                 string_append (&decl, ")");
3566               }
3567             string_append (&decl, "[");
3568             if (**mangled != '_')
3569               success = demangle_template_value_parm (work, mangled, &decl,
3570                                                       tk_integral);
3571             if (**mangled == '_')
3572               ++(*mangled);
3573             string_append (&decl, "]");
3574             break;
3575           }
3576
3577         /* A back reference to a previously seen type */
3578         case 'T':
3579           (*mangled)++;
3580           if (!get_count (mangled, &n) || n >= work -> ntypes)
3581             {
3582               success = 0;
3583             }
3584           else
3585             {
3586               remembered_type = work -> typevec[n];
3587               mangled = &remembered_type;
3588             }
3589           break;
3590
3591           /* A function */
3592         case 'F':
3593           (*mangled)++;
3594             if (!STRING_EMPTY (&decl)
3595                 && (decl.b[0] == '*' || decl.b[0] == '&'))
3596             {
3597               string_prepend (&decl, "(");
3598               string_append (&decl, ")");
3599             }
3600           /* After picking off the function args, we expect to either find the
3601              function return type (preceded by an '_') or the end of the
3602              string.  */
3603           if (!demangle_nested_args (work, mangled, &decl)
3604               || (**mangled != '_' && **mangled != '\0'))
3605             {
3606               success = 0;
3607               break;
3608             }
3609           if (success && (**mangled == '_'))
3610             (*mangled)++;
3611           break;
3612
3613         case 'M':
3614         case 'O':
3615           {
3616             type_quals = TYPE_UNQUALIFIED;
3617
3618             member = **mangled == 'M';
3619             (*mangled)++;
3620
3621             string_append (&decl, ")");
3622
3623             /* We don't need to prepend `::' for a qualified name;
3624                demangle_qualified will do that for us.  */
3625             if (**mangled != 'Q')
3626               string_prepend (&decl, SCOPE_STRING (work));
3627
3628             if (ISDIGIT ((unsigned char)**mangled))
3629               {
3630                 n = consume_count (mangled);
3631                 if (n == -1
3632                     || (int) strlen (*mangled) < n)
3633                   {
3634                     success = 0;
3635                     break;
3636                   }
3637                 string_prependn (&decl, *mangled, n);
3638                 *mangled += n;
3639               }
3640             else if (**mangled == 'X' || **mangled == 'Y')
3641               {
3642                 string temp;
3643                 do_type (work, mangled, &temp);
3644                 string_prepends (&decl, &temp);
3645                 string_delete (&temp);
3646               }
3647             else if (**mangled == 't')
3648               {
3649                 string temp;
3650                 string_init (&temp);
3651                 success = demangle_template (work, mangled, &temp,
3652                                              NULL, 1, 1);
3653                 if (success)
3654                   {
3655                     string_prependn (&decl, temp.b, temp.p - temp.b);
3656                     string_delete (&temp);
3657                   }
3658                 else
3659                   break;
3660               }
3661             else if (**mangled == 'Q')
3662               {
3663                 success = demangle_qualified (work, mangled, &decl,
3664                                               /*isfuncnam=*/0,
3665                                               /*append=*/0);
3666                 if (!success)
3667                   break;
3668               }
3669             else
3670               {
3671                 success = 0;
3672                 break;
3673               }
3674
3675             string_prepend (&decl, "(");
3676             if (member)
3677               {
3678                 switch (**mangled)
3679                   {
3680                   case 'C':
3681                   case 'V':
3682                   case 'u':
3683                     type_quals |= code_for_qualifier (**mangled);
3684                     (*mangled)++;
3685                     break;
3686
3687                   default:
3688                     break;
3689                   }
3690
3691                 if (*(*mangled)++ != 'F')
3692                   {
3693                     success = 0;
3694                     break;
3695                   }
3696               }
3697             if ((member && !demangle_nested_args (work, mangled, &decl))
3698                 || **mangled != '_')
3699               {
3700                 success = 0;
3701                 break;
3702               }
3703             (*mangled)++;
3704             if (! PRINT_ANSI_QUALIFIERS)
3705               {
3706                 break;
3707               }
3708             if (type_quals != TYPE_UNQUALIFIED)
3709               {
3710                 APPEND_BLANK (&decl);
3711                 string_append (&decl, qualifier_string (type_quals));
3712               }
3713             break;
3714           }
3715         case 'G':
3716           (*mangled)++;
3717           break;
3718
3719         case 'C':
3720         case 'V':
3721         case 'u':
3722           if (PRINT_ANSI_QUALIFIERS)
3723             {
3724               if (!STRING_EMPTY (&decl))
3725                 string_prepend (&decl, " ");
3726
3727               string_prepend (&decl, demangle_qualifier (**mangled));
3728             }
3729           (*mangled)++;
3730           break;
3731           /*
3732             }
3733             */
3734
3735           /* fall through */
3736         default:
3737           done = 1;
3738           break;
3739         }
3740     }
3741
3742   if (success) switch (**mangled)
3743     {
3744       /* A qualified name, such as "Outer::Inner".  */
3745     case 'Q':
3746     case 'K':
3747       {
3748         success = demangle_qualified (work, mangled, result, 0, 1);
3749         break;
3750       }
3751
3752     /* A back reference to a previously seen squangled type */
3753     case 'B':
3754       (*mangled)++;
3755       if (!get_count (mangled, &n) || n >= work -> numb)
3756         success = 0;
3757       else
3758         string_append (result, work->btypevec[n]);
3759       break;
3760
3761     case 'X':
3762     case 'Y':
3763       /* A template parm.  We substitute the corresponding argument. */
3764       {
3765         int idx;
3766
3767         (*mangled)++;
3768         idx = consume_count_with_underscores (mangled);
3769
3770         if (idx == -1
3771             || (work->tmpl_argvec && idx >= work->ntmpl_args)
3772             || consume_count_with_underscores (mangled) == -1)
3773           {
3774             success = 0;
3775             break;
3776           }
3777
3778         if (work->tmpl_argvec)
3779           string_append (result, work->tmpl_argvec[idx]);
3780         else
3781           string_append_template_idx (result, idx);
3782
3783         success = 1;
3784       }
3785     break;
3786
3787     default:
3788       success = demangle_fund_type (work, mangled, result);
3789       if (tk == tk_none)
3790         tk = (type_kind_t) success;
3791       break;
3792     }
3793
3794   if (success)
3795     {
3796       if (!STRING_EMPTY (&decl))
3797         {
3798           string_append (result, " ");
3799           string_appends (result, &decl);
3800         }
3801     }
3802   else
3803     string_delete (result);
3804   string_delete (&decl);
3805
3806   if (success)
3807     /* Assume an integral type, if we're not sure.  */
3808     return (int) ((tk == tk_none) ? tk_integral : tk);
3809   else
3810     return 0;
3811 }
3812
3813 /* Given a pointer to a type string that represents a fundamental type
3814    argument (int, long, unsigned int, etc) in TYPE, a pointer to the
3815    string in which the demangled output is being built in RESULT, and
3816    the WORK structure, decode the types and add them to the result.
3817
3818    For example:
3819
3820         "Ci"    =>      "const int"
3821         "Sl"    =>      "signed long"
3822         "CUs"   =>      "const unsigned short"
3823
3824    The value returned is really a type_kind_t.  */
3825
3826 static int
3827 demangle_fund_type (struct work_stuff *work,
3828                     const char **mangled, string *result)
3829 {
3830   int done = 0;
3831   int success = 1;
3832   char buf[INTBUF_SIZE + 5 /* 'int%u_t' */];
3833   unsigned int dec = 0;
3834   type_kind_t tk = tk_integral;
3835
3836   /* First pick off any type qualifiers.  There can be more than one.  */
3837
3838   while (!done)
3839     {
3840       switch (**mangled)
3841         {
3842         case 'C':
3843         case 'V':
3844         case 'u':
3845           if (PRINT_ANSI_QUALIFIERS)
3846             {
3847               if (!STRING_EMPTY (result))
3848                 string_prepend (result, " ");
3849               string_prepend (result, demangle_qualifier (**mangled));
3850             }
3851           (*mangled)++;
3852           break;
3853         case 'U':
3854           (*mangled)++;
3855           APPEND_BLANK (result);
3856           string_append (result, "unsigned");
3857           break;
3858         case 'S': /* signed char only */
3859           (*mangled)++;
3860           APPEND_BLANK (result);
3861           string_append (result, "signed");
3862           break;
3863         case 'J':
3864           (*mangled)++;
3865           APPEND_BLANK (result);
3866           string_append (result, "__complex");
3867           break;
3868         default:
3869           done = 1;
3870           break;
3871         }
3872     }
3873
3874   /* Now pick off the fundamental type.  There can be only one.  */
3875
3876   switch (**mangled)
3877     {
3878     case '\0':
3879     case '_':
3880       break;
3881     case 'v':
3882       (*mangled)++;
3883       APPEND_BLANK (result);
3884       string_append (result, "void");
3885       break;
3886     case 'x':
3887       (*mangled)++;
3888       APPEND_BLANK (result);
3889       string_append (result, "long long");
3890       break;
3891     case 'l':
3892       (*mangled)++;
3893       APPEND_BLANK (result);
3894       string_append (result, "long");
3895       break;
3896     case 'i':
3897       (*mangled)++;
3898       APPEND_BLANK (result);
3899       string_append (result, "int");
3900       break;
3901     case 's':
3902       (*mangled)++;
3903       APPEND_BLANK (result);
3904       string_append (result, "short");
3905       break;
3906     case 'b':
3907       (*mangled)++;
3908       APPEND_BLANK (result);
3909       string_append (result, "bool");
3910       tk = tk_bool;
3911       break;
3912     case 'c':
3913       (*mangled)++;
3914       APPEND_BLANK (result);
3915       string_append (result, "char");
3916       tk = tk_char;
3917       break;
3918     case 'w':
3919       (*mangled)++;
3920       APPEND_BLANK (result);
3921       string_append (result, "wchar_t");
3922       tk = tk_char;
3923       break;
3924     case 'r':
3925       (*mangled)++;
3926       APPEND_BLANK (result);
3927       string_append (result, "long double");
3928       tk = tk_real;
3929       break;
3930     case 'd':
3931       (*mangled)++;
3932       APPEND_BLANK (result);
3933       string_append (result, "double");
3934       tk = tk_real;
3935       break;
3936     case 'f':
3937       (*mangled)++;
3938       APPEND_BLANK (result);
3939       string_append (result, "float");
3940       tk = tk_real;
3941       break;
3942     case 'G':
3943       (*mangled)++;
3944       if (!ISDIGIT ((unsigned char)**mangled))
3945         {
3946           success = 0;
3947           break;
3948         }
3949     case 'I':
3950       (*mangled)++;
3951       if (**mangled == '_')
3952         {
3953           int i;
3954           (*mangled)++;
3955           for (i = 0;
3956                i < (long) sizeof (buf) - 1 && **mangled && **mangled != '_';
3957                (*mangled)++, i++)
3958             buf[i] = **mangled;
3959           if (**mangled != '_')
3960             {
3961               success = 0;
3962               break;
3963             }
3964           buf[i] = '\0';
3965           (*mangled)++;
3966         }
3967       else
3968         {
3969           strncpy (buf, *mangled, 2);
3970           buf[2] = '\0';
3971           *mangled += min (strlen (*mangled), 2);
3972         }
3973       sscanf (buf, "%x", &dec);
3974       sprintf (buf, "int%u_t", dec);
3975       APPEND_BLANK (result);
3976       string_append (result, buf);
3977       break;
3978
3979       /* fall through */
3980       /* An explicit type, such as "6mytype" or "7integer" */
3981     case '0':
3982     case '1':
3983     case '2':
3984     case '3':
3985     case '4':
3986     case '5':
3987     case '6':
3988     case '7':
3989     case '8':
3990     case '9':
3991       {
3992         int bindex = register_Btype (work);
3993         string btype;
3994         string_init (&btype);
3995         if (demangle_class_name (work, mangled, &btype)) {
3996           remember_Btype (work, btype.b, LEN_STRING (&btype), bindex);
3997           APPEND_BLANK (result);
3998           string_appends (result, &btype);
3999         }
4000         else
4001           success = 0;
4002         string_delete (&btype);
4003         break;
4004       }
4005     case 't':
4006       {
4007         string btype;
4008         string_init (&btype);
4009         success = demangle_template (work, mangled, &btype, 0, 1, 1);
4010         string_appends (result, &btype);
4011         string_delete (&btype);
4012         break;
4013       }
4014     default:
4015       success = 0;
4016       break;
4017     }
4018
4019   return success ? ((int) tk) : 0;
4020 }
4021
4022
4023 /* Handle a template's value parameter for HP aCC (extension from ARM)
4024    **mangled points to 'S' or 'U' */
4025
4026 static int
4027 do_hpacc_template_const_value (struct work_stuff *work ATTRIBUTE_UNUSED,
4028                                const char **mangled, string *result)
4029 {
4030   int unsigned_const;
4031
4032   if (**mangled != 'U' && **mangled != 'S')
4033     return 0;
4034
4035   unsigned_const = (**mangled == 'U');
4036
4037   (*mangled)++;
4038
4039   switch (**mangled)
4040     {
4041       case 'N':
4042         string_append (result, "-");
4043         /* fall through */
4044       case 'P':
4045         (*mangled)++;
4046         break;
4047       case 'M':
4048         /* special case for -2^31 */
4049         string_append (result, "-2147483648");
4050         (*mangled)++;
4051         return 1;
4052       default:
4053         return 0;
4054     }
4055
4056   /* We have to be looking at an integer now */
4057   if (!(ISDIGIT ((unsigned char)**mangled)))
4058     return 0;
4059
4060   /* We only deal with integral values for template
4061      parameters -- so it's OK to look only for digits */
4062   while (ISDIGIT ((unsigned char)**mangled))
4063     {
4064       char_str[0] = **mangled;
4065       string_append (result, char_str);
4066       (*mangled)++;
4067     }
4068
4069   if (unsigned_const)
4070     string_append (result, "U");
4071
4072   /* FIXME? Some day we may have 64-bit (or larger :-) ) constants
4073      with L or LL suffixes. pai/1997-09-03 */
4074
4075   return 1; /* success */
4076 }
4077
4078 /* Handle a template's literal parameter for HP aCC (extension from ARM)
4079    **mangled is pointing to the 'A' */
4080
4081 static int
4082 do_hpacc_template_literal (struct work_stuff *work, const char **mangled,
4083                            string *result)
4084 {
4085   int literal_len = 0;
4086   char * recurse;
4087   char * recurse_dem;
4088
4089   if (**mangled != 'A')
4090     return 0;
4091
4092   (*mangled)++;
4093
4094   literal_len = consume_count (mangled);
4095
4096   if (literal_len <= 0)
4097     return 0;
4098
4099   /* Literal parameters are names of arrays, functions, etc.  and the
4100      canonical representation uses the address operator */
4101   string_append (result, "&");
4102
4103   /* Now recursively demangle the literal name */
4104   recurse = XNEWVEC (char, literal_len + 1);
4105   memcpy (recurse, *mangled, literal_len);
4106   recurse[literal_len] = '\000';
4107
4108   recurse_dem = cplus_demangle (recurse, work->options);
4109
4110   if (recurse_dem)
4111     {
4112       string_append (result, recurse_dem);
4113       free (recurse_dem);
4114     }
4115   else
4116     {
4117       string_appendn (result, *mangled, literal_len);
4118     }
4119   (*mangled) += literal_len;
4120   free (recurse);
4121
4122   return 1;
4123 }
4124
4125 static int
4126 snarf_numeric_literal (const char **args, string *arg)
4127 {
4128   if (**args == '-')
4129     {
4130       char_str[0] = '-';
4131       string_append (arg, char_str);
4132       (*args)++;
4133     }
4134   else if (**args == '+')
4135     (*args)++;
4136
4137   if (!ISDIGIT ((unsigned char)**args))
4138     return 0;
4139
4140   while (ISDIGIT ((unsigned char)**args))
4141     {
4142       char_str[0] = **args;
4143       string_append (arg, char_str);
4144       (*args)++;
4145     }
4146
4147   return 1;
4148 }
4149
4150 /* Demangle the next argument, given by MANGLED into RESULT, which
4151    *should be an uninitialized* string.  It will be initialized here,
4152    and free'd should anything go wrong.  */
4153
4154 static int
4155 do_arg (struct work_stuff *work, const char **mangled, string *result)
4156 {
4157   /* Remember where we started so that we can record the type, for
4158      non-squangling type remembering.  */
4159   const char *start = *mangled;
4160
4161   string_init (result);
4162
4163   if (work->nrepeats > 0)
4164     {
4165       --work->nrepeats;
4166
4167       if (work->previous_argument == 0)
4168         return 0;
4169
4170       /* We want to reissue the previous type in this argument list.  */
4171       string_appends (result, work->previous_argument);
4172       return 1;
4173     }
4174
4175   if (**mangled == 'n')
4176     {
4177       /* A squangling-style repeat.  */
4178       (*mangled)++;
4179       work->nrepeats = consume_count(mangled);
4180
4181       if (work->nrepeats <= 0)
4182         /* This was not a repeat count after all.  */
4183         return 0;
4184
4185       if (work->nrepeats > 9)
4186         {
4187           if (**mangled != '_')
4188             /* The repeat count should be followed by an '_' in this
4189                case.  */
4190             return 0;
4191           else
4192             (*mangled)++;
4193         }
4194
4195       /* Now, the repeat is all set up.  */
4196       return do_arg (work, mangled, result);
4197     }
4198
4199   /* Save the result in WORK->previous_argument so that we can find it
4200      if it's repeated.  Note that saving START is not good enough: we
4201      do not want to add additional types to the back-referenceable
4202      type vector when processing a repeated type.  */
4203   if (work->previous_argument)
4204     string_delete (work->previous_argument);
4205   else
4206     work->previous_argument = XNEW (string);
4207
4208   if (!do_type (work, mangled, work->previous_argument))
4209     return 0;
4210
4211   string_appends (result, work->previous_argument);
4212
4213   remember_type (work, start, *mangled - start);
4214   return 1;
4215 }
4216
4217 static void
4218 remember_type (struct work_stuff *work, const char *start, int len)
4219 {
4220   char *tem;
4221
4222   if (work->forgetting_types)
4223     return;
4224
4225   if (work -> ntypes >= work -> typevec_size)
4226     {
4227       if (work -> typevec_size == 0)
4228         {
4229           work -> typevec_size = 3;
4230           work -> typevec = XNEWVEC (char *, work->typevec_size);
4231         }
4232       else
4233         {
4234           work -> typevec_size *= 2;
4235           work -> typevec
4236             = XRESIZEVEC (char *, work->typevec, work->typevec_size);
4237         }
4238     }
4239   tem = XNEWVEC (char, len + 1);
4240   memcpy (tem, start, len);
4241   tem[len] = '\0';
4242   work -> typevec[work -> ntypes++] = tem;
4243 }
4244
4245
4246 /* Remember a K type class qualifier. */
4247 static void
4248 remember_Ktype (struct work_stuff *work, const char *start, int len)
4249 {
4250   char *tem;
4251
4252   if (work -> numk >= work -> ksize)
4253     {
4254       if (work -> ksize == 0)
4255         {
4256           work -> ksize = 5;
4257           work -> ktypevec = XNEWVEC (char *, work->ksize);
4258         }
4259       else
4260         {
4261           work -> ksize *= 2;
4262           work -> ktypevec
4263             = XRESIZEVEC (char *, work->ktypevec, work->ksize);
4264         }
4265     }
4266   tem = XNEWVEC (char, len + 1);
4267   memcpy (tem, start, len);
4268   tem[len] = '\0';
4269   work -> ktypevec[work -> numk++] = tem;
4270 }
4271
4272 /* Register a B code, and get an index for it. B codes are registered
4273    as they are seen, rather than as they are completed, so map<temp<char> >
4274    registers map<temp<char> > as B0, and temp<char> as B1 */
4275
4276 static int
4277 register_Btype (struct work_stuff *work)
4278 {
4279   int ret;
4280
4281   if (work -> numb >= work -> bsize)
4282     {
4283       if (work -> bsize == 0)
4284         {
4285           work -> bsize = 5;
4286           work -> btypevec = XNEWVEC (char *, work->bsize);
4287         }
4288       else
4289         {
4290           work -> bsize *= 2;
4291           work -> btypevec
4292             = XRESIZEVEC (char *, work->btypevec, work->bsize);
4293         }
4294     }
4295   ret = work -> numb++;
4296   work -> btypevec[ret] = NULL;
4297   return(ret);
4298 }
4299
4300 /* Store a value into a previously registered B code type. */
4301
4302 static void
4303 remember_Btype (struct work_stuff *work, const char *start,
4304                 int len, int index)
4305 {
4306   char *tem;
4307
4308   tem = XNEWVEC (char, len + 1);
4309   memcpy (tem, start, len);
4310   tem[len] = '\0';
4311   work -> btypevec[index] = tem;
4312 }
4313
4314 /* Lose all the info related to B and K type codes. */
4315 static void
4316 forget_B_and_K_types (struct work_stuff *work)
4317 {
4318   int i;
4319
4320   while (work -> numk > 0)
4321     {
4322       i = --(work -> numk);
4323       if (work -> ktypevec[i] != NULL)
4324         {
4325           free (work -> ktypevec[i]);
4326           work -> ktypevec[i] = NULL;
4327         }
4328     }
4329
4330   while (work -> numb > 0)
4331     {
4332       i = --(work -> numb);
4333       if (work -> btypevec[i] != NULL)
4334         {
4335           free (work -> btypevec[i]);
4336           work -> btypevec[i] = NULL;
4337         }
4338     }
4339 }
4340 /* Forget the remembered types, but not the type vector itself.  */
4341
4342 static void
4343 forget_types (struct work_stuff *work)
4344 {
4345   int i;
4346
4347   while (work -> ntypes > 0)
4348     {
4349       i = --(work -> ntypes);
4350       if (work -> typevec[i] != NULL)
4351         {
4352           free (work -> typevec[i]);
4353           work -> typevec[i] = NULL;
4354         }
4355     }
4356 }
4357
4358 /* Process the argument list part of the signature, after any class spec
4359    has been consumed, as well as the first 'F' character (if any).  For
4360    example:
4361
4362    "__als__3fooRT0"             =>      process "RT0"
4363    "complexfunc5__FPFPc_PFl_i"  =>      process "PFPc_PFl_i"
4364
4365    DECLP must be already initialised, usually non-empty.  It won't be freed
4366    on failure.
4367
4368    Note that g++ differs significantly from ARM and lucid style mangling
4369    with regards to references to previously seen types.  For example, given
4370    the source fragment:
4371
4372      class foo {
4373        public:
4374        foo::foo (int, foo &ia, int, foo &ib, int, foo &ic);
4375      };
4376
4377      foo::foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
4378      void foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
4379
4380    g++ produces the names:
4381
4382      __3fooiRT0iT2iT2
4383      foo__FiR3fooiT1iT1
4384
4385    while lcc (and presumably other ARM style compilers as well) produces:
4386
4387      foo__FiR3fooT1T2T1T2
4388      __ct__3fooFiR3fooT1T2T1T2
4389
4390    Note that g++ bases its type numbers starting at zero and counts all
4391    previously seen types, while lucid/ARM bases its type numbers starting
4392    at one and only considers types after it has seen the 'F' character
4393    indicating the start of the function args.  For lucid/ARM style, we
4394    account for this difference by discarding any previously seen types when
4395    we see the 'F' character, and subtracting one from the type number
4396    reference.
4397
4398  */
4399
4400 static int
4401 demangle_args (struct work_stuff *work, const char **mangled,
4402                string *declp)
4403 {
4404   string arg;
4405   int need_comma = 0;
4406   int r;
4407   int t;
4408   const char *tem;
4409   char temptype;
4410
4411   if (PRINT_ARG_TYPES)
4412     {
4413       string_append (declp, "(");
4414       if (**mangled == '\0')
4415         {
4416           string_append (declp, "void");
4417         }
4418     }
4419
4420   while ((**mangled != '_' && **mangled != '\0' && **mangled != 'e')
4421          || work->nrepeats > 0)
4422     {
4423       if ((**mangled == 'N') || (**mangled == 'T'))
4424         {
4425           temptype = *(*mangled)++;
4426
4427           if (temptype == 'N')
4428             {
4429               if (!get_count (mangled, &r))
4430                 {
4431                   return (0);
4432                 }
4433             }
4434           else
4435             {
4436               r = 1;
4437             }
4438           if ((HP_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING) && work -> ntypes >= 10)
4439             {
4440               /* If we have 10 or more types we might have more than a 1 digit
4441                  index so we'll have to consume the whole count here. This
4442                  will lose if the next thing is a type name preceded by a
4443                  count but it's impossible to demangle that case properly
4444                  anyway. Eg if we already have 12 types is T12Pc "(..., type1,
4445                  Pc, ...)"  or "(..., type12, char *, ...)" */
4446               if ((t = consume_count(mangled)) <= 0)
4447                 {
4448                   return (0);
4449                 }
4450             }
4451           else
4452             {
4453               if (!get_count (mangled, &t))
4454                 {
4455                   return (0);
4456                 }
4457             }
4458           if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
4459             {
4460               t--;
4461             }
4462           /* Validate the type index.  Protect against illegal indices from
4463              malformed type strings.  */
4464           if ((t < 0) || (t >= work -> ntypes))
4465             {
4466               return (0);
4467             }
4468           while (work->nrepeats > 0 || --r >= 0)
4469             {
4470               tem = work -> typevec[t];
4471               if (need_comma && PRINT_ARG_TYPES)
4472                 {
4473                   string_append (declp, ", ");
4474                 }
4475               if (!do_arg (work, &tem, &arg))
4476                 {
4477                   return (0);
4478                 }
4479               if (PRINT_ARG_TYPES)
4480                 {
4481                   string_appends (declp, &arg);
4482                 }
4483               string_delete (&arg);
4484               need_comma = 1;
4485             }
4486         }
4487       else
4488         {
4489           if (need_comma && PRINT_ARG_TYPES)
4490             string_append (declp, ", ");
4491           if (!do_arg (work, mangled, &arg))
4492             return (0);
4493           if (PRINT_ARG_TYPES)
4494             string_appends (declp, &arg);
4495           string_delete (&arg);
4496           need_comma = 1;
4497         }
4498     }
4499
4500   if (**mangled == 'e')
4501     {
4502       (*mangled)++;
4503       if (PRINT_ARG_TYPES)
4504         {
4505           if (need_comma)
4506             {
4507               string_append (declp, ",");
4508             }
4509           string_append (declp, "...");
4510         }
4511     }
4512
4513   if (PRINT_ARG_TYPES)
4514     {
4515       string_append (declp, ")");
4516     }
4517   return (1);
4518 }
4519
4520 /* Like demangle_args, but for demangling the argument lists of function
4521    and method pointers or references, not top-level declarations.  */
4522
4523 static int
4524 demangle_nested_args (struct work_stuff *work, const char **mangled,
4525                       string *declp)
4526 {
4527   string* saved_previous_argument;
4528   int result;
4529   int saved_nrepeats;
4530
4531   /* The G++ name-mangling algorithm does not remember types on nested
4532      argument lists, unless -fsquangling is used, and in that case the
4533      type vector updated by remember_type is not used.  So, we turn
4534      off remembering of types here.  */
4535   ++work->forgetting_types;
4536
4537   /* For the repeat codes used with -fsquangling, we must keep track of
4538      the last argument.  */
4539   saved_previous_argument = work->previous_argument;
4540   saved_nrepeats = work->nrepeats;
4541   work->previous_argument = 0;
4542   work->nrepeats = 0;
4543
4544   /* Actually demangle the arguments.  */
4545   result = demangle_args (work, mangled, declp);
4546
4547   /* Restore the previous_argument field.  */
4548   if (work->previous_argument)
4549     {
4550       string_delete (work->previous_argument);
4551       free ((char *) work->previous_argument);
4552     }
4553   work->previous_argument = saved_previous_argument;
4554   --work->forgetting_types;
4555   work->nrepeats = saved_nrepeats;
4556
4557   return result;
4558 }
4559
4560 /* Returns 1 if a valid function name was found or 0 otherwise.  */
4561
4562 static int
4563 demangle_function_name (struct work_stuff *work, const char **mangled,
4564                         string *declp, const char *scan)
4565 {
4566   size_t i;
4567   string type;
4568   const char *tem;
4569
4570   string_appendn (declp, (*mangled), scan - (*mangled));
4571   string_need (declp, 1);
4572   *(declp -> p) = '\0';
4573
4574   /* Consume the function name, including the "__" separating the name
4575      from the signature.  We are guaranteed that SCAN points to the
4576      separator.  */
4577
4578   (*mangled) = scan + 2;
4579   /* We may be looking at an instantiation of a template function:
4580      foo__Xt1t2_Ft3t4, where t1, t2, ... are template arguments and a
4581      following _F marks the start of the function arguments.  Handle
4582      the template arguments first. */
4583
4584   if (HP_DEMANGLING && (**mangled == 'X'))
4585     {
4586       demangle_arm_hp_template (work, mangled, 0, declp);
4587       /* This leaves MANGLED pointing to the 'F' marking func args */
4588     }
4589
4590   if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
4591     {
4592
4593       /* See if we have an ARM style constructor or destructor operator.
4594          If so, then just record it, clear the decl, and return.
4595          We can't build the actual constructor/destructor decl until later,
4596          when we recover the class name from the signature.  */
4597
4598       if (strcmp (declp -> b, "__ct") == 0)
4599         {
4600           work -> constructor += 1;
4601           string_clear (declp);
4602           return 1;
4603         }
4604       else if (strcmp (declp -> b, "__dt") == 0)
4605         {
4606           work -> destructor += 1;
4607           string_clear (declp);
4608           return 1;
4609         }
4610     }
4611
4612   if (declp->p - declp->b >= 3
4613       && declp->b[0] == 'o'
4614       && declp->b[1] == 'p'
4615       && strchr (cplus_markers, declp->b[2]) != NULL)
4616     {
4617       /* see if it's an assignment expression */
4618       if (declp->p - declp->b >= 10 /* op$assign_ */
4619           && memcmp (declp->b + 3, "assign_", 7) == 0)
4620         {
4621           for (i = 0; i < ARRAY_SIZE (optable); i++)
4622             {
4623               int len = declp->p - declp->b - 10;
4624               if ((int) strlen (optable[i].in) == len
4625                   && memcmp (optable[i].in, declp->b + 10, len) == 0)
4626                 {
4627                   string_clear (declp);
4628                   string_append (declp, "operator");
4629                   string_append (declp, optable[i].out);
4630                   string_append (declp, "=");
4631                   break;
4632                 }
4633             }
4634         }
4635       else
4636         {
4637           for (i = 0; i < ARRAY_SIZE (optable); i++)
4638             {
4639               int len = declp->p - declp->b - 3;
4640               if ((int) strlen (optable[i].in) == len
4641                   && memcmp (optable[i].in, declp->b + 3, len) == 0)
4642                 {
4643                   string_clear (declp);
4644                   string_append (declp, "operator");
4645                   string_append (declp, optable[i].out);
4646                   break;
4647                 }
4648             }
4649         }
4650     }
4651   else if (declp->p - declp->b >= 5 && memcmp (declp->b, "type", 4) == 0
4652            && strchr (cplus_markers, declp->b[4]) != NULL)
4653     {
4654       /* type conversion operator */
4655       tem = declp->b + 5;
4656       if (do_type (work, &tem, &type))
4657         {
4658           string_clear (declp);
4659           string_append (declp, "operator ");
4660           string_appends (declp, &type);
4661           string_delete (&type);
4662         }
4663     }
4664   else if (declp->b[0] == '_' && declp->b[1] == '_'
4665            && declp->b[2] == 'o' && declp->b[3] == 'p')
4666     {
4667       /* ANSI.  */
4668       /* type conversion operator.  */
4669       tem = declp->b + 4;
4670       if (do_type (work, &tem, &type))
4671         {
4672           string_clear (declp);
4673           string_append (declp, "operator ");
4674           string_appends (declp, &type);
4675           string_delete (&type);
4676         }
4677     }
4678   else if (declp->b[0] == '_' && declp->b[1] == '_'
4679            && ISLOWER((unsigned char)declp->b[2])
4680            && ISLOWER((unsigned char)declp->b[3]))
4681     {
4682       if (declp->b[4] == '\0')
4683         {
4684           /* Operator.  */
4685           for (i = 0; i < ARRAY_SIZE (optable); i++)
4686             {
4687               if (strlen (optable[i].in) == 2
4688                   && memcmp (optable[i].in, declp->b + 2, 2) == 0)
4689                 {
4690                   string_clear (declp);
4691                   string_append (declp, "operator");
4692                   string_append (declp, optable[i].out);
4693                   break;
4694                 }
4695             }
4696         }
4697       else
4698         {
4699           if (declp->b[2] == 'a' && declp->b[5] == '\0')
4700             {
4701               /* Assignment.  */
4702               for (i = 0; i < ARRAY_SIZE (optable); i++)
4703                 {
4704                   if (strlen (optable[i].in) == 3
4705                       && memcmp (optable[i].in, declp->b + 2, 3) == 0)
4706                     {
4707                       string_clear (declp);
4708                       string_append (declp, "operator");
4709                       string_append (declp, optable[i].out);
4710                       break;
4711                     }
4712                 }
4713             }
4714         }
4715     }
4716
4717   /* If a function name was obtained but it's not valid, we were not
4718      successful.  */
4719   if (LEN_STRING (declp) == 1 && declp->b[0] == '.')
4720     return 0;
4721   else
4722     return 1;
4723 }
4724
4725 /* a mini string-handling package */
4726
4727 static void
4728 string_need (string *s, int n)
4729 {
4730   int tem;
4731
4732   if (s->b == NULL)
4733     {
4734       if (n < 32)
4735         {
4736           n = 32;
4737         }
4738       s->p = s->b = XNEWVEC (char, n);
4739       s->e = s->b + n;
4740     }
4741   else if (s->e - s->p < n)
4742     {
4743       tem = s->p - s->b;
4744       n += tem;
4745       n *= 2;
4746       s->b = XRESIZEVEC (char, s->b, n);
4747       s->p = s->b + tem;
4748       s->e = s->b + n;
4749     }
4750 }
4751
4752 static void
4753 string_delete (string *s)
4754 {
4755   if (s->b != NULL)
4756     {
4757       free (s->b);
4758       s->b = s->e = s->p = NULL;
4759     }
4760 }
4761
4762 static void
4763 string_init (string *s)
4764 {
4765   s->b = s->p = s->e = NULL;
4766 }
4767
4768 static void
4769 string_clear (string *s)
4770 {
4771   s->p = s->b;
4772 }
4773
4774 #if 0
4775
4776 static int
4777 string_empty (string *s)
4778 {
4779   return (s->b == s->p);
4780 }
4781
4782 #endif
4783
4784 static void
4785 string_append (string *p, const char *s)
4786 {
4787   int n;
4788   if (s == NULL || *s == '\0')
4789     return;
4790   n = strlen (s);
4791   string_need (p, n);
4792   memcpy (p->p, s, n);
4793   p->p += n;
4794 }
4795
4796 static void
4797 string_appends (string *p, string *s)
4798 {
4799   int n;
4800
4801   if (s->b != s->p)
4802     {
4803       n = s->p - s->b;
4804       string_need (p, n);
4805       memcpy (p->p, s->b, n);
4806       p->p += n;
4807     }
4808 }
4809
4810 static void
4811 string_appendn (string *p, const char *s, int n)
4812 {
4813   if (n != 0)
4814     {
4815       string_need (p, n);
4816       memcpy (p->p, s, n);
4817       p->p += n;
4818     }
4819 }
4820
4821 static void
4822 string_prepend (string *p, const char *s)
4823 {
4824   if (s != NULL && *s != '\0')
4825     {
4826       string_prependn (p, s, strlen (s));
4827     }
4828 }
4829
4830 static void
4831 string_prepends (string *p, string *s)
4832 {
4833   if (s->b != s->p)
4834     {
4835       string_prependn (p, s->b, s->p - s->b);
4836     }
4837 }
4838
4839 static void
4840 string_prependn (string *p, const char *s, int n)
4841 {
4842   char *q;
4843
4844   if (n != 0)
4845     {
4846       string_need (p, n);
4847       for (q = p->p - 1; q >= p->b; q--)
4848         {
4849           q[n] = q[0];
4850         }
4851       memcpy (p->b, s, n);
4852       p->p += n;
4853     }
4854 }
4855
4856 static void
4857 string_append_template_idx (string *s, int idx)
4858 {
4859   char buf[INTBUF_SIZE + 1 /* 'T' */];
4860   sprintf(buf, "T%d", idx);
4861   string_append (s, buf);
4862 }