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 static int indentation
= 0;
40 static int is_object_interface
= 0;
41 user_type_list_t user_type_list
= LIST_INIT(user_type_list
);
42 context_handle_list_t context_handle_list
= LIST_INIT(context_handle_list
);
43 generic_handle_list_t generic_handle_list
= LIST_INIT(generic_handle_list
);
45 static void write_type_def_or_decl(FILE *f
, type_t
*t
, int field
, const char *name
);
47 static void indent(FILE *h
, int delta
)
50 if (delta
< 0) indentation
+= delta
;
51 for (c
=0; c
<indentation
; c
++) fprintf(h
, " ");
52 if (delta
> 0) indentation
+= delta
;
55 int is_ptrchain_attr(const var_t
*var
, enum attr_type t
)
57 if (is_attr(var
->attrs
, t
))
61 type_t
*type
= var
->type
;
64 if (is_attr(type
->attrs
, t
))
66 else if (type_is_alias(type
))
67 type
= type_alias_get_aliasee(type
);
68 else if (is_ptr(type
))
69 type
= type_pointer_get_ref(type
);
75 int is_aliaschain_attr(const type_t
*type
, enum attr_type attr
)
77 const type_t
*t
= type
;
80 if (is_attr(t
->attrs
, attr
))
82 else if (type_is_alias(t
))
83 t
= type_alias_get_aliasee(t
);
88 int is_attr(const attr_list_t
*list
, enum attr_type t
)
91 if (list
) LIST_FOR_EACH_ENTRY( attr
, list
, const attr_t
, entry
)
92 if (attr
->type
== t
) return 1;
96 void *get_attrp(const attr_list_t
*list
, enum attr_type t
)
99 if (list
) LIST_FOR_EACH_ENTRY( attr
, list
, const attr_t
, entry
)
100 if (attr
->type
== t
) return attr
->u
.pval
;
104 unsigned int get_attrv(const attr_list_t
*list
, enum attr_type t
)
107 if (list
) LIST_FOR_EACH_ENTRY( attr
, list
, const attr_t
, entry
)
108 if (attr
->type
== t
) return attr
->u
.ival
;
112 int is_void(const type_t
*t
)
114 return type_get_type(t
) == TYPE_VOID
;
117 int is_conformant_array(const type_t
*t
)
119 return is_array(t
) && type_array_has_conformance(t
);
122 void write_guid(FILE *f
, const char *guid_prefix
, const char *name
, const UUID
*uuid
)
125 fprintf(f
, "DEFINE_GUID(%s_%s, 0x%08x, 0x%04x, 0x%04x, 0x%02x,0x%02x, 0x%02x,"
126 "0x%02x,0x%02x,0x%02x,0x%02x,0x%02x);\n",
127 guid_prefix
, name
, uuid
->Data1
, uuid
->Data2
, uuid
->Data3
, uuid
->Data4
[0],
128 uuid
->Data4
[1], uuid
->Data4
[2], uuid
->Data4
[3], uuid
->Data4
[4], uuid
->Data4
[5],
129 uuid
->Data4
[6], uuid
->Data4
[7]);
132 static void write_uuid_decl(FILE *f
, const char *name
, const UUID
*uuid
)
134 fprintf(f
, "#ifdef __CRT_UUID_DECL\n");
135 fprintf(f
, "__CRT_UUID_DECL(%s, 0x%08x, 0x%04x, 0x%04x, 0x%02x,0x%02x, 0x%02x,"
136 "0x%02x,0x%02x,0x%02x,0x%02x,0x%02x)\n",
137 name
, uuid
->Data1
, uuid
->Data2
, uuid
->Data3
, uuid
->Data4
[0], uuid
->Data4
[1],
138 uuid
->Data4
[2], uuid
->Data4
[3], uuid
->Data4
[4], uuid
->Data4
[5], uuid
->Data4
[6],
140 fprintf(f
, "#endif\n");
143 static const char *uuid_string(const UUID
*uuid
)
147 sprintf(buf
, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
148 uuid
->Data1
, uuid
->Data2
, uuid
->Data3
, uuid
->Data4
[0], uuid
->Data4
[1], uuid
->Data4
[2],
149 uuid
->Data4
[3], uuid
->Data4
[4], uuid
->Data4
[5], uuid
->Data4
[6], uuid
->Data4
[7]);
154 const char *get_name(const var_t
*v
)
156 static char buffer
[256];
158 if (is_attr( v
->attrs
, ATTR_PROPGET
))
159 strcpy( buffer
, "get_" );
160 else if (is_attr( v
->attrs
, ATTR_PROPPUT
))
161 strcpy( buffer
, "put_" );
162 else if (is_attr( v
->attrs
, ATTR_PROPPUTREF
))
163 strcpy( buffer
, "putref_" );
166 strcat( buffer
, v
->name
);
170 static void write_fields(FILE *h
, var_list_t
*fields
)
172 unsigned nameless_struct_cnt
= 0, nameless_struct_i
= 0, nameless_union_cnt
= 0, nameless_union_i
= 0;
179 LIST_FOR_EACH_ENTRY( v
, fields
, var_t
, entry
) {
180 if (!v
|| !v
->type
) continue;
182 switch(type_get_type_detect_alias(v
->type
)) {
184 case TYPE_ENCAPSULATED_UNION
:
185 nameless_struct_cnt
++;
188 nameless_union_cnt
++;
195 LIST_FOR_EACH_ENTRY( v
, fields
, var_t
, entry
) {
196 if (!v
|| !v
->type
) continue;
201 switch(type_get_type_detect_alias(v
->type
)) {
203 case TYPE_ENCAPSULATED_UNION
:
205 fprintf(h
, "__C89_NAMELESS ");
206 if(nameless_struct_cnt
== 1) {
207 name
= "__C89_NAMELESSSTRUCTNAME";
208 }else if(nameless_struct_i
< 5 /* # of supporting macros */) {
209 sprintf(buf
, "__C89_NAMELESSSTRUCTNAME%d", ++nameless_struct_i
);
216 fprintf(h
, "__C89_NAMELESS ");
217 if(nameless_union_cnt
== 1) {
218 name
= "__C89_NAMELESSUNIONNAME";
219 }else if(nameless_union_i
< 8 /* # of supporting macros */ ) {
220 sprintf(buf
, "__C89_NAMELESSUNIONNAME%d", ++nameless_union_i
);
228 write_type_def_or_decl(h
, v
->type
, TRUE
, name
);
233 static void write_enums(FILE *h
, var_list_t
*enums
)
237 LIST_FOR_EACH_ENTRY( v
, enums
, var_t
, entry
)
241 fprintf(h
, "%s", get_name(v
));
244 write_expr(h
, v
->eval
, 0, 1, NULL
, NULL
, "");
247 if (list_next( enums
, &v
->entry
)) fprintf(h
, ",\n");
252 int needs_space_after(type_t
*t
)
254 return (type_is_alias(t
) ||
255 (!is_ptr(t
) && (!is_array(t
) || !type_array_is_decl_as_ptr(t
) || t
->name
)));
258 void write_type_left(FILE *h
, type_t
*t
, int declonly
)
262 if (is_attr(t
->attrs
, ATTR_CONST
) &&
263 (type_is_alias(t
) || !is_ptr(t
)))
264 fprintf(h
, "const ");
266 if (type_is_alias(t
)) fprintf(h
, "%s", t
->name
);
268 switch (type_get_type_detect_alias(t
)) {
270 if (!declonly
&& t
->defined
&& !t
->written
) {
271 if (t
->name
) fprintf(h
, "enum %s {\n", t
->name
);
272 else fprintf(h
, "enum {\n");
275 write_enums(h
, type_enum_get_values(t
));
279 else fprintf(h
, "enum %s", t
->name
? t
->name
: "");
282 case TYPE_ENCAPSULATED_UNION
:
283 if (!declonly
&& t
->defined
&& !t
->written
) {
284 if (t
->name
) fprintf(h
, "struct %s {\n", t
->name
);
285 else fprintf(h
, "struct {\n");
288 if (type_get_type(t
) != TYPE_STRUCT
)
289 write_fields(h
, type_encapsulated_union_get_fields(t
));
291 write_fields(h
, type_struct_get_fields(t
));
295 else fprintf(h
, "struct %s", t
->name
? t
->name
: "");
298 if (!declonly
&& t
->defined
&& !t
->written
) {
299 if (t
->name
) fprintf(h
, "union %s {\n", t
->name
);
300 else fprintf(h
, "union {\n");
303 write_fields(h
, type_union_get_cases(t
));
307 else fprintf(h
, "union %s", t
->name
? t
->name
: "");
310 write_type_left(h
, type_pointer_get_ref(t
), declonly
);
311 fprintf(h
, "%s*", needs_space_after(type_pointer_get_ref(t
)) ? " " : "");
312 if (is_attr(t
->attrs
, ATTR_CONST
)) fprintf(h
, "const ");
315 if (t
->name
&& type_array_is_decl_as_ptr(t
))
316 fprintf(h
, "%s", t
->name
);
319 write_type_left(h
, type_array_get_element(t
), declonly
);
320 if (type_array_is_decl_as_ptr(t
))
321 fprintf(h
, "%s*", needs_space_after(type_array_get_element(t
)) ? " " : "");
325 if (type_basic_get_type(t
) != TYPE_BASIC_INT32
&&
326 type_basic_get_type(t
) != TYPE_BASIC_INT64
&&
327 type_basic_get_type(t
) != TYPE_BASIC_HYPER
)
329 if (type_basic_get_sign(t
) < 0) fprintf(h
, "signed ");
330 else if (type_basic_get_sign(t
) > 0) fprintf(h
, "unsigned ");
332 switch (type_basic_get_type(t
))
334 case TYPE_BASIC_INT8
: fprintf(h
, "small"); break;
335 case TYPE_BASIC_INT16
: fprintf(h
, "short"); break;
336 case TYPE_BASIC_INT
: fprintf(h
, "int"); break;
337 case TYPE_BASIC_INT3264
: fprintf(h
, "__int3264"); break;
338 case TYPE_BASIC_BYTE
: fprintf(h
, "byte"); break;
339 case TYPE_BASIC_CHAR
: fprintf(h
, "char"); break;
340 case TYPE_BASIC_WCHAR
: fprintf(h
, "wchar_t"); break;
341 case TYPE_BASIC_FLOAT
: fprintf(h
, "float"); break;
342 case TYPE_BASIC_DOUBLE
: fprintf(h
, "double"); break;
343 case TYPE_BASIC_ERROR_STATUS_T
: fprintf(h
, "error_status_t"); break;
344 case TYPE_BASIC_HANDLE
: fprintf(h
, "handle_t"); break;
345 case TYPE_BASIC_INT32
:
346 if (type_basic_get_sign(t
) > 0)
351 case TYPE_BASIC_INT64
:
352 if (type_basic_get_sign(t
) > 0)
353 fprintf(h
, "UINT64");
357 case TYPE_BASIC_HYPER
:
358 if (type_basic_get_sign(t
) > 0)
359 fprintf(h
, "MIDL_uhyper");
368 fprintf(h
, "%s", t
->name
);
374 write_type_left(h
, type_bitfield_get_field(t
), declonly
);
378 /* handled elsewhere */
385 void write_type_right(FILE *h
, type_t
*t
, int is_field
)
389 switch (type_get_type(t
))
392 if (!type_array_is_decl_as_ptr(t
))
394 if (is_conformant_array(t
))
396 fprintf(h
, "[%s]", is_field
? "1" : "");
397 t
= type_array_get_element(t
);
400 type_get_type(t
) == TYPE_ARRAY
&& !type_array_is_decl_as_ptr(t
);
401 t
= type_array_get_element(t
))
402 fprintf(h
, "[%u]", type_array_get_dim(t
));
406 fprintf(h
, " : %u", type_bitfield_get_bits(t
)->cval
);
412 case TYPE_ENCAPSULATED_UNION
:
424 static void write_type_v(FILE *h
, type_t
*t
, int is_field
, int declonly
, const char *name
)
432 for (pt
= t
; is_ptr(pt
); pt
= type_pointer_get_ref(pt
), ptr_level
++)
435 if (type_get_type_detect_alias(pt
) == TYPE_FUNCTION
) {
437 const char *callconv
= get_attrp(pt
->attrs
, ATTR_CALLCONV
);
438 if (!callconv
&& is_object_interface
) callconv
= "STDMETHODCALLTYPE";
439 if (is_attr(pt
->attrs
, ATTR_INLINE
)) fprintf(h
, "inline ");
440 write_type_left(h
, type_function_get_rettype(pt
), declonly
);
442 if (ptr_level
) fputc('(', h
);
443 if (callconv
) fprintf(h
, "%s ", callconv
);
444 for (i
= 0; i
< ptr_level
; i
++)
447 write_type_left(h
, t
, declonly
);
450 if (name
) fprintf(h
, "%s%s", !t
|| needs_space_after(t
) ? " " : "", name
);
453 if (type_get_type_detect_alias(pt
) == TYPE_FUNCTION
) {
454 const var_list_t
*args
= type_function_get_args(pt
);
456 if (ptr_level
) fputc(')', h
);
459 write_args(h
, args
, NULL
, 0, FALSE
);
464 write_type_right(h
, t
, is_field
);
468 static void write_type_def_or_decl(FILE *f
, type_t
*t
, int field
, const char *name
)
470 write_type_v(f
, t
, field
, FALSE
, name
);
473 void write_type_decl(FILE *f
, type_t
*t
, const char *name
)
475 write_type_v(f
, t
, FALSE
, TRUE
, name
);
478 void write_type_decl_left(FILE *f
, type_t
*t
)
480 write_type_left(f
, t
, TRUE
);
483 static int user_type_registered(const char *name
)
486 LIST_FOR_EACH_ENTRY(ut
, &user_type_list
, user_type_t
, entry
)
487 if (!strcmp(name
, ut
->name
))
492 static int context_handle_registered(const char *name
)
494 context_handle_t
*ch
;
495 LIST_FOR_EACH_ENTRY(ch
, &context_handle_list
, context_handle_t
, entry
)
496 if (!strcmp(name
, ch
->name
))
501 static int generic_handle_registered(const char *name
)
503 generic_handle_t
*gh
;
504 LIST_FOR_EACH_ENTRY(gh
, &generic_handle_list
, generic_handle_t
, entry
)
505 if (!strcmp(name
, gh
->name
))
510 unsigned int get_context_handle_offset( const type_t
*type
)
512 context_handle_t
*ch
;
513 unsigned int index
= 0;
515 while (!is_attr( type
->attrs
, ATTR_CONTEXTHANDLE
))
517 if (type_is_alias( type
)) type
= type_alias_get_aliasee( type
);
518 else if (is_ptr( type
)) type
= type_pointer_get_ref( type
);
519 else error( "internal error: %s is not a context handle\n", type
->name
);
521 LIST_FOR_EACH_ENTRY( ch
, &context_handle_list
, context_handle_t
, entry
)
523 if (!strcmp( type
->name
, ch
->name
)) return index
;
526 error( "internal error: %s is not registered as a context handle\n", type
->name
);
530 unsigned int get_generic_handle_offset( const type_t
*type
)
532 generic_handle_t
*gh
;
533 unsigned int index
= 0;
535 while (!is_attr( type
->attrs
, ATTR_HANDLE
))
537 if (type_is_alias( type
)) type
= type_alias_get_aliasee( type
);
538 else if (is_ptr( type
)) type
= type_pointer_get_ref( type
);
539 else error( "internal error: %s is not a generic handle\n", type
->name
);
541 LIST_FOR_EACH_ENTRY( gh
, &generic_handle_list
, generic_handle_t
, entry
)
543 if (!strcmp( type
->name
, gh
->name
)) return index
;
546 error( "internal error: %s is not registered as a generic handle\n", type
->name
);
550 /* check for types which require additional prototypes to be generated in the
552 void check_for_additional_prototype_types(const var_list_t
*list
)
557 LIST_FOR_EACH_ENTRY( v
, list
, const var_t
, entry
)
559 type_t
*type
= v
->type
;
562 const char *name
= type
->name
;
563 if (type
->user_types_registered
) break;
564 type
->user_types_registered
= 1;
565 if (is_attr(type
->attrs
, ATTR_CONTEXTHANDLE
)) {
566 if (!context_handle_registered(name
))
568 context_handle_t
*ch
= xmalloc(sizeof(*ch
));
569 ch
->name
= xstrdup(name
);
570 list_add_tail(&context_handle_list
, &ch
->entry
);
572 /* don't carry on parsing fields within this type */
575 if ((type_get_type(type
) != TYPE_BASIC
||
576 type_basic_get_type(type
) != TYPE_BASIC_HANDLE
) &&
577 is_attr(type
->attrs
, ATTR_HANDLE
)) {
578 if (!generic_handle_registered(name
))
580 generic_handle_t
*gh
= xmalloc(sizeof(*gh
));
581 gh
->name
= xstrdup(name
);
582 list_add_tail(&generic_handle_list
, &gh
->entry
);
584 /* don't carry on parsing fields within this type */
587 if (is_attr(type
->attrs
, ATTR_WIREMARSHAL
)) {
588 if (!user_type_registered(name
))
590 user_type_t
*ut
= xmalloc(sizeof *ut
);
591 ut
->name
= xstrdup(name
);
592 list_add_tail(&user_type_list
, &ut
->entry
);
594 /* don't carry on parsing fields within this type as we are already
595 * using a wire marshaled type */
598 else if (type_is_complete(type
))
601 switch (type_get_type_detect_alias(type
))
604 vars
= type_enum_get_values(type
);
607 vars
= type_struct_get_fields(type
);
610 vars
= type_union_get_cases(type
);
616 check_for_additional_prototype_types(vars
);
619 if (type_is_alias(type
))
620 type
= type_alias_get_aliasee(type
);
621 else if (is_ptr(type
))
622 type
= type_pointer_get_ref(type
);
623 else if (is_array(type
))
624 type
= type_array_get_element(type
);
631 static void write_user_types(FILE *header
)
634 LIST_FOR_EACH_ENTRY(ut
, &user_type_list
, user_type_t
, entry
)
636 const char *name
= ut
->name
;
637 fprintf(header
, "ULONG __RPC_USER %s_UserSize (ULONG *, ULONG, %s *);\n", name
, name
);
638 fprintf(header
, "unsigned char * __RPC_USER %s_UserMarshal (ULONG *, unsigned char *, %s *);\n", name
, name
);
639 fprintf(header
, "unsigned char * __RPC_USER %s_UserUnmarshal(ULONG *, unsigned char *, %s *);\n", name
, name
);
640 fprintf(header
, "void __RPC_USER %s_UserFree (ULONG *, %s *);\n", name
, name
);
644 static void write_context_handle_rundowns(FILE *header
)
646 context_handle_t
*ch
;
647 LIST_FOR_EACH_ENTRY(ch
, &context_handle_list
, context_handle_t
, entry
)
649 const char *name
= ch
->name
;
650 fprintf(header
, "void __RPC_USER %s_rundown(%s);\n", name
, name
);
654 static void write_generic_handle_routines(FILE *header
)
656 generic_handle_t
*gh
;
657 LIST_FOR_EACH_ENTRY(gh
, &generic_handle_list
, generic_handle_t
, entry
)
659 const char *name
= gh
->name
;
660 fprintf(header
, "handle_t __RPC_USER %s_bind(%s);\n", name
, name
);
661 fprintf(header
, "void __RPC_USER %s_unbind(%s, handle_t);\n", name
, name
);
665 static void write_typedef(FILE *header
, type_t
*type
)
667 fprintf(header
, "typedef ");
668 write_type_def_or_decl(header
, type_alias_get_aliasee(type
), FALSE
, type
->name
);
669 fprintf(header
, ";\n");
672 int is_const_decl(const var_t
*var
)
675 /* strangely, MIDL accepts a const attribute on any pointer in the
676 * declaration to mean that data isn't being instantiated. this appears
677 * to be a bug, but there is no benefit to being incompatible with MIDL,
678 * so we'll do the same thing */
679 for (t
= var
->type
; ; )
681 if (is_attr(t
->attrs
, ATTR_CONST
))
684 t
= type_pointer_get_ref(t
);
690 static void write_declaration(FILE *header
, const var_t
*v
)
692 if (is_const_decl(v
) && v
->eval
)
694 fprintf(header
, "#define %s (", v
->name
);
695 write_expr(header
, v
->eval
, 0, 1, NULL
, NULL
, "");
696 fprintf(header
, ")\n\n");
703 case STG_REGISTER
: /* ignored */
706 fprintf(header
, "static ");
709 fprintf(header
, "extern ");
712 write_type_def_or_decl(header
, v
->type
, FALSE
, v
->name
);
713 fprintf(header
, ";\n\n");
717 static void write_library(FILE *header
, const typelib_t
*typelib
)
719 const UUID
*uuid
= get_attrp(typelib
->attrs
, ATTR_UUID
);
720 fprintf(header
, "\n");
721 write_guid(header
, "LIBID", typelib
->name
, uuid
);
722 fprintf(header
, "\n");
726 const type_t
* get_explicit_generic_handle_type(const var_t
* var
)
730 is_ptr(t
) || type_is_alias(t
);
731 t
= type_is_alias(t
) ? type_alias_get_aliasee(t
) : type_pointer_get_ref(t
))
732 if ((type_get_type_detect_alias(t
) != TYPE_BASIC
|| type_basic_get_type(t
) != TYPE_BASIC_HANDLE
) &&
733 is_attr(t
->attrs
, ATTR_HANDLE
))
738 const var_t
*get_func_handle_var( const type_t
*iface
, const var_t
*func
,
739 unsigned char *explicit_fc
, unsigned char *implicit_fc
)
742 const var_list_t
*args
= type_get_function_args( func
->type
);
744 *explicit_fc
= *implicit_fc
= 0;
745 if (args
) LIST_FOR_EACH_ENTRY( var
, args
, const var_t
, entry
)
747 if (!is_attr( var
->attrs
, ATTR_IN
) && is_attr( var
->attrs
, ATTR_OUT
)) continue;
748 if (type_get_type( var
->type
) == TYPE_BASIC
&& type_basic_get_type( var
->type
) == TYPE_BASIC_HANDLE
)
750 *explicit_fc
= RPC_FC_BIND_PRIMITIVE
;
753 if (get_explicit_generic_handle_type( var
))
755 *explicit_fc
= RPC_FC_BIND_GENERIC
;
758 if (is_context_handle( var
->type
))
760 *explicit_fc
= RPC_FC_BIND_CONTEXT
;
765 if ((var
= get_attrp( iface
->attrs
, ATTR_IMPLICIT_HANDLE
)))
767 if (type_get_type( var
->type
) == TYPE_BASIC
&&
768 type_basic_get_type( var
->type
) == TYPE_BASIC_HANDLE
)
769 *implicit_fc
= RPC_FC_BIND_PRIMITIVE
;
771 *implicit_fc
= RPC_FC_BIND_GENERIC
;
775 *implicit_fc
= RPC_FC_AUTO_HANDLE
;
779 int has_out_arg_or_return(const var_t
*func
)
783 if (!is_void(type_function_get_rettype(func
->type
)))
786 if (!type_get_function_args(func
->type
))
789 LIST_FOR_EACH_ENTRY( var
, type_get_function_args(func
->type
), const var_t
, entry
)
790 if (is_attr(var
->attrs
, ATTR_OUT
))
797 /********** INTERFACES **********/
799 int is_object(const type_t
*iface
)
802 if (type_is_defined(iface
) && type_iface_get_inherit(iface
))
804 if (iface
->attrs
) LIST_FOR_EACH_ENTRY( attr
, iface
->attrs
, const attr_t
, entry
)
805 if (attr
->type
== ATTR_OBJECT
|| attr
->type
== ATTR_ODL
) return 1;
809 int is_local(const attr_list_t
*a
)
811 return is_attr(a
, ATTR_LOCAL
);
814 const var_t
*is_callas(const attr_list_t
*a
)
816 return get_attrp(a
, ATTR_CALLAS
);
819 static void write_method_macro(FILE *header
, const type_t
*iface
, const char *name
)
821 const statement_t
*stmt
;
824 if (type_iface_get_inherit(iface
))
825 write_method_macro(header
, type_iface_get_inherit(iface
), name
);
827 STATEMENTS_FOR_EACH_FUNC(stmt
, type_iface_get_stmts(iface
))
829 const var_t
*func
= stmt
->u
.var
;
833 fprintf(header
, "/*** %s methods ***/\n", iface
->name
);
837 if (!is_callas(func
->attrs
)) {
840 fprintf(header
, "#define %s_%s(This", name
, get_name(func
));
841 if (type_get_function_args(func
->type
))
842 LIST_FOR_EACH_ENTRY( arg
, type_get_function_args(func
->type
), const var_t
, entry
)
843 fprintf(header
, ",%s", arg
->name
);
844 fprintf(header
, ") ");
846 fprintf(header
, "(This)->lpVtbl->%s(This", get_name(func
));
847 if (type_get_function_args(func
->type
))
848 LIST_FOR_EACH_ENTRY( arg
, type_get_function_args(func
->type
), const var_t
, entry
)
849 fprintf(header
, ",%s", arg
->name
);
850 fprintf(header
, ")\n");
855 void write_args(FILE *h
, const var_list_t
*args
, const char *name
, int method
, int do_indent
)
866 fprintf(h
, "%s* This", name
);
869 if (args
) LIST_FOR_EACH_ENTRY( arg
, args
, const var_t
, entry
) {
876 else fprintf(h
, ",");
878 write_type_decl(h
, arg
->type
, arg
->name
);
880 const expr_t
*expr
= get_attrp(arg
->attrs
, ATTR_DEFAULTVALUE
);
883 write_expr( h
, expr
, 0, 1, NULL
, NULL
, "" );
888 if (do_indent
) indentation
--;
891 static void write_cpp_method_def(FILE *header
, const type_t
*iface
)
893 const statement_t
*stmt
;
895 STATEMENTS_FOR_EACH_FUNC(stmt
, type_iface_get_stmts(iface
))
897 const var_t
*func
= stmt
->u
.var
;
898 if (!is_callas(func
->attrs
)) {
899 const char *callconv
= get_attrp(func
->type
->attrs
, ATTR_CALLCONV
);
900 if (!callconv
) callconv
= "STDMETHODCALLTYPE";
902 fprintf(header
, "virtual ");
903 write_type_decl_left(header
, type_function_get_rettype(func
->type
));
904 fprintf(header
, " %s %s(\n", callconv
, get_name(func
));
905 write_args(header
, type_get_function_args(func
->type
), iface
->name
, 2, TRUE
);
906 fprintf(header
, ") = 0;\n");
907 fprintf(header
, "\n");
912 static void write_inline_wrappers(FILE *header
, const type_t
*iface
, const char *name
)
914 const statement_t
*stmt
;
917 if (type_iface_get_inherit(iface
))
918 write_inline_wrappers(header
, type_iface_get_inherit(iface
), name
);
920 STATEMENTS_FOR_EACH_FUNC(stmt
, type_iface_get_stmts(iface
))
922 const var_t
*func
= stmt
->u
.var
;
926 fprintf(header
, "/*** %s methods ***/\n", iface
->name
);
930 if (!is_callas(func
->attrs
)) {
933 fprintf(header
, "static FORCEINLINE ");
934 write_type_decl_left(header
, type_function_get_rettype(func
->type
));
935 fprintf(header
, " %s_%s(", name
, get_name(func
));
936 write_args(header
, type_get_function_args(func
->type
), name
, 1, FALSE
);
937 fprintf(header
, ") {\n");
938 fprintf(header
, " %s", is_void(type_function_get_rettype(func
->type
)) ? "" : "return ");
939 fprintf(header
, "This->lpVtbl->%s(This", get_name(func
));
940 if (type_get_function_args(func
->type
))
941 LIST_FOR_EACH_ENTRY( arg
, type_get_function_args(func
->type
), const var_t
, entry
)
942 fprintf(header
, ",%s", arg
->name
);
943 fprintf(header
, ");\n");
944 fprintf(header
, "}\n");
949 static void do_write_c_method_def(FILE *header
, const type_t
*iface
, const char *name
)
951 const statement_t
*stmt
;
954 if (type_iface_get_inherit(iface
))
955 do_write_c_method_def(header
, type_iface_get_inherit(iface
), name
);
957 STATEMENTS_FOR_EACH_FUNC(stmt
, type_iface_get_stmts(iface
))
959 const var_t
*func
= stmt
->u
.var
;
962 fprintf(header
, "/*** %s methods ***/\n", iface
->name
);
965 if (!is_callas(func
->attrs
)) {
966 const char *callconv
= get_attrp(func
->type
->attrs
, ATTR_CALLCONV
);
967 if (!callconv
) callconv
= "STDMETHODCALLTYPE";
969 write_type_decl_left(header
, type_function_get_rettype(func
->type
));
970 fprintf(header
, " (%s *%s)(\n", callconv
, get_name(func
));
971 write_args(header
, type_get_function_args(func
->type
), name
, 1, TRUE
);
972 fprintf(header
, ");\n");
973 fprintf(header
, "\n");
978 static void write_c_method_def(FILE *header
, const type_t
*iface
)
980 do_write_c_method_def(header
, iface
, iface
->name
);
983 static void write_c_disp_method_def(FILE *header
, const type_t
*iface
)
985 do_write_c_method_def(header
, type_iface_get_inherit(iface
), iface
->name
);
988 static void write_method_proto(FILE *header
, const type_t
*iface
)
990 const statement_t
*stmt
;
992 STATEMENTS_FOR_EACH_FUNC(stmt
, type_iface_get_stmts(iface
))
994 const var_t
*func
= stmt
->u
.var
;
996 if (!is_local(func
->attrs
)) {
997 const char *callconv
= get_attrp(func
->type
->attrs
, ATTR_CALLCONV
);
998 if (!callconv
) callconv
= "STDMETHODCALLTYPE";
999 /* proxy prototype */
1000 write_type_decl_left(header
, type_function_get_rettype(func
->type
));
1001 fprintf(header
, " %s %s_%s_Proxy(\n", callconv
, iface
->name
, get_name(func
));
1002 write_args(header
, type_get_function_args(func
->type
), iface
->name
, 1, TRUE
);
1003 fprintf(header
, ");\n");
1004 /* stub prototype */
1005 fprintf(header
, "void __RPC_STUB %s_%s_Stub(\n", iface
->name
, get_name(func
));
1006 fprintf(header
, " IRpcStubBuffer* This,\n");
1007 fprintf(header
, " IRpcChannelBuffer* pRpcChannelBuffer,\n");
1008 fprintf(header
, " PRPC_MESSAGE pRpcMessage,\n");
1009 fprintf(header
, " DWORD* pdwStubPhase);\n");
1014 static void write_locals(FILE *fp
, const type_t
*iface
, int body
)
1016 static const char comment
[]
1017 = "/* WIDL-generated stub. You must provide an implementation for this. */";
1018 const statement_t
*stmt
;
1020 if (!is_object(iface
))
1023 STATEMENTS_FOR_EACH_FUNC(stmt
, type_iface_get_stmts(iface
)) {
1024 const var_t
*func
= stmt
->u
.var
;
1025 const var_t
*cas
= is_callas(func
->attrs
);
1028 const statement_t
*stmt2
= NULL
;
1029 STATEMENTS_FOR_EACH_FUNC(stmt2
, type_iface_get_stmts(iface
))
1030 if (!strcmp(stmt2
->u
.var
->name
, cas
->name
))
1032 if (&stmt2
->entry
!= type_iface_get_stmts(iface
)) {
1033 const var_t
*m
= stmt2
->u
.var
;
1034 /* proxy prototype - use local prototype */
1035 write_type_decl_left(fp
, type_function_get_rettype(m
->type
));
1036 fprintf(fp
, " CALLBACK %s_%s_Proxy(\n", iface
->name
, get_name(m
));
1037 write_args(fp
, type_get_function_args(m
->type
), iface
->name
, 1, TRUE
);
1040 type_t
*rt
= type_function_get_rettype(m
->type
);
1041 fprintf(fp
, "\n{\n");
1042 fprintf(fp
, " %s\n", comment
);
1043 if (rt
->name
&& strcmp(rt
->name
, "HRESULT") == 0)
1044 fprintf(fp
, " return E_NOTIMPL;\n");
1045 else if (type_get_type(rt
) != TYPE_VOID
) {
1047 write_type_decl(fp
, rt
, "rv");
1049 fprintf(fp
, " memset(&rv, 0, sizeof rv);\n");
1050 fprintf(fp
, " return rv;\n");
1052 fprintf(fp
, "}\n\n");
1056 /* stub prototype - use remotable prototype */
1057 write_type_decl_left(fp
, type_function_get_rettype(func
->type
));
1058 fprintf(fp
, " __RPC_STUB %s_%s_Stub(\n", iface
->name
, get_name(m
));
1059 write_args(fp
, type_get_function_args(func
->type
), iface
->name
, 1, TRUE
);
1062 /* Remotable methods must all return HRESULTs. */
1063 fprintf(fp
, "\n{\n %s\n return E_NOTIMPL;\n}\n\n", comment
);
1068 error_loc("invalid call_as attribute (%s -> %s)\n", func
->name
, cas
->name
);
1073 static void write_local_stubs_stmts(FILE *local_stubs
, const statement_list_t
*stmts
)
1075 const statement_t
*stmt
;
1076 if (stmts
) LIST_FOR_EACH_ENTRY( stmt
, stmts
, const statement_t
, entry
)
1078 if (stmt
->type
== STMT_TYPE
&& type_get_type(stmt
->u
.type
) == TYPE_INTERFACE
)
1079 write_locals(local_stubs
, stmt
->u
.type
, TRUE
);
1083 void write_local_stubs(const statement_list_t
*stmts
)
1087 if (!local_stubs_name
) return;
1089 local_stubs
= fopen(local_stubs_name
, "w");
1091 error("Could not open %s for output\n", local_stubs_name
);
1094 fprintf(local_stubs
, "/* call_as/local stubs for %s */\n\n", input_name
);
1095 fprintf(local_stubs
, "#include <objbase.h>\n");
1096 fprintf(local_stubs
, "#include \"%s\"\n\n", header_name
);
1098 write_local_stubs_stmts(local_stubs
, stmts
);
1100 fclose(local_stubs
);
1103 static void write_function_proto(FILE *header
, const type_t
*iface
, const var_t
*fun
, const char *prefix
)
1105 const char *callconv
= get_attrp(fun
->type
->attrs
, ATTR_CALLCONV
);
1107 if (!callconv
) callconv
= "__cdecl";
1108 /* FIXME: do we need to handle call_as? */
1109 write_type_decl_left(header
, type_function_get_rettype(fun
->type
));
1110 fprintf(header
, " %s ", callconv
);
1111 fprintf(header
, "%s%s(\n", prefix
, get_name(fun
));
1112 if (type_get_function_args(fun
->type
))
1113 write_args(header
, type_get_function_args(fun
->type
), iface
->name
, 0, TRUE
);
1115 fprintf(header
, " void");
1116 fprintf(header
, ");\n\n");
1119 static void write_forward(FILE *header
, type_t
*iface
)
1121 fprintf(header
, "#ifndef __%s_FWD_DEFINED__\n", iface
->name
);
1122 fprintf(header
, "#define __%s_FWD_DEFINED__\n", iface
->name
);
1123 fprintf(header
, "typedef interface %s %s;\n", iface
->name
, iface
->name
);
1124 fprintf(header
, "#endif\n\n" );
1127 static void write_com_interface_start(FILE *header
, const type_t
*iface
)
1129 int dispinterface
= is_attr(iface
->attrs
, ATTR_DISPINTERFACE
);
1130 fprintf(header
, "/*****************************************************************************\n");
1131 fprintf(header
, " * %s %sinterface\n", iface
->name
, dispinterface
? "disp" : "");
1132 fprintf(header
, " */\n");
1133 fprintf(header
,"#ifndef __%s_%sINTERFACE_DEFINED__\n", iface
->name
, dispinterface
? "DISP" : "");
1134 fprintf(header
,"#define __%s_%sINTERFACE_DEFINED__\n\n", iface
->name
, dispinterface
? "DISP" : "");
1137 static void write_com_interface_end(FILE *header
, type_t
*iface
)
1139 int dispinterface
= is_attr(iface
->attrs
, ATTR_DISPINTERFACE
);
1140 const UUID
*uuid
= get_attrp(iface
->attrs
, ATTR_UUID
);
1143 write_guid(header
, dispinterface
? "DIID" : "IID", iface
->name
, uuid
);
1146 fprintf(header
, "#if defined(__cplusplus) && !defined(CINTERFACE)\n");
1148 fprintf(header
, "MIDL_INTERFACE(\"%s\")\n", uuid_string(uuid
));
1150 fprintf(header
, "interface ");
1151 if (type_iface_get_inherit(iface
))
1153 fprintf(header
, "%s : public %s\n", iface
->name
,
1154 type_iface_get_inherit(iface
)->name
);
1155 fprintf(header
, "{\n");
1159 fprintf(header
, "%s\n", iface
->name
);
1160 fprintf(header
, "{\n");
1161 fprintf(header
, " BEGIN_INTERFACE\n");
1162 fprintf(header
, "\n");
1164 /* dispinterfaces don't have real functions, so don't write C++ functions for
1169 write_cpp_method_def(header
, iface
);
1172 if (!type_iface_get_inherit(iface
))
1173 fprintf(header
, " END_INTERFACE\n");
1174 fprintf(header
, "};\n");
1176 write_uuid_decl(header
, iface
->name
, uuid
);
1177 fprintf(header
, "#else\n");
1179 fprintf(header
, "typedef struct %sVtbl {\n", iface
->name
);
1181 fprintf(header
, " BEGIN_INTERFACE\n");
1182 fprintf(header
, "\n");
1184 write_c_disp_method_def(header
, iface
);
1186 write_c_method_def(header
, iface
);
1188 fprintf(header
, " END_INTERFACE\n");
1189 fprintf(header
, "} %sVtbl;\n", iface
->name
);
1190 fprintf(header
, "interface %s {\n", iface
->name
);
1191 fprintf(header
, " CONST_VTBL %sVtbl* lpVtbl;\n", iface
->name
);
1192 fprintf(header
, "};\n");
1193 fprintf(header
, "\n");
1194 fprintf(header
, "#ifdef COBJMACROS\n");
1195 /* dispinterfaces don't have real functions, so don't write macros for them,
1196 * only for the interface this interface inherits from, i.e. IDispatch */
1197 fprintf(header
, "#ifndef WIDL_C_INLINE_WRAPPERS\n");
1198 write_method_macro(header
, dispinterface
? type_iface_get_inherit(iface
) : iface
, iface
->name
);
1199 fprintf(header
, "#else\n");
1200 write_inline_wrappers(header
, dispinterface
? type_iface_get_inherit(iface
) : iface
, iface
->name
);
1201 fprintf(header
, "#endif\n");
1202 fprintf(header
, "#endif\n");
1203 fprintf(header
, "\n");
1204 fprintf(header
, "#endif\n");
1205 fprintf(header
, "\n");
1206 /* dispinterfaces don't have real functions, so don't write prototypes for
1210 write_method_proto(header
, iface
);
1211 write_locals(header
, iface
, FALSE
);
1212 fprintf(header
, "\n");
1214 fprintf(header
,"#endif /* __%s_%sINTERFACE_DEFINED__ */\n\n", iface
->name
, dispinterface
? "DISP" : "");
1217 static void write_rpc_interface_start(FILE *header
, const type_t
*iface
)
1219 unsigned int ver
= get_attrv(iface
->attrs
, ATTR_VERSION
);
1220 const var_t
*var
= get_attrp(iface
->attrs
, ATTR_IMPLICIT_HANDLE
);
1222 fprintf(header
, "/*****************************************************************************\n");
1223 fprintf(header
, " * %s interface (v%d.%d)\n", iface
->name
, MAJORVERSION(ver
), MINORVERSION(ver
));
1224 fprintf(header
, " */\n");
1225 fprintf(header
,"#ifndef __%s_INTERFACE_DEFINED__\n", iface
->name
);
1226 fprintf(header
,"#define __%s_INTERFACE_DEFINED__\n\n", iface
->name
);
1229 fprintf(header
, "extern ");
1230 write_type_decl( header
, var
->type
, var
->name
);
1231 fprintf(header
, ";\n");
1235 fprintf(header
, "extern RPC_IF_HANDLE %s%s_ClientIfHandle;\n", prefix_client
, iface
->name
);
1236 fprintf(header
, "extern RPC_IF_HANDLE %s%s_ServerIfHandle;\n", prefix_server
, iface
->name
);
1240 fprintf(header
, "extern RPC_IF_HANDLE %s%s_v%d_%d_c_ifspec;\n",
1241 prefix_client
, iface
->name
, MAJORVERSION(ver
), MINORVERSION(ver
));
1242 fprintf(header
, "extern RPC_IF_HANDLE %s%s_v%d_%d_s_ifspec;\n",
1243 prefix_server
, iface
->name
, MAJORVERSION(ver
), MINORVERSION(ver
));
1247 static void write_rpc_interface_end(FILE *header
, const type_t
*iface
)
1249 fprintf(header
,"\n#endif /* __%s_INTERFACE_DEFINED__ */\n\n", iface
->name
);
1252 static void write_coclass(FILE *header
, type_t
*cocl
)
1254 const UUID
*uuid
= get_attrp(cocl
->attrs
, ATTR_UUID
);
1256 fprintf(header
, "/*****************************************************************************\n");
1257 fprintf(header
, " * %s coclass\n", cocl
->name
);
1258 fprintf(header
, " */\n\n");
1260 write_guid(header
, "CLSID", cocl
->name
, uuid
);
1261 fprintf(header
, "\n#ifdef __cplusplus\n");
1264 fprintf(header
, "class DECLSPEC_UUID(\"%s\") %s;\n", uuid_string(uuid
), cocl
->name
);
1265 write_uuid_decl(header
, cocl
->name
, uuid
);
1269 fprintf(header
, "class %s;\n", cocl
->name
);
1271 fprintf(header
, "#endif\n");
1272 fprintf(header
, "\n");
1275 static void write_coclass_forward(FILE *header
, type_t
*cocl
)
1277 fprintf(header
, "#ifndef __%s_FWD_DEFINED__\n", cocl
->name
);
1278 fprintf(header
, "#define __%s_FWD_DEFINED__\n", cocl
->name
);
1279 fprintf(header
, "typedef struct %s %s;\n", cocl
->name
, cocl
->name
);
1280 fprintf(header
, "#endif /* defined __%s_FWD_DEFINED__ */\n\n", cocl
->name
);
1283 static void write_import(FILE *header
, const char *fname
)
1287 hname
= dup_basename(fname
, ".idl");
1288 p
= hname
+ strlen(hname
) - 2;
1289 if (p
<= hname
|| strcmp( p
, ".h" )) strcat(hname
, ".h");
1291 fprintf(header
, "#include <%s>\n", hname
);
1295 static void write_imports(FILE *header
, const statement_list_t
*stmts
)
1297 const statement_t
*stmt
;
1298 if (stmts
) LIST_FOR_EACH_ENTRY( stmt
, stmts
, const statement_t
, entry
)
1303 if (type_get_type(stmt
->u
.type
) == TYPE_INTERFACE
)
1304 write_imports(header
, type_iface_get_stmts(stmt
->u
.type
));
1307 case STMT_IMPORTLIB
:
1308 /* not included in header */
1311 write_import(header
, stmt
->u
.str
);
1316 case STMT_DECLARATION
:
1317 /* not processed here */
1320 write_imports(header
, stmt
->u
.lib
->stmts
);
1326 static void write_forward_decls(FILE *header
, const statement_list_t
*stmts
)
1328 const statement_t
*stmt
;
1329 if (stmts
) LIST_FOR_EACH_ENTRY( stmt
, stmts
, const statement_t
, entry
)
1334 if (type_get_type(stmt
->u
.type
) == TYPE_INTERFACE
)
1336 if (is_object(stmt
->u
.type
) || is_attr(stmt
->u
.type
->attrs
, ATTR_DISPINTERFACE
))
1337 write_forward(header
, stmt
->u
.type
);
1339 else if (type_get_type(stmt
->u
.type
) == TYPE_COCLASS
)
1340 write_coclass_forward(header
, stmt
->u
.type
);
1343 case STMT_IMPORTLIB
:
1344 /* not included in header */
1350 case STMT_DECLARATION
:
1351 /* not processed here */
1354 write_forward_decls(header
, stmt
->u
.lib
->stmts
);
1360 static void write_header_stmts(FILE *header
, const statement_list_t
*stmts
, const type_t
*iface
, int ignore_funcs
)
1362 const statement_t
*stmt
;
1363 if (stmts
) LIST_FOR_EACH_ENTRY( stmt
, stmts
, const statement_t
, entry
)
1368 if (type_get_type(stmt
->u
.type
) == TYPE_INTERFACE
)
1370 type_t
*iface
= stmt
->u
.type
;
1371 if (is_object(iface
)) is_object_interface
++;
1372 if (is_attr(stmt
->u
.type
->attrs
, ATTR_DISPINTERFACE
) || is_object(stmt
->u
.type
))
1374 write_com_interface_start(header
, iface
);
1375 write_header_stmts(header
, type_iface_get_stmts(iface
), stmt
->u
.type
, TRUE
);
1376 write_com_interface_end(header
, iface
);
1380 write_rpc_interface_start(header
, iface
);
1381 write_header_stmts(header
, type_iface_get_stmts(iface
), iface
, FALSE
);
1382 write_rpc_interface_end(header
, iface
);
1384 if (is_object(iface
)) is_object_interface
--;
1386 else if (type_get_type(stmt
->u
.type
) == TYPE_COCLASS
)
1387 write_coclass(header
, stmt
->u
.type
);
1390 write_type_def_or_decl(header
, stmt
->u
.type
, FALSE
, NULL
);
1391 fprintf(header
, ";\n\n");
1395 /* FIXME: shouldn't write out forward declarations for undefined
1396 * interfaces but a number of our IDL files depend on this */
1397 if (type_get_type(stmt
->u
.type
) == TYPE_INTERFACE
&& !stmt
->u
.type
->written
)
1398 write_forward(header
, stmt
->u
.type
);
1400 case STMT_IMPORTLIB
:
1402 /* not included in header */
1405 /* not processed here */
1409 const type_list_t
*type_entry
= stmt
->u
.type_list
;
1410 for (; type_entry
; type_entry
= type_entry
->next
)
1411 write_typedef(header
, type_entry
->type
);
1415 write_library(header
, stmt
->u
.lib
);
1416 write_header_stmts(header
, stmt
->u
.lib
->stmts
, NULL
, FALSE
);
1419 fprintf(header
, "%s\n", stmt
->u
.str
);
1421 case STMT_DECLARATION
:
1422 if (iface
&& type_get_type(stmt
->u
.var
->type
) == TYPE_FUNCTION
)
1426 int prefixes_differ
= strcmp(prefix_client
, prefix_server
);
1428 if (prefixes_differ
)
1430 fprintf(header
, "/* client prototype */\n");
1431 write_function_proto(header
, iface
, stmt
->u
.var
, prefix_client
);
1432 fprintf(header
, "/* server prototype */\n");
1434 write_function_proto(header
, iface
, stmt
->u
.var
, prefix_server
);
1438 write_declaration(header
, stmt
->u
.var
);
1444 void write_header(const statement_list_t
*stmts
)
1448 if (!do_header
) return;
1450 if(!(header
= fopen(header_name
, "w"))) {
1451 error("Could not open %s for output\n", header_name
);
1454 fprintf(header
, "/*** Autogenerated by WIDL %s from %s - Do not edit ***/\n\n", PACKAGE_VERSION
, input_name
);
1456 fprintf(header
, "#ifndef __REQUIRED_RPCNDR_H_VERSION__\n");
1457 fprintf(header
, "#define __REQUIRED_RPCNDR_H_VERSION__ 475\n");
1458 fprintf(header
, "#endif\n\n");
1460 fprintf(header
, "#include <rpc.h>\n" );
1461 fprintf(header
, "#include <rpcndr.h>\n\n" );
1463 fprintf(header
, "#ifndef COM_NO_WINDOWS_H\n");
1464 fprintf(header
, "#include <windows.h>\n");
1465 fprintf(header
, "#include <ole2.h>\n");
1466 fprintf(header
, "#endif\n\n");
1468 fprintf(header
, "#ifndef __%s__\n", header_token
);
1469 fprintf(header
, "#define __%s__\n\n", header_token
);
1471 fprintf(header
, "/* Forward declarations */\n\n");
1472 write_forward_decls(header
, stmts
);
1474 fprintf(header
, "/* Headers for imported files */\n\n");
1475 write_imports(header
, stmts
);
1476 fprintf(header
, "\n");
1477 start_cplusplus_guard(header
);
1479 write_header_stmts(header
, stmts
, NULL
, FALSE
);
1481 fprintf(header
, "/* Begin additional prototypes for all interfaces */\n");
1482 fprintf(header
, "\n");
1483 write_user_types(header
);
1484 write_generic_handle_routines(header
);
1485 write_context_handle_rundowns(header
);
1486 fprintf(header
, "\n");
1487 fprintf(header
, "/* End additional prototypes */\n");
1488 fprintf(header
, "\n");
1490 end_cplusplus_guard(header
);
1491 fprintf(header
, "#endif /* __%s__ */\n", header_token
);