1 ###################################################
2 # Samba4 parser generator for IDL structures
3 # Copyright tridge@samba.org 2000-2003
4 # Copyright tpot@samba.org 2001
5 # released under the GNU GPL
13 # the list of needed functions
26 #####################################################################
27 # parse a properties list
28 sub ParseProperties($)
31 foreach my $d (@{$props}) {
32 if (ref($d) ne "HASH") {
35 foreach my $k (keys %{$d}) {
36 pidl "[$k($d->{$k})] ";
42 ###################################
43 # find a sibling var in a structure
48 my($fn) = $e->{PARENT};
50 if ($name =~ /\*(.*)/) {
54 if ($fn->{TYPE} eq "FUNCTION") {
55 for my $e2 (@{$fn->{DATA}}) {
56 if ($e2->{NAME} eq $name) {
62 for my $e2 (@{$fn->{ELEMENTS}}) {
63 if ($e2->{NAME} eq $name) {
67 die "invalid sibling '$name'";
70 ####################################################################
71 # work out the name of a size_is() variable
72 sub find_size_var($$$)
76 my($var_prefix) = shift;
78 my($fn) = $e->{PARENT};
80 if (util::is_constant($size)) {
84 if ($size =~ /ndr->|\(/) {
90 if ($size =~ /\*(.*)/) {
95 if ($fn->{TYPE} ne "FUNCTION") {
96 return $prefix . "r->$size";
99 my $e2 = find_sibling($e, $size);
101 if (util::has_property($e2, "in") && util::has_property($e2, "out")) {
102 return $prefix . "$var_prefix$size";
104 if (util::has_property($e2, "in")) {
105 return $prefix . "r->in.$size";
107 if (util::has_property($e2, "out")) {
108 return $prefix . "r->out.$size";
111 die "invalid variable in $size for element $e->{NAME} in $fn->{NAME}\n";
115 #####################################################################
116 # work out is a parse function should be declared static or not
120 if ($fn->{TYPE} eq "TYPEDEF") {
121 if (util::has_property($fn->{DATA}, "public")) {
126 if ($fn->{TYPE} eq "FUNCTION") {
127 if (util::has_property($fn, "public")) {
135 ###################################################################
136 # setup any special flags for an element or structure
140 my $flags = util::has_property($e, "flag");
141 if (defined $flags) {
142 pidl "\t{ uint32 _flags_save_$e->{TYPE} = ndr->flags;\n";
143 pidl "\tndr->flags |= $flags;\n";
147 ###################################################################
148 # end any special flags for an element or structure
152 my $flags = util::has_property($e, "flag");
153 if (defined $flags) {
154 pidl "\tndr->flags = _flags_save_$e->{TYPE};\n\t}\n";
159 #####################################################################
160 # work out the correct alignment for a structure
166 for my $e (@{$s->{ELEMENTS}}) {
169 if (!util::need_wire_pointer($e)
170 && defined $structs{$e->{TYPE}}) {
171 if ($structs{$e->{TYPE}}->{DATA}->{TYPE} eq "STRUCT") {
172 $a = struct_alignment($structs{$e->{TYPE}}->{DATA});
173 } elsif ($structs{$e->{TYPE}}->{DATA}->{TYPE} eq "UNION") {
174 if (defined $structs{$e->{TYPE}}->{DATA}) {
175 $a = union_alignment($structs{$e->{TYPE}}->{DATA});
179 $a = util::type_align($e);
190 #####################################################################
191 # work out the correct alignment for a union
198 foreach my $e (@{$u->{DATA}}) {
201 if ($e->{TYPE} eq "EMPTY") {
205 if (!util::need_wire_pointer($e)
206 && defined $structs{$e->{DATA}->{TYPE}}) {
207 my $s = $structs{$e->{DATA}->{TYPE}};
208 if ($s->{DATA}->{TYPE} eq "STRUCT") {
209 $a = struct_alignment($s->{DATA});
210 } elsif ($s->{DATA}->{TYPE} eq "UNION") {
211 $a = union_alignment($s->{DATA});
214 $a = util::type_align($e->{DATA});
225 #####################################################################
226 # parse an array - push side
227 sub ParseArrayPush($$$)
230 my $var_prefix = shift;
231 my $ndr_flags = shift;
233 my $size = find_size_var($e, util::array_size($e), $var_prefix);
235 if (defined $e->{CONFORMANT_SIZE}) {
236 # the conformant size has already been pushed
237 } elsif (!util::is_inline_array($e)) {
238 # we need to emit the array size
239 pidl "\t\tNDR_CHECK(ndr_push_uint32(ndr, $size));\n";
242 if (my $length = util::has_property($e, "length_is")) {
243 $length = find_size_var($e, $length, $var_prefix);
244 pidl "\t\tNDR_CHECK(ndr_push_uint32(ndr, 0));\n";
245 pidl "\t\tNDR_CHECK(ndr_push_uint32(ndr, $length));\n";
249 if (util::is_scalar_type($e->{TYPE})) {
250 pidl "\t\tNDR_CHECK(ndr_push_array_$e->{TYPE}(ndr, $ndr_flags, $var_prefix$e->{NAME}, $size));\n";
252 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";
256 #####################################################################
258 sub ParseArrayPrint($$)
261 my $var_prefix = shift;
262 my $size = find_size_var($e, util::array_size($e), $var_prefix);
263 my $length = util::has_property($e, "length_is");
265 if (defined $length) {
266 $size = find_size_var($e, $length, $var_prefix);
269 if (util::is_scalar_type($e->{TYPE})) {
270 pidl "\t\tndr_print_array_$e->{TYPE}(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME}, $size);\n";
272 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";
276 #####################################################################
277 # parse an array - pull side
278 sub ParseArrayPull($$$)
281 my $var_prefix = shift;
282 my $ndr_flags = shift;
284 my $size = find_size_var($e, util::array_size($e), $var_prefix);
285 my $alloc_size = $size;
287 # if this is a conformant array then we use that size to allocate, and make sure
288 # we allocate enough to pull the elements
289 if (defined $e->{CONFORMANT_SIZE}) {
290 $alloc_size = $e->{CONFORMANT_SIZE};
292 pidl "\tif ($size > $alloc_size) {\n";
293 pidl "\t\treturn ndr_pull_error(ndr, NDR_ERR_CONFORMANT_SIZE, \"Bad conformant size %u should be %u\", $alloc_size, $size);\n";
295 } elsif (!util::is_inline_array($e)) {
296 if ($var_prefix =~ /^r->out/ && $size =~ /^\*r->in/) {
297 my $size2 = substr($size, 1);
298 pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { NDR_ALLOC(ndr, $size2); }\n";
301 # non fixed arrays encode the size just before the array
303 pidl "\t\tuint32 _array_size;\n";
304 pidl "\t\tNDR_CHECK(ndr_pull_uint32(ndr, &_array_size));\n";
305 if ($size =~ /r->in/) {
306 pidl "\t\tif (!(ndr->flags & LIBNDR_FLAG_REF_ALLOC) && _array_size != $size) {\n";
308 pidl "\t\tif ($size != _array_size) {\n";
310 pidl "\t\t\treturn ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, \"Bad array size %u should be %u\", _array_size, $size);\n";
312 if ($size =~ /r->/) {
313 pidl "else { $size = _array_size; }\n";
318 if ((util::need_alloc($e) && !util::is_fixed_array($e)) ||
319 ($var_prefix eq "r->in." && util::has_property($e, "ref"))) {
320 if (!util::is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") {
321 pidl "\t\tNDR_ALLOC_N_SIZE(ndr, $var_prefix$e->{NAME}, MAX(1, $alloc_size), sizeof($var_prefix$e->{NAME}\[0]));\n";
325 if (($var_prefix eq "r->out." && util::has_property($e, "ref"))) {
326 if (!util::is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") {
327 pidl "\tif (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {";
328 pidl "\t\tNDR_ALLOC_N_SIZE(ndr, $var_prefix$e->{NAME}, MAX(1, $alloc_size), sizeof($var_prefix$e->{NAME}\[0]));\n";
335 if (my $length = util::has_property($e, "length_is")) {
336 $length = find_size_var($e, $length, $var_prefix);
337 pidl "\t\tuint32 _offset, _length;\n";
338 pidl "\t\tNDR_CHECK(ndr_pull_uint32(ndr, &_offset));\n";
339 pidl "\t\tNDR_CHECK(ndr_pull_uint32(ndr, &_length));\n";
340 pidl "\t\tif (_offset != 0) return ndr_pull_error(ndr, NDR_ERR_OFFSET, \"Bad array offset 0x%08x\", _offset);\n";
341 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";
345 if (util::is_scalar_type($e->{TYPE})) {
346 pidl "\t\tNDR_CHECK(ndr_pull_array_$e->{TYPE}(ndr, $ndr_flags, $var_prefix$e->{NAME}, $size));\n";
348 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";
355 #####################################################################
356 # parse scalars in a structure element
357 sub ParseElementPushScalar($$$)
360 my($var_prefix) = shift;
361 my($ndr_flags) = shift;
362 my $cprefix = util::c_push_prefix($e);
363 my $sub_size = util::has_property($e, "subcontext");
367 if (my $value = util::has_property($e, "value")) {
368 pidl "\t$cprefix$var_prefix$e->{NAME} = $value;\n";
371 if (util::has_property($e, "relative")) {
372 pidl "\tNDR_CHECK(ndr_push_relative(ndr, NDR_SCALARS, $var_prefix$e->{NAME}, (ndr_push_const_fn_t) ndr_push_$e->{TYPE}));\n";
373 } elsif (util::is_inline_array($e)) {
374 ParseArrayPush($e, "r->", "NDR_SCALARS");
375 } elsif (util::need_wire_pointer($e)) {
376 pidl "\tNDR_CHECK(ndr_push_ptr(ndr, $var_prefix$e->{NAME}));\n";
377 } elsif (util::need_alloc($e)) {
378 # no scalar component
379 } elsif (my $switch = util::has_property($e, "switch_is")) {
380 ParseElementPushSwitch($e, $var_prefix, $ndr_flags, $switch);
381 } elsif (defined $sub_size) {
382 if (util::is_builtin_type($e->{TYPE})) {
383 pidl "\tNDR_CHECK(ndr_push_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_push_fn_t) ndr_push_$e->{TYPE}));\n";
385 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";
387 } elsif (util::is_builtin_type($e->{TYPE})) {
388 pidl "\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
390 pidl "\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
396 #####################################################################
397 # print scalars in a structure element
398 sub ParseElementPrintScalar($$)
401 my($var_prefix) = shift;
402 my $cprefix = util::c_push_prefix($e);
404 if (util::has_property($e, "noprint")) {
408 if (util::is_fixed_array($e)) {
409 ParseElementPrintBuffer($e, $var_prefix);
410 } elsif (util::has_direct_buffers($e)) {
411 pidl "\tndr_print_ptr(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME});\n";
412 pidl "\tndr->depth++;\n";
413 ParseElementPrintBuffer($e, $var_prefix);
414 pidl "\tndr->depth--;\n";
415 } elsif (my $switch = util::has_property($e, "switch_is")) {
416 ParseElementPrintSwitch($e, $var_prefix, $switch);
418 pidl "\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME});\n";
422 #####################################################################
423 # parse scalars in a structure element - pull size
424 sub ParseElementPullSwitch($$$$)
427 my($var_prefix) = shift;
428 my($ndr_flags) = shift;
430 my $switch_var = find_size_var($e, $switch, $var_prefix);
432 my $cprefix = util::c_pull_prefix($e);
434 my $utype = $structs{$e->{TYPE}};
435 if (!defined $utype ||
436 !util::has_property($utype->{DATA}, "nodiscriminant")) {
437 my $e2 = find_sibling($e, $switch);
438 pidl "\tif (($ndr_flags) & NDR_SCALARS) {\n";
439 pidl "\t\t $e2->{TYPE} _level;\n";
440 pidl "\t\tNDR_CHECK(ndr_pull_$e2->{TYPE}(ndr, &_level));\n";
441 if ($switch_var =~ /r->in/) {
442 pidl "\t\tif (!(ndr->flags & LIBNDR_FLAG_REF_ALLOC) && _level != $switch_var) {\n";
444 pidl "\t\tif (_level != $switch_var) {\n";
446 pidl "\t\t\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u in $e->{NAME}\");\t\t}\n";
447 if ($switch =~ /r->/) {
448 pidl "else { $switch_var = _level; }\n";
453 my $sub_size = util::has_property($e, "subcontext");
454 if (defined $sub_size) {
455 pidl "\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";
457 pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $switch_var, $cprefix$var_prefix$e->{NAME}));\n";
463 #####################################################################
464 # push switch element
465 sub ParseElementPushSwitch($$$$)
468 my($var_prefix) = shift;
469 my($ndr_flags) = shift;
471 my $switch_var = find_size_var($e, $switch, $var_prefix);
472 my $cprefix = util::c_push_prefix($e);
474 my $utype = $structs{$e->{TYPE}};
475 if (!defined $utype ||
476 !util::has_property($utype->{DATA}, "nodiscriminant")) {
477 my $e2 = find_sibling($e, $switch);
478 pidl "\tif (($ndr_flags) & NDR_SCALARS) {\n";
479 pidl "\t\tNDR_CHECK(ndr_push_$e2->{TYPE}(ndr, $switch_var));\n";
483 my $sub_size = util::has_property($e, "subcontext");
484 if (defined $sub_size) {
485 pidl "\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";
487 pidl "\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $switch_var, $cprefix$var_prefix$e->{NAME}));\n";
491 #####################################################################
492 # print scalars in a structure element
493 sub ParseElementPrintSwitch($$$)
496 my($var_prefix) = shift;
498 my $switch_var = find_size_var($e, $switch, $var_prefix);
499 my $cprefix = util::c_push_prefix($e);
501 pidl "\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $switch_var, $cprefix$var_prefix$e->{NAME});\n";
505 #####################################################################
506 # parse scalars in a structure element - pull size
507 sub ParseElementPullScalar($$$)
510 my($var_prefix) = shift;
511 my($ndr_flags) = shift;
512 my $cprefix = util::c_pull_prefix($e);
513 my $sub_size = util::has_property($e, "subcontext");
517 if (util::has_property($e, "relative")) {
518 pidl "\tNDR_CHECK(ndr_pull_relative(ndr, (const void **)&$var_prefix$e->{NAME}, sizeof(*$var_prefix$e->{NAME}), (ndr_pull_flags_fn_t)ndr_pull_$e->{TYPE}));\n";
519 } elsif (util::is_inline_array($e)) {
520 ParseArrayPull($e, "r->", "NDR_SCALARS");
521 } elsif (util::need_wire_pointer($e)) {
522 pidl "\tNDR_CHECK(ndr_pull_uint32(ndr, &_ptr_$e->{NAME}));\n";
523 pidl "\tif (_ptr_$e->{NAME}) {\n";
524 pidl "\t\tNDR_ALLOC(ndr, $var_prefix$e->{NAME});\n";
526 pidl "\t\t$var_prefix$e->{NAME} = NULL;\n";
528 } elsif (util::need_alloc($e)) {
529 # no scalar component
530 } elsif (my $switch = util::has_property($e, "switch_is")) {
531 ParseElementPullSwitch($e, $var_prefix, $ndr_flags, $switch);
532 } elsif (defined $sub_size) {
533 if (util::is_builtin_type($e->{TYPE})) {
534 pidl "\tNDR_CHECK(ndr_pull_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_fn_t) ndr_pull_$e->{TYPE}));\n";
536 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";
538 } elsif (util::is_builtin_type($e->{TYPE})) {
539 pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
541 pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
547 #####################################################################
548 # parse buffers in a structure element
549 sub ParseElementPushBuffer($$$)
552 my($var_prefix) = shift;
553 my($ndr_flags) = shift;
554 my $cprefix = util::c_push_prefix($e);
555 my $sub_size = util::has_property($e, "subcontext");
557 if (util::is_pure_scalar($e)) {
563 if (util::need_wire_pointer($e)) {
564 pidl "\tif ($var_prefix$e->{NAME}) {\n";
567 if (util::has_property($e, "relative")) {
568 pidl "\tNDR_CHECK(ndr_push_relative(ndr, NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}, (ndr_push_const_fn_t) ndr_push_$e->{TYPE}));\n";
569 } elsif (util::is_inline_array($e)) {
570 ParseArrayPush($e, "r->", "NDR_BUFFERS");
571 } elsif (util::array_size($e)) {
572 ParseArrayPush($e, "r->", "NDR_SCALARS|NDR_BUFFERS");
573 } elsif (my $switch = util::has_property($e, "switch_is")) {
574 if ($e->{POINTERS}) {
575 ParseElementPushSwitch($e, $var_prefix, "NDR_BUFFERS|NDR_SCALARS", $switch);
577 ParseElementPushSwitch($e, $var_prefix, "NDR_BUFFERS", $switch);
579 } elsif (defined $sub_size) {
580 if ($e->{POINTERS}) {
581 if (util::is_builtin_type($e->{TYPE})) {
582 pidl "\tNDR_CHECK(ndr_push_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_push_fn_t) ndr_push_$e->{TYPE}));\n";
584 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";
587 } elsif (util::is_builtin_type($e->{TYPE})) {
588 pidl "\t\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
589 } elsif ($e->{POINTERS}) {
590 pidl "\t\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, NDR_SCALARS|NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}));\n";
592 pidl "\t\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
595 if (util::need_wire_pointer($e)) {
602 #####################################################################
603 # print buffers in a structure element
604 sub ParseElementPrintBuffer($$)
607 my($var_prefix) = shift;
608 my $cprefix = util::c_push_prefix($e);
610 if (util::need_wire_pointer($e)) {
611 pidl "\tif ($var_prefix$e->{NAME}) {\n";
614 if (util::array_size($e)) {
615 ParseArrayPrint($e, $var_prefix);
616 } elsif (my $switch = util::has_property($e, "switch_is")) {
617 ParseElementPrintSwitch($e, $var_prefix, $switch);
619 pidl "\t\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME});\n";
622 if (util::need_wire_pointer($e)) {
628 #####################################################################
629 # parse buffers in a structure element - pull side
630 sub ParseElementPullBuffer($$$)
633 my($var_prefix) = shift;
634 my($ndr_flags) = shift;
635 my $cprefix = util::c_pull_prefix($e);
636 my $sub_size = util::has_property($e, "subcontext");
638 if (util::is_pure_scalar($e)) {
642 if (util::has_property($e, "relative")) {
648 if (util::need_wire_pointer($e)) {
649 pidl "\tif ($var_prefix$e->{NAME}) {\n";
652 if (util::is_inline_array($e)) {
653 ParseArrayPull($e, "r->", "NDR_BUFFERS");
654 } elsif (util::array_size($e)) {
655 ParseArrayPull($e, "r->", "NDR_SCALARS|NDR_BUFFERS");
656 } elsif (my $switch = util::has_property($e, "switch_is")) {
657 if ($e->{POINTERS}) {
658 ParseElementPullSwitch($e, $var_prefix, "NDR_SCALARS|NDR_BUFFERS", $switch);
660 ParseElementPullSwitch($e, $var_prefix, "NDR_BUFFERS", $switch);
662 } elsif (defined $sub_size) {
663 if ($e->{POINTERS}) {
664 if (util::is_builtin_type($e->{TYPE})) {
665 pidl "\tNDR_CHECK(ndr_pull_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_fn_t) ndr_pull_$e->{TYPE}));\n";
667 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";
670 } elsif (util::is_builtin_type($e->{TYPE})) {
671 pidl "\t\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
672 } elsif ($e->{POINTERS}) {
673 pidl "\t\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, NDR_SCALARS|NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}));\n";
675 pidl "\t\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
678 if (util::need_wire_pointer($e)) {
685 #####################################################################
687 sub ParseStructPush($)
692 if (! defined $struct->{ELEMENTS}) {
696 start_flags($struct);
698 # see if the structure contains a conformant array. If it
699 # does, then it must be the last element of the structure, and
700 # we need to push the conformant length early, as it fits on
701 # the wire before the structure (and even before the structure
703 my $e = $struct->{ELEMENTS}[-1];
704 if (defined $e->{ARRAY_LEN} && $e->{ARRAY_LEN} eq "*") {
705 my $size = find_size_var($e, util::array_size($e), "r->");
706 $e->{CONFORMANT_SIZE} = $size;
708 pidl "\tNDR_CHECK(ndr_push_uint32(ndr, $size));\n";
711 pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
713 pidl "\tNDR_CHECK(ndr_push_struct_start(ndr));\n";
715 my $align = struct_alignment($struct);
716 pidl "\tNDR_CHECK(ndr_push_align(ndr, $align));\n";
718 foreach my $e (@{$struct->{ELEMENTS}}) {
719 ParseElementPushScalar($e, "r->", "NDR_SCALARS");
723 pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
724 foreach my $e (@{$struct->{ELEMENTS}}) {
725 ParseElementPushBuffer($e, "r->", "NDR_BUFFERS");
728 pidl "\tndr_push_struct_end(ndr);\n";
735 #####################################################################
736 # generate a struct print function
737 sub ParseStructPrint($)
741 if (! defined $struct->{ELEMENTS}) {
745 start_flags($struct);
747 pidl "\tndr->depth++;\n";
748 foreach my $e (@{$struct->{ELEMENTS}}) {
749 ParseElementPrintScalar($e, "r->");
751 pidl "\tndr->depth--;\n";
756 #####################################################################
757 # parse a struct - pull side
758 sub ParseStructPull($)
763 if (! defined $struct->{ELEMENTS}) {
767 start_flags($struct);
769 # see if the structure contains a conformant array. If it
770 # does, then it must be the last element of the structure, and
771 # we need to pull the conformant length early, as it fits on
772 # the wire before the structure (and even before the structure
774 my $e = $struct->{ELEMENTS}[-1];
775 if (defined $e->{ARRAY_LEN} && $e->{ARRAY_LEN} eq "*") {
777 pidl "\tuint32 _conformant_size;\n";
778 $conform_e->{CONFORMANT_SIZE} = "_conformant_size";
781 # declare any internal pointers we need
782 foreach my $e (@{$struct->{ELEMENTS}}) {
783 if (util::need_wire_pointer($e) &&
784 !util::has_property($e, "relative")) {
785 pidl "\tuint32 _ptr_$e->{NAME};\n";
789 pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
791 pidl "\tNDR_CHECK(ndr_pull_struct_start(ndr));\n";
793 if (defined $conform_e) {
794 pidl "\tNDR_CHECK(ndr_pull_uint32(ndr, &$conform_e->{CONFORMANT_SIZE}));\n";
797 my $align = struct_alignment($struct);
798 pidl "\tNDR_CHECK(ndr_pull_align(ndr, $align));\n";
800 foreach my $e (@{$struct->{ELEMENTS}}) {
801 ParseElementPullScalar($e, "r->", "NDR_SCALARS");
805 pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
806 foreach my $e (@{$struct->{ELEMENTS}}) {
807 ParseElementPullBuffer($e, "r->", "NDR_BUFFERS");
810 pidl "\tndr_pull_struct_end(ndr);\n";
818 #####################################################################
819 # parse a union - push side
820 sub ParseUnionPush($)
823 my $have_default = 0;
827 pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
829 pidl "\tNDR_CHECK(ndr_push_struct_start(ndr));\n";
831 # my $align = union_alignment($e);
832 # pidl "\tNDR_CHECK(ndr_push_align(ndr, $align));\n";
834 pidl "\tswitch (level) {\n";
835 foreach my $el (@{$e->{DATA}}) {
836 if ($el->{CASE} eq "default") {
840 pidl "\tcase $el->{CASE}:\n";
842 if ($el->{TYPE} eq "UNION_ELEMENT") {
843 ParseElementPushScalar($el->{DATA}, "r->", "NDR_SCALARS");
847 if (! $have_default) {
849 pidl "\t\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
853 pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
854 pidl "\tswitch (level) {\n";
855 foreach my $el (@{$e->{DATA}}) {
856 if ($el->{CASE} eq "default") {
859 pidl "\tcase $el->{CASE}:\n";
861 if ($el->{TYPE} eq "UNION_ELEMENT") {
862 ParseElementPushBuffer($el->{DATA}, "r->", "NDR_BUFFERS");
866 if (! $have_default) {
868 pidl "\t\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
871 pidl "\tndr_push_struct_end(ndr);\n";
876 #####################################################################
878 sub ParseUnionPrint($)
881 my $have_default = 0;
885 pidl "\tswitch (level) {\n";
886 foreach my $el (@{$e->{DATA}}) {
887 if ($el->{CASE} eq "default") {
891 pidl "\tcase $el->{CASE}:\n";
893 if ($el->{TYPE} eq "UNION_ELEMENT") {
894 ParseElementPrintScalar($el->{DATA}, "r->");
898 if (! $have_default) {
899 pidl "\tdefault:\n\t\tndr_print_bad_level(ndr, name, level);\n";
906 #####################################################################
907 # parse a union - pull side
908 sub ParseUnionPull($)
911 my $have_default = 0;
915 pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
917 pidl "\tNDR_CHECK(ndr_pull_struct_start(ndr));\n";
919 # my $align = union_alignment($e);
920 # pidl "\tNDR_CHECK(ndr_pull_align(ndr, $align));\n";
922 pidl "\tswitch (level) {\n";
923 foreach my $el (@{$e->{DATA}}) {
924 if ($el->{CASE} eq "default") {
925 pidl "\tdefault: {\n";
928 pidl "\tcase $el->{CASE}: {\n";
930 if ($el->{TYPE} eq "UNION_ELEMENT") {
931 my $e2 = $el->{DATA};
932 if ($e2->{POINTERS}) {
933 pidl "\t\tuint32 _ptr_$e2->{NAME};\n";
935 ParseElementPullScalar($el->{DATA}, "r->", "NDR_SCALARS");
937 pidl "\tbreak; }\n\n";
939 if (! $have_default) {
941 pidl "\t\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
945 pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
946 pidl "\tswitch (level) {\n";
947 foreach my $el (@{$e->{DATA}}) {
948 if ($el->{CASE} eq "default") {
951 pidl "\tcase $el->{CASE}:\n";
953 if ($el->{TYPE} eq "UNION_ELEMENT") {
954 ParseElementPullBuffer($el->{DATA}, "r->", "NDR_BUFFERS");
958 if (! $have_default) {
960 pidl "\t\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
963 pidl "\tndr_pull_struct_end(ndr);\n";
968 #####################################################################
974 if (ref($data) eq "HASH") {
975 ($data->{TYPE} eq "STRUCT") &&
976 ParseStructPush($data);
977 ($data->{TYPE} eq "UNION") &&
978 ParseUnionPush($data);
982 #####################################################################
983 # generate a print function for a type
984 sub ParseTypePrint($)
988 if (ref($data) eq "HASH") {
989 ($data->{TYPE} eq "STRUCT") &&
990 ParseStructPrint($data);
991 ($data->{TYPE} eq "UNION") &&
992 ParseUnionPrint($data);
996 #####################################################################
1002 if (ref($data) eq "HASH") {
1003 ($data->{TYPE} eq "STRUCT") &&
1004 ParseStructPull($data);
1005 ($data->{TYPE} eq "UNION") &&
1006 ParseUnionPull($data);
1010 #####################################################################
1011 # parse a typedef - push side
1012 sub ParseTypedefPush($)
1015 my $static = fn_prefix($e);
1017 if (! $needed{"push_$e->{NAME}"}) {
1018 # print "push_$e->{NAME} not needed\n";
1022 if ($e->{DATA}->{TYPE} eq "STRUCT") {
1023 pidl $static . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, struct $e->{NAME} *r)";
1025 ParseTypePush($e->{DATA});
1026 pidl "\treturn NT_STATUS_OK;\n";
1030 if ($e->{DATA}->{TYPE} eq "UNION") {
1031 pidl $static . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, uint16 level, union $e->{NAME} *r)";
1033 ParseTypePush($e->{DATA});
1034 pidl "\treturn NT_STATUS_OK;\n";
1040 #####################################################################
1041 # parse a typedef - pull side
1042 sub ParseTypedefPull($)
1045 my $static = fn_prefix($e);
1047 if (! $needed{"pull_$e->{NAME}"}) {
1048 # print "pull_$e->{NAME} not needed\n";
1052 if ($e->{DATA}->{TYPE} eq "STRUCT") {
1053 pidl $static . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, struct $e->{NAME} *r)";
1055 ParseTypePull($e->{DATA});
1056 pidl "\treturn NT_STATUS_OK;\n";
1060 if ($e->{DATA}->{TYPE} eq "UNION") {
1061 pidl $static . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, uint16 level, union $e->{NAME} *r)";
1063 ParseTypePull($e->{DATA});
1064 pidl "\treturn NT_STATUS_OK;\n";
1070 #####################################################################
1071 # parse a typedef - print side
1072 sub ParseTypedefPrint($)
1076 if ($e->{DATA}->{TYPE} eq "STRUCT") {
1077 pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, struct $e->{NAME} *r)";
1079 pidl "\tndr_print_struct(ndr, name, \"$e->{NAME}\");\n";
1080 ParseTypePrint($e->{DATA});
1084 if ($e->{DATA}->{TYPE} eq "UNION") {
1085 pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, uint16 level, union $e->{NAME} *r)";
1087 pidl "\tndr_print_union(ndr, name, level, \"$e->{NAME}\");\n";
1088 ParseTypePrint($e->{DATA});
1093 #####################################################################
1094 # parse a function - print side
1095 sub ParseFunctionPrint($)
1099 pidl "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, struct $fn->{NAME} *r)";
1101 pidl "\tndr_print_struct(ndr, name, \"$fn->{NAME}\");\n";
1102 pidl "\tndr->depth++;\n";
1104 pidl "\tif (flags & NDR_IN) {\n";
1105 pidl "\t\tndr_print_struct(ndr, \"in\", \"$fn->{NAME}\");\n";
1106 pidl "\tndr->depth++;\n";
1107 foreach my $e (@{$fn->{DATA}}) {
1108 if (util::has_property($e, "in")) {
1109 ParseElementPrintScalar($e, "r->in.");
1112 pidl "\tndr->depth--;\n";
1115 pidl "\tif (flags & NDR_OUT) {\n";
1116 pidl "\t\tndr_print_struct(ndr, \"out\", \"$fn->{NAME}\");\n";
1117 pidl "\tndr->depth++;\n";
1118 foreach my $e (@{$fn->{DATA}}) {
1119 if (util::has_property($e, "out")) {
1120 ParseElementPrintScalar($e, "r->out.");
1123 if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1124 if (util::is_scalar_type($fn->{RETURN_TYPE})) {
1125 pidl "\tndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", r->out.result);\n";
1127 pidl "\tndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", &r->out.result);\n";
1130 pidl "\tndr->depth--;\n";
1133 pidl "\tndr->depth--;\n";
1138 #####################################################################
1139 # parse a function element
1140 sub ParseFunctionElementPush($$)
1145 if (util::array_size($e)) {
1146 if (util::need_wire_pointer($e)) {
1147 pidl "\tNDR_CHECK(ndr_push_ptr(ndr, r->$inout.$e->{NAME}));\n";
1149 pidl "\tif (r->$inout.$e->{NAME}) {\n";
1150 ParseArrayPush($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1153 ParseElementPushScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1154 if ($e->{POINTERS}) {
1155 ParseElementPushBuffer($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1160 #####################################################################
1162 sub ParseFunctionPush($)
1165 my $static = fn_prefix($fn);
1167 pidl $static . "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, struct $fn->{NAME} *r)\n{\n";
1169 pidl "\n\tif (!(flags & NDR_IN)) goto ndr_out;\n\n";
1170 foreach my $e (@{$fn->{DATA}}) {
1171 if (util::has_property($e, "in")) {
1172 ParseFunctionElementPush($e, "in");
1176 pidl "\nndr_out:\n";
1177 pidl "\tif (!(flags & NDR_OUT)) goto done;\n\n";
1178 foreach my $e (@{$fn->{DATA}}) {
1179 if (util::has_property($e, "out")) {
1180 ParseFunctionElementPush($e, "out");
1184 if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1185 pidl "\tNDR_CHECK(ndr_push_$fn->{RETURN_TYPE}(ndr, r->out.result));\n";
1189 pidl "\n\treturn NT_STATUS_OK;\n}\n\n";
1192 #####################################################################
1193 # parse a function element
1194 sub ParseFunctionElementPull($$)
1199 if (util::array_size($e)) {
1200 if (util::need_wire_pointer($e)) {
1201 pidl "\tNDR_CHECK(ndr_pull_uint32(ndr, &_ptr_$e->{NAME}));\n";
1202 pidl "\tif (_ptr_$e->{NAME}) {\n";
1203 } elsif ($inout eq "out" && util::has_property($e, "ref")) {
1204 pidl "\tif (r->$inout.$e->{NAME}) {\n";
1208 ParseArrayPull($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1211 if ($inout eq "out" && util::has_property($e, "ref")) {
1212 pidl "\tif (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {\n";
1213 pidl "\tNDR_ALLOC(ndr, r->out.$e->{NAME});\n";
1216 if ($inout eq "in" && util::has_property($e, "ref")) {
1217 pidl "\tNDR_ALLOC(ndr, r->in.$e->{NAME});\n";
1220 ParseElementPullScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1221 if ($e->{POINTERS}) {
1222 ParseElementPullBuffer($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1227 #####################################################################
1229 sub ParseFunctionPull($)
1232 my $static = fn_prefix($fn);
1234 # pull function args
1235 pidl $static . "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)\n{\n";
1237 # declare any internal pointers we need
1238 foreach my $e (@{$fn->{DATA}}) {
1239 if (util::need_wire_pointer($e)) {
1240 pidl "\tuint32 _ptr_$e->{NAME};\n";
1244 pidl "\n\tif (!(flags & NDR_IN)) goto ndr_out;\n\n";
1245 foreach my $e (@{$fn->{DATA}}) {
1246 if (util::has_property($e, "in")) {
1247 ParseFunctionElementPull($e, "in");
1251 pidl "\nndr_out:\n";
1252 pidl "\tif (!(flags & NDR_OUT)) goto done;\n\n";
1253 foreach my $e (@{$fn->{DATA}}) {
1254 if (util::has_property($e, "out")) {
1255 ParseFunctionElementPull($e, "out");
1259 if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1260 pidl "\tNDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, &r->out.result));\n";
1264 pidl "\n\treturn NT_STATUS_OK;\n}\n\n";
1267 #####################################################################
1268 # produce a function call table
1269 sub FunctionTable($)
1271 my($interface) = shift;
1272 my($data) = $interface->{DATA};
1274 my $uname = uc $interface->{NAME};
1276 foreach my $d (@{$data}) {
1277 if ($d->{TYPE} eq "FUNCTION") { $count++; }
1284 pidl "static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {\n";
1285 foreach my $d (@{$data}) {
1286 if ($d->{TYPE} eq "FUNCTION") {
1288 pidl "\t\t\"$d->{NAME}\",\n";
1289 pidl "\t\tsizeof(struct $d->{NAME}),\n";
1290 pidl "\t\t(ndr_push_flags_fn_t) ndr_push_$d->{NAME},\n";
1291 pidl "\t\t(ndr_pull_flags_fn_t) ndr_pull_$d->{NAME},\n";
1292 pidl "\t\t(ndr_print_function_t) ndr_print_$d->{NAME}\n";
1296 pidl "\t{ NULL, 0, NULL, NULL }\n};\n\n";
1300 if (! defined $if_endpoints) {
1301 $if_endpoints = $interface->{NAME};
1304 pidl "static const struct dcerpc_endpoint_list $interface->{NAME}\_endpoints = {\n";
1305 my @e = split / /, $if_endpoints;
1306 my $endpoint_count = $#e + 1;
1307 pidl "\t$endpoint_count,\n";
1309 for (my $i=0; $i < $#e; $i++) {
1310 pidl "\"$e[$i]\", ";
1312 pidl "\"$e[$#e]\" }\n";
1315 pidl "\nconst struct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {\n";
1316 pidl "\t\"$interface->{NAME}\",\n";
1317 pidl "\tDCERPC_$uname\_UUID,\n";
1318 pidl "\tDCERPC_$uname\_VERSION,\n";
1320 pidl "\t$interface->{NAME}\_calls,\n";
1321 pidl "\t&$interface->{NAME}\_endpoints\n";
1326 #####################################################################
1327 # parse the interface definitions
1328 sub ParseInterface($)
1330 my($interface) = shift;
1331 my($data) = $interface->{DATA};
1333 foreach my $d (@{$data}) {
1334 if ($d->{TYPE} eq "TYPEDEF") {
1335 $structs{$d->{NAME}} = $d;
1341 foreach my $d (@{$data}) {
1342 ($d->{TYPE} eq "TYPEDEF") &&
1343 ParseTypedefPush($d);
1344 ($d->{TYPE} eq "FUNCTION") &&
1345 ParseFunctionPush($d);
1347 foreach my $d (@{$data}) {
1348 ($d->{TYPE} eq "TYPEDEF") &&
1349 ParseTypedefPull($d);
1350 ($d->{TYPE} eq "FUNCTION") &&
1351 ParseFunctionPull($d);
1353 foreach my $d (@{$data}) {
1354 if ($d->{TYPE} eq "TYPEDEF" &&
1355 !util::has_property($d->{DATA}, "noprint")) {
1356 ParseTypedefPrint($d);
1358 if ($d->{TYPE} eq "FUNCTION" &&
1359 !util::has_property($d, "noprint")) {
1360 ParseFunctionPrint($d);
1364 FunctionTable($interface);
1368 sub NeededFunction($)
1371 $needed{"pull_$fn->{NAME}"} = 1;
1372 $needed{"push_$fn->{NAME}"} = 1;
1373 foreach my $e (@{$fn->{DATA}}) {
1375 $needed{"pull_$e->{TYPE}"} = 1;
1376 $needed{"push_$e->{TYPE}"} = 1;
1380 sub NeededTypedef($)
1383 if (util::has_property($t->{DATA}, "public")) {
1384 $needed{"pull_$t->{NAME}"} = 1;
1385 $needed{"push_$t->{NAME}"} = 1;
1387 if ($t->{DATA}->{TYPE} eq "STRUCT") {
1388 for my $e (@{$t->{DATA}->{ELEMENTS}}) {
1389 $e->{PARENT} = $t->{DATA};
1390 if ($needed{"pull_$t->{NAME}"}) {
1391 $needed{"pull_$e->{TYPE}"} = 1;
1393 if ($needed{"push_$t->{NAME}"}) {
1394 $needed{"push_$e->{TYPE}"} = 1;
1398 if ($t->{DATA}->{TYPE} eq "UNION") {
1399 for my $e (@{$t->{DATA}->{DATA}}) {
1400 $e->{PARENT} = $t->{DATA};
1401 if ($e->{TYPE} eq "UNION_ELEMENT") {
1402 if ($needed{"pull_$t->{NAME}"}) {
1403 $needed{"pull_$e->{DATA}->{TYPE}"} = 1;
1405 if ($needed{"push_$t->{NAME}"}) {
1406 $needed{"push_$e->{DATA}->{TYPE}"} = 1;
1413 #####################################################################
1414 # work out what parse functions are needed
1417 my($interface) = shift;
1418 my($data) = $interface->{DATA};
1419 foreach my $d (@{$data}) {
1420 ($d->{TYPE} eq "FUNCTION") &&
1423 foreach my $d (reverse @{$data}) {
1424 ($d->{TYPE} eq "TYPEDEF") &&
1429 #####################################################################
1430 # parse the interface definitions
1435 $if_uuid = $h->{PROPERTIES}->{uuid};
1436 $if_version = $h->{PROPERTIES}->{version};
1437 $if_endpoints = $h->{PROPERTIES}->{endpoints};
1440 #####################################################################
1441 # parse a parsed IDL structure back into an IDL file
1445 my($filename) = shift;
1447 open(OUT, ">$filename") || die "can't open $filename";
1449 pidl "/* parser auto-generated by pidl */\n\n";
1450 pidl "#include \"includes.h\"\n\n";
1451 foreach my $x (@{$idl}) {
1452 ($x->{TYPE} eq "MODULEHEADER") &&
1455 if ($x->{TYPE} eq "INTERFACE") {
1461 pidl IdlClient::Parse($idl);