cp-demangle.h File Reference

Go to the source code of this file.

Classes
struct	demangle_operator_info
struct	demangle_builtin_type_info
struct	d_info

Macros
#define	d_peek_char(di)   (*((di)->n))
#define	d_peek_next_char(di)   ((di)->n[1])
#define	d_advance(di, i)   ((di)->n += (i))
#define	d_check_char(di, c)   (d_peek_char(di) == c ? ((di)->n++, 1) : 0)
#define	d_next_char(di)   (d_peek_char(di) == '\0' ? '\0' : *((di)->n++))
#define	d_str(di)   ((di)->n)
#define	CP_STATIC_IF_GLIBCPP_V3   extern
#define	D_BUILTIN_TYPE_COUNT   (33)

Enumerations
enum	d_builtin_type_print {   D_PRINT_DEFAULT , D_PRINT_INT , D_PRINT_UNSIGNED , D_PRINT_LONG ,   D_PRINT_UNSIGNED_LONG , D_PRINT_LONG_LONG , D_PRINT_UNSIGNED_LONG_LONG , D_PRINT_BOOL ,   D_PRINT_FLOAT , D_PRINT_VOID }

Functions
CP_STATIC_IF_GLIBCPP_V3 struct demangle_component *	cplus_demangle_mangled_name (struct d_info *, int)
CP_STATIC_IF_GLIBCPP_V3 struct demangle_component *	cplus_demangle_type (struct d_info *)
void	cplus_demangle_init_info (const char *, int, size_t, struct d_info *)

Variables
const struct demangle_operator_info	cplus_demangle_operators []
CP_STATIC_IF_GLIBCPP_V3 const struct demangle_builtin_type_info	cplus_demangle_builtin_types [D_BUILTIN_TYPE_COUNT]

Macro Definition Documentation

CP_STATIC_IF_GLIBCPP_V3

#define CP_STATIC_IF_GLIBCPP_V3   extern

Definition at line 165 of file cp-demangle.h.

d_advance

#define d_advance	(		di,
			i
	)		((di)->n += (i))

Definition at line 134 of file cp-demangle.h.

D_BUILTIN_TYPE_COUNT

#define D_BUILTIN_TYPE_COUNT   (33)

Definition at line 172 of file cp-demangle.h.

d_check_char

#define d_check_char	(		di,
			c
	)		(d_peek_char(di) == c ? ((di)->n++, 1) : 0)

Definition at line 136 of file cp-demangle.h.

d_next_char

#define d_next_char

(

di

)

(d_peek_char(di) == '\0' ? '\0' : *((di)->n++))

Definition at line 137 of file cp-demangle.h.

d_peek_char

#define d_peek_char

(

di

)

(*((di)->n))

Definition at line 131 of file cp-demangle.h.

d_peek_next_char

#define d_peek_next_char

(

di

)

((di)->n[1])

Definition at line 133 of file cp-demangle.h.

d_str

#define d_str

(

di

)

((di)->n)

Definition at line 138 of file cp-demangle.h.

Enumeration Type Documentation

d_builtin_type_print

enum d_builtin_type_print

Enumerator
D_PRINT_DEFAULT
D_PRINT_INT
D_PRINT_UNSIGNED
D_PRINT_LONG
D_PRINT_UNSIGNED_LONG
D_PRINT_LONG_LONG
D_PRINT_UNSIGNED_LONG_LONG
D_PRINT_BOOL
D_PRINT_FLOAT
D_PRINT_VOID

Definition at line 52 of file cp-demangle.h.

                          {
    /* Print as (type)val.  */
    D_PRINT_DEFAULT,
    /* Print as integer.  */
    D_PRINT_INT,
    /* Print as unsigned integer, with trailing "u".  */
    D_PRINT_UNSIGNED,
    /* Print as long, with trailing "l".  */
    D_PRINT_LONG,
    /* Print as unsigned long, with trailing "ul".  */
    D_PRINT_UNSIGNED_LONG,
    /* Print as long long, with trailing "ll".  */
    D_PRINT_LONG_LONG,
    /* Print as unsigned long long, with trailing "ull".  */
    D_PRINT_UNSIGNED_LONG_LONG,
    /* Print as bool.  */
    D_PRINT_BOOL,
    /* Print as float--put value in square brackets.  */
    D_PRINT_FLOAT,
    /* Print in usual way, but here to detect void.  */
    D_PRINT_VOID
};

Function Documentation

cplus_demangle_init_info()

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

Definition at line 5681 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->last_name = NULL;
 
    di->expansion = 0;
    di->is_expression = 0;
    di->is_conversion = 0;
}

References d_info::expansion, d_info::is_conversion, d_info::is_expression, d_info::last_name, len, d_info::n, d_info::next_comp, d_info::next_sub, NULL, d_info::num_comps, d_info::num_subs, options, d_info::options, d_info::s, and d_info::send.

Referenced by d_demangle_callback(), and is_ctor_or_dtor().

cplus_demangle_mangled_name()

CP_STATIC_IF_GLIBCPP_V3 struct demangle_component* cplus_demangle_mangled_name	(	struct d_info *	di,
		int	top_level
	)

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

                                                              {
    struct demangle_component *p;
 
    if (!d_check_char(di, '_')
        /* Allow missing _ if not at toplevel to work around a
     bug in G++ abi-version=2 mangling; see the comment in
     write_template_arg.  */
        && top_level)
        return NULL;
    if (!d_check_char(di, 'Z'))
        return NULL;
    p = d_encoding(di, top_level);
 
    /* If at top level and parsing parameters, check for a clone
     suffix.  */
    if (top_level && (di->options & DMGL_PARAMS) != 0)
        while (d_peek_char(di) == '.' && (IS_LOWER(d_peek_next_char(di)) || d_peek_next_char(di) == '_' || IS_DIGIT(d_peek_next_char(di))))
            p = d_clone_suffix(di, p);
 
    return p;
}

References d_check_char, d_clone_suffix(), d_encoding(), d_peek_char, d_peek_next_char, DMGL_PARAMS, IS_DIGIT, IS_LOWER, NULL, d_info::options, and p.

Referenced by d_demangle_callback(), d_expr_primary(), and is_ctor_or_dtor().

cplus_demangle_type()

CP_STATIC_IF_GLIBCPP_V3 struct demangle_component* cplus_demangle_type

(

struct d_info *

di

)

Definition at line 2212 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.  */
 
    if (next_is_type_qual(di)) {
        struct demangle_component **pret;
 
        pret = d_cv_qualifiers(di, &ret, 0);
        if (pret == NULL)
            return NULL;
        if (d_peek_char(di) == 'F') {
            /* cv-qualifiers before a function type apply to 'this',
         so avoid adding the unqualified function type to
         the substitution list.  */
            *pret = d_function_type(di);
        } else
            *pret = cplus_demangle_type(di);
        if (!*pret)
            return NULL;
        if ((*pret)->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS || (*pret)->type == DEMANGLE_COMPONENT_REFERENCE_THIS) {
            /* Move the ref-qualifier outside the cv-qualifiers so that
         they are printed in the right order.  */
            struct demangle_component *fn = d_left(*pret);
            d_left(*pret) = ret;
            ret = *pret;
            *pret = fn;
        }
        if (!d_add_substitution(di, ret))
            return NULL;
        return ret;
    }
 
    can_subst = 1;
 
    peek = d_peek_char(di);
    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 may be <template-template-param> <template-args>.
         If this is the type for a conversion operator, we can
         have a <template-template-param> here only by following
         a derivation like this:
 
         <nested-name>
         -> <template-prefix> <template-args>
         -> <prefix> <template-unqualified-name> <template-args>
         -> <unqualified-name> <template-unqualified-name> <template-args>
         -> <source-name> <template-unqualified-name> <template-args>
         -> <source-name> <operator-name> <template-args>
         -> <source-name> cv <type> <template-args>
         -> <source-name> cv <template-template-param> <template-args> <template-args>
 
         where the <template-args> is followed by another.
         Otherwise, we must have a derivation like this:
 
         <nested-name>
         -> <template-prefix> <template-args>
         -> <prefix> <template-unqualified-name> <template-args>
         -> <unqualified-name> <template-unqualified-name> <template-args>
         -> <source-name> <template-unqualified-name> <template-args>
         -> <source-name> <operator-name> <template-args>
         -> <source-name> cv <type> <template-args>
         -> <source-name> cv <template-param> <template-args>
 
         where we need to leave the <template-args> to be processed
         by d_prefix (following the <template-prefix>).
 
         The <template-template-param> part is a substitution
         candidate.  */
            if (!di->is_conversion) {
                if (!d_add_substitution(di, ret))
                    return NULL;
                ret = d_make_comp(di, DEMANGLE_COMPONENT_TEMPLATE, ret,
                    d_template_args(di));
            } else {
                struct demangle_component *args;
                struct d_info_checkpoint checkpoint;
 
                d_checkpoint(di, &checkpoint);
                args = d_template_args(di);
                if (d_peek_char(di) == 'I') {
                    if (!d_add_substitution(di, ret))
                        return NULL;
                    ret = d_make_comp(di, DEMANGLE_COMPONENT_TEMPLATE, ret,
                        args);
                } else
                    d_backtrack(di, &checkpoint);
            }
        }
        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 'O':
        d_advance(di, 1);
        ret = d_make_comp(di, DEMANGLE_COMPONENT_RVALUE_REFERENCE,
            cplus_demangle_type(di), NULL);
        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);
        if (d_peek_char(di) == 'I')
            ret = d_make_comp(di, DEMANGLE_COMPONENT_TEMPLATE, ret,
                d_template_args(di));
        ret = d_make_comp(di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
            cplus_demangle_type(di), ret);
        break;
 
    case 'D':
        can_subst = 0;
        d_advance(di, 1);
        peek = d_next_char(di);
        switch (peek) {
        case 'T':
        case 't':
            /* decltype (expression) */
            ret = d_make_comp(di, DEMANGLE_COMPONENT_DECLTYPE,
                d_expression(di), NULL);
            if (ret && d_next_char(di) != 'E')
                ret = NULL;
            can_subst = 1;
            break;
 
        case 'p':
            /* Pack expansion.  */
            ret = d_make_comp(di, DEMANGLE_COMPONENT_PACK_EXPANSION,
                cplus_demangle_type(di), NULL);
            can_subst = 1;
            break;
 
        case 'a':
            /* auto */
            ret = d_make_name(di, "auto", 4);
            break;
        case 'c':
            /* decltype(auto) */
            ret = d_make_name(di, "decltype(auto)", 14);
            break;
 
        case 'f':
            /* 32-bit decimal floating point */
            ret = d_make_builtin_type(di, &cplus_demangle_builtin_types[26]);
            di->expansion += ret->u.s_builtin.type->len;
            break;
        case 'd':
            /* 64-bit DFP */
            ret = d_make_builtin_type(di, &cplus_demangle_builtin_types[27]);
            di->expansion += ret->u.s_builtin.type->len;
            break;
        case 'e':
            /* 128-bit DFP */
            ret = d_make_builtin_type(di, &cplus_demangle_builtin_types[28]);
            di->expansion += ret->u.s_builtin.type->len;
            break;
        case 'h':
            /* 16-bit half-precision FP */
            ret = d_make_builtin_type(di, &cplus_demangle_builtin_types[29]);
            di->expansion += ret->u.s_builtin.type->len;
            break;
        case 's':
            /* char16_t */
            ret = d_make_builtin_type(di, &cplus_demangle_builtin_types[30]);
            di->expansion += ret->u.s_builtin.type->len;
            break;
        case 'i':
            /* char32_t */
            ret = d_make_builtin_type(di, &cplus_demangle_builtin_types[31]);
            di->expansion += ret->u.s_builtin.type->len;
            break;
 
        case 'F':
            /* Fixed point types. DF<int bits><length><fract bits><sat>  */
            ret = d_make_empty(di);
            ret->type = DEMANGLE_COMPONENT_FIXED_TYPE;
            if ((ret->u.s_fixed.accum = IS_DIGIT(d_peek_char(di))))
                /* For demangling we don't care about the bits.  */
                d_number(di);
            ret->u.s_fixed.length = cplus_demangle_type(di);
            if (ret->u.s_fixed.length == NULL)
                return NULL;
            d_number(di);
            peek = d_next_char(di);
            ret->u.s_fixed.sat = (peek == 's');
            break;
 
        case 'v':
            ret = d_vector_type(di);
            can_subst = 1;
            break;
 
        case 'n':
            /* decltype(nullptr) */
            ret = d_make_builtin_type(di, &cplus_demangle_builtin_types[32]);
            di->expansion += ret->u.s_builtin.type->len;
            break;
 
        default:
            return NULL;
        }
        break;
 
    default:
        return NULL;
    }
 
    if (can_subst) {
        if (!d_add_substitution(di, ret))
            return NULL;
    }
 
    return ret;
}

References args, cplus_demangle_builtin_types, d_add_substitution(), d_advance, d_array_type(), d_backtrack(), d_checkpoint(), d_class_enum_type(), d_cv_qualifiers(), d_expression(), d_function_type(), d_left, d_make_builtin_type(), d_make_comp(), d_make_empty(), d_make_name(), d_next_char, d_number(), d_peek_char, d_peek_next_char, d_pointer_to_member_type(), d_source_name(), d_substitution(), d_template_args(), d_template_param(), d_vector_type(), DEMANGLE_COMPONENT_COMPLEX, DEMANGLE_COMPONENT_DECLTYPE, DEMANGLE_COMPONENT_FIXED_TYPE, DEMANGLE_COMPONENT_IMAGINARY, DEMANGLE_COMPONENT_PACK_EXPANSION, DEMANGLE_COMPONENT_POINTER, DEMANGLE_COMPONENT_REFERENCE, DEMANGLE_COMPONENT_REFERENCE_THIS, DEMANGLE_COMPONENT_RVALUE_REFERENCE, DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS, DEMANGLE_COMPONENT_SUB_STD, DEMANGLE_COMPONENT_TEMPLATE, DEMANGLE_COMPONENT_VENDOR_TYPE, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL, d_info::expansion, fn, d_info::is_conversion, IS_DIGIT, IS_UPPER, next_is_type_qual(), NULL, demangle_component::s_builtin, demangle_component::s_fixed, demangle_component::type, and demangle_component::u.

Referenced by d_array_type(), d_bare_function_type(), d_ctor_dtor_name(), d_demangle_callback(), d_expr_primary(), d_expression_1(), d_operator_name(), d_parmlist(), d_pointer_to_member_type(), d_prefix(), d_special_name(), d_template_arg(), and d_vector_type().

Variable Documentation

cplus_demangle_builtin_types

CP_STATIC_IF_GLIBCPP_V3 const struct demangle_builtin_type_info cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT]

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

cplus_demangle_operators

const struct demangle_operator_info cplus_demangle_operators[]

extern

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

Referenced by d_operator_name().