Back to index

cell-binutils  2.17cvs20070401
Classes | Defines | Enumerations | Functions | Variables
cp-demangle.c File Reference
#include <stdio.h>
#include "ansidecl.h"
#include "libiberty.h"
#include "demangle.h"
#include "cp-demangle.h"

Go to the source code of this file.

Classes

struct  d_standard_sub_info
struct  d_print_template
struct  d_print_mod
struct  d_growable_string
struct  d_print_info

Defines

#define CP_STATIC_IF_GLIBCPP_V3
#define IS_DIGIT(c)   ((c) >= '0' && (c) <= '9')
#define IS_UPPER(c)   ((c) >= 'A' && (c) <= 'Z')
#define IS_LOWER(c)   ((c) >= 'a' && (c) <= 'z')
#define ANONYMOUS_NAMESPACE_PREFIX   "_GLOBAL_"
#define ANONYMOUS_NAMESPACE_PREFIX_LEN   (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
#define d_left(dc)   ((dc)->u.s_binary.left)
#define d_right(dc)   ((dc)->u.s_binary.right)
#define NL(s)   s, (sizeof s) - 1

Enumerations

enum  { D_PRINT_BUFFER_LENGTH = 256 }

Functions

char * alloca ()
static struct demangle_componentd_make_empty (struct d_info *)
static struct demangle_componentd_make_comp (struct d_info *, enum demangle_component_type, struct demangle_component *, struct demangle_component *)
static struct demangle_componentd_make_name (struct d_info *, const char *, int)
static struct demangle_componentd_make_builtin_type (struct d_info *, const struct demangle_builtin_type_info *)
static struct demangle_componentd_make_operator (struct d_info *, const struct demangle_operator_info *)
static struct demangle_componentd_make_extended_operator (struct d_info *, int, struct demangle_component *)
static struct demangle_componentd_make_ctor (struct d_info *, enum gnu_v3_ctor_kinds, struct demangle_component *)
static struct demangle_componentd_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds, struct demangle_component *)
static struct demangle_componentd_make_template_param (struct d_info *, long)
static struct demangle_componentd_make_sub (struct d_info *, const char *, int)
static int has_return_type (struct demangle_component *)
static int is_ctor_dtor_or_conversion (struct demangle_component *)
static struct demangle_componentd_encoding (struct d_info *, int)
static struct demangle_componentd_name (struct d_info *)
static struct demangle_componentd_nested_name (struct d_info *)
static struct demangle_componentd_prefix (struct d_info *)
static struct demangle_componentd_unqualified_name (struct d_info *)
static struct demangle_componentd_source_name (struct d_info *)
static long d_number (struct d_info *)
static struct demangle_componentd_identifier (struct d_info *, int)
static struct demangle_componentd_operator_name (struct d_info *)
static struct demangle_componentd_special_name (struct d_info *)
static int d_call_offset (struct d_info *, int)
static struct demangle_componentd_ctor_dtor_name (struct d_info *)
static struct demangle_component ** d_cv_qualifiers (struct d_info *, struct demangle_component **, int)
static struct demangle_componentd_function_type (struct d_info *)
static struct demangle_componentd_bare_function_type (struct d_info *, int)
static struct demangle_componentd_class_enum_type (struct d_info *)
static struct demangle_componentd_array_type (struct d_info *)
static struct demangle_componentd_pointer_to_member_type (struct d_info *)
static struct demangle_componentd_template_param (struct d_info *)
static struct demangle_componentd_template_args (struct d_info *)
static struct demangle_componentd_template_arg (struct d_info *)
static struct demangle_componentd_expression (struct d_info *)
static struct demangle_componentd_expr_primary (struct d_info *)
static struct demangle_componentd_local_name (struct d_info *)
static int d_discriminator (struct d_info *)
static int d_add_substitution (struct d_info *, struct demangle_component *)
static struct demangle_componentd_substitution (struct d_info *, int)
static void d_growable_string_init (struct d_growable_string *, size_t)
static void d_growable_string_resize (struct d_growable_string *, size_t)
static void d_growable_string_append_buffer (struct d_growable_string *, const char *, size_t)
static void d_growable_string_callback_adapter (const char *, size_t, void *)
static void d_print_init (struct d_print_info *, int, demangle_callbackref, void *)
static void d_print_error (struct d_print_info *)
static int d_print_saw_error (struct d_print_info *)
static void d_print_flush (struct d_print_info *)
static void d_append_char (struct d_print_info *, char)
static void d_append_buffer (struct d_print_info *, const char *, size_t)
static void d_append_string (struct d_print_info *, const char *)
static char d_last_char (struct d_print_info *)
static void d_print_comp (struct d_print_info *, const struct demangle_component *)
static void d_print_java_identifier (struct d_print_info *, const char *, int)
static void d_print_mod_list (struct d_print_info *, struct d_print_mod *, int)
static void d_print_mod (struct d_print_info *, const struct demangle_component *)
static void d_print_function_type (struct d_print_info *, const struct demangle_component *, struct d_print_mod *)
static void d_print_array_type (struct d_print_info *, const struct demangle_component *, struct d_print_mod *)
static void d_print_expr_op (struct d_print_info *, const struct demangle_component *)
static void d_print_cast (struct d_print_info *, const struct demangle_component *)
static int d_demangle_callback (const char *, int, demangle_callbackref, void *)
static char * d_demangle (const char *, int, size_t *)
CP_STATIC_IF_GLIBCPP_V3 int cplus_demangle_fill_name (struct demangle_component *p, const char *s, int len)
CP_STATIC_IF_GLIBCPP_V3 int cplus_demangle_fill_extended_operator (struct demangle_component *p, int args, struct demangle_component *name)
CP_STATIC_IF_GLIBCPP_V3 int cplus_demangle_fill_ctor (struct demangle_component *p, enum gnu_v3_ctor_kinds kind, struct demangle_component *name)
CP_STATIC_IF_GLIBCPP_V3 int cplus_demangle_fill_dtor (struct demangle_component *p, enum gnu_v3_dtor_kinds kind, struct demangle_component *name)
CP_STATIC_IF_GLIBCPP_V3 struct
demangle_component
cplus_demangle_mangled_name (struct d_info *di, int top_level)
CP_STATIC_IF_GLIBCPP_V3 struct
demangle_component
cplus_demangle_type (struct d_info *di)
CP_STATIC_IF_GLIBCPP_V3 int cplus_demangle_print_callback (int options, const struct demangle_component *dc, demangle_callbackref callback, void *opaque)
CP_STATIC_IF_GLIBCPP_V3 char * cplus_demangle_print (int options, const struct demangle_component *dc, int estimate, size_t *palc)
CP_STATIC_IF_GLIBCPP_V3 void cplus_demangle_init_info (const char *mangled, int options, size_t len, struct d_info *di)
char * cplus_demangle_v3 (const char *mangled, int options)
int cplus_demangle_v3_callback (const char *mangled, int options, demangle_callbackref callback, void *opaque)
char * java_demangle_v3 (const char *mangled)
int java_demangle_v3_callback (const char *mangled, demangle_callbackref callback, void *opaque)
static int is_ctor_or_dtor (const char *mangled, enum gnu_v3_ctor_kinds *ctor_kind, enum gnu_v3_dtor_kinds *dtor_kind)
enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name)
enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name)

Variables

CP_STATIC_IF_GLIBCPP_V3 struct demangle_operator_info []
CP_STATIC_IF_GLIBCPP_V3 struct demangle_builtin_type_info [D_BUILTIN_TYPE_COUNT]
static struct d_standard_sub_info []

Class Documentation

struct d_standard_sub_info

Definition at line 212 of file cp-demangle.c.

Class Members
char code
const char * full_expansion
int full_len
const char * set_last_name
int set_last_name_len
const char * simple_expansion
int simple_len
struct d_print_template

Definition at line 240 of file cp-demangle.c.

Collaboration diagram for d_print_template:
Class Members
struct d_print_template * next
struct demangle_component * template_decl
struct d_print_mod

Definition at line 250 of file cp-demangle.c.

Collaboration diagram for d_print_mod:
Class Members
struct demangle_component * mod
struct d_print_mod * next
int printed
struct d_print_template * templates
struct d_growable_string

Definition at line 265 of file cp-demangle.c.

Class Members
size_t alc
int allocation_failure
char * buf
size_t len
struct d_print_info

Definition at line 278 of file cp-demangle.c.

Collaboration diagram for d_print_info:
Class Members
char buf
demangle_callbackref callback
int demangle_failure
char last_char
size_t len
struct d_print_mod * modifiers
void * opaque
int options
struct d_print_template * templates

Define Documentation

#define ANONYMOUS_NAMESPACE_PREFIX   "_GLOBAL_"

Definition at line 206 of file cp-demangle.c.

Definition at line 207 of file cp-demangle.c.

Definition at line 174 of file cp-demangle.c.

#define d_left (   dc)    ((dc)->u.s_binary.left)

Definition at line 235 of file cp-demangle.c.

#define d_right (   dc)    ((dc)->u.s_binary.right)

Definition at line 236 of file cp-demangle.c.

#define IS_DIGIT (   c)    ((c) >= '0' && (c) <= '9')

Definition at line 200 of file cp-demangle.c.

#define IS_LOWER (   c)    ((c) >= 'a' && (c) <= 'z')

Definition at line 202 of file cp-demangle.c.

#define IS_UPPER (   c)    ((c) >= 'A' && (c) <= 'Z')

Definition at line 201 of file cp-demangle.c.

#define NL (   s)    s, (sizeof s) - 1

Definition at line 1379 of file cp-demangle.c.


Enumeration Type Documentation

anonymous enum
Enumerator:
D_PRINT_BUFFER_LENGTH 

Definition at line 277 of file cp-demangle.c.


Function Documentation

char* alloca ( )

Definition at line 691 of file cp-demangle.c.

{
  if (p == NULL
      || name == NULL
      || (kind < gnu_v3_complete_object_ctor
         && kind > gnu_v3_complete_object_allocating_ctor))
    return 0;
  p->type = DEMANGLE_COMPONENT_CTOR;
  p->u.s_ctor.kind = kind;
  p->u.s_ctor.name = name;
  return 1;
}

Here is the caller graph for this function:

Definition at line 710 of file cp-demangle.c.

{
  if (p == NULL
      || name == NULL
      || (kind < gnu_v3_deleting_dtor
         && kind > gnu_v3_base_object_dtor))
    return 0;
  p->type = DEMANGLE_COMPONENT_DTOR;
  p->u.s_dtor.kind = kind;
  p->u.s_dtor.name = name;
  return 1;
}

Here is the caller graph for this function:

Definition at line 676 of file cp-demangle.c.

{
  if (p == NULL || args < 0 || name == NULL)
    return 0;
  p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR;
  p->u.s_extended_operator.args = args;
  p->u.s_extended_operator.name = name;
  return 1;
}

Here is the caller graph for this function:

Definition at line 662 of file cp-demangle.c.

{
  if (p == NULL || s == NULL || len == 0)
    return 0;
  p->type = DEMANGLE_COMPONENT_NAME;
  p->u.s_name.s = s;
  p->u.s_name.len = len;
  return 1;
}

Here is the caller graph for this function:

CP_STATIC_IF_GLIBCPP_V3 void cplus_demangle_init_info ( const char *  mangled,
int  options,
size_t  len,
struct d_info di 
)

Definition at line 3908 of file cp-demangle.c.

{
  di->s = mangled;
  di->send = mangled + len;
  di->options = options;

  di->n = mangled;

  /* We can not need more components than twice the number of chars in
     the mangled string.  Most components correspond directly to
     chars, but the ARGLIST types are exceptions.  */
  di->num_comps = 2 * len;
  di->next_comp = 0;

  /* Similarly, we can not need more substitutions than there are
     chars in the mangled string.  */
  di->num_subs = len;
  di->next_sub = 0;
  di->did_subs = 0;

  di->last_name = NULL;

  di->expansion = 0;
}

Here is the caller graph for this function:

Definition at line 960 of file cp-demangle.c.

{
  if (! d_check_char (di, '_'))
    return NULL;
  if (! d_check_char (di, 'Z'))
    return NULL;
  return d_encoding (di, top_level);
}

Here is the call graph for this function:

Here is the caller graph for this function:

CP_STATIC_IF_GLIBCPP_V3 char* cplus_demangle_print ( int  options,
const struct demangle_component dc,
int  estimate,
size_t palc 
)

Definition at line 2805 of file cp-demangle.c.

{
  struct d_growable_string dgs;

  d_growable_string_init (&dgs, estimate);

  if (! cplus_demangle_print_callback (options, dc,
                                       d_growable_string_callback_adapter,
                                       &dgs))
    {
      free (dgs.buf);
      *palc = 0;
      return NULL;
    }

  *palc = dgs.allocation_failure ? 1 : dgs.alc;
  return dgs.buf;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 2780 of file cp-demangle.c.

{
  struct d_print_info dpi;

  d_print_init (&dpi, options, callback, opaque);

  d_print_comp (&dpi, dc);

  d_print_flush (&dpi);

  return ! d_print_saw_error (&dpi);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1753 of file cp-demangle.c.

{
  char peek;
  struct demangle_component *ret;
  int can_subst;

  /* The ABI specifies that when CV-qualifiers are used, the base type
     is substitutable, and the fully qualified type is substitutable,
     but the base type with a strict subset of the CV-qualifiers is
     not substitutable.  The natural recursive implementation of the
     CV-qualifiers would cause subsets to be substitutable, so instead
     we pull them all off now.

     FIXME: The ABI says that order-insensitive vendor qualifiers
     should be handled in the same way, but we have no way to tell
     which vendor qualifiers are order-insensitive and which are
     order-sensitive.  So we just assume that they are all
     order-sensitive.  g++ 3.4 supports only one vendor qualifier,
     __vector, and it treats it as order-sensitive when mangling
     names.  */

  peek = d_peek_char (di);
  if (peek == 'r' || peek == 'V' || peek == 'K')
    {
      struct demangle_component **pret;

      pret = d_cv_qualifiers (di, &ret, 0);
      if (pret == NULL)
       return NULL;
      *pret = cplus_demangle_type (di);
      if (! *pret || ! d_add_substitution (di, ret))
       return NULL;
      return ret;
    }

  can_subst = 1;

  switch (peek)
    {
    case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
    case 'h': case 'i': case 'j':           case 'l': case 'm': case 'n':
    case 'o':                               case 's': case 't':
    case 'v': case 'w': case 'x': case 'y': case 'z':
      ret = d_make_builtin_type (di,
                             &cplus_demangle_builtin_types[peek - 'a']);
      di->expansion += ret->u.s_builtin.type->len;
      can_subst = 0;
      d_advance (di, 1);
      break;

    case 'u':
      d_advance (di, 1);
      ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE,
                      d_source_name (di), NULL);
      break;

    case 'F':
      ret = d_function_type (di);
      break;

    case '0': case '1': case '2': case '3': case '4':
    case '5': case '6': case '7': case '8': case '9':
    case 'N':
    case 'Z':
      ret = d_class_enum_type (di);
      break;

    case 'A':
      ret = d_array_type (di);
      break;

    case 'M':
      ret = d_pointer_to_member_type (di);
      break;

    case 'T':
      ret = d_template_param (di);
      if (d_peek_char (di) == 'I')
       {
         /* This is <template-template-param> <template-args>.  The
            <template-template-param> part is a substitution
            candidate.  */
         if (! d_add_substitution (di, ret))
           return NULL;
         ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
                          d_template_args (di));
       }
      break;

    case 'S':
      /* If this is a special substitution, then it is the start of
        <class-enum-type>.  */
      {
       char peek_next;

       peek_next = d_peek_next_char (di);
       if (IS_DIGIT (peek_next)
           || peek_next == '_'
           || IS_UPPER (peek_next))
         {
           ret = d_substitution (di, 0);
           /* The substituted name may have been a template name and
              may be followed by tepmlate args.  */
           if (d_peek_char (di) == 'I')
             ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
                             d_template_args (di));
           else
             can_subst = 0;
         }
       else
         {
           ret = d_class_enum_type (di);
           /* If the substitution was a complete type, then it is not
              a new substitution candidate.  However, if the
              substitution was followed by template arguments, then
              the whole thing is a substitution candidate.  */
           if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD)
             can_subst = 0;
         }
      }
      break;

    case 'P':
      d_advance (di, 1);
      ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER,
                      cplus_demangle_type (di), NULL);
      break;

    case 'R':
      d_advance (di, 1);
      ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE,
                      cplus_demangle_type (di), NULL);
      break;

    case 'C':
      d_advance (di, 1);
      ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX,
                      cplus_demangle_type (di), NULL);
      break;

    case 'G':
      d_advance (di, 1);
      ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY,
                      cplus_demangle_type (di), NULL);
      break;

    case 'U':
      d_advance (di, 1);
      ret = d_source_name (di);
      ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
                      cplus_demangle_type (di), ret);
      break;

    default:
      return NULL;
    }

  if (can_subst)
    {
      if (! d_add_substitution (di, ret))
       return NULL;
    }

  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* cplus_demangle_v3 ( const char *  mangled,
int  options 
)

Definition at line 4178 of file cp-demangle.c.

{
  size_t alc;

  return d_demangle (mangled, options, &alc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int cplus_demangle_v3_callback ( const char *  mangled,
int  options,
demangle_callbackref  callback,
void *  opaque 
)

Definition at line 4186 of file cp-demangle.c.

{
  return d_demangle_callback (mangled, options, callback, opaque);
}

Here is the call graph for this function:

static int d_add_substitution ( struct d_info di,
struct demangle_component dc 
) [static]

Definition at line 2476 of file cp-demangle.c.

{
  if (dc == NULL)
    return 0;
  if (di->next_sub >= di->num_subs)
    return 0;
  di->subs[di->next_sub] = dc;
  ++di->next_sub;
  return 1;
}

Here is the caller graph for this function:

static void d_append_buffer ( struct d_print_info dpi,
const char *  s,
size_t  l 
) [inline, static]

Definition at line 2749 of file cp-demangle.c.

{
  size_t i;

  for (i = 0; i < l; i++)
    d_append_char (dpi, s[i]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void d_append_char ( struct d_print_info dpi,
char  c 
) [inline, static]

Definition at line 2739 of file cp-demangle.c.

{
  if (dpi->len == sizeof (dpi->buf) - 1)
    d_print_flush (dpi);

  dpi->buf[dpi->len++] = c;
  dpi->last_char = c;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void d_append_string ( struct d_print_info dpi,
const char *  s 
) [inline, static]

Definition at line 2758 of file cp-demangle.c.

{
  d_append_buffer (dpi, s, strlen (s));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_array_type ( struct d_info di) [static, read]

Definition at line 2064 of file cp-demangle.c.

{
  char peek;
  struct demangle_component *dim;

  if (! d_check_char (di, 'A'))
    return NULL;

  peek = d_peek_char (di);
  if (peek == '_')
    dim = NULL;
  else if (IS_DIGIT (peek))
    {
      const char *s;

      s = d_str (di);
      do
       {
         d_advance (di, 1);
         peek = d_peek_char (di);
       }
      while (IS_DIGIT (peek));
      dim = d_make_name (di, s, d_str (di) - s);
      if (dim == NULL)
       return NULL;
    }
  else
    {
      dim = d_expression (di);
      if (dim == NULL)
       return NULL;
    }

  if (! d_check_char (di, '_'))
    return NULL;

  return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
                    cplus_demangle_type (di));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_bare_function_type ( struct d_info di,
int  has_return_type 
) [static, read]

Definition at line 1990 of file cp-demangle.c.

{
  struct demangle_component *return_type;
  struct demangle_component *tl;
  struct demangle_component **ptl;
  char peek;

  /* Detect special qualifier indicating that the first argument
     is the return type.  */
  peek = d_peek_char (di);
  if (peek == 'J')
    {
      d_advance (di, 1);
      has_return_type = 1;
    }

  return_type = NULL;
  tl = NULL;
  ptl = &tl;
  while (1)
    {
      struct demangle_component *type;

      peek = d_peek_char (di);
      if (peek == '\0' || peek == 'E')
       break;
      type = cplus_demangle_type (di);
      if (type == NULL)
       return NULL;
      if (has_return_type)
       {
         return_type = type;
         has_return_type = 0;
       }
      else
       {
         *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
         if (*ptl == NULL)
           return NULL;
         ptl = &d_right (*ptl);
       }
    }

  /* There should be at least one parameter type besides the optional
     return type.  A function which takes no arguments will have a
     single parameter type void.  */
  if (tl == NULL)
    return NULL;

  /* If we have a single parameter type void, omit it.  */
  if (d_right (tl) == NULL
      && d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
      && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID)
    {
      di->expansion -= d_left (tl)->u.s_builtin.type->len;
      tl = NULL;
    }

  return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE, return_type, tl);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int d_call_offset ( struct d_info di,
int  c 
) [static]

Definition at line 1606 of file cp-demangle.c.

{
  if (c == '\0')
    c = d_next_char (di);

  if (c == 'h')
    d_number (di);
  else if (c == 'v')
    {
      d_number (di);
      if (! d_check_char (di, '_'))
       return 0;
      d_number (di);
    }
  else
    return 0;

  if (! d_check_char (di, '_'))
    return 0;

  return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_class_enum_type ( struct d_info di) [static, read]

Definition at line 2054 of file cp-demangle.c.

{
  return d_name (di);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_ctor_dtor_name ( struct d_info di) [static, read]

Definition at line 1638 of file cp-demangle.c.

{
  if (di->last_name != NULL)
    {
      if (di->last_name->type == DEMANGLE_COMPONENT_NAME)
       di->expansion += di->last_name->u.s_name.len;
      else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD)
       di->expansion += di->last_name->u.s_string.len;
    }
  switch (d_peek_char (di))
    {
    case 'C':
      {
       enum gnu_v3_ctor_kinds kind;

       switch (d_peek_next_char (di))
         {
         case '1':
           kind = gnu_v3_complete_object_ctor;
           break;
         case '2':
           kind = gnu_v3_base_object_ctor;
           break;
         case '3':
           kind = gnu_v3_complete_object_allocating_ctor;
           break;
         default:
           return NULL;
         }
       d_advance (di, 2);
       return d_make_ctor (di, kind, di->last_name);
      }

    case 'D':
      {
       enum gnu_v3_dtor_kinds kind;

       switch (d_peek_next_char (di))
         {
         case '0':
           kind = gnu_v3_deleting_dtor;
           break;
         case '1':
           kind = gnu_v3_complete_object_dtor;
           break;
         case '2':
           kind = gnu_v3_base_object_dtor;
           break;
         default:
           return NULL;
         }
       d_advance (di, 2);
       return d_make_dtor (di, kind, di->last_name);
      }

    default:
      return NULL;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component ** d_cv_qualifiers ( struct d_info di,
struct demangle_component **  pret,
int  member_fn 
) [static, read]

Definition at line 1922 of file cp-demangle.c.

{
  char peek;

  peek = d_peek_char (di);
  while (peek == 'r' || peek == 'V' || peek == 'K')
    {
      enum demangle_component_type t;

      d_advance (di, 1);
      if (peek == 'r')
       {
         t = (member_fn
              ? DEMANGLE_COMPONENT_RESTRICT_THIS
              : DEMANGLE_COMPONENT_RESTRICT);
         di->expansion += sizeof "restrict";
       }
      else if (peek == 'V')
       {
         t = (member_fn
              ? DEMANGLE_COMPONENT_VOLATILE_THIS
              : DEMANGLE_COMPONENT_VOLATILE);
         di->expansion += sizeof "volatile";
       }
      else
       {
         t = (member_fn
              ? DEMANGLE_COMPONENT_CONST_THIS
              : DEMANGLE_COMPONENT_CONST);
         di->expansion += sizeof "const";
       }

      *pret = d_make_comp (di, t, NULL, NULL);
      if (*pret == NULL)
       return NULL;
      pret = &d_left (*pret);

      peek = d_peek_char (di);
    }

  return pret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char * d_demangle ( const char *  mangled,
int  options,
size_t palc 
) [static]

Definition at line 4018 of file cp-demangle.c.

{
  struct d_growable_string dgs;
  int status;

  d_growable_string_init (&dgs, 0);

  status = d_demangle_callback (mangled, options,
                                d_growable_string_callback_adapter, &dgs);
  if (status == 0)
    {
      free (dgs.buf);
      *palc = 0;
      return NULL;
    }

  *palc = dgs.allocation_failure ? 1 : 0;
  return dgs.buf;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int d_demangle_callback ( const char *  mangled,
int  options,
demangle_callbackref  callback,
void *  opaque 
) [static]

Definition at line 3940 of file cp-demangle.c.

{
  int type;
  struct d_info di;
  struct demangle_component *dc;
  int status;

  if (mangled[0] == '_' && mangled[1] == 'Z')
    type = 0;
  else if (strncmp (mangled, "_GLOBAL_", 8) == 0
          && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$')
          && (mangled[9] == 'D' || mangled[9] == 'I')
          && mangled[10] == '_')
    {
      const char *intro;

      intro = (mangled[9] == 'I')
              ? "global constructors keyed to "
              : "global destructors keyed to ";

      callback (intro, strlen (intro), opaque);
      callback (mangled + 11, strlen (mangled + 11), opaque);
      return 1;
    }
  else
    {
      if ((options & DMGL_TYPES) == 0)
       return 0;
      type = 1;
    }

  cplus_demangle_init_info (mangled, options, strlen (mangled), &di);

  {
#ifdef CP_DYNAMIC_ARRAYS
    __extension__ struct demangle_component comps[di.num_comps];
    __extension__ struct demangle_component *subs[di.num_subs];

    di.comps = comps;
    di.subs = subs;
#else
    di.comps = alloca (di.num_comps * sizeof (*di.comps));
    di.subs = alloca (di.num_subs * sizeof (*di.subs));
#endif

    if (type)
      dc = cplus_demangle_type (&di);
    else
      dc = cplus_demangle_mangled_name (&di, 1);

    /* If DMGL_PARAMS is set, then if we didn't consume the entire
       mangled string, then we didn't successfully demangle it.  If
       DMGL_PARAMS is not set, we didn't look at the trailing
       parameters.  */
    if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
      dc = NULL;

#ifdef CP_DEMANGLE_DEBUG
    d_dump (dc, 0);
#endif

    status = (dc != NULL)
             ? cplus_demangle_print_callback (options, dc, callback, opaque)
             : 0;
  }

  return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int d_discriminator ( struct d_info di) [static]

Definition at line 2460 of file cp-demangle.c.

{
  long discrim;

  if (d_peek_char (di) != '_')
    return 1;
  d_advance (di, 1);
  discrim = d_number (di);
  if (discrim < 0)
    return 0;
  return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_encoding ( struct d_info di,
int  top_level 
) [static, read]

Definition at line 1028 of file cp-demangle.c.

{
  char peek = d_peek_char (di);

  if (peek == 'G' || peek == 'T')
    return d_special_name (di);
  else
    {
      struct demangle_component *dc;

      dc = d_name (di);

      if (dc != NULL && top_level && (di->options & DMGL_PARAMS) == 0)
       {
         /* Strip off any initial CV-qualifiers, as they really apply
            to the `this' parameter, and they were not output by the
            v2 demangler without DMGL_PARAMS.  */
         while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
               || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
               || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
           dc = d_left (dc);

         /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
            there may be CV-qualifiers on its right argument which
            really apply here; this happens when parsing a class
            which is local to a function.  */
         if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME)
           {
             struct demangle_component *dcr;

             dcr = d_right (dc);
             while (dcr->type == DEMANGLE_COMPONENT_RESTRICT_THIS
                   || dcr->type == DEMANGLE_COMPONENT_VOLATILE_THIS
                   || dcr->type == DEMANGLE_COMPONENT_CONST_THIS)
              dcr = d_left (dcr);
             dc->u.s_binary.right = dcr;
           }

         return dc;
       }

      peek = d_peek_char (di);
      if (dc == NULL || peek == '\0' || peek == 'E')
       return dc;
      return d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME, dc,
                       d_bare_function_type (di, has_return_type (dc)));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_expr_primary ( struct d_info di) [static, read]

Definition at line 2362 of file cp-demangle.c.

{
  struct demangle_component *ret;

  if (! d_check_char (di, 'L'))
    return NULL;
  if (d_peek_char (di) == '_')
    ret = cplus_demangle_mangled_name (di, 0);
  else
    {
      struct demangle_component *type;
      enum demangle_component_type t;
      const char *s;

      type = cplus_demangle_type (di);
      if (type == NULL)
       return NULL;

      /* If we have a type we know how to print, we aren't going to
        print the type name itself.  */
      if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
         && type->u.s_builtin.type->print != D_PRINT_DEFAULT)
       di->expansion -= type->u.s_builtin.type->len;

      /* Rather than try to interpret the literal value, we just
        collect it as a string.  Note that it's possible to have a
        floating point literal here.  The ABI specifies that the
        format of such literals is machine independent.  That's fine,
        but what's not fine is that versions of g++ up to 3.2 with
        -fabi-version=1 used upper case letters in the hex constant,
        and dumped out gcc's internal representation.  That makes it
        hard to tell where the constant ends, and hard to dump the
        constant in any readable form anyhow.  We don't attempt to
        handle these cases.  */

      t = DEMANGLE_COMPONENT_LITERAL;
      if (d_peek_char (di) == 'n')
       {
         t = DEMANGLE_COMPONENT_LITERAL_NEG;
         d_advance (di, 1);
       }
      s = d_str (di);
      while (d_peek_char (di) != 'E')
       {
         if (d_peek_char (di) == '\0')
           return NULL;
         d_advance (di, 1);
       }
      ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
    }
  if (! d_check_char (di, 'E'))
    return NULL;
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_expression ( struct d_info di) [static, read]

Definition at line 2262 of file cp-demangle.c.

{
  char peek;

  peek = d_peek_char (di);
  if (peek == 'L')
    return d_expr_primary (di);
  else if (peek == 'T')
    return d_template_param (di);
  else if (peek == 's' && d_peek_next_char (di) == 'r')
    {
      struct demangle_component *type;
      struct demangle_component *name;

      d_advance (di, 2);
      type = cplus_demangle_type (di);
      name = d_unqualified_name (di);
      if (d_peek_char (di) != 'I')
       return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
      else
       return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type,
                         d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
                                    d_template_args (di)));
    }
  else
    {
      struct demangle_component *op;
      int args;

      op = d_operator_name (di);
      if (op == NULL)
       return NULL;

      if (op->type == DEMANGLE_COMPONENT_OPERATOR)
       di->expansion += op->u.s_operator.op->len - 2;

      if (op->type == DEMANGLE_COMPONENT_OPERATOR
         && strcmp (op->u.s_operator.op->code, "st") == 0)
       return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
                         cplus_demangle_type (di));

      switch (op->type)
       {
       default:
         return NULL;
       case DEMANGLE_COMPONENT_OPERATOR:
         args = op->u.s_operator.op->args;
         break;
       case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
         args = op->u.s_extended_operator.args;
         break;
       case DEMANGLE_COMPONENT_CAST:
         args = 1;
         break;
       }

      switch (args)
       {
       case 1:
         return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
                           d_expression (di));
       case 2:
         {
           struct demangle_component *left;

           left = d_expression (di);
           return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
                            d_make_comp (di,
                                        DEMANGLE_COMPONENT_BINARY_ARGS,
                                        left,
                                        d_expression (di)));
         }
       case 3:
         {
           struct demangle_component *first;
           struct demangle_component *second;

           first = d_expression (di);
           second = d_expression (di);
           return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
                            d_make_comp (di,
                                        DEMANGLE_COMPONENT_TRINARY_ARG1,
                                        first,
                                        d_make_comp (di,
                                                   DEMANGLE_COMPONENT_TRINARY_ARG2,
                                                   second,
                                                   d_expression (di))));
         }
       default:
         return NULL;
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_function_type ( struct d_info di) [static, read]

Definition at line 1969 of file cp-demangle.c.

{
  struct demangle_component *ret;

  if (! d_check_char (di, 'F'))
    return NULL;
  if (d_peek_char (di) == 'Y')
    {
      /* Function has C linkage.  We don't print this information.
        FIXME: We should print it in verbose mode.  */
      d_advance (di, 1);
    }
  ret = d_bare_function_type (di, 1);
  if (! d_check_char (di, 'E'))
    return NULL;
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void d_growable_string_append_buffer ( struct d_growable_string dgs,
const char *  s,
size_t  l 
) [inline, static]

Definition at line 2667 of file cp-demangle.c.

{
  size_t need;

  need = dgs->len + l + 1;
  if (need > dgs->alc)
    d_growable_string_resize (dgs, need);

  if (dgs->allocation_failure)
    return;

  memcpy (dgs->buf + dgs->len, s, l);
  dgs->buf[dgs->len + l] = '\0';
  dgs->len += l;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void d_growable_string_callback_adapter ( const char *  s,
size_t  l,
void *  opaque 
) [static]

Definition at line 2687 of file cp-demangle.c.

{
  struct d_growable_string *dgs = (struct d_growable_string*) opaque;

  d_growable_string_append_buffer (dgs, s, l);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void d_growable_string_init ( struct d_growable_string dgs,
size_t  estimate 
) [static]

Definition at line 2621 of file cp-demangle.c.

{
  dgs->buf = NULL;
  dgs->len = 0;
  dgs->alc = 0;
  dgs->allocation_failure = 0;

  if (estimate > 0)
    d_growable_string_resize (dgs, estimate);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void d_growable_string_resize ( struct d_growable_string dgs,
size_t  need 
) [inline, static]

Definition at line 2635 of file cp-demangle.c.

{
  size_t newalc;
  char *newbuf;

  if (dgs->allocation_failure)
    return;

  /* Start allocation at two bytes to avoid any possibility of confusion
     with the special value of 1 used as a return in *palc to indicate
     allocation failures.  */
  newalc = dgs->alc > 0 ? dgs->alc : 2;
  while (newalc < need)
    newalc <<= 1;

  newbuf = (char *) realloc (dgs->buf, newalc);
  if (newbuf == NULL)
    {
      free (dgs->buf);
      dgs->buf = NULL;
      dgs->len = 0;
      dgs->alc = 0;
      dgs->allocation_failure = 1;
      return;
    }
  dgs->buf = newbuf;
  dgs->alc = newalc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_identifier ( struct d_info di,
int  len 
) [static, read]

Definition at line 1334 of file cp-demangle.c.

{
  const char *name;

  name = d_str (di);

  if (di->send - name < len)
    return NULL;

  d_advance (di, len);

  /* A Java mangled name may have a trailing '$' if it is a C++
     keyword.  This '$' is not included in the length count.  We just
     ignore the '$'.  */
  if ((di->options & DMGL_JAVA) != 0
      && d_peek_char (di) == '$')
    d_advance (di, 1);

  /* Look for something which looks like a gcc encoding of an
     anonymous namespace, and replace it with a more user friendly
     name.  */
  if (len >= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN + 2
      && memcmp (name, ANONYMOUS_NAMESPACE_PREFIX,
               ANONYMOUS_NAMESPACE_PREFIX_LEN) == 0)
    {
      const char *s;

      s = name + ANONYMOUS_NAMESPACE_PREFIX_LEN;
      if ((*s == '.' || *s == '_' || *s == '$')
         && s[1] == 'N')
       {
         di->expansion -= len - sizeof "(anonymous namespace)";
         return d_make_name (di, "(anonymous namespace)",
                           sizeof "(anonymous namespace)" - 1);
       }
    }

  return d_make_name (di, name, len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char d_last_char ( struct d_print_info dpi) [inline, static]

Definition at line 2764 of file cp-demangle.c.

{
  return dpi->last_char;
}

Here is the caller graph for this function:

static struct demangle_component * d_local_name ( struct d_info di) [static, read]

Definition at line 2422 of file cp-demangle.c.

{
  struct demangle_component *function;

  if (! d_check_char (di, 'Z'))
    return NULL;

  function = d_encoding (di, 0);

  if (! d_check_char (di, 'E'))
    return NULL;

  if (d_peek_char (di) == 's')
    {
      d_advance (di, 1);
      if (! d_discriminator (di))
       return NULL;
      return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function,
                       d_make_name (di, "string literal",
                                   sizeof "string literal" - 1));
    }
  else
    {
      struct demangle_component *name;

      name = d_name (di);
      if (! d_discriminator (di))
       return NULL;
      return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 847 of file cp-demangle.c.

{
  struct demangle_component *p;

  if (type == NULL)
    return NULL;
  p = d_make_empty (di);
  if (p != NULL)
    {
      p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE;
      p->u.s_builtin.type = type;
    }
  return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_make_comp ( struct d_info di,
enum demangle_component_type  type,
struct demangle_component left,
struct demangle_component right 
) [static, read]

Definition at line 742 of file cp-demangle.c.

{
  struct demangle_component *p;

  /* We check for errors here.  A typical error would be a NULL return
     from a subroutine.  We catch those here, and return NULL
     upward.  */
  switch (type)
    {
      /* These types require two parameters.  */
    case DEMANGLE_COMPONENT_QUAL_NAME:
    case DEMANGLE_COMPONENT_LOCAL_NAME:
    case DEMANGLE_COMPONENT_TYPED_NAME:
    case DEMANGLE_COMPONENT_TEMPLATE:
    case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
    case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
    case DEMANGLE_COMPONENT_PTRMEM_TYPE:
    case DEMANGLE_COMPONENT_UNARY:
    case DEMANGLE_COMPONENT_BINARY:
    case DEMANGLE_COMPONENT_BINARY_ARGS:
    case DEMANGLE_COMPONENT_TRINARY:
    case DEMANGLE_COMPONENT_TRINARY_ARG1:
    case DEMANGLE_COMPONENT_TRINARY_ARG2:
    case DEMANGLE_COMPONENT_LITERAL:
    case DEMANGLE_COMPONENT_LITERAL_NEG:
      if (left == NULL || right == NULL)
       return NULL;
      break;

      /* These types only require one parameter.  */
    case DEMANGLE_COMPONENT_VTABLE:
    case DEMANGLE_COMPONENT_VTT:
    case DEMANGLE_COMPONENT_TYPEINFO:
    case DEMANGLE_COMPONENT_TYPEINFO_NAME:
    case DEMANGLE_COMPONENT_TYPEINFO_FN:
    case DEMANGLE_COMPONENT_THUNK:
    case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
    case DEMANGLE_COMPONENT_COVARIANT_THUNK:
    case DEMANGLE_COMPONENT_JAVA_CLASS:
    case DEMANGLE_COMPONENT_GUARD:
    case DEMANGLE_COMPONENT_REFTEMP:
    case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
    case DEMANGLE_COMPONENT_POINTER:
    case DEMANGLE_COMPONENT_REFERENCE:
    case DEMANGLE_COMPONENT_COMPLEX:
    case DEMANGLE_COMPONENT_IMAGINARY:
    case DEMANGLE_COMPONENT_VENDOR_TYPE:
    case DEMANGLE_COMPONENT_ARGLIST:
    case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
    case DEMANGLE_COMPONENT_CAST:
      if (left == NULL)
       return NULL;
      break;

      /* This needs a right parameter, but the left parameter can be
        empty.  */
    case DEMANGLE_COMPONENT_ARRAY_TYPE:
      if (right == NULL)
       return NULL;
      break;

      /* These are allowed to have no parameters--in some cases they
        will be filled in later.  */
    case DEMANGLE_COMPONENT_FUNCTION_TYPE:
    case DEMANGLE_COMPONENT_RESTRICT:
    case DEMANGLE_COMPONENT_VOLATILE:
    case DEMANGLE_COMPONENT_CONST:
    case DEMANGLE_COMPONENT_RESTRICT_THIS:
    case DEMANGLE_COMPONENT_VOLATILE_THIS:
    case DEMANGLE_COMPONENT_CONST_THIS:
      break;

      /* Other types should not be seen here.  */
    default:
      return NULL;
    }

  p = d_make_empty (di);
  if (p != NULL)
    {
      p->type = type;
      p->u.s_binary.left = left;
      p->u.s_binary.right = right;
    }
  return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_make_ctor ( struct d_info di,
enum gnu_v3_ctor_kinds  kind,
struct demangle_component name 
) [static, read]

Definition at line 896 of file cp-demangle.c.

{
  struct demangle_component *p;

  p = d_make_empty (di);
  if (! cplus_demangle_fill_ctor (p, kind, name))
    return NULL;
  return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_make_dtor ( struct d_info di,
enum gnu_v3_dtor_kinds  kind,
struct demangle_component name 
) [static, read]

Definition at line 910 of file cp-demangle.c.

{
  struct demangle_component *p;

  p = d_make_empty (di);
  if (! cplus_demangle_fill_dtor (p, kind, name))
    return NULL;
  return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_make_empty ( struct d_info di) [static, read]

Definition at line 728 of file cp-demangle.c.

{
  struct demangle_component *p;

  if (di->next_comp >= di->num_comps)
    return NULL;
  p = &di->comps[di->next_comp];
  ++di->next_comp;
  return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_make_extended_operator ( struct d_info di,
int  args,
struct demangle_component name 
) [static, read]

Definition at line 882 of file cp-demangle.c.

{
  struct demangle_component *p;

  p = d_make_empty (di);
  if (! cplus_demangle_fill_extended_operator (p, args, name))
    return NULL;
  return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_make_name ( struct d_info di,
const char *  s,
int  len 
) [static, read]

Definition at line 834 of file cp-demangle.c.

{
  struct demangle_component *p;

  p = d_make_empty (di);
  if (! cplus_demangle_fill_name (p, s, len))
    return NULL;
  return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 866 of file cp-demangle.c.

{
  struct demangle_component *p;

  p = d_make_empty (di);
  if (p != NULL)
    {
      p->type = DEMANGLE_COMPONENT_OPERATOR;
      p->u.s_operator.op = op;
    }
  return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_make_sub ( struct d_info di,
const char *  name,
int  len 
) [static, read]

Definition at line 940 of file cp-demangle.c.

{
  struct demangle_component *p;

  p = d_make_empty (di);
  if (p != NULL)
    {
      p->type = DEMANGLE_COMPONENT_SUB_STD;
      p->u.s_string.string = name;
      p->u.s_string.len = len;
    }
  return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_make_template_param ( struct d_info di,
long  i 
) [static, read]

Definition at line 924 of file cp-demangle.c.

{
  struct demangle_component *p;

  p = d_make_empty (di);
  if (p != NULL)
    {
      p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM;
      p->u.s_number.number = i;
    }
  return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_name ( struct d_info di) [static, read]

Definition at line 1090 of file cp-demangle.c.

{
  char peek = d_peek_char (di);
  struct demangle_component *dc;

  switch (peek)
    {
    case 'N':
      return d_nested_name (di);

    case 'Z':
      return d_local_name (di);

    case 'S':
      {
       int subst;

       if (d_peek_next_char (di) != 't')
         {
           dc = d_substitution (di, 0);
           subst = 1;
         }
       else
         {
           d_advance (di, 2);
           dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME,
                           d_make_name (di, "std", 3),
                           d_unqualified_name (di));
           di->expansion += 3;
           subst = 0;
         }

       if (d_peek_char (di) != 'I')
         {
           /* The grammar does not permit this case to occur if we
              called d_substitution() above (i.e., subst == 1).  We
              don't bother to check.  */
         }
       else
         {
           /* This is <template-args>, which means that we just saw
              <unscoped-template-name>, which is a substitution
              candidate if we didn't just get it from a
              substitution.  */
           if (! subst)
             {
              if (! d_add_substitution (di, dc))
                return NULL;
             }
           dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
                           d_template_args (di));
         }

       return dc;
      }

    default:
      dc = d_unqualified_name (di);
      if (d_peek_char (di) == 'I')
       {
         /* This is <template-args>, which means that we just saw
            <unscoped-template-name>, which is a substitution
            candidate.  */
         if (! d_add_substitution (di, dc))
           return NULL;
         dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
                         d_template_args (di));
       }
      return dc;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_nested_name ( struct d_info di) [static, read]

Definition at line 1167 of file cp-demangle.c.

{
  struct demangle_component *ret;
  struct demangle_component **pret;

  if (! d_check_char (di, 'N'))
    return NULL;

  pret = d_cv_qualifiers (di, &ret, 1);
  if (pret == NULL)
    return NULL;

  *pret = d_prefix (di);
  if (*pret == NULL)
    return NULL;

  if (! d_check_char (di, 'E'))
    return NULL;

  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static long d_number ( struct d_info di) [static]

Definition at line 1301 of file cp-demangle.c.

{
  int negative;
  char peek;
  long ret;

  negative = 0;
  peek = d_peek_char (di);
  if (peek == 'n')
    {
      negative = 1;
      d_advance (di, 1);
      peek = d_peek_char (di);
    }

  ret = 0;
  while (1)
    {
      if (! IS_DIGIT (peek))
       {
         if (negative)
           ret = - ret;
         return ret;
       }
      ret = ret * 10 + peek - '0';
      d_advance (di, 1);
      peek = d_peek_char (di);
    }
}

Here is the caller graph for this function:

static struct demangle_component * d_operator_name ( struct d_info di) [static, read]

Definition at line 1437 of file cp-demangle.c.

{
  char c1;
  char c2;

  c1 = d_next_char (di);
  c2 = d_next_char (di);
  if (c1 == 'v' && IS_DIGIT (c2))
    return d_make_extended_operator (di, c2 - '0', d_source_name (di));
  else if (c1 == 'c' && c2 == 'v')
    return d_make_comp (di, DEMANGLE_COMPONENT_CAST,
                     cplus_demangle_type (di), NULL);
  else
    {
      /* LOW is the inclusive lower bound.  */
      int low = 0;
      /* HIGH is the exclusive upper bound.  We subtract one to ignore
        the sentinel at the end of the array.  */
      int high = ((sizeof (cplus_demangle_operators)
                 / sizeof (cplus_demangle_operators[0]))
                - 1);

      while (1)
       {
         int i;
         const struct demangle_operator_info *p;

         i = low + (high - low) / 2;
         p = cplus_demangle_operators + i;

         if (c1 == p->code[0] && c2 == p->code[1])
           return d_make_operator (di, p);

         if (c1 < p->code[0] || (c1 == p->code[0] && c2 < p->code[1]))
           high = i;
         else
           low = i + 1;
         if (low == high)
           return NULL;
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_pointer_to_member_type ( struct d_info di) [static, read]

Definition at line 2107 of file cp-demangle.c.

{
  struct demangle_component *cl;
  struct demangle_component *mem;
  struct demangle_component **pmem;

  if (! d_check_char (di, 'M'))
    return NULL;

  cl = cplus_demangle_type (di);

  /* The ABI specifies that any type can be a substitution source, and
     that M is followed by two types, and that when a CV-qualified
     type is seen both the base type and the CV-qualified types are
     substitution sources.  The ABI also specifies that for a pointer
     to a CV-qualified member function, the qualifiers are attached to
     the second type.  Given the grammar, a plain reading of the ABI
     suggests that both the CV-qualified member function and the
     non-qualified member function are substitution sources.  However,
     g++ does not work that way.  g++ treats only the CV-qualified
     member function as a substitution source.  FIXME.  So to work
     with g++, we need to pull off the CV-qualifiers here, in order to
     avoid calling add_substitution() in cplus_demangle_type().  But
     for a CV-qualified member which is not a function, g++ does
     follow the ABI, so we need to handle that case here by calling
     d_add_substitution ourselves.  */

  pmem = d_cv_qualifiers (di, &mem, 1);
  if (pmem == NULL)
    return NULL;
  *pmem = cplus_demangle_type (di);
  if (*pmem == NULL)
    return NULL;

  if (pmem != &mem && (*pmem)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
    {
      if (! d_add_substitution (di, mem))
       return NULL;
    }

  return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_prefix ( struct d_info di) [static, read]

Definition at line 1201 of file cp-demangle.c.

{
  struct demangle_component *ret = NULL;

  while (1)
    {
      char peek;
      enum demangle_component_type comb_type;
      struct demangle_component *dc;

      peek = d_peek_char (di);
      if (peek == '\0')
       return NULL;

      /* The older code accepts a <local-name> here, but I don't see
        that in the grammar.  The older code does not accept a
        <template-param> here.  */

      comb_type = DEMANGLE_COMPONENT_QUAL_NAME;
      if (IS_DIGIT (peek)
         || IS_LOWER (peek)
         || peek == 'C'
         || peek == 'D')
       dc = d_unqualified_name (di);
      else if (peek == 'S')
       dc = d_substitution (di, 1);
      else if (peek == 'I')
       {
         if (ret == NULL)
           return NULL;
         comb_type = DEMANGLE_COMPONENT_TEMPLATE;
         dc = d_template_args (di);
       }
      else if (peek == 'T')
       dc = d_template_param (di);
      else if (peek == 'E')
       return ret;
      else
       return NULL;

      if (ret == NULL)
       ret = dc;
      else
       ret = d_make_comp (di, comb_type, ret, dc);

      if (peek != 'S' && d_peek_char (di) != 'E')
       {
         if (! d_add_substitution (di, ret))
           return NULL;
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void d_print_array_type ( struct d_print_info dpi,
const struct demangle_component dc,
struct d_print_mod mods 
) [static]

Definition at line 3796 of file cp-demangle.c.

{
  int need_space;

  need_space = 1;
  if (mods != NULL)
    {
      int need_paren;
      struct d_print_mod *p;

      need_paren = 0;
      for (p = mods; p != NULL; p = p->next)
       {
         if (! p->printed)
           {
             if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
              {
                need_space = 0;
                break;
              }
             else
              {
                need_paren = 1;
                need_space = 1;
                break;
              }
           }
       }

      if (need_paren)
       d_append_string (dpi, " (");

      d_print_mod_list (dpi, mods, 0);

      if (need_paren)
       d_append_char (dpi, ')');
    }

  if (need_space)
    d_append_char (dpi, ' ');

  d_append_char (dpi, '[');

  if (d_left (dc) != NULL)
    d_print_comp (dpi, d_left (dc));

  d_append_char (dpi, ']');
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void d_print_cast ( struct d_print_info dpi,
const struct demangle_component dc 
) [static]

Definition at line 3863 of file cp-demangle.c.

{
  if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
    d_print_comp (dpi, d_left (dc));
  else
    {
      struct d_print_mod *hold_dpm;
      struct d_print_template dpt;

      /* It appears that for a templated cast operator, we need to put
        the template parameters in scope for the operator name, but
        not for the parameters.  The effect is that we need to handle
        the template printing here.  */

      hold_dpm = dpi->modifiers;
      dpi->modifiers = NULL;

      dpt.next = dpi->templates;
      dpi->templates = &dpt;
      dpt.template_decl = d_left (dc);

      d_print_comp (dpi, d_left (d_left (dc)));

      dpi->templates = dpt.next;

      if (d_last_char (dpi) == '<')
       d_append_char (dpi, ' ');
      d_append_char (dpi, '<');
      d_print_comp (dpi, d_right (d_left (dc)));
      /* Avoid generating two consecutive '>' characters, to avoid
        the C++ syntactic ambiguity.  */
      if (d_last_char (dpi) == '>')
       d_append_char (dpi, ' ');
      d_append_char (dpi, '>');

      dpi->modifiers = hold_dpm;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void d_print_comp ( struct d_print_info dpi,
const struct demangle_component dc 
) [static]

Definition at line 2828 of file cp-demangle.c.

{
  if (dc == NULL)
    {
      d_print_error (dpi);
      return;
    }
  if (d_print_saw_error (dpi))
    return;

  switch (dc->type)
    {
    case DEMANGLE_COMPONENT_NAME:
      if ((dpi->options & DMGL_JAVA) == 0)
       d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
      else
       d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
      return;

    case DEMANGLE_COMPONENT_QUAL_NAME:
    case DEMANGLE_COMPONENT_LOCAL_NAME:
      d_print_comp (dpi, d_left (dc));
      if ((dpi->options & DMGL_JAVA) == 0)
       d_append_string (dpi, "::");
      else
       d_append_char (dpi, '.');
      d_print_comp (dpi, d_right (dc));
      return;

    case DEMANGLE_COMPONENT_TYPED_NAME:
      {
       struct d_print_mod *hold_modifiers;
       struct demangle_component *typed_name;
       struct d_print_mod adpm[4];
       unsigned int i;
       struct d_print_template dpt;

       /* Pass the name down to the type so that it can be printed in
          the right place for the type.  We also have to pass down
          any CV-qualifiers, which apply to the this parameter.  */
       hold_modifiers = dpi->modifiers;
       i = 0;
       typed_name = d_left (dc);
       while (typed_name != NULL)
         {
           if (i >= sizeof adpm / sizeof adpm[0])
             {
              d_print_error (dpi);
              return;
             }

           adpm[i].next = dpi->modifiers;
           dpi->modifiers = &adpm[i];
           adpm[i].mod = typed_name;
           adpm[i].printed = 0;
           adpm[i].templates = dpi->templates;
           ++i;

           if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS
              && typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS
              && typed_name->type != DEMANGLE_COMPONENT_CONST_THIS)
             break;

           typed_name = d_left (typed_name);
         }

       /* If typed_name is a template, then it applies to the
          function type as well.  */
       if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
         {
           dpt.next = dpi->templates;
           dpi->templates = &dpt;
           dpt.template_decl = typed_name;
         }

       /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
          there may be CV-qualifiers on its right argument which
          really apply here; this happens when parsing a class which
          is local to a function.  */
       if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
         {
           struct demangle_component *local_name;

           local_name = d_right (typed_name);
           while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS
                 || local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS
                 || local_name->type == DEMANGLE_COMPONENT_CONST_THIS)
             {
              if (i >= sizeof adpm / sizeof adpm[0])
                {
                  d_print_error (dpi);
                  return;
                }

              adpm[i] = adpm[i - 1];
              adpm[i].next = &adpm[i - 1];
              dpi->modifiers = &adpm[i];

              adpm[i - 1].mod = local_name;
              adpm[i - 1].printed = 0;
              adpm[i - 1].templates = dpi->templates;
              ++i;

              local_name = d_left (local_name);
             }
         }

       d_print_comp (dpi, d_right (dc));

       if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
         dpi->templates = dpt.next;

       /* If the modifiers didn't get printed by the type, print them
          now.  */
       while (i > 0)
         {
           --i;
           if (! adpm[i].printed)
             {
              d_append_char (dpi, ' ');
              d_print_mod (dpi, adpm[i].mod);
             }
         }

       dpi->modifiers = hold_modifiers;

       return;
      }

    case DEMANGLE_COMPONENT_TEMPLATE:
      {
       struct d_print_mod *hold_dpm;
       struct demangle_component *dcl;

       /* Don't push modifiers into a template definition.  Doing so
          could give the wrong definition for a template argument.
          Instead, treat the template essentially as a name.  */

       hold_dpm = dpi->modifiers;
       dpi->modifiers = NULL;

        dcl = d_left (dc);

        if ((dpi->options & DMGL_JAVA) != 0
            && dcl->type == DEMANGLE_COMPONENT_NAME
            && dcl->u.s_name.len == 6
            && strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
          {
            /* Special-case Java arrays, so that JArray<TYPE> appears
               instead as TYPE[].  */

            d_print_comp (dpi, d_right (dc));
            d_append_string (dpi, "[]");
          }
        else
          {
           d_print_comp (dpi, dcl);
           if (d_last_char (dpi) == '<')
             d_append_char (dpi, ' ');
           d_append_char (dpi, '<');
           d_print_comp (dpi, d_right (dc));
           /* Avoid generating two consecutive '>' characters, to avoid
              the C++ syntactic ambiguity.  */
           if (d_last_char (dpi) == '>')
             d_append_char (dpi, ' ');
           d_append_char (dpi, '>');
          }

       dpi->modifiers = hold_dpm;

       return;
      }

    case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
      {
       long i;
       struct demangle_component *a;
       struct d_print_template *hold_dpt;

       if (dpi->templates == NULL)
         {
           d_print_error (dpi);
           return;
         }
       i = dc->u.s_number.number;
       for (a = d_right (dpi->templates->template_decl);
            a != NULL;
            a = d_right (a))
         {
           if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
             {
              d_print_error (dpi);
              return;
             }
           if (i <= 0)
             break;
           --i;
         }
       if (i != 0 || a == NULL)
         {
           d_print_error (dpi);
           return;
         }

       /* While processing this parameter, we need to pop the list of
          templates.  This is because the template parameter may
          itself be a reference to a parameter of an outer
          template.  */

       hold_dpt = dpi->templates;
       dpi->templates = hold_dpt->next;

       d_print_comp (dpi, d_left (a));

       dpi->templates = hold_dpt;

       return;
      }

    case DEMANGLE_COMPONENT_CTOR:
      d_print_comp (dpi, dc->u.s_ctor.name);
      return;

    case DEMANGLE_COMPONENT_DTOR:
      d_append_char (dpi, '~');
      d_print_comp (dpi, dc->u.s_dtor.name);
      return;

    case DEMANGLE_COMPONENT_VTABLE:
      d_append_string (dpi, "vtable for ");
      d_print_comp (dpi, d_left (dc));
      return;

    case DEMANGLE_COMPONENT_VTT:
      d_append_string (dpi, "VTT for ");
      d_print_comp (dpi, d_left (dc));
      return;

    case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
      d_append_string (dpi, "construction vtable for ");
      d_print_comp (dpi, d_left (dc));
      d_append_string (dpi, "-in-");
      d_print_comp (dpi, d_right (dc));
      return;

    case DEMANGLE_COMPONENT_TYPEINFO:
      d_append_string (dpi, "typeinfo for ");
      d_print_comp (dpi, d_left (dc));
      return;

    case DEMANGLE_COMPONENT_TYPEINFO_NAME:
      d_append_string (dpi, "typeinfo name for ");
      d_print_comp (dpi, d_left (dc));
      return;

    case DEMANGLE_COMPONENT_TYPEINFO_FN:
      d_append_string (dpi, "typeinfo fn for ");
      d_print_comp (dpi, d_left (dc));
      return;

    case DEMANGLE_COMPONENT_THUNK:
      d_append_string (dpi, "non-virtual thunk to ");
      d_print_comp (dpi, d_left (dc));
      return;

    case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
      d_append_string (dpi, "virtual thunk to ");
      d_print_comp (dpi, d_left (dc));
      return;

    case DEMANGLE_COMPONENT_COVARIANT_THUNK:
      d_append_string (dpi, "covariant return thunk to ");
      d_print_comp (dpi, d_left (dc));
      return;

    case DEMANGLE_COMPONENT_JAVA_CLASS:
      d_append_string (dpi, "java Class for ");
      d_print_comp (dpi, d_left (dc));
      return;

    case DEMANGLE_COMPONENT_GUARD:
      d_append_string (dpi, "guard variable for ");
      d_print_comp (dpi, d_left (dc));
      return;

    case DEMANGLE_COMPONENT_REFTEMP:
      d_append_string (dpi, "reference temporary for ");
      d_print_comp (dpi, d_left (dc));
      return;

    case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
      d_append_string (dpi, "hidden alias for ");
      d_print_comp (dpi, d_left (dc));
      return;

    case DEMANGLE_COMPONENT_SUB_STD:
      d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
      return;

    case DEMANGLE_COMPONENT_RESTRICT:
    case DEMANGLE_COMPONENT_VOLATILE:
    case DEMANGLE_COMPONENT_CONST:
      {
       struct d_print_mod *pdpm;

       /* When printing arrays, it's possible to have cases where the
          same CV-qualifier gets pushed on the stack multiple times.
          We only need to print it once.  */

       for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next)
         {
           if (! pdpm->printed)
             {
              if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
                  && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
                  && pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
                break;
              if (pdpm->mod->type == dc->type)
                {
                  d_print_comp (dpi, d_left (dc));
                  return;
                }
             }
         }
      }
      /* Fall through.  */
    case DEMANGLE_COMPONENT_RESTRICT_THIS:
    case DEMANGLE_COMPONENT_VOLATILE_THIS:
    case DEMANGLE_COMPONENT_CONST_THIS:
    case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
    case DEMANGLE_COMPONENT_POINTER:
    case DEMANGLE_COMPONENT_REFERENCE:
    case DEMANGLE_COMPONENT_COMPLEX:
    case DEMANGLE_COMPONENT_IMAGINARY:
      {
       /* We keep a list of modifiers on the stack.  */
       struct d_print_mod dpm;

       dpm.next = dpi->modifiers;
       dpi->modifiers = &dpm;
       dpm.mod = dc;
       dpm.printed = 0;
       dpm.templates = dpi->templates;

       d_print_comp (dpi, d_left (dc));

       /* If the modifier didn't get printed by the type, print it
          now.  */
       if (! dpm.printed)
         d_print_mod (dpi, dc);

       dpi->modifiers = dpm.next;

       return;
      }

    case DEMANGLE_COMPONENT_BUILTIN_TYPE:
      if ((dpi->options & DMGL_JAVA) == 0)
       d_append_buffer (dpi, dc->u.s_builtin.type->name,
                      dc->u.s_builtin.type->len);
      else
       d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
                      dc->u.s_builtin.type->java_len);
      return;

    case DEMANGLE_COMPONENT_VENDOR_TYPE:
      d_print_comp (dpi, d_left (dc));
      return;

    case DEMANGLE_COMPONENT_FUNCTION_TYPE:
      {
       if ((dpi->options & DMGL_RET_POSTFIX) != 0)
         d_print_function_type (dpi, dc, dpi->modifiers);

       /* Print return type if present */
       if (d_left (dc) != NULL)
         {
           struct d_print_mod dpm;

           /* We must pass this type down as a modifier in order to
              print it in the right location.  */
           dpm.next = dpi->modifiers;
           dpi->modifiers = &dpm;
           dpm.mod = dc;
           dpm.printed = 0;
           dpm.templates = dpi->templates;

           d_print_comp (dpi, d_left (dc));

           dpi->modifiers = dpm.next;

           if (dpm.printed)
             return;

           /* In standard prefix notation, there is a space between the
              return type and the function signature.  */
           if ((dpi->options & DMGL_RET_POSTFIX) == 0)
             d_append_char (dpi, ' ');
         }

       if ((dpi->options & DMGL_RET_POSTFIX) == 0) 
         d_print_function_type (dpi, dc, dpi->modifiers);

       return;
      }

    case DEMANGLE_COMPONENT_ARRAY_TYPE:
      {
       struct d_print_mod *hold_modifiers;
       struct d_print_mod adpm[4];
       unsigned int i;
       struct d_print_mod *pdpm;

       /* We must pass this type down as a modifier in order to print
          multi-dimensional arrays correctly.  If the array itself is
          CV-qualified, we act as though the element type were
          CV-qualified.  We do this by copying the modifiers down
          rather than fiddling pointers, so that we don't wind up
          with a d_print_mod higher on the stack pointing into our
          stack frame after we return.  */

       hold_modifiers = dpi->modifiers;

       adpm[0].next = hold_modifiers;
       dpi->modifiers = &adpm[0];
       adpm[0].mod = dc;
       adpm[0].printed = 0;
       adpm[0].templates = dpi->templates;

       i = 1;
       pdpm = hold_modifiers;
       while (pdpm != NULL
              && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
                 || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
                 || pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
         {
           if (! pdpm->printed)
             {
              if (i >= sizeof adpm / sizeof adpm[0])
                {
                  d_print_error (dpi);
                  return;
                }

              adpm[i] = *pdpm;
              adpm[i].next = dpi->modifiers;
              dpi->modifiers = &adpm[i];
              pdpm->printed = 1;
              ++i;
             }

           pdpm = pdpm->next;
         }

       d_print_comp (dpi, d_right (dc));

       dpi->modifiers = hold_modifiers;

       if (adpm[0].printed)
         return;

       while (i > 1)
         {
           --i;
           d_print_mod (dpi, adpm[i].mod);
         }

       d_print_array_type (dpi, dc, dpi->modifiers);

       return;
      }

    case DEMANGLE_COMPONENT_PTRMEM_TYPE:
      {
       struct d_print_mod dpm;

       dpm.next = dpi->modifiers;
       dpi->modifiers = &dpm;
       dpm.mod = dc;
       dpm.printed = 0;
       dpm.templates = dpi->templates;

       d_print_comp (dpi, d_right (dc));

       /* If the modifier didn't get printed by the type, print it
          now.  */
       if (! dpm.printed)
         {
           d_append_char (dpi, ' ');
           d_print_comp (dpi, d_left (dc));
           d_append_string (dpi, "::*");
         }

       dpi->modifiers = dpm.next;

       return;
      }

    case DEMANGLE_COMPONENT_ARGLIST:
    case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
      d_print_comp (dpi, d_left (dc));
      if (d_right (dc) != NULL)
       {
         d_append_string (dpi, ", ");
         d_print_comp (dpi, d_right (dc));
       }
      return;

    case DEMANGLE_COMPONENT_OPERATOR:
      {
       char c;

       d_append_string (dpi, "operator");
       c = dc->u.s_operator.op->name[0];
       if (IS_LOWER (c))
         d_append_char (dpi, ' ');
       d_append_buffer (dpi, dc->u.s_operator.op->name,
                      dc->u.s_operator.op->len);
       return;
      }

    case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
      d_append_string (dpi, "operator ");
      d_print_comp (dpi, dc->u.s_extended_operator.name);
      return;

    case DEMANGLE_COMPONENT_CAST:
      d_append_string (dpi, "operator ");
      d_print_cast (dpi, dc);
      return;

    case DEMANGLE_COMPONENT_UNARY:
      if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST)
       d_print_expr_op (dpi, d_left (dc));
      else
       {
         d_append_char (dpi, '(');
         d_print_cast (dpi, d_left (dc));
         d_append_char (dpi, ')');
       }
      d_append_char (dpi, '(');
      d_print_comp (dpi, d_right (dc));
      d_append_char (dpi, ')');
      return;

    case DEMANGLE_COMPONENT_BINARY:
      if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
       {
         d_print_error (dpi);
         return;
       }

      /* We wrap an expression which uses the greater-than operator in
        an extra layer of parens so that it does not get confused
        with the '>' which ends the template parameters.  */
      if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
         && d_left (dc)->u.s_operator.op->len == 1
         && d_left (dc)->u.s_operator.op->name[0] == '>')
       d_append_char (dpi, '(');

      d_append_char (dpi, '(');
      d_print_comp (dpi, d_left (d_right (dc)));
      d_append_string (dpi, ") ");
      d_print_expr_op (dpi, d_left (dc));
      d_append_string (dpi, " (");
      d_print_comp (dpi, d_right (d_right (dc)));
      d_append_char (dpi, ')');

      if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
         && d_left (dc)->u.s_operator.op->len == 1
         && d_left (dc)->u.s_operator.op->name[0] == '>')
       d_append_char (dpi, ')');

      return;

    case DEMANGLE_COMPONENT_BINARY_ARGS:
      /* We should only see this as part of DEMANGLE_COMPONENT_BINARY.  */
      d_print_error (dpi);
      return;

    case DEMANGLE_COMPONENT_TRINARY:
      if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
         || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
       {
         d_print_error (dpi);
         return;
       }
      d_append_char (dpi, '(');
      d_print_comp (dpi, d_left (d_right (dc)));
      d_append_string (dpi, ") ");
      d_print_expr_op (dpi, d_left (dc));
      d_append_string (dpi, " (");
      d_print_comp (dpi, d_left (d_right (d_right (dc))));
      d_append_string (dpi, ") : (");
      d_print_comp (dpi, d_right (d_right (d_right (dc))));
      d_append_char (dpi, ')');
      return;

    case DEMANGLE_COMPONENT_TRINARY_ARG1:
    case DEMANGLE_COMPONENT_TRINARY_ARG2:
      /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY.  */
      d_print_error (dpi);
      return;

    case DEMANGLE_COMPONENT_LITERAL:
    case DEMANGLE_COMPONENT_LITERAL_NEG:
      {
       enum d_builtin_type_print tp;

       /* For some builtin types, produce simpler output.  */
       tp = D_PRINT_DEFAULT;
       if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
         {
           tp = d_left (dc)->u.s_builtin.type->print;
           switch (tp)
             {
             case D_PRINT_INT:
             case D_PRINT_UNSIGNED:
             case D_PRINT_LONG:
             case D_PRINT_UNSIGNED_LONG:
             case D_PRINT_LONG_LONG:
             case D_PRINT_UNSIGNED_LONG_LONG:
              if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
                {
                  if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
                    d_append_char (dpi, '-');
                  d_print_comp (dpi, d_right (dc));
                  switch (tp)
                    {
                    default:
                     break;
                    case D_PRINT_UNSIGNED:
                     d_append_char (dpi, 'u');
                     break;
                    case D_PRINT_LONG:
                     d_append_char (dpi, 'l');
                     break;
                    case D_PRINT_UNSIGNED_LONG:
                     d_append_string (dpi, "ul");
                     break;
                    case D_PRINT_LONG_LONG:
                     d_append_string (dpi, "ll");
                     break;
                    case D_PRINT_UNSIGNED_LONG_LONG:
                     d_append_string (dpi, "ull");
                     break;
                    }
                  return;
                }
              break;

             case D_PRINT_BOOL:
              if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
                  && d_right (dc)->u.s_name.len == 1
                  && dc->type == DEMANGLE_COMPONENT_LITERAL)
                {
                  switch (d_right (dc)->u.s_name.s[0])
                    {
                    case '0':
                     d_append_string (dpi, "false");
                     return;
                    case '1':
                     d_append_string (dpi, "true");
                     return;
                    default:
                     break;
                    }
                }
              break;

             default:
              break;
             }
         }

       d_append_char (dpi, '(');
       d_print_comp (dpi, d_left (dc));
       d_append_char (dpi, ')');
       if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
         d_append_char (dpi, '-');
       if (tp == D_PRINT_FLOAT)
         d_append_char (dpi, '[');
       d_print_comp (dpi, d_right (dc));
       if (tp == D_PRINT_FLOAT)
         d_append_char (dpi, ']');
      }
      return;

    default:
      d_print_error (dpi);
      return;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void d_print_error ( struct d_print_info dpi) [inline, static]

Definition at line 2715 of file cp-demangle.c.

{
  dpi->demangle_failure = 1;
}

Here is the caller graph for this function:

static void d_print_expr_op ( struct d_print_info dpi,
const struct demangle_component dc 
) [static]

Definition at line 3850 of file cp-demangle.c.

{
  if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
    d_append_buffer (dpi, dc->u.s_operator.op->name,
                   dc->u.s_operator.op->len);
  else
    d_print_comp (dpi, dc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void d_print_flush ( struct d_print_info dpi) [inline, static]

Definition at line 2729 of file cp-demangle.c.

{
  dpi->buf[dpi->len] = '\0';
  dpi->callback (dpi->buf, dpi->len, dpi->opaque);
  dpi->len = 0;
}

Here is the caller graph for this function:

static void d_print_function_type ( struct d_print_info dpi,
const struct demangle_component dc,
struct d_print_mod mods 
) [static]

Definition at line 3711 of file cp-demangle.c.

{
  int need_paren;
  int saw_mod;
  int need_space;
  struct d_print_mod *p;
  struct d_print_mod *hold_modifiers;

  need_paren = 0;
  saw_mod = 0;
  need_space = 0;
  for (p = mods; p != NULL; p = p->next)
    {
      if (p->printed)
       break;

      saw_mod = 1;
      switch (p->mod->type)
       {
       case DEMANGLE_COMPONENT_POINTER:
       case DEMANGLE_COMPONENT_REFERENCE:
         need_paren = 1;
         break;
       case DEMANGLE_COMPONENT_RESTRICT:
       case DEMANGLE_COMPONENT_VOLATILE:
       case DEMANGLE_COMPONENT_CONST:
       case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
       case DEMANGLE_COMPONENT_COMPLEX:
       case DEMANGLE_COMPONENT_IMAGINARY:
       case DEMANGLE_COMPONENT_PTRMEM_TYPE:
         need_space = 1;
         need_paren = 1;
         break;
       case DEMANGLE_COMPONENT_RESTRICT_THIS:
       case DEMANGLE_COMPONENT_VOLATILE_THIS:
       case DEMANGLE_COMPONENT_CONST_THIS:
         break;
       default:
         break;
       }
      if (need_paren)
       break;
    }

  if (d_left (dc) != NULL && ! saw_mod)
    need_paren = 1;

  if (need_paren)
    {
      if (! need_space)
       {
         if (d_last_char (dpi) != '('
             && d_last_char (dpi) != '*')
           need_space = 1;
       }
      if (need_space && d_last_char (dpi) != ' ')
       d_append_char (dpi, ' ');
      d_append_char (dpi, '(');
    }

  hold_modifiers = dpi->modifiers;
  dpi->modifiers = NULL;

  d_print_mod_list (dpi, mods, 0);

  if (need_paren)
    d_append_char (dpi, ')');

  d_append_char (dpi, '(');

  if (d_right (dc) != NULL)
    d_print_comp (dpi, d_right (dc));

  d_append_char (dpi, ')');

  d_print_mod_list (dpi, mods, 1);

  dpi->modifiers = hold_modifiers;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void d_print_init ( struct d_print_info dpi,
int  options,
demangle_callbackref  callback,
void *  opaque 
) [static]

Definition at line 2697 of file cp-demangle.c.

{
  dpi->options = options;
  dpi->len = 0;
  dpi->last_char = '\0';
  dpi->templates = NULL;
  dpi->modifiers = NULL;

  dpi->callback = callback;
  dpi->opaque = opaque;

  dpi->demangle_failure = 0;
}

Here is the caller graph for this function:

static void d_print_java_identifier ( struct d_print_info dpi,
const char *  name,
int  len 
) [static]

Definition at line 3529 of file cp-demangle.c.

{
  const char *p;
  const char *end;

  end = name + len;
  for (p = name; p < end; ++p)
    {
      if (end - p > 3
         && p[0] == '_'
         && p[1] == '_'
         && p[2] == 'U')
       {
         unsigned long c;
         const char *q;

         c = 0;
         for (q = p + 3; q < end; ++q)
           {
             int dig;

             if (IS_DIGIT (*q))
              dig = *q - '0';
             else if (*q >= 'A' && *q <= 'F')
              dig = *q - 'A' + 10;
             else if (*q >= 'a' && *q <= 'f')
              dig = *q - 'a' + 10;
             else
              break;

             c = c * 16 + dig;
           }
         /* If the Unicode character is larger than 256, we don't try
            to deal with it here.  FIXME.  */
         if (q < end && *q == '_' && c < 256)
           {
             d_append_char (dpi, c);
             p = q;
             continue;
           }
       }

      d_append_char (dpi, *p);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void d_print_mod ( struct d_print_info dpi,
const struct demangle_component mod 
) [static]

Definition at line 3656 of file cp-demangle.c.

{
  switch (mod->type)
    {
    case DEMANGLE_COMPONENT_RESTRICT:
    case DEMANGLE_COMPONENT_RESTRICT_THIS:
      d_append_string (dpi, " restrict");
      return;
    case DEMANGLE_COMPONENT_VOLATILE:
    case DEMANGLE_COMPONENT_VOLATILE_THIS:
      d_append_string (dpi, " volatile");
      return;
    case DEMANGLE_COMPONENT_CONST:
    case DEMANGLE_COMPONENT_CONST_THIS:
      d_append_string (dpi, " const");
      return;
    case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
      d_append_char (dpi, ' ');
      d_print_comp (dpi, d_right (mod));
      return;
    case DEMANGLE_COMPONENT_POINTER:
      /* There is no pointer symbol in Java.  */
      if ((dpi->options & DMGL_JAVA) == 0)
       d_append_char (dpi, '*');
      return;
    case DEMANGLE_COMPONENT_REFERENCE:
      d_append_char (dpi, '&');
      return;
    case DEMANGLE_COMPONENT_COMPLEX:
      d_append_string (dpi, "complex ");
      return;
    case DEMANGLE_COMPONENT_IMAGINARY:
      d_append_string (dpi, "imaginary ");
      return;
    case DEMANGLE_COMPONENT_PTRMEM_TYPE:
      if (d_last_char (dpi) != '(')
       d_append_char (dpi, ' ');
      d_print_comp (dpi, d_left (mod));
      d_append_string (dpi, "::*");
      return;
    case DEMANGLE_COMPONENT_TYPED_NAME:
      d_print_comp (dpi, d_left (mod));
      return;
    default:
      /* Otherwise, we have something that won't go back on the
        modifier stack, so we can just print it.  */
      d_print_comp (dpi, mod);
      return;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void d_print_mod_list ( struct d_print_info dpi,
struct d_print_mod mods,
int  suffix 
) [static]

Definition at line 3579 of file cp-demangle.c.

{
  struct d_print_template *hold_dpt;

  if (mods == NULL || d_print_saw_error (dpi))
    return;

  if (mods->printed
      || (! suffix
         && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS
             || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
             || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS)))
    {
      d_print_mod_list (dpi, mods->next, suffix);
      return;
    }

  mods->printed = 1;

  hold_dpt = dpi->templates;
  dpi->templates = mods->templates;

  if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
    {
      d_print_function_type (dpi, mods->mod, mods->next);
      dpi->templates = hold_dpt;
      return;
    }
  else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
    {
      d_print_array_type (dpi, mods->mod, mods->next);
      dpi->templates = hold_dpt;
      return;
    }
  else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
    {
      struct d_print_mod *hold_modifiers;
      struct demangle_component *dc;

      /* When this is on the modifier stack, we have pulled any
        qualifiers off the right argument already.  Otherwise, we
        print it as usual, but don't let the left argument see any
        modifiers.  */

      hold_modifiers = dpi->modifiers;
      dpi->modifiers = NULL;
      d_print_comp (dpi, d_left (mods->mod));
      dpi->modifiers = hold_modifiers;

      if ((dpi->options & DMGL_JAVA) == 0)
       d_append_string (dpi, "::");
      else
       d_append_char (dpi, '.');

      dc = d_right (mods->mod);
      while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
            || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
            || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
       dc = d_left (dc);

      d_print_comp (dpi, dc);

      dpi->templates = hold_dpt;
      return;
    }

  d_print_mod (dpi, mods->mod);

  dpi->templates = hold_dpt;

  d_print_mod_list (dpi, mods->next, suffix);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int d_print_saw_error ( struct d_print_info dpi) [inline, static]

Definition at line 2721 of file cp-demangle.c.

{
  return dpi->demangle_failure != 0;
}

Here is the caller graph for this function:

static struct demangle_component * d_source_name ( struct d_info di) [static, read]

Definition at line 1285 of file cp-demangle.c.

{
  long len;
  struct demangle_component *ret;

  len = d_number (di);
  if (len <= 0)
    return NULL;
  ret = d_identifier (di, len);
  di->last_name = ret;
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_special_name ( struct d_info di) [static, read]

Definition at line 1496 of file cp-demangle.c.

{
  di->expansion += 20;
  if (d_check_char (di, 'T'))
    {
      switch (d_next_char (di))
       {
       case 'V':
         di->expansion -= 5;
         return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE,
                           cplus_demangle_type (di), NULL);
       case 'T':
         di->expansion -= 10;
         return d_make_comp (di, DEMANGLE_COMPONENT_VTT,
                           cplus_demangle_type (di), NULL);
       case 'I':
         return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO,
                           cplus_demangle_type (di), NULL);
       case 'S':
         return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME,
                           cplus_demangle_type (di), NULL);

       case 'h':
         if (! d_call_offset (di, 'h'))
           return NULL;
         return d_make_comp (di, DEMANGLE_COMPONENT_THUNK,
                           d_encoding (di, 0), NULL);

       case 'v':
         if (! d_call_offset (di, 'v'))
           return NULL;
         return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK,
                           d_encoding (di, 0), NULL);

       case 'c':
         if (! d_call_offset (di, '\0'))
           return NULL;
         if (! d_call_offset (di, '\0'))
           return NULL;
         return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK,
                           d_encoding (di, 0), NULL);

       case 'C':
         {
           struct demangle_component *derived_type;
           long offset;
           struct demangle_component *base_type;

           derived_type = cplus_demangle_type (di);
           offset = d_number (di);
           if (offset < 0)
             return NULL;
           if (! d_check_char (di, '_'))
             return NULL;
           base_type = cplus_demangle_type (di);
           /* We don't display the offset.  FIXME: We should display
              it in verbose mode.  */
           di->expansion += 5;
           return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
                            base_type, derived_type);
         }

       case 'F':
         return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN,
                           cplus_demangle_type (di), NULL);
       case 'J':
         return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS,
                           cplus_demangle_type (di), NULL);

       default:
         return NULL;
       }
    }
  else if (d_check_char (di, 'G'))
    {
      switch (d_next_char (di))
       {
       case 'V':
         return d_make_comp (di, DEMANGLE_COMPONENT_GUARD, d_name (di), NULL);

       case 'R':
         return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, d_name (di),
                           NULL);

       case 'A':
         return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS,
                           d_encoding (di, 0), NULL);

       default:
         return NULL;
       }
    }
  else
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_substitution ( struct d_info di,
int  prefix 
) [static, read]

Definition at line 2532 of file cp-demangle.c.

{
  char c;

  if (! d_check_char (di, 'S'))
    return NULL;

  c = d_next_char (di);
  if (c == '_' || IS_DIGIT (c) || IS_UPPER (c))
    {
      int id;

      id = 0;
      if (c != '_')
       {
         do
           {
             if (IS_DIGIT (c))
              id = id * 36 + c - '0';
             else if (IS_UPPER (c))
              id = id * 36 + c - 'A' + 10;
             else
              return NULL;
             if (id < 0)
              return NULL;
             c = d_next_char (di);
           }
         while (c != '_');

         ++id;
       }

      if (id >= di->next_sub)
       return NULL;

      ++di->did_subs;

      return di->subs[id];
    }
  else
    {
      int verbose;
      const struct d_standard_sub_info *p;
      const struct d_standard_sub_info *pend;

      verbose = (di->options & DMGL_VERBOSE) != 0;
      if (! verbose && prefix)
       {
         char peek;

         peek = d_peek_char (di);
         if (peek == 'C' || peek == 'D')
           verbose = 1;
       }

      pend = (&standard_subs[0]
             + sizeof standard_subs / sizeof standard_subs[0]);
      for (p = &standard_subs[0]; p < pend; ++p)
       {
         if (c == p->code)
           {
             const char *s;
             int len;

             if (p->set_last_name != NULL)
              di->last_name = d_make_sub (di, p->set_last_name,
                                       p->set_last_name_len);
             if (verbose)
              {
                s = p->full_expansion;
                len = p->full_len;
              }
             else
              {
                s = p->simple_expansion;
                len = p->simple_len;
              }
             di->expansion += len;
             return d_make_sub (di, s, len);
           }
       }

      return NULL;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_template_arg ( struct d_info di) [static, read]

Definition at line 2230 of file cp-demangle.c.

{
  struct demangle_component *ret;

  switch (d_peek_char (di))
    {
    case 'X':
      d_advance (di, 1);
      ret = d_expression (di);
      if (! d_check_char (di, 'E'))
       return NULL;
      return ret;

    case 'L':
      return d_expr_primary (di);

    default:
      return cplus_demangle_type (di);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_template_args ( struct d_info di) [static, read]

Definition at line 2183 of file cp-demangle.c.

{
  struct demangle_component *hold_last_name;
  struct demangle_component *al;
  struct demangle_component **pal;

  /* Preserve the last name we saw--don't let the template arguments
     clobber it, as that would give us the wrong name for a subsequent
     constructor or destructor.  */
  hold_last_name = di->last_name;

  if (! d_check_char (di, 'I'))
    return NULL;

  al = NULL;
  pal = &al;
  while (1)
    {
      struct demangle_component *a;

      a = d_template_arg (di);
      if (a == NULL)
       return NULL;

      *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL);
      if (*pal == NULL)
       return NULL;
      pal = &d_right (*pal);

      if (d_peek_char (di) == 'E')
       {
         d_advance (di, 1);
         break;
       }
    }

  di->last_name = hold_last_name;

  return al;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_template_param ( struct d_info di) [static, read]

Definition at line 2155 of file cp-demangle.c.

{
  long param;

  if (! d_check_char (di, 'T'))
    return NULL;

  if (d_peek_char (di) == '_')
    param = 0;
  else
    {
      param = d_number (di);
      if (param < 0)
       return NULL;
      param += 1;
    }

  if (! d_check_char (di, '_'))
    return NULL;

  ++di->did_subs;

  return d_make_template_param (di, param);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct demangle_component * d_unqualified_name ( struct d_info di) [static, read]

Definition at line 1260 of file cp-demangle.c.

{
  char peek;

  peek = d_peek_char (di);
  if (IS_DIGIT (peek))
    return d_source_name (di);
  else if (IS_LOWER (peek))
    {
      struct demangle_component *ret;

      ret = d_operator_name (di);
      if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR)
       di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
      return ret;
    }
  else if (peek == 'C' || peek == 'D')
    return d_ctor_dtor_name (di);
  else
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int has_return_type ( struct demangle_component dc) [static]

Definition at line 979 of file cp-demangle.c.

{
  if (dc == NULL)
    return 0;
  switch (dc->type)
    {
    default:
      return 0;
    case DEMANGLE_COMPONENT_TEMPLATE:
      return ! is_ctor_dtor_or_conversion (d_left (dc));
    case DEMANGLE_COMPONENT_RESTRICT_THIS:
    case DEMANGLE_COMPONENT_VOLATILE_THIS:
    case DEMANGLE_COMPONENT_CONST_THIS:
      return has_return_type (d_left (dc));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1000 of file cp-demangle.c.

{
  if (dc == NULL)
    return 0;
  switch (dc->type)
    {
    default:
      return 0;
    case DEMANGLE_COMPONENT_QUAL_NAME:
    case DEMANGLE_COMPONENT_LOCAL_NAME:
      return is_ctor_dtor_or_conversion (d_right (dc));
    case DEMANGLE_COMPONENT_CTOR:
    case DEMANGLE_COMPONENT_DTOR:
    case DEMANGLE_COMPONENT_CAST:
      return 1;
    }
}

Here is the caller graph for this function:

static int is_ctor_or_dtor ( const char *  mangled,
enum gnu_v3_ctor_kinds ctor_kind,
enum gnu_v3_dtor_kinds dtor_kind 
) [static]

Definition at line 4224 of file cp-demangle.c.

{
  struct d_info di;
  struct demangle_component *dc;
  int ret;

  *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
  *dtor_kind = (enum gnu_v3_dtor_kinds) 0;

  cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);

  {
#ifdef CP_DYNAMIC_ARRAYS
    __extension__ struct demangle_component comps[di.num_comps];
    __extension__ struct demangle_component *subs[di.num_subs];

    di.comps = comps;
    di.subs = subs;
#else
    di.comps = alloca (di.num_comps * sizeof (*di.comps));
    di.subs = alloca (di.num_subs * sizeof (*di.subs));
#endif

    dc = cplus_demangle_mangled_name (&di, 1);

    /* Note that because we did not pass DMGL_PARAMS, we don't expect
       to demangle the entire string.  */

    ret = 0;
    while (dc != NULL)
      {
       switch (dc->type)
         {
         default:
           dc = NULL;
           break;
         case DEMANGLE_COMPONENT_TYPED_NAME:
         case DEMANGLE_COMPONENT_TEMPLATE:
         case DEMANGLE_COMPONENT_RESTRICT_THIS:
         case DEMANGLE_COMPONENT_VOLATILE_THIS:
         case DEMANGLE_COMPONENT_CONST_THIS:
           dc = d_left (dc);
           break;
         case DEMANGLE_COMPONENT_QUAL_NAME:
         case DEMANGLE_COMPONENT_LOCAL_NAME:
           dc = d_right (dc);
           break;
         case DEMANGLE_COMPONENT_CTOR:
           *ctor_kind = dc->u.s_ctor.kind;
           ret = 1;
           dc = NULL;
           break;
         case DEMANGLE_COMPONENT_DTOR:
           *dtor_kind = dc->u.s_dtor.kind;
           ret = 1;
           dc = NULL;
           break;
         }
      }
  }

  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 4294 of file cp-demangle.c.

{
  enum gnu_v3_ctor_kinds ctor_kind;
  enum gnu_v3_dtor_kinds dtor_kind;

  if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
    return (enum gnu_v3_ctor_kinds) 0;
  return ctor_kind;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 4309 of file cp-demangle.c.

{
  enum gnu_v3_ctor_kinds ctor_kind;
  enum gnu_v3_dtor_kinds dtor_kind;

  if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
    return (enum gnu_v3_dtor_kinds) 0;
  return dtor_kind;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* java_demangle_v3 ( const char *  mangled)

Definition at line 4199 of file cp-demangle.c.

{
  size_t alc;

  return d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, &alc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int java_demangle_v3_callback ( const char *  mangled,
demangle_callbackref  callback,
void *  opaque 
)

Definition at line 4207 of file cp-demangle.c.

Here is the call graph for this function:


Variable Documentation

Initial value:
{
  { 't', NL ("std"),
    NL ("std"),
    NULL, 0 },
  { 'a', NL ("std::allocator"),
    NL ("std::allocator"),
    NL ("allocator") },
  { 'b', NL ("std::basic_string"),
    NL ("std::basic_string"),
    NL ("basic_string") },
  { 's', NL ("std::string"),
    NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
    NL ("basic_string") },
  { 'i', NL ("std::istream"),
    NL ("std::basic_istream<char, std::char_traits<char> >"),
    NL ("basic_istream") },
  { 'o', NL ("std::ostream"),
    NL ("std::basic_ostream<char, std::char_traits<char> >"),
    NL ("basic_ostream") },
  { 'd', NL ("std::iostream"),
    NL ("std::basic_iostream<char, std::char_traits<char> >"),
    NL ("basic_iostream") }
}

Definition at line 2506 of file cp-demangle.c.

Definition at line 1719 of file cp-demangle.c.

Definition at line 1382 of file cp-demangle.c.