Patches taken from !6207, no-op but should make the `write_type` helpers more readable and flexible.
From: Rémi Bernon rbernon@codeweavers.com
--- tools/widl/header.c | 19 ---- tools/widl/typetree.c | 235 +++++++++++++++++++++-------------------- tools/widl/typetree.h | 5 + tools/widl/utils.c | 38 +++---- tools/widl/utils.h | 10 +- tools/widl/widltypes.h | 4 - 6 files changed, 149 insertions(+), 162 deletions(-)
diff --git a/tools/widl/header.c b/tools/widl/header.c index 81a789a74df..5409c79839c 100644 --- a/tools/widl/header.c +++ b/tools/widl/header.c @@ -66,25 +66,6 @@ static void write_line(FILE *f, int delta, const char *fmt, ...) fprintf(f, "\n"); }
-static char *format_parameterized_type_args(const type_t *type, const char *prefix, const char *suffix) -{ - typeref_list_t *params; - typeref_t *ref; - size_t len = 0, pos = 0; - char *buf = NULL; - - params = type->details.parameterized.params; - if (params) LIST_FOR_EACH_ENTRY(ref, params, typeref_t, entry) - { - assert(ref->type->type_type != TYPE_POINTER); - pos += strappend(&buf, &len, pos, "%s%s%s", prefix, ref->type->name, suffix); - if (list_next(params, &ref->entry)) pos += strappend(&buf, &len, pos, ", "); - } - - if (!buf) return xstrdup(""); - return buf; -} - static void write_guid(FILE *f, const char *guid_prefix, const char *name, const struct uuid *uuid) { if (!uuid) return; diff --git a/tools/widl/typetree.c b/tools/widl/typetree.c index 441b6cdcea1..b8b7f3853fa 100644 --- a/tools/widl/typetree.c +++ b/tools/widl/typetree.c @@ -109,58 +109,54 @@ const char *type_get_name(const type_t *type, enum name_type name_type) return NULL; }
-static size_t append_namespace(char **buf, size_t *len, size_t pos, struct namespace *namespace, const char *separator, const char *abi_prefix) +static void append_namespace( struct strbuf *str, const struct namespace *namespace, + const char *separator, const char *abi_prefix ) { int nested = namespace && !is_global_namespace(namespace); const char *name = nested ? namespace->name : abi_prefix; - size_t n = 0; - if (!name) return 0; - if (nested) n += append_namespace(buf, len, pos + n, namespace->parent, separator, abi_prefix); - n += strappend(buf, len, pos + n, "%s%s", name, separator); - return n; + if (!name) return; + if (nested) append_namespace( str, namespace->parent, separator, abi_prefix ); + strappend( str, "%s%s", name, separator ); }
-static size_t append_namespaces(char **buf, size_t *len, size_t pos, struct namespace *namespace, const char *prefix, - const char *separator, const char *suffix, const char *abi_prefix) +static void append_namespaces( struct strbuf *str, const struct namespace *namespace, const char *prefix, + const char *separator, const char *suffix, const char *abi_prefix ) { int nested = namespace && !is_global_namespace(namespace); - size_t n = 0; - n += strappend(buf, len, pos + n, "%s", prefix); - if (nested) n += append_namespace(buf, len, pos + n, namespace, separator, abi_prefix); - if (suffix) n += strappend(buf, len, pos + n, "%s", suffix); + strappend( str, "%s", prefix ); + if (nested) append_namespace( str, namespace, separator, abi_prefix ); + if (suffix) strappend( str, "%s", suffix ); else if (nested) { - n -= strlen(separator); - (*buf)[n] = 0; + str->pos -= strlen( separator ); + str->buf[str->pos] = 0; } - return n; }
-static size_t append_pointer_stars(char **buf, size_t *len, size_t pos, type_t *type) +static void append_pointer_stars( struct strbuf *str, type_t *type ) { - size_t n = 0; - for (; type && type->type_type == TYPE_POINTER; type = type_pointer_get_ref_type(type)) n += strappend(buf, len, pos + n, "*"); - return n; + for (; type && type_is_ptr( type ); type = type_pointer_get_ref_type( type )) + strappend( str, "*" ); }
-static size_t append_type_signature(char **buf, size_t *len, size_t pos, type_t *type); +static size_t append_type_signature( struct strbuf *str, type_t *type );
-static size_t append_var_list_signature(char **buf, size_t *len, size_t pos, var_list_t *var_list) +static size_t append_var_list_signature( struct strbuf *str, var_list_t *var_list ) { var_t *var; size_t n = 0;
- if (!var_list) n += strappend(buf, len, pos + n, ";"); + if (!var_list) strappend( str, ";" ); else LIST_FOR_EACH_ENTRY(var, var_list, var_t, entry) { - n += strappend(buf, len, pos + n, ";"); - n += append_type_signature(buf, len, pos + n, var->declspec.type); + strappend( str, ";" ); + append_type_signature( str, var->declspec.type ); }
return n; }
-static size_t append_type_signature(char **buf, size_t *len, size_t pos, type_t *type) +static size_t append_type_signature( struct strbuf *str, type_t *type ) { const struct uuid *uuid; size_t n = 0; @@ -169,72 +165,71 @@ static size_t append_type_signature(char **buf, size_t *len, size_t pos, type_t switch (type->type_type) { case TYPE_INTERFACE: - if (!strcmp(type->name, "IInspectable")) n += strappend(buf, len, pos + n, "cinterface(IInspectable)"); - else if (type->signature) n += strappend(buf, len, pos + n, "%s", type->signature); + if (!strcmp( type->name, "IInspectable" )) strappend( str, "cinterface(IInspectable)" ); + else if (type->signature) strappend( str, "%s", type->signature ); else { if (!(uuid = get_attrp( type->attrs, ATTR_UUID ))) error_at( &type->where, "cannot compute type signature, no uuid found for type %s.\n", type->name );
- n += strappend(buf, len, pos + n, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}", - uuid->Data1, uuid->Data2, uuid->Data3, - uuid->Data4[0], uuid->Data4[1], uuid->Data4[2], uuid->Data4[3], - uuid->Data4[4], uuid->Data4[5], uuid->Data4[6], uuid->Data4[7]); + strappend( str, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}", uuid->Data1, + uuid->Data2, uuid->Data3, uuid->Data4[0], uuid->Data4[1], uuid->Data4[2], + uuid->Data4[3], uuid->Data4[4], uuid->Data4[5], uuid->Data4[6], uuid->Data4[7] ); } return n; case TYPE_DELEGATE: - n += strappend(buf, len, pos + n, "delegate("); - n += append_type_signature(buf, len, pos + n, type_delegate_get_iface(type)); - n += strappend(buf, len, pos + n, ")"); + strappend( str, "delegate(" ); + append_type_signature( str, type_delegate_get_iface( type ) ); + strappend( str, ")" ); return n; case TYPE_RUNTIMECLASS: - n += strappend(buf, len, pos + n, "rc("); - n += append_namespaces(buf, len, pos + n, type->namespace, "", ".", type->name, NULL); - n += strappend(buf, len, pos + n, ";"); - n += append_type_signature(buf, len, pos + n, type_runtimeclass_get_default_iface(type, TRUE)); - n += strappend(buf, len, pos + n, ")"); + strappend( str, "rc(" ); + append_namespaces( str, type->namespace, "", ".", type->name, NULL ); + strappend( str, ";" ); + append_type_signature( str, type_runtimeclass_get_default_iface( type, TRUE ) ); + strappend( str, ")" ); return n; case TYPE_POINTER: - n += append_type_signature(buf, len, pos + n, type->details.pointer.ref.type); + append_type_signature( str, type->details.pointer.ref.type ); return n; case TYPE_ALIAS: - if (!strcmp(type->name, "boolean")) n += strappend(buf, len, pos + n, "b1"); - else if (!strcmp(type->name, "GUID")) n += strappend(buf, len, pos + n, "g16"); - else if (!strcmp(type->name, "HSTRING")) n += strappend(buf, len, pos + n, "string"); - else n += append_type_signature(buf, len, pos + n, type->details.alias.aliasee.type); + if (!strcmp( type->name, "boolean" )) strappend( str, "b1" ); + else if (!strcmp( type->name, "GUID" )) strappend( str, "g16" ); + else if (!strcmp( type->name, "HSTRING" )) strappend( str, "string" ); + else append_type_signature( str, type->details.alias.aliasee.type ); return n; case TYPE_STRUCT: - n += strappend(buf, len, pos + n, "struct("); - n += append_namespaces(buf, len, pos + n, type->namespace, "", ".", type->name, NULL); - n += append_var_list_signature(buf, len, pos + n, type->details.structure->fields); - n += strappend(buf, len, pos + n, ")"); + strappend( str, "struct(" ); + append_namespaces( str, type->namespace, "", ".", type->name, NULL ); + append_var_list_signature( str, type->details.structure->fields ); + strappend( str, ")" ); return n; case TYPE_BASIC: switch (type_basic_get_type(type)) { case TYPE_BASIC_INT16: - n += strappend(buf, len, pos + n, type_basic_get_sign(type) <= 0 ? "i2" : "u2"); + strappend( str, type_basic_get_sign( type ) <= 0 ? "i2" : "u2" ); return n; case TYPE_BASIC_INT: case TYPE_BASIC_INT32: case TYPE_BASIC_LONG: - n += strappend(buf, len, pos + n, type_basic_get_sign(type) <= 0 ? "i4" : "u4"); + strappend( str, type_basic_get_sign( type ) <= 0 ? "i4" : "u4" ); return n; case TYPE_BASIC_INT64: - n += strappend(buf, len, pos + n, type_basic_get_sign(type) <= 0 ? "i8" : "u8"); + strappend( str, type_basic_get_sign( type ) <= 0 ? "i8" : "u8" ); return n; case TYPE_BASIC_INT8: assert(type_basic_get_sign(type) > 0); /* signature string for signed char isn't specified */ - n += strappend(buf, len, pos + n, "u1"); + strappend( str, "u1" ); return n; case TYPE_BASIC_FLOAT: - n += strappend(buf, len, pos + n, "f4"); + strappend( str, "f4" ); return n; case TYPE_BASIC_DOUBLE: - n += strappend(buf, len, pos + n, "f8"); + strappend( str, "f8" ); return n; case TYPE_BASIC_BYTE: - n += strappend(buf, len, pos + n, "u1"); + strappend( str, "u1" ); return n; case TYPE_BASIC_INT3264: case TYPE_BASIC_CHAR: @@ -247,11 +242,11 @@ static size_t append_type_signature(char **buf, size_t *len, size_t pos, type_t break; } case TYPE_ENUM: - n += strappend(buf, len, pos + n, "enum("); - n += append_namespaces(buf, len, pos + n, type->namespace, "", ".", type->name, NULL); - if (is_attr(type->attrs, ATTR_FLAGS)) n += strappend(buf, len, pos + n, ";u4"); - else n += strappend(buf, len, pos + n, ";i4"); - n += strappend(buf, len, pos + n, ")"); + strappend( str, "enum(" ); + append_namespaces( str, type->namespace, "", ".", type->name, NULL ); + if (is_attr( type->attrs, ATTR_FLAGS )) strappend( str, ";u4" ); + else strappend( str, ";i4" ); + strappend( str, ")" ); return n; case TYPE_ARRAY: case TYPE_ENCAPSULATED_UNION: @@ -274,31 +269,48 @@ static size_t append_type_signature(char **buf, size_t *len, size_t pos, type_t return n; }
-char *format_namespace(struct namespace *namespace, const char *prefix, const char *separator, const char *suffix, const char *abi_prefix) +char *format_namespace( const struct namespace *namespace, const char *prefix, const char *separator, + const char *suffix, const char *abi_prefix ) { - size_t len = 0; - char *buf = NULL; - append_namespaces(&buf, &len, 0, namespace, prefix, separator, suffix, abi_prefix); - return buf; + struct strbuf str = {0}; + append_namespaces( &str, namespace, prefix, separator, suffix, abi_prefix ); + return str.buf; }
-char *format_parameterized_type_name(type_t *type, typeref_list_t *params) +char *format_parameterized_type_name( const type_t *type, const typeref_list_t *params ) { - size_t len = 0, pos = 0; - char *buf = NULL; + struct strbuf str = {0}; typeref_t *ref;
- pos += strappend(&buf, &len, pos, "%s<", type->name); + strappend( &str, "%s<", type->name ); if (params) LIST_FOR_EACH_ENTRY(ref, params, typeref_t, entry) { type = type_pointer_get_root_type(ref->type); - pos += strappend(&buf, &len, pos, "%s", type->qualified_name); - pos += append_pointer_stars(&buf, &len, pos, ref->type); - if (list_next(params, &ref->entry)) pos += strappend(&buf, &len, pos, ","); + strappend( &str, "%s", type->qualified_name ); + append_pointer_stars( &str, ref->type ); + if (list_next( params, &ref->entry )) strappend( &str, "," ); + } + strappend( &str, " >" ); + + return str.buf; +} + +char *format_parameterized_type_args( const type_t *type, const char *prefix, const char *suffix ) +{ + struct strbuf str = {0}; + typeref_list_t *params; + typeref_t *ref; + + params = type->details.parameterized.params; + if (params) LIST_FOR_EACH_ENTRY( ref, params, typeref_t, entry ) + { + assert( ref->type->type_type != TYPE_POINTER ); + strappend( &str, "%s%s%s", prefix, ref->type->name, suffix ); + if (list_next( params, &ref->entry )) strappend( &str, ", " ); } - pos += strappend(&buf, &len, pos, " >");
- return buf; + if (!str.buf) return xstrdup( "" ); + return str.buf; }
static char const *parameterized_type_shorthands[][2] = { @@ -310,109 +322,104 @@ static char const *parameterized_type_shorthands[][2] = {
static char *format_parameterized_type_c_name(type_t *type, typeref_list_t *params, const char *prefix, const char *separator) { + struct strbuf str = {0}; const char *tmp, *ns_prefix = "__x_", *abi_prefix = NULL; - size_t len = 0, pos = 0; - char *buf = NULL; int i, count = params ? list_count(params) : 0; typeref_t *ref;
if (!strcmp(separator, "__C")) ns_prefix = "_C"; else if (use_abi_namespace) abi_prefix = "ABI";
- pos += append_namespaces(&buf, &len, pos, type->namespace, ns_prefix, separator, "", abi_prefix); - pos += strappend(&buf, &len, pos, "%s%s_%d", prefix, type->name, count); + append_namespaces( &str, type->namespace, ns_prefix, separator, "", abi_prefix ); + strappend( &str, "%s%s_%d", prefix, type->name, count ); if (params) LIST_FOR_EACH_ENTRY(ref, params, typeref_t, entry) { type = type_pointer_get_root_type(ref->type); - if ((tmp = type->param_name)) pos += strappend(&buf, &len, pos, "_%s", tmp); - else pos += append_namespaces(&buf, &len, pos, type->namespace, "_", "__C", type->name, NULL); + if ((tmp = type->param_name)) strappend( &str, "_%s", tmp ); + else append_namespaces( &str, type->namespace, "_", "__C", type->name, NULL ); }
for (i = 0; i < ARRAY_SIZE(parameterized_type_shorthands); ++i) { - if ((tmp = strstr(buf, parameterized_type_shorthands[i][0])) && - (tmp - buf) == strlen(ns_prefix) + (abi_prefix ? 5 : 0)) + if ((tmp = strstr( str.buf, parameterized_type_shorthands[i][0] )) && + (tmp - str.buf) == strlen( ns_prefix ) + (abi_prefix ? 5 : 0)) { tmp += strlen(parameterized_type_shorthands[i][0]); - strcpy(buf, parameterized_type_shorthands[i][1]); - memmove(buf + 3, tmp, len - (tmp - buf)); + strcpy( str.buf, parameterized_type_shorthands[i][1] ); + memmove( str.buf + 3, tmp, str.len - (tmp - str.buf) ); } }
- return buf; + return str.buf; }
static char *format_parameterized_type_signature(type_t *type, typeref_list_t *params) { - size_t len = 0, pos = 0; - char *buf = NULL; + struct strbuf str = {0}; typeref_t *ref; const struct uuid *uuid;
if (!(uuid = get_attrp( type->attrs, ATTR_UUID ))) error_at( &type->where, "cannot compute type signature, no uuid found for type %s.\n", type->name );
- pos += strappend(&buf, &len, pos, "pinterface({%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}", - uuid->Data1, uuid->Data2, uuid->Data3, - uuid->Data4[0], uuid->Data4[1], uuid->Data4[2], uuid->Data4[3], - uuid->Data4[4], uuid->Data4[5], uuid->Data4[6], uuid->Data4[7]); + strappend( &str, "pinterface({%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}", uuid->Data1, + uuid->Data2, uuid->Data3, uuid->Data4[0], uuid->Data4[1], uuid->Data4[2], + uuid->Data4[3], uuid->Data4[4], uuid->Data4[5], uuid->Data4[6], uuid->Data4[7] ); if (params) LIST_FOR_EACH_ENTRY(ref, params, typeref_t, entry) { - pos += strappend(&buf, &len, pos, ";"); - pos += append_type_signature(&buf, &len, pos, ref->type); + strappend( &str, ";" ); + append_type_signature( &str, ref->type ); } - pos += strappend(&buf, &len, pos, ")"); + strappend( &str, ")" );
- return buf; + return str.buf; }
static char *format_parameterized_type_short_name(type_t *type, typeref_list_t *params, const char *prefix) { - size_t len = 0, pos = 0; - char *buf = NULL; + struct strbuf str = {0}; typeref_t *ref;
- pos += strappend(&buf, &len, pos, "%s%s", prefix, type->name); + strappend( &str, "%s%s", prefix, type->name ); if (params) LIST_FOR_EACH_ENTRY(ref, params, typeref_t, entry) { type = type_pointer_get_root_type(ref->type); - if (type->short_name) pos += strappend(&buf, &len, pos, "_%s", type->short_name); - else pos += strappend(&buf, &len, pos, "_%s", type->name); + if (type->short_name) strappend( &str, "_%s", type->short_name ); + else strappend( &str, "_%s", type->name ); }
- return buf; + return str.buf; }
static char *format_parameterized_type_impl_name(type_t *type, typeref_list_t *params, const char *prefix) { - size_t len = 0, pos = 0; - char *buf = NULL; + struct strbuf str = {0}; typeref_t *ref; type_t *iface;
- pos += strappend(&buf, &len, pos, "%s%s_impl<", prefix, type->name); + strappend( &str, "%s%s_impl<", prefix, type->name ); if (params) LIST_FOR_EACH_ENTRY(ref, params, typeref_t, entry) { type = type_pointer_get_root_type(ref->type); if (type->type_type == TYPE_RUNTIMECLASS) { - pos += strappend(&buf, &len, pos, "ABI::Windows::Foundation::Internal::AggregateType<%s", type->qualified_name); - pos += append_pointer_stars(&buf, &len, pos, ref->type); + strappend( &str, "ABI::Windows::Foundation::Internal::AggregateType<%s", type->qualified_name ); + append_pointer_stars( &str, ref->type ); iface = type_runtimeclass_get_default_iface(type, TRUE); - pos += strappend(&buf, &len, pos, ", %s", iface->qualified_name); - pos += append_pointer_stars(&buf, &len, pos, ref->type); - pos += strappend(&buf, &len, pos, " >"); + strappend( &str, ", %s", iface->qualified_name ); + append_pointer_stars( &str, ref->type ); + strappend( &str, " >" ); } else { - pos += strappend(&buf, &len, pos, "%s", type->qualified_name); - pos += append_pointer_stars(&buf, &len, pos, ref->type); + strappend( &str, "%s", type->qualified_name ); + append_pointer_stars( &str, ref->type ); } - if (list_next(params, &ref->entry)) pos += strappend(&buf, &len, pos, ", "); + if (list_next( params, &ref->entry )) strappend( &str, ", " ); } - pos += strappend(&buf, &len, pos, " >"); + strappend( &str, " >" );
- return buf; + return str.buf; }
type_t *type_new_function(var_list_t *args) diff --git a/tools/widl/typetree.h b/tools/widl/typetree.h index 6e5c606ab35..44b0c240b45 100644 --- a/tools/widl/typetree.h +++ b/tools/widl/typetree.h @@ -87,6 +87,11 @@ const char *type_get_decl_name(const type_t *type, enum name_type name_type); const char *type_get_name(const type_t *type, enum name_type name_type); char *gen_name(void);
+extern char *format_namespace( const struct namespace *namespace, const char *prefix, const char *separator, + const char *suffix, const char *abi_prefix ); +extern char *format_parameterized_type_name( const type_t *type, const typeref_list_t *params ); +extern char *format_parameterized_type_args( const type_t *type, const char *prefix, const char *suffix ); + typeref_t *make_typeref(type_t *type); typeref_list_t *append_typeref(typeref_list_t *list, typeref_t *ref);
diff --git a/tools/widl/utils.c b/tools/widl/utils.c index 4f2e9d3d602..a694ffa9841 100644 --- a/tools/widl/utils.c +++ b/tools/widl/utils.c @@ -117,41 +117,31 @@ size_t widl_getline(char **linep, size_t *lenp, FILE *fp) return n; }
-size_t strappend(char **buf, size_t *len, size_t pos, const char* fmt, ...) +void strappend( struct strbuf *str, const char *fmt, ... ) { - size_t size; va_list ap; - char *ptr; int n;
- assert( buf && len ); - assert( (*len == 0 && *buf == NULL) || (*len != 0 && *buf != NULL) ); - - if (*buf) - { - size = *len; - ptr = *buf; - } - else - { - size = 100; - ptr = xmalloc( size ); - } + assert( (str->len == 0 && str->buf == NULL) || + (str->len != 0 && str->buf != NULL) );
for (;;) { va_start( ap, fmt ); - n = vsnprintf( ptr + pos, size - pos, fmt, ap ); + n = str->len ? vsnprintf( str->buf + str->pos, str->len - str->pos, fmt, ap ) : 128; va_end( ap ); - if (n == -1) size *= 2; - else if (pos + (size_t)n >= size) size = pos + n + 1; - else break; - ptr = xrealloc( ptr, size ); + if (n >= 0 && n <= str->len && str->pos + n < str->len) break; + str->len = max( str->pos + n, str->len * 3 / 2 ); + str->buf = xrealloc( str->buf, str->len ); }
- *len = size; - *buf = ptr; - return n; + str->pos += n; +} + +void strfree( struct strbuf *str ) +{ + free( str->buf ); + memset( str, 0, sizeof(*str) ); }
/******************************************************************* diff --git a/tools/widl/utils.h b/tools/widl/utils.h index 2a6bc7d7930..5dd7869b842 100644 --- a/tools/widl/utils.h +++ b/tools/widl/utils.h @@ -31,7 +31,15 @@ void warning(const char *s, ...) __attribute__((format (printf, 1, 2))); void warning_at( const struct location *, const char *s, ... ) __attribute__((format( printf, 2, 3 ))); #define warning_loc( ... ) warning_at( NULL, ## __VA_ARGS__ ) void chat(const char *s, ...) __attribute__((format (printf, 1, 2))); -size_t strappend(char **buf, size_t *len, size_t pos, const char* fmt, ...) __attribute__((__format__ (__printf__, 4, 5 ))); + +struct strbuf +{ + char *buf; + size_t pos; + size_t len; +}; +extern void strappend( struct strbuf *str, const char *fmt, ... ) __attribute__((__format__( __printf__, 2, 3 ))); +extern void strfree( struct strbuf *str );
size_t widl_getline(char **linep, size_t *lenp, FILE *fp);
diff --git a/tools/widl/widltypes.h b/tools/widl/widltypes.h index 1706f392670..fb540e9bc31 100644 --- a/tools/widl/widltypes.h +++ b/tools/widl/widltypes.h @@ -709,10 +709,6 @@ type_t *reg_type(type_t *type, const char *name, struct namespace *namespace, in var_t *make_var(char *name); var_list_t *append_var(var_list_t *list, var_t *var);
-char *format_namespace(struct namespace *namespace, const char *prefix, const char *separator, const char *suffix, - const char *abi_prefix); -char *format_parameterized_type_name(type_t *type, typeref_list_t *params); - static inline enum type_type type_get_type_detect_alias(const type_t *type) { return type->type_type;
From: Rémi Bernon rbernon@codeweavers.com
--- tools/widl/header.c | 50 ++++--------------------------------------- tools/widl/typetree.c | 25 ++++++++++++++++++++++ tools/widl/typetree.h | 2 ++ 3 files changed, 31 insertions(+), 46 deletions(-)
diff --git a/tools/widl/header.c b/tools/widl/header.c index 5409c79839c..3fd2ab9461c 100644 --- a/tools/widl/header.c +++ b/tools/widl/header.c @@ -265,6 +265,7 @@ void write_type_left(FILE *h, const decl_spec_t *ds, enum name_type name_type, b { type_t *t = ds->type; const char *decl_name, *name; + struct strbuf str = {0}; char *args;
if (!h) return; @@ -364,52 +365,9 @@ void write_type_left(FILE *h, const decl_spec_t *ds, enum name_type name_type, b break; } case TYPE_BASIC: - if (type_basic_get_type(t) != TYPE_BASIC_INT32 && - type_basic_get_type(t) != TYPE_BASIC_INT64 && - type_basic_get_type(t) != TYPE_BASIC_LONG && - type_basic_get_type(t) != TYPE_BASIC_HYPER) - { - if (type_basic_get_sign(t) < 0) fprintf(h, "signed "); - else if (type_basic_get_sign(t) > 0) fprintf(h, "unsigned "); - } - switch (type_basic_get_type(t)) - { - case TYPE_BASIC_INT8: fprintf(h, "small"); break; - case TYPE_BASIC_INT16: fprintf(h, "short"); break; - case TYPE_BASIC_INT: fprintf(h, "int"); break; - case TYPE_BASIC_INT3264: fprintf(h, "__int3264"); break; - case TYPE_BASIC_BYTE: fprintf(h, "byte"); break; - case TYPE_BASIC_CHAR: fprintf(h, "char"); break; - case TYPE_BASIC_WCHAR: fprintf(h, "wchar_t"); break; - case TYPE_BASIC_FLOAT: fprintf(h, "float"); break; - case TYPE_BASIC_DOUBLE: fprintf(h, "double"); break; - case TYPE_BASIC_ERROR_STATUS_T: fprintf(h, "error_status_t"); break; - case TYPE_BASIC_HANDLE: fprintf(h, "handle_t"); break; - case TYPE_BASIC_INT32: - if (type_basic_get_sign(t) > 0) - fprintf(h, "UINT32"); - else - fprintf(h, "INT32"); - break; - case TYPE_BASIC_LONG: - if (type_basic_get_sign(t) > 0) - fprintf(h, "ULONG"); - else - fprintf(h, "LONG"); - break; - case TYPE_BASIC_INT64: - if (type_basic_get_sign(t) > 0) - fprintf(h, "UINT64"); - else - fprintf(h, "INT64"); - break; - case TYPE_BASIC_HYPER: - if (type_basic_get_sign(t) > 0) - fprintf(h, "MIDL_uhyper"); - else - fprintf(h, "hyper"); - break; - } + append_basic_type( &str, t ); + fwrite( str.buf, 1, str.pos, h ); + strfree( &str ); break; case TYPE_INTERFACE: case TYPE_MODULE: diff --git a/tools/widl/typetree.c b/tools/widl/typetree.c index b8b7f3853fa..af622595ae6 100644 --- a/tools/widl/typetree.c +++ b/tools/widl/typetree.c @@ -109,6 +109,31 @@ const char *type_get_name(const type_t *type, enum name_type name_type) return NULL; }
+void append_basic_type( struct strbuf *str, const type_t *type ) +{ + int sign = type_basic_get_sign( type ); + const char *prefix = sign > 0 ? "unsigned " : sign < 0 ? "signed " : ""; + + switch (type_basic_get_type( type )) + { + case TYPE_BASIC_INT8: return strappend( str, "%ssmall", prefix ); + case TYPE_BASIC_INT16: return strappend( str, "%sshort", prefix ); + case TYPE_BASIC_INT: return strappend( str, "%sint", prefix ); + case TYPE_BASIC_INT3264: return strappend( str, "%s__int3264", prefix ); + case TYPE_BASIC_BYTE: return strappend( str, "%sbyte", prefix ); + case TYPE_BASIC_CHAR: return strappend( str, "%schar", prefix ); + case TYPE_BASIC_WCHAR: return strappend( str, "%swchar_t", prefix ); + case TYPE_BASIC_FLOAT: return strappend( str, "%sfloat", prefix ); + case TYPE_BASIC_DOUBLE: return strappend( str, "%sdouble", prefix ); + case TYPE_BASIC_ERROR_STATUS_T: return strappend( str, "%serror_status_t", prefix ); + case TYPE_BASIC_HANDLE: return strappend( str, "%shandle_t", prefix ); + case TYPE_BASIC_INT32: return strappend( str, sign > 0 ? "UINT32" : "INT32" ); + case TYPE_BASIC_LONG: return strappend( str, sign > 0 ? "ULONG" : "LONG" ); + case TYPE_BASIC_INT64: return strappend( str, sign > 0 ? "UINT64" : "INT64" ); + case TYPE_BASIC_HYPER: return strappend( str, sign > 0 ? "MIDL_uhyper" : "hyper" ); + } +} + static void append_namespace( struct strbuf *str, const struct namespace *namespace, const char *separator, const char *abi_prefix ) { diff --git a/tools/widl/typetree.h b/tools/widl/typetree.h index 44b0c240b45..6ea64048d07 100644 --- a/tools/widl/typetree.h +++ b/tools/widl/typetree.h @@ -87,6 +87,8 @@ const char *type_get_decl_name(const type_t *type, enum name_type name_type); const char *type_get_name(const type_t *type, enum name_type name_type); char *gen_name(void);
+extern void append_basic_type( struct strbuf *str, const type_t *type ); + extern char *format_namespace( const struct namespace *namespace, const char *prefix, const char *separator, const char *suffix, const char *abi_prefix ); extern char *format_parameterized_type_name( const type_t *type, const typeref_list_t *params );
From: Rémi Bernon rbernon@codeweavers.com
--- tools/widl/header.c | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-)
diff --git a/tools/widl/header.c b/tools/widl/header.c index 3fd2ab9461c..69f10870569 100644 --- a/tools/widl/header.c +++ b/tools/widl/header.c @@ -384,11 +384,12 @@ void write_type_left(FILE *h, const decl_spec_t *ds, enum name_type name_type, b fprintf(h, "void"); break; case TYPE_BITFIELD: - { - const decl_spec_t ds = {.type = type_bitfield_get_field(t)}; - write_type_left(h, &ds, name_type, define, TRUE); - break; - } + t = type_bitfield_get_field( t ); + if (!type_is_alias( t )) append_basic_type( &str, t ); + else strappend( &str, "%s", type_get_name( t, name_type ) ); + fwrite( str.buf, 1, str.pos, h ); + strfree( &str ); + break; case TYPE_ALIAS: /* handled elsewhere */ assert(0);
From: Rémi Bernon rbernon@codeweavers.com
--- tools/widl/header.c | 64 ++++++++++++++----------------------------- tools/widl/typetree.c | 58 ++++++++++++++++++++++++++++++++++----- tools/widl/typetree.h | 2 +- 3 files changed, 72 insertions(+), 52 deletions(-)
diff --git a/tools/widl/header.c b/tools/widl/header.c index 69f10870569..5486fe86613 100644 --- a/tools/widl/header.c +++ b/tools/widl/header.c @@ -266,12 +266,10 @@ void write_type_left(FILE *h, const decl_spec_t *ds, enum name_type name_type, b type_t *t = ds->type; const char *decl_name, *name; struct strbuf str = {0}; - char *args;
if (!h) return;
decl_name = type_get_decl_name(t, name_type); - name = type_get_name(t, name_type);
if (ds->func_specifier & FUNCTION_SPECIFIER_INLINE) fprintf(h, "inline "); @@ -279,10 +277,11 @@ void write_type_left(FILE *h, const decl_spec_t *ds, enum name_type name_type, b if ((ds->qualifier & TYPE_QUALIFIER_CONST) && (type_is_alias(t) || !is_ptr(t))) fprintf(h, "const ");
- if (type_is_alias(t)) fprintf(h, "%s", name); + if ((name = type_get_name( t, name_type, false ))) fprintf(h, "%s", name); else { switch (type_get_type_detect_alias(t)) { case TYPE_ENUM: + name = type_get_name( t, name_type, true ); if (!define) fprintf(h, "enum %s", decl_name ? decl_name : ""); else if (!t->written) { assert(t->defined); @@ -299,6 +298,7 @@ void write_type_left(FILE *h, const decl_spec_t *ds, enum name_type name_type, b break; case TYPE_STRUCT: case TYPE_ENCAPSULATED_UNION: + name = type_get_name( t, name_type, true ); if (!define) fprintf(h, "struct %s", decl_name ? decl_name : ""); else if (!t->written) { assert(t->defined); @@ -317,6 +317,7 @@ void write_type_left(FILE *h, const decl_spec_t *ds, enum name_type name_type, b else fprintf(h, "struct %s", name ? name : ""); break; case TYPE_UNION: + name = type_get_name( t, name_type, true ); if (!define) fprintf(h, "union %s", decl_name ? decl_name : ""); else if (!t->written) { assert(t->defined); @@ -339,17 +340,11 @@ void write_type_left(FILE *h, const decl_spec_t *ds, enum name_type name_type, b break; } case TYPE_ARRAY: - if (t->name && type_array_is_decl_as_ptr(t)) - fprintf(h, "%s", t->name); - else - { - write_type_left(h, type_array_get_element(t), name_type, define, !type_array_is_decl_as_ptr(t)); - if (type_array_is_decl_as_ptr(t)) - write_pointer_left(h, type_array_get_element_type(t)); - } + write_type_left(h, type_array_get_element(t), name_type, define, !type_array_is_decl_as_ptr(t)); + if (type_array_is_decl_as_ptr(t)) + write_pointer_left(h, type_array_get_element_type(t)); break; case TYPE_FUNCTION: - { write_type_left(h, type_function_get_ret(t), name_type, define, TRUE);
/* A pointer to a function has to write the calling convention inside @@ -363,48 +358,29 @@ void write_type_left(FILE *h, const decl_spec_t *ds, enum name_type name_type, b if (callconv) fprintf(h, " %s ", callconv); } break; - } case TYPE_BASIC: - append_basic_type( &str, t ); - fwrite( str.buf, 1, str.pos, h ); - strfree( &str ); - break; - case TYPE_INTERFACE: - case TYPE_MODULE: - case TYPE_COCLASS: - fprintf(h, "%s", type_get_name(t, name_type)); - break; - case TYPE_RUNTIMECLASS: - fprintf(h, "%s", type_get_name(type_runtimeclass_get_default_iface(t, TRUE), name_type)); - break; - case TYPE_DELEGATE: - fprintf(h, "%s", type_get_name(type_delegate_get_iface(t), name_type)); - break; - case TYPE_VOID: - fprintf(h, "void"); - break; + append_basic_type( &str, t ); + fwrite( str.buf, 1, str.pos, h ); + strfree( &str ); + break; case TYPE_BITFIELD: t = type_bitfield_get_field( t ); if (!type_is_alias( t )) append_basic_type( &str, t ); - else strappend( &str, "%s", type_get_name( t, name_type ) ); + else strappend( &str, "%s", type_get_name( t, name_type, false ) ); fwrite( str.buf, 1, str.pos, h ); strfree( &str ); break; + case TYPE_INTERFACE: + case TYPE_MODULE: + case TYPE_COCLASS: + case TYPE_RUNTIMECLASS: + case TYPE_DELEGATE: + case TYPE_VOID: case TYPE_ALIAS: - /* handled elsewhere */ - assert(0); - break; case TYPE_PARAMETERIZED_TYPE: - { - type_t *iface = type_parameterized_type_get_real_type(t); - if (type_get_type(iface) == TYPE_DELEGATE) iface = type_delegate_get_iface(iface); - args = format_parameterized_type_args(t, "", "_logical"); - fprintf(h, "%s<%s>", iface->name, args); - free(args); - break; - } case TYPE_PARAMETER: - fprintf(h, "%s_abi", t->name); + /* handled elsewhere */ + assert(0); break; case TYPE_APICONTRACT: /* shouldn't be here */ diff --git a/tools/widl/typetree.c b/tools/widl/typetree.c index af622595ae6..85d374ca9e5 100644 --- a/tools/widl/typetree.c +++ b/tools/widl/typetree.c @@ -96,17 +96,61 @@ const char *type_get_decl_name(const type_t *type, enum name_type name_type) return NULL; }
-const char *type_get_name(const type_t *type, enum name_type name_type) +const char *type_get_name( const type_t *type, enum name_type name_type, bool record ) { - switch(name_type) { - case NAME_DEFAULT: - return type->qualified_name ? type->qualified_name : type->name; - case NAME_C: - return type->c_name ? type->c_name : type->name; + const char *name; + char *args; + + switch (name_type) + { + case NAME_DEFAULT: name = type->qualified_name ? type->qualified_name : type->name; break; + case NAME_C: name = type->c_name ? type->c_name : type->name; break; + default: assert(0); }
+ if (type_is_alias( type )) return name; + switch (type_get_type_detect_alias( type )) + { + case TYPE_ALIAS: return NULL; + case TYPE_APICONTRACT: return NULL; + case TYPE_BASIC: return NULL; + case TYPE_BITFIELD: return NULL; + case TYPE_FUNCTION: return NULL; + case TYPE_POINTER: return NULL; + + case TYPE_ENCAPSULATED_UNION: return record ? name : NULL; + case TYPE_ENUM: return record ? name : NULL; + case TYPE_STRUCT: return record ? name : NULL; + case TYPE_UNION: return record ? name : NULL; + + case TYPE_COCLASS: return name; + case TYPE_INTERFACE: return name; + case TYPE_MODULE: return name; + case TYPE_VOID: return "void"; + case TYPE_PARAMETER: return strmake( "%s_abi", type->name ); + + case TYPE_RUNTIMECLASS: + return type_get_name( type_runtimeclass_get_default_iface( type, TRUE ), name_type, false ); + case TYPE_DELEGATE: + return type_get_name( type_delegate_get_iface( type ), name_type, false ); + + case TYPE_ARRAY: + if (type->name && type_array_is_decl_as_ptr( type )) return type->name; + return NULL; + + case TYPE_PARAMETERIZED_TYPE: + { + type_t *iface = type_parameterized_type_get_real_type( type ); + if (type_get_type( iface ) == TYPE_DELEGATE) iface = type_delegate_get_iface( iface ); + args = format_parameterized_type_args( type, "", "_logical" ); + name = strmake( "%s<%s>", iface->name, args ); + free( args ); + return name; + } + } + + /* shouldn't be here */ assert(0); - return NULL; }
void append_basic_type( struct strbuf *str, const type_t *type ) diff --git a/tools/widl/typetree.h b/tools/widl/typetree.h index 6ea64048d07..66cf35aa9df 100644 --- a/tools/widl/typetree.h +++ b/tools/widl/typetree.h @@ -84,7 +84,7 @@ type_t *type_parameterized_type_specialize_declare(type_t *type, typeref_list_t type_t *type_parameterized_type_specialize_define(type_t *type); int type_is_equal(const type_t *type1, const type_t *type2); const char *type_get_decl_name(const type_t *type, enum name_type name_type); -const char *type_get_name(const type_t *type, enum name_type name_type); +extern const char *type_get_name( const type_t *type, enum name_type name_type, bool record ); char *gen_name(void);
extern void append_basic_type( struct strbuf *str, const type_t *type );
Jacek Caban (@jacek) commented about tools/widl/typetree.c:
- case TYPE_APICONTRACT: return NULL;
- case TYPE_BASIC: return NULL;
- case TYPE_BITFIELD: return NULL;
- case TYPE_FUNCTION: return NULL;
- case TYPE_POINTER: return NULL;
- case TYPE_ENCAPSULATED_UNION: return record ? name : NULL;
- case TYPE_ENUM: return record ? name : NULL;
- case TYPE_STRUCT: return record ? name : NULL;
- case TYPE_UNION: return record ? name : NULL;
- case TYPE_COCLASS: return name;
- case TYPE_INTERFACE: return name;
- case TYPE_MODULE: return name;
- case TYPE_VOID: return "void";
- case TYPE_PARAMETER: return strmake( "%s_abi", type->name );
Should we somehow store it in `type` instead of allocating here (and same for `TYPE_PARAMETERIZED_TYPE`)? Would `c_name` and `qualified_name` be appropriate of would it somehow complicate things?
-
Jacek Caban (＠jacek) -
Rémi Bernon
-
Rémi Bernon (＠rbernon)