15a0bd427618a1651ab6c8dd52a8d158488373ea
[samba.git] / source4 / build / pidl / header.pm
1 ###################################################
2 # create C header files for an IDL structure
3 # Copyright tridge@samba.org 2000
4 # released under the GNU GPL
5
6 package IdlHeader;
7
8 use strict;
9 use needed;
10
11 my($res);
12 my($tab_depth);
13
14 sub tabs()
15 {
16         for (my($i)=0; $i < $tab_depth; $i++) {
17                 $res .= "\t";
18         }
19 }
20
21 #####################################################################
22 # parse a properties list
23 sub HeaderProperties($)
24 {
25     my($props) = shift;
26
27     return;
28
29     foreach my $d (@{$props}) {
30         if (ref($d) ne "HASH") {
31             $res .= "/* [$d] */ ";
32         } else {
33             foreach my $k (keys %{$d}) {
34                 $res .= "/* [$k($d->{$k})] */ ";
35             }
36         }
37     }
38 }
39
40 #####################################################################
41 # parse a structure element
42 sub HeaderElement($)
43 {
44     my($element) = shift;
45
46     (defined $element->{PROPERTIES}) && HeaderProperties($element->{PROPERTIES});
47     $res .= tabs();
48     HeaderType($element, $element->{TYPE}, "");
49     $res .= " ";
50     if ($element->{POINTERS} && 
51         $element->{TYPE} ne "string") {
52             my($n) = $element->{POINTERS};
53             for (my($i)=$n; $i > 0; $i--) {
54                     $res .= "*";
55             }
56     }
57     if (defined $element->{ARRAY_LEN} && 
58         !util::is_constant($element->{ARRAY_LEN}) &&
59         !$element->{POINTERS}) {
60             # conformant arrays are ugly! I choose to implement them with
61             # pointers instead of the [1] method
62             $res .= "*";
63     }
64     $res .= "$element->{NAME}";
65     if (defined $element->{ARRAY_LEN} && util::is_constant($element->{ARRAY_LEN})) {
66             $res .= "[$element->{ARRAY_LEN}]";
67     }
68     $res .= ";\n";
69 }
70
71 #####################################################################
72 # parse a struct
73 sub HeaderStruct($$)
74 {
75     my($struct) = shift;
76     my($name) = shift;
77     $res .= "\nstruct $name {\n";
78     $tab_depth++;
79     my $el_count=0;
80     if (defined $struct->{ELEMENTS}) {
81         foreach my $e (@{$struct->{ELEMENTS}}) {
82             HeaderElement($e);
83             $el_count++;
84         }
85     }
86     if ($el_count == 0) {
87             # some compilers can't handle empty structures
88             $res .= "\tchar _empty_;\n";
89     }
90     $tab_depth--;
91     $res .= "}";
92 }
93
94 #####################################################################
95 # parse a enum
96 sub HeaderEnum($$)
97 {
98     my($enum) = shift;
99     my($name) = shift;
100
101     util::register_enum($name);
102
103     $res .= "\nenum $name {\n";
104     $tab_depth++;
105     my $els = \@{$enum->{ELEMENTS}};
106     foreach my $i (0 .. $#{$els}-1) {
107             my $e = ${$els}[$i];
108             tabs();
109             chomp $e;
110             $res .= "$e,\n";
111     }
112
113     my $e = ${$els}[$#{$els}];
114     tabs();
115     chomp $e;
116     if ($e !~ /^(.*?)\s*$/) {
117             die "Bad enum $name\n";
118     }
119     $res .= "$1\n";
120     $tab_depth--;
121     $res .= "}";
122 }
123
124 #####################################################################
125 # parse a bitmap
126 sub HeaderBitmap($$)
127 {
128     my($bitmap) = shift;
129     my($name) = shift;
130
131     util::register_bitmap($bitmap, $name);
132
133     $res .= "\n/* bitmap $name */\n";
134
135     my $els = \@{$bitmap->{ELEMENTS}};
136     foreach my $i (0 .. $#{$els}) {
137             my $e = ${$els}[$i];
138             chomp $e;
139             $res .= "#define $e\n";
140     }
141
142     $res .= "\n";
143 }
144
145 #####################################################################
146 # parse a union
147 sub HeaderUnion($$)
148 {
149         my($union) = shift;
150         my($name) = shift;
151         my %done = ();
152
153         (defined $union->{PROPERTIES}) && HeaderProperties($union->{PROPERTIES});
154         $res .= "\nunion $name {\n";
155         $tab_depth++;
156         foreach my $e (@{$union->{DATA}}) {
157                 if ($e->{TYPE} eq "UNION_ELEMENT") {
158                         if (! defined $done{$e->{DATA}->{NAME}}) {
159                                 HeaderElement($e->{DATA});
160                         }
161                         $done{$e->{DATA}->{NAME}} = 1;
162                 }
163         }
164         $tab_depth--;
165         $res .= "}";
166 }
167
168 #####################################################################
169 # parse a type
170 sub HeaderType($$$)
171 {
172         my $e = shift;
173         my($data) = shift;
174         my($name) = shift;
175         if (ref($data) eq "HASH") {
176                 ($data->{TYPE} eq "ENUM") &&
177                     HeaderEnum($data, $name);
178                 ($data->{TYPE} eq "BITMAP") &&
179                     HeaderBitmap($data, $name);
180                 ($data->{TYPE} eq "STRUCT") &&
181                     HeaderStruct($data, $name);
182                 ($data->{TYPE} eq "UNION") &&
183                     HeaderUnion($data, $name);
184                 return;
185         }
186         if ($data =~ "string") {
187                 $res .= "const char *";
188         } elsif (util::is_enum($e->{TYPE})) {
189                 $res .= "enum $data";
190         } elsif (util::is_bitmap($e->{TYPE})) {
191                 my $bitmap = util::get_bitmap($e->{TYPE});
192                 $res .= util::bitmap_type_decl($bitmap);
193         } elsif (util::is_scalar_type($data)) {
194                 $res .= "$data";
195         } elsif (util::has_property($e, "switch_is")) {
196                 $res .= "union $data";
197         } else {
198                 $res .= "struct $data";
199         }
200 }
201
202 #####################################################################
203 # parse a typedef
204 sub HeaderTypedef($)
205 {
206     my($typedef) = shift;
207     HeaderType($typedef, $typedef->{DATA}, $typedef->{NAME});
208     $res .= ";\n" unless ($typedef->{DATA}->{TYPE} eq "BITMAP");
209 }
210
211 #####################################################################
212 # prototype a typedef
213 sub HeaderTypedefProto($)
214 {
215     my($d) = shift;
216
217     if (needed::is_needed("ndr_size_$d->{NAME}")) {
218             $res .= "size_t ndr_size_$d->{NAME}(const struct $d->{NAME} *r, int flags);\n";
219     }
220
221     if (!util::has_property($d, "public")) {
222             return;
223     }
224
225     if ($d->{DATA}{TYPE} eq "STRUCT") {
226             $res .= "NTSTATUS ndr_push_$d->{NAME}(struct ndr_push *ndr, int ndr_flags, struct $d->{NAME} *r);\n";
227             $res .= "NTSTATUS ndr_pull_$d->{NAME}(struct ndr_pull *ndr, int ndr_flags, struct $d->{NAME} *r);\n";
228             if (!util::has_property($d, "noprint")) {
229                     $res .= "void ndr_print_$d->{NAME}(struct ndr_print *ndr, const char *name, struct $d->{NAME} *r);\n";
230             }
231
232     }
233     if ($d->{DATA}{TYPE} eq "UNION") {
234             $res .= "NTSTATUS ndr_push_$d->{NAME}(struct ndr_push *ndr, int ndr_flags, int level, union $d->{NAME} *r);\n";
235             $res .= "NTSTATUS ndr_pull_$d->{NAME}(struct ndr_pull *ndr, int ndr_flags, int level, union $d->{NAME} *r);\n";
236             if (!util::has_property($d, "noprint")) {
237                     $res .= "void ndr_print_$d->{NAME}(struct ndr_print *ndr, const char *name, int level, union $d->{NAME} *r);\n";
238             }
239     }
240 }
241
242 #####################################################################
243 # parse a const
244 sub HeaderConst($)
245 {
246     my($const) = shift;
247     if (!defined($const->{ARRAY_LEN})) {
248         $res .= "#define $const->{NAME}\t( $const->{VALUE} )\n";
249     } else {
250         $res .= "#define $const->{NAME}\t $const->{VALUE}\n";
251     }
252 }
253
254 #####################################################################
255 # parse a function
256 sub HeaderFunctionInOut($$)
257 {
258     my($fn) = shift;
259     my($prop) = shift;
260
261     foreach my $e (@{$fn->{DATA}}) {
262             if (util::has_property($e, $prop)) {
263                     HeaderElement($e);
264             }
265     }
266 }
267
268 #####################################################################
269 # determine if we need an "in" or "out" section
270 sub HeaderFunctionInOut_needed($$)
271 {
272     my($fn) = shift;
273     my($prop) = shift;
274
275     if ($prop eq "out" && $fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
276             return 1;
277     }
278
279     foreach my $e (@{$fn->{DATA}}) {
280             if (util::has_property($e, $prop)) {
281                     return 1;
282             }
283     }
284
285     return undef;
286 }
287
288
289 #####################################################################
290 # parse a function
291 sub HeaderFunction($)
292 {
293     my($fn) = shift;
294
295     $res .= "\nstruct $fn->{NAME} {\n";
296     $tab_depth++;
297     my $needed = 0;
298
299     if (HeaderFunctionInOut_needed($fn, "in")) {
300             tabs();
301             $res .= "struct {\n";
302             $tab_depth++;
303             HeaderFunctionInOut($fn, "in");
304             $tab_depth--;
305             tabs();
306             $res .= "} in;\n\n";
307             $needed++;
308     }
309
310     if (HeaderFunctionInOut_needed($fn, "out")) {
311             tabs();
312             $res .= "struct {\n";
313             $tab_depth++;
314             HeaderFunctionInOut($fn, "out");
315             if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
316                     tabs();
317                     $res .= "$fn->{RETURN_TYPE} result;\n";
318             }
319             $tab_depth--;
320             tabs();
321             $res .= "} out;\n\n";
322             $needed++;
323     }
324
325     if (! $needed) {
326             # sigh - some compilers don't like empty structures
327             tabs();
328             $res .= "int _dummy_element;\n";
329     }
330
331     $tab_depth--;
332     $res .= "};\n\n";
333 }
334
335 #####################################################################
336 # output prototypes for a IDL function
337 sub HeaderFnProto($$)
338 {
339         my $interface = shift;
340     my $fn = shift;
341     my $name = $fn->{NAME};
342         
343     $res .= "void ndr_print_$name(struct ndr_print *ndr, const char *name, int flags, struct $name *r);\n";
344
345         if (util::has_property($interface, "object")) {
346                 $res .= "NTSTATUS dcom_$interface->{NAME}_$name (struct dcom_interface_p *d, TALLOC_CTX *mem_ctx, struct $name *r);\n";
347         } else {
348             $res .= "NTSTATUS dcerpc_$name(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r);\n";
349         $res .= "struct rpc_request *dcerpc_$name\_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r);\n";
350         }
351     $res .= "\n";
352 }
353
354
355 #####################################################################
356 # generate vtable structure for DCOM interface
357 sub HeaderVTable($)
358 {
359         my $interface = shift;
360         $res .= "struct dcom_$interface->{NAME}_vtable {\n";
361         if (defined($interface->{BASE})) {
362                 $res .= "\tstruct dcom_$interface->{BASE}\_vtable base;\n";
363         }
364
365         my $data = $interface->{DATA};
366         foreach my $d (@{$data}) {
367                 $res .= "\tNTSTATUS (*$d->{NAME}) (struct dcom_interface_p *d, TALLOC_CTX *mem_ctx, struct $d->{NAME} *r);\n" if ($d->{TYPE} eq "FUNCTION");
368         }
369         $res .= "};\n\n";
370 }
371
372
373 #####################################################################
374 # parse the interface definitions
375 sub HeaderInterface($)
376 {
377     my($interface) = shift;
378     my($data) = $interface->{DATA};
379
380     my $count = 0;
381
382     $res .= "#ifndef _HEADER_NDR_$interface->{NAME}\n";
383     $res .= "#define _HEADER_NDR_$interface->{NAME}\n\n";
384
385     if (defined $interface->{PROPERTIES}->{depends}) {
386             my @d = split / /, $interface->{PROPERTIES}->{depends};
387             foreach my $i (@d) {
388                     $res .= "#include \"librpc/gen_ndr/ndr_$i\.h\"\n";
389             }
390     }
391
392     if (defined $interface->{PROPERTIES}->{uuid}) {
393             my $name = uc $interface->{NAME};
394             $res .= "#define DCERPC_$name\_UUID " . 
395                 util::make_str($interface->{PROPERTIES}->{uuid}) . "\n";
396
397                 if(!defined $interface->{PROPERTIES}->{version}) { $interface->{PROPERTIES}->{version} = "0.0"; }
398             $res .= "#define DCERPC_$name\_VERSION $interface->{PROPERTIES}->{version}\n";
399
400             $res .= "#define DCERPC_$name\_NAME \"$interface->{NAME}\"\n";
401
402                 if(!defined $interface->{PROPERTIES}->{helpstring}) { $interface->{PROPERTIES}->{helpstring} = "NULL"; }
403                 $res .= "#define DCERPC_$name\_HELPSTRING $interface->{PROPERTIES}->{helpstring}\n";
404
405             $res .= "\nextern const struct dcerpc_interface_table dcerpc_table_$interface->{NAME};\n";
406             $res .= "NTSTATUS dcerpc_server_$interface->{NAME}_init(void);\n\n";
407     }
408
409     foreach my $d (@{$data}) {
410             if ($d->{TYPE} eq "FUNCTION") {
411                     my $u_name = uc $d->{NAME};
412                         $res .= "#define DCERPC_$u_name (";
413                 
414                         if (defined($interface->{BASE})) {
415                                 $res .= "DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT + ";
416                         }
417                         
418                     $res .= sprintf("0x%02x", $count) . ")\n";
419                     $count++;
420             }
421     }
422
423         $res .= "\n#define DCERPC_" . uc $interface->{NAME} . "_CALL_COUNT (";
424         
425         if (defined($interface->{BASE})) {
426                 $res .= "DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT + ";
427         }
428         
429         $res .= "$count)\n\n";
430
431     foreach my $d (@{$data}) {
432         ($d->{TYPE} eq "CONST") &&
433             HeaderConst($d);
434         ($d->{TYPE} eq "TYPEDEF") &&
435             HeaderTypedef($d);
436         ($d->{TYPE} eq "TYPEDEF") &&
437             HeaderTypedefProto($d);
438         ($d->{TYPE} eq "FUNCTION") &&
439             HeaderFunction($d);
440         ($d->{TYPE} eq "FUNCTION") &&
441                         HeaderFnProto($interface, $d);
442     }
443         
444         (util::has_property($interface, "object")) &&
445                 HeaderVTable($interface);
446
447     $res .= "#endif /* _HEADER_NDR_$interface->{NAME} */\n";
448 }
449
450 #####################################################################
451 # parse a parsed IDL into a C header
452 sub Parse($)
453 {
454     my($idl) = shift;
455     $tab_depth = 0;
456
457     $res = "/* header auto-generated by pidl */\n\n";
458     foreach my $x (@{$idl}) {
459             if ($x->{TYPE} eq "INTERFACE") {
460                     needed::BuildNeeded($x);
461                     HeaderInterface($x);
462             }
463     }
464     return $res;
465 }
466
467 1;