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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
39 typedef struct _user_type_t generic_handle_t
;
41 static int indentation
= 0;
42 user_type_list_t user_type_list
= LIST_INIT(user_type_list
);
43 static context_handle_list_t context_handle_list
= LIST_INIT(context_handle_list
);
44 static struct list generic_handle_list
= LIST_INIT(generic_handle_list
);
46 static void indent(FILE *h
, int delta
)
49 if (delta
< 0) indentation
+= delta
;
50 for (c
=0; c
<indentation
; c
++) fprintf(h
, " ");
51 if (delta
> 0) indentation
+= delta
;
54 int is_ptrchain_attr(const var_t
*var
, enum attr_type t
)
56 if (is_attr(var
->attrs
, t
))
60 type_t
*type
= var
->type
;
63 if (is_attr(type
->attrs
, t
))
65 else if (type
->kind
== TKIND_ALIAS
)
67 else if (is_ptr(type
))
74 int is_aliaschain_attr(const type_t
*type
, enum attr_type attr
)
76 const type_t
*t
= type
;
79 if (is_attr(t
->attrs
, attr
))
81 else if (t
->kind
== TKIND_ALIAS
)
87 int is_attr(const attr_list_t
*list
, enum attr_type t
)
90 if (list
) LIST_FOR_EACH_ENTRY( attr
, list
, const attr_t
, entry
)
91 if (attr
->type
== t
) return 1;
95 void *get_attrp(const attr_list_t
*list
, enum attr_type t
)
98 if (list
) LIST_FOR_EACH_ENTRY( attr
, list
, const attr_t
, entry
)
99 if (attr
->type
== t
) return attr
->u
.pval
;
103 unsigned long get_attrv(const attr_list_t
*list
, enum attr_type t
)
106 if (list
) LIST_FOR_EACH_ENTRY( attr
, list
, const attr_t
, entry
)
107 if (attr
->type
== t
) return attr
->u
.ival
;
111 int is_void(const type_t
*t
)
113 if (!t
->type
&& !t
->ref
) return 1;
117 int is_conformant_array(const type_t
*t
)
119 return t
->type
== RPC_FC_CARRAY
120 || t
->type
== RPC_FC_CVARRAY
121 || (t
->type
== RPC_FC_BOGUS_ARRAY
&& t
->size_is
);
124 void write_guid(FILE *f
, const char *guid_prefix
, const char *name
, const UUID
*uuid
)
127 fprintf(f
, "DEFINE_GUID(%s_%s, 0x%08x, 0x%04x, 0x%04x, 0x%02x,0x%02x, 0x%02x,"
128 "0x%02x,0x%02x,0x%02x,0x%02x,0x%02x);\n",
129 guid_prefix
, name
, uuid
->Data1
, uuid
->Data2
, uuid
->Data3
, uuid
->Data4
[0],
130 uuid
->Data4
[1], uuid
->Data4
[2], uuid
->Data4
[3], uuid
->Data4
[4], uuid
->Data4
[5],
131 uuid
->Data4
[6], uuid
->Data4
[7]);
134 const char *get_name(const var_t
*v
)
136 static char buffer
[256];
138 if (is_attr( v
->attrs
, ATTR_PROPGET
))
139 strcpy( buffer
, "get_" );
140 else if (is_attr( v
->attrs
, ATTR_PROPPUT
))
141 strcpy( buffer
, "put_" );
142 else if (is_attr( v
->attrs
, ATTR_PROPPUTREF
))
143 strcpy( buffer
, "putref_" );
146 strcat( buffer
, v
->name
);
150 static void write_field(FILE *h
, var_t
*v
)
155 write_type_def_or_decl(h
, v
->type
, TRUE
, "%s", v
->name
);
160 static void write_fields(FILE *h
, var_list_t
*fields
)
164 LIST_FOR_EACH_ENTRY( v
, fields
, var_t
, entry
) write_field(h
, v
);
167 static void write_enums(FILE *h
, var_list_t
*enums
)
171 LIST_FOR_EACH_ENTRY( v
, enums
, var_t
, entry
)
175 fprintf(h
, "%s", get_name(v
));
178 write_expr(h
, v
->eval
, 0, 1, NULL
, NULL
, "");
181 if (list_next( enums
, &v
->entry
)) fprintf(h
, ",\n");
186 int needs_space_after(type_t
*t
)
188 return (t
->kind
== TKIND_ALIAS
189 || (!is_ptr(t
) && (!is_conformant_array(t
) || t
->declarray
)));
192 void write_type_left(FILE *h
, type_t
*t
, int declonly
)
196 if (is_attr(t
->attrs
, ATTR_CONST
) &&
197 (t
->kind
== TKIND_ALIAS
|| t
->declarray
|| !is_ptr(t
)))
198 fprintf(h
, "const ");
200 if (t
->kind
== TKIND_ALIAS
) fprintf(h
, "%s", t
->name
);
201 else if (t
->declarray
) write_type_left(h
, t
->ref
, declonly
);
203 if (t
->sign
> 0) fprintf(h
, "signed ");
204 else if (t
->sign
< 0) fprintf(h
, "unsigned ");
208 if (!declonly
&& t
->defined
&& !t
->written
) {
209 if (t
->name
) fprintf(h
, "enum %s {\n", t
->name
);
210 else fprintf(h
, "enum {\n");
213 write_enums(h
, type_enum_get_values(t
));
217 else fprintf(h
, "enum %s", t
->name
? t
->name
: "");
220 case RPC_FC_CVSTRUCT
:
221 case RPC_FC_CPSTRUCT
:
224 case RPC_FC_BOGUS_STRUCT
:
225 case RPC_FC_ENCAPSULATED_UNION
:
226 if (!declonly
&& t
->defined
&& !t
->written
) {
227 if (t
->name
) fprintf(h
, "struct %s {\n", t
->name
);
228 else fprintf(h
, "struct {\n");
231 if (t
->type
== RPC_FC_ENCAPSULATED_UNION
)
232 write_fields(h
, type_encapsulated_union_get_fields(t
));
234 write_fields(h
, type_struct_get_fields(t
));
238 else fprintf(h
, "struct %s", t
->name
? t
->name
: "");
240 case RPC_FC_NON_ENCAPSULATED_UNION
:
241 if (!declonly
&& t
->defined
&& !t
->written
) {
242 if (t
->name
) fprintf(h
, "union %s {\n", t
->name
);
243 else fprintf(h
, "union {\n");
246 write_fields(h
, type_union_get_cases(t
));
250 else fprintf(h
, "union %s", t
->name
? t
->name
: "");
258 case RPC_FC_BOGUS_ARRAY
:
259 write_type_left(h
, t
->ref
, declonly
);
260 fprintf(h
, "%s*", needs_space_after(t
->ref
) ? " " : "");
261 if (is_ptr(t
) && is_attr(t
->attrs
, ATTR_CONST
)) fprintf(h
, "const ");
264 fprintf(h
, "%s", t
->name
);
269 void write_type_right(FILE *h
, type_t
*t
, int is_field
)
274 if (is_conformant_array(t
)) {
275 fprintf(h
, "[%s]", is_field
? "1" : "");
278 for ( ; t
->declarray
; t
= t
->ref
)
279 fprintf(h
, "[%lu]", t
->dim
);
283 void write_type_v(FILE *h
, type_t
*t
, int is_field
, int declonly
,
284 const char *fmt
, va_list args
)
291 for (pt
= t
; is_ptr(pt
); pt
= pt
->ref
, ptr_level
++)
294 if (pt
->type
== RPC_FC_FUNCTION
) {
296 const char *callconv
= get_attrp(pt
->attrs
, ATTR_CALLCONV
);
297 if (!callconv
) callconv
= "";
298 if (is_attr(pt
->attrs
, ATTR_INLINE
)) fprintf(h
, "inline ");
299 write_type_left(h
, pt
->ref
, declonly
);
301 if (ptr_level
) fputc('(', h
);
302 fprintf(h
, "%s ", callconv
);
303 for (i
= 0; i
< ptr_level
; i
++)
306 write_type_left(h
, t
, declonly
);
308 if (needs_space_after(t
))
310 vfprintf(h
, fmt
, args
);
312 if (pt
->type
== RPC_FC_FUNCTION
) {
313 if (ptr_level
) fputc(')', h
);
315 write_args(h
, type_function_get_args(pt
), NULL
, 0, FALSE
);
318 write_type_right(h
, t
, is_field
);
321 void write_type_def_or_decl(FILE *f
, type_t
*t
, int field
, const char *fmt
, ...)
325 write_type_v(f
, t
, field
, FALSE
, fmt
, args
);
329 void write_type_decl(FILE *f
, type_t
*t
, const char *fmt
, ...)
333 write_type_v(f
, t
, FALSE
, TRUE
, fmt
, args
);
337 void write_type_decl_left(FILE *f
, type_t
*t
)
339 write_type_left(f
, t
, TRUE
);
342 static int user_type_registered(const char *name
)
345 LIST_FOR_EACH_ENTRY(ut
, &user_type_list
, user_type_t
, entry
)
346 if (!strcmp(name
, ut
->name
))
351 static int context_handle_registered(const char *name
)
353 context_handle_t
*ch
;
354 LIST_FOR_EACH_ENTRY(ch
, &context_handle_list
, context_handle_t
, entry
)
355 if (!strcmp(name
, ch
->name
))
360 static int generic_handle_registered(const char *name
)
362 generic_handle_t
*gh
;
363 LIST_FOR_EACH_ENTRY(gh
, &generic_handle_list
, generic_handle_t
, entry
)
364 if (!strcmp(name
, gh
->name
))
369 /* check for types which require additional prototypes to be generated in the
371 void check_for_additional_prototype_types(const var_list_t
*list
)
376 LIST_FOR_EACH_ENTRY( v
, list
, const var_t
, entry
)
379 for (type
= v
->type
; type
; type
= type
->kind
== TKIND_ALIAS
? type
->orig
: type
->ref
) {
380 const char *name
= type
->name
;
381 if (type
->user_types_registered
) continue;
382 type
->user_types_registered
= 1;
383 if (is_attr(type
->attrs
, ATTR_CONTEXTHANDLE
)) {
384 if (!context_handle_registered(name
))
386 context_handle_t
*ch
= xmalloc(sizeof(*ch
));
387 ch
->name
= xstrdup(name
);
388 list_add_tail(&context_handle_list
, &ch
->entry
);
390 /* don't carry on parsing fields within this type */
393 if (type
->type
!= RPC_FC_BIND_PRIMITIVE
&& is_attr(type
->attrs
, ATTR_HANDLE
)) {
394 if (!generic_handle_registered(name
))
396 generic_handle_t
*gh
= xmalloc(sizeof(*gh
));
397 gh
->name
= xstrdup(name
);
398 list_add_tail(&generic_handle_list
, &gh
->entry
);
400 /* don't carry on parsing fields within this type */
403 if (is_attr(type
->attrs
, ATTR_WIREMARSHAL
)) {
404 if (!user_type_registered(name
))
406 user_type_t
*ut
= xmalloc(sizeof *ut
);
407 ut
->name
= xstrdup(name
);
408 list_add_tail(&user_type_list
, &ut
->entry
);
410 /* don't carry on parsing fields within this type as we are already
411 * using a wire marshaled type */
414 else if (type_is_complete(type
))
416 var_list_t
*vars
= NULL
;
417 if (type
->type
== RPC_FC_ENUM16
|| type
->type
== RPC_FC_ENUM32
)
418 vars
= type_enum_get_values(type
);
419 else if (is_struct(type
->type
))
420 vars
= type_struct_get_fields(type
);
421 else if (is_union(type
->type
))
422 vars
= type_union_get_cases(type
);
423 check_for_additional_prototype_types(vars
);
429 static void write_user_types(FILE *header
)
432 LIST_FOR_EACH_ENTRY(ut
, &user_type_list
, user_type_t
, entry
)
434 const char *name
= ut
->name
;
435 fprintf(header
, "ULONG __RPC_USER %s_UserSize (ULONG *, ULONG, %s *);\n", name
, name
);
436 fprintf(header
, "unsigned char * __RPC_USER %s_UserMarshal (ULONG *, unsigned char *, %s *);\n", name
, name
);
437 fprintf(header
, "unsigned char * __RPC_USER %s_UserUnmarshal(ULONG *, unsigned char *, %s *);\n", name
, name
);
438 fprintf(header
, "void __RPC_USER %s_UserFree (ULONG *, %s *);\n", name
, name
);
442 static void write_context_handle_rundowns(FILE *header
)
444 context_handle_t
*ch
;
445 LIST_FOR_EACH_ENTRY(ch
, &context_handle_list
, context_handle_t
, entry
)
447 const char *name
= ch
->name
;
448 fprintf(header
, "void __RPC_USER %s_rundown(%s);\n", name
, name
);
452 static void write_generic_handle_routines(FILE *header
)
454 generic_handle_t
*gh
;
455 LIST_FOR_EACH_ENTRY(gh
, &generic_handle_list
, generic_handle_t
, entry
)
457 const char *name
= gh
->name
;
458 fprintf(header
, "handle_t __RPC_USER %s_bind(%s);\n", name
, name
);
459 fprintf(header
, "void __RPC_USER %s_unbind(%s, handle_t);\n", name
, name
);
463 static void write_typedef(FILE *header
, type_t
*type
)
465 fprintf(header
, "typedef ");
466 write_type_def_or_decl(header
, type
->orig
, FALSE
, "%s", type
->name
);
467 fprintf(header
, ";\n");
470 int is_const_decl(const var_t
*var
)
473 /* strangely, MIDL accepts a const attribute on any pointer in the
474 * declaration to mean that data isn't being instantiated. this appears
475 * to be a bug, but there is no benefit to being incompatible with MIDL,
476 * so we'll do the same thing */
477 for (t
= var
->type
; ; )
479 if (is_attr(t
->attrs
, ATTR_CONST
))
488 static void write_declaration(FILE *header
, const var_t
*v
)
490 if (is_const_decl(v
) && v
->eval
)
492 fprintf(header
, "#define %s (", v
->name
);
493 write_expr(header
, v
->eval
, 0, 1, NULL
, NULL
, "");
494 fprintf(header
, ")\n\n");
501 case STG_REGISTER
: /* ignored */
504 fprintf(header
, "static ");
507 fprintf(header
, "extern ");
510 write_type_def_or_decl(header
, v
->type
, FALSE
, "%s", v
->name
);
511 fprintf(header
, ";\n\n");
515 static void write_library(FILE *header
, const typelib_t
*typelib
)
517 const UUID
*uuid
= get_attrp(typelib
->attrs
, ATTR_UUID
);
518 fprintf(header
, "\n");
519 write_guid(header
, "LIBID", typelib
->name
, uuid
);
520 fprintf(header
, "\n");
524 const var_t
* get_explicit_handle_var(const func_t
* func
)
531 LIST_FOR_EACH_ENTRY( var
, func
->args
, const var_t
, entry
)
532 if (var
->type
->type
== RPC_FC_BIND_PRIMITIVE
)
538 const type_t
* get_explicit_generic_handle_type(const var_t
* var
)
541 for (t
= var
->type
; is_ptr(t
); t
= t
->ref
)
542 if (t
->type
!= RPC_FC_BIND_PRIMITIVE
&& is_attr(t
->attrs
, ATTR_HANDLE
))
547 const var_t
* get_explicit_generic_handle_var(const func_t
* func
)
554 LIST_FOR_EACH_ENTRY( var
, func
->args
, const var_t
, entry
)
555 if (get_explicit_generic_handle_type(var
))
561 const var_t
* get_context_handle_var(const func_t
* func
)
568 LIST_FOR_EACH_ENTRY( var
, func
->args
, const var_t
, entry
)
569 if (is_attr(var
->attrs
, ATTR_IN
) && is_context_handle(var
->type
))
575 int has_out_arg_or_return(const func_t
*func
)
579 if (!is_void(get_func_return_type(func
)))
585 LIST_FOR_EACH_ENTRY( var
, func
->args
, const var_t
, entry
)
586 if (is_attr(var
->attrs
, ATTR_OUT
))
593 /********** INTERFACES **********/
595 int is_object(const attr_list_t
*list
)
598 if (list
) LIST_FOR_EACH_ENTRY( attr
, list
, const attr_t
, entry
)
599 if (attr
->type
== ATTR_OBJECT
|| attr
->type
== ATTR_ODL
) return 1;
603 int is_local(const attr_list_t
*a
)
605 return is_attr(a
, ATTR_LOCAL
);
608 const var_t
*is_callas(const attr_list_t
*a
)
610 return get_attrp(a
, ATTR_CALLAS
);
613 static void write_method_macro(FILE *header
, const type_t
*iface
, const char *name
)
617 if (iface
->ref
) write_method_macro(header
, iface
->ref
, name
);
619 if (!iface
->funcs
) return;
621 fprintf(header
, "/*** %s methods ***/\n", iface
->name
);
622 LIST_FOR_EACH_ENTRY( cur
, iface
->funcs
, const func_t
, entry
)
624 var_t
*def
= cur
->def
;
625 if (!is_callas(def
->attrs
)) {
628 fprintf(header
, "#define %s_%s(This", name
, get_name(def
));
630 LIST_FOR_EACH_ENTRY( arg
, cur
->args
, const var_t
, entry
)
631 fprintf(header
, ",%s", arg
->name
);
632 fprintf(header
, ") ");
634 fprintf(header
, "(This)->lpVtbl->%s(This", get_name(def
));
636 LIST_FOR_EACH_ENTRY( arg
, cur
->args
, const var_t
, entry
)
637 fprintf(header
, ",%s", arg
->name
);
638 fprintf(header
, ")\n");
643 void write_args(FILE *h
, const var_list_t
*args
, const char *name
, int method
, int do_indent
)
654 fprintf(h
, "%s* This", name
);
657 if (args
) LIST_FOR_EACH_ENTRY( arg
, args
, const var_t
, entry
) {
664 else fprintf(h
, ",");
666 write_type_decl(h
, arg
->type
, "%s", arg
->name
);
669 if (do_indent
) indentation
--;
672 static void write_cpp_method_def(FILE *header
, const type_t
*iface
)
676 if (!iface
->funcs
) return;
678 LIST_FOR_EACH_ENTRY( cur
, iface
->funcs
, const func_t
, entry
)
680 var_t
*def
= cur
->def
;
681 if (!is_callas(def
->attrs
)) {
682 const char *callconv
= get_attrp(def
->type
->attrs
, ATTR_CALLCONV
);
683 if (!callconv
) callconv
= "";
685 fprintf(header
, "virtual ");
686 write_type_decl_left(header
, get_func_return_type(cur
));
687 fprintf(header
, " %s %s(\n", callconv
, get_name(def
));
688 write_args(header
, cur
->args
, iface
->name
, 2, TRUE
);
689 fprintf(header
, ") = 0;\n");
690 fprintf(header
, "\n");
695 static void do_write_c_method_def(FILE *header
, const type_t
*iface
, const char *name
)
699 if (iface
->ref
) do_write_c_method_def(header
, iface
->ref
, name
);
701 if (!iface
->funcs
) return;
703 fprintf(header
, "/*** %s methods ***/\n", iface
->name
);
704 LIST_FOR_EACH_ENTRY( cur
, iface
->funcs
, const func_t
, entry
)
706 const var_t
*def
= cur
->def
;
707 if (!is_callas(def
->attrs
)) {
708 const char *callconv
= get_attrp(def
->type
->attrs
, ATTR_CALLCONV
);
709 if (!callconv
) callconv
= "";
711 write_type_decl_left(header
, get_func_return_type(cur
));
712 fprintf(header
, " (%s *%s)(\n", callconv
, get_name(def
));
713 write_args(header
, cur
->args
, name
, 1, TRUE
);
714 fprintf(header
, ");\n");
715 fprintf(header
, "\n");
720 static void write_c_method_def(FILE *header
, const type_t
*iface
)
722 do_write_c_method_def(header
, iface
, iface
->name
);
725 static void write_c_disp_method_def(FILE *header
, const type_t
*iface
)
727 do_write_c_method_def(header
, iface
->ref
, iface
->name
);
730 static void write_method_proto(FILE *header
, const type_t
*iface
)
734 if (!iface
->funcs
) return;
735 LIST_FOR_EACH_ENTRY( cur
, iface
->funcs
, const func_t
, entry
)
737 const var_t
*def
= cur
->def
;
739 if (!is_local(def
->attrs
)) {
740 const char *callconv
= get_attrp(def
->type
->attrs
, ATTR_CALLCONV
);
741 if (!callconv
) callconv
= "";
742 /* proxy prototype */
743 write_type_decl_left(header
, get_func_return_type(cur
));
744 fprintf(header
, " %s %s_%s_Proxy(\n", callconv
, iface
->name
, get_name(def
));
745 write_args(header
, cur
->args
, iface
->name
, 1, TRUE
);
746 fprintf(header
, ");\n");
748 fprintf(header
, "void __RPC_STUB %s_%s_Stub(\n", iface
->name
, get_name(def
));
749 fprintf(header
, " IRpcStubBuffer* This,\n");
750 fprintf(header
, " IRpcChannelBuffer* pRpcChannelBuffer,\n");
751 fprintf(header
, " PRPC_MESSAGE pRpcMessage,\n");
752 fprintf(header
, " DWORD* pdwStubPhase);\n");
757 static void write_locals(FILE *fp
, const type_t
*iface
, int body
)
759 static const char comment
[]
760 = "/* WIDL-generated stub. You must provide an implementation for this. */";
761 const func_list_t
*funcs
= iface
->funcs
;
764 if (!is_object(iface
->attrs
) || !funcs
)
767 LIST_FOR_EACH_ENTRY(cur
, funcs
, const func_t
, entry
) {
768 const var_t
*def
= cur
->def
;
769 const var_t
*cas
= is_callas(def
->attrs
);
773 LIST_FOR_EACH_ENTRY(m
, iface
->funcs
, const func_t
, entry
)
774 if (!strcmp(m
->def
->name
, cas
->name
))
776 if (&m
->entry
!= iface
->funcs
) {
777 const var_t
*mdef
= m
->def
;
778 /* proxy prototype - use local prototype */
779 write_type_decl_left(fp
, get_func_return_type(m
));
780 fprintf(fp
, " CALLBACK %s_%s_Proxy(\n", iface
->name
, get_name(mdef
));
781 write_args(fp
, m
->args
, iface
->name
, 1, TRUE
);
784 type_t
*rt
= get_func_return_type(m
);
785 fprintf(fp
, "\n{\n");
786 fprintf(fp
, " %s\n", comment
);
787 if (rt
->name
&& strcmp(rt
->name
, "HRESULT") == 0)
788 fprintf(fp
, " return E_NOTIMPL;\n");
791 write_type_decl(fp
, rt
, "rv");
793 fprintf(fp
, " memset(&rv, 0, sizeof rv);\n");
794 fprintf(fp
, " return rv;\n");
796 fprintf(fp
, "}\n\n");
800 /* stub prototype - use remotable prototype */
801 write_type_decl_left(fp
, get_func_return_type(cur
));
802 fprintf(fp
, " __RPC_STUB %s_%s_Stub(\n", iface
->name
, get_name(mdef
));
803 write_args(fp
, cur
->args
, iface
->name
, 1, TRUE
);
806 /* Remotable methods must all return HRESULTs. */
807 fprintf(fp
, "\n{\n %s\n return E_NOTIMPL;\n}\n\n", comment
);
812 error_loc("invalid call_as attribute (%s -> %s)\n", def
->name
, cas
->name
);
817 static void write_local_stubs_stmts(FILE *local_stubs
, const statement_list_t
*stmts
)
819 const statement_t
*stmt
;
820 if (stmts
) LIST_FOR_EACH_ENTRY( stmt
, stmts
, const statement_t
, entry
)
822 if (stmt
->type
== STMT_TYPE
&& stmt
->u
.type
->type
== RPC_FC_IP
)
823 write_locals(local_stubs
, stmt
->u
.type
, TRUE
);
824 else if (stmt
->type
== STMT_LIBRARY
)
825 write_local_stubs_stmts(local_stubs
, stmt
->u
.lib
->stmts
);
829 void write_local_stubs(const statement_list_t
*stmts
)
833 if (!local_stubs_name
) return;
835 local_stubs
= fopen(local_stubs_name
, "w");
837 error("Could not open %s for output\n", local_stubs_name
);
840 fprintf(local_stubs
, "/* call_as/local stubs for %s */\n\n", input_name
);
841 fprintf(local_stubs
, "#include <objbase.h>\n");
842 fprintf(local_stubs
, "#include \"%s\"\n\n", header_name
);
844 write_local_stubs_stmts(local_stubs
, stmts
);
849 static void write_function_proto(FILE *header
, const type_t
*iface
, const var_t
*fun
, const char *prefix
)
851 const char *callconv
= get_attrp(fun
->type
->attrs
, ATTR_CALLCONV
);
853 /* FIXME: do we need to handle call_as? */
854 write_type_decl_left(header
, fun
->type
->ref
);
855 fprintf(header
, " ");
856 if (callconv
) fprintf(header
, "%s ", callconv
);
857 fprintf(header
, "%s%s(\n", prefix
, get_name(fun
));
858 if (fun
->type
->details
.function
->args
)
859 write_args(header
, fun
->type
->details
.function
->args
, iface
->name
, 0, TRUE
);
861 fprintf(header
, " void");
862 fprintf(header
, ");\n\n");
865 static void write_forward(FILE *header
, type_t
*iface
)
867 fprintf(header
, "#ifndef __%s_FWD_DEFINED__\n", iface
->name
);
868 fprintf(header
, "#define __%s_FWD_DEFINED__\n", iface
->name
);
869 fprintf(header
, "typedef interface %s %s;\n", iface
->name
, iface
->name
);
870 fprintf(header
, "#endif\n\n" );
873 static void write_iface_guid(FILE *header
, const type_t
*iface
)
875 const UUID
*uuid
= get_attrp(iface
->attrs
, ATTR_UUID
);
876 write_guid(header
, "IID", iface
->name
, uuid
);
879 static void write_dispiface_guid(FILE *header
, const type_t
*iface
)
881 const UUID
*uuid
= get_attrp(iface
->attrs
, ATTR_UUID
);
882 write_guid(header
, "DIID", iface
->name
, uuid
);
885 static void write_coclass_guid(FILE *header
, const type_t
*cocl
)
887 const UUID
*uuid
= get_attrp(cocl
->attrs
, ATTR_UUID
);
888 write_guid(header
, "CLSID", cocl
->name
, uuid
);
891 static void write_com_interface_start(FILE *header
, const type_t
*iface
)
893 int dispinterface
= is_attr(iface
->attrs
, ATTR_DISPINTERFACE
);
894 fprintf(header
, "/*****************************************************************************\n");
895 fprintf(header
, " * %s %sinterface\n", iface
->name
, dispinterface
? "disp" : "");
896 fprintf(header
, " */\n");
897 fprintf(header
,"#ifndef __%s_%sINTERFACE_DEFINED__\n", iface
->name
, dispinterface
? "DISP" : "");
898 fprintf(header
,"#define __%s_%sINTERFACE_DEFINED__\n\n", iface
->name
, dispinterface
? "DISP" : "");
901 static void write_com_interface_end(FILE *header
, type_t
*iface
)
903 int dispinterface
= is_attr(iface
->attrs
, ATTR_DISPINTERFACE
);
905 write_dispiface_guid(header
, iface
);
907 write_iface_guid(header
, iface
);
909 fprintf(header
, "#if defined(__cplusplus) && !defined(CINTERFACE)\n");
912 fprintf(header
, "interface %s : public %s\n", iface
->name
, iface
->ref
->name
);
913 fprintf(header
, "{\n");
917 fprintf(header
, "interface %s\n", iface
->name
);
918 fprintf(header
, "{\n");
919 fprintf(header
, " BEGIN_INTERFACE\n");
920 fprintf(header
, "\n");
922 /* dispinterfaces don't have real functions, so don't write C++ functions for
927 write_cpp_method_def(header
, iface
);
931 fprintf(header
, " END_INTERFACE\n");
932 fprintf(header
, "};\n");
933 fprintf(header
, "#else\n");
935 fprintf(header
, "typedef struct %sVtbl {\n", iface
->name
);
937 fprintf(header
, " BEGIN_INTERFACE\n");
938 fprintf(header
, "\n");
940 write_c_disp_method_def(header
, iface
);
942 write_c_method_def(header
, iface
);
944 fprintf(header
, " END_INTERFACE\n");
945 fprintf(header
, "} %sVtbl;\n", iface
->name
);
946 fprintf(header
, "interface %s {\n", iface
->name
);
947 fprintf(header
, " CONST_VTBL %sVtbl* lpVtbl;\n", iface
->name
);
948 fprintf(header
, "};\n");
949 fprintf(header
, "\n");
950 fprintf(header
, "#ifdef COBJMACROS\n");
951 /* dispinterfaces don't have real functions, so don't write macros for them,
952 * only for the interface this interface inherits from, i.e. IDispatch */
953 write_method_macro(header
, dispinterface
? iface
->ref
: iface
, iface
->name
);
954 fprintf(header
, "#endif\n");
955 fprintf(header
, "\n");
956 fprintf(header
, "#endif\n");
957 fprintf(header
, "\n");
958 /* dispinterfaces don't have real functions, so don't write prototypes for
962 write_method_proto(header
, iface
);
963 write_locals(header
, iface
, FALSE
);
964 fprintf(header
, "\n");
966 fprintf(header
,"#endif /* __%s_%sINTERFACE_DEFINED__ */\n\n", iface
->name
, dispinterface
? "DISP" : "");
969 static void write_rpc_interface_start(FILE *header
, const type_t
*iface
)
971 unsigned int ver
= get_attrv(iface
->attrs
, ATTR_VERSION
);
972 const char *var
= get_attrp(iface
->attrs
, ATTR_IMPLICIT_HANDLE
);
973 static int allocate_written
= 0;
975 if (!allocate_written
)
977 allocate_written
= 1;
978 fprintf(header
, "void * __RPC_USER MIDL_user_allocate(size_t);\n");
979 fprintf(header
, "void __RPC_USER MIDL_user_free(void *);\n\n");
982 fprintf(header
, "/*****************************************************************************\n");
983 fprintf(header
, " * %s interface (v%d.%d)\n", iface
->name
, MAJORVERSION(ver
), MINORVERSION(ver
));
984 fprintf(header
, " */\n");
985 fprintf(header
,"#ifndef __%s_INTERFACE_DEFINED__\n", iface
->name
);
986 fprintf(header
,"#define __%s_INTERFACE_DEFINED__\n\n", iface
->name
);
987 if (var
) fprintf(header
, "extern handle_t %s;\n", var
);
990 fprintf(header
, "extern RPC_IF_HANDLE %s%s_ClientIfHandle;\n", prefix_client
, iface
->name
);
991 fprintf(header
, "extern RPC_IF_HANDLE %s%s_ServerIfHandle;\n", prefix_server
, iface
->name
);
995 fprintf(header
, "extern RPC_IF_HANDLE %s%s_v%d_%d_c_ifspec;\n",
996 prefix_client
, iface
->name
, MAJORVERSION(ver
), MINORVERSION(ver
));
997 fprintf(header
, "extern RPC_IF_HANDLE %s%s_v%d_%d_s_ifspec;\n",
998 prefix_server
, iface
->name
, MAJORVERSION(ver
), MINORVERSION(ver
));
1002 static void write_rpc_interface_end(FILE *header
, const type_t
*iface
)
1004 fprintf(header
,"\n#endif /* __%s_INTERFACE_DEFINED__ */\n\n", iface
->name
);
1007 static void write_coclass(FILE *header
, type_t
*cocl
)
1009 fprintf(header
, "/*****************************************************************************\n");
1010 fprintf(header
, " * %s coclass\n", cocl
->name
);
1011 fprintf(header
, " */\n\n");
1012 write_coclass_guid(header
, cocl
);
1013 fprintf(header
, "\n");
1016 static void write_coclass_forward(FILE *header
, type_t
*cocl
)
1018 fprintf(header
, "#ifndef __%s_FWD_DEFINED__\n", cocl
->name
);
1019 fprintf(header
, "#define __%s_FWD_DEFINED__\n", cocl
->name
);
1020 fprintf(header
, "typedef struct %s %s;\n", cocl
->name
, cocl
->name
);
1021 fprintf(header
, "#endif /* defined __%s_FWD_DEFINED__ */\n\n", cocl
->name
);
1024 static void write_import(FILE *header
, const char *fname
)
1028 hname
= dup_basename(fname
, ".idl");
1029 p
= hname
+ strlen(hname
) - 2;
1030 if (p
<= hname
|| strcmp( p
, ".h" )) strcat(hname
, ".h");
1032 fprintf(header
, "#include <%s>\n", hname
);
1036 static void write_imports(FILE *header
, const statement_list_t
*stmts
)
1038 const statement_t
*stmt
;
1039 if (stmts
) LIST_FOR_EACH_ENTRY( stmt
, stmts
, const statement_t
, entry
)
1044 if (stmt
->u
.type
->type
== RPC_FC_IP
)
1045 write_imports(header
, stmt
->u
.type
->stmts
);
1048 case STMT_IMPORTLIB
:
1049 /* not included in header */
1052 write_import(header
, stmt
->u
.str
);
1057 case STMT_DECLARATION
:
1058 /* not processed here */
1061 write_imports(header
, stmt
->u
.lib
->stmts
);
1067 static void write_forward_decls(FILE *header
, const statement_list_t
*stmts
)
1069 const statement_t
*stmt
;
1070 if (stmts
) LIST_FOR_EACH_ENTRY( stmt
, stmts
, const statement_t
, entry
)
1075 if (stmt
->u
.type
->type
== RPC_FC_IP
)
1077 if (is_object(stmt
->u
.type
->attrs
) || is_attr(stmt
->u
.type
->attrs
, ATTR_DISPINTERFACE
))
1078 write_forward(header
, stmt
->u
.type
);
1080 else if (stmt
->u
.type
->type
== RPC_FC_COCLASS
)
1081 write_coclass_forward(header
, stmt
->u
.type
);
1084 case STMT_IMPORTLIB
:
1085 /* not included in header */
1091 case STMT_DECLARATION
:
1092 /* not processed here */
1095 write_forward_decls(header
, stmt
->u
.lib
->stmts
);
1101 static void write_header_stmts(FILE *header
, const statement_list_t
*stmts
, const type_t
*iface
, int ignore_funcs
)
1103 const statement_t
*stmt
;
1104 if (stmts
) LIST_FOR_EACH_ENTRY( stmt
, stmts
, const statement_t
, entry
)
1109 if (stmt
->u
.type
->type
== RPC_FC_IP
)
1111 type_t
*iface
= stmt
->u
.type
;
1112 if (is_attr(stmt
->u
.type
->attrs
, ATTR_DISPINTERFACE
) || is_object(stmt
->u
.type
->attrs
))
1114 write_com_interface_start(header
, iface
);
1115 write_header_stmts(header
, iface
->stmts
, stmt
->u
.type
, TRUE
);
1116 write_com_interface_end(header
, iface
);
1120 write_rpc_interface_start(header
, iface
);
1121 write_header_stmts(header
, iface
->stmts
, iface
, FALSE
);
1122 write_rpc_interface_end(header
, iface
);
1125 else if (stmt
->u
.type
->type
== RPC_FC_COCLASS
)
1126 write_coclass(header
, stmt
->u
.type
);
1129 write_type_def_or_decl(header
, stmt
->u
.type
, FALSE
, NULL
);
1130 fprintf(header
, ";\n\n");
1134 /* FIXME: shouldn't write out forward declarations for undefined
1135 * interfaces but a number of our IDL files depend on this */
1136 if (stmt
->u
.type
->type
== RPC_FC_IP
&& !stmt
->u
.type
->written
)
1137 write_forward(header
, stmt
->u
.type
);
1139 case STMT_IMPORTLIB
:
1141 /* not included in header */
1144 /* not processed here */
1148 const type_list_t
*type_entry
= stmt
->u
.type_list
;
1149 for (; type_entry
; type_entry
= type_entry
->next
)
1150 write_typedef(header
, type_entry
->type
);
1154 write_library(header
, stmt
->u
.lib
);
1155 write_header_stmts(header
, stmt
->u
.lib
->stmts
, NULL
, FALSE
);
1158 fprintf(header
, "%s\n", stmt
->u
.str
);
1160 case STMT_DECLARATION
:
1161 if (iface
&& stmt
->u
.var
->type
->type
== RPC_FC_FUNCTION
)
1165 int prefixes_differ
= strcmp(prefix_client
, prefix_server
);
1167 if (prefixes_differ
)
1169 fprintf(header
, "/* client prototype */\n");
1170 write_function_proto(header
, iface
, stmt
->u
.var
, prefix_client
);
1171 fprintf(header
, "/* server prototype */\n");
1173 write_function_proto(header
, iface
, stmt
->u
.var
, prefix_server
);
1177 write_declaration(header
, stmt
->u
.var
);
1183 void write_header(const statement_list_t
*stmts
)
1187 if (!do_header
) return;
1189 if(!(header
= fopen(header_name
, "w"))) {
1190 error("Could not open %s for output\n", header_name
);
1193 fprintf(header
, "/*** Autogenerated by WIDL %s from %s - Do not edit ***/\n\n", PACKAGE_VERSION
, input_name
);
1194 fprintf(header
, "#include <rpc.h>\n" );
1195 fprintf(header
, "#include <rpcndr.h>\n\n" );
1197 fprintf(header
, "#ifndef __WIDL_%s\n", header_token
);
1198 fprintf(header
, "#define __WIDL_%s\n\n", header_token
);
1199 start_cplusplus_guard(header
);
1201 fprintf(header
, "/* Headers for imported files */\n\n");
1202 write_imports(header
, stmts
);
1203 fprintf(header
, "\n");
1205 /* FIXME: should be before imported file includes */
1206 fprintf(header
, "/* Forward declarations */\n\n");
1207 write_forward_decls(header
, stmts
);
1208 fprintf(header
, "\n");
1210 write_header_stmts(header
, stmts
, NULL
, FALSE
);
1212 fprintf(header
, "/* Begin additional prototypes for all interfaces */\n");
1213 fprintf(header
, "\n");
1214 write_user_types(header
);
1215 write_generic_handle_routines(header
);
1216 write_context_handle_rundowns(header
);
1217 fprintf(header
, "\n");
1218 fprintf(header
, "/* End additional prototypes */\n");
1219 fprintf(header
, "\n");
1221 end_cplusplus_guard(header
);
1222 fprintf(header
, "#endif /* __WIDL_%s */\n", header_token
);