package IdlParser;
-use Data::Dumper;
-
-my($res);
+use strict;
+use client;
# the list of needed functions
my %needed;
+my %structs;
+
+my $if_uuid;
+my $if_version;
+my $if_endpoints;
+
+sub pidl($)
+{
+ print OUT shift;
+}
#####################################################################
# parse a properties list
my($props) = shift;
foreach my $d (@{$props}) {
if (ref($d) ne "HASH") {
- $res .= "[$d] ";
+ pidl "[$d] ";
} else {
foreach my $k (keys %{$d}) {
- $res .= "[$k($d->{$k})] ";
+ pidl "[$k($d->{$k})] ";
}
}
}
}
+###################################
+# find a sibling var in a structure
+sub find_sibling($$)
+{
+ my($e) = shift;
+ my($name) = shift;
+ my($fn) = $e->{PARENT};
+
+ if ($name =~ /\*(.*)/) {
+ $name = $1;
+ }
+
+ if ($fn->{TYPE} eq "FUNCTION") {
+ for my $e2 (@{$fn->{DATA}}) {
+ if ($e2->{NAME} eq $name) {
+ return $e2;
+ }
+ }
+ }
+
+ for my $e2 (@{$fn->{ELEMENTS}}) {
+ if ($e2->{NAME} eq $name) {
+ return $e2;
+ }
+ }
+ die "invalid sibling '$name'";
+}
+
####################################################################
# work out the name of a size_is() variable
-sub find_size_var($$)
+sub find_size_var($$$)
{
my($e) = shift;
my($size) = shift;
+ my($var_prefix) = shift;
+
my($fn) = $e->{PARENT};
-
+
+ if (util::is_constant($size)) {
+ return $size;
+ }
+
+ if ($size =~ /ndr->|\(/) {
+ return $size;
+ }
+
+ my $prefix = "";
+
+ if ($size =~ /\*(.*)/) {
+ $size = $1;
+ $prefix = "*";
+ }
+
if ($fn->{TYPE} ne "FUNCTION") {
- return "r->$size";
+ return $prefix . "r->$size";
}
- for my $e2 (@{$fn->{DATA}}) {
- if ($e2->{NAME} eq $size) {
- if (util::has_property($e2, "in")) {
- return "r->in.$size";
- }
- if (util::has_property($e2, "out")) {
- return "r->out.$size";
- }
- }
+ my $e2 = find_sibling($e, $size);
+
+ if (util::has_property($e2, "in") && util::has_property($e2, "out")) {
+ return $prefix . "$var_prefix$size";
+ }
+ if (util::has_property($e2, "in")) {
+ return $prefix . "r->in.$size";
}
+ if (util::has_property($e2, "out")) {
+ return $prefix . "r->out.$size";
+ }
+
die "invalid variable in $size for element $e->{NAME} in $fn->{NAME}\n";
}
+#####################################################################
+# work out is a parse function should be declared static or not
+sub fn_prefix($)
+{
+ my $fn = shift;
+ if ($fn->{TYPE} eq "TYPEDEF") {
+ if (util::has_property($fn->{DATA}, "public")) {
+ return "";
+ }
+ }
+
+ if ($fn->{TYPE} eq "FUNCTION") {
+ if (util::has_property($fn, "public")) {
+ return "";
+ }
+ }
+ return "static ";
+}
+
+
+###################################################################
+# setup any special flags for an element or structure
+sub start_flags($)
+{
+ my $e = shift;
+ my $flags = util::has_property($e, "flag");
+ if (defined $flags) {
+ pidl "\t{ uint32_t _flags_save_$e->{TYPE} = ndr->flags;\n";
+ pidl "\tndr->flags |= $flags;\n";
+ }
+}
+
+###################################################################
+# end any special flags for an element or structure
+sub end_flags($)
+{
+ my $e = shift;
+ my $flags = util::has_property($e, "flag");
+ if (defined $flags) {
+ pidl "\tndr->flags = _flags_save_$e->{TYPE};\n\t}\n";
+ }
+}
+
+
#####################################################################
# work out the correct alignment for a structure
-sub struct_alignment($)
+sub struct_alignment
{
my $s = shift;
+
my $align = 1;
for my $e (@{$s->{ELEMENTS}}) {
- if ($align < util::type_align($e)) {
- $align = util::type_align($e);
+ my $a = 1;
+
+ if (!util::need_wire_pointer($e)
+ && defined $structs{$e->{TYPE}}) {
+ if ($structs{$e->{TYPE}}->{DATA}->{TYPE} eq "STRUCT") {
+ $a = struct_alignment($structs{$e->{TYPE}}->{DATA});
+ } elsif ($structs{$e->{TYPE}}->{DATA}->{TYPE} eq "UNION") {
+ if (defined $structs{$e->{TYPE}}->{DATA}) {
+ $a = union_alignment($structs{$e->{TYPE}}->{DATA});
+ }
+ }
+ } else {
+ $a = util::type_align($e);
+ }
+
+ if ($align < $a) {
+ $align = $a;
}
}
+
+ return $align;
+}
+
+#####################################################################
+# work out the correct alignment for a union
+sub union_alignment
+{
+ my $u = shift;
+
+ my $align = 1;
+
+ foreach my $e (@{$u->{DATA}}) {
+ my $a = 1;
+
+ if ($e->{TYPE} eq "EMPTY") {
+ next;
+ }
+
+ if (!util::need_wire_pointer($e)
+ && defined $structs{$e->{DATA}->{TYPE}}) {
+ my $s = $structs{$e->{DATA}->{TYPE}};
+ if ($s->{DATA}->{TYPE} eq "STRUCT") {
+ $a = struct_alignment($s->{DATA});
+ } elsif ($s->{DATA}->{TYPE} eq "UNION") {
+ $a = union_alignment($s->{DATA});
+ }
+ } else {
+ $a = util::type_align($e->{DATA});
+ }
+
+ if ($align < $a) {
+ $align = $a;
+ }
+ }
+
return $align;
}
#####################################################################
# parse an array - push side
-sub ParseArrayPush($$)
+sub ParseArrayPush($$$)
{
my $e = shift;
my $var_prefix = shift;
- my $size = find_size_var($e, util::array_size($e));
+ my $ndr_flags = shift;
+
+ my $size = find_size_var($e, util::array_size($e), $var_prefix);
+
+ if (defined $e->{CONFORMANT_SIZE}) {
+ # the conformant size has already been pushed
+ } elsif (!util::is_inline_array($e)) {
+ # we need to emit the array size
+ pidl "\t\tNDR_CHECK(ndr_push_uint32(ndr, $size));\n";
+ }
+
+ if (my $length = util::has_property($e, "length_is")) {
+ $length = find_size_var($e, $length, $var_prefix);
+ pidl "\t\tNDR_CHECK(ndr_push_uint32(ndr, 0));\n";
+ pidl "\t\tNDR_CHECK(ndr_push_uint32(ndr, $length));\n";
+ $size = $length;
+ }
if (util::is_scalar_type($e->{TYPE})) {
- $res .= "\t\tNDR_CHECK(ndr_push_array_$e->{TYPE}(ndr, $var_prefix$e->{NAME}, $size));\n";
+ pidl "\t\tNDR_CHECK(ndr_push_array_$e->{TYPE}(ndr, $ndr_flags, $var_prefix$e->{NAME}, $size));\n";
} else {
- $res .= "\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";
+ 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";
}
}
{
my $e = shift;
my $var_prefix = shift;
- my $size = find_size_var($e, util::array_size($e));
+ my $size = find_size_var($e, util::array_size($e), $var_prefix);
+ my $length = util::has_property($e, "length_is");
+
+ if (defined $length) {
+ $size = find_size_var($e, $length, $var_prefix);
+ }
if (util::is_scalar_type($e->{TYPE})) {
- $res .= "\t\tndr_print_array_$e->{TYPE}(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME}, $size);\n";
+ pidl "\t\tndr_print_array_$e->{TYPE}(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME}, $size);\n";
} else {
- $res .= "\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";
+ 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";
}
}
#####################################################################
# parse an array - pull side
-sub ParseArrayPull($$)
+sub ParseArrayPull($$$)
{
my $e = shift;
my $var_prefix = shift;
- my $size = find_size_var($e, util::array_size($e));
+ my $ndr_flags = shift;
+
+ my $size = find_size_var($e, util::array_size($e), $var_prefix);
+ my $alloc_size = $size;
+
+ # if this is a conformant array then we use that size to allocate, and make sure
+ # we allocate enough to pull the elements
+ if (defined $e->{CONFORMANT_SIZE}) {
+ $alloc_size = $e->{CONFORMANT_SIZE};
+
+ pidl "\tif ($size > $alloc_size) {\n";
+ pidl "\t\treturn ndr_pull_error(ndr, NDR_ERR_CONFORMANT_SIZE, \"Bad conformant size %u should be %u\", $alloc_size, $size);\n";
+ pidl "\t}\n";
+ } elsif (!util::is_inline_array($e)) {
+ if ($var_prefix =~ /^r->out/ && $size =~ /^\*r->in/) {
+ my $size2 = substr($size, 1);
+ pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { NDR_ALLOC(ndr, $size2); }\n";
+ }
+
+ # non fixed arrays encode the size just before the array
+ pidl "\t{\n";
+ pidl "\t\tuint32_t _array_size;\n";
+ pidl "\t\tNDR_CHECK(ndr_pull_uint32(ndr, &_array_size));\n";
+ if ($size =~ /r->in/) {
+ pidl "\t\tif (!(ndr->flags & LIBNDR_FLAG_REF_ALLOC) && _array_size != $size) {\n";
+ } else {
+ pidl "\t\tif ($size != _array_size) {\n";
+ }
+ pidl "\t\t\treturn ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, \"Bad array size %u should be %u\", _array_size, $size);\n";
+ pidl "\t\t}\n";
+ if ($size =~ /r->in/) {
+ pidl "else { $size = _array_size; }\n";
+ }
+ pidl "\t}\n";
+ }
+
+ if ((util::need_alloc($e) && !util::is_fixed_array($e)) ||
+ ($var_prefix eq "r->in." && util::has_property($e, "ref"))) {
+ if (!util::is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") {
+ pidl "\t\tNDR_ALLOC_N(ndr, $var_prefix$e->{NAME}, MAX(1, $alloc_size));\n";
+ }
+ }
- if (util::need_alloc($e)) {
- $res .= "\t\tNDR_ALLOC_N_SIZE(ndr, $var_prefix$e->{NAME}, $size, sizeof($var_prefix$e->{NAME}\[0]));\n";
+ if (($var_prefix eq "r->out." && util::has_property($e, "ref"))) {
+ if (!util::is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") {
+ pidl "\tif (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {";
+ pidl "\t\tNDR_ALLOC_N(ndr, $var_prefix$e->{NAME}, MAX(1, $alloc_size));\n";
+ pidl "\t}\n";
+ }
}
+
+ pidl "\t{\n";
+
+ if (my $length = util::has_property($e, "length_is")) {
+ $length = find_size_var($e, $length, $var_prefix);
+ pidl "\t\tuint32_t _offset, _length;\n";
+ pidl "\t\tNDR_CHECK(ndr_pull_uint32(ndr, &_offset));\n";
+ pidl "\t\tNDR_CHECK(ndr_pull_uint32(ndr, &_length));\n";
+ pidl "\t\tif (_offset != 0) return ndr_pull_error(ndr, NDR_ERR_OFFSET, \"Bad array offset 0x%08x\", _offset);\n";
+ 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";
+ $size = "_length";
+ }
+
if (util::is_scalar_type($e->{TYPE})) {
- $res .= "\t\tNDR_CHECK(ndr_pull_array_$e->{TYPE}(ndr, $var_prefix$e->{NAME}, $size));\n";
+ pidl "\t\tNDR_CHECK(ndr_pull_array_$e->{TYPE}(ndr, $ndr_flags, $var_prefix$e->{NAME}, $size));\n";
} else {
- $res .= "\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";
+ 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";
}
+
+ pidl "\t}\n";
}
my($var_prefix) = shift;
my($ndr_flags) = shift;
my $cprefix = util::c_push_prefix($e);
+ my $sub_size = util::has_property($e, "subcontext");
+
+ start_flags($e);
+
+ if (my $value = util::has_property($e, "value")) {
+ pidl "\t$cprefix$var_prefix$e->{NAME} = $value;\n";
+ }
- if (defined $e->{VALUE}) {
- $res .= "\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $e->{VALUE}));\n";
+ if (util::has_property($e, "relative")) {
+ pidl "\tNDR_CHECK(ndr_push_relative(ndr, NDR_SCALARS, $var_prefix$e->{NAME}, (ndr_push_const_fn_t) ndr_push_$e->{TYPE}));\n";
+ } elsif (util::is_inline_array($e)) {
+ ParseArrayPush($e, "r->", "NDR_SCALARS");
} elsif (util::need_wire_pointer($e)) {
- $res .= "\tNDR_CHECK(ndr_push_ptr(ndr, $var_prefix$e->{NAME}));\n";
+ pidl "\tNDR_CHECK(ndr_push_ptr(ndr, $var_prefix$e->{NAME}));\n";
+ } elsif (util::need_alloc($e)) {
+ # no scalar component
+ } elsif (my $switch = util::has_property($e, "switch_is")) {
+ ParseElementPushSwitch($e, $var_prefix, $ndr_flags, $switch);
+ } elsif (defined $sub_size) {
+ if (util::is_builtin_type($e->{TYPE})) {
+ pidl "\tNDR_CHECK(ndr_push_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_push_fn_t) ndr_push_$e->{TYPE}));\n";
+ } else {
+ 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";
+ }
} elsif (util::is_builtin_type($e->{TYPE})) {
- $res .= "\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
+ pidl "\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
} else {
- $res .= "\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
+ pidl "\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
}
+
+ end_flags($e);
}
#####################################################################
my($var_prefix) = shift;
my $cprefix = util::c_push_prefix($e);
- if (util::has_property($e, "struct_len")) {
+ if (util::has_property($e, "noprint")) {
return;
}
- if (defined $e->{VALUE}) {
- $res .= "\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $e->{VALUE});\n";
+ if (my $value = util::has_property($e, "value")) {
+ pidl "\tif (ndr->flags & LIBNDR_PRINT_SET_VALUES) {\n";
+ pidl "\t\t$cprefix$var_prefix$e->{NAME} = $value;\n";
+ pidl "\t}\n";
+ }
+
+ if (util::is_fixed_array($e)) {
+ ParseElementPrintBuffer($e, $var_prefix);
} elsif (util::has_direct_buffers($e)) {
- $res .= "\tndr_print_ptr(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME});\n";
- $res .= "\tndr->depth++;\n";
- ParseElementPrintBuffer($e, "r->");
- $res .= "\tndr->depth--;\n";
+ pidl "\tndr_print_ptr(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME});\n";
+ pidl "\tndr->depth++;\n";
+ ParseElementPrintBuffer($e, $var_prefix);
+ pidl "\tndr->depth--;\n";
+ } elsif (my $switch = util::has_property($e, "switch_is")) {
+ ParseElementPrintSwitch($e, $var_prefix, $switch);
} else {
- $res .= "\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME});\n";
+ pidl "\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME});\n";
}
}
my($var_prefix) = shift;
my($ndr_flags) = shift;
my $switch = shift;
- my $switch_var = find_size_var($e, $switch);
+ my $switch_var = find_size_var($e, $switch, $var_prefix);
my $cprefix = util::c_pull_prefix($e);
- $res .= "\t{ uint16 _level;\n";
- $res .= "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, &_level, $cprefix$var_prefix$e->{NAME}));\n";
- $res .= "\tif (_level != $switch_var) return NT_STATUS_INVALID_LEVEL;\n";
- $res .= "\t}\n";
+ my $utype = $structs{$e->{TYPE}};
+ if (!defined $utype ||
+ !util::has_property($utype->{DATA}, "nodiscriminant")) {
+ my $e2 = find_sibling($e, $switch);
+ pidl "\tif (($ndr_flags) & NDR_SCALARS) {\n";
+ pidl "\t\t $e2->{TYPE} _level;\n";
+ pidl "\t\tNDR_CHECK(ndr_pull_$e2->{TYPE}(ndr, &_level));\n";
+ if ($switch_var =~ /r->in/) {
+ pidl "\t\tif (!(ndr->flags & LIBNDR_FLAG_REF_ALLOC) && _level != $switch_var) {\n";
+ } else {
+ pidl "\t\tif (_level != $switch_var) {\n";
+ }
+ pidl "\t\t\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u in $e->{NAME}\", _level);\n";
+ pidl "\t\t}\n";
+ if ($switch_var =~ /r->/) {
+ pidl "else { $switch_var = _level; }\n";
+ }
+ pidl "\t}\n";
+ }
+
+ my $sub_size = util::has_property($e, "subcontext");
+ if (defined $sub_size) {
+ 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";
+ } else {
+ pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $switch_var, $cprefix$var_prefix$e->{NAME}));\n";
+ }
+
+
+}
+
+#####################################################################
+# push switch element
+sub ParseElementPushSwitch($$$$)
+{
+ my($e) = shift;
+ my($var_prefix) = shift;
+ my($ndr_flags) = shift;
+ my $switch = shift;
+ my $switch_var = find_size_var($e, $switch, $var_prefix);
+ my $cprefix = util::c_push_prefix($e);
+
+ my $utype = $structs{$e->{TYPE}};
+ if (!defined $utype ||
+ !util::has_property($utype->{DATA}, "nodiscriminant")) {
+ my $e2 = find_sibling($e, $switch);
+ pidl "\tif (($ndr_flags) & NDR_SCALARS) {\n";
+ pidl "\t\tNDR_CHECK(ndr_push_$e2->{TYPE}(ndr, $switch_var));\n";
+ pidl "\t}\n";
+ }
+
+ my $sub_size = util::has_property($e, "subcontext");
+ if (defined $sub_size) {
+ 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";
+ } else {
+ pidl "\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $switch_var, $cprefix$var_prefix$e->{NAME}));\n";
+ }
+}
+
+#####################################################################
+# print scalars in a structure element
+sub ParseElementPrintSwitch($$$)
+{
+ my($e) = shift;
+ my($var_prefix) = shift;
+ my $switch = shift;
+ my $switch_var = find_size_var($e, $switch, $var_prefix);
+ my $cprefix = util::c_push_prefix($e);
+
+ pidl "\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $switch_var, $cprefix$var_prefix$e->{NAME});\n";
}
my($var_prefix) = shift;
my($ndr_flags) = shift;
my $cprefix = util::c_pull_prefix($e);
+ my $sub_size = util::has_property($e, "subcontext");
- if (defined $e->{VALUE}) {
- $res .= "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $e->{VALUE}));\n";
+ start_flags($e);
+
+ if (util::has_property($e, "relative")) {
+ 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";
+ } elsif (util::is_inline_array($e)) {
+ ParseArrayPull($e, "r->", "NDR_SCALARS");
} elsif (util::need_wire_pointer($e)) {
- $res .= "\tNDR_CHECK(ndr_pull_uint32(ndr, &_ptr_$e->{NAME}));\n";
- $res .= "\tif (_ptr_$e->{NAME}) {\n";
- $res .= "\t\tNDR_ALLOC(ndr, $var_prefix$e->{NAME});\n";
- $res .= "\t} else {\n";
- $res .= "\t\t$var_prefix$e->{NAME} = NULL;\n";
- $res .= "\t}\n";
+ pidl "\tNDR_CHECK(ndr_pull_ptr(ndr, &_ptr_$e->{NAME}));\n";
+ pidl "\tif (_ptr_$e->{NAME}) {\n";
+ pidl "\t\tNDR_ALLOC(ndr, $var_prefix$e->{NAME});\n";
+ pidl "\t} else {\n";
+ pidl "\t\t$var_prefix$e->{NAME} = NULL;\n";
+ pidl "\t}\n";
} elsif (util::need_alloc($e)) {
# no scalar component
} elsif (my $switch = util::has_property($e, "switch_is")) {
ParseElementPullSwitch($e, $var_prefix, $ndr_flags, $switch);
+ } elsif (defined $sub_size) {
+ if (util::is_builtin_type($e->{TYPE})) {
+ pidl "\tNDR_CHECK(ndr_pull_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_fn_t) ndr_pull_$e->{TYPE}));\n";
+ } else {
+ 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";
+ }
} elsif (util::is_builtin_type($e->{TYPE})) {
- $res .= "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
+ pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
} else {
- $res .= "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
+ pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
}
+
+ end_flags($e);
}
#####################################################################
# parse buffers in a structure element
-sub ParseElementPushBuffer($$)
+sub ParseElementPushBuffer($$$)
{
my($e) = shift;
my($var_prefix) = shift;
+ my($ndr_flags) = shift;
my $cprefix = util::c_push_prefix($e);
+ my $sub_size = util::has_property($e, "subcontext");
if (util::is_pure_scalar($e)) {
return;
}
+ start_flags($e);
+
if (util::need_wire_pointer($e)) {
- $res .= "\tif ($var_prefix$e->{NAME}) {\n";
+ pidl "\tif ($var_prefix$e->{NAME}) {\n";
}
- if (util::array_size($e)) {
- ParseArrayPush($e, "r->");
+ if (util::has_property($e, "relative")) {
+ pidl "\tNDR_CHECK(ndr_push_relative(ndr, NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}, (ndr_push_const_fn_t) ndr_push_$e->{TYPE}));\n";
+ } elsif (util::is_inline_array($e)) {
+ ParseArrayPush($e, "r->", "NDR_BUFFERS");
+ } elsif (util::array_size($e)) {
+ ParseArrayPush($e, "r->", "NDR_SCALARS|NDR_BUFFERS");
+ } elsif (my $switch = util::has_property($e, "switch_is")) {
+ if ($e->{POINTERS}) {
+ ParseElementPushSwitch($e, $var_prefix, "NDR_BUFFERS|NDR_SCALARS", $switch);
+ } else {
+ ParseElementPushSwitch($e, $var_prefix, "NDR_BUFFERS", $switch);
+ }
+ } elsif (defined $sub_size) {
+ if ($e->{POINTERS}) {
+ if (util::is_builtin_type($e->{TYPE})) {
+ pidl "\tNDR_CHECK(ndr_push_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_push_fn_t) ndr_push_$e->{TYPE}));\n";
+ } else {
+ 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";
+ }
+ }
} elsif (util::is_builtin_type($e->{TYPE})) {
- $res .= "\t\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
+ pidl "\t\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
+ } elsif ($e->{POINTERS}) {
+ pidl "\t\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, NDR_SCALARS|NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}));\n";
} else {
- $res .= "\t\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
+ pidl "\t\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
}
if (util::need_wire_pointer($e)) {
- $res .= "\t}\n";
+ pidl "\t}\n";
}
+
+ end_flags($e);
}
#####################################################################
my($var_prefix) = shift;
my $cprefix = util::c_push_prefix($e);
- if (util::is_pure_scalar($e)) {
- return;
- }
-
if (util::need_wire_pointer($e)) {
- $res .= "\tif ($var_prefix$e->{NAME}) {\n";
+ pidl "\tif ($var_prefix$e->{NAME}) {\n";
}
if (util::array_size($e)) {
- ParseArrayPrint($e, "r->");
+ ParseArrayPrint($e, $var_prefix);
+ } elsif (my $switch = util::has_property($e, "switch_is")) {
+ ParseElementPrintSwitch($e, $var_prefix, $switch);
} else {
- $res .= "\t\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME});\n";
+ pidl "\t\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME});\n";
}
if (util::need_wire_pointer($e)) {
- $res .= "\t}\n";
+ pidl "\t}\n";
}
}
my($var_prefix) = shift;
my($ndr_flags) = shift;
my $cprefix = util::c_pull_prefix($e);
+ my $sub_size = util::has_property($e, "subcontext");
if (util::is_pure_scalar($e)) {
return;
}
+ if (util::has_property($e, "relative")) {
+ return;
+ }
+
+ start_flags($e);
+
if (util::need_wire_pointer($e)) {
- $res .= "\tif ($var_prefix$e->{NAME}) {\n";
+ pidl "\tif ($var_prefix$e->{NAME}) {\n";
}
- if (util::array_size($e)) {
- ParseArrayPull($e, "r->");
+ if (util::is_inline_array($e)) {
+ ParseArrayPull($e, "r->", "NDR_BUFFERS");
+ } elsif (util::array_size($e)) {
+ ParseArrayPull($e, "r->", "NDR_SCALARS|NDR_BUFFERS");
} elsif (my $switch = util::has_property($e, "switch_is")) {
- ParseElementPullSwitch($e, $var_prefix, $ndr_flags, $switch);
+ if ($e->{POINTERS}) {
+ ParseElementPullSwitch($e, $var_prefix, "NDR_SCALARS|NDR_BUFFERS", $switch);
+ } else {
+ ParseElementPullSwitch($e, $var_prefix, "NDR_BUFFERS", $switch);
+ }
+ } elsif (defined $sub_size) {
+ if ($e->{POINTERS}) {
+ if (util::is_builtin_type($e->{TYPE})) {
+ pidl "\tNDR_CHECK(ndr_pull_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_fn_t) ndr_pull_$e->{TYPE}));\n";
+ } else {
+ 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";
+ }
+ }
} elsif (util::is_builtin_type($e->{TYPE})) {
- $res .= "\t\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
+ pidl "\t\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
} elsif ($e->{POINTERS}) {
- $res .= "\t\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, NDR_SCALARS|NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}));\n";
+ pidl "\t\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, NDR_SCALARS|NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}));\n";
} else {
- $res .= "\t\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
+ pidl "\t\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
}
if (util::need_wire_pointer($e)) {
- $res .= "\t}\n";
+ pidl "\t}\n";
}
+
+ end_flags($e);
}
#####################################################################
sub ParseStructPush($)
{
my($struct) = shift;
- my($struct_len);
-
+ my $conform_e;
+
if (! defined $struct->{ELEMENTS}) {
return;
}
- # see if we have a structure length
- foreach my $e (@{$struct->{ELEMENTS}}) {
- $e->{PARENT} = $struct;
- if (util::has_property($e, "struct_len")) {
- $struct_len = $e;
- $e->{VALUE} = "0";
- }
- }
-
- if (defined $struct_len) {
- $res .= "\tstruct ndr_push_save _save1, _save2, _save3;\n";
- $res .= "\tndr_push_save(ndr, &_save1);\n";
+ start_flags($struct);
+
+ # see if the structure contains a conformant array. If it
+ # does, then it must be the last element of the structure, and
+ # we need to push the conformant length early, as it fits on
+ # the wire before the structure (and even before the structure
+ # alignment)
+ my $e = $struct->{ELEMENTS}[-1];
+ if (defined $e->{ARRAY_LEN} && $e->{ARRAY_LEN} eq "*") {
+ my $size = find_size_var($e, util::array_size($e), "r->");
+ $e->{CONFORMANT_SIZE} = $size;
+ $conform_e = $e;
+ pidl "\tNDR_CHECK(ndr_push_uint32(ndr, $size));\n";
}
- my $align = struct_alignment($struct);
- $res .= "\tNDR_CHECK(ndr_push_align(ndr, $align));\n";
+ pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
+
+ pidl "\tNDR_CHECK(ndr_push_struct_start(ndr));\n";
- $res .= "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
+ my $align = struct_alignment($struct);
+ pidl "\tNDR_CHECK(ndr_push_align(ndr, $align));\n";
foreach my $e (@{$struct->{ELEMENTS}}) {
- if (defined($struct_len) && $e == $struct_len) {
- $res .= "\tNDR_CHECK(ndr_push_align(ndr, sizeof($e->{TYPE})));\n";
- $res .= "\tndr_push_save(ndr, &_save2);\n";
- }
ParseElementPushScalar($e, "r->", "NDR_SCALARS");
}
- $res .= "buffers:\n";
- $res .= "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
+ pidl "buffers:\n";
+ pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
foreach my $e (@{$struct->{ELEMENTS}}) {
- ParseElementPushBuffer($e, "r->");
+ ParseElementPushBuffer($e, "r->", "NDR_BUFFERS");
}
- if (defined $struct_len) {
- $res .= "\tndr_push_save(ndr, &_save3);\n";
- $res .= "\tndr_push_restore(ndr, &_save2);\n";
- $struct_len->{VALUE} = "_save3.offset - _save1.offset";
- ParseElementPushScalar($struct_len, "r->", "NDR_SCALARS");
- $res .= "\tndr_push_restore(ndr, &_save3);\n";
- }
+ pidl "\tndr_push_struct_end(ndr);\n";
- $res .= "done:\n";
+ pidl "done:\n";
+
+ end_flags($struct);
}
#####################################################################
return;
}
- $res .= "\tndr->depth++;\n";
+ start_flags($struct);
+
+ pidl "\tndr->depth++;\n";
foreach my $e (@{$struct->{ELEMENTS}}) {
ParseElementPrintScalar($e, "r->");
}
- $res .= "\tndr->depth--;\n";
+ pidl "\tndr->depth--;\n";
+
+ end_flags($struct);
}
#####################################################################
sub ParseStructPull($)
{
my($struct) = shift;
- my($struct_len);
+ my $conform_e;
if (! defined $struct->{ELEMENTS}) {
return;
}
+ # see if the structure contains a conformant array. If it
+ # does, then it must be the last element of the structure, and
+ # we need to pull the conformant length early, as it fits on
+ # the wire before the structure (and even before the structure
+ # alignment)
+ my $e = $struct->{ELEMENTS}[-1];
+ if (defined $e->{ARRAY_LEN} && $e->{ARRAY_LEN} eq "*") {
+ $conform_e = $e;
+ pidl "\tuint32_t _conformant_size;\n";
+ $conform_e->{CONFORMANT_SIZE} = "_conformant_size";
+ }
+
# declare any internal pointers we need
foreach my $e (@{$struct->{ELEMENTS}}) {
- $e->{PARENT} = $struct;
- if (util::need_wire_pointer($e)) {
- $res .= "\tuint32 _ptr_$e->{NAME};\n";
+ if (util::need_wire_pointer($e) &&
+ !util::has_property($e, "relative")) {
+ pidl "\tuint32_t _ptr_$e->{NAME};\n";
}
}
+ start_flags($struct);
- # see if we have a structure length. If we do then we need to advance
- # the ndr_pull offset to that length past the front of the structure
- # when we have finished with the structure
- # we also need to make sure that we limit the size of our parsing
- # of this structure to the given size
- foreach my $e (@{$struct->{ELEMENTS}}) {
- if (util::has_property($e, "struct_len")) {
- $struct_len = $e;
- $e->{VALUE} = "&_size";
- }
- }
+ pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
- if (defined $struct_len) {
- $res .= "\tuint32 _size;\n";
- $res .= "\tstruct ndr_pull_save _save;\n";
- $res .= "\tndr_pull_save(ndr, &_save);\n";
+ pidl "\tNDR_CHECK(ndr_pull_struct_start(ndr));\n";
+
+ if (defined $conform_e) {
+ pidl "\tNDR_CHECK(ndr_pull_uint32(ndr, &$conform_e->{CONFORMANT_SIZE}));\n";
}
my $align = struct_alignment($struct);
- $res .= "\tNDR_CHECK(ndr_pull_align(ndr, $align));\n";
+ pidl "\tNDR_CHECK(ndr_pull_align(ndr, $align));\n";
- $res .= "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
foreach my $e (@{$struct->{ELEMENTS}}) {
ParseElementPullScalar($e, "r->", "NDR_SCALARS");
- if (defined($struct_len) && $e == $struct_len) {
- $res .= "\tNDR_CHECK(ndr_pull_limit_size(ndr, _size, 4));\n";
- }
}
- $res .= "buffers:\n";
- $res .= "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
+ pidl "buffers:\n";
+ pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
foreach my $e (@{$struct->{ELEMENTS}}) {
- ParseElementPullBuffer($e, "r->", "ndr_flags");
+ ParseElementPullBuffer($e, "r->", "NDR_BUFFERS");
}
- if (defined $struct_len) {
- $res .= "\tndr_pull_restore(ndr, &_save);\n";
- $res .= "\tNDR_CHECK(ndr_pull_advance(ndr, _size));\n";
- }
+ pidl "\tndr_pull_struct_end(ndr);\n";
- $res .= "done:\n";
+ pidl "done:\n";
+
+ end_flags($struct);
}
sub ParseUnionPush($)
{
my $e = shift;
- print "WARNING! union push not done\n";
+ my $have_default = 0;
+
+ start_flags($e);
+
+ pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
+
+ pidl "\tNDR_CHECK(ndr_push_struct_start(ndr));\n";
+
+# my $align = union_alignment($e);
+# pidl "\tNDR_CHECK(ndr_push_align(ndr, $align));\n";
+
+ pidl "\tswitch (level) {\n";
+ foreach my $el (@{$e->{DATA}}) {
+ if ($el->{CASE} eq "default") {
+ pidl "\tdefault:\n";
+ $have_default = 1;
+ } else {
+ pidl "\tcase $el->{CASE}:\n";
+ }
+ if ($el->{TYPE} eq "UNION_ELEMENT") {
+ ParseElementPushScalar($el->{DATA}, "r->", "NDR_SCALARS");
+ }
+ pidl "\tbreak;\n\n";
+ }
+ if (! $have_default) {
+ pidl "\tdefault:\n";
+ pidl "\t\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
+ }
+ pidl "\t}\n";
+ pidl "buffers:\n";
+ pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
+ pidl "\tswitch (level) {\n";
+ foreach my $el (@{$e->{DATA}}) {
+ if ($el->{CASE} eq "default") {
+ pidl "\tdefault:\n";
+ } else {
+ pidl "\tcase $el->{CASE}:\n";
+ }
+ if ($el->{TYPE} eq "UNION_ELEMENT") {
+ ParseElementPushBuffer($el->{DATA}, "r->", "NDR_BUFFERS");
+ }
+ pidl "\tbreak;\n\n";
+ }
+ if (! $have_default) {
+ pidl "\tdefault:\n";
+ pidl "\t\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
+ }
+ pidl "\t}\n";
+ pidl "\tndr_push_struct_end(ndr);\n";
+ pidl "done:\n";
+ end_flags($e);
}
#####################################################################
sub ParseUnionPrint($)
{
my $e = shift;
+ my $have_default = 0;
- $res .= "\tswitch (level) {\n";
+ start_flags($e);
+
+ pidl "\tswitch (level) {\n";
foreach my $el (@{$e->{DATA}}) {
- $res .= "\tcase $el->{CASE}:\n";
- ParseElementPrintScalar($el->{DATA}, "r->");
- $res .= "\tbreak;\n\n";
+ if ($el->{CASE} eq "default") {
+ $have_default = 1;
+ pidl "\tdefault:\n";
+ } else {
+ pidl "\tcase $el->{CASE}:\n";
+ }
+ if ($el->{TYPE} eq "UNION_ELEMENT") {
+ ParseElementPrintScalar($el->{DATA}, "r->");
+ }
+ pidl "\tbreak;\n\n";
}
- $res .= "\tdefault:\n\t\tndr_print_bad_level(ndr, name, level);\n";
- $res .= "\t}\n";
+ if (! $have_default) {
+ pidl "\tdefault:\n\t\tndr_print_bad_level(ndr, name, level);\n";
+ }
+ pidl "\t}\n";
+
+ end_flags($e);
}
#####################################################################
sub ParseUnionPull($)
{
my $e = shift;
+ my $have_default = 0;
+
+ start_flags($e);
+
+ pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
+
+ pidl "\tNDR_CHECK(ndr_pull_struct_start(ndr));\n";
+
+# my $align = union_alignment($e);
+# pidl "\tNDR_CHECK(ndr_pull_align(ndr, $align));\n";
- $res .= "\tNDR_CHECK(ndr_pull_uint16(ndr, level));\n";
- $res .= "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
- $res .= "\tswitch (*level) {\n";
+ pidl "\tswitch (level) {\n";
foreach my $el (@{$e->{DATA}}) {
- $res .= "\tcase $el->{CASE}:\n";
- ParseElementPullScalar($el->{DATA}, "r->", "NDR_SCALARS");
- $res .= "\tbreak;\n\n";
- }
- $res .= "\tdefault:\n\t\treturn NT_STATUS_INVALID_LEVEL;\n";
- $res .= "\t}\n";
- $res .= "buffers:\n";
- $res .= "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
- $res .= "\tswitch (*level) {\n";
+ if ($el->{CASE} eq "default") {
+ pidl "\tdefault: {\n";
+ $have_default = 1;
+ } else {
+ pidl "\tcase $el->{CASE}: {\n";
+ }
+ if ($el->{TYPE} eq "UNION_ELEMENT") {
+ my $e2 = $el->{DATA};
+ if ($e2->{POINTERS}) {
+ pidl "\t\tuint32_t _ptr_$e2->{NAME};\n";
+ }
+ ParseElementPullScalar($el->{DATA}, "r->", "NDR_SCALARS");
+ }
+ pidl "\tbreak; }\n\n";
+ }
+ if (! $have_default) {
+ pidl "\tdefault:\n";
+ pidl "\t\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
+ }
+ pidl "\t}\n";
+ pidl "buffers:\n";
+ pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
+ pidl "\tswitch (level) {\n";
foreach my $el (@{$e->{DATA}}) {
- $res .= "\tcase $el->{CASE}:\n";
- ParseElementPullBuffer($el->{DATA}, "r->", "NDR_BUFFERS");
- $res .= "\tbreak;\n\n";
+ if ($el->{CASE} eq "default") {
+ pidl "\tdefault:\n";
+ } else {
+ pidl "\tcase $el->{CASE}:\n";
+ }
+ if ($el->{TYPE} eq "UNION_ELEMENT") {
+ ParseElementPullBuffer($el->{DATA}, "r->", "NDR_BUFFERS");
+ }
+ pidl "\tbreak;\n\n";
+ }
+ if (! $have_default) {
+ pidl "\tdefault:\n";
+ pidl "\t\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
}
- $res .= "\tdefault:\n\t\treturn NT_STATUS_INVALID_LEVEL;\n";
- $res .= "\t}\n";
- $res .= "done:\n";
+ pidl "\t}\n";
+ pidl "\tndr_pull_struct_end(ndr);\n";
+ pidl "done:\n";
+ end_flags($e);
}
#####################################################################
sub ParseTypedefPush($)
{
my($e) = shift;
+ my $static = fn_prefix($e);
if (! $needed{"push_$e->{NAME}"}) {
# print "push_$e->{NAME} not needed\n";
}
if ($e->{DATA}->{TYPE} eq "STRUCT") {
- $res .= "static NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, struct $e->{NAME} *r)";
- $res .= "\n{\n";
+ pidl $static . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, struct $e->{NAME} *r)";
+ pidl "\n{\n";
ParseTypePush($e->{DATA});
- $res .= "\treturn NT_STATUS_OK;\n";
- $res .= "}\n\n";
+ pidl "\treturn NT_STATUS_OK;\n";
+ pidl "}\n\n";
}
if ($e->{DATA}->{TYPE} eq "UNION") {
- $res .= "static NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, uint16 level, union $e->{NAME} *r)";
- $res .= "\n{\n";
+ pidl $static . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, uint16_t level, union $e->{NAME} *r)";
+ pidl "\n{\n";
ParseTypePush($e->{DATA});
- $res .= "\treturn NT_STATUS_OK;\n";
- $res .= "}\n\n";
+ pidl "\treturn NT_STATUS_OK;\n";
+ pidl "}\n\n";
}
}
sub ParseTypedefPull($)
{
my($e) = shift;
+ my $static = fn_prefix($e);
if (! $needed{"pull_$e->{NAME}"}) {
# print "pull_$e->{NAME} not needed\n";
}
if ($e->{DATA}->{TYPE} eq "STRUCT") {
- $res .= "static NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, struct $e->{NAME} *r)";
- $res .= "\n{\n";
+ pidl $static . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, struct $e->{NAME} *r)";
+ pidl "\n{\n";
ParseTypePull($e->{DATA});
- $res .= "\treturn NT_STATUS_OK;\n";
- $res .= "}\n\n";
+ pidl "\treturn NT_STATUS_OK;\n";
+ pidl "}\n\n";
}
if ($e->{DATA}->{TYPE} eq "UNION") {
- $res .= "static NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, uint16 *level, union $e->{NAME} *r)";
- $res .= "\n{\n";
+ pidl $static . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, uint16_t level, union $e->{NAME} *r)";
+ pidl "\n{\n";
ParseTypePull($e->{DATA});
- $res .= "\treturn NT_STATUS_OK;\n";
- $res .= "}\n\n";
+ pidl "\treturn NT_STATUS_OK;\n";
+ pidl "}\n\n";
}
}
#####################################################################
-# parse a typedef - push side
+# parse a typedef - print side
sub ParseTypedefPrint($)
{
my($e) = shift;
if ($e->{DATA}->{TYPE} eq "STRUCT") {
- $res .= "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, struct $e->{NAME} *r)";
- $res .= "\n{\n";
- $res .= "\tndr_print_struct(ndr, name, \"$e->{NAME}\");\n";
+ pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, struct $e->{NAME} *r)";
+ pidl "\n{\n";
+ pidl "\tndr_print_struct(ndr, name, \"$e->{NAME}\");\n";
ParseTypePrint($e->{DATA});
- $res .= "}\n\n";
+ pidl "}\n\n";
}
if ($e->{DATA}->{TYPE} eq "UNION") {
- $res .= "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, uint16 level, union $e->{NAME} *r)";
- $res .= "\n{\n";
- $res .= "\tndr_print_union(ndr, name, level, \"$e->{NAME}\");\n";
+ pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, uint16_t level, union $e->{NAME} *r)";
+ pidl "\n{\n";
+ pidl "\tndr_print_union(ndr, name, level, \"$e->{NAME}\");\n";
ParseTypePrint($e->{DATA});
- $res .= "}\n\n";
+ pidl "}\n\n";
+ }
+}
+
+#####################################################################
+# parse a function - print side
+sub ParseFunctionPrint($)
+{
+ my($fn) = shift;
+
+ pidl "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, struct $fn->{NAME} *r)";
+ pidl "\n{\n";
+ pidl "\tndr_print_struct(ndr, name, \"$fn->{NAME}\");\n";
+ pidl "\tndr->depth++;\n";
+
+ pidl "\tif (flags & NDR_SET_VALUES) {\n";
+ pidl "\t\tndr->flags |= LIBNDR_PRINT_SET_VALUES;\n";
+ pidl "\t}\n";
+
+ pidl "\tif (flags & NDR_IN) {\n";
+ pidl "\t\tndr_print_struct(ndr, \"in\", \"$fn->{NAME}\");\n";
+ pidl "\tndr->depth++;\n";
+ foreach my $e (@{$fn->{DATA}}) {
+ if (util::has_property($e, "in")) {
+ ParseElementPrintScalar($e, "r->in.");
+ }
+ }
+ pidl "\tndr->depth--;\n";
+ pidl "\t}\n";
+
+ pidl "\tif (flags & NDR_OUT) {\n";
+ pidl "\t\tndr_print_struct(ndr, \"out\", \"$fn->{NAME}\");\n";
+ pidl "\tndr->depth++;\n";
+ foreach my $e (@{$fn->{DATA}}) {
+ if (util::has_property($e, "out")) {
+ ParseElementPrintScalar($e, "r->out.");
+ }
}
+ if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
+ if (util::is_scalar_type($fn->{RETURN_TYPE})) {
+ pidl "\tndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", r->out.result);\n";
+ } else {
+ pidl "\tndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", &r->out.result);\n";
+ }
+ }
+ pidl "\tndr->depth--;\n";
+ pidl "\t}\n";
+
+ pidl "\tndr->depth--;\n";
+ pidl "}\n\n";
}
+#####################################################################
+# parse a function element
+sub ParseFunctionElementPush($$)
+{
+ my $e = shift;
+ my $inout = shift;
+
+ if (util::array_size($e)) {
+ if (util::need_wire_pointer($e)) {
+ pidl "\tNDR_CHECK(ndr_push_ptr(ndr, r->$inout.$e->{NAME}));\n";
+ pidl "\tif (r->$inout.$e->{NAME}) {\n";
+ ParseArrayPush($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
+ pidl "\t}\n";
+ } else {
+ ParseArrayPush($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
+ }
+ } else {
+ ParseElementPushScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
+ if ($e->{POINTERS}) {
+ ParseElementPushBuffer($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
+ }
+ }
+}
+
#####################################################################
# parse a function
sub ParseFunctionPush($)
{
- my($function) = shift;
+ my($fn) = shift;
+ my $static = fn_prefix($fn);
- # Input function
- $res .= "NTSTATUS ndr_push_$function->{NAME}(struct ndr_push *ndr, struct $function->{NAME} *r)\n{\n";
+ pidl $static . "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, struct $fn->{NAME} *r)\n{\n";
- foreach my $e (@{$function->{DATA}}) {
+ pidl "\n\tif (!(flags & NDR_IN)) goto ndr_out;\n\n";
+ foreach my $e (@{$fn->{DATA}}) {
if (util::has_property($e, "in")) {
- $e->{PARENT} = $function;
- if (util::array_size($e)) {
- $res .= "\tif (r->in.$e->{NAME}) {\n";
- if (!util::is_scalar_type($e->{TYPE})) {
- $res .= "\t\tint ndr_flags = NDR_SCALARS|NDR_BUFFERS;\n";
- }
- ParseArrayPush($e, "r->in.");
- $res .= "\t}\n";
- } else {
- ParseElementPushScalar($e, "r->in.", "NDR_SCALARS|NDR_BUFFERS");
- ParseElementPushBuffer($e, "r->in.");
- }
- }
+ ParseFunctionElementPush($e, "in");
+ }
+ }
+
+ pidl "\nndr_out:\n";
+ pidl "\tif (!(flags & NDR_OUT)) goto done;\n\n";
+ foreach my $e (@{$fn->{DATA}}) {
+ if (util::has_property($e, "out")) {
+ ParseFunctionElementPush($e, "out");
+ }
+ }
+
+ if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
+ pidl "\tNDR_CHECK(ndr_push_$fn->{RETURN_TYPE}(ndr, r->out.result));\n";
}
- $res .= "\n\treturn NT_STATUS_OK;\n}\n\n";
+ pidl "\ndone:\n";
+ pidl "\n\treturn NT_STATUS_OK;\n}\n\n";
+}
+
+#####################################################################
+# parse a function element
+sub ParseFunctionElementPull($$)
+{
+ my $e = shift;
+ my $inout = shift;
+
+ if (util::array_size($e)) {
+ if (util::need_wire_pointer($e)) {
+ pidl "\tNDR_CHECK(ndr_pull_ptr(ndr, &_ptr_$e->{NAME}));\n";
+ pidl "\tif (_ptr_$e->{NAME}) {\n";
+ } elsif ($inout eq "out" && util::has_property($e, "ref")) {
+ pidl "\tif (r->$inout.$e->{NAME}) {\n";
+ } else {
+ pidl "\t{\n";
+ }
+ ParseArrayPull($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
+ pidl "\t}\n";
+ } else {
+ if ($inout eq "out" && util::has_property($e, "ref")) {
+ pidl "\tif (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {\n";
+ pidl "\tNDR_ALLOC(ndr, r->out.$e->{NAME});\n";
+ pidl "\t}\n";
+ }
+ if ($inout eq "in" && util::has_property($e, "ref")) {
+ pidl "\tNDR_ALLOC(ndr, r->in.$e->{NAME});\n";
+ }
+
+ ParseElementPullScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
+ if ($e->{POINTERS}) {
+ ParseElementPullBuffer($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
+ }
+ }
+}
+
+
+############################################################
+# allocate ref variables
+sub AllocateRefVars($)
+{
+ my $e = shift;
+ my $asize = util::array_size($e);
+
+ # note that if the variable is also an "in"
+ # variable then we copy the initial value from
+ # the in side
+
+ if (!defined $asize) {
+ # its a simple variable
+ pidl "\tNDR_ALLOC(ndr, r->out.$e->{NAME});\n";
+ if (util::has_property($e, "in")) {
+ pidl "\t*r->out.$e->{NAME} = *r->in.$e->{NAME};\n";
+ } else {
+ pidl "\tZERO_STRUCTP(r->out.$e->{NAME});\n";
+ }
+ return;
+ }
+
+ # its an array
+ my $size = find_size_var($e, $asize, "r->out.");
+ pidl "\tNDR_ALLOC_N(ndr, r->out.$e->{NAME}, MAX(1, $size));\n";
+ if (util::has_property($e, "in")) {
+ pidl "\tmemcpy(r->out.$e->{NAME},r->in.$e->{NAME},$size * sizeof(*r->in.$e->{NAME}));\n";
+ } else {
+ pidl "\tmemset(r->out.$e->{NAME}, 0, $size * sizeof(*r->out.$e->{NAME}));\n";
+ }
}
+
#####################################################################
# parse a function
sub ParseFunctionPull($)
{
my($fn) = shift;
+ my $static = fn_prefix($fn);
# pull function args
- $res .= "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, struct $fn->{NAME} *r)\n{\n";
+ pidl $static . "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)\n{\n";
# declare any internal pointers we need
+ foreach my $e (@{$fn->{DATA}}) {
+ if (util::need_wire_pointer($e)) {
+ pidl "\tuint32_t _ptr_$e->{NAME};\n";
+ }
+ }
+
+ pidl "\n\tif (!(flags & NDR_IN)) goto ndr_out;\n\n";
+
+ # auto-init the out section of a structure. I originally argued that
+ # this was a bad idea as it hides bugs, but coping correctly
+ # with initialisation and not wiping ref vars is turning
+ # out to be too tricky (tridge)
foreach my $e (@{$fn->{DATA}}) {
if (util::has_property($e, "out")) {
- if (util::need_wire_pointer($e)) {
- $res .= "\tuint32 _ptr_$e->{NAME};\n";
- }
+ pidl "\tZERO_STRUCT(r->out);\n\n";
+ last;
+ }
+ }
+
+ foreach my $e (@{$fn->{DATA}}) {
+ if (util::has_property($e, "in")) {
+ ParseFunctionElementPull($e, "in");
+ }
+ # we need to allocate any reference output variables, so that
+ # a dcerpc backend can be sure they are non-null
+ if (util::has_property($e, "out") && util::has_property($e, "ref")) {
+ AllocateRefVars($e);
}
}
+ pidl "\nndr_out:\n";
+ pidl "\tif (!(flags & NDR_OUT)) goto done;\n\n";
foreach my $e (@{$fn->{DATA}}) {
if (util::has_property($e, "out")) {
- $e->{PARENT} = $fn;
- if (util::array_size($e)) {
- $res .= "\tif (r->out.$e->{NAME}) {\n";
- if (!util::is_scalar_type($e->{TYPE})) {
- $res .= "\t\tint ndr_flags = NDR_SCALARS|NDR_BUFFERS;\n";
- }
- ParseArrayPull($e, "r->out.");
- $res .= "\t}\n";
- } else {
- ParseElementPullScalar($e, "r->out.", "NDR_SCALARS|NDR_BUFFERS");
- ParseElementPullBuffer($e, "r->out.", "NDR_SCALARS|NDR_BUFFERS");
- }
+ ParseFunctionElementPull($e, "out");
}
}
if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
- $res .= "\tNDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, &r->out.result));\n";
+ pidl "\tNDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, &r->out.result));\n";
}
-
- $res .= "\n\treturn NT_STATUS_OK;\n}\n\n";
+ pidl "\ndone:\n";
+ pidl "\n\treturn NT_STATUS_OK;\n}\n\n";
}
#####################################################################
-# parse a typedef
-sub ParseTypedef($)
+# produce a function call table
+sub FunctionTable($)
{
- my($e) = shift;
- ParseTypedefPush($e);
- ParseTypedefPull($e);
- ParseTypedefPrint($e);
-}
+ my($interface) = shift;
+ my($data) = $interface->{DATA};
+ my $count = 0;
+ my $uname = uc $interface->{NAME};
-#####################################################################
-# parse a function
-sub ParseFunction($)
-{
- my $i = shift;
- ParseFunctionPush($i);
- ParseFunctionPull($i);
+ foreach my $d (@{$data}) {
+ if ($d->{TYPE} eq "FUNCTION") { $count++; }
+ }
+
+ if ($count == 0) {
+ return;
+ }
+
+ pidl "static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {\n";
+ foreach my $d (@{$data}) {
+ if ($d->{TYPE} eq "FUNCTION") {
+ pidl "\t{\n";
+ pidl "\t\t\"$d->{NAME}\",\n";
+ pidl "\t\tsizeof(struct $d->{NAME}),\n";
+ pidl "\t\t(ndr_push_flags_fn_t) ndr_push_$d->{NAME},\n";
+ pidl "\t\t(ndr_pull_flags_fn_t) ndr_pull_$d->{NAME},\n";
+ pidl "\t\t(ndr_print_function_t) ndr_print_$d->{NAME}\n";
+ pidl "\t},\n";
+ }
+ }
+ pidl "\t{ NULL, 0, NULL, NULL }\n};\n\n";
+
+ my $endpoints;
+
+ if (! defined $if_endpoints) {
+ $if_endpoints = $interface->{NAME};
+ }
+
+ my @e = split / /, $if_endpoints;
+ my $endpoint_count = $#e + 1;
+
+ pidl "static const char * const $interface->{NAME}\_endpoint_strings[] = {\n\t";
+ for (my $i=0; $i < $#e; $i++) {
+ pidl "\"$e[$i]\", ";
+ }
+ pidl "\"$e[$#e]\"\n";
+ pidl "};\n\n";
+
+ pidl "static const struct dcerpc_endpoint_list $interface->{NAME}\_endpoints = {\n";
+ pidl "\t$endpoint_count, $interface->{NAME}\_endpoint_strings\n";
+ pidl "};\n\n";
+
+ pidl "\nconst struct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {\n";
+ pidl "\t\"$interface->{NAME}\",\n";
+ pidl "\tDCERPC_$uname\_UUID,\n";
+ pidl "\tDCERPC_$uname\_VERSION,\n";
+ pidl "\t$count,\n";
+ pidl "\t$interface->{NAME}\_calls,\n";
+ pidl "\t&$interface->{NAME}\_endpoints\n";
+ pidl "};\n\n";
}
+
#####################################################################
# parse the interface definitions
sub ParseInterface($)
{
my($interface) = shift;
my($data) = $interface->{DATA};
+
+ foreach my $d (@{$data}) {
+ if ($d->{TYPE} eq "TYPEDEF") {
+ $structs{$d->{NAME}} = $d;
+ }
+ }
+
+
+
+ foreach my $d (@{$data}) {
+ ($d->{TYPE} eq "TYPEDEF") &&
+ ParseTypedefPush($d);
+ ($d->{TYPE} eq "FUNCTION") &&
+ ParseFunctionPush($d);
+ }
foreach my $d (@{$data}) {
($d->{TYPE} eq "TYPEDEF") &&
- ParseTypedef($d);
+ ParseTypedefPull($d);
($d->{TYPE} eq "FUNCTION") &&
- ParseFunction($d);
+ ParseFunctionPull($d);
}
+ foreach my $d (@{$data}) {
+ if ($d->{TYPE} eq "TYPEDEF" &&
+ !util::has_property($d->{DATA}, "noprint")) {
+ ParseTypedefPrint($d);
+ }
+ if ($d->{TYPE} eq "FUNCTION" &&
+ !util::has_property($d, "noprint")) {
+ ParseFunctionPrint($d);
+ }
+ }
+
+ FunctionTable($interface);
+
}
sub NeededFunction($)
$needed{"pull_$fn->{NAME}"} = 1;
$needed{"push_$fn->{NAME}"} = 1;
foreach my $e (@{$fn->{DATA}}) {
- if (util::has_property($e, "out")) {
- $needed{"pull_$e->{TYPE}"} = 1;
- }
- if (util::has_property($e, "in")) {
- $needed{"push_$e->{TYPE}"} = 1;
- }
+ $e->{PARENT} = $fn;
+ $needed{"pull_$e->{TYPE}"} = 1;
+ $needed{"push_$e->{TYPE}"} = 1;
}
}
sub NeededTypedef($)
{
my $t = shift;
+ if (util::has_property($t->{DATA}, "public")) {
+ $needed{"pull_$t->{NAME}"} = 1;
+ $needed{"push_$t->{NAME}"} = 1;
+ }
if ($t->{DATA}->{TYPE} eq "STRUCT") {
for my $e (@{$t->{DATA}->{ELEMENTS}}) {
- if ($needed{"pull_$t->{NAME}"}) {
- $needed{"pull_$e->{TYPE}"} = 1;
- }
- if ($needed{"push_$t->{NAME}"}) {
- $needed{"push_$e->{TYPE}"} = 1;
- }
+ $e->{PARENT} = $t->{DATA};
+ if ($needed{"pull_$t->{NAME}"}) {
+ $needed{"pull_$e->{TYPE}"} = 1;
+ }
+ if ($needed{"push_$t->{NAME}"}) {
+ $needed{"push_$e->{TYPE}"} = 1;
}
}
+ }
if ($t->{DATA}->{TYPE} eq "UNION") {
for my $e (@{$t->{DATA}->{DATA}}) {
- if ($needed{"pull_$t->{NAME}"}) {
- $needed{"pull_$e->{DATA}->{TYPE}"} = 1;
- }
- if ($needed{"push_$t->{NAME}"}) {
- $needed{"push_$e->{DATA}->{TYPE}"} = 1;
+ $e->{PARENT} = $t->{DATA};
+ if ($e->{TYPE} eq "UNION_ELEMENT") {
+ if ($needed{"pull_$t->{NAME}"}) {
+ $needed{"pull_$e->{DATA}->{TYPE}"} = 1;
+ }
+ if ($needed{"push_$t->{NAME}"}) {
+ $needed{"push_$e->{DATA}->{TYPE}"} = 1;
+ }
}
}
}
}
}
+#####################################################################
+# parse the interface definitions
+sub ModuleHeader($)
+{
+ my($h) = shift;
+
+ $if_uuid = $h->{PROPERTIES}->{uuid};
+ $if_version = $h->{PROPERTIES}->{version};
+ $if_endpoints = $h->{PROPERTIES}->{endpoints};
+}
#####################################################################
# parse a parsed IDL structure back into an IDL file
-sub Parse($)
+sub Parse($$)
{
my($idl) = shift;
- $res = "/* parser auto-generated by pidl */\n\n";
- $res .= "#include \"includes.h\"\n\n";
+ my($filename) = shift;
+
+ open(OUT, ">$filename") || die "can't open $filename";
+
+ pidl "/* parser auto-generated by pidl */\n\n";
+ pidl "#include \"includes.h\"\n\n";
foreach my $x (@{$idl}) {
+ ($x->{TYPE} eq "MODULEHEADER") &&
+ ModuleHeader($x);
+
if ($x->{TYPE} eq "INTERFACE") {
BuildNeeded($x);
ParseInterface($x);
}
}
- return $res;
+
+ pidl IdlClient::Parse($idl);
+
+ close(OUT);
}
1;
git.samba.org / samba.git / blobdiff