-- v2: widl: Add rows for the requires keyword. widl: Add rows for the exclusiveto attribute. widl: Add rows for the uuid attribute. widl: Add rows for the interface type.
From: Hans Leidekker hans@codeweavers.com
--- tools/widl/metadata.c | 108 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 108 insertions(+)
diff --git a/tools/widl/metadata.c b/tools/widl/metadata.c index ee8222ee35e..a58089e3455 100644 --- a/tools/widl/metadata.c +++ b/tools/widl/metadata.c @@ -1112,6 +1112,65 @@ enum
static char *assembly_name;
+static enum element_type map_basic_type( enum type_basic_type type, int sign ) +{ + enum element_type elem_type; + + switch (type) + { + case TYPE_BASIC_CHAR: elem_type = ELEMENT_TYPE_BOOLEAN; break; + case TYPE_BASIC_INT16: elem_type = (sign > 0) ? ELEMENT_TYPE_U2 : ELEMENT_TYPE_I2; break; + case TYPE_BASIC_INT: + case TYPE_BASIC_INT32: + case TYPE_BASIC_LONG: elem_type = (sign > 0) ? ELEMENT_TYPE_U4 : ELEMENT_TYPE_I4; break; + case TYPE_BASIC_INT64: elem_type = (sign > 0) ? ELEMENT_TYPE_U8 : ELEMENT_TYPE_I8; break; + case TYPE_BASIC_BYTE: elem_type = ELEMENT_TYPE_U1; break; + case TYPE_BASIC_WCHAR: elem_type = ELEMENT_TYPE_CHAR; break; + case TYPE_BASIC_FLOAT: elem_type = ELEMENT_TYPE_R4; break; + case TYPE_BASIC_DOUBLE: elem_type = ELEMENT_TYPE_R8; break; + default: + fprintf( stderr, "Unhandled basic type %u.\n", type ); + exit( 1 ); + } + return elem_type; +} + +static UINT make_struct_field_sig( const var_t *var, BYTE *buf ) +{ + const type_t *type = var->declspec.type; + + if (!strcmp( type->name, "HSTRING" )) + { + buf[0] = SIG_TYPE_FIELD; + buf[1] = ELEMENT_TYPE_STRING; + return 2; + } + + if (!strcmp( type->name, "GUID" )) + { + UINT token = typedef_or_ref( TABLE_TYPEREF, type->md.ref ); + return make_field_value_sig( token, buf ); + } + + type = type_get_real_type( type ); + + if (type_get_type( type ) == TYPE_ENUM || type_get_type( type ) == TYPE_STRUCT) + { + UINT token = typedef_or_ref( TABLE_TYPEREF, type->md.ref ); + return make_field_value_sig( token, buf ); + } + + if (type_get_type( type ) != TYPE_BASIC) + { + fprintf( stderr, "Unhandled struct field type %u.\n", type_get_type( type ) ); + exit( 1 ); + } + + buf[0] = SIG_TYPE_FIELD; + buf[1] = map_basic_type( type_basic_get_type(type), type_basic_get_sign(type) ); + return 2; +} + static UINT make_member_sig( UINT token, BYTE *buf ) { UINT len = 4; @@ -1294,6 +1353,49 @@ static void add_enum_type_step2( type_t *type ) add_flags_attr_step2( type ); }
+static void add_struct_type_step1( type_t *type ) +{ + UINT name, namespace, scope, typeref; + const var_t *var; + + name = add_name( type, &namespace ); + scope = resolution_scope( TABLE_ASSEMBLYREF, MSCORLIB_ROW ); + + LIST_FOR_EACH_ENTRY( var, type_struct_get_fields(type), const var_t, entry ) + { + type_t *field_type = var->declspec.type; + if (!strcmp( field_type->name, "GUID" )) + field_type->md.ref = add_typeref_row( scope, add_string("Guid"), add_string("System") ); + } + + typeref = add_typeref_row( scope, add_string("ValueType"), add_string("System") ); + type->md.extends = typedef_or_ref( TABLE_TYPEREF, typeref ); + type->md.ref = add_typeref_row( resolution_scope(TABLE_MODULE, MODULE_ROW), name, namespace ); + + add_contract_attr_step1( type ); +} + +static void add_struct_type_step2( type_t *type ) +{ + UINT name, namespace, field, flags, sig_size, first_field = 0; + const var_t *var; + BYTE sig[32]; + + name = add_name( type, &namespace ); + + LIST_FOR_EACH_ENTRY( var, type_struct_get_fields(type), const var_t, entry ) + { + sig_size = make_struct_field_sig( var, sig ); + field = add_field_row( FIELD_ATTR_PUBLIC, add_string(var->name), add_blob(sig, sig_size) ); + if (!first_field) first_field = field; + } + + flags = TYPE_ATTR_PUBLIC | TYPE_ATTR_SEQUENTIALLAYOUT | TYPE_ATTR_SEALED | TYPE_ATTR_UNKNOWN; + type->md.def = add_typedef_row( flags, name, namespace, type->md.extends, first_field, 0 ); + + add_contract_attr_step2( type ); +} + static UINT make_contractversion_value( const type_t *type, BYTE *buf ) { UINT version = get_attrv( type->attrs, ATTR_CONTRACTVERSION ), len = 2 + sizeof(version); @@ -1402,6 +1504,9 @@ static void build_tables( const statement_list_t *stmt_list ) case TYPE_ENUM: add_enum_type_step1( type ); break; + case TYPE_STRUCT: + add_struct_type_step1( type ); + break; case TYPE_APICONTRACT: add_apicontract_type_step1( type ); break; @@ -1422,6 +1527,9 @@ static void build_tables( const statement_list_t *stmt_list ) case TYPE_ENUM: add_enum_type_step2( type ); break; + case TYPE_STRUCT: + add_struct_type_step2( type ); + break; case TYPE_APICONTRACT: add_apicontract_type_step2( type ); break;
From: Hans Leidekker hans@codeweavers.com
--- tools/widl/metadata.c | 60 +++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 58 insertions(+), 2 deletions(-)
diff --git a/tools/widl/metadata.c b/tools/widl/metadata.c index a58089e3455..4f162976a6f 100644 --- a/tools/widl/metadata.c +++ b/tools/widl/metadata.c @@ -1084,10 +1084,37 @@ enum #define MODULE_ROW 1 #define MSCORLIB_ROW 1
+static char *make_shortname( const char *src ) +{ + char *dst; + const char *ptr = strchr( src, '<' ); + UINT len, count = 1, level = 0; + + if (!ptr) return (char *)src; + + len = ptr - src; + dst = xmalloc( len + 12 ); + memcpy( dst, src, ptr - src ); + while (*ptr) + { + if (*ptr == '<') level++; + if (*ptr == '>' && !--level) break; + if (level == 1 && *ptr == ',') count++; + ptr++; + } + sprintf( dst + len, "`%u", count ); + return dst; +} + static UINT add_name( type_t *type, UINT *namespace ) { - UINT name = add_string( type->name ); - char *str = format_namespace( type->namespace, "", ".", NULL, NULL ); + char *str = make_shortname( type->name ); + UINT name; + + name = add_string( str ); + if (str != type->name) free( str ); + + str = format_namespace( type->namespace, "", ".", NULL, NULL ); *namespace = add_string( str ); free( str ); return name; @@ -1396,6 +1423,29 @@ static void add_struct_type_step2( type_t *type ) add_contract_attr_step2( type ); }
+static void add_interface_type_step1( type_t *type ) +{ + UINT name, namespace; + + name = add_name( type, &namespace ); + + type->md.ref = add_typeref_row( resolution_scope(TABLE_MODULE, MODULE_ROW), name, namespace ); + + add_contract_attr_step1( type ); +} + +static void add_interface_type_step2( type_t *type ) +{ + UINT name, namespace, flags = TYPE_ATTR_INTERFACE | TYPE_ATTR_ABSTRACT | TYPE_ATTR_UNKNOWN; + + name = add_name( type, &namespace ); + + if (!is_attr( type->attrs, ATTR_EXCLUSIVETO )) flags |= TYPE_ATTR_PUBLIC; + type->md.def = add_typedef_row( flags, name, namespace, 0, 0, 0 ); + + add_contract_attr_step2( type ); +} + static UINT make_contractversion_value( const type_t *type, BYTE *buf ) { UINT version = get_attrv( type->attrs, ATTR_CONTRACTVERSION ), len = 2 + sizeof(version); @@ -1507,6 +1557,9 @@ static void build_tables( const statement_list_t *stmt_list ) case TYPE_STRUCT: add_struct_type_step1( type ); break; + case TYPE_INTERFACE: + add_interface_type_step1( type ); + break; case TYPE_APICONTRACT: add_apicontract_type_step1( type ); break; @@ -1530,6 +1583,9 @@ static void build_tables( const statement_list_t *stmt_list ) case TYPE_STRUCT: add_struct_type_step2( type ); break; + case TYPE_INTERFACE: + add_interface_type_step2( type ); + break; case TYPE_APICONTRACT: add_apicontract_type_step2( type ); break;
From: Hans Leidekker hans@codeweavers.com
--- tools/widl/metadata.c | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+)
diff --git a/tools/widl/metadata.c b/tools/widl/metadata.c index 4f162976a6f..cdc1612d591 100644 --- a/tools/widl/metadata.c +++ b/tools/widl/metadata.c @@ -1423,6 +1423,38 @@ static void add_struct_type_step2( type_t *type ) add_contract_attr_step2( type ); }
+static void add_uuid_attr_step1( 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; + + 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)) ); +} + +static void add_uuid_attr_step2( 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 ); + BYTE value[sizeof(*uuid) + 4] = { 0x01 }; + UINT parent, attr_type; + + if (uuid) memcpy( value + 2, uuid, sizeof(*uuid) ); + else memcpy( value + 2, default_uuid, sizeof(default_uuid) ); + + parent = has_customattribute( TABLE_TYPEDEF, type->md.def ); + attr_type = customattribute_type( TABLE_MEMBERREF, type->md.member[MD_ATTR_UUID] ); + add_customattribute_row( parent, attr_type, add_blob(value, sizeof(value)) ); +} + static void add_interface_type_step1( type_t *type ) { UINT name, namespace; @@ -1432,6 +1464,7 @@ static void add_interface_type_step1( type_t *type ) type->md.ref = add_typeref_row( resolution_scope(TABLE_MODULE, MODULE_ROW), name, namespace );
add_contract_attr_step1( type ); + add_uuid_attr_step1( type ); }
static void add_interface_type_step2( type_t *type ) @@ -1444,6 +1477,7 @@ static void add_interface_type_step2( type_t *type ) type->md.def = add_typedef_row( flags, name, namespace, 0, 0, 0 );
add_contract_attr_step2( type ); + add_uuid_attr_step2( type ); }
static UINT make_contractversion_value( const type_t *type, BYTE *buf )
From: Hans Leidekker hans@codeweavers.com
--- tools/widl/metadata.c | 64 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+)
diff --git a/tools/widl/metadata.c b/tools/widl/metadata.c index cdc1612d591..59b88ee12a8 100644 --- a/tools/widl/metadata.c +++ b/tools/widl/metadata.c @@ -1211,6 +1211,18 @@ static UINT make_member_sig( UINT token, BYTE *buf ) return len; }
+static UINT make_member_sig2( UINT type, UINT token, BYTE *buf ) +{ + UINT len = 4; + + buf[0] = SIG_TYPE_HASTHIS; + buf[1] = 1; + buf[2] = ELEMENT_TYPE_VOID; + buf[3] = type; + len += encode_int( token, buf + 4 ); + return len; +} + static UINT make_contract_value( const type_t *type, BYTE *buf ) { const expr_t *contract = get_attrp( type->attrs, ATTR_CONTRACT ); @@ -1455,6 +1467,56 @@ static void add_uuid_attr_step2( type_t *type ) add_customattribute_row( parent, attr_type, add_blob(value, sizeof(value)) ); }
+static UINT make_exclusiveto_value( const type_t *type, BYTE *buf ) +{ + const type_t *attr = get_attrp( type->attrs, ATTR_EXCLUSIVETO ); + char *name = format_namespace( attr->namespace, "", ".", attr->name, NULL ); + UINT len = strlen( name ); + + buf[0] = 1; + buf[1] = 0; + buf[2] = len; + memcpy( buf + 3, name, len ); + len += 3; + buf[len++] = 0; + buf[len++] = 0; + + free( name ); + return len; +} + +static void add_exclusiveto_attr_step1( type_t *type ) +{ + UINT assemblyref, scope, typeref, typeref_type, class, sig_size; + BYTE sig[32]; + + if (!is_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") ); + + assemblyref = add_assemblyref_row( 0x200, 0, add_string("Windows.Foundation") ); + scope = resolution_scope( TABLE_ASSEMBLYREF, assemblyref ); + typeref = add_typeref_row( scope, add_string("ExclusiveToAttribute"), add_string("Windows.Foundation.Metadata") ); + + 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) ); +} + +static void add_exclusiveto_attr_step2( type_t *type ) +{ + UINT parent, attr_type, value_size; + BYTE value[256 + 5]; + + if (!is_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 ); + add_customattribute_row( parent, attr_type, add_blob(value, value_size) ); +} + static void add_interface_type_step1( type_t *type ) { UINT name, namespace; @@ -1465,6 +1527,7 @@ static void add_interface_type_step1( type_t *type )
add_contract_attr_step1( type ); add_uuid_attr_step1( type ); + add_exclusiveto_attr_step1( type ); }
static void add_interface_type_step2( type_t *type ) @@ -1478,6 +1541,7 @@ static void add_interface_type_step2( type_t *type )
add_contract_attr_step2( type ); add_uuid_attr_step2( type ); + add_exclusiveto_attr_step2( type ); }
static UINT make_contractversion_value( const type_t *type, BYTE *buf )
From: Hans Leidekker hans@codeweavers.com
--- tools/widl/metadata.c | 50 ++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 49 insertions(+), 1 deletion(-)
diff --git a/tools/widl/metadata.c b/tools/widl/metadata.c index 59b88ee12a8..64c51f5de44 100644 --- a/tools/widl/metadata.c +++ b/tools/widl/metadata.c @@ -718,6 +718,45 @@ static void serialize_field_table( void ) } }
+struct interfaceimpl_row +{ + UINT class; + UINT interface; +}; + +static UINT add_interfaceimpl_row( UINT class, UINT interface ) +{ + struct interfaceimpl_row row = { class, interface }; + return add_row( TABLE_INTERFACEIMPL, (const BYTE *)&row, sizeof(row) ); +} + +static int cmp_interfaceimpl_row( const void *a, const void *b ) +{ + const struct interfaceimpl_row *row = a, *row2 = b; + if (row->class > row2->class) return 1; + if (row->class < row2->class) return -1; + if (row->interface > row2->interface) return 1; + if (row->interface < row2->interface) return -1; + return 0; +} + +/* sorted by class, interface */ +static void serialize_interfaceimpl_table( void ) +{ + const struct interfaceimpl_row *row = (const struct interfaceimpl_row *)tables[TABLE_INTERFACEIMPL].ptr; + UINT i; + + qsort( tables[TABLE_INTERFACEIMPL].ptr, tables[TABLE_INTERFACEIMPL].count, sizeof(*row), + cmp_interfaceimpl_row ); + + for (i = 0; i < tables_idx[TABLE_INTERFACEIMPL].count; i++) + { + serialize_table_idx( row->class, TABLE_TYPEDEF ); + serialize_table_idx( row->interface, typedef_or_ref_to_table(row->interface) ); + row++; + } +} + struct memberref_row { UINT class; @@ -1532,13 +1571,21 @@ static void add_interface_type_step1( type_t *type )
static void add_interface_type_step2( type_t *type ) { - UINT name, namespace, flags = TYPE_ATTR_INTERFACE | TYPE_ATTR_ABSTRACT | TYPE_ATTR_UNKNOWN; + UINT name, namespace, interface, flags = TYPE_ATTR_INTERFACE | TYPE_ATTR_ABSTRACT | TYPE_ATTR_UNKNOWN; + const typeref_list_t *require_list = type_iface_get_requires( type ); + const typeref_t *require;
name = add_name( type, &namespace );
if (!is_attr( type->attrs, ATTR_EXCLUSIVETO )) flags |= TYPE_ATTR_PUBLIC; type->md.def = add_typedef_row( flags, name, namespace, 0, 0, 0 );
+ if (require_list) LIST_FOR_EACH_ENTRY( require, require_list, typeref_t, entry ) + { + interface = typedef_or_ref( TABLE_TYPEREF, require->type->md.ref ); + add_interfaceimpl_row( type->md.def, interface ); + } + add_contract_attr_step2( type ); add_uuid_attr_step2( type ); add_exclusiveto_attr_step2( type ); @@ -1731,6 +1778,7 @@ static void build_table_stream( const statement_list_t *stmts ) serialize_typeref_table(); serialize_typedef_table(); serialize_field_table(); + serialize_interfaceimpl_table(); serialize_memberref_table(); serialize_constant_table(); serialize_customattribute_table();
On Fri Jun 6 10:20:20 2025 +0000, Rémi Bernon wrote:
I forgot to include the name mangling changes when splitting patches. Does this look better?
On Fri Jun 6 11:03:27 2025 +0000, Hans Leidekker wrote:
I forgot to include the name mangling changes when splitting patches. Does this look better?
Well, not really. This strips all the parameters from the parameterized interfaces (p-iface) and merges all of the p-iface instanciations together, and now they have multiple GUIDs associated with each (every specialization of a p-iface generates a new GUID based on its parameters).
The p-ifaces specializations should simply not appear as `typedefs` in the output, though they may as `typerefs`, but in that case with the full parameter list as in ``Type`n<Parameters...>``.
Note that parameters themselves can also be p-iface specializations, so you will probably need to yet another flavor of names. I'd suggest to generate them on type creation in `type_parameterized_type_specialize_declare`.
On Fri Jun 6 11:21:58 2025 +0000, Rémi Bernon wrote:
Right I have mostly been ignoring parameterized types, working from IDL snippets rather than our IDL files because that's still a way to go. Would you mind if I address this later?
On Fri Jun 6 12:11:29 2025 +0000, Hans Leidekker wrote:
In that case let's remove the `make_shortname` helper which would not be needed and add something like this to skip p-ifaces in the step1/step2 TYPE_INTERFACE cases:
``` if (type->signature && !strncmp( type->signature, "pinterface", 10 )) { fprintf( stderr, "Ingoring unsupported %s parameterized interface\n", type->name ); break; } ```
-
Hans Leidekker -
Hans Leidekker (＠hans)
-
Rémi Bernon (＠rbernon)