libiberty/cplus-dem.c

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