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
14 # the list of needed functions
22 #####################################################################
23 # parse a properties list
24 sub ParseProperties($)
27 foreach my $d (@{$props}) {
28 if (ref($d) ne "HASH") {
31 foreach my $k (keys %{$d}) {
32 pidl "[$k($d->{$k})] ";
38 ###################################
39 # find a sibling var in a structure
44 my($fn) = $e->{PARENT};
46 if ($name =~ /\*(.*)/) {
50 if ($fn->{TYPE} eq "FUNCTION") {
51 for my $e2 (@{$fn->{DATA}}) {
52 if ($e2->{NAME} eq $name) {
58 for my $e2 (@{$fn->{ELEMENTS}}) {
59 if ($e2->{NAME} eq $name) {
63 die "invalid sibling '$name'";
66 ####################################################################
67 # work out the name of a size_is() variable
68 sub find_size_var($$$)
72 my($var_prefix) = shift;
74 my($fn) = $e->{PARENT};
76 if (util::is_constant($size)) {
80 if ($size =~ /ndr->|\(/) {
86 if ($size =~ /\*(.*)/) {
91 if ($fn->{TYPE} ne "FUNCTION") {
92 return $prefix . "r->$size";
95 my $e2 = find_sibling($e, $size);
97 if (util::has_property($e2, "in") && util::has_property($e2, "out")) {
98 return $prefix . "$var_prefix$size";
100 if (util::has_property($e2, "in")) {
101 return $prefix . "r->in.$size";
103 if (util::has_property($e2, "out")) {
104 return $prefix . "r->out.$size";
107 die "invalid variable in $size for element $e->{NAME} in $fn->{NAME}\n";
111 #####################################################################
112 # work out is a parse function should be declared static or not
116 if ($fn->{TYPE} eq "TYPEDEF") {
117 if (util::has_property($fn->{DATA}, "public")) {
122 if ($fn->{TYPE} eq "FUNCTION") {
123 if (util::has_property($fn, "public")) {
131 ###################################################################
132 # setup any special flags for an element or structure
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";
143 ###################################################################
144 # end any special flags for an element or structure
148 my $flags = util::has_property($e, "flag");
149 if (defined $flags) {
150 pidl "\tndr->flags = _flags_save_$e->{TYPE};\n\t}\n";
155 #####################################################################
156 # work out the correct alignment for a structure
162 for my $e (@{$s->{ELEMENTS}}) {
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});
175 $a = util::type_align($e);
186 #####################################################################
187 # work out the correct alignment for a union
194 foreach my $e (@{$u->{DATA}}) {
197 if ($e->{TYPE} eq "EMPTY") {
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});
210 $a = util::type_align($e->{DATA});
221 #####################################################################
222 # parse an array - push side
223 sub ParseArrayPush($$$)
226 my $var_prefix = shift;
227 my $ndr_flags = shift;
229 my $size = find_size_var($e, util::array_size($e), $var_prefix);
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";
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";
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";
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";
252 #####################################################################
254 sub ParseArrayPrint($$)
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");
261 if (defined $length) {
262 $size = find_size_var($e, $length, $var_prefix);
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";
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";
272 #####################################################################
273 # parse an array - pull side
274 sub ParseArrayPull($$$)
277 my $var_prefix = shift;
278 my $ndr_flags = shift;
280 my $size = find_size_var($e, util::array_size($e), $var_prefix);
281 my $alloc_size = $size;
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};
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";
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";
297 # non fixed arrays encode the size just before the array
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";
304 pidl "\t\tif ($size != _array_size) {\n";
306 pidl "\t\t\treturn ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, \"Bad array size %u should be %u\", _array_size, $size);\n";
308 if ($size =~ /r->in/) {
309 pidl "else { $size = _array_size; }\n";
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";
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";
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";
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";
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";
351 #####################################################################
352 # parse scalars in a structure element
353 sub ParseElementPushScalar($$$)
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");
363 if (my $value = util::has_property($e, "value")) {
364 pidl "\t$cprefix$var_prefix$e->{NAME} = $value;\n";
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";
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";
383 } elsif (util::is_builtin_type($e->{TYPE})) {
384 pidl "\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
386 pidl "\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
392 #####################################################################
393 # print scalars in a structure element
394 sub ParseElementPrintScalar($$)
397 my($var_prefix) = shift;
398 my $cprefix = util::c_push_prefix($e);
400 if (util::has_property($e, "noprint")) {
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";
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);
420 pidl "\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME});\n";
424 #####################################################################
425 # parse scalars in a structure element - pull size
426 sub ParseElementPullSwitch($$$$)
429 my($var_prefix) = shift;
430 my($ndr_flags) = shift;
432 my $switch_var = find_size_var($e, $switch, $var_prefix);
434 my $cprefix = util::c_pull_prefix($e);
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";
446 pidl "\t\tif (_level != $switch_var) {\n";
448 pidl "\t\t\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u in $e->{NAME}\", _level);\n";
450 if ($switch_var =~ /r->/) {
451 pidl "else { $switch_var = _level; }\n";
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";
462 pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $switch_var, $cprefix$var_prefix$e->{NAME}));\n";
468 #####################################################################
469 # push switch element
470 sub ParseElementPushSwitch($$$$)
473 my($var_prefix) = shift;
474 my($ndr_flags) = shift;
476 my $switch_var = find_size_var($e, $switch, $var_prefix);
477 my $cprefix = util::c_push_prefix($e);
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";
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";
494 pidl "\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $switch_var, $cprefix$var_prefix$e->{NAME}));\n";
498 #####################################################################
499 # print scalars in a structure element
500 sub ParseElementPrintSwitch($$$)
503 my($var_prefix) = shift;
505 my $switch_var = find_size_var($e, $switch, $var_prefix);
506 my $cprefix = util::c_push_prefix($e);
508 pidl "\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $switch_var, $cprefix$var_prefix$e->{NAME});\n";
512 #####################################################################
513 # parse scalars in a structure element - pull size
514 sub ParseElementPullScalar($$$)
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");
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}));";
534 pidl "\t\t$var_prefix$e->{NAME} = NULL;\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";
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";
546 } elsif (util::is_builtin_type($e->{TYPE})) {
547 pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
549 pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
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";
560 #####################################################################
561 # parse buffers in a structure element
562 sub ParseElementPushBuffer($$$)
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");
570 if (util::is_pure_scalar($e)) {
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";
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);
591 ParseElementPushSwitch($e, $var_prefix, "NDR_BUFFERS", $switch);
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";
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";
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";
606 pidl "\t\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
609 if (util::need_wire_pointer($e)) {
616 #####################################################################
617 # print buffers in a structure element
618 sub ParseElementPrintBuffer($$)
621 my($var_prefix) = shift;
622 my $cprefix = util::c_push_prefix($e);
624 if (util::need_wire_pointer($e)) {
625 pidl "\tif ($var_prefix$e->{NAME}) {\n";
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);
633 pidl "\t\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME});\n";
636 if (util::need_wire_pointer($e)) {
642 #####################################################################
643 # parse buffers in a structure element - pull side
644 sub ParseElementPullBuffer($$$)
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");
652 if (util::is_pure_scalar($e)) {
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";
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);
675 ParseElementPullSwitch($e, $var_prefix, "NDR_BUFFERS", $switch);
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";
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";
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";
690 pidl "\t\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
693 if (util::need_wire_pointer($e)) {
694 if (util::has_property($e, "relative")) {
695 pidl "\t\tndr_pull_restore(ndr, &_relative_save);\n";
703 #####################################################################
705 sub ParseStructPush($)
710 if (! defined $struct->{ELEMENTS}) {
714 start_flags($struct);
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
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;
726 pidl "\tNDR_CHECK(ndr_push_uint32(ndr, $size));\n";
729 pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
731 pidl "\tNDR_CHECK(ndr_push_struct_start(ndr));\n";
733 my $align = struct_alignment($struct);
734 pidl "\tNDR_CHECK(ndr_push_align(ndr, $align));\n";
736 foreach my $e (@{$struct->{ELEMENTS}}) {
737 ParseElementPushScalar($e, "r->", "NDR_SCALARS");
741 pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
742 foreach my $e (@{$struct->{ELEMENTS}}) {
743 ParseElementPushBuffer($e, "r->", "NDR_BUFFERS");
746 pidl "\tndr_push_struct_end(ndr);\n";
753 #####################################################################
754 # generate a struct print function
755 sub ParseStructPrint($)
759 if (! defined $struct->{ELEMENTS}) {
763 start_flags($struct);
765 pidl "\tndr->depth++;\n";
766 foreach my $e (@{$struct->{ELEMENTS}}) {
767 ParseElementPrintScalar($e, "r->");
769 pidl "\tndr->depth--;\n";
774 #####################################################################
775 # parse a struct - pull side
776 sub ParseStructPull($)
781 if (! defined $struct->{ELEMENTS}) {
785 # see if the structure contains a conformant array. If it
786 # does, then it must be the last element of the structure, and
787 # we need to pull the conformant length early, as it fits on
788 # the wire before the structure (and even before the structure
790 my $e = $struct->{ELEMENTS}[-1];
791 if (defined $e->{ARRAY_LEN} && $e->{ARRAY_LEN} eq "*") {
793 pidl "\tuint32_t _conformant_size;\n";
794 $conform_e->{CONFORMANT_SIZE} = "_conformant_size";
797 # declare any internal pointers we need
798 foreach my $e (@{$struct->{ELEMENTS}}) {
799 if (util::need_wire_pointer($e)) {
800 pidl "\tuint32_t _ptr_$e->{NAME};\n";
804 start_flags($struct);
806 pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
808 pidl "\tNDR_CHECK(ndr_pull_struct_start(ndr));\n";
810 if (defined $conform_e) {
811 pidl "\tNDR_CHECK(ndr_pull_uint32(ndr, &$conform_e->{CONFORMANT_SIZE}));\n";
814 my $align = struct_alignment($struct);
815 pidl "\tNDR_CHECK(ndr_pull_align(ndr, $align));\n";
817 foreach my $e (@{$struct->{ELEMENTS}}) {
818 ParseElementPullScalar($e, "r->", "NDR_SCALARS");
822 pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
823 foreach my $e (@{$struct->{ELEMENTS}}) {
824 ParseElementPullBuffer($e, "r->", "NDR_BUFFERS");
827 pidl "\tndr_pull_struct_end(ndr);\n";
834 #####################################################################
835 # calculate size of ndr struct
837 sub ParseStructNdrSize($)
840 my $static = fn_prefix($t);
843 pidl $static . "size_t ndr_size_$t->{NAME}(int ret, struct $t->{NAME} *r, int flags)\n";
846 if (util::has_property($t->{DATA}, "flag")) {
848 pidl "\tflags = flags | " . $t->{DATA}->{PROPERTIES}->{flag} . ";\n";
851 pidl "\tif(!r) return 0;\n";
853 pidl "\tret = NDR_SIZE_ALIGN(ret, " . struct_alignment($t->{DATA}) . ", flags);\n";
855 for my $e (@{$t->{DATA}->{ELEMENTS}}) {
858 if (util::has_property($e, "subcontext")) {
859 pidl "\tret += $e->{PROPERTIES}->{subcontext}; /* Subcontext length */\n";
862 if (util::has_property($e, "switch_is")) {
863 $switch = ", r->$e->{PROPERTIES}->{switch_is}";
866 if ($e->{POINTERS} > 0) {
867 pidl "\tret = ndr_size_ptr(ret, &r->$e->{NAME}, flags); \n";
868 } elsif (util::is_inline_array($e)) {
869 $sizevar = find_size_var($e, util::array_size($e), "r->");
872 pidl "\t\tfor(i = 0; i < $sizevar; i++) {\n";
873 pidl "\t\t\tret = ndr_size_$e->{TYPE}(ret, &r->" . $e->{NAME} . "[i], flags);\n";
877 pidl "\tret = ndr_size_$e->{TYPE}(ret, &r->$e->{NAME}$switch, flags); \n";
881 # Add lengths of relative members
882 for my $e (@{$t->{DATA}->{ELEMENTS}}) {
883 next unless (util::has_property($e, "relative"));
885 pidl "\tif (r->$e->{NAME}) {\n";
886 pidl "\t\tret = ndr_size_$e->{TYPE}(ret, r->$e->{NAME}, flags); \n";
890 pidl "\treturn ret;\n";
894 #####################################################################
895 # parse a union - push side
896 sub ParseUnionPush($)
899 my $have_default = 0;
903 pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
905 pidl "\tNDR_CHECK(ndr_push_struct_start(ndr));\n";
907 # my $align = union_alignment($e);
908 # pidl "\tNDR_CHECK(ndr_push_align(ndr, $align));\n";
910 pidl "\tswitch (level) {\n";
911 foreach my $el (@{$e->{DATA}}) {
912 if ($el->{CASE} eq "default") {
916 pidl "\tcase $el->{CASE}:\n";
918 if ($el->{TYPE} eq "UNION_ELEMENT") {
919 ParseElementPushScalar($el->{DATA}, "r->", "NDR_SCALARS");
923 if (! $have_default) {
925 pidl "\t\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
929 pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
930 pidl "\tswitch (level) {\n";
931 foreach my $el (@{$e->{DATA}}) {
932 if ($el->{CASE} eq "default") {
935 pidl "\tcase $el->{CASE}:\n";
937 if ($el->{TYPE} eq "UNION_ELEMENT") {
938 ParseElementPushBuffer($el->{DATA}, "r->", "NDR_BUFFERS");
942 if (! $have_default) {
944 pidl "\t\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
947 pidl "\tndr_push_struct_end(ndr);\n";
952 #####################################################################
954 sub ParseUnionPrint($)
957 my $have_default = 0;
961 pidl "\tswitch (level) {\n";
962 foreach my $el (@{$e->{DATA}}) {
963 if ($el->{CASE} eq "default") {
967 pidl "\tcase $el->{CASE}:\n";
969 if ($el->{TYPE} eq "UNION_ELEMENT") {
970 ParseElementPrintScalar($el->{DATA}, "r->");
974 if (! $have_default) {
975 pidl "\tdefault:\n\t\tndr_print_bad_level(ndr, name, level);\n";
982 #####################################################################
983 # parse a union - pull side
984 sub ParseUnionPull($)
987 my $have_default = 0;
991 pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
993 pidl "\tNDR_CHECK(ndr_pull_struct_start(ndr));\n";
995 # my $align = union_alignment($e);
996 # pidl "\tNDR_CHECK(ndr_pull_align(ndr, $align));\n";
998 pidl "\tswitch (level) {\n";
999 foreach my $el (@{$e->{DATA}}) {
1000 if ($el->{CASE} eq "default") {
1001 pidl "\tdefault: {\n";
1004 pidl "\tcase $el->{CASE}: {\n";
1006 if ($el->{TYPE} eq "UNION_ELEMENT") {
1007 my $e2 = $el->{DATA};
1008 if ($e2->{POINTERS}) {
1009 pidl "\t\tuint32_t _ptr_$e2->{NAME};\n";
1011 ParseElementPullScalar($el->{DATA}, "r->", "NDR_SCALARS");
1013 pidl "\tbreak; }\n\n";
1015 if (! $have_default) {
1016 pidl "\tdefault:\n";
1017 pidl "\t\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
1021 pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
1022 pidl "\tswitch (level) {\n";
1023 foreach my $el (@{$e->{DATA}}) {
1024 if ($el->{CASE} eq "default") {
1025 pidl "\tdefault:\n";
1027 pidl "\tcase $el->{CASE}:\n";
1029 if ($el->{TYPE} eq "UNION_ELEMENT") {
1030 ParseElementPullBuffer($el->{DATA}, "r->", "NDR_BUFFERS");
1032 pidl "\tbreak;\n\n";
1034 if (! $have_default) {
1035 pidl "\tdefault:\n";
1036 pidl "\t\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
1039 pidl "\tndr_pull_struct_end(ndr);\n";
1044 #####################################################################
1045 # calculate size of ndr union
1047 sub ParseUnionNdrSize($)
1050 my $static = fn_prefix($t);
1052 pidl $static . "size_t ndr_size_$t->{NAME}(int ret, union $t->{NAME} *data, uint16 level, int flags)\n";
1054 if (util::has_property($t->{DATA}, "flag")) {
1055 pidl "\tflags = flags | " . $t->{DATA}->{PROPERTIES}->{flag} . ";\n";
1057 pidl "\tif(!data) return 0;\n\n";
1059 pidl "\tret = NDR_SIZE_ALIGN(ret, " . union_alignment($t->{DATA}) . ", flags);\n";
1061 pidl "\tswitch(level) {\n";
1063 for my $e (@{$t->{DATA}->{DATA}}) {
1064 if ($e->{TYPE} eq "UNION_ELEMENT") {
1066 if ($e->{CASE} eq "default") {
1067 pidl "\t\tdefault:";
1069 pidl "\t\tcase $e->{CASE}:";
1072 pidl " return ndr_size_$e->{DATA}->{TYPE}(ret, &data->$e->{DATA}->{NAME}, flags); \n";
1077 pidl "\treturn ret;\n";
1081 #####################################################################
1083 sub ParseTypePush($)
1087 if (ref($data) eq "HASH") {
1088 ($data->{TYPE} eq "STRUCT") &&
1089 ParseStructPush($data);
1090 ($data->{TYPE} eq "UNION") &&
1091 ParseUnionPush($data);
1095 #####################################################################
1096 # generate a print function for a type
1097 sub ParseTypePrint($)
1101 if (ref($data) eq "HASH") {
1102 ($data->{TYPE} eq "STRUCT") &&
1103 ParseStructPrint($data);
1104 ($data->{TYPE} eq "UNION") &&
1105 ParseUnionPrint($data);
1109 #####################################################################
1111 sub ParseTypePull($)
1115 if (ref($data) eq "HASH") {
1116 ($data->{TYPE} eq "STRUCT") &&
1117 ParseStructPull($data);
1118 ($data->{TYPE} eq "UNION") &&
1119 ParseUnionPull($data);
1123 #####################################################################
1124 # parse a typedef - push side
1125 sub ParseTypedefPush($)
1128 my $static = fn_prefix($e);
1130 if (! needed::is_needed("push_$e->{NAME}")) {
1131 # print "push_$e->{NAME} not needed\n";
1135 if ($e->{DATA}->{TYPE} eq "STRUCT") {
1136 pidl $static . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, struct $e->{NAME} *r)";
1138 ParseTypePush($e->{DATA});
1139 pidl "\treturn NT_STATUS_OK;\n";
1143 if ($e->{DATA}->{TYPE} eq "UNION") {
1144 pidl $static . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, int level, union $e->{NAME} *r)";
1146 ParseTypePush($e->{DATA});
1147 pidl "\treturn NT_STATUS_OK;\n";
1153 #####################################################################
1154 # parse a typedef - pull side
1155 sub ParseTypedefPull($)
1158 my $static = fn_prefix($e);
1160 if (! needed::is_needed("pull_$e->{NAME}")) {
1161 # print "pull_$e->{NAME} not needed\n";
1165 if ($e->{DATA}->{TYPE} eq "STRUCT") {
1166 pidl $static . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, struct $e->{NAME} *r)";
1168 ParseTypePull($e->{DATA});
1169 pidl "\treturn NT_STATUS_OK;\n";
1173 if ($e->{DATA}->{TYPE} eq "UNION") {
1174 pidl $static . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, int level, union $e->{NAME} *r)";
1176 ParseTypePull($e->{DATA});
1177 pidl "\treturn NT_STATUS_OK;\n";
1183 #####################################################################
1184 # parse a typedef - print side
1185 sub ParseTypedefPrint($)
1189 if ($e->{DATA}->{TYPE} eq "STRUCT") {
1190 pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, struct $e->{NAME} *r)";
1192 pidl "\tndr_print_struct(ndr, name, \"$e->{NAME}\");\n";
1193 ParseTypePrint($e->{DATA});
1197 if ($e->{DATA}->{TYPE} eq "UNION") {
1198 pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, int level, union $e->{NAME} *r)";
1200 pidl "\tndr_print_union(ndr, name, level, \"$e->{NAME}\");\n";
1201 ParseTypePrint($e->{DATA});
1206 #####################################################################
1207 ## calculate the size of a structure
1208 sub ParseTypedefNdrSize($)
1211 if (! needed::is_needed("ndr_size_$t->{NAME}")) {
1215 ($t->{DATA}->{TYPE} eq "STRUCT") &&
1216 ParseStructNdrSize($t);
1218 ($t->{DATA}->{TYPE} eq "UNION") &&
1219 ParseUnionNdrSize($t);
1223 #####################################################################
1224 # parse a function - print side
1225 sub ParseFunctionPrint($)
1229 pidl "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, struct $fn->{NAME} *r)";
1231 pidl "\tndr_print_struct(ndr, name, \"$fn->{NAME}\");\n";
1232 pidl "\tndr->depth++;\n";
1234 pidl "\tif (flags & NDR_SET_VALUES) {\n";
1235 pidl "\t\tndr->flags |= LIBNDR_PRINT_SET_VALUES;\n";
1238 pidl "\tif (flags & NDR_IN) {\n";
1239 pidl "\t\tndr_print_struct(ndr, \"in\", \"$fn->{NAME}\");\n";
1240 pidl "\tndr->depth++;\n";
1241 foreach my $e (@{$fn->{DATA}}) {
1242 if (util::has_property($e, "in")) {
1243 ParseElementPrintScalar($e, "r->in.");
1246 pidl "\tndr->depth--;\n";
1249 pidl "\tif (flags & NDR_OUT) {\n";
1250 pidl "\t\tndr_print_struct(ndr, \"out\", \"$fn->{NAME}\");\n";
1251 pidl "\tndr->depth++;\n";
1252 foreach my $e (@{$fn->{DATA}}) {
1253 if (util::has_property($e, "out")) {
1254 ParseElementPrintScalar($e, "r->out.");
1257 if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1258 if (util::is_scalar_type($fn->{RETURN_TYPE})) {
1259 pidl "\tndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", r->out.result);\n";
1261 pidl "\tndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", &r->out.result);\n";
1264 pidl "\tndr->depth--;\n";
1267 pidl "\tndr->depth--;\n";
1272 #####################################################################
1273 # parse a function element
1274 sub ParseFunctionElementPush($$)
1279 if (util::array_size($e)) {
1280 if (util::need_wire_pointer($e)) {
1281 pidl "\tNDR_CHECK(ndr_push_ptr(ndr, r->$inout.$e->{NAME}));\n";
1282 pidl "\tif (r->$inout.$e->{NAME}) {\n";
1283 ParseArrayPush($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1286 ParseArrayPush($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1289 ParseElementPushScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1290 if ($e->{POINTERS}) {
1291 ParseElementPushBuffer($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1296 #####################################################################
1298 sub ParseFunctionPush($)
1301 my $static = fn_prefix($fn);
1303 pidl $static . "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, struct $fn->{NAME} *r)\n{\n";
1305 pidl "\n\tif (!(flags & NDR_IN)) goto ndr_out;\n\n";
1306 foreach my $e (@{$fn->{DATA}}) {
1307 if (util::has_property($e, "in")) {
1308 ParseFunctionElementPush($e, "in");
1312 pidl "\nndr_out:\n";
1313 pidl "\tif (!(flags & NDR_OUT)) goto done;\n\n";
1314 foreach my $e (@{$fn->{DATA}}) {
1315 if (util::has_property($e, "out")) {
1316 ParseFunctionElementPush($e, "out");
1320 if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1321 pidl "\tNDR_CHECK(ndr_push_$fn->{RETURN_TYPE}(ndr, r->out.result));\n";
1325 pidl "\n\treturn NT_STATUS_OK;\n}\n\n";
1328 #####################################################################
1329 # parse a function element
1330 sub ParseFunctionElementPull($$)
1335 if (util::array_size($e)) {
1336 if (util::need_wire_pointer($e)) {
1337 pidl "\tNDR_CHECK(ndr_pull_ptr(ndr, &_ptr_$e->{NAME}));\n";
1338 pidl "\tif (_ptr_$e->{NAME}) {\n";
1339 } elsif ($inout eq "out" && util::has_property($e, "ref")) {
1340 pidl "\tif (r->$inout.$e->{NAME}) {\n";
1344 ParseArrayPull($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1347 if ($inout eq "out" && util::has_property($e, "ref")) {
1348 pidl "\tif (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {\n";
1349 pidl "\tNDR_ALLOC(ndr, r->out.$e->{NAME});\n";
1352 if ($inout eq "in" && util::has_property($e, "ref")) {
1353 pidl "\tNDR_ALLOC(ndr, r->in.$e->{NAME});\n";
1356 ParseElementPullScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1357 if ($e->{POINTERS}) {
1358 ParseElementPullBuffer($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1364 ############################################################
1365 # allocate ref variables
1366 sub AllocateRefVars($)
1369 my $asize = util::array_size($e);
1371 # note that if the variable is also an "in"
1372 # variable then we copy the initial value from
1375 if (!defined $asize) {
1376 # its a simple variable
1377 pidl "\tNDR_ALLOC(ndr, r->out.$e->{NAME});\n";
1378 if (util::has_property($e, "in")) {
1379 pidl "\t*r->out.$e->{NAME} = *r->in.$e->{NAME};\n";
1381 pidl "\tZERO_STRUCTP(r->out.$e->{NAME});\n";
1387 my $size = find_size_var($e, $asize, "r->out.");
1388 pidl "\tNDR_ALLOC_N(ndr, r->out.$e->{NAME}, MAX(1, $size));\n";
1389 if (util::has_property($e, "in")) {
1390 pidl "\tmemcpy(r->out.$e->{NAME},r->in.$e->{NAME},$size * sizeof(*r->in.$e->{NAME}));\n";
1392 pidl "\tmemset(r->out.$e->{NAME}, 0, $size * sizeof(*r->out.$e->{NAME}));\n";
1397 #####################################################################
1399 sub ParseFunctionPull($)
1402 my $static = fn_prefix($fn);
1404 # pull function args
1405 pidl $static . "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)\n{\n";
1407 # declare any internal pointers we need
1408 foreach my $e (@{$fn->{DATA}}) {
1409 if (util::need_wire_pointer($e)) {
1410 pidl "\tuint32_t _ptr_$e->{NAME};\n";
1414 pidl "\n\tif (!(flags & NDR_IN)) goto ndr_out;\n\n";
1416 # auto-init the out section of a structure. I originally argued that
1417 # this was a bad idea as it hides bugs, but coping correctly
1418 # with initialisation and not wiping ref vars is turning
1419 # out to be too tricky (tridge)
1420 foreach my $e (@{$fn->{DATA}}) {
1421 if (util::has_property($e, "out")) {
1422 pidl "\tZERO_STRUCT(r->out);\n\n";
1427 foreach my $e (@{$fn->{DATA}}) {
1428 if (util::has_property($e, "in")) {
1429 ParseFunctionElementPull($e, "in");
1431 # we need to allocate any reference output variables, so that
1432 # a dcerpc backend can be sure they are non-null
1433 if (util::has_property($e, "out") && util::has_property($e, "ref")) {
1434 AllocateRefVars($e);
1438 pidl "\nndr_out:\n";
1439 pidl "\tif (!(flags & NDR_OUT)) goto done;\n\n";
1440 foreach my $e (@{$fn->{DATA}}) {
1441 if (util::has_property($e, "out")) {
1442 ParseFunctionElementPull($e, "out");
1446 if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1447 pidl "\tNDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, &r->out.result));\n";
1451 pidl "\n\treturn NT_STATUS_OK;\n}\n\n";
1454 #####################################################################
1455 # produce a function call table
1456 sub FunctionTable($)
1458 my($interface) = shift;
1459 my($data) = $interface->{INHERITED_DATA};
1461 my $uname = uc $interface->{NAME};
1463 foreach my $d (@{$data}) {
1464 if ($d->{TYPE} eq "FUNCTION") { $count++; }
1471 pidl "static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {\n";
1472 foreach my $d (@{$data}) {
1473 if ($d->{TYPE} eq "FUNCTION") {
1475 pidl "\t\t\"$d->{NAME}\",\n";
1476 pidl "\t\tsizeof(struct $d->{NAME}),\n";
1477 pidl "\t\t(ndr_push_flags_fn_t) ndr_push_$d->{NAME},\n";
1478 pidl "\t\t(ndr_pull_flags_fn_t) ndr_pull_$d->{NAME},\n";
1479 pidl "\t\t(ndr_print_function_t) ndr_print_$d->{NAME}\n";
1483 pidl "\t{ NULL, 0, NULL, NULL }\n};\n\n";
1485 # If no endpoint is set, default to the interface name as a named pipe
1486 if (! defined $interface->{PROPERTIES}->{endpoint}) {
1487 $interface->{PROPERTIES}->{endpoint} = "\"ncacn_np:[\\\\pipe\\\\" . $interface->{NAME} . "]\"";
1490 my @e = split / /, $interface->{PROPERTIES}->{endpoint};
1491 my $endpoint_count = $#e + 1;
1493 pidl "static const char * const $interface->{NAME}\_endpoint_strings[] = {\n";
1494 foreach my $ep (@e) {
1499 pidl "static const struct dcerpc_endpoint_list $interface->{NAME}\_endpoints = {\n";
1500 pidl "\t$endpoint_count, $interface->{NAME}\_endpoint_strings\n";
1503 pidl "\nconst struct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {\n";
1504 pidl "\t\"$interface->{NAME}\",\n";
1505 pidl "\tDCERPC_$uname\_UUID,\n";
1506 pidl "\tDCERPC_$uname\_VERSION,\n";
1507 pidl "\tDCERPC_$uname\_HELPSTRING,\n";
1509 pidl "\t$interface->{NAME}\_calls,\n";
1510 pidl "\t&$interface->{NAME}\_endpoints\n";
1515 #####################################################################
1516 # parse the interface definitions
1517 sub ParseInterface($)
1519 my($interface) = shift;
1520 my($data) = $interface->{DATA};
1522 foreach my $d (@{$data}) {
1523 if ($d->{TYPE} eq "TYPEDEF") {
1524 $structs{$d->{NAME}} = $d;
1528 foreach my $d (@{$data}) {
1529 ($d->{TYPE} eq "TYPEDEF") &&
1530 ParseTypedefNdrSize($d);
1533 foreach my $d (@{$data}) {
1534 ($d->{TYPE} eq "TYPEDEF") &&
1535 ParseTypedefPush($d);
1536 ($d->{TYPE} eq "FUNCTION") &&
1537 ParseFunctionPush($d);
1539 foreach my $d (@{$data}) {
1540 ($d->{TYPE} eq "TYPEDEF") &&
1541 ParseTypedefPull($d);
1542 ($d->{TYPE} eq "FUNCTION") &&
1543 ParseFunctionPull($d);
1545 foreach my $d (@{$data}) {
1546 if ($d->{TYPE} eq "TYPEDEF" &&
1547 !util::has_property($d->{DATA}, "noprint")) {
1548 ParseTypedefPrint($d);
1550 if ($d->{TYPE} eq "FUNCTION" &&
1551 !util::has_property($d, "noprint")) {
1552 ParseFunctionPrint($d);
1556 FunctionTable($interface);
1560 #####################################################################
1561 # parse a parsed IDL structure back into an IDL file
1565 my($filename) = shift;
1567 open(OUT, ">$filename") || die "can't open $filename";
1569 pidl "/* parser auto-generated by pidl */\n\n";
1570 pidl "#include \"includes.h\"\n\n";
1571 foreach my $x (@{$idl}) {
1572 if ($x->{TYPE} eq "INTERFACE") {
1573 needed::BuildNeeded($x);
1578 pidl IdlClient::Parse($idl);