ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

widl: Convert variable lists to standard Wine lists.

This commit is contained in:
Alexandre Julliard 2007-01-22 14:26:12 +01:00
parent 58827d026b
commit eed74e4e4a
9 changed files with 278 additions and 339 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
tools/widl/client.c
View File

@ -65,16 +65,13 @@ static void print_message_buffer_size(const func_t *func)
if (func->args)
{
const var_t *var = func->args;
while (NEXT_LINK(var)) var = NEXT_LINK(var);
while (var)
const var_t *var;
LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
{
unsigned int alignment;
total_size += get_required_buffer_size(var, &alignment, PASS_IN);
total_size += alignment;
var = PREV_LINK(var);
}
}
fprintf(client, " %u", total_size);
@ -82,14 +79,12 @@ static void print_message_buffer_size(const func_t *func)
static void check_pointers(const func_t *func)
{
var_t *var;
const var_t *var;
if (!func->args)
return;
var = func->args;
while (NEXT_LINK(var)) var = NEXT_LINK(var);
while (var)
LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
{
if (is_var_ptr(var) && cant_be_null(var))
{
@ -100,8 +95,6 @@ static void check_pointers(const func_t *func)
indent--;
print_client("}\n\n");
}
var = PREV_LINK(var);
}
}
@ -110,7 +103,7 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset, unsig
const func_t *func;
const char *implicit_handle = get_attrp(iface->attrs, ATTR_IMPLICIT_HANDLE);
int explicit_handle = is_attr(iface->attrs, ATTR_EXPLICIT_HANDLE);
var_t *var;
const var_t *var;
int method_count = 0;
if (iface->funcs) LIST_FOR_EACH_ENTRY( func, iface->funcs, const func_t, entry )
@ -259,13 +252,8 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset, unsig
/* update proc_offset */
if (func->args)
{
var = func->args;
while (NEXT_LINK(var)) var = NEXT_LINK(var);
while (var)
{
LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
*proc_offset += get_size_procformatstring_var(var);
var = PREV_LINK(var);
}
}
if (!is_void(def->type, NULL))
*proc_offset += get_size_procformatstring_var(def);

87
tools/widl/header.c
View File

@ -164,23 +164,19 @@ static void write_field(FILE *h, var_t *v)
}
}
static void write_fields(FILE *h, var_t *v)
static void write_fields(FILE *h, var_list_t *fields)
{
var_t *first = v;
if (!v) return;
while (NEXT_LINK(v)) v = NEXT_LINK(v);
while (v) {
write_field(h, v);
if (v == first) break;
v = PREV_LINK(v);
}
var_t *v;
if (!fields) return;
LIST_FOR_EACH_ENTRY( v, fields, var_t, entry ) write_field(h, v);
}
static void write_enums(FILE *h, var_t *v)
static void write_enums(FILE *h, var_list_t *enums)
{
if (!v) return;
while (NEXT_LINK(v)) v = NEXT_LINK(v);
while (v) {
var_t *v;
if (!enums) return;
LIST_FOR_EACH_ENTRY( v, enums, var_t, entry )
{
if (get_name(v)) {
indent(h, 0);
write_name(h, v);
@ -189,9 +185,7 @@ static void write_enums(FILE *h, var_t *v)
write_expr(h, v->eval, 0);
}
}
if (PREV_LINK(v))
fprintf(h, ",\n");
v = PREV_LINK(v);
if (list_next( enums, &v->entry )) fprintf(h, ",\n");
}
fprintf(h, "\n");
}
@ -292,9 +286,13 @@ static int user_type_registered(const char *name)
return 0;
}
static void check_for_user_types(const var_t *v)
static void check_for_user_types(const var_list_t *list)
{
while (v) {
const var_t *v;
if (!list) return;
LIST_FOR_EACH_ENTRY( v, list, const var_t, entry )
{
type_t *type;
for (type = v->type; type; type = type->kind == TKIND_ALIAS ? type->orig : type->ref) {
const char *name = type->name;
@ -312,14 +310,11 @@ static void check_for_user_types(const var_t *v)
* using a wire marshaled type */
break;
}
else if (type->fields)
else
{
const var_t *fields = type->fields;
while (NEXT_LINK(fields)) fields = NEXT_LINK(fields);
check_for_user_types(fields);
check_for_user_types(type->fields);
}
}
v = PREV_LINK(v);
}
}
@ -456,22 +451,16 @@ const var_t* get_explicit_handle_var(const func_t* func)
if (!func->args)
return NULL;
var = func->args;
while (NEXT_LINK(var)) var = NEXT_LINK(var);
while (var)
{
LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
if (var->type->type == RPC_FC_BIND_PRIMITIVE)
return var;
var = PREV_LINK(var);
}
return NULL;
}
int has_out_arg_or_return(const func_t *func)
{
var_t *var;
const var_t *var;
if (!is_void(func->def->type, NULL))
return 1;
@ -479,15 +468,10 @@ int has_out_arg_or_return(const func_t *func)
if (!func->args)
return 0;
var = func->args;
while (NEXT_LINK(var)) var = NEXT_LINK(var);
while (var)
{
LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
if (is_attr(var->attrs, ATTR_OUT))
return 1;
var = PREV_LINK(var);
}
return 0;
}
@ -525,13 +509,11 @@ static void write_method_macro(const type_t *iface, const char *name)
{
var_t *def = cur->def;
if (!is_callas(def->attrs)) {
var_t *arg = cur->args;
const var_t *arg;
int argc = 0;
int c;
while (arg) {
arg = NEXT_LINK(arg);
argc++;
}
if (cur->args) LIST_FOR_EACH_ENTRY( arg, cur->args, const var_t, entry ) argc++;
fprintf(header, "#define %s_", name);
write_name(header,def);
@ -550,13 +532,11 @@ static void write_method_macro(const type_t *iface, const char *name)
}
}
void write_args(FILE *h, var_t *arg, const char *name, int method, int do_indent)
void write_args(FILE *h, const var_list_t *args, const char *name, int method, int do_indent)
{
const var_t *arg;
int count = 0;
if (arg) {
while (NEXT_LINK(arg))
arg = NEXT_LINK(arg);
}
if (do_indent)
{
indentation++;
@ -566,7 +546,7 @@ void write_args(FILE *h, var_t *arg, const char *name, int method, int do_indent
fprintf(h, "%s* This", name);
count++;
}
while (arg) {
if (args) LIST_FOR_EACH_ENTRY( arg, args, const var_t, entry ) {
if (count) {
if (do_indent)
{
@ -591,7 +571,6 @@ void write_args(FILE *h, var_t *arg, const char *name, int method, int do_indent
write_name(h, arg);
}
write_array(h, arg->array, 0);
arg = PREV_LINK(arg);
count++;
}
if (do_indent) indentation--;
@ -664,7 +643,7 @@ static void write_method_proto(const type_t *iface)
{
const var_t *def = cur->def;
const var_t *cas = is_callas(def->attrs);
const var_t *args;
if (!is_local(def->attrs)) {
/* proxy prototype */
write_type(header, def->type, def, def->tname);
@ -681,13 +660,7 @@ static void write_method_proto(const type_t *iface)
fprintf(header, " IRpcChannelBuffer* pRpcChannelBuffer,\n");
fprintf(header, " PRPC_MESSAGE pRpcMessage,\n");
fprintf(header, " DWORD* pdwStubPhase);\n");
args = cur->args;
if (args) {
while (NEXT_LINK(args))
args = NEXT_LINK(args);
}
check_for_user_types(args);
check_for_user_types(cur->args);
}
if (cas) {
const func_t *m;

2
tools/widl/header.h
View File

@ -31,7 +31,7 @@ extern void write_type(FILE *h, type_t *t, const var_t *v, const char *n);
extern int is_object(const attr_list_t *list);
extern int is_local(const attr_list_t *list);
extern const var_t *is_callas(const attr_list_t *list);
extern void write_args(FILE *h, var_t *arg, const char *name, int obj, int do_indent);
extern void write_args(FILE *h, const var_list_t *arg, const char *name, int obj, int do_indent);
extern void write_array(FILE *h, const expr_t *v, int field);
extern void write_forward(type_t *iface);
extern void write_interface(type_t *iface);

113
tools/widl/parser.y
View File

@ -82,21 +82,22 @@ static type_t *type_ref(typeref_t *ref);
static void set_type(var_t *v, typeref_t *ref, expr_t *arr);
static ifref_list_t *append_ifref(ifref_list_t *list, ifref_t *iface);
static ifref_t *make_ifref(type_t *iface);
static var_list_t *append_var(var_list_t *list, var_t *var);
static var_t *make_var(char *name);
static func_list_t *append_func(func_list_t *list, func_t *func);
static func_t *make_func(var_t *def, var_t *args);
static func_t *make_func(var_t *def, var_list_t *args);
static type_t *make_class(char *name);
static type_t *make_safearray(void);
static type_t *make_builtin(char *name);
static type_t *make_int(int sign);
static type_t *reg_type(type_t *type, const char *name, int t);
static type_t *reg_typedefs(type_t *type, var_t *names, attr_list_t *attrs);
static type_t *reg_typedefs(type_t *type, var_list_t *names, attr_list_t *attrs);
static type_t *find_type(const char *name, int t);
static type_t *find_type2(char *name, int t);
static type_t *get_type(unsigned char type, char *name, int t);
static type_t *get_typev(unsigned char type, var_t *name, int t);
static int get_struct_type(var_t *fields);
static int get_struct_type(var_list_t *fields);
static var_t *reg_const(var_t *var);
static var_t *find_const(char *name, int f);
@ -108,7 +109,7 @@ static void write_iid(type_t *iface);
static int compute_method_indexes(type_t *iface);
static char *gen_name(void);
static void process_typedefs(var_t *names);
static void process_typedefs(var_list_t *names);
static void check_arg(var_t *arg);
#define tsENUM 1
@ -123,6 +124,7 @@ static void check_arg(var_t *arg);
type_t *type;
typeref_t *tref;
var_t *var;
var_list_t *var_list;
func_t *func;
func_list_t *func_list;
ifref_t *ifref;
@ -227,10 +229,9 @@ static void check_arg(var_t *arg);
%type <ifref> coclass_int
%type <ifref_list> gbl_statements coclass_ints
%type <tref> type
%type <var> m_args no_args args arg
%type <var> fields field s_field cases case enums enum_list enum constdef externdef
%type <var> m_ident t_ident ident p_ident pident pident_list
%type <var> dispint_props
%type <var> arg field s_field case enum constdef externdef
%type <var_list> m_args no_args args fields cases enums enum_list pident_list dispint_props
%type <var> m_ident t_ident ident p_ident pident
%type <func> funcdef
%type <func_list> int_statements dispint_meths
%type <type> coclass coclasshdr coclassdef
@ -328,8 +329,8 @@ m_args: { $$ = NULL; }
no_args: tVOID { $$ = NULL; }
;
args: arg { check_arg($1); $$ = $1; }
| args ',' arg { check_arg($3); LINK($3, $1); $$ = $3; }
args: arg { check_arg($1); $$ = append_var( NULL, $1 ); }
| args ',' arg { check_arg($3); $$ = append_var( $1, $3); }
| no_args
;
@ -457,9 +458,7 @@ callconv:
;
cases: { $$ = NULL; }
| cases case { if ($2) { LINK($2, $1); $$ = $2; }
else { $$ = $1; }
}
| cases case { $$ = append_var( $1, $2 ); }
;
case: tCASE expr ':' field { attr_t *a = make_attrp(ATTR_CASE, $2);
@ -483,12 +482,16 @@ enums: { $$ = NULL; }
| enum_list
;
enum_list: enum { if (!$$->eval)
$$->eval = make_exprl(EXPR_NUM, 0 /* default for first enum entry */);
enum_list: enum { if (!$1->eval)
$1->eval = make_exprl(EXPR_NUM, 0 /* default for first enum entry */);
$$ = append_var( NULL, $1 );
}
| enum_list ',' enum { LINK($3, $1); $$ = $3;
if (!$$->eval)
$$->eval = make_exprl(EXPR_NUM, $1->eval->cval + 1);
| enum_list ',' enum { if (!$3->eval)
{
var_t *last = LIST_ENTRY( list_tail($$), var_t, entry );
$3->eval = make_exprl(EXPR_NUM, last->eval->cval + 1);
}
$$ = append_var( $1, $3 );
}
;
@ -566,9 +569,7 @@ externdef: tEXTERN tCONST type ident { $$ = $4;
;
fields: { $$ = NULL; }
| fields field { if ($2) { LINK($2, $1); $$ = $2; }
else { $$ = $1; }
}
| fields field { $$ = append_var( $1, $2 ); }
;
field: s_field ';' { $$ = $1; }
@ -702,7 +703,7 @@ dispinterfacehdr: attributes dispinterface { attr_t *attrs;
;
dispint_props: tPROPERTIES ':' { $$ = NULL; }
| dispint_props s_field ';' { LINK($2, $1); $$ = $2; }
| dispint_props s_field ';' { $$ = append_var( $1, $2 ); }
;
dispint_meths: tMETHODS ':' { $$ = NULL; }
@ -795,8 +796,8 @@ pident: ident
;
pident_list:
pident
| pident_list ',' pident { LINK($3, $1); $$ = $3; }
pident { $$ = append_var( NULL, $1 ); }
| pident_list ',' pident { $$ = append_var( $1, $3 ); }
;
pointer_type:
@ -849,7 +850,8 @@ uniondef: tUNION t_ident '{' fields '}' { $$ = get_typev(RPC_FC_NON_ENCAPSULATE
u->type->kind = TKIND_UNION;
u->type->fields = $9;
u->type->defined = TRUE;
LINK(u, $5); $$->fields = u;
$$->fields = append_var( $$->fields, $5 );
$$->fields = append_var( $$->fields, u );
$$->defined = TRUE;
}
;
@ -1225,6 +1227,18 @@ static ifref_t *make_ifref(type_t *iface)
return l;
}
static var_list_t *append_var(var_list_t *list, var_t *var)
{
if (!var) return list;
if (!list)
{
list = xmalloc( sizeof(*list) );
list_init( list );
}
list_add_tail( list, &var->entry );
return list;
}
static var_t *make_var(char *name)
{
var_t *v = xmalloc(sizeof(var_t));
@ -1236,7 +1250,6 @@ static var_t *make_var(char *name)
v->attrs = NULL;
v->array = NULL;
v->eval = NULL;
INIT_LINK(v);
return v;
}
@ -1252,7 +1265,7 @@ static func_list_t *append_func(func_list_t *list, func_t *func)
return list;
}
static func_t *make_func(var_t *def, var_t *args)
static func_t *make_func(var_t *def, var_list_t *args)
{
func_t *f = xmalloc(sizeof(func_t));
f->def = def;
@ -1319,9 +1332,10 @@ static type_t *reg_type(type_t *type, const char *name, int t)
return type;
}
static type_t *reg_typedefs(type_t *type, var_t *names, attr_list_t *attrs)
static type_t *reg_typedefs(type_t *type, var_list_t *names, attr_list_t *attrs)
{
type_t *ptr = type;
const var_t *name;
int ptrc = 0;
int is_str = is_attr(attrs, ATTR_STRING);
unsigned char ptr_type = get_attrv(attrs, ATTR_POINTERTYPE);
@ -1336,8 +1350,11 @@ static type_t *reg_typedefs(type_t *type, var_t *names, attr_list_t *attrs)
c = t->type;
if (c != RPC_FC_CHAR && c != RPC_FC_BYTE && c != RPC_FC_WCHAR)
{
name = LIST_ENTRY( list_head( names ), const var_t, entry );
yyerror("'%s': [string] attribute is only valid on 'char', 'byte', or 'wchar_t' pointers and arrays",
names->name);
name->name);
}
}
/* We must generate names for tagless enum, struct or union.
@ -1352,11 +1369,11 @@ static type_t *reg_typedefs(type_t *type, var_t *names, attr_list_t *attrs)
type->name = gen_name();
}
while (names) {
var_t *next = NEXT_LINK(names);
if (names->name) {
LIST_FOR_EACH_ENTRY( name, names, const var_t, entry )
{
if (name->name) {
type_t *cur = ptr;
int cptr = names->ptr_level;
int cptr = name->ptr_level;
if (cptr > ptrc) {
while (cptr > ptrc) {
cur = ptr = make_type(RPC_FC_RP, cur);
@ -1368,7 +1385,7 @@ static type_t *reg_typedefs(type_t *type, var_t *names, attr_list_t *attrs)
cptr++;
}
}
cur = alias(cur, names->name);
cur = alias(cur, name->name);
cur->attrs = attrs;
if (ptr_type)
{
@ -1384,7 +1401,6 @@ static type_t *reg_typedefs(type_t *type, var_t *names, attr_list_t *attrs)
reg_type(cur, cur->name, 0);
}
names = next;
}
return type;
}
@ -1446,13 +1462,14 @@ static type_t *get_typev(unsigned char type, var_t *name, int t)
return get_type(type, sname, t);
}
static int get_struct_type(var_t *field)
static int get_struct_type(var_list_t *fields)
{
int has_pointer = 0;
int has_conformance = 0;
int has_variance = 0;
var_t *field;
for (; field; field = NEXT_LINK(field))
if (fields) LIST_FOR_EACH_ENTRY( field, fields, var_t, entry )
{
type_t *t = field->type;
@ -1474,7 +1491,7 @@ static int get_struct_type(var_t *field)
if (field->array && !field->array->is_const)
{
has_conformance = 1;
if (PREV_LINK(field))
if (list_next( fields, &field->entry ))
yyerror("field '%s' deriving from a conformant array must be the last field in the structure",
field->name);
}
@ -1518,7 +1535,7 @@ static int get_struct_type(var_t *field)
break;
case RPC_FC_CARRAY:
has_conformance = 1;
if (PREV_LINK(field))
if (list_next( fields, &field->entry ))
yyerror("field '%s' deriving from a conformant array must be the last field in the structure",
field->name);
break;
@ -1535,7 +1552,7 @@ static int get_struct_type(var_t *field)
case RPC_FC_CPSTRUCT:
has_conformance = 1;
if (PREV_LINK(field))
if (list_next( fields, &field->entry ))
yyerror("field '%s' deriving from a conformant array must be the last field in the structure",
field->name);
has_pointer = 1;
@ -1543,7 +1560,7 @@ static int get_struct_type(var_t *field)
case RPC_FC_CSTRUCT:
has_conformance = 1;
if (PREV_LINK(field))
if (list_next( fields, &field->entry ))
yyerror("field '%s' deriving from a conformant array must be the last field in the structure",
field->name);
break;
@ -1689,21 +1706,21 @@ static char *gen_name(void)
return name;
}
static void process_typedefs(var_t *names)
static void process_typedefs(var_list_t *names)
{
END_OF_LIST(names);
while (names)
var_t *name, *next;
if (!names) return;
LIST_FOR_EACH_ENTRY_SAFE( name, next, names, var_t, entry )
{
var_t *next = PREV_LINK(names);
type_t *type = find_type(names->name, 0);
type_t *type = find_type(name->name, 0);
if (! parse_only && do_header)
write_typedef(type);
if (in_typelib && type->attrs)
add_typelib_entry(type);
free(names);
names = next;
free(name);
}
}

149
tools/widl/proxy.c
View File

@ -106,26 +106,28 @@ static void init_proxy(ifref_list_t *ifaces)
write_stubdescproto();
}
static void clear_output_vars( var_t *arg )
static void clear_output_vars( const var_list_t *args )
{
END_OF_LIST(arg);
while (arg) {
const var_t *arg;
if (!args) return;
LIST_FOR_EACH_ENTRY( arg, args, const var_t, entry )
{
if (is_attr(arg->attrs, ATTR_OUT) && !is_attr(arg->attrs, ATTR_IN)) {
print_proxy( "if(%s)\n", arg->name );
indent++;
print_proxy( "MIDL_memset( %s, 0, sizeof( *%s ));\n", arg->name, arg->name );
indent--;
}
arg = PREV_LINK(arg);
}
}
int is_var_ptr(var_t *v)
int is_var_ptr(const var_t *v)
{
return v->ptr_level || is_ptr(v->type);
}
int cant_be_null(var_t *v)
int cant_be_null(const var_t *v)
{
/* Search backwards for the most recent pointer attribute. */
const attr_list_t *attrs = v->attrs;
@ -159,7 +161,7 @@ int cant_be_null(var_t *v)
return 1; /* Default is RPC_FC_RP. */
}
static int is_user_derived(var_t *v)
static int is_user_derived(const var_t *v)
{
const attr_list_t *attrs = v->attrs;
const type_t *type = v->type;
@ -187,21 +189,23 @@ static int is_user_derived(var_t *v)
return 0;
}
static void proxy_check_pointers( var_t *arg )
static void proxy_check_pointers( const var_list_t *args )
{
END_OF_LIST(arg);
while (arg) {
const var_t *arg;
if (!args) return;
LIST_FOR_EACH_ENTRY( arg, args, const var_t, entry )
{
if (is_var_ptr(arg) && cant_be_null(arg)) {
print_proxy( "if(!%s)\n", arg->name );
indent++;
print_proxy( "RpcRaiseException(RPC_X_NULL_REF_POINTER);\n");
indent--;
}
arg = PREV_LINK(arg);
}
}
static void marshall_size_arg( var_t *arg )
static void marshall_size_arg( const var_t *arg )
{
int index = 0;
const type_t *type = arg->type;
@ -289,22 +293,23 @@ static void marshall_size_arg( var_t *arg )
}
}
static void proxy_gen_marshall_size( var_t *arg )
static void proxy_gen_marshall_size( const var_list_t *args )
{
print_proxy( "_StubMsg.BufferLength = 0U;\n" );
const var_t *arg;
END_OF_LIST(arg);
while (arg) {
if (is_attr(arg->attrs, ATTR_IN))
print_proxy( "_StubMsg.BufferLength = 0U;\n" );
if (!args) return;
LIST_FOR_EACH_ENTRY( arg, args, const var_t, entry )
{
if (is_attr(arg->attrs, ATTR_IN))
{
marshall_size_arg( arg );
fprintf(proxy, "\n");
}
arg = PREV_LINK(arg);
}
}
static void marshall_copy_arg( var_t *arg )
static void marshall_copy_arg( const var_t *arg )
{
int index = 0;
type_t *type = arg->type;
@ -390,34 +395,36 @@ static void marshall_copy_arg( var_t *arg )
}
}
static void gen_marshall_copydata( var_t *arg )
static void gen_marshall_copydata( const var_list_t *args )
{
END_OF_LIST(arg);
while (arg) {
if (is_attr(arg->attrs, ATTR_IN))
const var_t *arg;
if (!args) return;
LIST_FOR_EACH_ENTRY( arg, args, const var_t, entry )
{
if (is_attr(arg->attrs, ATTR_IN))
{
marshall_copy_arg( arg );
fprintf(proxy, "\n");
}
arg = PREV_LINK(arg);
}
}
static void gen_marshall( var_t *arg )
static void gen_marshall( const var_list_t *args )
{
/* generated code to determine the size of the buffer required */
proxy_gen_marshall_size( arg );
proxy_gen_marshall_size( args );
/* generated code to allocate the buffer */
print_proxy( "NdrProxyGetBuffer(This, &_StubMsg);\n" );
/* generated code to copy the args into the buffer */
gen_marshall_copydata( arg );
gen_marshall_copydata( args );
print_proxy( "\n");
}
static void unmarshall_copy_arg( var_t *arg )
static void unmarshall_copy_arg( const var_t *arg )
{
int index = 0;
type_t *type = arg->type;
@ -501,20 +508,22 @@ static void unmarshall_copy_arg( var_t *arg )
}
}
static void gen_unmarshall( var_t *arg )
static void gen_unmarshall( var_list_t *args )
{
END_OF_LIST(arg);
while (arg) {
if (is_attr(arg->attrs, ATTR_OUT))
const var_t *arg;
if (!args) return;
LIST_FOR_EACH_ENTRY( arg, args, const var_t, entry )
{
if (is_attr(arg->attrs, ATTR_OUT))
{
unmarshall_copy_arg( arg );
fprintf(proxy, "\n");
}
arg = PREV_LINK(arg);
}
}
static void free_variable( var_t *arg )
static void free_variable( const var_t *arg )
{
var_t *constraint;
int index = 0; /* FIXME */
@ -563,16 +572,18 @@ static void free_variable( var_t *arg )
}
}
static void proxy_free_variables( var_t *arg )
static void proxy_free_variables( var_list_t *args )
{
END_OF_LIST(arg);
while (arg) {
if (is_attr(arg->attrs, ATTR_OUT))
const var_t *arg;
if (!args) return;
LIST_FOR_EACH_ENTRY( arg, args, const var_t, entry )
{
if (is_attr(arg->attrs, ATTR_OUT))
{
free_variable( arg );
fprintf(proxy, "\n");
}
arg = PREV_LINK(arg);
}
}
@ -670,11 +681,14 @@ static void gen_proxy(type_t *iface, const func_t *cur, int idx)
print_proxy( "\n");
}
static void stub_write_locals( var_t *arg )
static void stub_write_locals( var_list_t *args )
{
int n = 0;
END_OF_LIST(arg);
while (arg) {
const var_t *arg;
if (!args) return;
LIST_FOR_EACH_ENTRY( arg, args, const var_t, entry )
{
int outptr = is_attr(arg->attrs, ATTR_OUT)
&& ! is_attr(arg->attrs, ATTR_IN);
@ -692,15 +706,17 @@ static void stub_write_locals( var_t *arg )
fprintf(proxy, " ");
write_name(proxy, arg);
fprintf(proxy, ";\n");
arg = PREV_LINK(arg);
}
}
static void stub_unmarshall( var_t *arg )
static void stub_unmarshall( const var_list_t *args )
{
int n = 0;
END_OF_LIST(arg);
while (arg) {
const var_t *arg;
if (!args) return;
LIST_FOR_EACH_ENTRY( arg, args, const var_t, entry )
{
if (is_attr(arg->attrs, ATTR_IN))
{
unmarshall_copy_arg( arg );
@ -726,33 +742,32 @@ static void stub_unmarshall( var_t *arg )
break;
}
}
arg = PREV_LINK(arg);
}
}
static void stub_gen_marshall_size( var_t *arg )
static void stub_gen_marshall_size( const var_list_t *args )
{
const var_t *arg;
print_proxy( "_StubMsg.BufferLength = 0U;\n" );
END_OF_LIST(arg);
while (arg) {
if (!args) return;
LIST_FOR_EACH_ENTRY( arg, args, const var_t, entry )
if (is_attr(arg->attrs, ATTR_OUT))
marshall_size_arg( arg );
arg = PREV_LINK(arg);
}
}
static void stub_gen_marshall_copydata( var_t *arg )
static void stub_gen_marshall_copydata( const var_list_t *args )
{
END_OF_LIST(arg);
while (arg) {
const var_t *arg;
if (!args) return;
LIST_FOR_EACH_ENTRY( arg, args, const var_t, entry )
if (is_attr(arg->attrs, ATTR_OUT))
marshall_copy_arg( arg );
arg = PREV_LINK(arg);
}
}
static void stub_genmarshall( var_t *args )
static void stub_genmarshall( const var_list_t *args )
{
/* FIXME: size buffer */
stub_gen_marshall_size( args );
@ -765,7 +780,7 @@ static void stub_genmarshall( var_t *args )
static void gen_stub(type_t *iface, const func_t *cur, const char *cas)
{
var_t *def = cur->def;
var_t *arg;
const var_t *arg;
int has_ret = !is_void(def->type, def);
indent = 0;
@ -816,14 +831,14 @@ static void gen_stub(type_t *iface, const func_t *cur, const char *cas)
if (cas) fprintf(proxy, "%s_Stub", cas);
else write_name(proxy, def);
fprintf(proxy, "(_This");
arg = cur->args;
if (arg) {
END_OF_LIST(arg);
while (arg) {
fprintf(proxy, ", ");
write_name(proxy, arg);
arg = PREV_LINK(arg);
}
if (cur->args)
{
LIST_FOR_EACH_ENTRY( arg, cur->args, const var_t, entry )
{
fprintf(proxy, ", ");
write_name(proxy, arg);
}
}
fprintf(proxy, ");\n");
fprintf(proxy, "\n");

41
tools/widl/server.c
View File

@ -68,15 +68,10 @@ static void write_parameters_init(const func_t *func)
if (!func->args)
return;
var = func->args;
while (NEXT_LINK(var)) var = NEXT_LINK(var);
while (var)
{
LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
if (var->type->type != RPC_FC_BIND_PRIMITIVE)
print_server("%s = 0;\n", var->name);
var = PREV_LINK(var);
}
fprintf(server, "\n");
}
@ -85,14 +80,12 @@ static void declare_args(const func_t *func)
{
int in_attr, out_attr;
int i = 0;
var_t *var;
const var_t *var;
if (!func->args)
return;
var = func->args;
while (NEXT_LINK(var)) var = NEXT_LINK(var);
while (var)
LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
{
const expr_t *size_is = get_attrp(var->attrs, ATTR_SIZEIS);
int has_size = size_is && (size_is->type != EXPR_VOID);
@ -119,8 +112,6 @@ static void declare_args(const func_t *func)
write_name(server, var);
write_array(server, var->array, 0);
fprintf(server, ";\n");
var = PREV_LINK(var);
}
}
@ -129,16 +120,14 @@ static void assign_out_args(const func_t *func)
{
int in_attr, out_attr;
int i = 0, sep = 0;
var_t *var;
const var_t *var;
const expr_t *size_is;
int has_size;
if (!func->args)
return;
var = func->args;
while (NEXT_LINK(var)) var = NEXT_LINK(var);
while (var)
LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
{
int is_string = is_attr(var->attrs, ATTR_STRING);
size_is = get_attrp(var->attrs, ATTR_SIZEIS);
@ -173,8 +162,6 @@ static void assign_out_args(const func_t *func)
sep = 1;
}
var = PREV_LINK(var);
}
if (sep)
@ -319,9 +306,7 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset, unsig
fprintf(server, "(\n");
indent++;
var = func->args;
while (NEXT_LINK(var)) var = NEXT_LINK(var);
while (var)
LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
{
if (first_arg)
first_arg = 0;
@ -329,7 +314,6 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset, unsig
fprintf(server, ",\n");
print_server("");
write_name(server, var);
var = PREV_LINK(var);
}
fprintf(server, ");\n");
indent--;
@ -341,9 +325,7 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset, unsig
if (func->args)
{
const var_t *var = func->args;
while (NEXT_LINK(var)) var = NEXT_LINK(var);
while (var)
LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
{
if (is_attr(var->attrs, ATTR_OUT))
{
@ -351,8 +333,6 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset, unsig
buffer_size += get_required_buffer_size(var, &alignment, PASS_OUT);
buffer_size += alignment;
}
var = PREV_LINK(var);
}
}
@ -417,13 +397,8 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset, unsig
/* update proc_offset */
if (func->args)
{
var = func->args;
while (NEXT_LINK(var)) var = NEXT_LINK(var);
while (var)
{
LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
*proc_offset += get_size_procformatstring_var(var);
var = PREV_LINK(var);
}
}
if (!is_void(def->type, NULL))
*proc_offset += get_size_procformatstring_var(def);

130
tools/widl/typegen.c
View File

@ -60,7 +60,7 @@ struct expr_eval_routine
};
static size_t type_memsize(const type_t *t, int ptr_level, const expr_t *array);
static size_t fields_memsize(const var_t *v);
static size_t fields_memsize(const var_list_t *fields);
static int compare_expr(const expr_t *a, const expr_t *b)
{
@ -263,7 +263,7 @@ void write_procformatstring(FILE *file, const ifref_list_t *ifaces, int for_obje
{
const ifref_t *iface;
int indent = 0;
var_t *var;
const var_t *var;
unsigned int type_offset = 2;
print_file(file, indent, "static const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString =\n");
@ -286,15 +286,8 @@ void write_procformatstring(FILE *file, const ifref_list_t *ifaces, int for_obje
/* emit argument data */
if (func->args)
{
var = func->args;
while (NEXT_LINK(var)) var = NEXT_LINK(var);
while (var)
{
write_procformatstring_var(file, indent, var, FALSE,
&type_offset);
var = PREV_LINK(var);
}
LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
write_procformatstring_var(file, indent, var, FALSE, &type_offset);
}
/* emit return value data */
@ -399,7 +392,8 @@ static size_t write_conf_or_var_desc(FILE *file, const func_t *func, const type_
{
const var_t *var;
for (offset = 0, var = structure->fields; var; var = NEXT_LINK(var))
offset = 0;
if (structure->fields) LIST_FOR_EACH_ENTRY( var, structure->fields, const var_t, entry )
{
offset -= type_memsize(var->type, var->ptr_level, var->array);
if (!strcmp(var->name, subexpr->u.sval))
@ -416,17 +410,18 @@ static size_t write_conf_or_var_desc(FILE *file, const func_t *func, const type_
}
else
{
const var_t *var = func->args;
const var_t *var;
while (NEXT_LINK(var)) var = NEXT_LINK(var);
/* FIXME: not all stack variables are sizeof(void *) */
for (offset = 0; var; offset += sizeof(void *), var = PREV_LINK(var))
offset = 0;
if (func->args) LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
{
if (!strcmp(var->name, subexpr->u.sval))
{
correlation_variable = var->type;
break;
}
/* FIXME: not all stack variables are sizeof(void *) */
offset += sizeof(void *);
}
if (!correlation_variable)
error("write_conf_or_var_desc: couldn't find variable %s in function\n",
@ -530,17 +525,15 @@ static size_t write_conf_or_var_desc(FILE *file, const func_t *func, const type_
return 4;
}
static size_t fields_memsize(const var_t *v)
static size_t fields_memsize(const var_list_t *fields)
{
size_t size = 0;
const var_t *first = v;
if (!v) return 0;
while (NEXT_LINK(v)) v = NEXT_LINK(v);
while (v) {
const var_t *v;
if (!fields) return 0;
LIST_FOR_EACH_ENTRY( v, fields, const var_t, entry )
size += type_memsize(v->type, v->ptr_level, v->array);
if (v == first) break;
v = PREV_LINK(v);
}
return size;
}
@ -638,10 +631,8 @@ static int write_pointers(FILE *file, const attr_list_t *attrs,
case RPC_FC_CPSTRUCT:
case RPC_FC_CSTRUCT:
case RPC_FC_PSTRUCT:
v = type->fields;
if (!v) break;
while (NEXT_LINK(v)) v = NEXT_LINK(v);
for (; v; v = PREV_LINK(v))
if (!type->fields) break;
LIST_FOR_EACH_ENTRY( v, type->fields, const var_t, entry )
pointers_written += write_pointers(file, v->attrs, v->type,
v->ptr_level, v->array,
level + 1,
@ -691,10 +682,8 @@ static size_t write_pointer_description(FILE *file, const attr_list_t *attrs,
case RPC_FC_CPSTRUCT:
case RPC_FC_CSTRUCT:
case RPC_FC_PSTRUCT:
v = type->fields;
if (!v) break;
while (NEXT_LINK(v)) v = NEXT_LINK(v);
for (; v; v = PREV_LINK(v))
if (!type->fields) break;
LIST_FOR_EACH_ENTRY( v, type->fields, const var_t, entry )
size += write_pointer_description(file, v->attrs, v->type,
v->ptr_level, v->array,
level + 1,
@ -1001,8 +990,8 @@ static size_t write_array_tfs(FILE *file, const attr_list_t *attrs,
static const var_t *find_array_or_string_in_struct(const type_t *type)
{
/* last field is the first in the fields linked list */
const var_t *last_field = type->fields;
const var_t *last_field = LIST_ENTRY( list_tail(type->fields), const var_t, entry );
if (is_array_type(last_field->attrs, last_field->ptr_level, last_field->array))
return last_field;
@ -1016,11 +1005,9 @@ static const var_t *find_array_or_string_in_struct(const type_t *type)
static size_t write_struct_members(FILE *file, const type_t *type)
{
size_t typestring_size = 0;
var_t *field;
const var_t *field;
field = type->fields;
while (NEXT_LINK(field)) field = NEXT_LINK(field);
for (; field; field = PREV_LINK(field))
if (type->fields) LIST_FOR_EACH_ENTRY( field, type->fields, const var_t, entry )
{
unsigned char rtype = field->type->type;
@ -1458,7 +1445,7 @@ static size_t write_typeformatstring_var(FILE *file, int indent,
void write_typeformatstring(FILE *file, const ifref_list_t *ifaces, int for_objects)
{
int indent = 0;
var_t *var;
const var_t *var;
unsigned int typeformat_offset;
const ifref_t *iface;
@ -1483,16 +1470,9 @@ void write_typeformatstring(FILE *file, const ifref_list_t *ifaces, int for_obje
{
current_func = func;
if (func->args)
{
var = func->args;
while (NEXT_LINK(var)) var = NEXT_LINK(var);
while (var)
{
LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
write_typeformatstring_var(file, indent, var,
&typeformat_offset);
var = PREV_LINK(var);
}
}
}
}
}
@ -1547,7 +1527,8 @@ static unsigned int get_required_buffer_size_type(
{
size_t size = 0;
const var_t *field;
for (field = type->fields; field; field = NEXT_LINK(field))
if (!type->fields) return 0;
LIST_FOR_EACH_ENTRY( field, type->fields, const var_t, entry )
{
unsigned int alignment;
size += get_required_buffer_size_type(
@ -1587,7 +1568,9 @@ unsigned int get_required_buffer_size(const var_t *var, unsigned int *alignment,
{
const var_t *field;
unsigned int size = 36;
for (field = type->fields; field; field = NEXT_LINK(field))
if (!type->fields) return size;
LIST_FOR_EACH_ENTRY( field, type->fields, const var_t, entry )
{
unsigned int align;
size += get_required_buffer_size_type(
@ -1615,7 +1598,9 @@ unsigned int get_required_buffer_size(const var_t *var, unsigned int *alignment,
{
unsigned int size = 36;
const var_t *field;
for (field = type->fields; field; field = NEXT_LINK(field))
if (!type->fields) return size;
LIST_FOR_EACH_ENTRY( field, type->fields, const var_t, entry )
{
unsigned int align;
size += get_required_buffer_size_type(
@ -1772,14 +1757,12 @@ void write_remoting_arguments(FILE *file, int indent, const func_t *func,
const expr_t *length_is;
const expr_t *size_is;
int in_attr, out_attr, has_length, has_size, pointer_type;
var_t *var;
const var_t *var;
if (!func->args)
return;
var = func->args;
while (NEXT_LINK(var)) var = NEXT_LINK(var);
for (; var; *type_offset += get_size_typeformatstring_var(var), var = PREV_LINK(var))
LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
{
const type_t *type = var->type;
unsigned char rtype;
@ -1801,12 +1784,10 @@ void write_remoting_arguments(FILE *file, int indent, const func_t *func,
switch (pass)
{
case PASS_IN:
if (!in_attr)
continue;
if (!in_attr) goto next;
break;
case PASS_OUT:
if (!out_attr)
continue;
if (!out_attr) goto next;
break;
case PASS_RETURN:
break;
@ -1943,6 +1924,8 @@ void write_remoting_arguments(FILE *file, int indent, const func_t *func,
}
}
fprintf(file, "\n");
next:
*type_offset += get_size_typeformatstring_var(var);
}
}
@ -1966,7 +1949,7 @@ size_t get_size_procformatstring(const ifref_list_t *ifaces, int for_objects)
const ifref_t *iface;
size_t size = 1;
const func_t *func;
var_t *var;
const var_t *var;
if (ifaces) LIST_FOR_EACH_ENTRY( iface, ifaces, const ifref_t, entry )
{
@ -1979,15 +1962,8 @@ size_t get_size_procformatstring(const ifref_list_t *ifaces, int for_objects)
{
/* argument list size */
if (func->args)
{
var = func->args;
while (NEXT_LINK(var)) var = NEXT_LINK(var);
while (var)
{
LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
size += get_size_procformatstring_var(var);
var = PREV_LINK(var);
}
}
var = func->def;
/* return value size */
@ -2006,7 +1982,7 @@ size_t get_size_typeformatstring(const ifref_list_t *ifaces, int for_objects)
const ifref_t *iface;
size_t size = 3;
const func_t *func;
var_t *var;
const var_t *var;
if (ifaces) LIST_FOR_EACH_ENTRY( iface, ifaces, const ifref_t, entry )
{
@ -2019,15 +1995,8 @@ size_t get_size_typeformatstring(const ifref_list_t *ifaces, int for_objects)
{
/* argument list size */
if (func->args)
{
var = func->args;
while (NEXT_LINK(var)) var = NEXT_LINK(var);
while (var)
{
LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
size += get_size_typeformatstring_var(var);
var = PREV_LINK(var);
}
}
}
}
}
@ -2035,7 +2004,7 @@ size_t get_size_typeformatstring(const ifref_list_t *ifaces, int for_objects)
}
static void write_struct_expr(FILE *h, const expr_t *e, int brackets,
const var_t *fields, const char *structvar)
const var_list_t *fields, const char *structvar)
{
switch (e->type) {
case EXPR_VOID:
@ -2055,15 +2024,14 @@ static void write_struct_expr(FILE *h, const expr_t *e, int brackets,
case EXPR_IDENTIFIER:
{
const var_t *field;
for (field = fields; field; field = NEXT_LINK(field))
{
LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry )
if (!strcmp(e->u.sval, field->name))
{
fprintf(h, "%s->%s", structvar, e->u.sval);
break;
}
}
if (!field) error("no field found for identifier %s\n", e->u.sval);
if (&field->entry == fields) error("no field found for identifier %s\n", e->u.sval);
break;
}
case EXPR_NEG:

13
tools/widl/widltypes.h
View File

@ -48,6 +48,7 @@ typedef struct _typelib_t typelib_t;
typedef struct list attr_list_t;
typedef struct list func_list_t;
typedef struct list var_list_t;
typedef struct list ifref_list_t;
#define DECL_LINK(type) \
@ -210,7 +211,7 @@ struct _type_t {
struct _type_t *ref;
const attr_list_t *attrs;
func_list_t *funcs; /* interfaces and modules */
var_t *fields; /* interfaces, structures and enumerations */
var_list_t *fields; /* interfaces, structures and enumerations */
ifref_list_t *ifaces; /* coclasses */
type_t *orig; /* dup'd types */
int ignore, is_const, sign;
@ -231,18 +232,18 @@ struct _var_t {
int ptr_level;
expr_t *array;
type_t *type;
var_t *args; /* for function pointers */
var_list_t *args; /* for function pointers */
const char *tname;
attr_list_t *attrs;
expr_t *eval;
/* parser-internal */
DECL_LINK(var_t);
struct list entry;
};
struct _func_t {
var_t *def;
var_t *args;
var_list_t *args;
int ignore, idx;
/* parser-internal */
@ -301,7 +302,7 @@ type_t *duptype(type_t *t, int dupname);
type_t *alias(type_t *t, const char *name);
int is_ptr(const type_t *t);
int is_var_ptr(var_t *v);
int cant_be_null(var_t *v);
int is_var_ptr(const var_t *v);
int cant_be_null(const var_t *v);
#endif

58
tools/widl/write_msft.c
View File

@ -1250,7 +1250,7 @@ static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, const func_t *func, int
int i, id, next_idx;
int decoded_size, extra_attr = 0;
int num_params = 0, num_defaults = 0;
var_t *arg, *last_arg = NULL;
var_t *arg;
char *namedata;
const attr_t *attr;
unsigned int funcflags = 0, callconv = 4 /* CC_STDCALL */;
@ -1279,8 +1279,9 @@ static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, const func_t *func, int
return S_FALSE;
}
for(arg = func->args; arg; arg = NEXT_LINK(arg)) {
last_arg = arg;
if (func->args)
LIST_FOR_EACH_ENTRY( arg, func->args, var_t, entry )
{
num_params++;
if (arg->attrs) LIST_FOR_EACH_ENTRY( attr, arg->attrs, const attr_t, entry ) {
if(attr->type == ATTR_DEFAULTVALUE_EXPR || attr->type == ATTR_DEFAULTVALUE_STRING) {
@ -1288,7 +1289,7 @@ static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, const func_t *func, int
break;
}
}
}
}
chat("add_func_desc: num of params %d\n", num_params);
@ -1433,7 +1434,11 @@ static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, const func_t *func, int
warning("unknown number of optional attrs\n");
}
for (arg = last_arg, i = 0; arg; arg = PREV_LINK(arg), i++) {
if (func->args)
{
i = 0;
LIST_FOR_EACH_ENTRY( arg, func->args, var_t, entry )
{
const attr_t *attr;
int paramflags = 0;
int *paramdata = typedata + 6 + extra_attr + (num_defaults ? num_params : 0) + i * 3;
@ -1491,6 +1496,8 @@ static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, const func_t *func, int
paramdata[1] = -1;
paramdata[2] = paramflags;
typedata[3] += decoded_size << 16;
i++;
}
}
if(typeinfo->funcs_allocated == 0) {
@ -1541,10 +1548,16 @@ static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, const func_t *func, int
if(invokekind != 0x4 /* INVOKE_PROPERTYPUT */ && invokekind != 0x8 /* INVOKE_PROPERTYPUTREF */) {
/* don't give the arg of a [propput*] func a name */
for (arg = last_arg, i = 0; arg; arg = PREV_LINK(arg), i++) {
if (func->args)
{
i = 0;
LIST_FOR_EACH_ENTRY( arg, func->args, var_t, entry )
{
int *paramdata = typedata + 6 + extra_attr + (num_defaults ? num_params : 0) + i * 3;
offset = ctl2_alloc_name(typeinfo->typelib, arg->name);
paramdata[1] = offset;
i++;
}
}
}
return S_OK;
@ -1919,14 +1932,9 @@ static void add_dispinterface_typeinfo(msft_typelib_t *typelib, type_t *dispinte
if (dispinterface->funcs)
LIST_FOR_EACH_ENTRY( func, dispinterface->funcs, const func_t, entry ) idx++;
if((var = dispinterface->fields)) {
while(NEXT_LINK(var)) var = NEXT_LINK(var);
while(var) {
add_var_desc(msft_typeinfo, idx, var);
idx++;
var = PREV_LINK(var);
}
}
if (dispinterface->fields)
LIST_FOR_EACH_ENTRY( var, dispinterface->fields, var_t, entry )
add_var_desc(msft_typeinfo, idx++, var);
if (dispinterface->funcs)
{
@ -1998,7 +2006,7 @@ static void add_interface_typeinfo(msft_typelib_t *typelib, type_t *interface)
static void add_structure_typeinfo(msft_typelib_t *typelib, type_t *structure)
{
int idx = 0;
var_t *cur = structure->fields;
var_t *cur;
msft_typeinfo_t *msft_typeinfo;
if (-1 < structure->typelib_idx)
@ -2008,30 +2016,24 @@ static void add_structure_typeinfo(msft_typelib_t *typelib, type_t *structure)
msft_typeinfo = create_msft_typeinfo(typelib, TKIND_RECORD, structure->name, structure->attrs);
msft_typeinfo->typeinfo->size = 0;
while(NEXT_LINK(cur)) cur = NEXT_LINK(cur);
while(cur) {
add_var_desc(msft_typeinfo, idx, cur);
idx++;
cur = PREV_LINK(cur);
}
if (structure->fields)
LIST_FOR_EACH_ENTRY( cur, structure->fields, var_t, entry )
add_var_desc(msft_typeinfo, idx++, cur);
}
static void add_enum_typeinfo(msft_typelib_t *typelib, type_t *enumeration)
{
int idx = 0;
var_t *cur = enumeration->fields;
var_t *cur;
msft_typeinfo_t *msft_typeinfo;
enumeration->typelib_idx = typelib->typelib_header.nrtypeinfos;
msft_typeinfo = create_msft_typeinfo(typelib, TKIND_ENUM, enumeration->name, enumeration->attrs);
msft_typeinfo->typeinfo->size = 0;
while(NEXT_LINK(cur)) cur = NEXT_LINK(cur);
while(cur) {
add_var_desc(msft_typeinfo, idx, cur);
idx++;
cur = PREV_LINK(cur);
}
if (enumeration->fields)
LIST_FOR_EACH_ENTRY( cur, enumeration->fields, var_t, entry )
add_var_desc(msft_typeinfo, idx++, cur);
}
static void add_typedef_typeinfo(msft_typelib_t *typelib, type_t *tdef)