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