OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [libiberty/] [cplus-dem.c] - Diff between revs 827 and 840

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 827 Rev 840
/* Demangler for GNU C++
/* Demangler for GNU C++
   Copyright 1989, 1991, 1994, 1995, 1996, 1997, 1998, 1999,
   Copyright 1989, 1991, 1994, 1995, 1996, 1997, 1998, 1999,
   2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   Written by James Clark (jjc@jclark.uucp)
   Written by James Clark (jjc@jclark.uucp)
   Rewritten by Fred Fish (fnf@cygnus.com) for ARM and Lucid demangling
   Rewritten by Fred Fish (fnf@cygnus.com) for ARM and Lucid demangling
   Modified by Satish Pai (pai@apollo.hp.com) for HP demangling
   Modified by Satish Pai (pai@apollo.hp.com) for HP demangling
 
 
This file is part of the libiberty library.
This file is part of the libiberty library.
Libiberty is free software; you can redistribute it and/or
Libiberty is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
version 2 of the License, or (at your option) any later version.
 
 
In addition to the permissions in the GNU Library General Public
In addition to the permissions in the GNU Library General Public
License, the Free Software Foundation gives you unlimited permission
License, the Free Software Foundation gives you unlimited permission
to link the compiled version of this file into combinations with other
to link the compiled version of this file into combinations with other
programs, and to distribute those combinations without any restriction
programs, and to distribute those combinations without any restriction
coming from the use of this file.  (The Library Public License
coming from the use of this file.  (The Library Public License
restrictions do apply in other respects; for example, they cover
restrictions do apply in other respects; for example, they cover
modification of the file, and distribution when not linked into a
modification of the file, and distribution when not linked into a
combined executable.)
combined executable.)
 
 
Libiberty is distributed in the hope that it will be useful,
Libiberty is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Library General Public License for more details.
Library General Public License for more details.
 
 
You should have received a copy of the GNU Library General Public
You should have received a copy of the GNU Library General Public
License along with libiberty; see the file COPYING.LIB.  If
License along with libiberty; see the file COPYING.LIB.  If
not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
Boston, MA 02110-1301, USA.  */
Boston, MA 02110-1301, USA.  */
 
 
/* This file exports two functions; cplus_mangle_opname and cplus_demangle.
/* This file exports two functions; cplus_mangle_opname and cplus_demangle.
 
 
   This file imports xmalloc and xrealloc, which are like malloc and
   This file imports xmalloc and xrealloc, which are like malloc and
   realloc except that they generate a fatal error if there is no
   realloc except that they generate a fatal error if there is no
   available memory.  */
   available memory.  */
 
 
/* This file lives in both GCC and libiberty.  When making changes, please
/* This file lives in both GCC and libiberty.  When making changes, please
   try not to break either.  */
   try not to break either.  */
 
 
#ifdef HAVE_CONFIG_H
#ifdef HAVE_CONFIG_H
#include "config.h"
#include "config.h"
#endif
#endif
 
 
#include "safe-ctype.h"
#include "safe-ctype.h"
 
 
#include <sys/types.h>
#include <sys/types.h>
#include <string.h>
#include <string.h>
#include <stdio.h>
#include <stdio.h>
 
 
#ifdef HAVE_STDLIB_H
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#include <stdlib.h>
#else
#else
void * malloc ();
void * malloc ();
void * realloc ();
void * realloc ();
#endif
#endif
 
 
#include <demangle.h>
#include <demangle.h>
#undef CURRENT_DEMANGLING_STYLE
#undef CURRENT_DEMANGLING_STYLE
#define CURRENT_DEMANGLING_STYLE work->options
#define CURRENT_DEMANGLING_STYLE work->options
 
 
#include "libiberty.h"
#include "libiberty.h"
 
 
static char *ada_demangle (const char *, int);
static char *ada_demangle (const char *, int);
 
 
#define min(X,Y) (((X) < (Y)) ? (X) : (Y))
#define min(X,Y) (((X) < (Y)) ? (X) : (Y))
 
 
/* A value at least one greater than the maximum number of characters
/* A value at least one greater than the maximum number of characters
   that will be output when using the `%d' format with `printf'.  */
   that will be output when using the `%d' format with `printf'.  */
#define INTBUF_SIZE 32
#define INTBUF_SIZE 32
 
 
extern void fancy_abort (void) ATTRIBUTE_NORETURN;
extern void fancy_abort (void) ATTRIBUTE_NORETURN;
 
 
/* In order to allow a single demangler executable to demangle strings
/* In order to allow a single demangler executable to demangle strings
   using various common values of CPLUS_MARKER, as well as any specific
   using various common values of CPLUS_MARKER, as well as any specific
   one set at compile time, we maintain a string containing all the
   one set at compile time, we maintain a string containing all the
   commonly used ones, and check to see if the marker we are looking for
   commonly used ones, and check to see if the marker we are looking for
   is in that string.  CPLUS_MARKER is usually '$' on systems where the
   is in that string.  CPLUS_MARKER is usually '$' on systems where the
   assembler can deal with that.  Where the assembler can't, it's usually
   assembler can deal with that.  Where the assembler can't, it's usually
   '.' (but on many systems '.' is used for other things).  We put the
   '.' (but on many systems '.' is used for other things).  We put the
   current defined CPLUS_MARKER first (which defaults to '$'), followed
   current defined CPLUS_MARKER first (which defaults to '$'), followed
   by the next most common value, followed by an explicit '$' in case
   by the next most common value, followed by an explicit '$' in case
   the value of CPLUS_MARKER is not '$'.
   the value of CPLUS_MARKER is not '$'.
 
 
   We could avoid this if we could just get g++ to tell us what the actual
   We could avoid this if we could just get g++ to tell us what the actual
   cplus marker character is as part of the debug information, perhaps by
   cplus marker character is as part of the debug information, perhaps by
   ensuring that it is the character that terminates the gcc<n>_compiled
   ensuring that it is the character that terminates the gcc<n>_compiled
   marker symbol (FIXME).  */
   marker symbol (FIXME).  */
 
 
#if !defined (CPLUS_MARKER)
#if !defined (CPLUS_MARKER)
#define CPLUS_MARKER '$'
#define CPLUS_MARKER '$'
#endif
#endif
 
 
enum demangling_styles current_demangling_style = auto_demangling;
enum demangling_styles current_demangling_style = auto_demangling;
 
 
static char cplus_markers[] = { CPLUS_MARKER, '.', '$', '\0' };
static char cplus_markers[] = { CPLUS_MARKER, '.', '$', '\0' };
 
 
static char char_str[2] = { '\000', '\000' };
static char char_str[2] = { '\000', '\000' };
 
 
void
void
set_cplus_marker_for_demangling (int ch)
set_cplus_marker_for_demangling (int ch)
{
{
  cplus_markers[0] = ch;
  cplus_markers[0] = ch;
}
}
 
 
typedef struct string           /* Beware: these aren't required to be */
typedef struct string           /* Beware: these aren't required to be */
{                               /*  '\0' terminated.  */
{                               /*  '\0' terminated.  */
  char *b;                      /* pointer to start of string */
  char *b;                      /* pointer to start of string */
  char *p;                      /* pointer after last character */
  char *p;                      /* pointer after last character */
  char *e;                      /* pointer after end of allocated space */
  char *e;                      /* pointer after end of allocated space */
} string;
} string;
 
 
/* Stuff that is shared between sub-routines.
/* Stuff that is shared between sub-routines.
   Using a shared structure allows cplus_demangle to be reentrant.  */
   Using a shared structure allows cplus_demangle to be reentrant.  */
 
 
struct work_stuff
struct work_stuff
{
{
  int options;
  int options;
  char **typevec;
  char **typevec;
  char **ktypevec;
  char **ktypevec;
  char **btypevec;
  char **btypevec;
  int numk;
  int numk;
  int numb;
  int numb;
  int ksize;
  int ksize;
  int bsize;
  int bsize;
  int ntypes;
  int ntypes;
  int typevec_size;
  int typevec_size;
  int constructor;
  int constructor;
  int destructor;
  int destructor;
  int static_type;      /* A static member function */
  int static_type;      /* A static member function */
  int temp_start;       /* index in demangled to start of template args */
  int temp_start;       /* index in demangled to start of template args */
  int type_quals;       /* The type qualifiers.  */
  int type_quals;       /* The type qualifiers.  */
  int dllimported;      /* Symbol imported from a PE DLL */
  int dllimported;      /* Symbol imported from a PE DLL */
  char **tmpl_argvec;   /* Template function arguments. */
  char **tmpl_argvec;   /* Template function arguments. */
  int ntmpl_args;       /* The number of template function arguments. */
  int ntmpl_args;       /* The number of template function arguments. */
  int forgetting_types; /* Nonzero if we are not remembering the types
  int forgetting_types; /* Nonzero if we are not remembering the types
                           we see.  */
                           we see.  */
  string* previous_argument; /* The last function argument demangled.  */
  string* previous_argument; /* The last function argument demangled.  */
  int nrepeats;         /* The number of times to repeat the previous
  int nrepeats;         /* The number of times to repeat the previous
                           argument.  */
                           argument.  */
};
};
 
 
#define PRINT_ANSI_QUALIFIERS (work -> options & DMGL_ANSI)
#define PRINT_ANSI_QUALIFIERS (work -> options & DMGL_ANSI)
#define PRINT_ARG_TYPES       (work -> options & DMGL_PARAMS)
#define PRINT_ARG_TYPES       (work -> options & DMGL_PARAMS)
 
 
static const struct optable
static const struct optable
{
{
  const char *const in;
  const char *const in;
  const char *const out;
  const char *const out;
  const int flags;
  const int flags;
} optable[] = {
} optable[] = {
  {"nw",          " new",       DMGL_ANSI},     /* new (1.92,    ansi) */
  {"nw",          " new",       DMGL_ANSI},     /* new (1.92,    ansi) */
  {"dl",          " delete",    DMGL_ANSI},     /* new (1.92,    ansi) */
  {"dl",          " delete",    DMGL_ANSI},     /* new (1.92,    ansi) */
  {"new",         " new",       0},              /* old (1.91,    and 1.x) */
  {"new",         " new",       0},              /* old (1.91,    and 1.x) */
  {"delete",      " delete",    0},              /* old (1.91,    and 1.x) */
  {"delete",      " delete",    0},              /* old (1.91,    and 1.x) */
  {"vn",          " new []",    DMGL_ANSI},     /* GNU, pending ansi */
  {"vn",          " new []",    DMGL_ANSI},     /* GNU, pending ansi */
  {"vd",          " delete []", DMGL_ANSI},     /* GNU, pending ansi */
  {"vd",          " delete []", DMGL_ANSI},     /* GNU, pending ansi */
  {"as",          "=",          DMGL_ANSI},     /* ansi */
  {"as",          "=",          DMGL_ANSI},     /* ansi */
  {"ne",          "!=",         DMGL_ANSI},     /* old, ansi */
  {"ne",          "!=",         DMGL_ANSI},     /* old, ansi */
  {"eq",          "==",         DMGL_ANSI},     /* old, ansi */
  {"eq",          "==",         DMGL_ANSI},     /* old, ansi */
  {"ge",          ">=",         DMGL_ANSI},     /* old, ansi */
  {"ge",          ">=",         DMGL_ANSI},     /* old, ansi */
  {"gt",          ">",          DMGL_ANSI},     /* old, ansi */
  {"gt",          ">",          DMGL_ANSI},     /* old, ansi */
  {"le",          "<=",         DMGL_ANSI},     /* old, ansi */
  {"le",          "<=",         DMGL_ANSI},     /* old, ansi */
  {"lt",          "<",          DMGL_ANSI},     /* old, ansi */
  {"lt",          "<",          DMGL_ANSI},     /* old, ansi */
  {"plus",        "+",          0},              /* old */
  {"plus",        "+",          0},              /* old */
  {"pl",          "+",          DMGL_ANSI},     /* ansi */
  {"pl",          "+",          DMGL_ANSI},     /* ansi */
  {"apl",         "+=",         DMGL_ANSI},     /* ansi */
  {"apl",         "+=",         DMGL_ANSI},     /* ansi */
  {"minus",       "-",          0},              /* old */
  {"minus",       "-",          0},              /* old */
  {"mi",          "-",          DMGL_ANSI},     /* ansi */
  {"mi",          "-",          DMGL_ANSI},     /* ansi */
  {"ami",         "-=",         DMGL_ANSI},     /* ansi */
  {"ami",         "-=",         DMGL_ANSI},     /* ansi */
  {"mult",        "*",          0},              /* old */
  {"mult",        "*",          0},              /* old */
  {"ml",          "*",          DMGL_ANSI},     /* ansi */
  {"ml",          "*",          DMGL_ANSI},     /* ansi */
  {"amu",         "*=",         DMGL_ANSI},     /* ansi (ARM/Lucid) */
  {"amu",         "*=",         DMGL_ANSI},     /* ansi (ARM/Lucid) */
  {"aml",         "*=",         DMGL_ANSI},     /* ansi (GNU/g++) */
  {"aml",         "*=",         DMGL_ANSI},     /* ansi (GNU/g++) */
  {"convert",     "+",          0},              /* old (unary +) */
  {"convert",     "+",          0},              /* old (unary +) */
  {"negate",      "-",          0},              /* old (unary -) */
  {"negate",      "-",          0},              /* old (unary -) */
  {"trunc_mod",   "%",          0},              /* old */
  {"trunc_mod",   "%",          0},              /* old */
  {"md",          "%",          DMGL_ANSI},     /* ansi */
  {"md",          "%",          DMGL_ANSI},     /* ansi */
  {"amd",         "%=",         DMGL_ANSI},     /* ansi */
  {"amd",         "%=",         DMGL_ANSI},     /* ansi */
  {"trunc_div",   "/",          0},              /* old */
  {"trunc_div",   "/",          0},              /* old */
  {"dv",          "/",          DMGL_ANSI},     /* ansi */
  {"dv",          "/",          DMGL_ANSI},     /* ansi */
  {"adv",         "/=",         DMGL_ANSI},     /* ansi */
  {"adv",         "/=",         DMGL_ANSI},     /* ansi */
  {"truth_andif", "&&",         0},              /* old */
  {"truth_andif", "&&",         0},              /* old */
  {"aa",          "&&",         DMGL_ANSI},     /* ansi */
  {"aa",          "&&",         DMGL_ANSI},     /* ansi */
  {"truth_orif",  "||",         0},              /* old */
  {"truth_orif",  "||",         0},              /* old */
  {"oo",          "||",         DMGL_ANSI},     /* ansi */
  {"oo",          "||",         DMGL_ANSI},     /* ansi */
  {"truth_not",   "!",          0},              /* old */
  {"truth_not",   "!",          0},              /* old */
  {"nt",          "!",          DMGL_ANSI},     /* ansi */
  {"nt",          "!",          DMGL_ANSI},     /* ansi */
  {"postincrement","++",        0},              /* old */
  {"postincrement","++",        0},              /* old */
  {"pp",          "++",         DMGL_ANSI},     /* ansi */
  {"pp",          "++",         DMGL_ANSI},     /* ansi */
  {"postdecrement","--",        0},              /* old */
  {"postdecrement","--",        0},              /* old */
  {"mm",          "--",         DMGL_ANSI},     /* ansi */
  {"mm",          "--",         DMGL_ANSI},     /* ansi */
  {"bit_ior",     "|",          0},              /* old */
  {"bit_ior",     "|",          0},              /* old */
  {"or",          "|",          DMGL_ANSI},     /* ansi */
  {"or",          "|",          DMGL_ANSI},     /* ansi */
  {"aor",         "|=",         DMGL_ANSI},     /* ansi */
  {"aor",         "|=",         DMGL_ANSI},     /* ansi */
  {"bit_xor",     "^",          0},              /* old */
  {"bit_xor",     "^",          0},              /* old */
  {"er",          "^",          DMGL_ANSI},     /* ansi */
  {"er",          "^",          DMGL_ANSI},     /* ansi */
  {"aer",         "^=",         DMGL_ANSI},     /* ansi */
  {"aer",         "^=",         DMGL_ANSI},     /* ansi */
  {"bit_and",     "&",          0},              /* old */
  {"bit_and",     "&",          0},              /* old */
  {"ad",          "&",          DMGL_ANSI},     /* ansi */
  {"ad",          "&",          DMGL_ANSI},     /* ansi */
  {"aad",         "&=",         DMGL_ANSI},     /* ansi */
  {"aad",         "&=",         DMGL_ANSI},     /* ansi */
  {"bit_not",     "~",          0},              /* old */
  {"bit_not",     "~",          0},              /* old */
  {"co",          "~",          DMGL_ANSI},     /* ansi */
  {"co",          "~",          DMGL_ANSI},     /* ansi */
  {"call",        "()",         0},              /* old */
  {"call",        "()",         0},              /* old */
  {"cl",          "()",         DMGL_ANSI},     /* ansi */
  {"cl",          "()",         DMGL_ANSI},     /* ansi */
  {"alshift",     "<<",         0},              /* old */
  {"alshift",     "<<",         0},              /* old */
  {"ls",          "<<",         DMGL_ANSI},     /* ansi */
  {"ls",          "<<",         DMGL_ANSI},     /* ansi */
  {"als",         "<<=",        DMGL_ANSI},     /* ansi */
  {"als",         "<<=",        DMGL_ANSI},     /* ansi */
  {"arshift",     ">>",         0},              /* old */
  {"arshift",     ">>",         0},              /* old */
  {"rs",          ">>",         DMGL_ANSI},     /* ansi */
  {"rs",          ">>",         DMGL_ANSI},     /* ansi */
  {"ars",         ">>=",        DMGL_ANSI},     /* ansi */
  {"ars",         ">>=",        DMGL_ANSI},     /* ansi */
  {"component",   "->",         0},              /* old */
  {"component",   "->",         0},              /* old */
  {"pt",          "->",         DMGL_ANSI},     /* ansi; Lucid C++ form */
  {"pt",          "->",         DMGL_ANSI},     /* ansi; Lucid C++ form */
  {"rf",          "->",         DMGL_ANSI},     /* ansi; ARM/GNU form */
  {"rf",          "->",         DMGL_ANSI},     /* ansi; ARM/GNU form */
  {"indirect",    "*",          0},              /* old */
  {"indirect",    "*",          0},              /* old */
  {"method_call",  "->()",      0},              /* old */
  {"method_call",  "->()",      0},              /* old */
  {"addr",        "&",          0},              /* old (unary &) */
  {"addr",        "&",          0},              /* old (unary &) */
  {"array",       "[]",         0},              /* old */
  {"array",       "[]",         0},              /* old */
  {"vc",          "[]",         DMGL_ANSI},     /* ansi */
  {"vc",          "[]",         DMGL_ANSI},     /* ansi */
  {"compound",    ", ",         0},              /* old */
  {"compound",    ", ",         0},              /* old */
  {"cm",          ", ",         DMGL_ANSI},     /* ansi */
  {"cm",          ", ",         DMGL_ANSI},     /* ansi */
  {"cond",        "?:",         0},              /* old */
  {"cond",        "?:",         0},              /* old */
  {"cn",          "?:",         DMGL_ANSI},     /* pseudo-ansi */
  {"cn",          "?:",         DMGL_ANSI},     /* pseudo-ansi */
  {"max",         ">?",         0},              /* old */
  {"max",         ">?",         0},              /* old */
  {"mx",          ">?",         DMGL_ANSI},     /* pseudo-ansi */
  {"mx",          ">?",         DMGL_ANSI},     /* pseudo-ansi */
  {"min",         "<?",         0},              /* old */
  {"min",         "<?",         0},              /* old */
  {"mn",          "<?",         DMGL_ANSI},     /* pseudo-ansi */
  {"mn",          "<?",         DMGL_ANSI},     /* pseudo-ansi */
  {"nop",         "",           0},              /* old (for operator=) */
  {"nop",         "",           0},              /* old (for operator=) */
  {"rm",          "->*",        DMGL_ANSI},     /* ansi */
  {"rm",          "->*",        DMGL_ANSI},     /* ansi */
  {"sz",          "sizeof ",    DMGL_ANSI}      /* pseudo-ansi */
  {"sz",          "sizeof ",    DMGL_ANSI}      /* pseudo-ansi */
};
};
 
 
/* These values are used to indicate the various type varieties.
/* These values are used to indicate the various type varieties.
   They are all non-zero so that they can be used as `success'
   They are all non-zero so that they can be used as `success'
   values.  */
   values.  */
typedef enum type_kind_t
typedef enum type_kind_t
{
{
  tk_none,
  tk_none,
  tk_pointer,
  tk_pointer,
  tk_reference,
  tk_reference,
  tk_integral,
  tk_integral,
  tk_bool,
  tk_bool,
  tk_char,
  tk_char,
  tk_real
  tk_real
} type_kind_t;
} type_kind_t;
 
 
const struct demangler_engine libiberty_demanglers[] =
const struct demangler_engine libiberty_demanglers[] =
{
{
  {
  {
    NO_DEMANGLING_STYLE_STRING,
    NO_DEMANGLING_STYLE_STRING,
    no_demangling,
    no_demangling,
    "Demangling disabled"
    "Demangling disabled"
  }
  }
  ,
  ,
  {
  {
    AUTO_DEMANGLING_STYLE_STRING,
    AUTO_DEMANGLING_STYLE_STRING,
      auto_demangling,
      auto_demangling,
      "Automatic selection based on executable"
      "Automatic selection based on executable"
  }
  }
  ,
  ,
  {
  {
    GNU_DEMANGLING_STYLE_STRING,
    GNU_DEMANGLING_STYLE_STRING,
      gnu_demangling,
      gnu_demangling,
      "GNU (g++) style demangling"
      "GNU (g++) style demangling"
  }
  }
  ,
  ,
  {
  {
    LUCID_DEMANGLING_STYLE_STRING,
    LUCID_DEMANGLING_STYLE_STRING,
      lucid_demangling,
      lucid_demangling,
      "Lucid (lcc) style demangling"
      "Lucid (lcc) style demangling"
  }
  }
  ,
  ,
  {
  {
    ARM_DEMANGLING_STYLE_STRING,
    ARM_DEMANGLING_STYLE_STRING,
      arm_demangling,
      arm_demangling,
      "ARM style demangling"
      "ARM style demangling"
  }
  }
  ,
  ,
  {
  {
    HP_DEMANGLING_STYLE_STRING,
    HP_DEMANGLING_STYLE_STRING,
      hp_demangling,
      hp_demangling,
      "HP (aCC) style demangling"
      "HP (aCC) style demangling"
  }
  }
  ,
  ,
  {
  {
    EDG_DEMANGLING_STYLE_STRING,
    EDG_DEMANGLING_STYLE_STRING,
      edg_demangling,
      edg_demangling,
      "EDG style demangling"
      "EDG style demangling"
  }
  }
  ,
  ,
  {
  {
    GNU_V3_DEMANGLING_STYLE_STRING,
    GNU_V3_DEMANGLING_STYLE_STRING,
    gnu_v3_demangling,
    gnu_v3_demangling,
    "GNU (g++) V3 ABI-style demangling"
    "GNU (g++) V3 ABI-style demangling"
  }
  }
  ,
  ,
  {
  {
    JAVA_DEMANGLING_STYLE_STRING,
    JAVA_DEMANGLING_STYLE_STRING,
    java_demangling,
    java_demangling,
    "Java style demangling"
    "Java style demangling"
  }
  }
  ,
  ,
  {
  {
    GNAT_DEMANGLING_STYLE_STRING,
    GNAT_DEMANGLING_STYLE_STRING,
    gnat_demangling,
    gnat_demangling,
    "GNAT style demangling"
    "GNAT style demangling"
  }
  }
  ,
  ,
  {
  {
    NULL, unknown_demangling, NULL
    NULL, unknown_demangling, NULL
  }
  }
};
};
 
 
#define STRING_EMPTY(str)       ((str) -> b == (str) -> p)
#define STRING_EMPTY(str)       ((str) -> b == (str) -> p)
#define APPEND_BLANK(str)       {if (!STRING_EMPTY(str)) \
#define APPEND_BLANK(str)       {if (!STRING_EMPTY(str)) \
    string_append(str, " ");}
    string_append(str, " ");}
#define LEN_STRING(str)         ( (STRING_EMPTY(str))?0:((str)->p - (str)->b))
#define LEN_STRING(str)         ( (STRING_EMPTY(str))?0:((str)->p - (str)->b))
 
 
/* The scope separator appropriate for the language being demangled.  */
/* The scope separator appropriate for the language being demangled.  */
 
 
#define SCOPE_STRING(work) ((work->options & DMGL_JAVA) ? "." : "::")
#define SCOPE_STRING(work) ((work->options & DMGL_JAVA) ? "." : "::")
 
 
#define ARM_VTABLE_STRING "__vtbl__"    /* Lucid/ARM virtual table prefix */
#define ARM_VTABLE_STRING "__vtbl__"    /* Lucid/ARM virtual table prefix */
#define ARM_VTABLE_STRLEN 8             /* strlen (ARM_VTABLE_STRING) */
#define ARM_VTABLE_STRLEN 8             /* strlen (ARM_VTABLE_STRING) */
 
 
/* Prototypes for local functions */
/* Prototypes for local functions */
 
 
static void delete_work_stuff (struct work_stuff *);
static void delete_work_stuff (struct work_stuff *);
 
 
static void delete_non_B_K_work_stuff (struct work_stuff *);
static void delete_non_B_K_work_stuff (struct work_stuff *);
 
 
static char *mop_up (struct work_stuff *, string *, int);
static char *mop_up (struct work_stuff *, string *, int);
 
 
static void squangle_mop_up (struct work_stuff *);
static void squangle_mop_up (struct work_stuff *);
 
 
static void work_stuff_copy_to_from (struct work_stuff *, struct work_stuff *);
static void work_stuff_copy_to_from (struct work_stuff *, struct work_stuff *);
 
 
#if 0
#if 0
static int
static int
demangle_method_args (struct work_stuff *, const char **, string *);
demangle_method_args (struct work_stuff *, const char **, string *);
#endif
#endif
 
 
static char *
static char *
internal_cplus_demangle (struct work_stuff *, const char *);
internal_cplus_demangle (struct work_stuff *, const char *);
 
 
static int
static int
demangle_template_template_parm (struct work_stuff *work,
demangle_template_template_parm (struct work_stuff *work,
                                 const char **, string *);
                                 const char **, string *);
 
 
static int
static int
demangle_template (struct work_stuff *work, const char **, string *,
demangle_template (struct work_stuff *work, const char **, string *,
                   string *, int, int);
                   string *, int, int);
 
 
static int
static int
arm_pt (struct work_stuff *, const char *, int, const char **,
arm_pt (struct work_stuff *, const char *, int, const char **,
        const char **);
        const char **);
 
 
static int
static int
demangle_class_name (struct work_stuff *, const char **, string *);
demangle_class_name (struct work_stuff *, const char **, string *);
 
 
static int
static int
demangle_qualified (struct work_stuff *, const char **, string *,
demangle_qualified (struct work_stuff *, const char **, string *,
                    int, int);
                    int, int);
 
 
static int demangle_class (struct work_stuff *, const char **, string *);
static int demangle_class (struct work_stuff *, const char **, string *);
 
 
static int demangle_fund_type (struct work_stuff *, const char **, string *);
static int demangle_fund_type (struct work_stuff *, const char **, string *);
 
 
static int demangle_signature (struct work_stuff *, const char **, string *);
static int demangle_signature (struct work_stuff *, const char **, string *);
 
 
static int demangle_prefix (struct work_stuff *, const char **, string *);
static int demangle_prefix (struct work_stuff *, const char **, string *);
 
 
static int gnu_special (struct work_stuff *, const char **, string *);
static int gnu_special (struct work_stuff *, const char **, string *);
 
 
static int arm_special (const char **, string *);
static int arm_special (const char **, string *);
 
 
static void string_need (string *, int);
static void string_need (string *, int);
 
 
static void string_delete (string *);
static void string_delete (string *);
 
 
static void
static void
string_init (string *);
string_init (string *);
 
 
static void string_clear (string *);
static void string_clear (string *);
 
 
#if 0
#if 0
static int string_empty (string *);
static int string_empty (string *);
#endif
#endif
 
 
static void string_append (string *, const char *);
static void string_append (string *, const char *);
 
 
static void string_appends (string *, string *);
static void string_appends (string *, string *);
 
 
static void string_appendn (string *, const char *, int);
static void string_appendn (string *, const char *, int);
 
 
static void string_prepend (string *, const char *);
static void string_prepend (string *, const char *);
 
 
static void string_prependn (string *, const char *, int);
static void string_prependn (string *, const char *, int);
 
 
static void string_append_template_idx (string *, int);
static void string_append_template_idx (string *, int);
 
 
static int get_count (const char **, int *);
static int get_count (const char **, int *);
 
 
static int consume_count (const char **);
static int consume_count (const char **);
 
 
static int consume_count_with_underscores (const char**);
static int consume_count_with_underscores (const char**);
 
 
static int demangle_args (struct work_stuff *, const char **, string *);
static int demangle_args (struct work_stuff *, const char **, string *);
 
 
static int demangle_nested_args (struct work_stuff*, const char**, string*);
static int demangle_nested_args (struct work_stuff*, const char**, string*);
 
 
static int do_type (struct work_stuff *, const char **, string *);
static int do_type (struct work_stuff *, const char **, string *);
 
 
static int do_arg (struct work_stuff *, const char **, string *);
static int do_arg (struct work_stuff *, const char **, string *);
 
 
static int
static int
demangle_function_name (struct work_stuff *, const char **, string *,
demangle_function_name (struct work_stuff *, const char **, string *,
                        const char *);
                        const char *);
 
 
static int
static int
iterate_demangle_function (struct work_stuff *,
iterate_demangle_function (struct work_stuff *,
                           const char **, string *, const char *);
                           const char **, string *, const char *);
 
 
static void remember_type (struct work_stuff *, const char *, int);
static void remember_type (struct work_stuff *, const char *, int);
 
 
static void remember_Btype (struct work_stuff *, const char *, int, int);
static void remember_Btype (struct work_stuff *, const char *, int, int);
 
 
static int register_Btype (struct work_stuff *);
static int register_Btype (struct work_stuff *);
 
 
static void remember_Ktype (struct work_stuff *, const char *, int);
static void remember_Ktype (struct work_stuff *, const char *, int);
 
 
static void forget_types (struct work_stuff *);
static void forget_types (struct work_stuff *);
 
 
static void forget_B_and_K_types (struct work_stuff *);
static void forget_B_and_K_types (struct work_stuff *);
 
 
static void string_prepends (string *, string *);
static void string_prepends (string *, string *);
 
 
static int
static int
demangle_template_value_parm (struct work_stuff*, const char**,
demangle_template_value_parm (struct work_stuff*, const char**,
                              string*, type_kind_t);
                              string*, type_kind_t);
 
 
static int
static int
do_hpacc_template_const_value (struct work_stuff *, const char **, string *);
do_hpacc_template_const_value (struct work_stuff *, const char **, string *);
 
 
static int
static int
do_hpacc_template_literal (struct work_stuff *, const char **, string *);
do_hpacc_template_literal (struct work_stuff *, const char **, string *);
 
 
static int snarf_numeric_literal (const char **, string *);
static int snarf_numeric_literal (const char **, string *);
 
 
/* There is a TYPE_QUAL value for each type qualifier.  They can be
/* There is a TYPE_QUAL value for each type qualifier.  They can be
   combined by bitwise-or to form the complete set of qualifiers for a
   combined by bitwise-or to form the complete set of qualifiers for a
   type.  */
   type.  */
 
 
#define TYPE_UNQUALIFIED   0x0
#define TYPE_UNQUALIFIED   0x0
#define TYPE_QUAL_CONST    0x1
#define TYPE_QUAL_CONST    0x1
#define TYPE_QUAL_VOLATILE 0x2
#define TYPE_QUAL_VOLATILE 0x2
#define TYPE_QUAL_RESTRICT 0x4
#define TYPE_QUAL_RESTRICT 0x4
 
 
static int code_for_qualifier (int);
static int code_for_qualifier (int);
 
 
static const char* qualifier_string (int);
static const char* qualifier_string (int);
 
 
static const char* demangle_qualifier (int);
static const char* demangle_qualifier (int);
 
 
static int demangle_expression (struct work_stuff *, const char **, string *,
static int demangle_expression (struct work_stuff *, const char **, string *,
                                type_kind_t);
                                type_kind_t);
 
 
static int
static int
demangle_integral_value (struct work_stuff *, const char **, string *);
demangle_integral_value (struct work_stuff *, const char **, string *);
 
 
static int
static int
demangle_real_value (struct work_stuff *, const char **, string *);
demangle_real_value (struct work_stuff *, const char **, string *);
 
 
static void
static void
demangle_arm_hp_template (struct work_stuff *, const char **, int, string *);
demangle_arm_hp_template (struct work_stuff *, const char **, int, string *);
 
 
static void
static void
recursively_demangle (struct work_stuff *, const char **, string *, int);
recursively_demangle (struct work_stuff *, const char **, string *, int);
 
 
static void grow_vect (char **, size_t *, size_t, int);
static void grow_vect (char **, size_t *, size_t, int);
 
 
/* Translate count to integer, consuming tokens in the process.
/* Translate count to integer, consuming tokens in the process.
   Conversion terminates on the first non-digit character.
   Conversion terminates on the first non-digit character.
 
 
   Trying to consume something that isn't a count results in no
   Trying to consume something that isn't a count results in no
   consumption of input and a return of -1.
   consumption of input and a return of -1.
 
 
   Overflow consumes the rest of the digits, and returns -1.  */
   Overflow consumes the rest of the digits, and returns -1.  */
 
 
static int
static int
consume_count (const char **type)
consume_count (const char **type)
{
{
  int count = 0;
  int count = 0;
 
 
  if (! ISDIGIT ((unsigned char)**type))
  if (! ISDIGIT ((unsigned char)**type))
    return -1;
    return -1;
 
 
  while (ISDIGIT ((unsigned char)**type))
  while (ISDIGIT ((unsigned char)**type))
    {
    {
      count *= 10;
      count *= 10;
 
 
      /* Check for overflow.
      /* Check for overflow.
         We assume that count is represented using two's-complement;
         We assume that count is represented using two's-complement;
         no power of two is divisible by ten, so if an overflow occurs
         no power of two is divisible by ten, so if an overflow occurs
         when multiplying by ten, the result will not be a multiple of
         when multiplying by ten, the result will not be a multiple of
         ten.  */
         ten.  */
      if ((count % 10) != 0)
      if ((count % 10) != 0)
        {
        {
          while (ISDIGIT ((unsigned char) **type))
          while (ISDIGIT ((unsigned char) **type))
            (*type)++;
            (*type)++;
          return -1;
          return -1;
        }
        }
 
 
      count += **type - '0';
      count += **type - '0';
      (*type)++;
      (*type)++;
    }
    }
 
 
  if (count < 0)
  if (count < 0)
    count = -1;
    count = -1;
 
 
  return (count);
  return (count);
}
}
 
 
 
 
/* Like consume_count, but for counts that are preceded and followed
/* Like consume_count, but for counts that are preceded and followed
   by '_' if they are greater than 10.  Also, -1 is returned for
   by '_' if they are greater than 10.  Also, -1 is returned for
   failure, since 0 can be a valid value.  */
   failure, since 0 can be a valid value.  */
 
 
static int
static int
consume_count_with_underscores (const char **mangled)
consume_count_with_underscores (const char **mangled)
{
{
  int idx;
  int idx;
 
 
  if (**mangled == '_')
  if (**mangled == '_')
    {
    {
      (*mangled)++;
      (*mangled)++;
      if (!ISDIGIT ((unsigned char)**mangled))
      if (!ISDIGIT ((unsigned char)**mangled))
        return -1;
        return -1;
 
 
      idx = consume_count (mangled);
      idx = consume_count (mangled);
      if (**mangled != '_')
      if (**mangled != '_')
        /* The trailing underscore was missing. */
        /* The trailing underscore was missing. */
        return -1;
        return -1;
 
 
      (*mangled)++;
      (*mangled)++;
    }
    }
  else
  else
    {
    {
      if (**mangled < '0' || **mangled > '9')
      if (**mangled < '0' || **mangled > '9')
        return -1;
        return -1;
 
 
      idx = **mangled - '0';
      idx = **mangled - '0';
      (*mangled)++;
      (*mangled)++;
    }
    }
 
 
  return idx;
  return idx;
}
}
 
 
/* C is the code for a type-qualifier.  Return the TYPE_QUAL
/* C is the code for a type-qualifier.  Return the TYPE_QUAL
   corresponding to this qualifier.  */
   corresponding to this qualifier.  */
 
 
static int
static int
code_for_qualifier (int c)
code_for_qualifier (int c)
{
{
  switch (c)
  switch (c)
    {
    {
    case 'C':
    case 'C':
      return TYPE_QUAL_CONST;
      return TYPE_QUAL_CONST;
 
 
    case 'V':
    case 'V':
      return TYPE_QUAL_VOLATILE;
      return TYPE_QUAL_VOLATILE;
 
 
    case 'u':
    case 'u':
      return TYPE_QUAL_RESTRICT;
      return TYPE_QUAL_RESTRICT;
 
 
    default:
    default:
      break;
      break;
    }
    }
 
 
  /* C was an invalid qualifier.  */
  /* C was an invalid qualifier.  */
  abort ();
  abort ();
}
}
 
 
/* Return the string corresponding to the qualifiers given by
/* Return the string corresponding to the qualifiers given by
   TYPE_QUALS.  */
   TYPE_QUALS.  */
 
 
static const char*
static const char*
qualifier_string (int type_quals)
qualifier_string (int type_quals)
{
{
  switch (type_quals)
  switch (type_quals)
    {
    {
    case TYPE_UNQUALIFIED:
    case TYPE_UNQUALIFIED:
      return "";
      return "";
 
 
    case TYPE_QUAL_CONST:
    case TYPE_QUAL_CONST:
      return "const";
      return "const";
 
 
    case TYPE_QUAL_VOLATILE:
    case TYPE_QUAL_VOLATILE:
      return "volatile";
      return "volatile";
 
 
    case TYPE_QUAL_RESTRICT:
    case TYPE_QUAL_RESTRICT:
      return "__restrict";
      return "__restrict";
 
 
    case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE:
    case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE:
      return "const volatile";
      return "const volatile";
 
 
    case TYPE_QUAL_CONST | TYPE_QUAL_RESTRICT:
    case TYPE_QUAL_CONST | TYPE_QUAL_RESTRICT:
      return "const __restrict";
      return "const __restrict";
 
 
    case TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT:
    case TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT:
      return "volatile __restrict";
      return "volatile __restrict";
 
 
    case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT:
    case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT:
      return "const volatile __restrict";
      return "const volatile __restrict";
 
 
    default:
    default:
      break;
      break;
    }
    }
 
 
  /* TYPE_QUALS was an invalid qualifier set.  */
  /* TYPE_QUALS was an invalid qualifier set.  */
  abort ();
  abort ();
}
}
 
 
/* C is the code for a type-qualifier.  Return the string
/* C is the code for a type-qualifier.  Return the string
   corresponding to this qualifier.  This function should only be
   corresponding to this qualifier.  This function should only be
   called with a valid qualifier code.  */
   called with a valid qualifier code.  */
 
 
static const char*
static const char*
demangle_qualifier (int c)
demangle_qualifier (int c)
{
{
  return qualifier_string (code_for_qualifier (c));
  return qualifier_string (code_for_qualifier (c));
}
}
 
 
int
int
cplus_demangle_opname (const char *opname, char *result, int options)
cplus_demangle_opname (const char *opname, char *result, int options)
{
{
  int len, len1, ret;
  int len, len1, ret;
  string type;
  string type;
  struct work_stuff work[1];
  struct work_stuff work[1];
  const char *tem;
  const char *tem;
 
 
  len = strlen(opname);
  len = strlen(opname);
  result[0] = '\0';
  result[0] = '\0';
  ret = 0;
  ret = 0;
  memset ((char *) work, 0, sizeof (work));
  memset ((char *) work, 0, sizeof (work));
  work->options = options;
  work->options = options;
 
 
  if (opname[0] == '_' && opname[1] == '_'
  if (opname[0] == '_' && opname[1] == '_'
      && opname[2] == 'o' && opname[3] == 'p')
      && opname[2] == 'o' && opname[3] == 'p')
    {
    {
      /* ANSI.  */
      /* ANSI.  */
      /* type conversion operator.  */
      /* type conversion operator.  */
      tem = opname + 4;
      tem = opname + 4;
      if (do_type (work, &tem, &type))
      if (do_type (work, &tem, &type))
        {
        {
          strcat (result, "operator ");
          strcat (result, "operator ");
          strncat (result, type.b, type.p - type.b);
          strncat (result, type.b, type.p - type.b);
          string_delete (&type);
          string_delete (&type);
          ret = 1;
          ret = 1;
        }
        }
    }
    }
  else if (opname[0] == '_' && opname[1] == '_'
  else if (opname[0] == '_' && opname[1] == '_'
           && ISLOWER((unsigned char)opname[2])
           && ISLOWER((unsigned char)opname[2])
           && ISLOWER((unsigned char)opname[3]))
           && ISLOWER((unsigned char)opname[3]))
    {
    {
      if (opname[4] == '\0')
      if (opname[4] == '\0')
        {
        {
          /* Operator.  */
          /* Operator.  */
          size_t i;
          size_t i;
          for (i = 0; i < ARRAY_SIZE (optable); i++)
          for (i = 0; i < ARRAY_SIZE (optable); i++)
            {
            {
              if (strlen (optable[i].in) == 2
              if (strlen (optable[i].in) == 2
                  && memcmp (optable[i].in, opname + 2, 2) == 0)
                  && memcmp (optable[i].in, opname + 2, 2) == 0)
                {
                {
                  strcat (result, "operator");
                  strcat (result, "operator");
                  strcat (result, optable[i].out);
                  strcat (result, optable[i].out);
                  ret = 1;
                  ret = 1;
                  break;
                  break;
                }
                }
            }
            }
        }
        }
      else
      else
        {
        {
          if (opname[2] == 'a' && opname[5] == '\0')
          if (opname[2] == 'a' && opname[5] == '\0')
            {
            {
              /* Assignment.  */
              /* Assignment.  */
              size_t i;
              size_t i;
              for (i = 0; i < ARRAY_SIZE (optable); i++)
              for (i = 0; i < ARRAY_SIZE (optable); i++)
                {
                {
                  if (strlen (optable[i].in) == 3
                  if (strlen (optable[i].in) == 3
                      && memcmp (optable[i].in, opname + 2, 3) == 0)
                      && memcmp (optable[i].in, opname + 2, 3) == 0)
                    {
                    {
                      strcat (result, "operator");
                      strcat (result, "operator");
                      strcat (result, optable[i].out);
                      strcat (result, optable[i].out);
                      ret = 1;
                      ret = 1;
                      break;
                      break;
                    }
                    }
                }
                }
            }
            }
        }
        }
    }
    }
  else if (len >= 3
  else if (len >= 3
           && opname[0] == 'o'
           && opname[0] == 'o'
           && opname[1] == 'p'
           && opname[1] == 'p'
           && strchr (cplus_markers, opname[2]) != NULL)
           && strchr (cplus_markers, opname[2]) != NULL)
    {
    {
      /* see if it's an assignment expression */
      /* see if it's an assignment expression */
      if (len >= 10 /* op$assign_ */
      if (len >= 10 /* op$assign_ */
          && memcmp (opname + 3, "assign_", 7) == 0)
          && memcmp (opname + 3, "assign_", 7) == 0)
        {
        {
          size_t i;
          size_t i;
          for (i = 0; i < ARRAY_SIZE (optable); i++)
          for (i = 0; i < ARRAY_SIZE (optable); i++)
            {
            {
              len1 = len - 10;
              len1 = len - 10;
              if ((int) strlen (optable[i].in) == len1
              if ((int) strlen (optable[i].in) == len1
                  && memcmp (optable[i].in, opname + 10, len1) == 0)
                  && memcmp (optable[i].in, opname + 10, len1) == 0)
                {
                {
                  strcat (result, "operator");
                  strcat (result, "operator");
                  strcat (result, optable[i].out);
                  strcat (result, optable[i].out);
                  strcat (result, "=");
                  strcat (result, "=");
                  ret = 1;
                  ret = 1;
                  break;
                  break;
                }
                }
            }
            }
        }
        }
      else
      else
        {
        {
          size_t i;
          size_t i;
          for (i = 0; i < ARRAY_SIZE (optable); i++)
          for (i = 0; i < ARRAY_SIZE (optable); i++)
            {
            {
              len1 = len - 3;
              len1 = len - 3;
              if ((int) strlen (optable[i].in) == len1
              if ((int) strlen (optable[i].in) == len1
                  && memcmp (optable[i].in, opname + 3, len1) == 0)
                  && memcmp (optable[i].in, opname + 3, len1) == 0)
                {
                {
                  strcat (result, "operator");
                  strcat (result, "operator");
                  strcat (result, optable[i].out);
                  strcat (result, optable[i].out);
                  ret = 1;
                  ret = 1;
                  break;
                  break;
                }
                }
            }
            }
        }
        }
    }
    }
  else if (len >= 5 && memcmp (opname, "type", 4) == 0
  else if (len >= 5 && memcmp (opname, "type", 4) == 0
           && strchr (cplus_markers, opname[4]) != NULL)
           && strchr (cplus_markers, opname[4]) != NULL)
    {
    {
      /* type conversion operator */
      /* type conversion operator */
      tem = opname + 5;
      tem = opname + 5;
      if (do_type (work, &tem, &type))
      if (do_type (work, &tem, &type))
        {
        {
          strcat (result, "operator ");
          strcat (result, "operator ");
          strncat (result, type.b, type.p - type.b);
          strncat (result, type.b, type.p - type.b);
          string_delete (&type);
          string_delete (&type);
          ret = 1;
          ret = 1;
        }
        }
    }
    }
  squangle_mop_up (work);
  squangle_mop_up (work);
  return ret;
  return ret;
 
 
}
}
 
 
/* Takes operator name as e.g. "++" and returns mangled
/* Takes operator name as e.g. "++" and returns mangled
   operator name (e.g. "postincrement_expr"), or NULL if not found.
   operator name (e.g. "postincrement_expr"), or NULL if not found.
 
 
   If OPTIONS & DMGL_ANSI == 1, return the ANSI name;
   If OPTIONS & DMGL_ANSI == 1, return the ANSI name;
   if OPTIONS & DMGL_ANSI == 0, return the old GNU name.  */
   if OPTIONS & DMGL_ANSI == 0, return the old GNU name.  */
 
 
const char *
const char *
cplus_mangle_opname (const char *opname, int options)
cplus_mangle_opname (const char *opname, int options)
{
{
  size_t i;
  size_t i;
  int len;
  int len;
 
 
  len = strlen (opname);
  len = strlen (opname);
  for (i = 0; i < ARRAY_SIZE (optable); i++)
  for (i = 0; i < ARRAY_SIZE (optable); i++)
    {
    {
      if ((int) strlen (optable[i].out) == len
      if ((int) strlen (optable[i].out) == len
          && (options & DMGL_ANSI) == (optable[i].flags & DMGL_ANSI)
          && (options & DMGL_ANSI) == (optable[i].flags & DMGL_ANSI)
          && memcmp (optable[i].out, opname, len) == 0)
          && memcmp (optable[i].out, opname, len) == 0)
        return optable[i].in;
        return optable[i].in;
    }
    }
  return (0);
  return (0);
}
}
 
 
/* Add a routine to set the demangling style to be sure it is valid and
/* Add a routine to set the demangling style to be sure it is valid and
   allow for any demangler initialization that maybe necessary. */
   allow for any demangler initialization that maybe necessary. */
 
 
enum demangling_styles
enum demangling_styles
cplus_demangle_set_style (enum demangling_styles style)
cplus_demangle_set_style (enum demangling_styles style)
{
{
  const struct demangler_engine *demangler = libiberty_demanglers;
  const struct demangler_engine *demangler = libiberty_demanglers;
 
 
  for (; demangler->demangling_style != unknown_demangling; ++demangler)
  for (; demangler->demangling_style != unknown_demangling; ++demangler)
    if (style == demangler->demangling_style)
    if (style == demangler->demangling_style)
      {
      {
        current_demangling_style = style;
        current_demangling_style = style;
        return current_demangling_style;
        return current_demangling_style;
      }
      }
 
 
  return unknown_demangling;
  return unknown_demangling;
}
}
 
 
/* Do string name to style translation */
/* Do string name to style translation */
 
 
enum demangling_styles
enum demangling_styles
cplus_demangle_name_to_style (const char *name)
cplus_demangle_name_to_style (const char *name)
{
{
  const struct demangler_engine *demangler = libiberty_demanglers;
  const struct demangler_engine *demangler = libiberty_demanglers;
 
 
  for (; demangler->demangling_style != unknown_demangling; ++demangler)
  for (; demangler->demangling_style != unknown_demangling; ++demangler)
    if (strcmp (name, demangler->demangling_style_name) == 0)
    if (strcmp (name, demangler->demangling_style_name) == 0)
      return demangler->demangling_style;
      return demangler->demangling_style;
 
 
  return unknown_demangling;
  return unknown_demangling;
}
}
 
 
/* char *cplus_demangle (const char *mangled, int options)
/* char *cplus_demangle (const char *mangled, int options)
 
 
   If MANGLED is a mangled function name produced by GNU C++, then
   If MANGLED is a mangled function name produced by GNU C++, then
   a pointer to a @code{malloc}ed string giving a C++ representation
   a pointer to a @code{malloc}ed string giving a C++ representation
   of the name will be returned; otherwise NULL will be returned.
   of the name will be returned; otherwise NULL will be returned.
   It is the caller's responsibility to free the string which
   It is the caller's responsibility to free the string which
   is returned.
   is returned.
 
 
   The OPTIONS arg may contain one or more of the following bits:
   The OPTIONS arg may contain one or more of the following bits:
 
 
        DMGL_ANSI       ANSI qualifiers such as `const' and `void' are
        DMGL_ANSI       ANSI qualifiers such as `const' and `void' are
                        included.
                        included.
        DMGL_PARAMS     Function parameters are included.
        DMGL_PARAMS     Function parameters are included.
 
 
   For example,
   For example,
 
 
   cplus_demangle ("foo__1Ai", DMGL_PARAMS)             => "A::foo(int)"
   cplus_demangle ("foo__1Ai", DMGL_PARAMS)             => "A::foo(int)"
   cplus_demangle ("foo__1Ai", DMGL_PARAMS | DMGL_ANSI) => "A::foo(int)"
   cplus_demangle ("foo__1Ai", DMGL_PARAMS | DMGL_ANSI) => "A::foo(int)"
   cplus_demangle ("foo__1Ai", 0)                       => "A::foo"
   cplus_demangle ("foo__1Ai", 0)                       => "A::foo"
 
 
   cplus_demangle ("foo__1Afe", DMGL_PARAMS)            => "A::foo(float,...)"
   cplus_demangle ("foo__1Afe", DMGL_PARAMS)            => "A::foo(float,...)"
   cplus_demangle ("foo__1Afe", DMGL_PARAMS | DMGL_ANSI)=> "A::foo(float,...)"
   cplus_demangle ("foo__1Afe", DMGL_PARAMS | DMGL_ANSI)=> "A::foo(float,...)"
   cplus_demangle ("foo__1Afe", 0)                      => "A::foo"
   cplus_demangle ("foo__1Afe", 0)                      => "A::foo"
 
 
   Note that any leading underscores, or other such characters prepended by
   Note that any leading underscores, or other such characters prepended by
   the compilation system, are presumed to have already been stripped from
   the compilation system, are presumed to have already been stripped from
   MANGLED.  */
   MANGLED.  */
 
 
char *
char *
cplus_demangle (const char *mangled, int options)
cplus_demangle (const char *mangled, int options)
{
{
  char *ret;
  char *ret;
  struct work_stuff work[1];
  struct work_stuff work[1];
 
 
  if (current_demangling_style == no_demangling)
  if (current_demangling_style == no_demangling)
    return xstrdup (mangled);
    return xstrdup (mangled);
 
 
  memset ((char *) work, 0, sizeof (work));
  memset ((char *) work, 0, sizeof (work));
  work->options = options;
  work->options = options;
  if ((work->options & DMGL_STYLE_MASK) == 0)
  if ((work->options & DMGL_STYLE_MASK) == 0)
    work->options |= (int) current_demangling_style & DMGL_STYLE_MASK;
    work->options |= (int) current_demangling_style & DMGL_STYLE_MASK;
 
 
  /* The V3 ABI demangling is implemented elsewhere.  */
  /* The V3 ABI demangling is implemented elsewhere.  */
  if (GNU_V3_DEMANGLING || AUTO_DEMANGLING)
  if (GNU_V3_DEMANGLING || AUTO_DEMANGLING)
    {
    {
      ret = cplus_demangle_v3 (mangled, work->options);
      ret = cplus_demangle_v3 (mangled, work->options);
      if (ret || GNU_V3_DEMANGLING)
      if (ret || GNU_V3_DEMANGLING)
        return ret;
        return ret;
    }
    }
 
 
  if (JAVA_DEMANGLING)
  if (JAVA_DEMANGLING)
    {
    {
      ret = java_demangle_v3 (mangled);
      ret = java_demangle_v3 (mangled);
      if (ret)
      if (ret)
        return ret;
        return ret;
    }
    }
 
 
  if (GNAT_DEMANGLING)
  if (GNAT_DEMANGLING)
    return ada_demangle(mangled,options);
    return ada_demangle(mangled,options);
 
 
  ret = internal_cplus_demangle (work, mangled);
  ret = internal_cplus_demangle (work, mangled);
  squangle_mop_up (work);
  squangle_mop_up (work);
  return (ret);
  return (ret);
}
}
 
 
 
 
/* Assuming *OLD_VECT points to an array of *SIZE objects of size
/* Assuming *OLD_VECT points to an array of *SIZE objects of size
   ELEMENT_SIZE, grow it to contain at least MIN_SIZE objects,
   ELEMENT_SIZE, grow it to contain at least MIN_SIZE objects,
   updating *OLD_VECT and *SIZE as necessary.  */
   updating *OLD_VECT and *SIZE as necessary.  */
 
 
static void
static void
grow_vect (char **old_vect, size_t *size, size_t min_size, int element_size)
grow_vect (char **old_vect, size_t *size, size_t min_size, int element_size)
{
{
  if (*size < min_size)
  if (*size < min_size)
    {
    {
      *size *= 2;
      *size *= 2;
      if (*size < min_size)
      if (*size < min_size)
        *size = min_size;
        *size = min_size;
      *old_vect = XRESIZEVAR (char, *old_vect, *size * element_size);
      *old_vect = XRESIZEVAR (char, *old_vect, *size * element_size);
    }
    }
}
}
 
 
/* Demangle ada names:
/* Demangle ada names:
   1. Discard final __{DIGIT}+ or ${DIGIT}+
   1. Discard final __{DIGIT}+ or ${DIGIT}+
   2. Convert other instances of embedded "__" to `.'.
   2. Convert other instances of embedded "__" to `.'.
   3. Discard leading _ada_.
   3. Discard leading _ada_.
   4. Remove everything after first ___ if it is followed by 'X'.
   4. Remove everything after first ___ if it is followed by 'X'.
   5. Put symbols that should be suppressed in <...> brackets.
   5. Put symbols that should be suppressed in <...> brackets.
   The resulting string is valid until the next call of ada_demangle.  */
   The resulting string is valid until the next call of ada_demangle.  */
 
 
static char *
static char *
ada_demangle (const char *mangled, int option ATTRIBUTE_UNUSED)
ada_demangle (const char *mangled, int option ATTRIBUTE_UNUSED)
{
{
  int i, j;
  int i, j;
  int len0;
  int len0;
  const char* p;
  const char* p;
  char *demangled = NULL;
  char *demangled = NULL;
  int changed;
  int changed;
  size_t demangled_size = 0;
  size_t demangled_size = 0;
 
 
  changed = 0;
  changed = 0;
 
 
  if (strncmp (mangled, "_ada_", 5) == 0)
  if (strncmp (mangled, "_ada_", 5) == 0)
    {
    {
      mangled += 5;
      mangled += 5;
      changed = 1;
      changed = 1;
    }
    }
 
 
  if (mangled[0] == '_' || mangled[0] == '<')
  if (mangled[0] == '_' || mangled[0] == '<')
    goto Suppress;
    goto Suppress;
 
 
  p = strstr (mangled, "___");
  p = strstr (mangled, "___");
  if (p == NULL)
  if (p == NULL)
    len0 = strlen (mangled);
    len0 = strlen (mangled);
  else
  else
    {
    {
      if (p[3] == 'X')
      if (p[3] == 'X')
        {
        {
          len0 = p - mangled;
          len0 = p - mangled;
          changed = 1;
          changed = 1;
        }
        }
      else
      else
        goto Suppress;
        goto Suppress;
    }
    }
 
 
  /* Make demangled big enough for possible expansion by operator name.  */
  /* Make demangled big enough for possible expansion by operator name.  */
  grow_vect (&demangled,
  grow_vect (&demangled,
             &demangled_size,  2 * len0 + 1,
             &demangled_size,  2 * len0 + 1,
             sizeof (char));
             sizeof (char));
 
 
  if (ISDIGIT ((unsigned char) mangled[len0 - 1])) {
  if (ISDIGIT ((unsigned char) mangled[len0 - 1])) {
    for (i = len0 - 2; i >= 0 && ISDIGIT ((unsigned char) mangled[i]); i -= 1)
    for (i = len0 - 2; i >= 0 && ISDIGIT ((unsigned char) mangled[i]); i -= 1)
      ;
      ;
    if (i > 1 && mangled[i] == '_' && mangled[i - 1] == '_')
    if (i > 1 && mangled[i] == '_' && mangled[i - 1] == '_')
      {
      {
        len0 = i - 1;
        len0 = i - 1;
        changed = 1;
        changed = 1;
      }
      }
    else if (mangled[i] == '$')
    else if (mangled[i] == '$')
      {
      {
        len0 = i;
        len0 = i;
        changed = 1;
        changed = 1;
      }
      }
  }
  }
 
 
  for (i = 0, j = 0; i < len0 && ! ISALPHA ((unsigned char)mangled[i]);
  for (i = 0, j = 0; i < len0 && ! ISALPHA ((unsigned char)mangled[i]);
       i += 1, j += 1)
       i += 1, j += 1)
    demangled[j] = mangled[i];
    demangled[j] = mangled[i];
 
 
  while (i < len0)
  while (i < len0)
    {
    {
      if (i < len0 - 2 && mangled[i] == '_' && mangled[i + 1] == '_')
      if (i < len0 - 2 && mangled[i] == '_' && mangled[i + 1] == '_')
        {
        {
          demangled[j] = '.';
          demangled[j] = '.';
          changed = 1;
          changed = 1;
          i += 2; j += 1;
          i += 2; j += 1;
        }
        }
      else
      else
        {
        {
          demangled[j] = mangled[i];
          demangled[j] = mangled[i];
          i += 1;  j += 1;
          i += 1;  j += 1;
        }
        }
    }
    }
  demangled[j] = '\000';
  demangled[j] = '\000';
 
 
  for (i = 0; demangled[i] != '\0'; i += 1)
  for (i = 0; demangled[i] != '\0'; i += 1)
    if (ISUPPER ((unsigned char)demangled[i]) || demangled[i] == ' ')
    if (ISUPPER ((unsigned char)demangled[i]) || demangled[i] == ' ')
      goto Suppress;
      goto Suppress;
 
 
  if (! changed)
  if (! changed)
    {
    {
      free (demangled);
      free (demangled);
      return NULL;
      return NULL;
    }
    }
  else
  else
    return demangled;
    return demangled;
 
 
 Suppress:
 Suppress:
  grow_vect (&demangled,
  grow_vect (&demangled,
             &demangled_size,  strlen (mangled) + 3,
             &demangled_size,  strlen (mangled) + 3,
             sizeof (char));
             sizeof (char));
 
 
  if (mangled[0] == '<')
  if (mangled[0] == '<')
     strcpy (demangled, mangled);
     strcpy (demangled, mangled);
  else
  else
    sprintf (demangled, "<%s>", mangled);
    sprintf (demangled, "<%s>", mangled);
 
 
  return demangled;
  return demangled;
}
}
 
 
/* This function performs most of what cplus_demangle use to do, but
/* This function performs most of what cplus_demangle use to do, but
   to be able to demangle a name with a B, K or n code, we need to
   to be able to demangle a name with a B, K or n code, we need to
   have a longer term memory of what types have been seen. The original
   have a longer term memory of what types have been seen. The original
   now initializes and cleans up the squangle code info, while internal
   now initializes and cleans up the squangle code info, while internal
   calls go directly to this routine to avoid resetting that info. */
   calls go directly to this routine to avoid resetting that info. */
 
 
static char *
static char *
internal_cplus_demangle (struct work_stuff *work, const char *mangled)
internal_cplus_demangle (struct work_stuff *work, const char *mangled)
{
{
 
 
  string decl;
  string decl;
  int success = 0;
  int success = 0;
  char *demangled = NULL;
  char *demangled = NULL;
  int s1, s2, s3, s4;
  int s1, s2, s3, s4;
  s1 = work->constructor;
  s1 = work->constructor;
  s2 = work->destructor;
  s2 = work->destructor;
  s3 = work->static_type;
  s3 = work->static_type;
  s4 = work->type_quals;
  s4 = work->type_quals;
  work->constructor = work->destructor = 0;
  work->constructor = work->destructor = 0;
  work->type_quals = TYPE_UNQUALIFIED;
  work->type_quals = TYPE_UNQUALIFIED;
  work->dllimported = 0;
  work->dllimported = 0;
 
 
  if ((mangled != NULL) && (*mangled != '\0'))
  if ((mangled != NULL) && (*mangled != '\0'))
    {
    {
      string_init (&decl);
      string_init (&decl);
 
 
      /* First check to see if gnu style demangling is active and if the
      /* First check to see if gnu style demangling is active and if the
         string to be demangled contains a CPLUS_MARKER.  If so, attempt to
         string to be demangled contains a CPLUS_MARKER.  If so, attempt to
         recognize one of the gnu special forms rather than looking for a
         recognize one of the gnu special forms rather than looking for a
         standard prefix.  In particular, don't worry about whether there
         standard prefix.  In particular, don't worry about whether there
         is a "__" string in the mangled string.  Consider "_$_5__foo" for
         is a "__" string in the mangled string.  Consider "_$_5__foo" for
         example.  */
         example.  */
 
 
      if ((AUTO_DEMANGLING || GNU_DEMANGLING))
      if ((AUTO_DEMANGLING || GNU_DEMANGLING))
        {
        {
          success = gnu_special (work, &mangled, &decl);
          success = gnu_special (work, &mangled, &decl);
        }
        }
      if (!success)
      if (!success)
        {
        {
          success = demangle_prefix (work, &mangled, &decl);
          success = demangle_prefix (work, &mangled, &decl);
        }
        }
      if (success && (*mangled != '\0'))
      if (success && (*mangled != '\0'))
        {
        {
          success = demangle_signature (work, &mangled, &decl);
          success = demangle_signature (work, &mangled, &decl);
        }
        }
      if (work->constructor == 2)
      if (work->constructor == 2)
        {
        {
          string_prepend (&decl, "global constructors keyed to ");
          string_prepend (&decl, "global constructors keyed to ");
          work->constructor = 0;
          work->constructor = 0;
        }
        }
      else if (work->destructor == 2)
      else if (work->destructor == 2)
        {
        {
          string_prepend (&decl, "global destructors keyed to ");
          string_prepend (&decl, "global destructors keyed to ");
          work->destructor = 0;
          work->destructor = 0;
        }
        }
      else if (work->dllimported == 1)
      else if (work->dllimported == 1)
        {
        {
          string_prepend (&decl, "import stub for ");
          string_prepend (&decl, "import stub for ");
          work->dllimported = 0;
          work->dllimported = 0;
        }
        }
      demangled = mop_up (work, &decl, success);
      demangled = mop_up (work, &decl, success);
    }
    }
  work->constructor = s1;
  work->constructor = s1;
  work->destructor = s2;
  work->destructor = s2;
  work->static_type = s3;
  work->static_type = s3;
  work->type_quals = s4;
  work->type_quals = s4;
  return demangled;
  return demangled;
}
}
 
 
 
 
/* Clear out and squangling related storage */
/* Clear out and squangling related storage */
static void
static void
squangle_mop_up (struct work_stuff *work)
squangle_mop_up (struct work_stuff *work)
{
{
  /* clean up the B and K type mangling types. */
  /* clean up the B and K type mangling types. */
  forget_B_and_K_types (work);
  forget_B_and_K_types (work);
  if (work -> btypevec != NULL)
  if (work -> btypevec != NULL)
    {
    {
      free ((char *) work -> btypevec);
      free ((char *) work -> btypevec);
    }
    }
  if (work -> ktypevec != NULL)
  if (work -> ktypevec != NULL)
    {
    {
      free ((char *) work -> ktypevec);
      free ((char *) work -> ktypevec);
    }
    }
}
}
 
 
 
 
/* Copy the work state and storage.  */
/* Copy the work state and storage.  */
 
 
static void
static void
work_stuff_copy_to_from (struct work_stuff *to, struct work_stuff *from)
work_stuff_copy_to_from (struct work_stuff *to, struct work_stuff *from)
{
{
  int i;
  int i;
 
 
  delete_work_stuff (to);
  delete_work_stuff (to);
 
 
  /* Shallow-copy scalars.  */
  /* Shallow-copy scalars.  */
  memcpy (to, from, sizeof (*to));
  memcpy (to, from, sizeof (*to));
 
 
  /* Deep-copy dynamic storage.  */
  /* Deep-copy dynamic storage.  */
  if (from->typevec_size)
  if (from->typevec_size)
    to->typevec = XNEWVEC (char *, from->typevec_size);
    to->typevec = XNEWVEC (char *, from->typevec_size);
 
 
  for (i = 0; i < from->ntypes; i++)
  for (i = 0; i < from->ntypes; i++)
    {
    {
      int len = strlen (from->typevec[i]) + 1;
      int len = strlen (from->typevec[i]) + 1;
 
 
      to->typevec[i] = XNEWVEC (char, len);
      to->typevec[i] = XNEWVEC (char, len);
      memcpy (to->typevec[i], from->typevec[i], len);
      memcpy (to->typevec[i], from->typevec[i], len);
    }
    }
 
 
  if (from->ksize)
  if (from->ksize)
    to->ktypevec = XNEWVEC (char *, from->ksize);
    to->ktypevec = XNEWVEC (char *, from->ksize);
 
 
  for (i = 0; i < from->numk; i++)
  for (i = 0; i < from->numk; i++)
    {
    {
      int len = strlen (from->ktypevec[i]) + 1;
      int len = strlen (from->ktypevec[i]) + 1;
 
 
      to->ktypevec[i] = XNEWVEC (char, len);
      to->ktypevec[i] = XNEWVEC (char, len);
      memcpy (to->ktypevec[i], from->ktypevec[i], len);
      memcpy (to->ktypevec[i], from->ktypevec[i], len);
    }
    }
 
 
  if (from->bsize)
  if (from->bsize)
    to->btypevec = XNEWVEC (char *, from->bsize);
    to->btypevec = XNEWVEC (char *, from->bsize);
 
 
  for (i = 0; i < from->numb; i++)
  for (i = 0; i < from->numb; i++)
    {
    {
      int len = strlen (from->btypevec[i]) + 1;
      int len = strlen (from->btypevec[i]) + 1;
 
 
      to->btypevec[i] = XNEWVEC (char , len);
      to->btypevec[i] = XNEWVEC (char , len);
      memcpy (to->btypevec[i], from->btypevec[i], len);
      memcpy (to->btypevec[i], from->btypevec[i], len);
    }
    }
 
 
  if (from->ntmpl_args)
  if (from->ntmpl_args)
    to->tmpl_argvec = XNEWVEC (char *, from->ntmpl_args);
    to->tmpl_argvec = XNEWVEC (char *, from->ntmpl_args);
 
 
  for (i = 0; i < from->ntmpl_args; i++)
  for (i = 0; i < from->ntmpl_args; i++)
    {
    {
      int len = strlen (from->tmpl_argvec[i]) + 1;
      int len = strlen (from->tmpl_argvec[i]) + 1;
 
 
      to->tmpl_argvec[i] = XNEWVEC (char, len);
      to->tmpl_argvec[i] = XNEWVEC (char, len);
      memcpy (to->tmpl_argvec[i], from->tmpl_argvec[i], len);
      memcpy (to->tmpl_argvec[i], from->tmpl_argvec[i], len);
    }
    }
 
 
  if (from->previous_argument)
  if (from->previous_argument)
    {
    {
      to->previous_argument = XNEW (string);
      to->previous_argument = XNEW (string);
      string_init (to->previous_argument);
      string_init (to->previous_argument);
      string_appends (to->previous_argument, from->previous_argument);
      string_appends (to->previous_argument, from->previous_argument);
    }
    }
}
}
 
 
 
 
/* Delete dynamic stuff in work_stuff that is not to be re-used.  */
/* Delete dynamic stuff in work_stuff that is not to be re-used.  */
 
 
static void
static void
delete_non_B_K_work_stuff (struct work_stuff *work)
delete_non_B_K_work_stuff (struct work_stuff *work)
{
{
  /* Discard the remembered types, if any.  */
  /* Discard the remembered types, if any.  */
 
 
  forget_types (work);
  forget_types (work);
  if (work -> typevec != NULL)
  if (work -> typevec != NULL)
    {
    {
      free ((char *) work -> typevec);
      free ((char *) work -> typevec);
      work -> typevec = NULL;
      work -> typevec = NULL;
      work -> typevec_size = 0;
      work -> typevec_size = 0;
    }
    }
  if (work->tmpl_argvec)
  if (work->tmpl_argvec)
    {
    {
      int i;
      int i;
 
 
      for (i = 0; i < work->ntmpl_args; i++)
      for (i = 0; i < work->ntmpl_args; i++)
        if (work->tmpl_argvec[i])
        if (work->tmpl_argvec[i])
          free ((char*) work->tmpl_argvec[i]);
          free ((char*) work->tmpl_argvec[i]);
 
 
      free ((char*) work->tmpl_argvec);
      free ((char*) work->tmpl_argvec);
      work->tmpl_argvec = NULL;
      work->tmpl_argvec = NULL;
    }
    }
  if (work->previous_argument)
  if (work->previous_argument)
    {
    {
      string_delete (work->previous_argument);
      string_delete (work->previous_argument);
      free ((char*) work->previous_argument);
      free ((char*) work->previous_argument);
      work->previous_argument = NULL;
      work->previous_argument = NULL;
    }
    }
}
}
 
 
 
 
/* Delete all dynamic storage in work_stuff.  */
/* Delete all dynamic storage in work_stuff.  */
static void
static void
delete_work_stuff (struct work_stuff *work)
delete_work_stuff (struct work_stuff *work)
{
{
  delete_non_B_K_work_stuff (work);
  delete_non_B_K_work_stuff (work);
  squangle_mop_up (work);
  squangle_mop_up (work);
}
}
 
 
 
 
/* Clear out any mangled storage */
/* Clear out any mangled storage */
 
 
static char *
static char *
mop_up (struct work_stuff *work, string *declp, int success)
mop_up (struct work_stuff *work, string *declp, int success)
{
{
  char *demangled = NULL;
  char *demangled = NULL;
 
 
  delete_non_B_K_work_stuff (work);
  delete_non_B_K_work_stuff (work);
 
 
  /* If demangling was successful, ensure that the demangled string is null
  /* If demangling was successful, ensure that the demangled string is null
     terminated and return it.  Otherwise, free the demangling decl.  */
     terminated and return it.  Otherwise, free the demangling decl.  */
 
 
  if (!success)
  if (!success)
    {
    {
      string_delete (declp);
      string_delete (declp);
    }
    }
  else
  else
    {
    {
      string_appendn (declp, "", 1);
      string_appendn (declp, "", 1);
      demangled = declp->b;
      demangled = declp->b;
    }
    }
  return (demangled);
  return (demangled);
}
}
 
 
/*
/*
 
 
LOCAL FUNCTION
LOCAL FUNCTION
 
 
        demangle_signature -- demangle the signature part of a mangled name
        demangle_signature -- demangle the signature part of a mangled name
 
 
SYNOPSIS
SYNOPSIS
 
 
        static int
        static int
        demangle_signature (struct work_stuff *work, const char **mangled,
        demangle_signature (struct work_stuff *work, const char **mangled,
                            string *declp);
                            string *declp);
 
 
DESCRIPTION
DESCRIPTION
 
 
        Consume and demangle the signature portion of the mangled name.
        Consume and demangle the signature portion of the mangled name.
 
 
        DECLP is the string where demangled output is being built.  At
        DECLP is the string where demangled output is being built.  At
        entry it contains the demangled root name from the mangled name
        entry it contains the demangled root name from the mangled name
        prefix.  I.E. either a demangled operator name or the root function
        prefix.  I.E. either a demangled operator name or the root function
        name.  In some special cases, it may contain nothing.
        name.  In some special cases, it may contain nothing.
 
 
        *MANGLED points to the current unconsumed location in the mangled
        *MANGLED points to the current unconsumed location in the mangled
        name.  As tokens are consumed and demangling is performed, the
        name.  As tokens are consumed and demangling is performed, the
        pointer is updated to continuously point at the next token to
        pointer is updated to continuously point at the next token to
        be consumed.
        be consumed.
 
 
        Demangling GNU style mangled names is nasty because there is no
        Demangling GNU style mangled names is nasty because there is no
        explicit token that marks the start of the outermost function
        explicit token that marks the start of the outermost function
        argument list.  */
        argument list.  */
 
 
static int
static int
demangle_signature (struct work_stuff *work,
demangle_signature (struct work_stuff *work,
                    const char **mangled, string *declp)
                    const char **mangled, string *declp)
{
{
  int success = 1;
  int success = 1;
  int func_done = 0;
  int func_done = 0;
  int expect_func = 0;
  int expect_func = 0;
  int expect_return_type = 0;
  int expect_return_type = 0;
  const char *oldmangled = NULL;
  const char *oldmangled = NULL;
  string trawname;
  string trawname;
  string tname;
  string tname;
 
 
  while (success && (**mangled != '\0'))
  while (success && (**mangled != '\0'))
    {
    {
      switch (**mangled)
      switch (**mangled)
        {
        {
        case 'Q':
        case 'Q':
          oldmangled = *mangled;
          oldmangled = *mangled;
          success = demangle_qualified (work, mangled, declp, 1, 0);
          success = demangle_qualified (work, mangled, declp, 1, 0);
          if (success)
          if (success)
            remember_type (work, oldmangled, *mangled - oldmangled);
            remember_type (work, oldmangled, *mangled - oldmangled);
          if (AUTO_DEMANGLING || GNU_DEMANGLING)
          if (AUTO_DEMANGLING || GNU_DEMANGLING)
            expect_func = 1;
            expect_func = 1;
          oldmangled = NULL;
          oldmangled = NULL;
          break;
          break;
 
 
        case 'K':
        case 'K':
          oldmangled = *mangled;
          oldmangled = *mangled;
          success = demangle_qualified (work, mangled, declp, 1, 0);
          success = demangle_qualified (work, mangled, declp, 1, 0);
          if (AUTO_DEMANGLING || GNU_DEMANGLING)
          if (AUTO_DEMANGLING || GNU_DEMANGLING)
            {
            {
              expect_func = 1;
              expect_func = 1;
            }
            }
          oldmangled = NULL;
          oldmangled = NULL;
          break;
          break;
 
 
        case 'S':
        case 'S':
          /* Static member function */
          /* Static member function */
          if (oldmangled == NULL)
          if (oldmangled == NULL)
            {
            {
              oldmangled = *mangled;
              oldmangled = *mangled;
            }
            }
          (*mangled)++;
          (*mangled)++;
          work -> static_type = 1;
          work -> static_type = 1;
          break;
          break;
 
 
        case 'C':
        case 'C':
        case 'V':
        case 'V':
        case 'u':
        case 'u':
          work->type_quals |= code_for_qualifier (**mangled);
          work->type_quals |= code_for_qualifier (**mangled);
 
 
          /* a qualified member function */
          /* a qualified member function */
          if (oldmangled == NULL)
          if (oldmangled == NULL)
            oldmangled = *mangled;
            oldmangled = *mangled;
          (*mangled)++;
          (*mangled)++;
          break;
          break;
 
 
        case 'L':
        case 'L':
          /* Local class name follows after "Lnnn_" */
          /* Local class name follows after "Lnnn_" */
          if (HP_DEMANGLING)
          if (HP_DEMANGLING)
            {
            {
              while (**mangled && (**mangled != '_'))
              while (**mangled && (**mangled != '_'))
                (*mangled)++;
                (*mangled)++;
              if (!**mangled)
              if (!**mangled)
                success = 0;
                success = 0;
              else
              else
                (*mangled)++;
                (*mangled)++;
            }
            }
          else
          else
            success = 0;
            success = 0;
          break;
          break;
 
 
        case '0': case '1': case '2': case '3': case '4':
        case '0': case '1': case '2': case '3': case '4':
        case '5': case '6': case '7': case '8': case '9':
        case '5': case '6': case '7': case '8': case '9':
          if (oldmangled == NULL)
          if (oldmangled == NULL)
            {
            {
              oldmangled = *mangled;
              oldmangled = *mangled;
            }
            }
          work->temp_start = -1; /* uppermost call to demangle_class */
          work->temp_start = -1; /* uppermost call to demangle_class */
          success = demangle_class (work, mangled, declp);
          success = demangle_class (work, mangled, declp);
          if (success)
          if (success)
            {
            {
              remember_type (work, oldmangled, *mangled - oldmangled);
              remember_type (work, oldmangled, *mangled - oldmangled);
            }
            }
          if (AUTO_DEMANGLING || GNU_DEMANGLING || EDG_DEMANGLING)
          if (AUTO_DEMANGLING || GNU_DEMANGLING || EDG_DEMANGLING)
            {
            {
              /* EDG and others will have the "F", so we let the loop cycle
              /* EDG and others will have the "F", so we let the loop cycle
                 if we are looking at one. */
                 if we are looking at one. */
              if (**mangled != 'F')
              if (**mangled != 'F')
                 expect_func = 1;
                 expect_func = 1;
            }
            }
          oldmangled = NULL;
          oldmangled = NULL;
          break;
          break;
 
 
        case 'B':
        case 'B':
          {
          {
            string s;
            string s;
            success = do_type (work, mangled, &s);
            success = do_type (work, mangled, &s);
            if (success)
            if (success)
              {
              {
                string_append (&s, SCOPE_STRING (work));
                string_append (&s, SCOPE_STRING (work));
                string_prepends (declp, &s);
                string_prepends (declp, &s);
                string_delete (&s);
                string_delete (&s);
              }
              }
            oldmangled = NULL;
            oldmangled = NULL;
            expect_func = 1;
            expect_func = 1;
          }
          }
          break;
          break;
 
 
        case 'F':
        case 'F':
          /* Function */
          /* Function */
          /* ARM/HP style demangling includes a specific 'F' character after
          /* ARM/HP style demangling includes a specific 'F' character after
             the class name.  For GNU style, it is just implied.  So we can
             the class name.  For GNU style, it is just implied.  So we can
             safely just consume any 'F' at this point and be compatible
             safely just consume any 'F' at this point and be compatible
             with either style.  */
             with either style.  */
 
 
          oldmangled = NULL;
          oldmangled = NULL;
          func_done = 1;
          func_done = 1;
          (*mangled)++;
          (*mangled)++;
 
 
          /* For lucid/ARM/HP style we have to forget any types we might
          /* For lucid/ARM/HP style we have to forget any types we might
             have remembered up to this point, since they were not argument
             have remembered up to this point, since they were not argument
             types.  GNU style considers all types seen as available for
             types.  GNU style considers all types seen as available for
             back references.  See comment in demangle_args() */
             back references.  See comment in demangle_args() */
 
 
          if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
          if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
            {
            {
              forget_types (work);
              forget_types (work);
            }
            }
          success = demangle_args (work, mangled, declp);
          success = demangle_args (work, mangled, declp);
          /* After picking off the function args, we expect to either
          /* After picking off the function args, we expect to either
             find the function return type (preceded by an '_') or the
             find the function return type (preceded by an '_') or the
             end of the string. */
             end of the string. */
          if (success && (AUTO_DEMANGLING || EDG_DEMANGLING) && **mangled == '_')
          if (success && (AUTO_DEMANGLING || EDG_DEMANGLING) && **mangled == '_')
            {
            {
              ++(*mangled);
              ++(*mangled);
              /* At this level, we do not care about the return type. */
              /* At this level, we do not care about the return type. */
              success = do_type (work, mangled, &tname);
              success = do_type (work, mangled, &tname);
              string_delete (&tname);
              string_delete (&tname);
            }
            }
 
 
          break;
          break;
 
 
        case 't':
        case 't':
          /* G++ Template */
          /* G++ Template */
          string_init(&trawname);
          string_init(&trawname);
          string_init(&tname);
          string_init(&tname);
          if (oldmangled == NULL)
          if (oldmangled == NULL)
            {
            {
              oldmangled = *mangled;
              oldmangled = *mangled;
            }
            }
          success = demangle_template (work, mangled, &tname,
          success = demangle_template (work, mangled, &tname,
                                       &trawname, 1, 1);
                                       &trawname, 1, 1);
          if (success)
          if (success)
            {
            {
              remember_type (work, oldmangled, *mangled - oldmangled);
              remember_type (work, oldmangled, *mangled - oldmangled);
            }
            }
          string_append (&tname, SCOPE_STRING (work));
          string_append (&tname, SCOPE_STRING (work));
 
 
          string_prepends(declp, &tname);
          string_prepends(declp, &tname);
          if (work -> destructor & 1)
          if (work -> destructor & 1)
            {
            {
              string_prepend (&trawname, "~");
              string_prepend (&trawname, "~");
              string_appends (declp, &trawname);
              string_appends (declp, &trawname);
              work->destructor -= 1;
              work->destructor -= 1;
            }
            }
          if ((work->constructor & 1) || (work->destructor & 1))
          if ((work->constructor & 1) || (work->destructor & 1))
            {
            {
              string_appends (declp, &trawname);
              string_appends (declp, &trawname);
              work->constructor -= 1;
              work->constructor -= 1;
            }
            }
          string_delete(&trawname);
          string_delete(&trawname);
          string_delete(&tname);
          string_delete(&tname);
          oldmangled = NULL;
          oldmangled = NULL;
          expect_func = 1;
          expect_func = 1;
          break;
          break;
 
 
        case '_':
        case '_':
          if ((AUTO_DEMANGLING || GNU_DEMANGLING) && expect_return_type)
          if ((AUTO_DEMANGLING || GNU_DEMANGLING) && expect_return_type)
            {
            {
              /* Read the return type. */
              /* Read the return type. */
              string return_type;
              string return_type;
 
 
              (*mangled)++;
              (*mangled)++;
              success = do_type (work, mangled, &return_type);
              success = do_type (work, mangled, &return_type);
              APPEND_BLANK (&return_type);
              APPEND_BLANK (&return_type);
 
 
              string_prepends (declp, &return_type);
              string_prepends (declp, &return_type);
              string_delete (&return_type);
              string_delete (&return_type);
              break;
              break;
            }
            }
          else
          else
            /* At the outermost level, we cannot have a return type specified,
            /* At the outermost level, we cannot have a return type specified,
               so if we run into another '_' at this point we are dealing with
               so if we run into another '_' at this point we are dealing with
               a mangled name that is either bogus, or has been mangled by
               a mangled name that is either bogus, or has been mangled by
               some algorithm we don't know how to deal with.  So just
               some algorithm we don't know how to deal with.  So just
               reject the entire demangling.  */
               reject the entire demangling.  */
            /* However, "_nnn" is an expected suffix for alternate entry point
            /* However, "_nnn" is an expected suffix for alternate entry point
               numbered nnn for a function, with HP aCC, so skip over that
               numbered nnn for a function, with HP aCC, so skip over that
               without reporting failure. pai/1997-09-04 */
               without reporting failure. pai/1997-09-04 */
            if (HP_DEMANGLING)
            if (HP_DEMANGLING)
              {
              {
                (*mangled)++;
                (*mangled)++;
                while (**mangled && ISDIGIT ((unsigned char)**mangled))
                while (**mangled && ISDIGIT ((unsigned char)**mangled))
                  (*mangled)++;
                  (*mangled)++;
              }
              }
            else
            else
              success = 0;
              success = 0;
          break;
          break;
 
 
        case 'H':
        case 'H':
          if (AUTO_DEMANGLING || GNU_DEMANGLING)
          if (AUTO_DEMANGLING || GNU_DEMANGLING)
            {
            {
              /* A G++ template function.  Read the template arguments. */
              /* A G++ template function.  Read the template arguments. */
              success = demangle_template (work, mangled, declp, 0, 0,
              success = demangle_template (work, mangled, declp, 0, 0,
                                           0);
                                           0);
              if (!(work->constructor & 1))
              if (!(work->constructor & 1))
                expect_return_type = 1;
                expect_return_type = 1;
              (*mangled)++;
              (*mangled)++;
              break;
              break;
            }
            }
          else
          else
            /* fall through */
            /* fall through */
            {;}
            {;}
 
 
        default:
        default:
          if (AUTO_DEMANGLING || GNU_DEMANGLING)
          if (AUTO_DEMANGLING || GNU_DEMANGLING)
            {
            {
              /* Assume we have stumbled onto the first outermost function
              /* Assume we have stumbled onto the first outermost function
                 argument token, and start processing args.  */
                 argument token, and start processing args.  */
              func_done = 1;
              func_done = 1;
              success = demangle_args (work, mangled, declp);
              success = demangle_args (work, mangled, declp);
            }
            }
          else
          else
            {
            {
              /* Non-GNU demanglers use a specific token to mark the start
              /* Non-GNU demanglers use a specific token to mark the start
                 of the outermost function argument tokens.  Typically 'F',
                 of the outermost function argument tokens.  Typically 'F',
                 for ARM/HP-demangling, for example.  So if we find something
                 for ARM/HP-demangling, for example.  So if we find something
                 we are not prepared for, it must be an error.  */
                 we are not prepared for, it must be an error.  */
              success = 0;
              success = 0;
            }
            }
          break;
          break;
        }
        }
      /*
      /*
        if (AUTO_DEMANGLING || GNU_DEMANGLING)
        if (AUTO_DEMANGLING || GNU_DEMANGLING)
        */
        */
      {
      {
        if (success && expect_func)
        if (success && expect_func)
          {
          {
            func_done = 1;
            func_done = 1;
              if (LUCID_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING)
              if (LUCID_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING)
                {
                {
                  forget_types (work);
                  forget_types (work);
                }
                }
            success = demangle_args (work, mangled, declp);
            success = demangle_args (work, mangled, declp);
            /* Since template include the mangling of their return types,
            /* Since template include the mangling of their return types,
               we must set expect_func to 0 so that we don't try do
               we must set expect_func to 0 so that we don't try do
               demangle more arguments the next time we get here.  */
               demangle more arguments the next time we get here.  */
            expect_func = 0;
            expect_func = 0;
          }
          }
      }
      }
    }
    }
  if (success && !func_done)
  if (success && !func_done)
    {
    {
      if (AUTO_DEMANGLING || GNU_DEMANGLING)
      if (AUTO_DEMANGLING || GNU_DEMANGLING)
        {
        {
          /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
          /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
             bar__3fooi is 'foo::bar(int)'.  We get here when we find the
             bar__3fooi is 'foo::bar(int)'.  We get here when we find the
             first case, and need to ensure that the '(void)' gets added to
             first case, and need to ensure that the '(void)' gets added to
             the current declp.  Note that with ARM/HP, the first case
             the current declp.  Note that with ARM/HP, the first case
             represents the name of a static data member 'foo::bar',
             represents the name of a static data member 'foo::bar',
             which is in the current declp, so we leave it alone.  */
             which is in the current declp, so we leave it alone.  */
          success = demangle_args (work, mangled, declp);
          success = demangle_args (work, mangled, declp);
        }
        }
    }
    }
  if (success && PRINT_ARG_TYPES)
  if (success && PRINT_ARG_TYPES)
    {
    {
      if (work->static_type)
      if (work->static_type)
        string_append (declp, " static");
        string_append (declp, " static");
      if (work->type_quals != TYPE_UNQUALIFIED)
      if (work->type_quals != TYPE_UNQUALIFIED)
        {
        {
          APPEND_BLANK (declp);
          APPEND_BLANK (declp);
          string_append (declp, qualifier_string (work->type_quals));
          string_append (declp, qualifier_string (work->type_quals));
        }
        }
    }
    }
 
 
  return (success);
  return (success);
}
}
 
 
#if 0
#if 0
 
 
static int
static int
demangle_method_args (struct work_stuff *work, const char **mangled,
demangle_method_args (struct work_stuff *work, const char **mangled,
                      string *declp)
                      string *declp)
{
{
  int success = 0;
  int success = 0;
 
 
  if (work -> static_type)
  if (work -> static_type)
    {
    {
      string_append (declp, *mangled + 1);
      string_append (declp, *mangled + 1);
      *mangled += strlen (*mangled);
      *mangled += strlen (*mangled);
      success = 1;
      success = 1;
    }
    }
  else
  else
    {
    {
      success = demangle_args (work, mangled, declp);
      success = demangle_args (work, mangled, declp);
    }
    }
  return (success);
  return (success);
}
}
 
 
#endif
#endif
 
 
static int
static int
demangle_template_template_parm (struct work_stuff *work,
demangle_template_template_parm (struct work_stuff *work,
                                 const char **mangled, string *tname)
                                 const char **mangled, string *tname)
{
{
  int i;
  int i;
  int r;
  int r;
  int need_comma = 0;
  int need_comma = 0;
  int success = 1;
  int success = 1;
  string temp;
  string temp;
 
 
  string_append (tname, "template <");
  string_append (tname, "template <");
  /* get size of template parameter list */
  /* get size of template parameter list */
  if (get_count (mangled, &r))
  if (get_count (mangled, &r))
    {
    {
      for (i = 0; i < r; i++)
      for (i = 0; i < r; i++)
        {
        {
          if (need_comma)
          if (need_comma)
            {
            {
              string_append (tname, ", ");
              string_append (tname, ", ");
            }
            }
 
 
            /* Z for type parameters */
            /* Z for type parameters */
            if (**mangled == 'Z')
            if (**mangled == 'Z')
              {
              {
                (*mangled)++;
                (*mangled)++;
                string_append (tname, "class");
                string_append (tname, "class");
              }
              }
              /* z for template parameters */
              /* z for template parameters */
            else if (**mangled == 'z')
            else if (**mangled == 'z')
              {
              {
                (*mangled)++;
                (*mangled)++;
                success =
                success =
                  demangle_template_template_parm (work, mangled, tname);
                  demangle_template_template_parm (work, mangled, tname);
                if (!success)
                if (!success)
                  {
                  {
                    break;
                    break;
                  }
                  }
              }
              }
            else
            else
              {
              {
                /* temp is initialized in do_type */
                /* temp is initialized in do_type */
                success = do_type (work, mangled, &temp);
                success = do_type (work, mangled, &temp);
                if (success)
                if (success)
                  {
                  {
                    string_appends (tname, &temp);
                    string_appends (tname, &temp);
                  }
                  }
                string_delete(&temp);
                string_delete(&temp);
                if (!success)
                if (!success)
                  {
                  {
                    break;
                    break;
                  }
                  }
              }
              }
          need_comma = 1;
          need_comma = 1;
        }
        }
 
 
    }
    }
  if (tname->p[-1] == '>')
  if (tname->p[-1] == '>')
    string_append (tname, " ");
    string_append (tname, " ");
  string_append (tname, "> class");
  string_append (tname, "> class");
  return (success);
  return (success);
}
}
 
 
static int
static int
demangle_expression (struct work_stuff *work, const char **mangled,
demangle_expression (struct work_stuff *work, const char **mangled,
                     string *s, type_kind_t tk)
                     string *s, type_kind_t tk)
{
{
  int need_operator = 0;
  int need_operator = 0;
  int success;
  int success;
 
 
  success = 1;
  success = 1;
  string_appendn (s, "(", 1);
  string_appendn (s, "(", 1);
  (*mangled)++;
  (*mangled)++;
  while (success && **mangled != 'W' && **mangled != '\0')
  while (success && **mangled != 'W' && **mangled != '\0')
    {
    {
      if (need_operator)
      if (need_operator)
        {
        {
          size_t i;
          size_t i;
          size_t len;
          size_t len;
 
 
          success = 0;
          success = 0;
 
 
          len = strlen (*mangled);
          len = strlen (*mangled);
 
 
          for (i = 0; i < ARRAY_SIZE (optable); ++i)
          for (i = 0; i < ARRAY_SIZE (optable); ++i)
            {
            {
              size_t l = strlen (optable[i].in);
              size_t l = strlen (optable[i].in);
 
 
              if (l <= len
              if (l <= len
                  && memcmp (optable[i].in, *mangled, l) == 0)
                  && memcmp (optable[i].in, *mangled, l) == 0)
                {
                {
                  string_appendn (s, " ", 1);
                  string_appendn (s, " ", 1);
                  string_append (s, optable[i].out);
                  string_append (s, optable[i].out);
                  string_appendn (s, " ", 1);
                  string_appendn (s, " ", 1);
                  success = 1;
                  success = 1;
                  (*mangled) += l;
                  (*mangled) += l;
                  break;
                  break;
                }
                }
            }
            }
 
 
          if (!success)
          if (!success)
            break;
            break;
        }
        }
      else
      else
        need_operator = 1;
        need_operator = 1;
 
 
      success = demangle_template_value_parm (work, mangled, s, tk);
      success = demangle_template_value_parm (work, mangled, s, tk);
    }
    }
 
 
  if (**mangled != 'W')
  if (**mangled != 'W')
    success = 0;
    success = 0;
  else
  else
    {
    {
      string_appendn (s, ")", 1);
      string_appendn (s, ")", 1);
      (*mangled)++;
      (*mangled)++;
    }
    }
 
 
  return success;
  return success;
}
}
 
 
static int
static int
demangle_integral_value (struct work_stuff *work,
demangle_integral_value (struct work_stuff *work,
                         const char **mangled, string *s)
                         const char **mangled, string *s)
{
{
  int success;
  int success;
 
 
  if (**mangled == 'E')
  if (**mangled == 'E')
    success = demangle_expression (work, mangled, s, tk_integral);
    success = demangle_expression (work, mangled, s, tk_integral);
  else if (**mangled == 'Q' || **mangled == 'K')
  else if (**mangled == 'Q' || **mangled == 'K')
    success = demangle_qualified (work, mangled, s, 0, 1);
    success = demangle_qualified (work, mangled, s, 0, 1);
  else
  else
    {
    {
      int value;
      int value;
 
 
      /* By default, we let the number decide whether we shall consume an
      /* By default, we let the number decide whether we shall consume an
         underscore.  */
         underscore.  */
      int multidigit_without_leading_underscore = 0;
      int multidigit_without_leading_underscore = 0;
      int leave_following_underscore = 0;
      int leave_following_underscore = 0;
 
 
      success = 0;
      success = 0;
 
 
      if (**mangled == '_')
      if (**mangled == '_')
        {
        {
          if (mangled[0][1] == 'm')
          if (mangled[0][1] == 'm')
            {
            {
              /* Since consume_count_with_underscores does not handle the
              /* Since consume_count_with_underscores does not handle the
                 `m'-prefix we must do it here, using consume_count and
                 `m'-prefix we must do it here, using consume_count and
                 adjusting underscores: we have to consume the underscore
                 adjusting underscores: we have to consume the underscore
                 matching the prepended one.  */
                 matching the prepended one.  */
              multidigit_without_leading_underscore = 1;
              multidigit_without_leading_underscore = 1;
              string_appendn (s, "-", 1);
              string_appendn (s, "-", 1);
              (*mangled) += 2;
              (*mangled) += 2;
            }
            }
          else
          else
            {
            {
              /* Do not consume a following underscore;
              /* Do not consume a following underscore;
                 consume_count_with_underscores will consume what
                 consume_count_with_underscores will consume what
                 should be consumed.  */
                 should be consumed.  */
              leave_following_underscore = 1;
              leave_following_underscore = 1;
            }
            }
        }
        }
      else
      else
        {
        {
          /* Negative numbers are indicated with a leading `m'.  */
          /* Negative numbers are indicated with a leading `m'.  */
          if (**mangled == 'm')
          if (**mangled == 'm')
          {
          {
            string_appendn (s, "-", 1);
            string_appendn (s, "-", 1);
            (*mangled)++;
            (*mangled)++;
          }
          }
          /* Since consume_count_with_underscores does not handle
          /* Since consume_count_with_underscores does not handle
             multi-digit numbers that do not start with an underscore,
             multi-digit numbers that do not start with an underscore,
             and this number can be an integer template parameter,
             and this number can be an integer template parameter,
             we have to call consume_count. */
             we have to call consume_count. */
          multidigit_without_leading_underscore = 1;
          multidigit_without_leading_underscore = 1;
          /* These multi-digit numbers never end on an underscore,
          /* These multi-digit numbers never end on an underscore,
             so if there is one then don't eat it. */
             so if there is one then don't eat it. */
          leave_following_underscore = 1;
          leave_following_underscore = 1;
        }
        }
 
 
      /* We must call consume_count if we expect to remove a trailing
      /* We must call consume_count if we expect to remove a trailing
         underscore, since consume_count_with_underscores expects
         underscore, since consume_count_with_underscores expects
         the leading underscore (that we consumed) if it is to handle
         the leading underscore (that we consumed) if it is to handle
         multi-digit numbers.  */
         multi-digit numbers.  */
      if (multidigit_without_leading_underscore)
      if (multidigit_without_leading_underscore)
        value = consume_count (mangled);
        value = consume_count (mangled);
      else
      else
        value = consume_count_with_underscores (mangled);
        value = consume_count_with_underscores (mangled);
 
 
      if (value != -1)
      if (value != -1)
        {
        {
          char buf[INTBUF_SIZE];
          char buf[INTBUF_SIZE];
          sprintf (buf, "%d", value);
          sprintf (buf, "%d", value);
          string_append (s, buf);
          string_append (s, buf);
 
 
          /* Numbers not otherwise delimited, might have an underscore
          /* Numbers not otherwise delimited, might have an underscore
             appended as a delimeter, which we should skip.
             appended as a delimeter, which we should skip.
 
 
             ??? This used to always remove a following underscore, which
             ??? This used to always remove a following underscore, which
             is wrong.  If other (arbitrary) cases are followed by an
             is wrong.  If other (arbitrary) cases are followed by an
             underscore, we need to do something more radical.  */
             underscore, we need to do something more radical.  */
 
 
          if ((value > 9 || multidigit_without_leading_underscore)
          if ((value > 9 || multidigit_without_leading_underscore)
              && ! leave_following_underscore
              && ! leave_following_underscore
              && **mangled == '_')
              && **mangled == '_')
            (*mangled)++;
            (*mangled)++;
 
 
          /* All is well.  */
          /* All is well.  */
          success = 1;
          success = 1;
        }
        }
      }
      }
 
 
  return success;
  return success;
}
}
 
 
/* Demangle the real value in MANGLED.  */
/* Demangle the real value in MANGLED.  */
 
 
static int
static int
demangle_real_value (struct work_stuff *work,
demangle_real_value (struct work_stuff *work,
                     const char **mangled, string *s)
                     const char **mangled, string *s)
{
{
  if (**mangled == 'E')
  if (**mangled == 'E')
    return demangle_expression (work, mangled, s, tk_real);
    return demangle_expression (work, mangled, s, tk_real);
 
 
  if (**mangled == 'm')
  if (**mangled == 'm')
    {
    {
      string_appendn (s, "-", 1);
      string_appendn (s, "-", 1);
      (*mangled)++;
      (*mangled)++;
    }
    }
  while (ISDIGIT ((unsigned char)**mangled))
  while (ISDIGIT ((unsigned char)**mangled))
    {
    {
      string_appendn (s, *mangled, 1);
      string_appendn (s, *mangled, 1);
      (*mangled)++;
      (*mangled)++;
    }
    }
  if (**mangled == '.') /* fraction */
  if (**mangled == '.') /* fraction */
    {
    {
      string_appendn (s, ".", 1);
      string_appendn (s, ".", 1);
      (*mangled)++;
      (*mangled)++;
      while (ISDIGIT ((unsigned char)**mangled))
      while (ISDIGIT ((unsigned char)**mangled))
        {
        {
          string_appendn (s, *mangled, 1);
          string_appendn (s, *mangled, 1);
          (*mangled)++;
          (*mangled)++;
        }
        }
    }
    }
  if (**mangled == 'e') /* exponent */
  if (**mangled == 'e') /* exponent */
    {
    {
      string_appendn (s, "e", 1);
      string_appendn (s, "e", 1);
      (*mangled)++;
      (*mangled)++;
      while (ISDIGIT ((unsigned char)**mangled))
      while (ISDIGIT ((unsigned char)**mangled))
        {
        {
          string_appendn (s, *mangled, 1);
          string_appendn (s, *mangled, 1);
          (*mangled)++;
          (*mangled)++;
        }
        }
    }
    }
 
 
  return 1;
  return 1;
}
}
 
 
static int
static int
demangle_template_value_parm (struct work_stuff *work, const char **mangled,
demangle_template_value_parm (struct work_stuff *work, const char **mangled,
                              string *s, type_kind_t tk)
                              string *s, type_kind_t tk)
{
{
  int success = 1;
  int success = 1;
 
 
  if (**mangled == 'Y')
  if (**mangled == 'Y')
    {
    {
      /* The next argument is a template parameter. */
      /* The next argument is a template parameter. */
      int idx;
      int idx;
 
 
      (*mangled)++;
      (*mangled)++;
      idx = consume_count_with_underscores (mangled);
      idx = consume_count_with_underscores (mangled);
      if (idx == -1
      if (idx == -1
          || (work->tmpl_argvec && idx >= work->ntmpl_args)
          || (work->tmpl_argvec && idx >= work->ntmpl_args)
          || consume_count_with_underscores (mangled) == -1)
          || consume_count_with_underscores (mangled) == -1)
        return -1;
        return -1;
      if (work->tmpl_argvec)
      if (work->tmpl_argvec)
        string_append (s, work->tmpl_argvec[idx]);
        string_append (s, work->tmpl_argvec[idx]);
      else
      else
        string_append_template_idx (s, idx);
        string_append_template_idx (s, idx);
    }
    }
  else if (tk == tk_integral)
  else if (tk == tk_integral)
    success = demangle_integral_value (work, mangled, s);
    success = demangle_integral_value (work, mangled, s);
  else if (tk == tk_char)
  else if (tk == tk_char)
    {
    {
      char tmp[2];
      char tmp[2];
      int val;
      int val;
      if (**mangled == 'm')
      if (**mangled == 'm')
        {
        {
          string_appendn (s, "-", 1);
          string_appendn (s, "-", 1);
          (*mangled)++;
          (*mangled)++;
        }
        }
      string_appendn (s, "'", 1);
      string_appendn (s, "'", 1);
      val = consume_count(mangled);
      val = consume_count(mangled);
      if (val <= 0)
      if (val <= 0)
        success = 0;
        success = 0;
      else
      else
        {
        {
          tmp[0] = (char)val;
          tmp[0] = (char)val;
          tmp[1] = '\0';
          tmp[1] = '\0';
          string_appendn (s, &tmp[0], 1);
          string_appendn (s, &tmp[0], 1);
          string_appendn (s, "'", 1);
          string_appendn (s, "'", 1);
        }
        }
    }
    }
  else if (tk == tk_bool)
  else if (tk == tk_bool)
    {
    {
      int val = consume_count (mangled);
      int val = consume_count (mangled);
      if (val == 0)
      if (val == 0)
        string_appendn (s, "false", 5);
        string_appendn (s, "false", 5);
      else if (val == 1)
      else if (val == 1)
        string_appendn (s, "true", 4);
        string_appendn (s, "true", 4);
      else
      else
        success = 0;
        success = 0;
    }
    }
  else if (tk == tk_real)
  else if (tk == tk_real)
    success = demangle_real_value (work, mangled, s);
    success = demangle_real_value (work, mangled, s);
  else if (tk == tk_pointer || tk == tk_reference)
  else if (tk == tk_pointer || tk == tk_reference)
    {
    {
      if (**mangled == 'Q')
      if (**mangled == 'Q')
        success = demangle_qualified (work, mangled, s,
        success = demangle_qualified (work, mangled, s,
                                      /*isfuncname=*/0,
                                      /*isfuncname=*/0,
                                      /*append=*/1);
                                      /*append=*/1);
      else
      else
        {
        {
          int symbol_len  = consume_count (mangled);
          int symbol_len  = consume_count (mangled);
          if (symbol_len == -1)
          if (symbol_len == -1)
            return -1;
            return -1;
          if (symbol_len == 0)
          if (symbol_len == 0)
            string_appendn (s, "0", 1);
            string_appendn (s, "0", 1);
          else
          else
            {
            {
              char *p = XNEWVEC (char, symbol_len + 1), *q;
              char *p = XNEWVEC (char, symbol_len + 1), *q;
              strncpy (p, *mangled, symbol_len);
              strncpy (p, *mangled, symbol_len);
              p [symbol_len] = '\0';
              p [symbol_len] = '\0';
              /* We use cplus_demangle here, rather than
              /* We use cplus_demangle here, rather than
                 internal_cplus_demangle, because the name of the entity
                 internal_cplus_demangle, because the name of the entity
                 mangled here does not make use of any of the squangling
                 mangled here does not make use of any of the squangling
                 or type-code information we have built up thus far; it is
                 or type-code information we have built up thus far; it is
                 mangled independently.  */
                 mangled independently.  */
              q = cplus_demangle (p, work->options);
              q = cplus_demangle (p, work->options);
              if (tk == tk_pointer)
              if (tk == tk_pointer)
                string_appendn (s, "&", 1);
                string_appendn (s, "&", 1);
              /* FIXME: Pointer-to-member constants should get a
              /* FIXME: Pointer-to-member constants should get a
                 qualifying class name here.  */
                 qualifying class name here.  */
              if (q)
              if (q)
                {
                {
                  string_append (s, q);
                  string_append (s, q);
                  free (q);
                  free (q);
                }
                }
              else
              else
                string_append (s, p);
                string_append (s, p);
              free (p);
              free (p);
            }
            }
          *mangled += symbol_len;
          *mangled += symbol_len;
        }
        }
    }
    }
 
 
  return success;
  return success;
}
}
 
 
/* Demangle the template name in MANGLED.  The full name of the
/* Demangle the template name in MANGLED.  The full name of the
   template (e.g., S<int>) is placed in TNAME.  The name without the
   template (e.g., S<int>) is placed in TNAME.  The name without the
   template parameters (e.g. S) is placed in TRAWNAME if TRAWNAME is
   template parameters (e.g. S) is placed in TRAWNAME if TRAWNAME is
   non-NULL.  If IS_TYPE is nonzero, this template is a type template,
   non-NULL.  If IS_TYPE is nonzero, this template is a type template,
   not a function template.  If both IS_TYPE and REMEMBER are nonzero,
   not a function template.  If both IS_TYPE and REMEMBER are nonzero,
   the template is remembered in the list of back-referenceable
   the template is remembered in the list of back-referenceable
   types.  */
   types.  */
 
 
static int
static int
demangle_template (struct work_stuff *work, const char **mangled,
demangle_template (struct work_stuff *work, const char **mangled,
                   string *tname, string *trawname,
                   string *tname, string *trawname,
                   int is_type, int remember)
                   int is_type, int remember)
{
{
  int i;
  int i;
  int r;
  int r;
  int need_comma = 0;
  int need_comma = 0;
  int success = 0;
  int success = 0;
  int is_java_array = 0;
  int is_java_array = 0;
  string temp;
  string temp;
 
 
  (*mangled)++;
  (*mangled)++;
  if (is_type)
  if (is_type)
    {
    {
      /* get template name */
      /* get template name */
      if (**mangled == 'z')
      if (**mangled == 'z')
        {
        {
          int idx;
          int idx;
          (*mangled)++;
          (*mangled)++;
          (*mangled)++;
          (*mangled)++;
 
 
          idx = consume_count_with_underscores (mangled);
          idx = consume_count_with_underscores (mangled);
          if (idx == -1
          if (idx == -1
              || (work->tmpl_argvec && idx >= work->ntmpl_args)
              || (work->tmpl_argvec && idx >= work->ntmpl_args)
              || consume_count_with_underscores (mangled) == -1)
              || consume_count_with_underscores (mangled) == -1)
            return (0);
            return (0);
 
 
          if (work->tmpl_argvec)
          if (work->tmpl_argvec)
            {
            {
              string_append (tname, work->tmpl_argvec[idx]);
              string_append (tname, work->tmpl_argvec[idx]);
              if (trawname)
              if (trawname)
                string_append (trawname, work->tmpl_argvec[idx]);
                string_append (trawname, work->tmpl_argvec[idx]);
            }
            }
          else
          else
            {
            {
              string_append_template_idx (tname, idx);
              string_append_template_idx (tname, idx);
              if (trawname)
              if (trawname)
                string_append_template_idx (trawname, idx);
                string_append_template_idx (trawname, idx);
            }
            }
        }
        }
      else
      else
        {
        {
          if ((r = consume_count (mangled)) <= 0
          if ((r = consume_count (mangled)) <= 0
              || (int) strlen (*mangled) < r)
              || (int) strlen (*mangled) < r)
            {
            {
              return (0);
              return (0);
            }
            }
          is_java_array = (work -> options & DMGL_JAVA)
          is_java_array = (work -> options & DMGL_JAVA)
            && strncmp (*mangled, "JArray1Z", 8) == 0;
            && strncmp (*mangled, "JArray1Z", 8) == 0;
          if (! is_java_array)
          if (! is_java_array)
            {
            {
              string_appendn (tname, *mangled, r);
              string_appendn (tname, *mangled, r);
            }
            }
          if (trawname)
          if (trawname)
            string_appendn (trawname, *mangled, r);
            string_appendn (trawname, *mangled, r);
          *mangled += r;
          *mangled += r;
        }
        }
    }
    }
  if (!is_java_array)
  if (!is_java_array)
    string_append (tname, "<");
    string_append (tname, "<");
  /* get size of template parameter list */
  /* get size of template parameter list */
  if (!get_count (mangled, &r))
  if (!get_count (mangled, &r))
    {
    {
      return (0);
      return (0);
    }
    }
  if (!is_type)
  if (!is_type)
    {
    {
      /* Create an array for saving the template argument values. */
      /* Create an array for saving the template argument values. */
      work->tmpl_argvec = XNEWVEC (char *, r);
      work->tmpl_argvec = XNEWVEC (char *, r);
      work->ntmpl_args = r;
      work->ntmpl_args = r;
      for (i = 0; i < r; i++)
      for (i = 0; i < r; i++)
        work->tmpl_argvec[i] = 0;
        work->tmpl_argvec[i] = 0;
    }
    }
  for (i = 0; i < r; i++)
  for (i = 0; i < r; i++)
    {
    {
      if (need_comma)
      if (need_comma)
        {
        {
          string_append (tname, ", ");
          string_append (tname, ", ");
        }
        }
      /* Z for type parameters */
      /* Z for type parameters */
      if (**mangled == 'Z')
      if (**mangled == 'Z')
        {
        {
          (*mangled)++;
          (*mangled)++;
          /* temp is initialized in do_type */
          /* temp is initialized in do_type */
          success = do_type (work, mangled, &temp);
          success = do_type (work, mangled, &temp);
          if (success)
          if (success)
            {
            {
              string_appends (tname, &temp);
              string_appends (tname, &temp);
 
 
              if (!is_type)
              if (!is_type)
                {
                {
                  /* Save the template argument. */
                  /* Save the template argument. */
                  int len = temp.p - temp.b;
                  int len = temp.p - temp.b;
                  work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
                  work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
                  memcpy (work->tmpl_argvec[i], temp.b, len);
                  memcpy (work->tmpl_argvec[i], temp.b, len);
                  work->tmpl_argvec[i][len] = '\0';
                  work->tmpl_argvec[i][len] = '\0';
                }
                }
            }
            }
          string_delete(&temp);
          string_delete(&temp);
          if (!success)
          if (!success)
            {
            {
              break;
              break;
            }
            }
        }
        }
      /* z for template parameters */
      /* z for template parameters */
      else if (**mangled == 'z')
      else if (**mangled == 'z')
        {
        {
          int r2;
          int r2;
          (*mangled)++;
          (*mangled)++;
          success = demangle_template_template_parm (work, mangled, tname);
          success = demangle_template_template_parm (work, mangled, tname);
 
 
          if (success
          if (success
              && (r2 = consume_count (mangled)) > 0
              && (r2 = consume_count (mangled)) > 0
              && (int) strlen (*mangled) >= r2)
              && (int) strlen (*mangled) >= r2)
            {
            {
              string_append (tname, " ");
              string_append (tname, " ");
              string_appendn (tname, *mangled, r2);
              string_appendn (tname, *mangled, r2);
              if (!is_type)
              if (!is_type)
                {
                {
                  /* Save the template argument. */
                  /* Save the template argument. */
                  int len = r2;
                  int len = r2;
                  work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
                  work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
                  memcpy (work->tmpl_argvec[i], *mangled, len);
                  memcpy (work->tmpl_argvec[i], *mangled, len);
                  work->tmpl_argvec[i][len] = '\0';
                  work->tmpl_argvec[i][len] = '\0';
                }
                }
              *mangled += r2;
              *mangled += r2;
            }
            }
          if (!success)
          if (!success)
            {
            {
              break;
              break;
            }
            }
        }
        }
      else
      else
        {
        {
          string  param;
          string  param;
          string* s;
          string* s;
 
 
          /* otherwise, value parameter */
          /* otherwise, value parameter */
 
 
          /* temp is initialized in do_type */
          /* temp is initialized in do_type */
          success = do_type (work, mangled, &temp);
          success = do_type (work, mangled, &temp);
          string_delete(&temp);
          string_delete(&temp);
          if (!success)
          if (!success)
            break;
            break;
 
 
          if (!is_type)
          if (!is_type)
            {
            {
              s = &param;
              s = &param;
              string_init (s);
              string_init (s);
            }
            }
          else
          else
            s = tname;
            s = tname;
 
 
          success = demangle_template_value_parm (work, mangled, s,
          success = demangle_template_value_parm (work, mangled, s,
                                                  (type_kind_t) success);
                                                  (type_kind_t) success);
 
 
          if (!success)
          if (!success)
            {
            {
              if (!is_type)
              if (!is_type)
                string_delete (s);
                string_delete (s);
              success = 0;
              success = 0;
              break;
              break;
            }
            }
 
 
          if (!is_type)
          if (!is_type)
            {
            {
              int len = s->p - s->b;
              int len = s->p - s->b;
              work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
              work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
              memcpy (work->tmpl_argvec[i], s->b, len);
              memcpy (work->tmpl_argvec[i], s->b, len);
              work->tmpl_argvec[i][len] = '\0';
              work->tmpl_argvec[i][len] = '\0';
 
 
              string_appends (tname, s);
              string_appends (tname, s);
              string_delete (s);
              string_delete (s);
            }
            }
        }
        }
      need_comma = 1;
      need_comma = 1;
    }
    }
  if (is_java_array)
  if (is_java_array)
    {
    {
      string_append (tname, "[]");
      string_append (tname, "[]");
    }
    }
  else
  else
    {
    {
      if (tname->p[-1] == '>')
      if (tname->p[-1] == '>')
        string_append (tname, " ");
        string_append (tname, " ");
      string_append (tname, ">");
      string_append (tname, ">");
    }
    }
 
 
  if (is_type && remember)
  if (is_type && remember)
    {
    {
      const int bindex = register_Btype (work);
      const int bindex = register_Btype (work);
      remember_Btype (work, tname->b, LEN_STRING (tname), bindex);
      remember_Btype (work, tname->b, LEN_STRING (tname), bindex);
    }
    }
 
 
  /*
  /*
    if (work -> static_type)
    if (work -> static_type)
    {
    {
    string_append (declp, *mangled + 1);
    string_append (declp, *mangled + 1);
    *mangled += strlen (*mangled);
    *mangled += strlen (*mangled);
    success = 1;
    success = 1;
    }
    }
    else
    else
    {
    {
    success = demangle_args (work, mangled, declp);
    success = demangle_args (work, mangled, declp);
    }
    }
    }
    }
    */
    */
  return (success);
  return (success);
}
}
 
 
static int
static int
arm_pt (struct work_stuff *work, const char *mangled,
arm_pt (struct work_stuff *work, const char *mangled,
        int n, const char **anchor, const char **args)
        int n, const char **anchor, const char **args)
{
{
  /* Check if ARM template with "__pt__" in it ("parameterized type") */
  /* Check if ARM template with "__pt__" in it ("parameterized type") */
  /* Allow HP also here, because HP's cfront compiler follows ARM to some extent */
  /* Allow HP also here, because HP's cfront compiler follows ARM to some extent */
  if ((ARM_DEMANGLING || HP_DEMANGLING) && (*anchor = strstr (mangled, "__pt__")))
  if ((ARM_DEMANGLING || HP_DEMANGLING) && (*anchor = strstr (mangled, "__pt__")))
    {
    {
      int len;
      int len;
      *args = *anchor + 6;
      *args = *anchor + 6;
      len = consume_count (args);
      len = consume_count (args);
      if (len == -1)
      if (len == -1)
        return 0;
        return 0;
      if (*args + len == mangled + n && **args == '_')
      if (*args + len == mangled + n && **args == '_')
        {
        {
          ++*args;
          ++*args;
          return 1;
          return 1;
        }
        }
    }
    }
  if (AUTO_DEMANGLING || EDG_DEMANGLING)
  if (AUTO_DEMANGLING || EDG_DEMANGLING)
    {
    {
      if ((*anchor = strstr (mangled, "__tm__"))
      if ((*anchor = strstr (mangled, "__tm__"))
          || (*anchor = strstr (mangled, "__ps__"))
          || (*anchor = strstr (mangled, "__ps__"))
          || (*anchor = strstr (mangled, "__pt__")))
          || (*anchor = strstr (mangled, "__pt__")))
        {
        {
          int len;
          int len;
          *args = *anchor + 6;
          *args = *anchor + 6;
          len = consume_count (args);
          len = consume_count (args);
          if (len == -1)
          if (len == -1)
            return 0;
            return 0;
          if (*args + len == mangled + n && **args == '_')
          if (*args + len == mangled + n && **args == '_')
            {
            {
              ++*args;
              ++*args;
              return 1;
              return 1;
            }
            }
        }
        }
      else if ((*anchor = strstr (mangled, "__S")))
      else if ((*anchor = strstr (mangled, "__S")))
        {
        {
          int len;
          int len;
          *args = *anchor + 3;
          *args = *anchor + 3;
          len = consume_count (args);
          len = consume_count (args);
          if (len == -1)
          if (len == -1)
            return 0;
            return 0;
          if (*args + len == mangled + n && **args == '_')
          if (*args + len == mangled + n && **args == '_')
            {
            {
              ++*args;
              ++*args;
              return 1;
              return 1;
            }
            }
        }
        }
    }
    }
 
 
  return 0;
  return 0;
}
}
 
 
static void
static void
demangle_arm_hp_template (struct work_stuff *work, const char **mangled,
demangle_arm_hp_template (struct work_stuff *work, const char **mangled,
                          int n, string *declp)
                          int n, string *declp)
{
{
  const char *p;
  const char *p;
  const char *args;
  const char *args;
  const char *e = *mangled + n;
  const char *e = *mangled + n;
  string arg;
  string arg;
 
 
  /* Check for HP aCC template spec: classXt1t2 where t1, t2 are
  /* Check for HP aCC template spec: classXt1t2 where t1, t2 are
     template args */
     template args */
  if (HP_DEMANGLING && ((*mangled)[n] == 'X'))
  if (HP_DEMANGLING && ((*mangled)[n] == 'X'))
    {
    {
      char *start_spec_args = NULL;
      char *start_spec_args = NULL;
      int hold_options;
      int hold_options;
 
 
      /* First check for and omit template specialization pseudo-arguments,
      /* First check for and omit template specialization pseudo-arguments,
         such as in "Spec<#1,#1.*>" */
         such as in "Spec<#1,#1.*>" */
      start_spec_args = strchr (*mangled, '<');
      start_spec_args = strchr (*mangled, '<');
      if (start_spec_args && (start_spec_args - *mangled < n))
      if (start_spec_args && (start_spec_args - *mangled < n))
        string_appendn (declp, *mangled, start_spec_args - *mangled);
        string_appendn (declp, *mangled, start_spec_args - *mangled);
      else
      else
        string_appendn (declp, *mangled, n);
        string_appendn (declp, *mangled, n);
      (*mangled) += n + 1;
      (*mangled) += n + 1;
      string_init (&arg);
      string_init (&arg);
      if (work->temp_start == -1) /* non-recursive call */
      if (work->temp_start == -1) /* non-recursive call */
        work->temp_start = declp->p - declp->b;
        work->temp_start = declp->p - declp->b;
 
 
      /* We want to unconditionally demangle parameter types in
      /* We want to unconditionally demangle parameter types in
         template parameters.  */
         template parameters.  */
      hold_options = work->options;
      hold_options = work->options;
      work->options |= DMGL_PARAMS;
      work->options |= DMGL_PARAMS;
 
 
      string_append (declp, "<");
      string_append (declp, "<");
      while (1)
      while (1)
        {
        {
          string_delete (&arg);
          string_delete (&arg);
          switch (**mangled)
          switch (**mangled)
            {
            {
              case 'T':
              case 'T':
                /* 'T' signals a type parameter */
                /* 'T' signals a type parameter */
                (*mangled)++;
                (*mangled)++;
                if (!do_type (work, mangled, &arg))
                if (!do_type (work, mangled, &arg))
                  goto hpacc_template_args_done;
                  goto hpacc_template_args_done;
                break;
                break;
 
 
              case 'U':
              case 'U':
              case 'S':
              case 'S':
                /* 'U' or 'S' signals an integral value */
                /* 'U' or 'S' signals an integral value */
                if (!do_hpacc_template_const_value (work, mangled, &arg))
                if (!do_hpacc_template_const_value (work, mangled, &arg))
                  goto hpacc_template_args_done;
                  goto hpacc_template_args_done;
                break;
                break;
 
 
              case 'A':
              case 'A':
                /* 'A' signals a named constant expression (literal) */
                /* 'A' signals a named constant expression (literal) */
                if (!do_hpacc_template_literal (work, mangled, &arg))
                if (!do_hpacc_template_literal (work, mangled, &arg))
                  goto hpacc_template_args_done;
                  goto hpacc_template_args_done;
                break;
                break;
 
 
              default:
              default:
                /* Today, 1997-09-03, we have only the above types
                /* Today, 1997-09-03, we have only the above types
                   of template parameters */
                   of template parameters */
                /* FIXME: maybe this should fail and return null */
                /* FIXME: maybe this should fail and return null */
                goto hpacc_template_args_done;
                goto hpacc_template_args_done;
            }
            }
          string_appends (declp, &arg);
          string_appends (declp, &arg);
         /* Check if we're at the end of template args.
         /* Check if we're at the end of template args.
             0 if at end of static member of template class,
             0 if at end of static member of template class,
             _ if done with template args for a function */
             _ if done with template args for a function */
          if ((**mangled == '\000') || (**mangled == '_'))
          if ((**mangled == '\000') || (**mangled == '_'))
            break;
            break;
          else
          else
            string_append (declp, ",");
            string_append (declp, ",");
        }
        }
    hpacc_template_args_done:
    hpacc_template_args_done:
      string_append (declp, ">");
      string_append (declp, ">");
      string_delete (&arg);
      string_delete (&arg);
      if (**mangled == '_')
      if (**mangled == '_')
        (*mangled)++;
        (*mangled)++;
      work->options = hold_options;
      work->options = hold_options;
      return;
      return;
    }
    }
  /* ARM template? (Also handles HP cfront extensions) */
  /* ARM template? (Also handles HP cfront extensions) */
  else if (arm_pt (work, *mangled, n, &p, &args))
  else if (arm_pt (work, *mangled, n, &p, &args))
    {
    {
      int hold_options;
      int hold_options;
      string type_str;
      string type_str;
 
 
      string_init (&arg);
      string_init (&arg);
      string_appendn (declp, *mangled, p - *mangled);
      string_appendn (declp, *mangled, p - *mangled);
      if (work->temp_start == -1)  /* non-recursive call */
      if (work->temp_start == -1)  /* non-recursive call */
        work->temp_start = declp->p - declp->b;
        work->temp_start = declp->p - declp->b;
 
 
      /* We want to unconditionally demangle parameter types in
      /* We want to unconditionally demangle parameter types in
         template parameters.  */
         template parameters.  */
      hold_options = work->options;
      hold_options = work->options;
      work->options |= DMGL_PARAMS;
      work->options |= DMGL_PARAMS;
 
 
      string_append (declp, "<");
      string_append (declp, "<");
      /* should do error checking here */
      /* should do error checking here */
      while (args < e) {
      while (args < e) {
        string_delete (&arg);
        string_delete (&arg);
 
 
        /* Check for type or literal here */
        /* Check for type or literal here */
        switch (*args)
        switch (*args)
          {
          {
            /* HP cfront extensions to ARM for template args */
            /* HP cfront extensions to ARM for template args */
            /* spec: Xt1Lv1 where t1 is a type, v1 is a literal value */
            /* spec: Xt1Lv1 where t1 is a type, v1 is a literal value */
            /* FIXME: We handle only numeric literals for HP cfront */
            /* FIXME: We handle only numeric literals for HP cfront */
          case 'X':
          case 'X':
            /* A typed constant value follows */
            /* A typed constant value follows */
            args++;
            args++;
            if (!do_type (work, &args, &type_str))
            if (!do_type (work, &args, &type_str))
              goto cfront_template_args_done;
              goto cfront_template_args_done;
            string_append (&arg, "(");
            string_append (&arg, "(");
            string_appends (&arg, &type_str);
            string_appends (&arg, &type_str);
            string_delete (&type_str);
            string_delete (&type_str);
            string_append (&arg, ")");
            string_append (&arg, ")");
            if (*args != 'L')
            if (*args != 'L')
              goto cfront_template_args_done;
              goto cfront_template_args_done;
            args++;
            args++;
            /* Now snarf a literal value following 'L' */
            /* Now snarf a literal value following 'L' */
            if (!snarf_numeric_literal (&args, &arg))
            if (!snarf_numeric_literal (&args, &arg))
              goto cfront_template_args_done;
              goto cfront_template_args_done;
            break;
            break;
 
 
          case 'L':
          case 'L':
            /* Snarf a literal following 'L' */
            /* Snarf a literal following 'L' */
            args++;
            args++;
            if (!snarf_numeric_literal (&args, &arg))
            if (!snarf_numeric_literal (&args, &arg))
              goto cfront_template_args_done;
              goto cfront_template_args_done;
            break;
            break;
          default:
          default:
            /* Not handling other HP cfront stuff */
            /* Not handling other HP cfront stuff */
            {
            {
              const char* old_args = args;
              const char* old_args = args;
              if (!do_type (work, &args, &arg))
              if (!do_type (work, &args, &arg))
                goto cfront_template_args_done;
                goto cfront_template_args_done;
 
 
              /* Fail if we didn't make any progress: prevent infinite loop. */
              /* Fail if we didn't make any progress: prevent infinite loop. */
              if (args == old_args)
              if (args == old_args)
                {
                {
                  work->options = hold_options;
                  work->options = hold_options;
                  return;
                  return;
                }
                }
            }
            }
          }
          }
        string_appends (declp, &arg);
        string_appends (declp, &arg);
        string_append (declp, ",");
        string_append (declp, ",");
      }
      }
    cfront_template_args_done:
    cfront_template_args_done:
      string_delete (&arg);
      string_delete (&arg);
      if (args >= e)
      if (args >= e)
        --declp->p; /* remove extra comma */
        --declp->p; /* remove extra comma */
      string_append (declp, ">");
      string_append (declp, ">");
      work->options = hold_options;
      work->options = hold_options;
    }
    }
  else if (n>10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
  else if (n>10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
           && (*mangled)[9] == 'N'
           && (*mangled)[9] == 'N'
           && (*mangled)[8] == (*mangled)[10]
           && (*mangled)[8] == (*mangled)[10]
           && strchr (cplus_markers, (*mangled)[8]))
           && strchr (cplus_markers, (*mangled)[8]))
    {
    {
      /* A member of the anonymous namespace.  */
      /* A member of the anonymous namespace.  */
      string_append (declp, "{anonymous}");
      string_append (declp, "{anonymous}");
    }
    }
  else
  else
    {
    {
      if (work->temp_start == -1) /* non-recursive call only */
      if (work->temp_start == -1) /* non-recursive call only */
        work->temp_start = 0;     /* disable in recursive calls */
        work->temp_start = 0;     /* disable in recursive calls */
      string_appendn (declp, *mangled, n);
      string_appendn (declp, *mangled, n);
    }
    }
  *mangled += n;
  *mangled += n;
}
}
 
 
/* Extract a class name, possibly a template with arguments, from the
/* Extract a class name, possibly a template with arguments, from the
   mangled string; qualifiers, local class indicators, etc. have
   mangled string; qualifiers, local class indicators, etc. have
   already been dealt with */
   already been dealt with */
 
 
static int
static int
demangle_class_name (struct work_stuff *work, const char **mangled,
demangle_class_name (struct work_stuff *work, const char **mangled,
                     string *declp)
                     string *declp)
{
{
  int n;
  int n;
  int success = 0;
  int success = 0;
 
 
  n = consume_count (mangled);
  n = consume_count (mangled);
  if (n == -1)
  if (n == -1)
    return 0;
    return 0;
  if ((int) strlen (*mangled) >= n)
  if ((int) strlen (*mangled) >= n)
    {
    {
      demangle_arm_hp_template (work, mangled, n, declp);
      demangle_arm_hp_template (work, mangled, n, declp);
      success = 1;
      success = 1;
    }
    }
 
 
  return (success);
  return (success);
}
}
 
 
/*
/*
 
 
LOCAL FUNCTION
LOCAL FUNCTION
 
 
        demangle_class -- demangle a mangled class sequence
        demangle_class -- demangle a mangled class sequence
 
 
SYNOPSIS
SYNOPSIS
 
 
        static int
        static int
        demangle_class (struct work_stuff *work, const char **mangled,
        demangle_class (struct work_stuff *work, const char **mangled,
                        strint *declp)
                        strint *declp)
 
 
DESCRIPTION
DESCRIPTION
 
 
        DECLP points to the buffer into which demangling is being done.
        DECLP points to the buffer into which demangling is being done.
 
 
        *MANGLED points to the current token to be demangled.  On input,
        *MANGLED points to the current token to be demangled.  On input,
        it points to a mangled class (I.E. "3foo", "13verylongclass", etc.)
        it points to a mangled class (I.E. "3foo", "13verylongclass", etc.)
        On exit, it points to the next token after the mangled class on
        On exit, it points to the next token after the mangled class on
        success, or the first unconsumed token on failure.
        success, or the first unconsumed token on failure.
 
 
        If the CONSTRUCTOR or DESTRUCTOR flags are set in WORK, then
        If the CONSTRUCTOR or DESTRUCTOR flags are set in WORK, then
        we are demangling a constructor or destructor.  In this case
        we are demangling a constructor or destructor.  In this case
        we prepend "class::class" or "class::~class" to DECLP.
        we prepend "class::class" or "class::~class" to DECLP.
 
 
        Otherwise, we prepend "class::" to the current DECLP.
        Otherwise, we prepend "class::" to the current DECLP.
 
 
        Reset the constructor/destructor flags once they have been
        Reset the constructor/destructor flags once they have been
        "consumed".  This allows demangle_class to be called later during
        "consumed".  This allows demangle_class to be called later during
        the same demangling, to do normal class demangling.
        the same demangling, to do normal class demangling.
 
 
        Returns 1 if demangling is successful, 0 otherwise.
        Returns 1 if demangling is successful, 0 otherwise.
 
 
*/
*/
 
 
static int
static int
demangle_class (struct work_stuff *work, const char **mangled, string *declp)
demangle_class (struct work_stuff *work, const char **mangled, string *declp)
{
{
  int success = 0;
  int success = 0;
  int btype;
  int btype;
  string class_name;
  string class_name;
  char *save_class_name_end = 0;
  char *save_class_name_end = 0;
 
 
  string_init (&class_name);
  string_init (&class_name);
  btype = register_Btype (work);
  btype = register_Btype (work);
  if (demangle_class_name (work, mangled, &class_name))
  if (demangle_class_name (work, mangled, &class_name))
    {
    {
      save_class_name_end = class_name.p;
      save_class_name_end = class_name.p;
      if ((work->constructor & 1) || (work->destructor & 1))
      if ((work->constructor & 1) || (work->destructor & 1))
        {
        {
          /* adjust so we don't include template args */
          /* adjust so we don't include template args */
          if (work->temp_start && (work->temp_start != -1))
          if (work->temp_start && (work->temp_start != -1))
            {
            {
              class_name.p = class_name.b + work->temp_start;
              class_name.p = class_name.b + work->temp_start;
            }
            }
          string_prepends (declp, &class_name);
          string_prepends (declp, &class_name);
          if (work -> destructor & 1)
          if (work -> destructor & 1)
            {
            {
              string_prepend (declp, "~");
              string_prepend (declp, "~");
              work -> destructor -= 1;
              work -> destructor -= 1;
            }
            }
          else
          else
            {
            {
              work -> constructor -= 1;
              work -> constructor -= 1;
            }
            }
        }
        }
      class_name.p = save_class_name_end;
      class_name.p = save_class_name_end;
      remember_Ktype (work, class_name.b, LEN_STRING(&class_name));
      remember_Ktype (work, class_name.b, LEN_STRING(&class_name));
      remember_Btype (work, class_name.b, LEN_STRING(&class_name), btype);
      remember_Btype (work, class_name.b, LEN_STRING(&class_name), btype);
      string_prepend (declp, SCOPE_STRING (work));
      string_prepend (declp, SCOPE_STRING (work));
      string_prepends (declp, &class_name);
      string_prepends (declp, &class_name);
      success = 1;
      success = 1;
    }
    }
  string_delete (&class_name);
  string_delete (&class_name);
  return (success);
  return (success);
}
}
 
 
 
 
/* Called when there's a "__" in the mangled name, with `scan' pointing to
/* Called when there's a "__" in the mangled name, with `scan' pointing to
   the rightmost guess.
   the rightmost guess.
 
 
   Find the correct "__"-sequence where the function name ends and the
   Find the correct "__"-sequence where the function name ends and the
   signature starts, which is ambiguous with GNU mangling.
   signature starts, which is ambiguous with GNU mangling.
   Call demangle_signature here, so we can make sure we found the right
   Call demangle_signature here, so we can make sure we found the right
   one; *mangled will be consumed so caller will not make further calls to
   one; *mangled will be consumed so caller will not make further calls to
   demangle_signature.  */
   demangle_signature.  */
 
 
static int
static int
iterate_demangle_function (struct work_stuff *work, const char **mangled,
iterate_demangle_function (struct work_stuff *work, const char **mangled,
                           string *declp, const char *scan)
                           string *declp, const char *scan)
{
{
  const char *mangle_init = *mangled;
  const char *mangle_init = *mangled;
  int success = 0;
  int success = 0;
  string decl_init;
  string decl_init;
  struct work_stuff work_init;
  struct work_stuff work_init;
 
 
  if (*(scan + 2) == '\0')
  if (*(scan + 2) == '\0')
    return 0;
    return 0;
 
 
  /* Do not iterate for some demangling modes, or if there's only one
  /* Do not iterate for some demangling modes, or if there's only one
     "__"-sequence.  This is the normal case.  */
     "__"-sequence.  This is the normal case.  */
  if (ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING
  if (ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING
      || strstr (scan + 2, "__") == NULL)
      || strstr (scan + 2, "__") == NULL)
    return demangle_function_name (work, mangled, declp, scan);
    return demangle_function_name (work, mangled, declp, scan);
 
 
  /* Save state so we can restart if the guess at the correct "__" was
  /* Save state so we can restart if the guess at the correct "__" was
     wrong.  */
     wrong.  */
  string_init (&decl_init);
  string_init (&decl_init);
  string_appends (&decl_init, declp);
  string_appends (&decl_init, declp);
  memset (&work_init, 0, sizeof work_init);
  memset (&work_init, 0, sizeof work_init);
  work_stuff_copy_to_from (&work_init, work);
  work_stuff_copy_to_from (&work_init, work);
 
 
  /* Iterate over occurrences of __, allowing names and types to have a
  /* Iterate over occurrences of __, allowing names and types to have a
     "__" sequence in them.  We must start with the first (not the last)
     "__" sequence in them.  We must start with the first (not the last)
     occurrence, since "__" most often occur between independent mangled
     occurrence, since "__" most often occur between independent mangled
     parts, hence starting at the last occurence inside a signature
     parts, hence starting at the last occurence inside a signature
     might get us a "successful" demangling of the signature.  */
     might get us a "successful" demangling of the signature.  */
 
 
  while (scan[2])
  while (scan[2])
    {
    {
      if (demangle_function_name (work, mangled, declp, scan))
      if (demangle_function_name (work, mangled, declp, scan))
        {
        {
          success = demangle_signature (work, mangled, declp);
          success = demangle_signature (work, mangled, declp);
          if (success)
          if (success)
            break;
            break;
        }
        }
 
 
      /* Reset demangle state for the next round.  */
      /* Reset demangle state for the next round.  */
      *mangled = mangle_init;
      *mangled = mangle_init;
      string_clear (declp);
      string_clear (declp);
      string_appends (declp, &decl_init);
      string_appends (declp, &decl_init);
      work_stuff_copy_to_from (work, &work_init);
      work_stuff_copy_to_from (work, &work_init);
 
 
      /* Leave this underscore-sequence.  */
      /* Leave this underscore-sequence.  */
      scan += 2;
      scan += 2;
 
 
      /* Scan for the next "__" sequence.  */
      /* Scan for the next "__" sequence.  */
      while (*scan && (scan[0] != '_' || scan[1] != '_'))
      while (*scan && (scan[0] != '_' || scan[1] != '_'))
        scan++;
        scan++;
 
 
      /* Move to last "__" in this sequence.  */
      /* Move to last "__" in this sequence.  */
      while (*scan && *scan == '_')
      while (*scan && *scan == '_')
        scan++;
        scan++;
      scan -= 2;
      scan -= 2;
    }
    }
 
 
  /* Delete saved state.  */
  /* Delete saved state.  */
  delete_work_stuff (&work_init);
  delete_work_stuff (&work_init);
  string_delete (&decl_init);
  string_delete (&decl_init);
 
 
  return success;
  return success;
}
}
 
 
/*
/*
 
 
LOCAL FUNCTION
LOCAL FUNCTION
 
 
        demangle_prefix -- consume the mangled name prefix and find signature
        demangle_prefix -- consume the mangled name prefix and find signature
 
 
SYNOPSIS
SYNOPSIS
 
 
        static int
        static int
        demangle_prefix (struct work_stuff *work, const char **mangled,
        demangle_prefix (struct work_stuff *work, const char **mangled,
                         string *declp);
                         string *declp);
 
 
DESCRIPTION
DESCRIPTION
 
 
        Consume and demangle the prefix of the mangled name.
        Consume and demangle the prefix of the mangled name.
        While processing the function name root, arrange to call
        While processing the function name root, arrange to call
        demangle_signature if the root is ambiguous.
        demangle_signature if the root is ambiguous.
 
 
        DECLP points to the string buffer into which demangled output is
        DECLP points to the string buffer into which demangled output is
        placed.  On entry, the buffer is empty.  On exit it contains
        placed.  On entry, the buffer is empty.  On exit it contains
        the root function name, the demangled operator name, or in some
        the root function name, the demangled operator name, or in some
        special cases either nothing or the completely demangled result.
        special cases either nothing or the completely demangled result.
 
 
        MANGLED points to the current pointer into the mangled name.  As each
        MANGLED points to the current pointer into the mangled name.  As each
        token of the mangled name is consumed, it is updated.  Upon entry
        token of the mangled name is consumed, it is updated.  Upon entry
        the current mangled name pointer points to the first character of
        the current mangled name pointer points to the first character of
        the mangled name.  Upon exit, it should point to the first character
        the mangled name.  Upon exit, it should point to the first character
        of the signature if demangling was successful, or to the first
        of the signature if demangling was successful, or to the first
        unconsumed character if demangling of the prefix was unsuccessful.
        unconsumed character if demangling of the prefix was unsuccessful.
 
 
        Returns 1 on success, 0 otherwise.
        Returns 1 on success, 0 otherwise.
 */
 */
 
 
static int
static int
demangle_prefix (struct work_stuff *work, const char **mangled,
demangle_prefix (struct work_stuff *work, const char **mangled,
                 string *declp)
                 string *declp)
{
{
  int success = 1;
  int success = 1;
  const char *scan;
  const char *scan;
  int i;
  int i;
 
 
  if (strlen(*mangled) > 6
  if (strlen(*mangled) > 6
      && (strncmp(*mangled, "_imp__", 6) == 0
      && (strncmp(*mangled, "_imp__", 6) == 0
          || strncmp(*mangled, "__imp_", 6) == 0))
          || strncmp(*mangled, "__imp_", 6) == 0))
    {
    {
      /* it's a symbol imported from a PE dynamic library. Check for both
      /* it's a symbol imported from a PE dynamic library. Check for both
         new style prefix _imp__ and legacy __imp_ used by older versions
         new style prefix _imp__ and legacy __imp_ used by older versions
         of dlltool. */
         of dlltool. */
      (*mangled) += 6;
      (*mangled) += 6;
      work->dllimported = 1;
      work->dllimported = 1;
    }
    }
  else if (strlen(*mangled) >= 11 && strncmp(*mangled, "_GLOBAL_", 8) == 0)
  else if (strlen(*mangled) >= 11 && strncmp(*mangled, "_GLOBAL_", 8) == 0)
    {
    {
      char *marker = strchr (cplus_markers, (*mangled)[8]);
      char *marker = strchr (cplus_markers, (*mangled)[8]);
      if (marker != NULL && *marker == (*mangled)[10])
      if (marker != NULL && *marker == (*mangled)[10])
        {
        {
          if ((*mangled)[9] == 'D')
          if ((*mangled)[9] == 'D')
            {
            {
              /* it's a GNU global destructor to be executed at program exit */
              /* it's a GNU global destructor to be executed at program exit */
              (*mangled) += 11;
              (*mangled) += 11;
              work->destructor = 2;
              work->destructor = 2;
              if (gnu_special (work, mangled, declp))
              if (gnu_special (work, mangled, declp))
                return success;
                return success;
            }
            }
          else if ((*mangled)[9] == 'I')
          else if ((*mangled)[9] == 'I')
            {
            {
              /* it's a GNU global constructor to be executed at program init */
              /* it's a GNU global constructor to be executed at program init */
              (*mangled) += 11;
              (*mangled) += 11;
              work->constructor = 2;
              work->constructor = 2;
              if (gnu_special (work, mangled, declp))
              if (gnu_special (work, mangled, declp))
                return success;
                return success;
            }
            }
        }
        }
    }
    }
  else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__std__", 7) == 0)
  else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__std__", 7) == 0)
    {
    {
      /* it's a ARM global destructor to be executed at program exit */
      /* it's a ARM global destructor to be executed at program exit */
      (*mangled) += 7;
      (*mangled) += 7;
      work->destructor = 2;
      work->destructor = 2;
    }
    }
  else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__sti__", 7) == 0)
  else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__sti__", 7) == 0)
    {
    {
      /* it's a ARM global constructor to be executed at program initial */
      /* it's a ARM global constructor to be executed at program initial */
      (*mangled) += 7;
      (*mangled) += 7;
      work->constructor = 2;
      work->constructor = 2;
    }
    }
 
 
  /*  This block of code is a reduction in strength time optimization
  /*  This block of code is a reduction in strength time optimization
      of:
      of:
      scan = strstr (*mangled, "__"); */
      scan = strstr (*mangled, "__"); */
 
 
  {
  {
    scan = *mangled;
    scan = *mangled;
 
 
    do {
    do {
      scan = strchr (scan, '_');
      scan = strchr (scan, '_');
    } while (scan != NULL && *++scan != '_');
    } while (scan != NULL && *++scan != '_');
 
 
    if (scan != NULL) --scan;
    if (scan != NULL) --scan;
  }
  }
 
 
  if (scan != NULL)
  if (scan != NULL)
    {
    {
      /* We found a sequence of two or more '_', ensure that we start at
      /* We found a sequence of two or more '_', ensure that we start at
         the last pair in the sequence.  */
         the last pair in the sequence.  */
      i = strspn (scan, "_");
      i = strspn (scan, "_");
      if (i > 2)
      if (i > 2)
        {
        {
          scan += (i - 2);
          scan += (i - 2);
        }
        }
    }
    }
 
 
  if (scan == NULL)
  if (scan == NULL)
    {
    {
      success = 0;
      success = 0;
    }
    }
  else if (work -> static_type)
  else if (work -> static_type)
    {
    {
      if (!ISDIGIT ((unsigned char)scan[0]) && (scan[0] != 't'))
      if (!ISDIGIT ((unsigned char)scan[0]) && (scan[0] != 't'))
        {
        {
          success = 0;
          success = 0;
        }
        }
    }
    }
  else if ((scan == *mangled)
  else if ((scan == *mangled)
           && (ISDIGIT ((unsigned char)scan[2]) || (scan[2] == 'Q')
           && (ISDIGIT ((unsigned char)scan[2]) || (scan[2] == 'Q')
               || (scan[2] == 't') || (scan[2] == 'K') || (scan[2] == 'H')))
               || (scan[2] == 't') || (scan[2] == 'K') || (scan[2] == 'H')))
    {
    {
      /* The ARM says nothing about the mangling of local variables.
      /* The ARM says nothing about the mangling of local variables.
         But cfront mangles local variables by prepending __<nesting_level>
         But cfront mangles local variables by prepending __<nesting_level>
         to them. As an extension to ARM demangling we handle this case.  */
         to them. As an extension to ARM demangling we handle this case.  */
      if ((LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING)
      if ((LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING)
          && ISDIGIT ((unsigned char)scan[2]))
          && ISDIGIT ((unsigned char)scan[2]))
        {
        {
          *mangled = scan + 2;
          *mangled = scan + 2;
          consume_count (mangled);
          consume_count (mangled);
          string_append (declp, *mangled);
          string_append (declp, *mangled);
          *mangled += strlen (*mangled);
          *mangled += strlen (*mangled);
          success = 1;
          success = 1;
        }
        }
      else
      else
        {
        {
          /* A GNU style constructor starts with __[0-9Qt].  But cfront uses
          /* A GNU style constructor starts with __[0-9Qt].  But cfront uses
             names like __Q2_3foo3bar for nested type names.  So don't accept
             names like __Q2_3foo3bar for nested type names.  So don't accept
             this style of constructor for cfront demangling.  A GNU
             this style of constructor for cfront demangling.  A GNU
             style member-template constructor starts with 'H'. */
             style member-template constructor starts with 'H'. */
          if (!(LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING))
          if (!(LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING))
            work -> constructor += 1;
            work -> constructor += 1;
          *mangled = scan + 2;
          *mangled = scan + 2;
        }
        }
    }
    }
  else if (ARM_DEMANGLING && scan[2] == 'p' && scan[3] == 't')
  else if (ARM_DEMANGLING && scan[2] == 'p' && scan[3] == 't')
    {
    {
      /* Cfront-style parameterized type.  Handled later as a signature. */
      /* Cfront-style parameterized type.  Handled later as a signature. */
      success = 1;
      success = 1;
 
 
      /* ARM template? */
      /* ARM template? */
      demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
      demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
    }
    }
  else if (EDG_DEMANGLING && ((scan[2] == 't' && scan[3] == 'm')
  else if (EDG_DEMANGLING && ((scan[2] == 't' && scan[3] == 'm')
                              || (scan[2] == 'p' && scan[3] == 's')
                              || (scan[2] == 'p' && scan[3] == 's')
                              || (scan[2] == 'p' && scan[3] == 't')))
                              || (scan[2] == 'p' && scan[3] == 't')))
    {
    {
      /* EDG-style parameterized type.  Handled later as a signature. */
      /* EDG-style parameterized type.  Handled later as a signature. */
      success = 1;
      success = 1;
 
 
      /* EDG template? */
      /* EDG template? */
      demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
      demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
    }
    }
  else if ((scan == *mangled) && !ISDIGIT ((unsigned char)scan[2])
  else if ((scan == *mangled) && !ISDIGIT ((unsigned char)scan[2])
           && (scan[2] != 't'))
           && (scan[2] != 't'))
    {
    {
      /* Mangled name starts with "__".  Skip over any leading '_' characters,
      /* Mangled name starts with "__".  Skip over any leading '_' characters,
         then find the next "__" that separates the prefix from the signature.
         then find the next "__" that separates the prefix from the signature.
         */
         */
      if (!(ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
      if (!(ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
          || (arm_special (mangled, declp) == 0))
          || (arm_special (mangled, declp) == 0))
        {
        {
          while (*scan == '_')
          while (*scan == '_')
            {
            {
              scan++;
              scan++;
            }
            }
          if ((scan = strstr (scan, "__")) == NULL || (*(scan + 2) == '\0'))
          if ((scan = strstr (scan, "__")) == NULL || (*(scan + 2) == '\0'))
            {
            {
              /* No separator (I.E. "__not_mangled"), or empty signature
              /* No separator (I.E. "__not_mangled"), or empty signature
                 (I.E. "__not_mangled_either__") */
                 (I.E. "__not_mangled_either__") */
              success = 0;
              success = 0;
            }
            }
          else
          else
            return iterate_demangle_function (work, mangled, declp, scan);
            return iterate_demangle_function (work, mangled, declp, scan);
        }
        }
    }
    }
  else if (*(scan + 2) != '\0')
  else if (*(scan + 2) != '\0')
    {
    {
      /* Mangled name does not start with "__" but does have one somewhere
      /* Mangled name does not start with "__" but does have one somewhere
         in there with non empty stuff after it.  Looks like a global
         in there with non empty stuff after it.  Looks like a global
         function name.  Iterate over all "__":s until the right
         function name.  Iterate over all "__":s until the right
         one is found.  */
         one is found.  */
      return iterate_demangle_function (work, mangled, declp, scan);
      return iterate_demangle_function (work, mangled, declp, scan);
    }
    }
  else
  else
    {
    {
      /* Doesn't look like a mangled name */
      /* Doesn't look like a mangled name */
      success = 0;
      success = 0;
    }
    }
 
 
  if (!success && (work->constructor == 2 || work->destructor == 2))
  if (!success && (work->constructor == 2 || work->destructor == 2))
    {
    {
      string_append (declp, *mangled);
      string_append (declp, *mangled);
      *mangled += strlen (*mangled);
      *mangled += strlen (*mangled);
      success = 1;
      success = 1;
    }
    }
  return (success);
  return (success);
}
}
 
 
/*
/*
 
 
LOCAL FUNCTION
LOCAL FUNCTION
 
 
        gnu_special -- special handling of gnu mangled strings
        gnu_special -- special handling of gnu mangled strings
 
 
SYNOPSIS
SYNOPSIS
 
 
        static int
        static int
        gnu_special (struct work_stuff *work, const char **mangled,
        gnu_special (struct work_stuff *work, const char **mangled,
                     string *declp);
                     string *declp);
 
 
 
 
DESCRIPTION
DESCRIPTION
 
 
        Process some special GNU style mangling forms that don't fit
        Process some special GNU style mangling forms that don't fit
        the normal pattern.  For example:
        the normal pattern.  For example:
 
 
                _$_3foo         (destructor for class foo)
                _$_3foo         (destructor for class foo)
                _vt$foo         (foo virtual table)
                _vt$foo         (foo virtual table)
                _vt$foo$bar     (foo::bar virtual table)
                _vt$foo$bar     (foo::bar virtual table)
                __vt_foo        (foo virtual table, new style with thunks)
                __vt_foo        (foo virtual table, new style with thunks)
                _3foo$varname   (static data member)
                _3foo$varname   (static data member)
                _Q22rs2tu$vw    (static data member)
                _Q22rs2tu$vw    (static data member)
                __t6vector1Zii  (constructor with template)
                __t6vector1Zii  (constructor with template)
                __thunk_4__$_7ostream (virtual function thunk)
                __thunk_4__$_7ostream (virtual function thunk)
 */
 */
 
 
static int
static int
gnu_special (struct work_stuff *work, const char **mangled, string *declp)
gnu_special (struct work_stuff *work, const char **mangled, string *declp)
{
{
  int n;
  int n;
  int success = 1;
  int success = 1;
  const char *p;
  const char *p;
 
 
  if ((*mangled)[0] == '_'
  if ((*mangled)[0] == '_'
      && strchr (cplus_markers, (*mangled)[1]) != NULL
      && strchr (cplus_markers, (*mangled)[1]) != NULL
      && (*mangled)[2] == '_')
      && (*mangled)[2] == '_')
    {
    {
      /* Found a GNU style destructor, get past "_<CPLUS_MARKER>_" */
      /* Found a GNU style destructor, get past "_<CPLUS_MARKER>_" */
      (*mangled) += 3;
      (*mangled) += 3;
      work -> destructor += 1;
      work -> destructor += 1;
    }
    }
  else if ((*mangled)[0] == '_'
  else if ((*mangled)[0] == '_'
           && (((*mangled)[1] == '_'
           && (((*mangled)[1] == '_'
                && (*mangled)[2] == 'v'
                && (*mangled)[2] == 'v'
                && (*mangled)[3] == 't'
                && (*mangled)[3] == 't'
                && (*mangled)[4] == '_')
                && (*mangled)[4] == '_')
               || ((*mangled)[1] == 'v'
               || ((*mangled)[1] == 'v'
                   && (*mangled)[2] == 't'
                   && (*mangled)[2] == 't'
                   && strchr (cplus_markers, (*mangled)[3]) != NULL)))
                   && strchr (cplus_markers, (*mangled)[3]) != NULL)))
    {
    {
      /* Found a GNU style virtual table, get past "_vt<CPLUS_MARKER>"
      /* Found a GNU style virtual table, get past "_vt<CPLUS_MARKER>"
         and create the decl.  Note that we consume the entire mangled
         and create the decl.  Note that we consume the entire mangled
         input string, which means that demangle_signature has no work
         input string, which means that demangle_signature has no work
         to do.  */
         to do.  */
      if ((*mangled)[2] == 'v')
      if ((*mangled)[2] == 'v')
        (*mangled) += 5; /* New style, with thunks: "__vt_" */
        (*mangled) += 5; /* New style, with thunks: "__vt_" */
      else
      else
        (*mangled) += 4; /* Old style, no thunks: "_vt<CPLUS_MARKER>" */
        (*mangled) += 4; /* Old style, no thunks: "_vt<CPLUS_MARKER>" */
      while (**mangled != '\0')
      while (**mangled != '\0')
        {
        {
          switch (**mangled)
          switch (**mangled)
            {
            {
            case 'Q':
            case 'Q':
            case 'K':
            case 'K':
              success = demangle_qualified (work, mangled, declp, 0, 1);
              success = demangle_qualified (work, mangled, declp, 0, 1);
              break;
              break;
            case 't':
            case 't':
              success = demangle_template (work, mangled, declp, 0, 1,
              success = demangle_template (work, mangled, declp, 0, 1,
                                           1);
                                           1);
              break;
              break;
            default:
            default:
              if (ISDIGIT((unsigned char)*mangled[0]))
              if (ISDIGIT((unsigned char)*mangled[0]))
                {
                {
                  n = consume_count(mangled);
                  n = consume_count(mangled);
                  /* We may be seeing a too-large size, or else a
                  /* We may be seeing a too-large size, or else a
                     ".<digits>" indicating a static local symbol.  In
                     ".<digits>" indicating a static local symbol.  In
                     any case, declare victory and move on; *don't* try
                     any case, declare victory and move on; *don't* try
                     to use n to allocate.  */
                     to use n to allocate.  */
                  if (n > (int) strlen (*mangled))
                  if (n > (int) strlen (*mangled))
                    {
                    {
                      success = 1;
                      success = 1;
                      break;
                      break;
                    }
                    }
                }
                }
              else
              else
                {
                {
                  n = strcspn (*mangled, cplus_markers);
                  n = strcspn (*mangled, cplus_markers);
                }
                }
              string_appendn (declp, *mangled, n);
              string_appendn (declp, *mangled, n);
              (*mangled) += n;
              (*mangled) += n;
            }
            }
 
 
          p = strpbrk (*mangled, cplus_markers);
          p = strpbrk (*mangled, cplus_markers);
          if (success && ((p == NULL) || (p == *mangled)))
          if (success && ((p == NULL) || (p == *mangled)))
            {
            {
              if (p != NULL)
              if (p != NULL)
                {
                {
                  string_append (declp, SCOPE_STRING (work));
                  string_append (declp, SCOPE_STRING (work));
                  (*mangled)++;
                  (*mangled)++;
                }
                }
            }
            }
          else
          else
            {
            {
              success = 0;
              success = 0;
              break;
              break;
            }
            }
        }
        }
      if (success)
      if (success)
        string_append (declp, " virtual table");
        string_append (declp, " virtual table");
    }
    }
  else if ((*mangled)[0] == '_'
  else if ((*mangled)[0] == '_'
           && (strchr("0123456789Qt", (*mangled)[1]) != NULL)
           && (strchr("0123456789Qt", (*mangled)[1]) != NULL)
           && (p = strpbrk (*mangled, cplus_markers)) != NULL)
           && (p = strpbrk (*mangled, cplus_markers)) != NULL)
    {
    {
      /* static data member, "_3foo$varname" for example */
      /* static data member, "_3foo$varname" for example */
      (*mangled)++;
      (*mangled)++;
      switch (**mangled)
      switch (**mangled)
        {
        {
        case 'Q':
        case 'Q':
        case 'K':
        case 'K':
          success = demangle_qualified (work, mangled, declp, 0, 1);
          success = demangle_qualified (work, mangled, declp, 0, 1);
          break;
          break;
        case 't':
        case 't':
          success = demangle_template (work, mangled, declp, 0, 1, 1);
          success = demangle_template (work, mangled, declp, 0, 1, 1);
          break;
          break;
        default:
        default:
          n = consume_count (mangled);
          n = consume_count (mangled);
          if (n < 0 || n > (long) strlen (*mangled))
          if (n < 0 || n > (long) strlen (*mangled))
            {
            {
              success = 0;
              success = 0;
              break;
              break;
            }
            }
 
 
          if (n > 10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
          if (n > 10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
              && (*mangled)[9] == 'N'
              && (*mangled)[9] == 'N'
              && (*mangled)[8] == (*mangled)[10]
              && (*mangled)[8] == (*mangled)[10]
              && strchr (cplus_markers, (*mangled)[8]))
              && strchr (cplus_markers, (*mangled)[8]))
            {
            {
              /* A member of the anonymous namespace.  There's information
              /* A member of the anonymous namespace.  There's information
                 about what identifier or filename it was keyed to, but
                 about what identifier or filename it was keyed to, but
                 it's just there to make the mangled name unique; we just
                 it's just there to make the mangled name unique; we just
                 step over it.  */
                 step over it.  */
              string_append (declp, "{anonymous}");
              string_append (declp, "{anonymous}");
              (*mangled) += n;
              (*mangled) += n;
 
 
              /* Now p points to the marker before the N, so we need to
              /* Now p points to the marker before the N, so we need to
                 update it to the first marker after what we consumed.  */
                 update it to the first marker after what we consumed.  */
              p = strpbrk (*mangled, cplus_markers);
              p = strpbrk (*mangled, cplus_markers);
              break;
              break;
            }
            }
 
 
          string_appendn (declp, *mangled, n);
          string_appendn (declp, *mangled, n);
          (*mangled) += n;
          (*mangled) += n;
        }
        }
      if (success && (p == *mangled))
      if (success && (p == *mangled))
        {
        {
          /* Consumed everything up to the cplus_marker, append the
          /* Consumed everything up to the cplus_marker, append the
             variable name.  */
             variable name.  */
          (*mangled)++;
          (*mangled)++;
          string_append (declp, SCOPE_STRING (work));
          string_append (declp, SCOPE_STRING (work));
          n = strlen (*mangled);
          n = strlen (*mangled);
          string_appendn (declp, *mangled, n);
          string_appendn (declp, *mangled, n);
          (*mangled) += n;
          (*mangled) += n;
        }
        }
      else
      else
        {
        {
          success = 0;
          success = 0;
        }
        }
    }
    }
  else if (strncmp (*mangled, "__thunk_", 8) == 0)
  else if (strncmp (*mangled, "__thunk_", 8) == 0)
    {
    {
      int delta;
      int delta;
 
 
      (*mangled) += 8;
      (*mangled) += 8;
      delta = consume_count (mangled);
      delta = consume_count (mangled);
      if (delta == -1)
      if (delta == -1)
        success = 0;
        success = 0;
      else
      else
        {
        {
          char *method = internal_cplus_demangle (work, ++*mangled);
          char *method = internal_cplus_demangle (work, ++*mangled);
 
 
          if (method)
          if (method)
            {
            {
              char buf[50];
              char buf[50];
              sprintf (buf, "virtual function thunk (delta:%d) for ", -delta);
              sprintf (buf, "virtual function thunk (delta:%d) for ", -delta);
              string_append (declp, buf);
              string_append (declp, buf);
              string_append (declp, method);
              string_append (declp, method);
              free (method);
              free (method);
              n = strlen (*mangled);
              n = strlen (*mangled);
              (*mangled) += n;
              (*mangled) += n;
            }
            }
          else
          else
            {
            {
              success = 0;
              success = 0;
            }
            }
        }
        }
    }
    }
  else if (strncmp (*mangled, "__t", 3) == 0
  else if (strncmp (*mangled, "__t", 3) == 0
           && ((*mangled)[3] == 'i' || (*mangled)[3] == 'f'))
           && ((*mangled)[3] == 'i' || (*mangled)[3] == 'f'))
    {
    {
      p = (*mangled)[3] == 'i' ? " type_info node" : " type_info function";
      p = (*mangled)[3] == 'i' ? " type_info node" : " type_info function";
      (*mangled) += 4;
      (*mangled) += 4;
      switch (**mangled)
      switch (**mangled)
        {
        {
        case 'Q':
        case 'Q':
        case 'K':
        case 'K':
          success = demangle_qualified (work, mangled, declp, 0, 1);
          success = demangle_qualified (work, mangled, declp, 0, 1);
          break;
          break;
        case 't':
        case 't':
          success = demangle_template (work, mangled, declp, 0, 1, 1);
          success = demangle_template (work, mangled, declp, 0, 1, 1);
          break;
          break;
        default:
        default:
          success = do_type (work, mangled, declp);
          success = do_type (work, mangled, declp);
          break;
          break;
        }
        }
      if (success && **mangled != '\0')
      if (success && **mangled != '\0')
        success = 0;
        success = 0;
      if (success)
      if (success)
        string_append (declp, p);
        string_append (declp, p);
    }
    }
  else
  else
    {
    {
      success = 0;
      success = 0;
    }
    }
  return (success);
  return (success);
}
}
 
 
static void
static void
recursively_demangle(struct work_stuff *work, const char **mangled,
recursively_demangle(struct work_stuff *work, const char **mangled,
                     string *result, int namelength)
                     string *result, int namelength)
{
{
  char * recurse = (char *)NULL;
  char * recurse = (char *)NULL;
  char * recurse_dem = (char *)NULL;
  char * recurse_dem = (char *)NULL;
 
 
  recurse = XNEWVEC (char, namelength + 1);
  recurse = XNEWVEC (char, namelength + 1);
  memcpy (recurse, *mangled, namelength);
  memcpy (recurse, *mangled, namelength);
  recurse[namelength] = '\000';
  recurse[namelength] = '\000';
 
 
  recurse_dem = cplus_demangle (recurse, work->options);
  recurse_dem = cplus_demangle (recurse, work->options);
 
 
  if (recurse_dem)
  if (recurse_dem)
    {
    {
      string_append (result, recurse_dem);
      string_append (result, recurse_dem);
      free (recurse_dem);
      free (recurse_dem);
    }
    }
  else
  else
    {
    {
      string_appendn (result, *mangled, namelength);
      string_appendn (result, *mangled, namelength);
    }
    }
  free (recurse);
  free (recurse);
  *mangled += namelength;
  *mangled += namelength;
}
}
 
 
/*
/*
 
 
LOCAL FUNCTION
LOCAL FUNCTION
 
 
        arm_special -- special handling of ARM/lucid mangled strings
        arm_special -- special handling of ARM/lucid mangled strings
 
 
SYNOPSIS
SYNOPSIS
 
 
        static int
        static int
        arm_special (const char **mangled,
        arm_special (const char **mangled,
                     string *declp);
                     string *declp);
 
 
 
 
DESCRIPTION
DESCRIPTION
 
 
        Process some special ARM style mangling forms that don't fit
        Process some special ARM style mangling forms that don't fit
        the normal pattern.  For example:
        the normal pattern.  For example:
 
 
                __vtbl__3foo            (foo virtual table)
                __vtbl__3foo            (foo virtual table)
                __vtbl__3foo__3bar      (bar::foo virtual table)
                __vtbl__3foo__3bar      (bar::foo virtual table)
 
 
 */
 */
 
 
static int
static int
arm_special (const char **mangled, string *declp)
arm_special (const char **mangled, string *declp)
{
{
  int n;
  int n;
  int success = 1;
  int success = 1;
  const char *scan;
  const char *scan;
 
 
  if (strncmp (*mangled, ARM_VTABLE_STRING, ARM_VTABLE_STRLEN) == 0)
  if (strncmp (*mangled, ARM_VTABLE_STRING, ARM_VTABLE_STRLEN) == 0)
    {
    {
      /* Found a ARM style virtual table, get past ARM_VTABLE_STRING
      /* Found a ARM style virtual table, get past ARM_VTABLE_STRING
         and create the decl.  Note that we consume the entire mangled
         and create the decl.  Note that we consume the entire mangled
         input string, which means that demangle_signature has no work
         input string, which means that demangle_signature has no work
         to do.  */
         to do.  */
      scan = *mangled + ARM_VTABLE_STRLEN;
      scan = *mangled + ARM_VTABLE_STRLEN;
      while (*scan != '\0')        /* first check it can be demangled */
      while (*scan != '\0')        /* first check it can be demangled */
        {
        {
          n = consume_count (&scan);
          n = consume_count (&scan);
          if (n == -1)
          if (n == -1)
            {
            {
              return (0);           /* no good */
              return (0);           /* no good */
            }
            }
          scan += n;
          scan += n;
          if (scan[0] == '_' && scan[1] == '_')
          if (scan[0] == '_' && scan[1] == '_')
            {
            {
              scan += 2;
              scan += 2;
            }
            }
        }
        }
      (*mangled) += ARM_VTABLE_STRLEN;
      (*mangled) += ARM_VTABLE_STRLEN;
      while (**mangled != '\0')
      while (**mangled != '\0')
        {
        {
          n = consume_count (mangled);
          n = consume_count (mangled);
          if (n == -1
          if (n == -1
              || n > (long) strlen (*mangled))
              || n > (long) strlen (*mangled))
            return 0;
            return 0;
          string_prependn (declp, *mangled, n);
          string_prependn (declp, *mangled, n);
          (*mangled) += n;
          (*mangled) += n;
          if ((*mangled)[0] == '_' && (*mangled)[1] == '_')
          if ((*mangled)[0] == '_' && (*mangled)[1] == '_')
            {
            {
              string_prepend (declp, "::");
              string_prepend (declp, "::");
              (*mangled) += 2;
              (*mangled) += 2;
            }
            }
        }
        }
      string_append (declp, " virtual table");
      string_append (declp, " virtual table");
    }
    }
  else
  else
    {
    {
      success = 0;
      success = 0;
    }
    }
  return (success);
  return (success);
}
}
 
 
/*
/*
 
 
LOCAL FUNCTION
LOCAL FUNCTION
 
 
        demangle_qualified -- demangle 'Q' qualified name strings
        demangle_qualified -- demangle 'Q' qualified name strings
 
 
SYNOPSIS
SYNOPSIS
 
 
        static int
        static int
        demangle_qualified (struct work_stuff *, const char *mangled,
        demangle_qualified (struct work_stuff *, const char *mangled,
                            string *result, int isfuncname, int append);
                            string *result, int isfuncname, int append);
 
 
DESCRIPTION
DESCRIPTION
 
 
        Demangle a qualified name, such as "Q25Outer5Inner" which is
        Demangle a qualified name, such as "Q25Outer5Inner" which is
        the mangled form of "Outer::Inner".  The demangled output is
        the mangled form of "Outer::Inner".  The demangled output is
        prepended or appended to the result string according to the
        prepended or appended to the result string according to the
        state of the append flag.
        state of the append flag.
 
 
        If isfuncname is nonzero, then the qualified name we are building
        If isfuncname is nonzero, then the qualified name we are building
        is going to be used as a member function name, so if it is a
        is going to be used as a member function name, so if it is a
        constructor or destructor function, append an appropriate
        constructor or destructor function, append an appropriate
        constructor or destructor name.  I.E. for the above example,
        constructor or destructor name.  I.E. for the above example,
        the result for use as a constructor is "Outer::Inner::Inner"
        the result for use as a constructor is "Outer::Inner::Inner"
        and the result for use as a destructor is "Outer::Inner::~Inner".
        and the result for use as a destructor is "Outer::Inner::~Inner".
 
 
BUGS
BUGS
 
 
        Numeric conversion is ASCII dependent (FIXME).
        Numeric conversion is ASCII dependent (FIXME).
 
 
 */
 */
 
 
static int
static int
demangle_qualified (struct work_stuff *work, const char **mangled,
demangle_qualified (struct work_stuff *work, const char **mangled,
                    string *result, int isfuncname, int append)
                    string *result, int isfuncname, int append)
{
{
  int qualifiers = 0;
  int qualifiers = 0;
  int success = 1;
  int success = 1;
  char num[2];
  char num[2];
  string temp;
  string temp;
  string last_name;
  string last_name;
  int bindex = register_Btype (work);
  int bindex = register_Btype (work);
 
 
  /* We only make use of ISFUNCNAME if the entity is a constructor or
  /* We only make use of ISFUNCNAME if the entity is a constructor or
     destructor.  */
     destructor.  */
  isfuncname = (isfuncname
  isfuncname = (isfuncname
                && ((work->constructor & 1) || (work->destructor & 1)));
                && ((work->constructor & 1) || (work->destructor & 1)));
 
 
  string_init (&temp);
  string_init (&temp);
  string_init (&last_name);
  string_init (&last_name);
 
 
  if ((*mangled)[0] == 'K')
  if ((*mangled)[0] == 'K')
    {
    {
    /* Squangling qualified name reuse */
    /* Squangling qualified name reuse */
      int idx;
      int idx;
      (*mangled)++;
      (*mangled)++;
      idx = consume_count_with_underscores (mangled);
      idx = consume_count_with_underscores (mangled);
      if (idx == -1 || idx >= work -> numk)
      if (idx == -1 || idx >= work -> numk)
        success = 0;
        success = 0;
      else
      else
        string_append (&temp, work -> ktypevec[idx]);
        string_append (&temp, work -> ktypevec[idx]);
    }
    }
  else
  else
    switch ((*mangled)[1])
    switch ((*mangled)[1])
    {
    {
    case '_':
    case '_':
      /* GNU mangled name with more than 9 classes.  The count is preceded
      /* GNU mangled name with more than 9 classes.  The count is preceded
         by an underscore (to distinguish it from the <= 9 case) and followed
         by an underscore (to distinguish it from the <= 9 case) and followed
         by an underscore.  */
         by an underscore.  */
      (*mangled)++;
      (*mangled)++;
      qualifiers = consume_count_with_underscores (mangled);
      qualifiers = consume_count_with_underscores (mangled);
      if (qualifiers == -1)
      if (qualifiers == -1)
        success = 0;
        success = 0;
      break;
      break;
 
 
    case '1':
    case '1':
    case '2':
    case '2':
    case '3':
    case '3':
    case '4':
    case '4':
    case '5':
    case '5':
    case '6':
    case '6':
    case '7':
    case '7':
    case '8':
    case '8':
    case '9':
    case '9':
      /* The count is in a single digit.  */
      /* The count is in a single digit.  */
      num[0] = (*mangled)[1];
      num[0] = (*mangled)[1];
      num[1] = '\0';
      num[1] = '\0';
      qualifiers = atoi (num);
      qualifiers = atoi (num);
 
 
      /* If there is an underscore after the digit, skip it.  This is
      /* If there is an underscore after the digit, skip it.  This is
         said to be for ARM-qualified names, but the ARM makes no
         said to be for ARM-qualified names, but the ARM makes no
         mention of such an underscore.  Perhaps cfront uses one.  */
         mention of such an underscore.  Perhaps cfront uses one.  */
      if ((*mangled)[2] == '_')
      if ((*mangled)[2] == '_')
        {
        {
          (*mangled)++;
          (*mangled)++;
        }
        }
      (*mangled) += 2;
      (*mangled) += 2;
      break;
      break;
 
 
    case '0':
    case '0':
    default:
    default:
      success = 0;
      success = 0;
    }
    }
 
 
  if (!success)
  if (!success)
    return success;
    return success;
 
 
  /* Pick off the names and collect them in the temp buffer in the order
  /* Pick off the names and collect them in the temp buffer in the order
     in which they are found, separated by '::'.  */
     in which they are found, separated by '::'.  */
 
 
  while (qualifiers-- > 0)
  while (qualifiers-- > 0)
    {
    {
      int remember_K = 1;
      int remember_K = 1;
      string_clear (&last_name);
      string_clear (&last_name);
 
 
      if (*mangled[0] == '_')
      if (*mangled[0] == '_')
        (*mangled)++;
        (*mangled)++;
 
 
      if (*mangled[0] == 't')
      if (*mangled[0] == 't')
        {
        {
          /* Here we always append to TEMP since we will want to use
          /* Here we always append to TEMP since we will want to use
             the template name without the template parameters as a
             the template name without the template parameters as a
             constructor or destructor name.  The appropriate
             constructor or destructor name.  The appropriate
             (parameter-less) value is returned by demangle_template
             (parameter-less) value is returned by demangle_template
             in LAST_NAME.  We do not remember the template type here,
             in LAST_NAME.  We do not remember the template type here,
             in order to match the G++ mangling algorithm.  */
             in order to match the G++ mangling algorithm.  */
          success = demangle_template(work, mangled, &temp,
          success = demangle_template(work, mangled, &temp,
                                      &last_name, 1, 0);
                                      &last_name, 1, 0);
          if (!success)
          if (!success)
            break;
            break;
        }
        }
      else if (*mangled[0] == 'K')
      else if (*mangled[0] == 'K')
        {
        {
          int idx;
          int idx;
          (*mangled)++;
          (*mangled)++;
          idx = consume_count_with_underscores (mangled);
          idx = consume_count_with_underscores (mangled);
          if (idx == -1 || idx >= work->numk)
          if (idx == -1 || idx >= work->numk)
            success = 0;
            success = 0;
          else
          else
            string_append (&temp, work->ktypevec[idx]);
            string_append (&temp, work->ktypevec[idx]);
          remember_K = 0;
          remember_K = 0;
 
 
          if (!success) break;
          if (!success) break;
        }
        }
      else
      else
        {
        {
          if (EDG_DEMANGLING)
          if (EDG_DEMANGLING)
            {
            {
              int namelength;
              int namelength;
              /* Now recursively demangle the qualifier
              /* Now recursively demangle the qualifier
               * This is necessary to deal with templates in
               * This is necessary to deal with templates in
               * mangling styles like EDG */
               * mangling styles like EDG */
              namelength = consume_count (mangled);
              namelength = consume_count (mangled);
              if (namelength == -1)
              if (namelength == -1)
                {
                {
                  success = 0;
                  success = 0;
                  break;
                  break;
                }
                }
              recursively_demangle(work, mangled, &temp, namelength);
              recursively_demangle(work, mangled, &temp, namelength);
            }
            }
          else
          else
            {
            {
              string_delete (&last_name);
              string_delete (&last_name);
              success = do_type (work, mangled, &last_name);
              success = do_type (work, mangled, &last_name);
              if (!success)
              if (!success)
                break;
                break;
              string_appends (&temp, &last_name);
              string_appends (&temp, &last_name);
            }
            }
        }
        }
 
 
      if (remember_K)
      if (remember_K)
        remember_Ktype (work, temp.b, LEN_STRING (&temp));
        remember_Ktype (work, temp.b, LEN_STRING (&temp));
 
 
      if (qualifiers > 0)
      if (qualifiers > 0)
        string_append (&temp, SCOPE_STRING (work));
        string_append (&temp, SCOPE_STRING (work));
    }
    }
 
 
  remember_Btype (work, temp.b, LEN_STRING (&temp), bindex);
  remember_Btype (work, temp.b, LEN_STRING (&temp), bindex);
 
 
  /* If we are using the result as a function name, we need to append
  /* If we are using the result as a function name, we need to append
     the appropriate '::' separated constructor or destructor name.
     the appropriate '::' separated constructor or destructor name.
     We do this here because this is the most convenient place, where
     We do this here because this is the most convenient place, where
     we already have a pointer to the name and the length of the name.  */
     we already have a pointer to the name and the length of the name.  */
 
 
  if (isfuncname)
  if (isfuncname)
    {
    {
      string_append (&temp, SCOPE_STRING (work));
      string_append (&temp, SCOPE_STRING (work));
      if (work -> destructor & 1)
      if (work -> destructor & 1)
        string_append (&temp, "~");
        string_append (&temp, "~");
      string_appends (&temp, &last_name);
      string_appends (&temp, &last_name);
    }
    }
 
 
  /* Now either prepend the temp buffer to the result, or append it,
  /* Now either prepend the temp buffer to the result, or append it,
     depending upon the state of the append flag.  */
     depending upon the state of the append flag.  */
 
 
  if (append)
  if (append)
    string_appends (result, &temp);
    string_appends (result, &temp);
  else
  else
    {
    {
      if (!STRING_EMPTY (result))
      if (!STRING_EMPTY (result))
        string_append (&temp, SCOPE_STRING (work));
        string_append (&temp, SCOPE_STRING (work));
      string_prepends (result, &temp);
      string_prepends (result, &temp);
    }
    }
 
 
  string_delete (&last_name);
  string_delete (&last_name);
  string_delete (&temp);
  string_delete (&temp);
  return (success);
  return (success);
}
}
 
 
/*
/*
 
 
LOCAL FUNCTION
LOCAL FUNCTION
 
 
        get_count -- convert an ascii count to integer, consuming tokens
        get_count -- convert an ascii count to integer, consuming tokens
 
 
SYNOPSIS
SYNOPSIS
 
 
        static int
        static int
        get_count (const char **type, int *count)
        get_count (const char **type, int *count)
 
 
DESCRIPTION
DESCRIPTION
 
 
        Assume that *type points at a count in a mangled name; set
        Assume that *type points at a count in a mangled name; set
        *count to its value, and set *type to the next character after
        *count to its value, and set *type to the next character after
        the count.  There are some weird rules in effect here.
        the count.  There are some weird rules in effect here.
 
 
        If *type does not point at a string of digits, return zero.
        If *type does not point at a string of digits, return zero.
 
 
        If *type points at a string of digits followed by an
        If *type points at a string of digits followed by an
        underscore, set *count to their value as an integer, advance
        underscore, set *count to their value as an integer, advance
        *type to point *after the underscore, and return 1.
        *type to point *after the underscore, and return 1.
 
 
        If *type points at a string of digits not followed by an
        If *type points at a string of digits not followed by an
        underscore, consume only the first digit.  Set *count to its
        underscore, consume only the first digit.  Set *count to its
        value as an integer, leave *type pointing after that digit,
        value as an integer, leave *type pointing after that digit,
        and return 1.
        and return 1.
 
 
        The excuse for this odd behavior: in the ARM and HP demangling
        The excuse for this odd behavior: in the ARM and HP demangling
        styles, a type can be followed by a repeat count of the form
        styles, a type can be followed by a repeat count of the form
        `Nxy', where:
        `Nxy', where:
 
 
        `x' is a single digit specifying how many additional copies
        `x' is a single digit specifying how many additional copies
            of the type to append to the argument list, and
            of the type to append to the argument list, and
 
 
        `y' is one or more digits, specifying the zero-based index of
        `y' is one or more digits, specifying the zero-based index of
            the first repeated argument in the list.  Yes, as you're
            the first repeated argument in the list.  Yes, as you're
            unmangling the name you can figure this out yourself, but
            unmangling the name you can figure this out yourself, but
            it's there anyway.
            it's there anyway.
 
 
        So, for example, in `bar__3fooFPiN51', the first argument is a
        So, for example, in `bar__3fooFPiN51', the first argument is a
        pointer to an integer (`Pi'), and then the next five arguments
        pointer to an integer (`Pi'), and then the next five arguments
        are the same (`N5'), and the first repeat is the function's
        are the same (`N5'), and the first repeat is the function's
        second argument (`1').
        second argument (`1').
*/
*/
 
 
static int
static int
get_count (const char **type, int *count)
get_count (const char **type, int *count)
{
{
  const char *p;
  const char *p;
  int n;
  int n;
 
 
  if (!ISDIGIT ((unsigned char)**type))
  if (!ISDIGIT ((unsigned char)**type))
    return (0);
    return (0);
  else
  else
    {
    {
      *count = **type - '0';
      *count = **type - '0';
      (*type)++;
      (*type)++;
      if (ISDIGIT ((unsigned char)**type))
      if (ISDIGIT ((unsigned char)**type))
        {
        {
          p = *type;
          p = *type;
          n = *count;
          n = *count;
          do
          do
            {
            {
              n *= 10;
              n *= 10;
              n += *p - '0';
              n += *p - '0';
              p++;
              p++;
            }
            }
          while (ISDIGIT ((unsigned char)*p));
          while (ISDIGIT ((unsigned char)*p));
          if (*p == '_')
          if (*p == '_')
            {
            {
              *type = p + 1;
              *type = p + 1;
              *count = n;
              *count = n;
            }
            }
        }
        }
    }
    }
  return (1);
  return (1);
}
}
 
 
/* RESULT will be initialised here; it will be freed on failure.  The
/* RESULT will be initialised here; it will be freed on failure.  The
   value returned is really a type_kind_t.  */
   value returned is really a type_kind_t.  */
 
 
static int
static int
do_type (struct work_stuff *work, const char **mangled, string *result)
do_type (struct work_stuff *work, const char **mangled, string *result)
{
{
  int n;
  int n;
  int done;
  int done;
  int success;
  int success;
  string decl;
  string decl;
  const char *remembered_type;
  const char *remembered_type;
  int type_quals;
  int type_quals;
  type_kind_t tk = tk_none;
  type_kind_t tk = tk_none;
 
 
  string_init (&decl);
  string_init (&decl);
  string_init (result);
  string_init (result);
 
 
  done = 0;
  done = 0;
  success = 1;
  success = 1;
  while (success && !done)
  while (success && !done)
    {
    {
      int member;
      int member;
      switch (**mangled)
      switch (**mangled)
        {
        {
 
 
          /* A pointer type */
          /* A pointer type */
        case 'P':
        case 'P':
        case 'p':
        case 'p':
          (*mangled)++;
          (*mangled)++;
          if (! (work -> options & DMGL_JAVA))
          if (! (work -> options & DMGL_JAVA))
            string_prepend (&decl, "*");
            string_prepend (&decl, "*");
          if (tk == tk_none)
          if (tk == tk_none)
            tk = tk_pointer;
            tk = tk_pointer;
          break;
          break;
 
 
          /* A reference type */
          /* A reference type */
        case 'R':
        case 'R':
          (*mangled)++;
          (*mangled)++;
          string_prepend (&decl, "&");
          string_prepend (&decl, "&");
          if (tk == tk_none)
          if (tk == tk_none)
            tk = tk_reference;
            tk = tk_reference;
          break;
          break;
 
 
          /* An array */
          /* An array */
        case 'A':
        case 'A':
          {
          {
            ++(*mangled);
            ++(*mangled);
            if (!STRING_EMPTY (&decl)
            if (!STRING_EMPTY (&decl)
                && (decl.b[0] == '*' || decl.b[0] == '&'))
                && (decl.b[0] == '*' || decl.b[0] == '&'))
              {
              {
                string_prepend (&decl, "(");
                string_prepend (&decl, "(");
                string_append (&decl, ")");
                string_append (&decl, ")");
              }
              }
            string_append (&decl, "[");
            string_append (&decl, "[");
            if (**mangled != '_')
            if (**mangled != '_')
              success = demangle_template_value_parm (work, mangled, &decl,
              success = demangle_template_value_parm (work, mangled, &decl,
                                                      tk_integral);
                                                      tk_integral);
            if (**mangled == '_')
            if (**mangled == '_')
              ++(*mangled);
              ++(*mangled);
            string_append (&decl, "]");
            string_append (&decl, "]");
            break;
            break;
          }
          }
 
 
        /* A back reference to a previously seen type */
        /* A back reference to a previously seen type */
        case 'T':
        case 'T':
          (*mangled)++;
          (*mangled)++;
          if (!get_count (mangled, &n) || n >= work -> ntypes)
          if (!get_count (mangled, &n) || n >= work -> ntypes)
            {
            {
              success = 0;
              success = 0;
            }
            }
          else
          else
            {
            {
              remembered_type = work -> typevec[n];
              remembered_type = work -> typevec[n];
              mangled = &remembered_type;
              mangled = &remembered_type;
            }
            }
          break;
          break;
 
 
          /* A function */
          /* A function */
        case 'F':
        case 'F':
          (*mangled)++;
          (*mangled)++;
            if (!STRING_EMPTY (&decl)
            if (!STRING_EMPTY (&decl)
                && (decl.b[0] == '*' || decl.b[0] == '&'))
                && (decl.b[0] == '*' || decl.b[0] == '&'))
            {
            {
              string_prepend (&decl, "(");
              string_prepend (&decl, "(");
              string_append (&decl, ")");
              string_append (&decl, ")");
            }
            }
          /* After picking off the function args, we expect to either find the
          /* After picking off the function args, we expect to either find the
             function return type (preceded by an '_') or the end of the
             function return type (preceded by an '_') or the end of the
             string.  */
             string.  */
          if (!demangle_nested_args (work, mangled, &decl)
          if (!demangle_nested_args (work, mangled, &decl)
              || (**mangled != '_' && **mangled != '\0'))
              || (**mangled != '_' && **mangled != '\0'))
            {
            {
              success = 0;
              success = 0;
              break;
              break;
            }
            }
          if (success && (**mangled == '_'))
          if (success && (**mangled == '_'))
            (*mangled)++;
            (*mangled)++;
          break;
          break;
 
 
        case 'M':
        case 'M':
        case 'O':
        case 'O':
          {
          {
            type_quals = TYPE_UNQUALIFIED;
            type_quals = TYPE_UNQUALIFIED;
 
 
            member = **mangled == 'M';
            member = **mangled == 'M';
            (*mangled)++;
            (*mangled)++;
 
 
            string_append (&decl, ")");
            string_append (&decl, ")");
 
 
            /* We don't need to prepend `::' for a qualified name;
            /* We don't need to prepend `::' for a qualified name;
               demangle_qualified will do that for us.  */
               demangle_qualified will do that for us.  */
            if (**mangled != 'Q')
            if (**mangled != 'Q')
              string_prepend (&decl, SCOPE_STRING (work));
              string_prepend (&decl, SCOPE_STRING (work));
 
 
            if (ISDIGIT ((unsigned char)**mangled))
            if (ISDIGIT ((unsigned char)**mangled))
              {
              {
                n = consume_count (mangled);
                n = consume_count (mangled);
                if (n == -1
                if (n == -1
                    || (int) strlen (*mangled) < n)
                    || (int) strlen (*mangled) < n)
                  {
                  {
                    success = 0;
                    success = 0;
                    break;
                    break;
                  }
                  }
                string_prependn (&decl, *mangled, n);
                string_prependn (&decl, *mangled, n);
                *mangled += n;
                *mangled += n;
              }
              }
            else if (**mangled == 'X' || **mangled == 'Y')
            else if (**mangled == 'X' || **mangled == 'Y')
              {
              {
                string temp;
                string temp;
                do_type (work, mangled, &temp);
                do_type (work, mangled, &temp);
                string_prepends (&decl, &temp);
                string_prepends (&decl, &temp);
                string_delete (&temp);
                string_delete (&temp);
              }
              }
            else if (**mangled == 't')
            else if (**mangled == 't')
              {
              {
                string temp;
                string temp;
                string_init (&temp);
                string_init (&temp);
                success = demangle_template (work, mangled, &temp,
                success = demangle_template (work, mangled, &temp,
                                             NULL, 1, 1);
                                             NULL, 1, 1);
                if (success)
                if (success)
                  {
                  {
                    string_prependn (&decl, temp.b, temp.p - temp.b);
                    string_prependn (&decl, temp.b, temp.p - temp.b);
                    string_delete (&temp);
                    string_delete (&temp);
                  }
                  }
                else
                else
                  break;
                  break;
              }
              }
            else if (**mangled == 'Q')
            else if (**mangled == 'Q')
              {
              {
                success = demangle_qualified (work, mangled, &decl,
                success = demangle_qualified (work, mangled, &decl,
                                              /*isfuncnam=*/0,
                                              /*isfuncnam=*/0,
                                              /*append=*/0);
                                              /*append=*/0);
                if (!success)
                if (!success)
                  break;
                  break;
              }
              }
            else
            else
              {
              {
                success = 0;
                success = 0;
                break;
                break;
              }
              }
 
 
            string_prepend (&decl, "(");
            string_prepend (&decl, "(");
            if (member)
            if (member)
              {
              {
                switch (**mangled)
                switch (**mangled)
                  {
                  {
                  case 'C':
                  case 'C':
                  case 'V':
                  case 'V':
                  case 'u':
                  case 'u':
                    type_quals |= code_for_qualifier (**mangled);
                    type_quals |= code_for_qualifier (**mangled);
                    (*mangled)++;
                    (*mangled)++;
                    break;
                    break;
 
 
                  default:
                  default:
                    break;
                    break;
                  }
                  }
 
 
                if (*(*mangled)++ != 'F')
                if (*(*mangled)++ != 'F')
                  {
                  {
                    success = 0;
                    success = 0;
                    break;
                    break;
                  }
                  }
              }
              }
            if ((member && !demangle_nested_args (work, mangled, &decl))
            if ((member && !demangle_nested_args (work, mangled, &decl))
                || **mangled != '_')
                || **mangled != '_')
              {
              {
                success = 0;
                success = 0;
                break;
                break;
              }
              }
            (*mangled)++;
            (*mangled)++;
            if (! PRINT_ANSI_QUALIFIERS)
            if (! PRINT_ANSI_QUALIFIERS)
              {
              {
                break;
                break;
              }
              }
            if (type_quals != TYPE_UNQUALIFIED)
            if (type_quals != TYPE_UNQUALIFIED)
              {
              {
                APPEND_BLANK (&decl);
                APPEND_BLANK (&decl);
                string_append (&decl, qualifier_string (type_quals));
                string_append (&decl, qualifier_string (type_quals));
              }
              }
            break;
            break;
          }
          }
        case 'G':
        case 'G':
          (*mangled)++;
          (*mangled)++;
          break;
          break;
 
 
        case 'C':
        case 'C':
        case 'V':
        case 'V':
        case 'u':
        case 'u':
          if (PRINT_ANSI_QUALIFIERS)
          if (PRINT_ANSI_QUALIFIERS)
            {
            {
              if (!STRING_EMPTY (&decl))
              if (!STRING_EMPTY (&decl))
                string_prepend (&decl, " ");
                string_prepend (&decl, " ");
 
 
              string_prepend (&decl, demangle_qualifier (**mangled));
              string_prepend (&decl, demangle_qualifier (**mangled));
            }
            }
          (*mangled)++;
          (*mangled)++;
          break;
          break;
          /*
          /*
            }
            }
            */
            */
 
 
          /* fall through */
          /* fall through */
        default:
        default:
          done = 1;
          done = 1;
          break;
          break;
        }
        }
    }
    }
 
 
  if (success) switch (**mangled)
  if (success) switch (**mangled)
    {
    {
      /* A qualified name, such as "Outer::Inner".  */
      /* A qualified name, such as "Outer::Inner".  */
    case 'Q':
    case 'Q':
    case 'K':
    case 'K':
      {
      {
        success = demangle_qualified (work, mangled, result, 0, 1);
        success = demangle_qualified (work, mangled, result, 0, 1);
        break;
        break;
      }
      }
 
 
    /* A back reference to a previously seen squangled type */
    /* A back reference to a previously seen squangled type */
    case 'B':
    case 'B':
      (*mangled)++;
      (*mangled)++;
      if (!get_count (mangled, &n) || n >= work -> numb)
      if (!get_count (mangled, &n) || n >= work -> numb)
        success = 0;
        success = 0;
      else
      else
        string_append (result, work->btypevec[n]);
        string_append (result, work->btypevec[n]);
      break;
      break;
 
 
    case 'X':
    case 'X':
    case 'Y':
    case 'Y':
      /* A template parm.  We substitute the corresponding argument. */
      /* A template parm.  We substitute the corresponding argument. */
      {
      {
        int idx;
        int idx;
 
 
        (*mangled)++;
        (*mangled)++;
        idx = consume_count_with_underscores (mangled);
        idx = consume_count_with_underscores (mangled);
 
 
        if (idx == -1
        if (idx == -1
            || (work->tmpl_argvec && idx >= work->ntmpl_args)
            || (work->tmpl_argvec && idx >= work->ntmpl_args)
            || consume_count_with_underscores (mangled) == -1)
            || consume_count_with_underscores (mangled) == -1)
          {
          {
            success = 0;
            success = 0;
            break;
            break;
          }
          }
 
 
        if (work->tmpl_argvec)
        if (work->tmpl_argvec)
          string_append (result, work->tmpl_argvec[idx]);
          string_append (result, work->tmpl_argvec[idx]);
        else
        else
          string_append_template_idx (result, idx);
          string_append_template_idx (result, idx);
 
 
        success = 1;
        success = 1;
      }
      }
    break;
    break;
 
 
    default:
    default:
      success = demangle_fund_type (work, mangled, result);
      success = demangle_fund_type (work, mangled, result);
      if (tk == tk_none)
      if (tk == tk_none)
        tk = (type_kind_t) success;
        tk = (type_kind_t) success;
      break;
      break;
    }
    }
 
 
  if (success)
  if (success)
    {
    {
      if (!STRING_EMPTY (&decl))
      if (!STRING_EMPTY (&decl))
        {
        {
          string_append (result, " ");
          string_append (result, " ");
          string_appends (result, &decl);
          string_appends (result, &decl);
        }
        }
    }
    }
  else
  else
    string_delete (result);
    string_delete (result);
  string_delete (&decl);
  string_delete (&decl);
 
 
  if (success)
  if (success)
    /* Assume an integral type, if we're not sure.  */
    /* Assume an integral type, if we're not sure.  */
    return (int) ((tk == tk_none) ? tk_integral : tk);
    return (int) ((tk == tk_none) ? tk_integral : tk);
  else
  else
    return 0;
    return 0;
}
}
 
 
/* Given a pointer to a type string that represents a fundamental type
/* Given a pointer to a type string that represents a fundamental type
   argument (int, long, unsigned int, etc) in TYPE, a pointer to the
   argument (int, long, unsigned int, etc) in TYPE, a pointer to the
   string in which the demangled output is being built in RESULT, and
   string in which the demangled output is being built in RESULT, and
   the WORK structure, decode the types and add them to the result.
   the WORK structure, decode the types and add them to the result.
 
 
   For example:
   For example:
 
 
        "Ci"    =>      "const int"
        "Ci"    =>      "const int"
        "Sl"    =>      "signed long"
        "Sl"    =>      "signed long"
        "CUs"   =>      "const unsigned short"
        "CUs"   =>      "const unsigned short"
 
 
   The value returned is really a type_kind_t.  */
   The value returned is really a type_kind_t.  */
 
 
static int
static int
demangle_fund_type (struct work_stuff *work,
demangle_fund_type (struct work_stuff *work,
                    const char **mangled, string *result)
                    const char **mangled, string *result)
{
{
  int done = 0;
  int done = 0;
  int success = 1;
  int success = 1;
  char buf[INTBUF_SIZE + 5 /* 'int%u_t' */];
  char buf[INTBUF_SIZE + 5 /* 'int%u_t' */];
  unsigned int dec = 0;
  unsigned int dec = 0;
  type_kind_t tk = tk_integral;
  type_kind_t tk = tk_integral;
 
 
  /* First pick off any type qualifiers.  There can be more than one.  */
  /* First pick off any type qualifiers.  There can be more than one.  */
 
 
  while (!done)
  while (!done)
    {
    {
      switch (**mangled)
      switch (**mangled)
        {
        {
        case 'C':
        case 'C':
        case 'V':
        case 'V':
        case 'u':
        case 'u':
          if (PRINT_ANSI_QUALIFIERS)
          if (PRINT_ANSI_QUALIFIERS)
            {
            {
              if (!STRING_EMPTY (result))
              if (!STRING_EMPTY (result))
                string_prepend (result, " ");
                string_prepend (result, " ");
              string_prepend (result, demangle_qualifier (**mangled));
              string_prepend (result, demangle_qualifier (**mangled));
            }
            }
          (*mangled)++;
          (*mangled)++;
          break;
          break;
        case 'U':
        case 'U':
          (*mangled)++;
          (*mangled)++;
          APPEND_BLANK (result);
          APPEND_BLANK (result);
          string_append (result, "unsigned");
          string_append (result, "unsigned");
          break;
          break;
        case 'S': /* signed char only */
        case 'S': /* signed char only */
          (*mangled)++;
          (*mangled)++;
          APPEND_BLANK (result);
          APPEND_BLANK (result);
          string_append (result, "signed");
          string_append (result, "signed");
          break;
          break;
        case 'J':
        case 'J':
          (*mangled)++;
          (*mangled)++;
          APPEND_BLANK (result);
          APPEND_BLANK (result);
          string_append (result, "__complex");
          string_append (result, "__complex");
          break;
          break;
        default:
        default:
          done = 1;
          done = 1;
          break;
          break;
        }
        }
    }
    }
 
 
  /* Now pick off the fundamental type.  There can be only one.  */
  /* Now pick off the fundamental type.  There can be only one.  */
 
 
  switch (**mangled)
  switch (**mangled)
    {
    {
    case '\0':
    case '\0':
    case '_':
    case '_':
      break;
      break;
    case 'v':
    case 'v':
      (*mangled)++;
      (*mangled)++;
      APPEND_BLANK (result);
      APPEND_BLANK (result);
      string_append (result, "void");
      string_append (result, "void");
      break;
      break;
    case 'x':
    case 'x':
      (*mangled)++;
      (*mangled)++;
      APPEND_BLANK (result);
      APPEND_BLANK (result);
      string_append (result, "long long");
      string_append (result, "long long");
      break;
      break;
    case 'l':
    case 'l':
      (*mangled)++;
      (*mangled)++;
      APPEND_BLANK (result);
      APPEND_BLANK (result);
      string_append (result, "long");
      string_append (result, "long");
      break;
      break;
    case 'i':
    case 'i':
      (*mangled)++;
      (*mangled)++;
      APPEND_BLANK (result);
      APPEND_BLANK (result);
      string_append (result, "int");
      string_append (result, "int");
      break;
      break;
    case 's':
    case 's':
      (*mangled)++;
      (*mangled)++;
      APPEND_BLANK (result);
      APPEND_BLANK (result);
      string_append (result, "short");
      string_append (result, "short");
      break;
      break;
    case 'b':
    case 'b':
      (*mangled)++;
      (*mangled)++;
      APPEND_BLANK (result);
      APPEND_BLANK (result);
      string_append (result, "bool");
      string_append (result, "bool");
      tk = tk_bool;
      tk = tk_bool;
      break;
      break;
    case 'c':
    case 'c':
      (*mangled)++;
      (*mangled)++;
      APPEND_BLANK (result);
      APPEND_BLANK (result);
      string_append (result, "char");
      string_append (result, "char");
      tk = tk_char;
      tk = tk_char;
      break;
      break;
    case 'w':
    case 'w':
      (*mangled)++;
      (*mangled)++;
      APPEND_BLANK (result);
      APPEND_BLANK (result);
      string_append (result, "wchar_t");
      string_append (result, "wchar_t");
      tk = tk_char;
      tk = tk_char;
      break;
      break;
    case 'r':
    case 'r':
      (*mangled)++;
      (*mangled)++;
      APPEND_BLANK (result);
      APPEND_BLANK (result);
      string_append (result, "long double");
      string_append (result, "long double");
      tk = tk_real;
      tk = tk_real;
      break;
      break;
    case 'd':
    case 'd':
      (*mangled)++;
      (*mangled)++;
      APPEND_BLANK (result);
      APPEND_BLANK (result);
      string_append (result, "double");
      string_append (result, "double");
      tk = tk_real;
      tk = tk_real;
      break;
      break;
    case 'f':
    case 'f':
      (*mangled)++;
      (*mangled)++;
      APPEND_BLANK (result);
      APPEND_BLANK (result);
      string_append (result, "float");
      string_append (result, "float");
      tk = tk_real;
      tk = tk_real;
      break;
      break;
    case 'G':
    case 'G':
      (*mangled)++;
      (*mangled)++;
      if (!ISDIGIT ((unsigned char)**mangled))
      if (!ISDIGIT ((unsigned char)**mangled))
        {
        {
          success = 0;
          success = 0;
          break;
          break;
        }
        }
    case 'I':
    case 'I':
      (*mangled)++;
      (*mangled)++;
      if (**mangled == '_')
      if (**mangled == '_')
        {
        {
          int i;
          int i;
          (*mangled)++;
          (*mangled)++;
          for (i = 0;
          for (i = 0;
               i < (long) sizeof (buf) - 1 && **mangled && **mangled != '_';
               i < (long) sizeof (buf) - 1 && **mangled && **mangled != '_';
               (*mangled)++, i++)
               (*mangled)++, i++)
            buf[i] = **mangled;
            buf[i] = **mangled;
          if (**mangled != '_')
          if (**mangled != '_')
            {
            {
              success = 0;
              success = 0;
              break;
              break;
            }
            }
          buf[i] = '\0';
          buf[i] = '\0';
          (*mangled)++;
          (*mangled)++;
        }
        }
      else
      else
        {
        {
          strncpy (buf, *mangled, 2);
          strncpy (buf, *mangled, 2);
          buf[2] = '\0';
          buf[2] = '\0';
          *mangled += min (strlen (*mangled), 2);
          *mangled += min (strlen (*mangled), 2);
        }
        }
      sscanf (buf, "%x", &dec);
      sscanf (buf, "%x", &dec);
      sprintf (buf, "int%u_t", dec);
      sprintf (buf, "int%u_t", dec);
      APPEND_BLANK (result);
      APPEND_BLANK (result);
      string_append (result, buf);
      string_append (result, buf);
      break;
      break;
 
 
      /* fall through */
      /* fall through */
      /* An explicit type, such as "6mytype" or "7integer" */
      /* An explicit type, such as "6mytype" or "7integer" */
    case '0':
    case '0':
    case '1':
    case '1':
    case '2':
    case '2':
    case '3':
    case '3':
    case '4':
    case '4':
    case '5':
    case '5':
    case '6':
    case '6':
    case '7':
    case '7':
    case '8':
    case '8':
    case '9':
    case '9':
      {
      {
        int bindex = register_Btype (work);
        int bindex = register_Btype (work);
        string btype;
        string btype;
        string_init (&btype);
        string_init (&btype);
        if (demangle_class_name (work, mangled, &btype)) {
        if (demangle_class_name (work, mangled, &btype)) {
          remember_Btype (work, btype.b, LEN_STRING (&btype), bindex);
          remember_Btype (work, btype.b, LEN_STRING (&btype), bindex);
          APPEND_BLANK (result);
          APPEND_BLANK (result);
          string_appends (result, &btype);
          string_appends (result, &btype);
        }
        }
        else
        else
          success = 0;
          success = 0;
        string_delete (&btype);
        string_delete (&btype);
        break;
        break;
      }
      }
    case 't':
    case 't':
      {
      {
        string btype;
        string btype;
        string_init (&btype);
        string_init (&btype);
        success = demangle_template (work, mangled, &btype, 0, 1, 1);
        success = demangle_template (work, mangled, &btype, 0, 1, 1);
        string_appends (result, &btype);
        string_appends (result, &btype);
        string_delete (&btype);
        string_delete (&btype);
        break;
        break;
      }
      }
    default:
    default:
      success = 0;
      success = 0;
      break;
      break;
    }
    }
 
 
  return success ? ((int) tk) : 0;
  return success ? ((int) tk) : 0;
}
}
 
 
 
 
/* Handle a template's value parameter for HP aCC (extension from ARM)
/* Handle a template's value parameter for HP aCC (extension from ARM)
   **mangled points to 'S' or 'U' */
   **mangled points to 'S' or 'U' */
 
 
static int
static int
do_hpacc_template_const_value (struct work_stuff *work ATTRIBUTE_UNUSED,
do_hpacc_template_const_value (struct work_stuff *work ATTRIBUTE_UNUSED,
                               const char **mangled, string *result)
                               const char **mangled, string *result)
{
{
  int unsigned_const;
  int unsigned_const;
 
 
  if (**mangled != 'U' && **mangled != 'S')
  if (**mangled != 'U' && **mangled != 'S')
    return 0;
    return 0;
 
 
  unsigned_const = (**mangled == 'U');
  unsigned_const = (**mangled == 'U');
 
 
  (*mangled)++;
  (*mangled)++;
 
 
  switch (**mangled)
  switch (**mangled)
    {
    {
      case 'N':
      case 'N':
        string_append (result, "-");
        string_append (result, "-");
        /* fall through */
        /* fall through */
      case 'P':
      case 'P':
        (*mangled)++;
        (*mangled)++;
        break;
        break;
      case 'M':
      case 'M':
        /* special case for -2^31 */
        /* special case for -2^31 */
        string_append (result, "-2147483648");
        string_append (result, "-2147483648");
        (*mangled)++;
        (*mangled)++;
        return 1;
        return 1;
      default:
      default:
        return 0;
        return 0;
    }
    }
 
 
  /* We have to be looking at an integer now */
  /* We have to be looking at an integer now */
  if (!(ISDIGIT ((unsigned char)**mangled)))
  if (!(ISDIGIT ((unsigned char)**mangled)))
    return 0;
    return 0;
 
 
  /* We only deal with integral values for template
  /* We only deal with integral values for template
     parameters -- so it's OK to look only for digits */
     parameters -- so it's OK to look only for digits */
  while (ISDIGIT ((unsigned char)**mangled))
  while (ISDIGIT ((unsigned char)**mangled))
    {
    {
      char_str[0] = **mangled;
      char_str[0] = **mangled;
      string_append (result, char_str);
      string_append (result, char_str);
      (*mangled)++;
      (*mangled)++;
    }
    }
 
 
  if (unsigned_const)
  if (unsigned_const)
    string_append (result, "U");
    string_append (result, "U");
 
 
  /* FIXME? Some day we may have 64-bit (or larger :-) ) constants
  /* FIXME? Some day we may have 64-bit (or larger :-) ) constants
     with L or LL suffixes. pai/1997-09-03 */
     with L or LL suffixes. pai/1997-09-03 */
 
 
  return 1; /* success */
  return 1; /* success */
}
}
 
 
/* Handle a template's literal parameter for HP aCC (extension from ARM)
/* Handle a template's literal parameter for HP aCC (extension from ARM)
   **mangled is pointing to the 'A' */
   **mangled is pointing to the 'A' */
 
 
static int
static int
do_hpacc_template_literal (struct work_stuff *work, const char **mangled,
do_hpacc_template_literal (struct work_stuff *work, const char **mangled,
                           string *result)
                           string *result)
{
{
  int literal_len = 0;
  int literal_len = 0;
  char * recurse;
  char * recurse;
  char * recurse_dem;
  char * recurse_dem;
 
 
  if (**mangled != 'A')
  if (**mangled != 'A')
    return 0;
    return 0;
 
 
  (*mangled)++;
  (*mangled)++;
 
 
  literal_len = consume_count (mangled);
  literal_len = consume_count (mangled);
 
 
  if (literal_len <= 0)
  if (literal_len <= 0)
    return 0;
    return 0;
 
 
  /* Literal parameters are names of arrays, functions, etc.  and the
  /* Literal parameters are names of arrays, functions, etc.  and the
     canonical representation uses the address operator */
     canonical representation uses the address operator */
  string_append (result, "&");
  string_append (result, "&");
 
 
  /* Now recursively demangle the literal name */
  /* Now recursively demangle the literal name */
  recurse = XNEWVEC (char, literal_len + 1);
  recurse = XNEWVEC (char, literal_len + 1);
  memcpy (recurse, *mangled, literal_len);
  memcpy (recurse, *mangled, literal_len);
  recurse[literal_len] = '\000';
  recurse[literal_len] = '\000';
 
 
  recurse_dem = cplus_demangle (recurse, work->options);
  recurse_dem = cplus_demangle (recurse, work->options);
 
 
  if (recurse_dem)
  if (recurse_dem)
    {
    {
      string_append (result, recurse_dem);
      string_append (result, recurse_dem);
      free (recurse_dem);
      free (recurse_dem);
    }
    }
  else
  else
    {
    {
      string_appendn (result, *mangled, literal_len);
      string_appendn (result, *mangled, literal_len);
    }
    }
  (*mangled) += literal_len;
  (*mangled) += literal_len;
  free (recurse);
  free (recurse);
 
 
  return 1;
  return 1;
}
}
 
 
static int
static int
snarf_numeric_literal (const char **args, string *arg)
snarf_numeric_literal (const char **args, string *arg)
{
{
  if (**args == '-')
  if (**args == '-')
    {
    {
      char_str[0] = '-';
      char_str[0] = '-';
      string_append (arg, char_str);
      string_append (arg, char_str);
      (*args)++;
      (*args)++;
    }
    }
  else if (**args == '+')
  else if (**args == '+')
    (*args)++;
    (*args)++;
 
 
  if (!ISDIGIT ((unsigned char)**args))
  if (!ISDIGIT ((unsigned char)**args))
    return 0;
    return 0;
 
 
  while (ISDIGIT ((unsigned char)**args))
  while (ISDIGIT ((unsigned char)**args))
    {
    {
      char_str[0] = **args;
      char_str[0] = **args;
      string_append (arg, char_str);
      string_append (arg, char_str);
      (*args)++;
      (*args)++;
    }
    }
 
 
  return 1;
  return 1;
}
}
 
 
/* Demangle the next argument, given by MANGLED into RESULT, which
/* Demangle the next argument, given by MANGLED into RESULT, which
   *should be an uninitialized* string.  It will be initialized here,
   *should be an uninitialized* string.  It will be initialized here,
   and free'd should anything go wrong.  */
   and free'd should anything go wrong.  */
 
 
static int
static int
do_arg (struct work_stuff *work, const char **mangled, string *result)
do_arg (struct work_stuff *work, const char **mangled, string *result)
{
{
  /* Remember where we started so that we can record the type, for
  /* Remember where we started so that we can record the type, for
     non-squangling type remembering.  */
     non-squangling type remembering.  */
  const char *start = *mangled;
  const char *start = *mangled;
 
 
  string_init (result);
  string_init (result);
 
 
  if (work->nrepeats > 0)
  if (work->nrepeats > 0)
    {
    {
      --work->nrepeats;
      --work->nrepeats;
 
 
      if (work->previous_argument == 0)
      if (work->previous_argument == 0)
        return 0;
        return 0;
 
 
      /* We want to reissue the previous type in this argument list.  */
      /* We want to reissue the previous type in this argument list.  */
      string_appends (result, work->previous_argument);
      string_appends (result, work->previous_argument);
      return 1;
      return 1;
    }
    }
 
 
  if (**mangled == 'n')
  if (**mangled == 'n')
    {
    {
      /* A squangling-style repeat.  */
      /* A squangling-style repeat.  */
      (*mangled)++;
      (*mangled)++;
      work->nrepeats = consume_count(mangled);
      work->nrepeats = consume_count(mangled);
 
 
      if (work->nrepeats <= 0)
      if (work->nrepeats <= 0)
        /* This was not a repeat count after all.  */
        /* This was not a repeat count after all.  */
        return 0;
        return 0;
 
 
      if (work->nrepeats > 9)
      if (work->nrepeats > 9)
        {
        {
          if (**mangled != '_')
          if (**mangled != '_')
            /* The repeat count should be followed by an '_' in this
            /* The repeat count should be followed by an '_' in this
               case.  */
               case.  */
            return 0;
            return 0;
          else
          else
            (*mangled)++;
            (*mangled)++;
        }
        }
 
 
      /* Now, the repeat is all set up.  */
      /* Now, the repeat is all set up.  */
      return do_arg (work, mangled, result);
      return do_arg (work, mangled, result);
    }
    }
 
 
  /* Save the result in WORK->previous_argument so that we can find it
  /* Save the result in WORK->previous_argument so that we can find it
     if it's repeated.  Note that saving START is not good enough: we
     if it's repeated.  Note that saving START is not good enough: we
     do not want to add additional types to the back-referenceable
     do not want to add additional types to the back-referenceable
     type vector when processing a repeated type.  */
     type vector when processing a repeated type.  */
  if (work->previous_argument)
  if (work->previous_argument)
    string_delete (work->previous_argument);
    string_delete (work->previous_argument);
  else
  else
    work->previous_argument = XNEW (string);
    work->previous_argument = XNEW (string);
 
 
  if (!do_type (work, mangled, work->previous_argument))
  if (!do_type (work, mangled, work->previous_argument))
    return 0;
    return 0;
 
 
  string_appends (result, work->previous_argument);
  string_appends (result, work->previous_argument);
 
 
  remember_type (work, start, *mangled - start);
  remember_type (work, start, *mangled - start);
  return 1;
  return 1;
}
}
 
 
static void
static void
remember_type (struct work_stuff *work, const char *start, int len)
remember_type (struct work_stuff *work, const char *start, int len)
{
{
  char *tem;
  char *tem;
 
 
  if (work->forgetting_types)
  if (work->forgetting_types)
    return;
    return;
 
 
  if (work -> ntypes >= work -> typevec_size)
  if (work -> ntypes >= work -> typevec_size)
    {
    {
      if (work -> typevec_size == 0)
      if (work -> typevec_size == 0)
        {
        {
          work -> typevec_size = 3;
          work -> typevec_size = 3;
          work -> typevec = XNEWVEC (char *, work->typevec_size);
          work -> typevec = XNEWVEC (char *, work->typevec_size);
        }
        }
      else
      else
        {
        {
          work -> typevec_size *= 2;
          work -> typevec_size *= 2;
          work -> typevec
          work -> typevec
            = XRESIZEVEC (char *, work->typevec, work->typevec_size);
            = XRESIZEVEC (char *, work->typevec, work->typevec_size);
        }
        }
    }
    }
  tem = XNEWVEC (char, len + 1);
  tem = XNEWVEC (char, len + 1);
  memcpy (tem, start, len);
  memcpy (tem, start, len);
  tem[len] = '\0';
  tem[len] = '\0';
  work -> typevec[work -> ntypes++] = tem;
  work -> typevec[work -> ntypes++] = tem;
}
}
 
 
 
 
/* Remember a K type class qualifier. */
/* Remember a K type class qualifier. */
static void
static void
remember_Ktype (struct work_stuff *work, const char *start, int len)
remember_Ktype (struct work_stuff *work, const char *start, int len)
{
{
  char *tem;
  char *tem;
 
 
  if (work -> numk >= work -> ksize)
  if (work -> numk >= work -> ksize)
    {
    {
      if (work -> ksize == 0)
      if (work -> ksize == 0)
        {
        {
          work -> ksize = 5;
          work -> ksize = 5;
          work -> ktypevec = XNEWVEC (char *, work->ksize);
          work -> ktypevec = XNEWVEC (char *, work->ksize);
        }
        }
      else
      else
        {
        {
          work -> ksize *= 2;
          work -> ksize *= 2;
          work -> ktypevec
          work -> ktypevec
            = XRESIZEVEC (char *, work->ktypevec, work->ksize);
            = XRESIZEVEC (char *, work->ktypevec, work->ksize);
        }
        }
    }
    }
  tem = XNEWVEC (char, len + 1);
  tem = XNEWVEC (char, len + 1);
  memcpy (tem, start, len);
  memcpy (tem, start, len);
  tem[len] = '\0';
  tem[len] = '\0';
  work -> ktypevec[work -> numk++] = tem;
  work -> ktypevec[work -> numk++] = tem;
}
}
 
 
/* Register a B code, and get an index for it. B codes are registered
/* Register a B code, and get an index for it. B codes are registered
   as they are seen, rather than as they are completed, so map<temp<char> >
   as they are seen, rather than as they are completed, so map<temp<char> >
   registers map<temp<char> > as B0, and temp<char> as B1 */
   registers map<temp<char> > as B0, and temp<char> as B1 */
 
 
static int
static int
register_Btype (struct work_stuff *work)
register_Btype (struct work_stuff *work)
{
{
  int ret;
  int ret;
 
 
  if (work -> numb >= work -> bsize)
  if (work -> numb >= work -> bsize)
    {
    {
      if (work -> bsize == 0)
      if (work -> bsize == 0)
        {
        {
          work -> bsize = 5;
          work -> bsize = 5;
          work -> btypevec = XNEWVEC (char *, work->bsize);
          work -> btypevec = XNEWVEC (char *, work->bsize);
        }
        }
      else
      else
        {
        {
          work -> bsize *= 2;
          work -> bsize *= 2;
          work -> btypevec
          work -> btypevec
            = XRESIZEVEC (char *, work->btypevec, work->bsize);
            = XRESIZEVEC (char *, work->btypevec, work->bsize);
        }
        }
    }
    }
  ret = work -> numb++;
  ret = work -> numb++;
  work -> btypevec[ret] = NULL;
  work -> btypevec[ret] = NULL;
  return(ret);
  return(ret);
}
}
 
 
/* Store a value into a previously registered B code type. */
/* Store a value into a previously registered B code type. */
 
 
static void
static void
remember_Btype (struct work_stuff *work, const char *start,
remember_Btype (struct work_stuff *work, const char *start,
                int len, int index)
                int len, int index)
{
{
  char *tem;
  char *tem;
 
 
  tem = XNEWVEC (char, len + 1);
  tem = XNEWVEC (char, len + 1);
  memcpy (tem, start, len);
  memcpy (tem, start, len);
  tem[len] = '\0';
  tem[len] = '\0';
  work -> btypevec[index] = tem;
  work -> btypevec[index] = tem;
}
}
 
 
/* Lose all the info related to B and K type codes. */
/* Lose all the info related to B and K type codes. */
static void
static void
forget_B_and_K_types (struct work_stuff *work)
forget_B_and_K_types (struct work_stuff *work)
{
{
  int i;
  int i;
 
 
  while (work -> numk > 0)
  while (work -> numk > 0)
    {
    {
      i = --(work -> numk);
      i = --(work -> numk);
      if (work -> ktypevec[i] != NULL)
      if (work -> ktypevec[i] != NULL)
        {
        {
          free (work -> ktypevec[i]);
          free (work -> ktypevec[i]);
          work -> ktypevec[i] = NULL;
          work -> ktypevec[i] = NULL;
        }
        }
    }
    }
 
 
  while (work -> numb > 0)
  while (work -> numb > 0)
    {
    {
      i = --(work -> numb);
      i = --(work -> numb);
      if (work -> btypevec[i] != NULL)
      if (work -> btypevec[i] != NULL)
        {
        {
          free (work -> btypevec[i]);
          free (work -> btypevec[i]);
          work -> btypevec[i] = NULL;
          work -> btypevec[i] = NULL;
        }
        }
    }
    }
}
}
/* Forget the remembered types, but not the type vector itself.  */
/* Forget the remembered types, but not the type vector itself.  */
 
 
static void
static void
forget_types (struct work_stuff *work)
forget_types (struct work_stuff *work)
{
{
  int i;
  int i;
 
 
  while (work -> ntypes > 0)
  while (work -> ntypes > 0)
    {
    {
      i = --(work -> ntypes);
      i = --(work -> ntypes);
      if (work -> typevec[i] != NULL)
      if (work -> typevec[i] != NULL)
        {
        {
          free (work -> typevec[i]);
          free (work -> typevec[i]);
          work -> typevec[i] = NULL;
          work -> typevec[i] = NULL;
        }
        }
    }
    }
}
}
 
 
/* Process the argument list part of the signature, after any class spec
/* Process the argument list part of the signature, after any class spec
   has been consumed, as well as the first 'F' character (if any).  For
   has been consumed, as well as the first 'F' character (if any).  For
   example:
   example:
 
 
   "__als__3fooRT0"             =>      process "RT0"
   "__als__3fooRT0"             =>      process "RT0"
   "complexfunc5__FPFPc_PFl_i"  =>      process "PFPc_PFl_i"
   "complexfunc5__FPFPc_PFl_i"  =>      process "PFPc_PFl_i"
 
 
   DECLP must be already initialised, usually non-empty.  It won't be freed
   DECLP must be already initialised, usually non-empty.  It won't be freed
   on failure.
   on failure.
 
 
   Note that g++ differs significantly from ARM and lucid style mangling
   Note that g++ differs significantly from ARM and lucid style mangling
   with regards to references to previously seen types.  For example, given
   with regards to references to previously seen types.  For example, given
   the source fragment:
   the source fragment:
 
 
     class foo {
     class foo {
       public:
       public:
       foo::foo (int, foo &ia, int, foo &ib, int, foo &ic);
       foo::foo (int, foo &ia, int, foo &ib, int, foo &ic);
     };
     };
 
 
     foo::foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
     foo::foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
     void foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
     void foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
 
 
   g++ produces the names:
   g++ produces the names:
 
 
     __3fooiRT0iT2iT2
     __3fooiRT0iT2iT2
     foo__FiR3fooiT1iT1
     foo__FiR3fooiT1iT1
 
 
   while lcc (and presumably other ARM style compilers as well) produces:
   while lcc (and presumably other ARM style compilers as well) produces:
 
 
     foo__FiR3fooT1T2T1T2
     foo__FiR3fooT1T2T1T2
     __ct__3fooFiR3fooT1T2T1T2
     __ct__3fooFiR3fooT1T2T1T2
 
 
   Note that g++ bases its type numbers starting at zero and counts all
   Note that g++ bases its type numbers starting at zero and counts all
   previously seen types, while lucid/ARM bases its type numbers starting
   previously seen types, while lucid/ARM bases its type numbers starting
   at one and only considers types after it has seen the 'F' character
   at one and only considers types after it has seen the 'F' character
   indicating the start of the function args.  For lucid/ARM style, we
   indicating the start of the function args.  For lucid/ARM style, we
   account for this difference by discarding any previously seen types when
   account for this difference by discarding any previously seen types when
   we see the 'F' character, and subtracting one from the type number
   we see the 'F' character, and subtracting one from the type number
   reference.
   reference.
 
 
 */
 */
 
 
static int
static int
demangle_args (struct work_stuff *work, const char **mangled,
demangle_args (struct work_stuff *work, const char **mangled,
               string *declp)
               string *declp)
{
{
  string arg;
  string arg;
  int need_comma = 0;
  int need_comma = 0;
  int r;
  int r;
  int t;
  int t;
  const char *tem;
  const char *tem;
  char temptype;
  char temptype;
 
 
  if (PRINT_ARG_TYPES)
  if (PRINT_ARG_TYPES)
    {
    {
      string_append (declp, "(");
      string_append (declp, "(");
      if (**mangled == '\0')
      if (**mangled == '\0')
        {
        {
          string_append (declp, "void");
          string_append (declp, "void");
        }
        }
    }
    }
 
 
  while ((**mangled != '_' && **mangled != '\0' && **mangled != 'e')
  while ((**mangled != '_' && **mangled != '\0' && **mangled != 'e')
         || work->nrepeats > 0)
         || work->nrepeats > 0)
    {
    {
      if ((**mangled == 'N') || (**mangled == 'T'))
      if ((**mangled == 'N') || (**mangled == 'T'))
        {
        {
          temptype = *(*mangled)++;
          temptype = *(*mangled)++;
 
 
          if (temptype == 'N')
          if (temptype == 'N')
            {
            {
              if (!get_count (mangled, &r))
              if (!get_count (mangled, &r))
                {
                {
                  return (0);
                  return (0);
                }
                }
            }
            }
          else
          else
            {
            {
              r = 1;
              r = 1;
            }
            }
          if ((HP_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING) && work -> ntypes >= 10)
          if ((HP_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING) && work -> ntypes >= 10)
            {
            {
              /* If we have 10 or more types we might have more than a 1 digit
              /* If we have 10 or more types we might have more than a 1 digit
                 index so we'll have to consume the whole count here. This
                 index so we'll have to consume the whole count here. This
                 will lose if the next thing is a type name preceded by a
                 will lose if the next thing is a type name preceded by a
                 count but it's impossible to demangle that case properly
                 count but it's impossible to demangle that case properly
                 anyway. Eg if we already have 12 types is T12Pc "(..., type1,
                 anyway. Eg if we already have 12 types is T12Pc "(..., type1,
                 Pc, ...)"  or "(..., type12, char *, ...)" */
                 Pc, ...)"  or "(..., type12, char *, ...)" */
              if ((t = consume_count(mangled)) <= 0)
              if ((t = consume_count(mangled)) <= 0)
                {
                {
                  return (0);
                  return (0);
                }
                }
            }
            }
          else
          else
            {
            {
              if (!get_count (mangled, &t))
              if (!get_count (mangled, &t))
                {
                {
                  return (0);
                  return (0);
                }
                }
            }
            }
          if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
          if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
            {
            {
              t--;
              t--;
            }
            }
          /* Validate the type index.  Protect against illegal indices from
          /* Validate the type index.  Protect against illegal indices from
             malformed type strings.  */
             malformed type strings.  */
          if ((t < 0) || (t >= work -> ntypes))
          if ((t < 0) || (t >= work -> ntypes))
            {
            {
              return (0);
              return (0);
            }
            }
          while (work->nrepeats > 0 || --r >= 0)
          while (work->nrepeats > 0 || --r >= 0)
            {
            {
              tem = work -> typevec[t];
              tem = work -> typevec[t];
              if (need_comma && PRINT_ARG_TYPES)
              if (need_comma && PRINT_ARG_TYPES)
                {
                {
                  string_append (declp, ", ");
                  string_append (declp, ", ");
                }
                }
              if (!do_arg (work, &tem, &arg))
              if (!do_arg (work, &tem, &arg))
                {
                {
                  return (0);
                  return (0);
                }
                }
              if (PRINT_ARG_TYPES)
              if (PRINT_ARG_TYPES)
                {
                {
                  string_appends (declp, &arg);
                  string_appends (declp, &arg);
                }
                }
              string_delete (&arg);
              string_delete (&arg);
              need_comma = 1;
              need_comma = 1;
            }
            }
        }
        }
      else
      else
        {
        {
          if (need_comma && PRINT_ARG_TYPES)
          if (need_comma && PRINT_ARG_TYPES)
            string_append (declp, ", ");
            string_append (declp, ", ");
          if (!do_arg (work, mangled, &arg))
          if (!do_arg (work, mangled, &arg))
            return (0);
            return (0);
          if (PRINT_ARG_TYPES)
          if (PRINT_ARG_TYPES)
            string_appends (declp, &arg);
            string_appends (declp, &arg);
          string_delete (&arg);
          string_delete (&arg);
          need_comma = 1;
          need_comma = 1;
        }
        }
    }
    }
 
 
  if (**mangled == 'e')
  if (**mangled == 'e')
    {
    {
      (*mangled)++;
      (*mangled)++;
      if (PRINT_ARG_TYPES)
      if (PRINT_ARG_TYPES)
        {
        {
          if (need_comma)
          if (need_comma)
            {
            {
              string_append (declp, ",");
              string_append (declp, ",");
            }
            }
          string_append (declp, "...");
          string_append (declp, "...");
        }
        }
    }
    }
 
 
  if (PRINT_ARG_TYPES)
  if (PRINT_ARG_TYPES)
    {
    {
      string_append (declp, ")");
      string_append (declp, ")");
    }
    }
  return (1);
  return (1);
}
}
 
 
/* Like demangle_args, but for demangling the argument lists of function
/* Like demangle_args, but for demangling the argument lists of function
   and method pointers or references, not top-level declarations.  */
   and method pointers or references, not top-level declarations.  */
 
 
static int
static int
demangle_nested_args (struct work_stuff *work, const char **mangled,
demangle_nested_args (struct work_stuff *work, const char **mangled,
                      string *declp)
                      string *declp)
{
{
  string* saved_previous_argument;
  string* saved_previous_argument;
  int result;
  int result;
  int saved_nrepeats;
  int saved_nrepeats;
 
 
  /* The G++ name-mangling algorithm does not remember types on nested
  /* The G++ name-mangling algorithm does not remember types on nested
     argument lists, unless -fsquangling is used, and in that case the
     argument lists, unless -fsquangling is used, and in that case the
     type vector updated by remember_type is not used.  So, we turn
     type vector updated by remember_type is not used.  So, we turn
     off remembering of types here.  */
     off remembering of types here.  */
  ++work->forgetting_types;
  ++work->forgetting_types;
 
 
  /* For the repeat codes used with -fsquangling, we must keep track of
  /* For the repeat codes used with -fsquangling, we must keep track of
     the last argument.  */
     the last argument.  */
  saved_previous_argument = work->previous_argument;
  saved_previous_argument = work->previous_argument;
  saved_nrepeats = work->nrepeats;
  saved_nrepeats = work->nrepeats;
  work->previous_argument = 0;
  work->previous_argument = 0;
  work->nrepeats = 0;
  work->nrepeats = 0;
 
 
  /* Actually demangle the arguments.  */
  /* Actually demangle the arguments.  */
  result = demangle_args (work, mangled, declp);
  result = demangle_args (work, mangled, declp);
 
 
  /* Restore the previous_argument field.  */
  /* Restore the previous_argument field.  */
  if (work->previous_argument)
  if (work->previous_argument)
    {
    {
      string_delete (work->previous_argument);
      string_delete (work->previous_argument);
      free ((char *) work->previous_argument);
      free ((char *) work->previous_argument);
    }
    }
  work->previous_argument = saved_previous_argument;
  work->previous_argument = saved_previous_argument;
  --work->forgetting_types;
  --work->forgetting_types;
  work->nrepeats = saved_nrepeats;
  work->nrepeats = saved_nrepeats;
 
 
  return result;
  return result;
}
}
 
 
/* Returns 1 if a valid function name was found or 0 otherwise.  */
/* Returns 1 if a valid function name was found or 0 otherwise.  */
 
 
static int
static int
demangle_function_name (struct work_stuff *work, const char **mangled,
demangle_function_name (struct work_stuff *work, const char **mangled,
                        string *declp, const char *scan)
                        string *declp, const char *scan)
{
{
  size_t i;
  size_t i;
  string type;
  string type;
  const char *tem;
  const char *tem;
 
 
  string_appendn (declp, (*mangled), scan - (*mangled));
  string_appendn (declp, (*mangled), scan - (*mangled));
  string_need (declp, 1);
  string_need (declp, 1);
  *(declp -> p) = '\0';
  *(declp -> p) = '\0';
 
 
  /* Consume the function name, including the "__" separating the name
  /* Consume the function name, including the "__" separating the name
     from the signature.  We are guaranteed that SCAN points to the
     from the signature.  We are guaranteed that SCAN points to the
     separator.  */
     separator.  */
 
 
  (*mangled) = scan + 2;
  (*mangled) = scan + 2;
  /* We may be looking at an instantiation of a template function:
  /* We may be looking at an instantiation of a template function:
     foo__Xt1t2_Ft3t4, where t1, t2, ... are template arguments and a
     foo__Xt1t2_Ft3t4, where t1, t2, ... are template arguments and a
     following _F marks the start of the function arguments.  Handle
     following _F marks the start of the function arguments.  Handle
     the template arguments first. */
     the template arguments first. */
 
 
  if (HP_DEMANGLING && (**mangled == 'X'))
  if (HP_DEMANGLING && (**mangled == 'X'))
    {
    {
      demangle_arm_hp_template (work, mangled, 0, declp);
      demangle_arm_hp_template (work, mangled, 0, declp);
      /* This leaves MANGLED pointing to the 'F' marking func args */
      /* This leaves MANGLED pointing to the 'F' marking func args */
    }
    }
 
 
  if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
  if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
    {
    {
 
 
      /* See if we have an ARM style constructor or destructor operator.
      /* See if we have an ARM style constructor or destructor operator.
         If so, then just record it, clear the decl, and return.
         If so, then just record it, clear the decl, and return.
         We can't build the actual constructor/destructor decl until later,
         We can't build the actual constructor/destructor decl until later,
         when we recover the class name from the signature.  */
         when we recover the class name from the signature.  */
 
 
      if (strcmp (declp -> b, "__ct") == 0)
      if (strcmp (declp -> b, "__ct") == 0)
        {
        {
          work -> constructor += 1;
          work -> constructor += 1;
          string_clear (declp);
          string_clear (declp);
          return 1;
          return 1;
        }
        }
      else if (strcmp (declp -> b, "__dt") == 0)
      else if (strcmp (declp -> b, "__dt") == 0)
        {
        {
          work -> destructor += 1;
          work -> destructor += 1;
          string_clear (declp);
          string_clear (declp);
          return 1;
          return 1;
        }
        }
    }
    }
 
 
  if (declp->p - declp->b >= 3
  if (declp->p - declp->b >= 3
      && declp->b[0] == 'o'
      && declp->b[0] == 'o'
      && declp->b[1] == 'p'
      && declp->b[1] == 'p'
      && strchr (cplus_markers, declp->b[2]) != NULL)
      && strchr (cplus_markers, declp->b[2]) != NULL)
    {
    {
      /* see if it's an assignment expression */
      /* see if it's an assignment expression */
      if (declp->p - declp->b >= 10 /* op$assign_ */
      if (declp->p - declp->b >= 10 /* op$assign_ */
          && memcmp (declp->b + 3, "assign_", 7) == 0)
          && memcmp (declp->b + 3, "assign_", 7) == 0)
        {
        {
          for (i = 0; i < ARRAY_SIZE (optable); i++)
          for (i = 0; i < ARRAY_SIZE (optable); i++)
            {
            {
              int len = declp->p - declp->b - 10;
              int len = declp->p - declp->b - 10;
              if ((int) strlen (optable[i].in) == len
              if ((int) strlen (optable[i].in) == len
                  && memcmp (optable[i].in, declp->b + 10, len) == 0)
                  && memcmp (optable[i].in, declp->b + 10, len) == 0)
                {
                {
                  string_clear (declp);
                  string_clear (declp);
                  string_append (declp, "operator");
                  string_append (declp, "operator");
                  string_append (declp, optable[i].out);
                  string_append (declp, optable[i].out);
                  string_append (declp, "=");
                  string_append (declp, "=");
                  break;
                  break;
                }
                }
            }
            }
        }
        }
      else
      else
        {
        {
          for (i = 0; i < ARRAY_SIZE (optable); i++)
          for (i = 0; i < ARRAY_SIZE (optable); i++)
            {
            {
              int len = declp->p - declp->b - 3;
              int len = declp->p - declp->b - 3;
              if ((int) strlen (optable[i].in) == len
              if ((int) strlen (optable[i].in) == len
                  && memcmp (optable[i].in, declp->b + 3, len) == 0)
                  && memcmp (optable[i].in, declp->b + 3, len) == 0)
                {
                {
                  string_clear (declp);
                  string_clear (declp);
                  string_append (declp, "operator");
                  string_append (declp, "operator");
                  string_append (declp, optable[i].out);
                  string_append (declp, optable[i].out);
                  break;
                  break;
                }
                }
            }
            }
        }
        }
    }
    }
  else if (declp->p - declp->b >= 5 && memcmp (declp->b, "type", 4) == 0
  else if (declp->p - declp->b >= 5 && memcmp (declp->b, "type", 4) == 0
           && strchr (cplus_markers, declp->b[4]) != NULL)
           && strchr (cplus_markers, declp->b[4]) != NULL)
    {
    {
      /* type conversion operator */
      /* type conversion operator */
      tem = declp->b + 5;
      tem = declp->b + 5;
      if (do_type (work, &tem, &type))
      if (do_type (work, &tem, &type))
        {
        {
          string_clear (declp);
          string_clear (declp);
          string_append (declp, "operator ");
          string_append (declp, "operator ");
          string_appends (declp, &type);
          string_appends (declp, &type);
          string_delete (&type);
          string_delete (&type);
        }
        }
    }
    }
  else if (declp->b[0] == '_' && declp->b[1] == '_'
  else if (declp->b[0] == '_' && declp->b[1] == '_'
           && declp->b[2] == 'o' && declp->b[3] == 'p')
           && declp->b[2] == 'o' && declp->b[3] == 'p')
    {
    {
      /* ANSI.  */
      /* ANSI.  */
      /* type conversion operator.  */
      /* type conversion operator.  */
      tem = declp->b + 4;
      tem = declp->b + 4;
      if (do_type (work, &tem, &type))
      if (do_type (work, &tem, &type))
        {
        {
          string_clear (declp);
          string_clear (declp);
          string_append (declp, "operator ");
          string_append (declp, "operator ");
          string_appends (declp, &type);
          string_appends (declp, &type);
          string_delete (&type);
          string_delete (&type);
        }
        }
    }
    }
  else if (declp->b[0] == '_' && declp->b[1] == '_'
  else if (declp->b[0] == '_' && declp->b[1] == '_'
           && ISLOWER((unsigned char)declp->b[2])
           && ISLOWER((unsigned char)declp->b[2])
           && ISLOWER((unsigned char)declp->b[3]))
           && ISLOWER((unsigned char)declp->b[3]))
    {
    {
      if (declp->b[4] == '\0')
      if (declp->b[4] == '\0')
        {
        {
          /* Operator.  */
          /* Operator.  */
          for (i = 0; i < ARRAY_SIZE (optable); i++)
          for (i = 0; i < ARRAY_SIZE (optable); i++)
            {
            {
              if (strlen (optable[i].in) == 2
              if (strlen (optable[i].in) == 2
                  && memcmp (optable[i].in, declp->b + 2, 2) == 0)
                  && memcmp (optable[i].in, declp->b + 2, 2) == 0)
                {
                {
                  string_clear (declp);
                  string_clear (declp);
                  string_append (declp, "operator");
                  string_append (declp, "operator");
                  string_append (declp, optable[i].out);
                  string_append (declp, optable[i].out);
                  break;
                  break;
                }
                }
            }
            }
        }
        }
      else
      else
        {
        {
          if (declp->b[2] == 'a' && declp->b[5] == '\0')
          if (declp->b[2] == 'a' && declp->b[5] == '\0')
            {
            {
              /* Assignment.  */
              /* Assignment.  */
              for (i = 0; i < ARRAY_SIZE (optable); i++)
              for (i = 0; i < ARRAY_SIZE (optable); i++)
                {
                {
                  if (strlen (optable[i].in) == 3
                  if (strlen (optable[i].in) == 3
                      && memcmp (optable[i].in, declp->b + 2, 3) == 0)
                      && memcmp (optable[i].in, declp->b + 2, 3) == 0)
                    {
                    {
                      string_clear (declp);
                      string_clear (declp);
                      string_append (declp, "operator");
                      string_append (declp, "operator");
                      string_append (declp, optable[i].out);
                      string_append (declp, optable[i].out);
                      break;
                      break;
                    }
                    }
                }
                }
            }
            }
        }
        }
    }
    }
 
 
  /* If a function name was obtained but it's not valid, we were not
  /* If a function name was obtained but it's not valid, we were not
     successful.  */
     successful.  */
  if (LEN_STRING (declp) == 1 && declp->b[0] == '.')
  if (LEN_STRING (declp) == 1 && declp->b[0] == '.')
    return 0;
    return 0;
  else
  else
    return 1;
    return 1;
}
}
 
 
/* a mini string-handling package */
/* a mini string-handling package */
 
 
static void
static void
string_need (string *s, int n)
string_need (string *s, int n)
{
{
  int tem;
  int tem;
 
 
  if (s->b == NULL)
  if (s->b == NULL)
    {
    {
      if (n < 32)
      if (n < 32)
        {
        {
          n = 32;
          n = 32;
        }
        }
      s->p = s->b = XNEWVEC (char, n);
      s->p = s->b = XNEWVEC (char, n);
      s->e = s->b + n;
      s->e = s->b + n;
    }
    }
  else if (s->e - s->p < n)
  else if (s->e - s->p < n)
    {
    {
      tem = s->p - s->b;
      tem = s->p - s->b;
      n += tem;
      n += tem;
      n *= 2;
      n *= 2;
      s->b = XRESIZEVEC (char, s->b, n);
      s->b = XRESIZEVEC (char, s->b, n);
      s->p = s->b + tem;
      s->p = s->b + tem;
      s->e = s->b + n;
      s->e = s->b + n;
    }
    }
}
}
 
 
static void
static void
string_delete (string *s)
string_delete (string *s)
{
{
  if (s->b != NULL)
  if (s->b != NULL)
    {
    {
      free (s->b);
      free (s->b);
      s->b = s->e = s->p = NULL;
      s->b = s->e = s->p = NULL;
    }
    }
}
}
 
 
static void
static void
string_init (string *s)
string_init (string *s)
{
{
  s->b = s->p = s->e = NULL;
  s->b = s->p = s->e = NULL;
}
}
 
 
static void
static void
string_clear (string *s)
string_clear (string *s)
{
{
  s->p = s->b;
  s->p = s->b;
}
}
 
 
#if 0
#if 0
 
 
static int
static int
string_empty (string *s)
string_empty (string *s)
{
{
  return (s->b == s->p);
  return (s->b == s->p);
}
}
 
 
#endif
#endif
 
 
static void
static void
string_append (string *p, const char *s)
string_append (string *p, const char *s)
{
{
  int n;
  int n;
  if (s == NULL || *s == '\0')
  if (s == NULL || *s == '\0')
    return;
    return;
  n = strlen (s);
  n = strlen (s);
  string_need (p, n);
  string_need (p, n);
  memcpy (p->p, s, n);
  memcpy (p->p, s, n);
  p->p += n;
  p->p += n;
}
}
 
 
static void
static void
string_appends (string *p, string *s)
string_appends (string *p, string *s)
{
{
  int n;
  int n;
 
 
  if (s->b != s->p)
  if (s->b != s->p)
    {
    {
      n = s->p - s->b;
      n = s->p - s->b;
      string_need (p, n);
      string_need (p, n);
      memcpy (p->p, s->b, n);
      memcpy (p->p, s->b, n);
      p->p += n;
      p->p += n;
    }
    }
}
}
 
 
static void
static void
string_appendn (string *p, const char *s, int n)
string_appendn (string *p, const char *s, int n)
{
{
  if (n != 0)
  if (n != 0)
    {
    {
      string_need (p, n);
      string_need (p, n);
      memcpy (p->p, s, n);
      memcpy (p->p, s, n);
      p->p += n;
      p->p += n;
    }
    }
}
}
 
 
static void
static void
string_prepend (string *p, const char *s)
string_prepend (string *p, const char *s)
{
{
  if (s != NULL && *s != '\0')
  if (s != NULL && *s != '\0')
    {
    {
      string_prependn (p, s, strlen (s));
      string_prependn (p, s, strlen (s));
    }
    }
}
}
 
 
static void
static void
string_prepends (string *p, string *s)
string_prepends (string *p, string *s)
{
{
  if (s->b != s->p)
  if (s->b != s->p)
    {
    {
      string_prependn (p, s->b, s->p - s->b);
      string_prependn (p, s->b, s->p - s->b);
    }
    }
}
}
 
 
static void
static void
string_prependn (string *p, const char *s, int n)
string_prependn (string *p, const char *s, int n)
{
{
  char *q;
  char *q;
 
 
  if (n != 0)
  if (n != 0)
    {
    {
      string_need (p, n);
      string_need (p, n);
      for (q = p->p - 1; q >= p->b; q--)
      for (q = p->p - 1; q >= p->b; q--)
        {
        {
          q[n] = q[0];
          q[n] = q[0];
        }
        }
      memcpy (p->b, s, n);
      memcpy (p->b, s, n);
      p->p += n;
      p->p += n;
    }
    }
}
}
 
 
static void
static void
string_append_template_idx (string *s, int idx)
string_append_template_idx (string *s, int idx)
{
{
  char buf[INTBUF_SIZE + 1 /* 'T' */];
  char buf[INTBUF_SIZE + 1 /* 'T' */];
  sprintf(buf, "T%d", idx);
  sprintf(buf, "T%d", idx);
  string_append (s, buf);
  string_append (s, buf);
}
}
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.