[PATCH 0/6] MR8690: widl: Various metadata fixes

List overview All Threads

newer

older

[PATCH v4 0/4] MR8555:...

[PATCH 0/1] MR8694: win32u: Clear...

Hans Leidekker (＠hans)

1 Aug 2025 1 Aug '25

7:55 a.m.

-- https://gitlab.winehq.org/wine/wine/-/merge_requests/8690

Show replies by date

Hans Leidekker

1 Aug 1 Aug

7:55 a.m.

New subject: [PATCH 1/6] widl: Fix version attribute value.

From: Hans Leidekker hans@codeweavers.com

winmd stores high and low word in opposite order from typelib. --- tools/widl/metadata.c | 7 +++---- tools/widl/parser.y | 4 ++-- 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/tools/widl/metadata.c b/tools/widl/metadata.c index bd953c50d53..3e7f2b911e5 100644 --- a/tools/widl/metadata.c +++ b/tools/widl/metadata.c @@ -1779,13 +1779,12 @@ static UINT make_contract_value( const type_t *type, BYTE *buf )

static UINT make_version_value( const type_t *type, BYTE *buf ) { - UINT version = get_attrv( type->attrs, ATTR_VERSION ); + UINT version = is_attr( type->attrs, ATTR_VERSION ) ? get_attrv( type->attrs, ATTR_VERSION ) : 1;

buf[0] = 1; buf[1] = 0; - buf[2] = is_attr( type->attrs, ATTR_VERSION ) ? 0 : 1; - buf[3] = 0; - memcpy( buf + 4, &version, sizeof(version) ); + memcpy( buf + 2, &version, sizeof(version) ); + buf[6] = buf[7] = 0; return 8; }

diff --git a/tools/widl/parser.y b/tools/widl/parser.y index fb21a2417f1..d31b8b10cc8 100644 --- a/tools/widl/parser.y +++ b/tools/widl/parser.y @@ -1386,8 +1386,8 @@ uniondef: tUNION m_typename '{' ne_union_fields '}' ;

version: - aNUM { $$ = MAKEVERSION($1.value, 0); } - | aNUM '.' aNUM { $$ = MAKEVERSION($1.value, $3.value); } + aNUM { $$ = winrt_mode ? MAKEVERSION(0, $1.value) : MAKEVERSION($1.value, 0); } + | aNUM '.' aNUM { $$ = winrt_mode ? MAKEVERSION($3.value, $1.value) : MAKEVERSION($1.value, $3.value); } | aHEXNUM { $$ = $1.value; } ;

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/8690

Hans Leidekker

7:55 a.m.

New subject: [PATCH 2/6] widl: Skip array size parameters.

From: Hans Leidekker hans@codeweavers.com

--- tools/widl/metadata.c | 5 +++-- tools/widl/parser.y | 10 +++++----- tools/widl/widl.h | 2 ++ 3 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/tools/widl/metadata.c b/tools/widl/metadata.c index 3e7f2b911e5..45dfbea709b 100644 --- a/tools/widl/metadata.c +++ b/tools/widl/metadata.c @@ -1669,7 +1669,7 @@ static UINT make_method_sig( const var_t *method, BYTE *buf, BOOL is_static ) /* add remaining parameters */ LIST_FOR_EACH_ENTRY( arg, arg_list, var_t, entry ) { - if (is_attr( arg->attrs, ATTR_RETVAL ) ) continue; + if (is_size_param( arg, arg_list ) || is_attr( arg->attrs, ATTR_RETVAL ) ) continue; len += make_type_sig( arg->declspec.type, buf + len ); buf[1]++; } @@ -2206,6 +2206,7 @@ static void add_method_params_step1( var_list_t *arg_list ) { type_t *type = arg->declspec.type;

+ if (is_size_param( arg, arg_list )) continue; if (type_get_type( type ) == TYPE_POINTER) type = type_pointer_get_ref_type( type ); if (type->name && !strcmp( type->name, "EventRegistrationToken" )) { @@ -2279,7 +2280,7 @@ static UINT add_method_params_step2( var_list_t *arg_list )

LIST_FOR_EACH_ENTRY( arg, arg_list, var_t, entry ) { - if (is_attr( arg->attrs, ATTR_RETVAL )) continue; + if (is_size_param( arg, arg_list) || is_attr( arg->attrs, ATTR_RETVAL )) continue; row = add_param_row( get_param_attrs(arg), seq++, add_string(arg->name) ); if (!first) first = row; } diff --git a/tools/widl/parser.y b/tools/widl/parser.y index d31b8b10cc8..dc6376edb0f 100644 --- a/tools/widl/parser.y +++ b/tools/widl/parser.y @@ -2604,7 +2604,7 @@ static void check_eventremove_args( const var_t *func, const var_list_t *args ) } }

-static int is_size_parameter( const var_t *param, const var_list_t *args ) +bool is_size_param( const var_t *param, const var_list_t *args ) { const var_t *arg;

@@ -2617,9 +2617,9 @@ static int is_size_parameter( const var_t *param, const var_list_t *args ) if (type->type_type != TYPE_ARRAY || !(size_is = type_array_get_conformance( type ))) continue;

if (size_is->type == EXPR_PPTR) size_is = size_is->ref; - if (!strcmp( param->name, size_is->u.sval )) return 1; + if (!strcmp( param->name, size_is->u.sval )) return true; } - return 0; + return false; }

static void check_propget_args( const var_t *func, const var_list_t *args ) @@ -2630,7 +2630,7 @@ static void check_propget_args( const var_t *func, const var_list_t *args ) LIST_FOR_EACH_ENTRY_REV( arg, args, const var_t, entry ) { const type_t *type = arg->declspec.type; - int is_size = is_size_parameter( arg, args ); + bool is_size = is_size_param( arg, args );

count++; if (count == 1 && (!is_ptr( type ) || !is_attr( arg->attrs, ATTR_RETVAL ))) @@ -2653,7 +2653,7 @@ static void check_propput_args( const var_t *func, const var_list_t *args )

LIST_FOR_EACH_ENTRY_REV( arg, args, const var_t, entry ) { - int is_size = is_size_parameter( arg, args ); + bool is_size = is_size_param( arg, args );

count++; if (is_attr( arg->attrs, ATTR_OUT )) diff --git a/tools/widl/widl.h b/tools/widl/widl.h index 08071e8fdf8..c17dbd90c59 100644 --- a/tools/widl/widl.h +++ b/tools/widl/widl.h @@ -93,6 +93,8 @@ extern void write_metadata(const statement_list_t *stmts); extern void start_cplusplus_guard(FILE *fp); extern void end_cplusplus_guard(FILE *fp);

+extern bool is_size_param( const var_t *param, const var_list_t *args ); + /* attribute.c */

extern attr_t *attr_int( struct location where, enum attr_type attr_type, unsigned int val );

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/8690

Hans Leidekker

7:55 a.m.

New subject: [PATCH 3/6] widl: Fix encoding of array parameters.

From: Hans Leidekker hans@codeweavers.com

Array return values are encoded as out parameters even if they have a retval attribute. --- tools/widl/metadata.c | 23 ++++++++++++++++------- 1 file changed, 16 insertions(+), 7 deletions(-)

diff --git a/tools/widl/metadata.c b/tools/widl/metadata.c index 45dfbea709b..557aaff57a7 100644 --- a/tools/widl/metadata.c +++ b/tools/widl/metadata.c @@ -1644,6 +1644,15 @@ static UINT make_type_sig( const type_t *type, BYTE *buf ) return len; }

+static BOOL is_retval( const var_t *arg ) +{ + const type_t *type = arg->declspec.type; + + /* array return values are encoded as out parameters even if the retval attribute is present */ + if (!is_attr( arg->attrs, ATTR_RETVAL ) || type_get_type( type ) == TYPE_ARRAY) return FALSE; + return TRUE; +} + static UINT make_method_sig( const var_t *method, BYTE *buf, BOOL is_static ) { const var_t *arg; @@ -1661,7 +1670,7 @@ static UINT make_method_sig( const var_t *method, BYTE *buf, BOOL is_static ) { const type_t *type;

- if (!is_attr( arg->attrs, ATTR_RETVAL )) continue; + if (!is_retval( arg )) continue; type = type_pointer_get_ref_type( arg->declspec.type ); /* retval must be a pointer */ len = make_type_sig( type, buf + 2 ) + 2; } @@ -1669,7 +1678,7 @@ static UINT make_method_sig( const var_t *method, BYTE *buf, BOOL is_static ) /* add remaining parameters */ LIST_FOR_EACH_ENTRY( arg, arg_list, var_t, entry ) { - if (is_size_param( arg, arg_list ) || is_attr( arg->attrs, ATTR_RETVAL ) ) continue; + if (is_size_param( arg, arg_list ) || is_retval( arg ) ) continue; len += make_type_sig( arg->declspec.type, buf + len ); buf[1]++; } @@ -1690,7 +1699,7 @@ static UINT make_property_sig( const var_t *method, BYTE *buf, BOOL is_static ) { const type_t *type;

if (method) LIST_FOR_EACH_ENTRY( arg, type_function_get_args(method->declspec.type), var_t, entry ) { - if (is_attr( arg->attrs, ATTR_RETVAL )) continue; + if (is_retval( arg )) continue; len += make_type_sig( arg->declspec.type, buf + len ); buf[1]++; } @@ -2271,7 +2280,7 @@ static UINT add_method_params_step2( var_list_t *arg_list )

LIST_FOR_EACH_ENTRY( arg, arg_list, var_t, entry ) { - if (is_attr( arg->attrs, ATTR_RETVAL )) + if (is_retval( arg )) { first = add_param_row( 0, 0, add_string(arg->name) ); break; @@ -2280,7 +2289,7 @@ static UINT add_method_params_step2( var_list_t *arg_list )

LIST_FOR_EACH_ENTRY( arg, arg_list, var_t, entry ) { - if (is_size_param( arg, arg_list) || is_attr( arg->attrs, ATTR_RETVAL )) continue; + if (is_size_param( arg, arg_list) || is_retval( arg )) continue; row = add_param_row( get_param_attrs(arg), seq++, add_string(arg->name) ); if (!first) first = row; } @@ -3177,7 +3186,7 @@ static void add_activation_interfaces( const type_t *class )

LIST_FOR_EACH_ENTRY( arg, type_function_get_args(method->declspec.type), var_t, entry ) { - if (is_attr( arg->attrs, ATTR_RETVAL )) continue; + if (is_retval( arg )) continue; row = add_param_row( get_param_attrs(arg), seq++, add_string(arg->name) ); if (!paramlist) paramlist = row; }

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/8690

Hans Leidekker

7:55 a.m.

New subject: [PATCH 4/6] widl: Only use 32-bit integers in row structures.

From: Hans Leidekker hans@codeweavers.com

To avoid uninitialized padding. --- tools/widl/metadata.c | 102 +++++++++++++++++++++--------------------- 1 file changed, 52 insertions(+), 50 deletions(-)

diff --git a/tools/widl/metadata.c b/tools/widl/metadata.c index 557aaff57a7..779b79d79d5 100644 --- a/tools/widl/metadata.c +++ b/tools/widl/metadata.c @@ -479,14 +479,16 @@ static void add_bytes( struct buffer *buf, const BYTE *data, UINT size ) buf->offset += size; }

-static void serialize_byte( BYTE value ) +static void serialize_byte( UINT value ) { - add_bytes( &tables_disk, (const BYTE *)&value, sizeof(value) ); + assert( !(value >> 24) ); + add_bytes( &tables_disk, (const BYTE *)&value, sizeof(BYTE) ); }

-static void serialize_ushort( USHORT value ) +static void serialize_ushort( UINT value ) { - add_bytes( &tables_disk, (const BYTE *)&value, sizeof(value) ); + assert( !(value >> 16) ); + add_bytes( &tables_disk, (const BYTE *)&value, sizeof(USHORT) ); }

static void serialize_uint( UINT value ) @@ -623,11 +625,11 @@ static enum table has_semantics_to_table( UINT token )

struct module_row { - USHORT generation; - UINT name; - UINT mvid; - UINT encid; - UINT encbaseid; + UINT generation; + UINT name; + UINT mvid; + UINT encid; + UINT encbaseid; };

static UINT add_module_row( UINT name, UINT mvid ) @@ -713,9 +715,9 @@ static void serialize_typedef_table( void )

struct field_row { - USHORT flags; - UINT name; - UINT signature; + UINT flags; + UINT name; + UINT signature; };

static UINT add_field_row( UINT flags, UINT name, UINT signature ) @@ -740,12 +742,12 @@ static void serialize_field_table( void )

struct methoddef_row { - UINT rva; - USHORT implflags; - USHORT flags; - UINT name; - UINT signature; - UINT paramlist; + UINT rva; + UINT implflags; + UINT flags; + UINT name; + UINT signature; + UINT paramlist; };

static UINT add_methoddef_row( UINT implflags, UINT flags, UINT name, UINT signature, UINT paramlist ) @@ -775,9 +777,9 @@ static void serialize_methoddef_table( void )

struct param_row { - USHORT flags; - USHORT sequence; - UINT name; + UINT flags; + UINT sequence; + UINT name; };

static UINT add_param_row( USHORT flags, USHORT sequence, UINT name ) @@ -868,8 +870,8 @@ static void serialize_memberref_table( void )

struct constant_row { - BYTE type; - BYTE padding; + UINT type; + UINT padding; UINT parent; UINT value; }; @@ -947,15 +949,15 @@ static void serialize_customattribute_table( void )

struct assembly_row { - UINT hashalgid; - USHORT majorversion; - USHORT minorversion; - USHORT buildnumber; - USHORT revisionnumber; - UINT flags; - UINT publickey; - UINT name; - UINT culture; + UINT hashalgid; + UINT majorversion; + UINT minorversion; + UINT buildnumber; + UINT revisionnumber; + UINT flags; + UINT publickey; + UINT name; + UINT culture; };

static UINT add_assembly_row( UINT name ) @@ -981,15 +983,15 @@ static void serialize_assembly_table( void )

struct assemblyref_row { - USHORT majorversion; - USHORT minorversion; - USHORT buildnumber; - USHORT revisionnumber; - UINT flags; - UINT publickey; - UINT name; - UINT culture; - UINT hashvalue; + UINT majorversion; + UINT minorversion; + UINT buildnumber; + UINT revisionnumber; + UINT flags; + UINT publickey; + UINT name; + UINT culture; + UINT hashvalue; };

static UINT add_assemblyref_row( UINT flags, UINT publickey, UINT name ) @@ -1045,9 +1047,9 @@ static void serialize_propertymap_table( void )

struct property_row { - USHORT flags; - UINT name; - UINT type; + UINT flags; + UINT name; + UINT type; };

static UINT add_property_row( USHORT flags, UINT name, UINT type ) @@ -1097,9 +1099,9 @@ static void serialize_eventmap_table( void )

struct event_row { - USHORT flags; - UINT name; - UINT type; + UINT flags; + UINT name; + UINT type; };

static UINT add_event_row( USHORT flags, UINT name, UINT type ) @@ -1124,9 +1126,9 @@ static void serialize_event_table( void )

struct methodsemantics_row { - USHORT semantics; - UINT method; - UINT association; + UINT semantics; + UINT method; + UINT association; };

static UINT add_methodsemantics_row( USHORT flags, UINT name, UINT type )

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/8690

Hans Leidekker

7:55 a.m.

New subject: [PATCH 5/6] widl: Add an implicit apicontract attribute.

From: Hans Leidekker hans@codeweavers.com

midlrt includes this attribute when generating metadata. Adding this attribute when an apicontract is defined allows us to move member references from types to attributes where they belong. --- tools/widl/attribute.c | 1 + tools/widl/typetree.c | 1 + tools/widl/widltypes.h | 1 + 3 files changed, 3 insertions(+)

diff --git a/tools/widl/attribute.c b/tools/widl/attribute.c index 2546e88b30a..6481df05e3e 100644 --- a/tools/widl/attribute.c +++ b/tools/widl/attribute.c @@ -134,6 +134,7 @@ struct allowed_attr allowed_attr[] = /* ATTR_AGGREGATABLE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, "aggregatable" }, /* ATTR_ALLOCATE */ { 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "allocate" }, /* ATTR_ANNOTATION */ { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "annotation" }, + /* ATTR_APICONTACT */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, "apicontract" }, /* ATTR_APPOBJECT */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, "appobject" }, /* ATTR_ASYNC */ { 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "async" }, /* ATTR_ASYNCUUID */ { 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, "async_uuid" }, diff --git a/tools/widl/typetree.c b/tools/widl/typetree.c index 441b6cdcea1..3bfb2efeea2 100644 --- a/tools/widl/typetree.c +++ b/tools/widl/typetree.c @@ -913,6 +913,7 @@ type_t *type_apicontract_declare(char *name, struct namespace *namespace) type_t *type_apicontract_define(type_t *apicontract, attr_list_t *attrs, const struct location *where) { apicontract->attrs = check_apicontract_attrs(apicontract->name, attrs); + apicontract->attrs = append_attr(apicontract->attrs, attr_int(*where, ATTR_APICONTRACT, 1)); define_type(apicontract, where); return apicontract; } diff --git a/tools/widl/widltypes.h b/tools/widl/widltypes.h index 1706f392670..c05b98b43f4 100644 --- a/tools/widl/widltypes.h +++ b/tools/widl/widltypes.h @@ -74,6 +74,7 @@ enum attr_type ATTR_AGGREGATABLE, ATTR_ALLOCATE, ATTR_ANNOTATION, + ATTR_APICONTRACT, /* implicit attribute */ ATTR_APPOBJECT, ATTR_ASYNC, ATTR_ASYNCUUID,

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/8690

Hans Leidekker

7:55 a.m.

New subject: [PATCH 6/6] widl: Always store member references in attributes.

From: Hans Leidekker hans@codeweavers.com

--- tools/widl/metadata.c | 279 +++++++++++++++++++++++------------------ tools/widl/widltypes.h | 22 +--- 2 files changed, 161 insertions(+), 140 deletions(-)

diff --git a/tools/widl/metadata.c b/tools/widl/metadata.c index 779b79d79d5..42c13ded7c8 100644 --- a/tools/widl/metadata.c +++ b/tools/widl/metadata.c @@ -1767,12 +1767,12 @@ static UINT make_deprecated_sig( UINT token, BYTE *buf ) return len; }

-static UINT make_contract_value( const type_t *type, BYTE *buf ) +static UINT make_contract_value( const attr_t *attr, BYTE *buf ) { - const expr_t *attr = get_attrp( type->attrs, ATTR_CONTRACT ); - const type_t *contract = attr->u.var->declspec.type; + const expr_t *expr = attr->u.pval; + const type_t *contract = expr->u.var->declspec.type; char *name = format_namespace( contract->namespace, "", ".", contract->name, NULL ); - UINT version = attr->ref->u.integer.value, len = strlen( name ); + UINT version = expr->ref->u.integer.value, len = strlen( name );

buf[0] = 1; buf[1] = 0; @@ -1788,9 +1788,9 @@ static UINT make_contract_value( const type_t *type, BYTE *buf ) return len; }

-static UINT make_version_value( const type_t *type, BYTE *buf ) +static UINT make_version_value( const attr_t *attr, BYTE *buf ) { - UINT version = is_attr( type->attrs, ATTR_VERSION ) ? get_attrv( type->attrs, ATTR_VERSION ) : 1; + UINT version = attr ? attr->u.ival : 0;

buf[0] = 1; buf[1] = 0; @@ -1799,12 +1799,23 @@ static UINT make_version_value( const type_t *type, BYTE *buf ) return 8; }

-static void add_contract_attr_step1( type_t *type ) +static attr_t *get_attr( const attr_list_t *list, enum attr_type attr_type ) +{ + attr_t *attr; + if (list) LIST_FOR_EACH_ENTRY( attr, list, attr_t, entry ) + { + if (attr->type == attr_type ) return attr; + } + return NULL; +} + +static void add_contract_attr_step1( const type_t *type ) { UINT assemblyref, scope, typeref, typeref_type, class, sig_size; BYTE sig[32]; + attr_t *attr;

- if (!is_attr( type->attrs, ATTR_CONTRACT )) return; + if (!(attr = get_attr( type->attrs, ATTR_CONTRACT ))) return;

add_assemblyref_row( 0x200, 0, add_string("windowscontracts") ); assemblyref = add_assemblyref_row( 0x200, 0, add_string("Windows.Foundation") ); @@ -1817,72 +1828,77 @@ static void add_contract_attr_step1( type_t *type )

class = memberref_parent( TABLE_TYPEREF, typeref ); sig_size = make_member_sig( typedef_or_ref(TABLE_TYPEREF, typeref_type), sig ); - type->md.member[MD_ATTR_CONTRACT] = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sig_size) ); + attr->md_member = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sig_size) ); }

-static void add_contract_attr_step2( type_t *type ) +static void add_contract_attr_step2( const type_t *type ) { UINT parent, attr_type, value_size; BYTE value[MAX_NAME + sizeof(UINT) + 5]; + const attr_t *attr;

- if (!is_attr( type->attrs, ATTR_CONTRACT )) return; + if (!(attr = get_attr( type->attrs, ATTR_CONTRACT ))) return;

parent = has_customattribute( TABLE_TYPEDEF, type->md.def ); - attr_type = customattribute_type( TABLE_MEMBERREF, type->md.member[MD_ATTR_CONTRACT] ); - value_size = make_contract_value( type, value ); + attr_type = customattribute_type( TABLE_MEMBERREF, attr->md_member ); + value_size = make_contract_value( attr, value ); add_customattribute_row( parent, attr_type, add_blob(value, value_size) ); }

-static void add_version_attr_step1( type_t *type ) +static void add_version_attr_step1( const type_t *type ) { static const BYTE sig[] = { SIG_TYPE_HASTHIS, 1, ELEMENT_TYPE_VOID, ELEMENT_TYPE_U4 }; UINT assemblyref, scope, typeref, class; + attr_t *attr;

- if (!is_attr( type->attrs, ATTR_VERSION ) && is_attr( type->attrs, ATTR_CONTRACT )) return; + if (!(attr = get_attr( type->attrs, ATTR_VERSION )) && is_attr( type->attrs, ATTR_CONTRACT )) return;

assemblyref = add_assemblyref_row( 0x200, 0, add_string("Windows.Foundation") ); scope = resolution_scope( TABLE_ASSEMBLYREF, assemblyref );

typeref = add_typeref_row( scope, add_string("VersionAttribute"), add_string("Windows.Foundation.Metadata") ); class = memberref_parent( TABLE_TYPEREF, typeref ); - type->md.member[MD_ATTR_VERSION] = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sizeof(sig)) ); + attr->md_member = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sizeof(sig)) ); }

-static void add_version_attr_step2( type_t *type ) +static void add_version_attr_step2( const type_t *type ) { UINT parent, attr_type, value_size; BYTE value[8]; + const attr_t *attr;

- if (!is_attr( type->attrs, ATTR_VERSION ) && is_attr( type->attrs, ATTR_CONTRACT )) return; + if (!(attr = get_attr( type->attrs, ATTR_VERSION )) && is_attr( type->attrs, ATTR_CONTRACT )) return;

parent = has_customattribute( TABLE_TYPEDEF, type->md.def ); - attr_type = customattribute_type( TABLE_MEMBERREF, type->md.member[MD_ATTR_VERSION] ); - value_size = make_version_value( type, value ); + attr_type = customattribute_type( TABLE_MEMBERREF, attr->md_member ); + value_size = make_version_value( attr, value ); add_customattribute_row( parent, attr_type, add_blob(value, value_size) ); }

-static void add_flags_attr_step1( type_t *type ) +static void add_flags_attr_step1( const type_t *type ) { static const BYTE sig[] = { SIG_TYPE_HASTHIS, 0, ELEMENT_TYPE_VOID }; UINT scope, typeref, class; + attr_t *attr;

- if (!is_attr( type->attrs, ATTR_FLAGS )) return; + if (!(attr = get_attr( type->attrs, ATTR_FLAGS ))) return;

scope = resolution_scope( TABLE_ASSEMBLYREF, MSCORLIB_ROW ); typeref = add_typeref_row( scope, add_string("FlagsAttribute"), add_string("System") ); class = memberref_parent( TABLE_TYPEREF, typeref ); - type->md.member[MD_ATTR_FLAGS] = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sizeof(sig)) ); + attr->md_member = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sizeof(sig)) ); }

-static void add_flags_attr_step2( type_t *type ) +static void add_flags_attr_step2( const type_t *type ) { static const BYTE value[] = { 0x01, 0x00, 0x00, 0x00 }; UINT parent, attr_type; + const attr_t *attr;

- if (!is_attr( type->attrs, ATTR_FLAGS )) return; + if (!(attr = get_attr( type->attrs, ATTR_FLAGS ))) return;

parent = has_customattribute( TABLE_TYPEDEF, type->md.def ); - attr_type = customattribute_type( TABLE_MEMBERREF, type->md.member[MD_ATTR_FLAGS] ); + attr_type = customattribute_type( TABLE_MEMBERREF, attr->md_member ); add_customattribute_row( parent, attr_type, add_blob(value, sizeof(value)) ); }

@@ -1979,42 +1995,46 @@ static void add_struct_type_step2( type_t *type ) add_contract_attr_step2( type ); }

-static void add_uuid_attr_step1( type_t *type ) +static void add_uuid_attr_step1( const type_t *type ) { static const BYTE sig[] = { SIG_TYPE_HASTHIS, 11, ELEMENT_TYPE_VOID, ELEMENT_TYPE_U4, ELEMENT_TYPE_U2, ELEMENT_TYPE_U2, ELEMENT_TYPE_U1, ELEMENT_TYPE_U1, ELEMENT_TYPE_U1, ELEMENT_TYPE_U1, ELEMENT_TYPE_U1, ELEMENT_TYPE_U1, ELEMENT_TYPE_U1, ELEMENT_TYPE_U1 }; UINT assemblyref, scope, typeref, class; + attr_t *attr; + + if (!(attr = get_attr( type->attrs, ATTR_UUID ))) return;

assemblyref = add_assemblyref_row( 0x200, 0, add_string("Windows.Foundation") ); scope = resolution_scope( TABLE_ASSEMBLYREF, assemblyref ); typeref = add_typeref_row( scope, add_string("GuidAttribute"), add_string("Windows.Foundation.Metadata") );

class = memberref_parent( TABLE_TYPEREF, typeref ); - type->md.member[MD_ATTR_UUID] = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sizeof(sig)) ); + attr->md_member = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sizeof(sig)) ); }

-static void add_uuid_attr_step2( type_t *type ) +static void add_uuid_attr_step2( const type_t *type ) { - static const BYTE default_uuid[] = - { 0xe7, 0x1f, 0xb5, 0x67, 0x6e, 0x38, 0x31, 0x5a, 0x8a, 0x1c, 0x89, 0x83, 0xc9, 0x49, 0x5c, 0x33 }; - const struct uuid *uuid = get_attrp( type->attrs, ATTR_UUID ); + const struct uuid *uuid; BYTE value[sizeof(*uuid) + 4] = { 0x01 }; UINT parent, attr_type; + const attr_t *attr; + + if (!(attr = get_attr( type->attrs, ATTR_UUID ))) return;

- if (uuid) memcpy( value + 2, uuid, sizeof(*uuid) ); - else memcpy( value + 2, default_uuid, sizeof(default_uuid) ); + uuid = attr->u.pval; + memcpy( value + 2, uuid, sizeof(*uuid) );

parent = has_customattribute( TABLE_TYPEDEF, type->md.def ); - attr_type = customattribute_type( TABLE_MEMBERREF, type->md.member[MD_ATTR_UUID] ); + attr_type = customattribute_type( TABLE_MEMBERREF, attr->md_member ); add_customattribute_row( parent, attr_type, add_blob(value, sizeof(value)) ); }

-static UINT make_exclusiveto_value( const type_t *type, BYTE *buf ) +static UINT make_exclusiveto_value( const attr_t *attr, BYTE *buf ) { - const type_t *attr = get_attrp( type->attrs, ATTR_EXCLUSIVETO ); - char *name = format_namespace( attr->namespace, "", ".", attr->name, NULL ); + const type_t *type = attr->u.pval; + char *name = format_namespace( type->namespace, "", ".", type->name, NULL ); UINT len = strlen( name );

buf[0] = 1; @@ -2029,12 +2049,13 @@ static UINT make_exclusiveto_value( const type_t *type, BYTE *buf ) return len; }

-static void add_exclusiveto_attr_step1( type_t *type ) +static void add_exclusiveto_attr_step1( const type_t *type ) { UINT assemblyref, scope, typeref, typeref_type, class, sig_size; BYTE sig[32]; + attr_t *attr;

- if (!is_attr( type->attrs, ATTR_EXCLUSIVETO )) return; + if (!(attr = get_attr( type->attrs, ATTR_EXCLUSIVETO ))) return;

scope = resolution_scope( TABLE_ASSEMBLYREF, MSCORLIB_ROW ); typeref_type = add_typeref_row( scope, add_string("Type"), add_string("System") ); @@ -2045,30 +2066,31 @@ static void add_exclusiveto_attr_step1( type_t *type )

class = memberref_parent( TABLE_TYPEREF, typeref ); sig_size = make_member_sig2( ELEMENT_TYPE_CLASS, typedef_or_ref(TABLE_TYPEREF, typeref_type), sig ); - type->md.member[MD_ATTR_EXCLUSIVETO] = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sig_size) ); + attr->md_member = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sig_size) ); }

-static void add_exclusiveto_attr_step2( type_t *type ) +static void add_exclusiveto_attr_step2( const type_t *type ) { UINT parent, attr_type, value_size; BYTE value[MAX_NAME + 5]; + const attr_t *attr;

- if (!is_attr( type->attrs, ATTR_EXCLUSIVETO )) return; + if (!(attr = get_attr( type->attrs, ATTR_EXCLUSIVETO ))) return;

parent = has_customattribute( TABLE_TYPEDEF, type->md.def ); - attr_type = customattribute_type( TABLE_MEMBERREF, type->md.member[MD_ATTR_EXCLUSIVETO] ); - value_size = make_exclusiveto_value( type, value ); + attr_type = customattribute_type( TABLE_MEMBERREF, attr->md_member ); + value_size = make_exclusiveto_value( attr, value ); add_customattribute_row( parent, attr_type, add_blob(value, value_size) ); }

-static UINT make_overload_value( const var_t *method, BYTE *buf ) +static UINT make_overload_value( const char *name, BYTE *buf ) { - UINT len = strlen( method->name ); + UINT len = strlen( name );

buf[0] = 1; buf[1] = 0; buf[2] = len; - memcpy( buf + 3, method->name, len ); + memcpy( buf + 3, name, len ); len += 3; buf[len++] = 0; buf[len++] = 0; @@ -2080,16 +2102,16 @@ static void add_overload_attr_step1( const var_t *method ) { static const BYTE sig[] = { SIG_TYPE_HASTHIS, 1, ELEMENT_TYPE_VOID, ELEMENT_TYPE_STRING }; UINT assemblyref, scope, typeref, class; - type_t *type = method->declspec.type; + attr_t *attr;

- if (!is_attr( method->attrs, ATTR_OVERLOAD )) return; + if (!(attr = get_attr( method->attrs, ATTR_OVERLOAD ))) return;

assemblyref = add_assemblyref_row( 0x200, 0, add_string("Windows.Foundation") ); scope = resolution_scope( TABLE_ASSEMBLYREF, assemblyref ); typeref = add_typeref_row( scope, add_string("OverloadAttribute"), add_string("Windows.Foundation.Metadata") );

class = memberref_parent( TABLE_TYPEREF, typeref ); - type->md.member[MD_ATTR_OVERLOAD] = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sizeof(sig)) ); + attr->md_member = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sizeof(sig)) ); }

static void add_overload_attr_step2( const var_t *method ) @@ -2097,12 +2119,13 @@ static void add_overload_attr_step2( const var_t *method ) const type_t *type = method->declspec.type; UINT parent, attr_type, value_size; BYTE value[MAX_NAME + 5]; + const attr_t *attr;

- if (!is_attr( method->attrs, ATTR_OVERLOAD )) return; + if (!(attr = get_attr( method->attrs, ATTR_OVERLOAD ))) return;

parent = has_customattribute( TABLE_METHODDEF, type->md.def ); - attr_type = customattribute_type( TABLE_MEMBERREF, type->md.member[MD_ATTR_OVERLOAD] ); - value_size = make_overload_value( method, value ); + attr_type = customattribute_type( TABLE_MEMBERREF, attr->md_member ); + value_size = make_overload_value( method->name, value ); add_customattribute_row( parent, attr_type, add_blob(value, value_size) ); }

@@ -2110,16 +2133,16 @@ static void add_default_overload_attr_step1( const var_t *method ) { static const BYTE sig[] = { SIG_TYPE_HASTHIS, 0, ELEMENT_TYPE_VOID }; UINT assemblyref, scope, typeref, class; - type_t *type = method->declspec.type; + attr_t *attr;

- if (!is_attr( method->attrs, ATTR_DEFAULT_OVERLOAD ) || !is_attr( method->attrs, ATTR_OVERLOAD )) return; + if (!(attr = get_attr( method->attrs, ATTR_DEFAULT_OVERLOAD )) || !is_attr( method->attrs, ATTR_OVERLOAD )) return;

assemblyref = add_assemblyref_row( 0x200, 0, add_string("Windows.Foundation") ); scope = resolution_scope( TABLE_ASSEMBLYREF, assemblyref ); typeref = add_typeref_row( scope, add_string("DefaultOverloadAttribute"), add_string("Windows.Foundation.Metadata") );

class = memberref_parent( TABLE_TYPEREF, typeref ); - type->md.member[MD_ATTR_DEFAULT_OVERLOAD] = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sizeof(sig)) ); + attr->md_member = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sizeof(sig)) ); }

static void add_default_overload_attr_step2( const var_t *method ) @@ -2127,21 +2150,22 @@ static void add_default_overload_attr_step2( const var_t *method ) static const BYTE value[] = { 0x01, 0x00, 0x00, 0x00 }; const type_t *type = method->declspec.type; UINT parent, attr_type; + const attr_t *attr;

parent = has_customattribute( TABLE_METHODDEF, type->md.def ); - attr_type = customattribute_type( TABLE_MEMBERREF, type->md.member[MD_ATTR_DEFAULT_OVERLOAD] ); + attr_type = customattribute_type( TABLE_MEMBERREF, attr->md_member ); add_customattribute_row( parent, attr_type, add_blob(value, sizeof(value)) ); }

-static UINT make_deprecated_value( const var_t *method, BYTE **ret_buf ) +static UINT make_deprecated_value( const attr_t *attr, BYTE **ret_buf ) { static const BYTE zero[] = { 0x00, 0x00, 0x00, 0x00 }, one[] = { 0x01, 0x00, 0x00, 0x00 }; - const expr_t *attr = get_attrp( method->attrs, ATTR_DEPRECATED ); - const type_t *type = attr->ext2->u.var->declspec.type; - const char *text = attr->ref->u.sval; - const char *kind = attr->u.ext->u.sval; + const expr_t *expr = attr->u.pval; + const type_t *type = expr->ext2->u.var->declspec.type; + const char *text = expr->ref->u.sval; + const char *kind = expr->u.ext->u.sval; BYTE encoded[4]; UINT len, len_text = strlen( text ), len_encoded = encode_int( len_text, encoded ); BYTE *buf = xmalloc( 2 + len_encoded + len_text + 6 + MAX_NAME + 5 ); @@ -2177,10 +2201,10 @@ static UINT make_deprecated_value( const var_t *method, BYTE **ret_buf ) static void add_deprecated_attr_step1( const var_t *method ) { UINT assemblyref, scope, typeref_type, typeref, class, sig_size; - type_t *type = method->declspec.type; BYTE sig[32]; + attr_t *attr;

- if (!is_attr( method->attrs, ATTR_DEPRECATED )) return; + if (!(attr = get_attr( method->attrs, ATTR_DEPRECATED ))) return;

assemblyref = add_assemblyref_row( 0x200, 0, add_string("Windows.Foundation") ); scope = resolution_scope( TABLE_ASSEMBLYREF, assemblyref ); @@ -2189,7 +2213,7 @@ static void add_deprecated_attr_step1( const var_t *method )

sig_size = make_deprecated_sig( typedef_or_ref(TABLE_TYPEREF, typeref_type), sig ); class = memberref_parent( TABLE_TYPEREF, typeref ); - type->md.member[MD_ATTR_DEPRECATED] = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sig_size) ); + attr->md_member = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sig_size) ); }

static void add_deprecated_attr_step2( const var_t *method ) @@ -2197,12 +2221,13 @@ static void add_deprecated_attr_step2( const var_t *method ) const type_t *type = method->declspec.type; UINT parent, attr_type, value_size; BYTE *value; + const attr_t *attr;

- if (!is_attr( method->attrs, ATTR_DEPRECATED )) return; + if (!(attr = get_attr( method->attrs, ATTR_DEPRECATED ))) return;

parent = has_customattribute( TABLE_METHODDEF, type->md.def ); - attr_type = customattribute_type( TABLE_MEMBERREF, type->md.member[MD_ATTR_DEPRECATED] ); - value_size = make_deprecated_value( method, &value ); + attr_type = customattribute_type( TABLE_MEMBERREF, attr->md_member ); + value_size = make_deprecated_value( attr, &value ); add_customattribute_row( parent, attr_type, add_blob(value, value_size) ); free( value ); } @@ -2589,9 +2614,9 @@ static void add_interface_type_step2( type_t *type ) add_exclusiveto_attr_step2( type ); }

-static UINT make_contractversion_value( const type_t *type, BYTE *buf ) +static UINT make_contractversion_value( const attr_t *attr, BYTE *buf ) { - UINT version = get_attrv( type->attrs, ATTR_CONTRACTVERSION ), len = 2 + sizeof(version); + UINT version = attr ? attr->u.ival : 0, len = 2 + sizeof(version);

buf[0] = 1; buf[1] = 0; @@ -2601,54 +2626,62 @@ static UINT make_contractversion_value( const type_t *type, BYTE *buf ) return len; }

-static void add_contractversion_attr_step1( type_t *type ) +static void add_contractversion_attr_step1( const type_t *type ) { static const BYTE sig[] = { SIG_TYPE_HASTHIS, 1, ELEMENT_TYPE_VOID, ELEMENT_TYPE_U4 }; UINT assemblyref, scope, typeref, class; + attr_t *attr;

- if (!is_attr( type->attrs, ATTR_CONTRACTVERSION )) return; + if (!(attr = get_attr( type->attrs, ATTR_CONTRACTVERSION ))) return;

assemblyref = add_assemblyref_row( 0x200, 0, add_string("Windows.Foundation") ); scope = resolution_scope( TABLE_ASSEMBLYREF, assemblyref ); typeref = add_typeref_row( scope, add_string("ContractVersionAttribute"), add_string("Windows.Foundation.Metadata") );

class = memberref_parent( TABLE_TYPEREF, typeref ); - type->md.member[MD_ATTR_CONTRACTVERSION] = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sizeof(sig)) ); + attr->md_member = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sizeof(sig)) ); }

-static void add_contractversion_attr_step2( type_t *type ) +static void add_contractversion_attr_step2( const type_t *type ) { UINT parent, attr_type, value_size; BYTE value[8]; + const attr_t *attr;

- if (!is_attr( type->attrs, ATTR_CONTRACTVERSION )) return; + if (!(attr = get_attr( type->attrs, ATTR_CONTRACTVERSION ))) return;

parent = has_customattribute( TABLE_TYPEDEF, type->md.def ); - attr_type = customattribute_type( TABLE_MEMBERREF, type->md.member[MD_ATTR_CONTRACTVERSION] ); - value_size = make_contractversion_value( type, value ); + attr_type = customattribute_type( TABLE_MEMBERREF, attr->md_member ); + value_size = make_contractversion_value( attr, value ); add_customattribute_row( parent, attr_type, add_blob(value, value_size) ); }

-static void add_apicontract_attr_step1( type_t *type ) +static void add_apicontract_attr_step1( const type_t *type ) { static const BYTE sig[] = { SIG_TYPE_HASTHIS, 0, ELEMENT_TYPE_VOID }; UINT assemblyref, scope, typeref, class; + attr_t *attr; + + if (!(attr = get_attr( type->attrs, ATTR_APICONTRACT ))) return;

assemblyref = add_assemblyref_row( 0x200, 0, add_string("Windows.Foundation") ); scope = resolution_scope( TABLE_ASSEMBLYREF, assemblyref ); typeref = add_typeref_row( scope, add_string("ApiContractAttribute"), add_string("Windows.Foundation.Metadata") );

class = memberref_parent( TABLE_TYPEREF, typeref ); - type->md.member[MD_ATTR_APICONTRACT] = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sizeof(sig)) ); + attr->md_member = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sizeof(sig)) ); }

-static void add_apicontract_attr_step2( type_t *type ) +static void add_apicontract_attr_step2( const type_t *type ) { static const BYTE value[] = { 0x01, 0x00, 0x00, 0x00 }; UINT parent, attr_type; + const attr_t *attr; + + if (!(attr = get_attr( type->attrs, ATTR_APICONTRACT ))) return;

parent = has_customattribute( TABLE_TYPEDEF, type->md.def ); - attr_type = customattribute_type( TABLE_MEMBERREF, type->md.member[MD_ATTR_APICONTRACT] ); + attr_type = customattribute_type( TABLE_MEMBERREF, attr->md_member ); add_customattribute_row( parent, attr_type, add_blob(value, sizeof(value)) ); }

@@ -2689,7 +2722,7 @@ static void add_runtimeclass_type_step1( type_t *type ) type->md.ref = add_typeref_row( resolution_scope(TABLE_MODULE, MODULE_ROW), name, namespace ); }

-static void add_default_attr( const type_t *type, UINT interfaceimpl_ref ) +static void add_default_attr( UINT interfaceimpl_ref ) { static const BYTE sig[] = { SIG_TYPE_HASTHIS, 0, ELEMENT_TYPE_VOID }; static const BYTE value[] = { 0x01, 0x00, 0x00, 0x00 }; @@ -2729,10 +2762,11 @@ static void add_method_contract_attrs( const type_t *class, const type_t *iface, { UINT parent, attr_type, value_size; BYTE value[MAX_NAME + sizeof(UINT) + 5]; + const attr_t *attr = get_attr( iface->attrs, ATTR_CONTRACT );

parent = has_customattribute( TABLE_METHODDEF, method->md.def ); - attr_type = customattribute_type( TABLE_MEMBERREF, iface->md.member[MD_ATTR_CONTRACT] ); - value_size = make_contract_value( class, value ); + attr_type = customattribute_type( TABLE_MEMBERREF, attr->md_member ); + value_size = make_contract_value( get_attr(class->attrs, ATTR_CONTRACT), value ); add_customattribute_row( parent, attr_type, add_blob(value, value_size) );

if (method->md.class_property) @@ -2777,12 +2811,13 @@ static UINT make_static_value( const expr_t *attr, BYTE *buf ) return len_iface + len_contract + 10; }

-static void add_static_attr_step1( type_t *type ) +static void add_static_attr_step1( const type_t *type ) { UINT assemblyref, scope, typeref, typeref_type, class, sig_size; BYTE sig[32]; + attr_t *attr;

- if (!is_attr( type->attrs, ATTR_STATIC )) return; + if (!(attr = get_attr( type->attrs, ATTR_STATIC ))) return;

assemblyref = add_assemblyref_row( 0x200, 0, add_string("Windows.Foundation") ); scope = resolution_scope( TABLE_ASSEMBLYREF, assemblyref ); @@ -2793,10 +2828,10 @@ static void add_static_attr_step1( type_t *type )

class = memberref_parent( TABLE_TYPEREF, typeref ); sig_size = make_member_sig3( typedef_or_ref(TABLE_TYPEREF, typeref_type), sig ); - type->md.member[MD_ATTR_STATIC] = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sig_size) ); + attr->md_member = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sig_size) ); }

-static void add_static_attr_step2( type_t *type ) +static void add_static_attr_step2( const type_t *type ) { const attr_t *attr;

@@ -2808,7 +2843,7 @@ static void add_static_attr_step2( type_t *type ) if (attr->type != ATTR_STATIC) continue;

parent = has_customattribute( TABLE_TYPEDEF, type->md.def ); - attr_type = customattribute_type( TABLE_MEMBERREF, type->md.member[MD_ATTR_STATIC] ); + attr_type = customattribute_type( TABLE_MEMBERREF, attr->md_member ); value_size = make_static_value( attr->u.pval, value ); add_customattribute_row( parent, attr_type, add_blob(value, value_size) ); } @@ -2866,7 +2901,7 @@ static UINT make_activatable_value( const expr_t *attr, BYTE *buf ) return len_iface + sizeof(version) + len_contract + len_extra; }

-static void add_activatable_attr_step1( type_t *type ) +static void add_activatable_attr_step1( const type_t *type ) { static const BYTE sig_default[] = { SIG_TYPE_HASTHIS, 2, ELEMENT_TYPE_VOID, ELEMENT_TYPE_U4, ELEMENT_TYPE_STRING }; attr_t *attr; @@ -2900,7 +2935,7 @@ static void add_activatable_attr_step1( type_t *type ) } }

-static void add_activatable_attr_step2( type_t *type ) +static void add_activatable_attr_step2( const type_t *type ) { const attr_t *attr;

@@ -2918,9 +2953,9 @@ static void add_activatable_attr_step2( type_t *type ) } }

-static UINT make_threading_value( const type_t *type, BYTE *buf ) +static UINT make_threading_value( const attr_t *attr, BYTE *buf ) { - UINT value, model = get_attrv( type->attrs, ATTR_THREADING ); + UINT value, model = attr->u.ival;

switch (model) { @@ -2945,12 +2980,13 @@ static UINT make_threading_value( const type_t *type, BYTE *buf ) return 8; }

-static void add_threading_attr_step1( type_t *type ) +static void add_threading_attr_step1( const type_t *type ) { UINT assemblyref, scope, typeref, typeref_attr, class, sig_size; BYTE sig[32]; + attr_t *attr;

- if (!is_attr( type->attrs, ATTR_THREADING )) return; + if (!(attr = get_attr( type->attrs, ATTR_THREADING ))) return;

assemblyref = add_assemblyref_row( 0x200, 0, add_string("Windows.Foundation") ); scope = resolution_scope( TABLE_ASSEMBLYREF, assemblyref ); @@ -2961,25 +2997,26 @@ static void add_threading_attr_step1( type_t *type )

class = memberref_parent( TABLE_TYPEREF, typeref_attr ); sig_size = make_member_sig2( ELEMENT_TYPE_VALUETYPE, typedef_or_ref(TABLE_TYPEREF, typeref), sig ); - type->md.member[MD_ATTR_THREADING] = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sig_size) ); + attr->md_member = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sig_size) ); }

-static void add_threading_attr_step2( type_t *type ) +static void add_threading_attr_step2( const type_t *type ) { UINT parent, attr_type, value_size; BYTE value[8]; + const attr_t *attr;

- if (!is_attr( type->attrs, ATTR_THREADING )) return; + if (!(attr = get_attr( type->attrs, ATTR_THREADING ))) return;

parent = has_customattribute( TABLE_TYPEDEF, type->md.def ); - attr_type = customattribute_type( TABLE_MEMBERREF, type->md.member[MD_ATTR_THREADING] ); - value_size = make_threading_value( type, value ); + attr_type = customattribute_type( TABLE_MEMBERREF, attr->md_member ); + value_size = make_threading_value( attr, value ); add_customattribute_row( parent, attr_type, add_blob(value, value_size) ); }

-static UINT make_marshalingbehavior_value( const type_t *type, BYTE *buf ) +static UINT make_marshalingbehavior_value( const attr_t *attr, BYTE *buf ) { - UINT marshaling = get_attrv( type->attrs, ATTR_MARSHALING_BEHAVIOR ); + UINT marshaling = attr->u.ival;

buf[0] = 1; buf[1] = 0; @@ -2988,12 +3025,13 @@ static UINT make_marshalingbehavior_value( const type_t *type, BYTE *buf ) return 8; }

-static void add_marshalingbehavior_attr_step1( type_t *type ) +static void add_marshalingbehavior_attr_step1( const type_t *type ) { UINT assemblyref, scope, typeref, typeref_attr, class, sig_size; BYTE sig[32]; + attr_t *attr;

- if (!is_attr( type->attrs, ATTR_MARSHALING_BEHAVIOR )) return; + if (!(attr = get_attr( type->attrs, ATTR_MARSHALING_BEHAVIOR ))) return;

assemblyref = add_assemblyref_row( 0x200, 0, add_string("Windows.Foundation") ); scope = resolution_scope( TABLE_ASSEMBLYREF, assemblyref ); @@ -3004,19 +3042,20 @@ static void add_marshalingbehavior_attr_step1( type_t *type )

class = memberref_parent( TABLE_TYPEREF, typeref_attr ); sig_size = make_member_sig2( ELEMENT_TYPE_VALUETYPE, typedef_or_ref(TABLE_TYPEREF, typeref), sig ); - type->md.member[MD_ATTR_MARSHALINGBEHAVIOR] = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sig_size) ); + attr->md_member = add_memberref_row( class, add_string(".ctor"), add_blob(sig, sig_size) ); }

-static void add_marshalingbehavior_attr_step2( type_t *type ) +static void add_marshalingbehavior_attr_step2( const type_t *type ) { UINT parent, attr_type, value_size; BYTE value[8]; + const attr_t *attr;

- if (!is_attr( type->attrs, ATTR_MARSHALING_BEHAVIOR )) return; + if (!(attr = get_attr( type->attrs, ATTR_MARSHALING_BEHAVIOR ))) return;

parent = has_customattribute( TABLE_TYPEDEF, type->md.def ); - attr_type = customattribute_type( TABLE_MEMBERREF, type->md.member[MD_ATTR_MARSHALINGBEHAVIOR] ); - value_size = make_marshalingbehavior_value( type, value ); + attr_type = customattribute_type( TABLE_MEMBERREF, attr->md_member ); + value_size = make_marshalingbehavior_value( attr, value ); add_customattribute_row( parent, attr_type, add_blob(value, value_size) ); }

@@ -3059,7 +3098,7 @@ static UINT make_composable_value( const expr_t *attr, BYTE *buf ) return len_iface + sizeof(access_type) + sizeof(contract_version) + len_contract + 6; }

-static void add_composable_attr_step1( type_t *type ) +static void add_composable_attr_step1( const type_t *type ) { attr_t *attr;

@@ -3084,7 +3123,7 @@ static void add_composable_attr_step1( type_t *type ) } }

-static void add_composable_attr_step2( type_t *type ) +static void add_composable_attr_step2( const type_t *type ) { const attr_t *attr;

@@ -3113,7 +3152,7 @@ static void add_member_interfaces( type_t *class ) UINT interfaceimpl_ref = add_interfaceimpl_row( class->md.def, interface ); const statement_t *stmt;

- if (is_attr( iface->attrs, ATTR_DEFAULT )) add_default_attr( class, interfaceimpl_ref ); + if (is_attr( iface->attrs, ATTR_DEFAULT )) add_default_attr( interfaceimpl_ref );

/* add properties in reverse order like midlrt */ STATEMENTS_FOR_EACH_FUNC_REV( stmt, type_iface_get_stmts(iface->type) ) @@ -3164,7 +3203,7 @@ static void add_static_interfaces( type_t *class ) static void add_activation_interfaces( const type_t *class ) { UINT flags = METHOD_ATTR_PUBLIC | METHOD_ATTR_HIDEBYSIG | METHOD_ATTR_SPECIALNAME | METHOD_ATTR_RTSPECIALNAME; - const attr_t *attr; + const attr_t *attr, *contract_attr = get_attr( class->attrs, ATTR_CONTRACT );

if (class->attrs) LIST_FOR_EACH_ENTRY_REV( attr, class->attrs, const attr_t, entry ) { @@ -3199,8 +3238,8 @@ static void add_activation_interfaces( const type_t *class ) methoddef = add_methoddef_row( METHOD_IMPL_RUNTIME, flags, add_string(".ctor"), add_blob(sig, sig_size), paramlist );

parent = has_customattribute( TABLE_METHODDEF, methoddef ); - attr_type = customattribute_type( TABLE_MEMBERREF, class->md.member[MD_ATTR_CONTRACT] ); - value_size = make_contract_value( class, value ); + attr_type = customattribute_type( TABLE_MEMBERREF, contract_attr->md_member ); + value_size = make_contract_value( contract_attr, value ); add_customattribute_row( parent, attr_type, add_blob(value, value_size) ); } } @@ -3208,7 +3247,7 @@ static void add_activation_interfaces( const type_t *class ) static void add_composition_interfaces( const type_t *class ) { UINT flags = METHOD_ATTR_FAMILY | METHOD_ATTR_HIDEBYSIG | METHOD_ATTR_SPECIALNAME | METHOD_ATTR_RTSPECIALNAME; - const attr_t *attr; + const attr_t *attr, *contract_attr = get_attr( class->attrs, ATTR_CONTRACT );

if (class->attrs) LIST_FOR_EACH_ENTRY_REV( attr, class->attrs, const attr_t, entry ) { @@ -3244,8 +3283,8 @@ static void add_composition_interfaces( const type_t *class ) methoddef = add_methoddef_row( METHOD_IMPL_RUNTIME, flags, add_string(".ctor"), add_blob(sig, sig_size), paramlist );

parent = has_customattribute( TABLE_METHODDEF, methoddef ); - attr_type = customattribute_type( TABLE_MEMBERREF, class->md.member[MD_ATTR_CONTRACT] ); - value_size = make_contract_value( class, value ); + attr_type = customattribute_type( TABLE_MEMBERREF, contract_attr->md_member ); + value_size = make_contract_value( contract_attr, value ); add_customattribute_row( parent, attr_type, add_blob(value, value_size) ); } } diff --git a/tools/widl/widltypes.h b/tools/widl/widltypes.h index c05b98b43f4..1e5cfbd8a1f 100644 --- a/tools/widl/widltypes.h +++ b/tools/widl/widltypes.h @@ -344,10 +344,11 @@ struct _attr_t { unsigned int ival; void *pval; } u; + /* metadata */ + unsigned int md_member; /* parser-internal */ struct list entry; struct location where; - unsigned int md_member; };

struct integer @@ -499,30 +500,11 @@ enum type_type TYPE_DELEGATE, };

-enum -{ - MD_ATTR_CONTRACT, - MD_ATTR_FLAGS, - MD_ATTR_APICONTRACT, - MD_ATTR_CONTRACTVERSION, - MD_ATTR_VERSION, - MD_ATTR_UUID, - MD_ATTR_EXCLUSIVETO, - MD_ATTR_STATIC, - MD_ATTR_THREADING, - MD_ATTR_MARSHALINGBEHAVIOR, - MD_ATTR_OVERLOAD, - MD_ATTR_DEFAULT_OVERLOAD, - MD_ATTR_DEPRECATED, - MD_ATTR_MAX, -}; - struct metadata { unsigned int ref; unsigned int def; unsigned int extends; - unsigned int member[MD_ATTR_MAX]; /* get/put methods */ unsigned int class_property; unsigned int iface_property;

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/8690

Rémi Bernon (＠rbernon)

11:15 a.m.

Rémi Bernon (@rbernon) commented about tools/widl/parser.y:

...

;

version:
 aNUM					{ $$ = MAKEVERSION($1.value, 0); }
| aNUM '.' aNUM { $$ = MAKEVERSION($1.value, $3.value); }
 aNUM					{ $$ = winrt_mode ? MAKEVERSION(0, $1.value) : MAKEVERSION($1.value, 0); }
| aNUM '.' aNUM { $$ = winrt_mode ? MAKEVERSION($3.value, $1.value) : MAKEVERSION($1.value, $3.value); }

I feel that this isn't the right place for this, MAKEVERSION comment and the two related macros expect a specific major/minor ordering. Maybe it would be cleaner to use an explicit version struct and decide on the typelib/winmd serialization side how to mangle major/minor into the output.

-- https://gitlab.winehq.org/wine/wine/-/merge_requests/8690#note_111804

Age (days ago)

Last active (days ago)

wine-gitlab@winehq.org

7 comments

3 participants

tags (0)

participants (3)

Hans Leidekker
Hans Leidekker (＠hans)
Rémi Bernon (＠rbernon)