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
const char *	get_name (const var_t *v)
void	write_type_left (FILE *h, const decl_spec_t *ds, enum name_type name_type, bool define, int write_callconv)
void	write_type_right (FILE *h, type_t *t, int is_field)
void	write_type_decl (FILE *f, const decl_spec_t *t, const char *name)
void	write_type_decl_left (FILE *f, const decl_spec_t *ds)
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)
const statement_t *	get_callas_source (const type_t *iface, const var_t *def)
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, enum name_type name_type)
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_func (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 460 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_callas_source()

const statement_t * get_callas_source	(	const type_t *	iface,
		const var_t *	def
	)

Definition at line 475 of file proxy.c.

{
  const statement_t * source;
  STATEMENTS_FOR_EACH_FUNC( source, type_iface_get_stmts(iface)) {
    const var_t * cas = is_callas(source->u.var->attrs );
    if (cas && !strcmp(def->name, cas->name))
      return source;
  }
  return NULL;
}

Referenced by write_iface_procformatstring(), write_proxy_methods(), write_proxy_procformatstring_offsets(), write_stub_methods(), and write_thunk_methods().

get_context_handle_offset()

unsigned int get_context_handle_offset

(

const type_t *

type

)

Definition at line 625 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( type );
        else if (is_ptr( type )) type = type_pointer_get_ref_type( 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_interp().

get_explicit_generic_handle_type()

const type_t * get_explicit_generic_handle_type

(

const var_t *

var

)

Definition at line 899 of file header.c.

{
    const type_t *t;
    for (t = var->declspec.type;
         is_ptr(t) || type_is_alias(t);
         t = type_is_alias(t) ? type_alias_get_aliasee_type(t) : type_pointer_get_ref_type(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 911 of file header.c.

{
    const var_t *var;
    const var_list_t *args = type_function_get_args( func->declspec.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->declspec.type ) == TYPE_BASIC && type_basic_get_type( var->declspec.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->declspec.type ))
        {
            *explicit_fc = FC_BIND_CONTEXT;
            return var;
        }
    }
 
    if ((var = get_attrp( iface->attrs, ATTR_IMPLICIT_HANDLE )))
    {
        if (type_get_type( var->declspec.type ) == TYPE_BASIC &&
            type_basic_get_type( var->declspec.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(), and write_proc_func_interp().

get_generic_handle_offset()

unsigned int get_generic_handle_offset

(

const type_t *

type

)

Definition at line 645 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( type );
        else if (is_ptr( type )) type = type_pointer_get_ref_type( 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_interp().

get_name()

const char * get_name

(

const var_t *

v

)

Definition at line 143 of file header.c.

{
    static char *buffer;
    free( buffer );
    if (is_attr( v->attrs, ATTR_EVENTADD ))
        return buffer = strmake( "add_%s", v->name );
    if (is_attr( v->attrs, ATTR_EVENTREMOVE ))
        return buffer = strmake( "remove_%s", v->name );
    if (is_attr( v->attrs, ATTR_PROPGET ))
        return buffer = strmake( "get_%s", v->name );
    if (is_attr( v->attrs, ATTR_PROPPUT ))
        return buffer = strmake( "put_%s", v->name );
    if (is_attr( v->attrs, ATTR_PROPPUTREF ))
        return buffer = strmake( "putref_%s", v->name );
    buffer = NULL;
    return v->name;
}

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(), write_method_proto(), write_parameterized_implementation(), and write_widl_using_method_macros().

has_out_arg_or_return()

int has_out_arg_or_return

(

const var_t *

func

)

Definition at line 952 of file header.c.

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

Referenced by write_function_stub().

is_array()

static int is_array ( const type_t *  t )

inlinestatic

Definition at line 60 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(), decl_needs_parens(), 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_remoting_arg(), write_string_tfs(), write_var_desc(), write_var_init(), and write_varying_array_pointer_descriptions().

is_callas()

const var_t * is_callas

(

const attr_list_t *

list

)

Definition at line 987 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_parameterized_implementation(), write_proxy(), write_proxy_methods(), write_proxy_procformatstring_offsets(), write_stub_methods(), write_thunk_methods(), and write_widl_using_method_macros().

is_conformant_array()

static int is_conformant_array ( const type_t *  t )

inlinestatic

Definition at line 80 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 845 of file header.c.

{
  const decl_spec_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->declspec; ; )
  {
    if (t->qualifier & TYPE_QUALIFIER_CONST)
      return TRUE;
    else if (is_ptr(t->type))
      t = type_pointer_get_ref(t->type);
    else break;
  }
  return FALSE;
}

Referenced by write_declaration().

is_context_handle()

static int is_context_handle ( const type_t *  type )

inlinestatic

Definition at line 101 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_type(t) : type_pointer_get_ref_type(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 75 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_func()

static int is_func ( const type_t *  t )

inlinestatic

Definition at line 65 of file header.h.

{
    return type_get_type(t) == TYPE_FUNCTION;
}

Referenced by decl_needs_parens().

is_local()

int is_local

(

const attr_list_t *

list

)

Definition at line 982 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(), get_timezone_id(), 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 972 of file header.c.

{
    const attr_t *attr;
    if (type_is_defined(iface) && (type_get_type(iface) == TYPE_DELEGATE || 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 fill_params_array(), 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_interp(), and write_typelib_interface().

is_ptr()

static int is_ptr ( const type_t *  t )

inlinestatic

Definition at line 55 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(), 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_var_desc(), and write_var_init().

is_string_type()

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

inlinestatic

Definition at line 95 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(), and write_struct_tfs().

is_void()

static int is_void ( const type_t *  t )

inlinestatic

Definition at line 70 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_interp(), and write_procformatstring_func().

last_array()

static int last_array ( const type_t *  type )

inlinestatic

Definition at line 90 of file header.h.

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

Referenced by is_string_type().

last_ptr()

static int last_ptr ( const type_t *  type )

inlinestatic

Definition at line 85 of file header.h.

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

Referenced by is_string_type().

need_inline_stubs()

int need_inline_stubs

(

const type_t *

iface

)

Definition at line 814 of file proxy.c.

{
    const statement_t *stmt;
 
    if (!interpreted_mode) 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 850 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 791 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 809 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 804 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 799 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 845 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 252 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,
		enum name_type	name_type
	)

Definition at line 1103 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, ",");
    }
    /* In theory we should be writing the definition using write_type_v(..., arg->define),
     * but that causes redefinition in e.g. proxy files. In fact MIDL disallows
     * defining UDTs inside of an argument list. */
    write_type_v(h, &arg->declspec, FALSE, false, arg->name, name_type);
    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->declspec.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(), write_parameterized_implementation(), and write_type_right().

write_serialize_functions()

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

Definition at line 336 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,
		const decl_spec_t *	t,
		const char *	name
	)

Definition at line 588 of file header.c.

{
    write_type_v(f, t, FALSE, false, name, NAME_DEFAULT);
}

Referenced by declare_stub_args(), gen_proxy(), print_phase_basetype(), print_start_tfs_comment(), write_expr(), 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,
		const decl_spec_t *	ds
	)

Definition at line 593 of file header.c.

{
  write_type_left(f, ds, NAME_DEFAULT, false, 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(), write_method_proto(), and write_parameterized_implementation().

write_type_left()

void write_type_left	(	FILE *	h,
		const decl_spec_t *	ds,
		enum name_type	name_type,
		bool	define,
		int	write_callconv
	)

Definition at line 282 of file header.c.

{
  type_t *t = ds->type;
  const char *decl_name, *name;
  char *args;
 
  if (!h) return;
 
  decl_name = type_get_decl_name(t, name_type);
  name = type_get_name(t, name_type);
 
  if (ds->func_specifier & FUNCTION_SPECIFIER_INLINE)
    fprintf(h, "inline ");
 
  if ((ds->qualifier & TYPE_QUALIFIER_CONST) && (type_is_alias(t) || !is_ptr(t)))
    fprintf(h, "const ");
 
  if (type_is_alias(t)) fprintf(h, "%s", name);
  else {
    switch (type_get_type_detect_alias(t)) {
      case TYPE_ENUM:
        if (!define) fprintf(h, "enum %s", decl_name ? decl_name : "");
        else if (!t->written) {
          assert(t->defined);
          if (decl_name) fprintf(h, "enum %s {\n", decl_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 if (winrt_mode && name_type == NAME_DEFAULT && name) fprintf(h, "%s", name);
        else fprintf(h, "enum %s", name ? name : "");
        break;
      case TYPE_STRUCT:
      case TYPE_ENCAPSULATED_UNION:
        if (!define) fprintf(h, "struct %s", decl_name ? decl_name : "");
        else if (!t->written) {
          assert(t->defined);
          if (decl_name) fprintf(h, "struct %s {\n", decl_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), name_type);
          else
            write_fields(h, type_struct_get_fields(t), name_type);
          indent(h, -1);
          fprintf(h, "}");
        }
        else if (winrt_mode && name_type == NAME_DEFAULT && name) fprintf(h, "%s", name);
        else fprintf(h, "struct %s", name ? name : "");
        break;
      case TYPE_UNION:
        if (!define) fprintf(h, "union %s", decl_name ? decl_name : "");
        else if (!t->written) {
          assert(t->defined);
          if (decl_name) fprintf(h, "union %s {\n", decl_name);
          else fprintf(h, "union {\n");
          t->written = TRUE;
          indentation++;
          write_fields(h, type_union_get_cases(t), name_type);
          indent(h, -1);
          fprintf(h, "}");
        }
        else if (winrt_mode && name_type == NAME_DEFAULT && name) fprintf(h, "%s", name);
        else fprintf(h, "union %s", name ? name : "");
        break;
      case TYPE_POINTER:
      {
        write_type_left(h, type_pointer_get_ref(t), name_type, define, FALSE);
        write_pointer_left(h, type_pointer_get_ref_type(t));
        if (ds->qualifier & TYPE_QUALIFIER_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, define, !type_array_is_decl_as_ptr(t));
          if (type_array_is_decl_as_ptr(t))
            write_pointer_left(h, type_array_get_element_type(t));
        }
        break;
      case TYPE_FUNCTION:
      {
        write_type_left(h, type_function_get_ret(t), name_type, define, TRUE);
 
        /* A pointer to a function has to write the calling convention inside
         * the parentheses. There's no way to handle that here, so we have to
         * use an extra parameter to tell us whether to write the calling
         * convention or not. */
        if (write_callconv)
        {
            const char *callconv = get_attrp(t->attrs, ATTR_CALLCONV);
            if (!callconv && is_object_interface) callconv = "STDMETHODCALLTYPE";
            if (callconv) fprintf(h, " %s ", callconv);
        }
        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", type_get_name(t, name_type));
        break;
      case TYPE_RUNTIMECLASS:
        fprintf(h, "%s", type_get_name(type_runtimeclass_get_default_iface(t, TRUE), name_type));
        break;
      case TYPE_DELEGATE:
        fprintf(h, "%s", type_get_name(type_delegate_get_iface(t), name_type));
        break;
      case TYPE_VOID:
        fprintf(h, "void");
        break;
      case TYPE_BITFIELD:
      {
        const decl_spec_t ds = {.type = type_bitfield_get_field(t)};
        write_type_left(h, &ds, name_type, define, TRUE);
        break;
      }
      case TYPE_ALIAS:
        /* handled elsewhere */
        assert(0);
        break;
      case TYPE_PARAMETERIZED_TYPE:
      {
        type_t *iface = type_parameterized_type_get_real_type(t);
        if (type_get_type(iface) == TYPE_DELEGATE) iface = type_delegate_get_iface(iface);
        args = format_parameterized_type_args(t, "", "_logical");
        fprintf(h, "%s<%s>", iface->name, args);
        free(args);
        break;
      }
      case TYPE_PARAMETER:
        fprintf(h, "%s_abi", t->name);
        break;
      case TYPE_APICONTRACT:
        /* shouldn't be here */
        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 476 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_type(t);
    if (type_array_is_decl_as_ptr(t))
    {
      if (decl_needs_parens(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_FUNCTION:
  {
    const var_list_t *args = type_function_get_args(t);
    fputc('(', h);
    if (args) write_args(h, args, NULL, 0, FALSE, NAME_DEFAULT);
    else
      fprintf(h, "void");
    fputc(')', h);
    write_type_right(h, type_function_get_rettype(t), FALSE);
    break;
  }
  case TYPE_POINTER:
  {
    type_t *ref = type_pointer_get_ref_type(t);
    if (decl_needs_parens(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_INTERFACE:
  case TYPE_RUNTIMECLASS:
  case TYPE_DELEGATE:
  case TYPE_PARAMETERIZED_TYPE:
  case TYPE_PARAMETER:
    break;
  case TYPE_APICONTRACT:
    /* not supposed to be here */
    assert(0);
    break;
  }
}

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