r1611: Put a brace on a new line.
[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);\n";
452                 pidl "\t\t}\n";
453                 if ($switch_var =~ /r->/) {
454                         pidl "else { $switch_var = _level; }\n";
455                 }
456                 pidl "\t}\n";
457         }
458
459         my $sub_size = util::has_property($e, "subcontext");
460         if (defined $sub_size) {
461                 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";
462         } else {
463                 pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $switch_var, $cprefix$var_prefix$e->{NAME}));\n";
464         }
465
466
467 }
468
469 #####################################################################
470 # push switch element
471 sub ParseElementPushSwitch($$$$)
472 {
473         my($e) = shift;
474         my($var_prefix) = shift;
475         my($ndr_flags) = shift;
476         my $switch = shift;
477         my $switch_var = find_size_var($e, $switch, $var_prefix);
478         my $cprefix = util::c_push_prefix($e);
479
480         my $utype = $structs{$e->{TYPE}};
481         if (!defined $utype ||
482             !util::has_property($utype->{DATA}, "nodiscriminant")) {
483                 my $e2 = find_sibling($e, $switch);
484                 pidl "\tif (($ndr_flags) & NDR_SCALARS) {\n";
485                 pidl "\t\tNDR_CHECK(ndr_push_$e2->{TYPE}(ndr, $switch_var));\n";
486                 pidl "\t}\n";
487         }
488
489         my $sub_size = util::has_property($e, "subcontext");
490         if (defined $sub_size) {
491                 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";
492         } else {
493                 pidl "\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $switch_var, $cprefix$var_prefix$e->{NAME}));\n";
494         }
495 }
496
497 #####################################################################
498 # print scalars in a structure element 
499 sub ParseElementPrintSwitch($$$)
500 {
501         my($e) = shift;
502         my($var_prefix) = shift;
503         my $switch = shift;
504         my $switch_var = find_size_var($e, $switch, $var_prefix);
505         my $cprefix = util::c_push_prefix($e);
506
507         pidl "\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $switch_var, $cprefix$var_prefix$e->{NAME});\n";
508 }
509
510
511 #####################################################################
512 # parse scalars in a structure element - pull size
513 sub ParseElementPullScalar($$$)
514 {
515         my($e) = shift;
516         my($var_prefix) = shift;
517         my($ndr_flags) = shift;
518         my $cprefix = util::c_pull_prefix($e);
519         my $sub_size = util::has_property($e, "subcontext");
520
521         start_flags($e);
522
523         if (util::has_property($e, "relative")) {
524                 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";
525         } elsif (util::is_inline_array($e)) {
526                 ParseArrayPull($e, "r->", "NDR_SCALARS");
527         } elsif (util::need_wire_pointer($e)) {
528                 pidl "\tNDR_CHECK(ndr_pull_ptr(ndr, &_ptr_$e->{NAME}));\n";
529                 pidl "\tif (_ptr_$e->{NAME}) {\n";
530                 pidl "\t\tNDR_ALLOC(ndr, $var_prefix$e->{NAME});\n";
531                 pidl "\t} else {\n";
532                 pidl "\t\t$var_prefix$e->{NAME} = NULL;\n";
533                 pidl "\t}\n";
534         } elsif (util::need_alloc($e)) {
535                 # no scalar component
536         } elsif (my $switch = util::has_property($e, "switch_is")) {
537                 ParseElementPullSwitch($e, $var_prefix, $ndr_flags, $switch);
538         } elsif (defined $sub_size) {
539                 if (util::is_builtin_type($e->{TYPE})) {
540                         pidl "\tNDR_CHECK(ndr_pull_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_fn_t) ndr_pull_$e->{TYPE}));\n";
541                 } else {
542                         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";
543                 }
544         } elsif (util::is_builtin_type($e->{TYPE})) {
545                 pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
546         } else {
547                 pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
548         }
549
550         end_flags($e);
551 }
552
553 #####################################################################
554 # parse buffers in a structure element
555 sub ParseElementPushBuffer($$$)
556 {
557         my($e) = shift;
558         my($var_prefix) = shift;
559         my($ndr_flags) = shift;
560         my $cprefix = util::c_push_prefix($e);
561         my $sub_size = util::has_property($e, "subcontext");
562
563         if (util::is_pure_scalar($e)) {
564                 return;
565         }
566
567         start_flags($e);
568
569         if (util::need_wire_pointer($e)) {
570                 pidl "\tif ($var_prefix$e->{NAME}) {\n";
571         }
572             
573         if (util::has_property($e, "relative")) {
574                 pidl "\tNDR_CHECK(ndr_push_relative(ndr, NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}, (ndr_push_const_fn_t) ndr_push_$e->{TYPE}));\n";
575         } elsif (util::is_inline_array($e)) {
576                 ParseArrayPush($e, "r->", "NDR_BUFFERS");
577         } elsif (util::array_size($e)) {
578                 ParseArrayPush($e, "r->", "NDR_SCALARS|NDR_BUFFERS");
579         } elsif (my $switch = util::has_property($e, "switch_is")) {
580                 if ($e->{POINTERS}) {
581                         ParseElementPushSwitch($e, $var_prefix, "NDR_BUFFERS|NDR_SCALARS", $switch);
582                 } else {
583                         ParseElementPushSwitch($e, $var_prefix, "NDR_BUFFERS", $switch);
584                 }
585         } elsif (defined $sub_size) {
586                 if ($e->{POINTERS}) {
587                         if (util::is_builtin_type($e->{TYPE})) {
588                                 pidl "\tNDR_CHECK(ndr_push_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_push_fn_t) ndr_push_$e->{TYPE}));\n";
589                         } else {
590                                 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";
591                         }
592                 }
593         } elsif (util::is_builtin_type($e->{TYPE})) {
594                 pidl "\t\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
595         } elsif ($e->{POINTERS}) {
596                 pidl "\t\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, NDR_SCALARS|NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}));\n";
597         } else {
598                 pidl "\t\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
599         }
600
601         if (util::need_wire_pointer($e)) {
602                 pidl "\t}\n";
603         }       
604
605         end_flags($e);
606 }
607
608 #####################################################################
609 # print buffers in a structure element
610 sub ParseElementPrintBuffer($$)
611 {
612         my($e) = shift;
613         my($var_prefix) = shift;
614         my $cprefix = util::c_push_prefix($e);
615
616         if (util::need_wire_pointer($e)) {
617                 pidl "\tif ($var_prefix$e->{NAME}) {\n";
618         }
619             
620         if (util::array_size($e)) {
621                 ParseArrayPrint($e, $var_prefix);
622         } elsif (my $switch = util::has_property($e, "switch_is")) {
623                 ParseElementPrintSwitch($e, $var_prefix, $switch);
624         } else {
625                 pidl "\t\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME});\n";
626         }
627
628         if (util::need_wire_pointer($e)) {
629                 pidl "\t}\n";
630         }       
631 }
632
633
634 #####################################################################
635 # parse buffers in a structure element - pull side
636 sub ParseElementPullBuffer($$$)
637 {
638         my($e) = shift;
639         my($var_prefix) = shift;
640         my($ndr_flags) = shift;
641         my $cprefix = util::c_pull_prefix($e);
642         my $sub_size = util::has_property($e, "subcontext");
643
644         if (util::is_pure_scalar($e)) {
645                 return;
646         }
647
648         if (util::has_property($e, "relative")) {
649                 return;
650         }
651
652         start_flags($e);
653
654         if (util::need_wire_pointer($e)) {
655                 pidl "\tif ($var_prefix$e->{NAME}) {\n";
656         }
657             
658         if (util::is_inline_array($e)) {
659                 ParseArrayPull($e, "r->", "NDR_BUFFERS");
660         } elsif (util::array_size($e)) {
661                 ParseArrayPull($e, "r->", "NDR_SCALARS|NDR_BUFFERS");
662         } elsif (my $switch = util::has_property($e, "switch_is")) {
663                 if ($e->{POINTERS}) {
664                         ParseElementPullSwitch($e, $var_prefix, "NDR_SCALARS|NDR_BUFFERS", $switch);
665                 } else {
666                         ParseElementPullSwitch($e, $var_prefix, "NDR_BUFFERS", $switch);
667                 }
668         } elsif (defined $sub_size) {
669                 if ($e->{POINTERS}) {
670                         if (util::is_builtin_type($e->{TYPE})) {
671                                 pidl "\tNDR_CHECK(ndr_pull_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_fn_t) ndr_pull_$e->{TYPE}));\n";
672                         } else {
673                                 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";
674                         }
675                 }
676         } elsif (util::is_builtin_type($e->{TYPE})) {
677                 pidl "\t\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
678         } elsif ($e->{POINTERS}) {
679                 pidl "\t\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, NDR_SCALARS|NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}));\n";
680         } else {
681                 pidl "\t\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
682         }
683
684         if (util::need_wire_pointer($e)) {
685                 pidl "\t}\n";
686         }       
687
688         end_flags($e);
689 }
690
691 #####################################################################
692 # parse a struct
693 sub ParseStructPush($)
694 {
695         my($struct) = shift;
696         my $conform_e;
697         
698         if (! defined $struct->{ELEMENTS}) {
699                 return;
700         }
701
702         start_flags($struct);
703
704         # see if the structure contains a conformant array. If it
705         # does, then it must be the last element of the structure, and
706         # we need to push the conformant length early, as it fits on
707         # the wire before the structure (and even before the structure
708         # alignment)
709         my $e = $struct->{ELEMENTS}[-1];
710         if (defined $e->{ARRAY_LEN} && $e->{ARRAY_LEN} eq "*") {
711                 my $size = find_size_var($e, util::array_size($e), "r->");
712                 $e->{CONFORMANT_SIZE} = $size;
713                 $conform_e = $e;
714                 pidl "\tNDR_CHECK(ndr_push_uint32(ndr, $size));\n";
715         }
716
717         pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
718
719         pidl "\tNDR_CHECK(ndr_push_struct_start(ndr));\n";
720
721         my $align = struct_alignment($struct);
722         pidl "\tNDR_CHECK(ndr_push_align(ndr, $align));\n";
723
724         foreach my $e (@{$struct->{ELEMENTS}}) {
725                 ParseElementPushScalar($e, "r->", "NDR_SCALARS");
726         }       
727
728         pidl "buffers:\n";
729         pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
730         foreach my $e (@{$struct->{ELEMENTS}}) {
731                 ParseElementPushBuffer($e, "r->", "NDR_BUFFERS");
732         }
733
734         pidl "\tndr_push_struct_end(ndr);\n";
735
736         pidl "done:\n";
737
738         end_flags($struct);
739 }
740
741 #####################################################################
742 # generate a struct print function
743 sub ParseStructPrint($)
744 {
745         my($struct) = shift;
746
747         if (! defined $struct->{ELEMENTS}) {
748                 return;
749         }
750
751         start_flags($struct);
752
753         pidl "\tndr->depth++;\n";
754         foreach my $e (@{$struct->{ELEMENTS}}) {
755                 ParseElementPrintScalar($e, "r->");
756         }
757         pidl "\tndr->depth--;\n";
758
759         end_flags($struct);
760 }
761
762 #####################################################################
763 # parse a struct - pull side
764 sub ParseStructPull($)
765 {
766         my($struct) = shift;
767         my $conform_e;
768
769         if (! defined $struct->{ELEMENTS}) {
770                 return;
771         }
772
773         # see if the structure contains a conformant array. If it
774         # does, then it must be the last element of the structure, and
775         # we need to pull the conformant length early, as it fits on
776         # the wire before the structure (and even before the structure
777         # alignment)
778         my $e = $struct->{ELEMENTS}[-1];
779         if (defined $e->{ARRAY_LEN} && $e->{ARRAY_LEN} eq "*") {
780                 $conform_e = $e;
781                 pidl "\tuint32_t _conformant_size;\n";
782                 $conform_e->{CONFORMANT_SIZE} = "_conformant_size";
783         }
784
785         # declare any internal pointers we need
786         foreach my $e (@{$struct->{ELEMENTS}}) {
787                 if (util::need_wire_pointer($e) &&
788                     !util::has_property($e, "relative")) {
789                         pidl "\tuint32_t _ptr_$e->{NAME};\n";
790                 }
791         }
792
793         start_flags($struct);
794
795         pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
796
797         pidl "\tNDR_CHECK(ndr_pull_struct_start(ndr));\n";
798
799         if (defined $conform_e) {
800                 pidl "\tNDR_CHECK(ndr_pull_uint32(ndr, &$conform_e->{CONFORMANT_SIZE}));\n";
801         }
802
803         my $align = struct_alignment($struct);
804         pidl "\tNDR_CHECK(ndr_pull_align(ndr, $align));\n";
805
806         foreach my $e (@{$struct->{ELEMENTS}}) {
807                 ParseElementPullScalar($e, "r->", "NDR_SCALARS");
808         }       
809
810         pidl "buffers:\n";
811         pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
812         foreach my $e (@{$struct->{ELEMENTS}}) {
813                 ParseElementPullBuffer($e, "r->", "NDR_BUFFERS");
814         }
815
816         pidl "\tndr_pull_struct_end(ndr);\n";
817
818         pidl "done:\n";
819
820         end_flags($struct);
821 }
822
823
824 #####################################################################
825 # parse a union - push side
826 sub ParseUnionPush($)
827 {
828         my $e = shift;
829         my $have_default = 0;
830
831         start_flags($e);
832
833         pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
834
835         pidl "\tNDR_CHECK(ndr_push_struct_start(ndr));\n";
836
837 #       my $align = union_alignment($e);
838 #       pidl "\tNDR_CHECK(ndr_push_align(ndr, $align));\n";
839
840         pidl "\tswitch (level) {\n";
841         foreach my $el (@{$e->{DATA}}) {
842                 if ($el->{CASE} eq "default") {
843                         pidl "\tdefault:\n";
844                         $have_default = 1;
845                 } else {
846                         pidl "\tcase $el->{CASE}:\n";
847                 }
848                 if ($el->{TYPE} eq "UNION_ELEMENT") {
849                         ParseElementPushScalar($el->{DATA}, "r->", "NDR_SCALARS");
850                 }
851                 pidl "\tbreak;\n\n";
852         }
853         if (! $have_default) {
854                 pidl "\tdefault:\n";
855                 pidl "\t\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
856         }
857         pidl "\t}\n";
858         pidl "buffers:\n";
859         pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
860         pidl "\tswitch (level) {\n";
861         foreach my $el (@{$e->{DATA}}) {
862                 if ($el->{CASE} eq "default") {
863                         pidl "\tdefault:\n";
864                 } else {
865                         pidl "\tcase $el->{CASE}:\n";
866                 }
867                 if ($el->{TYPE} eq "UNION_ELEMENT") {
868                         ParseElementPushBuffer($el->{DATA}, "r->", "NDR_BUFFERS");
869                 }
870                 pidl "\tbreak;\n\n";
871         }
872         if (! $have_default) {
873                 pidl "\tdefault:\n";
874                 pidl "\t\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
875         }
876         pidl "\t}\n";
877         pidl "\tndr_push_struct_end(ndr);\n";
878         pidl "done:\n";
879         end_flags($e);
880 }
881
882 #####################################################################
883 # print a union
884 sub ParseUnionPrint($)
885 {
886         my $e = shift;
887         my $have_default = 0;
888
889         start_flags($e);
890
891         pidl "\tswitch (level) {\n";
892         foreach my $el (@{$e->{DATA}}) {
893                 if ($el->{CASE} eq "default") {
894                         $have_default = 1;
895                         pidl "\tdefault:\n";
896                 } else {
897                         pidl "\tcase $el->{CASE}:\n";
898                 }
899                 if ($el->{TYPE} eq "UNION_ELEMENT") {
900                         ParseElementPrintScalar($el->{DATA}, "r->");
901                 }
902                 pidl "\tbreak;\n\n";
903         }
904         if (! $have_default) {
905                 pidl "\tdefault:\n\t\tndr_print_bad_level(ndr, name, level);\n";
906         }
907         pidl "\t}\n";
908
909         end_flags($e);
910 }
911
912 #####################################################################
913 # parse a union - pull side
914 sub ParseUnionPull($)
915 {
916         my $e = shift;
917         my $have_default = 0;
918
919         start_flags($e);
920
921         pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
922
923         pidl "\tNDR_CHECK(ndr_pull_struct_start(ndr));\n";
924
925 #       my $align = union_alignment($e);
926 #       pidl "\tNDR_CHECK(ndr_pull_align(ndr, $align));\n";
927
928         pidl "\tswitch (level) {\n";
929         foreach my $el (@{$e->{DATA}}) {
930                 if ($el->{CASE} eq "default") {
931                         pidl "\tdefault: {\n";
932                         $have_default = 1;
933                 } else {
934                         pidl "\tcase $el->{CASE}: {\n";
935                 }
936                 if ($el->{TYPE} eq "UNION_ELEMENT") {
937                         my $e2 = $el->{DATA};
938                         if ($e2->{POINTERS}) {
939                                 pidl "\t\tuint32_t _ptr_$e2->{NAME};\n";
940                         }
941                         ParseElementPullScalar($el->{DATA}, "r->", "NDR_SCALARS");
942                 }
943                 pidl "\tbreak; }\n\n";
944         }
945         if (! $have_default) {
946                 pidl "\tdefault:\n";
947                 pidl "\t\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
948         }
949         pidl "\t}\n";
950         pidl "buffers:\n";
951         pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
952         pidl "\tswitch (level) {\n";
953         foreach my $el (@{$e->{DATA}}) {
954                 if ($el->{CASE} eq "default") {
955                         pidl "\tdefault:\n";
956                 } else {
957                         pidl "\tcase $el->{CASE}:\n";
958                 }
959                 if ($el->{TYPE} eq "UNION_ELEMENT") {
960                         ParseElementPullBuffer($el->{DATA}, "r->", "NDR_BUFFERS");
961                 }
962                 pidl "\tbreak;\n\n";
963         }
964         if (! $have_default) {
965                 pidl "\tdefault:\n";
966                 pidl "\t\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
967         }
968         pidl "\t}\n";
969         pidl "\tndr_pull_struct_end(ndr);\n";
970         pidl "done:\n";
971         end_flags($e);
972 }
973
974 #####################################################################
975 # parse a type
976 sub ParseTypePush($)
977 {
978         my($data) = shift;
979
980         if (ref($data) eq "HASH") {
981                 ($data->{TYPE} eq "STRUCT") &&
982                     ParseStructPush($data);
983                 ($data->{TYPE} eq "UNION") &&
984                     ParseUnionPush($data);
985         }
986 }
987
988 #####################################################################
989 # generate a print function for a type
990 sub ParseTypePrint($)
991 {
992         my($data) = shift;
993
994         if (ref($data) eq "HASH") {
995                 ($data->{TYPE} eq "STRUCT") &&
996                     ParseStructPrint($data);
997                 ($data->{TYPE} eq "UNION") &&
998                     ParseUnionPrint($data);
999         }
1000 }
1001
1002 #####################################################################
1003 # parse a type
1004 sub ParseTypePull($)
1005 {
1006         my($data) = shift;
1007
1008         if (ref($data) eq "HASH") {
1009                 ($data->{TYPE} eq "STRUCT") &&
1010                     ParseStructPull($data);
1011                 ($data->{TYPE} eq "UNION") &&
1012                     ParseUnionPull($data);
1013         }
1014 }
1015
1016 #####################################################################
1017 # parse a typedef - push side
1018 sub ParseTypedefPush($)
1019 {
1020         my($e) = shift;
1021         my $static = fn_prefix($e);
1022
1023         if (! $needed{"push_$e->{NAME}"}) {
1024 #               print "push_$e->{NAME} not needed\n";
1025                 return;
1026         }
1027
1028         if ($e->{DATA}->{TYPE} eq "STRUCT") {
1029                 pidl $static . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, struct $e->{NAME} *r)";
1030                 pidl "\n{\n";
1031                 ParseTypePush($e->{DATA});
1032                 pidl "\treturn NT_STATUS_OK;\n";
1033                 pidl "}\n\n";
1034         }
1035
1036         if ($e->{DATA}->{TYPE} eq "UNION") {
1037                 pidl $static . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, uint16_t level, union $e->{NAME} *r)";
1038                 pidl "\n{\n";
1039                 ParseTypePush($e->{DATA});
1040                 pidl "\treturn NT_STATUS_OK;\n";
1041                 pidl "}\n\n";
1042         }
1043 }
1044
1045
1046 #####################################################################
1047 # parse a typedef - pull side
1048 sub ParseTypedefPull($)
1049 {
1050         my($e) = shift;
1051         my $static = fn_prefix($e);
1052
1053         if (! $needed{"pull_$e->{NAME}"}) {
1054 #               print "pull_$e->{NAME} not needed\n";
1055                 return;
1056         }
1057
1058         if ($e->{DATA}->{TYPE} eq "STRUCT") {
1059                 pidl $static . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, struct $e->{NAME} *r)";
1060                 pidl "\n{\n";
1061                 ParseTypePull($e->{DATA});
1062                 pidl "\treturn NT_STATUS_OK;\n";
1063                 pidl "}\n\n";
1064         }
1065
1066         if ($e->{DATA}->{TYPE} eq "UNION") {
1067                 pidl $static . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, uint16_t level, union $e->{NAME} *r)";
1068                 pidl "\n{\n";
1069                 ParseTypePull($e->{DATA});
1070                 pidl "\treturn NT_STATUS_OK;\n";
1071                 pidl "}\n\n";
1072         }
1073 }
1074
1075
1076 #####################################################################
1077 # parse a typedef - print side
1078 sub ParseTypedefPrint($)
1079 {
1080         my($e) = shift;
1081
1082         if ($e->{DATA}->{TYPE} eq "STRUCT") {
1083                 pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, struct $e->{NAME} *r)";
1084                 pidl "\n{\n";
1085                 pidl "\tndr_print_struct(ndr, name, \"$e->{NAME}\");\n";
1086                 ParseTypePrint($e->{DATA});
1087                 pidl "}\n\n";
1088         }
1089
1090         if ($e->{DATA}->{TYPE} eq "UNION") {
1091                 pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, uint16_t level, union $e->{NAME} *r)";
1092                 pidl "\n{\n";
1093                 pidl "\tndr_print_union(ndr, name, level, \"$e->{NAME}\");\n";
1094                 ParseTypePrint($e->{DATA});
1095                 pidl "}\n\n";
1096         }
1097 }
1098
1099 #####################################################################
1100 # parse a function - print side
1101 sub ParseFunctionPrint($)
1102 {
1103         my($fn) = shift;
1104
1105         pidl "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, struct $fn->{NAME} *r)";
1106         pidl "\n{\n";
1107         pidl "\tndr_print_struct(ndr, name, \"$fn->{NAME}\");\n";
1108         pidl "\tndr->depth++;\n";
1109
1110         pidl "\tif (flags & NDR_SET_VALUES) {\n";
1111         pidl "\t\tndr->flags |= LIBNDR_PRINT_SET_VALUES;\n";
1112         pidl "\t}\n";
1113
1114         pidl "\tif (flags & NDR_IN) {\n";
1115         pidl "\t\tndr_print_struct(ndr, \"in\", \"$fn->{NAME}\");\n";
1116         pidl "\tndr->depth++;\n";
1117         foreach my $e (@{$fn->{DATA}}) {
1118                 if (util::has_property($e, "in")) {
1119                         ParseElementPrintScalar($e, "r->in.");
1120                 }
1121         }
1122         pidl "\tndr->depth--;\n";
1123         pidl "\t}\n";
1124         
1125         pidl "\tif (flags & NDR_OUT) {\n";
1126         pidl "\t\tndr_print_struct(ndr, \"out\", \"$fn->{NAME}\");\n";
1127         pidl "\tndr->depth++;\n";
1128         foreach my $e (@{$fn->{DATA}}) {
1129                 if (util::has_property($e, "out")) {
1130                         ParseElementPrintScalar($e, "r->out.");
1131                 }
1132         }
1133         if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1134                 if (util::is_scalar_type($fn->{RETURN_TYPE})) {
1135                         pidl "\tndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", r->out.result);\n";
1136                 } else {
1137                         pidl "\tndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", &r->out.result);\n";
1138                 }
1139         }
1140         pidl "\tndr->depth--;\n";
1141         pidl "\t}\n";
1142         
1143         pidl "\tndr->depth--;\n";
1144         pidl "}\n\n";
1145 }
1146
1147
1148 #####################################################################
1149 # parse a function element
1150 sub ParseFunctionElementPush($$)
1151
1152         my $e = shift;
1153         my $inout = shift;
1154
1155         if (util::array_size($e)) {
1156                 if (util::need_wire_pointer($e)) {
1157                         pidl "\tNDR_CHECK(ndr_push_ptr(ndr, r->$inout.$e->{NAME}));\n";
1158                         pidl "\tif (r->$inout.$e->{NAME}) {\n";
1159                         ParseArrayPush($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1160                         pidl "\t}\n";
1161                 } else {
1162                         ParseArrayPush($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1163                 }
1164         } else {
1165                 ParseElementPushScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1166                 if ($e->{POINTERS}) {
1167                         ParseElementPushBuffer($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1168                 }
1169         }
1170 }       
1171
1172 #####################################################################
1173 # parse a function
1174 sub ParseFunctionPush($)
1175
1176         my($fn) = shift;
1177         my $static = fn_prefix($fn);
1178
1179         pidl $static . "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, struct $fn->{NAME} *r)\n{\n";
1180
1181         pidl "\n\tif (!(flags & NDR_IN)) goto ndr_out;\n\n";
1182         foreach my $e (@{$fn->{DATA}}) {
1183                 if (util::has_property($e, "in")) {
1184                         ParseFunctionElementPush($e, "in");
1185                 }               
1186         }
1187
1188         pidl "\nndr_out:\n";
1189         pidl "\tif (!(flags & NDR_OUT)) goto done;\n\n";
1190         foreach my $e (@{$fn->{DATA}}) {
1191                 if (util::has_property($e, "out")) {
1192                         ParseFunctionElementPush($e, "out");
1193                 }               
1194         }
1195
1196         if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1197                 pidl "\tNDR_CHECK(ndr_push_$fn->{RETURN_TYPE}(ndr, r->out.result));\n";
1198         }
1199     
1200         pidl "\ndone:\n";
1201         pidl "\n\treturn NT_STATUS_OK;\n}\n\n";
1202 }
1203
1204 #####################################################################
1205 # parse a function element
1206 sub ParseFunctionElementPull($$)
1207
1208         my $e = shift;
1209         my $inout = shift;
1210
1211         if (util::array_size($e)) {
1212                 if (util::need_wire_pointer($e)) {
1213                         pidl "\tNDR_CHECK(ndr_pull_ptr(ndr, &_ptr_$e->{NAME}));\n";
1214                         pidl "\tif (_ptr_$e->{NAME}) {\n";
1215                 } elsif ($inout eq "out" && util::has_property($e, "ref")) {
1216                         pidl "\tif (r->$inout.$e->{NAME}) {\n";
1217                 } else {
1218                         pidl "\t{\n";
1219                 }
1220                 ParseArrayPull($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1221                 pidl "\t}\n";
1222         } else {
1223                 if ($inout eq "out" && util::has_property($e, "ref")) {
1224                         pidl "\tif (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {\n";
1225                         pidl "\tNDR_ALLOC(ndr, r->out.$e->{NAME});\n";
1226                         pidl "\t}\n";
1227                 }
1228                 if ($inout eq "in" && util::has_property($e, "ref")) {
1229                         pidl "\tNDR_ALLOC(ndr, r->in.$e->{NAME});\n";
1230                 }
1231
1232                 ParseElementPullScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1233                 if ($e->{POINTERS}) {
1234                         ParseElementPullBuffer($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1235                 }
1236         }
1237 }
1238
1239
1240 ############################################################
1241 # allocate ref variables
1242 sub AllocateRefVars($)
1243 {
1244         my $e = shift;
1245         my $asize = util::array_size($e);
1246
1247         # note that if the variable is also an "in"
1248         # variable then we copy the initial value from
1249         # the in side
1250
1251         if (!defined $asize) {
1252                 # its a simple variable
1253                 pidl "\tNDR_ALLOC(ndr, r->out.$e->{NAME});\n";
1254                 if (util::has_property($e, "in")) {
1255                         pidl "\t*r->out.$e->{NAME} = *r->in.$e->{NAME};\n";
1256                 } else {
1257                         pidl "\tZERO_STRUCTP(r->out.$e->{NAME});\n";
1258                 }
1259                 return;
1260         }
1261
1262         # its an array
1263         my $size = find_size_var($e, $asize, "r->out.");
1264         pidl "\tNDR_ALLOC_N(ndr, r->out.$e->{NAME}, MAX(1, $size));\n";
1265         if (util::has_property($e, "in")) {
1266                 pidl "\tmemcpy(r->out.$e->{NAME},r->in.$e->{NAME},$size * sizeof(*r->in.$e->{NAME}));\n";
1267         } else {
1268                 pidl "\tmemset(r->out.$e->{NAME}, 0, $size * sizeof(*r->out.$e->{NAME}));\n";
1269         }
1270 }
1271
1272
1273 #####################################################################
1274 # parse a function
1275 sub ParseFunctionPull($)
1276
1277         my($fn) = shift;
1278         my $static = fn_prefix($fn);
1279
1280         # pull function args
1281         pidl $static . "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)\n{\n";
1282
1283         # declare any internal pointers we need
1284         foreach my $e (@{$fn->{DATA}}) {
1285                 if (util::need_wire_pointer($e)) {
1286                         pidl "\tuint32_t _ptr_$e->{NAME};\n";
1287                 }
1288         }
1289
1290         pidl "\n\tif (!(flags & NDR_IN)) goto ndr_out;\n\n";
1291
1292         # auto-init the out section of a structure. I originally argued that
1293         # this was a bad idea as it hides bugs, but coping correctly
1294         # with initialisation and not wiping ref vars is turning
1295         # out to be too tricky (tridge)
1296         foreach my $e (@{$fn->{DATA}}) {
1297                 if (util::has_property($e, "out")) {
1298                         pidl "\tZERO_STRUCT(r->out);\n\n";
1299                         last;
1300                 }
1301         }
1302
1303         foreach my $e (@{$fn->{DATA}}) {
1304                 if (util::has_property($e, "in")) {
1305                         ParseFunctionElementPull($e, "in");
1306                 }
1307                 # we need to allocate any reference output variables, so that
1308                 # a dcerpc backend can be sure they are non-null
1309                 if (util::has_property($e, "out") && util::has_property($e, "ref")) {
1310                         AllocateRefVars($e);
1311                 }
1312         }
1313
1314         pidl "\nndr_out:\n";
1315         pidl "\tif (!(flags & NDR_OUT)) goto done;\n\n";
1316         foreach my $e (@{$fn->{DATA}}) {
1317                 if (util::has_property($e, "out")) {
1318                         ParseFunctionElementPull($e, "out");
1319                 }
1320         }
1321
1322         if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1323                 pidl "\tNDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, &r->out.result));\n";
1324         }
1325
1326         pidl "\ndone:\n";
1327         pidl "\n\treturn NT_STATUS_OK;\n}\n\n";
1328 }
1329
1330 #####################################################################
1331 # produce a function call table
1332 sub FunctionTable($)
1333 {
1334         my($interface) = shift;
1335         my($data) = $interface->{DATA};
1336         my $count = 0;
1337         my $uname = uc $interface->{NAME};
1338
1339         foreach my $d (@{$data}) {
1340                 if ($d->{TYPE} eq "FUNCTION") { $count++; }
1341         }
1342
1343         if ($count == 0) {
1344                 return;
1345         }
1346
1347         pidl "static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {\n";
1348         foreach my $d (@{$data}) {
1349                 if ($d->{TYPE} eq "FUNCTION") {
1350                         pidl "\t{\n";
1351                         pidl "\t\t\"$d->{NAME}\",\n";
1352                         pidl "\t\tsizeof(struct $d->{NAME}),\n";
1353                         pidl "\t\t(ndr_push_flags_fn_t) ndr_push_$d->{NAME},\n";
1354                         pidl "\t\t(ndr_pull_flags_fn_t) ndr_pull_$d->{NAME},\n";
1355                         pidl "\t\t(ndr_print_function_t) ndr_print_$d->{NAME}\n";
1356                         pidl "\t},\n";
1357                 }
1358         }
1359         pidl "\t{ NULL, 0, NULL, NULL }\n};\n\n";
1360
1361         my $endpoints;
1362
1363         if (! defined $if_endpoints) {
1364                 $if_endpoints = $interface->{NAME};
1365         }
1366
1367         my @e = split / /, $if_endpoints;
1368         my $endpoint_count = $#e + 1;
1369
1370         pidl "static const char * const $interface->{NAME}\_endpoint_strings[] = {\n\t";
1371         for (my $i=0; $i < $#e; $i++) {
1372                 pidl "\"$e[$i]\", ";
1373         }
1374         pidl "\"$e[$#e]\"\n";
1375         pidl "};\n\n";
1376
1377         pidl "static const struct dcerpc_endpoint_list $interface->{NAME}\_endpoints = {\n";
1378         pidl "\t$endpoint_count, $interface->{NAME}\_endpoint_strings\n";
1379         pidl "};\n\n";
1380
1381         pidl "\nconst struct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {\n";
1382         pidl "\t\"$interface->{NAME}\",\n";
1383         pidl "\tDCERPC_$uname\_UUID,\n";
1384         pidl "\tDCERPC_$uname\_VERSION,\n";
1385         pidl "\t$count,\n";
1386         pidl "\t$interface->{NAME}\_calls,\n";
1387         pidl "\t&$interface->{NAME}\_endpoints\n";
1388         pidl "};\n\n";
1389 }
1390
1391
1392 #####################################################################
1393 # parse the interface definitions
1394 sub ParseInterface($)
1395 {
1396         my($interface) = shift;
1397         my($data) = $interface->{DATA};
1398
1399         foreach my $d (@{$data}) {
1400                 if ($d->{TYPE} eq "TYPEDEF") {
1401                     $structs{$d->{NAME}} = $d;
1402             }
1403         }
1404
1405
1406
1407         foreach my $d (@{$data}) {
1408                 ($d->{TYPE} eq "TYPEDEF") &&
1409                     ParseTypedefPush($d);
1410                 ($d->{TYPE} eq "FUNCTION") && 
1411                     ParseFunctionPush($d);
1412         }
1413         foreach my $d (@{$data}) {
1414                 ($d->{TYPE} eq "TYPEDEF") &&
1415                     ParseTypedefPull($d);
1416                 ($d->{TYPE} eq "FUNCTION") && 
1417                     ParseFunctionPull($d);
1418         }
1419         foreach my $d (@{$data}) {
1420                 if ($d->{TYPE} eq "TYPEDEF" &&
1421                     !util::has_property($d->{DATA}, "noprint")) {
1422                         ParseTypedefPrint($d);
1423                 }
1424                 if ($d->{TYPE} eq "FUNCTION" &&
1425                     !util::has_property($d, "noprint")) {
1426                         ParseFunctionPrint($d);
1427                 }
1428         }
1429
1430         FunctionTable($interface);
1431
1432 }
1433
1434 sub NeededFunction($)
1435 {
1436         my $fn = shift;
1437         $needed{"pull_$fn->{NAME}"} = 1;
1438         $needed{"push_$fn->{NAME}"} = 1;
1439         foreach my $e (@{$fn->{DATA}}) {
1440                 $e->{PARENT} = $fn;
1441                 $needed{"pull_$e->{TYPE}"} = 1;
1442                 $needed{"push_$e->{TYPE}"} = 1;
1443         }
1444 }
1445
1446 sub NeededTypedef($)
1447 {
1448         my $t = shift;
1449         if (util::has_property($t->{DATA}, "public")) {
1450                 $needed{"pull_$t->{NAME}"} = 1;
1451                 $needed{"push_$t->{NAME}"} = 1;         
1452         }
1453         if ($t->{DATA}->{TYPE} eq "STRUCT") {
1454                 for my $e (@{$t->{DATA}->{ELEMENTS}}) {
1455                         $e->{PARENT} = $t->{DATA};
1456                         if ($needed{"pull_$t->{NAME}"}) {
1457                                 $needed{"pull_$e->{TYPE}"} = 1;
1458                         }
1459                         if ($needed{"push_$t->{NAME}"}) {
1460                                 $needed{"push_$e->{TYPE}"} = 1;
1461                         }
1462                 }
1463         }
1464         if ($t->{DATA}->{TYPE} eq "UNION") {
1465                 for my $e (@{$t->{DATA}->{DATA}}) {
1466                         $e->{PARENT} = $t->{DATA};
1467                         if ($e->{TYPE} eq "UNION_ELEMENT") {
1468                                 if ($needed{"pull_$t->{NAME}"}) {
1469                                         $needed{"pull_$e->{DATA}->{TYPE}"} = 1;
1470                                 }
1471                                 if ($needed{"push_$t->{NAME}"}) {
1472                                         $needed{"push_$e->{DATA}->{TYPE}"} = 1;
1473                                 }
1474                         }
1475                 }
1476         }
1477 }
1478
1479 #####################################################################
1480 # work out what parse functions are needed
1481 sub BuildNeeded($)
1482 {
1483         my($interface) = shift;
1484         my($data) = $interface->{DATA};
1485         foreach my $d (@{$data}) {
1486                 ($d->{TYPE} eq "FUNCTION") && 
1487                     NeededFunction($d);
1488         }
1489         foreach my $d (reverse @{$data}) {
1490                 ($d->{TYPE} eq "TYPEDEF") &&
1491                     NeededTypedef($d);
1492         }
1493 }
1494
1495 #####################################################################
1496 # parse the interface definitions
1497 sub ModuleHeader($)
1498 {
1499     my($h) = shift;
1500
1501     $if_uuid = $h->{PROPERTIES}->{uuid};
1502     $if_version = $h->{PROPERTIES}->{version};
1503     $if_endpoints = $h->{PROPERTIES}->{endpoints};
1504 }
1505
1506 #####################################################################
1507 # parse a parsed IDL structure back into an IDL file
1508 sub Parse($$)
1509 {
1510         my($idl) = shift;
1511         my($filename) = shift;
1512
1513         open(OUT, ">$filename") || die "can't open $filename";    
1514
1515         pidl "/* parser auto-generated by pidl */\n\n";
1516         pidl "#include \"includes.h\"\n\n";
1517         foreach my $x (@{$idl}) {
1518                 ($x->{TYPE} eq "MODULEHEADER") && 
1519                     ModuleHeader($x);
1520
1521                 if ($x->{TYPE} eq "INTERFACE") { 
1522                         BuildNeeded($x);
1523                         ParseInterface($x);
1524                 }
1525         }
1526
1527         pidl IdlClient::Parse($idl);
1528
1529         close(OUT);
1530 }
1531
1532 1;