libiberty/cplus-dem.c

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