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