microsoft_demangle.c File Reference

#include "microsoft_demangle.h"
#include <ctype.h>

Go to the source code of this file.

Classes
struct	STypeCodeStr
struct	SStateInfo
struct	SStrInfo
struct	SDataType

Macros
#define	MICROSOFT_NAME_LEN   (256)
#define	MICROSOFR_CLASS_NAMESPACE_LEN   (256)
#define	IMPOSSIBLE_LEN   (MICROSOFT_NAME_LEN + MICROSOFR_CLASS_NAMESPACE_LEN)
#define	DECL_STATE_ACTION(action)   static void tc_state_##action(SStateInfo *state, STypeCodeStr *type_code_str);
#define	NAME(action)   tc_state_##action
#define	copy_string(type_code_str, str_for_copy)   copy_string_n(type_code_str, str_for_copy, str_for_copy ? strlen(str_for_copy) : 0)
#define	SET_OPERATOR_CODE(str)
#define	SINGLEQUOTED_A   'A'
#define	SINGLEQUOTED_B   'B'
#define	SINGLEQUOTED_C   'C'
#define	SINGLEQUOTED_D   'D'
#define	SINGLEQUOTED_E   'E'
#define	SINGLEQUOTED_F   'F'
#define	SINGLEQUOTED_G   'G'
#define	SINGLEQUOTED_H   'H'
#define	SINGLEQUOTED_I   'I'
#define	SINGLEQUOTED_J   'J'
#define	SINGLEQUOTED_K   'K'
#define	SINGLEQUOTED_L   'L'
#define	SINGLEQUOTED_M   'M'
#define	SINGLEQUOTED_N   'N'
#define	SINGLEQUOTED_O   'O'
#define	SINGLEQUOTED_P   'P'
#define	SINGLEQUOTED_Q   'Q'
#define	SINGLEQUOTED_R   'R'
#define	SINGLEQUOTED_S   'S'
#define	SINGLEQUOTED_T   'T'
#define	SINGLEQUOTED_U   'U'
#define	SINGLEQUOTED_V   'V'
#define	SINGLEQUOTED_W   'W'
#define	SINGLEQUOTED_X   'X'
#define	SINGLEQUOTED_Y   'Y'
#define	SINGLEQUOTED_Z   'Z'
#define	SINGLEQUOTED__   '_'
#define	SINGLEQUOTED_   $ '$'
#define	CHAR_WITH_QUOTES(letter)   (SINGLEQUOTED_##letter)
#define	DEF_STATE_ACTION(action)   static void tc_state_##action(SStateInfo *state, STypeCodeStr *type_code_str)
#define	GO_TO_NEXT_STATE(state, new_state)
#define	ONE_LETTER_ACTION(action, type)
#define	PROCESS_CASE(letter, type_str)
#define	GET_USER_DEF_TYPE_NAME(data_struct_str)
#define	PROCESS_CASE(case_string, type_str)
#define	PROCESS_CASE(case_string, type_str)
#define	PARSE_POINTER(pointer_str)   parse_pointer(state, type_code_str, pointer_str)
#define	ONE_LETTER_STATE(letter)
#define	SET_PTR_MODIFIER(letter, modifier_left, modifier_right)
#define	SET_THUNK_MODIFIER(letter, modifier_str)
#define	SET_ACCESS_MODIFIER(letter, flag_set, modifier_str)

Typedefs
typedef enum EObjectType	EObjectType
typedef enum ETCStateMachineErr	ETCStateMachineErr
typedef enum ETCState	ETCState
typedef struct STypeCodeStr	STypeCodeStr
typedef void(*	state_func) (struct SStateInfo *, STypeCodeStr *type_code_str)
typedef struct SStateInfo	SStateInfo
typedef struct SStrInfo	SStrInfo
typedef struct SDataType	SDataType

Enumerations
enum	EObjectType { eObjectTypeStaticClassMember = 2 , eObjectTypeGlobal = 3 , eObjectTypeMax = 99 }
enum	ETCStateMachineErr {   eTCStateMachineErrOK , eTCStateMachineErrUncorrectTypeCode , eTCStateMachineErrUnsupportedTypeCode , eTCStateMachineErrAlloc ,   eTCStateMachineErrMax }
enum	ETCState {   eTCStateStart = 0 , eTCStateEnd , eTCStateA , eTCStateB ,   eTCStateC , eTCStateD , eTCStateE , eTCStateF ,   eTCStateG , eTCStateH , eTCStateI , eTCStateJ ,   eTCStateK , eTCStateM , eTCStateN , eTCStateO ,   eTCStateP , eTCStateQ , eTCStateR , eTCStateS ,   eTCStateT , eTCStateU , eTCStateV , eTCStateW ,   eTCStateX , eTCStateZ , eTCState_ , eTCState ,   eTCStateMax }

Functions
static void	sdatatype_fini (SDataType *data_type)
static void	sstrinfo_free (SStrInfo *sstrinfo)
static void	init_state_struct (SStateInfo *state, const char *buff_for_parsing)
static EDemanglerErr	get_type_code_string (const char *sym, size_t *amount_of_read_chars, char **str_type_code)
static bool	init_type_code_str_struct (STypeCodeStr *type_code_str)
static void	free_type_code_str_struct (STypeCodeStr *type_code_str)
static char *	type_code_str_get (STypeCodeStr *type_code_str)
static size_t	get_template (const char *buf, SStrInfo *str_info, bool memorize)
static char *	get_num (SStateInfo *state)
static EDemanglerErr	parse_data_type (const char *sym, SDataType *demangled_type, size_t *len)
static size_t	get_namespace_and_name (const char *buf, STypeCodeStr *type_code_str, size_t *amount_of_names, bool memorize)
	get_namespace_and_name More...
static EDemanglerErr	get_storage_class (const char encoded, const char **storage_class)
static size_t	get_ptr_modifier (const char *encoded, SDataType *ptr_modifier)
static EDemanglerErr	parse_function (const char *sym, STypeCodeStr *type_code_str, char **demangled_function, size_t *chars_read)
static EDemanglerErr	parse_microsoft_mangled_name (const char *sym, char **demangled_name, size_t *chars_read)
static EDemanglerErr	parse_microsoft_rtti_mangled_name (const char *sym, char **demangled_name, size_t *chars_read)
static void	run_state (SStateInfo *state_info, STypeCodeStr *type_code_str)
static bool	copy_string_n (STypeCodeStr *type_code_str, const char *str_for_copy, size_t copy_len)
static int	get_template_params (const char *sym, size_t *amount_of_read_chars, char **str_type_code)
static ut16	read_be16 (const void *src)
static ssize_t	utf16be_to_utf8_impl (const char *utf16be, size_t utf16be_len, char *utf8, size_t utf8_len)
static EDemanglerErr	utf16be_to_utf8 (const char *utf16be, size_t utf16be_len, char **utf8, size_t *utf8_len)
static size_t	get_operator_code (const char *buf, DemList *names_l, bool memorize)
	DEF_STATE_ACTION (_)
	DEF_STATE_ACTION (T)
	DEF_STATE_ACTION (U)
	DEF_STATE_ACTION (W)
	DEF_STATE_ACTION (V)
static void	parse_type_modifier (SStateInfo *state, STypeCodeStr *type_code_str, const char *modifier_str)
	DEF_STATE_ACTION (S)
static const char *	get_calling_convention (char calling_convention)
static EDemanglerErr	parse_function_args (const char *sym, char **demangled_args, size_t *read_chars)
static void	parse_function_pointer (SStateInfo *state, STypeCodeStr *type_code_str, const char *pointer_str)
static void	parse_pointer (SStateInfo *state, STypeCodeStr *type_code_str, const char *pointer_str)
	DEF_STATE_ACTION (P)
	DEF_STATE_ACTION (R)
	DEF_STATE_ACTION (Q)
	DEF_STATE_ACTION (A)
	DEF_STATE_ACTION (B)
	DEF_STATE_ACTION ($)
static void	tc_state_start (SStateInfo *state, STypeCodeStr *type_code_str)
static void	tc_state_end (SStateInfo *state, STypeCodeStr *type_code_str)
static EDemanglerErr	parse_function_type (const char *sym, SDataType *data_type, size_t *len, bool *is_static, bool *is_implicit_this_pointer)
EDemanglerErr	microsoft_demangle (SDemangler *demangler, char **demangled_name)
	Do demangle for microsoft mangling scheme. Demangled name need to be free by user. More...

Variables
static DemList *	abbr_types = NULL
static DemList *	abbr_names = NULL
static state_func const	state_table [eTCStateMax]

Macro Definition Documentation

CHAR_WITH_QUOTES

#define CHAR_WITH_QUOTES

(

letter

)

(SINGLEQUOTED_##letter)

Definition at line 1174 of file microsoft_demangle.c.

copy_string

#define copy_string	(		type_code_str,
			str_for_copy
	)		copy_string_n(type_code_str, str_for_copy, str_for_copy ? strlen(str_for_copy) : 0)

Definition at line 197 of file microsoft_demangle.c.

DECL_STATE_ACTION

#define DECL_STATE_ACTION

(

action

)

static void tc_state_##action(SStateInfo *state, STypeCodeStr *type_code_str);

Definition at line 107 of file microsoft_demangle.c.

DEF_STATE_ACTION

#define DEF_STATE_ACTION

(

action

)

static void tc_state_##action(SStateInfo *state, STypeCodeStr *type_code_str)

Definition at line 1176 of file microsoft_demangle.c.

GET_USER_DEF_TYPE_NAME

#define GET_USER_DEF_TYPE_NAME

(

data_struct_str

)

Value:

    { \
        copy_string(type_code_str, data_struct_str); \
\
        check_len = get_namespace_and_name(state->buff_for_parsing, type_code_str, NULL, true); \
        if (check_len) { \
            state->amount_of_read_chars += check_len; \
            state->buff_for_parsing += check_len; \
            if (*state->buff_for_parsing) { \
                state->buff_for_parsing++; \
                state->amount_of_read_chars++; \
            } \
        } else { \
            state->err = eTCStateMachineErrUncorrectTypeCode; \
        } \
    }

Definition at line 1245 of file microsoft_demangle.c.

GO_TO_NEXT_STATE

#define GO_TO_NEXT_STATE	(		state,
			new_state
	)

Value:

    { \
        (state)->amount_of_read_chars++; \
        (state)->buff_for_parsing++; \
        (state)->state = eTCStateEnd; \
    }

Definition at line 1177 of file microsoft_demangle.c.

IMPOSSIBLE_LEN

#define IMPOSSIBLE_LEN   (MICROSOFT_NAME_LEN + MICROSOFR_CLASS_NAMESPACE_LEN)

Definition at line 9 of file microsoft_demangle.c.

MICROSOFR_CLASS_NAMESPACE_LEN

#define MICROSOFR_CLASS_NAMESPACE_LEN   (256)

Definition at line 8 of file microsoft_demangle.c.

MICROSOFT_NAME_LEN

#define MICROSOFT_NAME_LEN   (256)

Definition at line 7 of file microsoft_demangle.c.

NAME

#define NAME

(

action

)

tc_state_##action

Definition at line 138 of file microsoft_demangle.c.

ONE_LETTER_ACTION

#define ONE_LETTER_ACTION	(		action,
			type
	)

Value:

    static void tc_state_##action(SStateInfo *state, STypeCodeStr *type_code_str) { \
        if (copy_string(type_code_str, type) == 0) { \
            state->err = eTCStateMachineErrAlloc; \
        } \
        state->state = eTCStateEnd; \
    }

Definition at line 1183 of file microsoft_demangle.c.

ONE_LETTER_STATE

#define ONE_LETTER_STATE

(

letter

)

Value:

    case CHAR_WITH_QUOTES(letter): \
        state->state = eTCState##letter; \
        break;

PARSE_POINTER

#define PARSE_POINTER

(

pointer_str

)

parse_pointer(state, type_code_str, pointer_str)

Definition at line 1807 of file microsoft_demangle.c.

PROCESS_CASE [1/3]

#define PROCESS_CASE	(		case_string,
			type_str
	)

Value:

    { \
        check_len = strlen(case_string); \
        if (strncmp(state->buff_for_parsing, case_string, check_len) == 0) { \
            copy_string(type_code_str, type_str); \
            state->buff_for_parsing += check_len; \
            state->amount_of_read_chars += check_len; \
            return; \
        } \
    }

PROCESS_CASE [2/3]

#define PROCESS_CASE	(		case_string,
			type_str
	)

Value:

    { \
        check_len = strlen(case_string); \
        if (strncmp(state->buff_for_parsing, case_string, check_len) == 0) { \
            copy_string(type_code_str, type_str); \
            state->amount_of_read_chars += check_len; \
            state->buff_for_parsing += check_len; \
            return; \
        } \
    }

PROCESS_CASE [3/3]

#define PROCESS_CASE	(		letter,
			type_str
	)

Value:

    case CHAR_WITH_QUOTES(letter): \
        copy_string(type_code_str, type_str); \
        break;

SET_ACCESS_MODIFIER

#define SET_ACCESS_MODIFIER	(		letter,
			flag_set,
			modifier_str
	)

Value:

    case letter: \
        data_type->left = strdup(modifier_str); \
        *flag_set = true; \
        break;

SET_OPERATOR_CODE

#define SET_OPERATOR_CODE

(

str

)

Value:

    { \
        str_info = malloc(sizeof(SStrInfo)); \
        if (!str_info) \
            break; \
        str_info->len = strlen(str); \
        str_info->str_ptr = strdup(str); \
        dem_list_append(names_l, str_info); \
    }

SET_PTR_MODIFIER

#define SET_PTR_MODIFIER	(		letter,
			modifier_left,
			modifier_right
	)

Value:

    case letter: \
        ptr_modifier->left = dem_str_append(ptr_modifier->left, modifier_left); \
        ptr_modifier->right = dem_str_append(ptr_modifier->right, modifier_right); \
        break;

SET_THUNK_MODIFIER

#define SET_THUNK_MODIFIER	(		letter,
			modifier_str
	)

Value:

    case letter: { \
        SStateInfo state; \
        init_state_struct(&state, curr_pos); \
        char *num = get_num(&state); \
        if (!num) { \
            return eDemanglerErrUncorrectMangledSymbol; \
        } \
        data_type->left = strdup(modifier_str); \
        data_type->right = dem_str_newf("`adjustor{%s}'", num); \
        free(num); \
        *is_implicit_this_pointer = true; \
        curr_pos += state.amount_of_read_chars; \
        break; \
    }

SINGLEQUOTED_

#define SINGLEQUOTED_   $ '$'

Definition at line 1173 of file microsoft_demangle.c.

SINGLEQUOTED__

#define SINGLEQUOTED__   '_'

Definition at line 1172 of file microsoft_demangle.c.

SINGLEQUOTED_A

#define SINGLEQUOTED_A   'A'

Definition at line 1146 of file microsoft_demangle.c.

SINGLEQUOTED_B

#define SINGLEQUOTED_B   'B'

Definition at line 1147 of file microsoft_demangle.c.

SINGLEQUOTED_C

#define SINGLEQUOTED_C   'C'

Definition at line 1148 of file microsoft_demangle.c.

SINGLEQUOTED_D

#define SINGLEQUOTED_D   'D'

Definition at line 1149 of file microsoft_demangle.c.

SINGLEQUOTED_E

#define SINGLEQUOTED_E   'E'

Definition at line 1150 of file microsoft_demangle.c.

SINGLEQUOTED_F

#define SINGLEQUOTED_F   'F'

Definition at line 1151 of file microsoft_demangle.c.

SINGLEQUOTED_G

#define SINGLEQUOTED_G   'G'

Definition at line 1152 of file microsoft_demangle.c.

SINGLEQUOTED_H

#define SINGLEQUOTED_H   'H'

Definition at line 1153 of file microsoft_demangle.c.

SINGLEQUOTED_I

#define SINGLEQUOTED_I   'I'

Definition at line 1154 of file microsoft_demangle.c.

SINGLEQUOTED_J

#define SINGLEQUOTED_J   'J'

Definition at line 1155 of file microsoft_demangle.c.

SINGLEQUOTED_K

#define SINGLEQUOTED_K   'K'

Definition at line 1156 of file microsoft_demangle.c.

SINGLEQUOTED_L

#define SINGLEQUOTED_L   'L'

Definition at line 1157 of file microsoft_demangle.c.

SINGLEQUOTED_M

#define SINGLEQUOTED_M   'M'

Definition at line 1158 of file microsoft_demangle.c.

SINGLEQUOTED_N

#define SINGLEQUOTED_N   'N'

Definition at line 1159 of file microsoft_demangle.c.

SINGLEQUOTED_O

#define SINGLEQUOTED_O   'O'

Definition at line 1160 of file microsoft_demangle.c.

SINGLEQUOTED_P

#define SINGLEQUOTED_P   'P'

Definition at line 1161 of file microsoft_demangle.c.

SINGLEQUOTED_Q

#define SINGLEQUOTED_Q   'Q'

Definition at line 1162 of file microsoft_demangle.c.

SINGLEQUOTED_R

#define SINGLEQUOTED_R   'R'

Definition at line 1163 of file microsoft_demangle.c.

SINGLEQUOTED_S

#define SINGLEQUOTED_S   'S'

Definition at line 1164 of file microsoft_demangle.c.

SINGLEQUOTED_T

#define SINGLEQUOTED_T   'T'

Definition at line 1165 of file microsoft_demangle.c.

SINGLEQUOTED_U

#define SINGLEQUOTED_U   'U'

Definition at line 1166 of file microsoft_demangle.c.

SINGLEQUOTED_V

#define SINGLEQUOTED_V   'V'

Definition at line 1167 of file microsoft_demangle.c.

SINGLEQUOTED_W

#define SINGLEQUOTED_W   'W'

Definition at line 1168 of file microsoft_demangle.c.

SINGLEQUOTED_X

#define SINGLEQUOTED_X   'X'

Definition at line 1169 of file microsoft_demangle.c.

SINGLEQUOTED_Y

#define SINGLEQUOTED_Y   'Y'

Definition at line 1170 of file microsoft_demangle.c.

SINGLEQUOTED_Z

#define SINGLEQUOTED_Z   'Z'

Definition at line 1171 of file microsoft_demangle.c.

Typedef Documentation

EObjectType

typedef enum EObjectType EObjectType

ETCState

typedef enum ETCState ETCState

ETCStateMachineErr

typedef enum ETCStateMachineErr ETCStateMachineErr

SDataType

typedef struct SDataType SDataType

SStateInfo

typedef struct SStateInfo SStateInfo

SStrInfo

typedef struct SStrInfo SStrInfo

state_func

typedef void(* state_func) (struct SStateInfo *, STypeCodeStr *type_code_str)

Definition at line 72 of file microsoft_demangle.c.

STypeCodeStr

typedef struct STypeCodeStr STypeCodeStr

Enumeration Type Documentation

EObjectType

enum EObjectType

Enumerator
eObjectTypeStaticClassMember
eObjectTypeGlobal
eObjectTypeMax

Definition at line 15 of file microsoft_demangle.c.

                         {
    eObjectTypeStaticClassMember = 2,
    eObjectTypeGlobal = 3,
    eObjectTypeMax = 99
} EObjectType;

ETCState

enum ETCState

Enumerator
eTCStateStart
eTCStateEnd
eTCStateA
eTCStateB
eTCStateC
eTCStateD
eTCStateE
eTCStateF
eTCStateG
eTCStateH
eTCStateI
eTCStateJ
eTCStateK
eTCStateM
eTCStateN
eTCStateO
eTCStateP
eTCStateQ
eTCStateR
eTCStateS
eTCStateT
eTCStateU
eTCStateV
eTCStateW
eTCStateX
eTCStateZ
eTCState_
eTCState
eTCStateMax

Definition at line 32 of file microsoft_demangle.c.

                      { // TC - type code
    eTCStateStart = 0,
    eTCStateEnd,
    eTCStateA,
    eTCStateB,
    eTCStateC,
    eTCStateD,
    eTCStateE,
    eTCStateF,
    eTCStateG,
    eTCStateH,
    eTCStateI,
    eTCStateJ,
    eTCStateK,
    eTCStateM,
    eTCStateN,
    eTCStateO,
    eTCStateP,
    eTCStateQ,
    eTCStateR,
    eTCStateS,
    eTCStateT,
    eTCStateU,
    eTCStateV,
    eTCStateW,
    eTCStateX,
    eTCStateZ,
    eTCState_,
    eTCState$,
    eTCStateMax
} ETCState;

ETCStateMachineErr

enum ETCStateMachineErr

Enumerator
eTCStateMachineErrOK
eTCStateMachineErrUncorrectTypeCode
eTCStateMachineErrUnsupportedTypeCode
eTCStateMachineErrAlloc
eTCStateMachineErrMax

Definition at line 24 of file microsoft_demangle.c.

                                {
    eTCStateMachineErrOK,
    eTCStateMachineErrUncorrectTypeCode,
    eTCStateMachineErrUnsupportedTypeCode,
    eTCStateMachineErrAlloc,
    eTCStateMachineErrMax
} ETCStateMachineErr;

Function Documentation

copy_string_n()

static bool copy_string_n ( STypeCodeStr *  type_code_str, const char *  str_for_copy, size_t  copy_len  )

static

Definition at line 199 of file microsoft_demangle.c.

                                                                                                  {
    if (!copy_len) {
        return true;
    }
    size_t free_space = type_code_str->type_str_len - type_code_str->curr_pos - 1;
 
    if (free_space < copy_len) {
        size_t newlen = type_code_str->type_str_len + copy_len;
        if (newlen < type_code_str->type_str_len) {
            return false;
        }
        newlen *= 2;
        if (newlen < type_code_str->type_str_len) {
            return false;
        }
        type_code_str->type_str_len = newlen;
        char *type_str;
        if (type_code_str->type_str != type_code_str->type_str_buf) {
            type_str = realloc(type_code_str->type_str, newlen);
        } else {
            type_str = malloc(newlen);
            if (!type_str) {
                return false;
            }
            memcpy(type_str, type_code_str->type_str, type_code_str->curr_pos);
        }
        if (!type_str) {
            return false;
        }
        type_code_str->type_str = type_str;
        if (!type_code_str->type_str) {
            return false;
        }
    }
 
    char *dst = type_code_str->type_str + type_code_str->curr_pos;
    if (str_for_copy) {
        memcpy(dst, str_for_copy, copy_len);
    } else {
        memset(dst, 0, copy_len);
    }
    type_code_str->curr_pos += copy_len;
    if (type_code_str->type_str) {
        type_code_str->type_str[type_code_str->curr_pos] = '\0';
    }
    return true;
}

References STypeCodeStr::curr_pos, dst, malloc(), memcpy(), memset(), realloc(), STypeCodeStr::type_str, STypeCodeStr::type_str_buf, and STypeCodeStr::type_str_len.

Referenced by get_namespace_and_name(), get_template(), parse_function(), and parse_type_modifier().

DEF_STATE_ACTION() [1/12]

DEF_STATE_ACTION

(

$

)

Definition at line 1829 of file microsoft_demangle.c.

                    {
    if (*(state->buff_for_parsing++) != '$') {
        state->err = eTCStateMachineErrUncorrectTypeCode;
        return;
    }
    state->amount_of_read_chars += 2;
    switch (*state->buff_for_parsing++) {
    case 'A':
        state->state = eTCStateP;
        break;
    case 'B':
        parse_type_modifier(state, type_code_str, "");
        break;
    case 'C':
        parse_type_modifier(state, type_code_str, "");
        break;
    case 'F':
        state->state = eTCStateP;
        break;
    case 'Q':
        parse_type_modifier(state, type_code_str, "&&");
        state->state = eTCStateEnd;
        break;
    case 'R':
        parse_type_modifier(state, type_code_str, "&& volatile");
        state->state = eTCStateEnd;
        break;
    case 'T':
        copy_string(type_code_str, "std::nullptr_t");
        state->state = eTCStateEnd;
        break;
    case 'V':
        state->state = eTCStateEnd;
        break;
    case 'Z':
        state->state = eTCStateEnd;
        break;
    default:
        state->err = eTCStateMachineErrUncorrectTypeCode;
        break;
    }
}

References copy_string, eTCStateEnd, eTCStateMachineErrUncorrectTypeCode, eTCStateP, and parse_type_modifier().

DEF_STATE_ACTION() [2/12]

DEF_STATE_ACTION

(

_

)

Definition at line 1206 of file microsoft_demangle.c.

                    {
#define PROCESS_CASE(letter, type_str) \
    case CHAR_WITH_QUOTES(letter): \
        copy_string(type_code_str, type_str); \
        break;
 
    switch (*(state->buff_for_parsing)) {
        PROCESS_CASE(D, "__int8")
        PROCESS_CASE(E, "unsigned __int8")
        PROCESS_CASE(F, "__int16")
        PROCESS_CASE(G, "unsigned __int16")
        PROCESS_CASE(H, "__int32")
        PROCESS_CASE(I, "unsigned __int32")
        PROCESS_CASE(J, "__int64")
        PROCESS_CASE(K, "unsigned __int64")
        PROCESS_CASE(L, "__int128")
        PROCESS_CASE(M, "unsigned __int128")
        PROCESS_CASE(N, "bool")
        PROCESS_CASE(Q, "char8_t")
        PROCESS_CASE(S, "char16_t")
        PROCESS_CASE(T, "long double(80 bit precision)")
        PROCESS_CASE(U, "char32_t")
        PROCESS_CASE(W, "wchar_t")
        PROCESS_CASE(Z, "long double(64 bit precision)")
    default:
        state->err = eTCStateMachineErrUncorrectTypeCode;
        break;
    }
 
    state->amount_of_read_chars++;
    state->buff_for_parsing++;
    state->state = eTCStateEnd;
#undef PROCESS_CASE
}

References D, E, eTCStateEnd, eTCStateMachineErrUncorrectTypeCode, F, G, H, I, J, L, M, N, PROCESS_CASE, Q, S, T, W, and Z.

DEF_STATE_ACTION() [3/12]

DEF_STATE_ACTION

(

A

)

Definition at line 1821 of file microsoft_demangle.c.

                    {
    PARSE_POINTER("&");
}

References PARSE_POINTER.

DEF_STATE_ACTION() [4/12]

DEF_STATE_ACTION

(

B

)

Definition at line 1825 of file microsoft_demangle.c.

                    {
    PARSE_POINTER("& volatile");
}

References PARSE_POINTER.

DEF_STATE_ACTION() [5/12]

DEF_STATE_ACTION

(

P

)

Definition at line 1809 of file microsoft_demangle.c.

                    {
    PARSE_POINTER("*");
}

References PARSE_POINTER.

DEF_STATE_ACTION() [6/12]

DEF_STATE_ACTION

(

Q

)

Definition at line 1817 of file microsoft_demangle.c.

                    {
    PARSE_POINTER("* const");
}

References PARSE_POINTER.

DEF_STATE_ACTION() [7/12]

DEF_STATE_ACTION

(

R

)

Definition at line 1813 of file microsoft_demangle.c.

                    {
    PARSE_POINTER("* volatile");
}

References PARSE_POINTER.

DEF_STATE_ACTION() [8/12]

DEF_STATE_ACTION

(

S

)

Definition at line 1573 of file microsoft_demangle.c.

                    {
    parse_type_modifier(state, type_code_str, "* const volatile");
}

References parse_type_modifier().

DEF_STATE_ACTION() [9/12]

DEF_STATE_ACTION

(

T

)

Definition at line 1262 of file microsoft_demangle.c.

                    {
#define PROCESS_CASE(case_string, type_str) \
    { \
        check_len = strlen(case_string); \
        if (strncmp(state->buff_for_parsing, case_string, check_len) == 0) { \
            copy_string(type_code_str, type_str); \
            state->buff_for_parsing += check_len; \
            state->amount_of_read_chars += check_len; \
            return; \
        } \
    }
 
    size_t check_len = 0;
 
    state->state = eTCStateEnd;
 
    PROCESS_CASE("__m64@@", "__m64");
    PROCESS_CASE("__m128@@", "__m128");
    PROCESS_CASE("__m128i@@", "__m128i");
    PROCESS_CASE("__m256@@", "__m256");
    PROCESS_CASE("__m256i@@", "__m256i");
    PROCESS_CASE("__m512@@", "__m512");
    PROCESS_CASE("__m512i@@", "__m512i");
 
    GET_USER_DEF_TYPE_NAME("union ");
#undef PROCESS_CASE
}

References eTCStateEnd, GET_USER_DEF_TYPE_NAME, and PROCESS_CASE.

DEF_STATE_ACTION() [10/12]

DEF_STATE_ACTION

(

U

)

Definition at line 1290 of file microsoft_demangle.c.

                    {
#define PROCESS_CASE(case_string, type_str) \
    { \
        check_len = strlen(case_string); \
        if (strncmp(state->buff_for_parsing, case_string, check_len) == 0) { \
            copy_string(type_code_str, type_str); \
            state->amount_of_read_chars += check_len; \
            state->buff_for_parsing += check_len; \
            return; \
        } \
    }
 
    size_t check_len = 0;
 
    state->state = eTCStateEnd;
 
    PROCESS_CASE("__m128d@@", "__m128d");
    PROCESS_CASE("__m256d@@", "__m256d");
    PROCESS_CASE("__m512d@@", "__m512d");
 
    GET_USER_DEF_TYPE_NAME("struct ");
#undef PROCESS_CASE
}

References eTCStateEnd, GET_USER_DEF_TYPE_NAME, and PROCESS_CASE.

DEF_STATE_ACTION() [11/12]

DEF_STATE_ACTION

(

V

)

Definition at line 1330 of file microsoft_demangle.c.

                    {
    // VX@@ -> class X
    size_t check_len = 0;
    state->state = eTCStateEnd;
 
    GET_USER_DEF_TYPE_NAME("class ");
}

References eTCStateEnd, and GET_USER_DEF_TYPE_NAME.

DEF_STATE_ACTION() [12/12]

DEF_STATE_ACTION

(

W

)

Definition at line 1314 of file microsoft_demangle.c.

                    {
    // W4X@@ -> enum X, W4X@Y@@ -> enum Y::X
    size_t check_len = 0;
    state->state = eTCStateEnd;
 
    if (*state->buff_for_parsing != '4') {
        state->err = eTCStateMachineErrUncorrectTypeCode;
        return;
    }
 
    state->buff_for_parsing++;
    state->amount_of_read_chars++;
 
    GET_USER_DEF_TYPE_NAME("enum ");
}

References eTCStateEnd, eTCStateMachineErrUncorrectTypeCode, and GET_USER_DEF_TYPE_NAME.

free_type_code_str_struct()

static void free_type_code_str_struct ( STypeCodeStr *  type_code_str )

static

Definition at line 1941 of file microsoft_demangle.c.

                                                                   {
    if (type_code_str->type_str && type_code_str->type_str != type_code_str->type_str_buf) {
        RZ_FREE(type_code_str->type_str);
    }
    type_code_str->type_str_len = 0;
}

References RZ_FREE, STypeCodeStr::type_str, STypeCodeStr::type_str_buf, and STypeCodeStr::type_str_len.

Referenced by get_namespace_and_name(), get_template_params(), get_type_code_string(), parse_data_type(), parse_function(), parse_function_args(), parse_microsoft_mangled_name(), parse_pointer(), and parse_type_modifier().

get_calling_convention()

static const char* get_calling_convention ( char  calling_convention )

inlinestatic

Definition at line 1577 of file microsoft_demangle.c.

                                                                          {
    switch (calling_convention) {
    case 'A': return "__cdecl";
    case 'B': return "__cdecl __declspec(dllexport)";
    case 'C': return "__pascal";
    case 'D': return "__pascal __declspec(dllexport)";
    case 'E': return "__thiscall";
    case 'F': return "__thiscall __declspec(dllexport)";
    case 'G': return "__stdcall";
    case 'H': return "__stdcall __declspec(dllexport)";
    case 'I': return "__fastcall";
    case 'J': return "__fastcall __declspec(dllexport)";
    case 'K': return "default (none given)";
    case 'L': return "default (none given) __declspec(dllexport)";
    case 'M': return "__clrcall";
    case 'N': return "__clrcall __declspec(dllexport)";
    case 'O': return "__eabi";
    case 'P': return "__eabi __declspec(dllexport)";
    case 'Q': return "__vectorcall";
    case 'R': return "__vectorcall __declspec(dllexport)";
    case 'S': return "__swift_1";
    case 'T': return "__swift_1 __declspec(dllexport)";
    case 'U': return "__swift_2";
    case 'V': return "__swift_2 __declspec(dllexport)";
    case 'W': return "__swift_3";
    default: return NULL;
    }
}

References NULL.

Referenced by parse_function(), and parse_function_pointer().

get_namespace_and_name()

static size_t get_namespace_and_name ( const char *  buf, STypeCodeStr *  type_code_str, size_t *  amount_of_names, bool  memorize  )

static

get_namespace_and_name

Parameters

buf	Current buffer position with mangled name
type_code_str	String with got name and namespaces
amount_of_names	Amount of names that was in list

Returns

Return amount of processed chars

Definition at line 928 of file microsoft_demangle.c.

                                                                                                                           {
    const char *curr_pos = NULL, *prev_pos = NULL, *tmp = NULL;
    DemList /* <SStrInfo *> */ *names_l = NULL;
    DemListIter *it = NULL;
 
    if (RZ_STR_ISEMPTY(buf)) {
        return 0;
    }
 
    size_t len = 0, read_len = 0, tmp_len = 0;
 
    names_l = dem_list_newf((DemListFree)sstrinfo_free);
 
    if (*buf == '?') {
        size_t res = get_operator_code(buf, names_l, memorize);
        if (!res) {
            return 0;
        }
        memorize = true;
        buf += res;
        read_len += res;
    }
 
    prev_pos = buf;
    curr_pos = strchr(buf, '@');
 
    // hack for nested templates
    // think about how better to fix this...
    len = curr_pos - prev_pos;
    if (len == 0) {
        goto get_namespace_and_name_err;
    }
 
    while (curr_pos != NULL) {
        len = curr_pos - prev_pos;
        tmp = prev_pos;
 
        if ((len == 0) && (*(curr_pos) == '@')) {
            break;
        }
 
        // TODO:maybe add check of name correctness? like name can not start
        //      with number
        if ((len <= 0) || (len >= MICROSOFT_NAME_LEN)) {
            goto get_namespace_and_name_err;
        }
 
        // check if it is a template
        if ((*tmp == '?') && (*(tmp + 1) == '$')) {
            size_t i = 0;
            SStrInfo *str_info = RZ_NEW0(SStrInfo);
            if (!str_info) {
                break;
            }
            i = get_template(tmp + 2, str_info, memorize);
            if (!i) {
                RZ_FREE(str_info);
                goto get_namespace_and_name_err;
            }
            dem_list_append(names_l, str_info);
 
            prev_pos = tmp + i + 2;
            curr_pos = strchr(prev_pos, '@');
            read_len += i + 2;
            continue;
        }
 
        if ((*tmp == '?') && (*(tmp + 1) == 'Q')) {
            STypeCodeStr str;
            if (!init_type_code_str_struct(&str)) {
                break;
            }
            size_t i = get_namespace_and_name(tmp + 2, &str, NULL, true);
            read_len += i + 2;
            if (!i || *(tmp + i + 2) != '@') {
                free_type_code_str_struct(&str);
                break;
            }
            prev_pos = tmp + i + 3;
            curr_pos = strchr(prev_pos, '@');
            read_len++;
            SStrInfo *str_info = RZ_NEW0(SStrInfo);
            if (!str_info) {
                break;
            }
            str_info->str_ptr = dem_str_newf("[%s]", str.type_str);
            str_info->len = strlen(str_info->str_ptr);
            dem_list_append(names_l, str_info);
            free_type_code_str_struct(&str);
            continue;
        }
 
        // Nested name or numbered namespace
        if (*tmp == '?') {
            tmp++;
            read_len++;
            // Optional sequence number or numbered namespace
            bool nested_name = false;
            char *num = NULL;
            if (*tmp != '?') {
                SStateInfo state;
                init_state_struct(&state, tmp);
                num = get_num(&state);
                if (!num) {
                    break;
                }
                tmp += state.amount_of_read_chars;
                read_len += state.amount_of_read_chars;
                if (*tmp == '?' && tmp[1] == '?') {
                    tmp += 2;
                    read_len += 2;
                    nested_name = true;
                }
            } else {
                tmp++;
                read_len++;
                nested_name = true;
            }
            char *demangled = NULL;
            if (nested_name) {
                parse_microsoft_mangled_name(tmp, &demangled, &len);
                tmp += len;
                read_len += len;
            }
            SStrInfo *str_info = RZ_NEW0(SStrInfo);
            if (!str_info) {
                free(num);
                break;
            }
            if (num && demangled) {
                str_info->str_ptr = dem_str_newf("`%s'::`%s'", demangled, num);
            } else if (demangled) {
                str_info->str_ptr = dem_str_newf("`%s'", demangled);
            } else if (num) {
                str_info->str_ptr = dem_str_newf("`%s'", num);
            } else {
                str_info->str_ptr = strdup("");
            }
            if (!str_info->str_ptr) {
                RZ_FREE(str_info);
                free(num);
                break;
            }
            str_info->len = strlen(str_info->str_ptr);
            dem_list_append(names_l, str_info);
            if (demangled) {
                dem_list_append(abbr_names, strdup(str_info->str_ptr));
            }
            free(demangled);
            free(num);
            prev_pos = tmp;
            curr_pos = strchr(tmp, '@');
            continue;
        }
 
        bool abbreviation = false;
        if (isdigit((ut8)*tmp)) {
            abbreviation = true;
            tmp = dem_list_get_n(abbr_names, *tmp - '0');
            if (!tmp) {
                break;
            }
            len = 1;
        } else {
            char *tmpname = malloc(len + 1);
            if (!tmpname) {
                break;
            }
            memset(tmpname, 0, len + 1);
            memcpy(tmpname, prev_pos, len);
            dem_list_append(abbr_names, tmpname);
            tmp = tmpname;
        }
        SStrInfo *str_info = RZ_NEW0(SStrInfo);
        if (!str_info) {
            break;
        }
        str_info->str_ptr = strdup(tmp);
        str_info->len = strlen(tmp);
 
        dem_list_append(names_l, str_info);
 
        memorize = true;
 
        read_len += len;
        if (abbreviation) {
            if (*(prev_pos + 1) == '@') {
                prev_pos = curr_pos;
            } else {
                prev_pos++;
            }
        } else {
            prev_pos = curr_pos + 1;
            curr_pos = strchr(curr_pos + 1, '@');
            if (curr_pos) {
                read_len++;
            }
        }
    }
 
get_namespace_and_name_err:
    tmp_len = dem_list_length(names_l);
    if (amount_of_names) {
        *amount_of_names = tmp_len;
    }
    SStrInfo *str_info;
    dem_list_foreach_prev(names_l, it, str_info) {
        copy_string_n(type_code_str, str_info->str_ptr, str_info->len);
 
        if (--tmp_len) {
            copy_string(type_code_str, "::");
        }
    }
    dem_list_free(names_l);
 
    return read_len;
}

References abbr_names, copy_string, copy_string_n(), dem_list_append(), dem_list_foreach_prev, dem_list_free(), dem_list_get_n(), dem_list_length(), dem_list_newf(), dem_str_newf(), free(), free_type_code_str_struct(), get_num(), get_operator_code(), get_template(), i, init_state_struct(), init_type_code_str_struct(), isdigit, len, SStrInfo::len, malloc(), memcpy(), memset(), MICROSOFT_NAME_LEN, NULL, num, parse_microsoft_mangled_name(), RZ_FREE, RZ_NEW0, RZ_STR_ISEMPTY, sstrinfo_free(), cmd_descs_generate::str, SStrInfo::str_ptr, strdup(), and autogen_x86imm::tmp.

Referenced by get_template_params(), parse_data_type(), parse_microsoft_mangled_name(), and parse_pointer().

get_num()

static char * get_num ( SStateInfo *  state )

static

Definition at line 1340 of file microsoft_demangle.c.

                                        {
    char *ptr = NULL;
    bool negative = false;
    if (*state->buff_for_parsing == '?') {
        negative = true;
        state->buff_for_parsing++;
        state->amount_of_read_chars++;
    }
    if (*state->buff_for_parsing == '@') {
        state->buff_for_parsing++;
        state->amount_of_read_chars++;
        return strdup("0");
    }
    if (*state->buff_for_parsing >= '0' && *state->buff_for_parsing <= '8') {
        ptr = malloc(2);
        if (!ptr) {
            return NULL;
        }
        ptr[0] = *state->buff_for_parsing + 1;
        ptr[1] = '\0';
        state->buff_for_parsing++;
        state->amount_of_read_chars++;
    } else if (*state->buff_for_parsing == '9') {
        ptr = strdup("10");
        state->buff_for_parsing++;
        state->amount_of_read_chars++;
    } else if (*state->buff_for_parsing >= 'A' && *state->buff_for_parsing <= 'P') {
        ut32 ret = 0;
 
        if (state->buff_for_parsing[1] == '0' && state->buff_for_parsing[2] == 'x' && isxdigit(state->buff_for_parsing[3])) {
            size_t chars = 0;
            state->buff_for_parsing += 3;
            state->amount_of_read_chars += 3;
            while (isxdigit(*state->buff_for_parsing)) {
                state->buff_for_parsing++;
                state->amount_of_read_chars++;
                chars++;
            }
            ret = strtoul(state->buff_for_parsing - chars, NULL, 16);
        } else {
            while (*state->buff_for_parsing >= 'A' && *state->buff_for_parsing <= 'P') {
                ret *= 16;
                ret += *state->buff_for_parsing - 'A';
                state->buff_for_parsing++;
                state->amount_of_read_chars++;
            }
        }
 
        ptr = dem_str_newf("%u", ret);
        if (*state->buff_for_parsing && *state->buff_for_parsing == '@') {
            state->buff_for_parsing++;
            state->amount_of_read_chars++;
        }
    }
    if (negative && ptr) {
        char *tmp = ptr;
        ptr = dem_str_newf("-%s", tmp);
        free(tmp);
    }
    return ptr;
}

References dem_str_newf(), free(), isxdigit, malloc(), NULL, strdup(), and autogen_x86imm::tmp.

Referenced by get_namespace_and_name(), get_operator_code(), get_template_params(), and parse_type_modifier().

get_operator_code()

static size_t get_operator_code ( const char *  buf, DemList *  names_l, bool  memorize  )

static

Definition at line 491 of file microsoft_demangle.c.

                                                                                  {
    // C++ operator code (one character, or two if the first is '_')
#define SET_OPERATOR_CODE(str) \
    { \
        str_info = malloc(sizeof(SStrInfo)); \
        if (!str_info) \
            break; \
        str_info->len = strlen(str); \
        str_info->str_ptr = strdup(str); \
        dem_list_append(names_l, str_info); \
    }
    SStrInfo *str_info;
    size_t read_len = 1;
    switch (*++buf) {
    case '0': SET_OPERATOR_CODE("constructor"); break;
    case '1': SET_OPERATOR_CODE("~destructor"); break;
    case '2': SET_OPERATOR_CODE("operator new"); break;
    case '3': SET_OPERATOR_CODE("operator delete"); break;
    case '4': SET_OPERATOR_CODE("operator="); break;
    case '5': SET_OPERATOR_CODE("operator>>"); break;
    case '6': SET_OPERATOR_CODE("operator<<"); break;
    case '7': SET_OPERATOR_CODE("operator!"); break;
    case '8': SET_OPERATOR_CODE("operator=="); break;
    case '9': SET_OPERATOR_CODE("operator!="); break;
    case 'A': SET_OPERATOR_CODE("operator[]"); break;
    case 'B': SET_OPERATOR_CODE("operator #{return_type}"); break;
    case 'C': SET_OPERATOR_CODE("operator->"); break;
    case 'D': SET_OPERATOR_CODE("operator*"); break;
    case 'E': SET_OPERATOR_CODE("operator++"); break;
    case 'F': SET_OPERATOR_CODE("operator--"); break;
    case 'G': SET_OPERATOR_CODE("operator-"); break;
    case 'H': SET_OPERATOR_CODE("operator+"); break;
    case 'I': SET_OPERATOR_CODE("operator&"); break;
    case 'J': SET_OPERATOR_CODE("operator->*"); break;
    case 'K': SET_OPERATOR_CODE("operator/"); break;
    case 'L': SET_OPERATOR_CODE("operator%"); break;
    case 'M': SET_OPERATOR_CODE("operator<"); break;
    case 'N': SET_OPERATOR_CODE("operator<="); break;
    case 'O': SET_OPERATOR_CODE("operator>"); break;
    case 'P': SET_OPERATOR_CODE("operator>="); break;
    case 'Q': SET_OPERATOR_CODE("operator,"); break;
    case 'R': SET_OPERATOR_CODE("operator()"); break;
    case 'S': SET_OPERATOR_CODE("operator~"); break;
    case 'T': SET_OPERATOR_CODE("operator^"); break;
    case 'U': SET_OPERATOR_CODE("operator|"); break;
    case 'V': SET_OPERATOR_CODE("operator&"); break;
    case 'W': SET_OPERATOR_CODE("operator||"); break;
    case 'X': SET_OPERATOR_CODE("operator*="); break;
    case 'Y': SET_OPERATOR_CODE("operator+="); break;
    case 'Z': SET_OPERATOR_CODE("operator-="); break;
    case '$': {
        str_info = malloc(sizeof(SStrInfo));
        if (!str_info) {
            goto fail;
        }
        size_t i = get_template(buf + 1, str_info, memorize);
        if (!i) {
            RZ_FREE(str_info);
            goto fail;
        }
        dem_list_append(names_l, str_info);
        read_len += i;
        break;
    }
    case '_':
        switch (*++buf) {
        case '0': SET_OPERATOR_CODE("operator/="); break;
        case '1': SET_OPERATOR_CODE("operator%="); break;
        case '2': SET_OPERATOR_CODE("operator>>="); break;
        case '3': SET_OPERATOR_CODE("operator<<="); break;
        case '4': SET_OPERATOR_CODE("operator&="); break;
        case '5': SET_OPERATOR_CODE("operator|="); break;
        case '6': SET_OPERATOR_CODE("operator^="); break;
        case '7': SET_OPERATOR_CODE("vftable"); break;
        case '8': SET_OPERATOR_CODE("vbtable"); break;
        case '9': SET_OPERATOR_CODE("vcall"); break;
        case 'A': SET_OPERATOR_CODE("typeof"); break;
        case 'B': SET_OPERATOR_CODE("local_static_guard"); break;
        case 'C':
            if (*++buf != '@') {
                goto fail;
            }
            if (*++buf != '_') {
                goto fail;
            }
            buf++;
            read_len += 3;
            bool is_double_byte;
            if (*buf == '0') {
                is_double_byte = false;
            } else if (*buf == '1') {
                is_double_byte = true;
            } else {
                goto fail;
            }
            buf++;
            read_len++;
            const char *const str_buf_start = buf;
            SStateInfo state_info;
            init_state_struct(&state_info, buf);
            char *len = get_num(&state_info);
            if (!len) {
                goto fail;
            }
            free(len);
            buf += state_info.amount_of_read_chars;
            init_state_struct(&state_info, buf);
            char *checksum = get_num(&state_info);
            buf += state_info.amount_of_read_chars;
            DemString *s = dem_string_new();
            if (!s) {
                free(checksum);
                goto fail;
            }
            dem_string_append(s, "`string'::");
            if (checksum) {
                dem_string_appendf(s, "%s::\"", checksum);
                free(checksum);
            } else {
                dem_string_append(s, "\"");
            }
            DemString *unicode = NULL;
            if (is_double_byte) {
                unicode = dem_string_new();
                if (!unicode) {
                    dem_string_free(s);
                    goto fail;
                }
            }
            char c[2];
            int high = 0;
            const char *encoded = ",/\\:. \v\n'-";
            while (*buf && *buf != '@') {
                if (*buf == '?') {
                    buf++;
                    if (*buf == '$') {
                        buf++;
                        if (buf[0] < 'A' || buf[0] > 'P' ||
                            buf[1] < 'A' || buf[1] > 'P') {
                            dem_string_free(s);
                            dem_string_free(unicode);
                            goto fail;
                        }
                        const char nibble_high = (*buf++ - 'A');
                        const char nibble_low = (*buf - 'A');
                        c[high] = nibble_high | nibble_low;
                    } else if (isdigit((int)*buf)) {
                        c[high] = encoded[*buf - '0'];
                    } else if ((*buf > 'a' && *buf < 'p') || (*buf > 'A' && *buf < 'P')) {
                        c[high] = *buf + 0x80;
                    } else {
                        dem_string_free(unicode);
                        dem_string_free(s);
                        goto fail;
                    }
                } else {
                    c[high] = *buf;
                }
                buf++;
                if (is_double_byte) {
                    high++;
                    if (high > 1) {
                        if (!c[0] && !c[1]) {
                            break;
                        }
                        if (!dem_string_append_n(unicode, c, 2)) {
                            dem_string_free(unicode);
                            dem_string_free(s);
                            goto fail;
                        }
                        high = 0;
                    }
                } else {
                    if (!c[0]) {
                        break;
                    }
                    if (!dem_string_append_n(s, c, 1)) {
                        dem_string_free(s);
                        goto fail;
                    }
                }
            }
            if (is_double_byte) {
                size_t utf16_len = unicode->len;
                char *utf16 = dem_string_drain(unicode);
                char *utf8_buf = NULL;
                size_t utf8_len = 0;
                if (utf16be_to_utf8(utf16, utf16_len, &utf8_buf, &utf8_len) != eDemanglerErrOK) {
                    free(utf16);
                    dem_string_free(s);
                    goto fail;
                }
                free(utf16);
                if (!dem_string_append_n(s, utf8_buf, utf8_len)) {
                    free(utf8_buf);
                    dem_string_free(s);
                    goto fail;
                }
                free(utf8_buf);
            }
            dem_string_append_n(s, "\"", 1);
            if (*buf == '@' && buf[1]) {
                buf++;
                init_state_struct(&state_info, buf);
                char *unk = get_num(&state_info);
                if (unk) {
                    buf += state_info.amount_of_read_chars - 1;
                    dem_string_appendf(s, "::%s", unk);
                    free(unk);
                }
            }
            char *str = dem_string_drain(s);
            if (!str) {
                goto fail;
            }
            SET_OPERATOR_CODE(str);
            free(str);
            read_len += buf - str_buf_start;
            break;
        case 'D': SET_OPERATOR_CODE("vbase_dtor"); break;
        case 'E': SET_OPERATOR_CODE("vector_dtor"); break;
        case 'F': SET_OPERATOR_CODE("default_ctor_closure"); break;
        case 'G': SET_OPERATOR_CODE("scalar_dtor"); break;
        case 'H': SET_OPERATOR_CODE("vector_ctor_iter"); break;
        case 'I': SET_OPERATOR_CODE("vector_dtor_iter"); break;
        case 'J': SET_OPERATOR_CODE("vector_vbase_ctor_iter"); break;
        case 'K': SET_OPERATOR_CODE("virtual_displacement_map"); break;
        case 'L': SET_OPERATOR_CODE("eh_vector_ctor_iter"); break;
        case 'M': SET_OPERATOR_CODE("eh_vector_dtor_iter"); break;
        case 'N': SET_OPERATOR_CODE("eh_vector_vbase_ctor_iter"); break;
        case 'O': SET_OPERATOR_CODE("copy_ctor_closure"); break;
        case 'R':
            buf++;
            read_len++;
            switch (*buf++) {
            case '0': {
                size_t len;
                char *str = NULL;
                if (!*buf++) {
                    goto fail;
                }
                if (parse_microsoft_rtti_mangled_name(buf, &str, &len) != eDemanglerErrOK) {
                    goto fail;
                }
                read_len += len + 1;
                str = dem_str_append(str, " `RTTI Type Descriptor'");
                SET_OPERATOR_CODE(str);
                free(str);
                break;
            }
            case '1': {
                SStateInfo state;
                init_state_struct(&state, buf);
                char *a = get_num(&state);
                char *b = get_num(&state);
                char *c = get_num(&state);
                char *d = get_num(&state);
                if (!a || !b || !c || !d) {
                    free(a);
                    free(b);
                    free(c);
                    free(d);
                    goto fail;
                }
                read_len += state.amount_of_read_chars;
                char *tmp = dem_str_newf("`RTTI Base Class Descriptor at (%s,%s,%s,%s)'", a, b, c, d);
                SET_OPERATOR_CODE(tmp);
                free(tmp);
                free(a);
                free(b);
                free(c);
                free(d);
                break;
            }
            case '2': SET_OPERATOR_CODE("`RTTI Base Class Array'"); break;
            case '3': SET_OPERATOR_CODE("`RTTI Class Hierarchy Descriptor'"); break;
            case '4': SET_OPERATOR_CODE("`RTTI Complete Object Locator'"); break;
            default: goto fail;
            }
            break;
        case 'S': SET_OPERATOR_CODE("local_vftable"); break;
        case 'T': SET_OPERATOR_CODE("local_vftable_ctor_closure"); break;
        case 'U': SET_OPERATOR_CODE("operator new[]"); break;
        case 'V': SET_OPERATOR_CODE("operator delete[]"); break;
        case 'X': SET_OPERATOR_CODE("placement_new_closure"); break;
        case 'Y': SET_OPERATOR_CODE("placement_delete_closure"); break;
        case '_':
            buf++;
            read_len++;
            switch (*buf++) {
            case 'A': SET_OPERATOR_CODE("managed_vector_ctor_iter"); break;
            case 'B': SET_OPERATOR_CODE("managed_vector_dtor_iter"); break;
            case 'C': SET_OPERATOR_CODE("eh_vector_copy_ctor_iter"); break;
            case 'D': SET_OPERATOR_CODE("eh_vector_vbase_copy_ctor_iter"); break;
            case 'E': {
                const char *end;
                const char *op = "dynamic initializer";
                char *name;
                size_t name_len;
                goto get_name;
            case 'F':
                op = "dynamic atexit destructor";
            get_name:
                end = strchr(buf, '@');
                if (!end) {
                    goto fail;
                }
                name_len = end - buf;
                read_len += name_len + 1;
                name = malloc(name_len + 1);
                if (!name) {
                    goto fail;
                }
                memcpy(name, buf, name_len);
                name[name_len] = '\0';
                char *tmp = dem_str_newf("`%s for '%s''", op, name);
                free(name);
                SET_OPERATOR_CODE(tmp);
                free(tmp);
                break;
            }
            case 'G': SET_OPERATOR_CODE("vector_copy_ctor_iter"); break;
            case 'H': SET_OPERATOR_CODE("vector_vbase_copy_ctor_iter"); break;
            case 'I': SET_OPERATOR_CODE("managed_vector_copy_ctor_iter"); break;
            case 'J': SET_OPERATOR_CODE("local_static_thread_guard"); break;
            case 'K': SET_OPERATOR_CODE("user_defined_literal_op"); break;
            default: goto fail;
            }
            break;
        default: goto fail;
        }
        read_len++;
        break;
    default: goto fail;
    }
    if (*buf) {
        read_len++;
    }
    return read_len;
#undef SET_OPERATOR_CODE
fail:
    dem_list_free(names_l);
    return 0;
}

References a, SStateInfo::amount_of_read_chars, b, c, d, dem_list_append(), dem_list_free(), dem_str_append(), dem_str_newf(), dem_string_append(), dem_string_append_n(), dem_string_appendf(), dem_string_drain(), dem_string_free(), dem_string_new(), eDemanglerErrOK, test_evm::end, fail, free(), get_name(), get_num(), get_template(), i, init_state_struct(), isdigit, len, DemString::len, malloc(), memcpy(), name, NULL, parse_microsoft_rtti_mangled_name(), RZ_FREE, s, SET_OPERATOR_CODE, cmd_descs_generate::str, autogen_x86imm::tmp, and utf16be_to_utf8().

Referenced by get_namespace_and_name(), and get_template().

get_ptr_modifier()

static size_t get_ptr_modifier ( const char *  encoded, SDataType *  ptr_modifier  )

inlinestatic

Definition at line 2006 of file microsoft_demangle.c.

                                                                                    {
    const char *tmp = encoded;
    if (!ptr_modifier->left) {
        ptr_modifier->left = strdup("");
    }
    if (!ptr_modifier->right) {
        ptr_modifier->right = strdup("");
    }
#define SET_PTR_MODIFIER(letter, modifier_left, modifier_right) \
    case letter: \
        ptr_modifier->left = dem_str_append(ptr_modifier->left, modifier_left); \
        ptr_modifier->right = dem_str_append(ptr_modifier->right, modifier_right); \
        break;
 
    bool ref = false;
    bool refref = false;
    while (*tmp) {
        switch (*tmp++) {
            SET_PTR_MODIFIER('E', "", " __ptr64")
            SET_PTR_MODIFIER('F', " __unaligned", "")
            SET_PTR_MODIFIER('I', "", " __restrict")
        case 'G':
            ref = true;
            break;
        case 'H':
            refref = true;
            break;
        default:
            if (ref) {
                ptr_modifier->right = dem_str_append(ptr_modifier->right, "&");
                if (refref) {
                    ptr_modifier->right = dem_str_append(ptr_modifier->right, " ");
                }
            }
            if (refref) {
                ptr_modifier->right = dem_str_append(ptr_modifier->right, "&&");
            }
            return tmp - encoded - 1;
        }
    }
    return tmp - encoded;
#undef SET_PTR_MODIFIER
}

References dem_str_append(), SDataType::left, SDataType::right, SET_PTR_MODIFIER, strdup(), and autogen_x86imm::tmp.

Referenced by parse_data_type(), parse_function(), parse_pointer(), and parse_type_modifier().

get_storage_class()

static EDemanglerErr get_storage_class ( const char  encoded, const char **  storage_class  )

inlinestatic

Definition at line 2050 of file microsoft_demangle.c.

                                                                                              {
    switch (encoded) {
    case 'A':
        *storage_class = NULL;
        break; // non-const
    case 'B':
    case 'J':
        *storage_class = "const";
        break;
    case 'C':
    case 'G':
    case 'K':
        *storage_class = "volatile";
        break;
    case 'D':
    case 'H':
    case 'L':
        *storage_class = "const volatile";
        break;
    default:
        *storage_class = NULL;
        return eDemanglerErrUncorrectMangledSymbol;
    }
    return eDemanglerErrOK;
}

References eDemanglerErrOK, eDemanglerErrUncorrectMangledSymbol, and NULL.

Referenced by parse_data_type(), parse_function(), parse_function_pointer(), parse_microsoft_rtti_mangled_name(), parse_pointer(), and parse_type_modifier().

get_template()

static size_t get_template ( const char *  buf, SStrInfo *  str_info, bool  memorize  )

static

Definition at line 837 of file microsoft_demangle.c.

                                                                               {
    size_t len = 0;
    char *str_type_code = NULL;
    STypeCodeStr type_code_str;
    // DemListIter *it = NULL;
    DemList *saved_abbr_names = abbr_names; // save current abbr names, this
    DemList *new_abbr_names = dem_list_newf(free);
    memset(str_info, 0, sizeof(*str_info));
    if (!init_type_code_str_struct(&type_code_str)) {
        goto get_template_err;
    }
 
    if (*buf == '?') {
        DemList *names_l = dem_list_newf((DemListFree)sstrinfo_free);
        if (!names_l) {
            goto get_template_err;
        }
        size_t i = get_operator_code(buf, names_l, memorize);
        if (!i) {
            goto get_template_err;
        }
        len += i;
        buf += i;
        SStrInfo *name = dem_list_head(names_l)->data;
        copy_string_n(&type_code_str, name->str_ptr, name->len);
        dem_list_free(names_l);
    } else {
        char *tmp = strchr(buf, '@');
        if (!tmp) {
            goto get_template_err;
        }
 
        // get/copy template len/name
        len += (tmp - buf + 1);
        copy_string_n(&type_code_str, buf, len - 1);
        dem_list_append(new_abbr_names, dem_str_ndup(buf, len - 1));
        buf += len;
    }
 
    copy_string(&type_code_str, "<");
 
    abbr_names = new_abbr_names;
    bool first = true;
    // get identifier
    size_t i = 0;
    while (*buf != '@') {
        if (get_type_code_string(buf, &i, &str_type_code) != eDemanglerErrOK) {
            if (get_template_params(buf, &i, &str_type_code) != eDemanglerErrOK) {
                RZ_FREE(str_type_code);
                goto get_template_err;
            }
        }
        if (!RZ_STR_ISEMPTY(str_type_code)) {
            if (!first) {
                copy_string(&type_code_str, ", ");
            }
            copy_string(&type_code_str, str_type_code);
            first = false;
        }
        buf += i;
        len += i;
        RZ_FREE(str_type_code);
    }
    if (*buf != '@') {
        goto get_template_err;
    }
    len++;
 
get_template_err:
    if (type_code_str.curr_pos) {
        copy_string(&type_code_str, ">");
        str_info->str_ptr = type_code_str_get(&type_code_str);
        str_info->len = type_code_str.curr_pos;
    }
 
    dem_list_free(new_abbr_names);
    abbr_names = saved_abbr_names; // restore global list with name abbr.
 
    if (memorize && str_info->str_ptr) {
        dem_list_append(abbr_names, strdup(str_info->str_ptr));
    }
    return len;
}

References abbr_names, copy_string, copy_string_n(), STypeCodeStr::curr_pos, dem_list_append(), dem_list_free(), dem_list_head, dem_list_newf(), dem_str_ndup(), eDemanglerErrOK, free(), get_operator_code(), get_template_params(), get_type_code_string(), i, init_type_code_str_struct(), len, SStrInfo::len, memset(), NULL, RZ_FREE, RZ_STR_ISEMPTY, sstrinfo_free(), SStrInfo::str_ptr, strdup(), autogen_x86imm::tmp, and type_code_str_get().

Referenced by get_namespace_and_name(), and get_operator_code().

get_template_params()

static int get_template_params ( const char *  sym, size_t *  amount_of_read_chars, char **  str_type_code  )

static

Definition at line 247 of file microsoft_demangle.c.

                                                                                                    {
    SStateInfo state;
    init_state_struct(&state, sym);
    const char template_param[] = "template-parameter-";
    char *tmp, *res = NULL;
    const char *const start_sym = sym;
    if (!strncmp(sym, "?", 1)) {
        // anonymous template param
        state.amount_of_read_chars += 1;
        state.buff_for_parsing += 1;
        res = get_num(&state);
        if (res) {
            tmp = dem_str_newf("%s%s", template_param, res);
            free(res);
            res = tmp;
        }
    } else {
        if (strncmp(sym, "$", 1)) {
            return eDemanglerErrUncorrectMangledSymbol;
        }
        sym++;
        state.amount_of_read_chars += 2;
        state.buff_for_parsing += 2;
        char *a, *b, *c;
        switch (*sym) {
        case '0':
            // Signed integer
            a = get_num(&state);
            if (a) {
                int signed_a = atoi(a);
                res = dem_str_newf("%d", signed_a);
                free(a);
            }
            break;
        case '1': {
            STypeCodeStr str;
            EDemanglerErr err;
            if (!*(++sym) || !(*sym == '?')) {
                return eDemanglerErrUncorrectMangledSymbol;
            }
            if (!init_type_code_str_struct(&str)) {
                return eDemanglerErrMemoryAllocation;
            }
            size_t ret = get_namespace_and_name(++sym, &str, NULL, true);
            if (!ret) {
                free_type_code_str_struct(&str);
                return eDemanglerErrUncorrectMangledSymbol;
            }
            sym += ret;
            if (!*sym) {
                free_type_code_str_struct(&str);
                return eDemanglerErrUncorrectMangledSymbol;
            }
            SDataType data_type = { 0 };
            if (isdigit((int)*++sym)) {
                err = parse_data_type(sym, &data_type, &ret);
                *str_type_code = dem_str_newf("&%s %s%s", data_type.left, str.type_str, data_type.right);
                sdatatype_fini(&data_type);
            } else {
                char *tmp = NULL;
                err = parse_function(sym, &str, &tmp, &ret);
                *str_type_code = dem_str_newf("&%s", tmp);
                free(tmp);
            }
            sym += ret;
            *amount_of_read_chars = sym - start_sym;
            free_type_code_str_struct(&str);
            return err;
        }
        case '2':
            // real value a ^ b
            a = get_num(&state);
            b = get_num(&state);
            if (a && b) {
                int signed_b = atoi(b);
                res = dem_str_newf("%sE%d", a, signed_b);
            }
            free(a);
            free(b);
            break;
        case 'D':
            // anonymous template param
            res = get_num(&state);
            if (res) {
                tmp = dem_str_newf("%s%s", template_param, res);
                free(res);
                res = tmp;
            }
            break;
        case 'F':
            // Signed {a, b}
            a = get_num(&state);
            b = get_num(&state);
            if (a && b) {
                int signed_a = atoi(a);
                int signed_b = atoi(b);
                res = dem_str_newf("{%d, %d}", signed_a, signed_b);
            }
            free(a);
            free(b);
            break;
        case 'G':
            // Signed {a, b, c}
            a = get_num(&state);
            b = get_num(&state);
            c = get_num(&state);
            if (a && b && c) {
                int signed_a = atoi(a);
                int signed_b = atoi(b);
                int signed_c = atoi(c);
                res = dem_str_newf("{%d, %d, %d}", signed_a, signed_b, signed_c);
            }
            free(a);
            free(b);
            free(c);
            break;
        case 'H':
            // Unsigned integer
            res = get_num(&state);
            break;
        case 'I':
            // Unsigned {x, y}
            a = get_num(&state);
            b = get_num(&state);
            if (a && b) {
                res = dem_str_newf("{%s, %s}", a, b);
            }
            free(a);
            free(b);
            break;
        case 'J':
            // Unsigned {x, y, z}
            a = get_num(&state);
            b = get_num(&state);
            c = get_num(&state);
            if (a && b && c) {
                res = dem_str_newf("{%s, %s, %s}", a, b, c);
            }
            free(a);
            free(b);
            free(c);
            break;
        case 'Q':
            // anonymous non-type template parameter
            res = get_num(&state);
            if (res) {
                tmp = dem_str_newf("non-type-%s%s", template_param, res);
                free(res);
                res = tmp;
            }
            break;
        case 'S':
            // empty non-type parameter pack
            res = strdup("");
            break;
        default:
            break;
        }
    }
 
    if (!res) {
        return eDemanglerErrUnsupportedMangling;
    }
 
    *str_type_code = res;
    *amount_of_read_chars = state.amount_of_read_chars;
 
    return eDemanglerErrOK;
}

References a, b, c, dem_str_newf(), eDemanglerErrMemoryAllocation, eDemanglerErrOK, eDemanglerErrUncorrectMangledSymbol, eDemanglerErrUnsupportedMangling, err, free(), free_type_code_str_struct(), get_namespace_and_name(), get_num(), init_state_struct(), init_type_code_str_struct(), isdigit, SDataType::left, NULL, parse_data_type(), parse_function(), SDataType::right, sdatatype_fini(), cmd_descs_generate::str, strdup(), and autogen_x86imm::tmp.

Referenced by get_template().

get_type_code_string()

static EDemanglerErr get_type_code_string ( const char *  sym, size_t *  amount_of_read_chars, char **  str_type_code  )

static

Definition at line 1968 of file microsoft_demangle.c.

                                                                                                               {
    EDemanglerErr err = eDemanglerErrOK;
    STypeCodeStr type_code_str;
    SStateInfo state;
 
    if (!init_type_code_str_struct(&type_code_str)) {
        err = eDemanglerErrMemoryAllocation;
        goto get_type_code_string_err;
    }
 
    init_state_struct(&state, sym);
 
    while (state.state != eTCStateEnd) {
        run_state(&state, &type_code_str);
        if (state.err != eTCStateMachineErrOK) {
            *str_type_code = NULL;
            *amount_of_read_chars = 0;
            switch (state.err) {
            case eTCStateMachineErrUncorrectTypeCode:
                err = eDemanglerErrUncorrectMangledSymbol;
                break;
            case eTCStateMachineErrUnsupportedTypeCode:
                err = eDemanglerErrUnsupportedMangling;
            default:
                break;
            }
            goto get_type_code_string_err;
        }
    }
 
    *str_type_code = type_code_str_get(&type_code_str);
    *amount_of_read_chars = state.amount_of_read_chars;
 
get_type_code_string_err:
    free_type_code_str_struct(&type_code_str);
    return err;
}

References eDemanglerErrMemoryAllocation, eDemanglerErrOK, eDemanglerErrUncorrectMangledSymbol, eDemanglerErrUnsupportedMangling, err, eTCStateEnd, eTCStateMachineErrOK, eTCStateMachineErrUncorrectTypeCode, eTCStateMachineErrUnsupportedTypeCode, free_type_code_str_struct(), init_state_struct(), init_type_code_str_struct(), NULL, run_state(), and type_code_str_get().

Referenced by get_template(), parse_data_type(), parse_function(), parse_function_args(), parse_function_pointer(), parse_microsoft_rtti_mangled_name(), and parse_type_modifier().

init_state_struct()

static void init_state_struct ( SStateInfo *  state, const char *  buff_for_parsing  )

static

Definition at line 1926 of file microsoft_demangle.c.

                                                                               {
    state->state = eTCStateStart;
    state->buff_for_parsing = buff_for_parsing;
    state->amount_of_read_chars = 0;
    state->err = eTCStateMachineErrOK;
}

References eTCStateMachineErrOK, and eTCStateStart.

Referenced by get_namespace_and_name(), get_operator_code(), get_template_params(), and get_type_code_string().

init_type_code_str_struct()

static bool init_type_code_str_struct ( STypeCodeStr *  type_code_str )

static

Definition at line 1933 of file microsoft_demangle.c.

                                                                   {
    type_code_str->type_str_len = MICROSOFT_NAME_LEN;
    type_code_str->type_str = type_code_str->type_str_buf;
    *type_code_str->type_str = '\0';
    type_code_str->curr_pos = 0;
    return true;
}

References STypeCodeStr::curr_pos, MICROSOFT_NAME_LEN, STypeCodeStr::type_str, STypeCodeStr::type_str_buf, and STypeCodeStr::type_str_len.

Referenced by get_namespace_and_name(), get_template(), get_template_params(), get_type_code_string(), parse_data_type(), parse_function(), parse_function_args(), parse_microsoft_mangled_name(), parse_pointer(), and parse_type_modifier().

microsoft_demangle()

EDemanglerErr microsoft_demangle	(	SDemangler *	demangler,
		char **	demangled_name
	)

Do demangle for microsoft mangling scheme. Demangled name need to be free by user.

Parameters

demangler	'this' object of demangler
demangled_name	Demangled name of symbol of demangler object

Returns

Returns OK if initialization has been finish with success, else one of next errors: eDemanglerErrUnsupportedMangling, ...

Definition at line 2551 of file microsoft_demangle.c.

                                                                               {
    EDemanglerErr err = eDemanglerErrOK;
    //  DemListIter *it = NULL;
    //  char *tmp = NULL;
 
    // TODO: need refactor... maybe remove the static variable somewhere?
    abbr_types = dem_list_newf(free);
    abbr_names = dem_list_newf(free);
 
    if (!demangler || !demangled_name) {
        err = eDemanglerErrMemoryAllocation;
        goto microsoft_demangle_err;
    }
 
    if (!strncmp(demangler->symbol, ".?", 2)) {
        err = parse_microsoft_rtti_mangled_name(demangler->symbol + 2, demangled_name, NULL);
    } else {
        err = parse_microsoft_mangled_name(demangler->symbol + 1, demangled_name, NULL);
    }
 
microsoft_demangle_err:
    dem_list_free(abbr_names);
    dem_list_free(abbr_types);
    return err;
}

References abbr_names, abbr_types, dem_list_free(), dem_list_newf(), eDemanglerErrMemoryAllocation, eDemanglerErrOK, err, free(), NULL, parse_microsoft_mangled_name(), parse_microsoft_rtti_mangled_name(), and SDemangler::symbol.

Referenced by init_demangler().

parse_data_type()

static EDemanglerErr parse_data_type ( const char *  sym, SDataType *  demangled_type, size_t *  len  )

static

Definition at line 2076 of file microsoft_demangle.c.

                                                                                         {
    EDemanglerErr err = eDemanglerErrOK;
    size_t i;
    const char *curr_pos = sym;
    SDataType modifier = { 0 };
    const char *storage_class = NULL;
    char *tmp;
    if (len) {
        *len = 0;
    }
    if (!data_type) {
        return eDemanglerErrInternal;
    }
    data_type->left = data_type->right = NULL;
    // Data type and access level
    switch (*curr_pos) {
    // Data
    case '0': // Private static member
    case '1': // Protected static member
    case '2': // Public static member
    case '3': // Normal variable
    case '4': // Normal variable
    case '5': // Normal variable
        switch (*curr_pos) {
        case '0':
            modifier.left = strdup("private: static ");
            break;
        case '1':
            modifier.left = strdup("protected: static ");
            break;
        case '2':
            modifier.left = strdup("public: static ");
            break;
        default:
            break;
        }
        curr_pos++;
        i = 0;
        err = get_type_code_string(curr_pos, &i, &tmp);
        if (err != eDemanglerErrOK) {
            sdatatype_fini(&modifier);
            return err;
        }
 
        curr_pos += i;
        curr_pos += get_ptr_modifier(curr_pos, &modifier);
        if (get_storage_class(*curr_pos, &storage_class) != eDemanglerErrOK) {
            sdatatype_fini(&modifier);
            free(tmp);
            return eDemanglerErrUncorrectMangledSymbol;
        }
        curr_pos++;
 
        data_type->right = strdup("");
        if (storage_class) {
            data_type->left = dem_str_newf("%s%s %s%s", modifier.left, tmp, storage_class, modifier.right);
        } else {
            data_type->left = dem_str_newf("%s%s%s", modifier.left, tmp, modifier.right);
        }
        free(tmp);
        sdatatype_fini(&modifier);
        break;
    case '6': // compiler generated static
    case '7': // compiler generated static
        curr_pos++;
        curr_pos += get_ptr_modifier(curr_pos, &modifier);
        if (get_storage_class(*curr_pos, &storage_class) != eDemanglerErrOK) {
            sdatatype_fini(&modifier);
            return eDemanglerErrUncorrectMangledSymbol;
        }
        curr_pos++;
 
        if (storage_class) {
            data_type->left = dem_str_newf("%s%s%s", storage_class, modifier.left, modifier.right);
        } else {
            data_type->left = dem_str_newf("%s%s", modifier.left, modifier.right);
        }
        sdatatype_fini(&modifier);
        if (*curr_pos != '@') {
            STypeCodeStr str;
            if (!init_type_code_str_struct(&str)) {
                return eDemanglerErrMemoryAllocation;
            }
            size_t i = get_namespace_and_name(curr_pos, &str, NULL, true);
            if (!i) {
                free_type_code_str_struct(&str);
                return eDemanglerErrUncorrectMangledSymbol;
            }
            curr_pos += i;
            if (*curr_pos && *(curr_pos + 1) != '@') {
                STypeCodeStr str2;
                if (!init_type_code_str_struct(&str2)) {
                    free_type_code_str_struct(&str);
                    return eDemanglerErrMemoryAllocation;
                }
                i = get_namespace_and_name(curr_pos + 1, &str2, NULL, true);
                if (!i) {
                    free_type_code_str_struct(&str);
                    free_type_code_str_struct(&str2);
                    return eDemanglerErrUncorrectMangledSymbol;
                }
                curr_pos += i + 1;
                data_type->right = dem_str_newf("{for `%s's `%s'}", str.type_str, str2.type_str);
                free_type_code_str_struct(&str2);
            } else {
                data_type->right = dem_str_newf("{for `%s'}", str.type_str);
            }
            free_type_code_str_struct(&str);
        } else {
            data_type->right = strdup("");
        }
        if (*curr_pos == '@') {
            curr_pos++;
        }
        break;
    case '8':
    case '9':
        curr_pos++;
        break;
    default:
        return eDemanglerErrUncorrectMangledSymbol;
    }
    if (len) {
        *len = curr_pos - sym;
    }
    return eDemanglerErrOK;
}

References dem_str_newf(), eDemanglerErrInternal, eDemanglerErrMemoryAllocation, eDemanglerErrOK, eDemanglerErrUncorrectMangledSymbol, err, free(), free_type_code_str_struct(), get_namespace_and_name(), get_ptr_modifier(), get_storage_class(), get_type_code_string(), i, init_type_code_str_struct(), SDataType::left, len, NULL, SDataType::right, sdatatype_fini(), cmd_descs_generate::str, strdup(), autogen_x86imm::tmp, and STypeCodeStr::type_str.

Referenced by get_template_params(), and parse_microsoft_mangled_name().

parse_function()

static EDemanglerErr parse_function ( const char *  sym, STypeCodeStr *  type_code_str, char **  demangled_function, size_t *  chars_read  )

static

Definition at line 2275 of file microsoft_demangle.c.

                                                                                                                                 {
    EDemanglerErr err = eDemanglerErrOK;
    bool is_implicit_this_pointer;
    bool is_static;
    const char *memb_func_access_code = NULL;
    const char *call_conv = NULL;
    char *demangled_args = NULL;
    char *ret_type = NULL;
    SDataType data_type = { 0 };
    SDataType this_pointer_modifier = { 0 };
    const char *curr_pos = sym;
    bool __64ptr = false;
    size_t len;
 
    STypeCodeStr func_str;
    if (!init_type_code_str_struct(&func_str)) {
        err = eDemanglerErrMemoryAllocation;
        goto parse_function_err;
    }
 
    if (!strncmp(curr_pos, "$$F", 3)) {
        // Managed function (Managed C++ or C++/CLI)
        curr_pos += 3;
    }
 
    err = parse_function_type(curr_pos, &data_type, &len, &is_static, &is_implicit_this_pointer);
    if (err != eDemanglerErrOK) {
        goto parse_function_err;
    }
 
    curr_pos += len;
 
    if (*curr_pos == 'E') {
        __64ptr = true;
        curr_pos++;
    }
 
    if (*curr_pos == '$') {
        curr_pos++;
        if (*curr_pos) {
            curr_pos++;
        }
    }
 
    if (!*curr_pos) {
        goto print_function;
    }
 
    // member function access code
    if (is_implicit_this_pointer) {
        curr_pos += get_ptr_modifier(curr_pos, &this_pointer_modifier);
        err = get_storage_class(*curr_pos, &memb_func_access_code);
        if (err != eDemanglerErrOK) {
            goto parse_function_err;
        }
        curr_pos++;
    }
 
    // currently does not use because I can not find real example of
    // where to use this
    // just read in http://www.agner.org/optimize/calling_conventions.pdf
    // that this is possible
    // when some find the case where it is used please remove this (void)*
    // lines
    (void)is_static;
 
    // Calling convention
    call_conv = get_calling_convention(*curr_pos);
    if (!call_conv) {
        err = eDemanglerErrUncorrectMangledSymbol;
        goto parse_function_err;
    }
    curr_pos++;
 
    // get storage class code for return
    if (*curr_pos == '?') {
        err = get_storage_class(*++curr_pos, &memb_func_access_code);
        if (err != eDemanglerErrOK) {
            goto parse_function_err;
        }
        curr_pos++;
    }
 
    // Return type, or @ if 'void'
    if (*curr_pos == '@') {
        ret_type = strdup("void");
        curr_pos++;
    } else {
        err = get_type_code_string(curr_pos, &len, &ret_type);
        if (err != eDemanglerErrOK) {
            err = eDemanglerErrUncorrectMangledSymbol;
            goto parse_function_err;
        }
 
        curr_pos += len;
    }
    err = parse_function_args(curr_pos, &demangled_args, &len);
    if (err != eDemanglerErrOK) {
        goto parse_function_err;
    }
 
    curr_pos += len;
 
print_function:
 
    if (!RZ_STR_ISEMPTY(data_type.left)) {
        copy_string(&func_str, data_type.left);
        if (!strstr(data_type.left, "static")) {
            copy_string(&func_str, ": ");
        } else {
            copy_string(&func_str, " ");
        }
    }
 
    if (ret_type) {
        copy_string(&func_str, ret_type);
        copy_string(&func_str, " ");
    }
 
    if (call_conv) {
        copy_string(&func_str, call_conv);
        copy_string(&func_str, " ");
    }
 
    if (type_code_str->type_str) {
        copy_string_n(&func_str, type_code_str->type_str, type_code_str->curr_pos);
    }
 
    if (!RZ_STR_ISEMPTY(data_type.right)) {
        copy_string(&func_str, data_type.right);
    }
 
    copy_string(&func_str, demangled_args);
    RZ_FREE(demangled_args);
 
    if (memb_func_access_code) {
        copy_string(&func_str, memb_func_access_code);
    }
 
    copy_string(&func_str, this_pointer_modifier.left);
 
    if (__64ptr) {
        copy_string(&func_str, " __ptr64");
    }
 
    copy_string(&func_str, this_pointer_modifier.right);
 
    if (ret_type) {
        if (strstr(func_str.type_str, "#{return_type}")) {
            func_str.type_str = type_code_str_get(&func_str);
            func_str.type_str = dem_str_replace(func_str.type_str, "#{return_type}", ret_type, 0);
            func_str.curr_pos -= strlen("#{return_type}") - strlen(ret_type);
        }
    }
 
    // need to be free by user
    if (func_str.type_str) {
        *demangled_function = type_code_str_get(&func_str);
    }
 
parse_function_err:
    if (chars_read) {
        *chars_read = curr_pos - sym;
    }
    sdatatype_fini(&data_type);
    sdatatype_fini(&this_pointer_modifier);
    free_type_code_str_struct(&func_str);
    free(ret_type);
    free(demangled_args);
    return err;
}

References copy_string, copy_string_n(), STypeCodeStr::curr_pos, dem_str_replace(), eDemanglerErrMemoryAllocation, eDemanglerErrOK, eDemanglerErrUncorrectMangledSymbol, err, free(), free_type_code_str_struct(), get_calling_convention(), get_ptr_modifier(), get_storage_class(), get_type_code_string(), init_type_code_str_struct(), SDataType::left, len, NULL, parse_function_args(), parse_function_type(), SDataType::right, RZ_FREE, RZ_STR_ISEMPTY, sdatatype_fini(), strdup(), type_code_str_get(), and STypeCodeStr::type_str.

Referenced by get_template_params(), and parse_microsoft_mangled_name().

parse_function_args()

static EDemanglerErr parse_function_args ( const char *  sym, char **  demangled_args, size_t *  read_chars  )

static

Definition at line 1606 of file microsoft_demangle.c.

                                                                                                     {
    EDemanglerErr err = eDemanglerErrOK;
    const char *curr_pos = sym;
    size_t len = 0;
 
    STypeCodeStr func_str;
    if (!init_type_code_str_struct(&func_str)) {
        return eDemanglerErrMemoryAllocation;
    }
 
    copy_string(&func_str, "(");
 
    // Function arguments
    while (*curr_pos && *curr_pos != 'Z') {
        if (*curr_pos != '@') {
            char *tmp;
            bool is_abbr_type = false;
            if (len) {
                copy_string(&func_str, ", ");
            }
            err = get_type_code_string(curr_pos, &len, &tmp);
            if (err != eDemanglerErrOK) {
                // abbreviation of type processing
                if ((*curr_pos >= '0') && (*curr_pos <= '9')) {
                    free(tmp);
                    tmp = dem_list_get_n(abbr_types, (ut32)(*curr_pos - '0'));
                    if (!tmp) {
                        err = eDemanglerErrUncorrectMangledSymbol;
                        break;
                    }
                    err = eDemanglerErrOK;
                    len = 1;
                    is_abbr_type = true;
                } else {
                    err = eDemanglerErrUncorrectMangledSymbol;
                    free(tmp);
                    break;
                }
            }
            curr_pos += len;
 
            if (len > 1) {
                dem_list_append(abbr_types, strdup(tmp));
            }
 
            copy_string(&func_str, tmp);
 
            if (tmp && strncmp(tmp, "void", 4) == 0 && strlen(tmp) == 4) {
                // arguments list is void
                if (!is_abbr_type) {
                    free(tmp);
                }
                break;
            }
            if (!is_abbr_type) {
                free(tmp);
            }
        } else {
            curr_pos++;
        }
    }
 
    while (*curr_pos == '@') {
        curr_pos++;
    }
 
    if (*curr_pos != 'Z') {
        err = eDemanglerErrUncorrectMangledSymbol;
    }
 
    copy_string(&func_str, ")");
 
    if (demangled_args) {
        *demangled_args = strdup(func_str.type_str);
    }
 
    free_type_code_str_struct(&func_str);
 
    if (read_chars) {
        *read_chars = curr_pos - sym + 1;
    }
 
    return err;
}

References abbr_types, copy_string, dem_list_append(), dem_list_get_n(), eDemanglerErrMemoryAllocation, eDemanglerErrOK, eDemanglerErrUncorrectMangledSymbol, err, free(), free_type_code_str_struct(), get_type_code_string(), init_type_code_str_struct(), len, strdup(), autogen_x86imm::tmp, and STypeCodeStr::type_str.

Referenced by parse_function(), and parse_function_pointer().

parse_function_pointer()

static void parse_function_pointer ( SStateInfo *  state, STypeCodeStr *  type_code_str, const char *  pointer_str  )

static

Definition at line 1692 of file microsoft_demangle.c.

                                                                                                            {
    const char *call_conv = NULL;
    const char *storage = NULL;
    char *ret_type = NULL;
    size_t i = 0;
    EDemanglerErr err;
 
    state->state = eTCStateEnd;
 
    // Calling convention
    call_conv = get_calling_convention(*state->buff_for_parsing++);
    if (!call_conv) {
        // XXX unify error messages into a single enum
        state->err = eTCStateMachineErrUncorrectTypeCode;
        return;
    }
 
    state->amount_of_read_chars += 2; // '6' + call_conv
 
    // return type
    if (*state->buff_for_parsing == '?') {
        err = get_storage_class(*++state->buff_for_parsing, &storage);
        if (err != eDemanglerErrOK) {
            state->err = eTCStateMachineErrUncorrectTypeCode;
            return;
        }
        state->buff_for_parsing++;
        state->amount_of_read_chars += 2;
    }
    err = get_type_code_string(state->buff_for_parsing, &i, &ret_type);
    if (err != eDemanglerErrOK) {
        state->err = eTCStateMachineErrUnsupportedTypeCode;
        return;
    }
 
    copy_string(type_code_str, ret_type);
    if (storage) {
        copy_string(type_code_str, " ");
        copy_string(type_code_str, storage);
    }
    copy_string(type_code_str, " (");
    RZ_FREE(ret_type);
 
    copy_string(type_code_str, call_conv);
    copy_string(type_code_str, " ");
    copy_string(type_code_str, pointer_str);
    copy_string(type_code_str, ")");
 
    state->amount_of_read_chars += i;
    state->buff_for_parsing += i;
 
    char *demangled_args = NULL;
    if (parse_function_args(state->buff_for_parsing, &demangled_args, &i) != eDemanglerErrOK) {
        free(demangled_args);
        state->err = eTCStateMachineErrUncorrectTypeCode;
        return;
    }
    state->amount_of_read_chars += i;
    state->buff_for_parsing += i;
    copy_string(type_code_str, demangled_args);
    free(demangled_args);
    return;
}

References copy_string, eDemanglerErrOK, err, eTCStateEnd, eTCStateMachineErrUncorrectTypeCode, eTCStateMachineErrUnsupportedTypeCode, free(), get_calling_convention(), get_storage_class(), get_type_code_string(), i, NULL, parse_function_args(), and RZ_FREE.

Referenced by parse_pointer().

parse_function_type()

static EDemanglerErr parse_function_type ( const char *  sym, SDataType *  data_type, size_t *  len, bool *  is_static, bool *  is_implicit_this_pointer  )

static

Definition at line 2204 of file microsoft_demangle.c.

                                                                  {
    const char *curr_pos = sym;
    *is_static = *is_implicit_this_pointer = false;
#define SET_THUNK_MODIFIER(letter, modifier_str) \
    case letter: { \
        SStateInfo state; \
        init_state_struct(&state, curr_pos); \
        char *num = get_num(&state); \
        if (!num) { \
            return eDemanglerErrUncorrectMangledSymbol; \
        } \
        data_type->left = strdup(modifier_str); \
        data_type->right = dem_str_newf("`adjustor{%s}'", num); \
        free(num); \
        *is_implicit_this_pointer = true; \
        curr_pos += state.amount_of_read_chars; \
        break; \
    }
 
#define SET_ACCESS_MODIFIER(letter, flag_set, modifier_str) \
    case letter: \
        data_type->left = strdup(modifier_str); \
        *flag_set = true; \
        break;
 
    /* Functions */
    switch (*curr_pos++) {
        SET_ACCESS_MODIFIER('A', is_implicit_this_pointer, "private");
        SET_ACCESS_MODIFIER('B', is_implicit_this_pointer, "private");
        SET_ACCESS_MODIFIER('C', is_static, "private: static");
        SET_ACCESS_MODIFIER('D', is_static, "private: static");
        SET_ACCESS_MODIFIER('E', is_implicit_this_pointer, "private virtual");
        SET_ACCESS_MODIFIER('F', is_implicit_this_pointer, "private virtual");
        SET_THUNK_MODIFIER('G', "[thunk]:private virtual");
        SET_THUNK_MODIFIER('H', "[thunk]:private virtual");
        SET_ACCESS_MODIFIER('I', is_implicit_this_pointer, "protected");
        SET_ACCESS_MODIFIER('J', is_implicit_this_pointer, "protected");
        SET_ACCESS_MODIFIER('K', is_static, "protected: static");
        SET_ACCESS_MODIFIER('L', is_static, "protected: static");
        SET_ACCESS_MODIFIER('M', is_implicit_this_pointer, "protected virtual");
        SET_ACCESS_MODIFIER('N', is_implicit_this_pointer, "protected virtual");
        SET_THUNK_MODIFIER('O', "[thunk]:protected virtual");
        SET_THUNK_MODIFIER('P', "[thunk]:protected virtual");
        SET_ACCESS_MODIFIER('Q', is_implicit_this_pointer, "public");
        SET_ACCESS_MODIFIER('R', is_implicit_this_pointer, "public");
        SET_ACCESS_MODIFIER('S', is_static, "public: static");
        SET_ACCESS_MODIFIER('T', is_static, "public: static");
        SET_ACCESS_MODIFIER('U', is_implicit_this_pointer, "public virtual");
        SET_ACCESS_MODIFIER('V', is_implicit_this_pointer, "public virtual");
        SET_THUNK_MODIFIER('W', "[thunk]:public virtual");
        SET_THUNK_MODIFIER('X', "[thunk]:public virtual");
    case 'Y': // near
    case 'Z': // far
        break;
    default:
        return eDemanglerErrUncorrectMangledSymbol;
    }
#undef SET_ACCESS_MODIFIER
    if (len) {
        *len = curr_pos - sym;
    }
    if (!data_type->left) {
        data_type->left = strdup("");
    }
    if (!data_type->right) {
        data_type->right = strdup("");
    }
    return eDemanglerErrOK;
}

References eDemanglerErrOK, eDemanglerErrUncorrectMangledSymbol, SDataType::left, len, SDataType::right, SET_ACCESS_MODIFIER, SET_THUNK_MODIFIER, and strdup().

Referenced by parse_function().

parse_microsoft_mangled_name()

static EDemanglerErr parse_microsoft_mangled_name ( const char *  sym, char **  demangled_name, size_t *  chars_read  )

static

public mangled name of global object: <public name> ::= ?<name>@[<namespace>@](0->inf)@3<type><storage class> mangled name of a static class member object: <public name> ::= ?<name>@[<classname>@](1->inf)@2<type><storage class>

Definition at line 2453 of file microsoft_demangle.c.

                                                                                                              {
    STypeCodeStr type_code_str;
    EDemanglerErr err = eDemanglerErrOK;
 
    const char *curr_pos = sym;
 
    if (!init_type_code_str_struct(&type_code_str)) {
        err = eDemanglerErrMemoryAllocation;
        goto parse_microsoft_mangled_name_err;
    }
    size_t i;
    size_t len = get_namespace_and_name(curr_pos, &type_code_str, &i, false);
    if (!len) {
        err = eDemanglerErrUncorrectMangledSymbol;
        goto parse_microsoft_mangled_name_err;
    }
 
    curr_pos += len;
 
    if (!*curr_pos) {
        *demangled_name = type_code_str_get(&type_code_str);
        goto parse_microsoft_mangled_name_err;
    }
 
    curr_pos++;
 
    if (!strncmp(curr_pos, "$$F", 3)) {
        // Managed function (Managed C++ or C++/CLI)
        curr_pos += 3;
    }
 
    if (curr_pos[0] == '_') {
        // TODO: __based()
        curr_pos++;
    }
 
    if (isdigit(*curr_pos)) {
        SDataType data_type = { 0 };
        err = parse_data_type(curr_pos, &data_type, &len);
        if (err != eDemanglerErrOK) {
            sdatatype_fini(&data_type);
            goto parse_microsoft_mangled_name_err;
        }
        curr_pos += len;
        *demangled_name = NULL;
        if (data_type.left) {
            *demangled_name = dem_str_newf("%s ", data_type.left);
        }
        *demangled_name = dem_str_append(*demangled_name, type_code_str.type_str);
        *demangled_name = dem_str_append(*demangled_name, data_type.right);
        sdatatype_fini(&data_type);
    } else if (isalpha(*curr_pos)) {
        err = parse_function(curr_pos, &type_code_str, demangled_name, &len);
        curr_pos += len;
    } else {
        err = eDemanglerErrUncorrectMangledSymbol;
    }
 
parse_microsoft_mangled_name_err:
    free_type_code_str_struct(&type_code_str);
    if (chars_read) {
        *chars_read = curr_pos - sym;
    }
    return err;
}

References dem_str_append(), dem_str_newf(), eDemanglerErrMemoryAllocation, eDemanglerErrOK, eDemanglerErrUncorrectMangledSymbol, err, free_type_code_str_struct(), get_namespace_and_name(), i, init_type_code_str_struct(), isalpha, isdigit, SDataType::left, len, NULL, parse_data_type(), parse_function(), SDataType::right, sdatatype_fini(), type_code_str_get(), and STypeCodeStr::type_str.

Referenced by get_namespace_and_name(), and microsoft_demangle().

parse_microsoft_rtti_mangled_name()

static EDemanglerErr parse_microsoft_rtti_mangled_name ( const char *  sym, char **  demangled_name, size_t *  chars_read  )

static

Definition at line 2519 of file microsoft_demangle.c.

                                                                                                                   {
    EDemanglerErr err = eDemanglerErrOK;
    char *type = NULL;
    const char *storage = NULL;
    if (chars_read) {
        *chars_read = 0;
    }
    if (RZ_STR_ISEMPTY(sym)) {
        return eDemanglerErrUncorrectMangledSymbol;
    }
    err = get_storage_class(*sym++, &storage);
    if (err != eDemanglerErrOK) {
        return err;
    }
    size_t len;
    err = get_type_code_string(sym, &len, &type);
    if (err != eDemanglerErrOK) {
        return err;
    }
    if (storage) {
        *demangled_name = dem_str_newf("%s %s", type, storage);
    } else {
        *demangled_name = dem_str_newf("%s", type);
    }
    if (chars_read) {
        *chars_read = len + 1;
    }
    free(type);
    return err;
}

References dem_str_newf(), eDemanglerErrOK, eDemanglerErrUncorrectMangledSymbol, err, free(), get_storage_class(), get_type_code_string(), len, NULL, RZ_STR_ISEMPTY, and type.

Referenced by get_operator_code(), and microsoft_demangle().

parse_pointer()

static void parse_pointer ( SStateInfo *  state, STypeCodeStr *  type_code_str, const char *  pointer_str  )

static

Definition at line 1756 of file microsoft_demangle.c.

                                                                                                   {
    if (isdigit((ut8)*state->buff_for_parsing)) {
        ut8 digit = *state->buff_for_parsing++;
        if (digit == '6' || digit == '7') {
            parse_function_pointer(state, type_code_str, pointer_str);
            return;
        } else if (digit == '8' || digit == '9') {
            STypeCodeStr func_str;
            if (!init_type_code_str_struct(&func_str)) {
                state->err = eTCStateMachineErrAlloc;
                return;
            };
            size_t read = get_namespace_and_name(state->buff_for_parsing, &func_str, NULL, true);
            if (!read || !*(state->buff_for_parsing + read) || *(state->buff_for_parsing + read) != '@') {
                state->err = eTCStateMachineErrUncorrectTypeCode;
                free_type_code_str_struct(&func_str);
                return;
            }
            read++;
            state->amount_of_read_chars += read;
            state->buff_for_parsing += read;
            copy_string(&func_str, "::");
            copy_string(&func_str, pointer_str);
            SDataType data_type = { 0 };
            size_t ptr_mod_cnt = get_ptr_modifier(state->buff_for_parsing, &data_type);
            state->buff_for_parsing += ptr_mod_cnt;
            state->amount_of_read_chars += ptr_mod_cnt;
            const char *storage;
            if (get_storage_class(*state->buff_for_parsing++, &storage) != eDemanglerErrOK) {
                state->err = eTCStateMachineErrUncorrectTypeCode;
                free_type_code_str_struct(&func_str);
                sdatatype_fini(&data_type);
                return;
            }
            state->amount_of_read_chars++;
            copy_string(type_code_str, data_type.left);
            parse_function_pointer(state, type_code_str, func_str.type_str);
            free_type_code_str_struct(&func_str);
            if (storage) {
                copy_string(type_code_str, " ");
                copy_string(type_code_str, storage);
            }
            copy_string(type_code_str, data_type.right);
            sdatatype_fini(&data_type);
            state->state = eTCStateEnd;
            return;
        }
    }
    parse_type_modifier(state, type_code_str, pointer_str);
}

References copy_string, eDemanglerErrOK, eTCStateEnd, eTCStateMachineErrAlloc, eTCStateMachineErrUncorrectTypeCode, free_type_code_str_struct(), get_namespace_and_name(), get_ptr_modifier(), get_storage_class(), init_type_code_str_struct(), isdigit, SDataType::left, NULL, parse_function_pointer(), parse_type_modifier(), read(), SDataType::right, sdatatype_fini(), and STypeCodeStr::type_str.

parse_type_modifier()

static void parse_type_modifier ( SStateInfo *  state, STypeCodeStr *  type_code_str, const char *  modifier_str  )

inlinestatic

Definition at line 1402 of file microsoft_demangle.c.

                                                                                                                 {
    size_t i = 0;
    EDemanglerErr err = eDemanglerErrOK;
    char *tmp = NULL;
    STypeCodeStr tmp_str;
    STypeCodeStr storage_class;
    bool is_pin_ptr = false;
    char clr_type = '\0';
 
    state->state = eTCStateEnd;
 
    if (!init_type_code_str_struct(&tmp_str)) {
        state->err = eTCStateMachineErrAlloc;
        return;
    }
    if (!init_type_code_str_struct(&storage_class)) {
        free_type_code_str_struct(&tmp_str);
        state->err = eTCStateMachineErrAlloc;
        return;
    }
 
    STypeCodeStr mod_left;
    STypeCodeStr mod_right;
    if (!init_type_code_str_struct(&mod_left) ||
        !init_type_code_str_struct(&mod_right)) {
        state->err = eTCStateMachineErrAlloc;
        goto MODIFIER_err;
    }
 
    SDataType mod = { 0 };
    i = get_ptr_modifier(state->buff_for_parsing, &mod);
    copy_string(&mod_left, mod.left);
    copy_string(&mod_right, mod.right);
    sdatatype_fini(&mod);
 
    state->buff_for_parsing += i;
    state->amount_of_read_chars += i;
 
    if (*state->buff_for_parsing == '$') {
        state->buff_for_parsing++;
        switch (*state->buff_for_parsing++) {
        case 'A':
            clr_type = '^';
            break;
        case 'B': // cli::pin_ptr<T>
            is_pin_ptr = true;
            break;
        case 'C':
            clr_type = '%';
            break;
        case '\0':
            state->err = eTCStateMachineErrUncorrectTypeCode;
            goto MODIFIER_err;
        default:
            state->err = eTCStateMachineErrUnsupportedTypeCode;
            break;
        }
        state->amount_of_read_chars += 2;
    }
 
    do {
        i = get_ptr_modifier(state->buff_for_parsing, &mod);
        state->buff_for_parsing += i;
        state->amount_of_read_chars += i;
 
        const char *storage_class_str;
        err = get_storage_class(*state->buff_for_parsing, &storage_class_str);
        if (storage_class_str) {
            copy_string(&storage_class, storage_class_str);
        }
        if (err == eDemanglerErrOK) {
            state->buff_for_parsing++;
            state->amount_of_read_chars++;
        }
        copy_string(&mod_left, mod.left);
        copy_string(&mod_right, mod.right);
        sdatatype_fini(&mod);
    } while (i);
 
    if (*state->buff_for_parsing == 'Y') {
        char *n1;
        int num;
 
        state->buff_for_parsing++;
        state->amount_of_read_chars++;
        if (!(n1 = get_num(state))) {
            goto MODIFIER_err;
        }
        num = atoi(n1);
        RZ_FREE(n1);
 
        if (*storage_class.type_str || *mod_left.type_str || *mod_right.type_str || *modifier_str) {
            copy_string(&tmp_str, "(");
            copy_string_n(&tmp_str, storage_class.type_str, storage_class.curr_pos);
            copy_string_n(&tmp_str, mod_left.type_str, mod_left.curr_pos);
            const char last_char = tmp_str.type_str[tmp_str.curr_pos - 1];
            if (last_char != ' ' && last_char != '(') {
                copy_string(&tmp_str, " ");
            }
            copy_string(&tmp_str, modifier_str);
            copy_string_n(&tmp_str, mod_right.type_str, mod_right.curr_pos);
            copy_string(&tmp_str, ")");
        }
 
        while (num--) {
            n1 = get_num(state);
            if (!n1) {
                break;
            }
            copy_string(&tmp_str, "[");
            copy_string(&tmp_str, n1);
            copy_string(&tmp_str, "]");
            RZ_FREE(n1);
        }
    }
 
    if (tmp_str.curr_pos == 0) {
        copy_string_n(&tmp_str, storage_class.type_str, storage_class.curr_pos);
        copy_string_n(&tmp_str, mod_left.type_str, mod_left.curr_pos);
        if (tmp_str.curr_pos && tmp_str.type_str[tmp_str.curr_pos - 1] != ' ') {
            copy_string(&tmp_str, " ");
        }
        if (clr_type && *modifier_str != '\0') {
            copy_string_n(&tmp_str, &clr_type, 1);
            const char *rest_of_mod_str = modifier_str + (*(modifier_str + 1) == '&' ? 2 : 1);
            copy_string(&tmp_str, rest_of_mod_str);
        } else {
            if (is_pin_ptr && *modifier_str) {
                while (*++modifier_str == ' ') {
                };
            }
            copy_string(&tmp_str, modifier_str);
        }
        copy_string_n(&tmp_str, mod_right.type_str, mod_right.curr_pos);
    }
 
    if (!strncmp(state->buff_for_parsing, "__Z", 3)) {
        // TODO: no idea what this means
        state->buff_for_parsing += 3;
        state->amount_of_read_chars += 3;
    }
 
    err = get_type_code_string(state->buff_for_parsing, &i, &tmp);
    if (err != eDemanglerErrOK) {
        state->err = eTCStateMachineErrUnsupportedTypeCode;
        goto MODIFIER_err;
    }
 
    state->amount_of_read_chars += i;
    state->buff_for_parsing += i;
    if (is_pin_ptr) {
        copy_string(type_code_str, "cli::pin_ptr<");
    }
    copy_string(type_code_str, tmp);
    if (type_code_str->curr_pos && type_code_str->type_str[type_code_str->curr_pos - 1] != ' ' && tmp_str.type_str[0] != ' ') {
        copy_string(type_code_str, " ");
    }
    copy_string_n(type_code_str, tmp_str.type_str, tmp_str.curr_pos);
    if (is_pin_ptr) {
        copy_string(type_code_str, ">");
    }
 
MODIFIER_err:
    RZ_FREE(tmp);
    sdatatype_fini(&mod);
    free_type_code_str_struct(&tmp_str);
    free_type_code_str_struct(&storage_class);
    free_type_code_str_struct(&mod_left);
    free_type_code_str_struct(&mod_right);
}

References copy_string, copy_string_n(), STypeCodeStr::curr_pos, eDemanglerErrOK, err, eTCStateEnd, eTCStateMachineErrAlloc, eTCStateMachineErrUncorrectTypeCode, eTCStateMachineErrUnsupportedTypeCode, free_type_code_str_struct(), get_num(), get_ptr_modifier(), get_storage_class(), get_type_code_string(), i, init_type_code_str_struct(), mod(), NULL, num, RZ_FREE, sdatatype_fini(), autogen_x86imm::tmp, and STypeCodeStr::type_str.

Referenced by DEF_STATE_ACTION(), and parse_pointer().

read_be16()

static ut16 read_be16 ( const void *  src )

inlinestatic

Definition at line 417 of file microsoft_demangle.c.

                                              {
    const ut8 *s = (const ut8 *)src;
    return (((ut16)s[0]) << 8) | (((ut16)s[1]) << 0);
}

References s, and src.

Referenced by utf16be_to_utf8_impl().

run_state()

static void run_state ( SStateInfo *  state_info, STypeCodeStr *  type_code_str  )

static

Definition at line 193 of file microsoft_demangle.c.

                                                                           {
    state_table[state_info->state](state_info, type_code_str);
}

References SStateInfo::state, and state_table.

Referenced by get_type_code_string().

sdatatype_fini()

static void sdatatype_fini ( SDataType *  data_type )

inlinestatic

Definition at line 91 of file microsoft_demangle.c.

                                                        {
    if (!data_type) {
        return;
    }
    RZ_FREE(data_type->left);
    RZ_FREE(data_type->right);
}

References SDataType::left, SDataType::right, and RZ_FREE.

Referenced by get_template_params(), parse_data_type(), parse_function(), parse_microsoft_mangled_name(), parse_pointer(), and parse_type_modifier().

sstrinfo_free()

static void sstrinfo_free ( SStrInfo *  sstrinfo )

static

Definition at line 99 of file microsoft_demangle.c.

                                              {
    if (!sstrinfo) {
        return;
    }
    free(sstrinfo->str_ptr);
    free(sstrinfo);
}

References free(), and SStrInfo::str_ptr.

Referenced by get_namespace_and_name(), and get_template().

tc_state_end()

static void tc_state_end ( SStateInfo *  state, STypeCodeStr *  type_code_str  )

static

Definition at line 1922 of file microsoft_demangle.c.

                                                                         {
    return;
}

tc_state_start()

static void tc_state_start ( SStateInfo *  state, STypeCodeStr *  type_code_str  )

static

Definition at line 1876 of file microsoft_demangle.c.

                                                                           {
#define ONE_LETTER_STATE(letter) \
    case CHAR_WITH_QUOTES(letter): \
        state->state = eTCState##letter; \
        break;
 
    switch (*(state->buff_for_parsing)) {
        ONE_LETTER_STATE(A)
        ONE_LETTER_STATE(B)
        ONE_LETTER_STATE(C)
        ONE_LETTER_STATE(D)
        ONE_LETTER_STATE(E)
        ONE_LETTER_STATE(F)
        ONE_LETTER_STATE(G)
        ONE_LETTER_STATE(H)
        ONE_LETTER_STATE(I)
        ONE_LETTER_STATE(J)
        ONE_LETTER_STATE(K)
        ONE_LETTER_STATE(M)
        ONE_LETTER_STATE(N)
        ONE_LETTER_STATE(O)
        ONE_LETTER_STATE(P)
        ONE_LETTER_STATE(Q)
        ONE_LETTER_STATE(R)
        ONE_LETTER_STATE(S)
        ONE_LETTER_STATE(T)
        ONE_LETTER_STATE(U)
        ONE_LETTER_STATE(V)
        ONE_LETTER_STATE(W)
        ONE_LETTER_STATE(X)
        ONE_LETTER_STATE(Z)
        ONE_LETTER_STATE(_)
        ONE_LETTER_STATE($)
    default:
        // eprintf("[uncorrect type] error while parsing type\n");
 
        state->state = eTCStateEnd;
        state->err = eTCStateMachineErrUncorrectTypeCode;
        break;
    }
 
    state->amount_of_read_chars++;
    state->buff_for_parsing++;
#undef ONE_LETTER_STATE
}

References _, A, B, C, D, E, eTCStateEnd, eTCStateMachineErrUncorrectTypeCode, F, G, H, I, J, M, N, O, ONE_LETTER_STATE, P, Q, R, S, T, V, W, X, and Z.

type_code_str_get()

static char * type_code_str_get ( STypeCodeStr *  type_code_str )

static

Definition at line 1948 of file microsoft_demangle.c.

                                                            {
    char *ret;
    if (type_code_str->type_str == type_code_str->type_str_buf) {
        ret = malloc(type_code_str->curr_pos + 1);
        if (!ret) {
            return NULL;
        }
        memcpy(ret, type_code_str->type_str, type_code_str->curr_pos);
        ret[type_code_str->curr_pos] = '\0';
    } else {
        ret = type_code_str->type_str;
    }
    type_code_str->type_str = NULL;
    return ret;
}

References STypeCodeStr::curr_pos, malloc(), memcpy(), NULL, STypeCodeStr::type_str, and STypeCodeStr::type_str_buf.

Referenced by get_template(), get_type_code_string(), parse_function(), and parse_microsoft_mangled_name().

utf16be_to_utf8()

static EDemanglerErr utf16be_to_utf8 ( const char *  utf16be, size_t  utf16be_len, char **  utf8, size_t *  utf8_len  )

static

Definition at line 476 of file microsoft_demangle.c.

                                                                                                             {
    const size_t utf8_len_tmp = utf16be_len * 4;
    *utf8 = malloc(utf8_len_tmp);
    if (!*utf8) {
        return eDemanglerErrMemoryAllocation;
    }
    ssize_t res = utf16be_to_utf8_impl(utf16be, utf16be_len, *utf8, utf8_len_tmp);
    if (res < 0) {
        free(*utf8);
        return eDemanglerErrUncorrectMangledSymbol;
    }
    *utf8_len = res;
    return eDemanglerErrOK;
}

References eDemanglerErrMemoryAllocation, eDemanglerErrOK, eDemanglerErrUncorrectMangledSymbol, free(), malloc(), and utf16be_to_utf8_impl().

Referenced by get_operator_code().

utf16be_to_utf8_impl()

static ssize_t utf16be_to_utf8_impl ( const char *  utf16be, size_t  utf16be_len, char *  utf8, size_t  utf8_len  )

static

Definition at line 422 of file microsoft_demangle.c.

                                                                                                          {
    char *const outstart = utf8;
    char *const outend = utf8 + utf8_len;
    const ut16 *in = (const ut16 *)utf16be;
    ut32 c, d;
    int bits;
 
    const size_t inlen = utf16be_len / 2;
    const ut16 *const inend = in + inlen;
    while ((in < inend) && (utf8 - outstart + 5 < utf8_len)) {
        c = read_be16(in++);
        if ((c & 0xFC00) == 0xD800) { /* surrogates */
            if (in >= inend) { /* (in > inend) shouldn't happen */
                break;
            }
            d = read_be16(in++);
            if ((d & 0xFC00) == 0xDC00) {
                c &= 0x03FF;
                c <<= 10;
                c |= d & 0x03FF;
                c += 0x10000;
            } else {
                return -1;
            }
        }
 
        /* assertion: c is a single UTF-4 value */
        if (utf8 >= outend) {
            break;
        }
        if (c < 0x80) {
            *utf8++ = c;
            bits = -6;
        } else if (c < 0x800) {
            *utf8++ = ((c >> 6) & 0x1F) | 0xC0;
            bits = 0;
        } else if (c < 0x10000) {
            *utf8++ = ((c >> 12) & 0x0F) | 0xE0;
            bits = 6;
        } else {
            *utf8++ = ((c >> 18) & 0x07) | 0xF0;
            bits = 12;
        }
 
        for (; bits >= 0; bits -= 6) {
            if (utf8 >= outend) {
                break;
            }
            *utf8++ = ((c >> bits) & 0x3F) | 0x80;
        }
    }
    return utf8 - outstart;
}

References bits(), c, d, in, and read_be16().

Referenced by utf16be_to_utf8().

Variable Documentation

abbr_names

DemList* abbr_names = NULL

static

Definition at line 13 of file microsoft_demangle.c.

Referenced by get_namespace_and_name(), get_template(), and microsoft_demangle().

abbr_types

DemList* abbr_types = NULL

static

Definition at line 12 of file microsoft_demangle.c.

Referenced by microsoft_demangle(), and parse_function_args().

state_table

state_func const state_table[eTCStateMax]

static

Initial value:

= {
    NAME(start),
    NAME(end),
    NAME(A),
    NAME(B),
    NAME(C),
    NAME(D),
    NAME(E),
    NAME(F),
    NAME(G),
    NAME(H),
    NAME(I),
    NAME(J),
    NAME(K),
    NAME(M),
    NAME(N),
    NAME(O),
    NAME(P),
    NAME(Q),
    NAME(R),
    NAME(S),
    NAME(T),
    NAME(U),
    NAME(V),
    NAME(W),
    NAME(X),
    NAME(Z),
    NAME(_),
    NAME($),
}

Definition at line 139 of file microsoft_demangle.c.

Referenced by run_state().