[PATCH 1/3] widl: Remove duptype function so type_t* can be directly compared
Richard Pospesel
richard at torproject.org
Thu May 16 17:36:10 CDT 2019
Duplicated types made it impossible to avoid multiply defining user-
defined types (structs, enums, unions). The duptype function has been
removed and the remaining code refactored to no longer require it.
User-define types are now no longer duplicated in typetree.c
Various type attributes (ATTR_EXTERN, ATTR_CONST, and ATTR_INLINE)
had to be removed from a type_t's attributes and placed on struct
_decl_spec. These attributes are generally properties of an instance
of a type rather than that of the type itself.
The decl_spec_t type is now used in many places where a type_t
previously sufficed. It can be found on struct _var and on the pointer,
array, typedef, and bitfield details structs. However, as a result there
is a lot of churn in code previously referencing the type_t in these
places which must now reference a decl_spec_t's type_t.
Wine fully builds with these changes to widl, and all of the tests for
rpcrt4.dll and oleaut32.dll run with the same results.
Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=47035
Signed-off-by: Richard Pospesel <richard at torproject.net>
---
tools/widl/client.c | 34 +--
tools/widl/expr.c | 14 +-
tools/widl/header.c | 218 ++++++++-------
tools/widl/header.h | 11 +-
tools/widl/parser.y | 330 ++++++++++++++--------
tools/widl/proxy.c | 58 ++--
tools/widl/server.c | 19 +-
tools/widl/typegen.c | 594 +++++++++++++++++++++-------------------
tools/widl/typelib.c | 6 +-
tools/widl/typetree.c | 54 ++--
tools/widl/typetree.h | 57 ++--
tools/widl/widltypes.h | 51 +++-
tools/widl/write_msft.c | 48 ++--
13 files changed, 857 insertions(+), 637 deletions(-)
diff --git a/tools/widl/client.c b/tools/widl/client.c
index fe88f5993c..625641e0de 100644
--- a/tools/widl/client.c
+++ b/tools/widl/client.c
@@ -52,12 +52,12 @@ static void print_client( const char *format, ... )
static void write_client_func_decl( const type_t *iface, const var_t *func )
{
- const char *callconv = get_attrp(func->type->attrs, ATTR_CALLCONV);
- const var_list_t *args = type_get_function_args(func->type);
- type_t *rettype = type_function_get_rettype(func->type);
+ const char *callconv = get_attrp(func->declspec.type->attrs, ATTR_CALLCONV);
+ const var_list_t *args = type_get_function_args(func->declspec.type);
+ decl_spec_t *retdeclspec = type_function_get_retdeclspec(func->declspec.type);
if (!callconv) callconv = "__cdecl";
- write_type_decl_left(client, rettype);
+ write_declspec_decl_left(client, retdeclspec);
fprintf(client, " %s ", callconv);
fprintf(client, "%s%s(\n", prefix_client, get_name(func));
indent++;
@@ -74,9 +74,9 @@ static void write_function_stub( const type_t *iface, const var_t *func,
{
unsigned char explicit_fc, implicit_fc;
int has_full_pointer = is_full_pointer_function(func);
- var_t *retval = type_function_get_retval(func->type);
+ var_t *retval = type_function_get_retval(func->declspec.type);
const var_t *handle_var = get_func_handle_var( iface, func, &explicit_fc, &implicit_fc );
- int has_ret = !is_void(retval->type);
+ int has_ret = !is_void(retval->declspec.type);
if (is_interpreted_func( iface, func ))
{
@@ -97,7 +97,7 @@ static void write_function_stub( const type_t *iface, const var_t *func,
print_client("RPC_BINDING_HANDLE _Handle;\n");
}
- if (has_ret && decl_indirect(retval->type))
+ if (has_ret && decl_indirect(retval->declspec.type))
{
print_client("void *_p_%s;\n", retval->name);
}
@@ -136,7 +136,7 @@ static void write_function_stub( const type_t *iface, const var_t *func,
if (has_ret)
{
print_client("%s", "");
- write_type_decl(client, retval->type, retval->name);
+ write_declspec_decl(client, (decl_spec_t*)&retval->declspec, retval->name);
fprintf(client, ";\n");
}
print_client("RPC_MESSAGE _RpcMessage;\n");
@@ -147,7 +147,7 @@ static void write_function_stub( const type_t *iface, const var_t *func,
if (explicit_fc == FC_BIND_GENERIC)
print_client("__frame->%s = %s;\n", handle_var->name, handle_var->name );
}
- if (has_ret && decl_indirect(retval->type))
+ if (has_ret && decl_indirect(retval->declspec.type))
{
print_client("__frame->_p_%s = &%s;\n", retval->name, retval->name);
}
@@ -194,7 +194,7 @@ static void write_function_stub( const type_t *iface, const var_t *func,
/* if the context_handle attribute appears in the chain of types
* without pointers being followed, then the context handle must
* be direct, otherwise it is a pointer */
- int is_ch_ptr = !is_aliaschain_attr(handle_var->type, ATTR_CONTEXTHANDLE);
+ int is_ch_ptr = !is_aliaschain_attr(handle_var->declspec.type, ATTR_CONTEXTHANDLE);
print_client("if (%s%s != 0)\n", is_ch_ptr ? "*" : "", handle_var->name);
indent++;
print_client("__frame->_Handle = NDRCContextBinding(%s%s);\n",
@@ -257,9 +257,9 @@ static void write_function_stub( const type_t *iface, const var_t *func,
/* unmarshal return value */
if (has_ret)
{
- if (decl_indirect(retval->type))
+ if (decl_indirect(retval->declspec.type))
print_client("MIDL_memset(&%s, 0, sizeof(%s));\n", retval->name, retval->name);
- else if (is_ptr(retval->type) || is_array(retval->type))
+ else if (is_ptr(retval->declspec.type) || is_array(retval->declspec.type))
print_client("%s = 0;\n", retval->name);
write_remoting_arguments(client, indent, func, "", PASS_RETURN, PHASE_UNMARSHAL);
}
@@ -365,8 +365,8 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset)
case STMT_DECLARATION:
{
const var_t *func = stmt->u.var;
- if (stmt->u.var->stgclass != STG_NONE
- || type_get_type_detect_alias(stmt->u.var->type) != TYPE_FUNCTION)
+ if (stmt->u.var->declspec.stgclass != STG_NONE
+ || type_get_type_detect_alias(stmt->u.var->declspec.type) != TYPE_FUNCTION)
continue;
write_function_stub( iface, func, method_count++, *proc_offset );
*proc_offset += get_size_procformatstring_func( iface, func );
@@ -488,7 +488,7 @@ static void write_implicithandledecl(type_t *iface)
if (implicit_handle)
{
- write_type_decl( client, implicit_handle->type, implicit_handle->name );
+ write_declspec_decl( client, (decl_spec_t*)&implicit_handle->declspec, implicit_handle->name );
fprintf(client, ";\n\n");
}
}
@@ -532,8 +532,8 @@ static void write_client_ifaces(const statement_list_t *stmts, int expr_eval_rou
LIST_FOR_EACH_ENTRY(stmt2, type_iface_get_stmts(iface), const statement_t, entry)
{
- if (stmt2->type == STMT_DECLARATION && stmt2->u.var->stgclass == STG_NONE &&
- type_get_type_detect_alias(stmt2->u.var->type) == TYPE_FUNCTION)
+ if (stmt2->type == STMT_DECLARATION && stmt2->u.var->declspec.stgclass == STG_NONE &&
+ type_get_type_detect_alias(stmt2->u.var->declspec.type) == TYPE_FUNCTION)
{
needs_stub = 1;
break;
diff --git a/tools/widl/expr.c b/tools/widl/expr.c
index 2ed4aff6ad..85ba4639e1 100644
--- a/tools/widl/expr.c
+++ b/tools/widl/expr.c
@@ -194,10 +194,10 @@ expr_t *make_exprt(enum expr_type type, var_t *var, expr_t *expr)
expr_t *e;
type_t *tref;
- if (var->stgclass != STG_NONE && var->stgclass != STG_REGISTER)
+ if (var->declspec.stgclass != STG_NONE && var->declspec.stgclass != STG_REGISTER)
error_loc("invalid storage class for type expression\n");
- tref = var->type;
+ tref = var->declspec.type;
e = xmalloc(sizeof(expr_t));
e->type = type;
@@ -474,7 +474,7 @@ static type_t *find_identifier(const char *identifier, const type_t *cont_type,
if (fields) LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry )
if (field->name && !strcmp(identifier, field->name))
{
- type = field->type;
+ type = field->declspec.type;
*found_in_cont_type = 1;
break;
}
@@ -482,7 +482,7 @@ static type_t *find_identifier(const char *identifier, const type_t *cont_type,
if (!type)
{
var_t *const_var = find_const(identifier, 0);
- if (const_var) type = const_var->type;
+ if (const_var) type = const_var->declspec.type;
}
return type;
@@ -580,10 +580,10 @@ static struct expression_type resolve_expression(const struct expr_loc *expr_loc
case EXPR_PPTR:
result = resolve_expression(expr_loc, cont_type, e->ref);
if (result.type && is_ptr(result.type))
- result.type = type_pointer_get_ref(result.type);
+ result.type = type_pointer_get_ref_type(result.type);
else if(result.type && is_array(result.type)
&& type_array_is_decl_as_ptr(result.type))
- result.type = type_array_get_element(result.type);
+ result.type = type_array_get_element_type(result.type);
else
error_loc_info(&expr_loc->v->loc_info, "dereference operator applied to non-pointer type in expression%s%s\n",
expr_loc->attr ? " for attribute " : "",
@@ -665,7 +665,7 @@ static struct expression_type resolve_expression(const struct expr_loc *expr_loc
if (result.type && is_array(result.type))
{
struct expression_type index_result;
- result.type = type_array_get_element(result.type);
+ result.type = type_array_get_element_type(result.type);
index_result = resolve_expression(expr_loc, cont_type /* FIXME */, e->u.ext);
if (!index_result.type || !is_integer_type(index_result.type))
error_loc_info(&expr_loc->v->loc_info, "array subscript not of integral type in expression%s%s\n",
diff --git a/tools/widl/header.c b/tools/widl/header.c
index f618e02f3d..c96064151a 100644
--- a/tools/widl/header.c
+++ b/tools/widl/header.c
@@ -43,7 +43,7 @@ user_type_list_t user_type_list = LIST_INIT(user_type_list);
context_handle_list_t context_handle_list = LIST_INIT(context_handle_list);
generic_handle_list_t generic_handle_list = LIST_INIT(generic_handle_list);
-static void write_type_def_or_decl(FILE *f, type_t *t, int field, const char *name);
+static void write_type_def_or_decl(FILE *f, decl_spec_t *ds, int field, const char *name);
static void indent(FILE *h, int delta)
{
@@ -69,15 +69,15 @@ int is_ptrchain_attr(const var_t *var, enum attr_type t)
return 1;
else
{
- type_t *type = var->type;
+ type_t *type = var->declspec.type;
for (;;)
{
if (is_attr(type->attrs, t))
return 1;
else if (type_is_alias(type))
- type = type_alias_get_aliasee(type);
+ type = type_alias_get_aliasee_type(type);
else if (is_ptr(type))
- type = type_pointer_get_ref(type);
+ type = type_pointer_get_ref_type(type);
else return 0;
}
}
@@ -91,7 +91,7 @@ int is_aliaschain_attr(const type_t *type, enum attr_type attr)
if (is_attr(t->attrs, attr))
return 1;
else if (type_is_alias(t))
- t = type_alias_get_aliasee(t);
+ t = type_alias_get_aliasee_type(t);
else return 0;
}
}
@@ -120,6 +120,16 @@ unsigned int get_attrv(const attr_list_t *list, enum attr_type t)
return 0;
}
+decl_spec_t *get_attrds(const attr_list_t *list, enum attr_type t)
+{
+ const attr_t *attr;
+ /* only wire_marshal attrtibute uses the declspec */
+ assert(t == ATTR_WIREMARSHAL);
+ if (list) LIST_FOR_EACH_ENTRY( attr, list, const attr_t, entry )
+ if (attr->type == t) return (decl_spec_t*)&attr->u.dsval;
+ return NULL;
+}
+
static void write_guid(FILE *f, const char *guid_prefix, const char *name, const UUID *uuid)
{
if (!uuid) return;
@@ -204,9 +214,9 @@ static void write_fields(FILE *h, var_list_t *fields)
if (!fields) return;
LIST_FOR_EACH_ENTRY( v, fields, var_t, entry ) {
- if (!v || !v->type) continue;
+ if (!v || !v->declspec.type) continue;
- switch(type_get_type_detect_alias(v->type)) {
+ switch(type_get_type_detect_alias(v->declspec.type)) {
case TYPE_STRUCT:
case TYPE_ENCAPSULATED_UNION:
nameless_struct_cnt++;
@@ -220,12 +230,12 @@ static void write_fields(FILE *h, var_list_t *fields)
}
LIST_FOR_EACH_ENTRY( v, fields, var_t, entry ) {
- if (!v || !v->type) continue;
+ if (!v || !v->declspec.type) continue;
indent(h, 0);
name = v->name;
- switch(type_get_type_detect_alias(v->type)) {
+ switch(type_get_type_detect_alias(v->declspec.type)) {
case TYPE_STRUCT:
case TYPE_ENCAPSULATED_UNION:
if(!v->name) {
@@ -252,7 +262,7 @@ static void write_fields(FILE *h, var_list_t *fields)
default:
;
}
- write_type_def_or_decl(h, v->type, TRUE, name);
+ write_type_def_or_decl(h, &v->declspec, TRUE, name);
fprintf(h, ";\n");
}
}
@@ -295,16 +305,24 @@ static void write_pointer_left(FILE *h, type_t *ref)
}
void write_type_left(FILE *h, type_t *t, enum name_type name_type, int declonly)
+{
+ decl_spec_t ds;
+ write_declspec_left(h, init_declspec(&ds, t), name_type, declonly);
+}
+
+void write_declspec_left(FILE* h, decl_spec_t *ds, enum name_type name_type, int declonly)
{
const char *name;
+ type_t *t = ds->type;
if (!h) return;
name = type_get_name(t, name_type);
- if (is_attr(t->attrs, ATTR_CONST) &&
- (type_is_alias(t) || !is_ptr(t)))
+ if ((ds->typequalifier == TYPE_QUALIFIER_CONST) &&
+ (type_is_alias(t) || !is_ptr(t))) {
fprintf(h, "const ");
+ }
if (type_is_alias(t)) fprintf(h, "%s", t->name);
else {
@@ -351,9 +369,9 @@ void write_type_left(FILE *h, type_t *t, enum name_type name_type, int declonly)
break;
case TYPE_POINTER:
{
- write_type_left(h, type_pointer_get_ref(t), name_type, declonly);
- write_pointer_left(h, type_pointer_get_ref(t));
- if (is_attr(t->attrs, ATTR_CONST)) fprintf(h, "const ");
+ write_declspec_left(h, type_pointer_get_ref(t), name_type, declonly);
+ write_pointer_left(h, type_pointer_get_ref_type(t));
+ if (ds->typequalifier == TYPE_QUALIFIER_CONST) fprintf(h, "const ");
break;
}
case TYPE_ARRAY:
@@ -361,9 +379,9 @@ void write_type_left(FILE *h, type_t *t, enum name_type name_type, int declonly)
fprintf(h, "%s", t->name);
else
{
- write_type_left(h, type_array_get_element(t), name_type, declonly);
+ write_declspec_left(h, type_array_get_element(t), name_type, declonly);
if (type_array_is_decl_as_ptr(t))
- write_pointer_left(h, type_array_get_element(t));
+ write_pointer_left(h, type_array_get_element_type(t));
}
break;
case TYPE_BASIC:
@@ -423,7 +441,7 @@ void write_type_left(FILE *h, type_t *t, enum name_type name_type, int declonly)
fprintf(h, "void");
break;
case TYPE_BITFIELD:
- write_type_left(h, type_bitfield_get_field(t), name_type, declonly);
+ write_declspec_left(h, type_bitfield_get_field(t), name_type, declonly);
break;
case TYPE_ALIAS:
case TYPE_FUNCTION:
@@ -443,7 +461,7 @@ void write_type_right(FILE *h, type_t *t, int is_field)
{
case TYPE_ARRAY:
{
- type_t *elem = type_array_get_element(t);
+ type_t *elem = type_array_get_element_type(t);
if (type_array_is_decl_as_ptr(t))
{
if (!type_is_alias(elem) && is_array(elem) && !type_array_is_decl_as_ptr(elem))
@@ -461,7 +479,7 @@ void write_type_right(FILE *h, type_t *t, int is_field)
}
case TYPE_POINTER:
{
- type_t *ref = type_pointer_get_ref(t);
+ type_t *ref = type_pointer_get_ref_type(t);
if (!type_is_alias(ref) && is_array(ref) && !type_array_is_decl_as_ptr(ref))
fprintf(h, ")");
write_type_right(h, ref, FALSE);
@@ -485,30 +503,34 @@ void write_type_right(FILE *h, type_t *t, int is_field)
}
}
-static void write_type_v(FILE *h, type_t *t, int is_field, int declonly, const char *name)
+static void write_type_v(FILE *h, decl_spec_t *ds, int is_field, int declonly, const char *name)
{
+ type_t *t = ds->type;
type_t *pt = NULL;
int ptr_level = 0;
if (!h) return;
if (t) {
- for (pt = t; is_ptr(pt); pt = type_pointer_get_ref(pt), ptr_level++)
+ decl_spec_t *dpt = NULL;
+ for (dpt = ds; is_ptr(dpt->type); dpt = type_pointer_get_ref(dpt->type), ptr_level++)
;
+ pt = dpt->type;
if (type_get_type_detect_alias(pt) == TYPE_FUNCTION) {
int i;
const char *callconv = get_attrp(pt->attrs, ATTR_CALLCONV);
if (!callconv && is_object_interface) callconv = "STDMETHODCALLTYPE";
- if (is_attr(pt->attrs, ATTR_INLINE)) fprintf(h, "inline ");
- write_type_left(h, type_function_get_rettype(pt), NAME_DEFAULT, declonly);
+ if (dpt->funcspecifier == FUNCTION_SPECIFIER_INLINE) fprintf(h, "inline ");
+ write_declspec_left(h, type_function_get_retdeclspec(pt), NAME_DEFAULT, declonly);
fputc(' ', h);
if (ptr_level) fputc('(', h);
if (callconv) fprintf(h, "%s ", callconv);
for (i = 0; i < ptr_level; i++)
fputc('*', h);
- } else
- write_type_left(h, t, NAME_DEFAULT, declonly);
+ } else {
+ write_declspec_left(h, ds, NAME_DEFAULT, declonly);
+ }
}
if (name) fprintf(h, "%s%s", !t || needs_space_after(t) ? " " : "", name );
@@ -529,9 +551,9 @@ static void write_type_v(FILE *h, type_t *t, int is_field, int declonly, const c
}
}
-static void write_type_def_or_decl(FILE *f, type_t *t, int field, const char *name)
+static void write_type_def_or_decl(FILE *f, decl_spec_t *ds, int field, const char *name)
{
- write_type_v(f, t, field, FALSE, name);
+ write_type_v(f, ds, field, FALSE, name);
}
static void write_type_definition(FILE *f, type_t *t)
@@ -560,12 +582,18 @@ static void write_type_definition(FILE *f, type_t *t)
void write_type_decl(FILE *f, type_t *t, const char *name)
{
- write_type_v(f, t, FALSE, TRUE, name);
+ decl_spec_t ds;
+ write_declspec_decl(f, init_declspec(&ds, t), name);
+}
+
+void write_declspec_decl(FILE *f, decl_spec_t *ds, const char *name)
+{
+ write_type_v(f, ds, FALSE, TRUE, name);
}
-void write_type_decl_left(FILE *f, type_t *t)
+void write_declspec_decl_left(FILE *f, decl_spec_t *ds)
{
- write_type_left(f, t, NAME_DEFAULT, TRUE);
+ write_declspec_left(f, ds, NAME_DEFAULT, TRUE);
}
static int user_type_registered(const char *name)
@@ -602,8 +630,8 @@ unsigned int get_context_handle_offset( const type_t *type )
while (!is_attr( type->attrs, ATTR_CONTEXTHANDLE ))
{
- if (type_is_alias( type )) type = type_alias_get_aliasee( type );
- else if (is_ptr( type )) type = type_pointer_get_ref( type );
+ if (type_is_alias( type )) type = type_alias_get_aliasee_type( type );
+ else if (is_ptr( type )) type = type_pointer_get_ref_type( type );
else error( "internal error: %s is not a context handle\n", type->name );
}
LIST_FOR_EACH_ENTRY( ch, &context_handle_list, context_handle_t, entry )
@@ -622,8 +650,8 @@ unsigned int get_generic_handle_offset( const type_t *type )
while (!is_attr( type->attrs, ATTR_HANDLE ))
{
- if (type_is_alias( type )) type = type_alias_get_aliasee( type );
- else if (is_ptr( type )) type = type_pointer_get_ref( type );
+ if (type_is_alias( type )) type = type_alias_get_aliasee_type( type );
+ else if (is_ptr( type )) type = type_pointer_get_ref_type( type );
else error( "internal error: %s is not a generic handle\n", type->name );
}
LIST_FOR_EACH_ENTRY( gh, &generic_handle_list, generic_handle_t, entry )
@@ -697,15 +725,15 @@ void check_for_additional_prototype_types(type_t *type)
break;
}
if (vars) LIST_FOR_EACH_ENTRY( v, vars, const var_t, entry )
- check_for_additional_prototype_types(v->type);
+ check_for_additional_prototype_types(v->declspec.type);
}
if (type_is_alias(type))
- type = type_alias_get_aliasee(type);
+ type = type_alias_get_aliasee_type(type);
else if (is_ptr(type))
- type = type_pointer_get_ref(type);
+ type = type_pointer_get_ref_type(type);
else if (is_array(type))
- type = type_array_get_element(type);
+ type = type_array_get_element_type(type);
else
break;
}
@@ -795,17 +823,17 @@ static void write_typedef(FILE *header, type_t *type)
int is_const_decl(const var_t *var)
{
- const type_t *t;
+ const decl_spec_t *ds;
/* strangely, MIDL accepts a const attribute on any pointer in the
* declaration to mean that data isn't being instantiated. this appears
* to be a bug, but there is no benefit to being incompatible with MIDL,
* so we'll do the same thing */
- for (t = var->type; ; )
+ for (ds = &var->declspec; ;)
{
- if (is_attr(t->attrs, ATTR_CONST))
+ if (ds->typequalifier == TYPE_QUALIFIER_CONST)
return TRUE;
- else if (is_ptr(t))
- t = type_pointer_get_ref(t);
+ else if (is_ptr(ds->type))
+ ds = type_pointer_get_ref(ds->type);
else break;
}
return FALSE;
@@ -821,7 +849,7 @@ static void write_declaration(FILE *header, const var_t *v)
}
else
{
- switch (v->stgclass)
+ switch (v->declspec.stgclass)
{
case STG_NONE:
case STG_REGISTER: /* ignored */
@@ -833,7 +861,7 @@ static void write_declaration(FILE *header, const var_t *v)
fprintf(header, "extern ");
break;
}
- write_type_def_or_decl(header, v->type, FALSE, v->name);
+ write_type_def_or_decl(header, (decl_spec_t*)&v->declspec, FALSE, v->name);
fprintf(header, ";\n\n");
}
}
@@ -850,9 +878,9 @@ static void write_library(FILE *header, const typelib_t *typelib)
const type_t* get_explicit_generic_handle_type(const var_t* var)
{
const type_t *t;
- for (t = var->type;
+ for (t = var->declspec.type;
is_ptr(t) || type_is_alias(t);
- t = type_is_alias(t) ? type_alias_get_aliasee(t) : type_pointer_get_ref(t))
+ t = type_is_alias(t) ? type_alias_get_aliasee_type(t) : type_pointer_get_ref_type(t))
if ((type_get_type_detect_alias(t) != TYPE_BASIC || type_basic_get_type(t) != TYPE_BASIC_HANDLE) &&
is_attr(t->attrs, ATTR_HANDLE))
return t;
@@ -863,13 +891,13 @@ const var_t *get_func_handle_var( const type_t *iface, const var_t *func,
unsigned char *explicit_fc, unsigned char *implicit_fc )
{
const var_t *var;
- const var_list_t *args = type_get_function_args( func->type );
+ const var_list_t *args = type_get_function_args( func->declspec.type );
*explicit_fc = *implicit_fc = 0;
if (args) LIST_FOR_EACH_ENTRY( var, args, const var_t, entry )
{
if (!is_attr( var->attrs, ATTR_IN ) && is_attr( var->attrs, ATTR_OUT )) continue;
- if (type_get_type( var->type ) == TYPE_BASIC && type_basic_get_type( var->type ) == TYPE_BASIC_HANDLE)
+ if (type_get_type( var->declspec.type ) == TYPE_BASIC && type_basic_get_type( var->declspec.type ) == TYPE_BASIC_HANDLE)
{
*explicit_fc = FC_BIND_PRIMITIVE;
return var;
@@ -879,7 +907,7 @@ const var_t *get_func_handle_var( const type_t *iface, const var_t *func,
*explicit_fc = FC_BIND_GENERIC;
return var;
}
- if (is_context_handle( var->type ))
+ if (is_context_handle( var->declspec.type ))
{
*explicit_fc = FC_BIND_CONTEXT;
return var;
@@ -888,8 +916,8 @@ const var_t *get_func_handle_var( const type_t *iface, const var_t *func,
if ((var = get_attrp( iface->attrs, ATTR_IMPLICIT_HANDLE )))
{
- if (type_get_type( var->type ) == TYPE_BASIC &&
- type_basic_get_type( var->type ) == TYPE_BASIC_HANDLE)
+ if (type_get_type( var->declspec.type ) == TYPE_BASIC &&
+ type_basic_get_type( var->declspec.type ) == TYPE_BASIC_HANDLE)
*implicit_fc = FC_BIND_PRIMITIVE;
else
*implicit_fc = FC_BIND_GENERIC;
@@ -904,13 +932,13 @@ int has_out_arg_or_return(const var_t *func)
{
const var_t *var;
- if (!is_void(type_function_get_rettype(func->type)))
+ if (!is_void(type_function_get_rettype(func->declspec.type)))
return 1;
- if (!type_get_function_args(func->type))
+ if (!type_get_function_args(func->declspec.type))
return 0;
- LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry )
+ LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->declspec.type), const var_t, entry )
if (is_attr(var->attrs, ATTR_OUT))
return 1;
@@ -990,7 +1018,7 @@ static int is_override_method(const type_t *iface, const type_t *child, const va
static int is_aggregate_return(const var_t *func)
{
- enum type_type type = type_get_type(type_function_get_rettype(func->type));
+ enum type_type type = type_get_type(type_function_get_rettype(func->declspec.type));
return type == TYPE_STRUCT || type == TYPE_UNION ||
type == TYPE_COCLASS || type == TYPE_INTERFACE;
}
@@ -1030,8 +1058,8 @@ static void write_method_macro(FILE *header, const type_t *iface, const type_t *
const var_t *arg;
fprintf(header, "#define %s_%s(This", name, get_name(func));
- if (type_get_function_args(func->type))
- LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->type), const var_t, entry )
+ if (type_get_function_args(func->declspec.type))
+ LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->declspec.type), const var_t, entry )
fprintf(header, ",%s", arg->name);
fprintf(header, ") ");
@@ -1042,8 +1070,8 @@ static void write_method_macro(FILE *header, const type_t *iface, const type_t *
}
fprintf(header, "(This)->lpVtbl->%s(This", get_vtbl_entry_name(iface, func));
- if (type_get_function_args(func->type))
- LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->type), const var_t, entry )
+ if (type_get_function_args(func->declspec.type))
+ LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->declspec.type), const var_t, entry )
fprintf(header, ",%s", arg->name);
fprintf(header, ")\n");
}
@@ -1073,7 +1101,7 @@ void write_args(FILE *h, const var_list_t *args, const char *name, int method, i
}
else fprintf(h, ",");
}
- write_type_decl(h, arg->type, arg->name);
+ write_declspec_decl(h, (decl_spec_t*)&arg->declspec, arg->name);
if (method == 2) {
const expr_t *expr = get_attrp(arg->attrs, ATTR_DEFAULTVALUE);
if (expr) {
@@ -1085,7 +1113,7 @@ void write_args(FILE *h, const var_list_t *args, const char *name, int method, i
expr_t bstr;
/* Fixup the expression type for a BSTR like midl does. */
- if (get_type_vt(arg->type) == VT_BSTR && expr->type == EXPR_STRLIT)
+ if (get_type_vt(arg->declspec.type) == VT_BSTR && expr->type == EXPR_STRLIT)
{
bstr = *expr;
bstr.type = EXPR_WSTRLIT;
@@ -1114,8 +1142,8 @@ static void write_cpp_method_def(FILE *header, const type_t *iface)
{
const var_t *func = stmt->u.var;
if (!is_callas(func->attrs)) {
- const char *callconv = get_attrp(func->type->attrs, ATTR_CALLCONV);
- const var_list_t *args = type_get_function_args(func->type);
+ const char *callconv = get_attrp(func->declspec.type->attrs, ATTR_CALLCONV);
+ const var_list_t *args = type_get_function_args(func->declspec.type);
const var_t *arg;
if (!callconv) callconv = "STDMETHODCALLTYPE";
@@ -1125,11 +1153,11 @@ static void write_cpp_method_def(FILE *header, const type_t *iface)
indent(header, 0);
fprintf(header, "virtual ");
- write_type_decl_left(header, type_function_get_rettype(func->type));
+ write_declspec_decl_left(header, type_function_get_retdeclspec(func->declspec.type));
fprintf(header, "* %s %s(\n", callconv, get_name(func));
++indentation;
indent(header, 0);
- write_type_decl_left(header, type_function_get_rettype(func->type));
+ write_declspec_decl_left(header, type_function_get_retdeclspec(func->declspec.type));
fprintf(header, " *__ret");
--indentation;
if (args) {
@@ -1139,7 +1167,7 @@ static void write_cpp_method_def(FILE *header, const type_t *iface)
fprintf(header, ") = 0;\n");
indent(header, 0);
- write_type_decl_left(header, type_function_get_rettype(func->type));
+ write_declspec_decl_left(header, type_function_get_retdeclspec(func->declspec.type));
fprintf(header, " %s %s(\n", callconv, get_name(func));
write_args(header, args, iface->name, 2, TRUE);
fprintf(header, ")\n");
@@ -1147,7 +1175,7 @@ static void write_cpp_method_def(FILE *header, const type_t *iface)
fprintf(header, "{\n");
++indentation;
indent(header, 0);
- write_type_decl_left(header, type_function_get_rettype(func->type));
+ write_declspec_decl_left(header, type_function_get_retdeclspec(func->declspec.type));
fprintf(header, " __ret;\n");
indent(header, 0);
fprintf(header, "return *%s(&__ret", get_name(func));
@@ -1164,7 +1192,7 @@ static void write_cpp_method_def(FILE *header, const type_t *iface)
indent(header, 0);
fprintf(header, "virtual ");
- write_type_decl_left(header, type_function_get_rettype(func->type));
+ write_declspec_decl_left(header, type_function_get_retdeclspec(func->declspec.type));
fprintf(header, " %s %s(\n", callconv, get_name(func));
write_args(header, args, iface->name, 2, TRUE);
fprintf(header, ") = 0;\n");
@@ -1201,25 +1229,25 @@ static void write_inline_wrappers(FILE *header, const type_t *iface, const type_
const var_t *arg;
fprintf(header, "static FORCEINLINE ");
- write_type_decl_left(header, type_function_get_rettype(func->type));
+ write_declspec_decl_left(header, type_function_get_retdeclspec(func->declspec.type));
fprintf(header, " %s_%s(", name, get_name(func));
- write_args(header, type_get_function_args(func->type), name, 1, FALSE);
+ write_args(header, type_get_function_args(func->declspec.type), name, 1, FALSE);
fprintf(header, ") {\n");
++indentation;
if (!is_aggregate_return(func)) {
indent(header, 0);
fprintf(header, "%sThis->lpVtbl->%s(This",
- is_void(type_function_get_rettype(func->type)) ? "" : "return ",
+ is_void(type_function_get_rettype(func->declspec.type)) ? "" : "return ",
get_vtbl_entry_name(iface, func));
} else {
indent(header, 0);
- write_type_decl_left(header, type_function_get_rettype(func->type));
+ write_declspec_decl_left(header, type_function_get_retdeclspec(func->declspec.type));
fprintf(header, " __ret;\n");
indent(header, 0);
fprintf(header, "return *This->lpVtbl->%s(This,&__ret", get_vtbl_entry_name(iface, func));
}
- if (type_get_function_args(func->type))
- LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->type), const var_t, entry )
+ if (type_get_function_args(func->declspec.type))
+ LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->declspec.type), const var_t, entry )
fprintf(header, ",%s", arg->name);
fprintf(header, ");\n");
--indentation;
@@ -1245,10 +1273,10 @@ static void do_write_c_method_def(FILE *header, const type_t *iface, const char
first_iface = 0;
}
if (!is_callas(func->attrs)) {
- const char *callconv = get_attrp(func->type->attrs, ATTR_CALLCONV);
+ const char *callconv = get_attrp(func->declspec.type->attrs, ATTR_CALLCONV);
if (!callconv) callconv = "STDMETHODCALLTYPE";
indent(header, 0);
- write_type_decl_left(header, type_function_get_rettype(func->type));
+ write_declspec_decl_left(header, type_function_get_retdeclspec(func->declspec.type));
if (is_aggregate_return(func))
fprintf(header, " *");
if (is_inherited_method(iface, func))
@@ -1261,13 +1289,13 @@ static void do_write_c_method_def(FILE *header, const type_t *iface, const char
if (is_aggregate_return(func)) {
fprintf(header, ",\n");
indent(header, 0);
- write_type_decl_left(header, type_function_get_rettype(func->type));
+ write_declspec_decl_left(header, type_function_get_retdeclspec(func->declspec.type));
fprintf(header, " *__ret");
}
--indentation;
- if (type_get_function_args(func->type)) {
+ if (type_get_function_args(func->declspec.type)) {
fprintf(header, ",\n");
- write_args(header, type_get_function_args(func->type), name, 0, TRUE);
+ write_args(header, type_get_function_args(func->declspec.type), name, 0, TRUE);
}
fprintf(header, ");\n");
fprintf(header, "\n");
@@ -1294,12 +1322,12 @@ static void write_method_proto(FILE *header, const type_t *iface)
const var_t *func = stmt->u.var;
if (is_callas(func->attrs)) {
- const char *callconv = get_attrp(func->type->attrs, ATTR_CALLCONV);
+ const char *callconv = get_attrp(func->declspec.type->attrs, ATTR_CALLCONV);
if (!callconv) callconv = "STDMETHODCALLTYPE";
/* proxy prototype */
- write_type_decl_left(header, type_function_get_rettype(func->type));
+ write_declspec_decl_left(header, type_function_get_retdeclspec(func->declspec.type));
fprintf(header, " %s %s_%s_Proxy(\n", callconv, iface->name, get_name(func));
- write_args(header, type_get_function_args(func->type), iface->name, 1, TRUE);
+ write_args(header, type_get_function_args(func->declspec.type), iface->name, 1, TRUE);
fprintf(header, ");\n");
/* stub prototype */
fprintf(header, "void __RPC_STUB %s_%s_Stub(\n", iface->name, get_name(func));
@@ -1332,12 +1360,12 @@ static void write_locals(FILE *fp, const type_t *iface, int body)
if (&stmt2->entry != type_iface_get_stmts(iface)) {
const var_t *m = stmt2->u.var;
/* proxy prototype - use local prototype */
- write_type_decl_left(fp, type_function_get_rettype(m->type));
+ write_declspec_decl_left(fp, type_function_get_retdeclspec(m->declspec.type));
fprintf(fp, " CALLBACK %s_%s_Proxy(\n", iface->name, get_name(m));
- write_args(fp, type_get_function_args(m->type), iface->name, 1, TRUE);
+ write_args(fp, type_get_function_args(m->declspec.type), iface->name, 1, TRUE);
fprintf(fp, ")");
if (body) {
- type_t *rt = type_function_get_rettype(m->type);
+ type_t *rt = type_function_get_rettype(m->declspec.type);
fprintf(fp, "\n{\n");
fprintf(fp, " %s\n", comment);
if (rt->name && strcmp(rt->name, "HRESULT") == 0)
@@ -1354,9 +1382,9 @@ static void write_locals(FILE *fp, const type_t *iface, int body)
else
fprintf(fp, ";\n");
/* stub prototype - use remotable prototype */
- write_type_decl_left(fp, type_function_get_rettype(func->type));
+ write_declspec_decl_left(fp, type_function_get_retdeclspec(func->declspec.type));
fprintf(fp, " __RPC_STUB %s_%s_Stub(\n", iface->name, get_name(m));
- write_args(fp, type_get_function_args(func->type), iface->name, 1, TRUE);
+ write_args(fp, type_get_function_args(func->declspec.type), iface->name, 1, TRUE);
fprintf(fp, ")");
if (body)
/* Remotable methods must all return HRESULTs. */
@@ -1402,15 +1430,15 @@ void write_local_stubs(const statement_list_t *stmts)
static void write_function_proto(FILE *header, const type_t *iface, const var_t *fun, const char *prefix)
{
- const char *callconv = get_attrp(fun->type->attrs, ATTR_CALLCONV);
+ const char *callconv = get_attrp(fun->declspec.type->attrs, ATTR_CALLCONV);
if (!callconv) callconv = "__cdecl";
/* FIXME: do we need to handle call_as? */
- write_type_decl_left(header, type_function_get_rettype(fun->type));
+ write_declspec_decl_left(header, type_function_get_retdeclspec(fun->declspec.type));
fprintf(header, " %s ", callconv);
fprintf(header, "%s%s(\n", prefix, get_name(fun));
- if (type_get_function_args(fun->type))
- write_args(header, type_get_function_args(fun->type), iface->name, 0, TRUE);
+ if (type_get_function_args(fun->declspec.type))
+ write_args(header, type_get_function_args(fun->declspec.type), iface->name, 0, TRUE);
else
fprintf(header, " void");
fprintf(header, ");\n\n");
@@ -1536,7 +1564,7 @@ static void write_rpc_interface_start(FILE *header, const type_t *iface)
if (var)
{
fprintf(header, "extern ");
- write_type_decl( header, var->type, var->name );
+ write_declspec_decl( header, (decl_spec_t*)&var->declspec, var->name );
fprintf(header, ";\n");
}
if (old_names)
@@ -1745,7 +1773,7 @@ static void write_header_stmts(FILE *header, const statement_list_t *stmts, cons
fprintf(header, "%s\n", stmt->u.str);
break;
case STMT_DECLARATION:
- if (iface && type_get_type(stmt->u.var->type) == TYPE_FUNCTION)
+ if (iface && type_get_type(stmt->u.var->declspec.type) == TYPE_FUNCTION)
{
if (!ignore_funcs)
{
diff --git a/tools/widl/header.h b/tools/widl/header.h
index 0d44b4039f..bb73e01a5f 100644
--- a/tools/widl/header.h
+++ b/tools/widl/header.h
@@ -28,11 +28,14 @@ extern int is_aliaschain_attr(const type_t *var, enum attr_type t);
extern int is_attr(const attr_list_t *list, enum attr_type t);
extern void *get_attrp(const attr_list_t *list, enum attr_type t);
extern unsigned int get_attrv(const attr_list_t *list, enum attr_type t);
+extern decl_spec_t *get_attrds(const attr_list_t *list, enum attr_type t);
extern const char* get_name(const var_t *v);
+extern void write_declspec_left(FILE *h, decl_spec_t *ds, enum name_type name_type, int declonly);
extern void write_type_left(FILE *h, type_t *t, enum name_type name_type, int declonly);
extern void write_type_right(FILE *h, type_t *t, int is_field);
extern void write_type_decl(FILE *f, type_t *t, const char *name);
-extern void write_type_decl_left(FILE *f, type_t *t);
+extern void write_declspec_decl(FILE *f, decl_spec_t *ds, const char *name);
+extern void write_declspec_decl_left(FILE *f, decl_spec_t *ds);
extern unsigned int get_context_handle_offset( const type_t *type );
extern unsigned int get_generic_handle_offset( const type_t *type );
extern int needs_space_after(type_t *t);
@@ -83,12 +86,12 @@ static inline int is_conformant_array(const type_t *t)
static inline int last_ptr(const type_t *type)
{
- return is_ptr(type) && !is_declptr(type_pointer_get_ref(type));
+ return is_ptr(type) && !is_declptr(type_pointer_get_ref_type(type));
}
static inline int last_array(const type_t *type)
{
- return is_array(type) && !is_array(type_array_get_element(type));
+ return is_array(type) && !is_array(type_array_get_element_type(type));
}
static inline int is_string_type(const attr_list_t *attrs, const type_t *type)
@@ -102,7 +105,7 @@ static inline int is_context_handle(const type_t *type)
const type_t *t;
for (t = type;
is_ptr(t) || type_is_alias(t);
- t = type_is_alias(t) ? type_alias_get_aliasee(t) : type_pointer_get_ref(t))
+ t = type_is_alias(t) ? type_alias_get_aliasee_type(t) : type_pointer_get_ref_type(t))
if (is_attr(t->attrs, ATTR_CONTEXTHANDLE))
return 1;
return 0;
diff --git a/tools/widl/parser.y b/tools/widl/parser.y
index dd676e9a28..23e17a7739 100644
--- a/tools/widl/parser.y
+++ b/tools/widl/parser.y
@@ -52,13 +52,6 @@ struct _import_t
int import_performed;
};
-typedef struct _decl_spec_t
-{
- type_t *type;
- attr_list_t *attrs;
- enum storage_class stgclass;
-} decl_spec_t;
-
typelist_t incomplete_types = LIST_INIT(incomplete_types);
static void fix_incomplete(void);
@@ -68,9 +61,11 @@ static str_list_t *append_str(str_list_t *list, char *str);
static attr_list_t *append_attr(attr_list_t *list, attr_t *attr);
static attr_list_t *append_attr_list(attr_list_t *new_list, attr_list_t *old_list);
static decl_spec_t *make_decl_spec(type_t *type, decl_spec_t *left, decl_spec_t *right, attr_t *attr, enum storage_class stgclass);
+static decl_spec_t *make_decl_spec2(type_t *type, decl_spec_t *left, decl_spec_t *right, enum storage_class stgclass, enum type_qualifier typequalifier, enum function_specifier funcspecifier);
static attr_t *make_attr(enum attr_type type);
static attr_t *make_attrv(enum attr_type type, unsigned int val);
static attr_t *make_attrp(enum attr_type type, void *val);
+static attr_t *make_attrds(enum attr_type type, type_t *val);
static expr_list_t *append_expr(expr_list_t *list, expr_t *expr);
static type_t *append_array(type_t *chain, expr_t *expr);
static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const declarator_t *decl, int top);
@@ -597,7 +592,7 @@ attribute: { $$ = NULL; }
| tVARARG { $$ = make_attr(ATTR_VARARG); }
| tVERSION '(' version ')' { $$ = make_attrv(ATTR_VERSION, $3); }
| tVIPROGID '(' aSTRING ')' { $$ = make_attrp(ATTR_VIPROGID, $3); }
- | tWIREMARSHAL '(' type ')' { $$ = make_attrp(ATTR_WIREMARSHAL, $3); }
+ | tWIREMARSHAL '(' type ')' { $$ = make_attrds(ATTR_WIREMARSHAL, $3); }
| pointer_type { $$ = make_attrv(ATTR_POINTERTYPE, $1); }
;
@@ -651,10 +646,10 @@ enum_list: enum { if (!$1->eval)
enum: ident '=' expr_int_const { $$ = reg_const($1);
$$->eval = $3;
- $$->type = type_new_int(TYPE_BASIC_INT, 0);
+ $$->declspec.type = type_new_int(TYPE_BASIC_INT, 0);
}
| ident { $$ = reg_const($1);
- $$->type = type_new_int(TYPE_BASIC_INT, 0);
+ $$->declspec.type = type_new_int(TYPE_BASIC_INT, 0);
}
;
@@ -740,7 +735,7 @@ field: m_attributes decl_spec struct_declarator_list ';'
$$ = set_var_types($1, $2, $3);
}
| m_attributes uniondef ';' { var_t *v = make_var(NULL);
- v->type = $2; v->attrs = $1;
+ v->declspec.type = $2; v->attrs = $1;
$$ = append_var(NULL, v);
}
;
@@ -764,13 +759,13 @@ s_field: m_attributes decl_spec declarator { $$ = declare_var(check_field_attrs
free($3);
}
| m_attributes structdef { var_t *v = make_var(NULL);
- v->type = $2; v->attrs = $1;
+ v->declspec.type = $2; v->attrs = $1;
$$ = v;
}
;
funcdef: declaration { $$ = $1;
- if (type_get_type($$->type) != TYPE_FUNCTION)
+ if (type_get_type($$->declspec.type) != TYPE_FUNCTION)
error_loc("only methods may be declared inside the methods section of a dispinterface\n");
check_function_attrs($$->name, $$->attrs);
}
@@ -1197,7 +1192,8 @@ static void decl_builtin_basic(const char *name, enum type_basic_type type)
static void decl_builtin_alias(const char *name, type_t *t)
{
- reg_type(type_new_alias(t, name), name, NULL, 0);
+ decl_spec_t ds;
+ reg_type(type_new_alias(init_declspec(&ds, t), name, &global_namespace), name, &global_namespace, 0);
}
void init_types(void)
@@ -1261,6 +1257,18 @@ static attr_list_t *move_attr(attr_list_t *dst, attr_list_t *src, enum attr_type
return dst;
}
+
+static attr_list_t *remove_attr(attr_list_t *lst, enum attr_type type)
+{
+ attr_t *attr;
+ LIST_FOR_EACH_ENTRY(attr, lst, attr_t, entry)
+ if (attr->type == type)
+ {
+ list_remove(&attr->entry);
+ }
+ return lst;
+}
+
static attr_list_t *append_attr_list(attr_list_t *new_list, attr_list_t *old_list)
{
struct list *entry;
@@ -1299,52 +1307,91 @@ static attr_list_t *map_attrs(const attr_list_t *list, map_attrs_filter_t filter
}
static decl_spec_t *make_decl_spec(type_t *type, decl_spec_t *left, decl_spec_t *right, attr_t *attr, enum storage_class stgclass)
+{
+ enum type_qualifier typequalifier = TYPE_QUALIFIER_NONE;
+ enum function_specifier funcspecifier = FUNCTION_SPECIFIER_NONE;
+
+ assert(attr == NULL || attr->type == ATTR_CONST || attr->type == ATTR_INLINE);
+
+ if (attr != NULL)
+ {
+ if (attr->type == ATTR_CONST)
+ typequalifier = TYPE_QUALIFIER_CONST;
+ else if (attr->type == ATTR_INLINE)
+ funcspecifier = FUNCTION_SPECIFIER_INLINE;
+ }
+
+ return make_decl_spec2(type, left, right, stgclass, typequalifier, funcspecifier);
+}
+
+static decl_spec_t *make_decl_spec2(type_t *type, decl_spec_t *left, decl_spec_t *right, enum storage_class stgclass, enum type_qualifier typequalifier, enum function_specifier funcspecifier)
{
decl_spec_t *declspec = left ? left : right;
+
if (!declspec)
{
declspec = xmalloc(sizeof(*declspec));
declspec->type = NULL;
- declspec->attrs = NULL;
declspec->stgclass = STG_NONE;
+ declspec->typequalifier = TYPE_QUALIFIER_NONE;
+ declspec->funcspecifier = FUNCTION_SPECIFIER_NONE;
}
declspec->type = type;
if (left && declspec != left)
{
- declspec->attrs = append_attr_list(declspec->attrs, left->attrs);
if (declspec->stgclass == STG_NONE)
declspec->stgclass = left->stgclass;
else if (left->stgclass != STG_NONE)
error_loc("only one storage class can be specified\n");
+
+ if (declspec->typequalifier == TYPE_QUALIFIER_NONE)
+ declspec->typequalifier = left->typequalifier;
+ else if (left->typequalifier != TYPE_QUALIFIER_NONE)
+ error_loc("only one type qualifier can be specified\n");
+
+ if (declspec->funcspecifier == FUNCTION_SPECIFIER_NONE)
+ declspec->funcspecifier = left->funcspecifier;
+ else if (left->funcspecifier != FUNCTION_SPECIFIER_NONE)
+ error_loc("only one function specifier can be specified\n");
+
assert(!left->type);
free(left);
}
if (right && declspec != right)
{
- declspec->attrs = append_attr_list(declspec->attrs, right->attrs);
if (declspec->stgclass == STG_NONE)
declspec->stgclass = right->stgclass;
else if (right->stgclass != STG_NONE)
error_loc("only one storage class can be specified\n");
+
+ if (declspec->typequalifier == TYPE_QUALIFIER_NONE)
+ declspec->typequalifier = right->typequalifier;
+ else if (right->typequalifier != TYPE_QUALIFIER_NONE)
+ error_loc("only one type qualifier can be specified\n");
+
+ if (declspec->funcspecifier == FUNCTION_SPECIFIER_NONE)
+ declspec->funcspecifier = right->funcspecifier;
+ else if (right->funcspecifier != FUNCTION_SPECIFIER_NONE)
+ error_loc("only one function specifier can be specified\n");
+
assert(!right->type);
free(right);
}
- declspec->attrs = append_attr(declspec->attrs, attr);
if (declspec->stgclass == STG_NONE)
declspec->stgclass = stgclass;
else if (stgclass != STG_NONE)
error_loc("only one storage class can be specified\n");
- /* apply attributes to type */
- if (type && declspec->attrs)
- {
- attr_list_t *attrs;
- declspec->type = duptype(type, 1);
- attrs = map_attrs(type->attrs, NULL);
- declspec->type->attrs = append_attr_list(attrs, declspec->attrs);
- declspec->attrs = NULL;
- }
+ if (declspec->typequalifier == TYPE_QUALIFIER_NONE)
+ declspec->typequalifier = typequalifier;
+ else if (typequalifier != TYPE_QUALIFIER_NONE)
+ error_loc("only one type qualifier can be specified\n");
+
+ if (declspec->funcspecifier == FUNCTION_SPECIFIER_NONE)
+ declspec->funcspecifier = funcspecifier;
+ else if (funcspecifier != FUNCTION_SPECIFIER_NONE)
+ error_loc("only one function specifier can be specified\n");
return declspec;
}
@@ -1373,6 +1420,17 @@ static attr_t *make_attrp(enum attr_type type, void *val)
return a;
}
+static attr_t *make_attrds(enum attr_type type, type_t *val)
+{
+ attr_t *a = NULL;
+ assert(type == ATTR_WIREMARSHAL);
+ a = xmalloc(sizeof(attr_t));
+
+ a->type = type;
+ init_declspec(&a->u.dsval, val);
+ return a;
+}
+
static expr_list_t *append_expr(expr_list_t *list, expr_t *expr)
{
if (!expr) return list;
@@ -1474,15 +1532,16 @@ static int is_allowed_range_type(const type_t *type)
static type_t *get_array_or_ptr_ref(type_t *type)
{
if (is_ptr(type))
- return type_pointer_get_ref(type);
+ return type_pointer_get_ref_type(type);
else if (is_array(type))
- return type_array_get_element(type);
+ return type_array_get_element_type(type);
return NULL;
}
static type_t *append_chain_type(type_t *chain, type_t *type)
{
- type_t *chain_type;
+ type_t *chain_type = NULL;
+ decl_spec_t *chain_declspec = NULL;
if (!chain)
return type;
@@ -1490,12 +1549,20 @@ static type_t *append_chain_type(type_t *chain, type_t *type)
;
if (is_ptr(chain_type))
- chain_type->details.pointer.ref = type;
+ chain_declspec = &chain_type->details.pointer.ref;
else if (is_array(chain_type))
- chain_type->details.array.elem = type;
+ chain_declspec = &chain_type->details.array.elem;
else
assert(0);
+ chain_declspec->type = type;
+ /* we need to move the ATTR_CONST attribute off the type of the pointee and onto its declspec
+ * typequalifier on the pointer */
+ if (is_attr(type->attrs, ATTR_CONST)) {
+ type->attrs = remove_attr(type->attrs, ATTR_CONST);
+ chain_declspec->typequalifier = TYPE_QUALIFIER_CONST;
+ }
+
return chain;
}
@@ -1514,7 +1581,7 @@ static warning_list_t *append_warning(warning_list_t *list, int num)
return list;
}
-static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const declarator_t *decl,
+static var_t *declare_var(attr_list_t *attrs, decl_spec_t *declspec, const declarator_t *decl,
int top)
{
var_t *v = decl->var;
@@ -1523,58 +1590,79 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl
expr_t *dim;
type_t **ptype;
type_t *func_type = decl ? decl->func_type : NULL;
- type_t *type = decl_spec->type;
+ type_t *type = declspec->type;
- if (is_attr(type->attrs, ATTR_INLINE))
- {
+
+ if (declspec->funcspecifier == FUNCTION_SPECIFIER_INLINE) {
if (!func_type)
+ {
error_loc("inline attribute applied to non-function type\n");
+ }
else
{
- type_t *t;
- /* move inline attribute from return type node to function node */
- for (t = func_type; is_ptr(t); t = type_pointer_get_ref(t))
- ;
- t->attrs = move_attr(t->attrs, type->attrs, ATTR_INLINE);
+ v->declspec.funcspecifier = declspec->funcspecifier;
+ }
+ }
+
+ /* if the var type is a pointerish, we need to move the type qualifier to the pointee's declspec
+ * unless the pointee already has const type qualifier*/
+
+ /* we need to shuffle aroundand tranlate between TYPE_QUALIFEIR_CONST and ATTR_CONST
+ * in this block */
+ if (!decl)
+ {
+ /* simplest case, no pointers to deal with here */
+ v->declspec.typequalifier = declspec->typequalifier;
+ } else if (decl->bits) {
+ /* dealing with a bitfield, just pass it on */
+ v->declspec.type = type_new_bitfield(declspec, decl->bits);
+ }
+ else {
+ /* here we're dealing with a pointerish type chain, so we need to pull
+ * the typequalifier off of the declspec and stick them in the type's attr list
+ */
+ if (declspec->typequalifier == TYPE_QUALIFIER_CONST) {
+ type->attrs = append_attr(type->attrs, make_attr(ATTR_CONST));
+ assert(is_attr(type->attrs, ATTR_CONST));
+ }
+
+ v->declspec.type = append_chain_type(decl->type, type);
+ /* finally pull the ATTR_CONST attribute off the head of the pointerish type chain,
+ * and stick on the var's declspec */
+ if (is_attr(v->declspec.type->attrs, ATTR_CONST)) {
+ v->declspec.type->attrs = remove_attr(v->declspec.type->attrs, ATTR_CONST);
+ v->declspec.typequalifier = TYPE_QUALIFIER_CONST;
}
}
- /* add type onto the end of the pointers in pident->type */
- v->type = append_chain_type(decl ? decl->type : NULL, type);
- v->stgclass = decl_spec->stgclass;
+ v->declspec.stgclass = declspec->stgclass;
v->attrs = attrs;
/* check for pointer attribute being applied to non-pointer, non-array
* type */
- if (!is_array(v->type))
+ if (!is_array(v->declspec.type))
{
int ptr_attr = get_attrv(v->attrs, ATTR_POINTERTYPE);
const type_t *ptr = NULL;
/* pointer attributes on the left side of the type belong to the function
* pointer, if one is being declared */
- type_t **pt = func_type ? &func_type : &v->type;
+ type_t **pt = func_type ? &func_type : &v->declspec.type;
for (ptr = *pt; ptr && !ptr_attr; )
{
ptr_attr = get_attrv(ptr->attrs, ATTR_POINTERTYPE);
if (!ptr_attr && type_is_alias(ptr))
- ptr = type_alias_get_aliasee(ptr);
+ ptr = type_alias_get_aliasee_type(ptr);
else
break;
}
if (is_ptr(ptr))
{
if (ptr_attr && ptr_attr != FC_UP &&
- type_get_type(type_pointer_get_ref(ptr)) == TYPE_INTERFACE)
+ type_get_type(type_pointer_get_ref_type(ptr)) == TYPE_INTERFACE)
+ {
warning_loc_info(&v->loc_info,
"%s: pointer attribute applied to interface "
"pointer type has no effect\n", v->name);
- if (!ptr_attr && top && (*pt)->details.pointer.def_fc != FC_RP)
- {
- /* FIXME: this is a horrible hack to cope with the issue that we
- * store an offset to the typeformat string in the type object, but
- * two typeformat strings may be written depending on whether the
- * pointer is a toplevel parameter or not */
- *pt = duptype(*pt, 1);
}
}
else if (ptr_attr)
@@ -1585,16 +1673,16 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl
{
type_t *t = type;
- if (!is_ptr(v->type) && !is_array(v->type))
+ if (!is_ptr(v->declspec.type) && !is_array(v->declspec.type))
error_loc("'%s': [string] attribute applied to non-pointer, non-array type\n",
v->name);
for (;;)
{
if (is_ptr(t))
- t = type_pointer_get_ref(t);
+ t = type_pointer_get_ref_type(t);
else if (is_array(t))
- t = type_array_get_element(t);
+ t = type_array_get_element_type(t);
else
break;
}
@@ -1611,15 +1699,15 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl
if (is_attr(v->attrs, ATTR_V1ENUM))
{
- if (type_get_type_detect_alias(v->type) != TYPE_ENUM)
+ if (type_get_type_detect_alias(v->declspec.type) != TYPE_ENUM)
error_loc("'%s': [v1_enum] attribute applied to non-enum type\n", v->name);
}
- if (is_attr(v->attrs, ATTR_RANGE) && !is_allowed_range_type(v->type))
+ if (is_attr(v->attrs, ATTR_RANGE) && !is_allowed_range_type(v->declspec.type))
error_loc("'%s': [range] attribute applied to non-integer type\n",
v->name);
- ptype = &v->type;
+ ptype = &v->declspec.type;
if (sizes) LIST_FOR_EACH_ENTRY(dim, sizes, expr_t, entry)
{
if (dim->type != EXPR_VOID)
@@ -1635,21 +1723,23 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl
0, dim, NULL, 0);
}
else if (is_ptr(*ptype))
+ {
*ptype = type_new_array((*ptype)->name, type_pointer_get_ref(*ptype), TRUE,
0, dim, NULL, pointer_default);
+ }
else
error_loc("%s: size_is attribute applied to illegal type\n", v->name);
}
if (is_ptr(*ptype))
- ptype = &(*ptype)->details.pointer.ref;
+ ptype = &(*ptype)->details.pointer.ref.type;
else if (is_array(*ptype))
- ptype = &(*ptype)->details.array.elem;
+ ptype = &(*ptype)->details.array.elem.type;
else
error_loc("%s: too many expressions in size_is attribute\n", v->name);
}
- ptype = &v->type;
+ ptype = &v->declspec.type;
if (lengs) LIST_FOR_EACH_ENTRY(dim, lengs, expr_t, entry)
{
if (dim->type != EXPR_VOID)
@@ -1668,9 +1758,9 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl
}
if (is_ptr(*ptype))
- ptype = &(*ptype)->details.pointer.ref;
+ ptype = &(*ptype)->details.pointer.ref.type;
else if (is_array(*ptype))
- ptype = &(*ptype)->details.array.elem;
+ ptype = &(*ptype)->details.array.elem.type;
else
error_loc("%s: too many expressions in length_is attribute\n", v->name);
}
@@ -1681,29 +1771,31 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl
if (func_type)
{
type_t *ft, *t;
- type_t *return_type = v->type;
- v->type = func_type;
- for (ft = v->type; is_ptr(ft); ft = type_pointer_get_ref(ft))
+ type_t *return_type = v->declspec.type;
+ enum type_qualifier typequalifier = v->declspec.typequalifier;
+
+ v->declspec.type = func_type;
+ v->declspec.typequalifier = TYPE_QUALIFIER_NONE;
+ for (ft = v->declspec.type; is_ptr(ft); ft = type_pointer_get_ref_type(ft))
;
assert(type_get_type_detect_alias(ft) == TYPE_FUNCTION);
ft->details.function->retval = make_var(xstrdup("_RetVal"));
- ft->details.function->retval->type = return_type;
+ ft->details.function->retval->declspec.type = return_type;
+ ft->details.function->retval->declspec.typequalifier = typequalifier;
+
/* move calling convention attribute, if present, from pointer nodes to
* function node */
- for (t = v->type; is_ptr(t); t = type_pointer_get_ref(t))
+ for (t = v->declspec.type; is_ptr(t); t = type_pointer_get_ref_type(t))
ft->attrs = move_attr(ft->attrs, t->attrs, ATTR_CALLCONV);
}
else
{
type_t *t;
- for (t = v->type; is_ptr(t); t = type_pointer_get_ref(t))
+ for (t = v->declspec.type; is_ptr(t); t = type_pointer_get_ref_type(t))
if (is_attr(t->attrs, ATTR_CALLCONV))
error_loc("calling convention applied to non-function-pointer type\n");
}
- if (decl->bits)
- v->type = type_new_bitfield(v->type, decl->bits);
-
return v;
}
@@ -1770,10 +1862,12 @@ var_t *make_var(char *name)
{
var_t *v = xmalloc(sizeof(var_t));
v->name = name;
- v->type = NULL;
+ v->declspec.type = NULL;
+ v->declspec.stgclass = STG_NONE;
+ v->declspec.typequalifier = TYPE_QUALIFIER_NONE;
+ v->declspec.funcspecifier = FUNCTION_SPECIFIER_NONE;
v->attrs = NULL;
v->eval = NULL;
- v->stgclass = STG_NONE;
init_loc_info(&v->loc_info);
return v;
}
@@ -1782,10 +1876,9 @@ static var_t *copy_var(var_t *src, char *name, map_attrs_filter_t attr_filter)
{
var_t *v = xmalloc(sizeof(var_t));
v->name = name;
- v->type = src->type;
+ v->declspec = src->declspec;
v->attrs = map_attrs(src->attrs, attr_filter);
v->eval = src->eval;
- v->stgclass = src->stgclass;
v->loc_info = src->loc_info;
return v;
}
@@ -1813,7 +1906,16 @@ static declarator_t *make_declarator(var_t *var)
static type_t *make_safearray(type_t *type)
{
- return type_new_array(NULL, type_new_alias(type, "SAFEARRAY"), TRUE, 0,
+ decl_spec_t aliasee_ds;
+ decl_spec_t element_ds;
+
+ init_declspec(&element_ds,
+ type_new_alias(
+ init_declspec(&aliasee_ds, type),
+ "SAFEARRAY",
+ &global_namespace));
+
+ return type_new_array(NULL, &element_ds, TRUE, 0,
NULL, NULL, FC_RP);
}
@@ -1926,7 +2028,7 @@ void add_incomplete(type_t *t)
static void fix_type(type_t *t)
{
if (type_is_alias(t) && is_incomplete(t)) {
- type_t *ot = type_alias_get_aliasee(t);
+ type_t *ot = type_alias_get_aliasee_type(t);
fix_type(ot);
if (type_get_type_detect_alias(ot) == TYPE_STRUCT ||
type_get_type_detect_alias(ot) == TYPE_UNION ||
@@ -2010,7 +2112,7 @@ static type_t *reg_typedefs(decl_spec_t *decl_spec, declarator_list_t *decls, at
cur->loc_info.line_number);
name = declare_var(attrs, decl_spec, decl, 0);
- cur = type_new_alias(name->type, name->name);
+ cur = type_new_alias(&name->declspec, name->name, current_namespace);
cur->attrs = attrs;
if (is_incomplete(cur))
@@ -2285,10 +2387,10 @@ static attr_list_t *check_iface_attrs(const char *name, attr_list_t *attrs)
if (attr->type == ATTR_IMPLICIT_HANDLE)
{
const var_t *var = attr->u.pval;
- if (type_get_type( var->type) == TYPE_BASIC &&
- type_basic_get_type( var->type ) == TYPE_BASIC_HANDLE)
+ if (type_get_type( var->declspec.type) == TYPE_BASIC &&
+ type_basic_get_type( var->declspec.type ) == TYPE_BASIC_HANDLE)
continue;
- if (is_aliaschain_attr( var->type, ATTR_HANDLE ))
+ if (is_aliaschain_attr( var->declspec.type, ATTR_HANDLE ))
continue;
error_loc("attribute %s requires a handle type in interface %s\n",
allowed_attr[attr->type].display_name, name);
@@ -2493,7 +2595,7 @@ static int is_ptr_guid_type(const type_t *type)
/* second, make sure it is a pointer to something of size sizeof(GUID),
* i.e. 16 bytes */
- return (type_memsize(type_pointer_get_ref(type)) == 16);
+ return (type_memsize(type_pointer_get_ref_type(type)) == 16);
}
static void check_conformance_expr_list(const char *attr_name, const var_t *arg, const type_t *container_type, expr_list_t *expr_list)
@@ -2520,7 +2622,7 @@ static void check_remoting_fields(const var_t *var, type_t *type);
static void check_field_common(const type_t *container_type,
const char *container_name, const var_t *arg)
{
- type_t *type = arg->type;
+ type_t *type = arg->declspec.type;
int more_to_do;
const char *container_type_name;
const char *var_type;
@@ -2550,7 +2652,7 @@ static void check_field_common(const type_t *container_type,
}
if (is_attr(arg->attrs, ATTR_LENGTHIS) &&
- (is_attr(arg->attrs, ATTR_STRING) || is_aliaschain_attr(arg->type, ATTR_STRING)))
+ (is_attr(arg->attrs, ATTR_STRING) || is_aliaschain_attr(arg->declspec.type, ATTR_STRING)))
error_loc_info(&arg->loc_info,
"string and length_is specified for argument %s are mutually exclusive attributes\n",
arg->name);
@@ -2647,17 +2749,17 @@ static void check_field_common(const type_t *container_type,
{
const type_t *t = type;
while (is_ptr(t))
- t = type_pointer_get_ref(t);
+ t = type_pointer_get_ref_type(t);
if (is_aliaschain_attr(t, ATTR_RANGE))
warning_loc_info(&arg->loc_info, "%s: range not verified for a string of ranged types\n", arg->name);
break;
}
case TGT_POINTER:
- type = type_pointer_get_ref(type);
+ type = type_pointer_get_ref_type(type);
more_to_do = TRUE;
break;
case TGT_ARRAY:
- type = type_array_get_element(type);
+ type = type_array_get_element_type(type);
more_to_do = TRUE;
break;
case TGT_USER_TYPE:
@@ -2694,7 +2796,7 @@ static void check_remoting_fields(const var_t *var, type_t *type)
fields = type_union_get_cases(type);
if (fields) LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry )
- if (field->type) check_field_common(type, type->name, field);
+ if (field->declspec.type) check_field_common(type, type->name, field);
}
/* checks that arguments for a function make sense for marshalling and unmarshalling */
@@ -2703,9 +2805,9 @@ static void check_remoting_args(const var_t *func)
const char *funcname = func->name;
const var_t *arg;
- if (func->type->details.function->args) LIST_FOR_EACH_ENTRY( arg, func->type->details.function->args, const var_t, entry )
+ if (func->declspec.type->details.function->args) LIST_FOR_EACH_ENTRY( arg, func->declspec.type->details.function->args, const var_t, entry )
{
- const type_t *type = arg->type;
+ const type_t *type = arg->declspec.type;
/* check that [out] parameters have enough pointer levels */
if (is_attr(arg->attrs, ATTR_OUT))
@@ -2745,16 +2847,16 @@ static void check_remoting_args(const var_t *func)
}
}
- check_field_common(func->type, funcname, arg);
+ check_field_common(func->declspec.type, funcname, arg);
}
- if (type_get_type(type_function_get_rettype(func->type)) != TYPE_VOID)
+ if (type_get_type(type_function_get_rettype(func->declspec.type)) != TYPE_VOID)
{
var_t var;
var = *func;
- var.type = type_function_get_rettype(func->type);
+ var.declspec.type = type_function_get_rettype(func->declspec.type);
var.name = xstrdup("return value");
- check_field_common(func->type, funcname, &var);
+ check_field_common(func->declspec.type, funcname, &var);
free(var.name);
}
}
@@ -2771,8 +2873,8 @@ static void add_explicit_handle_if_necessary(const type_t *iface, var_t *func)
* function */
var_t *idl_handle = make_var(xstrdup("IDL_handle"));
idl_handle->attrs = append_attr(NULL, make_attr(ATTR_IN));
- idl_handle->type = find_type_or_error("handle_t", 0);
- type_function_add_head_arg(func->type, idl_handle);
+ idl_handle->declspec.type = find_type_or_error("handle_t", 0);
+ type_function_add_head_arg(func->declspec.type, idl_handle);
}
}
@@ -2853,7 +2955,7 @@ static void check_async_uuid(type_t *iface)
var_t *begin_func, *finish_func, *func = stmt->u.var, *arg;
var_list_t *begin_args = NULL, *finish_args = NULL, *args;
- args = func->type->details.function->args;
+ args = func->declspec.type->details.function->args;
if (args) LIST_FOR_EACH_ENTRY(arg, args, var_t, entry)
{
if (is_attr(arg->attrs, ATTR_IN) || !is_attr(arg->attrs, ATTR_OUT))
@@ -2863,15 +2965,15 @@ static void check_async_uuid(type_t *iface)
}
begin_func = copy_var(func, concat_str("Begin_", func->name), NULL);
- begin_func->type = type_new_function(begin_args);
- begin_func->type->attrs = func->attrs;
- begin_func->type->details.function->retval = func->type->details.function->retval;
+ begin_func->declspec.type = type_new_function(begin_args);
+ begin_func->declspec.type->attrs = func->attrs;
+ begin_func->declspec.type->details.function->retval = func->declspec.type->details.function->retval;
stmts = append_statement(stmts, make_statement_declaration(begin_func));
finish_func = copy_var(func, concat_str("Finish_", func->name), NULL);
- finish_func->type = type_new_function(finish_args);
- finish_func->type->attrs = func->attrs;
- finish_func->type->details.function->retval = func->type->details.function->retval;
+ finish_func->declspec.type = type_new_function(finish_args);
+ finish_func->declspec.type->attrs = func->attrs;
+ finish_func->declspec.type->details.function->retval = func->declspec.type->details.function->retval;
stmts = append_statement(stmts, make_statement_declaration(finish_func));
}
@@ -2923,10 +3025,10 @@ static void check_all_user_types(const statement_list_t *stmts)
const statement_t *stmt_func;
STATEMENTS_FOR_EACH_FUNC(stmt_func, type_iface_get_stmts(stmt->u.type)) {
const var_t *func = stmt_func->u.var;
- if (func->type->details.function->args)
- LIST_FOR_EACH_ENTRY( v, func->type->details.function->args, const var_t, entry )
- check_for_additional_prototype_types(v->type);
- check_for_additional_prototype_types(type_function_get_rettype(func->type));
+ if (func->declspec.type->details.function->args)
+ LIST_FOR_EACH_ENTRY( v, func->declspec.type->details.function->args, const var_t, entry )
+ check_for_additional_prototype_types(v->declspec.type);
+ check_for_additional_prototype_types(type_function_get_rettype(func->declspec.type));
}
}
}
@@ -2974,16 +3076,16 @@ static statement_t *make_statement_declaration(var_t *var)
{
statement_t *stmt = make_statement(STMT_DECLARATION);
stmt->u.var = var;
- if (var->stgclass == STG_EXTERN && var->eval)
+ if (var->declspec.stgclass == STG_EXTERN && var->eval)
warning("'%s' initialised and declared extern\n", var->name);
if (is_const_decl(var))
{
if (var->eval)
reg_const(var);
}
- else if (type_get_type(var->type) == TYPE_FUNCTION)
+ else if (type_get_type(var->declspec.type) == TYPE_FUNCTION)
check_function_attrs(var->name, var->attrs);
- else if (var->stgclass == STG_NONE || var->stgclass == STG_REGISTER)
+ else if (var->declspec.stgclass == STG_NONE || var->declspec.stgclass == STG_REGISTER)
error_loc("instantiation of data is illegal\n");
return stmt;
}
diff --git a/tools/widl/proxy.c b/tools/widl/proxy.c
index 8d0e8b2cc5..a6ad2a26cf 100644
--- a/tools/widl/proxy.c
+++ b/tools/widl/proxy.c
@@ -105,15 +105,15 @@ static void clear_output_vars( const var_list_t *args )
{
if (is_attr(arg->attrs, ATTR_IN)) continue;
if (!is_attr(arg->attrs, ATTR_OUT)) continue;
- if (is_ptr(arg->type))
+ if (is_ptr(arg->declspec.type))
{
- if (type_get_type(type_pointer_get_ref(arg->type)) == TYPE_BASIC) continue;
- if (type_get_type(type_pointer_get_ref(arg->type)) == TYPE_ENUM) continue;
+ if (type_get_type(type_pointer_get_ref_type(arg->declspec.type)) == TYPE_BASIC) continue;
+ if (type_get_type(type_pointer_get_ref_type(arg->declspec.type)) == TYPE_ENUM) continue;
}
print_proxy( "if (%s) MIDL_memset( %s, 0, ", arg->name, arg->name );
- if (is_array(arg->type) && type_array_has_conformance(arg->type))
+ if (is_array(arg->declspec.type) && type_array_has_conformance(arg->declspec.type))
{
- write_expr( proxy, type_array_get_conformance(arg->type), 1, 1, NULL, NULL, "" );
+ write_expr( proxy, type_array_get_conformance(arg->declspec.type), 1, 1, NULL, NULL, "" );
fprintf( proxy, " * " );
}
fprintf( proxy, "sizeof( *%s ));\n", arg->name );
@@ -147,7 +147,7 @@ static int need_delegation_indirect(const type_t *iface)
static void free_variable( const var_t *arg, const char *local_var_prefix )
{
unsigned int type_offset = arg->typestring_offset;
- type_t *type = arg->type;
+ type_t *type = arg->declspec.type;
write_parameter_conf_or_var_exprs(proxy, indent, local_var_prefix, PHASE_FREE, arg, FALSE);
@@ -191,18 +191,18 @@ static void proxy_free_variables( var_list_t *args, const char *local_var_prefix
static void gen_proxy(type_t *iface, const var_t *func, int idx,
unsigned int proc_offset)
{
- var_t *retval = type_function_get_retval(func->type);
- int has_ret = !is_void(retval->type);
+ var_t *retval = type_function_get_retval(func->declspec.type);
+ int has_ret = !is_void(retval->declspec.type);
int has_full_pointer = is_full_pointer_function(func);
- const char *callconv = get_attrp(func->type->attrs, ATTR_CALLCONV);
- const var_list_t *args = type_get_function_args(func->type);
+ const char *callconv = get_attrp(func->declspec.type->attrs, ATTR_CALLCONV);
+ const var_list_t *args = type_get_function_args(func->declspec.type);
if (!callconv) callconv = "STDMETHODCALLTYPE";
indent = 0;
if (is_interpreted_func( iface, func ))
{
if (get_stub_mode() == MODE_Oif && !is_callas( func->attrs )) return;
- write_type_decl_left(proxy, retval->type);
+ write_declspec_decl_left(proxy, &retval->declspec);
print_proxy( " %s %s_%s_Proxy(\n", callconv, iface->name, get_name(func));
write_args(proxy, args, iface->name, 1, TRUE);
print_proxy( ")\n");
@@ -219,7 +219,7 @@ static void gen_proxy(type_t *iface, const var_t *func, int idx,
print_proxy( "}\n");
print_proxy( "\n");
- write_type_decl_left(proxy, retval->type);
+ write_declspec_decl_left(proxy, (decl_spec_t*)&retval->declspec);
print_proxy( " %s %s_%s_Proxy(\n", callconv, iface->name, get_name(func));
write_args(proxy, args, iface->name, 1, TRUE);
print_proxy( ")\n");
@@ -229,12 +229,12 @@ static void gen_proxy(type_t *iface, const var_t *func, int idx,
/* local variables */
if (has_ret) {
print_proxy( "%s", "" );
- write_type_decl(proxy, retval->type, retval->name);
+ write_declspec_decl(proxy, &retval->declspec, retval->name);
fprintf( proxy, ";\n" );
}
print_proxy( "RPC_MESSAGE _RpcMessage;\n" );
if (has_ret) {
- if (decl_indirect(retval->type))
+ if (decl_indirect(retval->declspec.type))
print_proxy("void *_p_%s = &%s;\n", retval->name, retval->name);
}
print_proxy( "\n");
@@ -246,7 +246,7 @@ static void gen_proxy(type_t *iface, const var_t *func, int idx,
write_full_pointer_init(proxy, indent, func, FALSE);
/* FIXME: trace */
- clear_output_vars( type_get_function_args(func->type) );
+ clear_output_vars( type_get_function_args(func->declspec.type) );
print_proxy( "RpcTryExcept\n" );
print_proxy( "{\n" );
@@ -279,9 +279,9 @@ static void gen_proxy(type_t *iface, const var_t *func, int idx,
if (has_ret)
{
- if (decl_indirect(retval->type))
+ if (decl_indirect(retval->declspec.type))
print_proxy("MIDL_memset(&%s, 0, sizeof(%s));\n", retval->name, retval->name);
- else if (is_ptr(retval->type) || is_array(retval->type))
+ else if (is_ptr(retval->declspec.type) || is_array(retval->declspec.type))
print_proxy("%s = 0;\n", retval->name);
write_remoting_arguments(proxy, indent, func, "", PASS_RETURN, PHASE_UNMARSHAL);
}
@@ -301,7 +301,7 @@ static void gen_proxy(type_t *iface, const var_t *func, int idx,
print_proxy( "{\n" );
if (has_ret) {
indent++;
- proxy_free_variables( type_get_function_args(func->type), "" );
+ proxy_free_variables( type_get_function_args(func->declspec.type), "" );
print_proxy( "_RetVal = NdrProxyErrorHandler(RpcExceptionCode());\n" );
indent--;
}
@@ -320,7 +320,7 @@ static void gen_stub(type_t *iface, const var_t *func, const char *cas,
unsigned int proc_offset)
{
const var_t *arg;
- int has_ret = !is_void(type_function_get_rettype(func->type));
+ int has_ret = !is_void(type_function_get_rettype(func->declspec.type));
int has_full_pointer = is_full_pointer_function(func);
if (is_interpreted_func( iface, func )) return;
@@ -389,10 +389,10 @@ static void gen_stub(type_t *iface, const var_t *func, const char *cas,
else fprintf(proxy, "__frame->_This->lpVtbl->%s", get_name(func));
fprintf(proxy, "(__frame->_This");
- if (type_get_function_args(func->type))
+ if (type_get_function_args(func->declspec.type))
{
- LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->type), const var_t, entry )
- fprintf(proxy, ", %s__frame->%s", is_array(arg->type) && !type_array_is_decl_as_ptr(arg->type) ? "*" :"" , arg->name);
+ LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->declspec.type), const var_t, entry )
+ fprintf(proxy, ", %s__frame->%s", is_array(arg->declspec.type) && !type_array_is_decl_as_ptr(arg->declspec.type) ? "*" :"" , arg->name);
}
fprintf(proxy, ");\n");
fprintf(proxy, "\n");
@@ -401,7 +401,7 @@ static void gen_stub(type_t *iface, const var_t *func, const char *cas,
write_remoting_arguments(proxy, indent, func, "__frame->", PASS_OUT, PHASE_BUFFERSIZE);
- if (!is_void(type_function_get_rettype(func->type)))
+ if (!is_void(type_function_get_rettype(func->declspec.type)))
write_remoting_arguments(proxy, indent, func, "__frame->", PASS_RETURN, PHASE_BUFFERSIZE);
print_proxy("NdrStubGetBuffer(This, _pRpcChannelBuffer, &__frame->_StubMsg);\n");
@@ -410,7 +410,7 @@ static void gen_stub(type_t *iface, const var_t *func, const char *cas,
fprintf(proxy, "\n");
/* marshall the return value */
- if (!is_void(type_function_get_rettype(func->type)))
+ if (!is_void(type_function_get_rettype(func->declspec.type)))
write_remoting_arguments(proxy, indent, func, "__frame->", PASS_RETURN, PHASE_MARSHAL);
indent--;
@@ -432,16 +432,16 @@ static void gen_stub(type_t *iface, const var_t *func, const char *cas,
static void gen_stub_thunk( type_t *iface, const var_t *func, unsigned int proc_offset )
{
- int has_ret = !is_void( type_function_get_rettype( func->type ));
+ int has_ret = !is_void( type_function_get_rettype( func->declspec.type ));
const var_t *arg, *callas = is_callas( func->attrs );
- const var_list_t *args = type_get_function_args( func->type );
+ const var_list_t *args = type_get_function_args( func->declspec.type );
indent = 0;
print_proxy( "void __RPC_API %s_%s_Thunk( PMIDL_STUB_MESSAGE pStubMsg )\n",
iface->name, get_name(func) );
print_proxy( "{\n");
indent++;
- write_func_param_struct( proxy, iface, func->type,
+ write_func_param_struct( proxy, iface, func->declspec.type,
"*pParamStruct = (struct _PARAM_STRUCT *)pStubMsg->StackTop", has_ret );
print_proxy( "%s%s_%s_Stub( pParamStruct->This",
has_ret ? "pParamStruct->_RetVal = " : "", iface->name, callas->name );
@@ -613,14 +613,14 @@ static void write_proxy(type_t *iface, unsigned int *proc_offset)
if (!is_local(func->attrs)) {
const var_t *cas = is_callas(func->attrs);
const char *cname = cas ? cas->name : NULL;
- int idx = func->type->details.function->idx;
+ int idx = func->declspec.type->details.function->idx;
if (cname) {
const statement_t *stmt2;
STATEMENTS_FOR_EACH_FUNC(stmt2, type_iface_get_stmts(iface)) {
const var_t *m = stmt2->u.var;
if (!strcmp(m->name, cname))
{
- idx = m->type->details.function->idx;
+ idx = m->declspec.type->details.function->idx;
break;
}
}
diff --git a/tools/widl/server.c b/tools/widl/server.c
index 59c17d661f..a025da6999 100644
--- a/tools/widl/server.c
+++ b/tools/widl/server.c
@@ -55,7 +55,8 @@ static void write_function_stub(const type_t *iface, const var_t *func, unsigned
unsigned char explicit_fc, implicit_fc;
int has_full_pointer = is_full_pointer_function(func);
const var_t *handle_var = get_func_handle_var( iface, func, &explicit_fc, &implicit_fc );
- type_t *ret_type = type_function_get_rettype(func->type);
+ decl_spec_t *ret_declspec = type_function_get_retdeclspec(func->declspec.type);
+ type_t *ret_type = ret_declspec->type;
if (is_interpreted_func( iface, func )) return;
@@ -121,7 +122,7 @@ static void write_function_stub(const type_t *iface, const var_t *func, unsigned
if (has_full_pointer)
write_full_pointer_init(server, indent, func, TRUE);
- if (type_get_function_args(func->type))
+ if (type_get_function_args(func->declspec.type))
{
print_server("if ((_pRpcMessage->DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)\n");
indent++;
@@ -159,38 +160,38 @@ static void write_function_stub(const type_t *iface, const var_t *func, unsigned
{
print_server("__frame->_RetVal = NDRSContextUnmarshall((char*)0, _pRpcMessage->DataRepresentation);\n");
print_server("*((");
- write_type_decl(server, ret_type, NULL);
+ write_declspec_decl(server, ret_declspec, NULL);
fprintf(server, "*)NDRSContextValue(__frame->_RetVal)) = ");
}
else
print_server("%s", is_void(ret_type) ? "" : "__frame->_RetVal = ");
fprintf(server, "%s%s", prefix_server, get_name(func));
- if (type_get_function_args(func->type))
+ if (type_get_function_args(func->declspec.type))
{
int first_arg = 1;
fprintf(server, "(\n");
indent++;
- LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry )
+ LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->declspec.type), const var_t, entry )
{
if (first_arg)
first_arg = 0;
else
fprintf(server, ",\n");
- if (is_context_handle(var->type))
+ if (is_context_handle(var->declspec.type))
{
/* if the context_handle attribute appears in the chain of types
* without pointers being followed, then the context handle must
* be direct, otherwise it is a pointer */
- const char *ch_ptr = is_aliaschain_attr(var->type, ATTR_CONTEXTHANDLE) ? "*" : "";
+ const char *ch_ptr = is_aliaschain_attr(var->declspec.type, ATTR_CONTEXTHANDLE) ? "*" : "";
print_server("(");
- write_type_decl_left(server, var->type);
+ write_declspec_decl_left(server, (decl_spec_t*)&var->declspec);
fprintf(server, ")%sNDRSContextValue(__frame->%s)", ch_ptr, var->name);
}
else
{
- print_server("%s__frame->%s", is_array(var->type) && !type_array_is_decl_as_ptr(var->type) ? "*" : "", var->name);
+ print_server("%s__frame->%s", is_array(var->declspec.type) && !type_array_is_decl_as_ptr(var->declspec.type) ? "*" : "", var->name);
}
}
fprintf(server, ");\n");
diff --git a/tools/widl/typegen.c b/tools/widl/typegen.c
index e5fb20c55f..7a5492b618 100644
--- a/tools/widl/typegen.c
+++ b/tools/widl/typegen.c
@@ -85,14 +85,14 @@ static const unsigned short IsSimpleRef = 0x0100;
static unsigned int field_memsize(const type_t *type, unsigned int *offset);
static unsigned int fields_memsize(const var_list_t *fields, unsigned int *align);
-static unsigned int write_array_tfs(FILE *file, const attr_list_t *attrs, type_t *type,
+static unsigned int write_array_tfs(FILE *file, const attr_list_t *attrs, decl_spec_t *declspec,
const char *name, unsigned int *typestring_offset);
-static unsigned int write_struct_tfs(FILE *file, type_t *type, const char *name, unsigned int *tfsoff);
-static int write_embedded_types(FILE *file, const attr_list_t *attrs, type_t *type,
+static unsigned int write_struct_tfs(FILE *file, decl_spec_t *declspec, const char *name, unsigned int *tfsoff);
+static int write_embedded_types(FILE *file, const attr_list_t *attrs, decl_spec_t *declspec,
const char *name, int write_ptr, unsigned int *tfsoff);
static const var_t *find_array_or_string_in_struct(const type_t *type);
static unsigned int write_string_tfs(FILE *file, const attr_list_t *attrs,
- type_t *type, enum type_context context,
+ decl_spec_t *declspec, enum type_context context,
const char *name, unsigned int *typestring_offset);
static unsigned int get_required_buffer_size_type( const type_t *type, const char *name,
const attr_list_t *attrs, int toplevel_param,
@@ -197,7 +197,7 @@ static void *get_aliaschain_attrp(const type_t *type, enum attr_type attr)
if (is_attr(t->attrs, attr))
return get_attrp(t->attrs, attr);
else if (type_is_alias(t))
- t = type_alias_get_aliasee(t);
+ t = type_alias_get_aliasee_type(t);
else return NULL;
}
}
@@ -267,7 +267,7 @@ unsigned char get_pointer_fc(const type_t *type, const attr_list_t *attrs, int t
if (pointer_type)
return pointer_type;
- for (t = type; type_is_alias(t); t = type_alias_get_aliasee(t))
+ for (t = type; type_is_alias(t); t = type_alias_get_aliasee_type(t))
{
pointer_type = get_attrv(t->attrs, ATTR_POINTERTYPE);
if (pointer_type)
@@ -303,25 +303,34 @@ static unsigned char get_enum_fc(const type_t *type)
return FC_ENUM16;
}
-static type_t *get_user_type(const type_t *t, const char **pname)
+static decl_spec_t *get_user_declspec(const type_t *t, const char **pname)
{
for (;;)
{
- type_t *ut = get_attrp(t->attrs, ATTR_WIREMARSHAL);
- if (ut)
+ decl_spec_t *uds = get_attrds(t->attrs, ATTR_WIREMARSHAL);
+ if (uds)
{
if (pname)
*pname = t->name;
- return ut;
+ return uds;
}
if (type_is_alias(t))
- t = type_alias_get_aliasee(t);
+ t = type_alias_get_aliasee_type(t);
else
return NULL;
}
}
+static type_t *get_user_type(const type_t *t, const char **pname)
+{
+ decl_spec_t *declspec = get_user_declspec(t, pname);
+ if (declspec != NULL) {
+ return declspec->type;
+ }
+ return NULL;
+}
+
static int is_user_type(const type_t *t)
{
return get_user_type(t, NULL) != NULL;
@@ -351,10 +360,10 @@ enum typegen_type typegen_detect_type(const type_t *type, const attr_list_t *att
return TGT_RANGE;
return TGT_ENUM;
case TYPE_POINTER:
- if (type_get_type(type_pointer_get_ref(type)) == TYPE_INTERFACE ||
- (type_get_type(type_pointer_get_ref(type)) == TYPE_VOID && is_attr(attrs, ATTR_IIDIS)))
+ if (type_get_type(type_pointer_get_ref_type(type)) == TYPE_INTERFACE ||
+ (type_get_type(type_pointer_get_ref_type(type)) == TYPE_VOID && is_attr(attrs, ATTR_IIDIS)))
return TGT_IFACE_POINTER;
- else if (is_aliaschain_attr(type_pointer_get_ref(type), ATTR_CONTEXTHANDLE))
+ else if (is_aliaschain_attr(type_pointer_get_ref_type(type), ATTR_CONTEXTHANDLE))
return TGT_CTXT_HANDLE_POINTER;
else
return TGT_POINTER;
@@ -379,19 +388,18 @@ enum typegen_type typegen_detect_type(const type_t *type, const attr_list_t *att
static int cant_be_null(const var_t *v)
{
- switch (typegen_detect_type(v->type, v->attrs, TDT_IGNORE_STRINGS))
+ switch (typegen_detect_type(v->declspec.type, v->attrs, TDT_IGNORE_STRINGS))
{
case TGT_ARRAY:
- if (!type_array_is_decl_as_ptr( v->type )) return 0;
+ if (!type_array_is_decl_as_ptr( v->declspec.type )) return 0;
/* fall through */
case TGT_POINTER:
- return (get_pointer_fc(v->type, v->attrs, TRUE) == FC_RP);
+ return (get_pointer_fc(v->declspec.type, v->attrs, TRUE) == FC_RP);
case TGT_CTXT_HANDLE_POINTER:
return TRUE;
default:
return 0;
}
-
}
static int get_padding(const var_list_t *fields)
@@ -405,7 +413,7 @@ static int get_padding(const var_list_t *fields)
LIST_FOR_EACH_ENTRY(f, fields, const var_t, entry)
{
- type_t *ft = f->type;
+ type_t *ft = f->declspec.type;
unsigned int align = 0;
unsigned int size = type_memsize_and_alignment(ft, &align);
align = clamp_align(align);
@@ -422,7 +430,7 @@ static unsigned int get_stack_size( const var_t *var, int *by_value )
unsigned int stack_size;
int by_val;
- switch (typegen_detect_type( var->type, var->attrs, TDT_ALL_TYPES ))
+ switch (typegen_detect_type( var->declspec.type, var->attrs, TDT_ALL_TYPES ))
{
case TGT_BASIC:
case TGT_ENUM:
@@ -430,7 +438,7 @@ static unsigned int get_stack_size( const var_t *var, int *by_value )
case TGT_STRUCT:
case TGT_UNION:
case TGT_USER_TYPE:
- stack_size = type_memsize( var->type );
+ stack_size = type_memsize( var->declspec.type );
by_val = (pointer_size < 8 || stack_size <= pointer_size); /* FIXME: should be platform-specific */
break;
default:
@@ -495,14 +503,14 @@ unsigned char get_struct_fc(const type_t *type)
if (fields) LIST_FOR_EACH_ENTRY( field, fields, var_t, entry )
{
- type_t *t = field->type;
+ type_t *t = field->declspec.type;
enum typegen_type typegen_type;
typegen_type = typegen_detect_type(t, field->attrs, TDT_IGNORE_STRINGS);
if (typegen_type == TGT_ARRAY && !type_array_is_decl_as_ptr(t))
{
- if (is_string_type(field->attrs, field->type))
+ if (is_string_type(field->attrs, field->declspec.type))
{
if (is_conformant_array(t))
has_conformance = 1;
@@ -510,10 +518,10 @@ unsigned char get_struct_fc(const type_t *type)
continue;
}
- if (is_array(type_array_get_element(field->type)))
+ if (is_array(type_array_get_element_type(field->declspec.type)))
return FC_BOGUS_STRUCT;
- if (type_array_has_conformance(field->type))
+ if (type_array_has_conformance(field->declspec.type))
{
has_conformance = 1;
if (list_next(fields, &field->entry))
@@ -523,7 +531,7 @@ unsigned char get_struct_fc(const type_t *type)
if (type_array_has_variance(t))
has_variance = 1;
- t = type_array_get_element(t);
+ t = type_array_get_element_type(t);
typegen_type = typegen_detect_type(t, field->attrs, TDT_IGNORE_STRINGS);
}
@@ -625,7 +633,7 @@ static unsigned char get_array_fc(const type_t *type)
const expr_t *size_is;
const type_t *elem_type;
- elem_type = type_array_get_element(type);
+ elem_type = type_array_get_element_type(type);
size_is = type_array_get_conformance(type);
if (!size_is)
@@ -714,14 +722,14 @@ static int type_has_pointers(const type_t *type)
case TGT_POINTER:
return TRUE;
case TGT_ARRAY:
- return type_array_is_decl_as_ptr(type) || type_has_pointers(type_array_get_element(type));
+ return type_array_is_decl_as_ptr(type) || type_has_pointers(type_array_get_element_type(type));
case TGT_STRUCT:
{
var_list_t *fields = type_struct_get_fields(type);
const var_t *field;
if (fields) LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry )
{
- if (type_has_pointers(field->type))
+ if (type_has_pointers(field->declspec.type))
return TRUE;
}
break;
@@ -733,7 +741,7 @@ static int type_has_pointers(const type_t *type)
fields = type_union_get_cases(type);
if (fields) LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry )
{
- if (field->type && type_has_pointers(field->type))
+ if (field->declspec.type && type_has_pointers(field->declspec.type))
return TRUE;
}
break;
@@ -768,14 +776,14 @@ static int type_has_full_pointer(const type_t *type, const attr_list_t *attrs,
if (get_pointer_fc(type, attrs, toplevel_param) == FC_FP)
return TRUE;
else
- return type_has_full_pointer(type_array_get_element(type), NULL, FALSE);
+ return type_has_full_pointer(type_array_get_element_type(type), NULL, FALSE);
case TGT_STRUCT:
{
var_list_t *fields = type_struct_get_fields(type);
const var_t *field;
if (fields) LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry )
{
- if (type_has_full_pointer(field->type, field->attrs, FALSE))
+ if (type_has_full_pointer(field->declspec.type, field->attrs, FALSE))
return TRUE;
}
break;
@@ -787,7 +795,7 @@ static int type_has_full_pointer(const type_t *type, const attr_list_t *attrs,
fields = type_union_get_cases(type);
if (fields) LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry )
{
- if (field->type && type_has_full_pointer(field->type, field->attrs, FALSE))
+ if (field->declspec.type && type_has_full_pointer(field->declspec.type, field->attrs, FALSE))
return TRUE;
}
break;
@@ -857,7 +865,7 @@ static const char *get_context_handle_type_name(const type_t *type)
const type_t *t;
for (t = type;
is_ptr(t) || type_is_alias(t);
- t = type_is_alias(t) ? type_alias_get_aliasee(t) : type_pointer_get_ref(t))
+ t = type_is_alias(t) ? type_alias_get_aliasee_type(t) : type_pointer_get_ref_type(t))
if (is_attr(t->attrs, ATTR_CONTEXTHANDLE))
return t->name;
assert(0);
@@ -907,16 +915,16 @@ static void write_var_init(FILE *file, int indent, const type_t *t, const char *
void write_parameters_init(FILE *file, int indent, const var_t *func, const char *local_var_prefix)
{
- const var_t *var = type_function_get_retval(func->type);
+ const var_t *var = type_function_get_retval(func->declspec.type);
- if (!is_void(var->type))
- write_var_init(file, indent, var->type, var->name, local_var_prefix);
+ if (!is_void(var->declspec.type))
+ write_var_init(file, indent, var->declspec.type, var->name, local_var_prefix);
- if (!type_get_function_args(func->type))
+ if (!type_get_function_args(func->declspec.type))
return;
- LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry )
- write_var_init(file, indent, var->type, var->name, local_var_prefix);
+ LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->declspec.type), const var_t, entry )
+ write_var_init(file, indent, var->declspec.type, var->name, local_var_prefix);
fprintf(file, "\n");
}
@@ -980,14 +988,14 @@ static unsigned char get_parameter_fc( const var_t *var, int is_return, unsigned
if (is_out) *flags |= IsOut;
if (is_return) *flags |= IsReturn;
- if (!is_string_type( var->attrs, var->type ))
- buffer_size = get_required_buffer_size_type( var->type, NULL, var->attrs, TRUE, &alignment );
+ if (!is_string_type( var->attrs, var->declspec.type ))
+ buffer_size = get_required_buffer_size_type( var->declspec.type, NULL, var->attrs, TRUE, &alignment );
- switch (typegen_detect_type( var->type, var->attrs, TDT_ALL_TYPES ))
+ switch (typegen_detect_type( var->declspec.type, var->attrs, TDT_ALL_TYPES ))
{
case TGT_BASIC:
*flags |= IsBasetype;
- fc = get_basic_fc_signed( var->type );
+ fc = get_basic_fc_signed( var->declspec.type );
if (fc == FC_BIND_PRIMITIVE)
{
buffer_size = 4; /* actually 0 but avoids setting MustSize */
@@ -996,7 +1004,7 @@ static unsigned char get_parameter_fc( const var_t *var, int is_return, unsigned
break;
case TGT_ENUM:
*flags |= IsBasetype;
- fc = get_enum_fc( var->type );
+ fc = get_enum_fc( var->declspec.type );
break;
case TGT_RANGE:
*flags |= IsByValue;
@@ -1011,19 +1019,19 @@ static unsigned char get_parameter_fc( const var_t *var, int is_return, unsigned
break;
case TGT_ARRAY:
*flags |= MustFree;
- if (type_array_is_decl_as_ptr(var->type) && var->type->details.array.ptr_tfsoff &&
- get_pointer_fc( var->type, var->attrs, !is_return ) == FC_RP)
+ if (type_array_is_decl_as_ptr(var->declspec.type) && var->declspec.type->details.array.ptr_tfsoff &&
+ get_pointer_fc( var->declspec.type, var->attrs, !is_return ) == FC_RP)
{
- *typestring_offset = var->type->typestring_offset;
+ *typestring_offset = var->declspec.type->typestring_offset;
*flags |= IsSimpleRef;
}
break;
case TGT_STRING:
*flags |= MustFree;
- if (is_declptr( var->type ) && get_pointer_fc( var->type, var->attrs, !is_return ) == FC_RP)
+ if (is_declptr( var->declspec.type ) && get_pointer_fc( var->declspec.type, var->attrs, !is_return ) == FC_RP)
{
/* skip over pointer description straight to string description */
- if (is_conformant_array( var->type )) *typestring_offset += 4;
+ if (is_conformant_array( var->declspec.type )) *typestring_offset += 4;
else *typestring_offset += 2;
*flags |= IsSimpleRef;
}
@@ -1036,9 +1044,9 @@ static unsigned char get_parameter_fc( const var_t *var, int is_return, unsigned
buffer_size = 20;
break;
case TGT_POINTER:
- if (get_pointer_fc( var->type, var->attrs, !is_return ) == FC_RP)
+ if (get_pointer_fc( var->declspec.type, var->attrs, !is_return ) == FC_RP)
{
- const type_t *ref = type_pointer_get_ref( var->type );
+ const type_t *ref = type_pointer_get_ref_type( var->declspec.type );
if (!is_string_type( var->attrs, ref ))
buffer_size = get_required_buffer_size_type( ref, NULL, NULL, TRUE, &alignment );
@@ -1120,8 +1128,8 @@ static unsigned char get_parameter_fc( const var_t *var, int is_return, unsigned
static unsigned char get_func_oi2_flags( const var_t *func )
{
const var_t *var;
- var_list_t *args = type_get_function_args( func->type );
- var_t *retval = type_function_get_retval( func->type );
+ var_list_t *args = type_get_function_args( func->declspec.type );
+ var_t *retval = type_function_get_retval( func->declspec.type );
unsigned char oi2_flags = 0x40; /* HasExtensions */
unsigned short flags;
unsigned int stack_size, typestring_offset;
@@ -1136,7 +1144,7 @@ static unsigned char get_func_oi2_flags( const var_t *func )
}
}
- if (!is_void( retval->type ))
+ if (!is_void( retval->declspec.type ))
{
oi2_flags |= 0x04; /* HasRet */
get_parameter_fc( retval, 1, &flags, &stack_size, &typestring_offset );
@@ -1190,8 +1198,8 @@ static unsigned int write_old_procformatstring_type(FILE *file, int indent, cons
if (!is_in && !is_out) is_in = TRUE;
- if (type_get_type(var->type) == TYPE_BASIC ||
- type_get_type(var->type) == TYPE_ENUM)
+ if (type_get_type(var->declspec.type) == TYPE_BASIC ||
+ type_get_type(var->declspec.type) == TYPE_ENUM)
{
unsigned char fc;
@@ -1200,13 +1208,13 @@ static unsigned int write_old_procformatstring_type(FILE *file, int indent, cons
else
print_file(file, indent, "0x4e, /* FC_IN_PARAM_BASETYPE */\n");
- if (type_get_type(var->type) == TYPE_ENUM)
+ if (type_get_type(var->declspec.type) == TYPE_ENUM)
{
- fc = get_enum_fc(var->type);
+ fc = get_enum_fc(var->declspec.type);
}
else
{
- fc = get_basic_fc_signed(var->type);
+ fc = get_basic_fc_signed(var->declspec.type);
if (fc == FC_BIND_PRIMITIVE)
fc = FC_IGNORE;
@@ -1220,10 +1228,10 @@ static unsigned int write_old_procformatstring_type(FILE *file, int indent, cons
{
unsigned short offset = var->typestring_offset;
- if (!is_interpreted && is_array(var->type) &&
- type_array_is_decl_as_ptr(var->type) &&
- var->type->details.array.ptr_tfsoff)
- offset = var->type->typestring_offset;
+ if (!is_interpreted && is_array(var->declspec.type) &&
+ type_array_is_decl_as_ptr(var->declspec.type) &&
+ var->declspec.type->details.array.ptr_tfsoff)
+ offset = var->declspec.type->typestring_offset;
if (is_return)
print_file(file, indent, "0x52, /* FC_RETURN_PARAM */\n");
@@ -1246,8 +1254,8 @@ int is_interpreted_func( const type_t *iface, const var_t *func )
{
const char *str;
const var_t *var;
- const var_list_t *args = type_get_function_args( func->type );
- const type_t *ret_type = type_function_get_rettype( func->type );
+ const var_list_t *args = type_get_function_args( func->declspec.type );
+ const type_t *ret_type = type_function_get_rettype( func->declspec.type );
if (type_get_type( ret_type ) == TYPE_BASIC)
{
@@ -1269,10 +1277,10 @@ int is_interpreted_func( const type_t *iface, const var_t *func )
if (get_stub_mode() != MODE_Oif && args)
{
LIST_FOR_EACH_ENTRY( var, args, const var_t, entry )
- switch (type_get_type( var->type ))
+ switch (type_get_type( var->declspec.type ))
{
case TYPE_BASIC:
- switch (type_basic_get_type( var->type ))
+ switch (type_basic_get_type( var->declspec.type ))
{
/* floating point arguments are not supported in Oi mode */
case TYPE_BASIC_FLOAT: return 0;
@@ -1297,7 +1305,7 @@ static void write_proc_func_header( FILE *file, int indent, const type_t *iface,
unsigned short num_proc )
{
var_t *var;
- var_list_t *args = type_get_function_args( func->type );
+ var_list_t *args = type_get_function_args( func->declspec.type );
unsigned char explicit_fc, implicit_fc;
unsigned char handle_flags;
const var_t *handle_var = get_func_handle_var( iface, func, &explicit_fc, &implicit_fc );
@@ -1328,7 +1336,7 @@ static void write_proc_func_header( FILE *file, int indent, const type_t *iface,
param_num++;
nb_args++;
}
- if (!is_void( type_function_get_rettype( func->type )))
+ if (!is_void( type_function_get_rettype( func->declspec.type )))
{
stack_size += pointer_size;
nb_args++;
@@ -1356,22 +1364,22 @@ static void write_proc_func_header( FILE *file, int indent, const type_t *iface,
*offset += 4;
break;
case FC_BIND_GENERIC:
- handle_flags = type_memsize( handle_var->type );
+ handle_flags = type_memsize( handle_var->declspec.type );
print_file( file, indent, "0x%02x,\t/* %s */\n", explicit_fc, string_of_type(explicit_fc) );
print_file( file, indent, "0x%02x,\n", handle_flags );
print_file( file, indent, "NdrFcShort(0x%hx),\t/* stack offset = %hu */\n",
handle_stack_offset, handle_stack_offset );
- print_file( file, indent, "0x%02x,\n", get_generic_handle_offset( handle_var->type ) );
+ print_file( file, indent, "0x%02x,\n", get_generic_handle_offset( handle_var->declspec.type ) );
print_file( file, indent, "0x%x,\t/* FC_PAD */\n", FC_PAD);
*offset += 6;
break;
case FC_BIND_CONTEXT:
- handle_flags = get_contexthandle_flags( iface, handle_var->attrs, handle_var->type, 0 );
+ handle_flags = get_contexthandle_flags( iface, handle_var->attrs, handle_var->declspec.type, 0 );
print_file( file, indent, "0x%02x,\t/* %s */\n", explicit_fc, string_of_type(explicit_fc) );
print_file( file, indent, "0x%02x,\n", handle_flags );
print_file( file, indent, "NdrFcShort(0x%hx),\t/* stack offset = %hu */\n",
handle_stack_offset, handle_stack_offset );
- print_file( file, indent, "0x%02x,\n", get_context_handle_offset( handle_var->type ) );
+ print_file( file, indent, "0x%02x,\n", get_context_handle_offset( handle_var->declspec.type ) );
print_file( file, indent, "0x%02x,\t/* param %hu */\n", handle_param_num, handle_param_num );
*offset += 6;
break;
@@ -1407,9 +1415,9 @@ static void write_proc_func_header( FILE *file, int indent, const type_t *iface,
if (is_object( iface )) pos += 2;
if (args) LIST_FOR_EACH_ENTRY( var, args, var_t, entry )
{
- if (type_get_type( var->type ) == TYPE_BASIC)
+ if (type_get_type( var->declspec.type ) == TYPE_BASIC)
{
- switch (type_basic_get_type( var->type ))
+ switch (type_basic_get_type( var->declspec.type ))
{
case TYPE_BASIC_FLOAT: fpu_mask |= 1 << pos; break;
case TYPE_BASIC_DOUBLE: fpu_mask |= 2 << pos; break;
@@ -1432,15 +1440,15 @@ static void write_procformatstring_func( FILE *file, int indent, const type_t *i
unsigned int stack_offset = is_object( iface ) ? pointer_size : 0;
int is_interpreted = is_interpreted_func( iface, func );
int is_new_style = is_interpreted && (get_stub_mode() == MODE_Oif);
- var_t *retval = type_function_get_retval( func->type );
+ var_t *retval = type_function_get_retval( func->declspec.type );
if (is_interpreted) write_proc_func_header( file, indent, iface, func, offset, num_proc );
/* emit argument data */
- if (type_get_function_args(func->type))
+ if (type_get_function_args(func->declspec.type))
{
const var_t *var;
- LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry )
+ LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->declspec.type), const var_t, entry )
{
print_file( file, 0, "/* %u (parameter %s) */\n", *offset, var->name );
if (is_new_style)
@@ -1451,7 +1459,7 @@ static void write_procformatstring_func( FILE *file, int indent, const type_t *i
}
/* emit return value data */
- if (is_void(retval->type))
+ if (is_void(retval->declspec.type))
{
if (!is_new_style)
{
@@ -1598,7 +1606,7 @@ static unsigned int write_conf_or_var_desc(FILE *file, const type_t *cont_type,
{
conftype = FC_TOP_LEVEL_CONFORMANCE;
conftype_string = "parameter";
- cont_type = current_func->type;
+ cont_type = current_func->declspec.type;
name = current_func->name;
iface = current_iface;
}
@@ -1669,7 +1677,7 @@ static unsigned int write_conf_or_var_desc(FILE *file, const type_t *cont_type,
if (var->name && !strcmp(var->name, subexpr->u.sval))
{
expr_loc.v = var;
- correlation_variable = var->type;
+ correlation_variable = var->declspec.type;
break;
}
offset += get_stack_size( var, NULL );
@@ -1681,11 +1689,11 @@ static unsigned int write_conf_or_var_desc(FILE *file, const type_t *cont_type,
if (fields) LIST_FOR_EACH_ENTRY( var, fields, const var_t, entry )
{
- unsigned int size = field_memsize( var->type, &offset );
+ unsigned int size = field_memsize( var->declspec.type, &offset );
if (var->name && !strcmp(var->name, subexpr->u.sval))
{
expr_loc.v = var;
- correlation_variable = var->type;
+ correlation_variable = var->declspec.type;
break;
}
offset += size;
@@ -1824,7 +1832,7 @@ static unsigned int fields_memsize(const var_list_t *fields, unsigned int *align
LIST_FOR_EACH_ENTRY( v, fields, const var_t, entry )
{
unsigned int falign = 0;
- unsigned int fsize = type_memsize_and_alignment(v->type, &falign);
+ unsigned int fsize = type_memsize_and_alignment(v->declspec.type, &falign);
if (*align < falign) *align = falign;
falign = clamp_align(falign);
size = ROUND_SIZE(size, falign);
@@ -1846,9 +1854,9 @@ static unsigned int union_memsize(const var_list_t *fields, unsigned int *pmaxa)
if (fields) LIST_FOR_EACH_ENTRY( v, fields, const var_t, entry )
{
/* we could have an empty default field with NULL type */
- if (v->type)
+ if (v->declspec.type)
{
- size = type_memsize_and_alignment(v->type, &align);
+ size = type_memsize_and_alignment(v->declspec.type, &align);
if (maxs < size) maxs = size;
if (*pmaxa < align) *pmaxa = align;
}
@@ -1936,12 +1944,12 @@ unsigned int type_memsize_and_alignment(const type_t *t, unsigned int *align)
{
if (is_conformant_array(t))
{
- type_memsize_and_alignment(type_array_get_element(t), align);
+ type_memsize_and_alignment(type_array_get_element_type(t), align);
size = 0;
}
else
size = type_array_get_dim(t) *
- type_memsize_and_alignment(type_array_get_element(t), align);
+ type_memsize_and_alignment(type_array_get_element_type(t), align);
}
else /* declared as a pointer */
{
@@ -2021,8 +2029,8 @@ static unsigned int type_buffer_alignment(const type_t *t)
if (!(fields = type_struct_get_fields(t))) break;
LIST_FOR_EACH_ENTRY( var, fields, const var_t, entry )
{
- if (!var->type) continue;
- align = type_buffer_alignment( var->type );
+ if (!var->declspec.type) continue;
+ align = type_buffer_alignment( var->declspec.type );
if (max < align) max = align;
}
break;
@@ -2030,8 +2038,8 @@ static unsigned int type_buffer_alignment(const type_t *t)
if (!(fields = type_encapsulated_union_get_fields(t))) break;
LIST_FOR_EACH_ENTRY( var, fields, const var_t, entry )
{
- if (!var->type) continue;
- align = type_buffer_alignment( var->type );
+ if (!var->declspec.type) continue;
+ align = type_buffer_alignment( var->declspec.type );
if (max < align) max = align;
}
break;
@@ -2039,14 +2047,14 @@ static unsigned int type_buffer_alignment(const type_t *t)
if (!(fields = type_union_get_cases(t))) break;
LIST_FOR_EACH_ENTRY( var, fields, const var_t, entry )
{
- if (!var->type) continue;
- align = type_buffer_alignment( var->type );
+ if (!var->declspec.type) continue;
+ align = type_buffer_alignment( var->declspec.type );
if (max < align) max = align;
}
break;
case TYPE_ARRAY:
if (!type_array_is_decl_as_ptr(t))
- return type_buffer_alignment( type_array_get_element(t) );
+ return type_buffer_alignment( type_array_get_element_type(t) );
/* else fall through */
case TYPE_POINTER:
return 4;
@@ -2069,12 +2077,12 @@ static unsigned int type_buffer_alignment(const type_t *t)
int is_full_pointer_function(const var_t *func)
{
const var_t *var;
- if (type_has_full_pointer(type_function_get_rettype(func->type), func->attrs, TRUE))
+ if (type_has_full_pointer(type_function_get_rettype(func->declspec.type), func->attrs, TRUE))
return TRUE;
- if (!type_get_function_args(func->type))
+ if (!type_get_function_args(func->declspec.type))
return FALSE;
- LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry )
- if (type_has_full_pointer( var->type, var->attrs, TRUE ))
+ LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->declspec.type), const var_t, entry )
+ if (type_has_full_pointer( var->declspec.type, var->attrs, TRUE ))
return TRUE;
return FALSE;
}
@@ -2119,7 +2127,7 @@ static unsigned int write_nonsimple_pointer(FILE *file, const attr_list_t *attrs
{
if (context == TYPE_CONTEXT_TOPLEVELPARAM && is_ptr(type) && pointer_type == FC_RP)
{
- switch (typegen_detect_type(type_pointer_get_ref(type), NULL, TDT_ALL_TYPES))
+ switch (typegen_detect_type(type_pointer_get_ref_type(type), NULL, TDT_ALL_TYPES))
{
case TGT_STRING:
case TGT_POINTER:
@@ -2139,7 +2147,7 @@ static unsigned int write_nonsimple_pointer(FILE *file, const attr_list_t *attrs
if (is_ptr(type))
{
- type_t *ref = type_pointer_get_ref(type);
+ type_t *ref = type_pointer_get_ref_type(type);
if(is_declptr(ref) && !is_user_type(ref))
flags |= FC_POINTER_DEREF;
}
@@ -2180,7 +2188,7 @@ static unsigned int write_simple_pointer(FILE *file, const attr_list_t *attrs,
pointer_fc = get_pointer_fc_context(type, attrs, context);
- ref = type_pointer_get_ref(type);
+ ref = type_pointer_get_ref_type(type);
if (type_get_type(ref) == TYPE_ENUM)
fc = get_enum_fc(ref);
else
@@ -2205,22 +2213,23 @@ static unsigned int write_simple_pointer(FILE *file, const attr_list_t *attrs,
return 4;
}
-static void print_start_tfs_comment(FILE *file, type_t *t, unsigned int tfsoff)
+static void print_start_tfs_comment(FILE *file, decl_spec_t *ds, unsigned int tfsoff)
{
print_file(file, 0, "/* %u (", tfsoff);
- write_type_decl(file, t, NULL);
+ write_declspec_decl(file, ds, NULL);
print_file(file, 0, ") */\n");
}
static unsigned int write_pointer_tfs(FILE *file, const attr_list_t *attrs,
- type_t *type, unsigned int ref_offset,
+ decl_spec_t *declspec, unsigned int ref_offset,
enum type_context context,
unsigned int *typestring_offset)
{
unsigned int offset = *typestring_offset;
- type_t *ref = type_pointer_get_ref(type);
+ type_t *type = declspec->type;
+ type_t *ref = type_pointer_get_ref_type(type);
- print_start_tfs_comment(file, type, offset);
+ print_start_tfs_comment(file, declspec, offset);
update_tfsoff(type, offset, file);
switch (typegen_detect_type(ref, attrs, TDT_ALL_TYPES))
@@ -2263,10 +2272,12 @@ static int user_type_has_variable_size(const type_t *t)
return FALSE;
}
-static unsigned int write_user_tfs(FILE *file, type_t *type, unsigned int *tfsoff)
+static unsigned int write_user_tfs(FILE *file, decl_spec_t *declspec, unsigned int *tfsoff)
{
unsigned int start, absoff, flags;
const char *name = NULL;
+ type_t *type = declspec->type;
+ decl_spec_t *udeclspec = get_user_declspec(type, &name);
type_t *utype = get_user_type(type, &name);
unsigned int usize = type_memsize(utype);
unsigned int ualign = type_buffer_alignment(utype);
@@ -2291,7 +2302,7 @@ static unsigned int write_user_tfs(FILE *file, type_t *type, unsigned int *tfsof
fc = get_basic_fc(utype);
absoff = *tfsoff;
- print_start_tfs_comment(file, utype, absoff);
+ print_start_tfs_comment(file, udeclspec, absoff);
print_file(file, 2, "0x%x,\t/* %s */\n", fc, string_of_type(fc));
print_file(file, 2, "0x5c,\t/* FC_PAD */\n");
*tfsoff += 2;
@@ -2299,7 +2310,9 @@ static unsigned int write_user_tfs(FILE *file, type_t *type, unsigned int *tfsof
else
{
if (!processed(utype))
- write_embedded_types(file, NULL, utype, utype->name, TRUE, tfsoff);
+ {
+ write_embedded_types(file, NULL, udeclspec, utype->name, TRUE, tfsoff);
+ }
absoff = utype->typestring_offset;
}
@@ -2312,7 +2325,7 @@ static unsigned int write_user_tfs(FILE *file, type_t *type, unsigned int *tfsof
start = *tfsoff;
update_tfsoff(type, start, file);
- print_start_tfs_comment(file, type, start);
+ print_start_tfs_comment(file, declspec, start);
print_file(file, 2, "0x%x,\t/* FC_USER_MARSHAL */\n", FC_USER_MARSHAL);
print_file(file, 2, "0x%x,\t/* Alignment= %d, Flags= %02x */\n",
flags | (ualign - 1), ualign - 1, flags);
@@ -2369,11 +2382,12 @@ static void write_member_type(FILE *file, const type_t *cont,
static void write_array_element_type(FILE *file, const attr_list_t *attrs, const type_t *type,
int cont_is_complex, unsigned int *tfsoff)
{
- type_t *elem = type_array_get_element(type);
+ decl_spec_t *element = type_array_get_element(type);
+ type_t *elem = element->type;
if (!is_embedded_complex(elem) && is_ptr(elem))
{
- type_t *ref = type_pointer_get_ref(elem);
+ type_t *ref = type_pointer_get_ref_type(elem);
if (processed(ref))
{
@@ -2383,7 +2397,7 @@ static void write_array_element_type(FILE *file, const attr_list_t *attrs, const
}
if (cont_is_complex && is_string_type(attrs, elem))
{
- write_string_tfs(file, NULL, elem, TYPE_CONTEXT_CONTAINER, NULL, tfsoff);
+ write_string_tfs(file, NULL, element, TYPE_CONTEXT_CONTAINER, NULL, tfsoff);
return;
}
if (!is_string_type(NULL, elem) &&
@@ -2415,7 +2429,7 @@ static void write_descriptors(FILE *file, type_t *type, unsigned int *tfsoff)
if (fs) LIST_FOR_EACH_ENTRY(f, fs, var_t, entry)
{
- type_t *ft = f->type;
+ type_t *ft = f->declspec.type;
unsigned int size = field_memsize( ft, &offset );
if (type_get_type(ft) == TYPE_UNION && is_attr(f->attrs, ATTR_SWITCHIS))
{
@@ -2438,13 +2452,14 @@ static void write_descriptors(FILE *file, type_t *type, unsigned int *tfsoff)
}
static int write_pointer_description_offsets(
- FILE *file, const attr_list_t *attrs, type_t *type,
+ FILE *file, const attr_list_t *attrs, decl_spec_t *declspec,
unsigned int *offset_in_memory, unsigned int *offset_in_buffer,
unsigned int *typestring_offset)
{
+ type_t *type = declspec->type;
int written = 0;
- if ((is_ptr(type) && type_get_type(type_pointer_get_ref(type)) != TYPE_INTERFACE) ||
+ if ((is_ptr(type) && type_get_type(type_pointer_get_ref_type(type)) != TYPE_INTERFACE) ||
(is_array(type) && type_array_is_decl_as_ptr(type)))
{
if (offset_in_memory && offset_in_buffer)
@@ -2469,10 +2484,10 @@ static int write_pointer_description_offsets(
if (is_ptr(type))
{
- type_t *ref = type_pointer_get_ref(type);
+ type_t *ref = type_pointer_get_ref_type(type);
if (is_string_type(attrs, type))
- write_string_tfs(file, attrs, type, TYPE_CONTEXT_CONTAINER, NULL, typestring_offset);
+ write_string_tfs(file, attrs, declspec, TYPE_CONTEXT_CONTAINER, NULL, typestring_offset);
else if (processed(ref))
write_nonsimple_pointer(file, attrs, type, TYPE_CONTEXT_CONTAINER,
ref->typestring_offset, typestring_offset);
@@ -2510,13 +2525,13 @@ static int write_pointer_description_offsets(
{
unsigned int padding;
unsigned int align = 0;
- type_memsize_and_alignment(v->type, &align);
+ type_memsize_and_alignment(v->declspec.type, &align);
padding = ROUNDING(*offset_in_memory, align);
*offset_in_memory += padding;
*offset_in_buffer += padding;
}
written += write_pointer_description_offsets(
- file, v->attrs, v->type, offset_in_memory, offset_in_buffer,
+ file, v->attrs, (decl_spec_t*)&v->declspec, offset_in_memory, offset_in_buffer,
typestring_offset);
}
}
@@ -2536,10 +2551,11 @@ static int write_pointer_description_offsets(
}
static int write_no_repeat_pointer_descriptions(
- FILE *file, const attr_list_t *attrs, type_t *type,
+ FILE *file, const attr_list_t *attrs, decl_spec_t *declspec,
unsigned int *offset_in_memory, unsigned int *offset_in_buffer,
unsigned int *typestring_offset)
{
+ type_t *type = declspec->type;
int written = 0;
if (is_ptr(type) ||
@@ -2549,7 +2565,7 @@ static int write_no_repeat_pointer_descriptions(
print_file(file, 2, "0x%02x, /* FC_PAD */\n", FC_PAD);
*typestring_offset += 2;
- return write_pointer_description_offsets(file, attrs, type,
+ return write_pointer_description_offsets(file, attrs, declspec,
offset_in_memory, offset_in_buffer, typestring_offset);
}
@@ -2562,13 +2578,13 @@ static int write_no_repeat_pointer_descriptions(
{
unsigned int padding;
unsigned int align = 0;
- type_memsize_and_alignment(v->type, &align);
+ type_memsize_and_alignment(v->declspec.type, &align);
padding = ROUNDING(*offset_in_memory, align);
*offset_in_memory += padding;
*offset_in_buffer += padding;
}
written += write_no_repeat_pointer_descriptions(
- file, v->attrs, v->type,
+ file, v->attrs, (decl_spec_t*)&v->declspec,
offset_in_memory, offset_in_buffer, typestring_offset);
}
}
@@ -2587,10 +2603,11 @@ static int write_no_repeat_pointer_descriptions(
/* Note: if file is NULL return value is number of pointers to write, else
* it is the number of type format characters written */
static int write_fixed_array_pointer_descriptions(
- FILE *file, const attr_list_t *attrs, type_t *type,
+ FILE *file, const attr_list_t *attrs, decl_spec_t *declspec,
unsigned int *offset_in_memory, unsigned int *offset_in_buffer,
unsigned int *typestring_offset)
{
+ type_t *type = declspec->type;
int pointer_count = 0;
if (type_get_type(type) == TYPE_ARRAY &&
@@ -2607,7 +2624,7 @@ static int write_fixed_array_pointer_descriptions(
unsigned int offset_of_array_pointer_mem = 0;
unsigned int offset_of_array_pointer_buf = 0;
- increment_size = type_memsize(type_array_get_element(type));
+ increment_size = type_memsize(type_array_get_element_type(type));
print_file(file, 2, "0x%02x, /* FC_FIXED_REPEAT */\n", FC_FIXED_REPEAT);
print_file(file, 2, "0x%02x, /* FC_PAD */\n", FC_PAD);
@@ -2618,7 +2635,7 @@ static int write_fixed_array_pointer_descriptions(
*typestring_offset += 10;
pointer_count = write_pointer_description_offsets(
- file, attrs, type, &offset_of_array_pointer_mem,
+ file, attrs, declspec, &offset_of_array_pointer_mem,
&offset_of_array_pointer_buf, typestring_offset);
}
}
@@ -2631,13 +2648,13 @@ static int write_fixed_array_pointer_descriptions(
{
unsigned int padding;
unsigned int align = 0;
- type_memsize_and_alignment(v->type, &align);
+ type_memsize_and_alignment(v->declspec.type, &align);
padding = ROUNDING(*offset_in_memory, align);
*offset_in_memory += padding;
*offset_in_buffer += padding;
}
pointer_count += write_fixed_array_pointer_descriptions(
- file, v->attrs, v->type, offset_in_memory, offset_in_buffer,
+ file, v->attrs, (decl_spec_t*)&v->declspec, offset_in_memory, offset_in_buffer,
typestring_offset);
}
}
@@ -2678,7 +2695,7 @@ static int write_conformant_array_pointer_descriptions(
unsigned int offset_of_array_pointer_mem = offset_in_memory;
unsigned int offset_of_array_pointer_buf = offset_in_memory;
- increment_size = type_memsize(type_array_get_element(type));
+ increment_size = type_memsize(type_array_get_element_type(type));
if (increment_size > USHRT_MAX)
error("array size of %u bytes is too large\n", increment_size);
@@ -2720,7 +2737,7 @@ static int write_varying_array_pointer_descriptions(
{
unsigned int increment_size;
- increment_size = type_memsize(type_array_get_element(type));
+ increment_size = type_memsize(type_array_get_element_type(type));
if (increment_size > USHRT_MAX)
error("array size of %u bytes is too large\n", increment_size);
@@ -2746,20 +2763,20 @@ static int write_varying_array_pointer_descriptions(
{
unsigned int align = 0, padding;
- if (is_array(v->type) && type_array_has_variance(v->type))
+ if (is_array(v->declspec.type) && type_array_has_variance(v->declspec.type))
{
*offset_in_buffer = ROUND_SIZE(*offset_in_buffer, 4);
/* skip over variance and offset in buffer */
*offset_in_buffer += 8;
}
- type_memsize_and_alignment(v->type, &align);
+ type_memsize_and_alignment(v->declspec.type, &align);
padding = ROUNDING(*offset_in_memory, align);
*offset_in_memory += padding;
*offset_in_buffer += padding;
}
pointer_count += write_varying_array_pointer_descriptions(
- file, v->attrs, v->type, offset_in_memory, offset_in_buffer,
+ file, v->attrs, v->declspec.type, offset_in_memory, offset_in_buffer,
typestring_offset);
}
}
@@ -2778,9 +2795,10 @@ static int write_varying_array_pointer_descriptions(
return pointer_count;
}
-static void write_pointer_description(FILE *file, const attr_list_t *attrs, type_t *type,
+static void write_pointer_description(FILE *file, const attr_list_t *attrs, decl_spec_t *declspec,
unsigned int *typestring_offset)
{
+ type_t *type = declspec->type;
unsigned int offset_in_buffer;
unsigned int offset_in_memory;
@@ -2791,7 +2809,7 @@ static void write_pointer_description(FILE *file, const attr_list_t *attrs, type
offset_in_memory = 0;
offset_in_buffer = 0;
write_no_repeat_pointer_descriptions(
- file, NULL, type,
+ file, NULL, declspec,
&offset_in_memory, &offset_in_buffer, typestring_offset);
}
@@ -2799,7 +2817,7 @@ static void write_pointer_description(FILE *file, const attr_list_t *attrs, type
offset_in_memory = 0;
offset_in_buffer = 0;
write_fixed_array_pointer_descriptions(
- file, NULL, type,
+ file, NULL, declspec,
&offset_in_memory, &offset_in_buffer, typestring_offset);
/* pass 3: search for pointers in conformant only arrays (but don't descend
@@ -2811,7 +2829,7 @@ static void write_pointer_description(FILE *file, const attr_list_t *attrs, type
else if (type_get_type(type) == TYPE_STRUCT &&
get_struct_fc(type) == FC_CPSTRUCT)
{
- type_t *carray = find_array_or_string_in_struct(type)->type;
+ type_t *carray = find_array_or_string_in_struct(type)->declspec.type;
write_conformant_array_pointer_descriptions( file, NULL, carray,
type_memsize(type), typestring_offset);
}
@@ -2825,9 +2843,10 @@ static void write_pointer_description(FILE *file, const attr_list_t *attrs, type
}
static unsigned int write_string_tfs(FILE *file, const attr_list_t *attrs,
- type_t *type, enum type_context context,
+ decl_spec_t *declspec, enum type_context context,
const char *name, unsigned int *typestring_offset)
{
+ type_t *type = declspec->type;
unsigned int start_offset;
unsigned char rtype;
type_t *elem_type;
@@ -2841,7 +2860,7 @@ static unsigned int write_string_tfs(FILE *file, const attr_list_t *attrs,
int pointer_type = get_pointer_fc_context(type, attrs, context);
if (!pointer_type)
pointer_type = FC_RP;
- print_start_tfs_comment(file, type, *typestring_offset);
+ print_start_tfs_comment(file, declspec, *typestring_offset);
print_file(file, 2,"0x%x, 0x%x,\t/* %s%s */\n",
pointer_type, flag, string_of_type(pointer_type),
flag ? " [simple_pointer]" : "");
@@ -2855,12 +2874,12 @@ static unsigned int write_string_tfs(FILE *file, const attr_list_t *attrs,
}
if (is_array(type))
- elem_type = type_array_get_element(type);
+ elem_type = type_array_get_element_type(type);
else
- elem_type = type_pointer_get_ref(type);
+ elem_type = type_pointer_get_ref_type(type);
if (type_get_type(elem_type) == TYPE_POINTER && is_array(type))
- return write_array_tfs(file, attrs, type, name, typestring_offset);
+ return write_array_tfs(file, attrs, declspec, name, typestring_offset);
if (type_get_type(elem_type) != TYPE_BASIC)
{
@@ -2934,9 +2953,10 @@ static unsigned int write_string_tfs(FILE *file, const attr_list_t *attrs,
}
}
-static unsigned int write_array_tfs(FILE *file, const attr_list_t *attrs, type_t *type,
+static unsigned int write_array_tfs(FILE *file, const attr_list_t *attrs, decl_spec_t *declspec,
const char *name, unsigned int *typestring_offset)
{
+ type_t *type = declspec->type;
const expr_t *length_is = type_array_get_variance(type);
const expr_t *size_is = type_array_get_conformance(type);
unsigned int align;
@@ -2952,16 +2972,16 @@ static unsigned int write_array_tfs(FILE *file, const attr_list_t *attrs, type_t
if (!pointer_type)
pointer_type = FC_RP;
- if (!is_string_type(attrs, type_array_get_element(type)))
+ if (!is_string_type(attrs, type_array_get_element_type(type)))
write_embedded_types(file, attrs, type_array_get_element(type), name, FALSE, typestring_offset);
- size = type_memsize(is_conformant_array(type) ? type_array_get_element(type) : type);
- align = type_buffer_alignment(is_conformant_array(type) ? type_array_get_element(type) : type);
+ size = type_memsize(is_conformant_array(type) ? type_array_get_element_type(type) : type);
+ align = type_buffer_alignment(is_conformant_array(type) ? type_array_get_element_type(type) : type);
fc = get_array_fc(type);
start_offset = *typestring_offset;
update_tfsoff(type, start_offset, file);
- print_start_tfs_comment(file, type, start_offset);
+ print_start_tfs_comment(file, declspec, start_offset);
print_file(file, 2, "0x%02x,\t/* %s */\n", fc, string_of_type(fc));
print_file(file, 2, "0x%x,\t/* %d */\n", align - 1, align - 1);
*typestring_offset += 2;
@@ -2987,7 +3007,7 @@ static unsigned int write_array_tfs(FILE *file, const attr_list_t *attrs, type_t
if (fc == FC_SMVARRAY || fc == FC_LGVARRAY)
{
- unsigned int elsize = type_memsize(type_array_get_element(type));
+ unsigned int elsize = type_memsize(type_array_get_element_type(type));
unsigned int dim = type_array_get_dim(type);
if (fc == FC_LGVARRAY)
@@ -3010,13 +3030,13 @@ static unsigned int write_array_tfs(FILE *file, const attr_list_t *attrs, type_t
+= write_conf_or_var_desc(file, current_structure, baseoff,
type, length_is);
- if (type_has_pointers(type_array_get_element(type)) &&
+ if (type_has_pointers(type_array_get_element_type(type)) &&
(type_array_is_decl_as_ptr(type) || !current_structure))
{
print_file(file, 2, "0x%x,\t/* FC_PP */\n", FC_PP);
print_file(file, 2, "0x%x,\t/* FC_PAD */\n", FC_PAD);
*typestring_offset += 2;
- write_pointer_description(file, is_string_type(attrs, type) ? attrs : NULL, type, typestring_offset);
+ write_pointer_description(file, is_string_type(attrs, type) ? attrs : NULL, declspec, typestring_offset);
print_file(file, 2, "0x%x,\t/* FC_END */\n", FC_END);
*typestring_offset += 1;
}
@@ -3053,7 +3073,7 @@ static const var_t *find_array_or_string_in_struct(const type_t *type)
return NULL;
last_field = LIST_ENTRY( list_tail(fields), const var_t, entry );
- ft = last_field->type;
+ ft = last_field->declspec.type;
if (is_conformant_array(ft) && !type_array_is_decl_as_ptr(ft))
return last_field;
@@ -3076,7 +3096,7 @@ static void write_struct_members(FILE *file, const type_t *type,
if (fields) LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry )
{
- type_t *ft = field->type;
+ type_t *ft = field->declspec.type;
unsigned int align = 0;
unsigned int size = type_memsize_and_alignment(ft, &align);
align = clamp_align(align);
@@ -3105,7 +3125,7 @@ static void write_struct_members(FILE *file, const type_t *type,
offset = ROUND_SIZE(offset, align);
*typestring_offset += 1;
}
- write_member_type(file, type, is_complex, field->attrs, field->type, corroff,
+ write_member_type(file, type, is_complex, field->attrs, field->declspec.type, corroff,
typestring_offset);
offset += size;
}
@@ -3123,9 +3143,10 @@ static void write_struct_members(FILE *file, const type_t *type,
write_end(file, typestring_offset);
}
-static unsigned int write_struct_tfs(FILE *file, type_t *type,
+static unsigned int write_struct_tfs(FILE *file, decl_spec_t *declspec,
const char *name, unsigned int *tfsoff)
{
+ type_t *type = declspec->type;
const type_t *save_current_structure = current_structure;
unsigned int total_size;
const var_t *array;
@@ -3148,15 +3169,15 @@ static unsigned int write_struct_tfs(FILE *file, type_t *type,
name, USHRT_MAX, total_size - USHRT_MAX);
if (fields) LIST_FOR_EACH_ENTRY(f, fields, var_t, entry)
- write_embedded_types(file, f->attrs, f->type, f->name, FALSE, tfsoff);
+ write_embedded_types(file, f->attrs, &f->declspec, f->name, FALSE, tfsoff);
array = find_array_or_string_in_struct(type);
- if (array && !processed(array->type))
+ if (array && !processed(array->declspec.type))
{
- if(is_string_type(array->attrs, array->type))
- write_string_tfs(file, array->attrs, array->type, TYPE_CONTEXT_CONTAINER, array->name, tfsoff);
+ if(is_string_type(array->attrs, array->declspec.type))
+ write_string_tfs(file, array->attrs, (decl_spec_t*)&array->declspec, TYPE_CONTEXT_CONTAINER, array->name, tfsoff);
else
- write_array_tfs(file, array->attrs, array->type, array->name, tfsoff);
+ write_array_tfs(file, array->attrs, (decl_spec_t*)&array->declspec, array->name, tfsoff);
}
corroff = *tfsoff;
@@ -3164,7 +3185,7 @@ static unsigned int write_struct_tfs(FILE *file, type_t *type,
start_offset = *tfsoff;
update_tfsoff(type, start_offset, file);
- print_start_tfs_comment(file, type, start_offset);
+ print_start_tfs_comment(file, declspec, start_offset);
print_file(file, 2, "0x%x,\t/* %s */\n", fc, string_of_type(fc));
print_file(file, 2, "0x%x,\t/* %d */\n", align - 1, align - 1);
print_file(file, 2, "NdrFcShort(0x%hx),\t/* %d */\n", (unsigned short)total_size, total_size);
@@ -3172,7 +3193,7 @@ static unsigned int write_struct_tfs(FILE *file, type_t *type,
if (array)
{
- unsigned int absoff = array->type->typestring_offset;
+ unsigned int absoff = array->declspec.type->typestring_offset;
short reloff = absoff - *tfsoff;
print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset= %hd (%u) */\n",
reloff, reloff, absoff);
@@ -3203,7 +3224,7 @@ static unsigned int write_struct_tfs(FILE *file, type_t *type,
print_file(file, 2, "0x%x,\t/* FC_PP */\n", FC_PP);
print_file(file, 2, "0x%x,\t/* FC_PAD */\n", FC_PAD);
*tfsoff += 2;
- write_pointer_description(file, NULL, type, tfsoff);
+ write_pointer_description(file, NULL, declspec, tfsoff);
print_file(file, 2, "0x%x,\t/* FC_END */\n", FC_END);
*tfsoff += 1;
}
@@ -3218,15 +3239,16 @@ static unsigned int write_struct_tfs(FILE *file, type_t *type,
type->ptrdesc = *tfsoff;
if (fields) LIST_FOR_EACH_ENTRY(f, fields, const var_t, entry)
{
- type_t *ft = f->type;
+ decl_spec_t *fds = (decl_spec_t*)&f->declspec;
+ type_t *ft = fds->type;
switch (typegen_detect_type(ft, f->attrs, TDT_IGNORE_STRINGS))
{
case TGT_POINTER:
if (is_string_type(f->attrs, ft))
- write_string_tfs(file, f->attrs, ft, TYPE_CONTEXT_CONTAINER, f->name, tfsoff);
+ write_string_tfs(file, f->attrs, fds, TYPE_CONTEXT_CONTAINER, f->name, tfsoff);
else
- write_pointer_tfs(file, f->attrs, ft,
- type_pointer_get_ref(ft)->typestring_offset,
+ write_pointer_tfs(file, f->attrs, fds,
+ type_pointer_get_ref_type(ft)->typestring_offset,
TYPE_CONTEXT_CONTAINER, tfsoff);
break;
case TGT_ARRAY:
@@ -3288,8 +3310,9 @@ static void write_branch_type(FILE *file, const type_t *t, unsigned int *tfsoff)
}
static unsigned int write_union_tfs(FILE *file, const attr_list_t *attrs,
- type_t *type, unsigned int *tfsoff)
+ decl_spec_t *declspec, unsigned int *tfsoff)
{
+ type_t* type = declspec->type;
unsigned int start_offset;
unsigned int size;
var_list_t *fields;
@@ -3314,17 +3337,17 @@ static unsigned int write_union_tfs(FILE *file, const attr_list_t *attrs,
expr_list_t *cases = get_attrp(f->attrs, ATTR_CASE);
if (cases)
nbranch += list_count(cases);
- if (f->type)
- write_embedded_types(file, f->attrs, f->type, f->name, TRUE, tfsoff);
+ if (f->declspec.type)
+ write_embedded_types(file, f->attrs, &f->declspec, f->name, TRUE, tfsoff);
}
start_offset = *tfsoff;
update_tfsoff(type, start_offset, file);
- print_start_tfs_comment(file, type, start_offset);
+ print_start_tfs_comment(file, declspec, start_offset);
if (type_get_type(type) == TYPE_ENCAPSULATED_UNION)
{
const var_t *sv = type_union_get_switch_value(type);
- const type_t *st = sv->type;
+ const type_t *st = sv->declspec.type;
unsigned int align = 0;
unsigned char fc;
@@ -3356,8 +3379,8 @@ static unsigned int write_union_tfs(FILE *file, const attr_list_t *attrs,
type_memsize_and_alignment(st, &align);
if (fields) LIST_FOR_EACH_ENTRY(f, fields, var_t, entry)
{
- if (f->type)
- type_memsize_and_alignment(f->type, &align);
+ if (f->declspec.type)
+ type_memsize_and_alignment(f->declspec.type, &align);
}
print_file(file, 2, "0x%x,\t/* FC_ENCAPSULATED_UNION */\n", FC_ENCAPSULATED_UNION);
@@ -3412,7 +3435,7 @@ static unsigned int write_union_tfs(FILE *file, const attr_list_t *attrs,
if (fields) LIST_FOR_EACH_ENTRY(f, fields, var_t, entry)
{
- type_t *ft = f->type;
+ type_t *ft = f->declspec.type;
expr_list_t *cases = get_attrp(f->attrs, ATTR_CASE);
int deflt = is_attr(f->attrs, ATTR_DEFAULT);
expr_t *c;
@@ -3453,16 +3476,17 @@ static unsigned int write_union_tfs(FILE *file, const attr_list_t *attrs,
return start_offset;
}
-static unsigned int write_ip_tfs(FILE *file, const attr_list_t *attrs, type_t *type,
+static unsigned int write_ip_tfs(FILE *file, const attr_list_t *attrs, decl_spec_t *declspec,
unsigned int *typeformat_offset)
{
unsigned int i;
+ type_t *type = declspec->type;
unsigned int start_offset = *typeformat_offset;
expr_t *iid = get_attrp(attrs, ATTR_IIDIS);
if (!iid && processed(type)) return type->typestring_offset;
- print_start_tfs_comment(file, type, start_offset);
+ print_start_tfs_comment(file, declspec, start_offset);
update_tfsoff(type, start_offset, file);
if (iid)
@@ -3474,7 +3498,7 @@ static unsigned int write_ip_tfs(FILE *file, const attr_list_t *attrs, type_t *t
}
else
{
- const type_t *base = is_ptr(type) ? type_pointer_get_ref(type) : type;
+ const type_t *base = is_ptr(type) ? type_pointer_get_ref_type(type) : type;
const UUID *uuid = get_attrp(base->attrs, ATTR_UUID);
if (! uuid)
@@ -3498,14 +3522,15 @@ static unsigned int write_ip_tfs(FILE *file, const attr_list_t *attrs, type_t *t
static unsigned int write_contexthandle_tfs(FILE *file,
const attr_list_t *attrs,
- type_t *type,
+ decl_spec_t *declspec,
enum type_context context,
unsigned int *typeformat_offset)
{
+ type_t *type = declspec->type;
unsigned int start_offset = *typeformat_offset;
unsigned char flags = get_contexthandle_flags( current_iface, attrs, type, context == TYPE_CONTEXT_RETVAL );
- print_start_tfs_comment(file, type, start_offset);
+ print_start_tfs_comment(file, declspec, start_offset);
if (flags & 0x80) /* via ptr */
{
@@ -3573,22 +3598,23 @@ static unsigned int write_range_tfs(FILE *file, const attr_list_t *attrs,
}
static unsigned int write_type_tfs(FILE *file, int indent,
- const attr_list_t *attrs, type_t *type,
+ const attr_list_t *attrs, decl_spec_t *declspec,
const char *name,
enum type_context context,
unsigned int *typeformat_offset)
{
unsigned int offset;
+ type_t *type = declspec->type;
switch (typegen_detect_type(type, attrs, TDT_ALL_TYPES))
{
case TGT_CTXT_HANDLE:
case TGT_CTXT_HANDLE_POINTER:
- return write_contexthandle_tfs(file, attrs, type, context, typeformat_offset);
+ return write_contexthandle_tfs(file, attrs, declspec, context, typeformat_offset);
case TGT_USER_TYPE:
- return write_user_tfs(file, type, typeformat_offset);
+ return write_user_tfs(file, declspec, typeformat_offset);
case TGT_STRING:
- return write_string_tfs(file, attrs, type, context, name, typeformat_offset);
+ return write_string_tfs(file, attrs, declspec, context, name, typeformat_offset);
case TGT_ARRAY:
{
unsigned int off;
@@ -3596,7 +3622,7 @@ static unsigned int write_type_tfs(FILE *file, int indent,
if ((context != TYPE_CONTEXT_CONTAINER &&
context != TYPE_CONTEXT_CONTAINER_NO_POINTERS) ||
!is_conformant_array(type) || type_array_is_decl_as_ptr(type))
- off = write_array_tfs(file, attrs, type, name, typeformat_offset);
+ off = write_array_tfs(file, attrs, declspec, name, typeformat_offset);
else
off = 0;
if (context != TYPE_CONTEXT_CONTAINER &&
@@ -3623,9 +3649,9 @@ static unsigned int write_type_tfs(FILE *file, int indent,
return off;
}
case TGT_STRUCT:
- return write_struct_tfs(file, type, name, typeformat_offset);
+ return write_struct_tfs(file, declspec, name, typeformat_offset);
case TGT_UNION:
- return write_union_tfs(file, attrs, type, typeformat_offset);
+ return write_union_tfs(file, attrs, declspec, typeformat_offset);
case TGT_ENUM:
case TGT_BASIC:
/* nothing to do */
@@ -3638,11 +3664,12 @@ static unsigned int write_type_tfs(FILE *file, int indent,
return write_range_tfs(file, attrs, type, range_list, typeformat_offset);
}
case TGT_IFACE_POINTER:
- return write_ip_tfs(file, attrs, type, typeformat_offset);
+ return write_ip_tfs(file, attrs, declspec, typeformat_offset);
case TGT_POINTER:
{
enum type_context ref_context;
- type_t *ref = type_pointer_get_ref(type);
+ decl_spec_t *ref = type_pointer_get_ref(type);
+ type_t *reftype = ref->type;
if (context == TYPE_CONTEXT_TOPLEVELPARAM)
ref_context = TYPE_CONTEXT_PARAM;
@@ -3651,10 +3678,10 @@ static unsigned int write_type_tfs(FILE *file, int indent,
else
ref_context = context;
- if (is_string_type(attrs, ref))
+ if (is_string_type(attrs, reftype))
{
if (context != TYPE_CONTEXT_CONTAINER_NO_POINTERS)
- write_pointer_tfs(file, attrs, type, *typeformat_offset + 4, context, typeformat_offset);
+ write_pointer_tfs(file, attrs, declspec, *typeformat_offset + 4, context, typeformat_offset);
offset = write_type_tfs(file, indent, attrs, ref, name, ref_context, typeformat_offset);
if (context == TYPE_CONTEXT_CONTAINER_NO_POINTERS)
@@ -3666,7 +3693,7 @@ static unsigned int write_type_tfs(FILE *file, int indent,
ref_context, typeformat_offset);
if (context == TYPE_CONTEXT_CONTAINER_NO_POINTERS)
return 0;
- return write_pointer_tfs(file, attrs, type, offset, context, typeformat_offset);
+ return write_pointer_tfs(file, attrs, declspec, offset, context, typeformat_offset);
}
case TGT_INVALID:
break;
@@ -3675,10 +3702,10 @@ static unsigned int write_type_tfs(FILE *file, int indent,
return 0;
}
-static int write_embedded_types(FILE *file, const attr_list_t *attrs, type_t *type,
+static int write_embedded_types(FILE *file, const attr_list_t *attrs, decl_spec_t *declspec,
const char *name, int write_ptr, unsigned int *tfsoff)
{
- return write_type_tfs(file, 2, attrs, type, name, write_ptr ? TYPE_CONTEXT_CONTAINER : TYPE_CONTEXT_CONTAINER_NO_POINTERS, tfsoff);
+ return write_type_tfs(file, 2, attrs, declspec, name, write_ptr ? TYPE_CONTEXT_CONTAINER : TYPE_CONTEXT_CONTAINER_NO_POINTERS, tfsoff);
}
static void process_tfs_iface(type_t *iface, FILE *file, int indent, unsigned int *offset)
@@ -3696,21 +3723,21 @@ static void process_tfs_iface(type_t *iface, FILE *file, int indent, unsigned in
{
const var_t *func = stmt->u.var;
- if(stmt->u.var->stgclass != STG_NONE
- || type_get_type_detect_alias(stmt->u.var->type) != TYPE_FUNCTION)
+ if(stmt->u.var->declspec.stgclass != STG_NONE
+ || type_get_type_detect_alias(stmt->u.var->declspec.type) != TYPE_FUNCTION)
continue;
current_func = func;
if (is_local(func->attrs)) continue;
- var = type_function_get_retval(func->type);
- if (!is_void(var->type))
- var->typestring_offset = write_type_tfs( file, 2, var->attrs, var->type, func->name,
+ var = type_function_get_retval(func->declspec.type);
+ if (!is_void(var->declspec.type))
+ var->typestring_offset = write_type_tfs( file, 2, var->attrs, &var->declspec, func->name,
TYPE_CONTEXT_RETVAL, offset);
- if (type_get_function_args(func->type))
- LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), var_t, entry )
- var->typestring_offset = write_type_tfs( file, 2, var->attrs, var->type, var->name,
+ if (type_get_function_args(func->declspec.type))
+ LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->declspec.type), var_t, entry )
+ var->typestring_offset = write_type_tfs( file, 2, var->attrs, &var->declspec, var->name,
TYPE_CONTEXT_TOPLEVELPARAM, offset );
break;
@@ -3722,9 +3749,12 @@ static void process_tfs_iface(type_t *iface, FILE *file, int indent, unsigned in
{
if (is_attr(type_entry->type->attrs, ATTR_ENCODE)
|| is_attr(type_entry->type->attrs, ATTR_DECODE))
+ {
+ decl_spec_t ds;
type_entry->type->typestring_offset = write_type_tfs( file, 2,
- type_entry->type->attrs, type_entry->type, type_entry->type->name,
+ type_entry->type->attrs, init_declspec(&ds, type_entry->type), type_entry->type->name,
TYPE_CONTEXT_CONTAINER, offset);
+ }
}
break;
}
@@ -3845,7 +3875,7 @@ static unsigned int get_required_buffer_size_type(
case TGT_POINTER:
{
unsigned int size, align;
- const type_t *ref = type_pointer_get_ref(type);
+ const type_t *ref = type_pointer_get_ref_type(type);
if (is_string_type( attrs, ref )) break;
if (!(size = get_required_buffer_size_type( ref, name, NULL, FALSE, &align ))) break;
if (get_pointer_fc(type, attrs, toplevel_param) != FC_RP)
@@ -3865,7 +3895,7 @@ static unsigned int get_required_buffer_size_type(
case FC_SMFARRAY:
case FC_LGFARRAY:
return type_array_get_dim(type) *
- get_required_buffer_size_type(type_array_get_element(type), name,
+ get_required_buffer_size_type(type_array_get_element_type(type), name,
NULL, FALSE, alignment);
}
}
@@ -3896,8 +3926,8 @@ static unsigned int get_required_buffer_size(const var_t *var, unsigned int *ali
return 20;
}
- if (!is_string_type(var->attrs, var->type))
- return get_required_buffer_size_type(var->type, var->name,
+ if (!is_string_type(var->attrs, var->declspec.type))
+ return get_required_buffer_size_type(var->declspec.type, var->name,
var->attrs, TRUE, alignment);
}
return 0;
@@ -3908,19 +3938,19 @@ static unsigned int get_function_buffer_size( const var_t *func, enum pass pass
const var_t *var;
unsigned int total_size = 0, alignment;
- if (type_get_function_args(func->type))
+ if (type_get_function_args(func->declspec.type))
{
- LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry )
+ LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->declspec.type), const var_t, entry )
{
total_size += get_required_buffer_size(var, &alignment, pass);
total_size += alignment;
}
}
- if (pass == PASS_OUT && !is_void(type_function_get_rettype(func->type)))
+ if (pass == PASS_OUT && !is_void(type_function_get_rettype(func->declspec.type)))
{
var_t v = *func;
- v.type = type_function_get_rettype(func->type);
+ v.declspec.type = type_function_get_rettype(func->declspec.type);
total_size += get_required_buffer_size(&v, &alignment, PASS_RETURN);
total_size += alignment;
}
@@ -3956,9 +3986,9 @@ static void print_phase_function(FILE *file, int indent, const char *type,
print_file(file, indent, "&__frame->_StubMsg,\n");
print_file(file, indent, "%s%s%s%s%s,\n",
(phase == PHASE_UNMARSHAL) ? "(unsigned char **)" : "(unsigned char *)",
- (phase == PHASE_UNMARSHAL || decl_indirect(var->type)) ? "&" : "",
+ (phase == PHASE_UNMARSHAL || decl_indirect(var->declspec.type)) ? "&" : "",
local_var_prefix,
- (phase == PHASE_UNMARSHAL && decl_indirect(var->type)) ? "_p_" : "",
+ (phase == PHASE_UNMARSHAL && decl_indirect(var->declspec.type)) ? "_p_" : "",
var->name);
print_file(file, indent, "(PFORMAT_STRING)&__MIDL_TypeFormatString.Format[%d]%s\n",
type_offset, (phase == PHASE_UNMARSHAL) ? "," : ");");
@@ -3971,7 +4001,8 @@ void print_phase_basetype(FILE *file, int indent, const char *local_var_prefix,
enum remoting_phase phase, enum pass pass, const var_t *var,
const char *varname)
{
- type_t *type = var->type;
+ decl_spec_t *declspec = (decl_spec_t*)&var->declspec;
+ type_t *type = declspec->type;
unsigned int alignment = 0;
/* no work to do for other phases, buffer sizing is done elsewhere */
@@ -4002,8 +4033,9 @@ void print_phase_basetype(FILE *file, int indent, const char *local_var_prefix,
}
else
{
- const type_t *ref = is_ptr(type) ? type_pointer_get_ref(type) : type;
- switch (get_basic_fc(ref))
+ const decl_spec_t *ref = is_ptr(type) ? type_pointer_get_ref(type) : declspec;
+ const type_t *reftype = ref->type;
+ switch (get_basic_fc(reftype))
{
case FC_BYTE:
case FC_CHAR:
@@ -4040,7 +4072,7 @@ void print_phase_basetype(FILE *file, int indent, const char *local_var_prefix,
default:
error("print_phase_basetype: Unsupported type: %s (0x%02x, ptr_level: 0)\n",
- var->name, get_basic_fc(ref));
+ var->name, get_basic_fc(reftype));
}
if (phase == PHASE_MARSHAL && alignment > 1)
@@ -4051,7 +4083,7 @@ void print_phase_basetype(FILE *file, int indent, const char *local_var_prefix,
if (phase == PHASE_MARSHAL)
{
print_file(file, indent, "*(");
- write_type_decl(file, is_ptr(type) ? type_pointer_get_ref(type) : type, NULL);
+ write_declspec_decl(file, is_ptr(type) ? type_pointer_get_ref(type) : declspec, NULL);
if (is_ptr(type))
fprintf(file, " *)__frame->_StubMsg.Buffer = *");
else
@@ -4062,7 +4094,7 @@ void print_phase_basetype(FILE *file, int indent, const char *local_var_prefix,
else if (phase == PHASE_UNMARSHAL)
{
print_file(file, indent, "if (__frame->_StubMsg.Buffer + sizeof(");
- write_type_decl(file, is_ptr(type) ? type_pointer_get_ref(type) : type, NULL);
+ write_declspec_decl(file, is_ptr(type) ? type_pointer_get_ref(type) : declspec, NULL);
fprintf(file, ") > __frame->_StubMsg.BufferEnd)\n");
print_file(file, indent, "{\n");
print_file(file, indent + 1, "RpcRaiseException(RPC_X_BAD_STUB_DATA);\n");
@@ -4074,12 +4106,12 @@ void print_phase_basetype(FILE *file, int indent, const char *local_var_prefix,
fprintf(file, " = (");
else
fprintf(file, " = *(");
- write_type_decl(file, is_ptr(type) ? type_pointer_get_ref(type) : type, NULL);
+ write_declspec_decl(file, is_ptr(type) ? type_pointer_get_ref(type) : declspec, NULL);
fprintf(file, " *)__frame->_StubMsg.Buffer;\n");
}
print_file(file, indent, "__frame->_StubMsg.Buffer += sizeof(");
- write_type_decl(file, is_ptr(type) ? type_pointer_get_ref(type) : type, NULL);
+ write_declspec_decl(file, is_ptr(type) ? type_pointer_get_ref(type) : declspec, NULL);
fprintf(file, ");\n");
}
}
@@ -4095,7 +4127,7 @@ expr_t *get_size_is_expr(const type_t *t, const char *name)
{
expr_t *x = NULL;
- for ( ; is_array(t); t = type_array_get_element(t))
+ for ( ; is_array(t); t = type_array_get_element_type(t))
if (type_array_has_conformance(t) &&
type_array_get_conformance(t)->type != EXPR_VOID)
{
@@ -4113,7 +4145,7 @@ expr_t *get_size_is_expr(const type_t *t, const char *name)
void write_parameter_conf_or_var_exprs(FILE *file, int indent, const char *local_var_prefix,
enum remoting_phase phase, const var_t *var, int valid_variance)
{
- const type_t *type = var->type;
+ const type_t *type = var->declspec.type;
/* get fundamental type for the argument */
for (;;)
{
@@ -4165,7 +4197,7 @@ void write_parameter_conf_or_var_exprs(FILE *file, int indent, const char *local
break;
}
case TGT_POINTER:
- type = type_pointer_get_ref(type);
+ type = type_pointer_get_ref_type(type);
continue;
case TGT_INVALID:
case TGT_USER_TYPE:
@@ -4187,7 +4219,7 @@ static void write_remoting_arg(FILE *file, int indent, const var_t *func, const
{
int in_attr, out_attr, pointer_type;
const char *type_str = NULL;
- const type_t *type = var->type;
+ const type_t *type = var->declspec.type;
unsigned int alignment, start_offset = type->typestring_offset;
if (is_ptr(type) || is_array(type))
@@ -4240,7 +4272,7 @@ static void write_remoting_arg(FILE *file, int indent, const var_t *func, const
print_file(file, indent, "NdrServerContextNewMarshall(\n");
print_file(file, indent + 1, "&__frame->_StubMsg,\n");
print_file(file, indent + 1, "(NDR_SCONTEXT)%s%s,\n", local_var_prefix, var->name);
- print_file(file, indent + 1, "(NDR_RUNDOWN)%s_rundown,\n", get_context_handle_type_name(var->type));
+ print_file(file, indent + 1, "(NDR_RUNDOWN)%s_rundown,\n", get_context_handle_type_name(var->declspec.type));
print_file(file, indent + 1, "(PFORMAT_STRING)&__MIDL_TypeFormatString.Format[%d]);\n", start_offset);
}
}
@@ -4384,9 +4416,9 @@ static void write_remoting_arg(FILE *file, int indent, const var_t *func, const
range_max = LIST_ENTRY(list_next(range_list, list_head(range_list)), const expr_t, entry);
print_file(file, indent, "if ((%s%s < (", local_var_prefix, var->name);
- write_type_decl(file, var->type, NULL);
+ write_declspec_decl(file, (decl_spec_t*)&var->declspec, NULL);
fprintf(file, ")0x%x) || (%s%s > (", range_min->cval, local_var_prefix, var->name);
- write_type_decl(file, var->type, NULL);
+ write_declspec_decl(file, (decl_spec_t*)&var->declspec, NULL);
fprintf(file, ")0x%x))\n", range_max->cval);
print_file(file, indent, "{\n");
print_file(file, indent+1, "RpcRaiseException(RPC_S_INVALID_BOUND);\n");
@@ -4432,7 +4464,7 @@ static void write_remoting_arg(FILE *file, int indent, const var_t *func, const
}
case TGT_POINTER:
{
- const type_t *ref = type_pointer_get_ref(type);
+ const type_t *ref = type_pointer_get_ref_type(type);
if (pointer_type == FC_RP) switch (typegen_detect_type(ref, NULL, TDT_ALL_TYPES))
{
case TGT_BASIC:
@@ -4553,14 +4585,14 @@ void write_remoting_arguments(FILE *file, int indent, const var_t *func, const c
if (pass == PASS_RETURN)
{
write_remoting_arg( file, indent, func, local_var_prefix, pass, phase,
- type_function_get_retval(func->type) );
+ type_function_get_retval(func->declspec.type) );
}
else
{
const var_t *var;
- if (!type_get_function_args(func->type))
+ if (!type_get_function_args(func->declspec.type))
return;
- LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry )
+ LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->declspec.type), const var_t, entry )
write_remoting_arg( file, indent, func, local_var_prefix, pass, phase, var );
}
}
@@ -4601,62 +4633,62 @@ void declare_stub_args( FILE *file, int indent, const var_t *func )
{
int in_attr, out_attr;
int i = 0;
- const var_t *var = type_function_get_retval(func->type);
+ const var_t *var = type_function_get_retval(func->declspec.type);
/* declare return value */
- if (!is_void(var->type))
+ if (!is_void(var->declspec.type))
{
- if (is_context_handle(var->type))
+ if (is_context_handle(var->declspec.type))
print_file(file, indent, "NDR_SCONTEXT %s;\n", var->name);
else
{
print_file(file, indent, "%s", "");
- write_type_decl(file, var->type, var->name);
+ write_declspec_decl(file, (decl_spec_t*)&var->declspec, var->name);
fprintf(file, ";\n");
}
}
- if (!type_get_function_args(func->type))
+ if (!type_get_function_args(func->declspec.type))
return;
- LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry )
+ LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->declspec.type), const var_t, entry )
{
in_attr = is_attr(var->attrs, ATTR_IN);
out_attr = is_attr(var->attrs, ATTR_OUT);
if (!out_attr && !in_attr)
in_attr = 1;
- if (is_context_handle(var->type))
+ if (is_context_handle(var->declspec.type))
print_file(file, indent, "NDR_SCONTEXT %s;\n", var->name);
else
{
- if (!in_attr && !is_conformant_array(var->type))
+ if (!in_attr && !is_conformant_array(var->declspec.type))
{
- type_t *type_to_print;
+ decl_spec_t *declspec_to_print;
char name[16];
print_file(file, indent, "%s", "");
- if (type_get_type(var->type) == TYPE_ARRAY &&
- !type_array_is_decl_as_ptr(var->type))
- type_to_print = var->type;
+ if (type_get_type(var->declspec.type) == TYPE_ARRAY &&
+ !type_array_is_decl_as_ptr(var->declspec.type))
+ declspec_to_print = (decl_spec_t*)&var->declspec;
else
- type_to_print = type_pointer_get_ref(var->type);
+ declspec_to_print = type_pointer_get_ref(var->declspec.type);
sprintf(name, "_W%u", i++);
- write_type_decl(file, type_to_print, name);
+ write_declspec_decl(file, declspec_to_print, name);
fprintf(file, ";\n");
}
print_file(file, indent, "%s", "");
- write_type_decl_left(file, var->type);
+ write_declspec_decl_left(file, (decl_spec_t*)&var->declspec);
fprintf(file, " ");
- if (type_get_type(var->type) == TYPE_ARRAY &&
- !type_array_is_decl_as_ptr(var->type)) {
+ if (type_get_type(var->declspec.type) == TYPE_ARRAY &&
+ !type_array_is_decl_as_ptr(var->declspec.type)) {
fprintf(file, "(*%s)", var->name);
} else
fprintf(file, "%s", var->name);
- write_type_right(file, var->type, FALSE);
+ write_type_right(file, var->declspec.type, FALSE);
fprintf(file, ";\n");
- if (decl_indirect(var->type))
+ if (decl_indirect(var->declspec.type))
print_file(file, indent, "void *_p_%s;\n", var->name);
}
}
@@ -4670,10 +4702,10 @@ void assign_stub_out_args( FILE *file, int indent, const var_t *func, const char
const var_t *var;
type_t *ref;
- if (!type_get_function_args(func->type))
+ if (!type_get_function_args(func->declspec.type))
return;
- LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry )
+ LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->declspec.type), const var_t, entry )
{
in_attr = is_attr(var->attrs, ATTR_IN);
out_attr = is_attr(var->attrs, ATTR_OUT);
@@ -4684,7 +4716,7 @@ void assign_stub_out_args( FILE *file, int indent, const var_t *func, const char
{
print_file(file, indent, "%s%s", local_var_prefix, var->name);
- switch (typegen_detect_type(var->type, var->attrs, TDT_IGNORE_STRINGS))
+ switch (typegen_detect_type(var->declspec.type, var->attrs, TDT_IGNORE_STRINGS))
{
case TGT_CTXT_HANDLE_POINTER:
fprintf(file, " = NdrContextHandleInitialize(\n");
@@ -4693,15 +4725,15 @@ void assign_stub_out_args( FILE *file, int indent, const var_t *func, const char
var->typestring_offset);
break;
case TGT_ARRAY:
- if (type_array_has_conformance(var->type))
+ if (type_array_has_conformance(var->declspec.type))
{
unsigned int size;
type_t *type;
fprintf(file, " = NdrAllocate(&__frame->_StubMsg, ");
- for (type = var->type;
+ for (type = var->declspec.type;
is_array(type) && type_array_has_conformance(type);
- type = type_array_get_element(type))
+ type = type_array_get_element_type(type))
{
write_expr(file, type_array_get_conformance(type), TRUE,
TRUE, NULL, NULL, local_var_prefix);
@@ -4711,9 +4743,9 @@ void assign_stub_out_args( FILE *file, int indent, const var_t *func, const char
fprintf(file, "%u);\n", size);
print_file(file, indent, "memset(%s%s, 0, ", local_var_prefix, var->name);
- for (type = var->type;
+ for (type = var->declspec.type;
is_array(type) && type_array_has_conformance(type);
- type = type_array_get_element(type))
+ type = type_array_get_element_type(type))
{
write_expr(file, type_array_get_conformance(type), TRUE,
TRUE, NULL, NULL, local_var_prefix);
@@ -4727,7 +4759,7 @@ void assign_stub_out_args( FILE *file, int indent, const var_t *func, const char
break;
case TGT_POINTER:
fprintf(file, " = &%s_W%u;\n", local_var_prefix, i);
- ref = type_pointer_get_ref(var->type);
+ ref = type_pointer_get_ref_type(var->declspec.type);
switch (typegen_detect_type(ref, var->attrs, TDT_IGNORE_STRINGS))
{
case TGT_BASIC:
@@ -4747,7 +4779,7 @@ void assign_stub_out_args( FILE *file, int indent, const var_t *func, const char
print_file(file, indent, "%s_W%u = 0;\n", local_var_prefix, i);
break;
}
- ref = type_array_get_element(ref);
+ ref = type_array_get_element_type(ref);
/* fall through */
case TGT_STRUCT:
case TGT_UNION:
@@ -4787,7 +4819,7 @@ void write_func_param_struct( FILE *file, const type_t *iface, const type_t *fun
if (args)
LIST_FOR_EACH_ENTRY( arg, args, const var_t, entry )
- if (!is_array( arg->type )) type_memsize_and_alignment( arg->type, &align );
+ if (!is_array( arg->declspec.type )) type_memsize_and_alignment( arg->declspec.type, &align );
needs_packing = (align > pointer_size);
@@ -4799,26 +4831,26 @@ void write_func_param_struct( FILE *file, const type_t *iface, const type_t *fun
if (args) LIST_FOR_EACH_ENTRY( arg, args, const var_t, entry )
{
print_file(file, 2, "%s", "");
- write_type_left( file, (type_t *)arg->type, NAME_DEFAULT, TRUE );
- if (needs_space_after( arg->type )) fputc( ' ', file );
- if (is_array( arg->type ) && !type_array_is_decl_as_ptr( arg->type )) fputc( '*', file );
+ write_declspec_left( file, (decl_spec_t *)&arg->declspec, NAME_DEFAULT, TRUE );
+ if (needs_space_after( arg->declspec.type )) fputc( ' ', file );
+ if (is_array( arg->declspec.type ) && !type_array_is_decl_as_ptr( arg->declspec.type )) fputc( '*', file );
/* FIXME: should check for large args being passed by pointer */
align = 0;
- if (is_array( arg->type ) || is_ptr( arg->type )) align = pointer_size;
- else type_memsize_and_alignment( arg->type, &align );
+ if (is_array( arg->declspec.type ) || is_ptr( arg->declspec.type )) align = pointer_size;
+ else type_memsize_and_alignment( arg->declspec.type, &align );
if (align >= pointer_size)
fprintf( file, "%s;\n", arg->name );
else
fprintf( file, "%s DECLSPEC_ALIGN(%u);\n", arg->name, pointer_size );
}
- if (add_retval && !is_void( retval->type ))
+ if (add_retval && !is_void( retval->declspec.type ))
{
print_file(file, 2, "%s", "");
- write_type_decl( file, retval->type, retval->name );
- if (is_array( retval->type ) || is_ptr( retval->type ) ||
- type_memsize( retval->type ) == pointer_size)
+ write_declspec_decl( file, (decl_spec_t*)&retval->declspec, retval->name );
+ if (is_array( retval->declspec.type ) || is_ptr( retval->declspec.type ) ||
+ type_memsize( retval->declspec.type ) == pointer_size)
fprintf( file, ";\n" );
else
fprintf( file, " DECLSPEC_ALIGN(%u);\n", pointer_size );
@@ -4830,7 +4862,7 @@ void write_func_param_struct( FILE *file, const type_t *iface, const type_t *fun
void write_pointer_checks( FILE *file, int indent, const var_t *func )
{
- const var_list_t *args = type_get_function_args( func->type );
+ const var_list_t *args = type_get_function_args( func->declspec.type );
const var_t *var;
if (!args) return;
@@ -4863,10 +4895,11 @@ int write_expr_eval_routines(FILE *file, const char *iface)
}
else
{
+ decl_spec_t declspec;
print_file(file, 1, "%s", "");
- write_type_left(file, (type_t *)eval->cont_type, NAME_DEFAULT, TRUE);
+ write_declspec_left(file, init_declspec(&declspec, (type_t*)eval->cont_type), NAME_DEFAULT, TRUE);
fprintf(file, " *%s = (", var_name);
- write_type_left(file, (type_t *)eval->cont_type, NAME_DEFAULT, TRUE);
+ write_declspec_left(file, init_declspec(&declspec, (type_t*)eval->cont_type), NAME_DEFAULT, TRUE);
fprintf(file, " *)(pStubMsg->StackTop - %u);\n", eval->baseoff);
}
print_file(file, 1, "pStubMsg->Offset = 0;\n"); /* FIXME */
@@ -4960,9 +4993,10 @@ error:
void write_client_call_routine( FILE *file, const type_t *iface, const var_t *func,
const char *prefix, unsigned int proc_offset )
{
- type_t *rettype = type_function_get_rettype( func->type );
+ decl_spec_t *retdeclspec = type_function_get_retdeclspec(func->declspec.type);
+ type_t *rettype = retdeclspec->type;
int has_ret = !is_void( rettype );
- const var_list_t *args = type_get_function_args( func->type );
+ const var_list_t *args = type_get_function_args( func->declspec.type );
const var_t *arg;
int len, needs_params = 0;
@@ -4973,7 +5007,7 @@ void write_client_call_routine( FILE *file, const type_t *iface, const var_t *fu
if (needs_params)
{
if (has_ret) print_file( file, 1, "%s", "CLIENT_CALL_RETURN _RetVal;\n" );
- write_func_param_struct( file, iface, func->type, "__params", FALSE );
+ write_func_param_struct( file, iface, func->declspec.type, "__params", FALSE );
if (is_object( iface )) print_file( file, 1, "__params.This = This;\n" );
if (args)
LIST_FOR_EACH_ENTRY( arg, args, const var_t, entry )
@@ -5010,7 +5044,7 @@ void write_client_call_routine( FILE *file, const type_t *iface, const var_t *fu
if (has_ret)
{
print_file( file, 1, "return (" );
- write_type_decl_left(file, rettype);
+ write_declspec_decl_left(file, retdeclspec);
fprintf( file, ")%s;\n", pointer_size == 8 ? "_RetVal.Simple" : "*(LONG_PTR *)&_RetVal" );
}
print_file( file, 0, "}\n\n");
diff --git a/tools/widl/typelib.c b/tools/widl/typelib.c
index 93f8f4de19..4f6b4fc38a 100644
--- a/tools/widl/typelib.c
+++ b/tools/widl/typelib.c
@@ -97,9 +97,9 @@ static unsigned short builtin_vt(const type_t *t)
{
const type_t *elem_type;
if (is_array(t))
- elem_type = type_array_get_element(t);
+ elem_type = type_array_get_element_type(t);
else
- elem_type = type_pointer_get_ref(t);
+ elem_type = type_pointer_get_ref_type(t);
if (type_get_type(elem_type) == TYPE_BASIC)
{
switch (type_basic_get_type(elem_type))
@@ -198,7 +198,7 @@ unsigned short get_type_vt(type_t *t)
case TYPE_ARRAY:
if (type_array_is_decl_as_ptr(t))
{
- if (match(type_array_get_element(t)->name, "SAFEARRAY"))
+ if (match(type_array_get_element_type(t)->name, "SAFEARRAY"))
return VT_SAFEARRAY;
return VT_PTR;
}
diff --git a/tools/widl/typetree.c b/tools/widl/typetree.c
index b93806be98..203d851a8c 100644
--- a/tools/widl/typetree.c
+++ b/tools/widl/typetree.c
@@ -30,17 +30,6 @@
#include "typetree.h"
#include "header.h"
-type_t *duptype(type_t *t, int dupname)
-{
- type_t *d = alloc_type();
-
- *d = *t;
- if (dupname && t->name)
- d->name = xstrdup(t->name);
-
- return d;
-}
-
type_t *make_type(enum type_type type)
{
type_t *t = alloc_type();
@@ -49,7 +38,6 @@ type_t *make_type(enum type_type type)
t->type_type = type;
t->attrs = NULL;
t->c_name = NULL;
- t->orig = NULL;
memset(&t->details, 0, sizeof(t->details));
t->typestring_offset = 0;
t->ptrdesc = 0;
@@ -137,7 +125,7 @@ type_t *type_new_function(var_list_t *args)
if (args)
{
arg = LIST_ENTRY(list_head(args), var_t, entry);
- if (list_count(args) == 1 && !arg->name && arg->type && type_get_type(arg->type) == TYPE_VOID)
+ if (list_count(args) == 1 && !arg->name && arg->declspec.type && type_get_type(arg->declspec.type) == TYPE_VOID)
{
list_remove(&arg->entry);
free(arg);
@@ -147,7 +135,7 @@ type_t *type_new_function(var_list_t *args)
}
if (args) LIST_FOR_EACH_ENTRY(arg, args, var_t, entry)
{
- if (arg->type && type_get_type(arg->type) == TYPE_VOID)
+ if (arg->declspec.type && type_get_type(arg->declspec.type) == TYPE_VOID)
error_loc("argument '%s' has void type\n", arg->name);
if (!arg->name)
{
@@ -182,21 +170,26 @@ type_t *type_new_pointer(unsigned char pointer_default, type_t *ref, attr_list_t
{
type_t *t = make_type(TYPE_POINTER);
t->details.pointer.def_fc = pointer_default;
- t->details.pointer.ref = ref;
+ init_declspec(&t->details.pointer.ref, ref);
t->attrs = attrs;
return t;
}
-type_t *type_new_alias(type_t *t, const char *name)
+type_t* type_new_alias(const decl_spec_t *declspec, const char *name, struct namespace *namespace)
{
- type_t *a = duptype(t, 0);
+ type_t *a = NULL;
+
+ assert(declspec != NULL);
+ assert(name != NULL);
+
+ a = alloc_type();
+ *a = *declspec->type;
a->name = xstrdup(name);
+ a->namespace = namespace;
a->attrs = NULL;
- a->orig = t;
+ a->details.alias.aliasee = *declspec;
a->is_alias = TRUE;
- /* for pointer types */
- a->details = t->details;
init_loc_info(&a->loc_info);
return a;
@@ -222,10 +215,9 @@ type_t *type_new_coclass(char *name)
return type;
}
-
-type_t *type_new_array(const char *name, type_t *element, int declptr,
- unsigned int dim, expr_t *size_is, expr_t *length_is,
- unsigned char ptr_default_fc)
+type_t *type_new_array(const char *name, const decl_spec_t *element, int declptr,
+ unsigned int dim, expr_t *size_is, expr_t *length_is,
+ unsigned char ptr_default_fc)
{
type_t *t = make_type(TYPE_ARRAY);
if (name) t->name = xstrdup(name);
@@ -235,7 +227,9 @@ type_t *type_new_array(const char *name, type_t *element, int declptr,
t->details.array.size_is = size_is;
else
t->details.array.dim = dim;
- t->details.array.elem = element;
+ if (element) {
+ t->details.array.elem = *element;
+ }
t->details.array.ptr_def_fc = ptr_default_fc;
return t;
}
@@ -354,7 +348,7 @@ type_t *type_new_encapsulated_union(char *name, var_t *switch_field, var_t *unio
{
type_t *t = get_type(TYPE_ENCAPSULATED_UNION, name, NULL, tsUNION);
if (!union_field) union_field = make_var( xstrdup("tagged_union") );
- union_field->type = type_new_nonencapsulated_union(NULL, TRUE, cases);
+ union_field->declspec.type = type_new_nonencapsulated_union(NULL, TRUE, cases);
t->details.structure = xmalloc(sizeof(*t->details.structure));
t->details.structure->fields = append_var( NULL, switch_field );
t->details.structure->fields = append_var( t->details.structure->fields, union_field );
@@ -395,11 +389,11 @@ static int is_valid_bitfield_type(const type_t *type)
}
}
-type_t *type_new_bitfield(type_t *field, const expr_t *bits)
+type_t *type_new_bitfield(const decl_spec_t *field, const expr_t *bits)
{
type_t *t;
- if (!is_valid_bitfield_type(field))
+ if (!is_valid_bitfield_type(field->type))
error_loc("bit-field has invalid type\n");
if (bits->cval < 0)
@@ -408,7 +402,7 @@ type_t *type_new_bitfield(type_t *field, const expr_t *bits)
/* FIXME: validate bits->cval <= memsize(field) * 8 */
t = make_type(TYPE_BITFIELD);
- t->details.bitfield.field = field;
+ t->details.bitfield.field = *field;
t->details.bitfield.bits = bits;
return t;
}
@@ -430,7 +424,7 @@ static int compute_method_indexes(type_t *iface)
{
var_t *func = stmt->u.var;
if (!is_callas(func->attrs))
- func->type->details.function->idx = idx++;
+ func->declspec.type->details.function->idx = idx++;
}
return idx;
diff --git a/tools/widl/typetree.h b/tools/widl/typetree.h
index fc134cd575..19db6e6a53 100644
--- a/tools/widl/typetree.h
+++ b/tools/widl/typetree.h
@@ -31,9 +31,9 @@ enum name_type {
type_t *type_new_function(var_list_t *args);
type_t *type_new_pointer(unsigned char pointer_default, type_t *ref, attr_list_t *attrs);
-type_t *type_new_alias(type_t *t, const char *name);
+type_t *type_new_alias(const decl_spec_t *aliasee, const char *name, struct namespace *namespace);
type_t *type_new_module(char *name);
-type_t *type_new_array(const char *name, type_t *element, int declptr,
+type_t *type_new_array(const char* name, const decl_spec_t *element, int declptr,
unsigned int dim, expr_t *size_is, expr_t *length_is,
unsigned char ptr_default_fc);
type_t *type_new_basic(enum type_basic_type basic_type);
@@ -44,7 +44,7 @@ type_t *type_new_enum(const char *name, struct namespace *namespace, int defined
type_t *type_new_struct(char *name, struct namespace *namespace, int defined, var_list_t *fields);
type_t *type_new_nonencapsulated_union(const char *name, int defined, var_list_t *fields);
type_t *type_new_encapsulated_union(char *name, var_t *switch_field, var_t *union_field, var_list_t *cases);
-type_t *type_new_bitfield(type_t *field_type, const expr_t *bits);
+type_t *type_new_bitfield(const decl_spec_t *field_type, const expr_t *bits);
void type_interface_define(type_t *iface, type_t *inherit, statement_list_t *stmts);
void type_dispinterface_define(type_t *iface, var_list_t *props, var_list_t *methods);
void type_dispinterface_define_from_iface(type_t *dispiface, type_t *iface);
@@ -53,14 +53,11 @@ type_t *type_coclass_define(type_t *coclass, ifref_list_t *ifaces);
int type_is_equal(const type_t *type1, const type_t *type2);
const char *type_get_name(const type_t *type, enum name_type name_type);
-/* FIXME: shouldn't need to export this */
-type_t *duptype(type_t *t, int dupname);
-
/* un-alias the type until finding the non-alias type */
static inline type_t *type_get_real_type(const type_t *type)
{
if (type->is_alias)
- return type_get_real_type(type->orig);
+ return type_get_real_type(type->details.alias.aliasee.type);
else
return (type_t *)type;
}
@@ -105,9 +102,14 @@ static inline var_t *type_function_get_retval(const type_t *type)
return type->details.function->retval;
}
+static inline decl_spec_t* type_function_get_retdeclspec(const type_t *type)
+{
+ return &(type_function_get_retval(type)->declspec);
+}
+
static inline type_t *type_function_get_rettype(const type_t *type)
{
- return type_function_get_retval(type)->type;
+ return type_function_get_retdeclspec(type)->type;
}
static inline var_list_t *type_enum_get_values(const type_t *type)
@@ -142,7 +144,7 @@ static inline var_list_t *type_union_get_cases(const type_t *type)
if (type_type == TYPE_ENCAPSULATED_UNION)
{
const var_t *uv = LIST_ENTRY(list_tail(type->details.structure->fields), const var_t, entry);
- return uv->type->details.structure->fields;
+ return uv->declspec.type->details.structure->fields;
}
else
return type->details.structure->fields;
@@ -250,11 +252,18 @@ static inline expr_t *type_array_get_variance(const type_t *type)
return type->details.array.length_is;
}
-static inline type_t *type_array_get_element(const type_t *type)
+static inline decl_spec_t *type_array_get_element(const type_t *type)
{
type = type_get_real_type(type);
assert(type_get_type(type) == TYPE_ARRAY);
- return type->details.array.elem;
+ return (decl_spec_t*)&type->details.array.elem;
+}
+
+static inline type_t *type_array_get_element_type(const type_t *type)
+{
+ decl_spec_t *ds = type_array_get_element(type);
+ if (ds) return ds->type;
+ return NULL;
}
static inline int type_array_is_decl_as_ptr(const type_t *type)
@@ -276,10 +285,17 @@ static inline int type_is_alias(const type_t *type)
return type->is_alias;
}
-static inline type_t *type_alias_get_aliasee(const type_t *type)
+static inline decl_spec_t *type_alias_get_aliasee(const type_t *type)
{
assert(type_is_alias(type));
- return type->orig;
+ return (decl_spec_t*)&type->details.alias.aliasee;
+}
+
+static inline type_t *type_alias_get_aliasee_type(const type_t *type)
+{
+ decl_spec_t *ds = type_alias_get_aliasee(type);
+ if (ds) return ds->type;
+ return NULL;
}
static inline ifref_list_t *type_coclass_get_ifaces(const type_t *type)
@@ -289,11 +305,18 @@ static inline ifref_list_t *type_coclass_get_ifaces(const type_t *type)
return type->details.coclass.ifaces;
}
-static inline type_t *type_pointer_get_ref(const type_t *type)
+static inline decl_spec_t *type_pointer_get_ref(const type_t *type)
{
type = type_get_real_type(type);
assert(type_get_type(type) == TYPE_POINTER);
- return type->details.pointer.ref;
+ return (decl_spec_t*)&type->details.pointer.ref;
+}
+
+static inline type_t *type_pointer_get_ref_type(const type_t *type)
+{
+ decl_spec_t *ds = type_pointer_get_ref(type);
+ if (ds) return ds->type;
+ return NULL;
}
static inline unsigned char type_pointer_get_default_fc(const type_t *type)
@@ -303,11 +326,11 @@ static inline unsigned char type_pointer_get_default_fc(const type_t *type)
return type->details.pointer.def_fc;
}
-static inline type_t *type_bitfield_get_field(const type_t *type)
+static inline decl_spec_t *type_bitfield_get_field(const type_t *type)
{
type = type_get_real_type(type);
assert(type_get_type(type) == TYPE_BITFIELD);
- return type->details.bitfield.field;
+ return (decl_spec_t*)&type->details.bitfield.field;
}
static inline const expr_t *type_bitfield_get_bits(const type_t *type)
diff --git a/tools/widl/widltypes.h b/tools/widl/widltypes.h
index 1177c1a00a..93c3e31c9e 100644
--- a/tools/widl/widltypes.h
+++ b/tools/widl/widltypes.h
@@ -40,6 +40,7 @@ typedef struct _attr_t attr_t;
typedef struct _expr_t expr_t;
typedef struct _type_t type_t;
typedef struct _var_t var_t;
+typedef struct _decl_spec_t decl_spec_t;
typedef struct _declarator_t declarator_t;
typedef struct _ifref_t ifref_t;
typedef struct _typelib_entry_t typelib_entry_t;
@@ -234,6 +235,18 @@ enum storage_class
STG_REGISTER,
};
+enum type_qualifier
+{
+ TYPE_QUALIFIER_NONE,
+ TYPE_QUALIFIER_CONST
+};
+
+enum function_specifier
+{
+ FUNCTION_SPECIFIER_NONE,
+ FUNCTION_SPECIFIER_INLINE,
+};
+
enum statement_type
{
STMT_LIBRARY,
@@ -293,11 +306,20 @@ struct str_list_entry_t
struct list entry;
};
+struct _decl_spec_t
+{
+ type_t *type;
+ enum storage_class stgclass;
+ enum type_qualifier typequalifier;
+ enum function_specifier funcspecifier;
+};
+
struct _attr_t {
enum attr_type type;
union {
unsigned int ival;
void *pval;
+ struct _decl_spec_t dsval;
} u;
/* parser-internal */
struct list entry;
@@ -356,7 +378,7 @@ struct array_details
{
expr_t *size_is;
expr_t *length_is;
- struct _type_t *elem;
+ struct _decl_spec_t elem;
unsigned int dim;
unsigned char ptr_def_fc;
unsigned char declptr; /* if declared as a pointer */
@@ -376,16 +398,21 @@ struct basic_details
struct pointer_details
{
- struct _type_t *ref;
+ struct _decl_spec_t ref;
unsigned char def_fc;
};
struct bitfield_details
{
- struct _type_t *field;
+ struct _decl_spec_t field;
const expr_t *bits;
};
+struct typedef_details
+{
+ struct _decl_spec_t aliasee;
+};
+
#define HASHMAX 64
struct namespace {
@@ -431,9 +458,9 @@ struct _type_t {
struct basic_details basic;
struct pointer_details pointer;
struct bitfield_details bitfield;
+ struct typedef_details alias;
} details;
const char *c_name;
- type_t *orig; /* dup'd types */
unsigned int typestring_offset;
unsigned int ptrdesc; /* used for complex structs */
int typelib_idx;
@@ -449,10 +476,9 @@ struct _type_t {
struct _var_t {
char *name;
- type_t *type;
+ decl_spec_t declspec;
attr_list_t *attrs;
expr_t *eval;
- enum storage_class stgclass;
unsigned int procstring_offset;
unsigned int typestring_offset;
@@ -596,8 +622,8 @@ static inline enum type_type type_get_type_detect_alias(const type_t *type)
#define STATEMENTS_FOR_EACH_FUNC(stmt, stmts) \
if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, statement_t, entry ) \
- if (stmt->type == STMT_DECLARATION && stmt->u.var->stgclass == STG_NONE && \
- type_get_type_detect_alias(stmt->u.var->type) == TYPE_FUNCTION)
+ if (stmt->type == STMT_DECLARATION && stmt->u.var->declspec.stgclass == STG_NONE && \
+ type_get_type_detect_alias(stmt->u.var->declspec.type) == TYPE_FUNCTION)
static inline int statements_has_func(const statement_list_t *stmts)
{
@@ -616,4 +642,13 @@ static inline int is_global_namespace(const struct namespace *namespace)
return !namespace->name;
}
+static inline decl_spec_t* init_declspec(decl_spec_t *declspec, type_t *type)
+{
+ declspec->type = type;
+ declspec->stgclass=STG_NONE;
+ declspec->typequalifier=TYPE_QUALIFIER_NONE;
+ declspec->funcspecifier=FUNCTION_SPECIFIER_NONE;
+ return declspec;
+}
+
#endif
diff --git a/tools/widl/write_msft.c b/tools/widl/write_msft.c
index 4dcbc03702..ad82327e98 100644
--- a/tools/widl/write_msft.c
+++ b/tools/widl/write_msft.c
@@ -862,8 +862,8 @@ static int encode_type(
case VT_PTR:
{
int next_vt;
- for(next_vt = 0; is_ptr(type); type = type_pointer_get_ref(type)) {
- next_vt = get_type_vt(type_pointer_get_ref(type));
+ for(next_vt = 0; is_ptr(type); type = type_pointer_get_ref_type(type)) {
+ next_vt = get_type_vt(type_pointer_get_ref_type(type));
if (next_vt != 0)
break;
}
@@ -871,7 +871,7 @@ static int encode_type(
if (next_vt == 0)
next_vt = VT_VOID;
- encode_type(typelib, next_vt, type_pointer_get_ref(type),
+ encode_type(typelib, next_vt, type_pointer_get_ref_type(type),
&target_type, &child_size);
/* these types already have an implicit pointer, so we don't need to
* add another */
@@ -912,10 +912,10 @@ static int encode_type(
case VT_SAFEARRAY:
{
- type_t *element_type = type_alias_get_aliasee(type_array_get_element(type));
+ type_t *element_type = type_alias_get_aliasee_type(type_array_get_element_type(type));
int next_vt = get_type_vt(element_type);
- encode_type(typelib, next_vt, type_alias_get_aliasee(type_array_get_element(type)),
+ encode_type(typelib, next_vt, type_alias_get_aliasee_type(type_array_get_element_type(type)),
&target_type, &child_size);
for (typeoffset = 0; typeoffset < typelib->typelib_segdir[MSFT_SEG_TYPEDESC].length; typeoffset += 8) {
@@ -968,7 +968,7 @@ static int encode_type(
{
/* typedef'd types without public attribute aren't included in the typelib */
while (type_is_alias(type) && !is_attr(type->attrs, ATTR_PUBLIC))
- type = type_alias_get_aliasee(type);
+ type = type_alias_get_aliasee_type(type);
chat("encode_type: VT_USERDEFINED - adding new type %s, real type %d\n",
type->name, type_get_type(type));
@@ -1056,7 +1056,7 @@ static int encode_var(
num_dims = 0;
for (atype = type;
is_array(atype) && !type_array_is_decl_as_ptr(atype);
- atype = type_array_get_element(atype))
+ atype = type_array_get_element_type(atype))
++num_dims;
chat("array with %d dimensions\n", num_dims);
@@ -1071,7 +1071,7 @@ static int encode_var(
arraydata += 2;
for (atype = type;
is_array(atype) && !type_array_is_decl_as_ptr(atype);
- atype = type_array_get_element(atype))
+ atype = type_array_get_element_type(atype))
{
arraydata[0] = type_array_get_dim(atype);
arraydata[1] = 0;
@@ -1093,7 +1093,7 @@ static int encode_var(
vt = get_type_vt(type);
if (vt == VT_PTR) {
type_t *ref = is_ptr(type) ?
- type_pointer_get_ref(type) : type_array_get_element(type);
+ type_pointer_get_ref_type(type) : type_array_get_element_type(type);
int skip_ptr = encode_var(typelib, ref, var, &target_type, &child_size);
if(skip_ptr == 2) {
@@ -1114,7 +1114,7 @@ static int encode_var(
if (target_type & 0x80000000) {
mix_field = ((target_type >> 16) & 0x3fff) | VT_BYREF;
} else if (get_type_vt(ref) == VT_SAFEARRAY) {
- type_t *element_type = type_alias_get_aliasee(type_array_get_element(ref));
+ type_t *element_type = type_alias_get_aliasee_type(type_array_get_element_type(ref));
mix_field = get_type_vt(element_type) | VT_ARRAY | VT_BYREF;
} else {
typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][target_type];
@@ -1204,7 +1204,7 @@ static void write_default_value(msft_typelib_t *typelib, type_t *type, expr_t *e
if (type_get_type(type) == TYPE_ENUM) {
vt = VT_I4;
} else if (is_ptr(type)) {
- vt = get_type_vt(type_pointer_get_ref(type));
+ vt = get_type_vt(type_pointer_get_ref_type(type));
if (vt == VT_USERDEFINED)
vt = VT_I4;
if (expr->cval)
@@ -1301,8 +1301,8 @@ static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, var_t *func, int index)
return S_FALSE;
}
- if (type_get_function_args(func->type))
- LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->type), var_t, entry )
+ if (type_get_function_args(func->declspec.type))
+ LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->declspec.type), var_t, entry )
{
num_params++;
if (arg->attrs) LIST_FOR_EACH_ENTRY( attr, arg->attrs, const attr_t, entry ) {
@@ -1444,7 +1444,7 @@ static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, var_t *func, int index)
/* fill out the basic type information */
typedata[0] = typedata_size | (index << 16);
- encode_var(typeinfo->typelib, type_function_get_rettype(func->type), func,
+ encode_var(typeinfo->typelib, type_function_get_rettype(func->declspec.type), func,
&typedata[1], &decoded_size);
typedata[2] = funcflags;
typedata[3] = ((52 /*sizeof(FUNCDESC)*/ + decoded_size) << 16) | typeinfo->typeinfo->cbSizeVft;
@@ -1471,10 +1471,10 @@ static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, var_t *func, int index)
warning("unknown number of optional attrs\n");
}
- if (type_get_function_args(func->type))
+ if (type_get_function_args(func->declspec.type))
{
i = 0;
- LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->type), var_t, entry )
+ LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->declspec.type), var_t, entry )
{
int paramflags = 0;
int *paramdata = typedata + 6 + extra_attr + (num_defaults ? num_params : 0) + i * 3;
@@ -1482,13 +1482,13 @@ static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, var_t *func, int index)
if(defaultdata) *defaultdata = -1;
- encode_var(typeinfo->typelib, arg->type, arg, paramdata, &decoded_size);
+ encode_var(typeinfo->typelib, arg->declspec.type, arg, paramdata, &decoded_size);
if (arg->attrs) LIST_FOR_EACH_ENTRY( attr, arg->attrs, const attr_t, entry ) {
switch(attr->type) {
case ATTR_DEFAULTVALUE:
{
paramflags |= 0x30; /* PARAMFLAG_FHASDEFAULT | PARAMFLAG_FOPT */
- write_default_value(typeinfo->typelib, arg->type, (expr_t *)attr->u.pval, defaultdata);
+ write_default_value(typeinfo->typelib, arg->declspec.type, (expr_t *)attr->u.pval, defaultdata);
break;
}
case ATTR_IN:
@@ -1572,10 +1572,10 @@ static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, var_t *func, int index)
if(typeinfo->typekind == TKIND_MODULE)
namedata[9] |= 0x20;
- if (type_get_function_args(func->type))
+ if (type_get_function_args(func->declspec.type))
{
i = 0;
- LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->type), var_t, entry )
+ LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->declspec.type), var_t, entry )
{
/* don't give the last arg of a [propput*] func a name */
if(i != num_params - 1 || (invokekind != 0x4 /* INVOKE_PROPERTYPUT */ && invokekind != 0x8 /* INVOKE_PROPERTYPUTREF */))
@@ -1697,8 +1697,8 @@ static HRESULT add_var_desc(msft_typeinfo_t *typeinfo, UINT index, var_t* var)
typeinfo->var_offsets[var_num] = offset;
/* figure out type widths and whatnot */
- var_datawidth = type_memsize_and_alignment(var->type, &var_alignment);
- encode_var(typeinfo->typelib, var->type, var, &typedata[1], &var_type_size);
+ var_datawidth = type_memsize_and_alignment(var->declspec.type, &var_alignment);
+ encode_var(typeinfo->typelib, var->declspec.type, var, &typedata[1], &var_type_size);
/* pad out starting position to data width */
typeinfo->datawidth += var_alignment - 1;
@@ -2181,7 +2181,7 @@ static void add_typedef_typeinfo(msft_typelib_t *typelib, type_t *tdef)
if (-1 < tdef->typelib_idx)
return;
- type = type_alias_get_aliasee(tdef);
+ type = type_alias_get_aliasee_type(tdef);
if (!type->name || strcmp(tdef->name, type->name) != 0)
{
@@ -2364,7 +2364,7 @@ static void add_entry(msft_typelib_t *typelib, const statement_t *stmt)
if (is_attr(type_entry->type->attrs, ATTR_PUBLIC))
add_typedef_typeinfo(typelib, type_entry->type);
else
- add_type_typeinfo(typelib, type_alias_get_aliasee(type_entry->type));
+ add_type_typeinfo(typelib, type_alias_get_aliasee_type(type_entry->type));
}
break;
}
--
2.17.1
More information about the wine-devel
mailing list