4 * Copyright 2002 Ove Kaaven
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
39 static int indentation
= 0;
41 static void indent(FILE *h
, int delta
)
44 if (delta
< 0) indentation
+= delta
;
45 for (c
=0; c
<indentation
; c
++) fprintf(h
, " ");
46 if (delta
> 0) indentation
+= delta
;
49 int is_attr(const attr_t
*a
, enum attr_type t
)
52 if (a
->type
== t
) return 1;
58 void *get_attrp(const attr_t
*a
, enum attr_type t
)
61 if (a
->type
== t
) return a
->u
.pval
;
67 unsigned long get_attrv(const attr_t
*a
, enum attr_type t
)
70 if (a
->type
== t
) return a
->u
.ival
;
76 int is_void(const type_t
*t
, const var_t
*v
)
78 if (v
&& v
->ptr_level
) return 0;
79 if (!t
->type
&& !t
->ref
) return 1;
83 static void write_guid(const char *guid_prefix
, const char *name
, UUID
*uuid
)
86 fprintf(header
, "DEFINE_GUID(%s_%s, 0x%08lx, 0x%04x, 0x%04x, 0x%02x,0x%02x, 0x%02x,"
87 "0x%02x,0x%02x,0x%02x,0x%02x,0x%02x);\n",
88 guid_prefix
, name
, uuid
->Data1
, uuid
->Data2
, uuid
->Data3
, uuid
->Data4
[0],
89 uuid
->Data4
[1], uuid
->Data4
[2], uuid
->Data4
[3], uuid
->Data4
[4], uuid
->Data4
[5],
90 uuid
->Data4
[6], uuid
->Data4
[7]);
93 static void write_pident(FILE *h
, const var_t
*v
)
96 for (c
=0; c
<v
->ptr_level
; c
++) {
99 if (v
->name
) fprintf(h
, "%s", v
->name
);
102 void write_name(FILE *h
, const var_t
*v
)
104 if (is_attr( v
->attrs
, ATTR_PROPGET
))
106 else if (is_attr( v
->attrs
, ATTR_PROPPUT
))
108 else if (is_attr( v
->attrs
, ATTR_PROPPUTREF
))
109 fprintf(h
, "putref_" );
110 fprintf(h
, "%s", v
->name
);
113 const char* get_name(const var_t
*v
)
118 void write_array(FILE *h
, const expr_t
*v
, int field
)
121 while (NEXT_LINK(v
)) v
= NEXT_LINK(v
);
125 fprintf(h
, "%ld", v
->cval
); /* statically sized array */
127 if (field
) fprintf(h
, "1"); /* dynamically sized array */
135 static void write_field(FILE *h
, var_t
*v
)
140 write_type(h
, v
->type
, NULL
, v
->tname
);
146 /* not all C/C++ compilers support anonymous structs and unions */
147 switch (v
->type
->type
) {
149 case RPC_FC_CVSTRUCT
:
150 case RPC_FC_CPSTRUCT
:
153 case RPC_FC_BOGUS_STRUCT
:
154 case RPC_FC_ENCAPSULATED_UNION
:
155 fprintf(h
, " DUMMYSTRUCTNAME");
157 case RPC_FC_NON_ENCAPSULATED_UNION
:
158 fprintf(h
, " DUMMYUNIONNAME");
165 write_array(h
, v
->array
, 1);
170 static void write_fields(FILE *h
, var_t
*v
)
174 while (NEXT_LINK(v
)) v
= NEXT_LINK(v
);
177 if (v
== first
) break;
182 static void write_enums(FILE *h
, var_t
*v
)
185 while (NEXT_LINK(v
)) v
= NEXT_LINK(v
);
192 write_expr(h
, v
->eval
, 0);
202 void write_type(FILE *h
, type_t
*t
, const var_t
*v
, const char *n
)
206 if (n
) fprintf(h
, "%s", n
);
208 if (t
->is_const
) fprintf(h
, "const ");
210 if (t
->sign
> 0) fprintf(h
, "signed ");
211 else if (t
->sign
< 0) fprintf(h
, "unsigned ");
214 if (t
->ref
) fprintf(h
, t
->ref
->name
);
215 else fprintf(h
, "byte");
218 if (t
->ref
) fprintf(h
, t
->ref
->name
);
219 else fprintf(h
, "char");
226 if (t
->ref
) fprintf(h
, t
->ref
->name
);
227 else fprintf(h
, "small");
231 if (t
->ref
) fprintf(h
, t
->ref
->name
);
232 else fprintf(h
, "short");
236 if (t
->ref
) fprintf(h
, t
->ref
->name
);
237 else fprintf(h
, "long");
240 if (t
->ref
) fprintf(h
, t
->ref
->name
);
241 else fprintf(h
, "hyper");
247 fprintf(h
, "double");
251 if (t
->defined
&& !t
->written
) {
252 if (t
->name
) fprintf(h
, "enum %s {\n", t
->name
);
253 else fprintf(h
, "enum {\n");
256 write_enums(h
, t
->fields
);
260 else fprintf(h
, "enum %s", t
->name
);
262 case RPC_FC_ERROR_STATUS_T
:
263 if (t
->ref
) fprintf(h
, t
->ref
->name
);
264 else fprintf(h
, "error_status_t");
266 case RPC_FC_BIND_PRIMITIVE
:
267 if (t
->ref
) fprintf(h
, t
->ref
->name
);
268 else fprintf(h
, "handle_t");
271 case RPC_FC_CVSTRUCT
:
272 case RPC_FC_CPSTRUCT
:
275 case RPC_FC_BOGUS_STRUCT
:
276 case RPC_FC_ENCAPSULATED_UNION
:
277 if (t
->defined
&& !t
->written
) {
278 if (t
->name
) fprintf(h
, "struct %s {\n", t
->name
);
279 else fprintf(h
, "struct {\n");
282 write_fields(h
, t
->fields
);
286 else fprintf(h
, "struct %s", t
->name
);
288 case RPC_FC_NON_ENCAPSULATED_UNION
:
289 if (t
->defined
&& !t
->written
) {
290 if (t
->name
) fprintf(h
, "union %s {\n", t
->name
);
291 else fprintf(h
, "union {\n");
294 write_fields(h
, t
->fields
);
298 else fprintf(h
, "union %s", t
->name
);
301 fprintf(h
, "(unknown-type:%d)", t
->type
);
306 write_type(h
, t
->ref
, NULL
, t
->name
);
308 else fprintf(h
, "void");
312 for (c
=0; c
<v
->ptr_level
; c
++) {
321 struct user_type
*next
;
325 static struct user_type
*user_type_list
;
327 static int user_type_registered(const char *name
)
329 struct user_type
*ut
;
330 for (ut
= user_type_list
; ut
; ut
= ut
->next
)
331 if (!strcmp(name
, ut
->name
))
336 static void check_for_user_types(var_t
*v
)
339 type_t
*type
= v
->type
;
340 const char *name
= v
->tname
;
341 for (type
= v
->type
; type
; type
= type
->ref
) {
342 if (type
->user_types_registered
) continue;
343 type
->user_types_registered
= 1;
344 if (is_attr(type
->attrs
, ATTR_WIREMARSHAL
)) {
345 if (!user_type_registered(name
))
347 struct user_type
*ut
= xmalloc(sizeof(struct user_type
) + strlen(name
));
348 strcpy(ut
->name
, name
);
349 ut
->next
= user_type_list
;
352 /* don't carry on parsing fields within this type as we are already
353 * using a wire marshaled type */
356 else if (type
->fields
)
358 var_t
*fields
= type
->fields
;
359 while (NEXT_LINK(fields
)) fields
= NEXT_LINK(fields
);
360 check_for_user_types(fields
);
362 /* the wire_marshal attribute is always at least one reference away
363 * from the name of the type, so update it after the rest of the
364 * processing above */
365 if (type
->name
) name
= type
->name
;
371 void write_user_types(void)
373 struct user_type
*ut
;
374 for (ut
= user_type_list
; ut
; ut
= ut
->next
)
376 const char *name
= ut
->name
;
377 fprintf(header
, "unsigned long __RPC_USER %s_UserSize (unsigned long *, unsigned long, %s *);\n", name
, name
);
378 fprintf(header
, "unsigned char * __RPC_USER %s_UserMarshal (unsigned long *, unsigned char *, %s *);\n", name
, name
);
379 fprintf(header
, "unsigned char * __RPC_USER %s_UserUnmarshal(unsigned long *, unsigned char *, %s *);\n", name
, name
);
380 fprintf(header
, "void __RPC_USER %s_UserFree (unsigned long *, %s *);\n", name
, name
);
384 void write_typedef(type_t
*type
, const var_t
*names
)
386 char *tname
= names
->tname
;
388 while (NEXT_LINK(names
)) names
= NEXT_LINK(names
);
390 fprintf(header
, "typedef ");
391 write_type(header
, type
, NULL
, tname
);
392 fprintf(header
, " ");
394 write_pident(header
, names
);
395 if (PREV_LINK(names
))
396 fprintf(header
, ", ");
397 names
= PREV_LINK(names
);
399 fprintf(header
, ";\n");
402 void write_expr(FILE *h
, const expr_t
*e
, int brackets
)
408 fprintf(h
, "%ld", e
->u
.lval
);
411 fprintf(h
, "0x%lx", e
->u
.lval
);
413 case EXPR_IDENTIFIER
:
414 fprintf(h
, "%s", e
->u
.sval
);
418 write_expr(h
, e
->ref
, 1);
422 write_expr(h
, e
->ref
, 1);
426 write_expr(h
, e
->ref
, 1);
430 write_type(h
, e
->u
.tref
->ref
, NULL
, e
->u
.tref
->name
);
432 write_expr(h
, e
->ref
, 1);
435 fprintf(h
, "sizeof(");
436 write_type(h
, e
->u
.tref
->ref
, NULL
, e
->u
.tref
->name
);
447 if (brackets
) fprintf(h
, "(");
448 write_expr(h
, e
->ref
, 1);
450 case EXPR_SHL
: fprintf(h
, " << "); break;
451 case EXPR_SHR
: fprintf(h
, " >> "); break;
452 case EXPR_MUL
: fprintf(h
, " * "); break;
453 case EXPR_DIV
: fprintf(h
, " / "); break;
454 case EXPR_ADD
: fprintf(h
, " + "); break;
455 case EXPR_SUB
: fprintf(h
, " - "); break;
456 case EXPR_AND
: fprintf(h
, " & "); break;
457 case EXPR_OR
: fprintf(h
, " | "); break;
460 write_expr(h
, e
->u
.ext
, 1);
461 if (brackets
) fprintf(h
, ")");
464 if (brackets
) fprintf(h
, "(");
465 write_expr(h
, e
->ref
, 1);
467 write_expr(h
, e
->u
.ext
, 1);
469 write_expr(h
, e
->ext2
, 1);
470 if (brackets
) fprintf(h
, ")");
475 void write_constdef(const var_t
*v
)
477 fprintf(header
, "#define %s (", get_name(v
));
478 write_expr(header
, v
->eval
, 0);
479 fprintf(header
, ")\n\n");
482 void write_externdef(const var_t
*v
)
484 fprintf(header
, "extern const ");
485 write_type(header
, v
->type
, NULL
, v
->tname
);
487 fprintf(header
, " ");
488 write_pident(header
, v
);
490 fprintf(header
, ";\n\n");
493 void write_library(const char *name
, attr_t
*attr
) {
494 UUID
*uuid
= get_attrp(attr
, ATTR_UUID
);
495 fprintf(header
, "\n");
496 write_guid("LIBID", name
, uuid
);
497 fprintf(header
, "\n");
501 var_t
* get_explicit_handle_var(func_t
* func
)
509 while (NEXT_LINK(var
)) var
= NEXT_LINK(var
);
512 if (var
->type
->type
== RPC_FC_IGNORE
)
515 var
= PREV_LINK(var
);
522 /********** INTERFACES **********/
524 int is_object(attr_t
*a
)
527 if (a
->type
== ATTR_OBJECT
|| a
->type
== ATTR_ODL
) return 1;
533 int is_local(attr_t
*a
)
535 return is_attr(a
, ATTR_LOCAL
);
538 var_t
*is_callas(attr_t
*a
)
540 return get_attrp(a
, ATTR_CALLAS
);
543 static int write_method_macro(const type_t
*iface
, const char *name
)
546 func_t
*cur
= iface
->funcs
;
548 if (iface
->ref
) idx
= write_method_macro(iface
->ref
, name
);
551 if (!cur
) return idx
;
552 while (NEXT_LINK(cur
)) cur
= NEXT_LINK(cur
);
554 fprintf(header
, "/*** %s methods ***/\n", iface
->name
);
556 var_t
*def
= cur
->def
;
557 if (!is_callas(def
->attrs
)) {
558 var_t
*arg
= cur
->args
;
562 arg
= NEXT_LINK(arg
);
566 fprintf(header
, "#define %s_", name
);
567 write_name(header
,def
);
568 fprintf(header
, "(p");
569 for (c
=0; c
<argc
; c
++)
570 fprintf(header
, ",%c", c
+'a');
571 fprintf(header
, ") ");
573 fprintf(header
, "(p)->lpVtbl->");
574 write_name(header
, def
);
575 fprintf(header
, "(p");
576 for (c
=0; c
<argc
; c
++)
577 fprintf(header
, ",%c", c
+'a');
578 fprintf(header
, ")\n");
579 if (cur
->idx
== -1) cur
->idx
= idx
;
580 else if (cur
->idx
!= idx
) yyerror("BUG: method index mismatch in write_method_macro");
583 cur
= PREV_LINK(cur
);
588 void write_args(FILE *h
, var_t
*arg
, const char *name
, int method
, int do_indent
)
592 while (NEXT_LINK(arg
))
593 arg
= NEXT_LINK(arg
);
601 fprintf(h
, "%s* This", name
);
611 else fprintf(h
, ",");
613 write_type(h
, arg
->type
, arg
, arg
->tname
);
616 fprintf(h
, " (STDMETHODCALLTYPE *");
619 write_args(h
, arg
->args
, NULL
, 0, FALSE
);
627 write_array(h
, arg
->array
, 0);
628 arg
= PREV_LINK(arg
);
631 if (do_indent
) indentation
--;
634 static void write_cpp_method_def(const type_t
*iface
)
636 func_t
*cur
= iface
->funcs
;
639 while (NEXT_LINK(cur
)) cur
= NEXT_LINK(cur
);
641 var_t
*def
= cur
->def
;
642 if (!is_callas(def
->attrs
)) {
644 fprintf(header
, "virtual ");
645 write_type(header
, def
->type
, def
, def
->tname
);
646 fprintf(header
, " STDMETHODCALLTYPE ");
647 write_name(header
, def
);
648 fprintf(header
, "(\n");
649 write_args(header
, cur
->args
, iface
->name
, 2, TRUE
);
650 fprintf(header
, ") = 0;\n");
651 fprintf(header
, "\n");
653 cur
= PREV_LINK(cur
);
657 static void do_write_c_method_def(const type_t
*iface
, char *name
)
659 func_t
*cur
= iface
->funcs
;
661 if (iface
->ref
) do_write_c_method_def(iface
->ref
, name
);
664 while (NEXT_LINK(cur
)) cur
= NEXT_LINK(cur
);
666 fprintf(header
, "/*** %s methods ***/\n", iface
->name
);
668 var_t
*def
= cur
->def
;
669 if (!is_callas(def
->attrs
)) {
671 write_type(header
, def
->type
, def
, def
->tname
);
672 fprintf(header
, " (STDMETHODCALLTYPE *");
673 write_name(header
, def
);
674 fprintf(header
, ")(\n");
675 write_args(header
, cur
->args
, name
, 1, TRUE
);
676 fprintf(header
, ");\n");
677 fprintf(header
, "\n");
679 cur
= PREV_LINK(cur
);
683 static void write_c_method_def(const type_t
*iface
)
685 do_write_c_method_def(iface
, iface
->name
);
688 static void write_c_disp_method_def(const type_t
*iface
)
690 do_write_c_method_def(iface
->ref
, iface
->name
);
693 static void write_method_proto(const type_t
*iface
)
695 func_t
*cur
= iface
->funcs
;
698 while (NEXT_LINK(cur
)) cur
= NEXT_LINK(cur
);
700 var_t
*def
= cur
->def
;
701 var_t
*cas
= is_callas(def
->attrs
);
703 if (!is_local(def
->attrs
)) {
704 /* proxy prototype */
705 write_type(header
, def
->type
, def
, def
->tname
);
706 fprintf(header
, " CALLBACK %s_", iface
->name
);
707 write_name(header
, def
);
708 fprintf(header
, "_Proxy(\n");
709 write_args(header
, cur
->args
, iface
->name
, 1, TRUE
);
710 fprintf(header
, ");\n");
712 fprintf(header
, "void __RPC_STUB %s_", iface
->name
);
713 write_name(header
,def
);
714 fprintf(header
, "_Stub(\n");
715 fprintf(header
, " IRpcStubBuffer* This,\n");
716 fprintf(header
, " IRpcChannelBuffer* pRpcChannelBuffer,\n");
717 fprintf(header
, " PRPC_MESSAGE pRpcMessage,\n");
718 fprintf(header
, " DWORD* pdwStubPhase);\n");
722 while (NEXT_LINK(args
))
723 args
= NEXT_LINK(args
);
725 check_for_user_types(args
);
728 func_t
*m
= iface
->funcs
;
729 while (m
&& strcmp(get_name(m
->def
), cas
->name
))
732 var_t
*mdef
= m
->def
;
733 /* proxy prototype - use local prototype */
734 write_type(header
, mdef
->type
, mdef
, mdef
->tname
);
735 fprintf(header
, " CALLBACK %s_", iface
->name
);
736 write_name(header
, mdef
);
737 fprintf(header
, "_Proxy(\n");
738 write_args(header
, m
->args
, iface
->name
, 1, TRUE
);
739 fprintf(header
, ");\n");
740 /* stub prototype - use remotable prototype */
741 write_type(header
, def
->type
, def
, def
->tname
);
742 fprintf(header
, " __RPC_STUB %s_", iface
->name
);
743 write_name(header
, mdef
);
744 fprintf(header
, "_Stub(\n");
745 write_args(header
, cur
->args
, iface
->name
, 1, TRUE
);
746 fprintf(header
, ");\n");
749 yywarning("invalid call_as attribute (%s -> %s)\n", get_name(def
), cas
->name
);
753 cur
= PREV_LINK(cur
);
757 static void write_function_proto(const type_t
*iface
)
759 char *implicit_handle
= get_attrp(iface
->attrs
, ATTR_IMPLICIT_HANDLE
);
760 int explicit_handle
= is_attr(iface
->attrs
, ATTR_EXPLICIT_HANDLE
);
761 var_t
* explicit_handle_var
;
763 func_t
*cur
= iface
->funcs
;
764 while (NEXT_LINK(cur
)) cur
= NEXT_LINK(cur
);
766 var_t
*def
= cur
->def
;
768 /* check for a defined binding handle */
769 explicit_handle_var
= get_explicit_handle_var(cur
);
770 if (explicit_handle
) {
771 if (!explicit_handle_var
) {
772 error("%s() does not define an explicit binding handle!\n", def
->name
);
775 } else if (implicit_handle
) {
776 if (explicit_handle_var
) {
777 error("%s() must not define a binding handle!\n", def
->name
);
782 /* FIXME: do we need to handle call_as? */
783 write_type(header
, def
->type
, def
, def
->tname
);
784 fprintf(header
, " ");
785 write_name(header
, def
);
786 fprintf(header
, "(\n");
788 write_args(header
, cur
->args
, iface
->name
, 0, TRUE
);
790 fprintf(header
, " void");
791 fprintf(header
, ");\n");
793 cur
= PREV_LINK(cur
);
797 void write_forward(type_t
*iface
)
799 /* C/C++ forwards should only be written for object interfaces, so if we
800 * have a full definition we only write one if we find [object] among the
801 * attributes - however, if we don't have a full definition at this point
802 * (i.e. this is an IDL forward), then we also assume that it is an object
803 * interface, since non-object interfaces shouldn't need forwards */
804 if ((!iface
->defined
|| is_object(iface
->attrs
) || is_attr(iface
->attrs
, ATTR_DISPINTERFACE
))
805 && !iface
->written
) {
806 fprintf(header
, "#ifndef __%s_FWD_DEFINED__\n", iface
->name
);
807 fprintf(header
, "#define __%s_FWD_DEFINED__\n", iface
->name
);
808 fprintf(header
, "typedef interface %s %s;\n", iface
->name
, iface
->name
);
809 fprintf(header
, "#endif\n\n" );
810 iface
->written
= TRUE
;
814 static void write_iface_guid(const type_t
*iface
)
816 UUID
*uuid
= get_attrp(iface
->attrs
, ATTR_UUID
);
817 write_guid("IID", iface
->name
, uuid
);
820 static void write_dispiface_guid(const type_t
*iface
)
822 UUID
*uuid
= get_attrp(iface
->attrs
, ATTR_UUID
);
823 write_guid("DIID", iface
->name
, uuid
);
826 static void write_coclass_guid(class_t
*cocl
)
828 UUID
*uuid
= get_attrp(cocl
->attrs
, ATTR_UUID
);
829 write_guid("CLSID", cocl
->name
, uuid
);
832 static void write_com_interface(type_t
*iface
)
834 if (!iface
->funcs
&& !iface
->ref
) {
835 yywarning("%s has no methods", iface
->name
);
839 fprintf(header
, "/*****************************************************************************\n");
840 fprintf(header
, " * %s interface\n", iface
->name
);
841 fprintf(header
, " */\n");
842 fprintf(header
,"#ifndef __%s_INTERFACE_DEFINED__\n", iface
->name
);
843 fprintf(header
,"#define __%s_INTERFACE_DEFINED__\n\n", iface
->name
);
844 write_iface_guid(iface
);
845 write_forward(iface
);
847 fprintf(header
, "#if defined(__cplusplus) && !defined(CINTERFACE)\n");
850 fprintf(header
, "interface %s : public %s\n", iface
->name
, iface
->ref
->name
);
851 fprintf(header
, "{\n");
853 write_cpp_method_def(iface
);
855 fprintf(header
, "};\n");
859 fprintf(header
, "interface %s\n", iface
->name
);
860 fprintf(header
, "{\n");
861 fprintf(header
, " BEGIN_INTERFACE\n");
862 fprintf(header
, "\n");
864 write_cpp_method_def(iface
);
866 fprintf(header
, " END_INTERFACE\n");
867 fprintf(header
, "};\n");
869 fprintf(header
, "#else\n");
871 fprintf(header
, "typedef struct %sVtbl {\n", iface
->name
);
873 fprintf(header
, " BEGIN_INTERFACE\n");
874 fprintf(header
, "\n");
875 write_c_method_def(iface
);
877 fprintf(header
, " END_INTERFACE\n");
878 fprintf(header
, "} %sVtbl;\n", iface
->name
);
879 fprintf(header
, "interface %s {\n", iface
->name
);
880 fprintf(header
, " const %sVtbl* lpVtbl;\n", iface
->name
);
881 fprintf(header
, "};\n");
882 fprintf(header
, "\n");
883 fprintf(header
, "#ifdef COBJMACROS\n");
884 write_method_macro(iface
, iface
->name
);
885 fprintf(header
, "#endif\n");
886 fprintf(header
, "\n");
887 fprintf(header
, "#endif\n");
888 fprintf(header
, "\n");
889 write_method_proto(iface
);
890 fprintf(header
,"\n#endif /* __%s_INTERFACE_DEFINED__ */\n\n", iface
->name
);
893 static void write_rpc_interface(const type_t
*iface
)
895 unsigned long ver
= get_attrv(iface
->attrs
, ATTR_VERSION
);
896 char *var
= get_attrp(iface
->attrs
, ATTR_IMPLICIT_HANDLE
);
898 if (!iface
->funcs
) return;
900 fprintf(header
, "/*****************************************************************************\n");
901 fprintf(header
, " * %s interface (v%d.%d)\n", iface
->name
, LOWORD(ver
), HIWORD(ver
));
902 fprintf(header
, " */\n");
903 write_iface_guid(iface
);
904 if (var
) fprintf(header
, "extern handle_t %s;\n", var
);
905 fprintf(header
, "extern RPC_IF_HANDLE %s_v%d_%d_c_ifspec;\n", iface
->name
, LOWORD(ver
), HIWORD(ver
));
906 fprintf(header
, "extern RPC_IF_HANDLE %s_v%d_%d_s_ifspec;\n", iface
->name
, LOWORD(ver
), HIWORD(ver
));
907 write_function_proto(iface
);
908 fprintf(header
, "\n");
910 /* FIXME: server/client code */
913 void write_interface(type_t
*iface
)
915 if (is_object(iface
->attrs
))
916 write_com_interface(iface
);
918 write_rpc_interface(iface
);
921 void write_dispinterface(type_t
*iface
)
923 fprintf(header
, "/*****************************************************************************\n");
924 fprintf(header
, " * %s dispinterface\n", iface
->name
);
925 fprintf(header
, " */\n");
926 fprintf(header
,"#ifndef __%s_DISPINTERFACE_DEFINED__\n", iface
->name
);
927 fprintf(header
,"#define __%s_DISPINTERFACE_DEFINED__\n\n", iface
->name
);
928 write_dispiface_guid(iface
);
929 write_forward(iface
);
931 fprintf(header
, "#if defined(__cplusplus) && !defined(CINTERFACE)\n");
932 fprintf(header
, "interface %s : public %s\n", iface
->name
, iface
->ref
->name
);
933 fprintf(header
, "{\n");
934 fprintf(header
, "};\n");
935 fprintf(header
, "#else\n");
937 fprintf(header
, "typedef struct %sVtbl {\n", iface
->name
);
939 fprintf(header
, " BEGIN_INTERFACE\n");
940 fprintf(header
, "\n");
941 write_c_disp_method_def(iface
);
943 fprintf(header
, " END_INTERFACE\n");
944 fprintf(header
, "} %sVtbl;\n", iface
->name
);
945 fprintf(header
, "interface %s {\n", iface
->name
);
946 fprintf(header
, " const %sVtbl* lpVtbl;\n", iface
->name
);
947 fprintf(header
, "};\n");
948 fprintf(header
, "\n");
949 fprintf(header
, "#ifdef COBJMACROS\n");
950 write_method_macro(iface
->ref
, iface
->name
);
951 fprintf(header
, "#endif\n");
952 fprintf(header
, "\n");
953 fprintf(header
, "#endif\n");
954 fprintf(header
, "\n");
955 fprintf(header
,"#endif /* __%s_DISPINTERFACE_DEFINED__ */\n\n", iface
->name
);
958 void write_coclass(class_t
*cocl
)
960 fprintf(header
, "/*****************************************************************************\n");
961 fprintf(header
, " * %s coclass\n", cocl
->name
);
962 fprintf(header
, " */\n\n");
963 write_coclass_guid(cocl
);
964 fprintf(header
, "\n");