r5475: Move some existing and new type information functions to typelist.pm
[samba.git] / source4 / build / pidl / ndr.pm
1 ###################################################
2 # Samba4 NDR parser generator for IDL structures
3 # Copyright tridge@samba.org 2000-2003
4 # Copyright tpot@samba.org 2001
5 # Copyright jelmer@samba.org 2004-2005
6 # released under the GNU GPL
7
8 package NdrParser;
9
10 use strict;
11 use needed;
12 use typelist;
13
14 # list of known types
15 my %typefamily;
16
17 sub get_typefamily($)
18 {
19         my $n = shift;
20         return $typefamily{$n};
21 }
22
23 my %scalar_alignments = 
24 (
25      "char"           => 1,
26      "int8"           => 1,
27      "uint8"          => 1,
28      "short"          => 2,
29      "wchar_t"        => 2,
30      "int16"          => 2,
31      "uint16"         => 2,
32      "long"           => 4,
33      "int32"          => 4,
34      "uint32"         => 4,
35      "dlong"          => 4,
36      "udlong"         => 4,
37      "udlongr"        => 4,
38      "NTTIME"         => 4,
39      "NTTIME_1sec"    => 4,
40      "time_t"         => 4,
41      "DATA_BLOB"      => 4,
42      "error_status_t" => 4,
43      "WERROR"         => 4,
44          "NTSTATUS"       => 4,
45      "boolean32"      => 4,
46      "unsigned32"     => 4,
47      "ipv4address"    => 4,
48      "hyper"          => 8,
49      "NTTIME_hyper"   => 8
50 );
51
52 $typefamily{SCALAR} = {
53         ALIGN => sub { 
54                 my $t = shift;
55                 return $scalar_alignments{$t->{NAME}}; 
56         }
57 };
58
59 sub is_scalar_type($)
60 {
61     my $type = shift;
62
63         return 0 unless typelist::hasType($type);
64
65         if (my $dt = typelist::getType($type)->{DATA}->{TYPE}) {
66                 return 1 if ($dt eq "SCALAR" or $dt eq "ENUM" or $dt eq "BITMAP");
67         }
68
69     return 0;
70 }
71
72 sub pointer_type($)
73 {
74         my $e = shift;
75
76         return undef unless $e->{POINTERS};
77         
78         return "ref" if (util::has_property($e, "ref"));
79         return "ptr" if (util::has_property($e, "ptr"));
80         return "unique" if (util::has_property($e, "unique"));
81         return "relative" if (util::has_property($e, "relative"));
82         return "ignore" if (util::has_property($e, "ignore"));
83
84         return undef;
85 }
86
87 # return 1 if this is a fixed array
88 sub is_fixed_array($)
89 {
90         my $e = shift;
91         my $len = $e->{"ARRAY_LEN"};
92         if (defined $len && util::is_constant($len)) {
93                 return 1;
94         }
95         return 0;
96 }
97
98 # return 1 if this is a conformant array
99 sub is_conformant_array($)
100 {
101         my $e = shift;
102         return 1 if (util::has_property($e, "size_is"));
103         return 0;
104 }
105
106 # return 1 if this is a inline array
107 sub is_inline_array($)
108 {
109         my $e = shift;
110         my $len = $e->{"ARRAY_LEN"};
111         if (is_fixed_array($e) ||
112             defined $len && $len ne "*") {
113                 return 1;
114         }
115         return 0;
116 }
117
118 # return 1 if this is a varying array
119 sub is_varying_array($)
120 {
121         my $e = shift;
122         return 1 if (util::has_property($e, "length_is"));
123         return 0;
124 }
125
126 # return 1 if this is a surrounding array (sometimes 
127 # referred to as an embedded array). Can only occur as 
128 # the last element in a struct and can not contain any pointers.
129 sub is_surrounding_array($)
130 {
131         my $e = shift;
132
133         return ($e->{POINTERS} == 0 
134                 and defined $e->{ARRAY_LEN} 
135                 and     $e->{ARRAY_LEN} eq "*"
136                 and $e == $e->{PARENT}->{ELEMENTS}[-1] 
137                 and $e->{PARENT}->{TYPE} ne "FUNCTION");
138 }
139
140 sub array_type($)
141 {
142         my $e = shift;
143
144         return "conformant-varying" if (is_varying_array($e) and is_conformant_array($e));
145         return "conformant" if (is_varying_array($e));
146         return "varying" if (is_varying_array($e));
147         return "inline" if (is_inline_array($e));
148         return "fixed" if (is_fixed_array($e));
149
150         return undef;
151 }
152
153 # determine if an element needs a reference pointer on the wire
154 # in its NDR representation
155 sub need_wire_pointer($)
156 {
157         my $e = shift;
158
159         my $n = $e->{POINTERS};
160         my $pt = pointer_type($e);
161
162         if (    defined($pt) 
163                 and $pt eq "ref" 
164                 and $e->{PARENT}->{TYPE} eq "FUNCTION") 
165         {
166                 $n--;
167         }
168
169         return $n;
170 }
171
172 # determine if an element is a pure scalar. pure scalars do not
173 # have a "buffers" section in NDR
174 sub is_pure_scalar($)
175 {
176         my $e = shift;
177         if (is_scalar_type($e->{TYPE}) && 
178             need_wire_pointer($e) == 0 && 
179             !util::array_size($e)) {
180                 return 1;
181         }
182         return 0;
183 }
184
185 # see if a variable needs to be allocated by the NDR subsystem on pull
186 sub need_alloc($)
187 {
188         my $e = shift;
189
190         return 0 if (util::has_property($e, "ref"));
191         return 1 if ($e->{POINTERS} || util::array_size($e));
192         return 0;
193 }
194
195 sub c_ptr_prefix($)
196 {
197         my $e = shift;
198         my $pointers = "";
199         foreach my $i (need_wire_pointer($e)..$e->{POINTERS}-1) { $pointers.="*"; }
200         return $pointers;
201 }
202
203 # determine the C prefix used to refer to a variable when passing to a push
204 # function. This will be '*' for pointers to scalar types, '' for scalar
205 # types and normal pointers and '&' for pass-by-reference structures
206 sub c_push_prefix($)
207 {
208         my $e = shift;
209
210         my $ret = "";
211
212         if ($e->{TYPE} =~ "string") {
213                 $ret = "";
214         } elsif (is_scalar_type($e->{TYPE}) &&
215             $e->{POINTERS}) {
216                 $ret = "*";
217         } elsif (!is_scalar_type($e->{TYPE}) &&
218             !$e->{POINTERS} &&
219             !util::array_size($e)) {
220                 return "&";
221         }
222
223         foreach my $i (2..$e->{POINTERS}) { $ret.="*"; }
224         
225         return $ret;
226 }
227
228 # determine the C prefix used to refer to a variable when passing to a pull
229 # return '&' or ''
230 sub c_pull_prefix($)
231 {
232         my $e = shift;
233
234         if (!$e->{POINTERS} && !util::array_size($e)) {
235                 return "&";
236         }
237
238         if ($e->{TYPE} =~ "string") {
239                 return "&";
240         }
241
242         my $ret = "";
243         foreach my $i (2..$e->{POINTERS}) { $ret.="*"; }
244         return $ret;
245 }
246 my $res = "";
247 my $tabs = "";
248 sub pidl($)
249 {
250         my $d = shift;
251         if ($d) {
252                 $res .= $tabs;
253                 $res .= $d;
254         }
255         $res .="\n";
256 }
257
258 sub indent
259 {
260         $tabs .= "\t";
261 }
262
263 sub deindent
264 {
265         $tabs = substr($tabs, 0, -1);
266 }
267
268 ###################################
269 # find a sibling var in a structure
270 sub find_sibling($$)
271 {
272         my($e) = shift;
273         my($name) = shift;
274         my($fn) = $e->{PARENT};
275
276         if ($name =~ /\*(.*)/) {
277                 $name = $1;
278         }
279
280         for my $e2 (@{$fn->{ELEMENTS}}) {
281                 return $e2 if ($e2->{NAME} eq $name);
282         }
283
284         die "invalid sibling '$name'";
285 }
286
287 ####################################################################
288 # work out the name of a size_is() variable
289 sub ParseExpr($$$)
290 {
291         my($e) = shift;
292         my($size) = shift;
293         my($var_prefix) = shift;
294
295         my($fn) = $e->{PARENT};
296
297         return $size if (util::is_constant($size));
298
299         return $size if ($size =~ /ndr->|\(/);
300
301         my $prefix = "";
302
303         if ($size =~ /\*(.*)/) {
304                 $size = $1;
305                 $prefix = "*";
306         }
307
308         if ($fn->{TYPE} ne "FUNCTION") {
309                 return $prefix . "r->$size";
310         }
311
312         my $e2 = find_sibling($e, $size);
313
314         if (util::has_property($e2, "in") && util::has_property($e2, "out")) {
315                 return $prefix . "$var_prefix$size";
316         }
317         
318         if (util::has_property($e2, "in")) {
319                 return $prefix . "r->in.$size";
320         }
321         
322         if (util::has_property($e2, "out")) {
323                 return $prefix . "r->out.$size";
324         }
325
326         die "invalid variable in $size for element $e->{NAME} in $fn->{NAME}\n";
327 }
328
329 #####################################################################
330 # check that a variable we get from ParseExpr isn't a null pointer
331 sub check_null_pointer($)
332 {
333         my $size = shift;
334         if ($size =~ /^\*/) {
335                 my $size2 = substr($size, 1);
336                 pidl "if ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;";
337         }
338 }
339
340 #####################################################################
341 # check that a variable we get from ParseExpr isn't a null pointer
342 # void return varient
343 sub check_null_pointer_void($)
344 {
345         my $size = shift;
346         if ($size =~ /^\*/) {
347                 my $size2 = substr($size, 1);
348                 pidl "if ($size2 == NULL) return;";
349         }
350 }
351
352 #####################################################################
353 # work out is a parse function should be declared static or not
354 sub fn_prefix($)
355 {
356         my $fn = shift;
357         if ($fn->{TYPE} eq "TYPEDEF") {
358                 if (util::has_property($fn, "public")) {
359                         return "";
360                 }
361         }
362
363         if ($fn->{TYPE} eq "FUNCTION") {
364                 if (util::has_property($fn, "public")) {
365                         return "";
366                 }
367         }
368         return "static ";
369 }
370
371 ###################################################################
372 # setup any special flags for an element or structure
373 sub start_flags($)
374 {
375         my $e = shift;
376         my $flags = util::has_property($e, "flag");
377         if (defined $flags) {
378                 pidl "{ uint32_t _flags_save_$e->{TYPE} = ndr->flags;";
379                 pidl "ndr_set_flags(&ndr->flags, $flags);";
380         }
381 }
382
383 ###################################################################
384 # end any special flags for an element or structure
385 sub end_flags($)
386 {
387         my $e = shift;
388         my $flags = util::has_property($e, "flag");
389         if (defined $flags) {
390                 pidl "ndr->flags = _flags_save_$e->{TYPE};\n\t}";
391         }
392 }
393
394 #####################################################################
395 # work out the correct alignment for a structure or union
396 sub find_largest_alignment($)
397 {
398         my $s = shift;
399
400         my $align = 1;
401         for my $e (@{$s->{ELEMENTS}}) {
402                 my $a = 1;
403
404                 if (need_wire_pointer($e)) {
405                         $a = 4; 
406                 } else { 
407                         $a = align_type($e->{TYPE}); 
408                 }
409
410                 $align = $a if ($align < $a);
411         }
412
413         return $align;
414 }
415
416 #####################################################################
417 # align a type
418 sub align_type
419 {
420         my $e = shift;
421
422         unless (typelist::hasType($e)) {
423             # it must be an external type - all we can do is guess 
424                 # print "Warning: assuming alignment of unknown type '$e' is 4\n";
425             return 4;
426         }
427
428         my $dt = typelist::getType($e)->{DATA};
429
430         my $tmp = $typefamily{$dt->{TYPE}}->{ALIGN}->($dt);
431         return $tmp;
432 }
433
434 #####################################################################
435 # parse array preceding data - push side
436 sub ParseArrayPushPreceding($$$)
437 {
438         my $e = shift;
439         my $var_prefix = shift;
440         my $ndr_flags = shift;
441
442         my $size = ParseExpr($e, util::array_size($e), $var_prefix);
443
444         if (!is_inline_array($e)) {
445                 # we need to emit the array size
446                 pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $size));";
447         }
448 }
449
450 #####################################################################
451 # parse the data of an array - push side
452 sub ParseArrayPush($$$)
453 {
454         my $e = shift;
455         my $var_prefix = shift;
456         my $ndr_flags = shift;
457
458         my $size = ParseExpr($e, util::array_size($e), $var_prefix);
459
460         if (!is_surrounding_array($e)) {
461                 ParseArrayPushPreceding($e, $var_prefix, $ndr_flags);
462         }
463         
464         if (is_varying_array($e)) {
465                 my $length = util::has_property($e, "length_is");
466                 $length = ParseExpr($e, $length, $var_prefix);
467                 pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));";
468                 pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $length));";
469                 $size = $length;
470         }
471
472         if (is_scalar_type($e->{TYPE})) {
473                 pidl "NDR_CHECK(ndr_push_array_$e->{TYPE}(ndr, $ndr_flags, $var_prefix$e->{NAME}, $size));";
474         } else {
475                 pidl "NDR_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}));";
476         }
477 }
478
479 #####################################################################
480 # print an array
481 sub ParseArrayPrint($$)
482 {
483         my $e = shift;
484         my $var_prefix = shift;
485         my $size = ParseExpr($e, util::array_size($e), $var_prefix);
486
487         if (is_varying_array($e)) {
488                 $size = ParseExpr($e, util::has_property($e, "length_is"), $var_prefix);
489         }
490
491         if (is_scalar_type($e->{TYPE})) {
492                 pidl "ndr_print_array_$e->{TYPE}(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME}, $size);";
493         } else {
494                 pidl "ndr_print_array(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME}, sizeof($var_prefix$e->{NAME}\[0]), $size, (ndr_print_fn_t)ndr_print_$e->{TYPE});";
495         }
496 }
497
498 #####################################################################
499 # check the size_is and length_is constraints
500 sub CheckArraySizes($$)
501 {
502         my $e = shift;
503         my $var_prefix = shift;
504
505         if (!is_surrounding_array($e) && is_conformant_array($e)) {
506                 my $size = ParseExpr($e, util::array_size($e), $var_prefix);
507                 pidl "if ($var_prefix$e->{NAME}) {";
508                 indent;
509                 check_null_pointer($size);
510                 pidl "NDR_CHECK(ndr_check_array_size(ndr, (void*)&$var_prefix$e->{NAME}, $size));";
511                 deindent;
512                 pidl "}";
513         }
514
515         if (is_varying_array($e)) {
516                 my $length = util::has_property($e, "length_is");
517                 $length = ParseExpr($e, $length, $var_prefix);
518                 pidl "if ($var_prefix$e->{NAME}) {";
519                 indent;
520                 check_null_pointer($length);
521                 pidl "NDR_CHECK(ndr_check_array_length(ndr, (void*)&$var_prefix$e->{NAME}, $length));";
522                 deindent;
523                 pidl "}"
524         }
525 }
526
527 sub ParseArrayPullPreceding($$$)
528 {
529         my $e = shift;
530         my $var_prefix = shift;
531         my $ndr_flags = shift;
532
533         if (!is_inline_array($e)) {
534                 # non fixed arrays encode the size just before the array
535                 pidl "NDR_CHECK(ndr_pull_array_size(ndr, &$var_prefix$e->{NAME}));";
536         }
537 }
538
539 #####################################################################
540 # parse an array - pull side
541 sub ParseArrayPull($$$)
542 {
543         my $e = shift;
544         my $var_prefix = shift;
545         my $ndr_flags = shift;
546
547         my $size = ParseExpr($e, util::array_size($e), $var_prefix);
548         my $alloc_size = $size;
549
550         # if this is a conformant array then we use that size to allocate, and make sure
551         # we allocate enough to pull the elements
552         if (is_conformant_array($e) and is_surrounding_array($e)) {
553                 $alloc_size = "ndr_get_array_size(ndr, &$var_prefix$e->{NAME})";
554                 check_null_pointer($size);
555                 pidl "if ($size > $alloc_size) {";
556                 indent;
557                 pidl "return ndr_pull_error(ndr, NDR_ERR_CONFORMANT_SIZE, \"Bad conformant size %u should be %u\", $alloc_size, $size);";
558                 deindent;
559                 pidl "}";
560         } elsif (!is_inline_array($e)) {
561                 if ($var_prefix =~ /^r->out/ && $size =~ /^\*r->in/) {
562                         my $size2 = substr($size, 1);
563                         pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { NDR_ALLOC(ndr, $size2); }";
564                 }
565
566                 ParseArrayPullPreceding($e, $var_prefix, $ndr_flags);
567
568                 $alloc_size = "ndr_get_array_size(ndr, &$var_prefix$e->{NAME})";
569         }
570
571         if ((need_alloc($e) && !is_fixed_array($e)) ||
572             ($var_prefix eq "r->in." && util::has_property($e, "ref"))) {
573                 if (!is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") {
574                         pidl "NDR_ALLOC_N(ndr, $var_prefix$e->{NAME}, $alloc_size);";
575                 }
576         }
577
578         if (($var_prefix eq "r->out." && util::has_property($e, "ref"))) {
579                 if (!is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") {
580                         pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {";
581                         indent;
582                         pidl "NDR_ALLOC_N(ndr, $var_prefix$e->{NAME}, $alloc_size);";
583                         deindent;
584                         pidl "}";
585                 }
586         }
587
588         if (is_varying_array($e)) {
589                 pidl "NDR_CHECK(ndr_pull_array_length(ndr, &$var_prefix$e->{NAME}));";
590                 $size = "ndr_get_array_length(ndr, &$var_prefix$e->{NAME})";
591         }
592
593         check_null_pointer($size);
594
595         if (is_scalar_type($e->{TYPE})) {
596                 pidl "NDR_CHECK(ndr_pull_array_$e->{TYPE}(ndr, $ndr_flags, $var_prefix$e->{NAME}, $size));";
597         } else {
598                 pidl "NDR_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}));";
599         }
600 }
601
602 #####################################################################
603 # parse scalars in a structure element
604 sub ParseElementPushScalar($$$)
605 {
606         my($e) = shift;
607         my($var_prefix) = shift;
608         my($ndr_flags) = shift;
609         my $cprefix = c_push_prefix($e);
610         my $ptr_prefix = c_ptr_prefix($e);
611         my $sub_size = util::has_property($e, "subcontext");
612
613         start_flags($e);
614
615         if (my $value = util::has_property($e, "value")) {
616                 pidl "$cprefix$var_prefix$e->{NAME} = $value;";
617         }
618
619         if (util::has_property($e, "relative")) {
620                 pidl "NDR_CHECK(ndr_push_relative_ptr1(ndr, $ptr_prefix$var_prefix$e->{NAME}));";
621         } elsif (need_wire_pointer($e)) {
622                 ParseElementPushPtr($e, $ptr_prefix.$var_prefix, "NDR_SCALARS");
623         } elsif (is_inline_array($e)) {
624                 ParseArrayPush($e, "r->", "NDR_SCALARS");
625         } elsif (need_alloc($e)) {
626                 # no scalar component
627         } elsif (my $switch = util::has_property($e, "switch_is")) {
628                 ParseElementPushSwitch($e, $var_prefix, $ndr_flags, $switch);
629         } elsif (defined $sub_size) {
630                 pidl "NDR_CHECK(ndr_push_subcontext_flags_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_push_flags_fn_t) ndr_push_$e->{TYPE}));";
631         } else {
632                 pidl "NDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));";
633         }
634
635         end_flags($e);
636 }
637
638 #####################################################################
639 # parse a pointer in a struct element or function
640 sub ParseElementPushPtr($$$)
641 {
642         my $e = shift;
643         my $var_prefix = shift;
644         my $ndr_flags = shift;
645
646         pidl "NDR_CHECK(ndr_push_unique_ptr(ndr, $var_prefix$e->{NAME}));";
647 }
648
649 #####################################################################
650 # print scalars in a structure element
651 sub ParseElementPrint($$)
652 {
653         my($e) = shift;
654         my($var_prefix) = shift;
655         my $cprefix = c_push_prefix($e);
656         my $ptr_prefix = c_ptr_prefix($e);
657
658         return if (util::has_property($e, "noprint"));
659
660         if (my $value = util::has_property($e, "value")) {
661                 pidl "if (ndr->flags & LIBNDR_PRINT_SET_VALUES) {";
662                 indent;
663                 pidl "$cprefix$var_prefix$e->{NAME} = $value;";
664                 deindent;
665                 pidl "}";
666         }
667
668         my $l = $e->{POINTERS};
669         $l++ if (util::array_size($e) and $l == 0 and !is_fixed_array($e));
670
671         foreach my $i (1..$l) {
672                 pidl "ndr_print_ptr(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME});";
673                 pidl "ndr->depth++;";
674                 if ($i > $l-need_wire_pointer($e)) {
675                         pidl "if ($ptr_prefix$var_prefix$e->{NAME}) {";
676                         indent;
677                 }
678         }
679
680         if (util::array_size($e)) {
681                 ParseArrayPrint($e, $var_prefix)
682         } elsif (my $switch = util::has_property($e, "switch_is")) {
683                 my $switch_var = ParseExpr($e, $switch, $var_prefix);
684                 check_null_pointer_void($switch_var);
685
686                 pidl "ndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $switch_var, $cprefix$var_prefix$e->{NAME});";
687         } else {
688                 pidl "ndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME});";
689         }
690
691         foreach my $i (1..$l) {
692                 if ($i > $l-need_wire_pointer($e)) {
693                         deindent;
694                         pidl "}";
695                 }
696                 pidl "ndr->depth--;";
697         }
698 }
699
700 #####################################################################
701 # parse scalars in a structure element - pull size
702 sub ParseElementPullSwitch($$$$)
703 {
704         my($e) = shift;
705         my($var_prefix) = shift;
706         my($ndr_flags) = shift;
707         my $switch = shift;
708         my $switch_var = ParseExpr($e, $switch, $var_prefix);
709
710         my $cprefix = c_pull_prefix($e);
711
712         my $utype = typelist::getType($e->{TYPE});
713
714         check_null_pointer($switch_var);
715
716         if (!defined $utype ||
717             !util::has_property($utype, "nodiscriminant")) {
718                 my $e2 = find_sibling($e, $switch);
719                 my $type_decl = typelist::mapType($e2);
720                 pidl "if (($ndr_flags) & NDR_SCALARS) {";
721                 indent;
722                 if (typelist::getType($e2->{TYPE})->{DATA}->{TYPE} eq "ENUM") {
723                         $type_decl = typelist::mapType($e2);
724                 } elsif (typelist::getType($e2->{TYPE})->{DATA}->{TYPE} eq "BITMAP") {
725                         $type_decl = typelist::mapType($e2);
726                 }
727                 pidl "$type_decl _level;";
728                 pidl "NDR_CHECK(ndr_pull_$e2->{TYPE}(ndr, NDR_SCALARS, &_level));";
729                 if ($switch_var =~ /r->in/) {
730                         pidl "if (!(ndr->flags & LIBNDR_FLAG_REF_ALLOC) && _level != $switch_var) {";
731                         indent;
732                 } else {
733                         pidl "if (_level != $switch_var) {"; 
734                         indent;
735                 }
736                 pidl "return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u in $e->{NAME}\", _level);";
737                 deindent;
738                 if ($switch_var =~ /r->/) {
739                         pidl "} else { $switch_var = _level; }";
740                 } else {
741                         pidl "}";
742                 }
743                 deindent;
744                 pidl "}";
745         }
746
747         my $sub_size = util::has_property($e, "subcontext");
748         if (defined $sub_size) {
749                 pidl "if (($ndr_flags) & NDR_SCALARS) {";
750                 indent;
751                 pidl "NDR_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}));";
752                 deindent;
753                 pidl "}";
754         } else {
755                 pidl "NDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $switch_var, $cprefix$var_prefix$e->{NAME}));";
756         }
757
758
759 }
760
761 #####################################################################
762 # push switch element
763 sub ParseElementPushSwitch($$$$)
764 {
765         my($e) = shift;
766         my($var_prefix) = shift;
767         my($ndr_flags) = shift;
768         my $switch = shift;
769         my $switch_var = ParseExpr($e, $switch, $var_prefix);
770         my $cprefix = c_push_prefix($e);
771
772         check_null_pointer($switch_var);
773
774         my $utype = typelist::getType($e->{TYPE});
775         if (!defined $utype ||
776             !util::has_property($utype, "nodiscriminant")) {
777                 my $e2 = find_sibling($e, $switch);
778                 pidl "if (($ndr_flags) & NDR_SCALARS) {";
779                 indent;
780                 pidl "NDR_CHECK(ndr_push_$e2->{TYPE}(ndr, NDR_SCALARS, $switch_var));";
781                 deindent;
782                 pidl "}";
783         }
784
785         my $sub_size = util::has_property($e, "subcontext");
786         if (defined $sub_size) {
787                 pidl "if(($ndr_flags) & NDR_SCALARS) {";
788                 indent;
789                 pidl "NDR_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}));";
790                 deindent;
791                 pidl "}";
792         } else {
793                 pidl "NDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $switch_var, $cprefix$var_prefix$e->{NAME}));";
794         }
795 }
796
797 #####################################################################
798 # parse scalars in a structure element - pull size
799 sub ParseElementPullScalar($$$)
800 {
801         my($e) = shift;
802         my($var_prefix) = shift;
803         my($ndr_flags) = shift;
804         my $cprefix = c_pull_prefix($e);
805         my $ptr_prefix = c_ptr_prefix($e);
806         my $sub_size = util::has_property($e, "subcontext");
807
808         start_flags($e);
809
810         if (is_inline_array($e)) {
811                 ParseArrayPull($e, "r->", "NDR_SCALARS");
812         } elsif (need_wire_pointer($e)) {
813                 ParseElementPullPtr($e, $ptr_prefix.$var_prefix, "NDR_SCALARS");
814         } elsif (is_surrounding_array($e)) {
815         } elsif (my $switch = util::has_property($e, "switch_is")) {
816                 ParseElementPullSwitch($e, $var_prefix, $ndr_flags, $switch);
817         } elsif (defined $sub_size) {
818                 pidl "NDR_CHECK(ndr_pull_subcontext_flags_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_flags_fn_t) ndr_pull_$e->{TYPE}));";
819         } else {
820                 pidl "NDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));";
821         }
822
823         if (my $range = util::has_property($e, "range")) {
824                 my ($low, $high) = split(/ /, $range, 2);
825                 pidl "if ($var_prefix$e->{NAME} < $low || $var_prefix$e->{NAME} > $high) {";
826                 pidl "\treturn ndr_pull_error(ndr, NDR_ERR_RANGE, \"value out of range\");";
827                 pidl "}";
828         }
829
830         end_flags($e);
831 }
832
833 #####################################################################
834 # parse a pointer in a struct element or function
835 sub ParseElementPullPtr($$$)
836 {
837         my($e) = shift;
838         my($var_prefix) = shift;
839         my($ndr_flags) = shift;
840
841         pidl "NDR_CHECK(ndr_pull_unique_ptr(ndr, &_ptr_$e->{NAME}));";
842         pidl "if (_ptr_$e->{NAME}) {";
843         indent;
844         pidl "NDR_ALLOC(ndr, $var_prefix$e->{NAME});";
845         if (util::has_property($e, "relative")) {
846                 pidl "NDR_CHECK(ndr_pull_relative_ptr1(ndr, $var_prefix$e->{NAME}, _ptr_$e->{NAME}));";
847         }
848         deindent;
849         pidl "} else {";
850         pidl "\t$var_prefix$e->{NAME} = NULL;";
851         pidl "}";
852 }
853
854 #####################################################################
855 # parse buffers in a structure element
856 sub ParseElementPushBuffer($$$)
857 {
858         my($e) = shift;
859         my($var_prefix) = shift;
860         my($ndr_flags) = shift;
861         my $cprefix = c_push_prefix($e);
862         my $sub_size = util::has_property($e, "subcontext");
863
864         return if (is_pure_scalar($e));
865
866         start_flags($e);
867
868         my $pointers = c_ptr_prefix($e);
869         for my $i (1..need_wire_pointer($e)) {
870                 if ($i > 1) {
871                         ParseElementPushPtr($e,$pointers.$var_prefix,$ndr_flags);
872                 }
873                 pidl "if ($pointers$var_prefix$e->{NAME}) {";
874                 indent;
875                 $pointers.="*";
876         }
877                 
878         if (util::has_property($e, "relative")) {
879                 pidl "NDR_CHECK(ndr_push_relative_ptr2(ndr, $var_prefix$e->{NAME}));";
880         }
881             
882         if (is_inline_array($e)) {
883                 ParseArrayPush($e, "r->", "NDR_BUFFERS");
884         } elsif (util::array_size($e)) {
885                 ParseArrayPush($e, "r->", "NDR_SCALARS|NDR_BUFFERS");
886         } elsif (my $switch = util::has_property($e, "switch_is")) {
887                 if ($e->{POINTERS}) {
888                         ParseElementPushSwitch($e, $var_prefix, "NDR_BUFFERS|NDR_SCALARS", $switch);
889                 } else {
890                         ParseElementPushSwitch($e, $var_prefix, "NDR_BUFFERS", $switch);
891                 }
892         } elsif (defined $sub_size) {
893                 if ($e->{POINTERS}) {
894                         pidl "NDR_CHECK(ndr_push_subcontext_flags_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_push_flags_fn_t) ndr_push_$e->{TYPE}));";
895                 }
896         } elsif ($e->{POINTERS}) {
897                 pidl "NDR_CHECK(ndr_push_$e->{TYPE}(ndr, NDR_SCALARS|NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}));";
898         } else {
899                 pidl "NDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));";
900         }
901
902         for my $i (1..need_wire_pointer($e)) {
903                 deindent;
904                 pidl "}";
905         }
906
907         end_flags($e);
908 }
909
910 #####################################################################
911 # parse buffers in a structure element - pull side
912 sub ParseElementPullBuffer($$$)
913 {
914         my($e) = shift;
915         my($var_prefix) = shift;
916         my($ndr_flags) = shift;
917         my $cprefix = c_pull_prefix($e);
918         my $sub_size = util::has_property($e, "subcontext");
919
920         return if (is_pure_scalar($e));
921
922         start_flags($e);
923
924         my $pointers = c_ptr_prefix($e);
925         for my $i (1..need_wire_pointer($e)) {
926                 if ($i > 1) {
927                         ParseElementPullPtr($e,$pointers.$var_prefix,"NDR_SCALARS");
928                 }
929                 pidl "if ($pointers$var_prefix$e->{NAME}) {";
930                 indent;
931                 $pointers.="*";
932         }
933  
934         if (util::has_property($e, "relative")) {
935                 pidl "struct ndr_pull_save _relative_save;";
936                 pidl "ndr_pull_save(ndr, &_relative_save);";
937                 pidl "NDR_CHECK(ndr_pull_relative_ptr2(ndr, $var_prefix$e->{NAME}));";
938         }
939             
940         if (is_inline_array($e)) {
941                 ParseArrayPull($e, "r->", "NDR_BUFFERS");
942         } elsif (util::array_size($e)) {
943                 ParseArrayPull($e, "r->", "NDR_SCALARS|NDR_BUFFERS");
944         } elsif (my $switch = util::has_property($e, "switch_is")) {
945                 if ($e->{POINTERS}) {
946                         ParseElementPullSwitch($e, $var_prefix, "NDR_SCALARS|NDR_BUFFERS", $switch);
947                 } else {
948                         ParseElementPullSwitch($e, $var_prefix, "NDR_BUFFERS", $switch);
949                 }
950         } elsif (defined $sub_size) {
951                 if ($e->{POINTERS}) {
952                         pidl "NDR_CHECK(ndr_pull_subcontext_flags_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_flags_fn_t) ndr_pull_$e->{TYPE}));";
953                 }
954         } elsif ($e->{POINTERS}) {
955                 pidl "NDR_CHECK(ndr_pull_$e->{TYPE}(ndr, NDR_SCALARS|NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}));";
956         } else {
957                 pidl "NDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));";
958         }
959
960         if (util::has_property($e, "relative")) {
961                 pidl "ndr_pull_restore(ndr, &_relative_save);";
962         }
963         for my $i (1..need_wire_pointer($e)) {
964                 deindent;
965                 pidl "}";
966         }
967
968         end_flags($e);
969 }
970
971 #####################################################################
972 # parse a struct
973 sub ParseStructPush($)
974 {
975         my($struct) = shift;
976         
977         return unless defined($struct->{ELEMENTS});
978
979         start_flags($struct);
980
981         # see if the structure contains a conformant array. If it
982         # does, then it must be the last element of the structure, and
983         # we need to push the conformant length early, as it fits on
984         # the wire before the structure (and even before the structure
985         # alignment)
986         my $e = $struct->{ELEMENTS}[-1];
987         if (is_conformant_array($e) and is_surrounding_array($e)) {
988                 ParseArrayPushPreceding($e, "r->", "NDR_SCALARS");
989         }
990
991         if (defined $e->{TYPE} && $e->{TYPE} eq "string" 
992             &&  util::property_matches($e, "flag", ".*LIBNDR_FLAG_STR_CONFORMANT.*")) {
993                 pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_string_array_size(ndr, r->$e->{NAME})));";
994         }
995
996         pidl "if (!(ndr_flags & NDR_SCALARS)) goto buffers;";
997
998         pidl "NDR_CHECK(ndr_push_struct_start(ndr));";
999
1000         my $align = find_largest_alignment($struct);
1001         pidl "NDR_CHECK(ndr_push_align(ndr, $align));";
1002
1003         foreach my $e (@{$struct->{ELEMENTS}}) {
1004                 ParseElementPushScalar($e, "r->", "NDR_SCALARS");
1005         }       
1006
1007         pidl "buffers:";
1008         pidl "if (!(ndr_flags & NDR_BUFFERS)) goto done;";
1009         foreach my $e (@{$struct->{ELEMENTS}}) {
1010                 ParseElementPushBuffer($e, "r->", "NDR_BUFFERS");
1011         }
1012
1013         pidl "ndr_push_struct_end(ndr);";
1014
1015         pidl "done:";
1016
1017         end_flags($struct);
1018 }
1019
1020 #####################################################################
1021 # generate a push function for an enum
1022 sub ParseEnumPush($)
1023 {
1024         my($enum) = shift;
1025         my($type_fn) = typelist::enum_type_fn($enum);
1026
1027         start_flags($enum);
1028
1029         pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));";
1030
1031         end_flags($enum);
1032 }
1033
1034 #####################################################################
1035 # generate a pull function for an enum
1036 sub ParseEnumPull($)
1037 {
1038         my($enum) = shift;
1039         my($type_fn) = typelist::enum_type_fn($enum);
1040         my($type_v_decl) = typelist::mapScalarType(typelist::enum_type_fn($enum));
1041
1042         pidl "$type_v_decl v;";
1043         start_flags($enum);
1044         pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));";
1045         pidl "*r = v;";
1046
1047         end_flags($enum);
1048 }
1049
1050 #####################################################################
1051 # generate a print function for an enum
1052 sub ParseEnumPrint($)
1053 {
1054         my($enum) = shift;
1055
1056         pidl "const char *val = NULL;";
1057         pidl "";
1058
1059         start_flags($enum);
1060
1061         pidl "switch (r) {";
1062         indent;
1063         my $els = \@{$enum->{ELEMENTS}};
1064         foreach my $i (0 .. $#{$els}) {
1065                 my $e = ${$els}[$i];
1066                 chomp $e;
1067                 if ($e =~ /^(.*)=/) {
1068                         $e = $1;
1069                 }
1070                 pidl "case $e: val = \"$e\"; break;";
1071         }
1072
1073         deindent;
1074         pidl "}";
1075         
1076         pidl "ndr_print_enum(ndr, name, \"$enum->{TYPE}\", val, r);";
1077
1078         end_flags($enum);
1079 }
1080
1081 sub ArgsEnumPush($)
1082 {
1083         my $e = shift;
1084         return "struct ndr_push *ndr, int ndr_flags, enum $e->{NAME} r";
1085 }
1086
1087 sub ArgsEnumPrint($)
1088 {
1089         my $e = shift;
1090         return "struct ndr_print *ndr, const char *name, enum $e->{NAME} r";
1091 }
1092
1093 sub ArgsEnumPull($)
1094 {
1095         my $e = shift;
1096         return "struct ndr_pull *ndr, int ndr_flags, enum $e->{NAME} *r";
1097 }
1098
1099 $typefamily{ENUM} = {
1100         PUSH_FN_BODY => \&ParseEnumPush,
1101         PUSH_FN_ARGS => \&ArgsEnumPush,
1102         PULL_FN_BODY => \&ParseEnumPull,
1103         PULL_FN_ARGS => \&ArgsEnumPull,
1104         PRINT_FN_BODY => \&ParseEnumPrint,
1105         PRINT_FN_ARGS => \&ArgsEnumPrint,
1106         ALIGN => sub { return align_type(typelist::enum_type_fn(shift)); }
1107 };
1108
1109 #####################################################################
1110 # generate a push function for a bitmap
1111 sub ParseBitmapPush($)
1112 {
1113         my($bitmap) = shift;
1114         my($type_fn) = typelist::bitmap_type_fn($bitmap);
1115
1116         start_flags($bitmap);
1117
1118         pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));";
1119
1120         end_flags($bitmap);
1121 }
1122
1123 #####################################################################
1124 # generate a pull function for an bitmap
1125 sub ParseBitmapPull($)
1126 {
1127         my($bitmap) = shift;
1128         my($type_fn) = typelist::bitmap_type_fn($bitmap);
1129         my($type_decl) = typelist::mapType($bitmap);
1130
1131         pidl "$type_decl v;";
1132         start_flags($bitmap);
1133         pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));";
1134         pidl "*r = v;";
1135
1136         end_flags($bitmap);
1137 }
1138
1139 #####################################################################
1140 # generate a print function for an bitmap
1141 sub ParseBitmapPrintElement($$)
1142 {
1143         my($e) = shift;
1144         my($bitmap) = shift;
1145         my($type_decl) = typelist::mapType($bitmap);
1146         my($type_fn) = typelist::bitmap_type_fn($bitmap);
1147         my($name) = $bitmap->{PARENT}->{NAME};
1148         my($flag);
1149
1150         if ($e =~ /^(\w+) .*$/) {
1151                 $flag = "$1";
1152         } else {
1153                 die "Bitmap: \"$name\" invalid Flag: \"$e\"";
1154         }
1155
1156         pidl "ndr_print_bitmap_flag(ndr, sizeof($type_decl), \"$flag\", $flag, r);";
1157 }
1158
1159 #####################################################################
1160 # generate a print function for an bitmap
1161 sub ParseBitmapPrint($)
1162 {
1163         my($bitmap) = shift;
1164         my($type_decl) = typelist::mapType($bitmap);
1165         my($type_fn) = typelist::bitmap_type_fn($bitmap);
1166
1167         start_flags($bitmap);
1168
1169         pidl "ndr_print_$type_fn(ndr, name, r);";
1170
1171         pidl "ndr->depth++;";
1172         foreach my $e (@{$bitmap->{ELEMENTS}}) {
1173                 ParseBitmapPrintElement($e, $bitmap);
1174         }
1175         pidl "ndr->depth--;";
1176
1177         end_flags($bitmap);
1178 }
1179
1180 sub ArgsBitmapPush($)
1181 {
1182         my $e = shift;
1183         my $type_decl = typelist::mapType($e->{DATA});
1184         return "struct ndr_push *ndr, int ndr_flags, $type_decl r";
1185 }
1186
1187 sub ArgsBitmapPrint($)
1188 {
1189         my $e = shift;
1190         my $type_decl = typelist::mapType($e->{DATA});
1191         return "struct ndr_print *ndr, const char *name, $type_decl r";
1192 }
1193
1194 sub ArgsBitmapPull($)
1195 {
1196         my $e = shift;
1197         my $type_decl = typelist::mapType($e->{DATA});
1198         return "struct ndr_pull *ndr, int ndr_flags, $type_decl *r";
1199 }
1200
1201 $typefamily{BITMAP} = {
1202         PUSH_FN_BODY => \&ParseBitmapPush,
1203         PUSH_FN_ARGS => \&ArgsBitmapPush,
1204         PULL_FN_BODY => \&ParseBitmapPull,
1205         PULL_FN_ARGS => \&ArgsBitmapPull,
1206         PRINT_FN_BODY => \&ParseBitmapPrint,
1207         PRINT_FN_ARGS => \&ArgsBitmapPrint,
1208         ALIGN => sub { return align_type(typelist::bitmap_type_fn(shift)); }
1209 };
1210
1211 #####################################################################
1212 # generate a struct print function
1213 sub ParseStructPrint($)
1214 {
1215         my($struct) = shift;
1216         my($name) = $struct->{PARENT}->{NAME};
1217
1218         return unless defined $struct->{ELEMENTS};
1219
1220         pidl "ndr_print_struct(ndr, name, \"$name\");";
1221
1222         start_flags($struct);
1223
1224         pidl "ndr->depth++;";
1225         foreach my $e (@{$struct->{ELEMENTS}}) {
1226                 ParseElementPrint($e, "r->");
1227         }
1228         pidl "ndr->depth--;";
1229
1230         end_flags($struct);
1231 }
1232
1233 #####################################################################
1234 # parse a struct - pull side
1235 sub ParseStructPull($)
1236 {
1237         my($struct) = shift;
1238         my $conform_e;
1239
1240         return unless defined $struct->{ELEMENTS};
1241
1242         # see if the structure contains a conformant array. If it
1243         # does, then it must be the last element of the structure, and
1244         # we need to pull the conformant length early, as it fits on
1245         # the wire before the structure (and even before the structure
1246         # alignment)
1247         my $e = $struct->{ELEMENTS}[-1];
1248         if (is_conformant_array($e) and is_surrounding_array($e)) {
1249                 $conform_e = $e;
1250         }
1251
1252         if (defined $e->{TYPE} && $e->{TYPE} eq "string"
1253             &&  util::property_matches($e, "flag", ".*LIBNDR_FLAG_STR_CONFORMANT.*")) {
1254                 $conform_e = $e;
1255         }
1256
1257         # declare any internal pointers we need
1258         foreach my $e (@{$struct->{ELEMENTS}}) {
1259                 if (need_wire_pointer($e)) {
1260                         pidl "uint32_t _ptr_$e->{NAME};";
1261                 }
1262         }
1263
1264         start_flags($struct);
1265
1266         pidl "if (!(ndr_flags & NDR_SCALARS)) goto buffers;";
1267
1268         pidl "NDR_CHECK(ndr_pull_struct_start(ndr));";
1269
1270         if (defined $conform_e) {
1271                 ParseArrayPullPreceding($conform_e, "r->", "NDR_SCALARS");
1272         }
1273
1274         my $align = find_largest_alignment($struct);
1275         pidl "NDR_CHECK(ndr_pull_align(ndr, $align));";
1276
1277         foreach my $e (@{$struct->{ELEMENTS}}) {
1278                 ParseElementPullScalar($e, "r->", "NDR_SCALARS");
1279         }       
1280
1281         pidl "buffers:\n";
1282         pidl "if (!(ndr_flags & NDR_BUFFERS)) goto done;";
1283         foreach my $e (@{$struct->{ELEMENTS}}) {
1284                 ParseElementPullBuffer($e, "r->", "NDR_BUFFERS");
1285         }
1286
1287         foreach my $e (@{$struct->{ELEMENTS}}) {
1288                 CheckArraySizes($e, "r->");
1289         }
1290
1291         pidl "ndr_pull_struct_end(ndr);";
1292
1293         pidl "done:";
1294
1295         end_flags($struct);
1296 }
1297
1298 #####################################################################
1299 # calculate size of ndr struct
1300 sub ParseStructNdrSize($)
1301 {
1302         my $t = shift;
1303         my $static = fn_prefix($t);
1304         my $sizevar;
1305
1306         pidl "size_t ndr_size_$t->{NAME}(const struct $t->{NAME} *r, int flags)";
1307         pidl "{";
1308         indent;
1309         if (my $flags = util::has_property($t, "flag")) {
1310                 pidl "flags |= $flags;";
1311         }
1312         pidl "return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});";
1313         deindent;
1314         pidl "}";
1315         pidl "";
1316 }
1317
1318 sub ArgsStructPush($)
1319 {
1320         my $e = shift;
1321         return "struct ndr_push *ndr, int ndr_flags, struct $e->{NAME} *r";
1322 }
1323
1324 sub ArgsStructPrint($)
1325 {
1326         my $e = shift;
1327         return "struct ndr_print *ndr, const char *name, struct $e->{NAME} *r";
1328 }
1329
1330 sub ArgsStructPull($)
1331 {
1332         my $e = shift;
1333         return "struct ndr_pull *ndr, int ndr_flags, struct $e->{NAME} *r";
1334 }
1335
1336 $typefamily{STRUCT} = {
1337         PUSH_FN_BODY => \&ParseStructPush,
1338         PUSH_FN_ARGS => \&ArgsStructPush,
1339         PULL_FN_BODY => \&ParseStructPull,
1340         PULL_FN_ARGS => \&ArgsStructPull,
1341         PRINT_FN_BODY => \&ParseStructPrint,
1342         PRINT_FN_ARGS => \&ArgsStructPrint,
1343         SIZE_FN => \&ParseStructNdrSize,
1344         ALIGN => \&find_largest_alignment
1345 };
1346
1347 #####################################################################
1348 # calculate size of ndr struct
1349 sub ParseUnionNdrSize($)
1350 {
1351         my $t = shift;
1352         my $static = fn_prefix($t);
1353         my $sizevar;
1354
1355         pidl "size_t ndr_size_$t->{NAME}(const union $t->{NAME} *r, int level, int flags)";
1356         pidl "{";
1357         indent;
1358         if (my $flags = util::has_property($t, "flag")) {
1359                 pidl "flags |= $flags;";
1360         }
1361         pidl "return ndr_size_union(r, flags, level, (ndr_push_union_fn_t)ndr_push_$t->{NAME});";
1362         deindent;
1363         pidl "}";
1364         pidl "";;
1365 }
1366
1367 #####################################################################
1368 # parse a union - push side
1369 sub ParseUnionPush($)
1370 {
1371         my $e = shift;
1372         my $have_default = 0;
1373
1374         start_flags($e);
1375
1376         pidl "if (!(ndr_flags & NDR_SCALARS)) goto buffers;";
1377
1378         pidl "NDR_CHECK(ndr_push_struct_start(ndr));";
1379
1380 #       my $align = union_alignment($e);
1381 #       pidl "NDR_CHECK(ndr_push_align(ndr, $align));";
1382
1383         pidl "switch (level) {";
1384         indent;
1385         foreach my $el (@{$e->{ELEMENTS}}) {
1386                 if (util::has_property($el, "default")) {
1387                         pidl "default:";
1388                         $have_default = 1;
1389                 } else {
1390                         pidl "case $el->{PROPERTIES}->{case}:";
1391
1392                 }
1393                 if ($el->{TYPE} ne "EMPTY") {
1394                         indent;
1395                         ParseElementPushScalar($el, "r->", "NDR_SCALARS");
1396                         deindent;
1397                 }
1398                 pidl "break;";
1399                 pidl "";
1400         }
1401         if (! $have_default) {
1402                 pidl "default:";
1403                 pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
1404         }
1405         deindent;
1406         pidl "}";
1407         pidl "buffers:";
1408         pidl "if (!(ndr_flags & NDR_BUFFERS)) goto done;";
1409         pidl "switch (level) {";
1410         indent;
1411         foreach my $el (@{$e->{ELEMENTS}}) {
1412                 if (util::has_property($el, "default")) {
1413                         pidl "default:";
1414                 } else {
1415                         pidl "case $el->{PROPERTIES}->{case}:";
1416                 }
1417                 if ($el->{TYPE} ne "EMPTY") {
1418                         indent;
1419                         ParseElementPushBuffer($el, "r->", "NDR_BUFFERS");
1420                         deindent;
1421                 }
1422                 pidl "break;";
1423                 pidl "";
1424         }
1425         if (! $have_default) {
1426                 pidl "default:";
1427                 pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
1428         }
1429         deindent;
1430         pidl "}";
1431         pidl "ndr_push_struct_end(ndr);";
1432         pidl "done:";
1433         end_flags($e);
1434 }
1435
1436 #####################################################################
1437 # print a union
1438 sub ParseUnionPrint($)
1439 {
1440         my $e = shift;
1441         my $have_default = 0;
1442         my($name) = $e->{PARENT}->{NAME};
1443
1444         pidl "ndr_print_union(ndr, name, level, \"$name\");";
1445         start_flags($e);
1446
1447         pidl "switch (level) {";
1448         indent;
1449         foreach my $el (@{$e->{ELEMENTS}}) {
1450                 if (util::has_property($el, "default")) {
1451                         $have_default = 1;
1452                         pidl "default:";
1453                 } else {
1454                         pidl "case $el->{PROPERTIES}->{case}:";
1455                 }
1456                 if ($el->{TYPE} ne "EMPTY") {
1457                         indent;
1458                         ParseElementPrint($el, "r->");
1459                         deindent;
1460                 }
1461                 pidl "break;";
1462                 pidl "";
1463         }
1464         if (! $have_default) {
1465                 pidl "default:";
1466                 pidl "\tndr_print_bad_level(ndr, name, level);";
1467         }
1468         deindent;
1469         pidl "}";
1470
1471         end_flags($e);
1472 }
1473
1474 #####################################################################
1475 # parse a union - pull side
1476 sub ParseUnionPull($)
1477 {
1478         my $e = shift;
1479         my $have_default = 0;
1480
1481         start_flags($e);
1482
1483         pidl "if (!(ndr_flags & NDR_SCALARS)) goto buffers;";
1484
1485         pidl "NDR_CHECK(ndr_pull_struct_start(ndr));";
1486
1487 #       my $align = union_alignment($e);
1488 #       pidl "\tNDR_CHECK(ndr_pull_align(ndr, $align));\n";
1489
1490         pidl "switch (level) {";
1491         indent;
1492         foreach my $el (@{$e->{ELEMENTS}}) {
1493                 if (util::has_property($el, "default")) {
1494                         pidl "default: {";
1495                         $have_default = 1;
1496                 } else {
1497                         pidl "case $el->{PROPERTIES}->{case}: {";
1498                 }
1499                 if ($el->{TYPE} ne "EMPTY") {
1500                         indent;
1501                         if ($el->{POINTERS}) {
1502                                 pidl "uint32_t _ptr_$el->{NAME};";
1503                         }
1504                         ParseElementPullScalar($el, "r->", "NDR_SCALARS");
1505                         deindent;
1506                 }
1507                 pidl "break; }";
1508                 pidl "";
1509         }
1510         if (! $have_default) {
1511                 pidl "default:";
1512                 pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
1513         }
1514         deindent;
1515         pidl "}";
1516         pidl "buffers:";
1517         pidl "if (!(ndr_flags & NDR_BUFFERS)) goto done;";
1518         pidl "switch (level) {";
1519         indent;
1520         foreach my $el (@{$e->{ELEMENTS}}) {
1521                 if (util::has_property($el, "default")) {
1522                         pidl "default:";
1523                 } else {
1524                         pidl "case $el->{PROPERTIES}->{case}:";
1525                 }
1526                 if ($el->{TYPE} ne "EMPTY") {
1527                         indent;
1528                         ParseElementPullBuffer($el, "r->", "NDR_BUFFERS");
1529                         deindent;
1530                 }
1531                 pidl "break;";
1532                 pidl "";
1533         }
1534         if (! $have_default) {
1535                 pidl "default:";
1536                 pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
1537         }
1538         deindent;
1539         pidl "}";
1540         pidl "ndr_pull_struct_end(ndr);";
1541         pidl "done:";
1542         end_flags($e);
1543 }
1544
1545 sub ArgsUnionPush($)
1546 {
1547         my $e = shift;
1548         return "struct ndr_push *ndr, int ndr_flags, int level, union $e->{NAME} *r";
1549 }
1550
1551 sub ArgsUnionPrint($)
1552 {
1553         my $e = shift;
1554         return "struct ndr_print *ndr, const char *name, int level, union $e->{NAME} *r";
1555 }
1556
1557 sub ArgsUnionPull($)
1558 {
1559         my $e = shift;
1560         return "struct ndr_pull *ndr, int ndr_flags, int level, union $e->{NAME} *r";
1561 }
1562
1563 $typefamily{UNION} = {
1564         PUSH_FN_BODY => \&ParseUnionPush,
1565         PUSH_FN_ARGS => \&ArgsUnionPush,
1566         PULL_FN_BODY => \&ParseUnionPull,
1567         PULL_FN_ARGS => \&ArgsUnionPull,
1568         PRINT_FN_BODY => \&ParseUnionPrint,
1569         PRINT_FN_ARGS => \&ArgsUnionPrint,
1570         SIZE_FN => \&ParseUnionNdrSize,
1571         ALIGN => \&find_largest_alignment
1572 };
1573         
1574 #####################################################################
1575 # parse a typedef - push side
1576 sub ParseTypedefPush($)
1577 {
1578         my($e) = shift;
1579         my $static = fn_prefix($e);
1580
1581         return unless needed::is_needed("push_$e->{NAME}");
1582
1583         my $args = $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_ARGS}->($e);
1584         pidl $static . "NTSTATUS ndr_push_$e->{NAME}($args)";
1585
1586         pidl "{";
1587         indent;
1588         $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($e->{DATA});
1589         pidl "return NT_STATUS_OK;";
1590         deindent;
1591         pidl "}";
1592         pidl "";;
1593 }
1594
1595
1596 #####################################################################
1597 # parse a typedef - pull side
1598 sub ParseTypedefPull($)
1599 {
1600         my($e) = shift;
1601         my $static = fn_prefix($e);
1602
1603         return unless needed::is_needed("pull_$e->{NAME}");
1604
1605         my $args = $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_ARGS}->($e);
1606
1607         pidl $static . "NTSTATUS ndr_pull_$e->{NAME}($args)";
1608
1609         pidl "{";
1610         indent;
1611         $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($e->{DATA});
1612         pidl "return NT_STATUS_OK;";
1613         deindent;
1614         pidl "}";
1615         pidl "";
1616 }
1617
1618 #####################################################################
1619 # parse a typedef - print side
1620 sub ParseTypedefPrint($)
1621 {
1622         my($e) = shift;
1623
1624         my $args = $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_ARGS}->($e);
1625
1626         pidl "void ndr_print_$e->{NAME}($args)";
1627         pidl "{";
1628         indent;
1629         $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($e->{DATA});
1630         deindent;
1631         pidl "}";
1632 }
1633
1634 #####################################################################
1635 ## calculate the size of a structure
1636 sub ParseTypedefNdrSize($)
1637 {
1638         my($t) = shift;
1639
1640         return unless needed::is_needed("ndr_size_$t->{NAME}");
1641
1642         $typefamily{$t->{DATA}->{TYPE}}->{SIZE_FN}->($t);
1643 }
1644
1645 #####################################################################
1646 # parse a function - print side
1647 sub ParseFunctionPrint($)
1648 {
1649         my($fn) = shift;
1650
1651         pidl "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, struct $fn->{NAME} *r)";
1652         pidl "{";
1653         indent;
1654         pidl "ndr_print_struct(ndr, name, \"$fn->{NAME}\");";
1655         pidl "ndr->depth++;";
1656
1657         pidl "if (flags & NDR_SET_VALUES) {";
1658         pidl "\tndr->flags |= LIBNDR_PRINT_SET_VALUES;";
1659         pidl "}";
1660
1661         pidl "if (flags & NDR_IN) {";
1662         indent;
1663         pidl "ndr_print_struct(ndr, \"in\", \"$fn->{NAME}\");";
1664         pidl "ndr->depth++;";
1665
1666         foreach my $e (@{$fn->{ELEMENTS}}) {
1667                 if (util::has_property($e, "in")) {
1668                         ParseElementPrint($e, "r->in.");
1669                 }
1670         }
1671         pidl "ndr->depth--;";
1672         deindent;
1673         pidl "}";
1674         
1675         pidl "if (flags & NDR_OUT) {";
1676         indent;
1677         pidl "ndr_print_struct(ndr, \"out\", \"$fn->{NAME}\");";
1678         pidl "ndr->depth++;";
1679         foreach my $e (@{$fn->{ELEMENTS}}) {
1680                 if (util::has_property($e, "out")) {
1681                         ParseElementPrint($e, "r->out.");
1682                 }
1683         }
1684         if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1685                 my $cprefix = "&";
1686                 $cprefix = "" if (is_scalar_type($fn->{RETURN_TYPE})) ; # FIXME: Should really use util::c_push_prefix here
1687                 pidl "ndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", $cprefix"."r->out.result);";
1688         }
1689         pidl "ndr->depth--;";
1690         deindent;
1691         pidl "}";
1692         
1693         pidl "ndr->depth--;";
1694         deindent;
1695         pidl "}";
1696         pidl "";
1697 }
1698
1699 #####################################################################
1700 # parse a function element
1701 sub ParseFunctionElementPush($$)
1702
1703         my $e = shift;
1704         my $inout = shift;
1705
1706         if (util::array_size($e)) {
1707                 if (need_wire_pointer($e)) {
1708                         pidl "NDR_CHECK(ndr_push_unique_ptr(ndr, r->$inout.$e->{NAME}));";
1709                         pidl "if (r->$inout.$e->{NAME}) {";
1710                         indent;
1711                         ParseArrayPush($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1712                         deindent;
1713                         pidl "}";
1714                 } else {
1715                         ParseArrayPush($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1716                 }
1717         } else {
1718                 ParseElementPushScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1719
1720                 if (need_wire_pointer($e)) {
1721                         ParseElementPushBuffer($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1722                 }
1723         }
1724 }       
1725
1726 #####################################################################
1727 # parse a function
1728 sub ParseFunctionPush($)
1729
1730         my($fn) = shift;
1731         my $static = fn_prefix($fn);
1732
1733         pidl $static . "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, struct $fn->{NAME} *r)";
1734         pidl "{";
1735         indent;
1736
1737         pidl "if (!(flags & NDR_IN)) goto ndr_out;";
1738         pidl "";
1739
1740         foreach my $e (@{$fn->{ELEMENTS}}) {
1741                 if (util::has_property($e, "in")) {
1742                         ParseFunctionElementPush($e, "in");
1743                 }               
1744         }
1745
1746         pidl "ndr_out:";
1747         pidl "if (!(flags & NDR_OUT)) goto done;";
1748         pidl "";
1749
1750         foreach my $e (@{$fn->{ELEMENTS}}) {
1751                 if (util::has_property($e, "out")) {
1752                         ParseFunctionElementPush($e, "out");
1753                 }               
1754         }
1755
1756         if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1757                 pidl "NDR_CHECK(ndr_push_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, r->out.result));";
1758         }
1759     
1760         pidl "done:";
1761         pidl "return NT_STATUS_OK;";
1762         deindent;
1763         pidl "}";
1764         pidl "";
1765 }
1766
1767 #####################################################################
1768 # parse a function element
1769 sub ParseFunctionElementPull($$)
1770
1771         my $e = shift;
1772         my $inout = shift;
1773
1774         if (util::array_size($e)) {
1775                 if (need_wire_pointer($e)) {
1776                         pidl "NDR_CHECK(ndr_pull_unique_ptr(ndr, &_ptr_$e->{NAME}));";
1777                         pidl "r->$inout.$e->{NAME} = NULL;";
1778                         pidl "if (_ptr_$e->{NAME}) {";
1779                 } elsif ($inout eq "out" && util::has_property($e, "ref")) {
1780                         pidl "if (r->$inout.$e->{NAME}) {";
1781                 } else {
1782                         pidl "{";
1783                 }
1784                 indent;
1785                 ParseArrayPull($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1786                 deindent;
1787                 pidl "}";
1788         } else {
1789                 if ($inout eq "out" && util::has_property($e, "ref")) {
1790                         pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {";
1791                         pidl "\tNDR_ALLOC(ndr, r->out.$e->{NAME});";
1792                         pidl "}";
1793                 }
1794
1795                 if ($inout eq "in" && util::has_property($e, "ref")) {
1796                         pidl "NDR_ALLOC(ndr, r->in.$e->{NAME});";
1797                 }
1798
1799                 ParseElementPullScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1800                 if (need_wire_pointer($e)) {
1801                         ParseElementPullBuffer($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1802                 }
1803         }
1804 }
1805
1806 ############################################################
1807 # allocate ref variables
1808 sub AllocateRefVars($)
1809 {
1810         my $e = shift;
1811         my $asize = util::array_size($e);
1812
1813         # note that if the variable is also an "in"
1814         # variable then we copy the initial value from
1815         # the in side
1816
1817         if (!defined $asize) {
1818                 # its a simple variable
1819                 pidl "NDR_ALLOC(ndr, r->out.$e->{NAME});";
1820                 if (util::has_property($e, "in")) {
1821                         pidl "*r->out.$e->{NAME} = *r->in.$e->{NAME};";
1822                 } else {
1823                         pidl "ZERO_STRUCTP(r->out.$e->{NAME});";
1824                 }
1825                 return;
1826         }
1827
1828         # its an array
1829         my $size = ParseExpr($e, $asize, "r->out.");
1830         check_null_pointer($size);
1831         pidl "NDR_ALLOC_N(ndr, r->out.$e->{NAME}, $size);";
1832         if (util::has_property($e, "in")) {
1833                 pidl "memcpy(r->out.$e->{NAME},r->in.$e->{NAME},$size * sizeof(*r->in.$e->{NAME}));";
1834         } else {
1835                 pidl "memset(r->out.$e->{NAME}, 0, $size * sizeof(*r->out.$e->{NAME}));";
1836         }
1837 }
1838
1839 #####################################################################
1840 # parse a function
1841 sub ParseFunctionPull($)
1842
1843         my($fn) = shift;
1844         my $static = fn_prefix($fn);
1845
1846         # pull function args
1847         pidl $static . "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)";
1848         pidl "{";
1849         indent;
1850
1851         # declare any internal pointers we need
1852         foreach my $e (@{$fn->{ELEMENTS}}) {
1853                 if (need_wire_pointer($e)) {
1854                         pidl "uint32_t _ptr_$e->{NAME};";
1855                 }
1856         }
1857
1858         pidl "if (!(flags & NDR_IN)) goto ndr_out;";
1859         pidl "";
1860
1861         # auto-init the out section of a structure. I originally argued that
1862         # this was a bad idea as it hides bugs, but coping correctly
1863         # with initialisation and not wiping ref vars is turning
1864         # out to be too tricky (tridge)
1865         foreach my $e (@{$fn->{ELEMENTS}}) {
1866                 if (util::has_property($e, "out")) {
1867                         pidl "ZERO_STRUCT(r->out);";
1868                         pidl "";
1869                         last;
1870                 }
1871         }
1872
1873         foreach my $e (@{$fn->{ELEMENTS}}) {
1874                 if (util::has_property($e, "in")) {
1875                         ParseFunctionElementPull($e, "in");
1876                 }
1877                 # we need to allocate any reference output variables, so that
1878                 # a dcerpc backend can be sure they are non-null
1879                 if (util::has_property($e, "out") && util::has_property($e, "ref")) {
1880                         AllocateRefVars($e);
1881                 }
1882         }
1883
1884         foreach my $e (@{$fn->{ELEMENTS}}) {
1885                 if (util::has_property($e, "in")) {
1886                         CheckArraySizes($e, "r->in.");
1887                 }
1888         }
1889
1890         pidl "ndr_out:";
1891         pidl "if (!(flags & NDR_OUT)) goto done;";
1892         pidl "";
1893
1894         foreach my $e (@{$fn->{ELEMENTS}}) {
1895                 if (util::has_property($e, "out")) {
1896                         ParseFunctionElementPull($e, "out");
1897                 }
1898         }
1899
1900         foreach my $e (@{$fn->{ELEMENTS}}) {
1901                 if (util::has_property($e, "out")) {
1902                         CheckArraySizes($e, "r->out.");
1903                 }
1904         }
1905
1906         if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1907                 pidl "NDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, &r->out.result));";
1908         }
1909
1910         pidl "done:";
1911         pidl "";
1912         pidl "return NT_STATUS_OK;";
1913         deindent;
1914         pidl "}";
1915         pidl "";
1916 }
1917
1918 #####################################################################
1919 # produce a function call table
1920 sub FunctionTable($)
1921 {
1922         my($interface) = shift;
1923         my($data) = $interface->{INHERITED_DATA};
1924         my $count = 0;
1925         my $uname = uc $interface->{NAME};
1926
1927         foreach my $d (@{$data}) {
1928                 if ($d->{TYPE} eq "FUNCTION") { $count++; }
1929         }
1930
1931         return if ($count == 0);
1932
1933         pidl "static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {";
1934         foreach my $d (@{$data}) {
1935                 if ($d->{TYPE} eq "FUNCTION") {
1936                         pidl "\t{";
1937                         pidl "\t\t\"$d->{NAME}\",";
1938                         pidl "\t\tsizeof(struct $d->{NAME}),";
1939                         pidl "\t\t(ndr_push_flags_fn_t) ndr_push_$d->{NAME},";
1940                         pidl "\t\t(ndr_pull_flags_fn_t) ndr_pull_$d->{NAME},";
1941                         pidl "\t\t(ndr_print_function_t) ndr_print_$d->{NAME}";
1942                         pidl "\t},";
1943                 }
1944         }
1945         pidl "\t{ NULL, 0, NULL, NULL, NULL }";
1946         pidl "};";
1947         pidl "";
1948
1949         # If no endpoint is set, default to the interface name as a named pipe
1950         if (! defined $interface->{PROPERTIES}->{endpoint}) {
1951                 $interface->{PROPERTIES}->{endpoint} = "\"ncacn_np:[\\\\pipe\\\\" . $interface->{NAME} . "]\"";
1952         }
1953
1954         my @e = split / /, $interface->{PROPERTIES}->{endpoint};
1955         my $endpoint_count = $#e + 1;
1956
1957         pidl "static const char * const $interface->{NAME}\_endpoint_strings[] = {";
1958         foreach my $ep (@e) {
1959                 pidl "\t$ep, ";
1960         }
1961         pidl "};";
1962         pidl "";
1963
1964         pidl "static const struct dcerpc_endpoint_list $interface->{NAME}\_endpoints = {";
1965         pidl "\t$endpoint_count, $interface->{NAME}\_endpoint_strings";
1966         pidl "};";
1967         pidl "";
1968
1969         pidl "\nconst struct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {";
1970         pidl "\t\"$interface->{NAME}\",";
1971         pidl "\tDCERPC_$uname\_UUID,";
1972         pidl "\tDCERPC_$uname\_VERSION,";
1973         pidl "\tDCERPC_$uname\_HELPSTRING,";
1974         pidl "\t$count,";
1975         pidl "\t$interface->{NAME}\_calls,";
1976         pidl "\t&$interface->{NAME}\_endpoints";
1977         pidl "};";
1978         pidl "";
1979
1980         pidl "static NTSTATUS dcerpc_ndr_$interface->{NAME}_init(void)";
1981         pidl "{";
1982         pidl "\treturn librpc_register_interface(&dcerpc_table_$interface->{NAME});";
1983         pidl "}";
1984         pidl "";
1985 }
1986
1987 #####################################################################
1988 # parse the interface definitions
1989 sub ParseInterface($)
1990 {
1991         my($interface) = shift;
1992         my($data) = $interface->{DATA};
1993
1994         # Push functions
1995         foreach my $d (@{$data}) {
1996                 ($d->{TYPE} eq "TYPEDEF") &&
1997                     ParseTypedefPush($d);
1998                 ($d->{TYPE} eq "FUNCTION") && 
1999                     ParseFunctionPush($d);
2000         }
2001
2002         # Pull functions
2003         foreach my $d (@{$data}) {
2004                 ($d->{TYPE} eq "TYPEDEF") &&
2005                     ParseTypedefPull($d);
2006                 ($d->{TYPE} eq "FUNCTION") && 
2007                     ParseFunctionPull($d);
2008         }
2009         
2010         # Print functions
2011         foreach my $d (@{$data}) {
2012                 if ($d->{TYPE} eq "TYPEDEF" &&
2013                     !util::has_property($d, "noprint")) {
2014                         ParseTypedefPrint($d);
2015                 }
2016                 if ($d->{TYPE} eq "FUNCTION" &&
2017                     !util::has_property($d, "noprint")) {
2018                         ParseFunctionPrint($d);
2019                 }
2020         }
2021
2022         # Size functions
2023         foreach my $d (@{$data}) {
2024                 ($d->{TYPE} eq "TYPEDEF") && 
2025                         ParseTypedefNdrSize($d);
2026         }
2027
2028         FunctionTable($interface);
2029 }
2030
2031 sub RegistrationFunction($$)
2032 {
2033         my $idl = shift;
2034         my $filename = shift;
2035
2036         $filename =~ /.*\/ndr_(.*).c/;
2037         my $basename = $1;
2038         pidl "NTSTATUS dcerpc_$basename\_init(void)";
2039         pidl "{";
2040         indent;
2041         pidl "NTSTATUS status = NT_STATUS_OK;";
2042         foreach my $interface (@{$idl}) {
2043                 next if $interface->{TYPE} ne "INTERFACE";
2044
2045                 my $data = $interface->{INHERITED_DATA};
2046                 my $count = 0;
2047                 foreach my $d (@{$data}) {
2048                         if ($d->{TYPE} eq "FUNCTION") { $count++; }
2049                 }
2050
2051                 next if ($count == 0);
2052
2053                 pidl "status = dcerpc_ndr_$interface->{NAME}_init();";
2054                 pidl "if (NT_STATUS_IS_ERR(status)) {";
2055                 pidl "\treturn status;";
2056                 pidl "}";
2057                 pidl "";
2058         }
2059         pidl "return status;";
2060         deindent;
2061         pidl "}";
2062         pidl "";
2063 }
2064
2065 sub CheckPointerTypes($$)
2066 {
2067         my $s = shift;
2068         my $default = shift;
2069
2070         foreach my $e (@{$s->{ELEMENTS}}) {
2071                 if ($e->{POINTERS}) {
2072                         if (not defined(pointer_type($e))) {
2073                                 $e->{PROPERTIES}->{$default} = 1;
2074                         }
2075
2076                         if (pointer_type($e) eq "ptr") {
2077                                 print "Warning: ptr is not supported by pidl yet\n";
2078                         }
2079                 }
2080         }
2081 }
2082
2083 sub LoadInterface($)
2084 {
2085         my $x = shift;
2086
2087         if (not util::has_property($x, "pointer_default")) {
2088                 # MIDL defaults to "ptr" in DCE compatible mode (/osf)
2089                 # and "unique" in Microsoft Extensions mode (default)
2090                 $x->{PROPERTIES}->{pointer_default} = "unique";
2091         }
2092
2093         foreach my $d (@{$x->{DATA}}) {
2094                 if (($d->{TYPE} eq "DECLARE") or ($d->{TYPE} eq "TYPEDEF")) {
2095                         typelist::addType($d);
2096                         if ($d->{DATA}->{TYPE} eq "STRUCT" or $d->{DATA}->{TYPE} eq "UNION") {
2097                                 CheckPointerTypes($d->{DATA}, $x->{PROPERTIES}->{pointer_default});
2098                         }
2099
2100                         if (defined($d->{PROPERTIES}) && !defined($d->{DATA}->{PROPERTIES})) {
2101                                 $d->{DATA}->{PROPERTIES} = $d->{PROPERTIES};
2102                         }
2103                 }
2104                 if ($d->{TYPE} eq "FUNCTION") {
2105                         CheckPointerTypes($d, 
2106                                 $x->{PROPERTIES}->{pointer_default}  # MIDL defaults to "ref"
2107                         );
2108                 }
2109         }
2110 }
2111
2112 # Add ORPC specific bits to an interface.
2113 sub InterfaceORPC($)
2114 {
2115         my $x = shift;  
2116         # Add [in] ORPCTHIS *this, [out] ORPCTHAT *that
2117         # for 'object' interfaces
2118         if (util::has_property($x, "object")) {
2119                 foreach my $e (@{$x->{DATA}}) {
2120                         if($e->{TYPE} eq "FUNCTION") {
2121                                 $e->{PROPERTIES}->{object} = 1;
2122                                 unshift(@{$e->{ELEMENTS}}, 
2123                        { 'NAME' => 'ORPCthis',
2124                          'POINTERS' => 0,
2125                          'PROPERTIES' => { 'in' => '1' },
2126                          'TYPE' => 'ORPCTHIS'
2127                        });
2128                                 unshift(@{$e->{ELEMENTS}},
2129                        { 'NAME' => 'ORPCthat',
2130                          'POINTERS' => 0,
2131                          'PROPERTIES' => { 'out' => '1' },
2132                                           'TYPE' => 'ORPCTHAT'
2133                        });
2134                         }
2135                 }
2136         }
2137 }
2138
2139 sub Load($)
2140 {
2141         my $idl = shift;
2142
2143         foreach my $x (@{$idl}) {
2144                 LoadInterface($x);
2145         }
2146 }
2147
2148 #####################################################################
2149 # parse a parsed IDL structure back into an IDL file
2150 sub Parse($$)
2151 {
2152         my($idl) = shift;
2153         my($filename) = shift;
2154         my $h_filename = $filename;
2155         $res = "";
2156
2157         Load($idl);
2158
2159         if ($h_filename =~ /(.*)\.c/) {
2160                 $h_filename = "$1.h";
2161         }
2162
2163         pidl "/* parser auto-generated by pidl */";
2164         pidl "";
2165         pidl "#include \"includes.h\"";
2166         pidl "#include \"$h_filename\"";
2167         pidl "";
2168
2169         foreach my $x (@{$idl}) {
2170                 if ($x->{TYPE} eq "INTERFACE") { 
2171                         needed::BuildNeeded($x);
2172                         ParseInterface($x);
2173                 }
2174         }
2175
2176         RegistrationFunction($idl, $filename);
2177
2178         return $res;
2179 }
2180
2181 1;