attribute.c File Reference

#include "config.h"
#include "widl.h"
#include "typetree.h"
#include "parser.tab.h"

Include dependency graph for attribute.c:

Go to the source code of this file.

Classes
struct	allowed_attr

Functions
attr_t *	attr_int (struct location where, enum attr_type attr_type, unsigned int val)
attr_t *	attr_ptr (struct location where, enum attr_type attr_type, void *val)
int	is_attr (const attr_list_t *list, enum attr_type attr_type)
int	is_ptrchain_attr (const var_t *var, enum attr_type attr_type)
int	is_aliaschain_attr (const type_t *type, enum attr_type attr_type)
unsigned int	get_attrv (const attr_list_t *list, enum attr_type attr_type)
void *	get_attrp (const attr_list_t *list, enum attr_type attr_type)
void *	get_aliaschain_attrp (const type_t *type, enum attr_type attr_type)
static const char *	get_attr_display_name (enum attr_type attr_type)
attr_list_t *	append_attr (attr_list_t *list, attr_t *attr)
attr_list_t *	append_attr_list (attr_list_t *new_list, attr_list_t *old_list)
attr_list_t *	append_attribs (attr_list_t *l1, attr_list_t *l2)
attr_list_t *	map_attrs (const attr_list_t *list, map_attrs_filter_t filter)
attr_list_t *	move_attr (attr_list_t *dst, attr_list_t *src, enum attr_type type)
attr_list_t *	check_apicontract_attrs (const char *name, attr_list_t *attrs)
attr_list_t *	check_coclass_attrs (const char *name, attr_list_t *attrs)
attr_list_t *	check_dispiface_attrs (const char *name, attr_list_t *attrs)
attr_list_t *	check_enum_attrs (attr_list_t *attrs)
attr_list_t *	check_enum_member_attrs (attr_list_t *attrs)
attr_list_t *	check_field_attrs (const char *name, attr_list_t *attrs)
attr_list_t *	check_function_attrs (const char *name, attr_list_t *attrs)
attr_list_t *	check_interface_attrs (const char *name, attr_list_t *attrs)
attr_list_t *	check_library_attrs (const char *name, attr_list_t *attrs)
attr_list_t *	check_module_attrs (const char *name, attr_list_t *attrs)
attr_list_t *	check_runtimeclass_attrs (const char *name, attr_list_t *attrs)
attr_list_t *	check_struct_attrs (attr_list_t *attrs)
attr_list_t *	check_typedef_attrs (attr_list_t *attrs)
attr_list_t *	check_union_attrs (attr_list_t *attrs)
void	check_arg_attrs (const var_t *arg)

Variables
struct allowed_attr	allowed_attr []

Function Documentation

append_attr()

attr_list_t * append_attr	(	attr_list_t *	list,
		attr_t *	attr
	)

Definition at line 255 of file attribute.c.

{
    attr_t *attr_existing;
    if (!attr) return list;
    if (!list)
    {
        list = xmalloc( sizeof(*list) );
        list_init( list );
    }
    if (!allowed_attr[attr->type].multiple)
    {
        LIST_FOR_EACH_ENTRY( attr_existing, list, attr_t, entry )
        {
            if (attr_existing->type != attr->type) continue;
            warning_at( &attr->where, "duplicate attribute %s\n", get_attr_display_name( attr->type ) );
            /* use the last attribute, like MIDL does */
            list_remove( &attr_existing->entry );
            break;
        }
    }
    list_add_tail( list, &attr->entry );
    return list;
}

Referenced by append_attr_list(), compute_interface_signature_uuid(), and move_attr().

append_attr_list()

attr_list_t * append_attr_list	(	attr_list_t *	new_list,
		attr_list_t *	old_list
	)

Definition at line 279 of file attribute.c.

{
    struct list *entry;
 
    if (!old_list) return new_list;
 
    while ((entry = list_head( old_list )))
    {
        attr_t *attr = LIST_ENTRY( entry, attr_t, entry );
        list_remove( entry );
        new_list = append_attr( new_list, attr );
    }
    return new_list;
}

append_attribs()

attr_list_t * append_attribs	(	attr_list_t *	l1,
		attr_list_t *	l2
	)

Definition at line 294 of file attribute.c.

{
    if (!l2) return l1;
    if (!l1 || l1 == l2) return l2;
    list_move_tail( l1, l2 );
    return l1;
}

attr_int()

attr_t * attr_int	(	struct location	where,
		enum attr_type attr_type attr_type	,
		unsigned int	val
	)

Definition at line 27 of file attribute.c.

{
    attr_t *a = xmalloc( sizeof(attr_t) );
    a->where = where;
    a->type = attr_type;
    a->u.ival = val;
    return a;
}

attr_ptr()

attr_t * attr_ptr	(	struct location	where,
		enum attr_type attr_type attr_type	,
		void *	val
	)

Definition at line 36 of file attribute.c.

{
    attr_t *a = xmalloc( sizeof(attr_t) );
    a->where = where;
    a->type = attr_type;
    a->u.pval = val;
    return a;
}

Referenced by compute_interface_signature_uuid().

check_apicontract_attrs()

attr_list_t * check_apicontract_attrs	(	const char *	name,
		attr_list_t *	attrs
	)

Definition at line 337 of file attribute.c.

{
    const attr_t *attr;
    if (!attrs) return NULL;
    LIST_FOR_EACH_ENTRY( attr, attrs, const attr_t, entry )
    {
        if (!allowed_attr[attr->type].on_apicontract)
            error_at( &attr->where, "inapplicable attribute %s for apicontract %s\n",
                      allowed_attr[attr->type].display_name, name );
    }
    return attrs;
}

Referenced by type_apicontract_define().

check_arg_attrs()

void check_arg_attrs

(

const var_t *

arg

)

Definition at line 530 of file attribute.c.

{
    const attr_t *attr;
    if (!arg->attrs) return;
    LIST_FOR_EACH_ENTRY( attr, arg->attrs, const attr_t, entry )
    {
        if (!allowed_attr[attr->type].on_arg)
            error_at( &attr->where, "inapplicable attribute %s for argument %s\n",
                      allowed_attr[attr->type].display_name, arg->name );
    }
}

check_coclass_attrs()

attr_list_t * check_coclass_attrs	(	const char *	name,
		attr_list_t *	attrs
	)

Definition at line 350 of file attribute.c.

{
    const attr_t *attr;
    if (!attrs) return NULL;
    LIST_FOR_EACH_ENTRY( attr, attrs, const attr_t, entry )
    {
        if (!allowed_attr[attr->type].on_coclass)
            error_at( &attr->where, "inapplicable attribute %s for coclass %s\n",
                      allowed_attr[attr->type].display_name, name );
    }
    return attrs;
}

Referenced by type_coclass_define().

check_dispiface_attrs()

attr_list_t * check_dispiface_attrs	(	const char *	name,
		attr_list_t *	attrs
	)

Definition at line 363 of file attribute.c.

{
    const attr_t *attr;
    if (!attrs) return NULL;
    LIST_FOR_EACH_ENTRY( attr, attrs, const attr_t, entry )
    {
        if (!allowed_attr[attr->type].on_dispinterface)
            error_at( &attr->where, "inapplicable attribute %s for dispinterface %s\n",
                      allowed_attr[attr->type].display_name, name );
    }
    return attrs;
}

Referenced by type_dispinterface_define(), and type_dispinterface_define_from_iface().

check_enum_attrs()

attr_list_t * check_enum_attrs

(

attr_list_t *

attrs

)

Definition at line 376 of file attribute.c.

{
    const attr_t *attr;
    if (!attrs) return NULL;
    LIST_FOR_EACH_ENTRY( attr, attrs, const attr_t, entry )
    {
        if (!allowed_attr[attr->type].on_enum)
            error_at( &attr->where, "inapplicable attribute %s for enum\n",
                      allowed_attr[attr->type].display_name );
    }
    return attrs;
}

check_enum_member_attrs()

attr_list_t * check_enum_member_attrs

(

attr_list_t *

attrs

)

Definition at line 389 of file attribute.c.

{
    const attr_t *attr;
    if (!attrs) return NULL;
    LIST_FOR_EACH_ENTRY( attr, attrs, const attr_t, entry )
    {
        if (!allowed_attr[attr->type].on_enum_member)
            error_at( &attr->where, "inapplicable attribute %s for enum member\n",
                      allowed_attr[attr->type].display_name );
    }
    return attrs;
}

check_field_attrs()

attr_list_t * check_field_attrs	(	const char *	name,
		attr_list_t *	attrs
	)

Definition at line 402 of file attribute.c.

{
    const attr_t *attr;
    if (!attrs) return NULL;
    LIST_FOR_EACH_ENTRY( attr, attrs, const attr_t, entry )
    {
        if (!allowed_attr[attr->type].on_field)
            error_at( &attr->where, "inapplicable attribute %s for field %s\n",
                      allowed_attr[attr->type].display_name, name );
    }
    return attrs;
}

check_function_attrs()

attr_list_t * check_function_attrs	(	const char *	name,
		attr_list_t *	attrs
	)

Definition at line 415 of file attribute.c.

{
    const attr_t *attr;
    if (!attrs) return NULL;
    LIST_FOR_EACH_ENTRY( attr, attrs, const attr_t, entry )
    {
        if (!allowed_attr[attr->type].on_function)
            error_at( &attr->where, "inapplicable attribute %s for function %s\n",
                      allowed_attr[attr->type].display_name, name );
    }
    return attrs;
}

check_interface_attrs()

attr_list_t * check_interface_attrs	(	const char *	name,
		attr_list_t *	attrs
	)

Definition at line 428 of file attribute.c.

{
    const attr_t *attr;
    if (!attrs) return NULL;
    LIST_FOR_EACH_ENTRY( attr, attrs, const attr_t, entry )
    {
        if (!allowed_attr[attr->type].on_interface)
            error_at( &attr->where, "inapplicable attribute %s for interface %s\n",
                      allowed_attr[attr->type].display_name, name );
        if (attr->type == ATTR_IMPLICIT_HANDLE)
        {
            const var_t *var = attr->u.pval;
            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->declspec.type, ATTR_HANDLE )) continue;
            error_at( &attr->where, "attribute %s requires a handle type in interface %s\n",
                      allowed_attr[attr->type].display_name, name );
        }
    }
    return attrs;
}

Referenced by type_delegate_define(), type_interface_define(), type_parameterized_delegate_define(), and type_parameterized_interface_define().

check_library_attrs()

attr_list_t * check_library_attrs	(	const char *	name,
		attr_list_t *	attrs
	)

Definition at line 451 of file attribute.c.

{
    const attr_t *attr;
    if (!attrs) return NULL;
    LIST_FOR_EACH_ENTRY( attr, attrs, const attr_t, entry )
    {
        if (!allowed_attr[attr->type].on_library)
            error_at( &attr->where, "inapplicable attribute %s for library %s\n",
                      allowed_attr[attr->type].display_name, name );
    }
    return attrs;
}

check_module_attrs()

attr_list_t * check_module_attrs	(	const char *	name,
		attr_list_t *	attrs
	)

Definition at line 464 of file attribute.c.

{
    const attr_t *attr;
    if (!attrs) return NULL;
    LIST_FOR_EACH_ENTRY( attr, attrs, const attr_t, entry )
    {
        if (!allowed_attr[attr->type].on_module)
            error_at( &attr->where, "inapplicable attribute %s for module %s\n",
                      allowed_attr[attr->type].display_name, name );
    }
    return attrs;
}

Referenced by type_module_define().

check_runtimeclass_attrs()

attr_list_t * check_runtimeclass_attrs	(	const char *	name,
		attr_list_t *	attrs
	)

Definition at line 477 of file attribute.c.

{
    const attr_t *attr;
    if (!attrs) return NULL;
    LIST_FOR_EACH_ENTRY( attr, attrs, const attr_t, entry )
    {
        if (!allowed_attr[attr->type].on_runtimeclass)
            error_at( &attr->where, "inapplicable attribute %s for runtimeclass %s\n",
                      allowed_attr[attr->type].display_name, name );
    }
    return attrs;
}

Referenced by type_runtimeclass_define().

check_struct_attrs()

attr_list_t * check_struct_attrs

(

attr_list_t *

attrs

)

Definition at line 490 of file attribute.c.

{
    int mask = winrt_mode ? 3 : 1;
    const attr_t *attr;
    if (!attrs) return NULL;
    LIST_FOR_EACH_ENTRY( attr, attrs, const attr_t, entry )
    {
        if (!(allowed_attr[attr->type].on_struct & mask))
            error_at( &attr->where, "inapplicable attribute %s for struct\n",
                      allowed_attr[attr->type].display_name );
    }
    return attrs;
}

check_typedef_attrs()

attr_list_t * check_typedef_attrs

(

attr_list_t *

attrs

)

Definition at line 504 of file attribute.c.

{
    const attr_t *attr;
    if (!attrs) return NULL;
    LIST_FOR_EACH_ENTRY( attr, attrs, const attr_t, entry )
    {
        if (!allowed_attr[attr->type].on_type)
            error_at( &attr->where, "inapplicable attribute %s for typedef\n",
                      allowed_attr[attr->type].display_name );
    }
    return attrs;
}

check_union_attrs()

attr_list_t * check_union_attrs

(

attr_list_t *

attrs

)

Definition at line 517 of file attribute.c.

{
    const attr_t *attr;
    if (!attrs) return NULL;
    LIST_FOR_EACH_ENTRY( attr, attrs, const attr_t, entry )
    {
        if (!allowed_attr[attr->type].on_union)
            error_at( &attr->where, "inapplicable attribute %s for union\n",
                      allowed_attr[attr->type].display_name );
    }
    return attrs;
}

get_aliaschain_attrp()

void * get_aliaschain_attrp	(	const type_t *	type,
		enum attr_type attr_type attr_type
	)

Definition at line 96 of file attribute.c.

{
    for (;;)
    {
        if (is_attr( type->attrs, attr_type )) return get_attrp( type->attrs, attr_type );
        if (!type_is_alias( type )) return NULL;
        type = type_alias_get_aliasee_type( type );
    }
}

Referenced by write_remoting_arg(), and write_type_tfs().

get_attr_display_name()

static const char * get_attr_display_name ( enum attr_type  attr_type )

static

Definition at line 250 of file attribute.c.

{
    return allowed_attr[attr_type].display_name;
}

Referenced by append_attr().

get_attrp()

void * get_attrp	(	const attr_list_t *	list,
		enum attr_type attr_type attr_type
	)

Definition at line 87 of file attribute.c.

{
    const attr_t *attr;
    if (!list) return NULL;
    LIST_FOR_EACH_ENTRY( attr, list, const attr_t, entry )
        if (attr->type == attr_type) return attr->u.pval;
    return NULL;
}

Referenced by add_typeinfo_block(), append_type_signature(), cmp_iid(), compute_interface_signature_uuid(), do_write_c_method_def(), encode_type(), format_parameterized_type_signature(), gen_proxy(), get_aliaschain_attrp(), get_func_handle_var(), get_user_type(), is_callas(), is_interpreted_func(), output_typelib_regscript(), save_all_changes(), set_doc_string(), set_guid(), set_help_context(), set_help_file_name(), set_help_string_context(), set_help_string_dll(), set_lcid(), type_runtimeclass_define(), write_args(), write_client_func_decl(), write_clientinterfacedecl(), write_coclass(), write_com_interface_end(), write_com_interface_start(), write_cpp_method_def(), write_descriptors(), write_enums(), write_fields(), write_function_proto(), write_function_stubs(), write_id_data_stmts(), write_implicithandledecl(), write_interface(), write_ip_tfs(), write_library(), write_method_proto(), write_parameter_conf_or_var_exprs(), write_pointer_left(), write_progid(), write_remoting_arg(), write_rpc_interface_end(), write_rpc_interface_start(), write_runtimeclass(), write_runtimeclasses_registry(), write_serverinterfacedecl(), write_stubdescriptor(), write_type_definition(), write_type_left(), write_type_tfs(), write_typelib_interface(), write_union_tfs(), and write_widl_using_macros().

get_attrv()

unsigned int get_attrv	(	const attr_list_t *	list,
		enum attr_type attr_type attr_type
	)

Definition at line 78 of file attribute.c.

{
    const attr_t *attr;
    if (!list) return 0;
    LIST_FOR_EACH_ENTRY( attr, list, const attr_t, entry )
        if (attr->type == attr_type) return attr->u.ival;
    return 0;
}

Referenced by get_coclass_threading(), get_pointer_fc(), init_typeinfo(), output_typelib_regscript(), set_version(), write_apicontract(), write_clientinterfacedecl(), write_coclass(), write_dispatchtable(), write_nonsimple_pointer(), write_rpc_interface_start(), write_serverinterfacedecl(), and write_typelib_interface().

is_aliaschain_attr()

int is_aliaschain_attr	(	const type_t *	type,
		enum attr_type attr_type attr_type
	)

Definition at line 67 of file attribute.c.

{
    const type_t *t = type;
    for (;;)
    {
        if (is_attr( t->attrs, attr_type )) return 1;
        else if (type_is_alias( t )) t = type_alias_get_aliasee_type( t );
        else return 0;
    }
}

Referenced by check_interface_attrs(), get_enum_fc(), is_string_type(), typegen_detect_type(), write_function_stub(), and write_remoting_arg().

is_attr()

int is_attr	(	const attr_list_t *	list,
		enum attr_type attr_type attr_type
	)

Definition at line 45 of file attribute.c.

{
    const attr_t *attr;
    if (!list) return 0;
    LIST_FOR_EACH_ENTRY( attr, list, const attr_t, entry )
        if (attr->type == attr_type) return 1;
    return 0;
}

Referenced by add_entry(), add_interface_typeinfo(), append_type_signature(), assign_stub_out_args(), check_for_additional_prototype_types(), clear_output_vars(), declare_stub_args(), encode_type(), for_each_serializable(), get_aliaschain_attrp(), get_context_handle_offset(), get_context_handle_type_name(), get_contexthandle_flags(), get_explicit_generic_handle_type(), get_func_handle_var(), get_generic_handle_offset(), get_name(), get_parameter_fc(), get_pointer_fc_context(), get_required_buffer_size(), get_rpc_flags(), get_type_vt(), has_out_arg_or_return(), is_aliaschain_attr(), is_context_handle(), is_local(), is_ptrchain_attr(), is_string_type(), need_proxy(), output_typelib_regscript(), process_tfs_iface(), proxy_free_variables(), type_runtimeclass_get_default_iface(), typegen_detect_type(), write_client_ifaces(), write_com_interface_end(), write_com_interface_start(), write_descriptors(), write_forward_decls(), write_function_stub(), write_header_stmts(), write_id_data_stmts(), write_member_type(), write_nonsimple_pointer(), write_old_procformatstring_type(), write_proc_func_interp(), write_remoting_arg(), write_serialize_functions(), write_simple_pointer(), and write_union_tfs().

is_ptrchain_attr()

int is_ptrchain_attr	(	const var_t *	var,
		enum attr_type attr_type attr_type
	)

Definition at line 54 of file attribute.c.

{
    type_t *type = var->declspec.type;
    if (is_attr( var->attrs, attr_type )) return 1;
    for (;;)
    {
        if (is_attr( type->attrs, attr_type )) return 1;
        else if (type_is_alias( type )) type = type_alias_get_aliasee_type( type );
        else if (type_is_ptr( type )) type = type_pointer_get_ref_type( type );
        else return 0;
    }
}

Referenced by get_required_buffer_size().

map_attrs()

attr_list_t * map_attrs	(	const attr_list_t *	list,
		map_attrs_filter_t	filter
	)

Definition at line 302 of file attribute.c.

{
    attr_list_t *new_list;
    const attr_t *attr;
    attr_t *new_attr;
 
    if (!list) return NULL;
 
    new_list = xmalloc( sizeof(*list) );
    list_init( new_list );
    LIST_FOR_EACH_ENTRY( attr, list, const attr_t, entry )
    {
        if (filter && !filter( new_list, attr )) continue;
        new_attr = xmalloc( sizeof(*new_attr) );
        *new_attr = *attr;
        list_add_tail( new_list, &new_attr->entry );
    }
    return new_list;
}

move_attr()

attr_list_t * move_attr	(	attr_list_t *	dst,
		attr_list_t *	src,
		enum attr_type	type
	)

Definition at line 322 of file attribute.c.

{
    attr_t *attr;
    if (!src) return dst;
    LIST_FOR_EACH_ENTRY( attr, src, attr_t, entry )
    {
        if (attr->type == type)
        {
            list_remove( &attr->entry );
            return append_attr( dst, attr );
        }
    }
    return dst;
}

Variable Documentation

allowed_attr

struct allowed_attr allowed_attr[]

Definition at line 130 of file attribute.c.