header.h File Reference

#include "typetree.h"

Include dependency graph for header.h:

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

Go to the source code of this file.

Functions
int	is_ptrchain_attr (const var_t *var, enum attr_type t)
int	is_aliaschain_attr (const type_t *var, enum attr_type t)
int	is_attr (const attr_list_t *list, enum attr_type t)
void *	get_attrp (const attr_list_t *list, enum attr_type t)
unsigned int	get_attrv (const attr_list_t *list, enum attr_type t)
const char *	get_name (const var_t *v)
void	write_type_left (FILE *h, type_t *t, enum name_type name_type, int declonly)
void	write_type_right (FILE *h, type_t *t, int is_field)
void	write_type_decl (FILE *f, type_t *t, const char *name)
void	write_type_decl_left (FILE *f, type_t *t)
unsigned int	get_context_handle_offset (const type_t *type)
unsigned int	get_generic_handle_offset (const type_t *type)
int	needs_space_after (type_t *t)
int	is_object (const type_t *iface)
int	is_local (const attr_list_t *list)
int	count_methods (const type_t *iface)
int	need_stub (const type_t *iface)
int	need_proxy (const type_t *iface)
int	need_inline_stubs (const type_t *iface)
int	need_stub_files (const statement_list_t *stmts)
int	need_proxy_file (const statement_list_t *stmts)
int	need_proxy_delegation (const statement_list_t *stmts)
int	need_inline_stubs_file (const statement_list_t *stmts)
const var_t *	is_callas (const attr_list_t *list)
void	write_args (FILE *h, const var_list_t *arg, const char *name, int obj, int do_indent)
const type_t *	get_explicit_generic_handle_type (const var_t *var)
const var_t *	get_func_handle_var (const type_t *iface, const var_t *func, unsigned char *explicit_fc, unsigned char *implicit_fc)
int	has_out_arg_or_return (const var_t *func)
int	is_const_decl (const var_t *var)
void	write_serialize_functions (FILE *file, const type_t *type, const type_t *iface)
static int	is_ptr (const type_t *t)
static int	is_array (const type_t *t)
static int	is_void (const type_t *t)
static int	is_declptr (const type_t *t)
static int	is_conformant_array (const type_t *t)
static int	last_ptr (const type_t *type)
static int	last_array (const type_t *type)
static int	is_string_type (const attr_list_t *attrs, const type_t *type)
static int	is_context_handle (const type_t *type)

Function Documentation

count_methods()

int count_methods

(

const type_t *

iface

)

Definition at line 465 of file proxy.c.

{
    const statement_t *stmt;
    int count = 0;
 
    if (type_iface_get_inherit(iface))
        count = count_methods(type_iface_get_inherit(iface));
 
    STATEMENTS_FOR_EACH_FUNC(stmt, type_iface_get_stmts(iface)) {
        const var_t *func = stmt->u.var;
        if (!is_callas(func->attrs)) count++;
    }
    return count;
}

Referenced by count_methods(), write_iface_procformatstring(), write_interface(), and write_proxy().

get_attrp()

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

Definition at line 107 of file header.c.

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

Referenced by add_typeinfo_block(), cmp_iid(), do_write_c_method_def(), 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(), write_args(), write_client_func_decl(), write_clientinterfacedecl(), write_coclass(), write_com_interface_end(), write_cpp_method_def(), write_descriptors(), 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_progid(), write_remoting_arg(), write_rpc_interface_start(), write_serverinterfacedecl(), write_stubdescriptor(), write_type_tfs(), write_type_v(), write_typelib_interface(), and write_union_tfs().

get_attrv()

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

Definition at line 115 of file header.c.

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

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

get_context_handle_offset()

unsigned int get_context_handle_offset

(

const type_t *

type

)

Definition at line 598 of file header.c.

{
    context_handle_t *ch;
    unsigned int index = 0;
 
    while (!is_attr( type->attrs, ATTR_CONTEXTHANDLE ))
    {
        if (type_is_alias( type )) type = type_alias_get_aliasee( type );
        else if (is_ptr( type )) type = type_pointer_get_ref( type );
        else error( "internal error: %s is not a context handle\n", type->name );
    }
    LIST_FOR_EACH_ENTRY( ch, &context_handle_list, context_handle_t, entry )
    {
        if (!strcmp( type->name, ch->name )) return index;
        index++;
    }
    error( "internal error: %s is not registered as a context handle\n", type->name );
    return index;
}

Referenced by write_contexthandle_tfs(), and write_proc_func_header().

get_explicit_generic_handle_type()

const type_t * get_explicit_generic_handle_type

(

const var_t *

var

)

Definition at line 855 of file header.c.

{
    const type_t *t;
    for (t = var->type;
         is_ptr(t) || type_is_alias(t);
         t = type_is_alias(t) ? type_alias_get_aliasee(t) : type_pointer_get_ref(t))
        if ((type_get_type_detect_alias(t) != TYPE_BASIC || type_basic_get_type(t) != TYPE_BASIC_HANDLE) &&
            is_attr(t->attrs, ATTR_HANDLE))
            return t;
    return NULL;
}

Referenced by get_func_handle_var(), and write_function_stub().

get_func_handle_var()

const var_t * get_func_handle_var	(	const type_t *	iface,
		const var_t *	func,
		unsigned char *	explicit_fc,
		unsigned char *	implicit_fc
	)

Definition at line 867 of file header.c.

{
    const var_t *var;
    const var_list_t *args = type_get_function_args( func->type );
 
    *explicit_fc = *implicit_fc = 0;
    if (args) LIST_FOR_EACH_ENTRY( var, args, const var_t, entry )
    {
        if (!is_attr( var->attrs, ATTR_IN ) && is_attr( var->attrs, ATTR_OUT )) continue;
        if (type_get_type( var->type ) == TYPE_BASIC && type_basic_get_type( var->type ) == TYPE_BASIC_HANDLE)
        {
            *explicit_fc = FC_BIND_PRIMITIVE;
            return var;
        }
        if (get_explicit_generic_handle_type( var ))
        {
            *explicit_fc = FC_BIND_GENERIC;
            return var;
        }
        if (is_context_handle( var->type ))
        {
            *explicit_fc = FC_BIND_CONTEXT;
            return var;
        }
    }
 
    if ((var = get_attrp( iface->attrs, ATTR_IMPLICIT_HANDLE )))
    {
        if (type_get_type( var->type ) == TYPE_BASIC &&
            type_basic_get_type( var->type ) == TYPE_BASIC_HANDLE)
            *implicit_fc = FC_BIND_PRIMITIVE;
        else
            *implicit_fc = FC_BIND_GENERIC;
        return var;
    }
 
    *implicit_fc = FC_AUTO_HANDLE;
    return NULL;
}

Referenced by write_function_stub(), write_proc_func_header(), and write_procformatstring_func().

get_generic_handle_offset()

unsigned int get_generic_handle_offset

(

const type_t *

type

)

Definition at line 618 of file header.c.

{
    generic_handle_t *gh;
    unsigned int index = 0;
 
    while (!is_attr( type->attrs, ATTR_HANDLE ))
    {
        if (type_is_alias( type )) type = type_alias_get_aliasee( type );
        else if (is_ptr( type )) type = type_pointer_get_ref( type );
        else error( "internal error: %s is not a generic handle\n", type->name );
    }
    LIST_FOR_EACH_ENTRY( gh, &generic_handle_list, generic_handle_t, entry )
    {
        if (!strcmp( type->name, gh->name )) return index;
        index++;
    }
    error( "internal error: %s is not registered as a generic handle\n", type->name );
    return index;
}

Referenced by write_proc_func_header().

get_name()

const char * get_name

(

const var_t *

v

)

Definition at line 181 of file header.c.

{
    static char buffer[256];
 
    if (is_attr( v->attrs, ATTR_PROPGET ))
        strcpy( buffer, "get_" );
    else if (is_attr( v->attrs, ATTR_PROPPUT ))
        strcpy( buffer, "put_" );
    else if (is_attr( v->attrs, ATTR_PROPPUTREF ))
        strcpy( buffer, "putref_" );
    else
        buffer[0] = 0;
    strcat( buffer, v->name );
    return buffer;
}

Referenced by do_write_c_method_def(), get_vtbl_entry_name(), is_inherited_method(), is_override_method(), write_cpp_method_def(), write_enums(), write_function_proto(), write_inline_wrappers(), write_locals(), write_method_macro(), and write_method_proto().

has_out_arg_or_return()

int has_out_arg_or_return

(

const var_t *

func

)

Definition at line 908 of file header.c.

{
    const var_t *var;
 
    if (!is_void(type_function_get_rettype(func->type)))
        return 1;
 
    if (!type_get_function_args(func->type))
        return 0;
 
    LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry )
        if (is_attr(var->attrs, ATTR_OUT))
            return 1;
 
    return 0;
}

Referenced by write_function_stub().

is_aliaschain_attr()

int is_aliaschain_attr	(	const type_t *	var,
		enum attr_type	t
	)

Definition at line 86 of file header.c.

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

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

is_array()

static int is_array ( const type_t *  t )

inlinestatic

Definition at line 64 of file header.h.

{
    return type_get_type(t) == TYPE_ARRAY;
}

Referenced by assign_stub_out_args(), builtin_vt(), check_for_additional_prototype_types(), clear_output_vars(), encode_var(), gen_proxy(), gen_stub(), get_pointer_fc(), get_size_is_expr(), get_struct_fc(), is_conformant_array(), last_array(), needs_space_after(), resolve_expression(), shader_glsl_get_coord_size(), write_conf_or_var_desc(), write_func_param_struct(), write_function_stub(), write_old_procformatstring_type(), write_pointer_description(), write_pointer_description_offsets(), write_pointer_left(), write_remoting_arg(), write_string_tfs(), write_type_right(), write_var_desc(), write_var_init(), and write_varying_array_pointer_descriptions().

is_attr()

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

Definition at line 99 of file header.c.

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

Referenced by add_entry(), add_interface_typeinfo(), 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_const_decl(), is_context_handle(), is_local(), is_ptrchain_attr(), is_string_type(), need_proxy(), output_typelib_regscript(), process_tfs_iface(), proxy_free_variables(), 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_header(), write_remoting_arg(), write_serialize_functions(), write_simple_pointer(), write_type_left(), write_type_v(), write_typelib_interface(), and write_union_tfs().

is_callas()

const var_t * is_callas

(

const attr_list_t *

list

)

Definition at line 943 of file header.c.

{
  return get_attrp(a, ATTR_CALLAS);
}

Referenced by compute_method_indexes(), count_methods(), do_write_c_method_def(), gen_proxy(), gen_stub_thunk(), get_callas_source(), is_inherited_method(), is_override_method(), write_cpp_method_def(), write_inline_wrappers(), write_locals(), write_method_macro(), write_method_proto(), write_proxy(), write_proxy_methods(), write_proxy_procformatstring_offsets(), write_stub_methods(), and write_thunk_methods().

is_conformant_array()

static int is_conformant_array ( const type_t *  t )

inlinestatic

Definition at line 79 of file header.h.

{
    return is_array(t) && type_array_has_conformance(t);
}

Referenced by declare_stub_args(), find_array_or_string_in_struct(), get_parameter_fc(), get_struct_fc(), type_memsize_and_alignment(), write_array_tfs(), write_conformant_array_pointer_descriptions(), write_member_type(), write_no_repeat_pointer_descriptions(), write_pointer_description(), write_remoting_arg(), write_string_tfs(), write_struct_members(), write_type_right(), and write_type_tfs().

is_const_decl()

int is_const_decl

(

const var_t *

var

)

Definition at line 801 of file header.c.

{
  const type_t *t;
  /* strangely, MIDL accepts a const attribute on any pointer in the
  * declaration to mean that data isn't being instantiated. this appears
  * to be a bug, but there is no benefit to being incompatible with MIDL,
  * so we'll do the same thing */
  for (t = var->type; ; )
  {
    if (is_attr(t->attrs, ATTR_CONST))
      return TRUE;
    else if (is_ptr(t))
      t = type_pointer_get_ref(t);
    else break;
  }
  return FALSE;
}

Referenced by write_declaration().

is_context_handle()

static int is_context_handle ( const type_t *  type )

inlinestatic

Definition at line 100 of file header.h.

{
    const type_t *t;
    for (t = type;
         is_ptr(t) || type_is_alias(t);
         t = type_is_alias(t) ? type_alias_get_aliasee(t) : type_pointer_get_ref(t))
        if (is_attr(t->attrs, ATTR_CONTEXTHANDLE))
            return 1;
    return 0;
}

Referenced by declare_stub_args(), get_func_handle_var(), and write_function_stub().

is_declptr()

static int is_declptr ( const type_t *  t )

inlinestatic

Definition at line 74 of file header.h.

{
    return is_ptr(t) || (type_get_type(t) == TYPE_ARRAY && type_array_is_decl_as_ptr(t));
}

Referenced by get_parameter_fc(), last_ptr(), write_nonsimple_pointer(), write_remoting_arg(), and write_string_tfs().

is_local()

int is_local

(

const attr_list_t *

list

)

Definition at line 938 of file header.c.

{
  return is_attr(a, ATTR_LOCAL);
}

Referenced by add_dispinterface_typeinfo(), add_func_desc(), add_interface_typeinfo(), codeview_add_variable(), get_size_procformatstring_iface(), need_delegation(), need_inline_stubs(), need_proxy(), need_proxy_and_inline_stubs(), need_stub(), process_tfs_iface(), write_iface_procformatstring(), write_interface(), write_procformatstring_offsets(), write_proxy(), write_proxy_methods(), write_proxy_procformatstring_offsets(), write_routinetable(), write_stub_methods(), and write_thunk_methods().

is_object()

int is_object

(

const type_t *

iface

)

Definition at line 928 of file header.c.

{
    const attr_t *attr;
    if (type_is_defined(iface) && type_iface_get_inherit(iface))
        return 1;
    if (iface->attrs) LIST_FOR_EACH_ENTRY( attr, iface->attrs, const attr_t, entry )
        if (attr->type == ATTR_OBJECT || attr->type == ATTR_ODL) return 1;
    return 0;
}

Referenced by get_pointer_fc_context(), need_proxy(), need_stub(), write_client_call_routine(), write_conf_or_var_desc(), write_forward_decls(), write_func_param_struct(), write_header_stmts(), write_id_data_stmts(), write_interface(), write_locals(), write_proc_func_header(), write_procformatstring_func(), and write_typelib_interface().

is_ptr()

static int is_ptr ( const type_t *  t )

inlinestatic

Definition at line 59 of file header.h.

{
    return type_get_type(t) == TYPE_POINTER;
}

Referenced by check_for_additional_prototype_types(), check_scalar_type(), clear_output_vars(), encode_type(), encode_var(), gen_proxy(), get_context_handle_offset(), get_context_handle_type_name(), get_contexthandle_flags(), get_explicit_generic_handle_type(), get_generic_handle_offset(), get_pointer_fc(), is_const_decl(), is_context_handle(), is_declptr(), is_ptrchain_attr(), last_ptr(), needs_space_after(), print_phase_basetype(), resolve_expression(), user_type_has_variable_size(), write_array_element_type(), write_conf_or_var_desc(), write_default_value(), write_func_param_struct(), write_function_stub(), write_ip_tfs(), write_member_type(), write_no_repeat_pointer_descriptions(), write_nonsimple_pointer(), write_pointer_description_offsets(), write_remoting_arg(), write_type_left(), write_type_v(), write_var_desc(), and write_var_init().

is_ptrchain_attr()

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

Definition at line 66 of file header.c.

{
    if (is_attr(var->attrs, t))
        return 1;
    else
    {
        type_t *type = var->type;
        for (;;)
        {
            if (is_attr(type->attrs, t))
                return 1;
            else if (type_is_alias(type))
                type = type_alias_get_aliasee(type);
            else if (is_ptr(type))
                type = type_pointer_get_ref(type);
            else return 0;
        }
    }
}

Referenced by get_required_buffer_size().

is_string_type()

static int is_string_type ( const attr_list_t *  attrs, const type_t *  type  )

inlinestatic

Definition at line 94 of file header.h.

{
    return ((is_attr(attrs, ATTR_STRING) || is_aliaschain_attr(type, ATTR_STRING))
            && (last_ptr(type) || last_array(type)));
}

Referenced by builtin_vt(), get_parameter_fc(), get_required_buffer_size(), get_required_buffer_size_type(), get_struct_fc(), typegen_detect_type(), write_array_element_type(), write_array_tfs(), write_pointer_description_offsets(), write_simple_pointer(), write_struct_tfs(), and write_type_tfs().

is_void()

static int is_void ( const type_t *  t )

inlinestatic

Definition at line 69 of file header.h.

{
    return type_get_type(t) == TYPE_VOID;
}

Referenced by declare_stub_args(), gen_proxy(), gen_stub(), gen_stub_thunk(), get_func_oi2_flags(), get_function_buffer_size(), has_out_arg_or_return(), process_tfs_iface(), write_client_call_routine(), write_func_param_struct(), write_function_stub(), write_inline_wrappers(), write_parameters_init(), write_proc_func_header(), and write_procformatstring_func().

last_array()

static int last_array ( const type_t *  type )

inlinestatic

Definition at line 89 of file header.h.

{
    return is_array(type) && !is_array(type_array_get_element(type));
}

Referenced by is_string_type().

last_ptr()

static int last_ptr ( const type_t *  type )

inlinestatic

Definition at line 84 of file header.h.

{
    return is_ptr(type) && !is_declptr(type_pointer_get_ref(type));
}

Referenced by is_string_type().

need_inline_stubs()

int need_inline_stubs

(

const type_t *

iface

)

Definition at line 819 of file proxy.c.

{
    const statement_t *stmt;
 
    if (get_stub_mode() == MODE_Os) return 1;
 
    STATEMENTS_FOR_EACH_FUNC( stmt, type_iface_get_stmts(iface) )
    {
        const var_t *func = stmt->u.var;
        if (is_local( func->attrs )) continue;
        if (!is_interpreted_func( iface, func )) return 1;
    }
    return 0;
}

Referenced by need_inline_stubs_file(), and write_proxy().

need_inline_stubs_file()

int need_inline_stubs_file

(

const statement_list_t *

stmts

)

Definition at line 855 of file proxy.c.

{
  return does_any_iface(stmts, need_inline_stubs);
}

Referenced by write_client_routines(), and write_server_routines().

need_proxy()

int need_proxy

(

const type_t *

iface

)

Definition at line 796 of file proxy.c.

{
    if (!is_object( iface )) return 0;
    if (is_local( iface->attrs )) return 0;
    if (is_attr( iface->attrs, ATTR_DISPINTERFACE )) return 0;
    return 1;
}

Referenced by build_iface_list(), need_proxy_and_inline_stubs(), need_proxy_file(), write_proxy_routines(), and write_proxy_stmts().

need_proxy_delegation()

int need_proxy_delegation

(

const statement_list_t *

stmts

)

Definition at line 814 of file proxy.c.

{
    return does_any_iface(stmts, need_delegation);
}

Referenced by write_dlldata().

need_proxy_file()

int need_proxy_file

(

const statement_list_t *

stmts

)

Definition at line 809 of file proxy.c.

{
    return does_any_iface(stmts, need_proxy);
}

Referenced by write_dlldata(), write_proxies(), and write_regscript().

need_stub()

int need_stub

(

const type_t *

iface

)

Definition at line 804 of file proxy.c.

{
  return !is_object(iface) && !is_local(iface->attrs);
}

Referenced by need_stub_files(), write_client_ifaces(), write_client_routines(), write_server_routines(), and write_server_stmts().

need_stub_files()

int need_stub_files

(

const statement_list_t *

stmts

)

Definition at line 850 of file proxy.c.

{
  return does_any_iface(stmts, need_stub);
}

Referenced by write_client(), and write_server().

needs_space_after()

int needs_space_after

(

type_t *

t

)

Definition at line 282 of file header.c.

{
  return (type_is_alias(t) ||
          (!is_ptr(t) && (!is_array(t) || !type_array_is_decl_as_ptr(t) || t->name)));
}

Referenced by write_func_param_struct(), write_pointer_left(), and write_type_v().

write_args()

void write_args	(	FILE *	h,
		const var_list_t *	arg,
		const char *	name,
		int	obj,
		int	do_indent
	)

Definition at line 1058 of file header.c.

{
  const var_t *arg;
  int count = 0;
 
  if (do_indent)
  {
      indentation++;
      indent(h, 0);
  }
  if (method == 1) {
    fprintf(h, "%s* This", name);
    count++;
  }
  if (args) LIST_FOR_EACH_ENTRY( arg, args, const var_t, entry ) {
    if (count) {
        if (do_indent)
        {
            fprintf(h, ",\n");
            indent(h, 0);
        }
        else fprintf(h, ",");
    }
    write_type_decl(h, arg->type, arg->name);
    if (method == 2) {
        const expr_t *expr = get_attrp(arg->attrs, ATTR_DEFAULTVALUE);
        if (expr) {
            const var_t *tail_arg;
 
            /* Output default value only if all following arguments also have default value. */
            LIST_FOR_EACH_ENTRY_REV( tail_arg, args, const var_t, entry ) {
                if(tail_arg == arg) {
                    expr_t bstr;
 
                    /* Fixup the expression type for a BSTR like midl does. */
                    if (get_type_vt(arg->type) == VT_BSTR && expr->type == EXPR_STRLIT)
                    {
                        bstr = *expr;
                        bstr.type = EXPR_WSTRLIT;
                        expr = &bstr;
                    }
 
                    fprintf(h, " = ");
                    write_expr( h, expr, 0, 1, NULL, NULL, "" );
                    break;
                }
                if(!get_attrp(tail_arg->attrs, ATTR_DEFAULTVALUE))
                    break;
            }
        }
    }
    count++;
  }
  if (do_indent) indentation--;
}

Referenced by do_write_c_method_def(), gen_proxy(), nfs41_write(), write_client_func_decl(), write_cpp_method_def(), write_function_proto(), write_inline_wrappers(), write_locals(), write_method_proto(), and write_type_v().

write_serialize_functions()

void write_serialize_functions	(	FILE *	file,
		const type_t *	type,
		const type_t *	iface
	)

Definition at line 338 of file client.c.

{
    if (is_attr(type->attrs, ATTR_ENCODE))
    {
        write_serialize_function(file, type, iface, "AlignSize", "SIZE_T");
        write_serialize_function(file, type, iface, "Encode", NULL);
    }
    if (is_attr(type->attrs, ATTR_DECODE))
    {
        write_serialize_function(file, type, iface, "Decode", NULL);
        write_serialize_function(file, type, iface, "Free", NULL);
    }
}

Referenced by write_function_stubs(), and write_serialize_function_decl().

write_type_decl()

void write_type_decl	(	FILE *	f,
		type_t *	t,
		const char *	name
	)

Definition at line 561 of file header.c.

{
  write_type_v(f, t, FALSE, TRUE, name);
}

Referenced by declare_stub_args(), gen_proxy(), print_phase_basetype(), print_start_tfs_comment(), write_args(), write_expr(), write_func_param_struct(), write_function_stub(), write_implicithandledecl(), write_locals(), write_remoting_arg(), and write_rpc_interface_start().

write_type_decl_left()

void write_type_decl_left	(	FILE *	f,
		type_t *	t
	)

Definition at line 566 of file header.c.

{
  write_type_left(f, t, NAME_DEFAULT, TRUE);
}

Referenced by declare_stub_args(), do_write_c_method_def(), gen_proxy(), write_client_call_routine(), write_client_func_decl(), write_cpp_method_def(), write_function_proto(), write_function_stub(), write_inline_wrappers(), write_locals(), and write_method_proto().

write_type_left()

void write_type_left	(	FILE *	h,
		type_t *	t,
		enum name_type	name_type,
		int	declonly
	)

Definition at line 297 of file header.c.

{
  const char *name;
 
  if (!h) return;
 
  name = type_get_name(t, name_type);
 
  if (is_attr(t->attrs, ATTR_CONST) &&
      (type_is_alias(t) || !is_ptr(t)))
    fprintf(h, "const ");
 
  if (type_is_alias(t)) fprintf(h, "%s", t->name);
  else {
    switch (type_get_type_detect_alias(t)) {
      case TYPE_ENUM:
        if (!declonly && t->defined && !t->written) {
          if (name) fprintf(h, "enum %s {\n", name);
          else fprintf(h, "enum {\n");
          t->written = TRUE;
          indentation++;
          write_enums(h, type_enum_get_values(t), is_global_namespace(t->namespace) ? NULL : t->name);
          indent(h, -1);
          fprintf(h, "}");
        }
        else fprintf(h, "enum %s", name ? name : "");
        break;
      case TYPE_STRUCT:
      case TYPE_ENCAPSULATED_UNION:
        if (!declonly && t->defined && !t->written) {
          if (name) fprintf(h, "struct %s {\n", name);
          else fprintf(h, "struct {\n");
          t->written = TRUE;
          indentation++;
          if (type_get_type(t) != TYPE_STRUCT)
            write_fields(h, type_encapsulated_union_get_fields(t));
          else
            write_fields(h, type_struct_get_fields(t));
          indent(h, -1);
          fprintf(h, "}");
        }
        else fprintf(h, "struct %s", name ? name : "");
        break;
      case TYPE_UNION:
        if (!declonly && t->defined && !t->written) {
          if (t->name) fprintf(h, "union %s {\n", t->name);
          else fprintf(h, "union {\n");
          t->written = TRUE;
          indentation++;
          write_fields(h, type_union_get_cases(t));
          indent(h, -1);
          fprintf(h, "}");
        }
        else fprintf(h, "union %s", t->name ? t->name : "");
        break;
      case TYPE_POINTER:
      {
        write_type_left(h, type_pointer_get_ref(t), name_type, declonly);
        write_pointer_left(h, type_pointer_get_ref(t));
        if (is_attr(t->attrs, ATTR_CONST)) fprintf(h, "const ");
        break;
      }
      case TYPE_ARRAY:
        if (t->name && type_array_is_decl_as_ptr(t))
          fprintf(h, "%s", t->name);
        else
        {
          write_type_left(h, type_array_get_element(t), name_type, declonly);
          if (type_array_is_decl_as_ptr(t))
            write_pointer_left(h, type_array_get_element(t));
        }
        break;
      case TYPE_BASIC:
        if (type_basic_get_type(t) != TYPE_BASIC_INT32 &&
            type_basic_get_type(t) != TYPE_BASIC_INT64 &&
            type_basic_get_type(t) != TYPE_BASIC_LONG &&
            type_basic_get_type(t) != TYPE_BASIC_HYPER)
        {
          if (type_basic_get_sign(t) < 0) fprintf(h, "signed ");
          else if (type_basic_get_sign(t) > 0) fprintf(h, "unsigned ");
        }
        switch (type_basic_get_type(t))
        {
        case TYPE_BASIC_INT8: fprintf(h, "small"); break;
        case TYPE_BASIC_INT16: fprintf(h, "short"); break;
        case TYPE_BASIC_INT: fprintf(h, "int"); break;
        case TYPE_BASIC_INT3264: fprintf(h, "__int3264"); break;
        case TYPE_BASIC_BYTE: fprintf(h, "byte"); break;
        case TYPE_BASIC_CHAR: fprintf(h, "char"); break;
        case TYPE_BASIC_WCHAR: fprintf(h, "wchar_t"); break;
        case TYPE_BASIC_FLOAT: fprintf(h, "float"); break;
        case TYPE_BASIC_DOUBLE: fprintf(h, "double"); break;
        case TYPE_BASIC_ERROR_STATUS_T: fprintf(h, "error_status_t"); break;
        case TYPE_BASIC_HANDLE: fprintf(h, "handle_t"); break;
        case TYPE_BASIC_INT32:
          if (type_basic_get_sign(t) > 0)
            fprintf(h, "UINT32");
          else
            fprintf(h, "INT32");
          break;
        case TYPE_BASIC_LONG:
          if (type_basic_get_sign(t) > 0)
            fprintf(h, "ULONG");
          else
            fprintf(h, "LONG");
          break;
        case TYPE_BASIC_INT64:
          if (type_basic_get_sign(t) > 0)
            fprintf(h, "UINT64");
          else
            fprintf(h, "INT64");
          break;
        case TYPE_BASIC_HYPER:
          if (type_basic_get_sign(t) > 0)
            fprintf(h, "MIDL_uhyper");
          else
            fprintf(h, "hyper");
          break;
        }
        break;
      case TYPE_INTERFACE:
      case TYPE_MODULE:
      case TYPE_COCLASS:
        fprintf(h, "%s", t->name);
        break;
      case TYPE_VOID:
        fprintf(h, "void");
        break;
      case TYPE_BITFIELD:
        write_type_left(h, type_bitfield_get_field(t), name_type, declonly);
        break;
      case TYPE_ALIAS:
      case TYPE_FUNCTION:
        /* handled elsewhere */
        assert(0);
        break;
    }
  }
}

Referenced by write_expr_eval_routines(), write_func_param_struct(), write_type_decl_left(), write_type_definition(), write_type_left(), and write_type_v().

write_type_right()

void write_type_right	(	FILE *	h,
		type_t *	t,
		int	is_field
	)

Definition at line 437 of file header.c.

{
  if (!h) return;
  if (type_is_alias(t)) return;
 
  switch (type_get_type(t))
  {
  case TYPE_ARRAY:
  {
    type_t *elem = type_array_get_element(t);
    if (type_array_is_decl_as_ptr(t))
    {
      if (!type_is_alias(elem) && is_array(elem) && !type_array_is_decl_as_ptr(elem))
        fprintf(h, ")");
    }
    else
    {
      if (is_conformant_array(t))
        fprintf(h, "[%s]", is_field ? "1" : "");
      else
        fprintf(h, "[%u]", type_array_get_dim(t));
    }
    write_type_right(h, elem, FALSE);
    break;
  }
  case TYPE_POINTER:
  {
    type_t *ref = type_pointer_get_ref(t);
    if (!type_is_alias(ref) && is_array(ref) && !type_array_is_decl_as_ptr(ref))
      fprintf(h, ")");
    write_type_right(h, ref, FALSE);
    break;
  }
  case TYPE_BITFIELD:
    fprintf(h, " : %u", type_bitfield_get_bits(t)->cval);
    break;
  case TYPE_VOID:
  case TYPE_BASIC:
  case TYPE_ENUM:
  case TYPE_STRUCT:
  case TYPE_ENCAPSULATED_UNION:
  case TYPE_UNION:
  case TYPE_ALIAS:
  case TYPE_MODULE:
  case TYPE_COCLASS:
  case TYPE_FUNCTION:
  case TYPE_INTERFACE:
    break;
  }
}

Referenced by declare_stub_args(), write_type_right(), and write_type_v().