r1606: make the low level socket read/write routines cope properly with non-blocking...
[samba.git] / source / build / pidl / parser.pm
1 ###################################################
2 # Samba4 parser generator for IDL structures
3 # Copyright tridge@samba.org 2000-2003
4 # Copyright tpot@samba.org 2001
5 # released under the GNU GPL
6
7 package IdlParser;
8
9 use strict;
10 use client;
11
12 # the list of needed functions
13 my %needed;
14 my %structs;
15
16 my $if_uuid;
17 my $if_version;
18 my $if_endpoints;
19
20 sub pidl($)
21 {
22         print OUT shift;
23 }
24
25 #####################################################################
26 # parse a properties list
27 sub ParseProperties($)
28 {
29     my($props) = shift;
30     foreach my $d (@{$props}) {
31         if (ref($d) ne "HASH") {
32             pidl "[$d] ";
33         } else {
34             foreach my $k (keys %{$d}) {
35                 pidl "[$k($d->{$k})] ";
36             }
37         }
38     }
39 }
40
41 ###################################
42 # find a sibling var in a structure
43 sub find_sibling($$)
44 {
45         my($e) = shift;
46         my($name) = shift;
47         my($fn) = $e->{PARENT};
48
49         if ($name =~ /\*(.*)/) {
50                 $name = $1;
51         }
52
53         if ($fn->{TYPE} eq "FUNCTION") {
54                 for my $e2 (@{$fn->{DATA}}) {
55                         if ($e2->{NAME} eq $name) {
56                                 return $e2;
57                         }
58                 }
59         }
60
61         for my $e2 (@{$fn->{ELEMENTS}}) {
62                 if ($e2->{NAME} eq $name) {
63                         return $e2;
64                 }
65         }
66         die "invalid sibling '$name'";
67 }
68
69 ####################################################################
70 # work out the name of a size_is() variable
71 sub find_size_var($$$)
72 {
73         my($e) = shift;
74         my($size) = shift;
75         my($var_prefix) = shift;
76
77         my($fn) = $e->{PARENT};
78
79         if (util::is_constant($size)) {
80                 return $size;
81         }
82
83         if ($size =~ /ndr->|\(/) {
84                 return $size;
85         }
86
87         my $prefix = "";
88
89         if ($size =~ /\*(.*)/) {
90                 $size = $1;
91                 $prefix = "*";
92         }
93
94         if ($fn->{TYPE} ne "FUNCTION") {
95                 return $prefix . "r->$size";
96         }
97
98         my $e2 = find_sibling($e, $size);
99
100         if (util::has_property($e2, "in") && util::has_property($e2, "out")) {
101                 return $prefix . "$var_prefix$size";
102         }
103         if (util::has_property($e2, "in")) {
104                 return $prefix . "r->in.$size";
105         }
106         if (util::has_property($e2, "out")) {
107                 return $prefix . "r->out.$size";
108         }
109
110         die "invalid variable in $size for element $e->{NAME} in $fn->{NAME}\n";
111 }
112
113
114 #####################################################################
115 # work out is a parse function should be declared static or not
116 sub fn_prefix($)
117 {
118         my $fn = shift;
119         if ($fn->{TYPE} eq "TYPEDEF") {
120                 if (util::has_property($fn->{DATA}, "public")) {
121                         return "";
122                 }
123         }
124
125         if ($fn->{TYPE} eq "FUNCTION") {
126                 if (util::has_property($fn, "public")) {
127                         return "";
128                 }
129         }
130         return "static ";
131 }
132
133
134 ###################################################################
135 # setup any special flags for an element or structure
136 sub start_flags($)
137 {
138         my $e = shift;
139         my $flags = util::has_property($e, "flag");
140         if (defined $flags) {
141                 pidl "\t{ uint32_t _flags_save_$e->{TYPE} = ndr->flags;\n";
142                 pidl "\tndr->flags |= $flags;\n";
143         }
144 }
145
146 ###################################################################
147 # end any special flags for an element or structure
148 sub end_flags($)
149 {
150         my $e = shift;
151         my $flags = util::has_property($e, "flag");
152         if (defined $flags) {
153                 pidl "\tndr->flags = _flags_save_$e->{TYPE};\n\t}\n";
154         }
155 }
156
157
158 #####################################################################
159 # work out the correct alignment for a structure
160 sub struct_alignment
161 {
162         my $s = shift;
163
164         my $align = 1;
165         for my $e (@{$s->{ELEMENTS}}) {
166                 my $a = 1;
167
168                 if (!util::need_wire_pointer($e)
169                     && defined $structs{$e->{TYPE}}) {
170                         if ($structs{$e->{TYPE}}->{DATA}->{TYPE} eq "STRUCT") {
171                                 $a = struct_alignment($structs{$e->{TYPE}}->{DATA});
172                         } elsif ($structs{$e->{TYPE}}->{DATA}->{TYPE} eq "UNION") {
173                                 if (defined $structs{$e->{TYPE}}->{DATA}) {
174                                         $a = union_alignment($structs{$e->{TYPE}}->{DATA});
175                                 }
176                         }
177                 } else {
178                         $a = util::type_align($e);
179                 }
180
181                 if ($align < $a) {
182                         $align = $a;
183                 }
184         }
185
186         return $align;
187 }
188
189 #####################################################################
190 # work out the correct alignment for a union
191 sub union_alignment
192 {
193         my $u = shift;
194
195         my $align = 1;
196
197         foreach my $e (@{$u->{DATA}}) {
198                 my $a = 1;
199
200                 if ($e->{TYPE} eq "EMPTY") {
201                         next;
202                 }
203
204                 if (!util::need_wire_pointer($e)
205                     && defined $structs{$e->{DATA}->{TYPE}}) {
206                         my $s = $structs{$e->{DATA}->{TYPE}};
207                         if ($s->{DATA}->{TYPE} eq "STRUCT") {
208                                 $a = struct_alignment($s->{DATA});
209                         } elsif ($s->{DATA}->{TYPE} eq "UNION") {
210                                 $a = union_alignment($s->{DATA});
211                         }
212                 } else {
213                         $a = util::type_align($e->{DATA});
214                 }
215
216                 if ($align < $a) {
217                         $align = $a;
218                 }
219         }
220
221         return $align;
222 }
223
224 #####################################################################
225 # parse an array - push side
226 sub ParseArrayPush($$$)
227 {
228         my $e = shift;
229         my $var_prefix = shift;
230         my $ndr_flags = shift;
231
232         my $size = find_size_var($e, util::array_size($e), $var_prefix);
233
234         if (defined $e->{CONFORMANT_SIZE}) {
235                 # the conformant size has already been pushed
236         } elsif (!util::is_inline_array($e)) {
237                 # we need to emit the array size
238                 pidl "\t\tNDR_CHECK(ndr_push_uint32(ndr, $size));\n";
239         }
240
241         if (my $length = util::has_property($e, "length_is")) {
242                 $length = find_size_var($e, $length, $var_prefix);
243                 pidl "\t\tNDR_CHECK(ndr_push_uint32(ndr, 0));\n";
244                 pidl "\t\tNDR_CHECK(ndr_push_uint32(ndr, $length));\n";
245                 $size = $length;
246         }
247
248         if (util::is_scalar_type($e->{TYPE})) {
249                 pidl "\t\tNDR_CHECK(ndr_push_array_$e->{TYPE}(ndr, $ndr_flags, $var_prefix$e->{NAME}, $size));\n";
250         } else {
251                 pidl "\t\tNDR_CHECK(ndr_push_array(ndr, $ndr_flags, $var_prefix$e->{NAME}, sizeof($var_prefix$e->{NAME}\[0]), $size, (ndr_push_flags_fn_t)ndr_push_$e->{TYPE}));\n";
252         }
253 }
254
255 #####################################################################
256 # print an array
257 sub ParseArrayPrint($$)
258 {
259         my $e = shift;
260         my $var_prefix = shift;
261         my $size = find_size_var($e, util::array_size($e), $var_prefix);
262         my $length = util::has_property($e, "length_is");
263
264         if (defined $length) {
265                 $size = find_size_var($e, $length, $var_prefix);
266         }
267
268         if (util::is_scalar_type($e->{TYPE})) {
269                 pidl "\t\tndr_print_array_$e->{TYPE}(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME}, $size);\n";
270         } else {
271                 pidl "\t\tndr_print_array(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME}, sizeof($var_prefix$e->{NAME}\[0]), $size, (ndr_print_fn_t)ndr_print_$e->{TYPE});\n";
272         }
273 }
274
275 #####################################################################
276 # parse an array - pull side
277 sub ParseArrayPull($$$)
278 {
279         my $e = shift;
280         my $var_prefix = shift;
281         my $ndr_flags = shift;
282
283         my $size = find_size_var($e, util::array_size($e), $var_prefix);
284         my $alloc_size = $size;
285
286         # if this is a conformant array then we use that size to allocate, and make sure
287         # we allocate enough to pull the elements
288         if (defined $e->{CONFORMANT_SIZE}) {
289                 $alloc_size = $e->{CONFORMANT_SIZE};
290
291                 pidl "\tif ($size > $alloc_size) {\n";
292                 pidl "\t\treturn ndr_pull_error(ndr, NDR_ERR_CONFORMANT_SIZE, \"Bad conformant size %u should be %u\", $alloc_size, $size);\n";
293                 pidl "\t}\n";
294         } elsif (!util::is_inline_array($e)) {
295                 if ($var_prefix =~ /^r->out/ && $size =~ /^\*r->in/) {
296                         my $size2 = substr($size, 1);
297                         pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { NDR_ALLOC(ndr, $size2); }\n";
298                 }
299
300                 # non fixed arrays encode the size just before the array
301                 pidl "\t{\n";
302                 pidl "\t\tuint32_t _array_size;\n";
303                 pidl "\t\tNDR_CHECK(ndr_pull_uint32(ndr, &_array_size));\n";
304                 if ($size =~ /r->in/) {
305                         pidl "\t\tif (!(ndr->flags & LIBNDR_FLAG_REF_ALLOC) && _array_size != $size) {\n";
306                 } else {
307                         pidl "\t\tif ($size != _array_size) {\n";
308                 }
309                 pidl "\t\t\treturn ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, \"Bad array size %u should be %u\", _array_size, $size);\n";
310                 pidl "\t\t}\n";
311                 if ($size =~ /r->in/) {
312                         pidl "else { $size = _array_size; }\n";
313                 }
314                 pidl "\t}\n";
315         }
316
317         if ((util::need_alloc($e) && !util::is_fixed_array($e)) ||
318             ($var_prefix eq "r->in." && util::has_property($e, "ref"))) {
319                 if (!util::is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") {
320                         pidl "\t\tNDR_ALLOC_N(ndr, $var_prefix$e->{NAME}, MAX(1, $alloc_size));\n";
321                 }
322         }
323
324         if (($var_prefix eq "r->out." && util::has_property($e, "ref"))) {
325                 if (!util::is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") {
326                         pidl "\tif (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {";
327                         pidl "\t\tNDR_ALLOC_N(ndr, $var_prefix$e->{NAME}, MAX(1, $alloc_size));\n";
328                         pidl "\t}\n";
329                 }
330         }
331
332         pidl "\t{\n";
333
334         if (my $length = util::has_property($e, "length_is")) {
335                 $length = find_size_var($e, $length, $var_prefix);
336                 pidl "\t\tuint32_t _offset, _length;\n";
337                 pidl "\t\tNDR_CHECK(ndr_pull_uint32(ndr, &_offset));\n";
338                 pidl "\t\tNDR_CHECK(ndr_pull_uint32(ndr, &_length));\n";
339                 pidl "\t\tif (_offset != 0) return ndr_pull_error(ndr, NDR_ERR_OFFSET, \"Bad array offset 0x%08x\", _offset);\n";
340                 pidl "\t\tif (_length > $size || _length != $length) return ndr_pull_error(ndr, NDR_ERR_LENGTH, \"Bad array length 0x%08x > size 0x%08x\", _offset, $size);\n\n";
341                 $size = "_length";
342         }
343
344         if (util::is_scalar_type($e->{TYPE})) {
345                 pidl "\t\tNDR_CHECK(ndr_pull_array_$e->{TYPE}(ndr, $ndr_flags, $var_prefix$e->{NAME}, $size));\n";
346         } else {
347                 pidl "\t\tNDR_CHECK(ndr_pull_array(ndr, $ndr_flags, (void **)$var_prefix$e->{NAME}, sizeof($var_prefix$e->{NAME}\[0]), $size, (ndr_pull_flags_fn_t)ndr_pull_$e->{TYPE}));\n";
348         }
349
350         pidl "\t}\n";
351 }
352
353
354 #####################################################################
355 # parse scalars in a structure element
356 sub ParseElementPushScalar($$$)
357 {
358         my($e) = shift;
359         my($var_prefix) = shift;
360         my($ndr_flags) = shift;
361         my $cprefix = util::c_push_prefix($e);
362         my $sub_size = util::has_property($e, "subcontext");
363
364         start_flags($e);
365
366         if (my $value = util::has_property($e, "value")) {
367                 pidl "\t$cprefix$var_prefix$e->{NAME} = $value;\n";
368         }
369
370         if (util::has_property($e, "relative")) {
371                 pidl "\tNDR_CHECK(ndr_push_relative(ndr, NDR_SCALARS, $var_prefix$e->{NAME}, (ndr_push_const_fn_t) ndr_push_$e->{TYPE}));\n";
372         } elsif (util::is_inline_array($e)) {
373                 ParseArrayPush($e, "r->", "NDR_SCALARS");
374         } elsif (util::need_wire_pointer($e)) {
375                 pidl "\tNDR_CHECK(ndr_push_ptr(ndr, $var_prefix$e->{NAME}));\n";
376         } elsif (util::need_alloc($e)) {
377                 # no scalar component
378         } elsif (my $switch = util::has_property($e, "switch_is")) {
379                 ParseElementPushSwitch($e, $var_prefix, $ndr_flags, $switch);
380         } elsif (defined $sub_size) {
381                 if (util::is_builtin_type($e->{TYPE})) {
382                         pidl "\tNDR_CHECK(ndr_push_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_push_fn_t) ndr_push_$e->{TYPE}));\n";
383                 } else {
384                         pidl "\tNDR_CHECK(ndr_push_subcontext_flags_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_push_flags_fn_t) ndr_push_$e->{TYPE}));\n";
385                 }
386         } elsif (util::is_builtin_type($e->{TYPE})) {
387                 pidl "\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
388         } else {
389                 pidl "\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
390         }
391
392         end_flags($e);
393 }
394
395 #####################################################################
396 # print scalars in a structure element
397 sub ParseElementPrintScalar($$)
398 {
399         my($e) = shift;
400         my($var_prefix) = shift;
401         my $cprefix = util::c_push_prefix($e);
402
403         if (util::has_property($e, "noprint")) {
404                 return;
405         }
406
407         if (my $value = util::has_property($e, "value")) {
408                 pidl "\tif (ndr->flags & LIBNDR_PRINT_SET_VALUES) {\n";
409                 pidl "\t\t$cprefix$var_prefix$e->{NAME} = $value;\n";
410                 pidl "\t}\n";
411         }
412
413         if (util::is_fixed_array($e)) {
414                 ParseElementPrintBuffer($e, $var_prefix);
415         } elsif (util::has_direct_buffers($e)) {
416                 pidl "\tndr_print_ptr(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME});\n";
417                 pidl "\tndr->depth++;\n";
418                 ParseElementPrintBuffer($e, $var_prefix);
419                 pidl "\tndr->depth--;\n";
420         } elsif (my $switch = util::has_property($e, "switch_is")) {
421                 ParseElementPrintSwitch($e, $var_prefix, $switch);
422         } else {
423                 pidl "\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME});\n";
424         }
425 }
426
427 #####################################################################
428 # parse scalars in a structure element - pull size
429 sub ParseElementPullSwitch($$$$)
430 {
431         my($e) = shift;
432         my($var_prefix) = shift;
433         my($ndr_flags) = shift;
434         my $switch = shift;
435         my $switch_var = find_size_var($e, $switch, $var_prefix);
436
437         my $cprefix = util::c_pull_prefix($e);
438
439         my $utype = $structs{$e->{TYPE}};
440         if (!defined $utype ||
441             !util::has_property($utype->{DATA}, "nodiscriminant")) {
442                 my $e2 = find_sibling($e, $switch);
443                 pidl "\tif (($ndr_flags) & NDR_SCALARS) {\n";
444                 pidl "\t\t $e2->{TYPE} _level;\n";
445                 pidl "\t\tNDR_CHECK(ndr_pull_$e2->{TYPE}(ndr, &_level));\n";
446                 if ($switch_var =~ /r->in/) {
447                         pidl "\t\tif (!(ndr->flags & LIBNDR_FLAG_REF_ALLOC) && _level != $switch_var) {\n";
448                 } else {
449                         pidl "\t\tif (_level != $switch_var) {\n";
450                 }
451                 pidl "\t\t\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u in $e->{NAME}\", _level);\t\t}\n";
452                 if ($switch_var =~ /r->/) {
453                         pidl "else { $switch_var = _level; }\n";
454                 }
455                 pidl "\t}\n";
456         }
457
458         my $sub_size = util::has_property($e, "subcontext");
459         if (defined $sub_size) {
460                 pidl "\tNDR_CHECK(ndr_pull_subcontext_union_fn(ndr, $sub_size, $switch_var, $cprefix$var_prefix$e->{NAME}, (ndr_pull_union_fn_t) ndr_pull_$e->{TYPE}));\n";
461         } else {
462                 pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $switch_var, $cprefix$var_prefix$e->{NAME}));\n";
463         }
464
465
466 }
467
468 #####################################################################
469 # push switch element
470 sub ParseElementPushSwitch($$$$)
471 {
472         my($e) = shift;
473         my($var_prefix) = shift;
474         my($ndr_flags) = shift;
475         my $switch = shift;
476         my $switch_var = find_size_var($e, $switch, $var_prefix);
477         my $cprefix = util::c_push_prefix($e);
478
479         my $utype = $structs{$e->{TYPE}};
480         if (!defined $utype ||
481             !util::has_property($utype->{DATA}, "nodiscriminant")) {
482                 my $e2 = find_sibling($e, $switch);
483                 pidl "\tif (($ndr_flags) & NDR_SCALARS) {\n";
484                 pidl "\t\tNDR_CHECK(ndr_push_$e2->{TYPE}(ndr, $switch_var));\n";
485                 pidl "\t}\n";
486         }
487
488         my $sub_size = util::has_property($e, "subcontext");
489         if (defined $sub_size) {
490                 pidl "\tNDR_CHECK(ndr_push_subcontext_union_fn(ndr, $sub_size, $switch_var, $cprefix$var_prefix$e->{NAME}, (ndr_push_union_fn_t) ndr_push_$e->{TYPE}));\n";
491         } else {
492                 pidl "\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $switch_var, $cprefix$var_prefix$e->{NAME}));\n";
493         }
494 }
495
496 #####################################################################
497 # print scalars in a structure element 
498 sub ParseElementPrintSwitch($$$)
499 {
500         my($e) = shift;
501         my($var_prefix) = shift;
502         my $switch = shift;
503         my $switch_var = find_size_var($e, $switch, $var_prefix);
504         my $cprefix = util::c_push_prefix($e);
505
506         pidl "\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $switch_var, $cprefix$var_prefix$e->{NAME});\n";
507 }
508
509
510 #####################################################################
511 # parse scalars in a structure element - pull size
512 sub ParseElementPullScalar($$$)
513 {
514         my($e) = shift;
515         my($var_prefix) = shift;
516         my($ndr_flags) = shift;
517         my $cprefix = util::c_pull_prefix($e);
518         my $sub_size = util::has_property($e, "subcontext");
519
520         start_flags($e);
521
522         if (util::has_property($e, "relative")) {
523                 pidl "\tNDR_CHECK(ndr_pull_relative(ndr, (const void **)&$var_prefix$e->{NAME}, sizeof(*$var_prefix$e->{NAME}), (ndr_pull_flags_fn_t)ndr_pull_$e->{TYPE}));\n";
524         } elsif (util::is_inline_array($e)) {
525                 ParseArrayPull($e, "r->", "NDR_SCALARS");
526         } elsif (util::need_wire_pointer($e)) {
527                 pidl "\tNDR_CHECK(ndr_pull_ptr(ndr, &_ptr_$e->{NAME}));\n";
528                 pidl "\tif (_ptr_$e->{NAME}) {\n";
529                 pidl "\t\tNDR_ALLOC(ndr, $var_prefix$e->{NAME});\n";
530                 pidl "\t} else {\n";
531                 pidl "\t\t$var_prefix$e->{NAME} = NULL;\n";
532                 pidl "\t}\n";
533         } elsif (util::need_alloc($e)) {
534                 # no scalar component
535         } elsif (my $switch = util::has_property($e, "switch_is")) {
536                 ParseElementPullSwitch($e, $var_prefix, $ndr_flags, $switch);
537         } elsif (defined $sub_size) {
538                 if (util::is_builtin_type($e->{TYPE})) {
539                         pidl "\tNDR_CHECK(ndr_pull_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_fn_t) ndr_pull_$e->{TYPE}));\n";
540                 } else {
541                         pidl "\tNDR_CHECK(ndr_pull_subcontext_flags_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_flags_fn_t) ndr_pull_$e->{TYPE}));\n";
542                 }
543         } elsif (util::is_builtin_type($e->{TYPE})) {
544                 pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
545         } else {
546                 pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
547         }
548
549         end_flags($e);
550 }
551
552 #####################################################################
553 # parse buffers in a structure element
554 sub ParseElementPushBuffer($$$)
555 {
556         my($e) = shift;
557         my($var_prefix) = shift;
558         my($ndr_flags) = shift;
559         my $cprefix = util::c_push_prefix($e);
560         my $sub_size = util::has_property($e, "subcontext");
561
562         if (util::is_pure_scalar($e)) {
563                 return;
564         }
565
566         start_flags($e);
567
568         if (util::need_wire_pointer($e)) {
569                 pidl "\tif ($var_prefix$e->{NAME}) {\n";
570         }
571             
572         if (util::has_property($e, "relative")) {
573                 pidl "\tNDR_CHECK(ndr_push_relative(ndr, NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}, (ndr_push_const_fn_t) ndr_push_$e->{TYPE}));\n";
574         } elsif (util::is_inline_array($e)) {
575                 ParseArrayPush($e, "r->", "NDR_BUFFERS");
576         } elsif (util::array_size($e)) {
577                 ParseArrayPush($e, "r->", "NDR_SCALARS|NDR_BUFFERS");
578         } elsif (my $switch = util::has_property($e, "switch_is")) {
579                 if ($e->{POINTERS}) {
580                         ParseElementPushSwitch($e, $var_prefix, "NDR_BUFFERS|NDR_SCALARS", $switch);
581                 } else {
582                         ParseElementPushSwitch($e, $var_prefix, "NDR_BUFFERS", $switch);
583                 }
584         } elsif (defined $sub_size) {
585                 if ($e->{POINTERS}) {
586                         if (util::is_builtin_type($e->{TYPE})) {
587                                 pidl "\tNDR_CHECK(ndr_push_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_push_fn_t) ndr_push_$e->{TYPE}));\n";
588                         } else {
589                                 pidl "\tNDR_CHECK(ndr_push_subcontext_flags_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_push_flags_fn_t) ndr_push_$e->{TYPE}));\n";
590                         }
591                 }
592         } elsif (util::is_builtin_type($e->{TYPE})) {
593                 pidl "\t\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
594         } elsif ($e->{POINTERS}) {
595                 pidl "\t\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, NDR_SCALARS|NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}));\n";
596         } else {
597                 pidl "\t\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
598         }
599
600         if (util::need_wire_pointer($e)) {
601                 pidl "\t}\n";
602         }       
603
604         end_flags($e);
605 }
606
607 #####################################################################
608 # print buffers in a structure element
609 sub ParseElementPrintBuffer($$)
610 {
611         my($e) = shift;
612         my($var_prefix) = shift;
613         my $cprefix = util::c_push_prefix($e);
614
615         if (util::need_wire_pointer($e)) {
616                 pidl "\tif ($var_prefix$e->{NAME}) {\n";
617         }
618             
619         if (util::array_size($e)) {
620                 ParseArrayPrint($e, $var_prefix);
621         } elsif (my $switch = util::has_property($e, "switch_is")) {
622                 ParseElementPrintSwitch($e, $var_prefix, $switch);
623         } else {
624                 pidl "\t\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME});\n";
625         }
626
627         if (util::need_wire_pointer($e)) {
628                 pidl "\t}\n";
629         }       
630 }
631
632
633 #####################################################################
634 # parse buffers in a structure element - pull side
635 sub ParseElementPullBuffer($$$)
636 {
637         my($e) = shift;
638         my($var_prefix) = shift;
639         my($ndr_flags) = shift;
640         my $cprefix = util::c_pull_prefix($e);
641         my $sub_size = util::has_property($e, "subcontext");
642
643         if (util::is_pure_scalar($e)) {
644                 return;
645         }
646
647         if (util::has_property($e, "relative")) {
648                 return;
649         }
650
651         start_flags($e);
652
653         if (util::need_wire_pointer($e)) {
654                 pidl "\tif ($var_prefix$e->{NAME}) {\n";
655         }
656             
657         if (util::is_inline_array($e)) {
658                 ParseArrayPull($e, "r->", "NDR_BUFFERS");
659         } elsif (util::array_size($e)) {
660                 ParseArrayPull($e, "r->", "NDR_SCALARS|NDR_BUFFERS");
661         } elsif (my $switch = util::has_property($e, "switch_is")) {
662                 if ($e->{POINTERS}) {
663                         ParseElementPullSwitch($e, $var_prefix, "NDR_SCALARS|NDR_BUFFERS", $switch);
664                 } else {
665                         ParseElementPullSwitch($e, $var_prefix, "NDR_BUFFERS", $switch);
666                 }
667         } elsif (defined $sub_size) {
668                 if ($e->{POINTERS}) {
669                         if (util::is_builtin_type($e->{TYPE})) {
670                                 pidl "\tNDR_CHECK(ndr_pull_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_fn_t) ndr_pull_$e->{TYPE}));\n";
671                         } else {
672                                 pidl "\tNDR_CHECK(ndr_pull_subcontext_flags_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_flags_fn_t) ndr_pull_$e->{TYPE}));\n";
673                         }
674                 }
675         } elsif (util::is_builtin_type($e->{TYPE})) {
676                 pidl "\t\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
677         } elsif ($e->{POINTERS}) {
678                 pidl "\t\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, NDR_SCALARS|NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}));\n";
679         } else {
680                 pidl "\t\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
681         }
682
683         if (util::need_wire_pointer($e)) {
684                 pidl "\t}\n";
685         }       
686
687         end_flags($e);
688 }
689
690 #####################################################################
691 # parse a struct
692 sub ParseStructPush($)
693 {
694         my($struct) = shift;
695         my $conform_e;
696         
697         if (! defined $struct->{ELEMENTS}) {
698                 return;
699         }
700
701         start_flags($struct);
702
703         # see if the structure contains a conformant array. If it
704         # does, then it must be the last element of the structure, and
705         # we need to push the conformant length early, as it fits on
706         # the wire before the structure (and even before the structure
707         # alignment)
708         my $e = $struct->{ELEMENTS}[-1];
709         if (defined $e->{ARRAY_LEN} && $e->{ARRAY_LEN} eq "*") {
710                 my $size = find_size_var($e, util::array_size($e), "r->");
711                 $e->{CONFORMANT_SIZE} = $size;
712                 $conform_e = $e;
713                 pidl "\tNDR_CHECK(ndr_push_uint32(ndr, $size));\n";
714         }
715
716         pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
717
718         pidl "\tNDR_CHECK(ndr_push_struct_start(ndr));\n";
719
720         my $align = struct_alignment($struct);
721         pidl "\tNDR_CHECK(ndr_push_align(ndr, $align));\n";
722
723         foreach my $e (@{$struct->{ELEMENTS}}) {
724                 ParseElementPushScalar($e, "r->", "NDR_SCALARS");
725         }       
726
727         pidl "buffers:\n";
728         pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
729         foreach my $e (@{$struct->{ELEMENTS}}) {
730                 ParseElementPushBuffer($e, "r->", "NDR_BUFFERS");
731         }
732
733         pidl "\tndr_push_struct_end(ndr);\n";
734
735         pidl "done:\n";
736
737         end_flags($struct);
738 }
739
740 #####################################################################
741 # generate a struct print function
742 sub ParseStructPrint($)
743 {
744         my($struct) = shift;
745
746         if (! defined $struct->{ELEMENTS}) {
747                 return;
748         }
749
750         start_flags($struct);
751
752         pidl "\tndr->depth++;\n";
753         foreach my $e (@{$struct->{ELEMENTS}}) {
754                 ParseElementPrintScalar($e, "r->");
755         }
756         pidl "\tndr->depth--;\n";
757
758         end_flags($struct);
759 }
760
761 #####################################################################
762 # parse a struct - pull side
763 sub ParseStructPull($)
764 {
765         my($struct) = shift;
766         my $conform_e;
767
768         if (! defined $struct->{ELEMENTS}) {
769                 return;
770         }
771
772         # see if the structure contains a conformant array. If it
773         # does, then it must be the last element of the structure, and
774         # we need to pull the conformant length early, as it fits on
775         # the wire before the structure (and even before the structure
776         # alignment)
777         my $e = $struct->{ELEMENTS}[-1];
778         if (defined $e->{ARRAY_LEN} && $e->{ARRAY_LEN} eq "*") {
779                 $conform_e = $e;
780                 pidl "\tuint32_t _conformant_size;\n";
781                 $conform_e->{CONFORMANT_SIZE} = "_conformant_size";
782         }
783
784         # declare any internal pointers we need
785         foreach my $e (@{$struct->{ELEMENTS}}) {
786                 if (util::need_wire_pointer($e) &&
787                     !util::has_property($e, "relative")) {
788                         pidl "\tuint32_t _ptr_$e->{NAME};\n";
789                 }
790         }
791
792         start_flags($struct);
793
794         pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
795
796         pidl "\tNDR_CHECK(ndr_pull_struct_start(ndr));\n";
797
798         if (defined $conform_e) {
799                 pidl "\tNDR_CHECK(ndr_pull_uint32(ndr, &$conform_e->{CONFORMANT_SIZE}));\n";
800         }
801
802         my $align = struct_alignment($struct);
803         pidl "\tNDR_CHECK(ndr_pull_align(ndr, $align));\n";
804
805         foreach my $e (@{$struct->{ELEMENTS}}) {
806                 ParseElementPullScalar($e, "r->", "NDR_SCALARS");
807         }       
808
809         pidl "buffers:\n";
810         pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
811         foreach my $e (@{$struct->{ELEMENTS}}) {
812                 ParseElementPullBuffer($e, "r->", "NDR_BUFFERS");
813         }
814
815         pidl "\tndr_pull_struct_end(ndr);\n";
816
817         pidl "done:\n";
818
819         end_flags($struct);
820 }
821
822
823 #####################################################################
824 # parse a union - push side
825 sub ParseUnionPush($)
826 {
827         my $e = shift;
828         my $have_default = 0;
829
830         start_flags($e);
831
832         pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
833
834         pidl "\tNDR_CHECK(ndr_push_struct_start(ndr));\n";
835
836 #       my $align = union_alignment($e);
837 #       pidl "\tNDR_CHECK(ndr_push_align(ndr, $align));\n";
838
839         pidl "\tswitch (level) {\n";
840         foreach my $el (@{$e->{DATA}}) {
841                 if ($el->{CASE} eq "default") {
842                         pidl "\tdefault:\n";
843                         $have_default = 1;
844                 } else {
845                         pidl "\tcase $el->{CASE}:\n";
846                 }
847                 if ($el->{TYPE} eq "UNION_ELEMENT") {
848                         ParseElementPushScalar($el->{DATA}, "r->", "NDR_SCALARS");
849                 }
850                 pidl "\tbreak;\n\n";
851         }
852         if (! $have_default) {
853                 pidl "\tdefault:\n";
854                 pidl "\t\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
855         }
856         pidl "\t}\n";
857         pidl "buffers:\n";
858         pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
859         pidl "\tswitch (level) {\n";
860         foreach my $el (@{$e->{DATA}}) {
861                 if ($el->{CASE} eq "default") {
862                         pidl "\tdefault:\n";
863                 } else {
864                         pidl "\tcase $el->{CASE}:\n";
865                 }
866                 if ($el->{TYPE} eq "UNION_ELEMENT") {
867                         ParseElementPushBuffer($el->{DATA}, "r->", "NDR_BUFFERS");
868                 }
869                 pidl "\tbreak;\n\n";
870         }
871         if (! $have_default) {
872                 pidl "\tdefault:\n";
873                 pidl "\t\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
874         }
875         pidl "\t}\n";
876         pidl "\tndr_push_struct_end(ndr);\n";
877         pidl "done:\n";
878         end_flags($e);
879 }
880
881 #####################################################################
882 # print a union
883 sub ParseUnionPrint($)
884 {
885         my $e = shift;
886         my $have_default = 0;
887
888         start_flags($e);
889
890         pidl "\tswitch (level) {\n";
891         foreach my $el (@{$e->{DATA}}) {
892                 if ($el->{CASE} eq "default") {
893                         $have_default = 1;
894                         pidl "\tdefault:\n";
895                 } else {
896                         pidl "\tcase $el->{CASE}:\n";
897                 }
898                 if ($el->{TYPE} eq "UNION_ELEMENT") {
899                         ParseElementPrintScalar($el->{DATA}, "r->");
900                 }
901                 pidl "\tbreak;\n\n";
902         }
903         if (! $have_default) {
904                 pidl "\tdefault:\n\t\tndr_print_bad_level(ndr, name, level);\n";
905         }
906         pidl "\t}\n";
907
908         end_flags($e);
909 }
910
911 #####################################################################
912 # parse a union - pull side
913 sub ParseUnionPull($)
914 {
915         my $e = shift;
916         my $have_default = 0;
917
918         start_flags($e);
919
920         pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
921
922         pidl "\tNDR_CHECK(ndr_pull_struct_start(ndr));\n";
923
924 #       my $align = union_alignment($e);
925 #       pidl "\tNDR_CHECK(ndr_pull_align(ndr, $align));\n";
926
927         pidl "\tswitch (level) {\n";
928         foreach my $el (@{$e->{DATA}}) {
929                 if ($el->{CASE} eq "default") {
930                         pidl "\tdefault: {\n";
931                         $have_default = 1;
932                 } else {
933                         pidl "\tcase $el->{CASE}: {\n";
934                 }
935                 if ($el->{TYPE} eq "UNION_ELEMENT") {
936                         my $e2 = $el->{DATA};
937                         if ($e2->{POINTERS}) {
938                                 pidl "\t\tuint32_t _ptr_$e2->{NAME};\n";
939                         }
940                         ParseElementPullScalar($el->{DATA}, "r->", "NDR_SCALARS");
941                 }
942                 pidl "\tbreak; }\n\n";
943         }
944         if (! $have_default) {
945                 pidl "\tdefault:\n";
946                 pidl "\t\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
947         }
948         pidl "\t}\n";
949         pidl "buffers:\n";
950         pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
951         pidl "\tswitch (level) {\n";
952         foreach my $el (@{$e->{DATA}}) {
953                 if ($el->{CASE} eq "default") {
954                         pidl "\tdefault:\n";
955                 } else {
956                         pidl "\tcase $el->{CASE}:\n";
957                 }
958                 if ($el->{TYPE} eq "UNION_ELEMENT") {
959                         ParseElementPullBuffer($el->{DATA}, "r->", "NDR_BUFFERS");
960                 }
961                 pidl "\tbreak;\n\n";
962         }
963         if (! $have_default) {
964                 pidl "\tdefault:\n";
965                 pidl "\t\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
966         }
967         pidl "\t}\n";
968         pidl "\tndr_pull_struct_end(ndr);\n";
969         pidl "done:\n";
970         end_flags($e);
971 }
972
973 #####################################################################
974 # parse a type
975 sub ParseTypePush($)
976 {
977         my($data) = shift;
978
979         if (ref($data) eq "HASH") {
980                 ($data->{TYPE} eq "STRUCT") &&
981                     ParseStructPush($data);
982                 ($data->{TYPE} eq "UNION") &&
983                     ParseUnionPush($data);
984         }
985 }
986
987 #####################################################################
988 # generate a print function for a type
989 sub ParseTypePrint($)
990 {
991         my($data) = shift;
992
993         if (ref($data) eq "HASH") {
994                 ($data->{TYPE} eq "STRUCT") &&
995                     ParseStructPrint($data);
996                 ($data->{TYPE} eq "UNION") &&
997                     ParseUnionPrint($data);
998         }
999 }
1000
1001 #####################################################################
1002 # parse a type
1003 sub ParseTypePull($)
1004 {
1005         my($data) = shift;
1006
1007         if (ref($data) eq "HASH") {
1008                 ($data->{TYPE} eq "STRUCT") &&
1009                     ParseStructPull($data);
1010                 ($data->{TYPE} eq "UNION") &&
1011                     ParseUnionPull($data);
1012         }
1013 }
1014
1015 #####################################################################
1016 # parse a typedef - push side
1017 sub ParseTypedefPush($)
1018 {
1019         my($e) = shift;
1020         my $static = fn_prefix($e);
1021
1022         if (! $needed{"push_$e->{NAME}"}) {
1023 #               print "push_$e->{NAME} not needed\n";
1024                 return;
1025         }
1026
1027         if ($e->{DATA}->{TYPE} eq "STRUCT") {
1028                 pidl $static . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, struct $e->{NAME} *r)";
1029                 pidl "\n{\n";
1030                 ParseTypePush($e->{DATA});
1031                 pidl "\treturn NT_STATUS_OK;\n";
1032                 pidl "}\n\n";
1033         }
1034
1035         if ($e->{DATA}->{TYPE} eq "UNION") {
1036                 pidl $static . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, uint16_t level, union $e->{NAME} *r)";
1037                 pidl "\n{\n";
1038                 ParseTypePush($e->{DATA});
1039                 pidl "\treturn NT_STATUS_OK;\n";
1040                 pidl "}\n\n";
1041         }
1042 }
1043
1044
1045 #####################################################################
1046 # parse a typedef - pull side
1047 sub ParseTypedefPull($)
1048 {
1049         my($e) = shift;
1050         my $static = fn_prefix($e);
1051
1052         if (! $needed{"pull_$e->{NAME}"}) {
1053 #               print "pull_$e->{NAME} not needed\n";
1054                 return;
1055         }
1056
1057         if ($e->{DATA}->{TYPE} eq "STRUCT") {
1058                 pidl $static . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, struct $e->{NAME} *r)";
1059                 pidl "\n{\n";
1060                 ParseTypePull($e->{DATA});
1061                 pidl "\treturn NT_STATUS_OK;\n";
1062                 pidl "}\n\n";
1063         }
1064
1065         if ($e->{DATA}->{TYPE} eq "UNION") {
1066                 pidl $static . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, uint16_t level, union $e->{NAME} *r)";
1067                 pidl "\n{\n";
1068                 ParseTypePull($e->{DATA});
1069                 pidl "\treturn NT_STATUS_OK;\n";
1070                 pidl "}\n\n";
1071         }
1072 }
1073
1074
1075 #####################################################################
1076 # parse a typedef - print side
1077 sub ParseTypedefPrint($)
1078 {
1079         my($e) = shift;
1080
1081         if ($e->{DATA}->{TYPE} eq "STRUCT") {
1082                 pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, struct $e->{NAME} *r)";
1083                 pidl "\n{\n";
1084                 pidl "\tndr_print_struct(ndr, name, \"$e->{NAME}\");\n";
1085                 ParseTypePrint($e->{DATA});
1086                 pidl "}\n\n";
1087         }
1088
1089         if ($e->{DATA}->{TYPE} eq "UNION") {
1090                 pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, uint16_t level, union $e->{NAME} *r)";
1091                 pidl "\n{\n";
1092                 pidl "\tndr_print_union(ndr, name, level, \"$e->{NAME}\");\n";
1093                 ParseTypePrint($e->{DATA});
1094                 pidl "}\n\n";
1095         }
1096 }
1097
1098 #####################################################################
1099 # parse a function - print side
1100 sub ParseFunctionPrint($)
1101 {
1102         my($fn) = shift;
1103
1104         pidl "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, struct $fn->{NAME} *r)";
1105         pidl "\n{\n";
1106         pidl "\tndr_print_struct(ndr, name, \"$fn->{NAME}\");\n";
1107         pidl "\tndr->depth++;\n";
1108
1109         pidl "\tif (flags & NDR_SET_VALUES) {\n";
1110         pidl "\t\tndr->flags |= LIBNDR_PRINT_SET_VALUES;\n";
1111         pidl "\t}\n";
1112
1113         pidl "\tif (flags & NDR_IN) {\n";
1114         pidl "\t\tndr_print_struct(ndr, \"in\", \"$fn->{NAME}\");\n";
1115         pidl "\tndr->depth++;\n";
1116         foreach my $e (@{$fn->{DATA}}) {
1117                 if (util::has_property($e, "in")) {
1118                         ParseElementPrintScalar($e, "r->in.");
1119                 }
1120         }
1121         pidl "\tndr->depth--;\n";
1122         pidl "\t}\n";
1123         
1124         pidl "\tif (flags & NDR_OUT) {\n";
1125         pidl "\t\tndr_print_struct(ndr, \"out\", \"$fn->{NAME}\");\n";
1126         pidl "\tndr->depth++;\n";
1127         foreach my $e (@{$fn->{DATA}}) {
1128                 if (util::has_property($e, "out")) {
1129                         ParseElementPrintScalar($e, "r->out.");
1130                 }
1131         }
1132         if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1133                 if (util::is_scalar_type($fn->{RETURN_TYPE})) {
1134                         pidl "\tndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", r->out.result);\n";
1135                 } else {
1136                         pidl "\tndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", &r->out.result);\n";
1137                 }
1138         }
1139         pidl "\tndr->depth--;\n";
1140         pidl "\t}\n";
1141         
1142         pidl "\tndr->depth--;\n";
1143         pidl "}\n\n";
1144 }
1145
1146
1147 #####################################################################
1148 # parse a function element
1149 sub ParseFunctionElementPush($$)
1150
1151         my $e = shift;
1152         my $inout = shift;
1153
1154         if (util::array_size($e)) {
1155                 if (util::need_wire_pointer($e)) {
1156                         pidl "\tNDR_CHECK(ndr_push_ptr(ndr, r->$inout.$e->{NAME}));\n";
1157                         pidl "\tif (r->$inout.$e->{NAME}) {\n";
1158                         ParseArrayPush($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1159                         pidl "\t}\n";
1160                 } else {
1161                         ParseArrayPush($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1162                 }
1163         } else {
1164                 ParseElementPushScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1165                 if ($e->{POINTERS}) {
1166                         ParseElementPushBuffer($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1167                 }
1168         }
1169 }       
1170
1171 #####################################################################
1172 # parse a function
1173 sub ParseFunctionPush($)
1174
1175         my($fn) = shift;
1176         my $static = fn_prefix($fn);
1177
1178         pidl $static . "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, struct $fn->{NAME} *r)\n{\n";
1179
1180         pidl "\n\tif (!(flags & NDR_IN)) goto ndr_out;\n\n";
1181         foreach my $e (@{$fn->{DATA}}) {
1182                 if (util::has_property($e, "in")) {
1183                         ParseFunctionElementPush($e, "in");
1184                 }               
1185         }
1186
1187         pidl "\nndr_out:\n";
1188         pidl "\tif (!(flags & NDR_OUT)) goto done;\n\n";
1189         foreach my $e (@{$fn->{DATA}}) {
1190                 if (util::has_property($e, "out")) {
1191                         ParseFunctionElementPush($e, "out");
1192                 }               
1193         }
1194
1195         if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1196                 pidl "\tNDR_CHECK(ndr_push_$fn->{RETURN_TYPE}(ndr, r->out.result));\n";
1197         }
1198     
1199         pidl "\ndone:\n";
1200         pidl "\n\treturn NT_STATUS_OK;\n}\n\n";
1201 }
1202
1203 #####################################################################
1204 # parse a function element
1205 sub ParseFunctionElementPull($$)
1206
1207         my $e = shift;
1208         my $inout = shift;
1209
1210         if (util::array_size($e)) {
1211                 if (util::need_wire_pointer($e)) {
1212                         pidl "\tNDR_CHECK(ndr_pull_ptr(ndr, &_ptr_$e->{NAME}));\n";
1213                         pidl "\tif (_ptr_$e->{NAME}) {\n";
1214                 } elsif ($inout eq "out" && util::has_property($e, "ref")) {
1215                         pidl "\tif (r->$inout.$e->{NAME}) {\n";
1216                 } else {
1217                         pidl "\t{\n";
1218                 }
1219                 ParseArrayPull($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1220                 pidl "\t}\n";
1221         } else {
1222                 if ($inout eq "out" && util::has_property($e, "ref")) {
1223                         pidl "\tif (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {\n";
1224                         pidl "\tNDR_ALLOC(ndr, r->out.$e->{NAME});\n";
1225                         pidl "\t}\n";
1226                 }
1227                 if ($inout eq "in" && util::has_property($e, "ref")) {
1228                         pidl "\tNDR_ALLOC(ndr, r->in.$e->{NAME});\n";
1229                 }
1230
1231                 ParseElementPullScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1232                 if ($e->{POINTERS}) {
1233                         ParseElementPullBuffer($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1234                 }
1235         }
1236 }
1237
1238
1239 ############################################################
1240 # allocate ref variables
1241 sub AllocateRefVars($)
1242 {
1243         my $e = shift;
1244         my $asize = util::array_size($e);
1245
1246         # note that if the variable is also an "in"
1247         # variable then we copy the initial value from
1248         # the in side
1249
1250         if (!defined $asize) {
1251                 # its a simple variable
1252                 pidl "\tNDR_ALLOC(ndr, r->out.$e->{NAME});\n";
1253                 if (util::has_property($e, "in")) {
1254                         pidl "\t*r->out.$e->{NAME} = *r->in.$e->{NAME};\n";
1255                 } else {
1256                         pidl "\tZERO_STRUCTP(r->out.$e->{NAME});\n";
1257                 }
1258                 return;
1259         }
1260
1261         # its an array
1262         my $size = find_size_var($e, $asize, "r->out.");
1263         pidl "\tNDR_ALLOC_N(ndr, r->out.$e->{NAME}, MAX(1, $size));\n";
1264         if (util::has_property($e, "in")) {
1265                 pidl "\tmemcpy(r->out.$e->{NAME},r->in.$e->{NAME},$size * sizeof(*r->in.$e->{NAME}));\n";
1266         } else {
1267                 pidl "\tmemset(r->out.$e->{NAME}, 0, $size * sizeof(*r->out.$e->{NAME}));\n";
1268         }
1269 }
1270
1271
1272 #####################################################################
1273 # parse a function
1274 sub ParseFunctionPull($)
1275
1276         my($fn) = shift;
1277         my $static = fn_prefix($fn);
1278
1279         # pull function args
1280         pidl $static . "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)\n{\n";
1281
1282         # declare any internal pointers we need
1283         foreach my $e (@{$fn->{DATA}}) {
1284                 if (util::need_wire_pointer($e)) {
1285                         pidl "\tuint32_t _ptr_$e->{NAME};\n";
1286                 }
1287         }
1288
1289         pidl "\n\tif (!(flags & NDR_IN)) goto ndr_out;\n\n";
1290
1291         # auto-init the out section of a structure. I originally argued that
1292         # this was a bad idea as it hides bugs, but coping correctly
1293         # with initialisation and not wiping ref vars is turning
1294         # out to be too tricky (tridge)
1295         foreach my $e (@{$fn->{DATA}}) {
1296                 if (util::has_property($e, "out")) {
1297                         pidl "\tZERO_STRUCT(r->out);\n\n";
1298                         last;
1299                 }
1300         }
1301
1302         foreach my $e (@{$fn->{DATA}}) {
1303                 if (util::has_property($e, "in")) {
1304                         ParseFunctionElementPull($e, "in");
1305                 }
1306                 # we need to allocate any reference output variables, so that
1307                 # a dcerpc backend can be sure they are non-null
1308                 if (util::has_property($e, "out") && util::has_property($e, "ref")) {
1309                         AllocateRefVars($e);
1310                 }
1311         }
1312
1313         pidl "\nndr_out:\n";
1314         pidl "\tif (!(flags & NDR_OUT)) goto done;\n\n";
1315         foreach my $e (@{$fn->{DATA}}) {
1316                 if (util::has_property($e, "out")) {
1317                         ParseFunctionElementPull($e, "out");
1318                 }
1319         }
1320
1321         if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1322                 pidl "\tNDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, &r->out.result));\n";
1323         }
1324
1325         pidl "\ndone:\n";
1326         pidl "\n\treturn NT_STATUS_OK;\n}\n\n";
1327 }
1328
1329 #####################################################################
1330 # produce a function call table
1331 sub FunctionTable($)
1332 {
1333         my($interface) = shift;
1334         my($data) = $interface->{DATA};
1335         my $count = 0;
1336         my $uname = uc $interface->{NAME};
1337
1338         foreach my $d (@{$data}) {
1339                 if ($d->{TYPE} eq "FUNCTION") { $count++; }
1340         }
1341
1342         if ($count == 0) {
1343                 return;
1344         }
1345
1346         pidl "static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {\n";
1347         foreach my $d (@{$data}) {
1348                 if ($d->{TYPE} eq "FUNCTION") {
1349                         pidl "\t{\n";
1350                         pidl "\t\t\"$d->{NAME}\",\n";
1351                         pidl "\t\tsizeof(struct $d->{NAME}),\n";
1352                         pidl "\t\t(ndr_push_flags_fn_t) ndr_push_$d->{NAME},\n";
1353                         pidl "\t\t(ndr_pull_flags_fn_t) ndr_pull_$d->{NAME},\n";
1354                         pidl "\t\t(ndr_print_function_t) ndr_print_$d->{NAME}\n";
1355                         pidl "\t},\n";
1356                 }
1357         }
1358         pidl "\t{ NULL, 0, NULL, NULL }\n};\n\n";
1359
1360         my $endpoints;
1361
1362         if (! defined $if_endpoints) {
1363                 $if_endpoints = $interface->{NAME};
1364         }
1365
1366         my @e = split / /, $if_endpoints;
1367         my $endpoint_count = $#e + 1;
1368
1369         pidl "static const char * const $interface->{NAME}\_endpoint_strings[] = {\n\t";
1370         for (my $i=0; $i < $#e; $i++) {
1371                 pidl "\"$e[$i]\", ";
1372         }
1373         pidl "\"$e[$#e]\"\n";
1374         pidl "};\n\n";
1375
1376         pidl "static const struct dcerpc_endpoint_list $interface->{NAME}\_endpoints = {\n";
1377         pidl "\t$endpoint_count, $interface->{NAME}\_endpoint_strings\n";
1378         pidl "};\n\n";
1379
1380         pidl "\nconst struct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {\n";
1381         pidl "\t\"$interface->{NAME}\",\n";
1382         pidl "\tDCERPC_$uname\_UUID,\n";
1383         pidl "\tDCERPC_$uname\_VERSION,\n";
1384         pidl "\t$count,\n";
1385         pidl "\t$interface->{NAME}\_calls,\n";
1386         pidl "\t&$interface->{NAME}\_endpoints\n";
1387         pidl "};\n\n";
1388 }
1389
1390
1391 #####################################################################
1392 # parse the interface definitions
1393 sub ParseInterface($)
1394 {
1395         my($interface) = shift;
1396         my($data) = $interface->{DATA};
1397
1398         foreach my $d (@{$data}) {
1399                 if ($d->{TYPE} eq "TYPEDEF") {
1400                     $structs{$d->{NAME}} = $d;
1401             }
1402         }
1403
1404
1405
1406         foreach my $d (@{$data}) {
1407                 ($d->{TYPE} eq "TYPEDEF") &&
1408                     ParseTypedefPush($d);
1409                 ($d->{TYPE} eq "FUNCTION") && 
1410                     ParseFunctionPush($d);
1411         }
1412         foreach my $d (@{$data}) {
1413                 ($d->{TYPE} eq "TYPEDEF") &&
1414                     ParseTypedefPull($d);
1415                 ($d->{TYPE} eq "FUNCTION") && 
1416                     ParseFunctionPull($d);
1417         }
1418         foreach my $d (@{$data}) {
1419                 if ($d->{TYPE} eq "TYPEDEF" &&
1420                     !util::has_property($d->{DATA}, "noprint")) {
1421                         ParseTypedefPrint($d);
1422                 }
1423                 if ($d->{TYPE} eq "FUNCTION" &&
1424                     !util::has_property($d, "noprint")) {
1425                         ParseFunctionPrint($d);
1426                 }
1427         }
1428
1429         FunctionTable($interface);
1430
1431 }
1432
1433 sub NeededFunction($)
1434 {
1435         my $fn = shift;
1436         $needed{"pull_$fn->{NAME}"} = 1;
1437         $needed{"push_$fn->{NAME}"} = 1;
1438         foreach my $e (@{$fn->{DATA}}) {
1439                 $e->{PARENT} = $fn;
1440                 $needed{"pull_$e->{TYPE}"} = 1;
1441                 $needed{"push_$e->{TYPE}"} = 1;
1442         }
1443 }
1444
1445 sub NeededTypedef($)
1446 {
1447         my $t = shift;
1448         if (util::has_property($t->{DATA}, "public")) {
1449                 $needed{"pull_$t->{NAME}"} = 1;
1450                 $needed{"push_$t->{NAME}"} = 1;         
1451         }
1452         if ($t->{DATA}->{TYPE} eq "STRUCT") {
1453                 for my $e (@{$t->{DATA}->{ELEMENTS}}) {
1454                         $e->{PARENT} = $t->{DATA};
1455                         if ($needed{"pull_$t->{NAME}"}) {
1456                                 $needed{"pull_$e->{TYPE}"} = 1;
1457                         }
1458                         if ($needed{"push_$t->{NAME}"}) {
1459                                 $needed{"push_$e->{TYPE}"} = 1;
1460                         }
1461                 }
1462         }
1463         if ($t->{DATA}->{TYPE} eq "UNION") {
1464                 for my $e (@{$t->{DATA}->{DATA}}) {
1465                         $e->{PARENT} = $t->{DATA};
1466                         if ($e->{TYPE} eq "UNION_ELEMENT") {
1467                                 if ($needed{"pull_$t->{NAME}"}) {
1468                                         $needed{"pull_$e->{DATA}->{TYPE}"} = 1;
1469                                 }
1470                                 if ($needed{"push_$t->{NAME}"}) {
1471                                         $needed{"push_$e->{DATA}->{TYPE}"} = 1;
1472                                 }
1473                         }
1474                 }
1475         }
1476 }
1477
1478 #####################################################################
1479 # work out what parse functions are needed
1480 sub BuildNeeded($)
1481 {
1482         my($interface) = shift;
1483         my($data) = $interface->{DATA};
1484         foreach my $d (@{$data}) {
1485                 ($d->{TYPE} eq "FUNCTION") && 
1486                     NeededFunction($d);
1487         }
1488         foreach my $d (reverse @{$data}) {
1489                 ($d->{TYPE} eq "TYPEDEF") &&
1490                     NeededTypedef($d);
1491         }
1492 }
1493
1494 #####################################################################
1495 # parse the interface definitions
1496 sub ModuleHeader($)
1497 {
1498     my($h) = shift;
1499
1500     $if_uuid = $h->{PROPERTIES}->{uuid};
1501     $if_version = $h->{PROPERTIES}->{version};
1502     $if_endpoints = $h->{PROPERTIES}->{endpoints};
1503 }
1504
1505 #####################################################################
1506 # parse a parsed IDL structure back into an IDL file
1507 sub Parse($$)
1508 {
1509         my($idl) = shift;
1510         my($filename) = shift;
1511
1512         open(OUT, ">$filename") || die "can't open $filename";    
1513
1514         pidl "/* parser auto-generated by pidl */\n\n";
1515         pidl "#include \"includes.h\"\n\n";
1516         foreach my $x (@{$idl}) {
1517                 ($x->{TYPE} eq "MODULEHEADER") && 
1518                     ModuleHeader($x);
1519
1520                 if ($x->{TYPE} eq "INTERFACE") { 
1521                         BuildNeeded($x);
1522                         ParseInterface($x);
1523                 }
1524         }
1525
1526         pidl IdlClient::Parse($idl);
1527
1528         close(OUT);
1529 }
1530
1531 1;