X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Fmetadata.c;h=b8f76940171b07b4a0c2abf43bda820ed8ea7718;hb=b8e5e458a9cb96685f8ad8f02fc012bcdf4a4cc4;hp=5454e67c8695a2a454dd149a925e64296a72a459;hpb=195d22172cd0e2e96fa000cfa384e0df9b2b3070;p=mono.git diff --git a/mono/metadata/metadata.c b/mono/metadata/metadata.c index 5454e67c869..b8f76940171 100644 --- a/mono/metadata/metadata.c +++ b/mono/metadata/metadata.c @@ -366,6 +366,18 @@ inverse of this mapping. #define idx_size(tableidx) (meta->tables [(tableidx)].rows < 65536 ? 2 : 4) /* Reference: Partition II - 23.2.6 */ +/* + * mono_metadata_compute_size: + * @meta: metadata context + * @tableindex: metadata table number + * @result_bitfield: pointer to guint32 where to store additional info + * + * mono_metadata_compute_size() computes the lenght in bytes of a single + * row in a metadata table. The size of each column is encoded in the + * @result_bitfield return value along with the number of columns in the table. + * the resulting bitfield should be handed to the mono_metadata_table_size() + * and mono_metadata_table_count() macros. + */ int mono_metadata_compute_size (MonoImage *meta, int tableindex, guint32 *result_bitfield) { @@ -669,7 +681,7 @@ void mono_metadata_compute_table_bases (MonoImage *meta) { int i; - char *base = meta->tables_base; + const char *base = meta->tables_base; for (i = 0; i < 64; i++){ if (meta->tables [i].rows == 0) @@ -691,7 +703,7 @@ mono_metadata_compute_table_bases (MonoImage *meta) * Returns a pointer to the @idx element in the metadata table * whose code is @table. */ -char * +const char * mono_metadata_locate (MonoImage *meta, int table, int idx) { /* idx == 0 refers always to NULL */ @@ -700,7 +712,15 @@ mono_metadata_locate (MonoImage *meta, int table, int idx) return meta->tables [table].base + (meta->tables [table].row_size * (idx - 1)); } -char * +/** + * mono_metadata_locate_token: + * @meta: metadata context + * @token: metadata token + * + * Returns a pointer to the data in the metadata represented by the + * token #token. + */ +const char * mono_metadata_locate_token (MonoImage *meta, guint32 token) { return mono_metadata_locate (meta, token >> 24, token & 0xffffff); @@ -733,14 +753,21 @@ const char * mono_metadata_string_heap (MonoImage *meta, guint32 index) { g_return_val_if_fail (index < meta->heap_strings.size, ""); - return meta->raw_metadata + meta->heap_strings.offset + index; + return meta->heap_strings.data + index; } +/** + * mono_metadata_user_string: + * @meta: metadata context + * @index: index into the user string heap. + * + * Returns: an in-memory pointer to the @index in the user string heap ("#US"). + */ const char * mono_metadata_user_string (MonoImage *meta, guint32 index) { g_return_val_if_fail (index < meta->heap_us.size, ""); - return meta->raw_metadata + meta->heap_us.offset + index; + return meta->heap_us.data + index; } /** @@ -754,7 +781,23 @@ const char * mono_metadata_blob_heap (MonoImage *meta, guint32 index) { g_return_val_if_fail (index < meta->heap_blob.size, ""); - return meta->raw_metadata + meta->heap_blob.offset + index; + return meta->heap_blob.data + index; +} + +/** + * mono_metadata_guid_heap: + * @meta: metadata context + * @index: index into the guid heap. + * + * Returns: an in-memory pointer to the @index in the guid heap. + */ +const char * +mono_metadata_guid_heap (MonoImage *meta, guint32 index) +{ + --index; + index *= 16; /* adjust for guid size and 1-based index */ + g_return_val_if_fail (index < meta->heap_guid.size, ""); + return meta->heap_guid.data + index; } static const char * @@ -777,7 +820,7 @@ mono_metadata_decode_row (MonoTableInfo *t, int idx, guint32 *res, int res_size) { guint32 bitfield = t->size_bitfield; int i, count = mono_metadata_table_count (bitfield); - char *data = t->base + idx * t->row_size; + const char *data = t->base + idx * t->row_size; g_assert (res_size == count); @@ -814,7 +857,7 @@ mono_metadata_decode_row_col (MonoTableInfo *t, int idx, guint col) { guint32 bitfield = t->size_bitfield; int i; - register char *data = t->base + idx * t->row_size; + register const char *data = t->base + idx * t->row_size; register int n; g_assert (col < mono_metadata_table_count (bitfield)); @@ -883,7 +926,7 @@ mono_metadata_decode_blob_size (const char *xptr, const char **rptr) guint32 mono_metadata_decode_value (const char *_ptr, const char **rptr) { - const unsigned char *ptr = (unsigned char *) _ptr; + const unsigned char *ptr = (const unsigned char *) _ptr; unsigned char b = *ptr; guint32 len; @@ -906,6 +949,15 @@ mono_metadata_decode_value (const char *_ptr, const char **rptr) return len; } +/* + * mono_metadata_parse_typedef_or_ref: + * @m: a metadata context. + * @ptr: a pointer to an encoded TypedefOrRef in @m + * @rptr: pointer updated to match the end of the decoded stream + * + * Returns: a token valid in the @m metadata decoded from + * the compressed representation. + */ guint32 mono_metadata_parse_typedef_or_ref (MonoImage *m, const char *ptr, const char **rptr) { @@ -916,6 +968,17 @@ mono_metadata_parse_typedef_or_ref (MonoImage *m, const char *ptr, const char ** return mono_metadata_token_from_dor (token); } +/* + * mono_metadata_parse_custom_mod: + * @m: a metadata context. + * @dest: storage where the info about the custom modifier is stored (may be NULL) + * @ptr: a pointer to (possibly) the start of a custom modifier list + * @rptr: pointer updated to match the end of the decoded stream + * + * Checks if @ptr points to a type custom modifier compressed representation. + * + * Returns: #TRUE if a custom modifier was found, #FALSE if not. + */ int mono_metadata_parse_custom_mod (MonoImage *m, MonoCustomMod *dest, const char *ptr, const char **rptr) { @@ -931,6 +994,17 @@ mono_metadata_parse_custom_mod (MonoImage *m, MonoCustomMod *dest, const char *p return FALSE; } +/* + * mono_metadata_parse_array: + * @m: a metadata context. + * @ptr: a pointer to an encoded array description. + * @rptr: pointer updated to match the end of the decoded stream + * + * Decodes the compressed array description found in the metadata @m at @ptr. + * + * Returns: a #MonoArrayType structure describing the array type + * and dimensions. + */ MonoArrayType * mono_metadata_parse_array (MonoImage *m, const char *ptr, const char **rptr) { @@ -957,6 +1031,12 @@ mono_metadata_parse_array (MonoImage *m, const char *ptr, const char **rptr) return array; } +/* + * mono_metadata_free_array: + * @array: array description + * + * Frees the array description returned from mono_metadata_parse_array(). + */ void mono_metadata_free_array (MonoArrayType *array) { @@ -1024,15 +1104,15 @@ static GHashTable *type_cache = NULL; static guint mono_type_hash (gconstpointer data) { - MonoType *type = (MonoType *) data; + const MonoType *type = (const MonoType *) data; return type->type | (type->byref << 8) | (type->attrs << 9); } static gint mono_type_equal (gconstpointer ka, gconstpointer kb) { - MonoType *a = (MonoType *) ka; - MonoType *b = (MonoType *) kb; + const MonoType *a = (const MonoType *) ka; + const MonoType *b = (const MonoType *) kb; if (a->type != b->type || a->byref != b->byref || a->attrs != b->attrs || a->pinned != b->pinned) return 0; @@ -1040,6 +1120,22 @@ mono_type_equal (gconstpointer ka, gconstpointer kb) return 1; } +/* + * mono_metadata_parse_type: + * @m: metadata context + * @mode: king of type that may be found at @ptr + * @opt_attrs: optional attributes to store in the returned type + * @ptr: pointer to the type representation + * @rptr: pointer updated to match the end of the decoded stream + * + * Decode a compressed type description found at @ptr in @m. + * @mode can be one of MONO_PARSE_MOD_TYPE, MONO_PARSE_PARAM, MONO_PARSE_RET, + * MONO_PARSE_FIELD, MONO_PARSE_LOCAL, MONO_PARSE_TYPE. + * This function can be used to decode type descriptions in method signatures, + * field signatures, locals signatures etc. + * + * Returns: a #MonoType structure representing the decoded type. + */ MonoType* mono_metadata_parse_type (MonoImage *m, MonoParseTypeMode mode, short opt_attrs, const char *ptr, const char **rptr) { @@ -1120,6 +1216,17 @@ mono_metadata_parse_type (MonoImage *m, MonoParseTypeMode mode, short opt_attrs, } } +/* + * mono_metadata_parse_method_signature: + * @m: metadata context + * @def: use #TRUE when parsing MethodDef, #FALSE with MethodRef signatures. + * @ptr: pointer to the signature metadata representation + * @rptr: pointer updated to match the end of the decoded stream + * + * Decode a method signature stored at @ptr. + * + * Returns: a MonoMethodSignature describing the signature. + */ MonoMethodSignature * mono_metadata_parse_method_signature (MonoImage *m, int def, const char *ptr, const char **rptr) { @@ -1164,15 +1271,21 @@ mono_metadata_parse_method_signature (MonoImage *m, int def, const char *ptr, co return method; } +/* + * mono_metadata_free_method_signature: + * @sig: signature to destroy + * + * Free the memory allocated in the signature @sig. + */ void -mono_metadata_free_method_signature (MonoMethodSignature *method) +mono_metadata_free_method_signature (MonoMethodSignature *sig) { int i; - mono_metadata_free_type (method->ret); - for (i = 0; i < method->param_count; ++i) - mono_metadata_free_type (method->params [i]); + mono_metadata_free_type (sig->ret); + for (i = 0; i < sig->param_count; ++i) + mono_metadata_free_type (sig->params [i]); - g_free (method); + g_free (sig); } /* @@ -1239,28 +1352,12 @@ do_mono_metadata_parse_type (MonoType *type, MonoImage *m, const char *ptr, cons *rptr = ptr; } -#if 0 -/** - * mono_metadata_parse_type: - * @m: metadata context to scan - * @ptr: pointer to encoded Type stream. - * @rptr: the new position in the stream after parsing the type +/* + * mono_metadata_free_type: + * @type: type to free * - * Returns: A MonoType structure that has the parsed information - * from the type stored at @ptr in the metadata table @m. + * Free the memory allocated for type @type. */ -MonoType * -mono_metadata_parse_type (MonoImage *m, const char *ptr, const char **rptr) -{ - /* should probably be allocated in a memchunk */ - MonoType *type = g_new0(MonoType, 1); - - do_mono_metadata_parse_type (type, m, ptr, rptr); - - return type; -} -#endif - void mono_metadata_free_type (MonoType *type) { @@ -1281,6 +1378,7 @@ mono_metadata_free_type (MonoType *type) g_free (type); } +#if 0 static void hex_dump (const char *buffer, int base, int count) { @@ -1301,6 +1399,7 @@ hex_dump (const char *buffer, int base, int count) } fflush (stdout); } +#endif /** * @mh: The Method header @@ -1385,11 +1484,21 @@ parse_section_data (MonoMethodHeader *mh, const unsigned char *ptr) } } +/* + * mono_metadata_parse_mh: + * @m: metadata context + * @ptr: pointer to the method header. + * + * Decode the method header at @ptr, including pointer to the IL code, + * info about local variables and optional exception tables. + * + * Returns: a MonoMethodHeader. + */ MonoMethodHeader * mono_metadata_parse_mh (MonoImage *m, const char *ptr) { MonoMethodHeader *mh; - unsigned char flags = *(unsigned char *) ptr; + unsigned char flags = *(const unsigned char *) ptr; unsigned char format = flags & METHOD_HEADER_FORMAT_MASK; guint16 fat_flags; guint32 local_var_sig_tok, max_stack, code_size, init_locals; @@ -1454,21 +1563,21 @@ mono_metadata_parse_mh (MonoImage *m, const char *ptr) if (local_var_sig_tok) { MonoTableInfo *t = &m->tables [MONO_TABLE_STANDALONESIG]; - const char *ptr; + const char *locals_ptr; guint32 cols [MONO_STAND_ALONE_SIGNATURE_SIZE]; int len=0, i, bsize; mono_metadata_decode_row (t, (local_var_sig_tok & 0xffffff)-1, cols, 1); - ptr = mono_metadata_blob_heap (m, cols [MONO_STAND_ALONE_SIGNATURE]); - bsize = mono_metadata_decode_blob_size (ptr, &ptr); - if (*ptr != 0x07) + locals_ptr = mono_metadata_blob_heap (m, cols [MONO_STAND_ALONE_SIGNATURE]); + bsize = mono_metadata_decode_blob_size (locals_ptr, &locals_ptr); + if (*locals_ptr != 0x07) g_warning ("wrong signature for locals blob"); - ptr++; - len = mono_metadata_decode_value (ptr, &ptr); + locals_ptr++; + len = mono_metadata_decode_value (locals_ptr, &locals_ptr); mh = g_malloc0 (sizeof (MonoMethodHeader) + (len - MONO_ZERO_LEN_ARRAY) * sizeof (MonoType*)); mh->num_locals = len; for (i = 0; i < len; ++i) - mh->locals [i] = mono_metadata_parse_type (m, MONO_PARSE_LOCAL, 0, ptr, &ptr); + mh->locals [i] = mono_metadata_parse_type (m, MONO_PARSE_LOCAL, 0, locals_ptr, &locals_ptr); } else { mh = g_new0 (MonoMethodHeader, 1); } @@ -1481,6 +1590,12 @@ mono_metadata_parse_mh (MonoImage *m, const char *ptr) return mh; } +/* + * mono_metadata_free_mh: + * @mh: a method header + * + * Free the memory allocated for the method header. + */ void mono_metadata_free_mh (MonoMethodHeader *mh) { @@ -1495,6 +1610,7 @@ mono_metadata_free_mh (MonoMethodHeader *mh) * mono_metadata_parse_field_type: * @m: metadata context to extract information from * @ptr: pointer to the field signature + * @rptr: pointer updated to match the end of the decoded stream * * Parses the field signature, and returns the type information for it. * @@ -1506,6 +1622,16 @@ mono_metadata_parse_field_type (MonoImage *m, short field_flags, const char *ptr return mono_metadata_parse_type (m, MONO_PARSE_FIELD, field_flags, ptr, rptr); } +/** + * mono_metadata_parse_param: + * @m: metadata context to extract information from + * @ptr: pointer to the param signature + * @rptr: pointer updated to match the end of the decoded stream + * + * Parses the param signature, and returns the type information for it. + * + * Returns: The MonoType that was extracted from @ptr. + */ MonoType * mono_metadata_parse_param (MonoImage *m, const char *ptr, const char **rptr) { @@ -1595,7 +1721,7 @@ static int typedef_locator (const void *a, const void *b) { locator_t *loc = (locator_t *) a; - char *bb = (char *) b; + const char *bb = (const char *) b; int typedef_index = (bb - loc->t->base) / loc->t->row_size; guint32 col, col_next; @@ -1625,7 +1751,7 @@ static int table_locator (const void *a, const void *b) { locator_t *loc = (locator_t *) a; - char *bb = (char *) b; + const char *bb = (const char *) b; guint32 table_index = (bb - loc->t->base) / loc->t->row_size; guint32 col; @@ -1641,6 +1767,15 @@ table_locator (const void *a, const void *b) return 1; } +/* + * mono_metadata_typedef_from_field: + * @meta: metadata context + * @index: FieldDef token + * + * Returns the 1-based index into the TypeDef table of the type that + * declared the field described by @index. + * Returns 0 if not found. + */ guint32 mono_metadata_typedef_from_field (MonoImage *meta, guint32 index) { @@ -1661,6 +1796,15 @@ mono_metadata_typedef_from_field (MonoImage *meta, guint32 index) return loc.result + 1; } +/* + * mono_metadata_typedef_from_method: + * @meta: metadata context + * @index: MethodDef token + * + * Returns the 1-based index into the TypeDef table of the type that + * declared the method described by @index. + * Returns 0 if not found. + */ guint32 mono_metadata_typedef_from_method (MonoImage *meta, guint32 index) { @@ -1681,6 +1825,14 @@ mono_metadata_typedef_from_method (MonoImage *meta, guint32 index) return loc.result + 1; } +/* + * mono_metadata_interfaces_from_typedef: + * @meta: metadata context + * @index: typedef token + * + * Returns and array of interfaces that the @index typedef token implements. + * The number of elemnts in the array is returned in @count. + */ MonoClass** mono_metadata_interfaces_from_typedef (MonoImage *meta, guint32 index, guint *count) { @@ -1727,8 +1879,13 @@ mono_metadata_interfaces_from_typedef (MonoImage *meta, guint32 index, guint *co } /* - * Return the typedef token of the type index is defined into. - * Return 0 if the index represents a toplevel type. + * mono_metadata_nested_in_typedef: + * @meta: metadata context + * @index: typedef token + * + * Returns: the 1-based index into the TypeDef table of the type + * where the type described by @index is nested. + * Retruns 0 if @index describes a non-nested type. */ guint32 mono_metadata_nested_in_typedef (MonoImage *meta, guint32 index) @@ -1750,6 +1907,15 @@ mono_metadata_nested_in_typedef (MonoImage *meta, guint32 index) return mono_metadata_decode_row_col (tdef, loc.result, MONO_NESTED_CLASS_ENCLOSING) | MONO_TOKEN_TYPE_DEF; } +/* + * mono_metadata_nesting_typedef: + * @meta: metadata context + * @index: typedef token + * + * Returns: the 1-based index into the TypeDef table of the first type + * that is nested inside the type described by @index. + * Retruns 0 if @index doesn't have nested types. + */ guint32 mono_metadata_nesting_typedef (MonoImage *meta, guint32 index) { @@ -1781,7 +1947,12 @@ mono_metadata_nesting_typedef (MonoImage *meta, guint32 index) } /* - * Return the info stored in the ClassLAyout table for the given typedef token. + * mono_metadata_packing_from_typedef: + * @meta: metadata context + * @index: token representing a type + * + * Returns the info stored in the ClassLAyout table for the given typedef token + * into the @packing and @size pointers. * Returns 0 if the info is not found. */ guint32 @@ -1887,6 +2058,9 @@ mono_type_size (MonoType *t, gint *align) case MONO_TYPE_VALUETYPE: { guint32 size; + if (!t->data.klass->size_inited) + mono_class_init (t->data.klass); + if (t->data.klass->enumtype) { return mono_type_size (t->data.klass->enum_basetype, align); } else { @@ -1974,6 +2148,38 @@ mono_type_stack_size (MonoType *t, gint *align) return 0; } +/* + * mono_metadata_type_hash: + * @t1: a type + * + * Computes an hash value for @t1 to be used in GHashTable. + */ +guint +mono_metadata_type_hash (MonoType *t1) +{ + guint hash = t1->type; + + hash |= t1->byref << 6; /* do not collide with t1->type values */ + switch (t1->type) { + case MONO_TYPE_VALUETYPE: + case MONO_TYPE_CLASS: + /* check if the distribution is good enough */ + return hash << 7 | g_str_hash (t1->data.klass->name); + case MONO_TYPE_PTR: + case MONO_TYPE_SZARRAY: + return hash << 7 | mono_metadata_type_hash (t1->data.type); + } + return hash; +} + +/* + * mono_metadata_type_equal: + * @t1: a type + * @t2: another type + * + * Determine if @t1 and @t2 represent the same type. + * Returns: #TRUE if @t1 and @t2 are equal. + */ gboolean mono_metadata_type_equal (MonoType *t1, MonoType *t2) { @@ -2003,8 +2209,13 @@ mono_metadata_type_equal (MonoType *t1, MonoType *t2) case MONO_TYPE_VALUETYPE: case MONO_TYPE_CLASS: return t1->data.klass == t2->data.klass; + case MONO_TYPE_PTR: case MONO_TYPE_SZARRAY: return mono_metadata_type_equal (t1->data.type, t2->data.type); + case MONO_TYPE_ARRAY: + if (t1->data.array->rank != t2->data.array->rank) + return FALSE; + return mono_metadata_type_equal (t1->data.array->type, t2->data.array->type); default: g_error ("implement type compare for %0x!", t1->type); return FALSE; @@ -2013,6 +2224,15 @@ mono_metadata_type_equal (MonoType *t1, MonoType *t2) return FALSE; } +/* + * mono_metadata_signature_equal: + * @sig1: a signature + * @sig2: another signature + * + * Determine if @sig1 and @sig2 represent the same signature, with the + * same number of arguments and the same types. + * Returns: #TRUE if @sig1 and @sig2 are equal. + */ gboolean mono_metadata_signature_equal (MonoMethodSignature *sig1, MonoMethodSignature *sig2) { @@ -2033,9 +2253,21 @@ mono_metadata_signature_equal (MonoMethodSignature *sig1, MonoMethodSignature *s return FALSE; } + if (!mono_metadata_type_equal (sig1->ret, sig2->ret)) + return FALSE; return TRUE; } +/* + * mono_metadata_encode_value: + * @value: value to encode + * @buf: buffer where to write the compressed representation + * @endbuf: pointer updated to point at the end of the encoded output + * + * Encodes the value @value in the compressed representation used + * in metadata and stores the result in @buf. @buf needs to be big + * enough to hold the data (4 bytes). + */ void mono_metadata_encode_value (guint32 value, char *buf, char **endbuf) { @@ -2064,7 +2296,7 @@ mono_metadata_encode_value (guint32 value, char *buf, char **endbuf) * @index: the index in the field table representing the field * @offset: a pointer to an integer where to store the offset that * may have been specified for the field in a FieldLayout table - * @rva: a pointer to the address of the field data in the image that + * @rva: a pointer to the RVA of the field data in the image that * may have been defined in a FieldRVA table * @marshal_info: a pointer to the marshal signature that may have been * defined for the field in a FieldMarshal table. @@ -2075,7 +2307,7 @@ mono_metadata_encode_value (guint32 value, char *buf, char **endbuf) * in the data. */ void -mono_metadata_field_info (MonoImage *meta, guint32 index, guint32 *offset, const char **rva, const char **marshal_info) +mono_metadata_field_info (MonoImage *meta, guint32 index, guint32 *offset, guint32 *rva, const char **marshal_info) { MonoTableInfo *tdef; locator_t loc; @@ -2103,9 +2335,9 @@ mono_metadata_field_info (MonoImage *meta, guint32 index, guint32 *offset, const /* * LAMESPEC: There is no signature, no nothing, just the raw data. */ - *rva = mono_cli_rva_map (meta->image_info, mono_metadata_decode_row_col (tdef, loc.result, MONO_FIELD_RVA_RVA)); + *rva = mono_metadata_decode_row_col (tdef, loc.result, MONO_FIELD_RVA_RVA); } else { - *rva = NULL; + *rva = 0; } } @@ -2153,6 +2385,103 @@ mono_metadata_get_constant_index (MonoImage *meta, guint32 token) return 0; } +/* + * mono_metadata_events_from_typedef: + * @meta: metadata context + * @index: 0-based index (in the TypeDef table) describing a type + * + * Returns: the 0-based index in the Event table for the events in the + * type. The last event that belongs to the type (plus 1) is stored + * in the @end_idx pointer. + */ +guint32 +mono_metadata_events_from_typedef (MonoImage *meta, guint32 index, guint *end_idx) +{ + locator_t loc; + guint32 start, end; + MonoTableInfo *tdef = &meta->tables [MONO_TABLE_EVENTMAP]; + + *end_idx = 0; + + if (!tdef->base) + return 0; + + loc.t = tdef; + loc.col_idx = MONO_EVENT_MAP_PARENT; + loc.idx = index + 1; + + if (!bsearch (&loc, tdef->base, tdef->rows, tdef->row_size, table_locator)) + return 0; + + start = mono_metadata_decode_row_col (tdef, loc.result, MONO_EVENT_MAP_EVENTLIST); + if (loc.result + 1 < tdef->rows) { + end = mono_metadata_decode_row_col (tdef, loc.result + 1, MONO_EVENT_MAP_EVENTLIST) - 1; + } else { + end = meta->tables [MONO_TABLE_EVENT].rows; + } + + *end_idx = end; + return start - 1; +} + +/* + * mono_metadata_methods_from_event: + * @meta: metadata context + * @index: 0-based index (in the Event table) describing a event + * + * Returns: the 0-based index in the MethodDef table for the methods in the + * event. The last method that belongs to the event (plus 1) is stored + * in the @end_idx pointer. + */ +guint32 +mono_metadata_methods_from_event (MonoImage *meta, guint32 index, guint *end_idx) +{ + locator_t loc; + guint start, end; + guint32 cols [MONO_METHOD_SEMA_SIZE]; + MonoTableInfo *msemt = &meta->tables [MONO_TABLE_METHODSEMANTICS]; + + *end_idx = 0; + if (!msemt->base) + return 0; + + loc.t = msemt; + loc.col_idx = MONO_METHOD_SEMA_ASSOCIATION; + loc.idx = ((index + 1) << HAS_SEMANTICS_BITS) | HAS_SEMANTICS_EVENT; /* Method association coded index */ + + if (!bsearch (&loc, msemt->base, msemt->rows, msemt->row_size, table_locator)) + return 0; + + start = loc.result; + /* + * We may end up in the middle of the rows... + */ + while (start > 0) { + if (loc.idx == mono_metadata_decode_row_col (msemt, start - 1, MONO_METHOD_SEMA_ASSOCIATION)) + start--; + else + break; + } + end = start + 1; + while (end < msemt->rows) { + mono_metadata_decode_row (msemt, end, cols, MONO_METHOD_SEMA_SIZE); + if (cols [MONO_METHOD_SEMA_ASSOCIATION] != loc.idx) + break; + ++end; + } + *end_idx = end; + return start; +} + +/* + * mono_metadata_properties_from_typedef: + * @meta: metadata context + * @index: 0-based index (in the TypeDef table) describing a type + * + * Returns: the 0-based index in the Property table for the properties in the + * type. The last property that belongs to the type (plus 1) is stored + * in the @end_idx pointer. + */ guint32 mono_metadata_properties_from_typedef (MonoImage *meta, guint32 index, guint *end_idx) { @@ -2183,6 +2512,15 @@ mono_metadata_properties_from_typedef (MonoImage *meta, guint32 index, guint *en return start - 1; } +/* + * mono_metadata_methods_from_property: + * @meta: metadata context + * @index: 0-based index (in the PropertyDef table) describing a property + * + * Returns: the 0-based index in the MethodDef table for the methods in the + * property. The last method that belongs to the property (plus 1) is stored + * in the @end_idx pointer. + */ guint32 mono_metadata_methods_from_property (MonoImage *meta, guint32 index, guint *end_idx) { @@ -2197,7 +2535,7 @@ mono_metadata_methods_from_property (MonoImage *meta, guint32 index, guint *en loc.t = msemt; loc.col_idx = MONO_METHOD_SEMA_ASSOCIATION; - loc.idx = ((index + 1) << 1) | 1; /* Method association coded index */ + loc.idx = ((index + 1) << HAS_SEMANTICS_BITS) | HAS_SEMANTICS_PROPERTY; /* Method association coded index */ if (!bsearch (&loc, msemt->base, msemt->rows, msemt->row_size, table_locator)) return 0; @@ -2226,6 +2564,9 @@ mono_metadata_methods_from_property (MonoImage *meta, guint32 index, guint *en /** * @image: context where the image is created * @type_spec: typespec token + * + * Creates a MonoType representing the TypeSpec indexed by the @type_spec + * token. */ MonoType * mono_type_create_from_typespec (MonoImage *image, guint32 type_spec)