ReactOS  0.4.14-dev-606-g14ebc0b
header.c File Reference
#include "config.h"
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "widl.h"
#include "utils.h"
#include "parser.h"
#include "header.h"
#include "expr.h"
#include "typetree.h"
#include "typelib.h"
Include dependency graph for header.c:

Go to the source code of this file.

Functions

static void write_type_def_or_decl (FILE *f, type_t *t, int field, const char *name)
 
static void indent (FILE *h, int delta)
 
static void write_line (FILE *f, int delta, const char *fmt,...)
 
int is_ptrchain_attr (const var_t *var, enum attr_type t)
 
int is_aliaschain_attr (const type_t *type, enum attr_type attr)
 
int is_attr (const attr_list_t *list, enum attr_type t)
 
voidget_attrp (const attr_list_t *list, enum attr_type t)
 
unsigned int get_attrv (const attr_list_t *list, enum attr_type t)
 
static void write_guid (FILE *f, const char *guid_prefix, const char *name, const UUID *uuid)
 
static void write_uuid_decl (FILE *f, type_t *type, const UUID *uuid)
 
static const charuuid_string (const UUID *uuid)
 
static void write_namespace_start (FILE *header, struct namespace *namespace)
 
static void write_namespace_end (FILE *header, struct namespace *namespace)
 
const charget_name (const var_t *v)
 
static void write_fields (FILE *h, var_list_t *fields)
 
static void write_enums (FILE *h, var_list_t *enums, const char *enum_name)
 
int needs_space_after (type_t *t)
 
static void write_pointer_left (FILE *h, type_t *ref)
 
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)
 
static void write_type_v (FILE *h, type_t *t, int is_field, int declonly, const char *name)
 
static void write_type_definition (FILE *f, type_t *t)
 
void write_type_decl (FILE *f, type_t *t, const char *name)
 
void write_type_decl_left (FILE *f, type_t *t)
 
static int user_type_registered (const char *name)
 
static int context_handle_registered (const char *name)
 
static int generic_handle_registered (const char *name)
 
unsigned int get_context_handle_offset (const type_t *type)
 
unsigned int get_generic_handle_offset (const type_t *type)
 
void check_for_additional_prototype_types (const var_list_t *list)
 
static int write_serialize_function_decl (FILE *header, const type_t *type)
 
static int serializable_exists (FILE *header, const type_t *type)
 
static int for_each_serializable (const statement_list_t *stmts, FILE *header, int(*proc)(FILE *, const type_t *))
 
static void write_user_types (FILE *header)
 
static void write_context_handle_rundowns (FILE *header)
 
static void write_generic_handle_routines (FILE *header)
 
static void write_typedef (FILE *header, type_t *type)
 
int is_const_decl (const var_t *var)
 
static void write_declaration (FILE *header, const var_t *v)
 
static void write_library (FILE *header, const typelib_t *typelib)
 
const type_tget_explicit_generic_handle_type (const var_t *var)
 
const var_tget_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_object (const type_t *iface)
 
int is_local (const attr_list_t *a)
 
const var_tis_callas (const attr_list_t *a)
 
static int is_inherited_method (const type_t *iface, const var_t *func)
 
static int is_override_method (const type_t *iface, const type_t *child, const var_t *func)
 
static int is_aggregate_return (const var_t *func)
 
static charget_vtbl_entry_name (const type_t *iface, const var_t *func)
 
static void write_method_macro (FILE *header, const type_t *iface, const type_t *child, const char *name)
 
void write_args (FILE *h, const var_list_t *args, const char *name, int method, int do_indent)
 
static void write_cpp_method_def (FILE *header, const type_t *iface)
 
static void write_inline_wrappers (FILE *header, const type_t *iface, const type_t *child, const char *name)
 
static void do_write_c_method_def (FILE *header, const type_t *iface, const char *name)
 
static void write_c_method_def (FILE *header, const type_t *iface)
 
static void write_c_disp_method_def (FILE *header, const type_t *iface)
 
static void write_method_proto (FILE *header, const type_t *iface)
 
static void write_locals (FILE *fp, const type_t *iface, int body)
 
static void write_local_stubs_stmts (FILE *local_stubs, const statement_list_t *stmts)
 
void write_local_stubs (const statement_list_t *stmts)
 
static void write_function_proto (FILE *header, const type_t *iface, const var_t *fun, const char *prefix)
 
static void write_forward (FILE *header, type_t *iface)
 
static void write_com_interface_start (FILE *header, const type_t *iface)
 
static void write_com_interface_end (FILE *header, type_t *iface)
 
static void write_rpc_interface_start (FILE *header, const type_t *iface)
 
static void write_rpc_interface_end (FILE *header, const type_t *iface)
 
static void write_coclass (FILE *header, type_t *cocl)
 
static void write_coclass_forward (FILE *header, type_t *cocl)
 
static void write_import (FILE *header, const char *fname)
 
static void write_imports (FILE *header, const statement_list_t *stmts)
 
static void write_forward_decls (FILE *header, const statement_list_t *stmts)
 
static void write_header_stmts (FILE *header, const statement_list_t *stmts, const type_t *iface, int ignore_funcs)
 
void write_header (const statement_list_t *stmts)
 

Variables

static int indentation = 0
 
static int is_object_interface = 0
 
user_type_list_t user_type_list = LIST_INIT(user_type_list)
 
context_handle_list_t context_handle_list = LIST_INIT(context_handle_list)
 
generic_handle_list_t generic_handle_list = LIST_INIT(generic_handle_list)
 

Function Documentation

◆ check_for_additional_prototype_types()

void check_for_additional_prototype_types ( const var_list_t list)

Definition at line 640 of file header.c.

641 {
642  const var_t *v;
643 
644  if (!list) return;
645  LIST_FOR_EACH_ENTRY( v, list, const var_t, entry )
646  {
647  type_t *type = v->type;
648  if (!type) continue;
649  for (;;) {
650  const char *name = type->name;
651  if (type->user_types_registered) break;
652  type->user_types_registered = 1;
653  if (is_attr(type->attrs, ATTR_CONTEXTHANDLE)) {
655  {
656  context_handle_t *ch = xmalloc(sizeof(*ch));
657  ch->name = xstrdup(name);
659  }
660  /* don't carry on parsing fields within this type */
661  break;
662  }
663  if ((type_get_type(type) != TYPE_BASIC ||
665  is_attr(type->attrs, ATTR_HANDLE)) {
667  {
668  generic_handle_t *gh = xmalloc(sizeof(*gh));
669  gh->name = xstrdup(name);
671  }
672  /* don't carry on parsing fields within this type */
673  break;
674  }
675  if (is_attr(type->attrs, ATTR_WIREMARSHAL)) {
677  {
678  user_type_t *ut = xmalloc(sizeof *ut);
679  ut->name = xstrdup(name);
681  }
682  /* don't carry on parsing fields within this type as we are already
683  * using a wire marshaled type */
684  break;
685  }
686  else if (type_is_complete(type))
687  {
688  var_list_t *vars;
690  {
691  case TYPE_ENUM:
692  vars = type_enum_get_values(type);
693  break;
694  case TYPE_STRUCT:
696  break;
697  case TYPE_UNION:
698  vars = type_union_get_cases(type);
699  break;
700  default:
701  vars = NULL;
702  break;
703  }
705  }
706 
707  if (type_is_alias(type))
709  else if (is_ptr(type))
711  else if (is_array(type))
713  else
714  break;
715  }
716  }
717 }
static var_list_t * type_struct_get_fields(const type_t *type)
Definition: typetree.h:87
generic_handle_list_t generic_handle_list
Definition: header.c:44
static type_t * type_array_get_element(const type_t *type)
Definition: typetree.h:253
static var_list_t * type_union_get_cases(const type_t *type)
Definition: typetree.h:134
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
static enum type_basic_type type_basic_get_type(const type_t *type)
Definition: typetree.h:73
static int context_handle_registered(const char *name)
Definition: header.c:580
static type_t * type_pointer_get_ref(const type_t *type)
Definition: typetree.h:292
__WINE_SERVER_LIST_INLINE void list_add_tail(struct list *list, struct list *elem)
Definition: list.h:102
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
void * xmalloc(int size)
Definition: uimain.c:747
static int is_ptr(const type_t *t)
Definition: header.h:59
static int type_is_alias(const type_t *type)
Definition: typetree.h:274
smooth NULL
Definition: ftsmooth.c:416
static int is_array(const type_t *t)
Definition: header.h:64
static var_list_t * type_enum_get_values(const type_t *type)
Definition: typetree.h:113
static int type_is_complete(const type_t *type)
Definition: typetree.h:191
static enum type_type type_get_type(const type_t *type)
Definition: typetree.h:68
static int generic_handle_registered(const char *name)
Definition: header.c:589
static enum type_type type_get_type_detect_alias(const type_t *type)
Definition: widltypes.h:589
user_type_list_t user_type_list
Definition: header.c:42
uint32_t entry
Definition: isohybrid.c:63
Definition: _list.h:228
void check_for_additional_prototype_types(const var_list_t *list)
Definition: header.c:640
const GLdouble * v
Definition: gl.h:2040
const char * name
Definition: widltypes.h:522
struct list entry
Definition: widltypes.h:521
static type_t * type_alias_get_aliasee(const type_t *type)
Definition: typetree.h:279
Definition: name.c:38
int is_attr(const attr_list_t *list, enum attr_type t)
Definition: header.c:99
char * xstrdup(const char *s)
Definition: uimain.c:768
static int user_type_registered(const char *name)
Definition: header.c:571
WCHAR * name
Definition: name.c:42

Referenced by check_all_user_types(), and check_for_additional_prototype_types().

◆ context_handle_registered()

static int context_handle_registered ( const char name)
static

Definition at line 580 of file header.c.

581 {
582  context_handle_t *ch;
584  if (!strcmp(name, ch->name))
585  return 1;
586  return 0;
587 }
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
uint32_t entry
Definition: isohybrid.c:63
const char * name
Definition: widltypes.h:522
Definition: name.c:38
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469

Referenced by check_for_additional_prototype_types().

◆ do_write_c_method_def()

static void do_write_c_method_def ( FILE header,
const type_t iface,
const char name 
)
static

Definition at line 1240 of file header.c.

1241 {
1242  const statement_t *stmt;
1243  int first_iface = 1;
1244 
1245  if (type_iface_get_inherit(iface))
1247 #ifdef __REACTOS__ /* r59312 / 3ab1571 */
1248  else if (type_iface_get_stmts(iface) == NULL)
1249  {
1250  fprintf(header, "#ifndef __cplusplus\n");
1251  indent(header, 0);
1252  fprintf(header, "char dummy;\n");
1253  fprintf(header, "#endif\n");
1254  fprintf(header, "\n");
1255  return;
1256  }
1257 #endif
1258 
1260  {
1261  const var_t *func = stmt->u.var;
1262  if (first_iface) {
1263  indent(header, 0);
1264  fprintf(header, "/*** %s methods ***/\n", iface->name);
1265  first_iface = 0;
1266  }
1267  if (!is_callas(func->attrs)) {
1268  const char *callconv = get_attrp(func->type->attrs, ATTR_CALLCONV);
1269  if (!callconv) callconv = "STDMETHODCALLTYPE";
1270  indent(header, 0);
1273  fprintf(header, " *");
1274  if (is_inherited_method(iface, func))
1275  fprintf(header, " (%s *%s_%s)(\n", callconv, iface->name, func->name);
1276  else
1277  fprintf(header, " (%s *%s)(\n", callconv, get_name(func));
1278  ++indentation;
1279  indent(header, 0);
1280  fprintf(header, "%s *This", name);
1281  if (is_aggregate_return(func)) {
1282  fprintf(header, ",\n");
1283  indent(header, 0);
1285  fprintf(header, " *__ret");
1286  }
1287  --indentation;
1288  if (type_get_function_args(func->type)) {
1289  fprintf(header, ",\n");
1291  }
1292  fprintf(header, ");\n");
1293  fprintf(header, "\n");
1294  }
1295  }
1296 }
#define STATEMENTS_FOR_EACH_FUNC(stmt, stmts)
Definition: widltypes.h:596
GLenum func
Definition: glext.h:6028
static var_list_t * type_get_function_args(const type_t *func_type)
Definition: widltypes.h:584
#define TRUE
Definition: types.h:120
static int is_aggregate_return(const var_t *func)
Definition: header.c:996
void * get_attrp(const attr_list_t *list, enum attr_type t)
Definition: header.c:107
static void indent(FILE *h, int delta)
Definition: header.c:48
var_t * var
Definition: widltypes.h:538
static int indentation
Definition: header.c:40
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
smooth NULL
Definition: ftsmooth.c:416
void write_args(FILE *h, const var_list_t *args, const char *name, int method, int do_indent)
Definition: header.c:1058
union _statement_t::@4054 u
static void do_write_c_method_def(FILE *header, const type_t *iface, const char *name)
Definition: header.c:1240
void write_type_decl_left(FILE *f, type_t *t)
Definition: header.c:566
static int is_inherited_method(const type_t *iface, const var_t *func)
Definition: header.c:948
const char * name
Definition: widltypes.h:418
static type_t * type_iface_get_inherit(const type_t *type)
Definition: typetree.h:158
const char * get_name(const var_t *v)
Definition: header.c:181
const var_t * is_callas(const attr_list_t *a)
Definition: header.c:943
Definition: name.c:38
static type_t * type_function_get_rettype(const type_t *type)
Definition: typetree.h:108
static statement_list_t * type_iface_get_stmts(const type_t *type)
Definition: typetree.h:151

Referenced by write_c_disp_method_def(), and write_c_method_def().

◆ for_each_serializable()

static int for_each_serializable ( const statement_list_t stmts,
FILE header,
int(*)(FILE *, const type_t *)  proc 
)
static

Definition at line 730 of file header.c.

732 {
733  statement_t *stmt, *iface_stmt;
734  statement_list_t *iface_stmts;
735  const type_list_t *type_entry;
736 
737  if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, statement_t, entry )
738  {
739  if (stmt->type != STMT_TYPE || type_get_type(stmt->u.type) != TYPE_INTERFACE)
740  continue;
741 
742  iface_stmts = type_iface_get_stmts(stmt->u.type);
743  if (iface_stmts) LIST_FOR_EACH_ENTRY( iface_stmt, iface_stmts, statement_t, entry )
744  {
745  if (iface_stmt->type != STMT_TYPEDEF) continue;
746  for (type_entry = iface_stmt->u.type_list; type_entry; type_entry = type_entry->next)
747  {
748  if (!is_attr(type_entry->type->attrs, ATTR_ENCODE)
749  && !is_attr(type_entry->type->attrs, ATTR_DECODE))
750  continue;
751  if (!proc(header, type_entry->type))
752  return 0;
753  }
754  }
755  }
756 
757  return 1;
758 }
static HANDLE proc()
Definition: pdb.c:32
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
type_t * type
Definition: widltypes.h:526
statement_type_t type
Definition: parser.h:124
union _statement_t::@4054 u
static enum type_type type_get_type(const type_t *type)
Definition: typetree.h:68
attr_list_t * attrs
Definition: widltypes.h:421
uint32_t entry
Definition: isohybrid.c:63
type_list_t * type_list
Definition: widltypes.h:540
int is_attr(const attr_list_t *list, enum attr_type t)
Definition: header.c:99
struct _type_list_t * next
Definition: widltypes.h:527
static statement_list_t * type_iface_get_stmts(const type_t *type)
Definition: typetree.h:151

Referenced by write_header().

◆ generic_handle_registered()

static int generic_handle_registered ( const char name)
static

Definition at line 589 of file header.c.

590 {
591  generic_handle_t *gh;
593  if (!strcmp(name, gh->name))
594  return 1;
595  return 0;
596 }
generic_handle_list_t generic_handle_list
Definition: header.c:44
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
uint32_t entry
Definition: isohybrid.c:63
const char * name
Definition: widltypes.h:522
Definition: name.c:38
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469

Referenced by check_for_additional_prototype_types().

◆ get_attrp()

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

Definition at line 107 of file header.c.

108 {
109  const attr_t *attr;
110  if (list) LIST_FOR_EACH_ENTRY( attr, list, const attr_t, entry )
111  if (attr->type == t) return attr->u.pval;
112  return NULL;
113 }
GLdouble GLdouble t
Definition: gl.h:2047
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
smooth NULL
Definition: ftsmooth.c:416
Definition: cookie.c:201
__u8 attr
Definition: mkdosfs.c:359
uint32_t entry
Definition: isohybrid.c:63
Definition: _list.h:228

Referenced by add_typeinfo_block(), check_field_common(), cmp_iid(), declare_var(), 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(), reg_typedefs(), 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.

116 {
117  const attr_t *attr;
118  if (list) LIST_FOR_EACH_ENTRY( attr, list, const attr_t, entry )
119  if (attr->type == t) return attr->u.ival;
120  return 0;
121 }
GLdouble GLdouble t
Definition: gl.h:2047
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
Definition: cookie.c:201
__u8 attr
Definition: mkdosfs.c:359
uint32_t entry
Definition: isohybrid.c:63
Definition: _list.h:228

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

◆ get_context_handle_offset()

unsigned int get_context_handle_offset ( const type_t type)

Definition at line 598 of file header.c.

599 {
600  context_handle_t *ch;
601  unsigned int index = 0;
602 
603  while (!is_attr( type->attrs, ATTR_CONTEXTHANDLE ))
604  {
606  else if (is_ptr( type )) type = type_pointer_get_ref( type );
607  else error( "internal error: %s is not a context handle\n", type->name );
608  }
610  {
611  if (!strcmp( type->name, ch->name )) return index;
612  index++;
613  }
614  error( "internal error: %s is not registered as a context handle\n", type->name );
615  return index;
616 }
#define error(str)
Definition: mkdosfs.c:1605
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
static type_t * type_pointer_get_ref(const type_t *type)
Definition: typetree.h:292
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
static int is_ptr(const type_t *t)
Definition: header.h:59
static int type_is_alias(const type_t *type)
Definition: typetree.h:274
GLuint index
Definition: glext.h:6031
#define index(s, c)
Definition: various.h:29
uint32_t entry
Definition: isohybrid.c:63
const char * name
Definition: widltypes.h:522
static type_t * type_alias_get_aliasee(const type_t *type)
Definition: typetree.h:279
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
int is_attr(const attr_list_t *list, enum attr_type t)
Definition: header.c:99

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.

856 {
857  const type_t *t;
858  for (t = var->type;
859  is_ptr(t) || type_is_alias(t);
862  is_attr(t->attrs, ATTR_HANDLE))
863  return t;
864  return NULL;
865 }
return
Definition: dirsup.c:529
GLdouble GLdouble t
Definition: gl.h:2047
static enum type_basic_type type_basic_get_type(const type_t *type)
Definition: typetree.h:73
static type_t * type_pointer_get_ref(const type_t *type)
Definition: typetree.h:292
static int is_ptr(const type_t *t)
Definition: header.h:59
static int type_is_alias(const type_t *type)
Definition: typetree.h:274
smooth NULL
Definition: ftsmooth.c:416
if(!(yy_init))
Definition: macro.lex.yy.c:714
type_t * type
Definition: widltypes.h:452
static enum type_type type_get_type_detect_alias(const type_t *type)
Definition: widltypes.h:589
static type_t * type_alias_get_aliasee(const type_t *type)
Definition: typetree.h:279
int is_attr(const attr_list_t *list, enum attr_type t)
Definition: header.c:99

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.

869 {
870  const var_t *var;
871  const var_list_t *args = type_get_function_args( func->type );
872 
873  *explicit_fc = *implicit_fc = 0;
874  if (args) LIST_FOR_EACH_ENTRY( var, args, const var_t, entry )
875  {
876  if (!is_attr( var->attrs, ATTR_IN ) && is_attr( var->attrs, ATTR_OUT )) continue;
878  {
879  *explicit_fc = FC_BIND_PRIMITIVE;
880  return var;
881  }
883  {
884  *explicit_fc = FC_BIND_GENERIC;
885  return var;
886  }
887  if (is_context_handle( var->type ))
888  {
889  *explicit_fc = FC_BIND_CONTEXT;
890  return var;
891  }
892  }
893 
894  if ((var = get_attrp( iface->attrs, ATTR_IMPLICIT_HANDLE )))
895  {
896  if (type_get_type( var->type ) == TYPE_BASIC &&
898  *implicit_fc = FC_BIND_PRIMITIVE;
899  else
900  *implicit_fc = FC_BIND_GENERIC;
901  return var;
902  }
903 
904  *implicit_fc = FC_AUTO_HANDLE;
905  return NULL;
906 }
GLenum func
Definition: glext.h:6028
static var_list_t * type_get_function_args(const type_t *func_type)
Definition: widltypes.h:584
void * get_attrp(const attr_list_t *list, enum attr_type t)
Definition: header.c:107
const type_t * get_explicit_generic_handle_type(const var_t *var)
Definition: header.c:855
static enum type_basic_type type_basic_get_type(const type_t *type)
Definition: typetree.h:73
Definition: match.c:390
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
smooth NULL
Definition: ftsmooth.c:416
static enum type_type type_get_type(const type_t *type)
Definition: typetree.h:68
type_t * type
Definition: widltypes.h:452
attr_list_t * attrs
Definition: widltypes.h:421
attr_list_t * attrs
Definition: widltypes.h:453
uint32_t entry
Definition: isohybrid.c:63
Definition: _list.h:228
static int is_context_handle(const type_t *type)
Definition: header.h:100
int is_attr(const attr_list_t *list, enum attr_type t)
Definition: header.c:99

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

◆ get_generic_handle_offset()

unsigned int get_generic_handle_offset ( const type_t type)

Definition at line 618 of file header.c.

619 {
620  generic_handle_t *gh;
621  unsigned int index = 0;
622 
623  while (!is_attr( type->attrs, ATTR_HANDLE ))
624  {
626  else if (is_ptr( type )) type = type_pointer_get_ref( type );
627  else error( "internal error: %s is not a generic handle\n", type->name );
628  }
630  {
631  if (!strcmp( type->name, gh->name )) return index;
632  index++;
633  }
634  error( "internal error: %s is not registered as a generic handle\n", type->name );
635  return index;
636 }
#define error(str)
Definition: mkdosfs.c:1605
generic_handle_list_t generic_handle_list
Definition: header.c:44
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
static type_t * type_pointer_get_ref(const type_t *type)
Definition: typetree.h:292
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
static int is_ptr(const type_t *t)
Definition: header.h:59
static int type_is_alias(const type_t *type)
Definition: typetree.h:274
GLuint index
Definition: glext.h:6031
#define index(s, c)
Definition: various.h:29
uint32_t entry
Definition: isohybrid.c:63
const char * name
Definition: widltypes.h:522
static type_t * type_alias_get_aliasee(const type_t *type)
Definition: typetree.h:279
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
int is_attr(const attr_list_t *list, enum attr_type t)
Definition: header.c:99

Referenced by write_proc_func_header().

◆ get_name()

const char* get_name ( const var_t v)

Definition at line 181 of file header.c.

182 {
183  static char buffer[256];
184 
185  if (is_attr( v->attrs, ATTR_PROPGET ))
186  strcpy( buffer, "get_" );
187  else if (is_attr( v->attrs, ATTR_PROPPUT ))
188  strcpy( buffer, "put_" );
189  else if (is_attr( v->attrs, ATTR_PROPPUTREF ))
190  strcpy( buffer, "putref_" );
191  else
192  buffer[0] = 0;
193  strcat( buffer, v->name );
194  return buffer;
195 }
char * strcat(char *DstString, const char *SrcString)
Definition: utclib.c:568
GLuint buffer
Definition: glext.h:5915
const GLdouble * v
Definition: gl.h:2040
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
int is_attr(const attr_list_t *list, enum attr_type t)
Definition: header.c:99

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().

◆ get_vtbl_entry_name()

static char* get_vtbl_entry_name ( const type_t iface,
const var_t func 
)
static

Definition at line 1003 of file header.c.

1004 {
1005  static char buff[255];
1006  if (is_inherited_method(iface, func))
1007  sprintf(buff, "%s_%s", iface->name, get_name(func));
1008  else
1009  sprintf(buff, "%s", get_name(func));
1010  return buff;
1011 }
GLenum func
Definition: glext.h:6028
#define sprintf(buf, format,...)
Definition: sprintf.c:55
static int is_inherited_method(const type_t *iface, const var_t *func)
Definition: header.c:948
const char * name
Definition: widltypes.h:418
const char * get_name(const var_t *v)
Definition: header.c:181
static unsigned char buff[32768]
Definition: fatten.c:17

Referenced by write_inline_wrappers(), and write_method_macro().

◆ has_out_arg_or_return()

int has_out_arg_or_return ( const var_t func)

Definition at line 908 of file header.c.

909 {
910  const var_t *var;
911 
913  return 1;
914 
915  if (!type_get_function_args(func->type))
916  return 0;
917 
919  if (is_attr(var->attrs, ATTR_OUT))
920  return 1;
921 
922  return 0;
923 }
GLenum func
Definition: glext.h:6028
static var_list_t * type_get_function_args(const type_t *func_type)
Definition: widltypes.h:584
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
attr_list_t * attrs
Definition: widltypes.h:453
uint32_t entry
Definition: isohybrid.c:63
static int is_void(const type_t *t)
Definition: header.h:69
static type_t * type_function_get_rettype(const type_t *type)
Definition: typetree.h:108
int is_attr(const attr_list_t *list, enum attr_type t)
Definition: header.c:99

Referenced by write_function_stub().

◆ indent()

static void indent ( FILE h,
int  delta 
)
static

Definition at line 48 of file header.c.

49 {
50  int c;
51  if (delta < 0) indentation += delta;
52  for (c=0; c<indentation; c++) fprintf(h, " ");
53  if (delta > 0) indentation += delta;
54 }
static int indentation
Definition: header.c:40
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
const GLubyte * c
Definition: glext.h:8905
#define c
Definition: ke_i.h:80

Referenced by do_write_c_method_def(), write_args(), write_com_interface_end(), write_cpp_method_def(), write_enums(), write_fields(), write_inline_wrappers(), write_line(), write_type_definition(), and write_type_left().

◆ is_aggregate_return()

static int is_aggregate_return ( const var_t func)
static

Definition at line 996 of file header.c.

997 {
999  return type == TYPE_STRUCT || type == TYPE_UNION ||
1001 }
GLenum func
Definition: glext.h:6028
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
type_type
Definition: widltypes.h:399
static enum type_type type_get_type(const type_t *type)
Definition: typetree.h:68
static type_t * type_function_get_rettype(const type_t *type)
Definition: typetree.h:108

Referenced by do_write_c_method_def(), write_cpp_method_def(), write_inline_wrappers(), and write_method_macro().

◆ is_aliaschain_attr()

int is_aliaschain_attr ( const type_t type,
enum attr_type  attr 
)

Definition at line 86 of file header.c.

87 {
88  const type_t *t = type;
89  for (;;)
90  {
91  if (is_attr(t->attrs, attr))
92  return 1;
93  else if (type_is_alias(t))
95  else return 0;
96  }
97 }
GLdouble GLdouble t
Definition: gl.h:2047
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
static int type_is_alias(const type_t *type)
Definition: typetree.h:274
Definition: cookie.c:201
static type_t * type_alias_get_aliasee(const type_t *type)
Definition: typetree.h:279
int is_attr(const attr_list_t *list, enum attr_type t)
Definition: header.c:99

Referenced by check_field_common(), check_iface_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  t 
)

Definition at line 99 of file header.c.

100 {
101  const attr_t *attr;
102  if (list) LIST_FOR_EACH_ENTRY( attr, list, const attr_t, entry )
103  if (attr->type == t) return 1;
104  return 0;
105 }
GLdouble GLdouble t
Definition: gl.h:2047
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
Definition: cookie.c:201
__u8 attr
Definition: mkdosfs.c:359
uint32_t entry
Definition: isohybrid.c:63
Definition: _list.h:228

Referenced by add_entry(), add_interface_typeinfo(), assign_stub_out_args(), check_async_uuid(), check_field_common(), check_for_additional_prototype_types(), check_functions(), check_remoting_args(), clear_output_vars(), declare_stub_args(), declare_var(), 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(), reg_typedefs(), 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(), write_union_tfs(), and yyparse().

◆ is_callas()

◆ is_const_decl()

int is_const_decl ( const var_t var)

Definition at line 801 of file header.c.

802 {
803  const type_t *t;
804  /* strangely, MIDL accepts a const attribute on any pointer in the
805  * declaration to mean that data isn't being instantiated. this appears
806  * to be a bug, but there is no benefit to being incompatible with MIDL,
807  * so we'll do the same thing */
808  for (t = var->type; ; )
809  {
810  if (is_attr(t->attrs, ATTR_CONST))
811  return TRUE;
812  else if (is_ptr(t))
814  else break;
815  }
816  return FALSE;
817 }
#define TRUE
Definition: types.h:120
GLdouble GLdouble t
Definition: gl.h:2047
static type_t * type_pointer_get_ref(const type_t *type)
Definition: typetree.h:292
static int is_ptr(const type_t *t)
Definition: header.h:59
type_t * type
Definition: widltypes.h:452
int is_attr(const attr_list_t *list, enum attr_type t)
Definition: header.c:99

Referenced by make_statement_declaration(), and write_declaration().

◆ is_inherited_method()

static int is_inherited_method ( const type_t iface,
const var_t func 
)
static

Definition at line 948 of file header.c.

949 {
950  while ((iface = type_iface_get_inherit(iface)))
951  {
952  const statement_t *stmt;
954  {
955  const var_t *funccmp = stmt->u.var;
956 
957  if (!is_callas(func->attrs))
958  {
959  char inherit_name[256];
960  /* compare full name including property prefix */
961  strcpy(inherit_name, get_name(funccmp));
962  if (!strcmp(inherit_name, get_name(func))) return 1;
963  }
964  }
965  }
966 
967  return 0;
968 }
#define STATEMENTS_FOR_EACH_FUNC(stmt, stmts)
Definition: widltypes.h:596
GLenum func
Definition: glext.h:6028
var_t * var
Definition: widltypes.h:538
union _statement_t::@4054 u
static type_t * type_iface_get_inherit(const type_t *type)
Definition: typetree.h:158
const char * get_name(const var_t *v)
Definition: header.c:181
const var_t * is_callas(const attr_list_t *a)
Definition: header.c:943
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
static statement_list_t * type_iface_get_stmts(const type_t *type)
Definition: typetree.h:151

Referenced by do_write_c_method_def(), and get_vtbl_entry_name().

◆ is_local()

◆ is_object()

int is_object ( const type_t iface)

Definition at line 928 of file header.c.

929 {
930  const attr_t *attr;
931  if (type_is_defined(iface) && type_iface_get_inherit(iface))
932  return 1;
933  if (iface->attrs) LIST_FOR_EACH_ENTRY( attr, iface->attrs, const attr_t, entry )
934  if (attr->type == ATTR_OBJECT || attr->type == ATTR_ODL) return 1;
935  return 0;
936 }
static int type_is_defined(const type_t *type)
Definition: typetree.h:186
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
attr_list_t * attrs
Definition: widltypes.h:421
Definition: cookie.c:201
static type_t * type_iface_get_inherit(const type_t *type)
Definition: typetree.h:158
__u8 attr
Definition: mkdosfs.c:359
uint32_t entry
Definition: isohybrid.c:63

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_override_method()

static int is_override_method ( const type_t iface,
const type_t child,
const var_t func 
)
static

Definition at line 970 of file header.c.

971 {
972  if (iface == child)
973  return 0;
974 
975  do
976  {
977  const statement_t *stmt;
979  {
980  const var_t *funccmp = stmt->u.var;
981 
982  if (!is_callas(func->attrs))
983  {
984  char inherit_name[256];
985  /* compare full name including property prefix */
986  strcpy(inherit_name, get_name(funccmp));
987  if (!strcmp(inherit_name, get_name(func))) return 1;
988  }
989  }
990  }
991  while ((child = type_iface_get_inherit(child)) && child != iface);
992 
993  return 0;
994 }
#define STATEMENTS_FOR_EACH_FUNC(stmt, stmts)
Definition: widltypes.h:596
GLenum func
Definition: glext.h:6028
var_t * var
Definition: widltypes.h:538
static HWND child
Definition: cursoricon.c:298
union _statement_t::@4054 u
static type_t * type_iface_get_inherit(const type_t *type)
Definition: typetree.h:158
const char * get_name(const var_t *v)
Definition: header.c:181
const var_t * is_callas(const attr_list_t *a)
Definition: header.c:943
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
static statement_list_t * type_iface_get_stmts(const type_t *type)
Definition: typetree.h:151

Referenced by write_inline_wrappers(), and write_method_macro().

◆ is_ptrchain_attr()

int is_ptrchain_attr ( const var_t var,
enum attr_type  t 
)

Definition at line 66 of file header.c.

67 {
68  if (is_attr(var->attrs, t))
69  return 1;
70  else
71  {
72  type_t *type = var->type;
73  for (;;)
74  {
75  if (is_attr(type->attrs, t))
76  return 1;
77  else if (type_is_alias(type))
79  else if (is_ptr(type))
81  else return 0;
82  }
83  }
84 }
GLdouble GLdouble t
Definition: gl.h:2047
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
static type_t * type_pointer_get_ref(const type_t *type)
Definition: typetree.h:292
static int is_ptr(const type_t *t)
Definition: header.h:59
static int type_is_alias(const type_t *type)
Definition: typetree.h:274
type_t * type
Definition: widltypes.h:452
attr_list_t * attrs
Definition: widltypes.h:453
static type_t * type_alias_get_aliasee(const type_t *type)
Definition: typetree.h:279
int is_attr(const attr_list_t *list, enum attr_type t)
Definition: header.c:99

Referenced by get_required_buffer_size().

◆ needs_space_after()

int needs_space_after ( type_t t)

Definition at line 282 of file header.c.

283 {
284  return (type_is_alias(t) ||
285  (!is_ptr(t) && (!is_array(t) || !type_array_is_decl_as_ptr(t) || t->name)));
286 }
GLdouble GLdouble t
Definition: gl.h:2047
static int is_ptr(const type_t *t)
Definition: header.h:59
static int type_is_alias(const type_t *type)
Definition: typetree.h:274
static int is_array(const type_t *t)
Definition: header.h:64
static int type_array_is_decl_as_ptr(const type_t *type)
Definition: typetree.h:260

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

◆ serializable_exists()

static int serializable_exists ( FILE header,
const type_t type 
)
static

Definition at line 725 of file header.c.

726 {
727  return 0;
728 }

Referenced by write_header().

◆ user_type_registered()

static int user_type_registered ( const char name)
static

Definition at line 571 of file header.c.

572 {
573  user_type_t *ut;
575  if (!strcmp(name, ut->name))
576  return 1;
577  return 0;
578 }
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
user_type_list_t user_type_list
Definition: header.c:42
uint32_t entry
Definition: isohybrid.c:63
const char * name
Definition: widltypes.h:522
Definition: name.c:38
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469

Referenced by check_for_additional_prototype_types().

◆ uuid_string()

static const char* uuid_string ( const UUID uuid)
static

Definition at line 146 of file header.c.

147 {
148  static char buf[37];
149 
150  sprintf(buf, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
151  uuid->Data1, uuid->Data2, uuid->Data3, uuid->Data4[0], uuid->Data4[1], uuid->Data4[2],
152  uuid->Data4[3], uuid->Data4[4], uuid->Data4[5], uuid->Data4[6], uuid->Data4[7]);
153 
154  return buf;
155 }
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define sprintf(buf, format,...)
Definition: sprintf.c:55
Definition: msctf.idl:510

Referenced by write_coclass(), and write_com_interface_end().

◆ write_args()

void write_args ( FILE h,
const var_list_t args,
const char name,
int  method,
int  do_indent 
)

Definition at line 1058 of file header.c.

1059 {
1060  const var_t *arg;
1061  int count = 0;
1062 
1063  if (do_indent)
1064  {
1065  indentation++;
1066  indent(h, 0);
1067  }
1068  if (method == 1) {
1069  fprintf(h, "%s* This", name);
1070  count++;
1071  }
1072  if (args) LIST_FOR_EACH_ENTRY( arg, args, const var_t, entry ) {
1073  if (count) {
1074  if (do_indent)
1075  {
1076  fprintf(h, ",\n");
1077  indent(h, 0);
1078  }
1079  else fprintf(h, ",");
1080  }
1081  write_type_decl(h, arg->type, arg->name);
1082  if (method == 2) {
1083  const expr_t *expr = get_attrp(arg->attrs, ATTR_DEFAULTVALUE);
1084  if (expr) {
1085  const var_t *tail_arg;
1086 
1087  /* Output default value only if all following arguments also have default value. */
1088  LIST_FOR_EACH_ENTRY_REV( tail_arg, args, const var_t, entry ) {
1089  if(tail_arg == arg) {
1090  expr_t bstr;
1091 
1092  /* Fixup the expression type for a BSTR like midl does. */
1093  if (get_type_vt(arg->type) == VT_BSTR && expr->type == EXPR_STRLIT)
1094  {
1095  bstr = *expr;
1096  bstr.type = EXPR_WSTRLIT;
1097  expr = &bstr;
1098  }
1099 
1100  fprintf(h, " = ");
1101  write_expr( h, expr, 0, 1, NULL, NULL, "" );
1102  break;
1103  }
1104  if(!get_attrp(tail_arg->attrs, ATTR_DEFAULTVALUE))
1105  break;
1106  }
1107  }
1108  }
1109  count++;
1110  }
1111  if (do_indent) indentation--;
1112 }
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
void * get_attrp(const attr_list_t *list, enum attr_type t)
Definition: header.c:107
static void indent(FILE *h, int delta)
Definition: header.c:48
enum expr_type type
Definition: widltypes.h:307
GLuint GLuint GLsizei count
Definition: gl.h:1545
static int indentation
Definition: header.c:40
void * arg
Definition: msvc.h:10
Definition: match.c:390
Definition: query.h:86
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
int type
Definition: query.h:88
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
smooth NULL
Definition: ftsmooth.c:416
void write_type_decl(FILE *f, type_t *t, const char *name)
Definition: header.c:561
attr_list_t * attrs
Definition: widltypes.h:453
method
Definition: dragdrop.c:53
uint32_t entry
Definition: isohybrid.c:63
void write_expr(FILE *h, const expr_t *e, int brackets, int toplevel, const char *toplevel_prefix, const type_t *cont_type, const char *local_var_prefix)
Definition: expr.c:691
#define LIST_FOR_EACH_ENTRY_REV(elem, list, type, field)
Definition: list.h:222
Definition: name.c:38
unsigned short get_type_vt(type_t *t)
Definition: typelib.c:129

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_c_disp_method_def()

static void write_c_disp_method_def ( FILE header,
const type_t iface 
)
static

Definition at line 1303 of file header.c.

1304 {
1306 }
static void do_write_c_method_def(FILE *header, const type_t *iface, const char *name)
Definition: header.c:1240
const char * c_name
Definition: widltypes.h:435
static type_t * type_iface_get_inherit(const type_t *type)
Definition: typetree.h:158

Referenced by write_com_interface_end().

◆ write_c_method_def()

static void write_c_method_def ( FILE header,
const type_t iface 
)
static

Definition at line 1298 of file header.c.

1299 {
1300  do_write_c_method_def(header, iface, iface->c_name);
1301 }
static void do_write_c_method_def(FILE *header, const type_t *iface, const char *name)
Definition: header.c:1240
const char * c_name
Definition: widltypes.h:435

Referenced by write_com_interface_end().

◆ write_coclass()

static void write_coclass ( FILE header,
type_t cocl 
)
static

Definition at line 1581 of file header.c.

1582 {
1583  const UUID *uuid = get_attrp(cocl->attrs, ATTR_UUID);
1584 
1585  fprintf(header, "/*****************************************************************************\n");
1586  fprintf(header, " * %s coclass\n", cocl->name);
1587  fprintf(header, " */\n\n");
1588  if (uuid)
1589  write_guid(header, "CLSID", cocl->name, uuid);
1590  fprintf(header, "\n#ifdef __cplusplus\n");
1591  if (uuid)
1592  {
1593  fprintf(header, "class DECLSPEC_UUID(\"%s\") %s;\n", uuid_string(uuid), cocl->name);
1594  write_uuid_decl(header, cocl, uuid);
1595  }
1596  else
1597  {
1598  fprintf(header, "class %s;\n", cocl->name);
1599  }
1600  fprintf(header, "#endif\n");
1601  fprintf(header, "\n");
1602 }
void * get_attrp(const attr_list_t *list, enum attr_type t)
Definition: header.c:107
static void write_guid(FILE *f, const char *guid_prefix, const char *name, const UUID *uuid)
Definition: header.c:123
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
static void write_uuid_decl(FILE *f, type_t *type, const UUID *uuid)
Definition: header.c:133
attr_list_t * attrs
Definition: widltypes.h:421
const char * name
Definition: widltypes.h:418
static const char * uuid_string(const UUID *uuid)
Definition: header.c:146
Definition: msctf.idl:510

Referenced by write_header_stmts().

◆ write_coclass_forward()

static void write_coclass_forward ( FILE header,
type_t cocl 
)
static

Definition at line 1604 of file header.c.

1605 {
1606  fprintf(header, "#ifndef __%s_FWD_DEFINED__\n", cocl->name);
1607  fprintf(header, "#define __%s_FWD_DEFINED__\n", cocl->name);
1608  fprintf(header, "#ifdef __cplusplus\n");
1609  fprintf(header, "typedef class %s %s;\n", cocl->name, cocl->name);
1610  fprintf(header, "#else\n");
1611  fprintf(header, "typedef struct %s %s;\n", cocl->name, cocl->name);
1612  fprintf(header, "#endif /* defined __cplusplus */\n");
1613  fprintf(header, "#endif /* defined __%s_FWD_DEFINED__ */\n\n", cocl->name );
1614 }
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
const char * name
Definition: widltypes.h:418

Referenced by write_forward_decls().

◆ write_com_interface_end()

static void write_com_interface_end ( FILE header,
type_t iface 
)
static

Definition at line 1462 of file header.c.

1463 {
1464  int dispinterface = is_attr(iface->attrs, ATTR_DISPINTERFACE);
1465  const UUID *uuid = get_attrp(iface->attrs, ATTR_UUID);
1466  type_t *type;
1467 
1468  if (uuid)
1469  write_guid(header, dispinterface ? "DIID" : "IID", iface->c_name, uuid);
1470 
1471  /* C++ interface */
1472  fprintf(header, "#if defined(__cplusplus) && !defined(CINTERFACE)\n");
1473  if (!is_global_namespace(iface->namespace)) {
1474  write_line(header, 0, "} /* extern \"C\" */");
1475  write_namespace_start(header, iface->namespace);
1476  }
1477  if (uuid) {
1478  write_line(header, 0, "MIDL_INTERFACE(\"%s\")", uuid_string(uuid));
1479  indent(header, 0);
1480  }else {
1481  indent(header, 0);
1482  fprintf(header, "interface ");
1483  }
1484  if (type_iface_get_inherit(iface))
1485  {
1486  fprintf(header, "%s : public %s\n", iface->name,
1487  type_iface_get_inherit(iface)->name);
1488  write_line(header, 1, "{");
1489  }
1490  else
1491  {
1492  fprintf(header, "%s\n", iface->name);
1493  write_line(header, 1, "{\n");
1494  write_line(header, 0, "BEGIN_INTERFACE\n");
1495  }
1496  /* dispinterfaces don't have real functions, so don't write C++ functions for
1497  * them */
1498  if (!dispinterface)
1499  write_cpp_method_def(header, iface);
1500  if (!type_iface_get_inherit(iface))
1501  write_line(header, 0, "END_INTERFACE\n");
1502  write_line(header, -1, "};");
1503  if (!is_global_namespace(iface->namespace)) {
1504  write_namespace_end(header, iface->namespace);
1505  write_line(header, 0, "extern \"C\" {");
1506  }
1507  if (uuid)
1508  write_uuid_decl(header, iface, uuid);
1509  fprintf(header, "#else\n");
1510  /* C interface */
1511  write_line(header, 1, "typedef struct %sVtbl {", iface->c_name);
1512  write_line(header, 0, "BEGIN_INTERFACE\n");
1513  if (dispinterface)
1515  else
1516  write_c_method_def(header, iface);
1517  write_line(header, 0, "END_INTERFACE");
1518  write_line(header, -1, "} %sVtbl;\n", iface->c_name);
1519  fprintf(header, "interface %s {\n", iface->c_name);
1520  fprintf(header, " CONST_VTBL %sVtbl* lpVtbl;\n", iface->c_name);
1521  fprintf(header, "};\n\n");
1522  fprintf(header, "#ifdef COBJMACROS\n");
1523  /* dispinterfaces don't have real functions, so don't write macros for them,
1524  * only for the interface this interface inherits from, i.e. IDispatch */
1525  fprintf(header, "#ifndef WIDL_C_INLINE_WRAPPERS\n");
1526  type = dispinterface ? type_iface_get_inherit(iface) : iface;
1528  fprintf(header, "#else\n");
1530  fprintf(header, "#endif\n");
1531  fprintf(header, "#endif\n");
1532  fprintf(header, "\n");
1533  fprintf(header, "#endif\n");
1534  fprintf(header, "\n");
1535  /* dispinterfaces don't have real functions, so don't write prototypes for
1536  * them */
1537  if (!dispinterface && !winrt_mode)
1538  {
1539  write_method_proto(header, iface);
1540  write_locals(header, iface, FALSE);
1541  fprintf(header, "\n");
1542  }
1543  fprintf(header,"#endif /* __%s_%sINTERFACE_DEFINED__ */\n\n", iface->c_name, dispinterface ? "DISP" : "");
1544 }
static int is_global_namespace(const struct namespace *namespace)
Definition: widltypes.h:613
void * get_attrp(const attr_list_t *list, enum attr_type t)
Definition: header.c:107
static void indent(FILE *h, int delta)
Definition: header.c:48
static void write_locals(FILE *fp, const type_t *iface, int body)
Definition: header.c:1334
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
static void write_guid(FILE *f, const char *guid_prefix, const char *name, const UUID *uuid)
Definition: header.c:123
static void write_namespace_start(FILE *header, struct namespace *namespace)
Definition: header.c:157
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
static void write_uuid_decl(FILE *f, type_t *type, const UUID *uuid)
Definition: header.c:133
static void write_namespace_end(FILE *header, struct namespace *namespace)
Definition: header.c:169
static void write_line(FILE *f, int delta, const char *fmt,...)
Definition: header.c:56
attr_list_t * attrs
Definition: widltypes.h:421
const char * c_name
Definition: widltypes.h:435
static void write_c_disp_method_def(FILE *header, const type_t *iface)
Definition: header.c:1303
static void write_method_macro(FILE *header, const type_t *iface, const type_t *child, const char *name)
Definition: header.c:1013
static void write_c_method_def(FILE *header, const type_t *iface)
Definition: header.c:1298
const char * name
Definition: widltypes.h:418
static type_t * type_iface_get_inherit(const type_t *type)
Definition: typetree.h:158
static const char * uuid_string(const UUID *uuid)
Definition: header.c:146
Definition: name.c:38
static void write_inline_wrappers(FILE *header, const type_t *iface, const type_t *child, const char *name)
Definition: header.c:1184
Definition: msctf.idl:510
static void write_method_proto(FILE *header, const type_t *iface)
Definition: header.c:1308
static void write_cpp_method_def(FILE *header, const type_t *iface)
Definition: header.c:1114
int is_attr(const attr_list_t *list, enum attr_type t)
Definition: header.c:99
int winrt_mode
Definition: widl.c:129

Referenced by write_header_stmts().

◆ write_com_interface_start()

static void write_com_interface_start ( FILE header,
const type_t iface 
)
static

Definition at line 1452 of file header.c.

1453 {
1454  int dispinterface = is_attr(iface->attrs, ATTR_DISPINTERFACE);
1455  fprintf(header, "/*****************************************************************************\n");
1456  fprintf(header, " * %s %sinterface\n", iface->name, dispinterface ? "disp" : "");
1457  fprintf(header, " */\n");
1458  fprintf(header,"#ifndef __%s_%sINTERFACE_DEFINED__\n", iface->c_name, dispinterface ? "DISP" : "");
1459  fprintf(header,"#define __%s_%sINTERFACE_DEFINED__\n\n", iface->c_name, dispinterface ? "DISP" : "");
1460 }
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
attr_list_t * attrs
Definition: widltypes.h:421
const char * c_name
Definition: widltypes.h:435
const char * name
Definition: widltypes.h:418
int is_attr(const attr_list_t *list, enum attr_type t)
Definition: header.c:99

Referenced by write_header_stmts().

◆ write_context_handle_rundowns()

static void write_context_handle_rundowns ( FILE header)
static

Definition at line 773 of file header.c.

774 {
775  context_handle_t *ch;
777  {
778  const char *name = ch->name;
779  fprintf(header, "void __RPC_USER %s_rundown(%s);\n", name, name);
780  }
781 }
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
uint32_t entry
Definition: isohybrid.c:63
const char * name
Definition: widltypes.h:522
Definition: name.c:38

Referenced by write_header().

◆ write_cpp_method_def()

static void write_cpp_method_def ( FILE header,
const type_t iface 
)
static

Definition at line 1114 of file header.c.

1115 {
1116  const statement_t *stmt;
1117 
1119  {
1120  const var_t *func = stmt->u.var;
1121  if (!is_callas(func->attrs)) {
1122  const char *callconv = get_attrp(func->type->attrs, ATTR_CALLCONV);
1123  const var_list_t *args = type_get_function_args(func->type);
1124  const var_t *arg;
1125 
1126  if (!callconv) callconv = "STDMETHODCALLTYPE";
1127 
1128  if (is_aggregate_return(func)) {
1129  fprintf(header, "#ifdef WIDL_EXPLICIT_AGGREGATE_RETURNS\n");
1130 
1131  indent(header, 0);
1132  fprintf(header, "virtual ");
1134  fprintf(header, "* %s %s(\n", callconv, get_name(func));
1135  ++indentation;
1136  indent(header, 0);
1138  fprintf(header, " *__ret");
1139  --indentation;
1140  if (args) {
1141  fprintf(header, ",\n");
1142  write_args(header, args, iface->name, 2, TRUE);
1143  }
1144  fprintf(header, ") = 0;\n");
1145 
1146  indent(header, 0);
1148  fprintf(header, " %s %s(\n", callconv, get_name(func));
1149  write_args(header, args, iface->name, 2, TRUE);
1150  fprintf(header, ")\n");
1151  indent(header, 0);
1152  fprintf(header, "{\n");
1153  ++indentation;
1154  indent(header, 0);
1156  fprintf(header, " __ret;\n");
1157  indent(header, 0);
1158  fprintf(header, "return *%s(&__ret", get_name(func));
1159  if (args)
1161  fprintf(header, ", %s", arg->name);
1162  fprintf(header, ");\n");
1163  --indentation;
1164  indent(header, 0);
1165  fprintf(header, "}\n");
1166 
1167  fprintf(header, "#else\n");
1168  }
1169 
1170  indent(header, 0);
1171  fprintf(header, "virtual ");
1173  fprintf(header, " %s %s(\n", callconv, get_name(func));
1174  write_args(header, args, iface->name, 2, TRUE);
1175  fprintf(header, ") = 0;\n");
1176 
1178  fprintf(header, "#endif\n");
1179  fprintf(header, "\n");
1180  }
1181  }
1182 }
#define STATEMENTS_FOR_EACH_FUNC(stmt, stmts)
Definition: widltypes.h:596
GLenum func
Definition: glext.h:6028
static var_list_t * type_get_function_args(const type_t *func_type)
Definition: widltypes.h:584
#define TRUE
Definition: types.h:120
static int is_aggregate_return(const var_t *func)
Definition: header.c:996
void * get_attrp(const attr_list_t *list, enum attr_type t)
Definition: header.c:107
static void indent(FILE *h, int delta)
Definition: header.c:48
var_t * var
Definition: widltypes.h:538
static int indentation
Definition: header.c:40
void * arg
Definition: msvc.h:10
Definition: match.c:390
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
void write_args(FILE *h, const var_list_t *args, const char *name, int method, int do_indent)
Definition: header.c:1058
union _statement_t::@4054 u
void write_type_decl_left(FILE *f, type_t *t)
Definition: header.c:566
const char * name
Definition: widltypes.h:418
uint32_t entry
Definition: isohybrid.c:63
Definition: _list.h:228
const char * get_name(const var_t *v)
Definition: header.c:181
const var_t * is_callas(const attr_list_t *a)
Definition: header.c:943
static type_t * type_function_get_rettype(const type_t *type)
Definition: typetree.h:108
static statement_list_t * type_iface_get_stmts(const type_t *type)
Definition: typetree.h:151

Referenced by write_com_interface_end().

◆ write_declaration()

static void write_declaration ( FILE header,
const var_t v 
)
static

Definition at line 819 of file header.c.

820 {
821  if (is_const_decl(v) && v->eval)
822  {
823  fprintf(header, "#define %s (", v->name);
824  write_expr(header, v->eval, 0, 1, NULL, NULL, "");
825  fprintf(header, ")\n\n");
826  }
827  else
828  {
829  switch (v->stgclass)
830  {
831  case STG_NONE:
832  case STG_REGISTER: /* ignored */
833  break;
834  case STG_STATIC:
835  fprintf(header, "static ");
836  break;
837  case STG_EXTERN:
838  fprintf(header, "extern ");
839  break;
840  }
841  write_type_def_or_decl(header, v->type, FALSE, v->name);
842  fprintf(header, ";\n\n");
843  }
844 }
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
smooth NULL
Definition: ftsmooth.c:416
static void write_type_def_or_decl(FILE *f, type_t *t, int field, const char *name)
Definition: header.c:532
void write_expr(FILE *h, const expr_t *e, int brackets, int toplevel, const char *toplevel_prefix, const type_t *cont_type, const char *local_var_prefix)
Definition: expr.c:691
const GLdouble * v
Definition: gl.h:2040
int is_const_decl(const var_t *var)
Definition: header.c:801

Referenced by write_header_stmts().

◆ write_enums()

static void write_enums ( FILE h,
var_list_t enums,
const char enum_name 
)
static

Definition at line 260 of file header.c.

261 {
262  var_t *v;
263  if (!enums) return;
265  {
266  if (v->name) {
267  indent(h, 0);
268  if(!enum_name)
269  fprintf(h, "%s", get_name(v));
270  else
271  fprintf(h, "%s_%s", enum_name, get_name(v));
272  if (v->eval) {
273  fprintf(h, " = ");
274  write_expr(h, v->eval, 0, 1, NULL, NULL, "");
275  }
276  }
277  if (list_next( enums, &v->entry )) fprintf(h, ",\n");
278  }
279  fprintf(h, "\n");
280 }
static void indent(FILE *h, int delta)
Definition: header.c:48
static const struct encodedInt enums[]
Definition: encode.c:365
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
smooth NULL
Definition: ftsmooth.c:416
uint32_t entry
Definition: isohybrid.c:63
void write_expr(FILE *h, const expr_t *e, int brackets, int toplevel, const char *toplevel_prefix, const type_t *cont_type, const char *local_var_prefix)
Definition: expr.c:691
const char * get_name(const var_t *v)
Definition: header.c:181
const GLdouble * v
Definition: gl.h:2040
__WINE_SERVER_LIST_INLINE struct list * list_next(const struct list *list, const struct list *elem)
Definition: list.h:115

Referenced by write_type_left().

◆ write_fields()

static void write_fields ( FILE h,
var_list_t fields 
)
static

Definition at line 197 of file header.c.

198 {
199  unsigned nameless_struct_cnt = 0, nameless_struct_i = 0, nameless_union_cnt = 0, nameless_union_i = 0;
200  const char *name;
201  char buf[32];
202  var_t *v;
203 
204  if (!fields) return;
205 
206  LIST_FOR_EACH_ENTRY( v, fields, var_t, entry ) {
207  if (!v || !v->type) continue;
208 
209  switch(type_get_type_detect_alias(v->type)) {
210  case TYPE_STRUCT:
212  nameless_struct_cnt++;
213  break;
214  case TYPE_UNION:
215  nameless_union_cnt++;
216  break;
217  default:
218  ;
219  }
220  }
221 
222  LIST_FOR_EACH_ENTRY( v, fields, var_t, entry ) {
223  if (!v || !v->type) continue;
224 
225  indent(h, 0);
226  name = v->name;
227 
228  switch(type_get_type_detect_alias(v->type)) {
229  case TYPE_STRUCT:
231  if(!v->name) {
232  fprintf(h, "__C89_NAMELESS ");
233  if(nameless_struct_cnt == 1) {
234  name = "__C89_NAMELESSSTRUCTNAME";
235  }else if(nameless_struct_i < 5 /* # of supporting macros */) {
236  sprintf(buf, "__C89_NAMELESSSTRUCTNAME%d", ++nameless_struct_i);
237  name = buf;
238  }
239  }
240  break;
241  case TYPE_UNION:
242  if(!v->name) {
243  fprintf(h, "__C89_NAMELESS ");
244  if(nameless_union_cnt == 1) {
245  name = "__C89_NAMELESSUNIONNAME";
246  }else if(nameless_union_i < 8 /* # of supporting macros */ ) {
247  sprintf(buf, "__C89_NAMELESSUNIONNAME%d", ++nameless_union_i);
248  name = buf;
249  }
250  }
251  break;
252  default:
253  ;
254  }
255  write_type_def_or_decl(h, v->type, TRUE, name);
256  fprintf(h, ";\n");
257  }
258 }
#define TRUE
Definition: types.h:120
static void indent(FILE *h, int delta)
Definition: header.c:48
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
#define sprintf(buf, format,...)
Definition: sprintf.c:55
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
static void write_type_def_or_decl(FILE *f, type_t *t, int field, const char *name)
Definition: header.c:532
static enum type_type type_get_type_detect_alias(const type_t *type)
Definition: widltypes.h:589
uint32_t entry
Definition: isohybrid.c:63
const GLdouble * v
Definition: gl.h:2040
Definition: name.c:38
WCHAR * name
Definition: name.c:42
GLuint const GLchar * name
Definition: glext.h:6031

Referenced by write_type_left().

◆ write_forward()

static void write_forward ( FILE header,
type_t iface 
)
static

Definition at line 1439 of file header.c.

1440 {
1441  fprintf(header, "#ifndef __%s_FWD_DEFINED__\n", iface->c_name);
1442  fprintf(header, "#define __%s_FWD_DEFINED__\n", iface->c_name);
1443  fprintf(header, "typedef interface %s %s;\n", iface->c_name, iface->c_name);
1444  fprintf(header, "#ifdef __cplusplus\n");
1445  write_namespace_start(header, iface->namespace);
1446  write_line(header, 0, "interface %s;", iface->name);
1447  write_namespace_end(header, iface->namespace);
1448  fprintf(header, "#endif /* __cplusplus */\n");
1449  fprintf(header, "#endif\n\n" );
1450 }
static void write_namespace_start(FILE *header, struct namespace *namespace)
Definition: header.c:157
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
static void write_namespace_end(FILE *header, struct namespace *namespace)
Definition: header.c:169
static void write_line(FILE *f, int delta, const char *fmt,...)
Definition: header.c:56
const char * c_name
Definition: widltypes.h:435
const char * name
Definition: widltypes.h:418

Referenced by write_forward_decls(), and write_header_stmts().

◆ write_forward_decls()

static void write_forward_decls ( FILE header,
const statement_list_t stmts 
)
static

Definition at line 1660 of file header.c.

1661 {
1662  const statement_t *stmt;
1663  if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry )
1664  {
1665  switch (stmt->type)
1666  {
1667  case STMT_TYPE:
1668  if (type_get_type(stmt->u.type) == TYPE_INTERFACE)
1669  {
1670  type_t *iface = stmt->u.type;
1671  if (is_object(iface) || is_attr(iface->attrs, ATTR_DISPINTERFACE))
1672  {
1673  write_forward(header, iface);
1674  if (iface->details.iface->async_iface)
1675  write_forward(header, iface->details.iface->async_iface);
1676  }
1677  }
1678  else if (type_get_type(stmt->u.type) == TYPE_COCLASS)
1680  break;
1681  case STMT_TYPEREF:
1682  case STMT_IMPORTLIB:
1683  /* not included in header */
1684  break;
1685  case STMT_IMPORT:
1686  case STMT_TYPEDEF:
1687  case STMT_MODULE:
1688  case STMT_CPPQUOTE:
1689  case STMT_PRAGMA:
1690  case STMT_DECLARATION:
1691  /* not processed here */
1692  break;
1693  case STMT_LIBRARY:
1695  break;
1696  }
1697  }
1698 }
typelib_t * lib
Definition: widltypes.h:539
static void write_coclass_forward(FILE *header, type_t *cocl)
Definition: header.c:1604
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
static void write_forward(FILE *header, type_t *iface)
Definition: header.c:1439
static void write_forward_decls(FILE *header, const statement_list_t *stmts)
Definition: header.c:1660
statement_type_t type
Definition: parser.h:124
union _statement_t::@4054 u
static enum type_type type_get_type(const type_t *type)
Definition: typetree.h:68
attr_list_t * attrs
Definition: widltypes.h:421
union _type_t::@4053 details
struct iface_details * iface
Definition: widltypes.h:427
uint32_t entry
Definition: isohybrid.c:63
statement_list_t * stmts
Definition: widltypes.h:517
int is_object(const type_t *iface)
Definition: header.c:928
int is_attr(const attr_list_t *list, enum attr_type t)
Definition: header.c:99

Referenced by write_header().

◆ write_function_proto()

static void write_function_proto ( FILE header,
const type_t iface,
const var_t fun,
const char prefix 
)
static

Definition at line 1423 of file header.c.

1424 {
1425  const char *callconv = get_attrp(fun->type->attrs, ATTR_CALLCONV);
1426 
1427  if (!callconv) callconv = "__cdecl";
1428  /* FIXME: do we need to handle call_as? */
1430  fprintf(header, " %s ", callconv);
1431  fprintf(header, "%s%s(\n", prefix, get_name(fun));
1432  if (type_get_function_args(fun->type))
1433  write_args(header, type_get_function_args(fun->type), iface->name, 0, TRUE);
1434  else
1435  fprintf(header, " void");
1436  fprintf(header, ");\n\n");
1437 }
static var_list_t * type_get_function_args(const type_t *func_type)
Definition: widltypes.h:584
#define TRUE
Definition: types.h:120
void * get_attrp(const attr_list_t *list, enum attr_type t)
Definition: header.c:107
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
void write_args(FILE *h, const var_list_t *args, const char *name, int method, int do_indent)
Definition: header.c:1058
type_t * type
Definition: widltypes.h:452
attr_list_t * attrs
Definition: widltypes.h:421
void write_type_decl_left(FILE *f, type_t *t)
Definition: header.c:566
const char * name
Definition: widltypes.h:418
const char * get_name(const var_t *v)
Definition: header.c:181
static type_t * type_function_get_rettype(const type_t *type)
Definition: typetree.h:108

Referenced by write_header_stmts().

◆ write_generic_handle_routines()

static void write_generic_handle_routines ( FILE header)
static

Definition at line 783 of file header.c.

784 {
785  generic_handle_t *gh;
787  {
788  const char *name = gh->name;
789  fprintf(header, "handle_t __RPC_USER %s_bind(%s);\n", name, name);
790  fprintf(header, "void __RPC_USER %s_unbind(%s, handle_t);\n", name, name);
791  }
792 }
generic_handle_list_t generic_handle_list
Definition: header.c:44
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
uint32_t entry
Definition: isohybrid.c:63
const char * name
Definition: widltypes.h:522
Definition: name.c:38

Referenced by write_header().

◆ write_guid()

static void write_guid ( FILE f,
const char guid_prefix,
const char name,
const UUID uuid 
)
static

Definition at line 123 of file header.c.

124 {
125  if (!uuid) return;
126  fprintf(f, "DEFINE_GUID(%s_%s, 0x%08x, 0x%04x, 0x%04x, 0x%02x,0x%02x, 0x%02x,"
127  "0x%02x,0x%02x,0x%02x,0x%02x,0x%02x);\n",
128  guid_prefix, name, uuid->Data1, uuid->Data2, uuid->Data3, uuid->Data4[0],
129  uuid->Data4[1], uuid->Data4[2], uuid->Data4[3], uuid->Data4[4], uuid->Data4[5],
130  uuid->Data4[6], uuid->Data4[7]);
131 }
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
GLfloat f
Definition: glext.h:7540
Definition: name.c:38
Definition: msctf.idl:510

Referenced by write_coclass(), write_com_interface_end(), and write_library().

◆ write_header()

void write_header ( const statement_list_t stmts)

Definition at line 1790 of file header.c.

1791 {
1792  FILE *header;
1793 
1794  if (!do_header) return;
1795 
1796  if(!(header = fopen(header_name, "w"))) {
1797  error("Could not open %s for output\n", header_name);
1798  return;
1799  }
1800  fprintf(header, "/*** Autogenerated by WIDL %s from %s - Do not edit ***/\n\n", PACKAGE_VERSION, input_name);
1801 
1802  fprintf(header, "#ifdef _WIN32\n");
1803  fprintf(header, "#ifndef __REQUIRED_RPCNDR_H_VERSION__\n");
1804  fprintf(header, "#define __REQUIRED_RPCNDR_H_VERSION__ 475\n");
1805  fprintf(header, "#endif\n\n");
1806 
1807  fprintf(header, "#ifdef __REACTOS__\n");
1808  fprintf(header, "#define WIN32_LEAN_AND_MEAN\n");
1809  fprintf(header, "#endif\n\n");
1810 
1811  fprintf(header, "#include <rpc.h>\n" );
1812  fprintf(header, "#include <rpcndr.h>\n" );
1814  fprintf(header, "#include <midles.h>\n" );
1815  fprintf(header, "#endif\n\n");
1816 
1817  fprintf(header, "#ifndef COM_NO_WINDOWS_H\n");
1818  fprintf(header, "#include <windows.h>\n");
1819  fprintf(header, "#include <ole2.h>\n");
1820  fprintf(header, "#endif\n\n");
1821 
1822  fprintf(header, "#ifndef __%s__\n", header_token);
1823  fprintf(header, "#define __%s__\n\n", header_token);
1824 
1825  fprintf(header, "/* Forward declarations */\n\n");
1826  write_forward_decls(header, stmts);
1827 
1828  fprintf(header, "/* Headers for imported files */\n\n");
1829  write_imports(header, stmts);
1830  fprintf(header, "\n");
1832 
1833  write_header_stmts(header, stmts, NULL, FALSE);
1834 
1835  fprintf(header, "/* Begin additional prototypes for all interfaces */\n");
1836  fprintf(header, "\n");
1841  fprintf(header, "\n");
1842  fprintf(header, "/* End additional prototypes */\n");
1843  fprintf(header, "\n");
1844 
1846  fprintf(header, "#endif /* __%s__ */\n", header_token);
1847 
1848  fclose(header);
1849 }
#define error(str)
Definition: mkdosfs.c:1605
#define PACKAGE_VERSION
Definition: config.h:835
char * header_token
Definition: widl.c:138
static void write_imports(FILE *header, const statement_list_t *stmts)
Definition: header.c:1628
static void write_generic_handle_routines(FILE *header)
Definition: header.c:783
void start_cplusplus_guard(FILE *fp)
Definition: widl.c:340
char * header_name
Definition: widl.c:136
static void write_context_handle_rundowns(FILE *header)
Definition: header.c:773
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
static void write_forward_decls(FILE *header, const statement_list_t *stmts)
Definition: header.c:1660
smooth NULL
Definition: ftsmooth.c:416
static void write_header_stmts(FILE *header, const statement_list_t *stmts, const type_t *iface, int ignore_funcs)
Definition: header.c:1700
int do_header
Definition: widl.c:116
void end_cplusplus_guard(FILE *fp)
Definition: widl.c:347
_Check_return_opt_ _CRTIMP int __cdecl fclose(_Inout_ FILE *_File)
_Check_return_ _CRTIMP FILE *__cdecl fopen(_In_z_ const char *_Filename, _In_z_ const char *_Mode)
static int serializable_exists(FILE *header, const type_t *type)
Definition: header.c:725
static int write_serialize_function_decl(FILE *header, const type_t *type)
Definition: header.c:719
static int for_each_serializable(const statement_list_t *stmts, FILE *header, int(*proc)(FILE *, const type_t *))
Definition: header.c:730
static void write_user_types(FILE *header)
Definition: header.c:760
struct CFHEADER header
Definition: fdi.c:101
char * input_name
Definition: parser.yy.c:774

Referenced by yyparse().

◆ write_header_stmts()

static void write_header_stmts ( FILE header,
const statement_list_t stmts,
const type_t iface,
int  ignore_funcs 
)
static

Definition at line 1700 of file header.c.

1701 {
1702  const statement_t *stmt;
1703  if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry )
1704  {
1705  switch (stmt->type)
1706  {
1707  case STMT_TYPE:
1708  if (type_get_type(stmt->u.type) == TYPE_INTERFACE)
1709  {
1710  type_t *iface = stmt->u.type;
1711  type_t *async_iface = iface->details.iface->async_iface;
1712  if (is_object(iface)) is_object_interface++;
1713  if (is_attr(stmt->u.type->attrs, ATTR_DISPINTERFACE) || is_object(stmt->u.type))
1714  {
1718  if (async_iface)
1719  {
1720  write_com_interface_start(header, async_iface);
1721  write_com_interface_end(header, async_iface);
1722  }
1723  }
1724  else
1725  {
1729  }
1730  if (is_object(iface)) is_object_interface--;
1731  }
1732  else if (type_get_type(stmt->u.type) == TYPE_COCLASS)
1733  write_coclass(header, stmt->u.type);
1734  else
1735  {
1737  }
1738  break;
1739  case STMT_TYPEREF:
1740  /* FIXME: shouldn't write out forward declarations for undefined
1741  * interfaces but a number of our IDL files depend on this */
1742  if (type_get_type(stmt->u.type) == TYPE_INTERFACE && !stmt->u.type->written)
1743  write_forward(header, stmt->u.type);
1744  break;
1745  case STMT_IMPORTLIB:
1746  case STMT_MODULE:
1747  case STMT_PRAGMA:
1748  /* not included in header */
1749  break;
1750  case STMT_IMPORT:
1751  /* not processed here */
1752  break;
1753  case STMT_TYPEDEF:
1754  {
1755  const type_list_t *type_entry = stmt->u.type_list;
1756  for (; type_entry; type_entry = type_entry->next)
1757  write_typedef(header, type_entry->type);
1758  break;
1759  }
1760  case STMT_LIBRARY:
1761  write_library(header, stmt->u.lib);
1763  break;
1764  case STMT_CPPQUOTE:
1765  fprintf(header, "%s\n", stmt->u.str);
1766  break;
1767  case STMT_DECLARATION:
1768  if (iface && type_get_type(stmt->u.var->type) == TYPE_FUNCTION)
1769  {
1770  if (!ignore_funcs)
1771  {
1772  int prefixes_differ = strcmp(prefix_client, prefix_server);
1773 
1774  if (prefixes_differ)
1775  {
1776  fprintf(header, "/* client prototype */\n");
1777  write_function_proto(header, iface, stmt->u.var, prefix_client);
1778  fprintf(header, "/* server prototype */\n");
1779  }
1780  write_function_proto(header, iface, stmt->u.var, prefix_server);
1781  }
1782  }
1783  else
1784  write_declaration(header, stmt->u.var);
1785  break;
1786  }
1787  }
1788 }
static void write_function_proto(FILE *header, const type_t *iface, const var_t *fun, const char *prefix)
Definition: header.c:1423
#define TRUE
Definition: types.h:120
typelib_t * lib
Definition: widltypes.h:539
const char * prefix_client
Definition: widl.c:151
var_t * var
Definition: widltypes.h:538
static void write_rpc_interface_end(FILE *header, const type_t *iface)
Definition: header.c:1576
static void write_rpc_interface_start(FILE *header, const type_t *iface)
Definition: header.c:1546
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
static void write_forward(FILE *header, type_t *iface)
Definition: header.c:1439
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
static void write_library(FILE *header, const typelib_t *typelib)
Definition: header.c:846
type_t * type
Definition: widltypes.h:526
smooth NULL
Definition: ftsmooth.c:416
static void write_header_stmts(FILE *header, const statement_list_t *stmts, const type_t *iface, int ignore_funcs)
Definition: header.c:1700
statement_type_t type
Definition: parser.h:124
union _statement_t::@4054 u
static void write_com_interface_end(FILE *header, type_t *iface)
Definition: header.c:1462
static enum type_type type_get_type(const type_t *type)
Definition: typetree.h:68
type_t * type
Definition: widltypes.h:452
union _type_t::@4053 details
struct iface_details * iface
Definition: widltypes.h:427
uint32_t entry
Definition: isohybrid.c:63
static void write_declaration(FILE *header, const var_t *v)
Definition: header.c:819
statement_list_t * stmts
Definition: widltypes.h:517
const char * str
Definition: widltypes.h:537
static void write_typedef(FILE *header, type_t *type)
Definition: header.c:794
type_list_t * type_list
Definition: widltypes.h:540
static int is_object_interface
Definition: header.c:41
static void write_coclass(FILE *header, type_t *cocl)
Definition: header.c:1581
static void write_type_definition(FILE *f, type_t *t)
Definition: header.c:537
int is_object(const type_t *iface)
Definition: header.c:928
const char * prefix_server
Definition: widl.c:152
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
int is_attr(const attr_list_t *list, enum attr_type t)
Definition: header.c:99
struct _type_list_t * next
Definition: widltypes.h:527
static statement_list_t * type_iface_get_stmts(const type_t *type)
Definition: typetree.h:151
static void write_com_interface_start(FILE *header, const type_t *iface)
Definition: header.c:1452

Referenced by write_header().

◆ write_import()

static void write_import ( FILE header,
const char fname 
)
static

Definition at line 1616 of file header.c.

1617 {
1618  char *hname, *p;
1619 
1620  hname = dup_basename(fname, ".idl");
1621  p = hname + strlen(hname) - 2;
1622  if (p <= hname || strcmp( p, ".h" )) strcat(hname, ".h");
1623 
1624  fprintf(header, "#include <%s>\n", hname);
1625  free(hname);
1626 }
char * strcat(char *DstString, const char *SrcString)
Definition: utclib.c:568
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define free
Definition: debug_ros.c:5
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
char * dup_basename(const char *name, const char *ext)
Definition: utils.c:143
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
GLfloat GLfloat p
Definition: glext.h:8902

Referenced by write_imports().

◆ write_imports()

static void write_imports ( FILE header,
const statement_list_t stmts 
)
static

Definition at line 1628 of file header.c.

1629 {
1630  const statement_t *stmt;
1631  if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry )
1632  {
1633  switch (stmt->type)
1634  {
1635  case STMT_TYPE:
1636  if (type_get_type(stmt->u.type) == TYPE_INTERFACE)
1638  break;
1639  case STMT_TYPEREF:
1640  case STMT_IMPORTLIB:
1641  /* not included in header */
1642  break;
1643  case STMT_IMPORT:
1644  write_import(header, stmt->u.str);
1645  break;
1646  case STMT_TYPEDEF:
1647  case STMT_MODULE:
1648  case STMT_CPPQUOTE:
1649  case STMT_PRAGMA:
1650  case STMT_DECLARATION:
1651  /* not processed here */
1652  break;
1653  case STMT_LIBRARY:
1654  write_imports(header, stmt->u.lib->stmts);
1655  break;
1656  }
1657  }
1658 }
typelib_t * lib
Definition: widltypes.h:539
static void write_imports(FILE *header, const statement_list_t *stmts)
Definition: header.c:1628
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
statement_type_t type
Definition: parser.h:124
union _statement_t::@4054 u
static enum type_type type_get_type(const type_t *type)
Definition: typetree.h:68
uint32_t entry
Definition: isohybrid.c:63
statement_list_t * stmts
Definition: widltypes.h:517
const char * str
Definition: widltypes.h:537
static void write_import(FILE *header, const char *fname)
Definition: header.c:1616
static statement_list_t * type_iface_get_stmts(const type_t *type)
Definition: typetree.h:151

Referenced by write_header().

◆ write_inline_wrappers()

static void write_inline_wrappers ( FILE header,
const type_t iface,
const type_t child,
const char name 
)
static

Definition at line 1184 of file header.c.

1185 {
1186  const statement_t *stmt;
1187  int first_iface = 1;
1188 
1189  if (type_iface_get_inherit(iface))
1191 
1193  {
1194  const var_t *func = stmt->u.var;
1195 
1196  if (first_iface)
1197  {
1198  fprintf(header, "/*** %s methods ***/\n", iface->name);
1199  first_iface = 0;
1200  }
1201 
1202  if (is_override_method(iface, child, func))
1203  continue;
1204 
1205  if (!is_callas(func->attrs)) {
1206  const var_t *arg;
1207 
1208 #ifdef __REACTOS__
1209  fprintf(header, "FORCEINLINE ");
1210 #else
1211  fprintf(header, "static FORCEINLINE ");
1212 #endif
1214  fprintf(header, " %s_%s(", name, get_name(func));
1216  fprintf(header, ") {\n");
1217  ++indentation;
1218  if (!is_aggregate_return(func)) {
1219  indent(header, 0);
1220  fprintf(header, "%sThis->lpVtbl->%s(This",
1221  is_void(type_function_get_rettype(func->type)) ? "" : "return ",
1222  get_vtbl_entry_name(iface, func));
1223  } else {
1224  indent(header, 0);
1226  fprintf(header, " __ret;\n");
1227  indent(header, 0);
1228  fprintf(header, "return *This->lpVtbl->%s(This,&__ret", get_vtbl_entry_name(iface, func));
1229  }
1230  if (type_get_function_args(func->type))
1232  fprintf(header, ",%s", arg->name);
1233  fprintf(header, ");\n");
1234  --indentation;
1235  fprintf(header, "}\n");
1236  }
1237  }
1238 }
#define STATEMENTS_FOR_EACH_FUNC(stmt, stmts)
Definition: widltypes.h:596
GLenum func
Definition: glext.h:6028
static var_list_t * type_get_function_args(const type_t *func_type)
Definition: widltypes.h:584
static int is_aggregate_return(const var_t *func)
Definition: header.c:996
static void indent(FILE *h, int delta)
Definition: header.c:48
var_t * var
Definition: widltypes.h:538
static int indentation
Definition: header.c:40
void * arg
Definition: msvc.h:10
static HWND child
Definition: cursoricon.c:298
static int is_override_method(const type_t *iface, const type_t *child, const var_t *func)
Definition: header.c:970
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
void write_args(FILE *h, const var_list_t *args, const char *name, int method, int do_indent)
Definition: header.c:1058
union _statement_t::@4054 u
void write_type_decl_left(FILE *f, type_t *t)
Definition: header.c:566
const char * name
Definition: widltypes.h:418
static type_t * type_iface_get_inherit(const type_t *type)
Definition: typetree.h:158
uint32_t entry
Definition: isohybrid.c:63
static char * get_vtbl_entry_name(const type_t *iface, const var_t *func)
Definition: header.c:1003
const char * get_name(const var_t *v)
Definition: header.c:181
const var_t * is_callas(const attr_list_t *a)
Definition: header.c:943
Definition: name.c:38
static void write_inline_wrappers(FILE *header, const type_t *iface, const type_t *child, const char *name)
Definition: header.c:1184
static int is_void(const type_t *t)
Definition: header.h:69
static type_t * type_function_get_rettype(const type_t *type)
Definition: typetree.h:108
static statement_list_t * type_iface_get_stmts(const type_t *type)
Definition: typetree.h:151

Referenced by write_com_interface_end().

◆ write_library()

static void write_library ( FILE header,
const typelib_t typelib 
)
static

Definition at line 846 of file header.c.

847 {
848  const UUID *uuid = get_attrp(typelib->attrs, ATTR_UUID);
849  fprintf(header, "\n");
850  write_guid(header, "LIBID", typelib->name, uuid);
851  fprintf(header, "\n");
852 }
void * get_attrp(const attr_list_t *list, enum attr_type t)
Definition: header.c:107
static ITypeLib * typelib
Definition: apps.c:108
static void write_guid(FILE *f, const char *guid_prefix, const char *name, const UUID *uuid)
Definition: header.c:123
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
Definition: msctf.idl:510

Referenced by write_header_stmts().

◆ write_line()

static void write_line ( FILE f,
int  delta,
const char fmt,
  ... 
)
static

Definition at line 56 of file header.c.

57 {
58  va_list ap;
59  indent(f, delta);
60  va_start(ap, fmt);
61  vfprintf(f, fmt, ap);
62  va_end(ap);
63  fprintf(f, "\n");
64 }
static void indent(FILE *h, int delta)
Definition: header.c:48
#define va_end(ap)
Definition: acmsvcex.h:90
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
char * va_list
Definition: acmsvcex.h:78
GLfloat f
Definition: glext.h:7540
#define va_start(ap, A)
Definition: acmsvcex.h:91
void int int ULONGLONG int va_list * ap
Definition: winesup.h:32
_Check_return_opt_ _CRTIMP int __cdecl vfprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format, va_list _ArgList)
Definition: dsound.c:943

Referenced by write_com_interface_end(), write_forward(), write_namespace_end(), and write_namespace_start().

◆ write_local_stubs()

void write_local_stubs ( const statement_list_t stmts)

Definition at line 1403 of file header.c.

1404 {
1405  FILE *local_stubs;
1406 
1407  if (!local_stubs_name) return;
1408 
1409  local_stubs = fopen(local_stubs_name, "w");
1410  if (!local_stubs) {
1411  error("Could not open %s for output\n", local_stubs_name);
1412  return;
1413  }
1414  fprintf(local_stubs, "/* call_as/local stubs for %s */\n\n", input_name);
1415  fprintf(local_stubs, "#include <objbase.h>\n");
1416  fprintf(local_stubs, "#include \"%s\"\n\n", header_name);
1417 
1418  write_local_stubs_stmts(local_stubs, stmts);
1419 
1420  fclose(local_stubs);
1421 }
#define error(str)
Definition: mkdosfs.c:1605
char * header_name
Definition: widl.c:136
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
static void write_local_stubs_stmts(FILE *local_stubs, const statement_list_t *stmts)
Definition: header.c:1393
char * local_stubs_name
Definition: widl.c:137
_Check_return_opt_ _CRTIMP int __cdecl fclose(_Inout_ FILE *_File)
_Check_return_ _CRTIMP FILE *__cdecl fopen(_In_z_ const char *_Filename, _In_z_ const char *_Mode)
char * input_name
Definition: parser.yy.c:774

Referenced by yyparse().

◆ write_local_stubs_stmts()

static void write_local_stubs_stmts ( FILE local_stubs,
const statement_list_t stmts 
)
static

Definition at line 1393 of file header.c.

1394 {
1395  const statement_t *stmt;
1396  if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry )
1397  {
1398  if (stmt->type == STMT_TYPE && type_get_type(stmt->u.type) == TYPE_INTERFACE)
1399  write_locals(local_stubs, stmt->u.type, TRUE);
1400  }
1401 }
#define TRUE
Definition: types.h:120
static void write_locals(FILE *fp, const type_t *iface, int body)
Definition: header.c:1334
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
statement_type_t type
Definition: parser.h:124
union _statement_t::@4054 u
static enum type_type type_get_type(const type_t *type)
Definition: typetree.h:68
uint32_t entry
Definition: isohybrid.c:63

Referenced by write_local_stubs().

◆ write_locals()

static void write_locals ( FILE fp,
const type_t iface,
int  body 
)
static

Definition at line 1334 of file header.c.

1335 {
1336  static const char comment[]
1337  = "/* WIDL-generated stub. You must provide an implementation for this. */";
1338  const statement_t *stmt;
1339 
1340  if (!is_object(iface))
1341  return;
1342 
1344  const var_t *func = stmt->u.var;
1345  const var_t *cas = is_callas(func->attrs);
1346 
1347  if (cas) {
1348  const statement_t *stmt2 = NULL;
1350  if (!strcmp(get_name(stmt2->u.var), cas->name))
1351  break;
1352  if (&stmt2->entry != type_iface_get_stmts(iface)) {
1353  const var_t *m = stmt2->u.var;
1354  /* proxy prototype - use local prototype */
1356  fprintf(fp, " CALLBACK %s_%s_Proxy(\n", iface->name, get_name(m));
1357  write_args(fp, type_get_function_args(m->type), iface->name, 1, TRUE);
1358  fprintf(fp, ")");
1359  if (body) {
1360  type_t *rt = type_function_get_rettype(m->type);
1361  fprintf(fp, "\n{\n");
1362  fprintf(fp, " %s\n", comment);
1363  if (rt->name && strcmp(rt->name, "HRESULT") == 0)
1364  fprintf(fp, " return E_NOTIMPL;\n");
1365  else if (type_get_type(rt) != TYPE_VOID) {
1366  fprintf(fp, " ");
1367  write_type_decl(fp, rt, "rv");
1368  fprintf(fp, ";\n");
1369  fprintf(fp, " memset(&rv, 0, sizeof rv);\n");
1370  fprintf(fp, " return rv;\n");
1371  }
1372  fprintf(fp, "}\n\n");
1373  }
1374  else
1375  fprintf(fp, ";\n");
1376  /* stub prototype - use remotable prototype */
1378  fprintf(fp, " __RPC_STUB %s_%s_Stub(\n", iface->name, get_name(m));
1379  write_args(fp, type_get_function_args(func->type), iface->name, 1, TRUE);
1380  fprintf(fp, ")");
1381  if (body)
1382  /* Remotable methods must all return HRESULTs. */
1383  fprintf(fp, "\n{\n %s\n return E_NOTIMPL;\n}\n\n", comment);
1384  else
1385  fprintf(fp, ";\n");
1386  }
1387  else
1388  error_loc("invalid call_as attribute (%s -> %s)\n", func->name, cas->name);
1389  }
1390  }
1391 }
#define STATEMENTS_FOR_EACH_FUNC(stmt, stmts)
Definition: widltypes.h:596
GLenum func
Definition: glext.h:6028
static var_list_t * type_get_function_args(const type_t *func_type)
Definition: widltypes.h:584
#define TRUE
Definition: types.h:120
var_t * var
Definition: widltypes.h:538
const GLfloat * m
Definition: glext.h:10848
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
void error_loc(const char *s,...)
Definition: utils.c:69
smooth NULL
Definition: ftsmooth.c:416
void write_type_decl(FILE *f, type_t *t, const char *name)
Definition: header.c:561
void write_args(FILE *h, const var_list_t *args, const char *name, int method, int do_indent)
Definition: header.c:1058
union _statement_t::@4054 u
static enum type_type type_get_type(const type_t *type)
Definition: typetree.h:68
void write_type_decl_left(FILE *f, type_t *t)
Definition: header.c:566
struct list entry
Definition: widltypes.h:531
const char * name
Definition: widltypes.h:418
Definition: id3.c:18
char * name
Definition: widltypes.h:451
const char * get_name(const var_t *v)
Definition: header.c:181
static const void * body(MD5_CTX *ctx, const void *data, unsigned long size)
Definition: md5.c:100
const var_t * is_callas(const attr_list_t *a)
Definition: header.c:943
int is_object(const type_t *iface)
Definition: header.c:928
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
static type_t * type_function_get_rettype(const type_t *type)
Definition: typetree.h:108
static statement_list_t * type_iface_get_stmts(const type_t *type)
Definition: typetree.h:151

Referenced by write_com_interface_end(), and write_local_stubs_stmts().

◆ write_method_macro()

static void write_method_macro ( FILE header,
const type_t iface,
const type_t child,
const char name 
)
static

Definition at line 1013 of file header.c.

1014 {
1015  const statement_t *stmt;
1016  int first_iface = 1;
1017 
1018  if (type_iface_get_inherit(iface))
1020 
1022  {
1023  const var_t *func = stmt->u.var;
1024 
1025  if (first_iface)
1026  {
1027  fprintf(header, "/*** %s methods ***/\n", iface->name);
1028  first_iface = 0;
1029  }
1030 
1031  if (is_override_method(iface, child, func))
1032  continue;
1033 
1034  if (!is_callas(func->attrs)) {
1035  const var_t *arg;
1036 
1037  fprintf(header, "#define %s_%s(This", name, get_name(func));
1038  if (type_get_function_args(func->type))
1040  fprintf(header, ",%s", arg->name);
1041  fprintf(header, ") ");
1042 
1044  {
1045  fprintf(header, "%s_%s_define_WIDL_C_INLINE_WRAPPERS_for_aggregate_return_support\n", name, get_name(func));
1046  continue;
1047  }
1048 
1049  fprintf(header, "(This)->lpVtbl->%s(This", get_vtbl_entry_name(iface, func));
1050  if (type_get_function_args(func->type))
1052  fprintf(header, ",%s", arg->name);
1053  fprintf(header, ")\n");
1054  }
1055  }
1056 }
#define STATEMENTS_FOR_EACH_FUNC(stmt, stmts)
Definition: widltypes.h:596
GLenum func
Definition: glext.h:6028
static var_list_t * type_get_function_args(const type_t *func_type)
Definition: widltypes.h:584
static int is_aggregate_return(const var_t *func)
Definition: header.c:996
var_t * var
Definition: widltypes.h:538
void * arg
Definition: msvc.h:10
static HWND child
Definition: cursoricon.c:298
static int is_override_method(const type_t *iface, const type_t *child, const var_t *func)
Definition: header.c:970
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
union _statement_t::@4054 u
static void write_method_macro(FILE *header, const type_t *iface, const type_t *child, const char *name)
Definition: header.c:1013
const char * name
Definition: widltypes.h:418
static type_t * type_iface_get_inherit(const type_t *type)
Definition: typetree.h:158
uint32_t entry
Definition: isohybrid.c:63
static char * get_vtbl_entry_name(const type_t *iface, const var_t *func)
Definition: header.c:1003
const char * get_name(const var_t *v)
Definition: header.c:181
const var_t * is_callas(const attr_list_t *a)
Definition: header.c:943
Definition: name.c:38
static statement_list_t * type_iface_get_stmts(const type_t *type)
Definition: typetree.h:151

Referenced by write_com_interface_end().

◆ write_method_proto()

static void write_method_proto ( FILE header,
const type_t iface 
)
static

Definition at line 1308 of file header.c.

1309 {
1310  const statement_t *stmt;
1311 
1313  {
1314  const var_t *func = stmt->u.var;
1315 
1316  if (is_callas(func->attrs)) {
1317  const char *callconv = get_attrp(func->type->attrs, ATTR_CALLCONV);
1318  if (!callconv) callconv = "STDMETHODCALLTYPE";
1319  /* proxy prototype */
1321  fprintf(header, " %s %s_%s_Proxy(\n", callconv, iface->name, get_name(func));
1322  write_args(header, type_get_function_args(func->type), iface->name, 1, TRUE);
1323  fprintf(header, ");\n");
1324  /* stub prototype */
1325  fprintf(header, "void __RPC_STUB %s_%s_Stub(\n", iface->name, get_name(func));
1326  fprintf(header, " IRpcStubBuffer* This,\n");
1327  fprintf(header, " IRpcChannelBuffer* pRpcChannelBuffer,\n");
1328  fprintf(header, " PRPC_MESSAGE pRpcMessage,\n");
1329  fprintf(header, " DWORD* pdwStubPhase);\n");
1330  }
1331  }
1332 }
#define STATEMENTS_FOR_EACH_FUNC(stmt, stmts)
Definition: widltypes.h:596
GLenum func
Definition: glext.h:6028
static var_list_t * type_get_function_args(const type_t *func_type)
Definition: widltypes.h:584
#define TRUE
Definition: types.h:120
void * get_attrp(const attr_list_t *list, enum attr_type t)
Definition: header.c:107
var_t * var
Definition: widltypes.h:538
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
void write_args(FILE *h, const var_list_t *args, const char *name, int method, int do_indent)
Definition: header.c:1058
union _statement_t::@4054 u
void write_type_decl_left(FILE *f, type_t *t)
Definition: header.c:566
const char * name
Definition: widltypes.h:418
const char * get_name(const var_t *v)
Definition: header.c:181
const var_t * is_callas(const attr_list_t *a)
Definition: header.c:943
static type_t * type_function_get_rettype(const type_t *type)
Definition: typetree.h:108
static statement_list_t * type_iface_get_stmts(const type_t *type)
Definition: typetree.h:151

Referenced by write_com_interface_end().

◆ write_namespace_end()

static void write_namespace_end ( FILE header,
struct namespace namespace 
)
static

Definition at line 169 of file header.c.

170 {
171  if(is_global_namespace(namespace)) {
173  write_line(header, -1, "}", namespace->name);
174  return;
175  }
176 
177  write_line(header, -1, "}", namespace->name);
179 }
static int is_global_namespace(const struct namespace *namespace)
Definition: widltypes.h:613
static void write_namespace_end(FILE *header, struct namespace *namespace)
Definition: header.c:169
static void write_line(FILE *f, int delta, const char *fmt,...)
Definition: header.c:56
int use_abi_namespace
Definition: widl.c:130
const char * name
Definition: widltypes.h:392
struct namespace * parent
Definition: widltypes.h:393

Referenced by write_com_interface_end(), write_forward(), and write_type_definition().

◆ write_namespace_start()

static void write_namespace_start ( FILE header,
struct namespace namespace 
)
static

Definition at line 157 of file header.c.

158 {
159  if(is_global_namespace(namespace)) {
161  write_line(header, 1, "namespace ABI {");
162  return;
163  }
164 
166  write_line(header, 1, "namespace %s {", namespace->name);
167 }
static int is_global_namespace(const struct namespace *namespace)
Definition: widltypes.h:613
static void write_namespace_start(FILE *header, struct namespace *namespace)
Definition: header.c:157
static void write_line(FILE *f, int delta, const char *fmt,...)
Definition: header.c:56
int use_abi_namespace
Definition: widl.c:130
const char * name
Definition: widltypes.h:392
struct namespace * parent
Definition: widltypes.h:393

Referenced by write_com_interface_end(), write_forward(), and write_type_definition().

◆ write_pointer_left()

static void write_pointer_left ( FILE h,
type_t ref 
)
static

Definition at line 288 of file header.c.

289 {
290  if (needs_space_after(ref))
291  fprintf(h, " ");
293  fprintf(h, "(");
294  fprintf(h, "*");
295 }
Definition: send.c:47
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
static int type_is_alias(const type_t *type)
Definition: typetree.h:274
static int is_array(const type_t *t)
Definition: header.h:64
int needs_space_after(type_t *t)
Definition: header.c:282
static int type_array_is_decl_as_ptr(const type_t *type)
Definition: typetree.h:260

Referenced by write_type_left().

◆ write_rpc_interface_end()

static void write_rpc_interface_end ( FILE header,
const type_t iface 
)
static

Definition at line 1576 of file header.c.

1577 {
1578  fprintf(header,"\n#endif /* __%s_INTERFACE_DEFINED__ */\n\n", iface->name);
1579 }
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
const char * name
Definition: widltypes.h:418

Referenced by write_header_stmts().

◆ write_rpc_interface_start()

static void write_rpc_interface_start ( FILE header,
const type_t iface 
)
static

Definition at line 1546 of file header.c.

1547 {
1548  unsigned int ver = get_attrv(iface->attrs, ATTR_VERSION);
1549  const var_t *var = get_attrp(iface->attrs, ATTR_IMPLICIT_HANDLE);
1550 
1551  fprintf(header, "/*****************************************************************************\n");
1552  fprintf(header, " * %s interface (v%d.%d)\n", iface->name, MAJORVERSION(ver), MINORVERSION(ver));
1553  fprintf(header, " */\n");
1554  fprintf(header,"#ifndef __%s_INTERFACE_DEFINED__\n", iface->name);
1555  fprintf(header,"#define __%s_INTERFACE_DEFINED__\n\n", iface->name);
1556  if (var)
1557  {
1558  fprintf(header, "extern ");
1559  write_type_decl( header, var->type, var->name );
1560  fprintf(header, ";\n");
1561  }
1562  if (old_names)
1563  {
1564  fprintf(header, "extern RPC_IF_HANDLE %s%s_ClientIfHandle;\n", prefix_client, iface->name);
1565  fprintf(header, "extern RPC_IF_HANDLE %s%s_ServerIfHandle;\n", prefix_server, iface->name);
1566  }
1567  else
1568  {
1569  fprintf(header, "extern RPC_IF_HANDLE %s%s_v%d_%d_c_ifspec;\n",
1570  prefix_client, iface->name, MAJORVERSION(ver), MINORVERSION(ver));
1571  fprintf(header, "extern RPC_IF_HANDLE %s%s_v%d_%d_s_ifspec;\n",
1572  prefix_server, iface->name, MAJORVERSION(ver), MINORVERSION(ver));
1573  }
1574 }
void * get_attrp(const attr_list_t *list, enum attr_type t)
Definition: header.c:107
unsigned int get_attrv(const attr_list_t *list, enum attr_type t)
Definition: header.c:115
const char * prefix_client
Definition: widl.c:151
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
void write_type_decl(FILE *f, type_t *t, const char *name)
Definition: header.c:561
type_t * type
Definition: widltypes.h:452
attr_list_t * attrs
Definition: widltypes.h:421
const char * name
Definition: widltypes.h:418
char * name
Definition: widltypes.h:451
const char * prefix_server
Definition: widl.c:152
int old_names
Definition: widl.c:126
#define MAJORVERSION(version)
Definition: utils.h:75
#define MINORVERSION(version)
Definition: utils.h:76

Referenced by write_header_stmts().

◆ write_serialize_function_decl()

static int write_serialize_function_decl ( FILE header,
const type_t type 
)
static

Definition at line 719 of file header.c.

720 {
722  return 1;
723 }
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
smooth NULL
Definition: ftsmooth.c:416
void write_serialize_functions(FILE *file, const type_t *type, const type_t *iface)
Definition: client.c:338

Referenced by write_header().

◆ write_type_decl()

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

Definition at line 561 of file header.c.

562 {
563  write_type_v(f, t, FALSE, TRUE, name);
564 }
#define TRUE
Definition: types.h:120
GLdouble GLdouble t
Definition: gl.h:2047
GLfloat f
Definition: glext.h:7540
Definition: name.c:38
static void write_type_v(FILE *h, type_t *t, int is_field, int declonly, const char *name)
Definition: header.c:488

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.

567 {
569 }
#define TRUE
Definition: types.h:120
void write_type_left(FILE *h, type_t *t, enum name_type name_type, int declonly)
Definition: header.c:297
GLdouble GLdouble t
Definition: gl.h:2047
GLfloat f
Definition: glext.h:7540

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_def_or_decl()

static void write_type_def_or_decl ( FILE f,
type_t t,
int  field,
const char name 
)
static

Definition at line 532 of file header.c.

533 {
535 }
GLdouble GLdouble t
Definition: gl.h:2047
GLfloat f
Definition: glext.h:7540
Definition: parser.c:43
Definition: name.c:38
static void write_type_v(FILE *h, type_t *t, int is_field, int declonly, const char *name)
Definition: header.c:488

Referenced by write_declaration(), write_fields(), and write_typedef().

◆ write_type_definition()

static void write_type_definition ( FILE f,
type_t t 
)
static

Definition at line 537 of file header.c.

538 {
539  int in_namespace = t->namespace && !is_global_namespace(t->namespace);
540  int save_written = t->written;
541 
542  if(in_namespace) {
543  fprintf(f, "#ifdef __cplusplus\n");
544  fprintf(f, "} /* extern \"C\" */\n");
545  write_namespace_start(f, t->namespace);
546  }
547  indent(f, 0);
549  fprintf(f, ";\n");
550  if(in_namespace) {
551  t->written = save_written;
552  write_namespace_end(f, t->namespace);
553  fprintf(f, "extern \"C\" {\n");
554  fprintf(f, "#else\n");
556  fprintf(f, ";\n");
557  fprintf(f, "#endif\n\n");
558  }
559 }
static int is_global_namespace(const struct namespace *namespace)
Definition: widltypes.h:613
static void indent(FILE *h, int delta)
Definition: header.c:48
void write_type_left(FILE *h, type_t *t, enum name_type name_type, int declonly)
Definition: header.c:297
GLdouble GLdouble t
Definition: gl.h:2047
static void write_namespace_start(FILE *header, struct namespace *namespace)
Definition: header.c:157
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
static void write_namespace_end(FILE *header, struct namespace *namespace)
Definition: header.c:169
GLfloat f
Definition: glext.h:7540

Referenced by write_header_stmts().

◆ 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.

298 {
299  const char *name;
300 
301  if (!h) return;
302 
304 
305  if (is_attr(t->attrs, ATTR_CONST) &&
306  (type_is_alias(t) || !is_ptr(t)))
307  fprintf(h, "const ");
308 
309  if (type_is_alias(t)) fprintf(h, "%s", t->name);
310  else {
311  switch (type_get_type_detect_alias(t)) {
312  case TYPE_ENUM:
313  if (!declonly && t->defined && !t->written) {
314  if (name) fprintf(h, "enum %s {\n", name);
315  else fprintf(h, "enum {\n");
316  t->written = TRUE;
317  indentation++;
318  write_enums(h, type_enum_get_values(t), is_global_namespace(t->namespace) ? NULL : t->name);
319  indent(h, -1);
320  fprintf(h, "}");
321  }
322  else fprintf(h, "enum %s", name ? name : "");
323  break;
324  case TYPE_STRUCT:
326  if (!declonly && t->defined && !t->written) {
327  if (name) fprintf(h, "struct %s {\n", name);
328  else fprintf(h, "struct {\n");
329  t->written = TRUE;
330  indentation++;
331  if (type_get_type(t) != TYPE_STRUCT)
333  else
335  indent(h, -1);
336  fprintf(h, "}");
337  }
338  else fprintf(h, "struct %s", name ? name : "");
339  break;
340  case TYPE_UNION:
341  if (!declonly && t->defined && !t->written) {
342  if (t->name) fprintf(h, "union %s {\n", t->name);
343  else fprintf(h, "union {\n");
344  t->written = TRUE;
345  indentation++;
347  indent(h, -1);
348  fprintf(h, "}");
349  }
350  else fprintf(h, "union %s", t->name ? t->name : "");
351  break;
352  case TYPE_POINTER:
353  {
356  if (is_attr(t->attrs, ATTR_CONST)) fprintf(h, "const ");
357  break;
358  }
359  case TYPE_ARRAY:
360  if (t->name && type_array_is_decl_as_ptr(t))
361  fprintf(h, "%s", t->name);
362  else
363  {
367  }
368  break;
369  case TYPE_BASIC:
374  {
375  if (type_basic_get_sign(t) < 0) fprintf(h, "signed ");
376  else if (type_basic_get_sign(t) > 0) fprintf(h, "unsigned ");
377  }
378  switch (type_basic_get_type(t))
379  {
380  case TYPE_BASIC_INT8: fprintf(h, "small"); break;
381  case TYPE_BASIC_INT16: fprintf(h, "short"); break;
382  case TYPE_BASIC_INT: fprintf(h, "int"); break;
383  case TYPE_BASIC_INT3264: fprintf(h, "__int3264"); break;
384  case TYPE_BASIC_BYTE: fprintf(h, "byte"); break;
385  case TYPE_BASIC_CHAR: fprintf(h, "char"); break;
386  case TYPE_BASIC_WCHAR: fprintf(h, "wchar_t"); break;
387  case TYPE_BASIC_FLOAT: fprintf(h, "float"); break;
388  case TYPE_BASIC_DOUBLE: fprintf(h, "double"); break;
389  case TYPE_BASIC_ERROR_STATUS_T: fprintf(h, "error_status_t"); break;
390  case TYPE_BASIC_HANDLE: fprintf(h, "handle_t"); break;
391  case TYPE_BASIC_INT32:
392  if (type_basic_get_sign(t) > 0)
393  fprintf(h, "UINT32");
394  else
395  fprintf(h, "INT32");
396  break;
397  case TYPE_BASIC_LONG:
398  if (type_basic_get_sign(t) > 0)
399  fprintf(h, "ULONG");
400  else
401  fprintf(h, "LONG");
402  break;
403  case TYPE_BASIC_INT64:
404  if (type_basic_get_sign(t) > 0)
405  fprintf(h, "UINT64");
406  else
407  fprintf(h, "INT64");
408  break;
409  case TYPE_BASIC_HYPER:
410  if (type_basic_get_sign(t) > 0)
411  fprintf(h, "MIDL_uhyper");
412  else
413  fprintf(h, "hyper");
414  break;
415  }
416  break;
417  case TYPE_INTERFACE:
418  case TYPE_MODULE:
419  case TYPE_COCLASS:
420  fprintf(h, "%s", t->name);
421  break;
422  case TYPE_VOID:
423  fprintf(h, "void");
424  break;
425  case TYPE_BITFIELD:
427  break;
428  case TYPE_ALIAS:
429  case TYPE_FUNCTION:
430  /* handled elsewhere */
431  assert(0);
432  break;
433  }
434  }
435 }
static int is_global_namespace(const struct namespace *namespace)
Definition: widltypes.h:613
#define TRUE
Definition: types.h:120
static void indent(FILE *h, int delta)
Definition: header.c:48
static var_list_t * type_struct_get_fields(const type_t *type)
Definition: typetree.h:87
static void write_pointer_left(FILE *h, type_t *ref)
Definition: header.c:288
static type_t * type_array_get_element(const type_t *type)
Definition: typetree.h:253
void write_type_left(FILE *h, type_t *t, enum name_type name_type, int declonly)
Definition: header.c:297
static var_list_t * type_union_get_cases(const type_t *type)
Definition: typetree.h:134
GLdouble GLdouble t
Definition: gl.h:2047
static int indentation
Definition: header.c:40
#define assert(x)
Definition: debug.h:53
name_type
Definition: typetree.h:27
static enum type_basic_type type_basic_get_type(const type_t *type)
Definition: typetree.h:73
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
static type_t * type_pointer_get_ref(const type_t *type)
Definition: typetree.h:292
static var_list_t * type_encapsulated_union_get_fields(const type_t *type)
Definition: typetree.h:127
const char * type_get_name(const type_t *type, enum name_type name_type)
Definition: typetree.c:81
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
static int is_ptr(const type_t *t)
Definition: header.h:59
static int type_is_alias(const type_t *type)
Definition: typetree.h:274
smooth NULL
Definition: ftsmooth.c:416
static var_list_t * type_enum_get_values(const type_t *type)
Definition: typetree.h:113
static type_t * type_bitfield_get_field(const type_t *type)
Definition: typetree.h:306
static enum type_type type_get_type(const type_t *type)
Definition: typetree.h:68
static void write_enums(FILE *h, var_list_t *enums, const char *enum_name)
Definition: header.c:260
static enum type_type type_get_type_detect_alias(const type_t *type)
Definition: widltypes.h:589
Definition: name.c:38
static int type_basic_get_sign(const type_t *type)
Definition: typetree.h:80
static int type_array_is_decl_as_ptr(const type_t *type)
Definition: typetree.h:260
int is_attr(const attr_list_t *list, enum attr_type t)
Definition: header.c:99
static void write_fields(FILE *h, var_list_t *fields)
Definition: header.c:197
GLuint const GLchar * name
Definition: glext.h:6031

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.

438 {
439  if (!h) return;
440  if (type_is_alias(t)) return;
441 
442  switch (type_get_type(t))
443  {
444  case TYPE_ARRAY:
445  {
448  {
450  fprintf(h, ")");
451  }
452  else
453  {
454  if (is_conformant_array(t))
455  fprintf(h, "[%s]", is_field ? "1" : "");
456  else
457  fprintf(h, "[%u]", type_array_get_dim(t));
458  }
460  break;
461  }
462  case TYPE_POINTER:
463  {
466  fprintf(h, ")");
468  break;
469  }
470  case TYPE_BITFIELD:
471  fprintf(h, " : %u", type_bitfield_get_bits(t)->cval);
472  break;
473  case TYPE_VOID:
474  case TYPE_BASIC:
475  case TYPE_ENUM:
476  case TYPE_STRUCT:
478  case TYPE_UNION:
479  case TYPE_ALIAS:
480  case TYPE_MODULE:
481  case TYPE_COCLASS:
482  case TYPE_FUNCTION:
483  case TYPE_INTERFACE:
484  break;
485  }
486 }
static unsigned int type_array_get_dim(const type_t *type)
Definition: typetree.h:232
static type_t * type_array_get_element(const type_t *type)
Definition: typetree.h:253
GLdouble GLdouble t
Definition: gl.h:2047
Definition: send.c:47
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
static type_t * type_pointer_get_ref(const type_t *type)
Definition: typetree.h:292
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
static size_t elem
Definition: string.c:68
static int type_is_alias(const type_t *type)
Definition: typetree.h:274
static int is_array(const type_t *t)
Definition: header.h:64
static int is_conformant_array(const type_t *t)
Definition: header.h:79
static enum type_type type_get_type(const type_t *type)
Definition: typetree.h:68
void write_type_right(FILE *h, type_t *t, int is_field)
Definition: header.c:437
static const expr_t * type_bitfield_get_bits(const type_t *type)
Definition: typetree.h:313
static int type_array_is_decl_as_ptr(const type_t *type)
Definition: typetree.h:260

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

◆ write_type_v()

static void write_type_v ( FILE h,
type_t t,
int  is_field,
int  declonly,
const char name 
)
static

Definition at line 488 of file header.c.

489 {
490  type_t *pt = NULL;
491  int ptr_level = 0;
492 
493  if (!h) return;
494 
495  if (t) {
496  for (pt = t; is_ptr(pt); pt = type_pointer_get_ref(pt), ptr_level++)
497  ;
498 
500  int i;
501  const char *callconv = get_attrp(pt->attrs, ATTR_CALLCONV);
502  if (!callconv && is_object_interface) callconv = "STDMETHODCALLTYPE";
503  if (is_attr(pt->attrs, ATTR_INLINE)) fprintf(h, "inline ");
505  fputc(' ', h);
506  if (ptr_level) fputc('(', h);
507  if (callconv) fprintf(h, "%s ", callconv);
508  for (i = 0; i < ptr_level; i++)
509  fputc('*', h);
510  } else
511  write_type_left(h, t, NAME_DEFAULT, declonly);
512  }
513 
514  if (name) fprintf(h, "%s%s", !t || needs_space_after(t) ? " " : "", name );
515 
516  if (t) {
519 
520  if (ptr_level) fputc(')', h);
521  fputc('(', h);
522  if (args)
523  write_args(h, args, NULL, 0, FALSE);
524  else
525  fprintf(h, "void");
526  fputc(')', h);
527  } else
528  write_type_right(h, t, is_field);
529  }
530 }
_Check_return_opt_ _CRTIMP int __cdecl fputc(_In_ int _Ch, _Inout_ FILE *_File)
void * get_attrp(const attr_list_t *list, enum attr_type t)
Definition: header.c:107
#define pt(x, y)
Definition: drawing.c:79
void write_type_left(FILE *h, type_t *t, enum name_type name_type, int declonly)
Definition: header.c:297
GLdouble GLdouble t
Definition: gl.h:2047
Definition: match.c:390
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
static type_t * type_pointer_get_ref(const type_t *type)
Definition: typetree.h:292
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
static var_list_t * type_function_get_args(const type_t *type)
Definition: typetree.h:94
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
static int is_ptr(const type_t *t)
Definition: header.h:59
smooth NULL
Definition: ftsmooth.c:416
void write_args(FILE *h, const var_list_t *args, const char *name, int method, int do_indent)
Definition: header.c:1058
int needs_space_after(type_t *t)
Definition: header.c:282
void write_type_right(FILE *h, type_t *t, int is_field)
Definition: header.c:437
static enum type_type type_get_type_detect_alias(const type_t *type)
Definition: widltypes.h:589
Definition: _list.h:228
static int is_object_interface
Definition: header.c:41
Definition: name.c:38
static type_t * type_function_get_rettype(const type_t *type)
Definition: typetree.h:108
int is_attr(const attr_list_t *list, enum attr_type t)
Definition: header.c:99

Referenced by write_type_decl(), and write_type_def_or_decl().

◆ write_typedef()

static void write_typedef ( FILE header,
type_t type 
)
static

Definition at line 794 of file header.c.