use strict;
use needed;
+use typelist;
# list of known types
-our %typedefs;
+my %typefamily;
-sub RegisterPrimitives()
+sub get_typefamily($)
{
- my %type_alignments =
- (
+ my $n = shift;
+ return $typefamily{$n};
+}
+
+my %scalar_alignments =
+(
"char" => 1,
"int8" => 1,
"uint8" => 1,
"uint32" => 4,
"dlong" => 4,
"udlong" => 4,
+ "udlongr" => 4,
"NTTIME" => 4,
"NTTIME_1sec" => 4,
"time_t" => 4,
"DATA_BLOB" => 4,
"error_status_t" => 4,
"WERROR" => 4,
+ "NTSTATUS" => 4,
"boolean32" => 4,
"unsigned32" => 4,
"ipv4address" => 4,
"hyper" => 8,
"NTTIME_hyper" => 8
- );
-
- foreach my $k (keys %type_alignments) {
- $typedefs{$k} = {
- NAME => $k,
- TYPE => "TYPEDEF",
- DATA => {
- TYPE => "SCALAR",
- ALIGN => $type_alignments{$k}
- }
- };
+);
+
+$typefamily{SCALAR} = {
+ ALIGN => sub {
+ my $t = shift;
+ return $scalar_alignments{$t->{NAME}};
}
-}
+};
sub is_scalar_type($)
{
my $type = shift;
- if (my $dt = $typedefs{$type}->{DATA}->{TYPE}) {
+ return 0 unless typelist::hasType($type);
+
+ if (my $dt = typelist::getType($type)->{DATA}->{TYPE}) {
return 1 if ($dt eq "SCALAR" or $dt eq "ENUM" or $dt eq "BITMAP");
}
return "ptr" if (util::has_property($e, "ptr"));
return "unique" if (util::has_property($e, "unique"));
return "relative" if (util::has_property($e, "relative"));
+ return "ignore" if (util::has_property($e, "ignore"));
+
+ return undef;
+}
+
+# return 1 if this is a fixed array
+sub is_fixed_array($)
+{
+ my $e = shift;
+ my $len = $e->{"ARRAY_LEN"};
+ return 1 if (defined $len && util::is_constant($len));
+ return 0;
+}
+
+# return 1 if this is a conformant array
+sub is_conformant_array($)
+{
+ my $e = shift;
+ return 1 if (util::has_property($e, "size_is"));
+ return 0;
+}
+
+# return 1 if this is a inline array
+sub is_inline_array($)
+{
+ my $e = shift;
+ my $len = $e->{"ARRAY_LEN"};
+ if (is_fixed_array($e) ||
+ defined $len && $len ne "*") {
+ return 1;
+ }
+ return 0;
+}
+
+# return 1 if this is a varying array
+sub is_varying_array($)
+{
+ my $e = shift;
+ return util::has_property($e, "length_is");
+}
+
+# return 1 if this is a surrounding array (sometimes
+# referred to as an embedded array). Can only occur as
+# the last element in a struct and can not contain any pointers.
+sub is_surrounding_array($)
+{
+ my $e = shift;
+
+ return ($e->{POINTERS} == 0
+ and defined $e->{ARRAY_LEN}
+ and $e->{ARRAY_LEN} eq "*"
+ and $e == $e->{PARENT}->{ELEMENTS}[-1]
+ and $e->{PARENT}->{TYPE} ne "FUNCTION");
+}
+
+sub array_type($)
+{
+ my $e = shift;
+
+ return "conformant-varying" if (is_varying_array($e) and is_conformant_array($e));
+ return "conformant" if (is_varying_array($e));
+ return "varying" if (is_varying_array($e));
+ return "inline" if (is_inline_array($e));
+ return "fixed" if (is_fixed_array($e));
return undef;
}
sub need_wire_pointer($)
{
my $e = shift;
- my $pt;
-
- return 0 unless ($pt = pointer_type($e));
- if ($pt ne "ref") {
- return 1;
- } else {
- return 0;
+ my $n = $e->{POINTERS};
+ my $pt = pointer_type($e);
+
+ # Top level "ref" pointers do not have a referrent identifier
+ if ( defined($pt)
+ and $pt eq "ref"
+ and $e->{PARENT}->{TYPE} eq "FUNCTION")
+ {
+ $n--;
}
+
+ return $n;
}
-# determine if an element is a pure scalar. pure scalars do not
-# have a "buffers" section in NDR
-sub is_pure_scalar($)
+# determine if an element needs a "buffers" section in NDR
+sub need_buffers_section($)
{
my $e = shift;
- if (util::has_property($e, "ref")) {
- return 1;
- }
- if (is_scalar_type($e->{TYPE}) &&
- !$e->{POINTERS} &&
+ if ((is_scalar_type($e->{TYPE}) || util::has_property($e, "subcontext")) &&
+ $e->{POINTERS} == 0 &&
!util::array_size($e)) {
- return 1;
+ return 0;
}
- return 0;
+ return 1;
}
# see if a variable needs to be allocated by the NDR subsystem on pull
{
my $e = shift;
- if (util::has_property($e, "ref")) {
- return 0;
- }
-
- if ($e->{POINTERS} || util::array_size($e)) {
- return 1;
- }
-
+ return 0 if (util::has_property($e, "ref"));
+ return 1 if ($e->{POINTERS} || util::array_size($e));
return 0;
}
+# Prefix to get the actual value of a variable
+sub c_ptr_prefix($)
+{
+ my $e = shift;
+ my $pointers = "";
+ foreach my $i (need_wire_pointer($e)..$e->{POINTERS}-1) { $pointers.="*"; }
+ return $pointers;
+}
# determine the C prefix used to refer to a variable when passing to a push
# function. This will be '*' for pointers to scalar types, '' for scalar
{
my $e = shift;
- if ($e->{TYPE} =~ "string") {
- return "";
- }
+ my $ret = "";
- if (is_scalar_type($e->{TYPE}) &&
- $e->{POINTERS}) {
- return "*";
- }
- if (!is_scalar_type($e->{TYPE}) &&
+ if ($e->{TYPE} =~ "string") {
+ $ret = "";
+ } elsif (is_scalar_type($e->{TYPE}) and $e->{POINTERS} and
+ !util::array_size($e)) {
+ $ret .="*";
+ } elsif (!is_scalar_type($e->{TYPE}) &&
!$e->{POINTERS} &&
!util::array_size($e)) {
return "&";
}
- return "";
-}
+ foreach my $i (2..$e->{POINTERS}) { $ret.="*"; }
+
+ return $ret;
+}
# determine the C prefix used to refer to a variable when passing to a pull
# return '&' or ''
return "&";
}
- return "";
+ my $ret = "";
+ foreach my $i (2..$e->{POINTERS}) { $ret.="*"; }
+ return $ret;
}
my $res = "";
+my $tabs = "";
sub pidl($)
{
- $res .= shift;
+ my $d = shift;
+ if ($d) {
+ $res .= $tabs;
+ $res .= $d;
+ }
+ $res .="\n";
}
-###################################
-# find a sibling var in a structure
-sub find_sibling($$)
+sub indent()
{
- my($e) = shift;
- my($name) = shift;
- my($fn) = $e->{PARENT};
-
- if ($name =~ /\*(.*)/) {
- $name = $1;
- }
-
- if ($fn->{TYPE} eq "FUNCTION") {
- for my $e2 (@{$fn->{ELEMENTS}}) {
- if ($e2->{NAME} eq $name) {
- return $e2;
- }
- }
- }
+ $tabs .= "\t";
+}
- for my $e2 (@{$fn->{ELEMENTS}}) {
- if ($e2->{NAME} eq $name) {
- return $e2;
- }
- }
- die "invalid sibling '$name'";
+sub deindent()
+{
+ $tabs = substr($tabs, 0, -1);
}
####################################################################
my($fn) = $e->{PARENT};
- if (util::is_constant($size)) {
- return $size;
- }
+ return $size if (util::is_constant($size));
- if ($size =~ /ndr->|\(/) {
- return $size;
- }
+ return $size if ($size =~ /ndr->|\(/);
my $prefix = "";
return $prefix . "r->$size";
}
- my $e2 = find_sibling($e, $size);
+ my $e2 = util::find_sibling($e, $size);
+
+ die("Invalid sibling '$size'") unless defined($e2);
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";
}
my $size = shift;
if ($size =~ /^\*/) {
my $size2 = substr($size, 1);
- pidl "\tif ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;\n";
+ pidl "if ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;";
}
}
my $size = shift;
if ($size =~ /^\*/) {
my $size2 = substr($size, 1);
- pidl "\tif ($size2 == NULL) return;\n";
+ pidl "if ($size2 == NULL) return;";
}
}
-
#####################################################################
# 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, "public")) {
- return "";
- }
- }
- if ($fn->{TYPE} eq "FUNCTION") {
- if (util::has_property($fn, "public")) {
- return "";
- }
+ if ($fn->{TYPE} eq "TYPEDEF" or
+ $fn->{TYPE} eq "FUNCTION") {
+ return "" if (util::has_property($fn, "public"));
}
+
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_set_flags(&ndr->flags, $flags);\n";
+ pidl "{ uint32_t _flags_save_$e->{TYPE} = ndr->flags;";
+ pidl "ndr_set_flags(&ndr->flags, $flags);";
}
}
my $e = shift;
my $flags = util::has_property($e, "flag");
if (defined $flags) {
- pidl "\tndr->flags = _flags_save_$e->{TYPE};\n\t}\n";
+ pidl "ndr->flags = _flags_save_$e->{TYPE};\n\t}";
}
}
#####################################################################
# work out the correct alignment for a structure or union
-sub struct_alignment
+sub find_largest_alignment($)
{
my $s = shift;
{
my $e = shift;
- unless (defined($typedefs{$e}) && defined($typedefs{$e}->{DATA}->{TYPE})) {
+ unless (typelist::hasType($e)) {
# it must be an external type - all we can do is guess
# print "Warning: assuming alignment of unknown type '$e' is 4\n";
return 4;
}
- my $dt = $typedefs{$e}->{DATA};
+ my $dt = typelist::getType($e)->{DATA};
+
+ my $tmp = $typefamily{$dt->{TYPE}}->{ALIGN}->($dt);
+ return $tmp;
+}
- return $dt->{ALIGN} if ($dt->{ALIGN});
+#####################################################################
+# parse array preceding data - push side
+sub ParseArrayPushPreceding($$$)
+{
+ my $e = shift;
+ my $var_prefix = shift;
+ my $ndr_flags = shift;
- if ($dt->{TYPE} eq "STRUCT") {
- $dt->{ALIGN} = struct_alignment($dt);
- } elsif($dt->{TYPE} eq "UNION") {
- $dt->{ALIGN} = struct_alignment($dt);
- } elsif ($dt->{TYPE} eq "ENUM") {
- $dt->{ALIGN} = align_type(util::enum_type_fn($typedefs{$e}->{DATA}));
- } elsif ($dt->{TYPE} eq "BITMAP") {
- $dt->{ALIGN} = align_type(util::bitmap_type_fn($typedefs{$e}->{DATA}));
- }
+ my $size = ParseExpr($e, util::array_size($e), $var_prefix);
- if (not defined($dt->{ALIGN})) {
- die("Internal pidl error. Unable to determine alignment for data type $dt->{TYPE}!");
+ if (!is_inline_array($e)) {
+ # we need to emit the array size
+ pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $size));";
}
-
- return $dt->{ALIGN};
}
#####################################################################
-# parse an array - push side
-sub ParseArrayPush($$$)
+# parse the data of an array - push side
+sub ParseArrayPush($$$$)
{
my $e = shift;
+ my $ndr = shift;
my $var_prefix = shift;
my $ndr_flags = shift;
+ my $cprefix = c_push_prefix($e);
my $size = ParseExpr($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, NDR_SCALARS, $size));\n";
+ # See whether the array size has been pushed yet
+ if (!is_surrounding_array($e)) {
+ ParseArrayPushPreceding($e, $var_prefix, $ndr_flags);
}
-
- if (my $length = util::has_property($e, "length_is")) {
+
+ if (is_varying_array($e)) {
+ my $length = util::has_property($e, "length_is");
$length = ParseExpr($e, $length, $var_prefix);
- pidl "\t\tNDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));\n";
- pidl "\t\tNDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $length));\n";
+ pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, 0));";
+ pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, $length));";
$size = $length;
}
if (is_scalar_type($e->{TYPE})) {
- pidl "\t\tNDR_CHECK(ndr_push_array_$e->{TYPE}(ndr, $ndr_flags, $var_prefix$e->{NAME}, $size));\n";
+ pidl "NDR_CHECK(ndr_push_array_$e->{TYPE}($ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}, $size));";
} else {
- 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";
+ pidl "NDR_CHECK(ndr_push_array($ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}, sizeof($cprefix$var_prefix$e->{NAME}\[0]), $size, (ndr_push_flags_fn_t)ndr_push_$e->{TYPE}));";
}
}
my $e = shift;
my $var_prefix = shift;
my $size = ParseExpr($e, util::array_size($e), $var_prefix);
- my $length = util::has_property($e, "length_is");
+ my $cprefix = c_push_prefix($e);
- if (defined $length) {
- $size = ParseExpr($e, $length, $var_prefix);
+ if (is_varying_array($e)) {
+ $size = ParseExpr($e, util::has_property($e, "length_is"), $var_prefix);
}
if (is_scalar_type($e->{TYPE})) {
- pidl "\t\tndr_print_array_$e->{TYPE}(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME}, $size);\n";
+ pidl "ndr_print_array_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME}, $size);";
} else {
- 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";
+ pidl "ndr_print_array(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME}, sizeof($cprefix$var_prefix$e->{NAME}\[0]), $size, (ndr_print_fn_t)ndr_print_$e->{TYPE});";
}
}
my $e = shift;
my $var_prefix = shift;
- if (!defined $e->{CONFORMANT_SIZE} &&
- util::has_property($e, "size_is")) {
+ if (is_conformant_array($e)) {
my $size = ParseExpr($e, util::array_size($e), $var_prefix);
- pidl "\tif ($var_prefix$e->{NAME}) {\n";
+ pidl "if ($var_prefix$e->{NAME}) {";
+ indent;
check_null_pointer($size);
- pidl "\t\tNDR_CHECK(ndr_check_array_size(ndr, (void*)&$var_prefix$e->{NAME}, $size));\n";
- pidl "\t}\n";
+ pidl "NDR_CHECK(ndr_check_array_size(ndr, (void*)&$var_prefix$e->{NAME}, $size));";
+ deindent;
+ pidl "}";
}
- if (my $length = util::has_property($e, "length_is")) {
+ if (is_varying_array($e)) {
+ my $length = util::has_property($e, "length_is");
$length = ParseExpr($e, $length, $var_prefix);
- pidl "\tif ($var_prefix$e->{NAME}) {\n";
+ pidl "if ($var_prefix$e->{NAME}) {";
+ indent;
check_null_pointer($length);
- pidl "\t\tNDR_CHECK(ndr_check_array_length(ndr, (void*)&$var_prefix$e->{NAME}, $length));\n";
- pidl "\t}\n";
+ pidl "NDR_CHECK(ndr_check_array_length(ndr, (void*)&$var_prefix$e->{NAME}, $length));";
+ deindent;
+ pidl "}"
+ }
+}
+
+sub ParseArrayPullPreceding($$$)
+{
+ my $e = shift;
+ my $var_prefix = shift;
+ my $ndr_flags = shift;
+
+ if (!is_inline_array($e)) {
+ # non fixed arrays encode the size just before the array
+ pidl "NDR_CHECK(ndr_pull_array_size(ndr, &$var_prefix$e->{NAME}));";
}
}
#####################################################################
# parse an array - pull side
-sub ParseArrayPull($$$)
+sub ParseArrayPull($$$$)
{
my $e = shift;
+ my $ndr = shift;
my $var_prefix = shift;
my $ndr_flags = shift;
- my $size = ParseExpr($e, util::array_size($e), $var_prefix);
- my $alloc_size = $size;
+ my $cprefix = c_pull_prefix($e);
+ my $length = ParseExpr($e, util::array_size($e), $var_prefix);
+ my $size = $length;
+
+ if (is_conformant_array($e)) {
+ $size = "ndr_get_array_size($ndr, &$var_prefix$e->{NAME})";
+ }
# 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};
- check_null_pointer($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";
+ if (!is_inline_array($e) and not is_surrounding_array($e)) {
+ if ($var_prefix =~ /^r->out/ && $length =~ /^\*r->in/) {
+ my $length2 = substr($length, 1);
+ pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { NDR_ALLOC($ndr, $length2); }";
}
- # non fixed arrays encode the size just before the array
- pidl "\t\tNDR_CHECK(ndr_pull_array_size(ndr, &$var_prefix$e->{NAME}));\n";
- $alloc_size = "ndr_get_array_size(ndr, &$var_prefix$e->{NAME})";
+ ParseArrayPullPreceding($e, $var_prefix, $ndr_flags);
}
- if ((need_alloc($e) && !util::is_fixed_array($e)) ||
+ if (is_varying_array($e)) {
+ pidl "NDR_CHECK(ndr_pull_array_length($ndr, &$var_prefix$e->{NAME}));";
+ $length = "ndr_get_array_length($ndr, &$var_prefix$e->{NAME})";
+ }
+
+ check_null_pointer($length);
+
+ if ($length ne $size) {
+ pidl "if ($length > $size) {";
+ indent;
+ pidl "return ndr_pull_error($ndr, NDR_ERR_CONFORMANT_SIZE, \"Bad conformant size %u should be %u\", $size, $length);";
+ deindent;
+ pidl "}";
+ }
+
+ if ((need_alloc($e) && !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}, $alloc_size);\n";
+ if (!is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") {
+ pidl "NDR_ALLOC_N($ndr, $var_prefix$e->{NAME}, $size);";
}
}
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}, $alloc_size);\n";
- pidl "\t}\n";
+ if (!is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") {
+ pidl "if ($ndr->flags & LIBNDR_FLAG_REF_ALLOC) {";
+ pidl "\tNDR_ALLOC_N($ndr, $var_prefix$e->{NAME}, $size);";
+ pidl "}";
}
}
- if (my $length = util::has_property($e, "length_is")) {
- pidl "\t\tNDR_CHECK(ndr_pull_array_length(ndr, &$var_prefix$e->{NAME}));\n";
- $size = "ndr_get_array_length(ndr, &$var_prefix$e->{NAME})";
+ if (is_scalar_type($e->{TYPE})) {
+ pidl "NDR_CHECK(ndr_pull_array_$e->{TYPE}($ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}, $length));";
+ } else {
+ pidl "NDR_CHECK(ndr_pull_array($ndr, $ndr_flags, (void **)$cprefix$var_prefix$e->{NAME}, sizeof($cprefix$var_prefix$e->{NAME}\[0]), $length, (ndr_pull_flags_fn_t)ndr_pull_$e->{TYPE}));";
}
+}
- check_null_pointer($size);
- if (is_scalar_type($e->{TYPE})) {
- pidl "\t\tNDR_CHECK(ndr_pull_array_$e->{TYPE}(ndr, $ndr_flags, $var_prefix$e->{NAME}, $size));\n";
+sub ParseSubcontextPushStart($)
+{
+ my $e = shift;
+ my $sub_size = util::has_property($e, "subcontext");
+
+ pidl "{";
+ indent;
+ pidl "struct ndr_push *_ndr_$e->{NAME};";
+ pidl "";
+ pidl "_ndr_$e->{NAME} = ndr_push_init_ctx(ndr);";
+ pidl "if (!_ndr_$e->{NAME}) return NT_STATUS_NO_MEMORY;";
+ pidl "_ndr_$e->{NAME}->flags = ndr->flags;";
+ pidl "";
+
+ return "_ndr_$e->{NAME}";
+}
+
+sub ParseSubcontextPushEnd($)
+{
+ my $e = shift;
+ my $sub_size = util::has_property($e, "subcontext");
+ pidl "NDR_CHECK(ndr_push_subcontext_header(ndr, $sub_size, _ndr_$e->{NAME}));";
+ pidl "NDR_CHECK(ndr_push_bytes(ndr, _ndr_$e->{NAME}->data, _ndr_$e->{NAME}->offset));";
+ deindent;
+ pidl "}";
+}
+
+sub ParseSubcontextPullStart($)
+{
+ my $e = shift;
+ my $sub_size = util::has_property($e, "subcontext");
+
+ pidl "{";
+ indent;
+ pidl "struct ndr_pull *_ndr_$e->{NAME};";
+ pidl "NDR_ALLOC(ndr, _ndr_$e->{NAME});";
+ pidl "NDR_CHECK(ndr_pull_subcontext_header(ndr, $sub_size, _ndr_$e->{NAME}));";
+
+ return "_ndr_$e->{NAME}";
+}
+
+sub ParseSubcontextPullEnd($)
+{
+ my $e = shift;
+ my $sub_size = util::has_property($e, "subcontext");
+
+ my $advance;
+ if ($sub_size) {
+ $advance = "_ndr_$e->{NAME}->data_size";
} else {
- 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";
+ $advance = "_ndr_$e->{NAME}->offset";
}
+ pidl "NDR_CHECK(ndr_pull_advance(ndr, $advance));";
+ deindent;
+ pidl "}";
}
#####################################################################
my($var_prefix) = shift;
my($ndr_flags) = shift;
my $cprefix = c_push_prefix($e);
+ my $ptr_prefix = c_ptr_prefix($e);
my $sub_size = util::has_property($e, "subcontext");
+ my $ndr = "ndr";
start_flags($e);
if (my $value = util::has_property($e, "value")) {
- pidl "\t$cprefix$var_prefix$e->{NAME} = $value;\n";
+ pidl "$cprefix$var_prefix$e->{NAME} = $value;";
}
- if (util::has_property($e, "relative")) {
- pidl "\tNDR_CHECK(ndr_push_relative_ptr1(ndr, $var_prefix$e->{NAME}));\n";
- } elsif (util::is_inline_array($e)) {
- ParseArrayPush($e, "r->", "NDR_SCALARS");
- } elsif (need_wire_pointer($e)) {
- pidl "\tNDR_CHECK(ndr_push_unique_ptr(ndr, $var_prefix$e->{NAME}));\n";
+ if (defined $sub_size and $e->{POINTERS} == 0) {
+ $ndr = ParseSubcontextPushStart($e);
+ }
+
+ if (need_wire_pointer($e)) {
+ ParsePtrPush($e, $ptr_prefix.$var_prefix);
+ } elsif (is_inline_array($e)) {
+ ParseArrayPush($e, $ndr, "r->", "NDR_SCALARS");
} elsif (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) {
- 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";
} else {
- pidl "\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
+ if (my $switch = util::has_property($e, "switch_is")) {
+ ParseSwitchPush($e, $ndr, $var_prefix, $ndr_flags, $switch);
+ }
+
+ pidl "NDR_CHECK(ndr_push_$e->{TYPE}($ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));";
+ }
+
+ if (defined $sub_size and $e->{POINTERS} == 0) {
+ ParseSubcontextPushEnd($e);
}
end_flags($e);
}
#####################################################################
-# print scalars in a structure element
-sub ParseElementPrintScalar($$)
+# parse a pointer in a struct element or function
+sub ParsePtrPush($$)
{
- my($e) = shift;
- my($var_prefix) = shift;
- my $cprefix = c_push_prefix($e);
-
- if (util::has_property($e, "noprint")) {
- return;
- }
+ my $e = shift;
+ my $var_prefix = shift;
- 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 ($e->{POINTERS} || util::array_size($e)) {
- 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);
+ if (util::has_property($e, "relative")) {
+ pidl "NDR_CHECK(ndr_push_relative_ptr1(ndr, $var_prefix$e->{NAME}));";
} else {
- pidl "\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME});\n";
+ pidl "NDR_CHECK(ndr_push_unique_ptr(ndr, $var_prefix$e->{NAME}));";
}
}
#####################################################################
-# parse scalars in a structure element - pull size
-sub ParseElementPullSwitch($$$$)
+# print scalars in a structure element
+sub ParseElementPrint($$)
{
my($e) = shift;
my($var_prefix) = shift;
- my($ndr_flags) = shift;
- my $switch = shift;
- my $switch_var = ParseExpr($e, $switch, $var_prefix);
+ my $cprefix = c_push_prefix($e);
+ my $ptr_prefix = c_ptr_prefix($e);
- my $cprefix = c_pull_prefix($e);
+ return if (util::has_property($e, "noprint"));
- my $utype = $typedefs{$e->{TYPE}};
+ if (my $value = util::has_property($e, "value")) {
+ pidl "if (ndr->flags & LIBNDR_PRINT_SET_VALUES) {";
+ pidl "\t$cprefix$var_prefix$e->{NAME} = $value;";
+ pidl "}";
+ }
- check_null_pointer($switch_var);
+ my $l = $e->{POINTERS};
+ $l++ if (util::array_size($e) and $l == 0 and !is_fixed_array($e));
- if (!defined $utype ||
- !util::has_property($utype, "nodiscriminant")) {
- my $e2 = find_sibling($e, $switch);
- my $type_decl = util::map_type($e2->{TYPE});
- pidl "\tif (($ndr_flags) & NDR_SCALARS) {\n";
- if ($typedefs{$e2->{TYPE}}->{DATA}->{TYPE} eq "ENUM") {
- $type_decl = util::enum_type_decl($e2);
- } elsif ($typedefs{$e2->{TYPE}}->{DATA}->{TYPE} eq "BITMAP") {
- $type_decl = util::bitmap_type_decl($e2);
+ foreach my $i (1..$l) {
+ pidl "ndr_print_ptr(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME});";
+ pidl "ndr->depth++;";
+ if ($i > $l-need_wire_pointer($e)) {
+ pidl "if ($ptr_prefix$var_prefix$e->{NAME}) {";
+ indent;
}
- pidl "\t\t$type_decl _level;\n";
- pidl "\t\tNDR_CHECK(ndr_pull_$e2->{TYPE}(ndr, NDR_SCALARS, &_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 "\tif (($ndr_flags) & NDR_SCALARS) {\n";
- 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";
- pidl "\t}\n";
+ if (util::array_size($e)) {
+ ParseArrayPrint($e, $var_prefix)
+ } elsif (my $switch = util::has_property($e, "switch_is")) {
+ my $switch_var = ParseExpr($e, $switch, $var_prefix);
+ check_null_pointer_void($switch_var);
+
+ pidl "ndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $switch_var, $cprefix$var_prefix$e->{NAME});";
} else {
- pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $switch_var, $cprefix$var_prefix$e->{NAME}));\n";
+ pidl "ndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME});";
}
-
+ foreach my $i (1..$l) {
+ if ($i > $l-need_wire_pointer($e)) {
+ deindent;
+ pidl "}";
+ }
+ pidl "ndr->depth--;";
+ }
}
#####################################################################
-# push switch element
-sub ParseElementPushSwitch($$$$)
+# parse scalars in a structure element - pull size
+sub ParseSwitchPull($$$$$)
{
my($e) = shift;
+ my $ndr = shift;
my($var_prefix) = shift;
my($ndr_flags) = shift;
my $switch = shift;
my $switch_var = ParseExpr($e, $switch, $var_prefix);
- my $cprefix = c_push_prefix($e);
+
+ my $cprefix = c_pull_prefix($e);
+
+ my $utype = typelist::getType($e->{TYPE});
check_null_pointer($switch_var);
- my $utype = $typedefs{$e->{TYPE}};
- if (!defined $utype ||
- !util::has_property($utype, "nodiscriminant")) {
- my $e2 = find_sibling($e, $switch);
- pidl "\tif (($ndr_flags) & NDR_SCALARS) {\n";
- pidl "\t\tNDR_CHECK(ndr_push_$e2->{TYPE}(ndr, NDR_SCALARS, $switch_var));\n";
- pidl "\t}\n";
- }
+ pidl "NDR_CHECK(ndr_pull_set_switch_value($ndr, $cprefix$var_prefix$e->{NAME}, $switch_var));";
- my $sub_size = util::has_property($e, "subcontext");
- if (defined $sub_size) {
- pidl "\tif(($ndr_flags) & NDR_SCALARS) {\n";
- 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";
- pidl "\t}\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($$$)
+# push switch element
+sub ParseSwitchPush($$$$$)
{
my($e) = shift;
+ my $ndr = shift;
my($var_prefix) = shift;
+ my($ndr_flags) = shift;
my $switch = shift;
my $switch_var = ParseExpr($e, $switch, $var_prefix);
my $cprefix = c_push_prefix($e);
- check_null_pointer_void($switch_var);
+ check_null_pointer($switch_var);
- pidl "\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $switch_var, $cprefix$var_prefix$e->{NAME});\n";
-}
+ pidl "NDR_CHECK(ndr_push_set_switch_value($ndr, $cprefix$var_prefix$e->{NAME}, $switch_var));";
+}
#####################################################################
# parse scalars in a structure element - pull size
my($var_prefix) = shift;
my($ndr_flags) = shift;
my $cprefix = c_pull_prefix($e);
+ my $ptr_prefix = c_ptr_prefix($e);
my $sub_size = util::has_property($e, "subcontext");
+ my $ndr = "ndr";
start_flags($e);
- if (util::is_inline_array($e)) {
- ParseArrayPull($e, "r->", "NDR_SCALARS");
+ if (defined $sub_size && $e->{POINTERS} == 0) {
+ $ndr = ParseSubcontextPullStart($e);
+ $ndr_flags = "NDR_SCALARS|NDR_BUFFERS";
+ }
+
+ if (is_inline_array($e)) {
+ ParseArrayPull($e, $ndr, "r->", "NDR_SCALARS");
} elsif (need_wire_pointer($e)) {
- pidl "\tNDR_CHECK(ndr_pull_unique_ptr(ndr, &_ptr_$e->{NAME}));\n";
- pidl "\tif (_ptr_$e->{NAME}) {\n";
- pidl "\t\tNDR_ALLOC(ndr, $var_prefix$e->{NAME});\n";
- if (util::has_property($e, "relative")) {
- pidl "\t\tNDR_CHECK(ndr_pull_relative_ptr1(ndr, $var_prefix$e->{NAME}, _ptr_$e->{NAME}));\n";
- }
- pidl "\t} else {\n";
- pidl "\t\t$var_prefix$e->{NAME} = NULL;\n";
- pidl "\t}\n";
- } elsif (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) {
- 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";
+ ParsePtrPull($e, $ptr_prefix.$var_prefix);
+ } elsif (is_surrounding_array($e)) {
} else {
- pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
+ if (my $switch = util::has_property($e, "switch_is")) {
+ ParseSwitchPull($e, $ndr, $var_prefix, $ndr_flags, $switch);
+ }
+
+ pidl "NDR_CHECK(ndr_pull_$e->{TYPE}($ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));";
}
+
if (my $range = util::has_property($e, "range")) {
my ($low, $high) = split(/ /, $range, 2);
- pidl "\tif ($var_prefix$e->{NAME} < $low || $var_prefix$e->{NAME} > $high) {\n";
- pidl "\t\treturn ndr_pull_error(ndr, NDR_ERR_RANGE, \"value out of range\");\n\t}\n";
+ pidl "if ($var_prefix$e->{NAME} < $low || $var_prefix$e->{NAME} > $high) {";
+ pidl "\treturn ndr_pull_error($ndr, NDR_ERR_RANGE, \"value out of range\");";
+ pidl "}";
+ }
+
+ if (defined $sub_size && $e->{POINTERS} == 0) {
+ ParseSubcontextPullEnd($e);
}
end_flags($e);
}
+#####################################################################
+# parse a pointer in a struct element or function
+sub ParsePtrPull($$)
+{
+ my($e) = shift;
+ my($var_prefix) = shift;
+
+ pidl "NDR_CHECK(ndr_pull_unique_ptr(ndr, &_ptr_$e->{NAME}));";
+ pidl "if (_ptr_$e->{NAME}) {";
+ indent;
+ pidl "NDR_ALLOC(ndr, $var_prefix$e->{NAME});";
+ if (util::has_property($e, "relative")) {
+ pidl "NDR_CHECK(ndr_pull_relative_ptr1(ndr, $var_prefix$e->{NAME}, _ptr_$e->{NAME}));";
+ }
+ deindent;
+ pidl "} else {";
+ pidl "\t$var_prefix$e->{NAME} = NULL;";
+ pidl "}";
+}
+
#####################################################################
# parse buffers in a structure element
-sub ParseElementPushBuffer($$$)
+sub ParseElementPushBuffer($$)
{
my($e) = shift;
my($var_prefix) = shift;
- my($ndr_flags) = shift;
my $cprefix = c_push_prefix($e);
my $sub_size = util::has_property($e, "subcontext");
+ my $ndr = "ndr";
- if (is_pure_scalar($e)) {
- return;
- }
+ return unless (need_buffers_section($e));
start_flags($e);
- if (need_wire_pointer($e)) {
- pidl "\tif ($var_prefix$e->{NAME}) {\n";
- if (util::has_property($e, "relative")) {
- pidl "\t\tNDR_CHECK(ndr_push_relative_ptr2(ndr, $var_prefix$e->{NAME}));\n";
+ my $pointers = c_ptr_prefix($e);
+ for my $i (1..need_wire_pointer($e)) {
+ if ($i > 1) {
+ ParsePtrPush($e,$pointers.$var_prefix);
}
+ pidl "if ($pointers$var_prefix$e->{NAME}) {";
+ indent;
+ $pointers.="*";
}
-
- if (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}) {
- 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 ($e->{POINTERS}) {
- pidl "\t\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, NDR_SCALARS|NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}));\n";
- } else {
- pidl "\t\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
+
+ if (util::has_property($e, "relative")) {
+ pidl "NDR_CHECK(ndr_push_relative_ptr2(ndr, $var_prefix$e->{NAME}));";
}
- if (need_wire_pointer($e)) {
- pidl "\t}\n";
- }
-
- end_flags($e);
-}
-
-#####################################################################
-# print buffers in a structure element
-sub ParseElementPrintBuffer($$)
-{
- my($e) = shift;
- my($var_prefix) = shift;
- my $cprefix = c_push_prefix($e);
+ my $ndr_flags = "NDR_BUFFERS";
+ if ($e->{POINTERS} || (util::array_size($e) && !is_inline_array($e)))
+ {
+ $ndr_flags="NDR_SCALARS|$ndr_flags"
+ }
- if (need_wire_pointer($e)) {
- pidl "\tif ($var_prefix$e->{NAME}) {\n";
+ if (defined $sub_size) {
+ $ndr = ParseSubcontextPushStart($e);
+ $ndr_flags = "NDR_SCALARS|NDR_BUFFERS";
}
if (util::array_size($e)) {
- ParseArrayPrint($e, $var_prefix)
- } elsif (my $switch = util::has_property($e, "switch_is")) {
- ParseElementPrintSwitch($e, $var_prefix, $switch);
+ ParseArrayPush($e, $ndr, "r->", $ndr_flags);
} else {
- pidl "\t\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME});\n";
+ if (my $switch = util::has_property($e, "switch_is")) {
+ ParseSwitchPush($e, $ndr, $var_prefix, $ndr_flags, $switch);
+ }
+
+ pidl "NDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));";
}
- if (need_wire_pointer($e)) {
- pidl "\t}\n";
- }
-}
+ if (defined $sub_size) {
+ ParseSubcontextPushEnd($e);
+ }
+ for my $i (1..need_wire_pointer($e)) {
+ deindent;
+ pidl "}";
+ }
+
+ end_flags($e);
+}
#####################################################################
# parse buffers in a structure element - pull side
-sub ParseElementPullBuffer($$$)
+sub ParseElementPullBuffer($$)
{
my($e) = shift;
my($var_prefix) = shift;
- my($ndr_flags) = shift;
my $cprefix = c_pull_prefix($e);
my $sub_size = util::has_property($e, "subcontext");
+ my $ndr = "ndr";
- if (is_pure_scalar($e)) {
- return;
- }
+ return unless (need_buffers_section($e));
start_flags($e);
- if (need_wire_pointer($e)) {
- pidl "\tif ($var_prefix$e->{NAME}) {\n";
- if (util::has_property($e, "relative")) {
- pidl "\t\tstruct ndr_pull_save _relative_save;\n";
- pidl "\t\tndr_pull_save(ndr, &_relative_save);\n";
- pidl "\t\tNDR_CHECK(ndr_pull_relative_ptr2(ndr, $var_prefix$e->{NAME}));\n";
- }
+ my $pointers = c_ptr_prefix($e);
+ for my $i (1..need_wire_pointer($e)) {
+ if ($i > 1) {
+ ParsePtrPull($e,$pointers.$var_prefix);
+ }
+ pidl "if ($pointers$var_prefix$e->{NAME}) {";
+ indent;
+ $pointers.="*";
+ }
+
+ if (util::has_property($e, "relative")) {
+ pidl "struct ndr_pull_save _relative_save;";
+ pidl "ndr_pull_save(ndr, &_relative_save);";
+ pidl "NDR_CHECK(ndr_pull_relative_ptr2(ndr, $var_prefix$e->{NAME}));";
+ }
+
+ my $ndr_flags = "NDR_BUFFERS";
+ if ($e->{POINTERS} || (util::array_size($e) && !is_inline_array($e)))
+ {
+ $ndr_flags="NDR_SCALARS|$ndr_flags"
}
-
- 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")) {
- 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}) {
- 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 ($e->{POINTERS}) {
- pidl "\t\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, NDR_SCALARS|NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}));\n";
- } else {
- pidl "\t\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
+
+ if (defined $sub_size) {
+ $ndr = ParseSubcontextPullStart($e);
+ $ndr_flags = "NDR_SCALARS|NDR_BUFFERS";
}
- if (need_wire_pointer($e)) {
- if (util::has_property($e, "relative")) {
- pidl "\t\tndr_pull_restore(ndr, &_relative_save);\n";
+ if (util::array_size($e)) {
+ ParseArrayPull($e, $ndr, "r->", $ndr_flags);
+ } else {
+ if (my $switch = util::has_property($e, "switch_is")) {
+ ParseSwitchPull($e, $ndr, $var_prefix, $ndr_flags, $switch);
}
- pidl "\t}\n";
- }
+
+ pidl "NDR_CHECK(ndr_pull_$e->{TYPE}($ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));";
+ }
+
+ if (defined $sub_size) {
+ ParseSubcontextPullEnd($e);
+ }
+
+ if (util::has_property($e, "relative")) {
+ pidl "ndr_pull_restore(ndr, &_relative_save);";
+ }
+
+ for my $i (1..need_wire_pointer($e)) {
+ deindent;
+ pidl "}";
+ }
end_flags($e);
}
{
my($struct) = shift;
- if (! defined $struct->{ELEMENTS}) {
- return;
- }
+ return unless defined($struct->{ELEMENTS});
start_flags($struct);
# 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 = ParseExpr($e, util::array_size($e), "r->");
- $e->{CONFORMANT_SIZE} = $size;
- check_null_pointer($size);
- pidl "\tNDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $size));\n";
+ if (is_conformant_array($e) and is_surrounding_array($e)) {
+ ParseArrayPushPreceding($e, "r->", "NDR_SCALARS");
}
if (defined $e->{TYPE} && $e->{TYPE} eq "string"
&& util::property_matches($e, "flag", ".*LIBNDR_FLAG_STR_CONFORMANT.*")) {
- pidl "\tNDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_string_array_size(ndr, r->$e->{NAME})));\n";
+ pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_string_array_size(ndr, r->$e->{NAME})));";
}
- pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
+ pidl "if (!(ndr_flags & NDR_SCALARS)) goto buffers;";
- pidl "\tNDR_CHECK(ndr_push_struct_start(ndr));\n";
+ pidl "NDR_CHECK(ndr_push_struct_start(ndr));";
- my $align = struct_alignment($struct);
- pidl "\tNDR_CHECK(ndr_push_align(ndr, $align));\n";
+ my $align = find_largest_alignment($struct);
+ pidl "NDR_CHECK(ndr_push_align(ndr, $align));";
foreach my $e (@{$struct->{ELEMENTS}}) {
ParseElementPushScalar($e, "r->", "NDR_SCALARS");
}
- pidl "buffers:\n";
- pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
+ pidl "buffers:";
+ pidl "if (!(ndr_flags & NDR_BUFFERS)) goto done;";
foreach my $e (@{$struct->{ELEMENTS}}) {
- ParseElementPushBuffer($e, "r->", "NDR_BUFFERS");
+ ParseElementPushBuffer($e, "r->");
}
- pidl "\tndr_push_struct_end(ndr);\n";
+ pidl "ndr_push_struct_end(ndr);";
- pidl "done:\n";
+ pidl "done:";
end_flags($struct);
}
-
#####################################################################
# generate a push function for an enum
sub ParseEnumPush($)
{
my($enum) = shift;
- my($type_fn) = util::enum_type_fn($enum);
+ my($type_fn) = typelist::enum_type_fn($enum);
start_flags($enum);
- pidl "\tNDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));\n";
+ pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));";
end_flags($enum);
}
sub ParseEnumPull($)
{
my($enum) = shift;
- my($type_fn) = util::enum_type_fn($enum);
- my($type_v_decl) = util::map_type(util::enum_type_fn($enum));
+ my($type_fn) = typelist::enum_type_fn($enum);
+ my($type_v_decl) = typelist::mapScalarType(typelist::enum_type_fn($enum));
- pidl "\t$type_v_decl v;\n";
+ pidl "$type_v_decl v;";
start_flags($enum);
- pidl "\tNDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));\n";
- pidl "\t*r = v;\n";
+ pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));";
+ pidl "*r = v;";
end_flags($enum);
}
{
my($enum) = shift;
- pidl "\tconst char *val = NULL;\n\n";
+ pidl "const char *val = NULL;";
+ pidl "";
start_flags($enum);
- pidl "\tswitch (r) {\n";
+ pidl "switch (r) {";
+ indent;
my $els = \@{$enum->{ELEMENTS}};
foreach my $i (0 .. $#{$els}) {
my $e = ${$els}[$i];
if ($e =~ /^(.*)=/) {
$e = $1;
}
- pidl "\t\tcase $e: val = \"$e\"; break;\n";
+ pidl "case $e: val = \"$e\"; break;";
}
- pidl "\t}\n\n\tndr_print_enum(ndr, name, \"$enum->{TYPE}\", val, r);\n";
+ deindent;
+ pidl "}";
+
+ pidl "ndr_print_enum(ndr, name, \"$enum->{TYPE}\", val, r);";
end_flags($enum);
}
+sub ArgsEnumPush($)
+{
+ my $e = shift;
+ return "struct ndr_push *ndr, int ndr_flags, enum $e->{NAME} r";
+}
+
+sub ArgsEnumPrint($)
+{
+ my $e = shift;
+ return "struct ndr_print *ndr, const char *name, enum $e->{NAME} r";
+}
+
+sub ArgsEnumPull($)
+{
+ my $e = shift;
+ return "struct ndr_pull *ndr, int ndr_flags, enum $e->{NAME} *r";
+}
+
+$typefamily{ENUM} = {
+ PUSH_FN_BODY => \&ParseEnumPush,
+ PUSH_FN_ARGS => \&ArgsEnumPush,
+ PULL_FN_BODY => \&ParseEnumPull,
+ PULL_FN_ARGS => \&ArgsEnumPull,
+ PRINT_FN_BODY => \&ParseEnumPrint,
+ PRINT_FN_ARGS => \&ArgsEnumPrint,
+ ALIGN => sub { return align_type(typelist::enum_type_fn(shift)); }
+};
#####################################################################
# generate a push function for a bitmap
sub ParseBitmapPush($)
{
my($bitmap) = shift;
- my($type_fn) = util::bitmap_type_fn($bitmap);
+ my($type_fn) = typelist::bitmap_type_fn($bitmap);
start_flags($bitmap);
- pidl "\tNDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));\n";
+ pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));";
end_flags($bitmap);
}
sub ParseBitmapPull($)
{
my($bitmap) = shift;
- my($type_fn) = util::bitmap_type_fn($bitmap);
- my($type_decl) = util::bitmap_type_decl($bitmap);
+ my($type_fn) = typelist::bitmap_type_fn($bitmap);
+ my($type_decl) = typelist::mapType($bitmap);
- pidl "\t$type_decl v;\n";
+ pidl "$type_decl v;";
start_flags($bitmap);
- pidl "\tNDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));\n";
- pidl "\t*r = v;\n";
+ pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));";
+ pidl "*r = v;";
end_flags($bitmap);
}
{
my($e) = shift;
my($bitmap) = shift;
- my($type_decl) = util::bitmap_type_decl($bitmap);
- my($type_fn) = util::bitmap_type_fn($bitmap);
+ my($type_decl) = typelist::mapType($bitmap);
+ my($type_fn) = typelist::bitmap_type_fn($bitmap);
my($name) = $bitmap->{PARENT}->{NAME};
my($flag);
die "Bitmap: \"$name\" invalid Flag: \"$e\"";
}
- pidl "\tndr_print_bitmap_flag(ndr, sizeof($type_decl), \"$flag\", $flag, r);\n";
+ pidl "ndr_print_bitmap_flag(ndr, sizeof($type_decl), \"$flag\", $flag, r);";
}
#####################################################################
sub ParseBitmapPrint($)
{
my($bitmap) = shift;
- my($type_decl) = util::bitmap_type_decl($bitmap);
- my($type_fn) = util::bitmap_type_fn($bitmap);
+ my($type_decl) = typelist::mapType($bitmap);
+ my($type_fn) = typelist::bitmap_type_fn($bitmap);
start_flags($bitmap);
- pidl "\tndr_print_$type_fn(ndr, name, r);\n";
+ pidl "ndr_print_$type_fn(ndr, name, r);";
- pidl "\tndr->depth++;\n";
+ pidl "ndr->depth++;";
foreach my $e (@{$bitmap->{ELEMENTS}}) {
ParseBitmapPrintElement($e, $bitmap);
}
- pidl "\tndr->depth--;\n";
+ pidl "ndr->depth--;";
end_flags($bitmap);
}
+sub ArgsBitmapPush($)
+{
+ my $e = shift;
+ my $type_decl = typelist::mapType($e->{DATA});
+ return "struct ndr_push *ndr, int ndr_flags, $type_decl r";
+}
+
+sub ArgsBitmapPrint($)
+{
+ my $e = shift;
+ my $type_decl = typelist::mapType($e->{DATA});
+ return "struct ndr_print *ndr, const char *name, $type_decl r";
+}
+
+sub ArgsBitmapPull($)
+{
+ my $e = shift;
+ my $type_decl = typelist::mapType($e->{DATA});
+ return "struct ndr_pull *ndr, int ndr_flags, $type_decl *r";
+}
+
+$typefamily{BITMAP} = {
+ PUSH_FN_BODY => \&ParseBitmapPush,
+ PUSH_FN_ARGS => \&ArgsBitmapPush,
+ PULL_FN_BODY => \&ParseBitmapPull,
+ PULL_FN_ARGS => \&ArgsBitmapPull,
+ PRINT_FN_BODY => \&ParseBitmapPrint,
+ PRINT_FN_ARGS => \&ArgsBitmapPrint,
+ ALIGN => sub { return align_type(typelist::bitmap_type_fn(shift)); }
+};
+
#####################################################################
# generate a struct print function
sub ParseStructPrint($)
{
my($struct) = shift;
+ my($name) = $struct->{PARENT}->{NAME};
- if (! defined $struct->{ELEMENTS}) {
- return;
- }
+ return unless defined $struct->{ELEMENTS};
+
+ pidl "ndr_print_struct(ndr, name, \"$name\");";
start_flags($struct);
- pidl "\tndr->depth++;\n";
+ pidl "ndr->depth++;";
foreach my $e (@{$struct->{ELEMENTS}}) {
- ParseElementPrintScalar($e, "r->");
+ ParseElementPrint($e, "r->");
}
- pidl "\tndr->depth--;\n";
+ pidl "ndr->depth--;";
end_flags($struct);
}
my($struct) = shift;
my $conform_e;
- if (! defined $struct->{ELEMENTS}) {
- return;
- }
+ return unless defined $struct->{ELEMENTS};
# see if the structure contains a conformant array. If it
# does, then it must be the last element of the structure, and
# 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 "*") {
+ if (is_conformant_array($e) and is_surrounding_array($e)) {
$conform_e = $e;
}
$conform_e = $e;
}
- if (defined $conform_e) {
- $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}}) {
if (need_wire_pointer($e)) {
- pidl "\tuint32_t _ptr_$e->{NAME};\n";
+ pidl "uint32_t _ptr_$e->{NAME};";
}
}
start_flags($struct);
- pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
+ pidl "if (!(ndr_flags & NDR_SCALARS)) goto buffers;";
- pidl "\tNDR_CHECK(ndr_pull_struct_start(ndr));\n";
+ pidl "NDR_CHECK(ndr_pull_struct_start(ndr));";
if (defined $conform_e) {
- pidl "\tNDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &$conform_e->{CONFORMANT_SIZE}));\n";
+ ParseArrayPullPreceding($conform_e, "r->", "NDR_SCALARS");
}
- my $align = struct_alignment($struct);
- pidl "\tNDR_CHECK(ndr_pull_align(ndr, $align));\n";
+ my $align = find_largest_alignment($struct);
+ pidl "NDR_CHECK(ndr_pull_align(ndr, $align));";
foreach my $e (@{$struct->{ELEMENTS}}) {
ParseElementPullScalar($e, "r->", "NDR_SCALARS");
}
pidl "buffers:\n";
- pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
+ pidl "if (!(ndr_flags & NDR_BUFFERS)) goto done;";
foreach my $e (@{$struct->{ELEMENTS}}) {
- ParseElementPullBuffer($e, "r->", "NDR_BUFFERS");
+ ParseElementPullBuffer($e, "r->");
}
foreach my $e (@{$struct->{ELEMENTS}}) {
CheckArraySizes($e, "r->");
}
- pidl "\tndr_pull_struct_end(ndr);\n";
+ pidl "ndr_pull_struct_end(ndr);";
- pidl "done:\n";
+ pidl "done:";
end_flags($struct);
}
my $static = fn_prefix($t);
my $sizevar;
- pidl "size_t ndr_size_$t->{NAME}(const struct $t->{NAME} *r, int flags)\n";
- pidl "{\n";
if (my $flags = util::has_property($t, "flag")) {
- pidl "\tflags |= $flags;\n";
+ pidl "flags |= $flags;";
}
- pidl "\treturn ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});\n";
- pidl "}\n\n";
+ pidl "return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});";
+}
+
+sub ArgsStructPush($)
+{
+ my $e = shift;
+ return "struct ndr_push *ndr, int ndr_flags, struct $e->{NAME} *r";
}
+sub ArgsStructPrint($)
+{
+ my $e = shift;
+ return "struct ndr_print *ndr, const char *name, struct $e->{NAME} *r";
+}
+
+sub ArgsStructPull($)
+{
+ my $e = shift;
+ return "struct ndr_pull *ndr, int ndr_flags, struct $e->{NAME} *r";
+}
+
+sub ArgsStructNdrSize($)
+{
+ my $d = shift;
+ return "const struct $d->{NAME} *r, int flags";
+}
+
+$typefamily{STRUCT} = {
+ PUSH_FN_BODY => \&ParseStructPush,
+ PUSH_FN_ARGS => \&ArgsStructPush,
+ PULL_FN_BODY => \&ParseStructPull,
+ PULL_FN_ARGS => \&ArgsStructPull,
+ PRINT_FN_BODY => \&ParseStructPrint,
+ PRINT_FN_ARGS => \&ArgsStructPrint,
+ SIZE_FN_BODY => \&ParseStructNdrSize,
+ SIZE_FN_ARGS => \&ArgsStructNdrSize,
+ ALIGN => \&find_largest_alignment
+};
+
#####################################################################
# calculate size of ndr struct
sub ParseUnionNdrSize($)
my $static = fn_prefix($t);
my $sizevar;
- pidl "size_t ndr_size_$t->{NAME}(const union $t->{NAME} *r, int level, int flags)\n";
- pidl "{\n";
if (my $flags = util::has_property($t, "flag")) {
- pidl "\tflags |= $flags;\n";
+ pidl "flags |= $flags;";
}
- pidl "\treturn ndr_size_union(r, flags, level, (ndr_push_union_fn_t)ndr_push_$t->{NAME});\n";
- pidl "}\n\n";
+ pidl "return ndr_size_union(r, flags, level, (ndr_push_union_fn_t)ndr_push_$t->{NAME});";
}
#####################################################################
my $e = shift;
my $have_default = 0;
+ pidl "int level;";
+
start_flags($e);
- pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
+ pidl "level = ndr_push_get_switch_value(ndr, r);";
+
+ pidl "if (!(ndr_flags & NDR_SCALARS)) goto buffers;";
+
+ if (!util::has_property($e, "nodiscriminant")) {
+ my $switch_type = util::has_property($e, "switch_type");
+ $switch_type = "uint32" unless (defined ($switch_type));
+ pidl "NDR_CHECK(ndr_push_$switch_type(ndr, NDR_SCALARS, level));";
+ }
- pidl "\tNDR_CHECK(ndr_push_struct_start(ndr));\n";
+ pidl "NDR_CHECK(ndr_push_struct_start(ndr));";
# my $align = union_alignment($e);
-# pidl "\tNDR_CHECK(ndr_push_align(ndr, $align));\n";
+# pidl "NDR_CHECK(ndr_push_align(ndr, $align));";
- pidl "\tswitch (level) {\n";
+ pidl "switch (level) {";
+ indent;
foreach my $el (@{$e->{ELEMENTS}}) {
if (util::has_property($el, "default")) {
- pidl "\tdefault:\n";
+ pidl "default:";
$have_default = 1;
} else {
- pidl "\tcase $el->{PROPERTIES}->{case}:\n";
+ pidl "case $el->{PROPERTIES}->{case}:";
+
}
if ($el->{TYPE} ne "EMPTY") {
+ indent;
ParseElementPushScalar($el, "r->", "NDR_SCALARS");
+ deindent;
}
- pidl "\tbreak;\n\n";
+ pidl "break;";
+ pidl "";
}
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";
+ pidl "default:";
+ pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
+ }
+ deindent;
+ pidl "}";
+ pidl "buffers:";
+ pidl "if (!(ndr_flags & NDR_BUFFERS)) goto done;";
+ pidl "switch (level) {";
+ indent;
foreach my $el (@{$e->{ELEMENTS}}) {
if (util::has_property($el, "default")) {
- pidl "\tdefault:\n";
+ pidl "default:";
} else {
- pidl "\tcase $el->{PROPERTIES}->{case}:\n";
+ pidl "case $el->{PROPERTIES}->{case}:";
}
if ($el->{TYPE} ne "EMPTY") {
- ParseElementPushBuffer($el, "r->", "NDR_BUFFERS");
+ indent;
+ ParseElementPushBuffer($el, "r->");
+ deindent;
}
- pidl "\tbreak;\n\n";
+ pidl "break;";
+ pidl "";
}
if (! $have_default) {
- pidl "\tdefault:\n";
- pidl "\t\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
+ pidl "default:";
+ pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
}
- pidl "\t}\n";
- pidl "\tndr_push_struct_end(ndr);\n";
- pidl "done:\n";
+ deindent;
+ pidl "}";
+ pidl "ndr_push_struct_end(ndr);";
+ pidl "done:";
end_flags($e);
}
{
my $e = shift;
my $have_default = 0;
+ my($name) = $e->{PARENT}->{NAME};
+ pidl "ndr_print_union(ndr, name, level, \"$name\");";
start_flags($e);
- pidl "\tswitch (level) {\n";
+ pidl "switch (level) {";
+ indent;
foreach my $el (@{$e->{ELEMENTS}}) {
if (util::has_property($el, "default")) {
$have_default = 1;
- pidl "\tdefault:\n";
+ pidl "default:";
} else {
- pidl "\tcase $el->{PROPERTIES}->{case}:\n";
+ pidl "case $el->{PROPERTIES}->{case}:";
}
if ($el->{TYPE} ne "EMPTY") {
- ParseElementPrintScalar($el, "r->");
+ indent;
+ ParseElementPrint($el, "r->");
+ deindent;
}
- pidl "\tbreak;\n\n";
+ pidl "break;";
+ pidl "";
}
if (! $have_default) {
- pidl "\tdefault:\n\t\tndr_print_bad_level(ndr, name, level);\n";
+ pidl "default:";
+ pidl "\tndr_print_bad_level(ndr, name, level);";
}
- pidl "\t}\n";
+ deindent;
+ pidl "}";
end_flags($e);
}
{
my $e = shift;
my $have_default = 0;
+ my $switch_type = util::has_property($e, "switch_type");
+ $switch_type = "uint32" unless defined($switch_type);
+
+ pidl "int level;";
+ if (!util::has_property($e, "nodiscriminant")) {
+ if (typelist::typeIs($switch_type, "ENUM")) {
+ $switch_type = typelist::enum_type_fn(typelist::getType($switch_type));
+ }
+ pidl typelist::mapScalarType($switch_type) . " _level;";
+ }
start_flags($e);
- pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
+ pidl "level = ndr_pull_get_switch_value(ndr, r);";
- pidl "\tNDR_CHECK(ndr_pull_struct_start(ndr));\n";
+ pidl "if (!(ndr_flags & NDR_SCALARS)) goto buffers;";
+
+ if (!util::has_property($e, "nodiscriminant")) {
+ pidl "NDR_CHECK(ndr_pull_$switch_type(ndr, NDR_SCALARS, &_level));";
+ pidl "if (_level != level) {";
+ pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u for $e->{PARENT}->{NAME}\", _level);";
+ pidl "}";
+ }
+
+ pidl "NDR_CHECK(ndr_pull_struct_start(ndr));";
# my $align = union_alignment($e);
# pidl "\tNDR_CHECK(ndr_pull_align(ndr, $align));\n";
- pidl "\tswitch (level) {\n";
+ pidl "switch (level) {";
+ indent;
foreach my $el (@{$e->{ELEMENTS}}) {
if (util::has_property($el, "default")) {
- pidl "\tdefault: {\n";
+ pidl "default: {";
$have_default = 1;
} else {
- pidl "\tcase $el->{PROPERTIES}->{case}: {\n";
+ pidl "case $el->{PROPERTIES}->{case}: {";
}
if ($el->{TYPE} ne "EMPTY") {
+ indent;
if ($el->{POINTERS}) {
- pidl "\t\tuint32_t _ptr_$el->{NAME};\n";
+ pidl "uint32_t _ptr_$el->{NAME};";
}
ParseElementPullScalar($el, "r->", "NDR_SCALARS");
+ deindent;
}
- pidl "\tbreak; }\n\n";
+ pidl "break; }";
+ pidl "";
}
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";
+ pidl "default:";
+ pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
+ }
+ deindent;
+ pidl "}";
+ pidl "buffers:";
+ pidl "if (!(ndr_flags & NDR_BUFFERS)) goto done;";
+ pidl "switch (level) {";
+ indent;
foreach my $el (@{$e->{ELEMENTS}}) {
if (util::has_property($el, "default")) {
- pidl "\tdefault:\n";
+ pidl "default:";
} else {
- pidl "\tcase $el->{PROPERTIES}->{case}:\n";
+ pidl "case $el->{PROPERTIES}->{case}:";
}
if ($el->{TYPE} ne "EMPTY") {
- ParseElementPullBuffer($el, "r->", "NDR_BUFFERS");
+ indent;
+ ParseElementPullBuffer($el, "r->");
+ deindent;
}
- pidl "\tbreak;\n\n";
+ pidl "break;";
+ pidl "";
}
if (! $have_default) {
- pidl "\tdefault:\n";
- pidl "\t\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
+ pidl "default:";
+ pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
}
- pidl "\t}\n";
- pidl "\tndr_pull_struct_end(ndr);\n";
- pidl "done:\n";
+ deindent;
+ pidl "}";
+ pidl "ndr_pull_struct_end(ndr);";
+ pidl "done:";
end_flags($e);
}
-my %typefamily = (
- STRUCT => {
- PUSH_FN_BODY => \&ParseStructPush,
- PULL_FN_BODY => \&ParseStructPull,
- PRINT_FN_BODY => \&ParseStructPrint
- },
- UNION => {
- PUSH_FN_BODY => \&ParseUnionPush,
- PULL_FN_BODY => \&ParseUnionPull,
- PRINT_FN_BODY => \&ParseUnionPrint
- },
- ENUM => {
- PUSH_FN_BODY => \&ParseEnumPush,
- PULL_FN_BODY => \&ParseEnumPull,
- PRINT_FN_BODY => \&ParseEnumPrint
- },
- BITMAP => {
- PUSH_FN_BODY => \&ParseBitmapPush,
- PULL_FN_BODY => \&ParseBitmapPull,
- PRINT_FN_BODY => \&ParseBitmapPrint
- }
-);
+sub ArgsUnionPush($)
+{
+ my $e = shift;
+ return "struct ndr_push *ndr, int ndr_flags, union $e->{NAME} *r";
+}
+
+sub ArgsUnionPrint($)
+{
+ my $e = shift;
+ return "struct ndr_print *ndr, const char *name, int level, union $e->{NAME} *r";
+}
+
+sub ArgsUnionPull($)
+{
+ my $e = shift;
+ return "struct ndr_pull *ndr, int ndr_flags, union $e->{NAME} *r";
+}
+
+sub ArgsUnionNdrSize($)
+{
+ my $d = shift;
+ return "const union $d->{NAME} *r, uint32_t level, int flags";
+}
+
+$typefamily{UNION} = {
+ PUSH_FN_BODY => \&ParseUnionPush,
+ PUSH_FN_ARGS => \&ArgsUnionPush,
+ PULL_FN_BODY => \&ParseUnionPull,
+ PULL_FN_ARGS => \&ArgsUnionPull,
+ PRINT_FN_BODY => \&ParseUnionPrint,
+ PRINT_FN_ARGS => \&ArgsUnionPrint,
+ SIZE_FN_ARGS => \&ArgsUnionNdrSize,
+ SIZE_FN_BODY => \&ParseUnionNdrSize,
+ ALIGN => \&find_largest_alignment
+};
#####################################################################
# parse a typedef - push side
my($e) = shift;
my $static = fn_prefix($e);
- if (! needed::is_needed("push_$e->{NAME}")) {
-# print "push_$e->{NAME} not needed\n";
- return;
- }
-
- if (defined($e->{PROPERTIES}) && !defined($e->{DATA}->{PROPERTIES})) {
- $e->{DATA}->{PROPERTIES} = $e->{PROPERTIES};
- }
+ return unless needed::is_needed("push_$e->{NAME}");
- if ($e->{DATA}->{TYPE} eq "STRUCT") {
- pidl $static . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, struct $e->{NAME} *r)";
- }
-
- if ($e->{DATA}->{TYPE} eq "UNION") {
- pidl $static . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, int level, union $e->{NAME} *r)";
- }
+ my $args = $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_ARGS}->($e);
+ pidl $static . "NTSTATUS ndr_push_$e->{NAME}($args)";
- if ($e->{DATA}->{TYPE} eq "ENUM") {
- pidl $static . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, enum $e->{NAME} r)";
- }
-
- if ($e->{DATA}->{TYPE} eq "BITMAP") {
- my $type_decl = util::bitmap_type_decl($e->{DATA});
- pidl $static . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, $type_decl r)";
- }
-
- pidl "\n{\n";
- $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}($e->{DATA});
- pidl "\treturn NT_STATUS_OK;\n";
- pidl "}\n\n";
+ pidl "{";
+ indent;
+ $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($e->{DATA});
+ pidl "return NT_STATUS_OK;";
+ deindent;
+ pidl "}";
+ pidl "";;
}
+
#####################################################################
# parse a typedef - pull side
sub ParseTypedefPull($)
my($e) = shift;
my $static = fn_prefix($e);
- if (defined($e->{PROPERTIES}) && !defined($e->{DATA}->{PROPERTIES})) {
- $e->{DATA}->{PROPERTIES} = $e->{PROPERTIES};
- }
-
- if (! needed::is_needed("pull_$e->{NAME}")) {
-# print "pull_$e->{NAME} not needed\n";
- return;
- }
-
- if ($e->{DATA}->{TYPE} eq "STRUCT") {
- pidl $static . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, struct $e->{NAME} *r)";
- }
+ return unless needed::is_needed("pull_$e->{NAME}");
- if ($e->{DATA}->{TYPE} eq "UNION") {
- pidl $static . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, int level, union $e->{NAME} *r)";
- }
-
- if ($e->{DATA}->{TYPE} eq "ENUM") {
- pidl $static . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, enum $e->{NAME} *r)";
- }
+ my $args = $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_ARGS}->($e);
- if ($e->{DATA}->{TYPE} eq "BITMAP") {
- my $type_decl = util::bitmap_type_decl($e->{DATA});
- pidl $static . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, $type_decl *r)";
- }
+ pidl $static . "NTSTATUS ndr_pull_$e->{NAME}($args)";
- pidl "\n{\n";
- $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}($e->{DATA});
- pidl "\treturn NT_STATUS_OK;\n";
- pidl "}\n\n";
+ pidl "{";
+ indent;
+ $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($e->{DATA});
+ pidl "return NT_STATUS_OK;";
+ deindent;
+ pidl "}";
+ pidl "";
}
#####################################################################
{
my($e) = shift;
- if (defined($e->{PROPERTIES}) && !defined($e->{DATA}->{PROPERTIES})) {
- $e->{DATA}->{PROPERTIES} = $e->{PROPERTIES};
- }
-
- if ($e->{DATA}->{TYPE} eq "STRUCT") {
- 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";
- }
-
- if ($e->{DATA}->{TYPE} eq "UNION") {
- pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, int level, union $e->{NAME} *r)";
- pidl "\n{\n";
- pidl "\tndr_print_union(ndr, name, level, \"$e->{NAME}\");\n";
- }
-
- if ($e->{DATA}->{TYPE} eq "ENUM") {
- pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, enum $e->{NAME} r)";
- pidl "\n{\n";
- }
+ my $args = $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_ARGS}->($e);
- if ($e->{DATA}->{TYPE} eq "BITMAP") {
- my $type_decl = util::bitmap_type_decl($e->{DATA});
- pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $type_decl r)";
- pidl "\n{\n";
- }
+ return unless !util::has_property($e, "noprint");
- $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}($e->{DATA});
- pidl "}\n\n";
+ pidl "void ndr_print_$e->{NAME}($args)";
+ pidl "{";
+ indent;
+ $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($e->{DATA});
+ deindent;
+ pidl "}";
}
#####################################################################
sub ParseTypedefNdrSize($)
{
my($t) = shift;
- if (! needed::is_needed("ndr_size_$t->{NAME}")) {
- return;
- }
-
- ($t->{DATA}->{TYPE} eq "STRUCT") &&
- ParseStructNdrSize($t);
- ($t->{DATA}->{TYPE} eq "UNION") &&
- ParseUnionNdrSize($t);
+ return unless needed::is_needed("ndr_size_$t->{NAME}");
+
+ my $tf = $typefamily{$t->{DATA}->{TYPE}};
+ my $args = $tf->{SIZE_FN_ARGS}->($t);
+
+ pidl "size_t ndr_size_$t->{NAME}($args)";
+ pidl "{";
+ indent;
+ $typefamily{$t->{DATA}->{TYPE}}->{SIZE_FN_BODY}->($t);
+ deindent;
+ pidl "}";
+ pidl "";
}
#####################################################################
{
my($fn) = shift;
+ return unless !util::has_property($fn, "noprint");
+
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 "{";
+ indent;
+ pidl "ndr_print_struct(ndr, name, \"$fn->{NAME}\");";
+ pidl "ndr->depth++;";
- pidl "\tif (flags & NDR_SET_VALUES) {\n";
- pidl "\t\tndr->flags |= LIBNDR_PRINT_SET_VALUES;\n";
- pidl "\t}\n";
+ pidl "if (flags & NDR_SET_VALUES) {";
+ pidl "\tndr->flags |= LIBNDR_PRINT_SET_VALUES;";
+ pidl "}";
- pidl "\tif (flags & NDR_IN) {\n";
- pidl "\t\tndr_print_struct(ndr, \"in\", \"$fn->{NAME}\");\n";
- pidl "\tndr->depth++;\n";
+ pidl "if (flags & NDR_IN) {";
+ indent;
+ pidl "ndr_print_struct(ndr, \"in\", \"$fn->{NAME}\");";
+ pidl "ndr->depth++;";
foreach my $e (@{$fn->{ELEMENTS}}) {
if (util::has_property($e, "in")) {
- ParseElementPrintScalar($e, "r->in.");
+ ParseElementPrint($e, "r->in.");
}
}
- pidl "\tndr->depth--;\n";
- pidl "\t}\n";
+ pidl "ndr->depth--;";
+ deindent;
+ pidl "}";
- pidl "\tif (flags & NDR_OUT) {\n";
- pidl "\t\tndr_print_struct(ndr, \"out\", \"$fn->{NAME}\");\n";
- pidl "\tndr->depth++;\n";
+ pidl "if (flags & NDR_OUT) {";
+ indent;
+ pidl "ndr_print_struct(ndr, \"out\", \"$fn->{NAME}\");";
+ pidl "ndr->depth++;";
foreach my $e (@{$fn->{ELEMENTS}}) {
if (util::has_property($e, "out")) {
- ParseElementPrintScalar($e, "r->out.");
+ ParseElementPrint($e, "r->out.");
}
}
if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
my $cprefix = "&";
$cprefix = "" if (is_scalar_type($fn->{RETURN_TYPE})) ; # FIXME: Should really use util::c_push_prefix here
- pidl "\tndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", $cprefix"."r->out.result);\n";
+ pidl "ndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", $cprefix"."r->out.result);";
}
- pidl "\tndr->depth--;\n";
- pidl "\t}\n";
+ pidl "ndr->depth--;";
+ deindent;
+ pidl "}";
- pidl "\tndr->depth--;\n";
- pidl "}\n\n";
+ pidl "ndr->depth--;";
+ deindent;
+ pidl "}";
+ pidl "";
}
#####################################################################
if (util::array_size($e)) {
if (need_wire_pointer($e)) {
- pidl "\tNDR_CHECK(ndr_push_unique_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";
+ pidl "NDR_CHECK(ndr_push_unique_ptr(ndr, r->$inout.$e->{NAME}));";
+ pidl "if (r->$inout.$e->{NAME}) {";
+ indent;
+ ParseArrayPush($e, "ndr", "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
+ deindent;
+ pidl "}";
} else {
- ParseArrayPush($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
+ ParseArrayPush($e, "ndr", "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");
+ if (need_wire_pointer($e)) {
+ ParseElementPushBuffer($e, "r->$inout.");
}
}
}
my($fn) = shift;
my $static = fn_prefix($fn);
- pidl $static . "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, struct $fn->{NAME} *r)\n{\n";
+ return unless !util::has_property($fn, "nopush");
- pidl "\n\tif (!(flags & NDR_IN)) goto ndr_out;\n\n";
+ pidl $static . "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, struct $fn->{NAME} *r)";
+ pidl "{";
+ indent;
+
+ pidl "if (!(flags & NDR_IN)) goto ndr_out;";
+ pidl "";
foreach my $e (@{$fn->{ELEMENTS}}) {
if (util::has_property($e, "in")) {
}
}
- pidl "\nndr_out:\n";
- pidl "\tif (!(flags & NDR_OUT)) goto done;\n\n";
+ pidl "ndr_out:";
+ pidl "if (!(flags & NDR_OUT)) goto done;";
+ pidl "";
foreach my $e (@{$fn->{ELEMENTS}}) {
if (util::has_property($e, "out")) {
}
if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
- pidl "\tNDR_CHECK(ndr_push_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, r->out.result));\n";
+ pidl "NDR_CHECK(ndr_push_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, r->out.result));";
}
- pidl "\ndone:\n";
- pidl "\n\treturn NT_STATUS_OK;\n}\n\n";
+ pidl "done:";
+ pidl "return NT_STATUS_OK;";
+ deindent;
+ pidl "}";
+ pidl "";
}
#####################################################################
if (util::array_size($e)) {
if (need_wire_pointer($e)) {
- pidl "\tNDR_CHECK(ndr_pull_unique_ptr(ndr, &_ptr_$e->{NAME}));\n";
- pidl "\tr->$inout.$e->{NAME} = NULL;\n";
- pidl "\tif (_ptr_$e->{NAME}) {\n";
+ pidl "NDR_CHECK(ndr_pull_unique_ptr(ndr, &_ptr_$e->{NAME}));";
+ pidl "r->$inout.$e->{NAME} = NULL;";
+ pidl "if (_ptr_$e->{NAME}) {";
+ indent;
} elsif ($inout eq "out" && util::has_property($e, "ref")) {
- pidl "\tif (r->$inout.$e->{NAME}) {\n";
- } else {
- pidl "\t{\n";
+ pidl "if (r->$inout.$e->{NAME}) {";
+ indent;
+ }
+
+ ParseArrayPull($e, "ndr", "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
+
+ if (need_wire_pointer($e) or ($inout eq "out" and util::has_property($e, "ref"))) {
+ deindent;
+ pidl "}";
}
- 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";
+ pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {";
+ pidl "\tNDR_ALLOC(ndr, r->out.$e->{NAME});";
+ pidl "}";
}
+
if ($inout eq "in" && util::has_property($e, "ref")) {
- pidl "\tNDR_ALLOC(ndr, r->in.$e->{NAME});\n";
+ pidl "NDR_ALLOC(ndr, r->in.$e->{NAME});";
}
ParseElementPullScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
- if ($e->{POINTERS}) {
- ParseElementPullBuffer($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
+ if (need_wire_pointer($e)) {
+ ParseElementPullBuffer($e, "r->$inout.");
}
}
}
if (!defined $asize) {
# its a simple variable
- pidl "\tNDR_ALLOC(ndr, r->out.$e->{NAME});\n";
+ pidl "NDR_ALLOC(ndr, r->out.$e->{NAME});";
if (util::has_property($e, "in")) {
- pidl "\t*r->out.$e->{NAME} = *r->in.$e->{NAME};\n";
+ pidl "*r->out.$e->{NAME} = *r->in.$e->{NAME};";
} else {
- pidl "\tZERO_STRUCTP(r->out.$e->{NAME});\n";
+ pidl "ZERO_STRUCTP(r->out.$e->{NAME});";
}
return;
}
# its an array
my $size = ParseExpr($e, $asize, "r->out.");
check_null_pointer($size);
- pidl "\tNDR_ALLOC_N(ndr, r->out.$e->{NAME}, $size);\n";
+ pidl "NDR_ALLOC_N(ndr, r->out.$e->{NAME}, $size);";
if (util::has_property($e, "in")) {
- pidl "\tmemcpy(r->out.$e->{NAME},r->in.$e->{NAME},$size * sizeof(*r->in.$e->{NAME}));\n";
+ pidl "memcpy(r->out.$e->{NAME},r->in.$e->{NAME},$size * sizeof(*r->in.$e->{NAME}));";
} else {
- pidl "\tmemset(r->out.$e->{NAME}, 0, $size * sizeof(*r->out.$e->{NAME}));\n";
+ pidl "memset(r->out.$e->{NAME}, 0, $size * sizeof(*r->out.$e->{NAME}));";
}
}
my($fn) = shift;
my $static = fn_prefix($fn);
+ return unless !util::has_property($fn, "nopull");
+
# pull function args
- pidl $static . "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)\n{\n";
+ pidl $static . "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)";
+ pidl "{";
+ indent;
# declare any internal pointers we need
foreach my $e (@{$fn->{ELEMENTS}}) {
if (need_wire_pointer($e)) {
- pidl "\tuint32_t _ptr_$e->{NAME};\n";
+ pidl "uint32_t _ptr_$e->{NAME};";
}
}
- pidl "\n\tif (!(flags & NDR_IN)) goto ndr_out;\n\n";
+ pidl "if (!(flags & NDR_IN)) goto ndr_out;";
+ pidl "";
# auto-init the out section of a structure. I originally argued that
# this was a bad idea as it hides bugs, but coping correctly
# out to be too tricky (tridge)
foreach my $e (@{$fn->{ELEMENTS}}) {
if (util::has_property($e, "out")) {
- pidl "\tZERO_STRUCT(r->out);\n\n";
+ pidl "ZERO_STRUCT(r->out);";
+ pidl "";
last;
}
}
}
}
- pidl "\nndr_out:\n";
- pidl "\tif (!(flags & NDR_OUT)) goto done;\n\n";
+ pidl "ndr_out:";
+ pidl "if (!(flags & NDR_OUT)) goto done;";
+ pidl "";
foreach my $e (@{$fn->{ELEMENTS}}) {
if (util::has_property($e, "out")) {
}
if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
- pidl "\tNDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, &r->out.result));\n";
+ pidl "NDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, &r->out.result));";
}
- pidl "\ndone:\n";
- pidl "\n\treturn NT_STATUS_OK;\n}\n\n";
+ pidl "done:";
+ pidl "";
+ pidl "return NT_STATUS_OK;";
+ deindent;
+ pidl "}";
+ pidl "";
}
#####################################################################
return if ($count == 0);
- pidl "static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {\n";
+ pidl "static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {";
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{";
+ pidl "\t\t\"$d->{NAME}\",";
+ pidl "\t\tsizeof(struct $d->{NAME}),";
+ pidl "\t\t(ndr_push_flags_fn_t) ndr_push_$d->{NAME},";
+ pidl "\t\t(ndr_pull_flags_fn_t) ndr_pull_$d->{NAME},";
+ pidl "\t\t(ndr_print_function_t) ndr_print_$d->{NAME}";
+ pidl "\t},";
}
}
- pidl "\t{ NULL, 0, NULL, NULL, NULL }\n};\n\n";
+ pidl "\t{ NULL, 0, NULL, NULL, NULL }";
+ pidl "};";
+ pidl "";
# If no endpoint is set, default to the interface name as a named pipe
if (! defined $interface->{PROPERTIES}->{endpoint}) {
my @e = split / /, $interface->{PROPERTIES}->{endpoint};
my $endpoint_count = $#e + 1;
- pidl "static const char * const $interface->{NAME}\_endpoint_strings[] = {\n";
+ pidl "static const char * const $interface->{NAME}\_endpoint_strings[] = {";
foreach my $ep (@e) {
- pidl "\t$ep, \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 "\tDCERPC_$uname\_HELPSTRING,\n";
- pidl "\t$count,\n";
- pidl "\t$interface->{NAME}\_calls,\n";
- pidl "\t&$interface->{NAME}\_endpoints\n";
- pidl "};\n\n";
-
- pidl "static NTSTATUS dcerpc_ndr_$interface->{NAME}_init(void)\n";
- pidl "{\n";
- pidl "\treturn librpc_register_interface(&dcerpc_table_$interface->{NAME});\n";
- pidl "}\n\n";
+ pidl "\t$ep, ";
+ }
+ pidl "};";
+ pidl "";
+
+ pidl "static const struct dcerpc_endpoint_list $interface->{NAME}\_endpoints = {";
+ pidl "\t.count\t= $endpoint_count,";
+ pidl "\t.names\t= $interface->{NAME}\_endpoint_strings";
+ pidl "};";
+ pidl "";
+
+ if (! defined $interface->{PROPERTIES}->{authservice}) {
+ $interface->{PROPERTIES}->{authservice} = "\"host\"";
+ }
+
+ my @a = split / /, $interface->{PROPERTIES}->{authservice};
+ my $authservice_count = $#a + 1;
+
+ pidl "static const char * const $interface->{NAME}\_authservice_strings[] = {";
+ foreach my $ap (@a) {
+ pidl "\t$ap, ";
+ }
+ pidl "};";
+ pidl "";
+
+ pidl "static const struct dcerpc_authservice_list $interface->{NAME}\_authservices = {";
+ pidl "\t.count\t= $endpoint_count,";
+ pidl "\t.names\t= $interface->{NAME}\_authservice_strings";
+ pidl "};";
+ pidl "";
+
+ pidl "\nconst struct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {";
+ pidl "\t.name\t\t= \"$interface->{NAME}\",";
+ pidl "\t.uuid\t\t= DCERPC_$uname\_UUID,";
+ pidl "\t.if_version\t= DCERPC_$uname\_VERSION,";
+ pidl "\t.helpstring\t= DCERPC_$uname\_HELPSTRING,";
+ pidl "\t.num_calls\t= $count,";
+ pidl "\t.calls\t\t= $interface->{NAME}\_calls,";
+ pidl "\t.endpoints\t= &$interface->{NAME}\_endpoints,";
+ pidl "\t.authservices\t= &$interface->{NAME}\_authservices";
+ pidl "};";
+ pidl "";
+
+ pidl "static NTSTATUS dcerpc_ndr_$interface->{NAME}_init(void)";
+ pidl "{";
+ pidl "\treturn librpc_register_interface(&dcerpc_table_$interface->{NAME});";
+ pidl "}";
+ pidl "";
}
#####################################################################
# Print functions
foreach my $d (@{$data}) {
- if ($d->{TYPE} eq "TYPEDEF" &&
- !util::has_property($d, "noprint")) {
+ ($d->{TYPE} eq "TYPEDEF") &&
ParseTypedefPrint($d);
- }
- if ($d->{TYPE} eq "FUNCTION" &&
- !util::has_property($d, "noprint")) {
+ ($d->{TYPE} eq "FUNCTION") &&
ParseFunctionPrint($d);
- }
}
# Size functions
$filename =~ /.*\/ndr_(.*).c/;
my $basename = $1;
- pidl "NTSTATUS dcerpc_$basename\_init(void)\n";
- pidl "{\n";
- pidl "\tNTSTATUS status = NT_STATUS_OK;\n";
+ pidl "NTSTATUS dcerpc_$basename\_init(void)";
+ pidl "{";
+ indent;
+ pidl "NTSTATUS status = NT_STATUS_OK;";
foreach my $interface (@{$idl}) {
next if $interface->{TYPE} ne "INTERFACE";
next if ($count == 0);
- pidl "\tstatus = dcerpc_ndr_$interface->{NAME}_init();\n";
- pidl "\tif (NT_STATUS_IS_ERR(status)) {\n";
- pidl "\t\treturn status;\n";
- pidl "\t}\n\n";
+ pidl "status = dcerpc_ndr_$interface->{NAME}_init();";
+ pidl "if (NT_STATUS_IS_ERR(status)) {";
+ pidl "\treturn status;";
+ pidl "}";
+ pidl "";
}
- pidl "\treturn status;\n";
- pidl "}\n\n";
+ pidl "return status;";
+ deindent;
+ pidl "}";
+ pidl "";
}
sub CheckPointerTypes($$)
foreach my $d (@{$x->{DATA}}) {
if (($d->{TYPE} eq "DECLARE") or ($d->{TYPE} eq "TYPEDEF")) {
- $typedefs{$d->{NAME}} = $d;
if ($d->{DATA}->{TYPE} eq "STRUCT" or $d->{DATA}->{TYPE} eq "UNION") {
CheckPointerTypes($d->{DATA}, $x->{PROPERTIES}->{pointer_default});
}
+
+ if (defined($d->{PROPERTIES}) && !defined($d->{DATA}->{PROPERTIES})) {
+ $d->{DATA}->{PROPERTIES} = $d->{PROPERTIES};
+ }
}
if ($d->{TYPE} eq "FUNCTION") {
CheckPointerTypes($d,
}
}
-# Add ORPC specific bits to an interface.
-sub InterfaceORPC($)
-{
- my $x = shift;
- # Add [in] ORPCTHIS *this, [out] ORPCTHAT *that
- # for 'object' interfaces
- if (util::has_property($x, "object")) {
- foreach my $e (@{$x->{DATA}}) {
- if($e->{TYPE} eq "FUNCTION") {
- $e->{PROPERTIES}->{object} = 1;
- unshift(@{$e->{ELEMENTS}},
- { 'NAME' => 'ORPCthis',
- 'POINTERS' => 0,
- 'PROPERTIES' => { 'in' => '1' },
- 'TYPE' => 'ORPCTHIS'
- });
- unshift(@{$e->{ELEMENTS}},
- { 'NAME' => 'ORPCthat',
- 'POINTERS' => 0,
- 'PROPERTIES' => { 'out' => '1' },
- 'TYPE' => 'ORPCTHAT'
- });
- }
- }
- }
-}
-
sub Load($)
{
my $idl = shift;
$h_filename = "$1.h";
}
- pidl "/* parser auto-generated by pidl */\n\n";
- pidl "#include \"includes.h\"\n";
- pidl "#include \"$h_filename\"\n\n";
+ pidl "/* parser auto-generated by pidl */";
+ pidl "";
+ pidl "#include \"includes.h\"";
+ pidl "#include \"$h_filename\"";
+ pidl "";
foreach my $x (@{$idl}) {
if ($x->{TYPE} eq "INTERFACE") {
return $res;
}
-RegisterPrimitives();
-
1;