tools/widl/typetree.c - wine - Git at Google

 /*
  * IDL Type Tree
  *
  * Copyright 2008 Robert Shearman
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */

 #include "config.h"

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

 #include "widl.h"
 #include "utils.h"
 #include "parser.h"
 #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();
     t->name = NULL;
     t->type_type = type;
     t->attrs = NULL;
     t->orig = NULL;
     memset(&t->details, 0, sizeof(t->details));
     t->typestring_offset = 0;
     t->ptrdesc = 0;
     t->ignore = (parse_only != 0);
     t->defined = FALSE;
     t->written = FALSE;
     t->user_types_registered = FALSE;
     t->tfswrite = FALSE;
     t->checked = FALSE;
     t->is_alias = FALSE;
     t->typelib_idx = -1;
     init_loc_info(&t->loc_info);
     return t;
 }

 static const var_t *find_arg(const var_list_t *args, const char *name)
 {
     const var_t *arg;

     if (args) LIST_FOR_EACH_ENTRY(arg, args, const var_t, entry)
     {
         if (arg->name && !strcmp(name, arg->name))
             return arg;
     }

     return NULL;
 }

 type_t *type_new_function(var_list_t *args)
 {
     var_t *arg;
     type_t *t;
     unsigned int i = 0;

     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)
         {
             list_remove(&arg->entry);
             free(arg);
             free(args);
             args = NULL;
         }
     }
     if (args) LIST_FOR_EACH_ENTRY(arg, args, var_t, entry)
     {
         if (arg->type && type_get_type(arg->type) == TYPE_VOID)
             error_loc("argument '%s' has void type\n", arg->name);
         if (!arg->name)
         {
             if (i > 26 * 26)
                 error_loc("too many unnamed arguments\n");
             else
             {
                 int unique;
                 do
                 {
                     char name[3];
                     name[0] = i > 26 ? 'a' + i / 26 : 'a' + i;
                     name[1] = i > 26 ? 'a' + i % 26 : 0;
                     name[2] = 0;
                     unique = !find_arg(args, name);
                     if (unique)
                         arg->name = xstrdup(name);
                     i++;
                 } while (!unique);
             }
         }
     }

     t = make_type(TYPE_FUNCTION);
     t->details.function = xmalloc(sizeof(*t->details.function));
     t->details.function->args = args;
     t->details.function->idx = -1;
     return t;
 }

 type_t *type_new_pointer(unsigned char pointer_default, type_t *ref, attr_list_t *attrs)
 {
     type_t *t = make_type(TYPE_POINTER);
     t->details.pointer.def_fc = pointer_default;
     t->details.pointer.ref = ref;
     t->attrs = attrs;
     return t;
 }

 type_t *type_new_alias(type_t *t, const char *name)
 {
     type_t *a = duptype(t, 0);

     a->name = xstrdup(name);
     a->attrs = NULL;
     a->orig = t;
     a->is_alias = TRUE;
     /* for pointer types */
     a->details = t->details;
     init_loc_info(&a->loc_info);

     return a;
 }

 type_t *type_new_module(char *name)
 {
     type_t *type = get_type(TYPE_MODULE, name, 0);
     if (type->type_type != TYPE_MODULE || type->defined)
         error_loc("%s: redefinition error; original definition was at %s:%d\n",
                   type->name, type->loc_info.input_name, type->loc_info.line_number);
     type->name = name;
     return type;
 }

 type_t *type_new_coclass(char *name)
 {
     type_t *type = get_type(TYPE_COCLASS, name, 0);
     if (type->type_type != TYPE_COCLASS || type->defined)
         error_loc("%s: redefinition error; original definition was at %s:%d\n",
                   type->name, type->loc_info.input_name, type->loc_info.line_number);
     type->name = 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 *t = make_type(TYPE_ARRAY);
     if (name) t->name = xstrdup(name);
     t->details.array.declptr = declptr;
     t->details.array.length_is = length_is;
     if (size_is)
         t->details.array.size_is = size_is;
     else
         t->details.array.dim = dim;
     t->details.array.elem = element;
     t->details.array.ptr_def_fc = ptr_default_fc;
     return t;
 }

 type_t *type_new_basic(enum type_basic_type basic_type)
 {
     type_t *t = make_type(TYPE_BASIC);
     t->details.basic.type = basic_type;
     t->details.basic.sign = 0;
     return t;
 }

 type_t *type_new_int(enum type_basic_type basic_type, int sign)
 {
     static type_t *int_types[TYPE_BASIC_INT_MAX+1][3];

     assert(basic_type <= TYPE_BASIC_INT_MAX);

     /* map sign { -1, 0, 1 } -> { 0, 1, 2 } */
     if (!int_types[basic_type][sign + 1])
     {
         int_types[basic_type][sign + 1] = type_new_basic(basic_type);
         int_types[basic_type][sign + 1]->details.basic.sign = sign;
     }
     return int_types[basic_type][sign + 1];
 }

 type_t *type_new_void(void)
 {
     static type_t *void_type = NULL;
     if (!void_type)
         void_type = make_type(TYPE_VOID);
     return void_type;
 }

 type_t *type_new_enum(const char *name, int defined, var_list_t *enums)
 {
     type_t *tag_type = name ? find_type(name, tsENUM) : NULL;
     type_t *t = make_type(TYPE_ENUM);
     t->name = name;

     if (tag_type && tag_type->details.enumeration)
         t->details.enumeration = tag_type->details.enumeration;
     else if (defined)
     {
         t->details.enumeration = xmalloc(sizeof(*t->details.enumeration));
         t->details.enumeration->enums = enums;
         t->defined = TRUE;
     }

     if (name)
     {
         if (defined)
             reg_type(t, name, tsENUM);
         else
             add_incomplete(t);
     }
     return t;
 }

 type_t *type_new_struct(char *name, int defined, var_list_t *fields)
 {
     type_t *tag_type = name ? find_type(name, tsSTRUCT) : NULL;
     type_t *t = make_type(TYPE_STRUCT);
     t->name = name;
     if (tag_type && tag_type->details.structure)
         t->details.structure = tag_type->details.structure;
     else if (defined)
     {
         t->details.structure = xmalloc(sizeof(*t->details.structure));
         t->details.structure->fields = fields;
         t->defined = TRUE;
     }
     if (name)
     {
         if (defined)
             reg_type(t, name, tsSTRUCT);
         else
             add_incomplete(t);
     }
     return t;
 }

 type_t *type_new_nonencapsulated_union(const char *name, int defined, var_list_t *fields)
 {
     type_t *tag_type = name ? find_type(name, tsUNION) : NULL;
     type_t *t = make_type(TYPE_UNION);
     t->name = name;
     if (tag_type && tag_type->details.structure)
         t->details.structure = tag_type->details.structure;
     else if (defined)
     {
         t->details.structure = xmalloc(sizeof(*t->details.structure));
         t->details.structure->fields = fields;
         t->defined = TRUE;
     }
     if (name)
     {
         if (defined)
             reg_type(t, name, tsUNION);
         else
             add_incomplete(t);
     }
     return t;
 }

 type_t *type_new_encapsulated_union(char *name, var_t *switch_field, var_t *union_field, var_list_t *cases)
 {
     type_t *t = get_type(TYPE_ENCAPSULATED_UNION, name, tsUNION);
     if (!union_field) union_field = make_var( xstrdup("tagged_union") );
     union_field->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 );
     t->defined = TRUE;
     return t;
 }

 static int is_valid_bitfield_type(const type_t *type)
 {
     switch (type_get_type(type))
     {
     case TYPE_ENUM:
         return TRUE;
     case TYPE_BASIC:
         switch (type_basic_get_type(type))
         {
         case TYPE_BASIC_INT8:
         case TYPE_BASIC_INT16:
         case TYPE_BASIC_INT32:
         case TYPE_BASIC_INT64:
         case TYPE_BASIC_INT:
         case TYPE_BASIC_INT3264:
         case TYPE_BASIC_CHAR:
         case TYPE_BASIC_HYPER:
         case TYPE_BASIC_BYTE:
         case TYPE_BASIC_WCHAR:
         case TYPE_BASIC_ERROR_STATUS_T:
             return TRUE;
         case TYPE_BASIC_FLOAT:
         case TYPE_BASIC_DOUBLE:
         case TYPE_BASIC_HANDLE:
             return FALSE;
         }
         return FALSE;
     default:
         return FALSE;
     }
 }

 type_t *type_new_bitfield(type_t *field, const expr_t *bits)
 {
     type_t *t;

     if (!is_valid_bitfield_type(field))
         error_loc("bit-field has invalid type\n");

     if (bits->cval < 0)
         error_loc("negative width for bit-field\n");

     /* FIXME: validate bits->cval <= memsize(field) * 8 */

     t = make_type(TYPE_BITFIELD);
     t->details.bitfield.field = field;
     t->details.bitfield.bits = bits;
     return t;
 }

 static int compute_method_indexes(type_t *iface)
 {
     int idx;
     statement_t *stmt;

     if (!iface->details.iface)
         return 0;

     if (type_iface_get_inherit(iface))
         idx = compute_method_indexes(type_iface_get_inherit(iface));
     else
         idx = 0;

     STATEMENTS_FOR_EACH_FUNC( stmt, type_iface_get_stmts(iface) )
     {
         var_t *func = stmt->u.var;
         if (!is_callas(func->attrs))
             func->type->details.function->idx = idx++;
     }

     return idx;
 }

 void type_interface_define(type_t *iface, type_t *inherit, statement_list_t *stmts)
 {
     iface->details.iface = xmalloc(sizeof(*iface->details.iface));
     iface->details.iface->disp_props = NULL;
     iface->details.iface->disp_methods = NULL;
     iface->details.iface->stmts = stmts;
     iface->details.iface->inherit = inherit;
     iface->defined = TRUE;
     compute_method_indexes(iface);
 }

 void type_dispinterface_define(type_t *iface, var_list_t *props, var_list_t *methods)
 {
     iface->details.iface = xmalloc(sizeof(*iface->details.iface));
     iface->details.iface->disp_props = props;
     iface->details.iface->disp_methods = methods;
     iface->details.iface->stmts = NULL;
     iface->details.iface->inherit = find_type("IDispatch", 0);
     if (!iface->details.iface->inherit) error_loc("IDispatch is undefined\n");
     iface->defined = TRUE;
     compute_method_indexes(iface);
 }

 void type_dispinterface_define_from_iface(type_t *dispiface, type_t *iface)
 {
     type_dispinterface_define(dispiface, iface->details.iface->disp_props,
                               iface->details.iface->disp_methods);
 }

 void type_module_define(type_t *module, statement_list_t *stmts)
 {
     if (module->details.module) error_loc("multiple definition error\n");
     module->details.module = xmalloc(sizeof(*module->details.module));
     module->details.module->stmts = stmts;
     module->defined = TRUE;
 }

 type_t *type_coclass_define(type_t *coclass, ifref_list_t *ifaces)
 {
     coclass->details.coclass.ifaces = ifaces;
     coclass->defined = TRUE;
     return coclass;
 }

 int type_is_equal(const type_t *type1, const type_t *type2)
 {
     if (type_get_type_detect_alias(type1) != type_get_type_detect_alias(type2))
         return FALSE;

     if (type1->name && type2->name)
         return !strcmp(type1->name, type2->name);
     else if ((!type1->name && type2->name) || (type1->name && !type2->name))
         return FALSE;

     /* FIXME: do deep inspection of types to determine if they are equal */

     return FALSE;
 }
	/*
	* IDL Type Tree
	*
	* Copyright 2008 Robert Shearman
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* This library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
	*/

	#include "config.h"

	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>

	#include "widl.h"
	#include "utils.h"
	#include "parser.h"
	#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();
	t->name = NULL;
	t->type_type = type;
	t->attrs = NULL;
	t->orig = NULL;
	memset(&t->details, 0, sizeof(t->details));
	t->typestring_offset = 0;
	t->ptrdesc = 0;
	t->ignore = (parse_only != 0);
	t->defined = FALSE;
	t->written = FALSE;
	t->user_types_registered = FALSE;
	t->tfswrite = FALSE;
	t->checked = FALSE;
	t->is_alias = FALSE;
	t->typelib_idx = -1;
	init_loc_info(&t->loc_info);
	return t;
	}

	static const var_t find_arg(const var_list_t args, const char *name)
	{
	const var_t *arg;

	if (args) LIST_FOR_EACH_ENTRY(arg, args, const var_t, entry)
	{
	if (arg->name && !strcmp(name, arg->name))
	return arg;
	}

	return NULL;
	}

	type_t type_new_function(var_list_t args)
	{
	var_t *arg;
	type_t *t;
	unsigned int i = 0;

	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)
	{
	list_remove(&arg->entry);
	free(arg);
	free(args);
	args = NULL;
	}
	}
	if (args) LIST_FOR_EACH_ENTRY(arg, args, var_t, entry)
	{
	if (arg->type && type_get_type(arg->type) == TYPE_VOID)
	error_loc("argument '%s' has void type\n", arg->name);
	if (!arg->name)
	{
	if (i > 26 * 26)
	error_loc("too many unnamed arguments\n");
	else
	{
	int unique;
	do
	{
	char name[3];
	name[0] = i > 26 ? 'a' + i / 26 : 'a' + i;
	name[1] = i > 26 ? 'a' + i % 26 : 0;
	name[2] = 0;
	unique = !find_arg(args, name);
	if (unique)
	arg->name = xstrdup(name);
	i++;
	} while (!unique);
	}
	}
	}

	t = make_type(TYPE_FUNCTION);
	t->details.function = xmalloc(sizeof(*t->details.function));
	t->details.function->args = args;
	t->details.function->idx = -1;
	return t;
	}

	type_t type_new_pointer(unsigned char pointer_default, type_t ref, attr_list_t *attrs)
	{
	type_t *t = make_type(TYPE_POINTER);
	t->details.pointer.def_fc = pointer_default;
	t->details.pointer.ref = ref;
	t->attrs = attrs;
	return t;
	}

	type_t type_new_alias(type_t t, const char *name)
	{
	type_t *a = duptype(t, 0);

	a->name = xstrdup(name);
	a->attrs = NULL;
	a->orig = t;
	a->is_alias = TRUE;
	/* for pointer types */
	a->details = t->details;
	init_loc_info(&a->loc_info);

	return a;
	}

	type_t type_new_module(char name)
	{
	type_t *type = get_type(TYPE_MODULE, name, 0);
	if (type->type_type != TYPE_MODULE \|\| type->defined)
	error_loc("%s: redefinition error; original definition was at %s:%d\n",
	type->name, type->loc_info.input_name, type->loc_info.line_number);
	type->name = name;
	return type;
	}

	type_t type_new_coclass(char name)
	{
	type_t *type = get_type(TYPE_COCLASS, name, 0);
	if (type->type_type != TYPE_COCLASS \|\| type->defined)
	error_loc("%s: redefinition error; original definition was at %s:%d\n",
	type->name, type->loc_info.input_name, type->loc_info.line_number);
	type->name = 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 *t = make_type(TYPE_ARRAY);
	if (name) t->name = xstrdup(name);
	t->details.array.declptr = declptr;
	t->details.array.length_is = length_is;
	if (size_is)
	t->details.array.size_is = size_is;
	else
	t->details.array.dim = dim;
	t->details.array.elem = element;
	t->details.array.ptr_def_fc = ptr_default_fc;
	return t;
	}

	type_t *type_new_basic(enum type_basic_type basic_type)
	{
	type_t *t = make_type(TYPE_BASIC);
	t->details.basic.type = basic_type;
	t->details.basic.sign = 0;
	return t;
	}

	type_t *type_new_int(enum type_basic_type basic_type, int sign)
	{
	static type_t *int_types[TYPE_BASIC_INT_MAX+1][3];

	assert(basic_type <= TYPE_BASIC_INT_MAX);

	/* map sign { -1, 0, 1 } -> { 0, 1, 2 } */
	if (!int_types[basic_type][sign + 1])
	{
	int_types[basic_type][sign + 1] = type_new_basic(basic_type);
	int_types[basic_type][sign + 1]->details.basic.sign = sign;
	}
	return int_types[basic_type][sign + 1];
	}

	type_t *type_new_void(void)
	{
	static type_t *void_type = NULL;
	if (!void_type)
	void_type = make_type(TYPE_VOID);
	return void_type;
	}

	type_t type_new_enum(const char name, int defined, var_list_t *enums)
	{
	type_t *tag_type = name ? find_type(name, tsENUM) : NULL;
	type_t *t = make_type(TYPE_ENUM);
	t->name = name;

	if (tag_type && tag_type->details.enumeration)
	t->details.enumeration = tag_type->details.enumeration;
	else if (defined)
	{
	t->details.enumeration = xmalloc(sizeof(*t->details.enumeration));
	t->details.enumeration->enums = enums;
	t->defined = TRUE;
	}

	if (name)
	{
	if (defined)
	reg_type(t, name, tsENUM);
	else
	add_incomplete(t);
	}
	return t;
	}

	type_t type_new_struct(char name, int defined, var_list_t *fields)
	{
	type_t *tag_type = name ? find_type(name, tsSTRUCT) : NULL;
	type_t *t = make_type(TYPE_STRUCT);
	t->name = name;
	if (tag_type && tag_type->details.structure)
	t->details.structure = tag_type->details.structure;
	else if (defined)
	{
	t->details.structure = xmalloc(sizeof(*t->details.structure));
	t->details.structure->fields = fields;
	t->defined = TRUE;
	}
	if (name)
	{
	if (defined)
	reg_type(t, name, tsSTRUCT);
	else
	add_incomplete(t);
	}
	return t;
	}

	type_t type_new_nonencapsulated_union(const char name, int defined, var_list_t *fields)
	{
	type_t *tag_type = name ? find_type(name, tsUNION) : NULL;
	type_t *t = make_type(TYPE_UNION);
	t->name = name;
	if (tag_type && tag_type->details.structure)
	t->details.structure = tag_type->details.structure;
	else if (defined)
	{
	t->details.structure = xmalloc(sizeof(*t->details.structure));
	t->details.structure->fields = fields;
	t->defined = TRUE;
	}
	if (name)
	{
	if (defined)
	reg_type(t, name, tsUNION);
	else
	add_incomplete(t);
	}
	return t;
	}

	type_t type_new_encapsulated_union(char name, var_t switch_field, var_t union_field, var_list_t *cases)
	{
	type_t *t = get_type(TYPE_ENCAPSULATED_UNION, name, tsUNION);
	if (!union_field) union_field = make_var( xstrdup("tagged_union") );
	union_field->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 );
	t->defined = TRUE;
	return t;
	}

	static int is_valid_bitfield_type(const type_t *type)
	{
	switch (type_get_type(type))
	{
	case TYPE_ENUM:
	return TRUE;
	case TYPE_BASIC:
	switch (type_basic_get_type(type))
	{
	case TYPE_BASIC_INT8:
	case TYPE_BASIC_INT16:
	case TYPE_BASIC_INT32:
	case TYPE_BASIC_INT64:
	case TYPE_BASIC_INT:
	case TYPE_BASIC_INT3264:
	case TYPE_BASIC_CHAR:
	case TYPE_BASIC_HYPER:
	case TYPE_BASIC_BYTE:
	case TYPE_BASIC_WCHAR:
	case TYPE_BASIC_ERROR_STATUS_T:
	return TRUE;
	case TYPE_BASIC_FLOAT:
	case TYPE_BASIC_DOUBLE:
	case TYPE_BASIC_HANDLE:
	return FALSE;
	}
	return FALSE;
	default:
	return FALSE;
	}
	}

	type_t type_new_bitfield(type_t field, const expr_t *bits)
	{
	type_t *t;

	if (!is_valid_bitfield_type(field))
	error_loc("bit-field has invalid type\n");

	if (bits->cval < 0)
	error_loc("negative width for bit-field\n");

	/* FIXME: validate bits->cval <= memsize(field) * 8 */

	t = make_type(TYPE_BITFIELD);
	t->details.bitfield.field = field;
	t->details.bitfield.bits = bits;
	return t;
	}

	static int compute_method_indexes(type_t *iface)
	{
	int idx;
	statement_t *stmt;

	if (!iface->details.iface)
	return 0;

	if (type_iface_get_inherit(iface))
	idx = compute_method_indexes(type_iface_get_inherit(iface));
	else
	idx = 0;

	STATEMENTS_FOR_EACH_FUNC( stmt, type_iface_get_stmts(iface) )
	{
	var_t *func = stmt->u.var;
	if (!is_callas(func->attrs))
	func->type->details.function->idx = idx++;
	}

	return idx;
	}

	void type_interface_define(type_t iface, type_t inherit, statement_list_t *stmts)
	{
	iface->details.iface = xmalloc(sizeof(*iface->details.iface));
	iface->details.iface->disp_props = NULL;
	iface->details.iface->disp_methods = NULL;
	iface->details.iface->stmts = stmts;
	iface->details.iface->inherit = inherit;
	iface->defined = TRUE;
	compute_method_indexes(iface);
	}

	void type_dispinterface_define(type_t iface, var_list_t props, var_list_t *methods)
	{
	iface->details.iface = xmalloc(sizeof(*iface->details.iface));
	iface->details.iface->disp_props = props;
	iface->details.iface->disp_methods = methods;
	iface->details.iface->stmts = NULL;
	iface->details.iface->inherit = find_type("IDispatch", 0);
	if (!iface->details.iface->inherit) error_loc("IDispatch is undefined\n");
	iface->defined = TRUE;
	compute_method_indexes(iface);
	}

	void type_dispinterface_define_from_iface(type_t dispiface, type_t iface)
	{
	type_dispinterface_define(dispiface, iface->details.iface->disp_props,
	iface->details.iface->disp_methods);
	}

	void type_module_define(type_t module, statement_list_t stmts)
	{
	if (module->details.module) error_loc("multiple definition error\n");
	module->details.module = xmalloc(sizeof(*module->details.module));
	module->details.module->stmts = stmts;
	module->defined = TRUE;
	}

	type_t type_coclass_define(type_t coclass, ifref_list_t *ifaces)
	{
	coclass->details.coclass.ifaces = ifaces;
	coclass->defined = TRUE;
	return coclass;
	}

	int type_is_equal(const type_t type1, const type_t type2)
	{
	if (type_get_type_detect_alias(type1) != type_get_type_detect_alias(type2))
	return FALSE;

	if (type1->name && type2->name)
	return !strcmp(type1->name, type2->name);
	else if ((!type1->name && type2->name) \|\| (type1->name && !type2->name))
	return FALSE;

	/* FIXME: do deep inspection of types to determine if they are equal */

	return FALSE;
	}