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