widl: Output NULL ref pointer check for pointer levels > 1 too.
[wine] / tools / widl / header.c
1 /*
2  * IDL Compiler
3  *
4  * Copyright 2002 Ove Kaaven
5  *
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.
10  *
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.
15  *
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
19  */
20
21 #include "config.h"
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #ifdef HAVE_UNISTD_H
26 # include <unistd.h>
27 #endif
28 #include <string.h>
29 #include <assert.h>
30 #include <ctype.h>
31 #include <signal.h>
32
33 #include "windef.h"
34 #include "widl.h"
35 #include "utils.h"
36 #include "parser.h"
37 #include "header.h"
38
39 static int indentation = 0;
40
41 static void indent(FILE *h, int delta)
42 {
43   int c;
44   if (delta < 0) indentation += delta;
45   for (c=0; c<indentation; c++) fprintf(h, "    ");
46   if (delta > 0) indentation += delta;
47 }
48
49 int is_attr(const attr_t *a, enum attr_type t)
50 {
51   while (a) {
52     if (a->type == t) return 1;
53     a = NEXT_LINK(a);
54   }
55   return 0;
56 }
57
58 void *get_attrp(const attr_t *a, enum attr_type t)
59 {
60   while (a) {
61     if (a->type == t) return a->u.pval;
62     a = NEXT_LINK(a);
63   }
64   return NULL;
65 }
66
67 unsigned long get_attrv(const attr_t *a, enum attr_type t)
68 {
69   while (a) {
70     if (a->type == t) return a->u.ival;
71     a = NEXT_LINK(a);
72   }
73   return 0;
74 }
75
76 int is_void(const type_t *t, const var_t *v)
77 {
78   if (v && v->ptr_level) return 0;
79   if (!t->type && !t->ref) return 1;
80   return 0;
81 }
82
83 static void write_guid(const char *guid_prefix, const char *name, const UUID *uuid)
84 {
85   if (!uuid) return;
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]);
91 }
92
93 static void write_pident(FILE *h, const var_t *v)
94 {
95   int c;
96   for (c=0; c<v->ptr_level; c++) {
97     fprintf(h, "*");
98   }
99   if (v->name) fprintf(h, "%s", v->name);
100 }
101
102 void write_name(FILE *h, const var_t *v)
103 {
104   if (is_attr( v->attrs, ATTR_PROPGET ))
105     fprintf(h, "get_" );
106   else if (is_attr( v->attrs, ATTR_PROPPUT ))
107     fprintf(h, "put_" );
108   else if (is_attr( v->attrs, ATTR_PROPPUTREF ))
109     fprintf(h, "putref_" );
110   fprintf(h, "%s", v->name);
111 }
112
113 const char* get_name(const var_t *v)
114 {
115   return v->name;
116 }
117
118 void write_array(FILE *h, const expr_t *v, int field)
119 {
120   if (!v) return;
121   while (NEXT_LINK(v)) v = NEXT_LINK(v);
122   fprintf(h, "[");
123   while (v) {
124     if (v->is_const)
125       fprintf(h, "%ld", v->cval); /* statically sized array */
126     else
127       if (field) fprintf(h, "1"); /* dynamically sized array */
128     if (PREV_LINK(v))
129       fprintf(h, ", ");
130     v = PREV_LINK(v);
131   }
132   fprintf(h, "]");
133 }
134
135 static void write_field(FILE *h, var_t *v)
136 {
137   if (!v) return;
138   if (v->type) {
139     indent(h, 0);
140     write_type(h, v->type, NULL, v->tname);
141     if (get_name(v)) {
142       fprintf(h, " ");
143       write_pident(h, v);
144     }
145     else {
146       /* not all C/C++ compilers support anonymous structs and unions */
147       switch (v->type->type) {
148       case RPC_FC_STRUCT:
149       case RPC_FC_CVSTRUCT:
150       case RPC_FC_CPSTRUCT:
151       case RPC_FC_CSTRUCT:
152       case RPC_FC_PSTRUCT:
153       case RPC_FC_BOGUS_STRUCT:
154       case RPC_FC_ENCAPSULATED_UNION:
155         fprintf(h, " DUMMYSTRUCTNAME");
156         break;
157       case RPC_FC_NON_ENCAPSULATED_UNION:
158         fprintf(h, " DUMMYUNIONNAME");
159         break;
160       default:
161         /* ? */
162         break;
163       }
164     }
165     write_array(h, v->array, 1);
166     fprintf(h, ";\n");
167   }
168 }
169
170 static void write_fields(FILE *h, var_t *v)
171 {
172   var_t *first = v;
173   if (!v) return;
174   while (NEXT_LINK(v)) v = NEXT_LINK(v);
175   while (v) {
176     write_field(h, v);
177     if (v == first) break;
178     v = PREV_LINK(v);
179   }
180 }
181
182 static void write_enums(FILE *h, var_t *v)
183 {
184   if (!v) return;
185   while (NEXT_LINK(v)) v = NEXT_LINK(v);
186   while (v) {
187     if (get_name(v)) {
188       indent(h, 0);
189       write_name(h, v);
190       if (v->eval) {
191         fprintf(h, " = ");
192         write_expr(h, v->eval, 0);
193       }
194     }
195     if (PREV_LINK(v))
196       fprintf(h, ",\n");
197     v = PREV_LINK(v);
198   }
199   fprintf(h, "\n");
200 }
201
202 void write_type(FILE *h, type_t *t, const var_t *v, const char *n)
203 {
204   int c;
205
206   if (n) fprintf(h, "%s", n);
207   else {
208     if (t->is_const) fprintf(h, "const ");
209     if (t->type) {
210       if (t->sign > 0) fprintf(h, "signed ");
211       else if (t->sign < 0) fprintf(h, "unsigned ");
212       switch (t->type) {
213       case RPC_FC_BYTE:
214         if (t->ref) fprintf(h, t->ref->name);
215         else fprintf(h, "byte");
216         break;
217       case RPC_FC_CHAR:
218         if (t->ref) fprintf(h, t->ref->name);
219         else fprintf(h, "char");
220         break;
221       case RPC_FC_WCHAR:
222         fprintf(h, "WCHAR");
223         break;
224       case RPC_FC_USMALL:
225       case RPC_FC_SMALL:
226         if (t->ref) fprintf(h, t->ref->name);
227         else fprintf(h, "small");
228         break;
229       case RPC_FC_USHORT:
230       case RPC_FC_SHORT:
231         if (t->ref) fprintf(h, t->ref->name);
232         else fprintf(h, "short");
233         break;
234       case RPC_FC_ULONG:
235       case RPC_FC_LONG:
236         if (t->ref) fprintf(h, t->ref->name);
237         else fprintf(h, "long");
238         break;
239       case RPC_FC_HYPER:
240         if (t->ref) fprintf(h, t->ref->name);
241         else fprintf(h, "hyper");
242         break;
243       case RPC_FC_FLOAT:
244         fprintf(h, "float");
245         break;
246       case RPC_FC_DOUBLE:
247         fprintf(h, "double");
248         break;
249       case RPC_FC_ENUM16:
250       case RPC_FC_ENUM32:
251         if (t->defined && !t->written) {
252           if (t->name) fprintf(h, "enum %s {\n", t->name);
253           else fprintf(h, "enum {\n");
254           t->written = TRUE;
255           indentation++;
256           write_enums(h, t->fields);
257           indent(h, -1);
258           fprintf(h, "}");
259         }
260         else fprintf(h, "enum %s", t->name);
261         break;
262       case RPC_FC_ERROR_STATUS_T:
263         if (t->ref) fprintf(h, t->ref->name);
264         else fprintf(h, "error_status_t");
265         break;
266       case RPC_FC_BIND_PRIMITIVE:
267         if (t->ref) fprintf(h, t->ref->name);
268         else fprintf(h, "handle_t");
269         break;
270       case RPC_FC_STRUCT:
271       case RPC_FC_CVSTRUCT:
272       case RPC_FC_CPSTRUCT:
273       case RPC_FC_CSTRUCT:
274       case RPC_FC_PSTRUCT:
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");
280           t->written = TRUE;
281           indentation++;
282           write_fields(h, t->fields);
283           indent(h, -1);
284           fprintf(h, "}");
285         }
286         else fprintf(h, "struct %s", t->name);
287         break;
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");
292           t->written = TRUE;
293           indentation++;
294           write_fields(h, t->fields);
295           indent(h, -1);
296           fprintf(h, "}");
297         }
298         else fprintf(h, "union %s", t->name);
299         break;
300       default:
301         fprintf(h, "(unknown-type:%d)", t->type);
302       }
303     }
304     else {
305       if (t->ref) {
306         write_type(h, t->ref, NULL, t->name);
307       }
308       else fprintf(h, "void");
309     }
310   }
311   if (v) {
312     for (c=0; c<v->ptr_level; c++) {
313       fprintf(h, "*");
314     }
315   }
316 }
317
318
319 struct user_type
320 {
321     struct user_type *next;
322     char name[1];
323 };
324
325 static struct user_type *user_type_list;
326
327 static int user_type_registered(const char *name)
328 {
329   struct user_type *ut;
330   for (ut = user_type_list; ut; ut = ut->next)
331     if (!strcmp(name, ut->name))
332         return 1;
333   return 0;
334 }
335
336 static void check_for_user_types(const var_t *v)
337 {
338   while (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))
346         {
347           struct user_type *ut = xmalloc(sizeof(struct user_type) + strlen(name));
348           strcpy(ut->name, name);
349           ut->next = user_type_list;
350           user_type_list = ut;
351         }
352         /* don't carry on parsing fields within this type as we are already
353          * using a wire marshaled type */
354         break;
355       }
356       else if (type->fields)
357       {
358         const var_t *fields = type->fields;
359         while (NEXT_LINK(fields)) fields = NEXT_LINK(fields);
360         check_for_user_types(fields);
361       }
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;
366     }
367     v = PREV_LINK(v);
368   }
369 }
370
371 void write_user_types(void)
372 {
373   struct user_type *ut;
374   for (ut = user_type_list; ut; ut = ut->next)
375   {
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);
381   }
382 }
383
384 void write_typedef(type_t *type, const var_t *names)
385 {
386   const char *tname = names->tname;
387   const var_t *lname;
388   while (NEXT_LINK(names)) names = NEXT_LINK(names);
389   lname = names;
390   fprintf(header, "typedef ");
391   write_type(header, type, NULL, tname);
392   fprintf(header, " ");
393   while (names) {
394     write_pident(header, names);
395     if (PREV_LINK(names))
396       fprintf(header, ", ");
397     names = PREV_LINK(names);
398   }
399   fprintf(header, ";\n");
400 }
401
402 void write_expr(FILE *h, const expr_t *e, int brackets)
403 {
404   switch (e->type) {
405   case EXPR_VOID:
406     break;
407   case EXPR_NUM:
408     fprintf(h, "%ld", e->u.lval);
409     break;
410   case EXPR_HEXNUM:
411     fprintf(h, "0x%lx", e->u.lval);
412     break;
413   case EXPR_IDENTIFIER:
414     fprintf(h, "%s", e->u.sval);
415     break;
416   case EXPR_NEG:
417     fprintf(h, "-");
418     write_expr(h, e->ref, 1);
419     break;
420   case EXPR_NOT:
421     fprintf(h, "~");
422     write_expr(h, e->ref, 1);
423     break;
424   case EXPR_PPTR:
425     fprintf(h, "*");
426     write_expr(h, e->ref, 1);
427     break;
428   case EXPR_CAST:
429     fprintf(h, "(");
430     write_type(h, e->u.tref->ref, NULL, e->u.tref->name);
431     fprintf(h, ")");
432     write_expr(h, e->ref, 1);
433     break;
434   case EXPR_SIZEOF:
435     fprintf(h, "sizeof(");
436     write_type(h, e->u.tref->ref, NULL, e->u.tref->name);
437     fprintf(h, ")");
438     break;
439   case EXPR_SHL:
440   case EXPR_SHR:
441   case EXPR_MUL:
442   case EXPR_DIV:
443   case EXPR_ADD:
444   case EXPR_SUB:
445   case EXPR_AND:
446   case EXPR_OR:
447     if (brackets) fprintf(h, "(");
448     write_expr(h, e->ref, 1);
449     switch (e->type) {
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;
458     default: break;
459     }
460     write_expr(h, e->u.ext, 1);
461     if (brackets) fprintf(h, ")");
462     break;
463   case EXPR_COND:
464     if (brackets) fprintf(h, "(");
465     write_expr(h, e->ref, 1);
466     fprintf(h, " ? ");
467     write_expr(h, e->u.ext, 1);
468     fprintf(h, " : ");
469     write_expr(h, e->ext2, 1);
470     if (brackets) fprintf(h, ")");
471     break;
472   }
473 }
474
475 void write_constdef(const var_t *v)
476 {
477   fprintf(header, "#define %s (", get_name(v));
478   write_expr(header, v->eval, 0);
479   fprintf(header, ")\n\n");
480 }
481
482 void write_externdef(const var_t *v)
483 {
484   fprintf(header, "extern const ");
485   write_type(header, v->type, NULL, v->tname);
486   if (get_name(v)) {
487     fprintf(header, " ");
488     write_pident(header, v);
489   }
490   fprintf(header, ";\n\n");
491 }
492
493 void write_library(const char *name, const attr_t *attr) {
494   const UUID *uuid = get_attrp(attr, ATTR_UUID);
495   fprintf(header, "\n");
496   write_guid("LIBID", name, uuid);
497   fprintf(header, "\n");
498 }
499
500
501 const var_t* get_explicit_handle_var(const func_t* func)
502 {
503     const var_t* var;
504
505     if (!func->args)
506         return NULL;
507
508     var = func->args;
509     while (NEXT_LINK(var)) var = NEXT_LINK(var);
510     while (var)
511     {
512         if (var->type->type == RPC_FC_BIND_PRIMITIVE)
513             return var;
514
515         var = PREV_LINK(var);
516     }
517
518     return NULL;
519 }
520
521 int has_out_arg_or_return(const func_t *func)
522 {
523     var_t *var;
524
525     if (!is_void(func->def->type, NULL))
526         return 1;
527
528     if (!func->args)
529         return 0;
530
531     var = func->args;
532     while (NEXT_LINK(var)) var = NEXT_LINK(var);
533     while (var)
534     {
535         if (is_attr(var->attrs, ATTR_OUT))
536             return 1;
537
538         var = PREV_LINK(var);
539     }
540     return 0;
541 }
542
543
544 /********** INTERFACES **********/
545
546 int is_object(const attr_t *a)
547 {
548   while (a) {
549     if (a->type == ATTR_OBJECT || a->type == ATTR_ODL) return 1;
550     a = NEXT_LINK(a);
551   }
552   return 0;
553 }
554
555 int is_local(const attr_t *a)
556 {
557   return is_attr(a, ATTR_LOCAL);
558 }
559
560 const var_t *is_callas(const attr_t *a)
561 {
562   return get_attrp(a, ATTR_CALLAS);
563 }
564
565 static int write_method_macro(const type_t *iface, const char *name)
566 {
567   int idx;
568   func_t *cur = iface->funcs;
569
570   if (iface->ref) idx = write_method_macro(iface->ref, name);
571   else idx = 0;
572
573   if (!cur) return idx;
574   while (NEXT_LINK(cur)) cur = NEXT_LINK(cur);
575
576   fprintf(header, "/*** %s methods ***/\n", iface->name);
577   while (cur) {
578     var_t *def = cur->def;
579     if (!is_callas(def->attrs)) {
580       var_t *arg = cur->args;
581       int argc = 0;
582       int c;
583       while (arg) {
584         arg = NEXT_LINK(arg);
585         argc++;
586       }
587
588       fprintf(header, "#define %s_", name);
589       write_name(header,def);
590       fprintf(header, "(p");
591       for (c=0; c<argc; c++)
592         fprintf(header, ",%c", c+'a');
593       fprintf(header, ") ");
594
595       fprintf(header, "(p)->lpVtbl->");
596       write_name(header, def);
597       fprintf(header, "(p");
598       for (c=0; c<argc; c++)
599         fprintf(header, ",%c", c+'a');
600       fprintf(header, ")\n");
601       if (cur->idx == -1) cur->idx = idx;
602       else if (cur->idx != idx) yyerror("BUG: method index mismatch in write_method_macro");
603       idx++;
604     }
605     cur = PREV_LINK(cur);
606   }
607   return idx;
608 }
609
610 void write_args(FILE *h, var_t *arg, const char *name, int method, int do_indent)
611 {
612   int count = 0;
613   if (arg) {
614     while (NEXT_LINK(arg))
615       arg = NEXT_LINK(arg);
616   }
617   if (do_indent)
618   {
619       indentation++;
620       indent(h, 0);
621   }
622   if (method == 1) {
623     fprintf(h, "%s* This", name);
624     count++;
625   }
626   while (arg) {
627     if (count) {
628         if (do_indent)
629         {
630             fprintf(h, ",\n");
631             indent(h, 0);
632         }
633         else fprintf(h, ",");
634     }
635     write_type(h, arg->type, arg, arg->tname);
636     if (arg->args)
637     {
638       fprintf(h, " (STDMETHODCALLTYPE *");
639       write_name(h,arg);
640       fprintf(h, ")(");
641       write_args(h, arg->args, NULL, 0, FALSE);
642       fprintf(h, ")");
643     }
644     else
645     {
646       fprintf(h, " ");
647       write_name(h, arg);
648     }
649     write_array(h, arg->array, 0);
650     arg = PREV_LINK(arg);
651     count++;
652   }
653   if (do_indent) indentation--;
654 }
655
656 static void write_cpp_method_def(const type_t *iface)
657 {
658   func_t *cur = iface->funcs;
659
660   if (!cur) return;
661   while (NEXT_LINK(cur)) cur = NEXT_LINK(cur);
662   while (cur) {
663     var_t *def = cur->def;
664     if (!is_callas(def->attrs)) {
665       indent(header, 0);
666       fprintf(header, "virtual ");
667       write_type(header, def->type, def, def->tname);
668       fprintf(header, " STDMETHODCALLTYPE ");
669       write_name(header, def);
670       fprintf(header, "(\n");
671       write_args(header, cur->args, iface->name, 2, TRUE);
672       fprintf(header, ") = 0;\n");
673       fprintf(header, "\n");
674     }
675     cur = PREV_LINK(cur);
676   }
677 }
678
679 static void do_write_c_method_def(const type_t *iface, const char *name)
680 {
681   const func_t *cur = iface->funcs;
682
683   if (iface->ref) do_write_c_method_def(iface->ref, name);
684
685   if (!cur) return;
686   while (NEXT_LINK(cur)) cur = NEXT_LINK(cur);
687   indent(header, 0);
688   fprintf(header, "/*** %s methods ***/\n", iface->name);
689   while (cur) {
690     const var_t *def = cur->def;
691     if (!is_callas(def->attrs)) {
692       indent(header, 0);
693       write_type(header, def->type, def, def->tname);
694       fprintf(header, " (STDMETHODCALLTYPE *");
695       write_name(header, def);
696       fprintf(header, ")(\n");
697       write_args(header, cur->args, name, 1, TRUE);
698       fprintf(header, ");\n");
699       fprintf(header, "\n");
700     }
701     cur = PREV_LINK(cur);
702   }
703 }
704
705 static void write_c_method_def(const type_t *iface)
706 {
707   do_write_c_method_def(iface, iface->name);
708 }
709
710 static void write_c_disp_method_def(const type_t *iface)
711 {
712   do_write_c_method_def(iface->ref, iface->name);
713 }
714
715 static void write_method_proto(const type_t *iface)
716 {
717   const func_t *cur = iface->funcs;
718
719   if (!cur) return;
720   while (NEXT_LINK(cur)) cur = NEXT_LINK(cur);
721   while (cur) {
722     const var_t *def = cur->def;
723     const var_t *cas = is_callas(def->attrs);
724     const var_t *args;
725     if (!is_local(def->attrs)) {
726       /* proxy prototype */
727       write_type(header, def->type, def, def->tname);
728       fprintf(header, " CALLBACK %s_", iface->name);
729       write_name(header, def);
730       fprintf(header, "_Proxy(\n");
731       write_args(header, cur->args, iface->name, 1, TRUE);
732       fprintf(header, ");\n");
733       /* stub prototype */
734       fprintf(header, "void __RPC_STUB %s_", iface->name);
735       write_name(header,def);
736       fprintf(header, "_Stub(\n");
737       fprintf(header, "    IRpcStubBuffer* This,\n");
738       fprintf(header, "    IRpcChannelBuffer* pRpcChannelBuffer,\n");
739       fprintf(header, "    PRPC_MESSAGE pRpcMessage,\n");
740       fprintf(header, "    DWORD* pdwStubPhase);\n");
741
742       args = cur->args;
743       if (args) {
744         while (NEXT_LINK(args))
745           args = NEXT_LINK(args);
746       }
747       check_for_user_types(args);
748     }
749     if (cas) {
750       const func_t *m = iface->funcs;
751       while (m && strcmp(get_name(m->def), cas->name))
752         m = NEXT_LINK(m);
753       if (m) {
754         const var_t *mdef = m->def;
755         /* proxy prototype - use local prototype */
756         write_type(header, mdef->type, mdef, mdef->tname);
757         fprintf(header, " CALLBACK %s_", iface->name);
758         write_name(header, mdef);
759         fprintf(header, "_Proxy(\n");
760         write_args(header, m->args, iface->name, 1, TRUE);
761         fprintf(header, ");\n");
762         /* stub prototype - use remotable prototype */
763         write_type(header, def->type, def, def->tname);
764         fprintf(header, " __RPC_STUB %s_", iface->name);
765         write_name(header, mdef);
766         fprintf(header, "_Stub(\n");
767         write_args(header, cur->args, iface->name, 1, TRUE);
768         fprintf(header, ");\n");
769       }
770       else {
771         yywarning("invalid call_as attribute (%s -> %s)\n", get_name(def), cas->name);
772       }
773     }
774
775     cur = PREV_LINK(cur);
776   }
777 }
778
779 static void write_function_proto(const type_t *iface)
780 {
781   const char *implicit_handle = get_attrp(iface->attrs, ATTR_IMPLICIT_HANDLE);
782   int explicit_handle = is_attr(iface->attrs, ATTR_EXPLICIT_HANDLE);
783   const var_t* explicit_handle_var;
784
785   func_t *cur = iface->funcs;
786   while (NEXT_LINK(cur)) cur = NEXT_LINK(cur);
787   while (cur) {
788     var_t *def = cur->def;
789
790     /* check for a defined binding handle */
791     explicit_handle_var = get_explicit_handle_var(cur);
792     if (explicit_handle) {
793       if (!explicit_handle_var) {
794         error("%s() does not define an explicit binding handle!\n", def->name);
795         return;
796       }
797     } else if (implicit_handle) {
798       if (explicit_handle_var) {
799         error("%s() must not define a binding handle!\n", def->name);
800         return;
801       }
802     }
803
804     /* FIXME: do we need to handle call_as? */
805     write_type(header, def->type, def, def->tname);
806     fprintf(header, " ");
807     write_name(header, def);
808     fprintf(header, "(\n");
809     if (cur->args)
810       write_args(header, cur->args, iface->name, 0, TRUE);
811     else
812       fprintf(header, "    void");
813     fprintf(header, ");\n");
814
815     cur = PREV_LINK(cur);
816   }
817 }
818
819 void write_forward(type_t *iface)
820 {
821   /* C/C++ forwards should only be written for object interfaces, so if we
822    * have a full definition we only write one if we find [object] among the
823    * attributes - however, if we don't have a full definition at this point
824    * (i.e. this is an IDL forward), then we also assume that it is an object
825    * interface, since non-object interfaces shouldn't need forwards */
826   if ((!iface->defined || is_object(iface->attrs) || is_attr(iface->attrs, ATTR_DISPINTERFACE))
827         && !iface->written) {
828     fprintf(header, "#ifndef __%s_FWD_DEFINED__\n", iface->name);
829     fprintf(header, "#define __%s_FWD_DEFINED__\n", iface->name);
830     fprintf(header, "typedef interface %s %s;\n", iface->name, iface->name);
831     fprintf(header, "#endif\n\n" );
832     iface->written = TRUE;
833   }
834 }
835
836 static void write_iface_guid(const type_t *iface)
837 {
838   const UUID *uuid = get_attrp(iface->attrs, ATTR_UUID);
839   write_guid("IID", iface->name, uuid);
840
841
842 static void write_dispiface_guid(const type_t *iface)
843 {
844   const UUID *uuid = get_attrp(iface->attrs, ATTR_UUID);
845   write_guid("DIID", iface->name, uuid);
846 }
847
848 static void write_coclass_guid(class_t *cocl)
849 {
850   const UUID *uuid = get_attrp(cocl->attrs, ATTR_UUID);
851   write_guid("CLSID", cocl->name, uuid);
852 }
853
854 static void write_com_interface(type_t *iface)
855 {
856   if (!iface->funcs && !iface->ref) {
857     yywarning("%s has no methods", iface->name);
858     return;
859   }
860
861   fprintf(header, "/*****************************************************************************\n");
862   fprintf(header, " * %s interface\n", iface->name);
863   fprintf(header, " */\n");
864   fprintf(header,"#ifndef __%s_INTERFACE_DEFINED__\n", iface->name);
865   fprintf(header,"#define __%s_INTERFACE_DEFINED__\n\n", iface->name);
866   write_iface_guid(iface);
867   write_forward(iface);
868   /* C++ interface */
869   fprintf(header, "#if defined(__cplusplus) && !defined(CINTERFACE)\n");
870   if (iface->ref)
871   {
872       fprintf(header, "interface %s : public %s\n", iface->name, iface->ref->name);
873       fprintf(header, "{\n");
874       indentation++;
875       write_cpp_method_def(iface);
876       indentation--;
877       fprintf(header, "};\n");
878   }
879   else
880   {
881       fprintf(header, "interface %s\n", iface->name);
882       fprintf(header, "{\n");
883       fprintf(header, "    BEGIN_INTERFACE\n");
884       fprintf(header, "\n");
885       indentation++;
886       write_cpp_method_def(iface);
887       indentation--;
888       fprintf(header, "    END_INTERFACE\n");
889       fprintf(header, "};\n");
890   }
891   fprintf(header, "#else\n");
892   /* C interface */
893   fprintf(header, "typedef struct %sVtbl {\n", iface->name);
894   indentation++;
895   fprintf(header, "    BEGIN_INTERFACE\n");
896   fprintf(header, "\n");
897   write_c_method_def(iface);
898   indentation--;
899   fprintf(header, "    END_INTERFACE\n");
900   fprintf(header, "} %sVtbl;\n", iface->name);
901   fprintf(header, "interface %s {\n", iface->name);
902   fprintf(header, "    const %sVtbl* lpVtbl;\n", iface->name);
903   fprintf(header, "};\n");
904   fprintf(header, "\n");
905   fprintf(header, "#ifdef COBJMACROS\n");
906   write_method_macro(iface, iface->name);
907   fprintf(header, "#endif\n");
908   fprintf(header, "\n");
909   fprintf(header, "#endif\n");
910   fprintf(header, "\n");
911   write_method_proto(iface);
912   fprintf(header,"\n#endif  /* __%s_INTERFACE_DEFINED__ */\n\n", iface->name);
913 }
914
915 static void write_rpc_interface(const type_t *iface)
916 {
917   unsigned long ver = get_attrv(iface->attrs, ATTR_VERSION);
918   const char *var = get_attrp(iface->attrs, ATTR_IMPLICIT_HANDLE);
919   static int allocate_written = 0;
920
921   if (!allocate_written)
922   {
923     allocate_written = 1;
924     fprintf(header, "void * __RPC_USER MIDL_user_allocate(size_t);\n");
925     fprintf(header, "void __RPC_USER MIDL_user_free(void *);\n\n");
926   }
927
928   fprintf(header, "/*****************************************************************************\n");
929   fprintf(header, " * %s interface (v%d.%d)\n", iface->name, LOWORD(ver), HIWORD(ver));
930   fprintf(header, " */\n");
931   fprintf(header,"#ifndef __%s_INTERFACE_DEFINED__\n", iface->name);
932   fprintf(header,"#define __%s_INTERFACE_DEFINED__\n\n", iface->name);
933   if (iface->funcs)
934   {
935     write_iface_guid(iface);
936     if (var) fprintf(header, "extern handle_t %s;\n", var);
937     fprintf(header, "extern RPC_IF_HANDLE %s_v%d_%d_c_ifspec;\n", iface->name, LOWORD(ver), HIWORD(ver));
938     fprintf(header, "extern RPC_IF_HANDLE %s_v%d_%d_s_ifspec;\n", iface->name, LOWORD(ver), HIWORD(ver));
939     write_function_proto(iface);
940   }
941   fprintf(header,"\n#endif  /* __%s_INTERFACE_DEFINED__ */\n\n", iface->name);
942
943   /* FIXME: server/client code */
944 }
945
946 void write_interface(type_t *iface)
947 {
948   if (is_object(iface->attrs))
949     write_com_interface(iface);
950   else
951     write_rpc_interface(iface);
952 }
953
954 void write_dispinterface(type_t *iface)
955 {
956   fprintf(header, "/*****************************************************************************\n");
957   fprintf(header, " * %s dispinterface\n", iface->name);
958   fprintf(header, " */\n");
959   fprintf(header,"#ifndef __%s_DISPINTERFACE_DEFINED__\n", iface->name);
960   fprintf(header,"#define __%s_DISPINTERFACE_DEFINED__\n\n", iface->name);
961   write_dispiface_guid(iface);
962   write_forward(iface);
963   /* C++ interface */
964   fprintf(header, "#if defined(__cplusplus) && !defined(CINTERFACE)\n");
965   fprintf(header, "interface %s : public %s\n", iface->name, iface->ref->name);
966   fprintf(header, "{\n");
967   fprintf(header, "};\n");
968   fprintf(header, "#else\n");
969   /* C interface */
970   fprintf(header, "typedef struct %sVtbl {\n", iface->name);
971   indentation++;
972   fprintf(header, "    BEGIN_INTERFACE\n");
973   fprintf(header, "\n");
974   write_c_disp_method_def(iface);
975   indentation--;
976   fprintf(header, "    END_INTERFACE\n");
977   fprintf(header, "} %sVtbl;\n", iface->name);
978   fprintf(header, "interface %s {\n", iface->name);
979   fprintf(header, "    const %sVtbl* lpVtbl;\n", iface->name);
980   fprintf(header, "};\n");
981   fprintf(header, "\n");
982   fprintf(header, "#ifdef COBJMACROS\n");
983   write_method_macro(iface->ref, iface->name);
984   fprintf(header, "#endif\n");
985   fprintf(header, "\n");
986   fprintf(header, "#endif\n");
987   fprintf(header, "\n");
988   fprintf(header,"#endif  /* __%s_DISPINTERFACE_DEFINED__ */\n\n", iface->name);
989 }
990
991 void write_coclass(class_t *cocl)
992 {
993   fprintf(header, "/*****************************************************************************\n");
994   fprintf(header, " * %s coclass\n", cocl->name);
995   fprintf(header, " */\n\n");
996   write_coclass_guid(cocl);
997   fprintf(header, "\n");
998 }