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