r5852: Rename ndr.pm to ndr_parser.pm

I'm going to add a ndr.pm later on that'll generate a
tree with necessary information for the two NDR backends
(eparser, ndr_parser) containing alignment info, etc.
(This used to be commit 5162daa9464cd64930f5a8fd0d7b381b122c931d)

1 files changed, 2275 insertions, 0 deletions

diff --git a/source4/build/pidl/ndr_parser.pm b/source4/build/pidl/ndr_parser.pm
new file mode 100644
index 0000000000..fde9f05d2f
--- /dev/null
+++ b/source4/build/pidl/ndr_parser.pm
@@ -0,0 +1,2275 @@
+###################################################
+# Samba4 NDR parser generator for IDL structures
+# Copyright tridge@samba.org 2000-2003
+# Copyright tpot@samba.org 2001
+# Copyright jelmer@samba.org 2004-2005
+# released under the GNU GPL
+
+package NdrParser;
+
+use strict;
+use needed;
+use typelist;
+
+# list of known types
+my %typefamily;
+
+sub get_typefamily($)
+{
+	my $n = shift;
+	return $typefamily{$n};
+}
+
+my %scalar_alignments = 
+(
+     "char"           => 1,
+     "int8"           => 1,
+     "uint8"          => 1,
+     "short"          => 2,
+     "wchar_t"        => 2,
+     "int16"          => 2,
+     "uint16"         => 2,
+     "long"           => 4,
+     "int32"          => 4,
+     "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
+);
+
+$typefamily{SCALAR} = {
+	ALIGN => sub { 
+		my $t = shift;
+		return $scalar_alignments{$t->{NAME}}; 
+	}
+};
+
+sub is_scalar_type($)
+{
+    my $type = shift;
+
+	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 0;
+}
+
+sub pointer_type($)
+{
+	my $e = shift;
+
+	return undef unless $e->{POINTERS};
+	
+	return "ref" if (util::has_property($e, "ref"));
+	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;
+}
+
+# determine if an element needs a reference pointer on the wire
+# in its NDR representation
+sub need_wire_pointer($)
+{
+	my $e = shift;
+
+	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 needs a "buffers" section in NDR
+sub need_buffers_section($)
+{
+	my $e = shift;
+	if (!can_contain_deferred($e) &&
+	    !util::array_size($e)) {
+		return 0;
+	}
+	return 1;
+}
+
+# see if a variable needs to be allocated by the NDR subsystem on pull
+sub need_alloc($)
+{
+	my $e = shift;
+
+	return 0 if (util::has_property($e, "ref") && $e->{PARENT}->{TYPE} eq "FUNCTION");
+	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
+# types and normal pointers and '&' for pass-by-reference structures
+sub c_push_prefix($)
+{
+	my $e = shift;
+
+	my $ret = "";
+
+	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 "&";
+	}
+
+	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 ''
+sub c_pull_prefix($)
+{
+	my $e = shift;
+
+	if (!$e->{POINTERS} && !util::array_size($e)) {
+		return "&";
+	}
+
+	if ($e->{TYPE} =~ "string") {
+		return "&";
+	}
+
+	my $ret = "";
+	foreach my $i (2..$e->{POINTERS}) { $ret.="*"; }
+	return $ret;
+}
+my $res = "";
+my $tabs = "";
+sub pidl($)
+{
+	my $d = shift;
+	if ($d) {
+		$res .= $tabs;
+		$res .= $d;
+	}
+	$res .="\n";
+}
+
+sub indent()
+{
+	$tabs .= "\t";
+}
+
+sub deindent()
+{
+	$tabs = substr($tabs, 0, -1);
+}
+
+####################################################################
+# work out the name of a size_is() variable
+sub ParseExpr($$$)
+{
+	my($e) = shift;
+	my($size) = shift;
+	my($var_prefix) = shift;
+
+	my($fn) = $e->{PARENT};
+
+	return $size if (util::is_constant($size));
+
+	return $size if ($size =~ /ndr->|\(/);
+
+	my $prefix = "";
+
+	if ($size =~ /\*(.*)/) {
+		$size = $1;
+		$prefix = "*";
+	}
+
+	if ($fn->{TYPE} ne "FUNCTION") {
+		return $prefix . "r->$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";
+	}
+
+	die "invalid variable in $size for element $e->{NAME} in $fn->{NAME}\n";
+}
+
+#####################################################################
+# check that a variable we get from ParseExpr isn't a null pointer
+sub check_null_pointer($)
+{
+	my $size = shift;
+	if ($size =~ /^\*/) {
+		my $size2 = substr($size, 1);
+		pidl "if ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;";
+	}
+}
+
+#####################################################################
+# check that a variable we get from ParseExpr isn't a null pointer
+# void return varient
+sub check_null_pointer_void($)
+{
+	my $size = shift;
+	if ($size =~ /^\*/) {
+		my $size2 = substr($size, 1);
+		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" 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 "{ uint32_t _flags_save_$e->{TYPE} = ndr->flags;";
+		pidl "ndr_set_flags(&ndr->flags, $flags);";
+	}
+}
+
+###################################################################
+# 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 "ndr->flags = _flags_save_$e->{TYPE};\n\t}";
+	}
+}
+
+#####################################################################
+# work out the correct alignment for a structure or union
+sub find_largest_alignment($)
+{
+	my $s = shift;
+
+	my $align = 1;
+	for my $e (@{$s->{ELEMENTS}}) {
+		my $a = 1;
+
+		if (need_wire_pointer($e)) {
+			$a = 4; 
+		} else { 
+			$a = align_type($e->{TYPE}); 
+		}
+
+		$align = $a if ($align < $a);
+	}
+
+	return $align;
+}
+
+#####################################################################
+# align a type
+sub align_type
+{
+	my $e = shift;
+
+	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 = typelist::getType($e)->{DATA};
+
+	my $tmp = $typefamily{$dt->{TYPE}}->{ALIGN}->($dt);
+	return $tmp;
+}
+
+#####################################################################
+# see if a type contains any deferred data 
+sub can_contain_deferred
+{
+	my $e = shift;
+
+	return 1 if ($e->{POINTERS});
+	return 0 if (is_scalar_type($e->{TYPE}));
+	return 0 if (util::has_property($e, "subcontext"));
+	return 1 unless (typelist::hasType($e->{TYPE})); # assume the worst
+
+	my $type = typelist::getType($e->{TYPE});
+
+	foreach my $x (@{$type->{DATA}->{ELEMENTS}}) {
+		return 1 if (can_contain_deferred ($x));
+	}
+	
+	return 0;
+}
+
+#####################################################################
+# parse array preceding data - push side
+sub ParseArrayPushPreceding($$$)
+{
+	my $e = shift;
+	my $var_prefix = shift;
+	my $ndr_flags = shift;
+
+	my $size = ParseExpr($e, util::array_size($e), $var_prefix);
+
+	if (!is_inline_array($e)) {
+		# we need to emit the array size
+		pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $size));";
+	}
+}
+
+#####################################################################
+# 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);
+
+	# See whether the array size has been pushed yet
+	if (!is_surrounding_array($e)) {
+		ParseArrayPushPreceding($e, $var_prefix, $ndr_flags);
+	}
+	
+	if (is_varying_array($e)) {
+		my $length = util::has_property($e, "length_is");
+		$length = ParseExpr($e, $length, $var_prefix);
+		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 "NDR_CHECK(ndr_push_array_$e->{TYPE}($ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}, $size));";
+	} else {
+		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}));";
+	}
+}
+
+#####################################################################
+# print an array
+sub ParseArrayPrint($$)
+{
+	my $e = shift;
+	my $var_prefix = shift;
+	my $size = ParseExpr($e, util::array_size($e), $var_prefix);
+	my $cprefix = c_push_prefix($e);
+
+	if (is_varying_array($e)) {
+		$size = ParseExpr($e, util::has_property($e, "length_is"), $var_prefix);
+	}
+
+	if (is_scalar_type($e->{TYPE})) {
+		pidl "ndr_print_array_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME}, $size);";
+	} else {
+		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});";
+	}
+}
+
+#####################################################################
+# check the size_is and length_is constraints
+sub CheckArraySizes($$)
+{
+	my $e = shift;
+	my $var_prefix = shift;
+
+	if (is_conformant_array($e)) {
+		my $size = ParseExpr($e, util::array_size($e), $var_prefix);
+		pidl "if ($var_prefix$e->{NAME}) {";
+		indent;
+		check_null_pointer($size);
+		pidl "NDR_CHECK(ndr_check_array_size(ndr, (void*)&$var_prefix$e->{NAME}, $size));";
+		deindent;
+		pidl "}";
+	}
+
+	if (is_varying_array($e)) {
+		my $length = util::has_property($e, "length_is");
+		$length = ParseExpr($e, $length, $var_prefix);
+		pidl "if ($var_prefix$e->{NAME}) {";
+		indent;
+		check_null_pointer($length);
+		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($$$$)
+{
+	my $e = shift;
+	my $ndr = shift;
+	my $var_prefix = shift;
+	my $ndr_flags = shift;
+
+	my $cprefix = c_pull_prefix($e);
+	my $length = ParseExpr($e, util::array_size($e), $var_prefix);
+	my $size = $length;
+
+	if (is_conformant_array($e)) {
+		$length = $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 (!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); }";
+		}
+
+		ParseArrayPullPreceding($e, $var_prefix, $ndr_flags);
+	}
+
+	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 (!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 (!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 (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}));";
+	}
+}
+
+sub ParseSubcontextPushStart($$)
+{
+	my $e = shift;
+	my $ndr_flags = shift;
+
+	pidl "if (($ndr_flags) & NDR_SCALARS) {";
+	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 $header_size = util::has_property($e, "subcontext");
+	my $size_is = util::has_property($e, "subcontext_size");
+
+	if (not defined($size_is)) {
+		$size_is = "-1";
+	}
+
+	pidl "NDR_CHECK(ndr_push_subcontext_header(ndr, $header_size, $size_is, _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 $ndr_flags = shift;	
+	my $header_size = util::has_property($e, "subcontext");
+	my $size_is = util::has_property($e, "subcontext_size");
+
+	if (not defined($size_is)) {
+		$size_is = "-1";
+	}
+
+	pidl "if (($ndr_flags) & NDR_SCALARS) {";
+	indent;
+	pidl "struct ndr_pull *_ndr_$e->{NAME};";
+	pidl "NDR_ALLOC(ndr, _ndr_$e->{NAME});";
+	pidl "NDR_CHECK(ndr_pull_subcontext_header(ndr, $header_size, $size_is, _ndr_$e->{NAME}));"; 
+	return "_ndr_$e->{NAME}";
+}
+
+sub ParseSubcontextPullEnd($)
+{
+	my $e = shift;
+	my $header_size = util::has_property($e, "subcontext");
+	my $size_is = util::has_property($e, "subcontext_size");
+
+	my $advance;
+	if (defined ($size_is)) {
+		$advance = "$size_is";	
+	} elsif ($header_size) {
+		$advance = "_ndr_$e->{NAME}->data_size";
+	} else {
+		$advance = "_ndr_$e->{NAME}->offset";
+	}
+	pidl "NDR_CHECK(ndr_pull_advance(ndr, $advance));";
+	deindent;
+	pidl "}";
+}
+
+#####################################################################
+# parse scalars in a structure element
+sub ParseElementPushScalar($$$)
+{
+	my($e) = shift;
+	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 "$cprefix$var_prefix$e->{NAME} = $value;";
+	}
+
+	if (defined $sub_size and $e->{POINTERS} == 0) {
+		$ndr = ParseSubcontextPushStart($e, "NDR_SCALARS");
+	}
+
+	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
+	} else {
+		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);
+}
+
+#####################################################################
+# parse a pointer in a struct element or function
+sub ParsePtrPush($$)
+{
+	my $e = shift;
+	my $var_prefix = shift;
+
+	if (util::has_property($e, "ref")) {
+		pidl "NDR_CHECK(ndr_push_ref_ptr(ndr, $var_prefix$e->{NAME}));";
+	} elsif (util::has_property($e, "relative")) {
+		pidl "NDR_CHECK(ndr_push_relative_ptr1(ndr, $var_prefix$e->{NAME}));";
+	} else {
+		pidl "NDR_CHECK(ndr_push_unique_ptr(ndr, $var_prefix$e->{NAME}));";
+	}
+}
+
+#####################################################################
+# print scalars in a structure element
+sub ParseElementPrint($$)
+{
+	my($e) = shift;
+	my($var_prefix) = shift;
+	my $cprefix = c_push_prefix($e);
+	my $ptr_prefix = c_ptr_prefix($e);
+
+	return if (util::has_property($e, "noprint"));
+
+	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 "}";
+	}
+
+	my $l = $e->{POINTERS};
+	$l++ if (util::array_size($e) and $l == 0 and !is_fixed_array($e));
+
+	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;
+		}
+	}
+
+	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 "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--;";
+	}
+}
+
+#####################################################################
+# 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_pull_prefix($e);
+
+	my $utype = typelist::getType($e->{TYPE});
+
+	check_null_pointer($switch_var);
+
+	pidl "NDR_CHECK(ndr_pull_set_switch_value($ndr, $cprefix$var_prefix$e->{NAME}, $switch_var));";
+
+}
+
+#####################################################################
+# 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($switch_var);
+
+	pidl "NDR_CHECK(ndr_push_set_switch_value($ndr, $cprefix$var_prefix$e->{NAME}, $switch_var));";
+
+}
+
+#####################################################################
+# parse scalars in a structure element - pull size
+sub ParseElementPullScalar($$$)
+{
+	my($e) = shift;
+	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 (defined $sub_size && $e->{POINTERS} == 0) {
+		$ndr = ParseSubcontextPullStart($e, $ndr_flags);
+		$ndr_flags = "NDR_SCALARS|NDR_BUFFERS";
+	}
+
+	if (is_inline_array($e)) {
+		ParseArrayPull($e, $ndr, "r->", "NDR_SCALARS");
+	} elsif (need_wire_pointer($e)) {
+		ParsePtrPull($e, $ptr_prefix.$var_prefix);
+	} elsif (is_surrounding_array($e)) {
+	} else {
+		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 "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;
+
+	if (util::has_property($e, "ref")) {
+		pidl "NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_$e->{NAME}));";
+	} else {
+		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($$)
+{
+	my($e) = shift;
+	my($var_prefix) = shift;
+	my $cprefix = c_push_prefix($e);
+	my $sub_size = util::has_property($e, "subcontext");
+	my $ndr = "ndr";
+
+	return unless (need_buffers_section($e));
+
+	start_flags($e);
+
+	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::has_property($e, "relative")) {
+		pidl "NDR_CHECK(ndr_push_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 (defined $sub_size) {
+		$ndr = ParseSubcontextPushStart($e, $ndr_flags);
+		$ndr_flags = "NDR_SCALARS|NDR_BUFFERS";
+	}
+
+	if (util::array_size($e)) {
+		ParseArrayPush($e, $ndr, "r->", $ndr_flags);
+	} else {
+		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) {
+		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($$)
+{
+	my($e) = shift;
+	my($var_prefix) = shift;
+	my $cprefix = c_pull_prefix($e);
+	my $sub_size = util::has_property($e, "subcontext");
+	my $ndr = "ndr";
+
+	return unless (need_buffers_section($e));
+
+	start_flags($e);
+
+ 	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 (defined $sub_size) {
+		$ndr = ParseSubcontextPullStart($e, $ndr_flags);
+		$ndr_flags = "NDR_SCALARS|NDR_BUFFERS";
+	}
+
+	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 "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);
+}
+
+#####################################################################
+# parse a struct
+sub ParseStructPush($)
+{
+	my($struct) = shift;
+	
+	return unless defined($struct->{ELEMENTS});
+
+	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 (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 "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_string_array_size(ndr, r->$e->{NAME})));";
+	}
+
+	pidl "if (!(ndr_flags & NDR_SCALARS)) goto buffers;";
+
+	pidl "NDR_CHECK(ndr_push_struct_start(ndr));";
+
+	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:";
+	pidl "if (!(ndr_flags & NDR_BUFFERS)) goto done;";
+	foreach my $e (@{$struct->{ELEMENTS}}) {
+		ParseElementPushBuffer($e, "r->");
+	}
+
+	pidl "ndr_push_struct_end(ndr);";
+
+	pidl "done:";
+
+	end_flags($struct);
+}
+
+#####################################################################
+# generate a push function for an enum
+sub ParseEnumPush($)
+{
+	my($enum) = shift;
+	my($type_fn) = typelist::enum_type_fn($enum);
+
+	start_flags($enum);
+
+	pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));";
+
+	end_flags($enum);
+}
+
+#####################################################################
+# generate a pull function for an enum
+sub ParseEnumPull($)
+{
+	my($enum) = shift;
+	my($type_fn) = typelist::enum_type_fn($enum);
+	my($type_v_decl) = typelist::mapScalarType(typelist::enum_type_fn($enum));
+
+	pidl "$type_v_decl v;";
+	start_flags($enum);
+	pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));";
+	pidl "*r = v;";
+
+	end_flags($enum);
+}
+
+#####################################################################
+# generate a print function for an enum
+sub ParseEnumPrint($)
+{
+	my($enum) = shift;
+
+	pidl "const char *val = NULL;";
+	pidl "";
+
+	start_flags($enum);
+
+	pidl "switch (r) {";
+	indent;
+	my $els = \@{$enum->{ELEMENTS}};
+	foreach my $i (0 .. $#{$els}) {
+		my $e = ${$els}[$i];
+		chomp $e;
+		if ($e =~ /^(.*)=/) {
+			$e = $1;
+		}
+		pidl "case $e: val = \"$e\"; break;";
+	}
+
+	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) = typelist::bitmap_type_fn($bitmap);
+
+	start_flags($bitmap);
+
+	pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));";
+
+	end_flags($bitmap);
+}
+
+#####################################################################
+# generate a pull function for an bitmap
+sub ParseBitmapPull($)
+{
+	my($bitmap) = shift;
+	my($type_fn) = typelist::bitmap_type_fn($bitmap);
+	my($type_decl) = typelist::mapType($bitmap);
+
+	pidl "$type_decl v;";
+	start_flags($bitmap);
+	pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));";
+	pidl "*r = v;";
+
+	end_flags($bitmap);
+}
+
+#####################################################################
+# generate a print function for an bitmap
+sub ParseBitmapPrintElement($$)
+{
+	my($e) = shift;
+	my($bitmap) = shift;
+	my($type_decl) = typelist::mapType($bitmap);
+	my($type_fn) = typelist::bitmap_type_fn($bitmap);
+	my($name) = $bitmap->{PARENT}->{NAME};
+	my($flag);
+
+	if ($e =~ /^(\w+) .*$/) {
+		$flag = "$1";
+	} else {
+		die "Bitmap: \"$name\" invalid Flag: \"$e\"";
+	}
+
+	pidl "ndr_print_bitmap_flag(ndr, sizeof($type_decl), \"$flag\", $flag, r);";
+}
+
+#####################################################################
+# generate a print function for an bitmap
+sub ParseBitmapPrint($)
+{
+	my($bitmap) = shift;
+	my($type_decl) = typelist::mapType($bitmap);
+	my($type_fn) = typelist::bitmap_type_fn($bitmap);
+
+	start_flags($bitmap);
+
+	pidl "ndr_print_$type_fn(ndr, name, r);";
+
+	pidl "ndr->depth++;";
+	foreach my $e (@{$bitmap->{ELEMENTS}}) {
+		ParseBitmapPrintElement($e, $bitmap);
+	}
+	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};
+
+	return unless defined $struct->{ELEMENTS};
+
+	pidl "ndr_print_struct(ndr, name, \"$name\");";
+
+	start_flags($struct);
+
+	pidl "ndr->depth++;";
+	foreach my $e (@{$struct->{ELEMENTS}}) {
+		ParseElementPrint($e, "r->");
+	}
+	pidl "ndr->depth--;";
+
+	end_flags($struct);
+}
+
+#####################################################################
+# parse a struct - pull side
+sub ParseStructPull($)
+{
+	my($struct) = shift;
+	my $conform_e;
+
+	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
+	# 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 (is_conformant_array($e) and is_surrounding_array($e)) {
+		$conform_e = $e;
+	}
+
+	if (defined $e->{TYPE} && $e->{TYPE} eq "string"
+	    &&  util::property_matches($e, "flag", ".*LIBNDR_FLAG_STR_CONFORMANT.*")) {
+		$conform_e = $e;
+	}
+
+	# declare any internal pointers we need
+	foreach my $e (@{$struct->{ELEMENTS}}) {
+		if (need_wire_pointer($e)) {
+			pidl "uint32_t _ptr_$e->{NAME};";
+		}
+	}
+
+	start_flags($struct);
+
+	pidl "if (!(ndr_flags & NDR_SCALARS)) goto buffers;";
+
+	pidl "NDR_CHECK(ndr_pull_struct_start(ndr));";
+
+	if (defined $conform_e) {
+		ParseArrayPullPreceding($conform_e, "r->", "NDR_SCALARS");
+	}
+
+	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 "if (!(ndr_flags & NDR_BUFFERS)) goto done;";
+	foreach my $e (@{$struct->{ELEMENTS}}) {
+		ParseElementPullBuffer($e, "r->");
+	}
+
+	foreach my $e (@{$struct->{ELEMENTS}}) {
+		CheckArraySizes($e, "r->");
+	}
+
+	pidl "ndr_pull_struct_end(ndr);";
+
+	pidl "done:";
+
+	end_flags($struct);
+}
+
+#####################################################################
+# calculate size of ndr struct
+sub ParseStructNdrSize($)
+{
+	my $t = shift;
+	my $static = fn_prefix($t);
+	my $sizevar;
+
+	if (my $flags = util::has_property($t, "flag")) {
+		pidl "flags |= $flags;";
+	}
+	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 $t = shift;
+	my $static = fn_prefix($t);
+	my $sizevar;
+
+	if (my $flags = util::has_property($t, "flag")) {
+		pidl "flags |= $flags;";
+	}
+	pidl "return ndr_size_union(r, flags, level, (ndr_push_union_fn_t)ndr_push_$t->{NAME});";
+}
+
+#####################################################################
+# parse a union - push side
+sub ParseUnionPush($)
+{
+	my $e = shift;
+	my $have_default = 0;
+
+	pidl "int level;";
+
+	start_flags($e);
+
+	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 "NDR_CHECK(ndr_push_struct_start(ndr));";
+
+#	my $align = union_alignment($e);
+#	pidl "NDR_CHECK(ndr_push_align(ndr, $align));";
+
+	pidl "switch (level) {";
+	indent;
+	foreach my $el (@{$e->{ELEMENTS}}) {
+		if (util::has_property($el, "default")) {
+			pidl "default:";
+			$have_default = 1;
+		} else {
+			pidl "case $el->{PROPERTIES}->{case}:";
+
+		}
+		if ($el->{TYPE} ne "EMPTY") {
+			indent;
+			ParseElementPushScalar($el, "r->", "NDR_SCALARS");
+			deindent;
+		}
+		pidl "break;";
+		pidl "";
+	}
+	if (! $have_default) {
+		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 "default:";
+		} else {
+			pidl "case $el->{PROPERTIES}->{case}:";
+		}
+		if ($el->{TYPE} ne "EMPTY") {
+			indent;
+			ParseElementPushBuffer($el, "r->");
+			deindent;
+		}
+		pidl "break;";
+		pidl "";
+	}
+	if (! $have_default) {
+		pidl "default:";
+		pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
+	}
+	deindent;
+	pidl "}";
+	pidl "ndr_push_struct_end(ndr);";
+	pidl "done:";
+	end_flags($e);
+}
+
+#####################################################################
+# print a union
+sub ParseUnionPrint($)
+{
+	my $e = shift;
+	my $have_default = 0;
+	my($name) = $e->{PARENT}->{NAME};
+
+	pidl "ndr_print_union(ndr, name, level, \"$name\");";
+	start_flags($e);
+
+	pidl "switch (level) {";
+	indent;
+	foreach my $el (@{$e->{ELEMENTS}}) {
+		if (util::has_property($el, "default")) {
+			$have_default = 1;
+			pidl "default:";
+		} else {
+			pidl "case $el->{PROPERTIES}->{case}:";
+		}
+		if ($el->{TYPE} ne "EMPTY") {
+			indent;
+			ParseElementPrint($el, "r->");
+			deindent;
+		}
+		pidl "break;";
+		pidl "";
+	}
+	if (! $have_default) {
+		pidl "default:";
+		pidl "\tndr_print_bad_level(ndr, name, level);";
+	}
+	deindent;
+	pidl "}";
+
+	end_flags($e);
+}
+
+#####################################################################
+# parse a union - pull side
+sub ParseUnionPull($)
+{
+	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 "level = ndr_pull_get_switch_value(ndr, r);";
+
+	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 "switch (level) {";
+	indent;
+	foreach my $el (@{$e->{ELEMENTS}}) {
+		if (util::has_property($el, "default")) {
+			pidl "default: {";
+			$have_default = 1;
+		} else {
+			pidl "case $el->{PROPERTIES}->{case}: {";
+		}
+		if ($el->{TYPE} ne "EMPTY") {
+			indent;
+			if ($el->{POINTERS}) {
+				pidl "uint32_t _ptr_$el->{NAME};";
+			}
+			ParseElementPullScalar($el, "r->", "NDR_SCALARS");
+			deindent;
+		}
+		pidl "break; }";
+		pidl "";
+	}
+	if (! $have_default) {
+		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 "default:";
+		} else {
+			pidl "case $el->{PROPERTIES}->{case}:";
+		}
+		if ($el->{TYPE} ne "EMPTY") {
+			indent;
+			ParseElementPullBuffer($el, "r->");
+			deindent;
+		}
+		pidl "break;";
+		pidl "";
+	}
+	if (! $have_default) {
+		pidl "default:";
+		pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
+	}
+	deindent;
+	pidl "}";
+	pidl "ndr_pull_struct_end(ndr);";
+	pidl "done:";
+	end_flags($e);
+}
+
+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
+sub ParseTypedefPush($)
+{
+	my($e) = shift;
+	my $static = fn_prefix($e);
+
+	return unless needed::is_needed("push_$e->{NAME}");
+
+	my $args = $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_ARGS}->($e);
+	pidl $static . "NTSTATUS ndr_push_$e->{NAME}($args)";
+
+	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);
+
+	return unless needed::is_needed("pull_$e->{NAME}");
+
+	my $args = $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_ARGS}->($e);
+
+	pidl $static . "NTSTATUS ndr_pull_$e->{NAME}($args)";
+
+	pidl "{";
+	indent;
+	$typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($e->{DATA});
+	pidl "return NT_STATUS_OK;";
+	deindent;
+	pidl "}";
+	pidl "";
+}
+
+#####################################################################
+# parse a typedef - print side
+sub ParseTypedefPrint($)
+{
+	my($e) = shift;
+
+	my $args = $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_ARGS}->($e);
+
+	return unless !util::has_property($e, "noprint");
+
+	pidl "void ndr_print_$e->{NAME}($args)";
+	pidl "{";
+	indent;
+	$typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($e->{DATA});
+	deindent;
+	pidl "}";
+}
+
+#####################################################################
+## calculate the size of a structure
+sub ParseTypedefNdrSize($)
+{
+	my($t) = shift;
+
+	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 "";
+}
+
+#####################################################################
+# parse a function - print side
+sub ParseFunctionPrint($)
+{
+	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 "{";
+	indent;
+	pidl "ndr_print_struct(ndr, name, \"$fn->{NAME}\");";
+	pidl "ndr->depth++;";
+
+	pidl "if (flags & NDR_SET_VALUES) {";
+	pidl "\tndr->flags |= LIBNDR_PRINT_SET_VALUES;";
+	pidl "}";
+
+	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")) {
+			ParseElementPrint($e, "r->in.");
+		}
+	}
+	pidl "ndr->depth--;";
+	deindent;
+	pidl "}";
+	
+	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")) {
+			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 "ndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", $cprefix"."r->out.result);";
+	}
+	pidl "ndr->depth--;";
+	deindent;
+	pidl "}";
+	
+	pidl "ndr->depth--;";
+	deindent;
+	pidl "}";
+	pidl "";
+}
+
+#####################################################################
+# parse a function element
+sub ParseFunctionElementPush($$)
+{ 
+	my $e = shift;
+	my $inout = shift;
+
+	if (util::array_size($e)) {
+		if (need_wire_pointer($e)) {
+			ParsePtrPush($e, "r->$inout.");
+			pidl "if (r->$inout.$e->{NAME}) {";
+			indent;
+			ParseArrayPush($e, "ndr", "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
+			deindent;
+			pidl "}";
+		} else {
+			ParseArrayPush($e, "ndr", "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
+		}
+	} else {
+		ParseElementPushScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
+		if (need_wire_pointer($e)) {
+			ParseElementPushBuffer($e, "r->$inout.");
+		}
+	}
+}	
+
+#####################################################################
+# parse a function
+sub ParseFunctionPush($)
+{ 
+	my($fn) = shift;
+	my $static = fn_prefix($fn);
+
+	return unless !util::has_property($fn, "nopush");
+
+	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")) {
+			if (util::has_property($e, "ref")) {
+				check_null_pointer("*r->in.$e->{NAME}");
+			} 
+			ParseFunctionElementPush($e, "in");
+		}		
+	}
+
+	pidl "ndr_out:";
+	pidl "if (!(flags & NDR_OUT)) goto done;";
+	pidl "";
+
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		if (util::has_property($e, "out")) {
+			if (util::has_property($e, "ref")) {
+				check_null_pointer("*r->out.$e->{NAME}");
+			} 
+			ParseFunctionElementPush($e, "out");
+		}		
+	}
+
+	if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
+		pidl "NDR_CHECK(ndr_push_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, r->out.result));";
+	}
+    
+	pidl "done:";
+	pidl "return NT_STATUS_OK;";
+	deindent;
+	pidl "}";
+	pidl "";
+}
+
+#####################################################################
+# parse a function element
+sub ParseFunctionElementPull($$)
+{ 
+	my $e = shift;
+	my $inout = shift;
+
+	if (util::array_size($e)) {
+		if (need_wire_pointer($e)) {
+			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 "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 "}";
+		}
+	} else {
+		if ($inout eq "out" && util::has_property($e, "ref")) {
+			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 "NDR_ALLOC(ndr, r->in.$e->{NAME});";
+		}
+
+		ParseElementPullScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
+		if (need_wire_pointer($e)) {
+			ParseElementPullBuffer($e, "r->$inout.");
+		}
+	}
+}
+
+############################################################
+# 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 "NDR_ALLOC(ndr, r->out.$e->{NAME});";
+		if (util::has_property($e, "in")) {
+			pidl "*r->out.$e->{NAME} = *r->in.$e->{NAME};";
+		} else {
+			pidl "ZERO_STRUCTP(r->out.$e->{NAME});";
+		}
+		return;
+	}
+
+	# its an array
+	my $size = ParseExpr($e, $asize, "r->out.");
+	check_null_pointer($size);
+	pidl "NDR_ALLOC_N(ndr, r->out.$e->{NAME}, $size);";
+	if (util::has_property($e, "in")) {
+		pidl "memcpy(r->out.$e->{NAME},r->in.$e->{NAME},$size * sizeof(*r->in.$e->{NAME}));";
+	} else {
+		pidl "memset(r->out.$e->{NAME}, 0, $size * sizeof(*r->out.$e->{NAME}));";
+	}
+}
+
+#####################################################################
+# parse a function
+sub ParseFunctionPull($)
+{ 
+	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)";
+	pidl "{";
+	indent;
+
+	# declare any internal pointers we need
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		if (need_wire_pointer($e)) {
+			pidl "uint32_t _ptr_$e->{NAME};";
+		}
+	}
+
+	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
+	# with initialisation and not wiping ref vars is turning
+	# out to be too tricky (tridge)
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		if (util::has_property($e, "out")) {
+			pidl "ZERO_STRUCT(r->out);";
+			pidl "";
+			last;
+		}
+	}
+
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		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);
+		}
+	}
+
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		if (util::has_property($e, "in")) {
+			CheckArraySizes($e, "r->in.");
+		}
+	}
+
+	pidl "ndr_out:";
+	pidl "if (!(flags & NDR_OUT)) goto done;";
+	pidl "";
+
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		if (util::has_property($e, "out")) {
+			ParseFunctionElementPull($e, "out");
+		}
+	}
+
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		if (util::has_property($e, "out")) {
+			CheckArraySizes($e, "r->out.");
+		}
+	}
+
+	if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
+		pidl "NDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, &r->out.result));";
+	}
+
+	pidl "done:";
+	pidl "";
+	pidl "return NT_STATUS_OK;";
+	deindent;
+	pidl "}";
+	pidl "";
+}
+
+#####################################################################
+# produce a function call table
+sub FunctionTable($)
+{
+	my($interface) = shift;
+	my($data) = $interface->{INHERITED_DATA};
+	my $count = 0;
+	my $uname = uc $interface->{NAME};
+
+	foreach my $d (@{$data}) {
+		if ($d->{TYPE} eq "FUNCTION") { $count++; }
+	}
+
+	return if ($count == 0);
+
+	pidl "static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {";
+	foreach my $d (@{$data}) {
+		if ($d->{TYPE} eq "FUNCTION") {
+			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 }";
+	pidl "};";
+	pidl "";
+
+	# If no endpoint is set, default to the interface name as a named pipe
+	if (! defined $interface->{PROPERTIES}->{endpoint}) {
+		$interface->{PROPERTIES}->{endpoint} = "\"ncacn_np:[\\\\pipe\\\\" . $interface->{NAME} . "]\"";
+	}
+
+	my @e = split / /, $interface->{PROPERTIES}->{endpoint};
+	my $endpoint_count = $#e + 1;
+
+	pidl "static const char * const $interface->{NAME}\_endpoint_strings[] = {";
+	foreach my $ep (@e) {
+		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 "";
+}
+
+#####################################################################
+# parse the interface definitions
+sub ParseInterface($)
+{
+	my($interface) = shift;
+	my($data) = $interface->{DATA};
+
+	# Push functions
+	foreach my $d (@{$data}) {
+		($d->{TYPE} eq "TYPEDEF") &&
+		    ParseTypedefPush($d);
+		($d->{TYPE} eq "FUNCTION") && 
+		    ParseFunctionPush($d);
+	}
+
+	# Pull functions
+	foreach my $d (@{$data}) {
+		($d->{TYPE} eq "TYPEDEF") &&
+		    ParseTypedefPull($d);
+		($d->{TYPE} eq "FUNCTION") && 
+		    ParseFunctionPull($d);
+	}
+	
+	# Print functions
+	foreach my $d (@{$data}) {
+		($d->{TYPE} eq "TYPEDEF") &&
+			ParseTypedefPrint($d);
+		($d->{TYPE} eq "FUNCTION") &&
+			ParseFunctionPrint($d);
+	}
+
+	# Size functions
+	foreach my $d (@{$data}) {
+		($d->{TYPE} eq "TYPEDEF") && 
+			ParseTypedefNdrSize($d);
+	}
+
+	FunctionTable($interface);
+}
+
+sub RegistrationFunction($$)
+{
+	my $idl = shift;
+	my $filename = shift;
+
+	$filename =~ /.*\/ndr_(.*).c/;
+	my $basename = $1;
+	pidl "NTSTATUS dcerpc_$basename\_init(void)";
+	pidl "{";
+	indent;
+	pidl "NTSTATUS status = NT_STATUS_OK;";
+	foreach my $interface (@{$idl}) {
+		next if $interface->{TYPE} ne "INTERFACE";
+
+		my $data = $interface->{INHERITED_DATA};
+		my $count = 0;
+		foreach my $d (@{$data}) {
+			if ($d->{TYPE} eq "FUNCTION") { $count++; }
+		}
+
+		next if ($count == 0);
+
+		pidl "status = dcerpc_ndr_$interface->{NAME}_init();";
+		pidl "if (NT_STATUS_IS_ERR(status)) {";
+		pidl "\treturn status;";
+		pidl "}";
+		pidl "";
+	}
+	pidl "return status;";
+	deindent;
+	pidl "}";
+	pidl "";
+}
+
+sub CheckPointerTypes($$)
+{
+	my $s = shift;
+	my $default = shift;
+
+	foreach my $e (@{$s->{ELEMENTS}}) {
+		if ($e->{POINTERS}) {
+			if (not defined(pointer_type($e))) {
+				$e->{PROPERTIES}->{$default} = 1;
+			}
+
+			if (pointer_type($e) eq "ptr") {
+				print "Warning: ptr is not supported by pidl yet\n";
+			}
+		}
+	}
+}
+
+sub LoadInterface($)
+{
+	my $x = shift;
+
+	if (not util::has_property($x, "pointer_default")) {
+		# MIDL defaults to "ptr" in DCE compatible mode (/osf)
+		# and "unique" in Microsoft Extensions mode (default)
+		$x->{PROPERTIES}->{pointer_default} = "unique";
+	}
+
+	foreach my $d (@{$x->{DATA}}) {
+		if (($d->{TYPE} eq "DECLARE") or ($d->{TYPE} eq "TYPEDEF")) {
+			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, 
+				$x->{PROPERTIES}->{pointer_default}  # MIDL defaults to "ref"
+			);
+		}
+	}
+}
+
+sub Load($)
+{
+	my $idl = shift;
+
+	foreach my $x (@{$idl}) {
+		LoadInterface($x);
+	}
+}
+
+#####################################################################
+# parse a parsed IDL structure back into an IDL file
+sub Parse($$)
+{
+	my($idl) = shift;
+	my($filename) = shift;
+	my $h_filename = $filename;
+	$res = "";
+
+	Load($idl);
+
+	if ($h_filename =~ /(.*)\.c/) {
+		$h_filename = "$1.h";
+	}
+
+	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") { 
+			needed::BuildNeeded($x);
+			ParseInterface($x);
+		}
+	}
+
+	RegistrationFunction($idl, $filename);
+
+	return $res;
+}
+
+1;