widl.h File Reference

#include "../tools.h"
#include "widltypes.h"
#include <time.h>

Include dependency graph for widl.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	DEBUGLEVEL_NONE   0x0000
#define	DEBUGLEVEL_CHAT   0x0001
#define	DEBUGLEVEL_DUMP   0x0002
#define	DEBUGLEVEL_TRACE   0x0004
#define	DEBUGLEVEL_PPMSG   0x0008
#define	DEBUGLEVEL_PPLEX   0x0010
#define	DEBUGLEVEL_PPTRACE   0x0020

Typedefs
typedef int(*	map_attrs_filter_t) (attr_list_t *, const attr_t *)

Functions
int	open_typelib (const char *name)
void	write_header (const statement_list_t *stmts)
void	write_id_data (const statement_list_t *stmts)
void	write_proxies (const statement_list_t *stmts)
void	write_client (const statement_list_t *stmts)
void	write_server (const statement_list_t *stmts)
void	write_regscript (const statement_list_t *stmts)
void	write_typelib_regscript (const statement_list_t *stmts)
void	output_typelib_regscript (const typelib_t *typelib)
void	write_local_stubs (const statement_list_t *stmts)
void	write_dlldata (const statement_list_t *stmts)
void	start_cplusplus_guard (FILE *fp)
void	end_cplusplus_guard (FILE *fp)
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)
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 *, attr_list_t *)
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
int	debuglevel
int	pedantic
int	do_everything
int	do_header
int	do_typelib
int	do_proxies
int	do_client
int	do_server
int	do_regscript
int	do_idfile
int	do_dlldata
int	old_names
int	old_typelib
int	winrt_mode
int	interpreted_mode
int	use_abi_namespace
char *	input_name
char *	idl_name
char *	acf_name
char *	header_name
char *	header_token
char *	local_stubs_name
char *	typelib_name
char *	dlldata_name
char *	proxy_name
char *	proxy_token
char *	client_name
char *	client_token
char *	server_name
char *	server_token
char *	regscript_name
char *	regscript_token
const char *	prefix_client
const char *	prefix_server
unsigned int	packing
unsigned int	pointer_size
struct target	target
time_t	now

Macro Definition Documentation

DEBUGLEVEL_CHAT

#define DEBUGLEVEL_CHAT   0x0001

Definition at line 31 of file widl.h.

DEBUGLEVEL_DUMP

#define DEBUGLEVEL_DUMP   0x0002

Definition at line 32 of file widl.h.

DEBUGLEVEL_NONE

#define DEBUGLEVEL_NONE   0x0000

Definition at line 30 of file widl.h.

DEBUGLEVEL_PPLEX

#define DEBUGLEVEL_PPLEX   0x0010

Definition at line 35 of file widl.h.

DEBUGLEVEL_PPMSG

#define DEBUGLEVEL_PPMSG   0x0008

Definition at line 34 of file widl.h.

DEBUGLEVEL_PPTRACE

#define DEBUGLEVEL_PPTRACE   0x0020

Definition at line 36 of file widl.h.

DEBUGLEVEL_TRACE

#define DEBUGLEVEL_TRACE   0x0004

Definition at line 33 of file widl.h.

Typedef Documentation

map_attrs_filter_t

typedef int(* map_attrs_filter_t) (attr_list_t *, const attr_t *)

Definition at line 106 of file widl.h.

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,
		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,
		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;
}

end_cplusplus_guard()

void end_cplusplus_guard

(

FILE *

fp

)

Definition at line 275 of file widl.c.

{
  fprintf(fp, "#ifdef __cplusplus\n");
  fprintf(fp, "}\n");
  fprintf(fp, "#endif\n\n");
}

Referenced by write_dlldata_list(), write_header(), and write_id_data().

get_aliaschain_attrp()

void * get_aliaschain_attrp	(	const type_t *	type,
		enum 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_attrp()

void * get_attrp	(	const attr_list_t *	list,
		enum 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
	)

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
	)

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
	)

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
	)

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;
}

open_typelib()

int open_typelib

(

const char *

name

)

Definition at line 650 of file widl.c.

{
#ifndef __REACTOS__
    static const char *default_dirs[] = { LIBDIR "/wine", "/usr/lib/wine", "/usr/local/lib/wine" };
#endif
    struct target win_target = { target.cpu, PLATFORM_WINDOWS };
    const char *pe_dir = get_arch_dir( win_target );
    int fd;
    unsigned int i;
 
#define TRYOPEN(str) do { \
        char *file = str; \
        if ((fd = open( file, O_RDONLY | O_BINARY )) != -1) return fd; \
        free( file ); } while(0)
 
    for (i = 0; i < dlldirs.count; i++)
    {
        if (strendswith( dlldirs.str[i], "/*" ))  /* special case for wine build tree */
        {
            int namelen = strlen( name );
            if (strendswith( name, ".dll" )) namelen -= 4;
            TRYOPEN( strmake( "%.*s/%.*s%s/%s", (int)strlen(dlldirs.str[i]) - 2, dlldirs.str[i],
                              namelen, name, pe_dir, name ));
        }
        else
        {
            TRYOPEN( strmake( "%s%s/%s", dlldirs.str[i], pe_dir, name ));
            TRYOPEN( strmake( "%s/%s", dlldirs.str[i], name ));
        }
    }
 
#ifndef __REACTOS__
    if (stdinc)
    {
        if (libdir)
        {
            TRYOPEN( strmake( "%s/wine%s/%s", libdir, pe_dir, name ));
            TRYOPEN( strmake( "%s/wine/%s", libdir, name ));
        }
        for (i = 0; i < ARRAY_SIZE(default_dirs); i++)
        {
            if (i && !strcmp( default_dirs[i], default_dirs[0] )) continue;
            TRYOPEN( strmake( "%s%s/%s", default_dirs[i], pe_dir, name ));
        }
    }
#endif
 
    error( "cannot find %s\n", name );
#undef TRYOPEN
 
#ifdef __REACTOS__
  return 1;
#endif
}

Referenced by read_importlib().

output_typelib_regscript()

void output_typelib_regscript

(

const typelib_t *

typelib

)

Definition at line 334 of file register.c.

{
    const struct uuid *typelib_uuid = get_attrp( typelib->attrs, ATTR_UUID );
    const char *descr = get_attrp( typelib->attrs, ATTR_HELPSTRING );
    const expr_t *lcid_expr = get_attrp( typelib->attrs, ATTR_LIBLCID );
    unsigned int version = get_attrv( typelib->attrs, ATTR_VERSION );
    unsigned int flags = 0;
    char id_part[12] = "";
    char *resname = typelib_name;
    expr_t *expr;
 
    if (is_attr( typelib->attrs, ATTR_RESTRICTED )) flags |= 1; /* LIBFLAG_FRESTRICTED */
    if (is_attr( typelib->attrs, ATTR_CONTROL )) flags |= 2; /* LIBFLAG_FCONTROL */
    if (is_attr( typelib->attrs, ATTR_HIDDEN )) flags |= 4; /* LIBFLAG_FHIDDEN */
 
    put_str( indent, "HKCR\n" );
    put_str( indent++, "{\n" );
 
    put_str( indent, "NoRemove Typelib\n" );
    put_str( indent++, "{\n" );
    put_str( indent, "NoRemove '%s'\n", format_uuid( typelib_uuid ));
    put_str( indent++, "{\n" );
    put_str( indent, "'%u.%u' = s '%s'\n",
             MAJORVERSION(version), MINORVERSION(version), descr ? descr : typelib->name );
    put_str( indent++, "{\n" );
    expr = get_attrp( typelib->attrs, ATTR_ID );
    if (expr)
    {
        snprintf(id_part, sizeof(id_part), "\\%d", expr->cval);
        resname = strmake("%s\\%d", typelib_name, expr->cval);
    }
    put_str( indent, "'%x' { %s = s '%%MODULE%%%s' }\n",
             lcid_expr ? lcid_expr->cval : 0, pointer_size == 8 ? "win64" : "win32", id_part );
    put_str( indent, "FLAGS = s '%u'\n", flags );
    put_str( --indent, "}\n" );
    put_str( --indent, "}\n" );
    put_str( --indent, "}\n" );
 
    put_str( indent, "NoRemove Interface\n" );
    put_str( indent++, "{\n" );
    write_typelib_interfaces( typelib );
    put_str( --indent, "}\n" );
 
    put_str( indent, "NoRemove CLSID\n" );
    put_str( indent++, "{\n" );
    write_coclasses( typelib->stmts, typelib );
    put_str( --indent, "}\n" );
 
    write_progids( typelib->stmts );
    put_str( --indent, "}\n" );
 
    add_output_to_resources( "WINE_REGISTRY", resname );
}

Referenced by save_all_changes().

start_cplusplus_guard()

void start_cplusplus_guard

(

FILE *

fp

)

Definition at line 268 of file widl.c.

{
  fprintf(fp, "#ifdef __cplusplus\n");
  fprintf(fp, "extern \"C\" {\n");
  fprintf(fp, "#endif\n\n");
}

Referenced by write_dlldata_list(), write_header(), and write_id_data().

write_client()

void write_client

(

const statement_list_t *

stmts

)

Definition at line 613 of file client.c.

{
    if (!do_client)
        return;
    if (do_everything && !need_stub_files(stmts))
        return;
 
    init_client();
    if (!client)
        return;
 
    write_client_routines( stmts );
    fclose(client);
}

write_dlldata()

void write_dlldata

(

const statement_list_t *

stmts

)

Definition at line 329 of file widl.c.

{
  struct strarray filenames = empty_strarray;
  int define_proxy_delegation = 0;
  FILE *dlldata;
 
  if (!do_dlldata || !need_proxy_file(stmts))
    return;
 
  define_proxy_delegation = need_proxy_delegation(stmts);
 
  dlldata = fopen(dlldata_name, "r");
  if (dlldata) {
    static const char marker[] = "REFERENCE_PROXY_FILE";
    static const char delegation_define[] = "#define PROXY_DELEGATION";
    char *line = NULL;
    size_t len = 0;
 
    while (widl_getline(&line, &len, dlldata)) {
      char *start, *end;
      start = eat_space(line);
      if (strncmp(start, marker, sizeof marker - 1) == 0) {
        start = eat_space(start + sizeof marker - 1);
        if (*start != '(')
          continue;
        end = start = eat_space(start + 1);
        while (*end && *end != ')')
          ++end;
        if (*end != ')')
          continue;
        while (isspace((unsigned char) end[-1]))
          --end;
        *end = '\0';
        if (start < end)
          strarray_add(&filenames, replace_extension( get_basename( start ), ".idl", "" ));
      }else if (!define_proxy_delegation && strncmp(start, delegation_define, sizeof(delegation_define)-1)) {
          define_proxy_delegation = 1;
      }
    }
 
    if (ferror(dlldata))
      error("couldn't read from %s: %s\n", dlldata_name, strerror(errno));
 
    free(line);
    fclose(dlldata);
  }
 
  if (strarray_exists( &filenames, proxy_token ))
      /* We're already in the list, no need to regenerate this file.  */
      return;
 
  strarray_add(&filenames, proxy_token);
  write_dlldata_list(filenames, define_proxy_delegation);
}

write_header()

void write_header

(

const statement_list_t *

stmts

)

Definition at line 2083 of file header.c.

{
  FILE *header;
 
  if (!do_header) return;
 
  if(!(header = fopen(header_name, "w"))) {
    error("Could not open %s for output\n", header_name);
    return;
  }
  fprintf(header, "/*** Autogenerated by WIDL %s from %s - Do not edit ***/\n\n", PACKAGE_VERSION, input_name);
 
  fprintf(header, "#ifdef _WIN32\n");
  fprintf(header, "#ifndef __REQUIRED_RPCNDR_H_VERSION__\n");
  fprintf(header, "#define __REQUIRED_RPCNDR_H_VERSION__ 475\n");
#ifdef __REACTOS__
  fprintf(header, "#endif\n\n");
 
  fprintf(header, "#ifdef __REACTOS__\n");
  fprintf(header, "#define WIN32_LEAN_AND_MEAN\n");
  fprintf(header, "#endif\n\n");
#else
  fprintf(header, "#endif\n");
#endif
  fprintf(header, "#include <rpc.h>\n" );
  fprintf(header, "#include <rpcndr.h>\n" );
  if (!for_each_serializable(stmts, NULL, serializable_exists))
    fprintf(header, "#include <midles.h>\n" );
  fprintf(header, "#endif\n\n");
 
  fprintf(header, "#ifndef COM_NO_WINDOWS_H\n");
  fprintf(header, "#include <windows.h>\n");
  fprintf(header, "#include <ole2.h>\n");
  fprintf(header, "#endif\n\n");
 
  fprintf(header, "#ifndef __%s__\n", header_token);
  fprintf(header, "#define __%s__\n\n", header_token);
 
  fprintf(header, "/* Forward declarations */\n\n");
  write_forward_decls(header, stmts);
 
  fprintf(header, "/* Headers for imported files */\n\n");
  write_imports(header, stmts);
  fprintf(header, "\n");
  start_cplusplus_guard(header);
 
  write_header_stmts(header, stmts, NULL, FALSE);
 
  fprintf(header, "/* Begin additional prototypes for all interfaces */\n");
  fprintf(header, "\n");
  for_each_serializable(stmts, header, write_serialize_function_decl);
  write_user_types(header);
  write_generic_handle_routines(header);
  write_context_handle_rundowns(header);
  fprintf(header, "\n");
  fprintf(header, "/* End additional prototypes */\n");
  fprintf(header, "\n");
 
  end_cplusplus_guard(header);
  fprintf(header, "#endif /* __%s__ */\n", header_token);
 
  fclose(header);
}

write_id_data()

void write_id_data

(

const statement_list_t *

stmts

)

Definition at line 431 of file widl.c.

{
  if (!do_idfile) return;
 
  idfile = fopen(idfile_name, "w");
  if (! idfile) {
    error("Could not open %s for output\n", idfile_name);
    return;
  }
 
  fprintf(idfile, "/*** Autogenerated by WIDL %s ", PACKAGE_VERSION);
  fprintf(idfile, "from %s - Do not edit ***/\n\n", idl_name);
#ifdef __REACTOS__
  fprintf(idfile, "#ifdef __REACTOS__\n");
  fprintf(idfile, "#define WIN32_NO_STATUS\n");
  fprintf(idfile, "#define WIN32_LEAN_AND_MEAN\n");
  fprintf(idfile, "#endif\n\n");
#endif
  fprintf(idfile, "#include <rpc.h>\n");
  fprintf(idfile, "#include <rpcndr.h>\n\n");
 
  fprintf(idfile, "#ifdef _MIDL_USE_GUIDDEF_\n\n");
 
  fprintf(idfile, "#ifndef INITGUID\n");
  fprintf(idfile, "#define INITGUID\n");
  fprintf(idfile, "#include <guiddef.h>\n");
  fprintf(idfile, "#undef INITGUID\n");
  fprintf(idfile, "#else\n");
  fprintf(idfile, "#include <guiddef.h>\n");
  fprintf(idfile, "#endif\n\n");
 
  fprintf(idfile, "#define MIDL_DEFINE_GUID(type,name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) \\\n");
  fprintf(idfile, "    DEFINE_GUID(name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8)\n\n");
 
  fprintf(idfile, "#elif defined(__cplusplus)\n\n");
 
  fprintf(idfile, "#define MIDL_DEFINE_GUID(type,name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) \\\n");
  fprintf(idfile, "    EXTERN_C const type DECLSPEC_SELECTANY name = {l,w1,w2,{b1,b2,b3,b4,b5,b6,b7,b8}}\n\n");
 
  fprintf(idfile, "#else\n\n");
 
  fprintf(idfile, "#define MIDL_DEFINE_GUID(type,name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) \\\n");
  fprintf(idfile, "    const type DECLSPEC_SELECTANY name = {l,w1,w2,{b1,b2,b3,b4,b5,b6,b7,b8}}\n\n");
 
  fprintf(idfile, "#endif\n\n");
  start_cplusplus_guard(idfile);
 
  write_id_data_stmts(stmts);
 
  fprintf(idfile, "\n");
  end_cplusplus_guard(idfile);
  fprintf(idfile, "#undef MIDL_DEFINE_GUID\n" );
 
  fclose(idfile);
}

write_local_stubs()

void write_local_stubs

(

const statement_list_t *

stmts

)

Definition at line 1448 of file header.c.

{
  FILE *local_stubs;
 
  if (!local_stubs_name) return;
 
  local_stubs = fopen(local_stubs_name, "w");
  if (!local_stubs) {
    error("Could not open %s for output\n", local_stubs_name);
    return;
  }
  fprintf(local_stubs, "/* call_as/local stubs for %s */\n\n", input_name);
  fprintf(local_stubs, "#include <objbase.h>\n");
  fprintf(local_stubs, "#include \"%s\"\n\n", header_name);
 
  write_local_stubs_stmts(local_stubs, stmts);
 
  fclose(local_stubs);
}

write_proxies()

void write_proxies

(

const statement_list_t *

stmts

)

Definition at line 1072 of file proxy.c.

{
  if (!do_proxies) return;
  if (do_everything && !need_proxy_file(stmts)) return;
 
  init_proxy(stmts);
  if(!proxy) return;
 
  write_proxy_routines( stmts );
  fclose(proxy);
}

write_regscript()

void write_regscript

(

const statement_list_t *

stmts

)

Definition at line 244 of file register.c.

{
    const type_t *ps_factory;
 
    if (!do_regscript) return;
    if (do_everything && !need_proxy_file( stmts )) return;
 
    init_output_buffer();
 
    if (winrt_mode)
    {
        put_str( indent, "HKLM\n" );
        put_str( indent++, "{\n" );
        put_str( indent, "NoRemove Software\n" );
        put_str( indent++, "{\n" );
        put_str( indent, "NoRemove Microsoft\n" );
        put_str( indent++, "{\n" );
        put_str( indent, "NoRemove WindowsRuntime\n" );
        put_str( indent++, "{\n" );
        put_str( indent, "NoRemove ActivatableClassId\n" );
        put_str( indent++, "{\n" );
        write_runtimeclasses_registry( stmts );
        put_str( --indent, "}\n" );
        put_str( --indent, "}\n" );
        put_str( --indent, "}\n" );
        put_str( --indent, "}\n" );
        put_str( --indent, "}\n" );
    }
    else
    {
        put_str( indent, "HKCR\n" );
        put_str( indent++, "{\n" );
 
        ps_factory = find_ps_factory( stmts );
        if (ps_factory)
        {
            put_str( indent, "NoRemove Interface\n" );
            put_str( indent++, "{\n" );
            write_interfaces( stmts, ps_factory );
            put_str( --indent, "}\n" );
        }
 
        put_str( indent, "NoRemove CLSID\n" );
        put_str( indent++, "{\n" );
        write_coclasses( stmts, NULL );
        put_str( --indent, "}\n" );
 
        write_progids( stmts );
        put_str( --indent, "}\n" );
    }
 
    if (strendswith( regscript_name, ".res" ))  /* create a binary resource file */
    {
        add_output_to_resources( "WINE_REGISTRY", regscript_token );
        flush_output_resources( regscript_name );
    }
    else
    {
        FILE *f = fopen( regscript_name, "w" );
        if (!f) error( "Could not open %s for output\n", regscript_name );
        if (fwrite( output_buffer, 1, output_buffer_pos, f ) != output_buffer_pos)
            error( "Failed to write to %s\n", regscript_name );
        if (fclose( f ))
            error( "Failed to write to %s\n", regscript_name );
    }
}

write_server()

void write_server

(

const statement_list_t *

stmts

)

Definition at line 541 of file server.c.

{
    if (!do_server)
        return;
    if (do_everything && !need_stub_files(stmts))
        return;
 
    init_server();
    if (!server)
        return;
 
    write_server_routines( stmts );
    fclose(server);
}

write_typelib_regscript()

void write_typelib_regscript

(

const statement_list_t *

stmts

)

Definition at line 311 of file register.c.

{
    const statement_t *stmt;
    unsigned int count = 0;
 
    if (!do_typelib) return;
    if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry )
    {
        if (stmt->type != STMT_LIBRARY) continue;
        if (count && !strendswith( typelib_name, ".res" ))
            error( "Cannot store multiple typelibs into %s\n", typelib_name );
        else
        {
            if (old_typelib)
                create_sltg_typelib( stmt->u.lib );
            else
                create_msft_typelib( stmt->u.lib );
        }
        count++;
    }
    if (count && strendswith( typelib_name, ".res" )) flush_output_resources( typelib_name );
}

Variable Documentation

acf_name

char* acf_name

extern

Definition at line 118 of file widl.c.

Referenced by option_callback().

client_name

char* client_name

extern

Definition at line 126 of file widl.c.

Referenced by init_client(), main(), option_callback(), and rm_tempfile().

client_token

char* client_token

extern

Definition at line 127 of file widl.c.

Referenced by main(), and write_client_routines().

debuglevel

int debuglevel

extern

Definition at line 94 of file widl.c.

Referenced by chat(), dump_var_desc(), main(), and option_callback().

dlldata_name

char* dlldata_name

extern

Definition at line 123 of file widl.c.

Referenced by main(), option_callback(), write_dlldata(), and write_dlldata_list().

do_client

int do_client

extern

Definition at line 103 of file widl.c.

Referenced by main(), option_callback(), rm_tempfile(), set_everything(), and write_client().

do_dlldata

int do_dlldata

extern

Definition at line 107 of file widl.c.

Referenced by main(), option_callback(), set_everything(), and write_dlldata().

do_everything

int do_everything

extern

Definition at line 98 of file widl.c.

Referenced by main(), option_callback(), write_client(), write_proxies(), write_regscript(), and write_server().

do_header

int do_header

extern

Definition at line 100 of file widl.c.

Referenced by main(), option_callback(), rm_tempfile(), set_everything(), and write_header().

do_idfile

int do_idfile

extern

Definition at line 106 of file widl.c.

Referenced by main(), option_callback(), rm_tempfile(), set_everything(), and write_id_data().

do_proxies

int do_proxies

extern

Definition at line 102 of file widl.c.

Referenced by main(), option_callback(), rm_tempfile(), set_everything(), and write_proxies().

do_regscript

int do_regscript

extern

Definition at line 105 of file widl.c.

Referenced by main(), option_callback(), rm_tempfile(), set_everything(), and write_regscript().

do_server

int do_server

extern

Definition at line 104 of file widl.c.

Referenced by main(), option_callback(), rm_tempfile(), set_everything(), and write_server().

do_typelib

int do_typelib

extern

Definition at line 101 of file widl.c.

Referenced by main(), option_callback(), rm_tempfile(), set_everything(), and write_typelib_regscript().

header_name

char* header_name

extern

Definition at line 119 of file widl.c.

Referenced by get_channel_http_header(), init_client(), init_server(), main(), option_callback(), rm_tempfile(), write_header(), write_local_stubs(), and write_proxy_routines().

header_token

char* header_token

extern

Definition at line 121 of file widl.c.

Referenced by main(), and write_header().

idl_name

char* idl_name

extern

Definition at line 117 of file widl.c.

Referenced by main(), and write_id_data().

input_name

char* input_name

extern

Definition at line 116 of file widl.c.

Referenced by init_client(), init_proxy(), init_server(), main(), write_header(), and write_local_stubs().

interpreted_mode

int interpreted_mode

extern

Definition at line 112 of file widl.c.

Referenced by is_interpreted_func(), need_inline_stubs(), need_proxy_and_inline_stubs(), option_callback(), write_client_call_routine(), write_conf_or_var_desc(), write_descriptors(), write_function_stub(), write_member_type(), write_proxy(), write_proxy_routines(), write_serialize_function(), write_stub_methods(), write_stubdesc(), and write_stubdescriptor().

local_stubs_name

char* local_stubs_name

extern

Definition at line 120 of file widl.c.

Referenced by main(), option_callback(), rm_tempfile(), and write_local_stubs().

now

time_t now

extern

Definition at line 65 of file finger.c.

Referenced by __attribute__(), __drv_requiresIRQL(), _Dispatch_type_(), add_special_defines(), adns__fdevents(), adns__internal_submit(), adns__must_gettimeofday(), adns__procdgram(), adns__query_send(), adns__search_next(), adns__tcp_tryconnect(), adns__timeouts(), adns__update_expires(), adns_afterselect(), adns_beforeselect(), adns_check(), adns_firsttimeout(), adns_processany(), adns_processreadable(), adns_processtimeouts(), adns_processwriteable(), adns_submit(), authunix_create(), authunix_refresh(), CertDllVerifyRevocation(), ClasspRetryRequestDpc(), clnt_dg_create(), clnt_vc_create(), collect_connections(), connection_collector(), CoWaitForMultipleHandles(), create_cache_entry(), create_directory_fcb(), create_stream(), create_subvol(), delete_fileref(), delete_reparse_point(), do_create_snapshot(), DSoundRender_DoRenderSample(), duplicate_extents(), Ext2FirstUnusedMcb(), Ext2QueryUnusedBH(), Ext2QueryUnusedFcb(), fd_event(), file_create2(), FTPGetOneF(), FTPUpdateIOTimer(), get_test_year(), GetDynamicTimeZoneInformation(), GetStartSpoolDate(), gettimeofday(), InitLsMonths(), inter_maxtoabs(), LogOpen(), look_for_roots(), LsCacheLookup(), main(), MediaControl_Run(), mknod(), move_across_subvols(), NetBTWaitForNameResponse(), open_file3(), print_ttl(), QualityControlRender_WaitFor(), query_alloc(), query_simple(), query_submit(), query_usetcp(), queue_current_time(), queue_timer_expire(), readclock_GetTime(), recvd_subvol(), NotifyArea::Refresh(), run_child_process(), SClose(), set_basic_information(), set_file_security(), set_link_information(), set_rename_information(), set_reparse_point2(), set_symlink(), set_zero_data(), SnmpSvcGetUptime(), SRead(), SRecv(), SRecvfrom(), SSend(), SSendto(), SSendtoByName(), stream_set_end_of_file_information(), sw_check_timers(), SWaitUntilReadyForReading(), SWaitUntilReadyForWriting(), SWrite(), tcp_connected(), tcp_events(), test_buffer(), test_buffer8(), test_cache_read(), test_get_state(), test_urlcacheA(), timeouts_queue(), timerqueue_thread_proc(), TpSetTimer(), TpSetWait(), UnDate(), UnLslR(), UnLslRLine(), UnMDTMDate(), UNUSED(), update_chunk_cache(), update_chunk_caches(), urlcache_entry_is_expired(), waitqueue_thread_proc(), warp_check(), write_one_file(), write_volume_label(), and WriteDefaultFirewallPrefs().

old_names

int old_names

extern

Definition at line 109 of file widl.c.

Referenced by option_callback(), write_clientinterfacedecl(), write_rpc_interface_start(), and write_serverinterfacedecl().

old_typelib

int old_typelib

extern

Definition at line 110 of file widl.c.

Referenced by option_callback(), and write_typelib_regscript().

packing

unsigned int packing

extern

Definition at line 146 of file widl.c.

Referenced by clamp_align(), gl_pixel_addr_in_image(), HLPFILE_DecompressGfx(), and option_callback().

pedantic

int pedantic

extern

Definition at line 97 of file widl.c.

pointer_size

unsigned int pointer_size

extern

Definition at line 147 of file widl.c.

Referenced by add_coclass_typeinfo(), add_dispinterface_typeinfo(), add_func_desc(), add_interface_typeinfo(), add_var_desc(), create_msft_typelib(), create_sltg_typelib(), fill_params_array(), get_array_fc(), get_correlation_type(), get_element_size(), get_parameter_fc(), get_required_buffer_size_type(), get_stack_size(), get_struct_fc(), get_type_vt(), init_library(), is_interpreted_func(), main(), option_callback(), output_typelib_regscript(), print_phase_basetype(), put_pword(), type_memsize_and_alignment(), vncNewCursor(), write_client_ifaces(), write_conf_or_var_desc(), write_func_param_struct(), write_old_procformatstring_type(), write_proc_func_interp(), write_proxy_routines(), and write_server_stmts().

prefix_client

const char* prefix_client

extern

Definition at line 135 of file widl.c.

Referenced by option_callback(), write_client_func_decl(), write_clientinterfacedecl(), write_function_stub(), write_header_stmts(), and write_rpc_interface_start().

prefix_server

const char* prefix_server

extern

Definition at line 136 of file widl.c.

Referenced by option_callback(), write_function_stub(), write_header_stmts(), write_routinetable(), write_rpc_interface_start(), and write_serverinterfacedecl().

proxy_name

char* proxy_name

extern

Definition at line 124 of file widl.c.

Referenced by init_proxy(), main(), option_callback(), and rm_tempfile().

proxy_token

char* proxy_token

extern

Definition at line 125 of file widl.c.

Referenced by main(), write_dlldata(), and write_proxy_routines().

regscript_name

char* regscript_name

extern

Definition at line 130 of file widl.c.

Referenced by main(), rm_tempfile(), and write_regscript().

regscript_token

char* regscript_token

extern

Definition at line 131 of file widl.c.

Referenced by main(), and write_regscript().

server_name

char* server_name

extern

Definition at line 128 of file widl.c.

Referenced by create_rpcsec_auth_client(), get_client_for_multi_addr(), get_client_for_netaddr(), init_server(), main(), match_common_name(), match_dns_to_subject_alt_name(), match_dns_to_subject_dn(), option_callback(), rm_tempfile(), WTSOpenServerExA(), and WTSOpenServerExW().

server_token

char* server_token

extern

Definition at line 129 of file widl.c.

Referenced by main(), and write_server_routines().

target

struct target target

extern

Definition at line 190 of file glfuncs.h.

typelib_name

char* typelib_name

extern

Definition at line 122 of file widl.c.

Referenced by main(), option_callback(), output_typelib_regscript(), rm_tempfile(), save_all_changes(), and write_typelib_regscript().

use_abi_namespace

int use_abi_namespace

extern

Definition at line 113 of file widl.c.

Referenced by compute_delegate_iface_names(), format_parameterized_type_c_name(), option_callback(), write_namespace_end(), and write_namespace_start().

winrt_mode

int winrt_mode

extern

Definition at line 111 of file widl.c.

Referenced by check_struct_attrs(), option_callback(), write_apicontract_guard_end(), write_apicontract_guard_start(), write_com_interface_end(), write_regscript(), write_type_definition(), write_type_left(), and write_typedef().