extern gboolean substitute_with_mscorlib_p;
-static MonoGenericContext *
-get_memberref_context (MonoImage *m, guint32 mrp_token, MonoGenericContext *context);
+static MonoGenericContainer *
+get_memberref_container (MonoImage *m, guint32 mrp_token, MonoGenericContainer *container);
static char *
-get_memberref_parent (MonoImage *m, guint32 mrp_token, MonoGenericContext *context);
+get_memberref_parent (MonoImage *m, guint32 mrp_token, MonoGenericContainer *container);
static gboolean
cant_print_generic_param_name (MonoGenericParam *gparam);
* Returns the stringified representation of a TypeSpec signature (22.2.17)
*/
char *
-get_typespec (MonoImage *m, guint32 idx, gboolean is_def, MonoGenericContext *context)
+get_typespec (MonoImage *m, guint32 idx, gboolean is_def, MonoGenericContainer *container)
{
guint32 cols [MONO_TYPESPEC_SIZE];
const char *ptr;
if (*ptr == MONO_TYPE_VOID)
g_string_append (res, "void");
else {
- ptr = get_type (m, ptr, &s, is_def, context);
+ ptr = get_type (m, ptr, &s, is_def, container);
if (s)
g_string_append (res, s);
}
break;
case MONO_TYPE_FNPTR:
- sig = mono_metadata_parse_method_signature_full (m, context ? context->container : NULL, 0, ptr, &ptr);
+ sig = mono_metadata_parse_method_signature_full (m, container, 0, ptr, &ptr);
s = dis_stringify_function_ptr (m, sig);
g_string_append (res, "method ");
g_string_append (res, s);
break;
case MONO_TYPE_ARRAY:
- ptr = get_type (m, ptr, &s, is_def, context);
+ ptr = get_type (m, ptr, &s, is_def, container);
g_string_append (res, s);
g_free (s);
g_string_append_c (res, ' ');
g_string_append_c (res, ' ');
g_free (s);
}
- ptr = get_type (m, ptr, &s, is_def, context);
+ ptr = get_type (m, ptr, &s, is_def, container);
g_string_append (res, s);
g_string_append (res, "[]");
g_free (s);
break;
default:
- ptr = get_type (m, ptr - 1, &s, is_def, context);
+ ptr = get_type (m, ptr - 1, &s, is_def, container);
g_string_append (res, s);
g_free (s);
break;
* at (dor_token >> 2)
*/
char *
-get_typedef_or_ref (MonoImage *m, guint32 dor_token, MonoGenericContext *context)
+get_typedef_or_ref (MonoImage *m, guint32 dor_token, MonoGenericContainer *container)
{
char *temp = NULL, *s = NULL;
int table, idx;
break;
case 2: /* TypeSpec */
- s = get_typespec (m, idx, FALSE, context);
+ s = get_typespec (m, idx, FALSE, container);
break;
default:
if (i > 0)
g_string_append (result, ",");
+
+ flags = param->flags & GENERIC_PARAMETER_ATTRIBUTE_VARIANCE_MASK;
+ if ((flags & GENERIC_PARAMETER_ATTRIBUTE_COVARIANT) == GENERIC_PARAMETER_ATTRIBUTE_COVARIANT)
+ g_string_append (result, "+ ");
+ if ((flags & GENERIC_PARAMETER_ATTRIBUTE_CONTRAVARIANT) == GENERIC_PARAMETER_ATTRIBUTE_CONTRAVARIANT)
+ g_string_append (result, "- ");
flags = param->flags & GENERIC_PARAMETER_ATTRIBUTE_SPECIAL_CONSTRAINTS_MASK;
if ((flags & GENERIC_PARAMETER_ATTRIBUTE_REFERENCE_TYPE_CONSTRAINT) == GENERIC_PARAMETER_ATTRIBUTE_REFERENCE_TYPE_CONSTRAINT)
char*
dis_stringify_method_signature (MonoImage *m, MonoMethodSignature *method, int methoddef_row,
- MonoGenericContext *context, gboolean fully_qualified)
+ MonoGenericContainer *container, gboolean fully_qualified)
{
- return dis_stringify_method_signature_full (m, method, methoddef_row, context, fully_qualified, TRUE);
+ return dis_stringify_method_signature_full (m, method, methoddef_row, container, fully_qualified, TRUE);
}
/*
*/
char*
dis_stringify_method_signature_full (MonoImage *m, MonoMethodSignature *method, int methoddef_row,
- MonoGenericContext *context, gboolean fully_qualified, gboolean with_marshal_info)
+ MonoGenericContainer *container, gboolean fully_qualified, gboolean with_marshal_info)
{
guint32 cols [MONO_METHOD_SIZE];
guint32 pcols [MONO_PARAM_SIZE];
char *gen_param = NULL;
GString *result = g_string_new ("");
GString *result_ret = g_string_new ("");
- MonoGenericContainer *container = NULL;
int i, start;
g_assert (method || methoddef_row);
if (!method) {
const char *sig = mono_metadata_blob_heap (m, cols [MONO_METHOD_SIGNATURE]);
- container = mono_metadata_load_generic_params (
- m, MONO_TOKEN_METHOD_DEF | methoddef_row, context ? context->container : NULL);
- if (container) {
- mono_metadata_load_generic_param_constraints (
- m, MONO_TOKEN_METHOD_DEF | methoddef_row, container);
- context = (MonoGenericContext *) container;
- }
+ container = mono_metadata_load_generic_params (m, MONO_TOKEN_METHOD_DEF | methoddef_row, container);
+ if (container)
+ mono_metadata_load_generic_param_constraints (m, MONO_TOKEN_METHOD_DEF | methoddef_row, container);
mono_metadata_decode_blob_size (sig, &sig);
method = mono_metadata_parse_method_signature_full (m, container, methoddef_row, sig, &sig);
free_method = 1;
- } else if (context)
- container = context->container;
+ }
if (container && container->is_method)
gen_param = get_generic_param (m, container);
if (c->generic_class) {
MonoGenericClass *gclass = c->generic_class;
+ MonoGenericInst *inst = gclass->context.class_inst;
GString *str = g_string_new ("");
int i;
- for (i = 0; i < gclass->inst->type_argc; i++){
- char *t = dis_stringify_type (m, gclass->inst->type_argv [i], is_def);
+ for (i = 0; i < inst->type_argc; i++){
+ char *t = dis_stringify_type (m, inst->type_argv [i], is_def);
g_string_append (str, t);
- if (i+1 != gclass->inst->type_argc)
+ if (i+1 != inst->type_argc)
g_string_append (str, ", ");
g_free (t);
}
break;
case MONO_TYPE_GENERICINST: {
GString *str = g_string_new ("");
+ MonoGenericInst *inst;
int i;
char *generic_type = dis_stringify_type (
m, &type->data.generic_class->container_class->byval_arg, is_def);
-
- for (i = 0; i < type->data.generic_class->inst->type_argc; i++){
- char *t = dis_stringify_type (m, type->data.generic_class->inst->type_argv [i], is_def);
+ inst = type->data.generic_class->context.class_inst;
+ for (i = 0; i < inst->type_argc; i++){
+ char *t = dis_stringify_type (m, inst->type_argv [i], is_def);
g_string_append (str, t);
- if (i+1 != type->data.generic_class->inst->type_argc)
+ if (i+1 != inst->type_argc)
g_string_append (str, ", ");
g_free (t);
}
* Returns: the new ptr to continue decoding
*/
const char *
-get_type (MonoImage *m, const char *ptr, char **result, gboolean is_def, MonoGenericContext *context)
+get_type (MonoImage *m, const char *ptr, char **result, gboolean is_def, MonoGenericContainer *container)
{
const char *start = ptr;
guint32 type;
int count, i;
char *temp;
- ptr = get_type (m, ptr, &temp, is_def, context);
+ ptr = get_type (m, ptr, &temp, is_def, container);
g_string_append (str, temp);
g_free (temp);
for (i = 0; i < count; i++) {
if (i)
g_string_append (str, ",");
- ptr = get_type (m, ptr, &temp, is_def, context);
+ ptr = get_type (m, ptr, &temp, is_def, container);
g_string_append (str, temp);
}
}
default:
- t = mono_metadata_parse_type_full (m, context ? context->container : NULL, MONO_PARSE_TYPE, 0, start, &ptr);
+ t = mono_metadata_parse_type_full (m, container, MONO_PARSE_TYPE, 0, start, &ptr);
*result = dis_stringify_type (m, t, is_def);
- mono_metadata_free_type (t);
break;
}
* Returns a stringified representation of a FieldSig (22.2.4)
*/
char *
-get_field_signature (MonoImage *m, guint32 blob_signature, MonoGenericContext *context)
+get_field_signature (MonoImage *m, guint32 blob_signature, MonoGenericContainer *container)
{
char *allocated_modifier_string, *allocated_type_string;
const char *ptr = mono_metadata_blob_heap (m, blob_signature);
ptr++; len--;
ptr = get_custom_mod (m, ptr, &allocated_modifier_string);
- ptr = get_type (m, ptr, &allocated_type_string, FALSE, context);
+ ptr = get_type (m, ptr, &allocated_type_string, FALSE, container);
res = g_strdup_printf (
"%s%s",
* Returns: the new ptr to continue decoding.
*/
const char *
-get_ret_type (MonoImage *m, const char *ptr, char **ret_type, MonoGenericContext *context)
+get_ret_type (MonoImage *m, const char *ptr, char **ret_type, MonoGenericContainer *container)
{
GString *str = g_string_new ("");
char *mod = NULL;
ptr++;
}
- ptr = get_type (m, ptr, &allocated_type_string, FALSE, context);
+ ptr = get_type (m, ptr, &allocated_type_string, FALSE, container);
g_string_append (str, allocated_type_string);
if (has_byref)
g_string_append (str, "& ");
* Returns: the new ptr to continue decoding.
*/
const char *
-get_param (MonoImage *m, const char *ptr, char **retval, MonoGenericContext *context)
+get_param (MonoImage *m, const char *ptr, char **retval, MonoGenericContainer *container)
{
GString *str = g_string_new ("");
char *allocated_mod_string, *allocated_type_string;
ptr++;
by_ref = 1;
}
- ptr = get_type (m, ptr, &allocated_type_string, FALSE, context);
+ ptr = get_type (m, ptr, &allocated_type_string, FALSE, container);
g_string_append (str, allocated_type_string);
if (by_ref)
g_string_append_c (str, '&');
for (s = name; *s; s++) {
if (isalnum (*s) || *s == '_' || *s == '$' || *s == '@' ||
- *s == '?' || *s == '.' || *s == 0 || *s == '!' || *s == '`')
+ *s == '?' || (*s == '.' && s != name) || *s == 0 || *s == '!' || *s == '`')
continue;
esc = str_escape (name, "'\\");
* Returns a stringifed representation of a field ref
*/
char *
-get_fieldref_signature (MonoImage *m, int idx, MonoGenericContext *context)
+get_fieldref_signature (MonoImage *m, int idx, MonoGenericContainer *container)
{
guint32 cols [MONO_MEMBERREF_SIZE];
- MonoGenericContext *new_context;
+ MonoGenericContainer *new_container;
char *type, *esname;
char *sig;
char *full_sig;
mono_metadata_decode_row (&m->tables [MONO_TABLE_MEMBERREF],
idx - 1, cols, MONO_MEMBERREF_SIZE);
- new_context = get_memberref_context (m, cols [MONO_MEMBERREF_CLASS], context);
- sig = get_field_signature (m, cols [MONO_MEMBERREF_SIGNATURE], new_context);
+ new_container = get_memberref_container (m, cols [MONO_MEMBERREF_CLASS], container);
+ sig = get_field_signature (m, cols [MONO_MEMBERREF_SIGNATURE], new_container);
- type = get_memberref_parent (m, cols [MONO_MEMBERREF_CLASS], context);
+ type = get_memberref_parent (m, cols [MONO_MEMBERREF_CLASS], container);
esname = get_escaped_name (mono_metadata_string_heap (m, cols [MONO_MEMBERREF_NAME]));
full_sig = g_strdup_printf ("%s %s%s%s",
* the TypeDef table and locate the actual "owner" of the field
*/
char *
-get_field (MonoImage *m, guint32 token, MonoGenericContext *context)
+get_field (MonoImage *m, guint32 token, MonoGenericContainer *container)
{
int idx = mono_metadata_token_index (token);
guint32 cols [MONO_FIELD_SIZE];
* defined in another module/assembly, just like in get_method ()
*/
if (mono_metadata_token_code (token) == MONO_TOKEN_MEMBER_REF) {
- return get_fieldref_signature (m, idx, context);
+ return get_fieldref_signature (m, idx, container);
}
g_assert (mono_metadata_token_code (token) == MONO_TOKEN_FIELD_DEF);
mono_metadata_decode_row (&m->tables [MONO_TABLE_FIELD], idx - 1, cols, MONO_FIELD_SIZE);
- sig = get_field_signature (m, cols [MONO_FIELD_SIGNATURE], context);
+ sig = get_field_signature (m, cols [MONO_FIELD_SIGNATURE], container);
/*
* To locate the actual "container" for this field, we have to scan
return res;
}
-static MonoGenericContext *
-get_memberref_context (MonoImage *m, guint32 mrp_token, MonoGenericContext *context)
+static MonoGenericContainer *
+get_memberref_container (MonoImage *m, guint32 mrp_token, MonoGenericContainer *container)
{
MonoClass *klass;
switch (table){
case 0: /* TypeDef */
- return (MonoGenericContext *) mono_metadata_load_generic_params (
- m, MONO_TOKEN_TYPE_DEF | idx, NULL);
+ return mono_metadata_load_generic_params (m, MONO_TOKEN_TYPE_DEF | idx, NULL);
case 1: /* TypeRef */
return NULL;
case 4: /* TypeSpec */
- klass = mono_class_get_full (m, MONO_TOKEN_TYPE_SPEC | idx, context);
+ klass = mono_class_get_full (m, MONO_TOKEN_TYPE_SPEC | idx, (MonoGenericContext *) container);
g_assert (klass);
- return klass->generic_class ? klass->generic_class->context : NULL;
+ return klass->generic_class ? klass->generic_class->container_class->generic_container : NULL;
}
g_assert_not_reached ();
return NULL;
}
static char *
-get_memberref_parent (MonoImage *m, guint32 mrp_token, MonoGenericContext *context)
+get_memberref_parent (MonoImage *m, guint32 mrp_token, MonoGenericContainer *container)
{
/*
* mrp_index is a MemberRefParent coded index
return g_strdup ("TODO:MethodDef");
case 4: /* TypeSpec */
- return get_typespec (m, idx, FALSE, context);
+ return get_typespec (m, idx, FALSE, container);
}
g_assert_not_reached ();
return NULL;
* the TypeDef table and locate the actual "owner" of the field
*/
static char *
-get_method_core (MonoImage *m, guint32 token, gboolean fullsig, MonoGenericContext *context)
+get_method_core (MonoImage *m, guint32 token, gboolean fullsig, MonoGenericContainer *container)
{
int idx = mono_metadata_token_index (token);
guint32 member_cols [MONO_MEMBERREF_SIZE], method_cols [MONO_METHOD_SIZE];
char *name;
MonoMethod *mh;
- MonoGenericContext *gc = context;
+ MonoGenericContainer *type_container = container;
- mh = mono_get_method_full (m, token, NULL, context);
+ mh = mono_get_method_full (m, token, NULL, (MonoGenericContext *) container);
if (mh) {
- mh = mono_get_inflated_method (mh);
if (mono_method_signature (mh)->is_inflated)
- context = ((MonoMethodInflated *) mh)->context;
+ container = mono_method_get_generic_container (((MonoMethodInflated *) mh)->declaring);
esname = get_escaped_name (mh->name);
sig = dis_stringify_type (m, &mh->klass->byval_arg, TRUE);
if (show_tokens)
mono_metadata_decode_row (&m->tables [MONO_TABLE_MEMBERREF],
idx - 1, member_cols, MONO_MEMBERREF_SIZE);
if (!name) {
- char *parent = get_memberref_parent (m, member_cols [MONO_MEMBERREF_CLASS], context),
+ char *parent = get_memberref_parent (m, member_cols [MONO_MEMBERREF_CLASS], container);
name = g_strdup_printf ("%s%s%s",
parent ? parent : "",
parent ? "::" : "",
if (mh) {
int arity = 0;
- if (mh->generic_container)
- arity = mh->generic_container->type_argc;
+ if (mh->is_generic)
+ arity = mono_method_get_generic_container (mh)->type_argc;
else
- if (mh->is_inflated && ((MonoMethodInflated *)mh)->declaring->generic_container)
- arity = ((MonoMethodInflated*) mh)->declaring->generic_container->type_argc;
+ if (mh->is_inflated && ((MonoMethodInflated *)mh)->declaring->is_generic)
+ arity = mono_method_get_generic_container (((MonoMethodInflated*) mh)->declaring)->type_argc;
if (arity > 0) {
char *str = g_strdup_printf ("%s <[%d]>", name, arity);
mono_metadata_decode_row (&m->tables [MONO_TABLE_METHODSPEC],
idx - 1, member_cols, MONO_METHODSPEC_SIZE);
token = member_cols [MONO_METHODSPEC_METHOD];
- sig = get_methodspec (m, idx, token, name, gc);
+ sig = get_methodspec (m, idx, token, name, type_container);
break;
}
}
char *
-get_method (MonoImage *m, guint32 token, MonoGenericContext *context)
+get_method (MonoImage *m, guint32 token, MonoGenericContainer *container)
{
- return get_method_core (m, token, TRUE, context);
+ return get_method_core (m, token, TRUE, container);
}
/**
}
char *
-get_method_type_param (MonoImage *m, guint32 blob_signature, MonoGenericContext *context)
+get_method_type_param (MonoImage *m, guint32 blob_signature, MonoGenericContainer *container)
{
GString *res = g_string_new ("");
const char *ptr = mono_metadata_blob_heap (m, blob_signature);
for (i = 0; i < param_count; i++){
char *param = NULL;
- ptr = get_param (m, ptr, ¶m, context);
+ ptr = get_param (m, ptr, ¶m, container);
g_string_append (res, param);
if (i+1 != param_count)
g_string_append (res, ", ");
*/
char *
-get_methodspec (MonoImage *m, int idx, guint32 token, const char *fancy_name, MonoGenericContext *context)
+get_methodspec (MonoImage *m, int idx, guint32 token, const char *fancy_name, MonoGenericContainer *type_container)
{
GString *res = g_string_new ("");
guint32 member_cols [MONO_MEMBERREF_SIZE], method_cols [MONO_METHOD_SIZE];
const char *ptr;
guint32 sig = 0;
int param_count, cconv, i, gen_count = 0;
- MonoGenericContainer *container = NULL;
- MonoGenericContext *parent_context = context;
+ MonoGenericContainer *container;
MonoMethod *mh = NULL;
switch (token & MONO_METHODDEFORREF_MASK) {
ptr = mono_metadata_blob_heap (m, sig);
mono_metadata_decode_value (ptr, &ptr);
- mh = mono_get_method_full (m, method_dor_to_token (token), NULL, parent_context);
+ mh = mono_get_method_full (m, method_dor_to_token (token), NULL, (MonoGenericContext *) type_container);
g_assert (mh);
- if ((container = mh->generic_container))
- context = (MonoGenericContext*) container;
+ container = mono_method_get_generic_container (mh);
+ if (!container)
+ container = type_container;
if (*ptr & 0x20){
if (*ptr & 0x40)
param_count = mono_metadata_decode_value (ptr, &ptr);
if (cconv != 0xa) {
char *allocated_ret_type;
- ptr = get_ret_type (m, ptr, &allocated_ret_type, context);
+ ptr = get_ret_type (m, ptr, &allocated_ret_type, container);
g_string_append (res, allocated_ret_type);
g_free (allocated_ret_type);
}
mono_metadata_decode_row (&m->tables [MONO_TABLE_METHODSPEC],
idx - 1, member_cols, MONO_METHODSPEC_SIZE);
token = member_cols [MONO_METHODSPEC_SIGNATURE];
- type_param = get_method_type_param (m, token, parent_context);
+ type_param = get_method_type_param (m, token, type_container);
g_string_append (res, type_param);
g_string_append (res, " (");
for (i = 0; i < param_count; i++){
char *param = NULL;
- ptr = get_param (m, ptr, ¶m, context);
+ ptr = get_param (m, ptr, ¶m, container);
g_string_append (res, param);
if (i+1 != param_count)
g_string_append (res, ", ");
char*
get_encoded_user_string_or_bytearray (const unsigned char *ptr, int len)
{
- unsigned char *res, *eres, *result;
+ char *res, *eres, *result;
int i;
res = g_malloc ((len >> 1) + 1);
char *
get_constant (MonoImage *m, MonoTypeEnum t, guint32 blob_index)
{
- const unsigned char *ptr = mono_metadata_blob_heap (m, blob_index);
+ const char *ptr = mono_metadata_blob_heap (m, blob_index);
int len;
- len = mono_metadata_decode_value (ptr, (const char**)&ptr);
+ len = mono_metadata_decode_value (ptr, &ptr);
switch (t){
case MONO_TYPE_BOOLEAN:
case MONO_TYPE_U1:
case MONO_TYPE_I1:
- return g_strdup_printf ("int8(0x%02x)", (int) (*ptr));
+ return g_strdup_printf ("int8(0x%02x)", (int) ((*ptr) & 0xFF));
break;
case MONO_TYPE_U2:
}
}
case MONO_TYPE_STRING:
- return get_encoded_user_string_or_bytearray (ptr, len);
+ return get_encoded_user_string_or_bytearray ((const guchar*)ptr, len);
case MONO_TYPE_CLASS:
return g_strdup ("nullref");
* constant.
*/
char *
-get_token (MonoImage *m, guint32 token, MonoGenericContext *context)
+get_token (MonoImage *m, guint32 token, MonoGenericContainer *container)
{
char *temp, *result;
guint32 idx = mono_metadata_token_index (token);
switch (mono_metadata_token_code (token)){
case MONO_TOKEN_FIELD_DEF:
- temp = get_field (m, token, context);
+ temp = get_field (m, token, container);
result = g_strdup_printf ("field %s", temp);
g_free (temp);
return result;
+ case MONO_TOKEN_METHOD_DEF:
+ temp = get_method (m, token, container);
+ result = g_strdup_printf ("method %s", temp);
+ g_free (temp);
+ return result;
case MONO_TOKEN_TYPE_DEF:
temp = get_typedef (m, idx);
result = get_escaped_name (temp);
case MONO_TOKEN_TYPE_REF:
return get_typeref (m, idx);
case MONO_TOKEN_TYPE_SPEC:
- return get_typespec (m, idx, TRUE, context);
+ return get_typespec (m, idx, TRUE, container);
case MONO_TOKEN_MEMBER_REF: {
guint32 cols [MONO_MEMBERREF_SIZE];
const char *sig;
sig = mono_metadata_blob_heap (m, cols [MONO_MEMBERREF_SIGNATURE]);
mono_metadata_decode_blob_size (sig, &sig);
if (*sig == 0x6) { /* it's a field */
- temp = get_field (m, token, context);
+ temp = get_field (m, token, container);
result = g_strdup_printf ("field %s", temp);
g_free (temp);
return result;
} else {
- temp = get_method (m, token, context);
+ temp = get_method (m, token, container);
result = g_strdup_printf ("method %s", temp);
g_free (temp);
return result;
* at (token & 0xffffff)
*/
char *
-get_token_type (MonoImage *m, guint32 token, MonoGenericContext *context)
+get_token_type (MonoImage *m, guint32 token, MonoGenericContainer *container)
{
char *temp = NULL, *s = NULL;
int idx;
break;
case MONO_TOKEN_TYPE_SPEC:
- s = get_typespec (m, idx, FALSE, context);
+ s = get_typespec (m, idx, FALSE, container);
break;
default:
const unsigned char *guid;
char *result;
- guid = mono_metadata_guid_heap (m, guid_index);
+ guid = (const guchar*)mono_metadata_guid_heap (m, guid_index);
result = g_strdup_printf ("{%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
guid [3], guid [2], guid [1], guid [0], guid [5], guid [4], guid [7], guid [6],
}
char *
-get_method_override (MonoImage *m, guint32 token, MonoGenericContext *context)
+get_method_override (MonoImage *m, guint32 token, MonoGenericContainer *container)
{
MonoTableInfo *t = &m->tables [MONO_TABLE_METHODIMPL];
int i;
if (token == impl) {
MonoMethod *mh = NULL;
- mh = mono_get_method_full (m, decl, NULL, context);
- mh = mono_get_inflated_method (mh);
+ mh = mono_get_method_full (m, decl, NULL, (MonoGenericContext *) container);
if (mh && (mh->klass && (mh->klass->generic_class || mh->klass->generic_container))) {
char *meth_str;
char *ret;
- meth_str = get_method_core (m, decl, TRUE, context);
+ meth_str = get_method_core (m, decl, TRUE, container);
ret = g_strdup_printf ("method %s", meth_str);
g_free (meth_str);
return ret;
} else {
- return get_method_core (m, decl, FALSE, context);
+ return get_method_core (m, decl, FALSE, container);
}
}
}
projects / mono.git / blobdiff