r9460: - Move pidl to lib/. This fixes standalone installation of pidl.

- Update the README
- Allow building the docs stand-alone
(This used to be commit b56084ce251ab7a35dd1422f38de258e8e1e1477)

24 files changed, 11123 insertions, 0 deletions

diff --git a/source4/pidl/lib/Parse/Pidl.pm b/source4/pidl/lib/Parse/Pidl.pm
new file mode 100644
index 0000000000..465f3409ad
--- /dev/null
+++ b/source4/pidl/lib/Parse/Pidl.pm
@@ -0,0 +1,16 @@
+###################################################
+# package to parse IDL files and generate code for
+# rpc functions in Samba
+# Copyright tridge@samba.org 2000-2003
+# Copyright jelmer@samba.org 2005
+# released under the GNU GPL
+
+package Parse::Pidl;
+
+use strict;
+
+use vars qw ( $VERSION );
+
+$VERSION = '0.01';
+
+1;
diff --git a/source4/pidl/lib/Parse/Pidl/Compat.pm b/source4/pidl/lib/Parse/Pidl/Compat.pm
new file mode 100644
index 0000000000..39cb67fd71
--- /dev/null
+++ b/source4/pidl/lib/Parse/Pidl/Compat.pm
@@ -0,0 +1,203 @@
+###################################################
+# IDL Compatibility checker
+# Copyright jelmer@samba.org 2005
+# released under the GNU GPL
+
+package Parse::Pidl::Compat;
+
+use Parse::Pidl::Util qw(has_property);
+use strict;
+
+my %supported_properties = (
+	# interface
+	"helpstring"		=> ["INTERFACE", "FUNCTION"],
+	"version"		=> ["INTERFACE"],
+	"uuid"			=> ["INTERFACE"],
+	"endpoint"		=> ["INTERFACE"],
+	"pointer_default"	=> ["INTERFACE"],
+
+	# dcom
+	"object"		=> ["INTERFACE"],
+	"local"			=> ["INTERFACE", "FUNCTION"],
+	"iid_is"		=> ["ELEMENT"],
+	"call_as"		=> ["FUNCTION"],
+	"idempotent"		=> ["FUNCTION"],
+
+	# function
+	"in"			=> ["ELEMENT"],
+	"out"			=> ["ELEMENT"],
+
+	# pointer
+	"ref"			=> ["ELEMENT"],
+	"ptr"			=> ["ELEMENT"],
+	"unique"		=> ["ELEMENT"],
+	"ignore"		=> ["ELEMENT"],
+
+	"value"			=> ["ELEMENT"],
+
+	# generic
+	"public"		=> ["FUNCTION", "TYPEDEF"],
+	"nopush"		=> ["FUNCTION", "TYPEDEF"],
+	"nopull"		=> ["FUNCTION", "TYPEDEF"],
+	"noprint"		=> ["FUNCTION", "TYPEDEF"],
+	"noejs"			=> ["FUNCTION", "TYPEDEF"],
+
+	# union
+	"switch_is"		=> ["ELEMENT"],
+	"switch_type"		=> ["ELEMENT", "TYPEDEF"],
+	"case"			=> ["ELEMENT"],
+	"default"		=> ["ELEMENT"],
+
+	# subcontext
+	"subcontext"		=> ["ELEMENT"],
+	"subcontext_size"	=> ["ELEMENT"],
+
+	# enum
+	"enum16bit"		=> ["TYPEDEF"],
+	"v1_enum"		=> ["TYPEDEF"],
+
+	# bitmap
+	"bitmap8bit"		=> ["TYPEDEF"],
+	"bitmap16bit"		=> ["TYPEDEF"],
+	"bitmap32bit"		=> ["TYPEDEF"],
+	"bitmap64bit"		=> ["TYPEDEF"],
+
+	# array
+	"range"			=> ["ELEMENT"],
+	"size_is"		=> ["ELEMENT"],
+	"string"		=> ["ELEMENT"],
+	"noheader"		=> ["ELEMENT"],
+	"charset"		=> ["ELEMENT"],
+	"length_is"		=> ["ELEMENT"],
+);
+
+
+my($res);
+
+sub warning($$)
+{
+	my $l = shift;
+	my $m = shift;
+
+	print "$l->{FILE}:$l->{LINE}:Warning:$m\n";
+}
+
+sub error($$)
+{
+	my ($l,$m) = @_;
+	print "$l->{FILE}:$l->{LINE}:$m\n";
+}
+
+sub CheckTypedef($)
+{
+	my $td = shift;
+
+	if (has_property($td, "nodiscriminant")) {
+		error($td, "nodiscriminant property not supported");
+	}
+
+	if ($td->{TYPE} eq "BITMAP") {
+		warning($td, "converting bitmap to scalar");
+		#FIXME
+	}
+
+	if (has_property($td, "gensize")) {
+		warning($td, "ignoring gensize() property. ");
+	}
+
+	if (has_property($td, "enum8bit") and has_property($td, "enum16bit")) {
+		warning($td, "8 and 16 bit enums not supported, converting to scalar");
+		#FIXME
+	}
+
+	StripProperties($td);
+}
+
+sub CheckElement($)
+{
+	my $e = shift;
+
+	if (has_property($e, "noheader")) {
+		error($e, "noheader property not supported");
+		return;
+	}
+
+	if (has_property($e, "subcontext")) {
+		warning($e, "converting subcontext to byte array");
+		#FIXME
+	}
+
+	if (has_property($e, "compression")) {
+		error($e, "compression() property not supported");
+	}
+
+	if (has_property($e, "obfuscation")) {
+		error($e, "obfuscation() property not supported");
+	}
+
+	if (has_property($e, "sptr")) {
+		error($e, "sptr() pointer property not supported");
+	}
+
+	if (has_property($e, "relative")) {
+		error($e, "relative() pointer property not supported");
+	}
+
+	if (has_property($td, "flag")) {
+		warning($e, "ignoring flag() property");
+	}
+	
+	if (has_property($td, "value")) {
+		warning($e, "ignoring value() property");
+	}
+
+	StripProperties($e);
+}
+
+sub CheckFunction($)
+{
+	my $fn = shift;
+
+	if (has_property($fn, "noopnum")) {
+		error($fn, "noopnum not converted. Opcodes will be out of sync.");
+	}
+
+	StripProperties($fn);
+
+
+}
+
+sub CheckInterface($)
+{
+	my $if = shift;
+
+	if (has_property($if, "pointer_default_top") and 
+		$if->{PROPERTIES}->{pointer_default_top} ne "ref") {
+		error($if, "pointer_default_top() is pidl-specific");
+	}
+
+	StripProperties($if);
+
+	foreach my $x (@{$if->{DATA}}) {
+		if ($x->{TYPE} eq "DECLARE") {
+			warning($if, "the declare keyword is pidl-specific");
+			next;
+		}
+	}
+}
+
+sub Check($)
+{
+	my $pidl = shift;
+	my $nidl = [];
+	my $res = "";
+
+	foreach my $x (@{$pidl}) {
+		push (@$nidl, CheckInterface($x)) 
+			if ($x->{TYPE} eq "INTERFACE");
+	}
+
+	return $res;
+}
+
+1;
diff --git a/source4/pidl/lib/Parse/Pidl/Dump.pm b/source4/pidl/lib/Parse/Pidl/Dump.pm
new file mode 100644
index 0000000000..bca599262a
--- /dev/null
+++ b/source4/pidl/lib/Parse/Pidl/Dump.pm
@@ -0,0 +1,277 @@
+###################################################
+# dump function for IDL structures
+# Copyright tridge@samba.org 2000
+# released under the GNU GPL
+
+package Parse::Pidl::Dump;
+
+use Exporter;
+
+@ISA = qw(Exporter);
+@EXPORT_OK = qw(DumpTypedef DumpStruct DumpEnum DumpBitmap DumpUnion DumpFunction);
+
+use strict;
+use Parse::Pidl::Util qw(has_property);
+
+my($res);
+
+#####################################################################
+# dump a properties list
+sub DumpProperties($)
+{
+    my($props) = shift;
+    my($res);
+
+    foreach my $d ($props) {
+	foreach my $k (keys %{$d}) {
+	    if ($k eq "in") {
+		$res .= "[in] ";
+		next;
+	    }
+	    if ($k eq "out") {
+		$res .= "[out] ";
+		next;
+	    }
+	    if ($k eq "ref") {
+		$res .= "[ref] ";
+		next;
+	    }
+	    $res .= "[$k($d->{$k})] ";
+	}
+    }
+    return $res;
+}
+
+#####################################################################
+# dump a structure element
+sub DumpElement($)
+{
+    my($element) = shift;
+    my($res);
+
+    (defined $element->{PROPERTIES}) && 
+	($res .= DumpProperties($element->{PROPERTIES}));
+    $res .= DumpType($element->{TYPE});
+    $res .= " ";
+	for my $i (1..$element->{POINTERS}) {
+	    $res .= "*";
+    }
+    $res .= "$element->{NAME}";
+	foreach (@{$element->{ARRAY_LEN}}) {
+		$res .= "[$_]";
+	}
+
+    return $res;
+}
+
+#####################################################################
+# dump a struct
+sub DumpStruct($)
+{
+    my($struct) = shift;
+    my($res);
+
+    $res .= "struct {\n";
+    if (defined $struct->{ELEMENTS}) {
+	foreach my $e (@{$struct->{ELEMENTS}}) {
+	    $res .= "\t" . DumpElement($e);
+	    $res .= ";\n";
+	}
+    }
+    $res .= "}";
+    
+    return $res;
+}
+
+
+#####################################################################
+# dump a struct
+sub DumpEnum($)
+{
+    my($enum) = shift;
+    my($res);
+
+    $res .= "enum {\n";
+
+    foreach (@{$enum->{ELEMENTS}}) {
+    	if (/^([A-Za-z0-9_]+)[ \t]*\((.*)\)$/) {
+		$res .= "\t$1 = $2,\n";
+	} else {
+		$res .= "\t$_,\n";
+	}
+    }
+
+    $res.= "}";
+    
+    return $res;
+}
+
+#####################################################################
+# dump a struct
+sub DumpBitmap($)
+{
+    my($bitmap) = shift;
+    my($res);
+
+    $res .= "bitmap {\n";
+
+    foreach (@{$bitmap->{ELEMENTS}}) {
+    	if (/^([A-Za-z0-9_]+)[ \t]*\((.*)\)$/) {
+		$res .= "\t$1 = $2,\n";
+	} else {
+		die ("Bitmap $bitmap->{NAME} has field $_ without proper value");
+	}
+    }
+
+    $res.= "}";
+    
+    return $res;
+}
+
+
+#####################################################################
+# dump a union element
+sub DumpUnionElement($)
+{
+    my($element) = shift;
+    my($res);
+
+    if (has_property($element, "default")) {
+	$res .= "[default] ;\n";
+    } else {
+	$res .= "[case($element->{PROPERTIES}->{case})] ";
+	$res .= DumpElement($element), if defined($element);
+	$res .= ";\n";
+    }
+
+    return $res;
+}
+
+#####################################################################
+# dump a union
+sub DumpUnion($)
+{
+    my($union) = shift;
+    my($res);
+
+    (defined $union->{PROPERTIES}) && 
+	($res .= DumpProperties($union->{PROPERTIES}));
+    $res .= "union {\n";
+    foreach my $e (@{$union->{ELEMENTS}}) {
+	$res .= DumpUnionElement($e);
+    }
+    $res .= "}";
+
+    return $res;
+}
+
+#####################################################################
+# dump a type
+sub DumpType($)
+{
+    my($data) = shift;
+    my($res);
+
+    if (ref($data) eq "HASH") {
+	($data->{TYPE} eq "STRUCT") && ($res .= DumpStruct($data));
+	($data->{TYPE} eq "UNION") && ($res .= DumpUnion($data));
+	($data->{TYPE} eq "ENUM") && ($res .= DumpEnum($data));
+	($data->{TYPE} eq "BITMAP") && ($res .= DumpBitmap($data));
+    } else {
+	$res .= "$data";
+    }
+
+    return $res;
+}
+
+#####################################################################
+# dump a typedef
+sub DumpTypedef($)
+{
+    my($typedef) = shift;
+    my($res);
+
+    $res .= "typedef ";
+    $res .= DumpType($typedef->{DATA});
+    $res .= " $typedef->{NAME};\n\n";
+
+    return $res;
+}
+
+#####################################################################
+# dump a typedef
+sub DumpFunction($)
+{
+    my($function) = shift;
+    my($first) = 1;
+    my($res);
+
+    $res .= DumpType($function->{RETURN_TYPE});
+    $res .= " $function->{NAME}(\n";
+    for my $d (@{$function->{DATA}}) {
+	$first || ($res .= ",\n"); $first = 0;
+	$res .= DumpElement($d);
+    }
+    $res .= "\n);\n\n";
+
+    return $res;
+}
+
+#####################################################################
+# dump a module header
+sub DumpInterfaceProperties($)
+{
+    my($header) = shift;
+    my($data) = $header->{DATA};
+    my($first) = 1;
+    my($res);
+
+    $res .= "[\n";
+    foreach my $k (keys %{$data}) {
+	    $first || ($res .= ",\n"); $first = 0;
+	    $res .= "$k($data->{$k})";
+    }
+    $res .= "\n]\n";
+
+    return $res;
+}
+
+#####################################################################
+# dump the interface definitions
+sub DumpInterface($)
+{
+    my($interface) = shift;
+    my($data) = $interface->{DATA};
+    my($res);
+
+	$res .= DumpInterfaceProperties($interface->{PROPERTIES});
+
+    $res .= "interface $interface->{NAME}\n{\n";
+    foreach my $d (@{$data}) {
+	($d->{TYPE} eq "TYPEDEF") &&
+	    ($res .= DumpTypedef($d));
+	($d->{TYPE} eq "FUNCTION") &&
+	    ($res .= DumpFunction($d));
+    }
+    $res .= "}\n";
+
+    return $res;
+}
+
+
+#####################################################################
+# dump a parsed IDL structure back into an IDL file
+sub Dump($)
+{
+    my($idl) = shift;
+    my($res);
+
+    $res = "/* Dumped by pidl */\n\n";
+    foreach my $x (@{$idl}) {
+	($x->{TYPE} eq "INTERFACE") && 
+	    ($res .= DumpInterface($x));
+    }
+    return $res;
+}
+
+1;
diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm
new file mode 100644
index 0000000000..45654fe6aa
--- /dev/null
+++ b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm
@@ -0,0 +1,161 @@
+###################################################
+# parse an ethereal conformance file
+# Copyright jelmer@samba.org 2005
+# released under the GNU GPL
+
+package Parse::Pidl::Ethereal::Conformance;
+
+require Exporter;
+
+@ISA = qw(Exporter);
+@EXPORT_OK = qw(ReadConformance);
+
+use strict;
+
+use Parse::Pidl::Util qw(has_property);
+
+sub handle_type($$$$$$$$)
+{
+	my ($data,$name,$dissectorname,$ft_type,$base_type,$mask,$valsstring,$alignment) = @_;
+
+	$data->{types}->{$name} = {
+		NAME => $name,
+		DISSECTOR_NAME => $dissectorname,
+		FT_TYPE => $ft_type,
+		BASE_TYPE => $base_type,
+		MASK => $mask,
+		VALSSTRING => $valsstring,
+		ALIGNMENT => $alignment
+	};
+}
+
+
+sub handle_hf_rename($$$)
+{
+	my ($data,$old,$new) = @_;
+	$data->{hf_renames}{$old} = $new;
+}
+
+sub handle_param_value($$$)
+{
+	my ($data,$dissector_name,$value) = @_;
+
+	$data->{dissectorparams}->{$dissector_name} = $value;
+}
+
+sub handle_hf_field($$$$$$$$$)
+{
+	my ($data,$hf,$title,$filter,$ft_type,$base_type,$valsstring,$mask,$blurb) = @_;
+
+	$data->{header_fields}->{$hf} = {
+		HF => $hf,
+		TITLE => $title,
+		FILTER => $filter,
+		FT_TYPE => $ft_type,
+		BASE_TYPE => $base_type,
+		VALSSTRING => $valsstring,
+		MASK => $mask,
+		BLURB => $blurb
+	};
+}
+
+sub handle_strip_prefix($$)
+{
+	my ($data,$x) = @_;
+
+	push (@{$data->{strip_prefixes}}, $x);
+}
+
+sub handle_noemit($$)
+{
+	my ($data,$type) = @_;
+
+	$data->{noemit}->{$type} = 1;
+}
+
+sub handle_protocol($$$$$)
+{
+	my ($data, $name, $longname, $shortname, $filtername) = @_;
+
+	$data->{protocols}->{$name} = {
+		LONGNAME => $longname,
+		SHORTNAME => $shortname,
+		FILTERNAME => $filtername
+	};
+}
+
+sub handle_fielddescription($$$)
+{
+	my ($data,$field,$desc) = @_;
+
+	$data->{fielddescription}->{$field} = $desc;
+}
+
+sub handle_import
+{
+	my $data = shift @_;
+	my $dissectorname = shift @_;
+
+	$data->{imports}->{$dissectorname} = join(' ', @_);
+}
+
+my %field_handlers = (
+	TYPE => \&handle_type,
+	NOEMIT => \&handle_noemit, 
+	PARAM_VALUE => \&handle_param_value, 
+	HF_FIELD => \&handle_hf_field, 
+	HF_RENAME => \&handle_hf_rename, 
+	STRIP_PREFIX => \&handle_strip_prefix,
+	PROTOCOL => \&handle_protocol,
+	FIELD_DESCRIPTION => \&handle_fielddescription,
+	IMPORT => \&handle_import
+);
+
+sub ReadConformance($$)
+{
+	my ($f,$data) = @_;
+
+	$data->{override} = "";
+
+	my $incodeblock = 0;
+
+	open(IN,"<$f") or return undef;
+
+	my $ln = 0;
+
+	foreach (<IN>) {
+		$ln++;
+		next if (/^#.*$/);
+		next if (/^$/);
+
+		s/[\r\n]//g;
+
+		if ($_ eq "CODE START") {
+			$incodeblock = 1;
+			next;
+		} elsif ($incodeblock and $_ eq "CODE END") {
+			$incodeblock = 0;
+			next;
+		} elsif ($incodeblock) {
+			$data->{override}.="$_\n";
+			next;
+		}
+
+		my @fields = split(/ /);
+
+		my $cmd = $fields[0];
+
+		shift @fields;
+
+		if (not defined($field_handlers{$cmd})) {
+			print "$f:$ln: Warning: Unknown command `$cmd'\n";
+			next;
+		}
+		
+		$field_handlers{$cmd}($data, @fields);
+	}
+
+	close(IN);
+}
+
+1;
diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm
new file mode 100644
index 0000000000..73dd34096e
--- /dev/null
+++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm
@@ -0,0 +1,844 @@
+##################################################
+# Samba4 NDR parser generator for IDL structures
+# Copyright tridge@samba.org 2000-2003
+# Copyright tpot@samba.org 2001
+# Copyright jelmer@samba.org 2004-2005
+# Portions based on idl2eth.c by Ronnie Sahlberg
+# released under the GNU GPL
+
+package Parse::Pidl::Ethereal::NDR;
+
+use strict;
+use Parse::Pidl::Typelist;
+use Parse::Pidl::Util qw(has_property ParseExpr property_matches);
+use Parse::Pidl::NDR;
+use Parse::Pidl::Dump qw(DumpTypedef DumpFunction);
+use Parse::Pidl::Ethereal::Conformance qw(ReadConformance);
+
+my %types;
+
+my $conformance = {imports=>{}};
+
+my %ptrtype_mappings = (
+	"unique" => "NDR_POINTER_UNIQUE",
+	"ref" => "NDR_POINTER_REF",
+	"ptr" => "NDR_POINTER_PTR"
+);
+
+sub type2ft($)
+{
+    my($t) = shift;
+ 
+    return "FT_UINT$1" if $t =~ /uint(8|16|32|64)/;
+    return "FT_INT$1" if $t =~ /int(8|16|32|64)/;
+    return "FT_UINT64", if $t eq "HYPER_T" or $t eq "NTTIME"
+	or $t eq "NTTIME_1sec" or $t eq "NTTIME_hyper" or $t eq "hyper";
+
+    return "FT_STRING" if ($t eq "string");
+   
+    return "FT_NONE";
+}
+
+sub StripPrefixes($)
+{
+	my ($s) = @_;
+
+	foreach (@{$conformance->{strip_prefixes}}) {
+		$s =~ s/^$_\_//g;
+	}
+
+	return $s;
+}
+
+# Convert a IDL structure field name (e.g access_mask) to a prettier
+# string like 'Access Mask'.
+
+sub field2name($)
+{
+    my($field) = shift;
+
+    $field =~ s/_/ /g;		# Replace underscores with spaces
+    $field =~ s/(\w+)/\u\L$1/g;	# Capitalise each word
+    
+    return $field;
+}
+
+my %res = ();
+my $tabs = "";
+sub pidl_code($)
+{
+	my $d = shift;
+	if ($d) {
+		$res{code} .= $tabs;
+		$res{code} .= $d;
+	}
+	$res{code} .="\n";
+}
+
+sub pidl_hdr($) { my $x = shift; $res{hdr} .= "$x\n"; }
+sub pidl_def($) { my $x = shift; $res{def} .= "$x\n"; }
+
+sub indent()
+{
+	$tabs .= "\t";
+}
+
+sub deindent()
+{
+	$tabs = substr($tabs, 0, -1);
+}
+
+sub PrintIdl($)
+{
+	my $idl = shift;
+
+	foreach (split /\n/, $idl) {
+		pidl_code "/* IDL: $_ */";
+	}
+}
+
+#####################################################################
+# parse the interface definitions
+sub Interface($)
+{
+	my($interface) = @_;
+	Const($_,$interface->{NAME}) foreach (@{$interface->{CONSTS}});
+	Typedef($_,$interface->{NAME}) foreach (@{$interface->{TYPEDEFS}});
+	Function($_,$interface->{NAME}) foreach (@{$interface->{FUNCTIONS}});
+}
+
+sub Enum($$$)
+{
+	my ($e,$name,$ifname) = @_;
+	my $valsstring = "$ifname\_$name\_vals";
+	my $dissectorname = "$ifname\_dissect\_".StripPrefixes($name);
+	return if (defined($conformance->{noemit}->{$dissectorname}));
+
+    	foreach (@{$e->{ELEMENTS}}) {
+		if (/([^=]*)=(.*)/) {
+			pidl_hdr "#define $1 ($2)";
+		}
+	}
+	
+	pidl_hdr "extern const value_string $valsstring\[];";
+	pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);";
+
+	pidl_def "const value_string ".$valsstring."[] = {";
+    	foreach (@{$e->{ELEMENTS}}) {
+		next unless (/([^=]*)=(.*)/);
+		pidl_def "\t{ $1, \"$1\" },";
+	}
+
+	pidl_def "{ 0, NULL }";
+	pidl_def "};";
+
+	pidl_code "int";
+	pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param _U_)";
+	pidl_code "{";
+	indent;
+	pidl_code "offset=dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, tree, drep, hf_index, NULL);";
+	pidl_code "return offset;";
+	deindent;
+	pidl_code "}\n";
+
+	my $enum_size = $e->{BASE_TYPE};
+	$enum_size =~ s/uint//g;
+	register_type($name, "offset=$dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", type2ft($e->{BASE_TYPE}), "BASE_DEC", "0", "VALS($valsstring)", $enum_size / 8);
+}
+
+sub Bitmap($$$)
+{
+	my ($e,$name,$ifname) = @_;
+	my $dissectorname = "$ifname\_dissect\_".StripPrefixes($name);
+
+	register_ett("ett_$ifname\_$name");
+
+
+	pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);";
+
+	pidl_code "int";
+	pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)";
+	pidl_code "{";
+	indent;
+	pidl_code "proto_item *item=NULL;";
+	pidl_code "proto_tree *tree=NULL;";
+	pidl_code "";
+		
+	pidl_code "g$e->{BASE_TYPE} flags;";
+	if ($e->{ALIGN} > 1) {
+		pidl_code "ALIGN_TO_$e->{ALIGN}_BYTES;";
+	}
+
+	pidl_code "";
+
+	pidl_code "if(parent_tree) {";
+	indent;
+	pidl_code "item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, $e->{ALIGN}, TRUE);";
+	pidl_code "tree=proto_item_add_subtree(item,ett_$ifname\_$name);";
+	deindent;
+	pidl_code "}\n";
+
+	pidl_code "offset=dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, NULL, drep, -1, &flags);";
+
+	foreach (@{$e->{ELEMENTS}}) {
+		next unless (/([^ ]*) (.*)/);
+		my ($en,$ev) = ($1,$2);
+		my $hf_bitname = "hf_$ifname\_$name\_$en";
+		my $filtername = "$ifname\.$name\.$en";
+		
+		register_hf_field($hf_bitname, field2name($en), $filtername, "FT_BOOLEAN", $e->{ALIGN} * 8, "TFS(&$name\_$en\_tfs)", $ev, "");
+
+		pidl_def "static const true_false_string $name\_$en\_tfs = {";
+		pidl_def "   \"$en is SET\",";
+		pidl_def "   \"$en is NOT SET\",";
+		pidl_def "};";
+		
+		pidl_code "proto_tree_add_boolean(tree, $hf_bitname, tvb, offset-$e->{ALIGN}, $e->{ALIGN}, flags);";
+		pidl_code "if (flags&$ev){";
+		pidl_code "\tproto_item_append_text(item,\"$en \");";
+		pidl_code "}";
+		pidl_code "flags&=(~$ev);";
+		pidl_code "";
+	}
+
+	pidl_code "if(flags){";
+	pidl_code "\tproto_item_append_text(item, \"UNKNOWN-FLAGS\");";
+	pidl_code "}\n";
+	pidl_code "return offset;";
+	deindent;
+	pidl_code "}\n";
+
+	my $size = $e->{BASE_TYPE};
+	$size =~ s/uint//g;
+	register_type($name, "offset=$dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", type2ft($e->{BASE_TYPE}), "BASE_DEC", "0", "NULL", $size/8);
+}
+
+sub ElementLevel($$$$$)
+{
+	my ($e,$l,$hf,$myname,$pn) = @_;
+
+	my $param = 0;
+
+	if (defined($conformance->{dissectorparams}->{$myname})) {
+		$param = $conformance->{dissectorparams}->{$myname};
+	}
+
+	if ($l->{TYPE} eq "POINTER") {
+		my $type;
+		if ($l->{LEVEL} eq "TOP") {
+			$type = "toplevel";
+		} elsif ($l->{LEVEL} eq "EMBEDDED") {
+			$type = "embedded";
+		}
+		pidl_code "offset=dissect_ndr_$type\_pointer(tvb,offset,pinfo,tree,drep,$myname\_,$ptrtype_mappings{$l->{POINTER_TYPE}},\"".field2name(StripPrefixes($e->{NAME})) . " (".StripPrefixes($e->{TYPE}).")\",$hf);";
+	} elsif ($l->{TYPE} eq "ARRAY") {
+		
+		if ($l->{IS_INLINE}) {
+			warn ("Inline arrays not supported");
+			pidl_code "/* FIXME: Handle inline array */";
+		} elsif ($l->{IS_FIXED}) {
+			pidl_code "int i;";
+			pidl_code "for (i = 0; i < $l->{SIZE_IS}; i++)";
+			pidl_code "\toffset=$myname\_(tvb,offset,pinfo,tree,drep);";
+		} else {
+			my $af = "";
+			($af = "ucarray") if ($l->{IS_CONFORMANT});
+			($af = "uvarray") if ($l->{IS_VARYING});
+			($af = "ucvarray") if ($l->{IS_CONFORMANT} and $l->{IS_VARYING});
+
+			pidl_code "offset=dissect_ndr_$af(tvb,offset,pinfo,tree,drep,$myname\_);";
+		}
+	} elsif ($l->{TYPE} eq "DATA") {
+		if ($l->{DATA_TYPE} eq "string") {
+			my $bs = 2; # Byte size defaults to that of UCS2
+
+
+			($bs = 1) if (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_ASCII.*"));
+			
+			if (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_SIZE4.*") and property_matches($e, "flag", ".*LIBNDR_FLAG_STR_LEN4.*")) {
+				pidl_code "offset=dissect_ndr_cvstring(tvb,offset,pinfo,tree,drep,$bs,$hf,FALSE,NULL);";
+			} elsif (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_SIZE4.*")) {
+				pidl_code "offset=dissect_ndr_vstring(tvb,offset,pinfo,tree,drep,$bs,$hf,FALSE,NULL);";
+			} else {
+				warn("Unable to handle string with flags $e->{PROPERTIES}->{flag}");
+			}
+		} else {
+			my $call;
+
+			if (defined($types{$l->{DATA_TYPE}})) {
+				$call= $types{$l->{DATA_TYPE}}->{CALL};
+			} elsif ($conformance->{imports}->{$l->{DATA_TYPE}}) {
+				$call = $conformance->{imports}->{$l->{DATA_TYPE}};	
+			} else {
+				warn("Unknown data type `$l->{DATA_TYPE}'");
+				pidl_code "/* FIXME: Handle unknown data type $l->{DATA_TYPE} */";
+				if ($l->{DATA_TYPE} =~ /^([a-z]+)\_(.*)$/)
+				{
+					pidl_code "offset=$1_dissect_$2(tvb,offset,pinfo,tree,drep,$hf,$param);";
+				}
+
+				return;
+			}
+
+			$call =~ s/\@HF\@/$hf/g;
+			$call =~ s/\@PARAM\@/$param/g;
+			pidl_code "$call";
+		}
+	} elsif ($_->{TYPE} eq "SUBCONTEXT") {
+		my $num_bits = ($l->{HEADER_SIZE}*8);
+		pidl_code "guint$num_bits size;";
+		pidl_code "int start_offset=offset;";
+		pidl_code "tvbuff_t *subtvb;";
+		pidl_code "offset=dissect_ndr_uint$num_bits(tvb,offset,pinfo,tree,drep,$hf,&size);";
+		pidl_code "proto_tree_add_text(tree,tvb,start_offset,offset-start_offset+size,\"Subcontext size\");";
+
+		pidl_code "subtvb = tvb_new_subset(tvb,offset,size,-1);";
+		pidl_code "$myname\_(subtvb,0,pinfo,tree,drep);";
+	} else {
+		die("Unknown type `$_->{TYPE}'");
+	}
+}
+
+sub Element($$$)
+{
+	my ($e,$pn,$ifname) = @_;
+
+	my $dissectorname = "$ifname\_dissect\_".StripPrefixes($pn)."\_".StripPrefixes($e->{NAME});
+
+	my $call_code = "offset=$dissectorname(tvb,offset,pinfo,tree,drep);";
+
+	my $hf = register_hf_field("hf_$ifname\_$pn\_$e->{NAME}", field2name($e->{NAME}), "$ifname.$pn.$e->{NAME}", type2ft($e->{TYPE}), "BASE_HEX", "NULL", 0, "");
+
+	if (defined($conformance->{noemit}->{$dissectorname})) {
+		return $call_code;
+	}
+
+	my $add = "";
+
+	foreach (@{$e->{LEVELS}}) {
+		next if ($_->{TYPE} eq "SWITCH");
+		pidl_def "static int $dissectorname$add(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep);";
+		pidl_code "static int";
+		pidl_code "$dissectorname$add(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)";
+		pidl_code "{";
+		indent;
+
+		ElementLevel($e,$_,$hf,$dissectorname.$add,$pn);
+
+		pidl_code "return offset;";
+		deindent;
+		pidl_code "}\n";
+		$add.="_";
+	}
+
+	return $call_code;
+}
+
+sub Function($$$)
+{
+	my ($fn,$ifname) = @_;
+
+	my %dissectornames;
+
+	foreach (@{$fn->{ELEMENTS}}) {
+		$dissectornames{$_->{NAME}} = Element($_, $fn->{NAME}, $ifname) 
+	}
+	
+	my $fn_name = $_->{NAME};
+	$fn_name =~ s/^${ifname}_//;
+
+	PrintIdl DumpFunction($fn->{ORIGINAL});
+	pidl_code "static int";
+	pidl_code "$ifname\_dissect\_${fn_name}_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)";
+	pidl_code "{";
+	indent;
+	foreach (@{$fn->{ELEMENTS}}) {
+		if (grep(/out/,@{$_->{DIRECTION}})) {
+			pidl_code "$dissectornames{$_->{NAME}}";
+			pidl_code "offset=dissect_deferred_pointers(pinfo,tvb,offset,drep);";
+			pidl_code "";
+		}
+	}
+
+	if (not defined($fn->{RETURN_TYPE})) {
+	} elsif ($fn->{RETURN_TYPE} eq "NTSTATUS") {
+		pidl_code "offset=dissect_ntstatus(tvb,offset,pinfo,tree,drep,hf\_$ifname\_status, NULL);";
+	} elsif ($fn->{RETURN_TYPE} eq "WERROR") {
+		pidl_code "offset=dissect_ndr_uint32(tvb,offset,pinfo,tree,drep,hf\_$ifname\_werror, NULL);";
+	}
+
+	pidl_code "return offset;";
+	deindent;
+	pidl_code "}\n";
+
+	pidl_code "static int";
+	pidl_code "$ifname\_dissect\_${fn_name}_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)";
+	pidl_code "{";
+	indent;
+	foreach (@{$fn->{ELEMENTS}}) {
+		if (grep(/in/,@{$_->{DIRECTION}})) {
+			pidl_code "$dissectornames{$_->{NAME}}";
+			pidl_code "offset=dissect_deferred_pointers(pinfo,tvb,offset,drep);";
+		}
+
+	}
+
+	pidl_code "return offset;";
+	deindent;
+	pidl_code "}\n";
+}
+
+sub Struct($$$)
+{
+	my ($e,$name,$ifname) = @_;
+	my $dissectorname = "$ifname\_dissect\_".StripPrefixes($name);
+
+	return if (defined($conformance->{noemit}->{$dissectorname}));
+
+	register_ett("ett_$ifname\_$name");
+
+	my $res = "";
+	($res.="\t".Element($_, $name, $ifname)."\n\n") foreach (@{$e->{ELEMENTS}});
+
+	pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_);";
+
+	pidl_code "int";
+	pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)";
+	pidl_code "{";
+	indent;
+	pidl_code "proto_item *item = NULL;";
+	pidl_code "proto_tree *tree = NULL;";
+	pidl_code "int old_offset;";
+	pidl_code "";
+
+	if ($e->{ALIGN} > 1) {
+		pidl_code "ALIGN_TO_$e->{ALIGN}_BYTES;";
+	}
+	pidl_code "";
+
+	pidl_code "old_offset=offset;";
+	pidl_code "";
+	pidl_code "if(parent_tree){";
+	indent;
+	pidl_code "item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);";
+	pidl_code "tree=proto_item_add_subtree(item, ett_$ifname\_$name);";
+	deindent;
+	pidl_code "}";
+
+	pidl_code "\n$res";
+
+	pidl_code "proto_item_set_len(item, offset-old_offset);";
+	pidl_code "return offset;";
+	deindent;
+	pidl_code "}\n";
+
+	register_type($name, "offset=$dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", "FT_NONE", "BASE_NONE", 0, "NULL", 0);
+}
+
+sub Union($$$)
+{
+	my ($e,$name,$ifname) = @_;
+
+	my $dissectorname = "$ifname\_dissect_".StripPrefixes($name);
+	return if (defined($conformance->{noemit}->{$dissectorname}));
+	
+	register_ett("ett_$ifname\_$name");
+
+	my $res = "";
+	foreach (@{$e->{ELEMENTS}}) {
+		$res.="\n\t\t$_->{CASE}:\n";
+		if ($_->{TYPE} ne "EMPTY") {
+			$res.="\t\t\t".Element($_, $name, $ifname)."\n";
+		}
+		$res.="\t\tbreak;\n";
+	}
+
+	pidl_code "static int";
+	pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)";
+	pidl_code "{";
+	indent;
+	pidl_code "proto_item *item=NULL;";
+	pidl_code "proto_tree *tree=NULL;";
+	pidl_code "int old_offset;";
+	pidl_code "g$e->{SWITCH_TYPE} level;";
+	pidl_code "";
+
+	if ($e->{ALIGN} > 1) {
+		pidl_code "ALIGN_TO_$e->{ALIGN}_BYTES;";
+	}
+
+	pidl_code "";
+
+	pidl_code "old_offset=offset;";
+	pidl_code "if(parent_tree){";
+	indent;
+	pidl_code "item=proto_tree_add_text(parent_tree,tvb,offset,-1,\"$name\");";
+	pidl_code "tree=proto_item_add_subtree(item,ett_$ifname\_$name);";
+	deindent;
+	pidl_code "}";
+
+	pidl_code "";
+
+	pidl_code "offset = dissect_ndr_$e->{SWITCH_TYPE}(tvb, offset, pinfo, tree, drep, hf_index, &level);";
+
+	pidl_code "switch(level) {$res\t}";
+	pidl_code "proto_item_set_len(item, offset-old_offset);";
+	pidl_code "return offset;";
+	deindent;
+	pidl_code "}";
+
+	register_type($name, "offset=$dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", "FT_NONE", "BASE_NONE", 0, "NULL", 0);
+}
+
+sub Const($$)
+{
+	my ($const,$ifname) = @_;
+	
+	if (!defined($const->{ARRAY_LEN}[0])) {
+    		pidl_hdr "#define $const->{NAME}\t( $const->{VALUE} )\n";
+    	} else {
+    		pidl_hdr "#define $const->{NAME}\t $const->{VALUE}\n";
+    	}
+}
+
+sub Typedef($$)
+{
+	my ($e,$ifname) = @_;
+
+	PrintIdl DumpTypedef($e->{ORIGINAL});
+
+	{
+		ENUM => \&Enum,
+		STRUCT => \&Struct,
+		UNION => \&Union,
+		BITMAP => \&Bitmap
+	}->{$e->{DATA}->{TYPE}}->($e->{DATA}, $e->{NAME}, $ifname);
+}
+
+sub RegisterInterface($)
+{
+	my ($x) = @_;
+
+	pidl_code "void proto_register_dcerpc_$x->{NAME}(void)";
+	pidl_code "{";
+	indent;
+
+	$res{code}.=DumpHfList()."\n";
+	$res{code}.="\n".DumpEttList()."\n";
+	
+	if (defined($x->{UUID})) {
+	    # These can be changed to non-pidl_code names if the old dissectors
+	    # in epan/dissctors are deleted.
+    
+	    my $name = "\"" . uc($x->{NAME}) . " (pidl)\"";
+	    my $short_name = $x->{NAME};
+	    my $filter_name = $x->{NAME};
+
+	    if (has_property($x, "helpstring")) {
+	    	$name = $x->{PROPERTIES}->{helpstring};
+	    }
+
+	    if (defined($conformance->{protocols}->{$x->{NAME}})) {
+		$short_name = $conformance->{protocols}->{$x->{NAME}}->{SHORTNAME};
+		$name = $conformance->{protocols}->{$x->{NAME}}->{LONGNAME};
+		$filter_name = $conformance->{protocols}->{$x->{NAME}}->{FILTERNAME};
+	    }
+
+	    pidl_code "proto_dcerpc_$x->{NAME} = proto_register_protocol($name, \"$short_name\", \"$filter_name\");";
+	    
+	    pidl_code "proto_register_field_array(proto_dcerpc_$x->{NAME}, hf, array_length (hf));";
+	    pidl_code "proto_register_subtree_array(ett, array_length(ett));";
+	} else {
+	    pidl_code "proto_dcerpc = proto_get_id_by_filter_name(\"dcerpc\");";
+	    pidl_code "proto_register_field_array(proto_dcerpc, hf, array_length(hf));";
+	    pidl_code "proto_register_subtree_array(ett, array_length(ett));";
+	}
+	    
+	deindent;
+	pidl_code "}\n";
+}
+
+sub RegisterInterfaceHandoff($)
+{
+	my $x = shift;
+	pidl_code "void proto_reg_handoff_dcerpc_$x->{NAME}(void)";
+	pidl_code "{";
+	indent;
+	pidl_code "dcerpc_init_uuid(proto_dcerpc_$x->{NAME}, ett_dcerpc_$x->{NAME},";
+	pidl_code "\t&uuid_dcerpc_$x->{NAME}, ver_dcerpc_$x->{NAME},";
+	pidl_code "\t$x->{NAME}_dissectors, hf_$x->{NAME}_opnum);";
+	deindent;
+	pidl_code "}";
+}
+
+sub ProcessInterface($)
+{
+	my ($x) = @_;
+
+	push(@{$conformance->{strip_prefixes}}, $x->{NAME});
+
+	my $define = "__PACKET_DCERPC_" . uc($_->{NAME}) . "_H";
+	pidl_hdr "#ifndef $define";
+	pidl_hdr "#define $define";
+	pidl_hdr "";
+
+	if (defined $x->{PROPERTIES}->{depends}) {
+		foreach (split / /, $x->{PROPERTIES}->{depends}) {
+			next if($_ eq "security");
+			pidl_hdr "#include \"packet-dcerpc-$_\.h\"\n";
+		}
+	}
+
+	pidl_def "static gint proto_dcerpc_$x->{NAME} = -1;";
+	register_ett("ett_dcerpc_$x->{NAME}");
+	register_hf_field("hf_$x->{NAME}_opnum", "Operation", "$x->{NAME}.opnum", "FT_UINT16", "BASE_DEC", "NULL", 0, "");
+	register_hf_field("hf_$x->{NAME}_status", "Status", "$x->{NAME}.status", "FT_UINT32", "BASE_HEX", "VALS(NT_errors)", 0, "");
+	register_hf_field("hf_$x->{NAME}_werror", "Windows Error", "$x->{NAME}.werror", "FT_UINT32", "BASE_HEX", "NULL", 0, "");
+
+	if (defined($x->{UUID})) {
+		my $if_uuid = $x->{UUID};
+
+	    pidl_def "/* Version information */\n\n";
+	    
+	    pidl_def "static e_uuid_t uuid_dcerpc_$x->{NAME} = {";
+	    pidl_def "\t0x" . substr($if_uuid, 1, 8) 
+  		. ", 0x" . substr($if_uuid, 10, 4)
+	    . ", 0x" . substr($if_uuid, 15, 4) . ",";
+	    pidl_def "\t{ 0x" . substr($if_uuid, 20, 2) 
+		. ", 0x" . substr($if_uuid, 22, 2)
+	    . ", 0x" . substr($if_uuid, 25, 2)
+	    . ", 0x" . substr($if_uuid, 27, 2)
+	    . ", 0x" . substr($if_uuid, 29, 2)
+	    . ", 0x" . substr($if_uuid, 31, 2)
+	    . ", 0x" . substr($if_uuid, 33, 2)
+	    . ", 0x" . substr($if_uuid, 35, 2) . " }";
+	    pidl_def "};";
+	
+	    my $maj = $x->{VERSION};
+	    $maj =~ s/\.(.*)$//g;
+	    pidl_def "static guint16 ver_dcerpc_$x->{NAME} = $maj;";
+	    pidl_def "";
+	}
+
+	Interface($x);
+
+	pidl_code "\n".DumpFunctionTable($x);
+
+	RegisterInterface($x);
+	RegisterInterfaceHandoff($x);
+
+	pidl_hdr "#endif /* $define */";
+}
+
+
+sub register_type($$$$$$$)
+{
+	my ($type,$call,$ft,$base,$mask,$vals,$length) = @_;
+
+	$types{$type} = {
+		TYPE => $type,
+		CALL => $call,
+		FT_TYPE => $ft,
+		BASE => $base,
+		MASK => $mask,
+		VALSSTRING => $vals,
+		LENGTH => $length
+	};
+}
+
+# Loads the default types
+sub Initialize($)
+{
+	my $cnf_file = shift;
+
+	$conformance = {};
+
+	ReadConformance($cnf_file, $conformance) or print "Warning: Not using conformance file `$cnf_file'\n";
+	
+	foreach my $bytes (qw(1 2 4 8)) {
+		my $bits = $bytes * 8;
+		register_type("uint$bits", "offset=dissect_ndr_uint$bits(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);", "FT_UINT$bits", "BASE_DEC", 0, "NULL", $bytes);
+		register_type("int$bits", "offset=dissect_ndr_uint$bits(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);", "FT_INT$bits", "BASE_DEC", 0, "NULL", $bytes);
+	}
+		
+	register_type("udlong", "offset=dissect_ndr_duint32(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);", "FT_UINT64", "BASE_DEC", 0, "NULL", 4);
+	register_type("bool8", "offset=dissect_ndr_uint8(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_INT8", "BASE_DEC", 0, "NULL", 1);
+	register_type("char", "offset=dissect_ndr_uint8(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_INT8", "BASE_DEC", 0, "NULL", 1);
+	register_type("long", "offset=dissect_ndr_uint32(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_INT32", "BASE_DEC", 0, "NULL", 4);
+	register_type("dlong", "offset=dissect_ndr_duint32(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_INT64", "BASE_DEC", 0, "NULL", 8);
+	register_type("GUID", "offset=dissect_ndr_uuid_t(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_GUID", "BASE_NONE", 0, "NULL", 4);
+	register_type("policy_handle", "offset=dissect_nt_policy_hnd(tvb,offset,pinfo,tree,drep,\@HF\@,NULL,NULL,\@PARAM\@&0x01,\@PARAM\@&0x02);","FT_BYTES", "BASE_NONE", 0, "NULL", 4);
+	register_type("NTTIME", "offset=dissect_ndr_nt_NTTIME(tvb,offset,pinfo,tree,drep,\@HF\@);","FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4);
+	register_type("NTTIME_hyper", "offset=dissect_ndr_nt_NTTIME(tvb,offset,pinfo,tree,drep,\@HF\@);","FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4);
+	register_type("time_t", "offset=dissect_ndr_time_t(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_ABSOLUTE_TIME", "BASE_DEC", 0, "NULL", 4);
+	register_type("NTTIME_1sec", "offset=dissect_ndr_nt_NTTIME(tvb,offset,pinfo,tree,drep,\@HF\@);", "FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4);
+	register_type("SID", "
+		dcerpc_info *di = (dcerpc_info *)pinfo->private_data;
+
+		di->hf_index = \@HF\@;
+
+		offset=dissect_ndr_nt_SID_with_options(tvb,offset,pinfo,tree,drep,param);
+	","FT_STRING", "BASE_DEC", 0, "NULL", 4);
+	register_type("WERROR", 
+		"offset=dissect_ndr_uint32(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_UINT32", "BASE_DEC", 0, "VALS(NT_errors)", 4);
+
+}
+
+#####################################################################
+# Generate ethereal parser and header code
+sub Parse($$)
+{
+	my($ndr,$h_filename,$cnf_file) = @_;
+	Initialize($cnf_file);
+
+	$tabs = "";
+
+	%res = (code=>"",def=>"",hdr=>"");
+
+	pidl_hdr "/* header auto-generated by pidl */";
+
+	$res{headers} = "\n";
+	$res{headers} .= "#ifdef HAVE_CONFIG_H\n";
+	$res{headers} .= "#include \"config.h\"\n";
+	$res{headers} .= "#endif\n\n";
+	$res{headers} .= "#include <glib.h>\n";
+	$res{headers} .= "#include <string.h>\n";
+	$res{headers} .= "#include <epan/packet.h>\n\n";
+
+	$res{headers} .= "#include \"packet-dcerpc.h\"\n";
+	$res{headers} .= "#include \"packet-dcerpc-nt.h\"\n";
+	$res{headers} .= "#include \"packet-windows-common.h\"\n";
+	$res{headers} .= "#include \"$h_filename\"\n";
+	pidl_code "";
+
+	# Ethereal protocol registration
+
+	ProcessInterface($_) foreach (@$ndr);
+
+	$res{ett} = DumpEttDeclaration();
+	$res{hf} = DumpHfDeclaration();
+
+	my $parser = "/* parser auto-generated by pidl */";
+	$parser.= $res{headers};
+	$parser.=$res{ett};
+	$parser.=$res{hf};
+	$parser.=$res{def};
+	$parser.=$conformance->{override};
+	$parser.=$res{code};
+
+	my $header = "/* autogenerated by pidl */\n\n";
+	$header.=$res{hdr};
+    
+	return ($parser,$header);
+}
+
+###############################################################################
+# ETT
+###############################################################################
+
+my @ett = ();
+
+sub register_ett($)
+{
+	my $name = shift;
+
+	push (@ett, $name);	
+}
+
+sub DumpEttList()
+{
+	my $res = "\tstatic gint *ett[] = {\n";
+	foreach (@ett) {
+		$res .= "\t\t&$_,\n";
+	}
+
+	return "$res\t};\n";
+}
+
+sub DumpEttDeclaration()
+{
+	my $res = "\n/* Ett declarations */\n";
+	foreach (@ett) {
+		$res .= "static gint $_ = -1;\n";
+	}
+
+	return "$res\n";
+}
+
+###############################################################################
+# HF
+###############################################################################
+
+my %hf = ();
+
+sub register_hf_field($$$$$$$$) 
+{
+	my ($index,$name,$filter_name,$ft_type,$base_type,$valsstring,$mask,$blurb) = @_;
+
+	return $conformance->{hf_renames}->{$index} if defined ($conformance->{hf_renames}->{$index});
+
+	$hf{$index} = {
+		INDEX => $index,
+		NAME => $name,
+		FILTER => $filter_name,
+		FT_TYPE => $ft_type,
+		BASE_TYPE => $base_type,
+		VALS => $valsstring,
+		MASK => $mask,
+		BLURB => $blurb
+	};
+
+	return $index;
+}
+
+sub DumpHfDeclaration()
+{
+	my $res = "";
+
+	$res = "\n/* Header field declarations */\n";
+
+	foreach (keys %hf) 
+	{
+		$res .= "static gint $_ = -1;\n";
+	}
+
+	return "$res\n";
+}
+
+sub DumpHfList()
+{
+	my $res = "\tstatic hf_register_info hf[] = {\n";
+
+	foreach (values %hf) 
+	{
+		$res .= "\t{ &$_->{INDEX}, 
+	  { \"$_->{NAME}\", \"$_->{FILTER}\", $_->{FT_TYPE}, $_->{BASE_TYPE}, $_->{VALS}, $_->{MASK}, \"$_->{BLURB}\", HFILL }},
+";
+	}
+
+	return $res."\t};\n";
+}
+
+
+###############################################################################
+# Function table
+###############################################################################
+
+sub DumpFunctionTable($)
+{
+	my $if = shift;
+
+	my $res = "static dcerpc_sub_dissector $if->{NAME}\_dissectors[] = {\n";
+	foreach (@{$if->{FUNCTIONS}}) {
+	        my $fn_name = $_->{NAME};
+		$fn_name =~ s/^$if->{NAME}_//;
+		$res.= "\t{ $_->{OPNUM}, \"$fn_name\",\n";
+		$res.= "\t   $if->{NAME}_dissect_${fn_name}_request, $if->{NAME}_dissect_${fn_name}_response},\n";
+	}
+
+	$res .= "\t{ 0, NULL, NULL, NULL }\n";
+
+	return "$res};\n";
+}
+
+1;
diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm
new file mode 100644
index 0000000000..7f7e5bcdca
--- /dev/null
+++ b/source4/pidl/lib/Parse/Pidl/IDL.pm
@@ -0,0 +1,2609 @@
+####################################################################
+#
+#    This file was generated using Parse::Yapp version 1.05.
+#
+#        Don't edit this file, use source file instead.
+#
+#             ANY CHANGE MADE HERE WILL BE LOST !
+#
+####################################################################
+package Parse::Pidl::IDL;
+use vars qw ( @ISA );
+use strict;
+
+@ISA= qw ( Parse::Yapp::Driver );
+#Included Parse/Yapp/Driver.pm file----------------------------------------
+{
+#
+# Module Parse::Yapp::Driver
+#
+# This module is part of the Parse::Yapp package available on your
+# nearest CPAN
+#
+# Any use of this module in a standalone parser make the included
+# text under the same copyright as the Parse::Yapp module itself.
+#
+# This notice should remain unchanged.
+#
+# (c) Copyright 1998-2001 Francois Desarmenien, all rights reserved.
+# (see the pod text in Parse::Yapp module for use and distribution rights)
+#
+
+package Parse::Yapp::Driver;
+
+require 5.004;
+
+use strict;
+
+use vars qw ( $VERSION $COMPATIBLE $FILENAME );
+
+$VERSION = '1.05';
+$COMPATIBLE = '0.07';
+$FILENAME=__FILE__;
+
+use Carp;
+
+#Known parameters, all starting with YY (leading YY will be discarded)
+my(%params)=(YYLEX => 'CODE', 'YYERROR' => 'CODE', YYVERSION => '',
+			 YYRULES => 'ARRAY', YYSTATES => 'ARRAY', YYDEBUG => '');
+#Mandatory parameters
+my(@params)=('LEX','RULES','STATES');
+
+sub new {
+    my($class)=shift;
+	my($errst,$nberr,$token,$value,$check,$dotpos);
+    my($self)={ ERROR => \&_Error,
+				ERRST => \$errst,
+                NBERR => \$nberr,
+				TOKEN => \$token,
+				VALUE => \$value,
+				DOTPOS => \$dotpos,
+				STACK => [],
+				DEBUG => 0,
+				CHECK => \$check };
+
+	_CheckParams( [], \%params, \@_, $self );
+
+		exists($$self{VERSION})
+	and	$$self{VERSION} < $COMPATIBLE
+	and	croak "Yapp driver version $VERSION ".
+			  "incompatible with version $$self{VERSION}:\n".
+			  "Please recompile parser module.";
+
+        ref($class)
+    and $class=ref($class);
+
+    bless($self,$class);
+}
+
+sub YYParse {
+    my($self)=shift;
+    my($retval);
+
+	_CheckParams( \@params, \%params, \@_, $self );
+
+	if($$self{DEBUG}) {
+		_DBLoad();
+		$retval = eval '$self->_DBParse()';#Do not create stab entry on compile
+        $@ and die $@;
+	}
+	else {
+		$retval = $self->_Parse();
+	}
+    $retval
+}
+
+sub YYData {
+	my($self)=shift;
+
+		exists($$self{USER})
+	or	$$self{USER}={};
+
+	$$self{USER};
+	
+}
+
+sub YYErrok {
+	my($self)=shift;
+
+	${$$self{ERRST}}=0;
+    undef;
+}
+
+sub YYNberr {
+	my($self)=shift;
+
+	${$$self{NBERR}};
+}
+
+sub YYRecovering {
+	my($self)=shift;
+
+	${$$self{ERRST}} != 0;
+}
+
+sub YYAbort {
+	my($self)=shift;
+
+	${$$self{CHECK}}='ABORT';
+    undef;
+}
+
+sub YYAccept {
+	my($self)=shift;
+
+	${$$self{CHECK}}='ACCEPT';
+    undef;
+}
+
+sub YYError {
+	my($self)=shift;
+
+	${$$self{CHECK}}='ERROR';
+    undef;
+}
+
+sub YYSemval {
+	my($self)=shift;
+	my($index)= $_[0] - ${$$self{DOTPOS}} - 1;
+
+		$index < 0
+	and	-$index <= @{$$self{STACK}}
+	and	return $$self{STACK}[$index][1];
+
+	undef;	#Invalid index
+}
+
+sub YYCurtok {
+	my($self)=shift;
+
+        @_
+    and ${$$self{TOKEN}}=$_[0];
+    ${$$self{TOKEN}};
+}
+
+sub YYCurval {
+	my($self)=shift;
+
+        @_
+    and ${$$self{VALUE}}=$_[0];
+    ${$$self{VALUE}};
+}
+
+sub YYExpect {
+    my($self)=shift;
+
+    keys %{$self->{STATES}[$self->{STACK}[-1][0]]{ACTIONS}}
+}
+
+sub YYLexer {
+    my($self)=shift;
+
+	$$self{LEX};
+}
+
+
+#################
+# Private stuff #
+#################
+
+
+sub _CheckParams {
+	my($mandatory,$checklist,$inarray,$outhash)=@_;
+	my($prm,$value);
+	my($prmlst)={};
+
+	while(($prm,$value)=splice(@$inarray,0,2)) {
+        $prm=uc($prm);
+			exists($$checklist{$prm})
+		or	croak("Unknow parameter '$prm'");
+			ref($value) eq $$checklist{$prm}
+		or	croak("Invalid value for parameter '$prm'");
+        $prm=unpack('@2A*',$prm);
+		$$outhash{$prm}=$value;
+	}
+	for (@$mandatory) {
+			exists($$outhash{$_})
+		or	croak("Missing mandatory parameter '".lc($_)."'");
+	}
+}
+
+sub _Error {
+	print "Parse error.\n";
+}
+
+sub _DBLoad {
+	{
+		no strict 'refs';
+
+			exists(${__PACKAGE__.'::'}{_DBParse})#Already loaded ?
+		and	return;
+	}
+	my($fname)=__FILE__;
+	my(@drv);
+	open(DRV,"<$fname") or die "Report this as a BUG: Cannot open $fname";
+	while(<DRV>) {
+                	/^\s*sub\s+_Parse\s*{\s*$/ .. /^\s*}\s*#\s*_Parse\s*$/
+        	and     do {
+                	s/^#DBG>//;
+                	push(@drv,$_);
+        	}
+	}
+	close(DRV);
+
+	$drv[0]=~s/_P/_DBP/;
+	eval join('',@drv);
+}
+
+#Note that for loading debugging version of the driver,
+#this file will be parsed from 'sub _Parse' up to '}#_Parse' inclusive.
+#So, DO NOT remove comment at end of sub !!!
+sub _Parse {
+    my($self)=shift;
+
+	my($rules,$states,$lex,$error)
+     = @$self{ 'RULES', 'STATES', 'LEX', 'ERROR' };
+	my($errstatus,$nberror,$token,$value,$stack,$check,$dotpos)
+     = @$self{ 'ERRST', 'NBERR', 'TOKEN', 'VALUE', 'STACK', 'CHECK', 'DOTPOS' };
+
+#DBG>	my($debug)=$$self{DEBUG};
+#DBG>	my($dbgerror)=0;
+
+#DBG>	my($ShowCurToken) = sub {
+#DBG>		my($tok)='>';
+#DBG>		for (split('',$$token)) {
+#DBG>			$tok.=		(ord($_) < 32 or ord($_) > 126)
+#DBG>					?	sprintf('<%02X>',ord($_))
+#DBG>					:	$_;
+#DBG>		}
+#DBG>		$tok.='<';
+#DBG>	};
+
+	$$errstatus=0;
+	$$nberror=0;
+	($$token,$$value)=(undef,undef);
+	@$stack=( [ 0, undef ] );
+	$$check='';
+
+    while(1) {
+        my($actions,$act,$stateno);
+
+        $stateno=$$stack[-1][0];
+        $actions=$$states[$stateno];
+
+#DBG>	print STDERR ('-' x 40),"\n";
+#DBG>		$debug & 0x2
+#DBG>	and	print STDERR "In state $stateno:\n";
+#DBG>		$debug & 0x08
+#DBG>	and	print STDERR "Stack:[".
+#DBG>					 join(',',map { $$_[0] } @$stack).
+#DBG>					 "]\n";
+
+
+        if  (exists($$actions{ACTIONS})) {
+
+				defined($$token)
+            or	do {
+				($$token,$$value)=&$lex($self);
+#DBG>				$debug & 0x01
+#DBG>			and	print STDERR "Need token. Got ".&$ShowCurToken."\n";
+			};
+
+            $act=   exists($$actions{ACTIONS}{$$token})
+                    ?   $$actions{ACTIONS}{$$token}
+                    :   exists($$actions{DEFAULT})
+                        ?   $$actions{DEFAULT}
+                        :   undef;
+        }
+        else {
+            $act=$$actions{DEFAULT};
+#DBG>			$debug & 0x01
+#DBG>		and	print STDERR "Don't need token.\n";
+        }
+
+            defined($act)
+        and do {
+
+                $act > 0
+            and do {        #shift
+
+#DBG>				$debug & 0x04
+#DBG>			and	print STDERR "Shift and go to state $act.\n";
+
+					$$errstatus
+				and	do {
+					--$$errstatus;
+
+#DBG>					$debug & 0x10
+#DBG>				and	$dbgerror
+#DBG>				and	$$errstatus == 0
+#DBG>				and	do {
+#DBG>					print STDERR "**End of Error recovery.\n";
+#DBG>					$dbgerror=0;
+#DBG>				};
+				};
+
+
+                push(@$stack,[ $act, $$value ]);
+
+					$$token ne ''	#Don't eat the eof
+				and	$$token=$$value=undef;
+                next;
+            };
+
+            #reduce
+            my($lhs,$len,$code,@sempar,$semval);
+            ($lhs,$len,$code)=@{$$rules[-$act]};
+
+#DBG>			$debug & 0x04
+#DBG>		and	$act
+#DBG>		and	print STDERR "Reduce using rule ".-$act." ($lhs,$len): ";
+
+                $act
+            or  $self->YYAccept();
+
+            $$dotpos=$len;
+
+                unpack('A1',$lhs) eq '@'    #In line rule
+            and do {
+                    $lhs =~ /^\@[0-9]+\-([0-9]+)$/
+                or  die "In line rule name '$lhs' ill formed: ".
+                        "report it as a BUG.\n";
+                $$dotpos = $1;
+            };
+
+            @sempar =       $$dotpos
+                        ?   map { $$_[1] } @$stack[ -$$dotpos .. -1 ]
+                        :   ();
+
+            $semval = $code ? &$code( $self, @sempar )
+                            : @sempar ? $sempar[0] : undef;
+
+            splice(@$stack,-$len,$len);
+
+                $$check eq 'ACCEPT'
+            and do {
+
+#DBG>			$debug & 0x04
+#DBG>		and	print STDERR "Accept.\n";
+
+				return($semval);
+			};
+
+                $$check eq 'ABORT'
+            and	do {
+
+#DBG>			$debug & 0x04
+#DBG>		and	print STDERR "Abort.\n";
+
+				return(undef);
+
+			};
+
+#DBG>			$debug & 0x04
+#DBG>		and	print STDERR "Back to state $$stack[-1][0], then ";
+
+                $$check eq 'ERROR'
+            or  do {
+#DBG>				$debug & 0x04
+#DBG>			and	print STDERR 
+#DBG>				    "go to state $$states[$$stack[-1][0]]{GOTOS}{$lhs}.\n";
+
+#DBG>				$debug & 0x10
+#DBG>			and	$dbgerror
+#DBG>			and	$$errstatus == 0
+#DBG>			and	do {
+#DBG>				print STDERR "**End of Error recovery.\n";
+#DBG>				$dbgerror=0;
+#DBG>			};
+
+			    push(@$stack,
+                     [ $$states[$$stack[-1][0]]{GOTOS}{$lhs}, $semval ]);
+                $$check='';
+                next;
+            };
+
+#DBG>			$debug & 0x04
+#DBG>		and	print STDERR "Forced Error recovery.\n";
+
+            $$check='';
+
+        };
+
+        #Error
+            $$errstatus
+        or   do {
+
+            $$errstatus = 1;
+            &$error($self);
+                $$errstatus # if 0, then YYErrok has been called
+            or  next;       # so continue parsing
+
+#DBG>			$debug & 0x10
+#DBG>		and	do {
+#DBG>			print STDERR "**Entering Error recovery.\n";
+#DBG>			++$dbgerror;
+#DBG>		};
+
+            ++$$nberror;
+
+        };
+
+			$$errstatus == 3	#The next token is not valid: discard it
+		and	do {
+				$$token eq ''	# End of input: no hope
+			and	do {
+#DBG>				$debug & 0x10
+#DBG>			and	print STDERR "**At eof: aborting.\n";
+				return(undef);
+			};
+
+#DBG>			$debug & 0x10
+#DBG>		and	print STDERR "**Dicard invalid token ".&$ShowCurToken.".\n";
+
+			$$token=$$value=undef;
+		};
+
+        $$errstatus=3;
+
+		while(	  @$stack
+			  and (		not exists($$states[$$stack[-1][0]]{ACTIONS})
+			        or  not exists($$states[$$stack[-1][0]]{ACTIONS}{error})
+					or	$$states[$$stack[-1][0]]{ACTIONS}{error} <= 0)) {
+
+#DBG>			$debug & 0x10
+#DBG>		and	print STDERR "**Pop state $$stack[-1][0].\n";
+
+			pop(@$stack);
+		}
+
+			@$stack
+		or	do {
+
+#DBG>			$debug & 0x10
+#DBG>		and	print STDERR "**No state left on stack: aborting.\n";
+
+			return(undef);
+		};
+
+		#shift the error token
+
+#DBG>			$debug & 0x10
+#DBG>		and	print STDERR "**Shift \$error token and go to state ".
+#DBG>						 $$states[$$stack[-1][0]]{ACTIONS}{error}.
+#DBG>						 ".\n";
+
+		push(@$stack, [ $$states[$$stack[-1][0]]{ACTIONS}{error}, undef ]);
+
+    }
+
+    #never reached
+	croak("Error in driver logic. Please, report it as a BUG");
+
+}#_Parse
+#DO NOT remove comment
+
+1;
+
+}
+#End of include--------------------------------------------------
+
+
+
+
+sub new {
+        my($class)=shift;
+        ref($class)
+    and $class=ref($class);
+
+    my($self)=$class->SUPER::new( yyversion => '1.05',
+                                  yystates =>
+[
+	{#State 0
+		DEFAULT => -1,
+		GOTOS => {
+			'idl' => 1
+		}
+	},
+	{#State 1
+		ACTIONS => {
+			'' => 2
+		},
+		DEFAULT => -63,
+		GOTOS => {
+			'interface' => 3,
+			'coclass' => 4,
+			'property_list' => 5
+		}
+	},
+	{#State 2
+		DEFAULT => 0
+	},
+	{#State 3
+		DEFAULT => -2
+	},
+	{#State 4
+		DEFAULT => -3
+	},
+	{#State 5
+		ACTIONS => {
+			"coclass" => 6,
+			"interface" => 8,
+			"[" => 7
+		}
+	},
+	{#State 6
+		ACTIONS => {
+			'IDENTIFIER' => 9
+		},
+		GOTOS => {
+			'identifier' => 10
+		}
+	},
+	{#State 7
+		ACTIONS => {
+			'IDENTIFIER' => 9
+		},
+		GOTOS => {
+			'identifier' => 11,
+			'properties' => 13,
+			'property' => 12
+		}
+	},
+	{#State 8
+		ACTIONS => {
+			'IDENTIFIER' => 9
+		},
+		GOTOS => {
+			'identifier' => 14
+		}
+	},
+	{#State 9
+		DEFAULT => -89
+	},
+	{#State 10
+		ACTIONS => {
+			"{" => 15
+		}
+	},
+	{#State 11
+		ACTIONS => {
+			"(" => 16
+		},
+		DEFAULT => -67
+	},
+	{#State 12
+		DEFAULT => -65
+	},
+	{#State 13
+		ACTIONS => {
+			"," => 17,
+			"]" => 18
+		}
+	},
+	{#State 14
+		ACTIONS => {
+			":" => 19
+		},
+		DEFAULT => -8,
+		GOTOS => {
+			'base_interface' => 20
+		}
+	},
+	{#State 15
+		DEFAULT => -5,
+		GOTOS => {
+			'interface_names' => 21
+		}
+	},
+	{#State 16
+		ACTIONS => {
+			'CONSTANT' => 28,
+			'TEXT' => 22,
+			'IDENTIFIER' => 9
+		},
+		DEFAULT => -73,
+		GOTOS => {
+			'identifier' => 23,
+			'listtext' => 26,
+			'anytext' => 25,
+			'text' => 24,
+			'constant' => 27
+		}
+	},
+	{#State 17
+		ACTIONS => {
+			'IDENTIFIER' => 9
+		},
+		GOTOS => {
+			'identifier' => 11,
+			'property' => 29
+		}
+	},
+	{#State 18
+		DEFAULT => -64
+	},
+	{#State 19
+		ACTIONS => {
+			'IDENTIFIER' => 9
+		},
+		GOTOS => {
+			'identifier' => 30
+		}
+	},
+	{#State 20
+		ACTIONS => {
+			"{" => 31
+		}
+	},
+	{#State 21
+		ACTIONS => {
+			"}" => 32,
+			"interface" => 33
+		}
+	},
+	{#State 22
+		DEFAULT => -93
+	},
+	{#State 23
+		DEFAULT => -74
+	},
+	{#State 24
+		DEFAULT => -76
+	},
+	{#State 25
+		ACTIONS => {
+			"-" => 34,
+			"<" => 35,
+			"+" => 37,
+			"~" => 36,
+			"&" => 39,
+			"{" => 38,
+			"/" => 40,
+			"(" => 41,
+			"|" => 42,
+			"*" => 43,
+			"." => 44,
+			">" => 45
+		},
+		DEFAULT => -69
+	},
+	{#State 26
+		ACTIONS => {
+			"," => 46,
+			")" => 47
+		}
+	},
+	{#State 27
+		DEFAULT => -75
+	},
+	{#State 28
+		DEFAULT => -92
+	},
+	{#State 29
+		DEFAULT => -66
+	},
+	{#State 30
+		DEFAULT => -9
+	},
+	{#State 31
+		ACTIONS => {
+			"typedef" => 48,
+			"union" => 49,
+			"enum" => 62,
+			"bitmap" => 63,
+			"declare" => 55,
+			"const" => 57,
+			"struct" => 60
+		},
+		DEFAULT => -63,
+		GOTOS => {
+			'typedecl' => 61,
+			'function' => 50,
+			'bitmap' => 64,
+			'definitions' => 51,
+			'definition' => 54,
+			'property_list' => 53,
+			'usertype' => 52,
+			'declare' => 66,
+			'const' => 65,
+			'struct' => 56,
+			'enum' => 58,
+			'typedef' => 59,
+			'union' => 67
+		}
+	},
+	{#State 32
+		ACTIONS => {
+			";" => 68
+		},
+		DEFAULT => -94,
+		GOTOS => {
+			'optional_semicolon' => 69
+		}
+	},
+	{#State 33
+		ACTIONS => {
+			'IDENTIFIER' => 9
+		},
+		GOTOS => {
+			'identifier' => 70
+		}
+	},
+	{#State 34
+		ACTIONS => {
+			'CONSTANT' => 28,
+			'TEXT' => 22,
+			'IDENTIFIER' => 9
+		},
+		DEFAULT => -73,
+		GOTOS => {
+			'identifier' => 23,
+			'anytext' => 71,
+			'text' => 24,
+			'constant' => 27
+		}
+	},
+	{#State 35
+		ACTIONS => {
+			'CONSTANT' => 28,
+			'TEXT' => 22,
+			'IDENTIFIER' => 9
+		},
+		DEFAULT => -73,
+		GOTOS => {
+			'identifier' => 23,
+			'anytext' => 72,
+			'text' => 24,
+			'constant' => 27
+		}
+	},
+	{#State 36
+		ACTIONS => {
+			'CONSTANT' => 28,
+			'TEXT' => 22,
+			'IDENTIFIER' => 9
+		},
+		DEFAULT => -73,
+		GOTOS => {
+			'identifier' => 23,
+			'anytext' => 73,
+			'text' => 24,
+			'constant' => 27
+		}
+	},
+	{#State 37
+		ACTIONS => {
+			'CONSTANT' => 28,
+			'TEXT' => 22,
+			'IDENTIFIER' => 9
+		},
+		DEFAULT => -73,
+		GOTOS => {
+			'identifier' => 23,
+			'anytext' => 74,
+			'text' => 24,
+			'constant' => 27
+		}
+	},
+	{#State 38
+		ACTIONS => {
+			'CONSTANT' => 28,
+			'TEXT' => 22,
+			'IDENTIFIER' => 9
+		},
+		DEFAULT => -73,
+		GOTOS => {
+			'identifier' => 23,
+			'anytext' => 75,
+			'text' => 24,
+			'constant' => 27,
+			'commalisttext' => 76
+		}
+	},
+	{#State 39
+		ACTIONS => {
+			'CONSTANT' => 28,
+			'TEXT' => 22,
+			'IDENTIFIER' => 9
+		},
+		DEFAULT => -73,
+		GOTOS => {
+			'identifier' => 23,
+			'anytext' => 77,
+			'text' => 24,
+			'constant' => 27
+		}
+	},
+	{#State 40
+		ACTIONS => {
+			'CONSTANT' => 28,
+			'TEXT' => 22,
+			'IDENTIFIER' => 9
+		},
+		DEFAULT => -73,
+		GOTOS => {
+			'identifier' => 23,
+			'anytext' => 78,
+			'text' => 24,
+			'constant' => 27
+		}
+	},
+	{#State 41
+		ACTIONS => {
+			'CONSTANT' => 28,
+			'TEXT' => 22,
+			'IDENTIFIER' => 9
+		},
+		DEFAULT => -73,
+		GOTOS => {
+			'identifier' => 23,
+			'anytext' => 75,
+			'text' => 24,
+			'constant' => 27,
+			'commalisttext' => 79
+		}
+	},
+	{#State 42
+		ACTIONS => {
+			'CONSTANT' => 28,
+			'TEXT' => 22,
+			'IDENTIFIER' => 9
+		},
+		DEFAULT => -73,
+		GOTOS => {
+			'identifier' => 23,
+			'anytext' => 80,
+			'text' => 24,
+			'constant' => 27
+		}
+	},
+	{#State 43
+		ACTIONS => {
+			'CONSTANT' => 28,
+			'TEXT' => 22,
+			'IDENTIFIER' => 9
+		},
+		DEFAULT => -73,
+		GOTOS => {
+			'identifier' => 23,
+			'anytext' => 81,
+			'text' => 24,
+			'constant' => 27
+		}
+	},
+	{#State 44
+		ACTIONS => {
+			'CONSTANT' => 28,
+			'TEXT' => 22,
+			'IDENTIFIER' => 9
+		},
+		DEFAULT => -73,
+		GOTOS => {
+			'identifier' => 23,
+			'anytext' => 82,
+			'text' => 24,
+			'constant' => 27
+		}
+	},
+	{#State 45
+		ACTIONS => {
+			'CONSTANT' => 28,
+			'TEXT' => 22,
+			'IDENTIFIER' => 9
+		},
+		DEFAULT => -73,
+		GOTOS => {
+			'identifier' => 23,
+			'anytext' => 83,
+			'text' => 24,
+			'constant' => 27
+		}
+	},
+	{#State 46
+		ACTIONS => {
+			'CONSTANT' => 28,
+			'TEXT' => 22,
+			'IDENTIFIER' => 9
+		},
+		DEFAULT => -73,
+		GOTOS => {
+			'identifier' => 23,
+			'anytext' => 84,
+			'text' => 24,
+			'constant' => 27
+		}
+	},
+	{#State 47
+		DEFAULT => -68
+	},
+	{#State 48
+		DEFAULT => -63,
+		GOTOS => {
+			'property_list' => 85
+		}
+	},
+	{#State 49
+		ACTIONS => {
+			'IDENTIFIER' => 86
+		},
+		DEFAULT => -91,
+		GOTOS => {
+			'optional_identifier' => 87
+		}
+	},
+	{#State 50
+		DEFAULT => -12
+	},
+	{#State 51
+		ACTIONS => {
+			"}" => 88,
+			"typedef" => 48,
+			"union" => 49,
+			"enum" => 62,
+			"bitmap" => 63,
+			"declare" => 55,
+			"const" => 57,
+			"struct" => 60
+		},
+		DEFAULT => -63,
+		GOTOS => {
+			'typedecl' => 61,
+			'function' => 50,
+			'bitmap' => 64,
+			'definition' => 89,
+			'property_list' => 53,
+			'usertype' => 52,
+			'const' => 65,
+			'struct' => 56,
+			'declare' => 66,
+			'enum' => 58,
+			'typedef' => 59,
+			'union' => 67
+		}
+	},
+	{#State 52
+		ACTIONS => {
+			";" => 90
+		}
+	},
+	{#State 53
+		ACTIONS => {
+			'IDENTIFIER' => 9,
+			"union" => 49,
+			"enum" => 62,
+			"bitmap" => 63,
+			"[" => 7,
+			'void' => 91,
+			"struct" => 60
+		},
+		GOTOS => {
+			'identifier' => 93,
+			'struct' => 56,
+			'enum' => 58,
+			'type' => 94,
+			'union' => 67,
+			'bitmap' => 64,
+			'usertype' => 92
+		}
+	},
+	{#State 54
+		DEFAULT => -10
+	},
+	{#State 55
+		DEFAULT => -63,
+		GOTOS => {
+			'property_list' => 95
+		}
+	},
+	{#State 56
+		DEFAULT => -26
+	},
+	{#State 57
+		ACTIONS => {
+			'IDENTIFIER' => 9
+		},
+		GOTOS => {
+			'identifier' => 96
+		}
+	},
+	{#State 58
+		DEFAULT => -28
+	},
+	{#State 59
+		DEFAULT => -14
+	},
+	{#State 60
+		ACTIONS => {
+			'IDENTIFIER' => 86
+		},
+		DEFAULT => -91,
+		GOTOS => {
+			'optional_identifier' => 97
+		}
+	},
+	{#State 61
+		DEFAULT => -16
+	},
+	{#State 62
+		ACTIONS => {
+			'IDENTIFIER' => 86
+		},
+		DEFAULT => -91,
+		GOTOS => {
+			'optional_identifier' => 98
+		}
+	},
+	{#State 63
+		ACTIONS => {
+			'IDENTIFIER' => 86
+		},
+		DEFAULT => -91,
+		GOTOS => {
+			'optional_identifier' => 99
+		}
+	},
+	{#State 64
+		DEFAULT => -29
+	},
+	{#State 65
+		DEFAULT => -13
+	},
+	{#State 66
+		DEFAULT => -15
+	},
+	{#State 67
+		DEFAULT => -27
+	},
+	{#State 68
+		DEFAULT => -95
+	},
+	{#State 69
+		DEFAULT => -4
+	},
+	{#State 70
+		ACTIONS => {
+			";" => 100
+		}
+	},
+	{#State 71
+		ACTIONS => {
+			"<" => 35,
+			"~" => 36,
+			"{" => 38
+		},
+		DEFAULT => -77
+	},
+	{#State 72
+		ACTIONS => {
+			"-" => 34,
+			"<" => 35,
+			"+" => 37,
+			"~" => 36,
+			"*" => 43,
+			"{" => 38,
+			"&" => 39,
+			"/" => 40,
+			"(" => 41,
+			"|" => 42,
+			"." => 44,
+			">" => 45
+		},
+		DEFAULT => -81
+	},
+	{#State 73
+		ACTIONS => {
+			"-" => 34,
+			"<" => 35,
+			"+" => 37,
+			"~" => 36,
+			"*" => 43,
+			"{" => 38,
+			"&" => 39,
+			"/" => 40,
+			"(" => 41,
+			"|" => 42,
+			"." => 44,
+			">" => 45
+		},
+		DEFAULT => -86
+	},
+	{#State 74
+		ACTIONS => {
+			"<" => 35,
+			"~" => 36,
+			"{" => 38
+		},
+		DEFAULT => -85
+	},
+	{#State 75
+		ACTIONS => {
+			"-" => 34,
+			"<" => 35,
+			"+" => 37,
+			"~" => 36,
+			"*" => 43,
+			"{" => 38,
+			"&" => 39,
+			"/" => 40,
+			"(" => 41,
+			"|" => 42,
+			"." => 44,
+			">" => 45
+		},
+		DEFAULT => -71
+	},
+	{#State 76
+		ACTIONS => {
+			"}" => 101,
+			"," => 102
+		}
+	},
+	{#State 77
+		ACTIONS => {
+			"<" => 35,
+			"~" => 36,
+			"{" => 38
+		},
+		DEFAULT => -83
+	},
+	{#State 78
+		ACTIONS => {
+			"<" => 35,
+			"~" => 36,
+			"{" => 38
+		},
+		DEFAULT => -84
+	},
+	{#State 79
+		ACTIONS => {
+			"," => 102,
+			")" => 103
+		}
+	},
+	{#State 80
+		ACTIONS => {
+			"<" => 35,
+			"~" => 36,
+			"{" => 38
+		},
+		DEFAULT => -82
+	},
+	{#State 81
+		ACTIONS => {
+			"<" => 35,
+			"~" => 36,
+			"{" => 38
+		},
+		DEFAULT => -79
+	},
+	{#State 82
+		ACTIONS => {
+			"<" => 35,
+			"~" => 36,
+			"{" => 38
+		},
+		DEFAULT => -78
+	},
+	{#State 83
+		ACTIONS => {
+			"<" => 35,
+			"~" => 36,
+			"{" => 38
+		},
+		DEFAULT => -80
+	},
+	{#State 84
+		ACTIONS => {
+			"-" => 34,
+			"<" => 35,
+			"+" => 37,
+			"~" => 36,
+			"&" => 39,
+			"{" => 38,
+			"/" => 40,
+			"|" => 42,
+			"(" => 41,
+			"*" => 43,
+			"." => 44,
+			">" => 45
+		},
+		DEFAULT => -70
+	},
+	{#State 85
+		ACTIONS => {
+			'IDENTIFIER' => 9,
+			"union" => 49,
+			"enum" => 62,
+			"bitmap" => 63,
+			"[" => 7,
+			'void' => 91,
+			"struct" => 60
+		},
+		GOTOS => {
+			'identifier' => 93,
+			'struct' => 56,
+			'enum' => 58,
+			'type' => 104,
+			'union' => 67,
+			'bitmap' => 64,
+			'usertype' => 92
+		}
+	},
+	{#State 86
+		DEFAULT => -90
+	},
+	{#State 87
+		ACTIONS => {
+			"{" => 105
+		}
+	},
+	{#State 88
+		ACTIONS => {
+			";" => 68
+		},
+		DEFAULT => -94,
+		GOTOS => {
+			'optional_semicolon' => 106
+		}
+	},
+	{#State 89
+		DEFAULT => -11
+	},
+	{#State 90
+		DEFAULT => -30
+	},
+	{#State 91
+		DEFAULT => -33
+	},
+	{#State 92
+		DEFAULT => -31
+	},
+	{#State 93
+		DEFAULT => -32
+	},
+	{#State 94
+		ACTIONS => {
+			'IDENTIFIER' => 9
+		},
+		GOTOS => {
+			'identifier' => 107
+		}
+	},
+	{#State 95
+		ACTIONS => {
+			"enum" => 111,
+			"bitmap" => 112,
+			"[" => 7
+		},
+		GOTOS => {
+			'decl_enum' => 108,
+			'decl_bitmap' => 109,
+			'decl_type' => 110
+		}
+	},
+	{#State 96
+		ACTIONS => {
+			'IDENTIFIER' => 9
+		},
+		GOTOS => {
+			'identifier' => 113
+		}
+	},
+	{#State 97
+		ACTIONS => {
+			"{" => 114
+		}
+	},
+	{#State 98
+		ACTIONS => {
+			"{" => 115
+		}
+	},
+	{#State 99
+		ACTIONS => {
+			"{" => 116
+		}
+	},
+	{#State 100
+		DEFAULT => -6
+	},
+	{#State 101
+		ACTIONS => {
+			'CONSTANT' => 28,
+			'TEXT' => 22,
+			'IDENTIFIER' => 9
+		},
+		DEFAULT => -73,
+		GOTOS => {
+			'identifier' => 23,
+			'anytext' => 117,
+			'text' => 24,
+			'constant' => 27
+		}
+	},
+	{#State 102
+		ACTIONS => {
+			'CONSTANT' => 28,
+			'TEXT' => 22,
+			'IDENTIFIER' => 9
+		},
+		DEFAULT => -73,
+		GOTOS => {
+			'identifier' => 23,
+			'anytext' => 118,
+			'text' => 24,
+			'constant' => 27
+		}
+	},
+	{#State 103
+		ACTIONS => {
+			'CONSTANT' => 28,
+			'TEXT' => 22,
+			'IDENTIFIER' => 9
+		},
+		DEFAULT => -73,
+		GOTOS => {
+			'identifier' => 23,
+			'anytext' => 119,
+			'text' => 24,
+			'constant' => 27
+		}
+	},
+	{#State 104
+		ACTIONS => {
+			'IDENTIFIER' => 9
+		},
+		GOTOS => {
+			'identifier' => 120
+		}
+	},
+	{#State 105
+		DEFAULT => -48,
+		GOTOS => {
+			'union_elements' => 121
+		}
+	},
+	{#State 106
+		DEFAULT => -7
+	},
+	{#State 107
+		ACTIONS => {
+			"(" => 122
+		}
+	},
+	{#State 108
+		DEFAULT => -21
+	},
+	{#State 109
+		DEFAULT => -22
+	},
+	{#State 110
+		ACTIONS => {
+			'IDENTIFIER' => 9
+		},
+		GOTOS => {
+			'identifier' => 123
+		}
+	},
+	{#State 111
+		DEFAULT => -23
+	},
+	{#State 112
+		DEFAULT => -24
+	},
+	{#State 113
+		ACTIONS => {
+			"[" => 124,
+			"=" => 126
+		},
+		GOTOS => {
+			'array_len' => 125
+		}
+	},
+	{#State 114
+		DEFAULT => -54,
+		GOTOS => {
+			'element_list1' => 127
+		}
+	},
+	{#State 115
+		ACTIONS => {
+			'IDENTIFIER' => 9
+		},
+		GOTOS => {
+			'identifier' => 128,
+			'enum_element' => 129,
+			'enum_elements' => 130
+		}
+	},
+	{#State 116
+		ACTIONS => {
+			'IDENTIFIER' => 9
+		},
+		GOTOS => {
+			'identifier' => 133,
+			'bitmap_elements' => 132,
+			'bitmap_element' => 131
+		}
+	},
+	{#State 117
+		ACTIONS => {
+			"-" => 34,
+			"<" => 35,
+			"+" => 37,
+			"~" => 36,
+			"*" => 43,
+			"{" => 38,
+			"&" => 39,
+			"/" => 40,
+			"(" => 41,
+			"|" => 42,
+			"." => 44,
+			">" => 45
+		},
+		DEFAULT => -88
+	},
+	{#State 118
+		ACTIONS => {
+			"-" => 34,
+			"<" => 35,
+			"+" => 37,
+			"~" => 36,
+			"*" => 43,
+			"{" => 38,
+			"&" => 39,
+			"/" => 40,
+			"(" => 41,
+			"|" => 42,
+			"." => 44,
+			">" => 45
+		},
+		DEFAULT => -72
+	},
+	{#State 119
+		ACTIONS => {
+			"<" => 35,
+			"~" => 36,
+			"{" => 38
+		},
+		DEFAULT => -87
+	},
+	{#State 120
+		ACTIONS => {
+			"[" => 124
+		},
+		DEFAULT => -60,
+		GOTOS => {
+			'array_len' => 134
+		}
+	},
+	{#State 121
+		ACTIONS => {
+			"}" => 135
+		},
+		DEFAULT => -63,
+		GOTOS => {
+			'optional_base_element' => 137,
+			'property_list' => 136
+		}
+	},
+	{#State 122
+		ACTIONS => {
+			"," => -56,
+			"void" => 141,
+			")" => -56
+		},
+		DEFAULT => -63,
+		GOTOS => {
+			'base_element' => 138,
+			'element_list2' => 140,
+			'property_list' => 139
+		}
+	},
+	{#State 123
+		ACTIONS => {
+			";" => 142
+		}
+	},
+	{#State 124
+		ACTIONS => {
+			'CONSTANT' => 28,
+			'TEXT' => 22,
+			"]" => 143,
+			'IDENTIFIER' => 9
+		},
+		DEFAULT => -73,
+		GOTOS => {
+			'identifier' => 23,
+			'anytext' => 144,
+			'text' => 24,
+			'constant' => 27
+		}
+	},
+	{#State 125
+		ACTIONS => {
+			"=" => 145
+		}
+	},
+	{#State 126
+		ACTIONS => {
+			'CONSTANT' => 28,
+			'TEXT' => 22,
+			'IDENTIFIER' => 9
+		},
+		DEFAULT => -73,
+		GOTOS => {
+			'identifier' => 23,
+			'anytext' => 146,
+			'text' => 24,
+			'constant' => 27
+		}
+	},
+	{#State 127
+		ACTIONS => {
+			"}" => 147
+		},
+		DEFAULT => -63,
+		GOTOS => {
+			'base_element' => 148,
+			'property_list' => 139
+		}
+	},
+	{#State 128
+		ACTIONS => {
+			"=" => 149
+		},
+		DEFAULT => -37
+	},
+	{#State 129
+		DEFAULT => -35
+	},
+	{#State 130
+		ACTIONS => {
+			"}" => 150,
+			"," => 151
+		}
+	},
+	{#State 131
+		DEFAULT => -40
+	},
+	{#State 132
+		ACTIONS => {
+			"}" => 152,
+			"," => 153
+		}
+	},
+	{#State 133
+		ACTIONS => {
+			"=" => 154
+		}
+	},
+	{#State 134
+		ACTIONS => {
+			";" => 155
+		}
+	},
+	{#State 135
+		DEFAULT => -50
+	},
+	{#State 136
+		ACTIONS => {
+			"[" => 7
+		},
+		DEFAULT => -63,
+		GOTOS => {
+			'base_or_empty' => 156,
+			'base_element' => 157,
+			'empty_element' => 158,
+			'property_list' => 159
+		}
+	},
+	{#State 137
+		DEFAULT => -49
+	},
+	{#State 138
+		DEFAULT => -58
+	},
+	{#State 139
+		ACTIONS => {
+			'IDENTIFIER' => 9,
+			"union" => 49,
+			"enum" => 62,
+			"bitmap" => 63,
+			"[" => 7,
+			'void' => 91,
+			"struct" => 60
+		},
+		GOTOS => {
+			'identifier' => 93,
+			'struct' => 56,
+			'enum' => 58,
+			'type' => 160,
+			'union' => 67,
+			'bitmap' => 64,
+			'usertype' => 92
+		}
+	},
+	{#State 140
+		ACTIONS => {
+			"," => 161,
+			")" => 162
+		}
+	},
+	{#State 141
+		DEFAULT => -57
+	},
+	{#State 142
+		DEFAULT => -20
+	},
+	{#State 143
+		ACTIONS => {
+			"[" => 124
+		},
+		DEFAULT => -60,
+		GOTOS => {
+			'array_len' => 163
+		}
+	},
+	{#State 144
+		ACTIONS => {
+			"-" => 34,
+			"<" => 35,
+			"+" => 37,
+			"~" => 36,
+			"&" => 39,
+			"{" => 38,
+			"/" => 40,
+			"|" => 42,
+			"(" => 41,
+			"*" => 43,
+			"." => 44,
+			"]" => 164,
+			">" => 45
+		}
+	},
+	{#State 145
+		ACTIONS => {
+			'CONSTANT' => 28,
+			'TEXT' => 22,
+			'IDENTIFIER' => 9
+		},
+		DEFAULT => -73,
+		GOTOS => {
+			'identifier' => 23,
+			'anytext' => 165,
+			'text' => 24,
+			'constant' => 27
+		}
+	},
+	{#State 146
+		ACTIONS => {
+			"-" => 34,
+			"<" => 35,
+			";" => 166,
+			"+" => 37,
+			"~" => 36,
+			"&" => 39,
+			"{" => 38,
+			"/" => 40,
+			"|" => 42,
+			"(" => 41,
+			"*" => 43,
+			"." => 44,
+			">" => 45
+		}
+	},
+	{#State 147
+		DEFAULT => -43
+	},
+	{#State 148
+		ACTIONS => {
+			";" => 167
+		}
+	},
+	{#State 149
+		ACTIONS => {
+			'CONSTANT' => 28,
+			'TEXT' => 22,
+			'IDENTIFIER' => 9
+		},
+		DEFAULT => -73,
+		GOTOS => {
+			'identifier' => 23,
+			'anytext' => 168,
+			'text' => 24,
+			'constant' => 27
+		}
+	},
+	{#State 150
+		DEFAULT => -34
+	},
+	{#State 151
+		ACTIONS => {
+			'IDENTIFIER' => 9
+		},
+		GOTOS => {
+			'identifier' => 128,
+			'enum_element' => 169
+		}
+	},
+	{#State 152
+		DEFAULT => -39
+	},
+	{#State 153
+		ACTIONS => {
+			'IDENTIFIER' => 9
+		},
+		GOTOS => {
+			'identifier' => 133,
+			'bitmap_element' => 170
+		}
+	},
+	{#State 154
+		ACTIONS => {
+			'CONSTANT' => 28,
+			'TEXT' => 22,
+			'IDENTIFIER' => 9
+		},
+		DEFAULT => -73,
+		GOTOS => {
+			'identifier' => 23,
+			'anytext' => 171,
+			'text' => 24,
+			'constant' => 27
+		}
+	},
+	{#State 155
+		DEFAULT => -25
+	},
+	{#State 156
+		DEFAULT => -47
+	},
+	{#State 157
+		ACTIONS => {
+			";" => 172
+		}
+	},
+	{#State 158
+		DEFAULT => -46
+	},
+	{#State 159
+		ACTIONS => {
+			'IDENTIFIER' => 9,
+			"union" => 49,
+			";" => 173,
+			"enum" => 62,
+			"bitmap" => 63,
+			'void' => 91,
+			"[" => 7,
+			"struct" => 60
+		},
+		GOTOS => {
+			'identifier' => 93,
+			'struct' => 56,
+			'enum' => 58,
+			'type' => 160,
+			'union' => 67,
+			'bitmap' => 64,
+			'usertype' => 92
+		}
+	},
+	{#State 160
+		DEFAULT => -52,
+		GOTOS => {
+			'pointers' => 174
+		}
+	},
+	{#State 161
+		DEFAULT => -63,
+		GOTOS => {
+			'base_element' => 175,
+			'property_list' => 139
+		}
+	},
+	{#State 162
+		ACTIONS => {
+			";" => 176
+		}
+	},
+	{#State 163
+		DEFAULT => -61
+	},
+	{#State 164
+		ACTIONS => {
+			"[" => 124
+		},
+		DEFAULT => -60,
+		GOTOS => {
+			'array_len' => 177
+		}
+	},
+	{#State 165
+		ACTIONS => {
+			"-" => 34,
+			"<" => 35,
+			";" => 178,
+			"+" => 37,
+			"~" => 36,
+			"&" => 39,
+			"{" => 38,
+			"/" => 40,
+			"|" => 42,
+			"(" => 41,
+			"*" => 43,
+			"." => 44,
+			">" => 45
+		}
+	},
+	{#State 166
+		DEFAULT => -17
+	},
+	{#State 167
+		DEFAULT => -55
+	},
+	{#State 168
+		ACTIONS => {
+			"-" => 34,
+			"<" => 35,
+			"+" => 37,
+			"~" => 36,
+			"&" => 39,
+			"{" => 38,
+			"/" => 40,
+			"|" => 42,
+			"(" => 41,
+			"*" => 43,
+			"." => 44,
+			">" => 45
+		},
+		DEFAULT => -38
+	},
+	{#State 169
+		DEFAULT => -36
+	},
+	{#State 170
+		DEFAULT => -41
+	},
+	{#State 171
+		ACTIONS => {
+			"-" => 34,
+			"<" => 35,
+			"+" => 37,
+			"~" => 36,
+			"&" => 39,
+			"{" => 38,
+			"/" => 40,
+			"|" => 42,
+			"(" => 41,
+			"*" => 43,
+			"." => 44,
+			">" => 45
+		},
+		DEFAULT => -42
+	},
+	{#State 172
+		DEFAULT => -45
+	},
+	{#State 173
+		DEFAULT => -44
+	},
+	{#State 174
+		ACTIONS => {
+			'IDENTIFIER' => 9,
+			"*" => 180
+		},
+		GOTOS => {
+			'identifier' => 179
+		}
+	},
+	{#State 175
+		DEFAULT => -59
+	},
+	{#State 176
+		DEFAULT => -19
+	},
+	{#State 177
+		DEFAULT => -62
+	},
+	{#State 178
+		DEFAULT => -18
+	},
+	{#State 179
+		ACTIONS => {
+			"[" => 124
+		},
+		DEFAULT => -60,
+		GOTOS => {
+			'array_len' => 181
+		}
+	},
+	{#State 180
+		DEFAULT => -53
+	},
+	{#State 181
+		DEFAULT => -51
+	}
+],
+                                  yyrules  =>
+[
+	[#Rule 0
+		 '$start', 2, undef
+	],
+	[#Rule 1
+		 'idl', 0, undef
+	],
+	[#Rule 2
+		 'idl', 2,
+sub
+#line 19 "build/pidl/idl.yp"
+{ push(@{$_[1]}, $_[2]); $_[1] }
+	],
+	[#Rule 3
+		 'idl', 2,
+sub
+#line 20 "build/pidl/idl.yp"
+{ push(@{$_[1]}, $_[2]); $_[1] }
+	],
+	[#Rule 4
+		 'coclass', 7,
+sub
+#line 24 "build/pidl/idl.yp"
+{$_[3] => {
+               "TYPE" => "COCLASS", 
+	       "PROPERTIES" => $_[1],
+	       "NAME" => $_[3],
+	       "DATA" => $_[5],
+		   "FILE" => $_[0]->YYData->{INPUT_FILENAME},
+		   "LINE" => $_[0]->YYData->{LINE},
+          }}
+	],
+	[#Rule 5
+		 'interface_names', 0, undef
+	],
+	[#Rule 6
+		 'interface_names', 4,
+sub
+#line 36 "build/pidl/idl.yp"
+{ push(@{$_[1]}, $_[2]); $_[1] }
+	],
+	[#Rule 7
+		 'interface', 8,
+sub
+#line 40 "build/pidl/idl.yp"
+{$_[3] => {
+               "TYPE" => "INTERFACE", 
+	       "PROPERTIES" => $_[1],
+	       "NAME" => $_[3],
+	       "BASE" => $_[4],
+	       "DATA" => $_[6],
+		   "FILE" => $_[0]->YYData->{INPUT_FILENAME},
+		   "LINE" => $_[0]->YYData->{LINE},
+          }}
+	],
+	[#Rule 8
+		 'base_interface', 0, undef
+	],
+	[#Rule 9
+		 'base_interface', 2,
+sub
+#line 53 "build/pidl/idl.yp"
+{ $_[2] }
+	],
+	[#Rule 10
+		 'definitions', 1,
+sub
+#line 57 "build/pidl/idl.yp"
+{ [ $_[1] ] }
+	],
+	[#Rule 11
+		 'definitions', 2,
+sub
+#line 58 "build/pidl/idl.yp"
+{ push(@{$_[1]}, $_[2]); $_[1] }
+	],
+	[#Rule 12
+		 'definition', 1, undef
+	],
+	[#Rule 13
+		 'definition', 1, undef
+	],
+	[#Rule 14
+		 'definition', 1, undef
+	],
+	[#Rule 15
+		 'definition', 1, undef
+	],
+	[#Rule 16
+		 'definition', 1, undef
+	],
+	[#Rule 17
+		 'const', 6,
+sub
+#line 66 "build/pidl/idl.yp"
+{{
+                     "TYPE"  => "CONST", 
+		     "DTYPE"  => $_[2],
+		     "NAME"  => $_[3],
+		     "VALUE" => $_[5],
+		     "FILE" => $_[0]->YYData->{INPUT_FILENAME},
+		     "LINE" => $_[0]->YYData->{LINE},
+        }}
+	],
+	[#Rule 18
+		 'const', 7,
+sub
+#line 75 "build/pidl/idl.yp"
+{{
+                     "TYPE"  => "CONST", 
+		     "DTYPE"  => $_[2],
+		     "NAME"  => $_[3],
+		     "ARRAY_LEN" => $_[4],
+		     "VALUE" => $_[6],
+		     "FILE" => $_[0]->YYData->{INPUT_FILENAME},
+		     "LINE" => $_[0]->YYData->{LINE},
+        }}
+	],
+	[#Rule 19
+		 'function', 7,
+sub
+#line 88 "build/pidl/idl.yp"
+{{
+		"TYPE" => "FUNCTION",
+		"NAME" => $_[3],
+		"RETURN_TYPE" => $_[2],
+		"PROPERTIES" => $_[1],
+		"ELEMENTS" => $_[5],
+		"FILE" => $_[0]->YYData->{INPUT_FILENAME},
+		"LINE" => $_[0]->YYData->{LINE},
+	  }}
+	],
+	[#Rule 20
+		 'declare', 5,
+sub
+#line 100 "build/pidl/idl.yp"
+{{
+	             "TYPE" => "DECLARE", 
+                     "PROPERTIES" => $_[2],
+		     "NAME" => $_[4],
+		     "DATA" => $_[3],
+		     "FILE" => $_[0]->YYData->{INPUT_FILENAME},
+		     "LINE" => $_[0]->YYData->{LINE},
+        }}
+	],
+	[#Rule 21
+		 'decl_type', 1, undef
+	],
+	[#Rule 22
+		 'decl_type', 1, undef
+	],
+	[#Rule 23
+		 'decl_enum', 1,
+sub
+#line 114 "build/pidl/idl.yp"
+{{
+                     "TYPE" => "ENUM"
+        }}
+	],
+	[#Rule 24
+		 'decl_bitmap', 1,
+sub
+#line 120 "build/pidl/idl.yp"
+{{
+                     "TYPE" => "BITMAP"
+        }}
+	],
+	[#Rule 25
+		 'typedef', 6,
+sub
+#line 126 "build/pidl/idl.yp"
+{{
+	             "TYPE" => "TYPEDEF", 
+                     "PROPERTIES" => $_[2],
+		     "NAME" => $_[4],
+		     "DATA" => $_[3],
+		     "ARRAY_LEN" => $_[5],
+		     "FILE" => $_[0]->YYData->{INPUT_FILENAME},
+		     "LINE" => $_[0]->YYData->{LINE},
+        }}
+	],
+	[#Rule 26
+		 'usertype', 1, undef
+	],
+	[#Rule 27
+		 'usertype', 1, undef
+	],
+	[#Rule 28
+		 'usertype', 1, undef
+	],
+	[#Rule 29
+		 'usertype', 1, undef
+	],
+	[#Rule 30
+		 'typedecl', 2,
+sub
+#line 139 "build/pidl/idl.yp"
+{ $_[1] }
+	],
+	[#Rule 31
+		 'type', 1, undef
+	],
+	[#Rule 32
+		 'type', 1, undef
+	],
+	[#Rule 33
+		 'type', 1,
+sub
+#line 142 "build/pidl/idl.yp"
+{ "void" }
+	],
+	[#Rule 34
+		 'enum', 5,
+sub
+#line 146 "build/pidl/idl.yp"
+{{
+             "TYPE" => "ENUM", 
+			 "NAME" => $_[2],
+		     "ELEMENTS" => $_[4]
+        }}
+	],
+	[#Rule 35
+		 'enum_elements', 1,
+sub
+#line 154 "build/pidl/idl.yp"
+{ [ $_[1] ] }
+	],
+	[#Rule 36
+		 'enum_elements', 3,
+sub
+#line 155 "build/pidl/idl.yp"
+{ push(@{$_[1]}, $_[3]); $_[1] }
+	],
+	[#Rule 37
+		 'enum_element', 1, undef
+	],
+	[#Rule 38
+		 'enum_element', 3,
+sub
+#line 159 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]" }
+	],
+	[#Rule 39
+		 'bitmap', 5,
+sub
+#line 163 "build/pidl/idl.yp"
+{{
+             "TYPE" => "BITMAP", 
+			 "NAME" => $_[2],
+		     "ELEMENTS" => $_[4]
+        }}
+	],
+	[#Rule 40
+		 'bitmap_elements', 1,
+sub
+#line 171 "build/pidl/idl.yp"
+{ [ $_[1] ] }
+	],
+	[#Rule 41
+		 'bitmap_elements', 3,
+sub
+#line 172 "build/pidl/idl.yp"
+{ push(@{$_[1]}, $_[3]); $_[1] }
+	],
+	[#Rule 42
+		 'bitmap_element', 3,
+sub
+#line 175 "build/pidl/idl.yp"
+{ "$_[1] ( $_[3] )" }
+	],
+	[#Rule 43
+		 'struct', 5,
+sub
+#line 179 "build/pidl/idl.yp"
+{{
+             "TYPE" => "STRUCT", 
+			 "NAME" => $_[2],
+		     "ELEMENTS" => $_[4]
+        }}
+	],
+	[#Rule 44
+		 'empty_element', 2,
+sub
+#line 187 "build/pidl/idl.yp"
+{{
+		 "NAME" => "",
+		 "TYPE" => "EMPTY",
+		 "PROPERTIES" => $_[1],
+		 "POINTERS" => 0,
+		 "ARRAY_LEN" => [],
+		 "FILE" => $_[0]->YYData->{INPUT_FILENAME},
+		 "LINE" => $_[0]->YYData->{LINE},
+	 }}
+	],
+	[#Rule 45
+		 'base_or_empty', 2, undef
+	],
+	[#Rule 46
+		 'base_or_empty', 1, undef
+	],
+	[#Rule 47
+		 'optional_base_element', 2,
+sub
+#line 201 "build/pidl/idl.yp"
+{ $_[2]->{PROPERTIES} = Parse::Pidl::Util::FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] }
+	],
+	[#Rule 48
+		 'union_elements', 0, undef
+	],
+	[#Rule 49
+		 'union_elements', 2,
+sub
+#line 206 "build/pidl/idl.yp"
+{ push(@{$_[1]}, $_[2]); $_[1] }
+	],
+	[#Rule 50
+		 'union', 5,
+sub
+#line 210 "build/pidl/idl.yp"
+{{
+             "TYPE" => "UNION", 
+		     "NAME" => $_[2],
+		     "ELEMENTS" => $_[4]
+        }}
+	],
+	[#Rule 51
+		 'base_element', 5,
+sub
+#line 218 "build/pidl/idl.yp"
+{{
+			   "NAME" => $_[4],
+			   "TYPE" => $_[2],
+			   "PROPERTIES" => $_[1],
+			   "POINTERS" => $_[3],
+			   "ARRAY_LEN" => $_[5],
+		       "FILE" => $_[0]->YYData->{INPUT_FILENAME},
+		       "LINE" => $_[0]->YYData->{LINE},
+              }}
+	],
+	[#Rule 52
+		 'pointers', 0,
+sub
+#line 232 "build/pidl/idl.yp"
+{ 0 }
+	],
+	[#Rule 53
+		 'pointers', 2,
+sub
+#line 233 "build/pidl/idl.yp"
+{ $_[1]+1 }
+	],
+	[#Rule 54
+		 'element_list1', 0, undef
+	],
+	[#Rule 55
+		 'element_list1', 3,
+sub
+#line 238 "build/pidl/idl.yp"
+{ push(@{$_[1]}, $_[2]); $_[1] }
+	],
+	[#Rule 56
+		 'element_list2', 0, undef
+	],
+	[#Rule 57
+		 'element_list2', 1, undef
+	],
+	[#Rule 58
+		 'element_list2', 1,
+sub
+#line 244 "build/pidl/idl.yp"
+{ [ $_[1] ] }
+	],
+	[#Rule 59
+		 'element_list2', 3,
+sub
+#line 245 "build/pidl/idl.yp"
+{ push(@{$_[1]}, $_[3]); $_[1] }
+	],
+	[#Rule 60
+		 'array_len', 0, undef
+	],
+	[#Rule 61
+		 'array_len', 3,
+sub
+#line 250 "build/pidl/idl.yp"
+{ push(@{$_[3]}, "*"); $_[3] }
+	],
+	[#Rule 62
+		 'array_len', 4,
+sub
+#line 251 "build/pidl/idl.yp"
+{ push(@{$_[4]}, "$_[2]"); $_[4] }
+	],
+	[#Rule 63
+		 'property_list', 0, undef
+	],
+	[#Rule 64
+		 'property_list', 4,
+sub
+#line 257 "build/pidl/idl.yp"
+{ Parse::Pidl::Util::FlattenHash([$_[1],$_[3]]); }
+	],
+	[#Rule 65
+		 'properties', 1,
+sub
+#line 260 "build/pidl/idl.yp"
+{ $_[1] }
+	],
+	[#Rule 66
+		 'properties', 3,
+sub
+#line 261 "build/pidl/idl.yp"
+{ Parse::Pidl::Util::FlattenHash([$_[1], $_[3]]); }
+	],
+	[#Rule 67
+		 'property', 1,
+sub
+#line 264 "build/pidl/idl.yp"
+{{ "$_[1]" => "1"     }}
+	],
+	[#Rule 68
+		 'property', 4,
+sub
+#line 265 "build/pidl/idl.yp"
+{{ "$_[1]" => "$_[3]" }}
+	],
+	[#Rule 69
+		 'listtext', 1, undef
+	],
+	[#Rule 70
+		 'listtext', 3,
+sub
+#line 270 "build/pidl/idl.yp"
+{ "$_[1] $_[3]" }
+	],
+	[#Rule 71
+		 'commalisttext', 1, undef
+	],
+	[#Rule 72
+		 'commalisttext', 3,
+sub
+#line 275 "build/pidl/idl.yp"
+{ "$_[1],$_[3]" }
+	],
+	[#Rule 73
+		 'anytext', 0,
+sub
+#line 279 "build/pidl/idl.yp"
+{ "" }
+	],
+	[#Rule 74
+		 'anytext', 1, undef
+	],
+	[#Rule 75
+		 'anytext', 1, undef
+	],
+	[#Rule 76
+		 'anytext', 1, undef
+	],
+	[#Rule 77
+		 'anytext', 3,
+sub
+#line 281 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]" }
+	],
+	[#Rule 78
+		 'anytext', 3,
+sub
+#line 282 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]" }
+	],
+	[#Rule 79
+		 'anytext', 3,
+sub
+#line 283 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]" }
+	],
+	[#Rule 80
+		 'anytext', 3,
+sub
+#line 284 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]" }
+	],
+	[#Rule 81
+		 'anytext', 3,
+sub
+#line 285 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]" }
+	],
+	[#Rule 82
+		 'anytext', 3,
+sub
+#line 286 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]" }
+	],
+	[#Rule 83
+		 'anytext', 3,
+sub
+#line 287 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]" }
+	],
+	[#Rule 84
+		 'anytext', 3,
+sub
+#line 288 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]" }
+	],
+	[#Rule 85
+		 'anytext', 3,
+sub
+#line 289 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]" }
+	],
+	[#Rule 86
+		 'anytext', 3,
+sub
+#line 290 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]" }
+	],
+	[#Rule 87
+		 'anytext', 5,
+sub
+#line 291 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]$_[4]$_[5]" }
+	],
+	[#Rule 88
+		 'anytext', 5,
+sub
+#line 292 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]$_[4]$_[5]" }
+	],
+	[#Rule 89
+		 'identifier', 1, undef
+	],
+	[#Rule 90
+		 'optional_identifier', 1, undef
+	],
+	[#Rule 91
+		 'optional_identifier', 0, undef
+	],
+	[#Rule 92
+		 'constant', 1, undef
+	],
+	[#Rule 93
+		 'text', 1,
+sub
+#line 306 "build/pidl/idl.yp"
+{ "\"$_[1]\"" }
+	],
+	[#Rule 94
+		 'optional_semicolon', 0, undef
+	],
+	[#Rule 95
+		 'optional_semicolon', 1, undef
+	]
+],
+                                  @_);
+    bless($self,$class);
+}
+
+#line 317 "build/pidl/idl.yp"
+
+
+use Parse::Pidl::Util;
+
+#####################################################################
+# traverse a perl data structure removing any empty arrays or
+# hashes and any hash elements that map to undef
+sub CleanData($)
+{
+    sub CleanData($);
+    my($v) = shift;
+    if (ref($v) eq "ARRAY") {
+	foreach my $i (0 .. $#{$v}) {
+	    CleanData($v->[$i]);
+	    if (ref($v->[$i]) eq "ARRAY" && $#{$v->[$i]}==-1) { 
+		    $v->[$i] = undef; 
+		    next; 
+	    }
+	}
+	# this removes any undefined elements from the array
+	@{$v} = grep { defined $_ } @{$v};
+    } elsif (ref($v) eq "HASH") {
+	foreach my $x (keys %{$v}) {
+	    CleanData($v->{$x});
+	    if (!defined $v->{$x}) { delete($v->{$x}); next; }
+	    if (ref($v->{$x}) eq "ARRAY" && $#{$v->{$x}}==-1) { delete($v->{$x}); next; }
+	}
+    }
+	return $v;
+}
+
+sub _Error {
+    if (exists $_[0]->YYData->{ERRMSG}) {
+		print $_[0]->YYData->{ERRMSG};
+		delete $_[0]->YYData->{ERRMSG};
+		return;
+	};
+	my $line = $_[0]->YYData->{LINE};
+	my $last_token = $_[0]->YYData->{LAST_TOKEN};
+	my $file = $_[0]->YYData->{INPUT_FILENAME};
+	
+	print "$file:$line: Syntax error near '$last_token'\n";
+}
+
+sub _Lexer($)
+{
+	my($parser)=shift;
+
+    $parser->YYData->{INPUT} or return('',undef);
+
+again:
+	$parser->YYData->{INPUT} =~ s/^[ \t]*//;
+
+	for ($parser->YYData->{INPUT}) {
+		if (/^\#/) {
+			if (s/^\# (\d+) \"(.*?)\"( \d+|)//) {
+				$parser->YYData->{LINE} = $1-1;
+				$parser->YYData->{INPUT_FILENAME} = $2;
+				goto again;
+			}
+			if (s/^\#line (\d+) \"(.*?)\"( \d+|)//) {
+				$parser->YYData->{LINE} = $1-1;
+				$parser->YYData->{INPUT_FILENAME} = $2;
+				goto again;
+			}
+			if (s/^(\#.*)$//m) {
+				goto again;
+			}
+		}
+		if (s/^(\n)//) {
+			$parser->YYData->{LINE}++;
+			goto again;
+		}
+		if (s/^\"(.*?)\"//) {
+			$parser->YYData->{LAST_TOKEN} = $1;
+			return('TEXT',$1); 
+		}
+		if (s/^(\d+)(\W|$)/$2/) {
+			$parser->YYData->{LAST_TOKEN} = $1;
+			return('CONSTANT',$1); 
+		}
+		if (s/^([\w_]+)//) {
+			$parser->YYData->{LAST_TOKEN} = $1;
+			if ($1 =~ 
+			    /^(coclass|interface|const|typedef|declare|union
+			      |struct|enum|bitmap|void)$/x) {
+				return $1;
+			}
+			return('IDENTIFIER',$1);
+		}
+		if (s/^(.)//s) {
+			$parser->YYData->{LAST_TOKEN} = $1;
+			return($1,$1);
+		}
+	}
+}
+
+sub parse_idl($$)
+{
+	my ($self,$filename) = @_;
+
+	my $saved_delim = $/;
+	undef $/;
+	my $cpp = $ENV{CPP};
+	if (! defined $cpp) {
+		$cpp = "cpp"
+	}
+	my $data = `$cpp -D__PIDL__ -xc $filename`;
+	$/ = $saved_delim;
+
+    $self->YYData->{INPUT} = $data;
+    $self->YYData->{LINE} = 0;
+    $self->YYData->{LAST_TOKEN} = "NONE";
+
+	my $idl = $self->YYParse( yylex => \&_Lexer, yyerror => \&_Error );
+
+	return CleanData($idl);
+}
+
+1;
diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm
new file mode 100644
index 0000000000..e00a0c9828
--- /dev/null
+++ b/source4/pidl/lib/Parse/Pidl/NDR.pm
@@ -0,0 +1,967 @@
+###################################################
+# Samba4 NDR info tree generator
+# Copyright tridge@samba.org 2000-2003
+# Copyright tpot@samba.org 2001
+# Copyright jelmer@samba.org 2004-2005
+# released under the GNU GPL
+
+package Parse::Pidl::NDR;
+
+require Exporter;
+@ISA = qw(Exporter);
+@EXPORT = qw(GetPrevLevel GetNextLevel ContainsDeferred);
+
+use strict;
+use Parse::Pidl::Typelist qw(hasType getType);
+use Parse::Pidl::Util qw(has_property property_matches);
+
+sub nonfatal($$)
+{
+	my ($e,$s) = @_;
+	warn ("$e->{FILE}:$e->{LINE}: Warning: $s\n");
+}
+
+#####################################################################
+# signal a fatal validation error
+sub fatal($$)
+{
+	my ($pos,$s) = @_;
+	die("$pos->{FILE}:$pos->{LINE}:$s\n");
+}
+
+#####################################################################
+# return a table describing the order in which the parts of an element
+# should be parsed
+# Possible level types:
+#  - POINTER
+#  - ARRAY
+#  - SUBCONTEXT
+#  - SWITCH
+#  - DATA
+sub GetElementLevelTable($)
+{
+	my $e = shift;
+
+	my $order = [];
+	my $is_deferred = 0;
+	my @bracket_array = ();
+	my @length_is = ();
+	my @size_is = ();
+
+	if (has_property($e, "size_is")) {
+		@size_is = split /,/, has_property($e, "size_is");
+	}
+
+	if (has_property($e, "length_is")) {
+		@length_is = split /,/, has_property($e, "length_is");
+	}
+
+	if (defined($e->{ARRAY_LEN})) {
+		@bracket_array = @{$e->{ARRAY_LEN}};
+	}
+	
+	# Parse the [][][][] style array stuff
+	foreach my $d (@bracket_array) {
+		my $size = $d;
+		my $length = $d;
+		my $is_surrounding = 0;
+		my $is_varying = 0;
+		my $is_conformant = 0;
+		my $is_string = 0;
+
+		if ($d eq "*") {
+			$is_conformant = 1;
+			if ($size = shift @size_is) {
+			} elsif ((scalar(@size_is) == 0) and has_property($e, "string")) {
+				$is_string = 1;
+				delete($e->{PROPERTIES}->{string});
+			} else {
+				print "$e->{FILE}:$e->{LINE}: Must specify size_is() for conformant array!\n";
+				exit 1;
+			}
+
+			if (($length = shift @length_is) or $is_string) {
+				$is_varying = 1;
+			} else {
+				$length = $size;
+			}
+
+			if ($e == $e->{PARENT}->{ELEMENTS}[-1] 
+				and $e->{PARENT}->{TYPE} ne "FUNCTION") {
+				$is_surrounding = 1;
+			}
+		}
+
+		push (@$order, {
+			TYPE => "ARRAY",
+			SIZE_IS => $size,
+			LENGTH_IS => $length,
+			IS_DEFERRED => "$is_deferred",
+			IS_SURROUNDING => "$is_surrounding",
+			IS_ZERO_TERMINATED => "$is_string",
+			IS_VARYING => "$is_varying",
+			IS_CONFORMANT => "$is_conformant",
+			IS_FIXED => (not $is_conformant and Parse::Pidl::Util::is_constant($size)),
+			IS_INLINE => (not $is_conformant and not Parse::Pidl::Util::is_constant($size))
+		});
+	}
+
+	# Next, all the pointers
+	foreach my $i (1..$e->{POINTERS}) {
+		my $pt = pointer_type($e);
+
+		my $level = "EMBEDDED";
+		# Top level "ref" pointers do not have a referrent identifier
+		$level = "TOP" if ( defined($pt) 
+				and $i == 1
+				and $e->{PARENT}->{TYPE} eq "FUNCTION");
+
+		push (@$order, { 
+			TYPE => "POINTER",
+			# for now, there can only be one pointer type per element
+			POINTER_TYPE => pointer_type($e),
+			IS_DEFERRED => "$is_deferred",
+			LEVEL => $level
+		});
+		
+		# everything that follows will be deferred
+		$is_deferred = 1 if ($e->{PARENT}->{TYPE} ne "FUNCTION");
+
+		my $array_size = shift @size_is;
+		my $array_length;
+		my $is_varying;
+		my $is_conformant;
+		my $is_string = 0;
+		if ($array_size) {
+			$is_conformant = 1;
+			if ($array_length = shift @length_is) {
+				$is_varying = 1;
+			} else {
+				$array_length = $array_size;
+				$is_varying =0;
+			}
+		} 
+		
+		if (scalar(@size_is) == 0 and has_property($e, "string")) {
+			$is_string = 1;
+			$is_varying = $is_conformant = has_property($e, "noheader")?0:1;
+			delete($e->{PROPERTIES}->{string});
+		}
+
+		if ($array_size or $is_string) {
+			push (@$order, {
+				TYPE => "ARRAY",
+				IS_ZERO_TERMINATED => "$is_string",
+				SIZE_IS => $array_size,
+				LENGTH_IS => $array_length,
+				IS_DEFERRED => "$is_deferred",
+				IS_SURROUNDING => 0,
+				IS_VARYING => "$is_varying",
+				IS_CONFORMANT => "$is_conformant",
+				IS_FIXED => 0,
+				IS_INLINE => 0,
+			});
+
+			$is_deferred = 0;
+		} 
+	}
+
+	if (defined(has_property($e, "subcontext"))) {
+		my $hdr_size = has_property($e, "subcontext");
+		my $subsize = has_property($e, "subcontext_size");
+		if (not defined($subsize)) { 
+			$subsize = -1; 
+		}
+		
+		push (@$order, {
+			TYPE => "SUBCONTEXT",
+			HEADER_SIZE => $hdr_size,
+			SUBCONTEXT_SIZE => $subsize,
+			IS_DEFERRED => $is_deferred,
+			COMPRESSION => has_property($e, "compression"),
+			OBFUSCATION => has_property($e, "obfuscation")
+		});
+	}
+
+	if (my $switch = has_property($e, "switch_is")) {
+		push (@$order, {
+			TYPE => "SWITCH", 
+			SWITCH_IS => $switch,
+			IS_DEFERRED => $is_deferred
+		});
+	}
+
+	if (scalar(@size_is) > 0) {
+		nonfatal($e, "size_is() on non-array element");
+	}
+
+	if (scalar(@length_is) > 0) {
+		nonfatal($e, "length_is() on non-array element");
+	}
+
+	if (has_property($e, "string")) {
+		nonfatal($e, "string() attribute on non-array element");
+	}
+
+	push (@$order, {
+		TYPE => "DATA",
+		DATA_TYPE => $e->{TYPE},
+		IS_DEFERRED => $is_deferred,
+		CONTAINS_DEFERRED => can_contain_deferred($e),
+		IS_SURROUNDING => 0 #FIXME
+	});
+
+	my $i = 0;
+	foreach (@$order) { $_->{LEVEL_INDEX} = $i; $i+=1; }
+
+	return $order;
+}
+
+#####################################################################
+# see if a type contains any deferred data 
+sub can_contain_deferred
+{
+	my $e = shift;
+
+	return 0 if (Parse::Pidl::Typelist::is_scalar($e->{TYPE}));
+	return 1 unless (hasType($e->{TYPE})); # assume the worst
+
+	my $type = getType($e->{TYPE});
+
+	foreach my $x (@{$type->{DATA}->{ELEMENTS}}) {
+		return 1 if ($x->{POINTERS});
+		return 1 if (can_contain_deferred ($x));
+	}
+	
+	return 0;
+}
+
+sub pointer_type($)
+{
+	my $e = shift;
+
+	return undef unless $e->{POINTERS};
+	
+	return "ref" if (has_property($e, "ref"));
+	return "ptr" if (has_property($e, "ptr"));
+	return "sptr" if (has_property($e, "sptr"));
+	return "unique" if (has_property($e, "unique"));
+	return "relative" if (has_property($e, "relative"));
+	return "ignore" if (has_property($e, "ignore"));
+
+	return undef;
+}
+
+#####################################################################
+# 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 ($e->{POINTERS}) {
+			$a = 4; 
+		} elsif (has_property($e, "subcontext")){ 
+			$a = 1;
+		} else {
+			$a = align_type($e->{TYPE}); 
+		}
+
+		$align = $a if ($align < $a);
+	}
+
+	return $align;
+}
+
+#####################################################################
+# align a type
+sub align_type
+{
+	my $e = shift;
+
+	unless (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 = getType($e)->{DATA};
+
+	if ($dt->{TYPE} eq "ENUM") {
+		return align_type(Parse::Pidl::Typelist::enum_type_fn($dt));
+	} elsif ($dt->{TYPE} eq "BITMAP") {
+		return align_type(Parse::Pidl::Typelist::bitmap_type_fn($dt));
+	} elsif (($dt->{TYPE} eq "STRUCT") or ($dt->{TYPE} eq "UNION")) {
+		return find_largest_alignment($dt);
+	} elsif ($dt->{TYPE} eq "SCALAR") {
+		return Parse::Pidl::Typelist::getScalarAlignment($dt->{NAME});
+	}
+
+	die("Unknown data type type $dt->{TYPE}");
+}
+
+sub ParseElement($)
+{
+	my $e = shift;
+
+	return {
+		NAME => $e->{NAME},
+		TYPE => $e->{TYPE},
+		PROPERTIES => $e->{PROPERTIES},
+		LEVELS => GetElementLevelTable($e),
+		ALIGN => align_type($e->{TYPE}),
+		ORIGINAL => $e
+	};
+}
+
+sub ParseStruct($)
+{
+	my $struct = shift;
+	my @elements = ();
+	my $surrounding = undef;
+
+	foreach my $x (@{$struct->{ELEMENTS}}) 
+	{
+		push @elements, ParseElement($x);
+	}
+
+	my $e = $elements[-1];
+	if (defined($e) and defined($e->{LEVELS}[0]->{IS_SURROUNDING}) and
+		$e->{LEVELS}[0]->{IS_SURROUNDING}) {
+		$surrounding = $e;
+	}
+
+	if (defined $e->{TYPE} && $e->{TYPE} eq "string"
+	    &&  property_matches($e, "flag", ".*LIBNDR_FLAG_STR_CONFORMANT.*")) {
+		$surrounding = $struct->{ELEMENTS}[-1];
+	}
+		
+	return {
+		TYPE => "STRUCT",
+		SURROUNDING_ELEMENT => $surrounding,
+		ELEMENTS => \@elements,
+		PROPERTIES => $struct->{PROPERTIES},
+		ORIGINAL => $struct
+	};
+}
+
+sub ParseUnion($)
+{
+	my $e = shift;
+	my @elements = ();
+	my $switch_type = has_property($e, "switch_type");
+	unless (defined($switch_type)) { $switch_type = "uint32"; }
+
+	if (has_property($e, "nodiscriminant")) { $switch_type = undef; }
+	
+	foreach my $x (@{$e->{ELEMENTS}}) 
+	{
+		my $t;
+		if ($x->{TYPE} eq "EMPTY") {
+			$t = { TYPE => "EMPTY" };
+		} else {
+			$t = ParseElement($x);
+		}
+		if (has_property($x, "default")) {
+			$t->{CASE} = "default";
+		} elsif (defined($x->{PROPERTIES}->{case})) {
+			$t->{CASE} = "case $x->{PROPERTIES}->{case}";
+		} else {
+			die("Union element $x->{NAME} has neither default nor case property");
+		}
+		push @elements, $t;
+	}
+
+	return {
+		TYPE => "UNION",
+		SWITCH_TYPE => $switch_type,
+		ELEMENTS => \@elements,
+		PROPERTIES => $e->{PROPERTIES},
+		ORIGINAL => $e
+	};
+}
+
+sub ParseEnum($)
+{
+	my $e = shift;
+
+	return {
+		TYPE => "ENUM",
+		BASE_TYPE => Parse::Pidl::Typelist::enum_type_fn($e),
+		ELEMENTS => $e->{ELEMENTS},
+		PROPERTIES => $e->{PROPERTIES},
+		ORIGINAL => $e
+	};
+}
+
+sub ParseBitmap($)
+{
+	my $e = shift;
+
+	return {
+		TYPE => "BITMAP",
+		BASE_TYPE => Parse::Pidl::Typelist::bitmap_type_fn($e),
+		ELEMENTS => $e->{ELEMENTS},
+		PROPERTIES => $e->{PROPERTIES},
+		ORIGINAL => $e
+	};
+}
+
+sub ParseTypedef($$)
+{
+	my ($ndr,$d) = @_;
+	my $data;
+
+	if ($d->{DATA}->{TYPE} eq "STRUCT" or $d->{DATA}->{TYPE} eq "UNION") {
+		CheckPointerTypes($d->{DATA}, $ndr->{PROPERTIES}->{pointer_default});
+	}
+
+	if (defined($d->{PROPERTIES}) && !defined($d->{DATA}->{PROPERTIES})) {
+		$d->{DATA}->{PROPERTIES} = $d->{PROPERTIES};
+	}
+
+	$data = {
+		STRUCT => \&ParseStruct,
+		UNION => \&ParseUnion,
+		ENUM => \&ParseEnum,
+		BITMAP => \&ParseBitmap
+	}->{$d->{DATA}->{TYPE}}->($d->{DATA});
+
+	$data->{ALIGN} = align_type($d->{NAME});
+
+	return {
+		NAME => $d->{NAME},
+		TYPE => $d->{TYPE},
+		PROPERTIES => $d->{PROPERTIES},
+		DATA => $data,
+		ORIGINAL => $d
+	};
+}
+
+sub ParseConst($$)
+{
+	my ($ndr,$d) = @_;
+
+	return $d;
+}
+
+sub ParseFunction($$$)
+{
+	my ($ndr,$d,$opnum) = @_;
+	my @elements = ();
+	my $rettype = undef;
+	my $thisopnum = undef;
+
+	CheckPointerTypes($d, $ndr->{PROPERTIES}->{pointer_default_top});
+
+	if (not defined($d->{PROPERTIES}{noopnum})) {
+		$thisopnum = ${$opnum};
+		${$opnum}++;
+	}
+
+	foreach my $x (@{$d->{ELEMENTS}}) {
+		my $e = ParseElement($x);
+		push (@{$e->{DIRECTION}}, "in") if (has_property($x, "in"));
+		push (@{$e->{DIRECTION}}, "out") if (has_property($x, "out"));
+		push (@elements, $e);
+	}
+
+	if ($d->{RETURN_TYPE} ne "void") {
+		$rettype = $d->{RETURN_TYPE};
+	}
+	
+	return {
+			NAME => $d->{NAME},
+			TYPE => "FUNCTION",
+			OPNUM => $thisopnum,
+			RETURN_TYPE => $rettype,
+			PROPERTIES => $d->{PROPERTIES},
+			ELEMENTS => \@elements,
+			ORIGINAL => $d
+		};
+}
+
+sub CheckPointerTypes($$)
+{
+	my $s = shift;
+	my $default = shift;
+
+	foreach my $e (@{$s->{ELEMENTS}}) {
+		if ($e->{POINTERS} and not defined(pointer_type($e))) {
+			$e->{PROPERTIES}->{$default} = 1;
+		}
+	}
+}
+
+sub ParseInterface($)
+{
+	my $idl = shift;
+	my @typedefs = ();
+	my @consts = ();
+	my @functions = ();
+	my @endpoints;
+	my @declares = ();
+	my $opnum = 0;
+	my $version;
+
+	if (not has_property($idl, "pointer_default")) {
+		# MIDL defaults to "ptr" in DCE compatible mode (/osf)
+		# and "unique" in Microsoft Extensions mode (default)
+		$idl->{PROPERTIES}->{pointer_default} = "unique";
+	}
+
+	if (not has_property($idl, "pointer_default_top")) {
+		$idl->{PROPERTIES}->{pointer_default_top} = "ref";
+	}
+
+	foreach my $d (@{$idl->{DATA}}) {
+		if ($d->{TYPE} eq "TYPEDEF") {
+			push (@typedefs, ParseTypedef($idl, $d));
+		}
+
+		if ($d->{TYPE} eq "DECLARE") {
+			push (@declares, $d);
+		}
+
+		if ($d->{TYPE} eq "FUNCTION") {
+			push (@functions, ParseFunction($idl, $d, \$opnum));
+		}
+
+		if ($d->{TYPE} eq "CONST") {
+			push (@consts, ParseConst($idl, $d));
+		}
+	}
+
+	$version = "0.0";
+
+	if(defined $idl->{PROPERTIES}->{version}) { 
+		$version = $idl->{PROPERTIES}->{version}; 
+	}
+
+	# If no endpoint is set, default to the interface name as a named pipe
+	if (!defined $idl->{PROPERTIES}->{endpoint}) {
+		push @endpoints, "\"ncacn_np:[\\\\pipe\\\\" . $idl->{NAME} . "]\"";
+	} else {
+		@endpoints = split / /, $idl->{PROPERTIES}->{endpoint};
+	}
+
+	return { 
+		NAME => $idl->{NAME},
+		UUID => has_property($idl, "uuid"),
+		VERSION => $version,
+		TYPE => "INTERFACE",
+		PROPERTIES => $idl->{PROPERTIES},
+		FUNCTIONS => \@functions,
+		CONSTS => \@consts,
+		TYPEDEFS => \@typedefs,
+		DECLARES => \@declares,
+		ENDPOINTS => \@endpoints
+	};
+}
+
+# Convert a IDL tree to a NDR tree
+# Gives a result tree describing all that's necessary for easily generating
+# NDR parsers / generators
+sub Parse($)
+{
+	my $idl = shift;
+	my @ndr = ();
+
+	push(@ndr, ParseInterface($_)) foreach (@{$idl});
+
+	return \@ndr;
+}
+
+sub GetNextLevel($$)
+{
+	my $e = shift;
+	my $fl = shift;
+
+	my $seen = 0;
+
+	foreach my $l (@{$e->{LEVELS}}) {
+		return $l if ($seen);
+		($seen = 1) if ($l == $fl);
+	}
+
+	return undef;
+}
+
+sub GetPrevLevel($$)
+{
+	my ($e,$fl) = @_;
+	my $prev = undef;
+
+	foreach my $l (@{$e->{LEVELS}}) {
+		(return $prev) if ($l == $fl);
+		$prev = $l;
+	}
+
+	return undef;
+}
+
+sub ContainsDeferred($$)
+{
+	my ($e,$l) = @_;
+
+	return 1 if ($l->{CONTAINS_DEFERRED});
+
+	while ($l = GetNextLevel($e,$l))
+	{
+		return 1 if ($l->{IS_DEFERRED}); 
+		return 1 if ($l->{CONTAINS_DEFERRED});
+	} 
+	
+	return 0;
+}
+
+sub el_name($)
+{
+	my $e = shift;
+
+	if ($e->{PARENT} && $e->{PARENT}->{NAME}) {
+		return "$e->{PARENT}->{NAME}.$e->{NAME}";
+	}
+
+	if ($e->{PARENT} && $e->{PARENT}->{PARENT}->{NAME}) {
+		return "$e->{PARENT}->{PARENT}->{NAME}.$e->{NAME}";
+	}
+
+	if ($e->{PARENT}) {
+		return "$e->{PARENT}->{NAME}.$e->{NAME}";
+	}
+
+	return $e->{NAME};
+}
+
+###################################
+# find a sibling var in a structure
+sub find_sibling($$)
+{
+	my($e,$name) = @_;
+	my($fn) = $e->{PARENT};
+
+	if ($name =~ /\*(.*)/) {
+		$name = $1;
+	}
+
+	for my $e2 (@{$fn->{ELEMENTS}}) {
+		return $e2 if ($e2->{NAME} eq $name);
+	}
+
+	return undef;
+}
+
+my %property_list = (
+	# interface
+	"helpstring"		=> ["INTERFACE", "FUNCTION"],
+	"version"		=> ["INTERFACE"],
+	"uuid"			=> ["INTERFACE"],
+	"endpoint"		=> ["INTERFACE"],
+	"pointer_default"	=> ["INTERFACE"],
+	"pointer_default_top"	=> ["INTERFACE"],
+	"depends"		=> ["INTERFACE"],
+	"authservice"		=> ["INTERFACE"],
+
+	# dcom
+	"object"		=> ["INTERFACE"],
+	"local"			=> ["INTERFACE", "FUNCTION"],
+	"iid_is"		=> ["ELEMENT"],
+	"call_as"		=> ["FUNCTION"],
+	"idempotent"		=> ["FUNCTION"],
+
+	# function
+	"noopnum"		=> ["FUNCTION"],
+	"in"			=> ["ELEMENT"],
+	"out"			=> ["ELEMENT"],
+
+	# pointer
+	"ref"			=> ["ELEMENT"],
+	"ptr"			=> ["ELEMENT"],
+	"sptr"			=> ["ELEMENT"],
+	"unique"		=> ["ELEMENT"],
+	"ignore"		=> ["ELEMENT"],
+	"relative"		=> ["ELEMENT"],
+	"relative_base"		=> ["TYPEDEF"],
+
+	"gensize"		=> ["TYPEDEF"],
+	"value"			=> ["ELEMENT"],
+	"flag"			=> ["ELEMENT", "TYPEDEF"],
+
+	# generic
+	"public"		=> ["FUNCTION", "TYPEDEF"],
+	"nopush"		=> ["FUNCTION", "TYPEDEF"],
+	"nopull"		=> ["FUNCTION", "TYPEDEF"],
+	"noprint"		=> ["FUNCTION", "TYPEDEF"],
+	"noejs"			=> ["FUNCTION", "TYPEDEF"],
+
+	# union
+	"switch_is"		=> ["ELEMENT"],
+	"switch_type"		=> ["ELEMENT", "TYPEDEF"],
+	"nodiscriminant"	=> ["TYPEDEF"],
+	"case"			=> ["ELEMENT"],
+	"default"		=> ["ELEMENT"],
+
+	# subcontext
+	"subcontext"		=> ["ELEMENT"],
+	"subcontext_size"	=> ["ELEMENT"],
+	"compression"		=> ["ELEMENT"],
+	"obfuscation"		=> ["ELEMENT"],
+
+	# enum
+	"enum8bit"		=> ["TYPEDEF"],
+	"enum16bit"		=> ["TYPEDEF"],
+	"v1_enum"		=> ["TYPEDEF"],
+
+	# bitmap
+	"bitmap8bit"		=> ["TYPEDEF"],
+	"bitmap16bit"		=> ["TYPEDEF"],
+	"bitmap32bit"		=> ["TYPEDEF"],
+	"bitmap64bit"		=> ["TYPEDEF"],
+
+	# array
+	"range"			=> ["ELEMENT"],
+	"size_is"		=> ["ELEMENT"],
+	"string"		=> ["ELEMENT"],
+	"noheader"		=> ["ELEMENT"],
+	"charset"		=> ["ELEMENT"],
+	"length_is"		=> ["ELEMENT"],
+);
+
+#####################################################################
+# check for unknown properties
+sub ValidProperties($$)
+{
+	my ($e,$t) = @_;
+
+	return unless defined $e->{PROPERTIES};
+
+	foreach my $key (keys %{$e->{PROPERTIES}}) {
+		fatal($e, el_name($e) . ": unknown property '$key'\n")
+			unless defined($property_list{$key});
+
+   		fatal($e, el_name($e) . ": property '$key' not allowed on '$t'\n")
+			unless grep($t, @{$property_list{$key}});
+	}
+}
+
+sub mapToScalar($)
+{
+	my $t = shift;
+	my $ti = getType($t);
+
+	if (not defined ($ti)) {
+		return undef;
+	} elsif ($ti->{DATA}->{TYPE} eq "ENUM") {
+		return Parse::Pidl::Typelist::enum_type_fn($ti->{DATA});
+	} elsif ($ti->{DATA}->{TYPE} eq "BITMAP") {
+		return Parse::Pidl::Typelist::enum_type_fn($ti->{DATA});
+	} elsif ($ti->{DATA}->{TYPE} eq "SCALAR") {
+		return $t;
+	}
+
+	return undef;
+}
+
+#####################################################################
+# parse a struct
+sub ValidElement($)
+{
+	my $e = shift;
+
+	ValidProperties($e,"ELEMENT");
+
+	if (has_property($e, "ptr")) {
+		fatal($e, el_name($e) . " : pidl does not support full NDR pointers yet\n");
+	}
+
+	# Check whether switches are used correctly.
+	if (my $switch = has_property($e, "switch_is")) {
+		my $e2 = find_sibling($e, $switch);
+		my $type = getType($e->{TYPE});
+
+		if (defined($type) and $type->{DATA}->{TYPE} ne "UNION") {
+			fatal($e, el_name($e) . ": switch_is() used on non-union type $e->{TYPE} which is a $type->{DATA}->{TYPE}");
+		}
+
+		if (!has_property($type, "nodiscriminant") and defined($e2)) {
+			my $discriminator_type = has_property($type, "switch_type");
+			$discriminator_type = "uint32" unless defined ($discriminator_type);
+
+			my $t1 = mapToScalar($discriminator_type);
+
+			if (not defined($t1)) {
+				fatal($e, el_name($e) . ": unable to map discriminator type '$discriminator_type' to scalar");
+			}
+
+			my $t2 = mapToScalar($e2->{TYPE});
+			if (not defined($t2)) {
+				fatal($e, el_name($e) . ": unable to map variable used for switch_is() to scalar");
+			}
+
+			if ($t1 ne $t2) {
+				nonfatal($e, el_name($e) . ": switch_is() is of type $e2->{TYPE} ($t2), while discriminator type for union $type->{NAME} is $discriminator_type ($t1)");
+			}
+		}
+	}
+
+	if (defined (has_property($e, "subcontext_size")) and not defined(has_property($e, "subcontext"))) {
+		fatal($e, el_name($e) . " : subcontext_size() on non-subcontext element");
+	}
+
+	if (defined (has_property($e, "compression")) and not defined(has_property($e, "subcontext"))) {
+		fatal($e, el_name($e) . " : compression() on non-subcontext element");
+	}
+
+	if (defined (has_property($e, "obfuscation")) and not defined(has_property($e, "subcontext"))) {
+		fatal($e, el_name($e) . " : obfuscation() on non-subcontext element");
+	}
+
+	if (!$e->{POINTERS} && (
+		has_property($e, "ptr") or
+		has_property($e, "sptr") or
+		has_property($e, "unique") or
+		has_property($e, "relative") or
+		has_property($e, "ref"))) {
+		fatal($e, el_name($e) . " : pointer properties on non-pointer element\n");	
+	}
+}
+
+#####################################################################
+# parse a struct
+sub ValidStruct($)
+{
+	my($struct) = shift;
+
+	ValidProperties($struct,"STRUCT");
+
+	foreach my $e (@{$struct->{ELEMENTS}}) {
+		$e->{PARENT} = $struct;
+		ValidElement($e);
+	}
+}
+
+#####################################################################
+# parse a union
+sub ValidUnion($)
+{
+	my($union) = shift;
+
+	ValidProperties($union,"UNION");
+
+	if (has_property($union->{PARENT}, "nodiscriminant") and has_property($union->{PARENT}, "switch_type")) {
+		fatal($union->{PARENT}, $union->{PARENT}->{NAME} . ": switch_type() on union without discriminant");
+	}
+	
+	foreach my $e (@{$union->{ELEMENTS}}) {
+		$e->{PARENT} = $union;
+
+		if (defined($e->{PROPERTIES}->{default}) and 
+			defined($e->{PROPERTIES}->{case})) {
+			fatal $e, "Union member $e->{NAME} can not have both default and case properties!\n";
+		}
+		
+		unless (defined ($e->{PROPERTIES}->{default}) or 
+				defined ($e->{PROPERTIES}->{case})) {
+			fatal $e, "Union member $e->{NAME} must have default or case property\n";
+		}
+
+		if (has_property($e, "ref")) {
+			fatal($e, el_name($e) . " : embedded ref pointers are not supported yet\n");
+		}
+
+
+		ValidElement($e);
+	}
+}
+
+#####################################################################
+# parse a typedef
+sub ValidTypedef($)
+{
+	my($typedef) = shift;
+	my $data = $typedef->{DATA};
+
+	ValidProperties($typedef,"TYPEDEF");
+
+	$data->{PARENT} = $typedef;
+
+	if (ref($data) eq "HASH") {
+		if ($data->{TYPE} eq "STRUCT") {
+			ValidStruct($data);
+		}
+
+		if ($data->{TYPE} eq "UNION") {
+			ValidUnion($data);
+		}
+	}
+}
+
+#####################################################################
+# parse a function
+sub ValidFunction($)
+{
+	my($fn) = shift;
+
+	ValidProperties($fn,"FUNCTION");
+
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		$e->{PARENT} = $fn;
+		if (has_property($e, "ref") && !$e->{POINTERS}) {
+			fatal $e, "[ref] variables must be pointers ($fn->{NAME}/$e->{NAME})\n";
+		}
+		ValidElement($e);
+	}
+}
+
+#####################################################################
+# parse the interface definitions
+sub ValidInterface($)
+{
+	my($interface) = shift;
+	my($data) = $interface->{DATA};
+
+	ValidProperties($interface,"INTERFACE");
+
+	if (has_property($interface, "pointer_default") && 
+		$interface->{PROPERTIES}->{pointer_default} eq "ptr") {
+		fatal $interface, "Full pointers are not supported yet\n";
+	}
+
+	if (has_property($interface, "object")) {
+     		if (has_property($interface, "version") && 
+			$interface->{PROPERTIES}->{version} != 0) {
+			fatal $interface, "Object interfaces must have version 0.0 ($interface->{NAME})\n";
+		}
+
+		if (!defined($interface->{BASE}) && 
+			not ($interface->{NAME} eq "IUnknown")) {
+			fatal $interface, "Object interfaces must all derive from IUnknown ($interface->{NAME})\n";
+		}
+	}
+		
+	foreach my $d (@{$data}) {
+		($d->{TYPE} eq "TYPEDEF") &&
+		    ValidTypedef($d);
+		($d->{TYPE} eq "FUNCTION") && 
+		    ValidFunction($d);
+	}
+
+}
+
+#####################################################################
+# Validate an IDL structure
+sub Validate($)
+{
+	my($idl) = shift;
+
+	foreach my $x (@{$idl}) {
+		($x->{TYPE} eq "INTERFACE") && 
+		    ValidInterface($x);
+	}
+}
+
+1;
diff --git a/source4/pidl/lib/Parse/Pidl/ODL.pm b/source4/pidl/lib/Parse/Pidl/ODL.pm
new file mode 100644
index 0000000000..03d66bfc45
--- /dev/null
+++ b/source4/pidl/lib/Parse/Pidl/ODL.pm
@@ -0,0 +1,92 @@
+##########################################
+# Converts ODL stuctures to IDL structures
+# (C) 2004-2005 Jelmer Vernooij <jelmer@samba.org>
+
+package Parse::Pidl::ODL;
+
+use Parse::Pidl::Util qw(has_property);
+use Parse::Pidl::Typelist qw(hasType getType);
+use strict;
+
+#####################################################################
+# find an interface in an array of interfaces
+sub get_interface($$)
+{
+	my($if) = shift;
+	my($n) = shift;
+
+	foreach(@{$if}) {
+		if($_->{NAME} eq $n) { return $_; }
+	}
+	
+	return 0;
+}
+
+sub FunctionAddObjArgs($)
+{
+	my $e = shift;
+	
+	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 ReplaceInterfacePointers($)
+{
+	my $e = shift;
+
+	foreach my $x (@{$e->{ELEMENTS}}) {
+		next unless (hasType($x->{TYPE}));
+		next unless getType($x->{TYPE})->{DATA}->{TYPE} eq "INTERFACE";
+		
+		$x->{TYPE} = "MInterfacePointer";
+	}
+}
+
+# Add ORPC specific bits to an interface.
+sub ODL2IDL($)
+{
+	my $odl = shift;
+	
+	foreach my $x (@{$odl}) {
+		# Add [in] ORPCTHIS *this, [out] ORPCTHAT *that
+		# and replace interfacepointers with MInterfacePointer
+		# for 'object' interfaces
+		if (has_property($x, "object")) {
+			foreach my $e (@{$x->{DATA}}) {
+				($e->{TYPE} eq "FUNCTION") && FunctionAddObjArgs($e);
+				ReplaceInterfacePointers($e);
+			}
+			# Object interfaces use ORPC
+			my @depends = ();
+			if(has_property($x, "depends")) {
+				@depends = split /,/, $x->{PROPERTIES}->{depends};
+			}
+			push @depends, "orpc";
+			$x->{PROPERTIES}->{depends} = join(',',@depends);
+		}
+
+		if ($x->{BASE}) {
+			my $base = get_interface($odl, $x->{BASE});
+
+			foreach my $fn (reverse @{$base->{DATA}}) {
+				next unless ($fn->{TYPE} eq "FUNCTION");
+				unshift (@{$x->{DATA}}, $fn);
+				push (@{$x->{INHERITED_FUNCTIONS}}, $fn->{NAME});
+			}
+		}
+	}
+
+	return $odl;
+}
+
+1;
diff --git a/source4/pidl/lib/Parse/Pidl/Samba/COM/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba/COM/Header.pm
new file mode 100644
index 0000000000..7b6c4db212
--- /dev/null
+++ b/source4/pidl/lib/Parse/Pidl/Samba/COM/Header.pm
@@ -0,0 +1,139 @@
+# COM Header generation
+# (C) 2005 Jelmer Vernooij <jelmer@samba.org>
+
+package Parse::Pidl::Samba::COM::Header;
+
+use Parse::Pidl::Typelist;
+use Parse::Pidl::Util qw(has_property);
+
+use strict;
+
+sub GetArgumentProtoList($)
+{
+	my $f = shift;
+	my $res = "";
+
+	foreach my $a (@{$f->{ELEMENTS}}) {
+
+		$res .= ", " . Parse::Pidl::Typelist::mapType($a->{TYPE}) . " ";
+
+		my $l = $a->{POINTERS};
+		$l-- if (Parse::Pidl::Typelist::scalar_is_reference($a->{TYPE}));
+		foreach my $i (1..$l) {
+			$res .= "*";
+		}
+
+		if (defined $a->{ARRAY_LEN}[0] && 
+		!Parse::Pidl::Util::is_constant($a->{ARRAY_LEN}[0]) &&
+		!$a->{POINTERS}) {
+			$res .= "*";
+		}
+		$res .= $a->{NAME};
+		if (defined $a->{ARRAY_LEN}[0] && Parse::Pidl::Util::is_constant($a->{ARRAY_LEN}[0])) {
+			$res .= "[$a->{ARRAY_LEN}[0]]";
+		}
+	}
+
+	return $res;
+}
+
+sub GetArgumentList($)
+{
+	my $f = shift;
+	my $res = "";
+
+	foreach my $a (@{$f->{ELEMENTS}}) {
+		$res .= ", $a->{NAME}";
+	}
+
+	return $res;
+}
+
+#####################################################################
+# generate vtable structure for COM interface
+sub HeaderVTable($)
+{
+	my $interface = shift;
+	my $res;
+	$res .= "#define " . uc($interface->{NAME}) . "_METHODS \\\n";
+	if (defined($interface->{BASE})) {
+		$res .= "\t" . uc($interface->{BASE} . "_METHODS") . "\\\n";
+	}
+
+	my $data = $interface->{DATA};
+	foreach my $d (@{$data}) {
+		$res .= "\t" . Parse::Pidl::Typelist::mapType($d->{RETURN_TYPE}) . " (*$d->{NAME}) (struct $interface->{NAME} *d, TALLOC_CTX *mem_ctx" . GetArgumentProtoList($d) . ");\\\n" if ($d->{TYPE} eq "FUNCTION");
+	}
+	$res .= "\n";
+	$res .= "struct $interface->{NAME}_vtable {\n";
+	$res .= "\tstruct GUID iid;\n";
+	$res .= "\t" . uc($interface->{NAME}) . "_METHODS\n";
+	$res .= "};\n\n";
+
+	return $res;
+}
+
+sub ParseInterface($)
+{
+	my $if = shift;
+	my $res;
+
+	$res .="\n\n/* $if->{NAME} */\n";
+
+	$res .="#define COM_" . uc($if->{NAME}) . "_UUID $if->{PROPERTIES}->{uuid}\n\n";
+
+	$res .="struct $if->{NAME}_vtable;\n\n";
+
+	$res .="struct $if->{NAME} {
+	struct com_context *ctx;
+	struct $if->{NAME}_vtable *vtable;
+	void *object_data;
+};\n\n";
+
+	$res.=HeaderVTable($if);
+
+	foreach my $d (@{$if->{DATA}}) {
+		next if ($d->{TYPE} ne "FUNCTION");
+
+		$res .= "#define $if->{NAME}_$d->{NAME}(interface, mem_ctx" . GetArgumentList($d) . ") ";
+
+		$res .= "((interface)->vtable->$d->{NAME}(interface, mem_ctx" . GetArgumentList($d) . "))";
+
+		$res .="\n";
+	}
+
+	return $res;
+}
+
+sub ParseCoClass($)
+{
+	my $c = shift;
+	my $res = "";
+	$res .= "#define CLSID_" . uc($c->{NAME}) . " $c->{PROPERTIES}->{uuid}\n";
+	if (has_property($c, "progid")) {
+		$res .= "#define PROGID_" . uc($c->{NAME}) . " $c->{PROPERTIES}->{progid}\n";
+	}
+	$res .= "\n";
+	return $res;
+}
+
+sub Parse($)
+{
+	my $idl = shift;
+	my $res = "";
+
+	foreach my $x (@{$idl})
+	{
+		if ($x->{TYPE} eq "INTERFACE" && has_property($x, "object")) {
+			$res.=ParseInterface($x);
+		} 
+
+		if ($x->{TYPE} eq "COCLASS") {
+			$res.=ParseCoClass($x);
+		}
+	}
+
+	return $res;
+}
+
+1;
diff --git a/source4/pidl/lib/Parse/Pidl/Samba/COM/Proxy.pm b/source4/pidl/lib/Parse/Pidl/Samba/COM/Proxy.pm
new file mode 100644
index 0000000000..c94ef59ae9
--- /dev/null
+++ b/source4/pidl/lib/Parse/Pidl/Samba/COM/Proxy.pm
@@ -0,0 +1,212 @@
+###################################################
+# DCOM parser for Samba
+# Basically the glue between COM and DCE/RPC with NDR
+# Copyright jelmer@samba.org 2003-2005
+# released under the GNU GPL
+
+package Parse::Pidl::Samba::COM::Proxy;
+
+use Parse::Pidl::Samba::COM::Header;
+use Parse::Pidl::Util qw(has_property);
+
+use strict;
+
+my($res);
+
+sub ParseVTable($$)
+{
+	my $interface = shift;
+	my $name = shift;
+
+	# Generate the vtable
+	$res .="\tstruct $interface->{NAME}_vtable $name = {";
+
+	if (defined($interface->{BASE})) {
+		$res .= "\n\t\t{},";
+	}
+
+	my $data = $interface->{DATA};
+
+	foreach my $d (@{$data}) {
+		if ($d->{TYPE} eq "FUNCTION") {
+		    $res .= "\n\t\tdcom_proxy_$interface->{NAME}_$d->{NAME}";
+			$res .= ",";
+		}
+	}
+
+	$res .= "\n\t};\n\n";
+}
+
+sub ParseRegFunc($)
+{
+	my $interface = shift;
+
+	$res .= "static NTSTATUS dcom_proxy_$interface->{NAME}_init(void)
+{
+	struct GUID base_iid;
+	struct $interface->{NAME}_vtable *proxy_vtable = talloc(talloc_autofree_context(), struct $interface->{NAME}_vtable);
+";
+
+	if (defined($interface->{BASE})) {
+		$res.= "
+	const void *base_vtable;
+
+	GUID_from_string(DCERPC_" . (uc $interface->{BASE}) . "_UUID, &base_iid);
+
+	base_vtable = dcom_proxy_vtable_by_iid(&base_iid);
+	if (base_vtable == NULL) {
+		DEBUG(0, (\"No proxy registered for base interface '$interface->{BASE}'\\n\"));
+		return NT_STATUS_FOOBAR;
+	}
+	
+	memcpy(&proxy_vtable, base_vtable, sizeof(struct $interface->{BASE}_vtable));
+
+";
+	}
+	foreach my $x (@{$interface->{DATA}}) {
+		next unless ($x->{TYPE} eq "FUNCTION");
+
+		$res .= "\tproxy_vtable.$x->{NAME} = dcom_proxy_$interface->{NAME}_$x->{NAME};\n";
+	}
+
+	$res.= "
+	GUID_from_string(DCERPC_" . (uc $interface->{NAME}) . "_UUID, &proxy_vtable.iid);
+
+	return dcom_register_proxy(&proxy_vtable);
+}\n\n";
+}
+
+#####################################################################
+# parse a function
+sub ParseFunction($$)
+{
+	my $interface = shift;
+	my $fn = shift;
+	my $name = $fn->{NAME};
+	my $uname = uc $name;
+
+	$res.="
+static $fn->{RETURN_TYPE} dcom_proxy_$interface->{NAME}_$name(struct $interface->{NAME} *d, TALLOC_CTX *mem_ctx" . Parse::Pidl::Samba::COM::Header::GetArgumentProtoList($fn) . ")
+{
+	struct dcerpc_pipe *p;
+	NTSTATUS status = dcom_get_pipe(d, &p);
+	struct $name r;
+	struct rpc_request *req;
+
+	if (NT_STATUS_IS_ERR(status)) {
+		return status;
+	}
+
+	ZERO_STRUCT(r.in.ORPCthis);
+	r.in.ORPCthis.version.MajorVersion = COM_MAJOR_VERSION;
+	r.in.ORPCthis.version.MinorVersion = COM_MINOR_VERSION;
+";
+	
+	# Put arguments into r
+	foreach my $a (@{$fn->{ELEMENTS}}) {
+		next unless (has_property($a, "in"));
+		if (Parse::Pidl::Typelist::typeIs($a->{TYPE}, "INTERFACE")) {
+			$res .="\tNDR_CHECK(dcom_OBJREF_from_IUnknown(&r.in.$a->{NAME}.obj, $a->{NAME}));\n";
+		} else {
+			$res .= "\tr.in.$a->{NAME} = $a->{NAME};\n";
+		}
+	}
+
+	$res .="
+	if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG($name, &r);		
+	}
+
+	status = dcerpc_ndr_request(p, &d->ipid, &dcerpc_table_$interface->{NAME}, DCERPC_$uname, mem_ctx, &r);
+
+	if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG($name, r);		
+	}
+
+";
+
+	# Put r info back into arguments
+	foreach my $a (@{$fn->{ELEMENTS}}) {
+		next unless (has_property($a, "out"));
+
+		if (Parse::Pidl::Typelist::typeIs($a->{TYPE}, "INTERFACE")) {
+			$res .="\tNDR_CHECK(dcom_IUnknown_from_OBJREF(d->ctx, &$a->{NAME}, r.out.$a->{NAME}.obj));\n";
+		} else {
+			$res .= "\t*$a->{NAME} = r.out.$a->{NAME};\n";
+		}
+
+	}
+	
+	if ($fn->{RETURN_TYPE} eq "NTSTATUS") {
+		$res .= "\tif (NT_STATUS_IS_OK(status)) status = r.out.result;\n";
+	}
+
+	$res .= 
+	"
+	return r.out.result;
+}\n\n";
+}
+
+#####################################################################
+# parse the interface definitions
+sub ParseInterface($)
+{
+	my($interface) = shift;
+	my($data) = $interface->{DATA};
+	$res = "/* DCOM proxy for $interface->{NAME} generated by pidl */\n\n";
+	foreach my $d (@{$data}) {
+		($d->{TYPE} eq "FUNCTION") && 
+		ParseFunction($interface, $d);
+	}
+
+	ParseRegFunc($interface);
+}
+
+sub RegistrationFunction($$)
+{
+	my $idl = shift;
+	my $basename = shift;
+
+	my $res = "\n\nNTSTATUS dcom_$basename\_init(void)\n";
+	$res .= "{\n";
+	$res .="\tNTSTATUS status = NT_STATUS_OK;\n";
+	foreach my $interface (@{$idl}) {
+		next if $interface->{TYPE} ne "INTERFACE";
+		next if not has_property($interface, "object");
+
+		my $data = $interface->{DATA};
+		my $count = 0;
+		foreach my $d (@{$data}) {
+			if ($d->{TYPE} eq "FUNCTION") { $count++; }
+		}
+
+		next if ($count == 0);
+
+		$res .= "\tstatus = dcom_$interface->{NAME}_init();\n";
+		$res .= "\tif (NT_STATUS_IS_ERR(status)) {\n";
+		$res .= "\t\treturn status;\n";
+		$res .= "\t}\n\n";
+	}
+	$res .= "\treturn status;\n";
+	$res .= "}\n\n";
+
+	return $res;
+}
+
+sub Parse($)
+{
+	my $pidl = shift;
+	my $res = "";
+
+	foreach my $x (@{$pidl}) {
+		next if ($x->{TYPE} ne "INTERFACE");
+		next if has_property($x, "local");
+		next unless has_property($x, "object");
+
+		$res .= ParseInterface($x);
+	}
+
+	return $res;
+}
+
+1;
diff --git a/source4/pidl/lib/Parse/Pidl/Samba/COM/Stub.pm b/source4/pidl/lib/Parse/Pidl/Samba/COM/Stub.pm
new file mode 100644
index 0000000000..785c34fc77
--- /dev/null
+++ b/source4/pidl/lib/Parse/Pidl/Samba/COM/Stub.pm
@@ -0,0 +1,324 @@
+###################################################
+# DCOM stub boilerplate generator
+# Copyright jelmer@samba.org 2004-2005
+# Copyright tridge@samba.org 2003
+# Copyright metze@samba.org 2004
+# released under the GNU GPL
+
+package Parse::Pidl::Samba::COM::Stub;
+
+use Parse::Pidl::Util qw(has_property);
+use strict;
+
+my($res);
+
+sub pidl($)
+{
+	$res .= shift;
+}
+
+#####################################################
+# generate the switch statement for function dispatch
+sub gen_dispatch_switch($)
+{
+	my $data = shift;
+
+	my $count = 0;
+	foreach my $d (@{$data}) {
+		next if ($d->{TYPE} ne "FUNCTION");
+
+		pidl "\tcase $count: {\n";
+		if ($d->{RETURN_TYPE} && $d->{RETURN_TYPE} ne "void") {
+			pidl "\t\tNTSTATUS result;\n";
+		}
+		pidl "\t\tstruct $d->{NAME} *r2 = r;\n";
+		pidl "\t\tif (DEBUGLEVEL > 10) {\n";
+		pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($d->{NAME}, NDR_IN, r2);\n";
+		pidl "\t\t}\n";
+		if ($d->{RETURN_TYPE} && $d->{RETURN_TYPE} ne "void") {
+			pidl "\t\tresult = vtable->$d->{NAME}(iface, mem_ctx, r2);\n";
+		} else {
+			pidl "\t\tvtable->$d->{NAME}(iface, mem_ctx, r2);\n";
+		}
+		pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n";
+		pidl "\t\t\tDEBUG(5,(\"function $d->{NAME} will reply async\\n\"));\n";
+		pidl "\t\t}\n";
+		pidl "\t\tbreak;\n\t}\n";
+		$count++; 
+	}
+}
+
+#####################################################
+# generate the switch statement for function reply
+sub gen_reply_switch($)
+{
+	my $data = shift;
+
+	my $count = 0;
+	foreach my $d (@{$data}) {
+		next if ($d->{TYPE} ne "FUNCTION");
+
+		pidl "\tcase $count: {\n";
+		pidl "\t\tstruct $d->{NAME} *r2 = r;\n";
+		pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n";
+		pidl "\t\t\tDEBUG(5,(\"function $d->{NAME} replied async\\n\"));\n";
+		pidl "\t\t}\n";
+		pidl "\t\tif (DEBUGLEVEL > 10 && dce_call->fault_code == 0) {\n";
+		pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($d->{NAME}, NDR_OUT | NDR_SET_VALUES, r2);\n";
+		pidl "\t\t}\n";
+		pidl "\t\tif (dce_call->fault_code != 0) {\n";
+		pidl "\t\t\tDEBUG(2,(\"dcerpc_fault %s in $d->{NAME}\\n\", dcerpc_errstr(mem_ctx, dce_call->fault_code)));\n";
+		pidl "\t\t}\n";
+		pidl "\t\tbreak;\n\t}\n";
+		$count++; 
+	}
+}
+
+#####################################################################
+# produce boilerplate code for a interface
+sub Boilerplate_Iface($)
+{
+	my($interface) = shift;
+	my($data) = $interface->{DATA};
+	my $name = $interface->{NAME};
+	my $uname = uc $name;
+	my $uuid = Parse::Pidl::Util::make_str($interface->{PROPERTIES}->{uuid});
+	my $if_version = $interface->{PROPERTIES}->{version};
+
+	pidl "
+static NTSTATUS $name\__op_bind(struct dcesrv_call_state *dce_call, const struct dcesrv_interface *iface)
+{
+#ifdef DCESRV_INTERFACE_$uname\_BIND
+	return DCESRV_INTERFACE_$uname\_BIND(dce_call,iface);
+#else
+	return NT_STATUS_OK;
+#endif
+}
+
+static void $name\__op_unbind(struct dcesrv_connection_context *context, const struct dcesrv_interface *iface)
+{
+#ifdef DCESRV_INTERFACE_$uname\_UNBIND
+	DCESRV_INTERFACE_$uname\_UNBIND(context, iface);
+#else
+	return;
+#endif
+}
+
+static NTSTATUS $name\__op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_pull *pull, void **r)
+{
+	NTSTATUS status;
+	uint16_t opnum = dce_call->pkt.u.request.opnum;
+
+	dce_call->fault_code = 0;
+
+	if (opnum >= dcerpc_table_$name.num_calls) {
+		dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
+		return NT_STATUS_NET_WRITE_FAULT;
+	}
+
+	*r = talloc_size(mem_ctx, dcerpc_table_$name.calls[opnum].struct_size);
+	NT_STATUS_HAVE_NO_MEMORY(*r);
+
+        /* unravel the NDR for the packet */
+	status = dcerpc_table_$name.calls[opnum].ndr_pull(pull, NDR_IN, *r);
+	if (!NT_STATUS_IS_OK(status)) {
+		dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN,
+				  &dce_call->pkt.u.request.stub_and_verifier);
+		dce_call->fault_code = DCERPC_FAULT_NDR;
+		return NT_STATUS_NET_WRITE_FAULT;
+	}
+
+	return NT_STATUS_OK;
+}
+
+static NTSTATUS $name\__op_dispatch(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
+{
+	uint16_t opnum = dce_call->pkt.u.request.opnum;
+	struct GUID ipid = dce_call->pkt.u.request.object.object;
+	struct dcom_interface_p *iface = dcom_get_local_iface_p(&ipid);
+	const struct dcom_$name\_vtable *vtable = iface->vtable;
+
+	switch (opnum) {
+";
+	gen_dispatch_switch($data);
+
+pidl "
+	default:
+		dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
+		break;
+	}
+
+	if (dce_call->fault_code != 0) {
+		dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN,
+				  &dce_call->pkt.u.request.stub_and_verifier);
+		return NT_STATUS_NET_WRITE_FAULT;
+	}
+
+	return NT_STATUS_OK;
+}
+
+static NTSTATUS $name\__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
+{
+	uint16_t opnum = dce_call->pkt.u.request.opnum;
+
+	switch (opnum) {
+";
+	gen_reply_switch($data);
+
+pidl "
+	default:
+		dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
+		break;
+	}
+
+	if (dce_call->fault_code != 0) {
+		dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN,
+				  &dce_call->pkt.u.request.stub_and_verifier);
+		return NT_STATUS_NET_WRITE_FAULT;
+	}
+
+	return NT_STATUS_OK;
+}
+
+static NTSTATUS $name\__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_push *push, const void *r)
+{
+	NTSTATUS status;
+	uint16_t opnum = dce_call->pkt.u.request.opnum;
+
+	status = dcerpc_table_$name.calls[opnum].ndr_push(push, NDR_OUT, r);
+	if (!NT_STATUS_IS_OK(status)) {
+		dce_call->fault_code = DCERPC_FAULT_NDR;
+		return NT_STATUS_NET_WRITE_FAULT;
+	}
+
+	return NT_STATUS_OK;
+}
+
+static const struct dcesrv_interface $name\_interface = {
+	.name		= \"$name\",
+	.uuid		= $uuid,
+	.if_version	= $if_version,
+	.bind		= $name\__op_bind,
+	.unbind		= $name\__op_unbind,
+	.ndr_pull	= $name\__op_ndr_pull,
+	.dispatch	= $name\__op_dispatch,
+	.reply		= $name\__op_reply,
+	.ndr_push	= $name\__op_ndr_push
+};
+
+";
+}
+
+#####################################################################
+# produce boilerplate code for an endpoint server
+sub Boilerplate_Ep_Server($)
+{
+	my($interface) = shift;
+	my $name = $interface->{NAME};
+	my $uname = uc $name;
+
+	pidl "
+static NTSTATUS $name\__op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server)
+{
+	int i;
+
+	for (i=0;i<dcerpc_table_$name.endpoints->count;i++) {
+		NTSTATUS ret;
+		const char *name = dcerpc_table_$name.endpoints->names[i];
+
+		ret = dcesrv_interface_register(dce_ctx, name, &$name\_interface, NULL);
+		if (!NT_STATUS_IS_OK(ret)) {
+			DEBUG(1,(\"$name\_op_init_server: failed to register endpoint \'%s\'\\n\",name));
+			return ret;
+		}
+	}
+
+	return NT_STATUS_OK;
+}
+
+static BOOL $name\__op_interface_by_uuid(struct dcesrv_interface *iface, const char *uuid, uint32_t if_version)
+{
+	if (dcerpc_table_$name.if_version == if_version &&
+		strcmp(dcerpc_table_$name.uuid, uuid)==0) {
+		memcpy(iface,&dcerpc_table_$name, sizeof(*iface));
+		return True;
+	}
+
+	return False;
+}
+
+static BOOL $name\__op_interface_by_name(struct dcesrv_interface *iface, const char *name)
+{
+	if (strcmp(dcerpc_table_$name.name, name)==0) {
+		memcpy(iface,&dcerpc_table_$name, sizeof(*iface));
+		return True;
+	}
+
+	return False;	
+}
+	
+NTSTATUS dcerpc_server_$name\_init(void)
+{
+	NTSTATUS ret;
+	struct dcesrv_endpoint_server ep_server;
+
+	/* fill in our name */
+	ep_server.name = \"$name\";
+
+	/* fill in all the operations */
+	ep_server.init_server = $name\__op_init_server;
+
+	ep_server.interface_by_uuid = $name\__op_interface_by_uuid;
+	ep_server.interface_by_name = $name\__op_interface_by_name;
+
+	/* register ourselves with the DCERPC subsystem. */
+	ret = dcerpc_register_ep_server(&ep_server);
+
+	if (!NT_STATUS_IS_OK(ret)) {
+		DEBUG(0,(\"Failed to register \'$name\' endpoint server!\\n\"));
+		return ret;
+	}
+
+	return ret;
+}
+
+";
+}
+
+#####################################################################
+# dcom interface stub from a parsed IDL structure 
+sub ParseInterface($)
+{
+	my($interface) = shift;
+	
+	return "" if has_property($interface, "local");
+	
+	my($data) = $interface->{DATA};
+	my $count = 0;
+
+	$res = "";
+
+	if (!defined $interface->{PROPERTIES}->{uuid}) {
+		return $res;
+	}
+
+	if (!defined $interface->{PROPERTIES}->{version}) {
+		$interface->{PROPERTIES}->{version} = "0.0";
+	}
+
+	foreach my $d (@{$data}) {
+		if ($d->{TYPE} eq "FUNCTION") { $count++; }
+	}
+
+	if ($count == 0) {
+		return $res;
+	}
+
+	$res = "/* dcom interface stub generated by pidl */\n\n";
+	Boilerplate_Iface($interface);
+	Boilerplate_Ep_Server($interface);
+
+	return $res;
+}
+
+1;
diff --git a/source4/pidl/lib/Parse/Pidl/Samba/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba/EJS.pm
new file mode 100644
index 0000000000..743139c8cd
--- /dev/null
+++ b/source4/pidl/lib/Parse/Pidl/Samba/EJS.pm
@@ -0,0 +1,835 @@
+###################################################
+# EJS function wrapper generator
+# Copyright jelmer@samba.org 2005
+# Copyright Andrew Tridgell 2005
+# released under the GNU GPL
+
+package Parse::Pidl::Samba::EJS;
+
+use strict;
+use Parse::Pidl::Typelist;
+use Parse::Pidl::Util qw(has_property);
+
+my($res);
+my %constants;
+
+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);
+}
+
+# this should probably be in ndr.pm
+sub GenerateStructEnv($)
+{
+	my $x = shift;
+	my %env;
+
+	foreach my $e (@{$x->{ELEMENTS}}) {
+		if ($e->{NAME}) {
+			$env{$e->{NAME}} = "r->$e->{NAME}";
+		}
+	}
+
+	$env{"this"} = "r";
+
+	return \%env;
+}
+
+sub GenerateFunctionInEnv($)
+{
+	my $fn = shift;
+	my %env;
+
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		if (grep (/in/, @{$e->{DIRECTION}})) {
+			$env{$e->{NAME}} = "r->in.$e->{NAME}";
+		}
+	}
+
+	return \%env;
+}
+
+sub GenerateFunctionOutEnv($)
+{
+	my $fn = shift;
+	my %env;
+
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		if (grep (/out/, @{$e->{DIRECTION}})) {
+			$env{$e->{NAME}} = "r->out.$e->{NAME}";
+		} elsif (grep (/in/, @{$e->{DIRECTION}})) {
+			$env{$e->{NAME}} = "r->in.$e->{NAME}";
+		}
+	}
+
+	return \%env;
+}
+
+sub get_pointer_to($)
+{
+	my $var_name = shift;
+	
+	if ($var_name =~ /^\*(.*)$/) {
+		return $1;
+	} elsif ($var_name =~ /^\&(.*)$/) {
+		return "&($var_name)";
+	} else {
+		return "&$var_name";
+	}
+}
+
+sub get_value_of($)
+{
+	my $var_name = shift;
+
+	if ($var_name =~ /^\&(.*)$/) {
+		return $1;
+	} else {
+		return "*$var_name";
+	}
+}
+
+#####################################################################
+# work out is a parse function should be declared static or not
+sub fn_prefix($)
+{
+	my $fn = shift;
+
+	return "" if (has_property($fn, "public"));
+	return "static ";
+}
+
+###########################
+# pull a scalar element
+sub EjsPullScalar($$$$$)
+{
+	my ($e, $l, $var, $name, $env) = @_;
+
+	return if (has_property($e, "value"));
+
+        my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l);
+        $var = get_pointer_to($var);
+        # have to handle strings specially :(
+        if ($e->{TYPE} eq "string" && $pl && $pl->{TYPE} eq "POINTER") {
+                $var = get_pointer_to($var);
+        }
+	pidl "NDR_CHECK(ejs_pull_$e->{TYPE}(ejs, v, $name, $var));";
+}
+
+###########################
+# pull a pointer element
+sub EjsPullPointer($$$$$)
+{
+	my ($e, $l, $var, $name, $env) = @_;
+	pidl "if (ejs_pull_null(ejs, v, $name)) {";
+	indent;
+	pidl "$var = NULL;";
+	deindent;
+	pidl "} else {";
+	indent;
+	pidl "EJS_ALLOC(ejs, $var);";
+	$var = get_value_of($var);		
+	EjsPullElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env);
+	deindent;
+	pidl "}";
+}
+
+###########################
+# pull a string element
+sub EjsPullString($$$$$)
+{
+	my ($e, $l, $var, $name, $env) = @_;
+	$var = get_pointer_to($var);
+	pidl "NDR_CHECK(ejs_pull_string(ejs, v, $name, $var));";
+}
+
+
+###########################
+# pull an array element
+sub EjsPullArray($$$$$)
+{
+	my ($e, $l, $var, $name, $env) = @_;
+	my $nl = Parse::Pidl::NDR::GetNextLevel($e, $l);
+	my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env);
+	my $size = Parse::Pidl::Util::ParseExpr($l->{SIZE_IS}, $env);
+	my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l);
+	if ($pl && $pl->{TYPE} eq "POINTER") {
+		$var = get_pointer_to($var);
+	}
+	# uint8 arrays are treated as data blobs
+	if ($nl->{TYPE} eq 'DATA' && $e->{TYPE} eq 'uint8') {
+		if (!$l->{IS_FIXED}) {
+			pidl "EJS_ALLOC_N(ejs, $var, $size);";
+		}
+		pidl "ejs_pull_array_uint8(ejs, v, $name, $var, $length);";
+		return;
+	}
+	my $avar = $var . "[i]";
+	pidl "{";
+	indent;
+	pidl "uint32_t i;";
+	if (!$l->{IS_FIXED}) {
+		pidl "EJS_ALLOC_N(ejs, $var, $size);";
+	}
+	pidl "for (i=0;i<$length;i++) {";
+	indent;
+	pidl "char *id = talloc_asprintf(ejs, \"%s.%u\", $name, i);";
+	EjsPullElement($e, $nl, $avar, "id", $env);
+	pidl "talloc_free(id);";
+	deindent;
+	pidl "}";
+	pidl "ejs_push_uint32(ejs, v, $name \".length\", &i);";
+	deindent;
+	pidl "}";
+}
+
+###########################
+# pull a switch element
+sub EjsPullSwitch($$$$$)
+{
+	my ($e, $l, $var, $name, $env) = @_;
+	my $switch_var = Parse::Pidl::Util::ParseExpr($l->{SWITCH_IS}, $env);
+	pidl "ejs_set_switch(ejs, $switch_var);";
+	EjsPullElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env);
+}
+
+###########################
+# pull a structure element
+sub EjsPullElement($$$$$)
+{
+	my ($e, $l, $var, $name, $env) = @_;
+	if (has_property($e, "charset")) {
+		EjsPullString($e, $l, $var, $name, $env);
+	} elsif ($l->{TYPE} eq "ARRAY") {
+		EjsPullArray($e, $l, $var, $name, $env);
+	} elsif ($l->{TYPE} eq "DATA") {
+		EjsPullScalar($e, $l, $var, $name, $env);
+	} elsif (($l->{TYPE} eq "POINTER")) {
+		EjsPullPointer($e, $l, $var, $name, $env);
+	} elsif (($l->{TYPE} eq "SWITCH")) {
+		EjsPullSwitch($e, $l, $var, $name, $env);
+	} else {
+		pidl "return ejs_panic(ejs, \"unhandled pull type $l->{TYPE}\");";
+	}
+}
+
+#############################################
+# pull a structure/union element at top level
+sub EjsPullElementTop($$)
+{
+	my $e = shift;
+	my $env = shift;
+	my $l = $e->{LEVELS}[0];
+	my $var = Parse::Pidl::Util::ParseExpr($e->{NAME}, $env);
+	my $name = "\"$e->{NAME}\"";
+	EjsPullElement($e, $l, $var, $name, $env);
+}
+
+###########################
+# pull a struct
+sub EjsStructPull($$)
+{
+	my $name = shift;
+	my $d = shift;
+	my $env = GenerateStructEnv($d);
+	pidl fn_prefix($d);
+	pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, struct $name *r)\n{";
+	indent;
+	pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, name));";
+        foreach my $e (@{$d->{ELEMENTS}}) {
+		EjsPullElementTop($e, $env);
+	}
+	pidl "return NT_STATUS_OK;";
+	deindent;
+	pidl "}\n";
+}
+
+###########################
+# pull a union
+sub EjsUnionPull($$)
+{
+	my $name = shift;
+	my $d = shift;
+	my $have_default = 0;
+	my $env = GenerateStructEnv($d);
+	pidl fn_prefix($d);
+	pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, union $name *r)\n{";
+	indent;
+	pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, name));";
+	pidl "switch (ejs->switch_var) {";
+	indent;
+	foreach my $e (@{$d->{ELEMENTS}}) {
+		if ($e->{CASE} eq "default") {
+			$have_default = 1;
+		}
+		pidl "$e->{CASE}:";
+		indent;
+		if ($e->{TYPE} ne "EMPTY") {
+			EjsPullElementTop($e, $env);
+		}
+		pidl "break;";
+		deindent;
+	}
+	if (! $have_default) {
+		pidl "default:";
+		indent;
+		pidl "return ejs_panic(ejs, \"Bad switch value\");";
+		deindent;
+	}
+	deindent;
+	pidl "}";
+	pidl "return NT_STATUS_OK;";
+	deindent;
+	pidl "}";
+}
+
+##############################################
+# put the enum elements in the constants array
+sub EjsEnumConstant($)
+{
+	my $d = shift;
+	my $v = 0;
+	foreach my $e (@{$d->{ELEMENTS}}) {
+		my $el = $e;
+		chomp $el;
+		if ($el =~ /^(.*)=\s*(.*)\s*$/) {
+			$el = $1;
+			$v = $2;
+		}
+		$constants{$el} = $v;
+		$v++;
+	}
+}
+
+###########################
+# pull a enum
+sub EjsEnumPull($$)
+{
+	my $name = shift;
+	my $d = shift;
+	EjsEnumConstant($d);
+	pidl fn_prefix($d);
+	pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, enum $name *r)\n{";
+	indent;
+	pidl "unsigned e;";
+	pidl "NDR_CHECK(ejs_pull_enum(ejs, v, name, &e));";
+	pidl "*r = e;";
+	pidl "return NT_STATUS_OK;";
+	deindent;
+	pidl "}\n";
+}
+
+###########################
+# pull a bitmap
+sub EjsBitmapPull($$)
+{
+	my $name = shift;
+	my $d = shift;
+	my $type_fn = $d->{BASE_TYPE};
+	my($type_decl) = Parse::Pidl::Typelist::mapType($d->{BASE_TYPE});
+	pidl fn_prefix($d);
+	pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, $type_decl *r)\n{";
+	indent;
+	pidl "return ejs_pull_$type_fn(ejs, v, name, r);";
+	deindent;
+	pidl "}";
+}
+
+
+###########################
+# generate a structure pull
+sub EjsTypedefPull($)
+{
+	my $d = shift;
+	return if (has_property($d, "noejs"));
+	if ($d->{DATA}->{TYPE} eq 'STRUCT') {
+		EjsStructPull($d->{NAME}, $d->{DATA});
+	} elsif ($d->{DATA}->{TYPE} eq 'UNION') {
+		EjsUnionPull($d->{NAME}, $d->{DATA});
+	} elsif ($d->{DATA}->{TYPE} eq 'ENUM') {
+		EjsEnumPull($d->{NAME}, $d->{DATA});
+	} elsif ($d->{DATA}->{TYPE} eq 'BITMAP') {
+		EjsBitmapPull($d->{NAME}, $d->{DATA});
+	} else {
+		warn "Unhandled pull typedef $d->{NAME} of type $d->{DATA}->{TYPE}";
+	}
+}
+
+#####################
+# generate a function
+sub EjsPullFunction($)
+{
+	my $d = shift;
+	my $env = GenerateFunctionInEnv($d);
+	my $name = $d->{NAME};
+
+	pidl "\nstatic NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, struct $name *r)";
+	pidl "{";
+	indent;
+	pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, \"input\"));";
+
+	# we pull non-array elements before array elements as arrays
+	# may have length_is() or size_is() properties that depend
+	# on the non-array elements
+	foreach my $e (@{$d->{ELEMENTS}}) {
+		next unless (grep(/in/, @{$e->{DIRECTION}}));
+		next if (has_property($e, "length_is") || 
+			 has_property($e, "size_is"));
+		EjsPullElementTop($e, $env);
+	}
+
+	foreach my $e (@{$d->{ELEMENTS}}) {
+		next unless (grep(/in/, @{$e->{DIRECTION}}));
+		next unless (has_property($e, "length_is") || 
+			     has_property($e, "size_is"));
+		EjsPullElementTop($e, $env);
+	}
+
+	pidl "return NT_STATUS_OK;";
+	deindent;
+	pidl "}\n";
+}
+
+
+###########################
+# push a scalar element
+sub EjsPushScalar($$$$$)
+{
+	my ($e, $l, $var, $name, $env) = @_;
+        # have to handle strings specially :(
+        my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l);
+        if ($e->{TYPE} ne "string" || ($pl && $pl->{TYPE} eq "POINTER")) {
+                $var = get_pointer_to($var);
+        }
+	pidl "NDR_CHECK(ejs_push_$e->{TYPE}(ejs, v, $name, $var));";
+}
+
+###########################
+# push a string element
+sub EjsPushString($$$$$)
+{
+	my ($e, $l, $var, $name, $env) = @_;
+	pidl "NDR_CHECK(ejs_push_string(ejs, v, $name, $var));";
+}
+
+###########################
+# push a pointer element
+sub EjsPushPointer($$$$$)
+{
+	my ($e, $l, $var, $name, $env) = @_;
+	pidl "if (NULL == $var) {";
+	indent;
+	pidl "NDR_CHECK(ejs_push_null(ejs, v, $name));";
+	deindent;
+	pidl "} else {";
+	indent;
+	$var = get_value_of($var);		
+	EjsPushElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env);
+	deindent;
+	pidl "}";
+}
+
+###########################
+# push a switch element
+sub EjsPushSwitch($$$$$)
+{
+	my ($e, $l, $var, $name, $env) = @_;
+	my $switch_var = Parse::Pidl::Util::ParseExpr($l->{SWITCH_IS}, $env);
+	pidl "ejs_set_switch(ejs, $switch_var);";
+	EjsPushElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env);
+}
+
+
+###########################
+# push an array element
+sub EjsPushArray($$$$$)
+{
+	my ($e, $l, $var, $name, $env) = @_;
+	my $nl = Parse::Pidl::NDR::GetNextLevel($e, $l);
+	my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env);
+	my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l);
+	if ($pl && $pl->{TYPE} eq "POINTER") {
+		$var = get_pointer_to($var);
+	}
+	# uint8 arrays are treated as data blobs
+	if ($nl->{TYPE} eq 'DATA' && $e->{TYPE} eq 'uint8') {
+		pidl "ejs_push_array_uint8(ejs, v, $name, $var, $length);";
+		return;
+	}
+	my $avar = $var . "[i]";
+	pidl "{";
+	indent;
+	pidl "uint32_t i;";
+	pidl "for (i=0;i<$length;i++) {";
+	indent;
+	pidl "const char *id = talloc_asprintf(ejs, \"%s.%u\", $name, i);";
+	EjsPushElement($e, $nl, $avar, "id", $env);
+	deindent;
+	pidl "}";
+	pidl "ejs_push_uint32(ejs, v, $name \".length\", &i);";
+	deindent;
+	pidl "}";
+}
+
+################################
+# push a structure/union element
+sub EjsPushElement($$$$$)
+{
+	my ($e, $l, $var, $name, $env) = @_;
+	if (has_property($e, "charset")) {
+		EjsPushString($e, $l, $var, $name, $env);
+	} elsif ($l->{TYPE} eq "ARRAY") {
+		EjsPushArray($e, $l, $var, $name, $env);
+	} elsif ($l->{TYPE} eq "DATA") {
+		EjsPushScalar($e, $l, $var, $name, $env);
+	} elsif (($l->{TYPE} eq "POINTER")) {
+		EjsPushPointer($e, $l, $var, $name, $env);
+	} elsif (($l->{TYPE} eq "SWITCH")) {
+		EjsPushSwitch($e, $l, $var, $name, $env);
+	} else {
+		pidl "return ejs_panic(ejs, \"unhandled push type $l->{TYPE}\");";
+	}
+}
+
+#############################################
+# push a structure/union element at top level
+sub EjsPushElementTop($$)
+{
+	my $e = shift;
+	my $env = shift;
+	my $l = $e->{LEVELS}[0];
+	my $var = Parse::Pidl::Util::ParseExpr($e->{NAME}, $env);
+	my $name = "\"$e->{NAME}\"";
+	EjsPushElement($e, $l, $var, $name, $env);
+}
+
+###########################
+# push a struct
+sub EjsStructPush($$)
+{
+	my $name = shift;
+	my $d = shift;
+	my $env = GenerateStructEnv($d);
+	pidl fn_prefix($d);
+	pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const struct $name *r)\n{";
+	indent;
+	pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, name));";
+        foreach my $e (@{$d->{ELEMENTS}}) {
+		EjsPushElementTop($e, $env);
+	}
+	pidl "return NT_STATUS_OK;";
+	deindent;
+	pidl "}\n";
+}
+
+###########################
+# push a union
+sub EjsUnionPush($$)
+{
+	my $name = shift;
+	my $d = shift;
+	my $have_default = 0;
+	my $env = GenerateStructEnv($d);
+	pidl fn_prefix($d);
+	pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const union $name *r)\n{";
+	indent;
+	pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, name));";
+	pidl "switch (ejs->switch_var) {";
+	indent;
+	foreach my $e (@{$d->{ELEMENTS}}) {
+		if ($e->{CASE} eq "default") {
+			$have_default = 1;
+		}
+		pidl "$e->{CASE}:";
+		indent;
+		if ($e->{TYPE} ne "EMPTY") {
+			EjsPushElementTop($e, $env);
+		}
+		pidl "break;";
+		deindent;
+	}
+	if (! $have_default) {
+		pidl "default:";
+		indent;
+		pidl "return ejs_panic(ejs, \"Bad switch value\");";
+		deindent;
+	}
+	deindent;
+	pidl "}";
+	pidl "return NT_STATUS_OK;";
+	deindent;
+	pidl "}";
+}
+
+###########################
+# push a enum
+sub EjsEnumPush($$)
+{
+	my $name = shift;
+	my $d = shift;
+	EjsEnumConstant($d);
+	pidl fn_prefix($d);
+	pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const enum $name *r)\n{";
+	indent;
+	pidl "unsigned e = *r;";
+	pidl "NDR_CHECK(ejs_push_enum(ejs, v, name, &e));";
+	pidl "return NT_STATUS_OK;";
+	deindent;
+	pidl "}\n";
+}
+
+###########################
+# push a bitmap
+sub EjsBitmapPush($$)
+{
+	my $name = shift;
+	my $d = shift;
+	my $type_fn = $d->{BASE_TYPE};
+	my($type_decl) = Parse::Pidl::Typelist::mapType($d->{BASE_TYPE});
+	# put the bitmap elements in the constants array
+	foreach my $e (@{$d->{ELEMENTS}}) {
+		if ($e =~ /^(\w*)\s*(.*)\s*$/) {
+			my $bname = $1;
+			my $v = $2;
+			$constants{$bname} = $v;
+		}
+	}
+	pidl fn_prefix($d);
+	pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const $type_decl *r)\n{";
+	indent;
+	pidl "return ejs_push_$type_fn(ejs, v, name, r);";
+	deindent;
+	pidl "}";
+}
+
+
+###########################
+# generate a structure push
+sub EjsTypedefPush($)
+{
+	my $d = shift;
+	return if (has_property($d, "noejs"));
+	if ($d->{DATA}->{TYPE} eq 'STRUCT') {
+		EjsStructPush($d->{NAME}, $d->{DATA});
+	} elsif ($d->{DATA}->{TYPE} eq 'UNION') {
+		EjsUnionPush($d->{NAME}, $d->{DATA});
+	} elsif ($d->{DATA}->{TYPE} eq 'ENUM') {
+		EjsEnumPush($d->{NAME}, $d->{DATA});
+	} elsif ($d->{DATA}->{TYPE} eq 'BITMAP') {
+		EjsBitmapPush($d->{NAME}, $d->{DATA});
+	} else {
+		warn "Unhandled push typedef $d->{NAME} of type $d->{DATA}->{TYPE}";
+	}
+}
+
+
+#####################
+# generate a function
+sub EjsPushFunction($)
+{
+	my $d = shift;
+	my $env = GenerateFunctionOutEnv($d);
+
+	pidl "\nstatic NTSTATUS ejs_push_$d->{NAME}(struct ejs_rpc *ejs, struct MprVar *v, const struct $d->{NAME} *r)";
+	pidl "{";
+	indent;
+	pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, \"output\"));";
+
+	foreach my $e (@{$d->{ELEMENTS}}) {
+		next unless (grep(/out/, @{$e->{DIRECTION}}));
+		EjsPushElementTop($e, $env);
+	}
+
+	if ($d->{RETURN_TYPE}) {
+		my $t = $d->{RETURN_TYPE};
+		pidl "NDR_CHECK(ejs_push_$t(ejs, v, \"result\", &r->out.result));";
+	}
+
+	pidl "return NT_STATUS_OK;";
+	deindent;
+	pidl "}\n";
+}
+
+
+#################################
+# generate a ejs mapping function
+sub EjsFunction($$)
+{
+	my $d = shift;
+	my $iface = shift;
+	my $name = $d->{NAME};
+	my $callnum = uc("DCERPC_$name");
+	my $table = "&dcerpc_table_$iface";
+
+	pidl "static int ejs_$name(int eid, int argc, struct MprVar **argv)";
+	pidl "{";
+	indent;
+	pidl "return ejs_rpc_call(eid, argc, argv, $table, $callnum, (ejs_pull_function_t)ejs_pull_$name, (ejs_push_function_t)ejs_push_$name);";
+	deindent;
+	pidl "}\n";
+}
+
+###################
+# handle a constant
+sub EjsConst($)
+{
+    my $const = shift;
+    $constants{$const->{NAME}} = $const->{VALUE};
+}
+
+#####################################################################
+# parse the interface definitions
+sub EjsInterface($$)
+{
+	my($interface,$needed) = @_;
+	my @fns = ();
+	my $name = $interface->{NAME};
+
+	%constants = ();
+
+	foreach my $d (@{$interface->{TYPEDEFS}}) {
+		($needed->{"push_$d->{NAME}"}) && EjsTypedefPush($d);
+		($needed->{"pull_$d->{NAME}"}) && EjsTypedefPull($d);
+	}
+
+	foreach my $d (@{$interface->{FUNCTIONS}}) {
+		next if not defined($d->{OPNUM});
+		
+		EjsPullFunction($d);
+		EjsPushFunction($d);
+		EjsFunction($d, $name);
+
+		push (@fns, $d->{NAME});
+	}
+
+	foreach my $d (@{$interface->{CONSTS}}) {
+		EjsConst($d);
+	}
+
+	pidl "static int ejs_$name\_init(int eid, int argc, struct MprVar **argv)";
+	pidl "{";
+	indent;
+	pidl "struct MprVar *obj = mprInitObject(eid, \"$name\", argc, argv);";
+	foreach (@fns) {
+		pidl "mprSetCFunction(obj, \"$_\", ejs_$_);";
+	}
+	foreach my $v (keys %constants) {
+		my $value = $constants{$v};
+		if (substr($value, 0, 1) eq "\"") {
+			pidl "mprSetVar(obj, \"$v\", mprString($value));";
+		} else {
+			pidl "mprSetVar(obj, \"$v\", mprCreateNumberVar($value));";
+		}
+	}
+	pidl "return ejs_rpc_init(obj, \"$name\");";
+	deindent;
+	pidl "}\n";
+
+	pidl "NTSTATUS ejs_init_$name(void)";
+	pidl "{";
+	indent;
+	pidl "return smbcalls_register_ejs(\"$name\_init\", ejs_$name\_init);";
+	deindent;
+	pidl "}";
+}
+
+#####################################################################
+# parse a parsed IDL into a C header
+sub Parse($$)
+{
+    my($ndr,$hdr) = @_;
+    
+    my $ejs_hdr = $hdr;
+    $ejs_hdr =~ s/.h$/_ejs.h/;
+    $res = "";
+    pidl "
+/* EJS wrapper functions auto-generated by pidl */
+#include \"includes.h\"
+#include \"lib/appweb/ejs/ejs.h\"
+#include \"scripting/ejs/ejsrpc.h\"
+#include \"scripting/ejs/smbcalls.h\"
+#include \"librpc/gen_ndr/ndr_misc_ejs.h\"
+#include \"$hdr\"
+#include \"$ejs_hdr\"
+
+";
+
+    my %needed = ();
+
+    foreach my $x (@{$ndr}) {
+	    ($x->{TYPE} eq "INTERFACE") && NeededInterface($x, \%needed);
+    }
+
+    foreach my $x (@{$ndr}) {
+	    ($x->{TYPE} eq "INTERFACE") && EjsInterface($x, \%needed);
+    }
+
+    return $res;
+}
+
+sub NeededFunction($$)
+{
+	my ($fn,$needed) = @_;
+	$needed->{"pull_$fn->{NAME}"} = 1;
+	$needed->{"push_$fn->{NAME}"} = 1;
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		if (grep (/in/, @{$e->{DIRECTION}})) {
+			$needed->{"pull_$e->{TYPE}"} = 1;
+		}
+		if (grep (/out/, @{$e->{DIRECTION}})) {
+			$needed->{"push_$e->{TYPE}"} = 1;
+		}
+	}
+}
+
+sub NeededTypedef($$)
+{
+	my ($t,$needed) = @_;
+	if (Parse::Pidl::Util::has_property($t, "public")) {
+		$needed->{"pull_$t->{NAME}"} = not Parse::Pidl::Util::has_property($t, "noejs");
+		$needed->{"push_$t->{NAME}"} = not Parse::Pidl::Util::has_property($t, "noejs");
+	}
+	if ($t->{DATA}->{TYPE} ne "STRUCT" && 
+	    $t->{DATA}->{TYPE} ne "UNION") {
+		return;
+	}
+	for my $e (@{$t->{DATA}->{ELEMENTS}}) {
+		if ($needed->{"pull_$t->{NAME}"}) {
+			$needed->{"pull_$e->{TYPE}"} = 1;
+		}
+		if ($needed->{"push_$t->{NAME}"}) {
+			$needed->{"push_$e->{TYPE}"} = 1;
+		}
+	}
+}
+
+#####################################################################
+# work out what parse functions are needed
+sub NeededInterface($$)
+{
+	my ($interface,$needed) = @_;
+	foreach my $d (@{$interface->{FUNCTIONS}}) {
+	    NeededFunction($d, $needed);
+	}
+	foreach my $d (reverse @{$interface->{TYPEDEFS}}) {
+	    NeededTypedef($d, $needed);
+	}
+}
+
+1;
diff --git a/source4/pidl/lib/Parse/Pidl/Samba/EJSHeader.pm b/source4/pidl/lib/Parse/Pidl/Samba/EJSHeader.pm
new file mode 100644
index 0000000000..81c75705de
--- /dev/null
+++ b/source4/pidl/lib/Parse/Pidl/Samba/EJSHeader.pm
@@ -0,0 +1,76 @@
+###################################################
+# create C header files for an EJS mapping functions
+# Copyright tridge@samba.org 2005
+# released under the GNU GPL
+
+package Parse::Pidl::Samba::EJSHeader;
+
+use strict;
+use Parse::Pidl::Typelist;
+use Parse::Pidl::Util qw(has_property);
+
+my($res);
+
+sub pidl ($)
+{
+	$res .= shift;
+}
+
+#####################################################################
+# prototype a typedef
+sub HeaderTypedefProto($)
+{
+	my $d = shift;
+	my $name = $d->{NAME};
+	
+	return unless has_property($d, "public");
+	
+	my $type_decl = Parse::Pidl::Typelist::mapType($name);
+
+	pidl "NTSTATUS ejs_push_$d->{NAME}(struct ejs_rpc *, struct MprVar *, const char *, const $type_decl *);\n";
+	pidl "NTSTATUS ejs_pull_$d->{NAME}(struct ejs_rpc *, struct MprVar *, const char *, $type_decl *);\n";
+}
+
+#####################################################################
+# parse the interface definitions
+sub HeaderInterface($)
+{
+	my($interface) = shift;
+
+	my $count = 0;
+
+	pidl "#ifndef _HEADER_EJS_$interface->{NAME}\n";
+	pidl "#define _HEADER_EJS_$interface->{NAME}\n\n";
+
+	if (defined $interface->{PROPERTIES}->{depends}) {
+		my @d = split / /, $interface->{PROPERTIES}->{depends};
+		foreach my $i (@d) {
+			pidl "#include \"librpc/gen_ndr/ndr_$i\_ejs\.h\"\n";
+		}
+	}
+
+	pidl "\n";
+
+	foreach my $d (@{$interface->{TYPEDEFS}}) {
+		HeaderTypedefProto($d);
+	}
+
+	pidl "\n";
+	pidl "#endif /* _HEADER_EJS_$interface->{NAME} */\n";
+}
+
+#####################################################################
+# parse a parsed IDL into a C header
+sub Parse($)
+{
+    my($idl) = shift;
+
+    $res = "";
+    pidl "/* header auto-generated by pidl */\n\n";
+    foreach my $x (@{$idl}) {
+	    ($x->{TYPE} eq "INTERFACE") && HeaderInterface($x);
+    }
+    return $res;
+}
+
+1;
diff --git a/source4/pidl/lib/Parse/Pidl/Samba/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba/Header.pm
new file mode 100644
index 0000000000..d88b37e229
--- /dev/null
+++ b/source4/pidl/lib/Parse/Pidl/Samba/Header.pm
@@ -0,0 +1,356 @@
+###################################################
+# create C header files for an IDL structure
+# Copyright tridge@samba.org 2000
+# Copyright jelmer@samba.org 2005
+# released under the GNU GPL
+
+package Parse::Pidl::Samba::Header;
+
+use strict;
+use Parse::Pidl::Typelist qw(mapType);
+use Parse::Pidl::Util qw(has_property is_constant);
+use Parse::Pidl::NDR qw(GetNextLevel GetPrevLevel);
+
+my($res);
+my($tab_depth);
+
+sub pidl ($)
+{
+	$res .= shift;
+}
+
+sub tabs()
+{
+	my $res = "";
+	$res .="\t" foreach (1..$tab_depth);
+	return $res;
+}
+
+#####################################################################
+# parse a properties list
+sub HeaderProperties($$)
+{
+    my($props,$ignores) = @_;
+	my $ret = "";
+
+    foreach my $d (keys %{$props}) {
+		next if (grep(/^$d$/, @$ignores));
+		if($props->{$d} ne "1") {
+			$ret.= "$d($props->{$d}),";
+		} else {
+			$ret.="$d,";
+		}
+	}
+
+	if ($ret) {
+		pidl "/* [" . substr($ret, 0, -1) . "] */";
+	}
+}
+
+#####################################################################
+# parse a structure element
+sub HeaderElement($)
+{
+	my($element) = shift;
+
+	pidl tabs();
+	HeaderType($element, $element->{TYPE}, "");
+	pidl " ";
+	my $numstar = $element->{POINTERS};
+	foreach (@{$element->{ARRAY_LEN}})
+	{
+		next if is_constant($_) and 
+			not has_property($element, "charset");
+		$numstar++;
+	}
+	$numstar-- if Parse::Pidl::Typelist::scalar_is_reference($element->{TYPE});
+	pidl "*" foreach (1..$numstar);
+	pidl $element->{NAME};
+	foreach (@{$element->{ARRAY_LEN}}) {
+		next unless (is_constant($_) and 
+			not has_property($element, "charset"));
+		pidl "[$_]";
+	}
+
+	pidl ";";
+	if (defined $element->{PROPERTIES}) {
+		HeaderProperties($element->{PROPERTIES}, ["in", "out"]);
+	}
+	pidl "\n";
+}
+
+#####################################################################
+# parse a struct
+sub HeaderStruct($$)
+{
+    my($struct,$name) = @_;
+	pidl "struct $name {\n";
+    $tab_depth++;
+    my $el_count=0;
+    if (defined $struct->{ELEMENTS}) {
+		foreach my $e (@{$struct->{ELEMENTS}}) {
+		    HeaderElement($e);
+		    $el_count++;
+		}
+    }
+    if ($el_count == 0) {
+	    # some compilers can't handle empty structures
+	    pidl tabs()."char _empty_;\n";
+    }
+    $tab_depth--;
+    pidl tabs()."}";
+	if (defined $struct->{PROPERTIES}) {
+		HeaderProperties($struct->{PROPERTIES}, []);
+	}
+}
+
+#####################################################################
+# parse a enum
+sub HeaderEnum($$)
+{
+    my($enum,$name) = @_;
+    my $first = 1;
+
+    if (not Parse::Pidl::Util::useUintEnums()) {
+    	pidl "enum $name {\n";
+	$tab_depth++;
+	foreach my $e (@{$enum->{ELEMENTS}}) {
+ 	    unless ($first) { pidl ",\n"; }
+	    $first = 0;
+	    pidl tabs();
+	    pidl $e;
+	}
+	pidl "\n";
+	$tab_depth--;
+	pidl "}";
+    } else {
+        my $count = 0;
+	pidl "enum $name { __donnot_use_enum_$name=0x7FFFFFFF};\n";
+	my $with_val = 0;
+	my $without_val = 0;
+	foreach my $e (@{$enum->{ELEMENTS}}) {
+	    my $t = "$e";
+	    my $name;
+	    my $value;
+	    if ($t =~ /(.*)=(.*)/) {
+	    	$name = $1;
+	    	$value = $2;
+		$with_val = 1;
+		die ("you can't mix enum member with values and without values when using --uint-enums!")
+			unless ($without_val == 0);
+	    } else {
+	    	$name = $t;
+	    	$value = $count++;
+		$without_val = 1;
+		die ("you can't mix enum member with values and without values when using --uint-enums!")
+			unless ($with_val == 0);
+	    }
+	    pidl "#define $name ( $value )\n";
+	}
+	pidl "\n";
+    }
+}
+
+#####################################################################
+# parse a bitmap
+sub HeaderBitmap($$)
+{
+    my($bitmap,$name) = @_;
+
+    pidl "/* bitmap $name */\n";
+    pidl "#define $_\n" foreach (@{$bitmap->{ELEMENTS}});
+    pidl "\n";
+}
+
+#####################################################################
+# parse a union
+sub HeaderUnion($$)
+{
+	my($union,$name) = @_;
+	my %done = ();
+
+	pidl "union $name {\n";
+	$tab_depth++;
+	foreach my $e (@{$union->{ELEMENTS}}) {
+		if ($e->{TYPE} ne "EMPTY") {
+			if (! defined $done{$e->{NAME}}) {
+				HeaderElement($e);
+			}
+			$done{$e->{NAME}} = 1;
+		}
+	}
+	$tab_depth--;
+	pidl "}";
+
+	if (defined $union->{PROPERTIES}) {
+		HeaderProperties($union->{PROPERTIES}, []);
+	}
+}
+
+#####################################################################
+# parse a type
+sub HeaderType($$$)
+{
+	my($e,$data,$name) = @_;
+	if (ref($data) eq "HASH") {
+		($data->{TYPE} eq "ENUM") && HeaderEnum($data, $name);
+		($data->{TYPE} eq "BITMAP") && HeaderBitmap($data, $name);
+		($data->{TYPE} eq "STRUCT") && HeaderStruct($data, $name);
+		($data->{TYPE} eq "UNION") && HeaderUnion($data, $name);
+		return;
+	}
+
+	if (has_property($e, "charset")) {
+		pidl "const char";
+	} else {
+		pidl mapType($e->{TYPE});
+	}
+}
+
+#####################################################################
+# parse a typedef
+sub HeaderTypedef($)
+{
+    my($typedef) = shift;
+    HeaderType($typedef, $typedef->{DATA}, $typedef->{NAME});
+    pidl ";\n\n" unless ($typedef->{DATA}->{TYPE} eq "BITMAP");
+}
+
+#####################################################################
+# parse a const
+sub HeaderConst($)
+{
+    my($const) = shift;
+    if (!defined($const->{ARRAY_LEN}[0])) {
+    	pidl "#define $const->{NAME}\t( $const->{VALUE} )\n";
+    } else {
+    	pidl "#define $const->{NAME}\t $const->{VALUE}\n";
+    }
+}
+
+#####################################################################
+# parse a function
+sub HeaderFunctionInOut($$)
+{
+    my($fn,$prop) = @_;
+
+    foreach my $e (@{$fn->{ELEMENTS}}) {
+	    if (has_property($e, $prop)) {
+		    HeaderElement($e);
+	    }
+    }
+}
+
+#####################################################################
+# determine if we need an "in" or "out" section
+sub HeaderFunctionInOut_needed($$)
+{
+    my($fn,$prop) = @_;
+
+    return 1 if ($prop eq "out" && $fn->{RETURN_TYPE} ne "void");
+
+    foreach (@{$fn->{ELEMENTS}}) {
+	    return 1 if (has_property($_, $prop));
+    }
+
+    return undef;
+}
+
+my %headerstructs = ();
+
+#####################################################################
+# parse a function
+sub HeaderFunction($)
+{
+    my($fn) = shift;
+
+    return if ($headerstructs{$fn->{NAME}});
+
+    $headerstructs{$fn->{NAME}} = 1;
+
+    pidl "\nstruct $fn->{NAME} {\n";
+    $tab_depth++;
+    my $needed = 0;
+
+    if (HeaderFunctionInOut_needed($fn, "in")) {
+	    pidl tabs()."struct {\n";
+	    $tab_depth++;
+	    HeaderFunctionInOut($fn, "in");
+	    $tab_depth--;
+	    pidl tabs()."} in;\n\n";
+	    $needed++;
+    }
+
+    if (HeaderFunctionInOut_needed($fn, "out")) {
+	    pidl tabs()."struct {\n";
+	    $tab_depth++;
+	    HeaderFunctionInOut($fn, "out");
+	    if ($fn->{RETURN_TYPE} ne "void") {
+		    pidl tabs().mapType($fn->{RETURN_TYPE}) . " result;\n";
+	    }
+	    $tab_depth--;
+	    pidl tabs()."} out;\n\n";
+	    $needed++;
+    }
+
+    if (! $needed) {
+	    # sigh - some compilers don't like empty structures
+	    pidl tabs()."int _dummy_element;\n";
+    }
+
+    $tab_depth--;
+    pidl "};\n\n";
+}
+
+#####################################################################
+# parse the interface definitions
+sub HeaderInterface($)
+{
+	my($interface) = shift;
+
+	my $count = 0;
+
+	pidl "#ifndef _HEADER_$interface->{NAME}\n";
+	pidl "#define _HEADER_$interface->{NAME}\n\n";
+
+	if (defined $interface->{PROPERTIES}->{depends}) {
+		my @d = split / /, $interface->{PROPERTIES}->{depends};
+		foreach my $i (@d) {
+			pidl "#include \"librpc/gen_ndr/$i\.h\"\n";
+		}
+	}
+
+	foreach my $d (@{$interface->{DATA}}) {
+		next if ($d->{TYPE} ne "CONST");
+		HeaderConst($d);
+	}
+
+	foreach my $d (@{$interface->{DATA}}) {
+		next if ($d->{TYPE} ne "TYPEDEF");
+		HeaderTypedef($d);
+	}
+
+	foreach my $d (@{$interface->{DATA}}) {
+		next if ($d->{TYPE} ne "FUNCTION");
+		HeaderFunction($d);
+	}
+
+	pidl "#endif /* _HEADER_$interface->{NAME} */\n";
+}
+
+#####################################################################
+# parse a parsed IDL into a C header
+sub Parse($)
+{
+    my($idl) = shift;
+    $tab_depth = 0;
+
+	$res = "";
+    pidl "/* header auto-generated by pidl */\n\n";
+    foreach my $x (@{$idl}) {
+	    ($x->{TYPE} eq "INTERFACE") && HeaderInterface($x);
+    }
+    return $res;
+}
+
+1;
diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Client.pm
new file mode 100644
index 0000000000..126dbc3ba9
--- /dev/null
+++ b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Client.pm
@@ -0,0 +1,99 @@
+###################################################
+# client calls generator
+# Copyright tridge@samba.org 2003
+# released under the GNU GPL
+
+package Parse::Pidl::Samba::NDR::Client;
+
+use strict;
+
+my($res);
+
+#####################################################################
+# parse a function
+sub ParseFunction($$)
+{
+	my ($interface, $fn) = @_;
+	my $name = $fn->{NAME};
+	my $uname = uc $name;
+
+	$res .= "
+struct rpc_request *dcerpc_$name\_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r)
+{
+	if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG($name, r);
+	}
+	
+	return dcerpc_ndr_request_send(p, NULL, &dcerpc_table_$interface->{NAME}, DCERPC_$uname, mem_ctx, r);
+}
+
+NTSTATUS dcerpc_$name(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r)
+{
+	struct rpc_request *req;
+	NTSTATUS status;
+	
+	req = dcerpc_$name\_send(p, mem_ctx, r);
+	if (req == NULL) return NT_STATUS_NO_MEMORY;
+
+	status = dcerpc_ndr_request_recv(req);
+
+        if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG($name, r);		
+	}
+";
+    
+        if (defined($fn->{RETURN_TYPE}) and $fn->{RETURN_TYPE} eq "NTSTATUS") {
+             $res .= "\tif (NT_STATUS_IS_OK(status)) status = r->out.result;\n";
+        }
+	$res .= 
+"
+	return status;
+}
+";
+}
+
+my %done;
+
+#####################################################################
+# parse the interface definitions
+sub ParseInterface($)
+{
+	my($interface) = shift;
+	$res .= "/* $interface->{NAME} - client functions generated by pidl */\n\n";
+
+	foreach my $fn (@{$interface->{FUNCTIONS}}) {
+		next if not defined($fn->{OPNUM});
+		next if defined($done{$fn->{NAME}});
+		ParseFunction($interface, $fn);
+		$done{$fn->{NAME}} = 1;
+	}
+
+	return $res;
+}
+
+sub Parse($$)
+{
+	my($ndr) = shift;
+	my($filename) = shift;
+
+	my $h_filename = $filename;
+	$res = "";
+
+	if ($h_filename =~ /(.*)\.c/) {
+		$h_filename = "$1.h";
+	}
+
+	$res .= "/* client functions auto-generated by pidl */\n";
+	$res .= "\n";
+	$res .= "#include \"includes.h\"\n";
+	$res .= "#include \"$h_filename\"\n";
+	$res .= "\n";
+
+	foreach my $x (@{$ndr}) {
+		($x->{TYPE} eq "INTERFACE") && ParseInterface($x);
+	}
+
+	return $res;
+}
+
+1;
diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Header.pm
new file mode 100644
index 0000000000..9aa0ed8daf
--- /dev/null
+++ b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Header.pm
@@ -0,0 +1,166 @@
+###################################################
+# create C header files for an IDL structure
+# Copyright tridge@samba.org 2000
+# Copyright jelmer@samba.org 2005
+# released under the GNU GPL
+
+package Parse::Pidl::Samba::NDR::Header;
+
+use strict;
+use Parse::Pidl::Typelist qw(mapType);
+use Parse::Pidl::Util qw(has_property is_constant);
+use Parse::Pidl::NDR qw(GetNextLevel GetPrevLevel);
+use Parse::Pidl::Samba::NDR::Parser;
+
+my($res);
+my($tab_depth);
+
+sub pidl ($)
+{
+	$res .= shift;
+}
+
+sub tabs()
+{
+	my $res = "";
+	$res .="\t" foreach (1..$tab_depth);
+	return $res;
+}
+
+#####################################################################
+# prototype a typedef
+sub HeaderTypedefProto($)
+{
+    my($d) = shift;
+
+	my $tf = Parse::Pidl::Samba::NDR::Parser::get_typefamily($d->{DATA}{TYPE});
+
+    if (has_property($d, "gensize")) {
+		my $size_args = $tf->{SIZE_FN_ARGS}->($d);
+		pidl "size_t ndr_size_$d->{NAME}($size_args);\n";
+    }
+
+    return unless has_property($d, "public");
+
+	unless (has_property($d, "nopush")) {
+		pidl "NTSTATUS ndr_push_$d->{NAME}(struct ndr_push *ndr, int ndr_flags, " . $tf->{DECL}->($d, "push") . ");\n";
+	}
+	unless (has_property($d, "nopull")) {
+	    pidl "NTSTATUS ndr_pull_$d->{NAME}(struct ndr_pull *ndr, int ndr_flags, " . $tf->{DECL}->($d, "pull") . ");\n";
+	}
+    unless (has_property($d, "noprint")) {
+	    pidl "void ndr_print_$d->{NAME}(struct ndr_print *ndr, const char *name, " . $tf->{DECL}->($d, "print") . ");\n";
+    }
+}
+
+#####################################################################
+# output prototypes for a IDL function
+sub HeaderFnProto($$)
+{
+	my ($interface,$fn) = @_;
+	my $name = $fn->{NAME};
+
+	pidl "void ndr_print_$name(struct ndr_print *ndr, const char *name, int flags, const struct $name *r);\n";
+
+	unless (has_property($fn, "noopnum")) {
+		pidl "NTSTATUS dcerpc_$name(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r);\n";
+   		pidl "struct rpc_request *dcerpc_$name\_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r);\n";
+	}
+
+	return unless has_property($fn, "public");
+
+	pidl "NTSTATUS ndr_push_$name(struct ndr_push *ndr, int flags, const struct $name *r);\n";
+	pidl "NTSTATUS ndr_pull_$name(struct ndr_pull *ndr, int flags, struct $name *r);\n";
+
+	pidl "\n";
+}
+
+#####################################################################
+# parse the interface definitions
+sub HeaderInterface($)
+{
+	my($interface) = shift;
+
+	if (defined $interface->{PROPERTIES}->{depends}) {
+		my @d = split / /, $interface->{PROPERTIES}->{depends};
+		foreach my $i (@d) {
+			pidl "#include \"librpc/gen_ndr/ndr_$i\.h\"\n";
+		}
+	}
+
+	my $count = 0;
+
+	pidl "#ifndef _HEADER_NDR_$interface->{NAME}\n";
+	pidl "#define _HEADER_NDR_$interface->{NAME}\n\n";
+
+	if (defined $interface->{PROPERTIES}->{uuid}) {
+		my $name = uc $interface->{NAME};
+		pidl "#define DCERPC_$name\_UUID " . 
+		Parse::Pidl::Util::make_str($interface->{PROPERTIES}->{uuid}) . "\n";
+
+		if(!defined $interface->{PROPERTIES}->{version}) { $interface->{PROPERTIES}->{version} = "0.0"; }
+		pidl "#define DCERPC_$name\_VERSION $interface->{PROPERTIES}->{version}\n";
+
+		pidl "#define DCERPC_$name\_NAME \"$interface->{NAME}\"\n";
+
+		if(!defined $interface->{PROPERTIES}->{helpstring}) { $interface->{PROPERTIES}->{helpstring} = "NULL"; }
+		pidl "#define DCERPC_$name\_HELPSTRING $interface->{PROPERTIES}->{helpstring}\n";
+
+		pidl "\nextern const struct dcerpc_interface_table dcerpc_table_$interface->{NAME};\n";
+		pidl "NTSTATUS dcerpc_server_$interface->{NAME}_init(void);\n\n";
+	}
+
+	foreach my $d (@{$interface->{DATA}}) {
+		next if $d->{TYPE} ne "FUNCTION";
+		next if has_property($d, "noopnum");
+		next if grep(/$d->{NAME}/,@{$interface->{INHERITED_FUNCTIONS}});
+		my $u_name = uc $d->{NAME};
+		pidl "#define DCERPC_$u_name (";
+	
+		if (defined($interface->{BASE})) {
+			pidl "DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT + ";
+		}
+
+		pidl sprintf("0x%02x", $count) . ")\n";
+		$count++;
+	}
+
+	pidl "\n#define DCERPC_" . uc $interface->{NAME} . "_CALL_COUNT (";
+	
+	if (defined($interface->{BASE})) {
+		pidl "DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT + ";
+	}
+	
+	pidl "$count)\n\n";
+
+	foreach my $d (@{$interface->{DATA}}) {
+		next if ($d->{TYPE} ne "TYPEDEF");
+		HeaderTypedefProto($d);
+	}
+
+	foreach my $d (@{$interface->{DATA}}) {
+		next if ($d->{TYPE} ne "FUNCTION");
+		HeaderFnProto($interface, $d);
+	}
+
+	pidl "#endif /* _HEADER_NDR_$interface->{NAME} */\n";
+}
+
+#####################################################################
+# parse a parsed IDL into a C header
+sub Parse($$)
+{
+    my($idl,$basename) = @_;
+    $tab_depth = 0;
+
+	$res = "";
+    pidl "/* header auto-generated by pidl */\n";
+	pidl "#include \"librpc/gen_ndr/$basename\.h\"\n\n";
+
+    foreach my $x (@{$idl}) {
+	    ($x->{TYPE} eq "INTERFACE") && HeaderInterface($x);
+    }
+    return $res;
+}
+
+1;
diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm
new file mode 100644
index 0000000000..ef22ff9788
--- /dev/null
+++ b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm
@@ -0,0 +1,2341 @@
+###################################################
+# 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 Parse::Pidl::Samba::NDR::Parser;
+
+use strict;
+use Parse::Pidl::Typelist qw(hasType getType mapType);
+use Parse::Pidl::Util qw(has_property ParseExpr);
+use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred);
+
+# list of known types
+my %typefamily;
+
+sub get_typefamily($)
+{
+	my $n = shift;
+	return $typefamily{$n};
+}
+
+sub append_prefix($$)
+{
+	my ($e, $var_name) = @_;
+	my $pointers = 0;
+
+	foreach my $l (@{$e->{LEVELS}}) {
+		if ($l->{TYPE} eq "POINTER") {
+			$pointers++;
+		} elsif ($l->{TYPE} eq "ARRAY") {
+			if (($pointers == 0) and 
+			    (not $l->{IS_FIXED}) and
+			    (not $l->{IS_INLINE})) {
+				return get_value_of($var_name); 
+			}
+		} elsif ($l->{TYPE} eq "DATA") {
+			if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
+				return get_value_of($var_name) unless ($pointers);
+			}
+		}
+	}
+	
+	return $var_name;
+}
+
+sub has_fast_array($$)
+{
+	my ($e,$l) = @_;
+
+	return 0 if ($l->{TYPE} ne "ARRAY");
+
+	my $nl = GetNextLevel($e,$l);
+	return 0 unless ($nl->{TYPE} eq "DATA");
+	return 0 unless (hasType($nl->{DATA_TYPE}));
+
+	my $t = getType($nl->{DATA_TYPE});
+
+	# Only uint8 and string have fast array functions at the moment
+	return ($t->{NAME} eq "uint8") or ($t->{NAME} eq "string");
+}
+
+sub is_charset_array($$)
+{
+	my ($e,$l) = @_;
+
+	return 0 if ($l->{TYPE} ne "ARRAY");
+
+	my $nl = GetNextLevel($e,$l);
+
+	return 0 unless ($nl->{TYPE} eq "DATA");
+
+	return has_property($e, "charset");
+}
+
+sub get_pointer_to($)
+{
+	my $var_name = shift;
+	
+	if ($var_name =~ /^\*(.*)$/) {
+		return $1;
+	} elsif ($var_name =~ /^\&(.*)$/) {
+		return "&($var_name)";
+	} else {
+		return "&$var_name";
+	}
+}
+
+sub get_value_of($)
+{
+	my $var_name = shift;
+
+	if ($var_name =~ /^\&(.*)$/) {
+		return $1;
+	} else {
+		return "*$var_name";
+	}
+}
+
+my $res = "";
+my $deferred = "";
+my $tabs = "";
+
+####################################
+# pidl() is our basic output routine
+sub pidl($)
+{
+	my $d = shift;
+	if ($d) {
+		$res .= $tabs;
+		$res .= $d;
+	}
+	$res .="\n";
+}
+
+####################################
+# defer() is like pidl(), but adds to 
+# a deferred buffer which is then added to the 
+# output buffer at the end of the structure/union/function
+# This is needed to cope with code that must be pushed back
+# to the end of a block of elements
+sub defer($)
+{
+	my $d = shift;
+	if ($d) {
+		$deferred .= $tabs;
+		$deferred .= $d;
+	}
+	$deferred .="\n";
+}
+
+########################################
+# add the deferred content to the current
+# output
+sub add_deferred()
+{
+	$res .= $deferred;
+	$deferred = "";
+}
+
+sub indent()
+{
+	$tabs .= "\t";
+}
+
+sub deindent()
+{
+	$tabs = substr($tabs, 0, -1);
+}
+
+#####################################################################
+# 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, 
+# putting the check at the end of the structure/function
+sub check_null_pointer_deferred($)
+{
+	my $size = shift;
+	if ($size =~ /^\*/) {
+		my $size2 = substr($size, 1);
+		defer "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;
+
+	return "" if (has_property($fn, "public"));
+	return "static ";
+}
+
+###################################################################
+# setup any special flags for an element or structure
+sub start_flags($)
+{
+	my $e = shift;
+	my $flags = has_property($e, "flag");
+	if (defined $flags) {
+		pidl "{";
+		indent;
+		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 = has_property($e, "flag");
+	if (defined $flags) {
+		pidl "ndr->flags = _flags_save_$e->{TYPE};";
+		deindent;
+		pidl "}";
+	}
+}
+
+sub GenerateStructEnv($)
+{
+	my $x = shift;
+	my %env;
+
+	foreach my $e (@{$x->{ELEMENTS}}) {
+		$env{$e->{NAME}} = "r->$e->{NAME}";
+	}
+
+	$env{"this"} = "r";
+
+	return \%env;
+}
+
+sub GenerateFunctionInEnv($)
+{
+	my $fn = shift;
+	my %env;
+
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		if (grep (/in/, @{$e->{DIRECTION}})) {
+			$env{$e->{NAME}} = "r->in.$e->{NAME}";
+		}
+	}
+
+	return \%env;
+}
+
+sub GenerateFunctionOutEnv($)
+{
+	my $fn = shift;
+	my %env;
+
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		if (grep (/out/, @{$e->{DIRECTION}})) {
+			$env{$e->{NAME}} = "r->out.$e->{NAME}";
+		} elsif (grep (/in/, @{$e->{DIRECTION}})) {
+			$env{$e->{NAME}} = "r->in.$e->{NAME}";
+		}
+	}
+
+	return \%env;
+}
+
+#####################################################################
+# parse the data of an array - push side
+sub ParseArrayPushHeader($$$$$)
+{
+	my ($e,$l,$ndr,$var_name,$env) = @_;
+
+	my $size;
+	my $length;
+
+	if ($l->{IS_ZERO_TERMINATED}) {
+		$size = $length = "ndr_string_length($var_name, sizeof(*$var_name))";
+	} else {
+		$size = ParseExpr($l->{SIZE_IS}, $env);
+		$length = ParseExpr($l->{LENGTH_IS}, $env);
+	}
+
+	if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) {
+		pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, $size));";
+	}
+	
+	if ($l->{IS_VARYING}) {
+		pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, 0));";  # array offset
+		pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, $length));";
+	} 
+
+	return $length;
+}
+
+#####################################################################
+# parse an array - pull side
+sub ParseArrayPullHeader($$$$$)
+{
+	my ($e,$l,$ndr,$var_name,$env) = @_;
+
+	my $length;
+	my $size;
+
+	if ($l->{IS_CONFORMANT}) {
+		$length = $size = "ndr_get_array_size($ndr, " . get_pointer_to($var_name) . ")";
+	} elsif ($l->{IS_ZERO_TERMINATED}) { # Noheader arrays
+		$length = $size = "ndr_get_string_size($ndr, sizeof(*$var_name))";
+	} else {
+		$length = $size = ParseExpr($l->{SIZE_IS}, $env);
+	}
+
+	if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) {
+		pidl "NDR_CHECK(ndr_pull_array_size(ndr, " . get_pointer_to($var_name) . "));";
+	}
+
+
+	if ($l->{IS_VARYING}) {
+		pidl "NDR_CHECK(ndr_pull_array_length($ndr, " . get_pointer_to($var_name) . "));";
+		$length = "ndr_get_array_length($ndr, " . get_pointer_to($var_name) .")";
+	}
+
+	check_null_pointer($length);
+
+	if ($length ne $size) {
+		pidl "if ($length > $size) {";
+		indent;
+		pidl "return ndr_pull_error($ndr, NDR_ERR_ARRAY_SIZE, \"Bad array size %u should exceed array length %u\", $size, $length);";
+		deindent;
+		pidl "}";
+	}
+
+	if ($l->{IS_CONFORMANT} and not $l->{IS_ZERO_TERMINATED}) {
+		my $size = ParseExpr($l->{SIZE_IS}, $env);
+		defer "if ($var_name) {";
+		check_null_pointer_deferred($size);
+		defer "NDR_CHECK(ndr_check_array_size(ndr, (void*)" . get_pointer_to($var_name) . ", $size));";
+		defer "}";
+	}
+
+	if ($l->{IS_VARYING} and not $l->{IS_ZERO_TERMINATED}) {
+		my $length = ParseExpr($l->{LENGTH_IS}, $env);
+		defer "if ($var_name) {";
+		check_null_pointer_deferred($length);
+		defer "NDR_CHECK(ndr_check_array_length(ndr, (void*)" . get_pointer_to($var_name) . ", $length));";
+		defer "}"
+	}
+
+	if (not $l->{IS_FIXED} and not is_charset_array($e, $l)) {
+		AllocateArrayLevel($e,$l,$ndr,$env,$size);
+	}
+
+	return $length;
+}
+
+sub compression_alg($$)
+{
+	my ($e,$l) = @_;
+	my $compression = $l->{COMPRESSION};
+	my ($alg, $clen, $dlen) = split(/ /, $compression);
+
+	return $alg;
+}
+
+sub compression_clen($$$)
+{
+	my ($e,$l,$env) = @_;
+	my $compression = $l->{COMPRESSION};
+	my ($alg, $clen, $dlen) = split(/ /, $compression);
+
+	return ParseExpr($clen, $env);
+}
+
+sub compression_dlen($$$)
+{
+	my ($e,$l,$env) = @_;
+	my $compression = $l->{COMPRESSION};
+	my ($alg, $clen, $dlen) = split(/ /, $compression);
+
+	return ParseExpr($dlen, $env);
+}
+
+sub ParseCompressionPushStart($$$$)
+{
+	my ($e,$l,$ndr,$env) = @_;
+	my $comndr = "$ndr\_compressed";
+	my $alg = compression_alg($e, $l);
+	my $dlen = compression_dlen($e, $l, $env);
+
+	pidl "{";
+	indent;
+	pidl "struct ndr_push *$comndr;";
+	pidl "NDR_CHECK(ndr_push_compression_start($ndr, &$comndr, $alg, $dlen));";
+
+	return $comndr;
+}
+
+sub ParseCompressionPushEnd($$$$)
+{
+	my ($e,$l,$ndr,$env) = @_;
+	my $comndr = "$ndr\_compressed";
+	my $alg = compression_alg($e, $l);
+	my $dlen = compression_dlen($e, $l, $env);
+
+	pidl "NDR_CHECK(ndr_push_compression_end($ndr, $comndr, $alg, $dlen));";
+	deindent;
+	pidl "}";
+}
+
+sub ParseCompressionPullStart($$$$)
+{
+	my ($e,$l,$ndr,$env) = @_;
+	my $comndr = "$ndr\_compressed";
+	my $alg = compression_alg($e, $l);
+	my $dlen = compression_dlen($e, $l, $env);
+
+	pidl "{";
+	indent;
+	pidl "struct ndr_pull *$comndr;";
+	pidl "NDR_CHECK(ndr_pull_compression_start($ndr, &$comndr, $alg, $dlen));";
+
+	return $comndr;
+}
+
+sub ParseCompressionPullEnd($$$$)
+{
+	my ($e,$l,$ndr,$env) = @_;
+	my $comndr = "$ndr\_compressed";
+	my $alg = compression_alg($e, $l);
+	my $dlen = compression_dlen($e, $l, $env);
+
+	pidl "NDR_CHECK(ndr_pull_compression_end($ndr, $comndr, $alg, $dlen));";
+	deindent;
+	pidl "}";
+}
+
+sub ParseObfuscationPushStart($$)
+{
+	my ($e,$ndr) = @_;
+	my $obfuscation = has_property($e, "obfuscation");
+
+	pidl "NDR_CHECK(ndr_push_obfuscation_start($ndr, $obfuscation));";
+
+	return $ndr;
+}
+
+sub ParseObfuscationPushEnd($$)
+{
+	my ($e,$ndr) = @_;
+	my $obfuscation = has_property($e, "obfuscation");
+
+	pidl "NDR_CHECK(ndr_push_obfuscation_end($ndr, $obfuscation));";
+}
+
+sub ParseObfuscationPullStart($$)
+{
+	my ($e,$ndr) = @_;
+	my $obfuscation = has_property($e, "obfuscation");
+
+	pidl "NDR_CHECK(ndr_pull_obfuscation_start($ndr, $obfuscation));";
+
+	return $ndr;
+}
+
+sub ParseObfuscationPullEnd($$)
+{
+	my ($e,$ndr) = @_;
+	my $obfuscation = has_property($e, "obfuscation");
+
+	pidl "NDR_CHECK(ndr_pull_obfuscation_end($ndr, $obfuscation));";
+}
+
+sub ParseSubcontextPushStart($$$$)
+{
+	my ($e,$l,$ndr,$env) = @_;
+	my $subndr = "_ndr_$e->{NAME}";
+	my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env);
+
+	pidl "{";
+	indent;
+	pidl "struct ndr_push *$subndr;";
+	pidl "NDR_CHECK(ndr_push_subcontext_start($ndr, &$subndr, $l->{HEADER_SIZE}, $subcontext_size));";
+
+	if (defined $l->{COMPRESSION}) {
+		$subndr = ParseCompressionPushStart($e, $l, $subndr, $env);
+	}
+
+	if (defined $l->{OBFUSCATION}) {
+		$subndr = ParseObfuscationPushStart($e, $subndr);
+	}
+
+	return $subndr;
+}
+
+sub ParseSubcontextPushEnd($$$$)
+{
+	my ($e,$l,$ndr,$env) = @_;
+	my $subndr = "_ndr_$e->{NAME}";
+	my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env);
+
+	if (defined $l->{COMPRESSION}) {
+		ParseCompressionPushEnd($e, $l, $subndr, $env);
+	}
+
+	if (defined $l->{OBFUSCATION}) {
+		ParseObfuscationPushEnd($e, $subndr);
+	}
+
+	pidl "NDR_CHECK(ndr_push_subcontext_end($ndr, $subndr, $l->{HEADER_SIZE}, $subcontext_size));";
+	deindent;
+	pidl "}";
+}
+
+sub ParseSubcontextPullStart($$$$)
+{
+	my ($e,$l,$ndr,$env) = @_;
+	my $subndr = "_ndr_$e->{NAME}";
+	my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env);
+
+	pidl "{";
+	indent;
+	pidl "struct ndr_pull *$subndr;";
+	pidl "NDR_CHECK(ndr_pull_subcontext_start($ndr, &$subndr, $l->{HEADER_SIZE}, $subcontext_size));";
+
+	if (defined $l->{COMPRESSION}) {
+		$subndr = ParseCompressionPullStart($e, $l, $subndr, $env);
+	}
+
+	if (defined $l->{OBFUSCATION}) {
+		$subndr = ParseObfuscationPullStart($e, $subndr);
+	}
+	
+	return $subndr;
+}
+
+sub ParseSubcontextPullEnd($$$$)
+{
+	my ($e,$l,$ndr,$env) = @_;
+	my $subndr = "_ndr_$e->{NAME}";
+	my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env);
+
+	if (defined $l->{COMPRESSION}) {
+		ParseCompressionPullEnd($e, $l, $subndr, $env);
+	}
+
+	if (defined $l->{OBFUSCATION}) {
+		ParseObfuscationPullEnd($e, $subndr);
+	}
+
+	pidl "NDR_CHECK(ndr_pull_subcontext_end($ndr, $subndr, $l->{HEADER_SIZE}, $subcontext_size));";
+	deindent;
+	pidl "}";
+}
+
+sub ParseElementPushLevel
+{
+	my ($e,$l,$ndr,$var_name,$env,$primitives,$deferred) = @_;
+
+	my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred);
+
+	if ($l->{TYPE} eq "ARRAY" and ($l->{IS_CONFORMANT} or $l->{IS_VARYING} 
+		or is_charset_array($e, $l))) {
+		$var_name = get_pointer_to($var_name);
+	}
+
+	if (defined($ndr_flags)) {
+		if ($l->{TYPE} eq "SUBCONTEXT") {
+			my $subndr = ParseSubcontextPushStart($e, $l, $ndr, $env);
+			ParseElementPushLevel($e, GetNextLevel($e, $l), $subndr, $var_name, $env, 1, 1);
+			ParseSubcontextPushEnd($e, $l, $ndr, $env);
+		} elsif ($l->{TYPE} eq "POINTER") {
+			ParsePtrPush($e, $l, $var_name);
+		} elsif ($l->{TYPE} eq "ARRAY") {
+			my $length = ParseArrayPushHeader($e, $l, $ndr, $var_name, $env); 
+
+			my $nl = GetNextLevel($e, $l);
+
+			# Allow speedups for arrays of scalar types
+			if (is_charset_array($e,$l)) {
+				pidl "NDR_CHECK(ndr_push_charset($ndr, $ndr_flags, $var_name, $length, sizeof(" . mapType($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));";
+				return;
+			} elsif (has_fast_array($e,$l)) {
+				pidl "NDR_CHECK(ndr_push_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));";
+				return;
+			} 
+		} elsif ($l->{TYPE} eq "SWITCH") {
+			ParseSwitchPush($e, $l, $ndr, $var_name, $ndr_flags, $env);
+		} elsif ($l->{TYPE} eq "DATA") {
+			ParseDataPush($e, $l, $ndr, $var_name, $ndr_flags);
+		}
+	}
+
+	if ($l->{TYPE} eq "POINTER" and $deferred) {
+		if ($l->{POINTER_TYPE} ne "ref") {
+			pidl "if ($var_name) {";
+			indent;
+			if ($l->{POINTER_TYPE} eq "relative") {
+				pidl "NDR_CHECK(ndr_push_relative_ptr2(ndr, $var_name));";
+			}
+		}
+		$var_name = get_value_of($var_name);
+		ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 1);
+
+		if ($l->{POINTER_TYPE} ne "ref") {
+			deindent;
+			pidl "}";
+		}
+	} elsif ($l->{TYPE} eq "ARRAY" and not has_fast_array($e,$l) and
+		not is_charset_array($e, $l)) {
+		my $length = ParseExpr($l->{LENGTH_IS}, $env);
+		my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}";
+
+		$var_name = $var_name . "[$counter]";
+
+		if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) {
+			pidl "for ($counter = 0; $counter < $length; $counter++) {";
+			indent;
+			ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 0);
+			deindent;
+			pidl "}";
+		}
+
+		if ($deferred and ContainsDeferred($e, $l)) {
+			pidl "for ($counter = 0; $counter < $length; $counter++) {";
+			indent;
+			ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 0, 1);
+			deindent;
+			pidl "}";
+		}	
+	} elsif ($l->{TYPE} eq "SWITCH") {
+		ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, $primitives, $deferred);
+	}
+}
+
+#####################################################################
+# parse scalars in a structure element
+sub ParseElementPush($$$$$$)
+{
+	my ($e,$ndr,$var_prefix,$env,$primitives,$deferred) = @_;
+	my $subndr = undef;
+
+	my $var_name = $var_prefix.$e->{NAME};
+
+	$var_name = append_prefix($e, $var_name);
+
+	return unless $primitives or ($deferred and ContainsDeferred($e, $e->{LEVELS}[0]));
+
+	start_flags($e);
+
+	if (my $value = has_property($e, "value")) {
+		$var_name = ParseExpr($value, $env);
+	}
+
+	ParseElementPushLevel($e, $e->{LEVELS}[0], $ndr, $var_name, $env, $primitives, $deferred);
+
+	end_flags($e);
+}
+
+#####################################################################
+# parse a pointer in a struct element or function
+sub ParsePtrPush($$$)
+{
+	my ($e,$l,$var_name) = @_;
+
+	if ($l->{POINTER_TYPE} eq "ref") {
+		if ($l->{LEVEL} eq "EMBEDDED") {
+			pidl "NDR_CHECK(ndr_push_ref_ptr(ndr, $var_name));";
+		} else {
+			check_null_pointer(get_value_of($var_name));
+		}
+	} elsif ($l->{POINTER_TYPE} eq "relative") {
+		pidl "NDR_CHECK(ndr_push_relative_ptr1(ndr, $var_name));";
+	} elsif ($l->{POINTER_TYPE} eq "unique") {
+		pidl "NDR_CHECK(ndr_push_unique_ptr(ndr, $var_name));";
+	} elsif ($l->{POINTER_TYPE} eq "sptr") {
+		pidl "NDR_CHECK(ndr_push_sptr_ptr(ndr, $var_name));";
+	} else {
+		die("Unhandled pointer type $l->{POINTER_TYPE}");
+	}
+}
+
+#####################################################################
+# print scalars in a structure element
+sub ParseElementPrint($$$)
+{
+	my($e,$var_name,$env) = @_;
+
+	$var_name = append_prefix($e, $var_name);
+	return if (has_property($e, "noprint"));
+
+	if (my $value = has_property($e, "value")) {
+		$var_name = "(ndr->flags & LIBNDR_PRINT_SET_VALUES)?" . ParseExpr($value,$env) . ":$var_name";
+	}
+
+	foreach my $l (@{$e->{LEVELS}}) {
+		if ($l->{TYPE} eq "POINTER") {
+			pidl "ndr_print_ptr(ndr, \"$e->{NAME}\", $var_name);";
+			pidl "ndr->depth++;";
+			if ($l->{POINTER_TYPE} ne "ref") {
+				pidl "if ($var_name) {";
+				indent;
+			}
+			$var_name = get_value_of($var_name);
+		} elsif ($l->{TYPE} eq "ARRAY") {
+			my $length;
+
+			if ($l->{IS_CONFORMANT} or $l->{IS_VARYING} or 
+				is_charset_array($e,$l)) { 
+				$var_name = get_pointer_to($var_name); 
+			}
+			
+			if ($l->{IS_ZERO_TERMINATED}) {
+				$length = "ndr_string_length($var_name, sizeof(*$var_name))";
+			} else {
+				$length = ParseExpr($l->{LENGTH_IS}, $env);
+			}
+
+			if (is_charset_array($e,$l)) {
+				pidl "ndr_print_string(ndr, \"$e->{NAME}\", $var_name);";
+				last;
+			} elsif (has_fast_array($e, $l)) {
+				my $nl = GetNextLevel($e, $l);
+				pidl "ndr_print_array_$nl->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name, $length);";
+				last;
+			} else {
+				my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}";
+
+				pidl "ndr->print(ndr, \"\%s: ARRAY(\%d)\", \"$e->{NAME}\", $length);";
+				pidl 'ndr->depth++;';
+				pidl "for ($counter=0;$counter<$length;$counter++) {";
+				indent;
+				pidl "char *idx_$l->{LEVEL_INDEX}=NULL;";
+				pidl "asprintf(&idx_$l->{LEVEL_INDEX}, \"[\%d]\", $counter);";
+				pidl "if (idx_$l->{LEVEL_INDEX}) {";
+				indent;
+
+				$var_name = $var_name . "[$counter]";
+			}
+		} elsif ($l->{TYPE} eq "DATA") {
+			if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
+				$var_name = get_pointer_to($var_name);
+			}
+			pidl "ndr_print_$l->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name);";
+		} elsif ($l->{TYPE} eq "SWITCH") {
+			my $switch_var = ParseExpr($l->{SWITCH_IS}, $env);
+			check_null_pointer_void($switch_var);
+			pidl "ndr_print_set_switch_value(ndr, " . get_pointer_to($var_name) . ", $switch_var);";
+		} 
+	}
+
+	foreach my $l (reverse @{$e->{LEVELS}}) {
+		if ($l->{TYPE} eq "POINTER") {
+			if ($l->{POINTER_TYPE} ne "ref") {
+				deindent;
+				pidl "}";
+			}
+			pidl "ndr->depth--;";
+		} elsif (($l->{TYPE} eq "ARRAY")
+			and not is_charset_array($e,$l)
+			and not has_fast_array($e,$l)) {
+			pidl "free(idx_$l->{LEVEL_INDEX});";
+			deindent;
+			pidl "}";
+			deindent;
+			pidl "}";
+			pidl "ndr->depth--;";
+		}
+	}
+}
+
+#####################################################################
+# parse scalars in a structure element - pull size
+sub ParseSwitchPull($$$$$$)
+{
+	my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_;
+	my $switch_var = ParseExpr($l->{SWITCH_IS}, $env);
+
+	check_null_pointer($switch_var);
+
+	$var_name = get_pointer_to($var_name);
+	pidl "NDR_CHECK(ndr_pull_set_switch_value($ndr, $var_name, $switch_var));";
+}
+
+#####################################################################
+# push switch element
+sub ParseSwitchPush($$$$$$)
+{
+	my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_;
+	my $switch_var = ParseExpr($l->{SWITCH_IS}, $env);
+
+	check_null_pointer($switch_var);
+	$var_name = get_pointer_to($var_name);
+	pidl "NDR_CHECK(ndr_push_set_switch_value($ndr, $var_name, $switch_var));";
+}
+
+sub ParseDataPull($$$$$)
+{
+	my ($e,$l,$ndr,$var_name,$ndr_flags) = @_;
+
+	if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
+		$var_name = get_pointer_to($var_name);
+	}
+
+	$var_name = get_pointer_to($var_name);
+
+	pidl "NDR_CHECK(ndr_pull_$l->{DATA_TYPE}($ndr, $ndr_flags, $var_name));";
+
+	if (my $range = has_property($e, "range")) {
+		$var_name = get_value_of($var_name);
+		my ($low, $high) = split(/ /, $range, 2);
+		pidl "if ($var_name < $low || $var_name > $high) {";
+		pidl "\treturn ndr_pull_error($ndr, NDR_ERR_RANGE, \"value out of range\");";
+		pidl "}";
+	}
+}
+
+sub ParseDataPush($$$$$)
+{
+	my ($e,$l,$ndr,$var_name,$ndr_flags) = @_;
+
+	# strings are passed by value rather then reference
+	if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
+		$var_name = get_pointer_to($var_name);
+	}
+
+	pidl "NDR_CHECK(ndr_push_$l->{DATA_TYPE}($ndr, $ndr_flags, $var_name));";
+}
+
+sub CalcNdrFlags($$$)
+{
+	my ($l,$primitives,$deferred) = @_;
+
+	my $scalars = 0;
+	my $buffers = 0;
+
+	# Add NDR_SCALARS if this one is deferred 
+	# and deferreds may be pushed
+	$scalars = 1 if ($l->{IS_DEFERRED} and $deferred);
+
+	# Add NDR_SCALARS if this one is not deferred and 
+	# primitives may be pushed
+	$scalars = 1 if (!$l->{IS_DEFERRED} and $primitives);
+	
+	# Add NDR_BUFFERS if this one contains deferred stuff
+	# and deferreds may be pushed
+	$buffers = 1 if ($l->{CONTAINS_DEFERRED} and $deferred);
+
+	return "NDR_SCALARS|NDR_BUFFERS" if ($scalars and $buffers);
+	return "NDR_SCALARS" if ($scalars);
+	return "NDR_BUFFERS" if ($buffers);
+	return undef;
+}
+
+sub ParseMemCtxPullStart($$$)
+{
+	my $e = shift;
+	my $l = shift;
+	my $ptr_name = shift;
+
+	my $mem_r_ctx = "_mem_save_$e->{NAME}_$l->{LEVEL_INDEX}";
+	my $mem_c_ctx = $ptr_name;
+	my $mem_c_flags = "0";
+
+	return if ($l->{TYPE} eq "ARRAY" and $l->{IS_FIXED});
+
+	if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) {
+		my $nl = GetNextLevel($e, $l);
+		my $next_is_array = ($nl->{TYPE} eq "ARRAY");
+		my $next_is_string = (($nl->{TYPE} eq "DATA") and 
+					($nl->{DATA_TYPE} eq "string"));
+		if ($next_is_array or $next_is_string) {
+			return;
+		} else {
+			$mem_c_flags = "LIBNDR_FLAG_REF_ALLOC";
+		}
+	}
+
+	pidl "$mem_r_ctx = NDR_PULL_GET_MEM_CTX(ndr);";
+	pidl "NDR_PULL_SET_MEM_CTX(ndr, $mem_c_ctx, $mem_c_flags);";
+}
+
+sub ParseMemCtxPullEnd($$)
+{
+	my $e = shift;
+	my $l = shift;
+
+	my $mem_r_ctx = "_mem_save_$e->{NAME}_$l->{LEVEL_INDEX}";
+	my $mem_r_flags = "0";
+
+	return if ($l->{TYPE} eq "ARRAY" and $l->{IS_FIXED});
+
+	if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) {
+		my $nl = GetNextLevel($e, $l);
+		my $next_is_array = ($nl->{TYPE} eq "ARRAY");
+		my $next_is_string = (($nl->{TYPE} eq "DATA") and 
+					($nl->{DATA_TYPE} eq "string"));
+		if ($next_is_array or $next_is_string) {
+			return;
+		} else {
+			$mem_r_flags = "LIBNDR_FLAG_REF_ALLOC";
+		}
+	}
+
+	pidl "NDR_PULL_SET_MEM_CTX(ndr, $mem_r_ctx, $mem_r_flags);";
+}
+
+sub ParseElementPullLevel
+{
+	my($e,$l,$ndr,$var_name,$env,$primitives,$deferred) = @_;
+
+	my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred);
+
+	if ($l->{TYPE} eq "ARRAY" and ($l->{IS_VARYING} or $l->{IS_CONFORMANT} 
+		or is_charset_array($e,$l))) {
+		$var_name = get_pointer_to($var_name);
+	}
+
+	# Only pull something if there's actually something to be pulled
+	if (defined($ndr_flags)) {
+		if ($l->{TYPE} eq "SUBCONTEXT") {
+			my $subndr = ParseSubcontextPullStart($e, $l, $ndr, $env);
+			ParseElementPullLevel($e, GetNextLevel($e,$l), $subndr, $var_name, $env, 1, 1);
+			ParseSubcontextPullEnd($e, $l, $ndr, $env);
+		} elsif ($l->{TYPE} eq "ARRAY") {
+			my $length = ParseArrayPullHeader($e, $l, $ndr, $var_name, $env);
+
+			my $nl = GetNextLevel($e, $l);
+
+			if (is_charset_array($e,$l)) {
+				pidl "NDR_CHECK(ndr_pull_charset($ndr, $ndr_flags, ".get_pointer_to($var_name).", $length, sizeof(" . mapType($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));";
+				return;
+			} elsif (has_fast_array($e, $l)) {
+				pidl "NDR_CHECK(ndr_pull_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));";
+				if ($l->{IS_ZERO_TERMINATED}) {
+					# Make sure last element is zero!
+					pidl "NDR_CHECK(ndr_check_string_terminator($ndr, $var_name, $length, sizeof(*$var_name)));";
+				}
+				return;
+			}
+		} elsif ($l->{TYPE} eq "POINTER") {
+			ParsePtrPull($e, $l, $ndr, $var_name);
+		} elsif ($l->{TYPE} eq "SWITCH") {
+			ParseSwitchPull($e, $l, $ndr, $var_name, $ndr_flags, $env);
+		} elsif ($l->{TYPE} eq "DATA") {
+			ParseDataPull($e, $l, $ndr, $var_name, $ndr_flags);
+		}
+	}
+
+	# add additional constructions
+	if ($l->{TYPE} eq "POINTER" and $deferred) {
+		if ($l->{POINTER_TYPE} ne "ref") {
+			pidl "if ($var_name) {";
+			indent;
+
+			if ($l->{POINTER_TYPE} eq "relative") {
+				pidl "struct ndr_pull_save _relative_save;";
+				pidl "ndr_pull_save(ndr, &_relative_save);";
+				pidl "NDR_CHECK(ndr_pull_relative_ptr2(ndr, $var_name));";
+			}
+		}
+
+		ParseMemCtxPullStart($e,$l, $var_name);
+
+		$var_name = get_value_of($var_name);
+		ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 1);
+
+		ParseMemCtxPullEnd($e,$l);
+
+		if ($l->{POINTER_TYPE} ne "ref") {
+    			if ($l->{POINTER_TYPE} eq "relative") {
+				pidl "ndr_pull_restore(ndr, &_relative_save);";
+			}
+			deindent;
+			pidl "}";
+		}
+	} elsif ($l->{TYPE} eq "ARRAY" and 
+			not has_fast_array($e,$l) and not is_charset_array($e, $l)) {
+		my $length = ParseExpr($l->{LENGTH_IS}, $env);
+		my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}";
+		my $array_name = $var_name;
+
+		$var_name = $var_name . "[$counter]";
+
+		ParseMemCtxPullStart($e,$l, $array_name);
+
+		if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) {
+			pidl "for ($counter = 0; $counter < $length; $counter++) {";
+			indent;
+			ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 0);
+			deindent;
+			pidl "}";
+
+			if ($l->{IS_ZERO_TERMINATED}) {
+				# Make sure last element is zero!
+				pidl "NDR_CHECK(ndr_check_string_terminator($ndr, $var_name, $length, sizeof(*$var_name)));";
+			}
+		}
+
+		if ($deferred and ContainsDeferred($e, $l)) {
+			pidl "for ($counter = 0; $counter < $length; $counter++) {";
+			indent;
+			ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 0, 1);
+			deindent;
+			pidl "}";
+		}
+
+		ParseMemCtxPullEnd($e,$l);
+
+	} elsif ($l->{TYPE} eq "SWITCH") {
+		ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, $primitives, $deferred);
+	}
+}
+
+#####################################################################
+# parse scalars in a structure element - pull size
+sub ParseElementPull($$$$$$)
+{
+	my($e,$ndr,$var_prefix,$env,$primitives,$deferred) = @_;
+
+	my $var_name = $var_prefix.$e->{NAME};
+
+	$var_name = append_prefix($e, $var_name);
+
+	return unless $primitives or ($deferred and ContainsDeferred($e, $e->{LEVELS}[0]));
+
+	start_flags($e);
+
+	ParseElementPullLevel($e,$e->{LEVELS}[0],$ndr,$var_name,$env,$primitives,$deferred);
+
+	end_flags($e);
+}
+
+#####################################################################
+# parse a pointer in a struct element or function
+sub ParsePtrPull($$$$)
+{
+	my($e,$l,$ndr,$var_name) = @_;
+
+	my $nl = GetNextLevel($e, $l);
+	my $next_is_array = ($nl->{TYPE} eq "ARRAY");
+	my $next_is_string = (($nl->{TYPE} eq "DATA") and 
+						 ($nl->{DATA_TYPE} eq "string"));
+
+	if ($l->{POINTER_TYPE} eq "ref") {
+		unless ($l->{LEVEL} eq "TOP") {
+			pidl "NDR_CHECK(ndr_pull_ref_ptr($ndr, &_ptr_$e->{NAME}));";
+		}
+
+		unless ($next_is_array or $next_is_string) {
+			pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {";
+			pidl "\tNDR_PULL_ALLOC($ndr, $var_name);"; 
+			pidl "}";
+		}
+		
+		return;
+	} elsif (($l->{POINTER_TYPE} eq "unique") or 
+		 ($l->{POINTER_TYPE} eq "relative") or
+		 ($l->{POINTER_TYPE} eq "sptr")) {
+		pidl "NDR_CHECK(ndr_pull_generic_ptr($ndr, &_ptr_$e->{NAME}));";
+		pidl "if (_ptr_$e->{NAME}) {";
+		indent;
+	} else {
+		die("Unhandled pointer type $l->{POINTER_TYPE}");
+	}
+
+	# Don't do this for arrays, they're allocated at the actual level 
+	# of the array
+	unless ($next_is_array or $next_is_string) { 
+		pidl "NDR_PULL_ALLOC($ndr, $var_name);"; 
+	} else {
+		# FIXME: Yes, this is nasty.
+		# We allocate an array twice
+		# - once just to indicate that it's there,
+		# - then the real allocation...
+		pidl "NDR_PULL_ALLOC_SIZE($ndr, $var_name, 1);";
+	}
+
+	#pidl "memset($var_name, 0, sizeof($var_name));";
+	if ($l->{POINTER_TYPE} eq "relative") {
+		pidl "NDR_CHECK(ndr_pull_relative_ptr1($ndr, $var_name, _ptr_$e->{NAME}));";
+	}
+	deindent;
+	pidl "} else {";
+	pidl "\t$var_name = NULL;";
+	pidl "}";
+}
+
+#####################################################################
+# parse a struct
+sub ParseStructPush($$)
+{
+	my($struct,$name) = @_;
+	
+	return unless defined($struct->{ELEMENTS});
+
+	my $env = GenerateStructEnv($struct);
+
+	# save the old relative_base_offset
+	pidl "uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);" if defined($struct->{PROPERTIES}{relative_base});
+
+	foreach my $e (@{$struct->{ELEMENTS}}) { 
+		DeclareArrayVariables($e);
+	}
+
+	start_flags($struct);
+
+	# see if the structure contains a conformant array. If it
+	# does, then it must be the last element of the structure, and
+	# we need to push the conformant length early, as it fits on
+	# the wire before the structure (and even before the structure
+	# alignment)
+	my $e = $struct->{ELEMENTS}[-1];
+	if (defined($struct->{SURROUNDING_ELEMENT})) {
+		my $e = $struct->{SURROUNDING_ELEMENT};
+
+		if (defined($e->{LEVELS}[0]) and 
+			$e->{LEVELS}[0]->{TYPE} eq "ARRAY") {
+			my $size = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env);
+
+			pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $size));";
+		} else {
+			pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_string_array_size(ndr, r->$e->{NAME})));";
+		}
+	}
+
+	pidl "if (ndr_flags & NDR_SCALARS) {";
+	indent;
+
+	pidl "NDR_CHECK(ndr_push_align(ndr, $struct->{ALIGN}));";
+
+	if (defined($struct->{PROPERTIES}{relative_base})) {
+		# set the current offset as base for relative pointers
+		# and store it based on the toplevel struct/union
+		pidl "NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));";
+	}
+
+	foreach my $e (@{$struct->{ELEMENTS}}) {
+		ParseElementPush($e, "ndr", "r->", $env, 1, 0);
+	}	
+
+	deindent;
+	pidl "}";
+
+	pidl "if (ndr_flags & NDR_BUFFERS) {";
+	indent;
+	if (defined($struct->{PROPERTIES}{relative_base})) {
+		# retrieve the current offset as base for relative pointers
+		# based on the toplevel struct/union
+		pidl "NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));";
+	}
+	foreach my $e (@{$struct->{ELEMENTS}}) {
+		ParseElementPush($e, "ndr", "r->", $env, 0, 1);
+	}
+
+	deindent;
+	pidl "}";
+
+	end_flags($struct);
+	# restore the old relative_base_offset
+	pidl "ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($struct->{PROPERTIES}{relative_base});
+}
+
+#####################################################################
+# generate a push function for an enum
+sub ParseEnumPush($$)
+{
+	my($enum,$name) = @_;
+	my($type_fn) = $enum->{BASE_TYPE};
+
+	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,$name) = @_;
+	my($type_fn) = $enum->{BASE_TYPE};
+	my($type_v_decl) = mapType($type_fn);
+
+	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,$name) = @_;
+
+	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 DeclEnum($)
+{
+	my ($e,$t) = @_;
+	return "enum $e->{NAME} " . 
+		($t eq "pull"?"*":"") . "r";
+}
+
+$typefamily{ENUM} = {
+	DECL => \&DeclEnum,
+	PUSH_FN_BODY => \&ParseEnumPush,
+	PULL_FN_BODY => \&ParseEnumPull,
+	PRINT_FN_BODY => \&ParseEnumPrint,
+};
+
+#####################################################################
+# generate a push function for a bitmap
+sub ParseBitmapPush($$)
+{
+	my($bitmap,$name) = @_;
+	my($type_fn) = $bitmap->{BASE_TYPE};
+
+	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,$name) = @_;
+	my $type_fn = $bitmap->{BASE_TYPE};
+	my($type_decl) = mapType($bitmap->{BASE_TYPE});
+
+	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,$bitmap,$name) = @_;
+	my($type_decl) = mapType($bitmap->{BASE_TYPE});
+	my($type_fn) = $bitmap->{BASE_TYPE};
+	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,$name) = @_;
+	my($type_decl) = mapType($bitmap->{TYPE});
+	my($type_fn) = $bitmap->{BASE_TYPE};
+
+	start_flags($bitmap);
+
+	pidl "ndr_print_$type_fn(ndr, name, r);";
+
+	pidl "ndr->depth++;";
+	foreach my $e (@{$bitmap->{ELEMENTS}}) {
+		ParseBitmapPrintElement($e, $bitmap, $name);
+	}
+	pidl "ndr->depth--;";
+
+	end_flags($bitmap);
+}
+
+sub DeclBitmap($$)
+{
+	my ($e,$t) = @_;
+	return mapType(Parse::Pidl::Typelist::bitmap_type_fn($e->{DATA})) . 
+		($t eq "pull"?" *":" ") . "r";
+}
+
+$typefamily{BITMAP} = {
+	DECL => \&DeclBitmap,
+	PUSH_FN_BODY => \&ParseBitmapPush,
+	PULL_FN_BODY => \&ParseBitmapPull,
+	PRINT_FN_BODY => \&ParseBitmapPrint,
+};
+
+#####################################################################
+# generate a struct print function
+sub ParseStructPrint($$)
+{
+	my($struct,$name) = @_;
+
+	return unless defined $struct->{ELEMENTS};
+
+	my $env = GenerateStructEnv($struct);
+
+	foreach my $e (@{$struct->{ELEMENTS}}) {
+		DeclareArrayVariables($e);
+	}
+
+	pidl "ndr_print_struct(ndr, name, \"$name\");";
+
+	start_flags($struct);
+
+	pidl "ndr->depth++;";
+	foreach my $e (@{$struct->{ELEMENTS}}) {
+		ParseElementPrint($e, "r->$e->{NAME}", $env);
+	}
+	pidl "ndr->depth--;";
+
+	end_flags($struct);
+}
+
+sub DeclarePtrVariables($)
+{
+	my $e = shift;
+	foreach my $l (@{$e->{LEVELS}}) {
+		if ($l->{TYPE} eq "POINTER" and 
+			not ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "TOP")) {
+			pidl "uint32_t _ptr_$e->{NAME};";
+			last;
+		}
+	}
+}
+
+sub DeclareArrayVariables($)
+{
+	my $e = shift;
+
+	foreach my $l (@{$e->{LEVELS}}) {
+		next if has_fast_array($e,$l);
+		next if is_charset_array($e,$l);
+		if ($l->{TYPE} eq "ARRAY") {
+			pidl "uint32_t cntr_$e->{NAME}_$l->{LEVEL_INDEX};";
+		}
+	}
+}
+
+sub need_decl_mem_ctx($$)
+{
+	my $e = shift;
+	my $l = shift;
+
+	return 0 if has_fast_array($e,$l);
+	return 0 if is_charset_array($e,$l);
+	return 1 if (($l->{TYPE} eq "ARRAY") and not $l->{IS_FIXED});
+
+	if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) {
+		my $nl = GetNextLevel($e, $l);
+		my $next_is_array = ($nl->{TYPE} eq "ARRAY");
+		my $next_is_string = (($nl->{TYPE} eq "DATA") and 
+					($nl->{DATA_TYPE} eq "string"));
+		return 0 if ($next_is_array or $next_is_string);
+	}
+	return 1 if ($l->{TYPE} eq "POINTER");
+
+	return 0;
+}
+
+sub DeclareMemCtxVariables($)
+{
+	my $e = shift;
+	foreach my $l (@{$e->{LEVELS}}) {
+		if (need_decl_mem_ctx($e, $l)) {
+			pidl "TALLOC_CTX *_mem_save_$e->{NAME}_$l->{LEVEL_INDEX};";
+		}
+	}
+}
+
+#####################################################################
+# parse a struct - pull side
+sub ParseStructPull($$)
+{
+	my($struct,$name) = @_;
+
+	return unless defined $struct->{ELEMENTS};
+
+	my $env = GenerateStructEnv($struct);
+
+	# declare any internal pointers we need
+	foreach my $e (@{$struct->{ELEMENTS}}) {
+		DeclarePtrVariables($e);
+		DeclareArrayVariables($e);
+		DeclareMemCtxVariables($e);
+	}
+
+	# save the old relative_base_offset
+	pidl "uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);" if defined($struct->{PROPERTIES}{relative_base});
+
+	start_flags($struct);
+
+	pidl "if (ndr_flags & NDR_SCALARS) {";
+	indent;
+
+	if (defined $struct->{SURROUNDING_ELEMENT}) {
+		pidl "NDR_CHECK(ndr_pull_array_size(ndr, &r->$struct->{SURROUNDING_ELEMENT}->{NAME}));";
+	}
+
+	pidl "NDR_CHECK(ndr_pull_align(ndr, $struct->{ALIGN}));";
+
+	if (defined($struct->{PROPERTIES}{relative_base})) {
+		# set the current offset as base for relative pointers
+		# and store it based on the toplevel struct/union
+		pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));";
+	}
+
+	foreach my $e (@{$struct->{ELEMENTS}}) {
+		ParseElementPull($e, "ndr", "r->", $env, 1, 0);
+	}	
+
+	add_deferred();
+
+	deindent;
+	pidl "}";
+	pidl "if (ndr_flags & NDR_BUFFERS) {";
+	indent;
+	if (defined($struct->{PROPERTIES}{relative_base})) {
+		# retrieve the current offset as base for relative pointers
+		# based on the toplevel struct/union
+		pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));";
+	}
+	foreach my $e (@{$struct->{ELEMENTS}}) {
+		ParseElementPull($e, "ndr", "r->", $env, 0, 1);
+	}
+
+	add_deferred();
+
+	deindent;
+	pidl "}";
+
+	end_flags($struct);
+	# restore the old relative_base_offset
+	pidl "ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($struct->{PROPERTIES}{relative_base});
+}
+
+#####################################################################
+# calculate size of ndr struct
+sub ParseStructNdrSize($)
+{
+	my $t = shift;
+	my $sizevar;
+
+	if (my $flags = has_property($t, "flag")) {
+		pidl "flags |= $flags;";
+	}
+	pidl "return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});";
+}
+
+sub DeclStruct($)
+{
+	my ($e,$t) = @_;
+	return ($t ne "pull"?"const ":"") . "struct $e->{NAME} *r";
+}
+
+sub ArgsStructNdrSize($)
+{
+	my $d = shift;
+	return "const struct $d->{NAME} *r, int flags";
+}
+
+$typefamily{STRUCT} = {
+	PUSH_FN_BODY => \&ParseStructPush,
+	DECL => \&DeclStruct,
+	PULL_FN_BODY => \&ParseStructPull,
+	PRINT_FN_BODY => \&ParseStructPrint,
+	SIZE_FN_BODY => \&ParseStructNdrSize,
+	SIZE_FN_ARGS => \&ArgsStructNdrSize,
+};
+
+#####################################################################
+# calculate size of ndr struct
+sub ParseUnionNdrSize($)
+{
+	my $t = shift;
+	my $sizevar;
+
+	if (my $flags = has_property($t, "flag")) {
+		pidl "flags |= $flags;";
+	}
+
+	pidl "return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});";
+}
+
+#####################################################################
+# parse a union - push side
+sub ParseUnionPush($$)
+{
+	my ($e,$name) = @_;
+	my $have_default = 0;
+
+	# save the old relative_base_offset
+	pidl "uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);" if defined($e->{PROPERTIES}{relative_base});
+	pidl "int level;";
+
+	start_flags($e);
+
+	pidl "level = ndr_push_get_switch_value(ndr, r);";
+
+	pidl "if (ndr_flags & NDR_SCALARS) {";
+	indent;
+
+	if (defined($e->{SWITCH_TYPE})) {
+		pidl "NDR_CHECK(ndr_push_$e->{SWITCH_TYPE}(ndr, NDR_SCALARS, level));";
+	}
+
+	pidl "switch (level) {";
+	indent;
+	foreach my $el (@{$e->{ELEMENTS}}) {
+		if ($el->{CASE} eq "default") {
+			$have_default = 1;
+		}
+		pidl "$el->{CASE}:";
+
+		if ($el->{TYPE} ne "EMPTY") {
+			indent;
+			if (defined($e->{PROPERTIES}{relative_base})) {
+				pidl "NDR_CHECK(ndr_push_align(ndr, $el->{ALIGN}));";
+				# set the current offset as base for relative pointers
+				# and store it based on the toplevel struct/union
+				pidl "NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));";
+			}
+			DeclareArrayVariables($el);
+			ParseElementPush($el, "ndr", "r->", {}, 1, 0);
+			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 "}";
+	deindent;
+	pidl "}";
+	pidl "if (ndr_flags & NDR_BUFFERS) {";
+	indent;
+	if (defined($e->{PROPERTIES}{relative_base})) {
+		# retrieve the current offset as base for relative pointers
+		# based on the toplevel struct/union
+		pidl "NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));";
+	}
+	pidl "switch (level) {";
+	indent;
+	foreach my $el (@{$e->{ELEMENTS}}) {
+		pidl "$el->{CASE}:";
+		if ($el->{TYPE} ne "EMPTY") {
+			indent;
+			ParseElementPush($el, "ndr", "r->", {}, 0, 1);
+			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 "}";
+
+	deindent;
+	pidl "}";
+	end_flags($e);
+	# restore the old relative_base_offset
+	pidl "ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($e->{PROPERTIES}{relative_base});
+}
+
+#####################################################################
+# print a union
+sub ParseUnionPrint($$)
+{
+	my ($e,$name) = @_;
+	my $have_default = 0;
+
+	pidl "int level = ndr_print_get_switch_value(ndr, r);";
+
+	foreach my $el (@{$e->{ELEMENTS}}) {
+		DeclareArrayVariables($el);
+	}
+
+	pidl "ndr_print_union(ndr, name, level, \"$name\");";
+	start_flags($e);
+
+	pidl "switch (level) {";
+	indent;
+	foreach my $el (@{$e->{ELEMENTS}}) {
+		if ($el->{CASE} eq "default") {
+			$have_default = 1;
+		}
+		pidl "$el->{CASE}:";
+		if ($el->{TYPE} ne "EMPTY") {
+			indent;
+			ParseElementPrint($el, "r->$el->{NAME}", {});
+			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,$name) = @_;
+	my $have_default = 0;
+	my $switch_type = $e->{SWITCH_TYPE};
+
+	# save the old relative_base_offset
+	pidl "uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);" if defined($e->{PROPERTIES}{relative_base});
+	pidl "int level;";
+	if (defined($switch_type)) {
+		if (Parse::Pidl::Typelist::typeIs($switch_type, "ENUM")) {
+			$switch_type = Parse::Pidl::Typelist::enum_type_fn(getType($switch_type));
+		}
+		pidl mapType($switch_type) . " _level;";
+	}
+
+	my %double_cases = ();
+	foreach my $el (@{$e->{ELEMENTS}}) {
+		next if ($el->{TYPE} eq "EMPTY");
+		next if ($double_cases{"$el->{NAME}"});
+		DeclareMemCtxVariables($el);
+		$double_cases{"$el->{NAME}"} = 1;
+	}
+
+	start_flags($e);
+
+	pidl "level = ndr_pull_get_switch_value(ndr, r);";
+
+	pidl "if (ndr_flags & NDR_SCALARS) {";
+	indent;
+
+	if (defined($switch_type)) {
+		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 $name\", _level);";
+		pidl "}";
+	}
+
+	pidl "switch (level) {";
+	indent;
+	foreach my $el (@{$e->{ELEMENTS}}) {
+		if ($el->{CASE} eq "default") {
+			$have_default = 1;
+		} 
+		pidl "$el->{CASE}: {";
+
+		if ($el->{TYPE} ne "EMPTY") {
+			indent;
+			DeclarePtrVariables($el);
+			DeclareArrayVariables($el);
+			if (defined($e->{PROPERTIES}{relative_base})) {
+				pidl "NDR_CHECK(ndr_pull_align(ndr, $el->{ALIGN}));";
+				# set the current offset as base for relative pointers
+				# and store it based on the toplevel struct/union
+				pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));";
+			}
+			ParseElementPull($el, "ndr", "r->", {}, 1, 0);
+			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 "}";
+	deindent;
+	pidl "}";
+	pidl "if (ndr_flags & NDR_BUFFERS) {";
+	indent;
+	if (defined($e->{PROPERTIES}{relative_base})) {
+		# retrieve the current offset as base for relative pointers
+		# based on the toplevel struct/union
+		pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));";
+	}
+	pidl "switch (level) {";
+	indent;
+	foreach my $el (@{$e->{ELEMENTS}}) {
+		pidl "$el->{CASE}:";
+		if ($el->{TYPE} ne "EMPTY") {
+			indent;
+			ParseElementPull($el, "ndr", "r->", {}, 0, 1);
+			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 "}";
+
+	deindent;
+	pidl "}";
+
+	add_deferred();
+
+	end_flags($e);
+	# restore the old relative_base_offset
+	pidl "ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($e->{PROPERTIES}{relative_base});
+}
+
+sub DeclUnion($$)
+{
+	my ($e,$t) = @_;
+	return ($t ne "pull"?"const ":"") . "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,
+	DECL => \&DeclUnion,
+	PULL_FN_BODY => \&ParseUnionPull,
+	PRINT_FN_BODY => \&ParseUnionPrint,
+	SIZE_FN_ARGS => \&ArgsUnionNdrSize,
+	SIZE_FN_BODY => \&ParseUnionNdrSize,
+};
+	
+#####################################################################
+# parse a typedef - push side
+sub ParseTypedefPush($)
+{
+	my($e) = shift;
+
+	my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"push");
+	pidl fn_prefix($e) . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, $args)";
+
+	pidl "{";
+	indent;
+	$typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($e->{DATA}, $e->{NAME});
+	pidl "return NT_STATUS_OK;";
+	deindent;
+	pidl "}";
+	pidl "";;
+}
+
+#####################################################################
+# parse a typedef - pull side
+sub ParseTypedefPull($)
+{
+	my($e) = shift;
+
+	my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"pull");
+
+	pidl fn_prefix($e) . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, $args)";
+
+	pidl "{";
+	indent;
+	$typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($e->{DATA}, $e->{NAME});
+	pidl "return NT_STATUS_OK;";
+	deindent;
+	pidl "}";
+	pidl "";
+}
+
+#####################################################################
+# parse a typedef - print side
+sub ParseTypedefPrint($)
+{
+	my($e) = shift;
+
+	my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"print");
+
+	pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args)";
+	pidl "{";
+	indent;
+	$typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($e->{DATA}, $e->{NAME});
+	deindent;
+	pidl "}";
+	pidl "";
+}
+
+#####################################################################
+## calculate the size of a structure
+sub ParseTypedefNdrSize($)
+{
+	my($t) = shift;
+
+	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 if has_property($fn, "noprint");
+
+	pidl "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r)";
+	pidl "{";
+	indent;
+
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		DeclareArrayVariables($e);
+	}
+
+	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++;";
+
+	my $env = GenerateFunctionInEnv($fn);
+
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		if (grep(/in/,@{$e->{DIRECTION}})) {
+			ParseElementPrint($e, "r->in.$e->{NAME}", $env);
+		}
+	}
+	pidl "ndr->depth--;";
+	deindent;
+	pidl "}";
+	
+	pidl "if (flags & NDR_OUT) {";
+	indent;
+	pidl "ndr_print_struct(ndr, \"out\", \"$fn->{NAME}\");";
+	pidl "ndr->depth++;";
+
+	$env = GenerateFunctionOutEnv($fn);
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		if (grep(/out/,@{$e->{DIRECTION}})) {
+			ParseElementPrint($e, "r->out.$e->{NAME}", $env);
+		}
+	}
+	if ($fn->{RETURN_TYPE}) {
+		pidl "ndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", r->out.result);";
+	}
+	pidl "ndr->depth--;";
+	deindent;
+	pidl "}";
+	
+	pidl "ndr->depth--;";
+	deindent;
+	pidl "}";
+	pidl "";
+}
+
+#####################################################################
+# parse a function
+sub ParseFunctionPush($)
+{ 
+	my($fn) = shift;
+
+	return if has_property($fn, "nopush");
+
+	pidl fn_prefix($fn) . "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, const struct $fn->{NAME} *r)";
+	pidl "{";
+	indent;
+
+	foreach my $e (@{$fn->{ELEMENTS}}) { 
+		DeclareArrayVariables($e);
+	}
+
+	pidl "if (flags & NDR_IN) {";
+	indent;
+
+	my $env = GenerateFunctionInEnv($fn);
+
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		if (grep(/in/,@{$e->{DIRECTION}})) {
+			ParseElementPush($e, "ndr", "r->in.", $env, 1, 1);
+		}
+	}
+
+	deindent;
+	pidl "}";
+
+	pidl "if (flags & NDR_OUT) {";
+	indent;
+
+	$env = GenerateFunctionOutEnv($fn);
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		if (grep(/out/,@{$e->{DIRECTION}})) {
+			ParseElementPush($e, "ndr", "r->out.", $env, 1, 1);
+		}
+	}
+
+	if ($fn->{RETURN_TYPE}) {
+		pidl "NDR_CHECK(ndr_push_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, r->out.result));";
+	}
+    
+	deindent;
+	pidl "}";
+	pidl "return NT_STATUS_OK;";
+	deindent;
+	pidl "}";
+	pidl "";
+}
+
+sub AllocateArrayLevel($$$$$)
+{
+	my ($e,$l,$ndr,$env,$size) = @_;
+
+	my $var = ParseExpr($e->{NAME}, $env);
+
+	check_null_pointer($size);
+	my $pl = GetPrevLevel($e, $l);
+	if (defined($pl) and 
+	    $pl->{TYPE} eq "POINTER" and 
+	    $pl->{POINTER_TYPE} eq "ref"
+	    and not $l->{IS_ZERO_TERMINATED}) {
+		pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {";
+		pidl "\tNDR_PULL_ALLOC_N($ndr, $var, $size);";
+		pidl "}";
+	} else {
+		pidl "NDR_PULL_ALLOC_N($ndr, $var, $size);";
+	}
+
+	if (grep(/in/,@{$e->{DIRECTION}}) and
+	    grep(/out/,@{$e->{DIRECTION}}) and
+	    $pl->{POINTER_TYPE} eq "ref") {
+		pidl "memcpy(r->out.$e->{NAME},r->in.$e->{NAME},$size * sizeof(*r->in.$e->{NAME}));";
+	}
+}
+
+#####################################################################
+# parse a function
+sub ParseFunctionPull($)
+{ 
+	my($fn) = shift;
+
+	return if has_property($fn, "nopull");
+
+	# pull function args
+	pidl fn_prefix($fn) . "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}}) { 
+		DeclarePtrVariables($e);
+		DeclareArrayVariables($e);
+	}
+
+	my %double_cases = ();
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		next if ($e->{TYPE} eq "EMPTY");
+		next if ($double_cases{"$e->{NAME}"});
+		DeclareMemCtxVariables($e);
+		$double_cases{"$e->{NAME}"} = 1;
+	}
+
+	pidl "if (flags & NDR_IN) {";
+	indent;
+
+	# 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}}) {
+		next unless grep(/out/, @{$e->{DIRECTION}});
+		pidl "ZERO_STRUCT(r->out);";
+		pidl "";
+		last;
+	}
+
+	my $env = GenerateFunctionInEnv($fn);
+
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		next unless (grep(/in/, @{$e->{DIRECTION}}));
+		ParseElementPull($e, "ndr", "r->in.", $env, 1, 1);
+	}
+
+	# allocate the "simple" out ref variables. FIXME: Shouldn't this have it's
+	# own flag rather then be in NDR_IN ?
+
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		next unless (grep(/out/, @{$e->{DIRECTION}}));
+		next unless ($e->{LEVELS}[0]->{TYPE} eq "POINTER" and 
+		             $e->{LEVELS}[0]->{POINTER_TYPE} eq "ref");
+		next if (($e->{LEVELS}[1]->{TYPE} eq "DATA") and 
+				 ($e->{LEVELS}[1]->{DATA_TYPE} eq "string"));
+		next if (($e->{LEVELS}[1]->{TYPE} eq "ARRAY") 
+			and   $e->{LEVELS}[1]->{IS_ZERO_TERMINATED});
+
+		if ($e->{LEVELS}[1]->{TYPE} eq "ARRAY") {
+			my $size = ParseExpr($e->{LEVELS}[1]->{SIZE_IS}, $env);
+			check_null_pointer($size);
+			
+			pidl "NDR_PULL_ALLOC_N(ndr, r->out.$e->{NAME}, $size);";
+
+			if (grep(/in/, @{$e->{DIRECTION}})) {
+				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}));";
+			}
+		} else {
+			pidl "NDR_PULL_ALLOC(ndr, r->out.$e->{NAME});";
+		
+			if (grep(/in/, @{$e->{DIRECTION}})) {
+				pidl "*r->out.$e->{NAME} = *r->in.$e->{NAME};";
+			} else {
+				pidl "ZERO_STRUCTP(r->out.$e->{NAME});";
+			}
+		}
+	}
+
+	add_deferred();
+	deindent;
+	pidl "}";
+	
+	pidl "if (flags & NDR_OUT) {";
+	indent;
+
+	$env = GenerateFunctionOutEnv($fn);
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		next unless grep(/out/, @{$e->{DIRECTION}});
+		ParseElementPull($e, "ndr", "r->out.", $env, 1, 1);
+	}
+
+	if ($fn->{RETURN_TYPE}) {
+		pidl "NDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, &r->out.result));";
+	}
+
+	add_deferred();
+	deindent;
+	pidl "}";
+
+	pidl "return NT_STATUS_OK;";
+	deindent;
+	pidl "}";
+	pidl "";
+}
+
+#####################################################################
+# produce a function call table
+sub FunctionTable($)
+{
+	my($interface) = shift;
+	my $count = 0;
+	my $uname = uc $interface->{NAME};
+
+	$count = $#{$interface->{FUNCTIONS}}+1;
+
+	return if ($count == 0);
+
+	pidl "static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {";
+	$count = 0;
+	foreach my $d (@{$interface->{FUNCTIONS}}) {
+		next if not defined($d->{OPNUM});
+		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},";
+		$count++;
+	}
+	pidl "\t{ NULL, 0, NULL, NULL, NULL }";
+	pidl "};";
+	pidl "";
+
+	pidl "static const char * const $interface->{NAME}\_endpoint_strings[] = {";
+	foreach my $ep (@{$interface->{ENDPOINTS}}) {
+		pidl "\t$ep, ";
+	}
+	my $endpoint_count = $#{$interface->{ENDPOINTS}}+1;
+	
+	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,$needed) = @_;
+
+	# Typedefs
+	foreach my $d (@{$interface->{TYPEDEFS}}) {
+		($needed->{"push_$d->{NAME}"}) && ParseTypedefPush($d);
+		($needed->{"pull_$d->{NAME}"}) && ParseTypedefPull($d);
+		($needed->{"print_$d->{NAME}"}) && ParseTypedefPrint($d);
+
+		# Make sure we don't generate a function twice...
+		$needed->{"push_$d->{NAME}"} = $needed->{"pull_$d->{NAME}"} = 
+			$needed->{"print_$d->{NAME}"} = 0;
+
+		($needed->{"ndr_size_$d->{NAME}"}) && ParseTypedefNdrSize($d);
+	}
+
+	# Functions
+	foreach my $d (@{$interface->{FUNCTIONS}}) {
+		($needed->{"push_$d->{NAME}"}) && ParseFunctionPush($d);
+		($needed->{"pull_$d->{NAME}"}) && ParseFunctionPull($d);
+		($needed->{"print_$d->{NAME}"}) && ParseFunctionPrint($d);
+
+		# Make sure we don't generate a function twice...
+		$needed->{"push_$d->{NAME}"} = $needed->{"pull_$d->{NAME}"} = 
+			$needed->{"print_$d->{NAME}"} = 0;
+	}
+
+	FunctionTable($interface);
+}
+
+sub RegistrationFunction($$)
+{
+	my ($idl,$filename) = @_;
+
+	$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 $count = ($#{$interface->{FUNCTIONS}}+1);
+
+		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 "";
+}
+
+#####################################################################
+# parse a parsed IDL structure back into an IDL file
+sub Parse($$)
+{
+	my($ndr,$filename) = @_;
+
+	$tabs = "";
+	my $h_filename = $filename;
+	$res = "";
+
+	if ($h_filename =~ /(.*)\.c/) {
+		$h_filename = "$1.h";
+	}
+
+	pidl "/* parser auto-generated by pidl */";
+	pidl "";
+	pidl "#include \"includes.h\"";
+	pidl "#include \"librpc/gen_ndr/ndr_misc.h\"";
+	pidl "#include \"librpc/gen_ndr/ndr_dcerpc.h\"";
+	pidl "#include \"$h_filename\"";
+	pidl "";
+
+	my %needed = ();
+
+	foreach my $x (@{$ndr}) {
+		($x->{TYPE} eq "INTERFACE") && NeededInterface($x, \%needed);
+	}
+
+	foreach my $x (@{$ndr}) {
+		($x->{TYPE} eq "INTERFACE") && ParseInterface($x, \%needed);
+	}
+
+	RegistrationFunction($ndr, $filename);
+
+	return $res;
+}
+
+sub NeededFunction($$)
+{
+	my ($fn,$needed) = @_;
+	$needed->{"pull_$fn->{NAME}"} = 1;
+	$needed->{"push_$fn->{NAME}"} = 1;
+	$needed->{"print_$fn->{NAME}"} = 1;
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		$e->{PARENT} = $fn;
+		unless(defined($needed->{"pull_$e->{TYPE}"})) {
+			$needed->{"pull_$e->{TYPE}"} = 1;
+		}
+		unless(defined($needed->{"push_$e->{TYPE}"})) {
+			$needed->{"push_$e->{TYPE}"} = 1;
+		}
+		unless(defined($needed->{"print_$e->{TYPE}"})) {
+			$needed->{"print_$e->{TYPE}"} = 1;
+		}
+	}
+}
+
+sub NeededTypedef($$)
+{
+	my ($t,$needed) = @_;
+	if (has_property($t, "public")) {
+		$needed->{"pull_$t->{NAME}"} = not has_property($t, "nopull");
+		$needed->{"push_$t->{NAME}"} = not has_property($t, "nopush");
+		$needed->{"print_$t->{NAME}"} = not has_property($t, "noprint");
+	}
+
+	if ($t->{DATA}->{TYPE} eq "STRUCT" or $t->{DATA}->{TYPE} eq "UNION") {
+		if (has_property($t, "gensize")) {
+			$needed->{"ndr_size_$t->{NAME}"} = 1;
+		}
+
+		for my $e (@{$t->{DATA}->{ELEMENTS}}) {
+			$e->{PARENT} = $t->{DATA};
+			if ($needed->{"pull_$t->{NAME}"} and
+				not defined($needed->{"pull_$e->{TYPE}"})) {
+				$needed->{"pull_$e->{TYPE}"} = 1;
+			}
+			if ($needed->{"push_$t->{NAME}"} and
+				not defined($needed->{"push_$e->{TYPE}"})) {
+				$needed->{"push_$e->{TYPE}"} = 1;
+			}
+			if ($needed->{"print_$t->{NAME}"} and 
+				not defined($needed->{"print_$e->{TYPE}"})) {
+				$needed->{"print_$e->{TYPE}"} = 1;
+			}
+		}
+	}
+}
+
+#####################################################################
+# work out what parse functions are needed
+sub NeededInterface($$)
+{
+	my ($interface,$needed) = @_;
+	foreach my $d (@{$interface->{FUNCTIONS}}) {
+	    NeededFunction($d, $needed);
+	}
+	foreach my $d (reverse @{$interface->{TYPEDEFS}}) {
+	    NeededTypedef($d, $needed);
+	}
+}
+
+1;
diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Server.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Server.pm
new file mode 100644
index 0000000000..a8c159572b
--- /dev/null
+++ b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Server.pm
@@ -0,0 +1,322 @@
+###################################################
+# server boilerplate generator
+# Copyright tridge@samba.org 2003
+# Copyright metze@samba.org 2004
+# released under the GNU GPL
+
+package Parse::Pidl::Samba::NDR::Server;
+
+use strict;
+
+my($res);
+
+sub pidl($)
+{
+	$res .= shift;
+}
+
+
+#####################################################
+# generate the switch statement for function dispatch
+sub gen_dispatch_switch($)
+{
+	my $interface = shift;
+
+	foreach my $fn (@{$interface->{FUNCTIONS}}) {
+		next if not defined($fn->{OPNUM});
+
+		pidl "\tcase $fn->{OPNUM}: {\n";
+		pidl "\t\tstruct $fn->{NAME} *r2 = r;\n";
+		pidl "\t\tif (DEBUGLEVEL >= 10) {\n";
+		pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($fn->{NAME}, NDR_IN, r2);\n";
+		pidl "\t\t}\n";
+		if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
+			pidl "\t\tr2->out.result = $fn->{NAME}(dce_call, mem_ctx, r2);\n";
+		} else {
+			pidl "\t\t$fn->{NAME}(dce_call, mem_ctx, r2);\n";
+		}
+		pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n";
+		pidl "\t\t\tDEBUG(5,(\"function $fn->{NAME} will reply async\\n\"));\n";
+		pidl "\t\t}\n";
+		pidl "\t\tbreak;\n\t}\n";
+	}
+}
+
+#####################################################
+# generate the switch statement for function reply
+sub gen_reply_switch($)
+{
+	my $interface = shift;
+
+	foreach my $fn (@{$interface->{FUNCTIONS}}) {
+		next if not defined($fn->{OPNUM});
+
+		pidl "\tcase $fn->{OPNUM}: {\n";
+		pidl "\t\tstruct $fn->{NAME} *r2 = r;\n";
+		pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n";
+		pidl "\t\t\tDEBUG(5,(\"function $fn->{NAME} replied async\\n\"));\n";
+		pidl "\t\t}\n";
+		pidl "\t\tif (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {\n";
+		pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($fn->{NAME}, NDR_OUT | NDR_SET_VALUES, r2);\n";
+		pidl "\t\t}\n";
+		pidl "\t\tif (dce_call->fault_code != 0) {\n";
+		pidl "\t\t\tDEBUG(2,(\"dcerpc_fault %s in $fn->{NAME}\\n\", dcerpc_errstr(mem_ctx, dce_call->fault_code)));\n";
+		pidl "\t\t}\n";
+		pidl "\t\tbreak;\n\t}\n";
+	}
+}
+
+#####################################################################
+# produce boilerplate code for a interface
+sub Boilerplate_Iface($)
+{
+	my($interface) = shift;
+	my $name = $interface->{NAME}; 
+	my $uname = uc $name;
+	my $uuid = Parse::Pidl::Util::make_str($interface->{PROPERTIES}->{uuid});
+	my $if_version = $interface->{PROPERTIES}->{version};
+
+	pidl "
+static NTSTATUS $name\__op_bind(struct dcesrv_call_state *dce_call, const struct dcesrv_interface *iface)
+{
+#ifdef DCESRV_INTERFACE_$uname\_BIND
+	return DCESRV_INTERFACE_$uname\_BIND(dce_call,iface);
+#else
+	return NT_STATUS_OK;
+#endif
+}
+
+static void $name\__op_unbind(struct dcesrv_connection_context *context, const struct dcesrv_interface *iface)
+{
+#ifdef DCESRV_INTERFACE_$uname\_UNBIND
+	DCESRV_INTERFACE_$uname\_UNBIND(context, iface);
+#else
+	return;
+#endif
+}
+
+static NTSTATUS $name\__op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_pull *pull, void **r)
+{
+	NTSTATUS status;
+	uint16_t opnum = dce_call->pkt.u.request.opnum;
+
+	dce_call->fault_code = 0;
+
+	if (opnum >= dcerpc_table_$name.num_calls) {
+		dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
+		return NT_STATUS_NET_WRITE_FAULT;
+	}
+
+	*r = talloc_size(mem_ctx, dcerpc_table_$name.calls[opnum].struct_size);
+	NT_STATUS_HAVE_NO_MEMORY(*r);
+
+        /* unravel the NDR for the packet */
+	status = dcerpc_table_$name.calls[opnum].ndr_pull(pull, NDR_IN, *r);
+	if (!NT_STATUS_IS_OK(status)) {
+		dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN,
+				  &dce_call->pkt.u.request.stub_and_verifier);
+		dce_call->fault_code = DCERPC_FAULT_NDR;
+		return NT_STATUS_NET_WRITE_FAULT;
+	}
+
+	return NT_STATUS_OK;
+}
+
+static NTSTATUS $name\__op_dispatch(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
+{
+	uint16_t opnum = dce_call->pkt.u.request.opnum;
+
+	switch (opnum) {
+";
+	gen_dispatch_switch($interface);
+
+pidl "
+	default:
+		dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
+		break;
+	}
+
+	if (dce_call->fault_code != 0) {
+		dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN,
+				  &dce_call->pkt.u.request.stub_and_verifier);
+		return NT_STATUS_NET_WRITE_FAULT;
+	}
+
+	return NT_STATUS_OK;
+}
+
+static NTSTATUS $name\__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
+{
+	uint16_t opnum = dce_call->pkt.u.request.opnum;
+
+	switch (opnum) {
+";
+	gen_reply_switch($interface);
+
+pidl "
+	default:
+		dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
+		break;
+	}
+
+	if (dce_call->fault_code != 0) {
+		dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN,
+				  &dce_call->pkt.u.request.stub_and_verifier);
+		return NT_STATUS_NET_WRITE_FAULT;
+	}
+
+	return NT_STATUS_OK;
+}
+
+static NTSTATUS $name\__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_push *push, const void *r)
+{
+	NTSTATUS status;
+	uint16_t opnum = dce_call->pkt.u.request.opnum;
+
+	status = dcerpc_table_$name.calls[opnum].ndr_push(push, NDR_OUT, r);
+	if (!NT_STATUS_IS_OK(status)) {
+		dce_call->fault_code = DCERPC_FAULT_NDR;
+		return NT_STATUS_NET_WRITE_FAULT;
+	}
+
+	return NT_STATUS_OK;
+}
+
+static const struct dcesrv_interface $name\_interface = {
+	.name		= \"$name\",
+	.uuid		= $uuid,
+	.if_version	= $if_version,
+	.bind		= $name\__op_bind,
+	.unbind		= $name\__op_unbind,
+	.ndr_pull	= $name\__op_ndr_pull,
+	.dispatch	= $name\__op_dispatch,
+	.reply		= $name\__op_reply,
+	.ndr_push	= $name\__op_ndr_push
+};
+
+";
+}
+
+#####################################################################
+# produce boilerplate code for an endpoint server
+sub Boilerplate_Ep_Server($)
+{
+	my($interface) = shift;
+	my $name = $interface->{NAME};
+	my $uname = uc $name;
+
+	pidl "
+static NTSTATUS $name\__op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server)
+{
+	int i;
+
+	for (i=0;i<dcerpc_table_$name.endpoints->count;i++) {
+		NTSTATUS ret;
+		const char *name = dcerpc_table_$name.endpoints->names[i];
+
+		ret = dcesrv_interface_register(dce_ctx, name, &$name\_interface, NULL);
+		if (!NT_STATUS_IS_OK(ret)) {
+			DEBUG(1,(\"$name\_op_init_server: failed to register endpoint \'%s\'\\n\",name));
+			return ret;
+		}
+	}
+
+	return NT_STATUS_OK;
+}
+
+static BOOL $name\__op_interface_by_uuid(struct dcesrv_interface *iface, const char *uuid, uint32_t if_version)
+{
+	if ($name\_interface.if_version == if_version &&
+		strcmp($name\_interface.uuid, uuid)==0) {
+		memcpy(iface,&$name\_interface, sizeof(*iface));
+		return True;
+	}
+
+	return False;
+}
+
+static BOOL $name\__op_interface_by_name(struct dcesrv_interface *iface, const char *name)
+{
+	if (strcmp($name\_interface.name, name)==0) {
+		memcpy(iface,&$name\_interface, sizeof(*iface));
+		return True;
+	}
+
+	return False;	
+}
+	
+NTSTATUS dcerpc_server_$name\_init(void)
+{
+	NTSTATUS ret;
+	struct dcesrv_endpoint_server ep_server;
+
+	/* fill in our name */
+	ep_server.name = \"$name\";
+
+	/* fill in all the operations */
+	ep_server.init_server = $name\__op_init_server;
+
+	ep_server.interface_by_uuid = $name\__op_interface_by_uuid;
+	ep_server.interface_by_name = $name\__op_interface_by_name;
+
+	/* register ourselves with the DCERPC subsystem. */
+	ret = dcerpc_register_ep_server(&ep_server);
+
+	if (!NT_STATUS_IS_OK(ret)) {
+		DEBUG(0,(\"Failed to register \'$name\' endpoint server!\\n\"));
+		return ret;
+	}
+
+	return ret;
+}
+
+";
+}
+
+#####################################################################
+# dcerpc server boilerplate from a parsed IDL structure 
+sub ParseInterface($)
+{
+	my($interface) = shift;
+	my $count = 0;
+
+	if (!defined $interface->{PROPERTIES}->{uuid}) {
+		return $res;
+	}
+
+	if (!defined $interface->{PROPERTIES}->{version}) {
+		$interface->{PROPERTIES}->{version} = "0.0";
+	}
+
+	foreach my $fn (@{$interface->{FUNCTIONS}}) {
+		if (defined($fn->{OPNUM})) { $count++; }
+	}
+
+	if ($count == 0) {
+		return $res;
+	}
+
+	$res .= "/* $interface->{NAME} - dcerpc server boilerplate generated by pidl */\n\n";
+	Boilerplate_Iface($interface);
+	Boilerplate_Ep_Server($interface);
+
+	return $res;
+}
+
+sub Parse($$)
+{
+	my($ndr) = shift;
+	my($filename) = shift;
+
+	$res =  "";
+	$res .= "/* server functions auto-generated by pidl */\n";
+	$res .= "\n";
+
+	foreach my $x (@{$ndr}) {
+		ParseInterface($x) if ($x->{TYPE} eq "INTERFACE" and not defined($x->{PROPERTIES}{object}));
+	}
+
+	return $res;
+}
+
+1;
diff --git a/source4/pidl/lib/Parse/Pidl/Samba/SWIG.pm b/source4/pidl/lib/Parse/Pidl/Samba/SWIG.pm
new file mode 100644
index 0000000000..409095804f
--- /dev/null
+++ b/source4/pidl/lib/Parse/Pidl/Samba/SWIG.pm
@@ -0,0 +1,76 @@
+###################################################
+# Samba4 parser generator for swig wrappers
+# Copyright tpot@samba.org 2004,2005
+# released under the GNU GPL
+
+package Parse::Pidl::Samba::SWIG;
+
+use strict;
+
+sub pidl($)
+{
+	print OUT shift;
+}
+
+#####################################################################
+# rewrite autogenerated header file
+sub RewriteHeader($$$)
+{
+    my($idl) = shift;
+    my($input) = shift;
+    my($output) = shift;
+
+    open(IN, "<$input") || die "can't open $input for reading";
+    open(OUT, ">$output") || die "can't open $output for writing";    
+
+    pidl "%{\n";
+    pidl "#define data_in in\n";
+    pidl "#define data_out out\n";
+    pidl "%}\n\n";
+   
+    while(<IN>) {
+
+	# Rename dom_sid2 to dom_sid as we don't care about the difference
+	# for the swig wrappers.
+
+	s/dom_sid2/dom_sid/g;
+
+	# Copy structure and union definitions
+
+	if (/^(struct|union) .*? {$/ .. /^\};$/) {
+	    s/\} (in|out);/\} data_$1;/; # "in" is a Python keyword
+	    pidl $_;
+	    next;
+	}
+
+	# Copy dcerpc functions
+
+	pidl $_ if /^NTSTATUS dcerpc_.*?\(struct dcerpc_pipe/;
+
+	# Copy interface definitions
+
+        pidl $_ 
+	    if /^\#define DCERPC_.*?_UUID/ or /^\#define DCERPC_.*?_VERSION/;
+    }
+
+    close(OUT);   
+}
+
+#####################################################################
+# rewrite autogenerated header file
+sub RewriteC($$$)
+{
+    my($idl) = shift;
+    my($input) = shift;
+    my($output) = shift;
+
+    open(IN, "<$input") || die "can't open $input for reading";
+    open(OUT, ">>$output") || die "can't open $output for writing";    
+   
+    while(<IN>) {
+    }
+
+    close(OUT);   
+}
+
+1;
diff --git a/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm b/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm
new file mode 100644
index 0000000000..b9bfd83e41
--- /dev/null
+++ b/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm
@@ -0,0 +1,266 @@
+###################################################
+# Trivial Parser Generator
+# Copyright jelmer@samba.org 2005
+# released under the GNU GPL
+
+package Parse::Pidl::Samba::TDR;
+use Parse::Pidl::Util qw(has_property ParseExpr is_constant);
+use Data::Dumper;
+
+use strict;
+
+my $ret = "";
+my $tabs = "";
+
+sub indent() { $tabs.="\t"; }
+sub deindent() { $tabs = substr($tabs, 1); }
+sub pidl($) { $ret .= $tabs.(shift)."\n"; }
+sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); }
+sub static($) { my $p = shift; return("static ") unless ($p); return ""; }
+sub printarg($) { 
+	my $t = shift; 
+	return(", const char *name") if ($t eq "print");
+	return("");
+}
+
+sub ContainsArray($)
+{
+	my $e = shift;
+	foreach (@{$e->{ELEMENTS}}) {
+		next if (has_property($_, "charset") and
+			scalar(@{$_->{ARRAY_LEN}}) == 1);
+		return 1 if (defined($_->{ARRAY_LEN}) and 
+				scalar(@{$_->{ARRAY_LEN}}) > 0);
+	}
+	return 0;
+}
+
+sub ParserElement($$$)
+{
+	my ($e,$t,$env) = @_;
+	my $switch = "";
+	my $array = "";
+	my $name = "";
+
+	fatal($e,"Pointers not supported in TDR") if ($e->{POINTERS} > 0);
+	fatal($e,"size_is() not supported in TDR") if (has_property($e, "size_is"));
+	fatal($e,"length_is() not supported in TDR") if (has_property($e, "length_is"));
+
+	if ($t eq "print") {
+		$name = ", \"$e->{NAME}\"$array";
+	}
+
+	if (has_property($e, "flag")) {
+		pidl "{";
+		indent;
+		pidl "uint32_t saved_flags = tdr->flags;";
+		pidl "tdr->flags |= $e->{PROPERTIES}->{flag};";
+	}
+
+	if (has_property($e, "charset")) {
+		fatal($e,"charset() on non-array element") unless (defined($e->{ARRAY_LEN}) and scalar(@{$e->{ARRAY_LEN}}) > 0);
+		
+		my $len = @{$e->{ARRAY_LEN}}[0];
+		if ($len eq "*") { $len = "-1"; }
+		pidl "TDR_CHECK(tdr_$t\_charset(tdr$name, &v->$e->{NAME}, $len, sizeof($e->{TYPE}_t), CH_$e->{PROPERTIES}->{charset}));";
+		return;
+	}
+
+
+	if (has_property($e, "switch_is")) {
+		$switch = ", " . ParseExpr($e->{PROPERTIES}->{switch_is}, $env);
+	}
+
+	if (defined($e->{ARRAY_LEN}) and scalar(@{$e->{ARRAY_LEN}}) > 0) {
+		my $len = ParseExpr($e->{ARRAY_LEN}[0], $env);
+
+		if ($t eq "pull" and not is_constant($len)) {
+			pidl "TDR_ALLOC(tdr, v->$e->{NAME}, $len);"
+		}
+
+		pidl "for (i = 0; i < $len; i++) {";
+		indent;
+		$array = "[i]";
+	}
+
+	if (has_property($e, "value") && $t eq "push") {
+		pidl "v->$e->{NAME} = ".ParseExpr($e->{PROPERTIES}->{value}, $env).";";
+	}
+
+	pidl "TDR_CHECK(tdr_$t\_$e->{TYPE}(tdr$name$switch, &v->$e->{NAME}$array));";
+
+	if ($array) { deindent; pidl "}"; }
+
+	if (has_property($e, "flag")) {
+		pidl "tdr->flags = saved_flags;";
+		deindent;
+		pidl "}";
+	}
+}
+
+sub ParserStruct($$$$)
+{
+	my ($e,$n,$t,$p) = @_;
+
+	pidl static($p)."NTSTATUS tdr_$t\_$n (struct tdr_$t *tdr".printarg($t).", struct $n *v)";
+	pidl "{"; indent;
+	pidl "int i;" if (ContainsArray($e));
+
+	if ($t eq "print") {
+		pidl "tdr->print(tdr, \"\%-25s: struct $n\", name);";
+		pidl "tdr->level++;";
+	}
+
+	my %env = map { $_->{NAME} => "v->$_->{NAME}" } @{$e->{ELEMENTS}};
+	ParserElement($_, $t, \%env) foreach (@{$e->{ELEMENTS}});
+	
+	if ($t eq "print") {
+		pidl "tdr->level--;";
+	}
+
+	pidl "return NT_STATUS_OK;";
+
+	deindent; pidl "}";
+}
+
+sub ParserUnion($$$$)
+{
+	my ($e,$n,$t,$p) = @_;
+
+	pidl static($p)."NTSTATUS tdr_$t\_$n(struct tdr_$t *tdr".printarg($t).", int level, union $n *v)";
+	pidl "{"; indent;
+	pidl "int i;" if (ContainsArray($e));
+
+	if ($t eq "print") {
+		pidl "tdr->print(tdr, \"\%-25s: union $n\", name);";
+		pidl "tdr->level++;";
+	}
+	
+	pidl "switch (level) {"; indent;
+	foreach (@{$e->{ELEMENTS}}) {
+		if (has_property($_, "case")) {
+			pidl "case " . $_->{PROPERTIES}->{case} . ":";
+		} elsif (has_property($_, "default")) {
+			pidl "default:";
+		}
+		indent; ParserElement($_, $t, {}); deindent;
+		pidl "break;";
+	}
+	deindent; pidl "}";
+
+	if ($t eq "print") {
+		pidl "tdr->level--;";
+	}
+	
+	pidl "return NT_STATUS_OK;\n";
+	deindent; pidl "}";
+}
+
+sub ParserBitmap($$$$)
+{
+	my ($e,$n,$t,$p) = @_;
+	return if ($p);
+	pidl "#define tdr_$t\_$n tdr_$t\_" . Parse::Pidl::Typelist::bitmap_type_fn($e);
+}
+
+sub ParserEnum($$$$)
+{
+	my ($e,$n,$t,$p) = @_;
+	my $bt = Parse::Pidl::Typelist::enum_type_fn($e);
+	
+	pidl static($p)."NTSTATUS tdr_$t\_$n (struct tdr_$t *tdr".printarg($t).", enum $n *v)";
+	pidl "{";
+	if ($t eq "pull") {
+		pidl "\t$bt\_t r;";
+		pidl "\tTDR_CHECK(tdr_$t\_$bt(tdr, \&r));";
+		pidl "\t*v = r;";
+	} elsif ($t eq "push") {
+		pidl "\tTDR_CHECK(tdr_$t\_$bt(tdr, ($bt\_t *)v));";
+	} elsif ($t eq "print") {
+		pidl "\t/* FIXME */";
+	}
+	pidl "\treturn NT_STATUS_OK;";
+	pidl "}";
+}
+
+sub ParserTypedef($$)
+{
+	my ($e,$t) = @_;
+
+	return if (has_property($e, "no$t"));
+
+	{ STRUCT => \&ParserStruct, UNION => \&ParserUnion, 
+		ENUM => \&ParserEnum, BITMAP => \&ParserBitmap
+	}->{$e->{DATA}->{TYPE}}($e->{DATA}, $e->{NAME}, $t, has_property($e, "public"));
+
+	pidl "";
+}
+
+sub ParserInterface($)
+{
+	my $x = shift;
+
+	foreach (@{$x->{DATA}}) {
+		next if ($_->{TYPE} ne "TYPEDEF");
+		ParserTypedef($_, "pull");
+		ParserTypedef($_, "push");
+		ParserTypedef($_, "print");
+	}
+}
+
+sub Parser($$)
+{
+	my ($idl,$hdrname) = @_;
+	$ret = "";
+	pidl "/* autogenerated by pidl */";
+	pidl "#include \"includes.h\"";
+	pidl "#include \"$hdrname\"";
+	foreach (@$idl) { ParserInterface($_) if ($_->{TYPE} eq "INTERFACE"); }	
+	return $ret;
+}
+
+sub HeaderInterface($$)
+{
+	my ($x,$outputdir) = @_;
+
+	pidl "#ifndef __TDR_$x->{NAME}_HEADER__";
+	pidl "#define __TDR_$x->{NAME}_HEADER__";
+
+	pidl "#include \"$outputdir/$x->{NAME}.h\"";
+	
+	foreach my $e (@{$x->{DATA}}) { 
+		next unless ($e->{TYPE} eq "TYPEDEF"); 
+		next unless has_property($e, "public");
+
+		my $switch = "";
+
+		$switch = ", int level" if ($e->{DATA}->{TYPE} eq "UNION");
+
+		if ($e->{DATA}->{TYPE} eq "BITMAP") {
+			# FIXME
+		} else {
+			my ($n, $d) = ($e->{NAME}, lc($e->{DATA}->{TYPE}));
+			pidl "NTSTATUS tdr_pull\_$n(struct tdr_pull *tdr$switch, $d $n *v);";
+			pidl "NTSTATUS tdr_print\_$n(struct tdr_print *tdr, const char *name$switch, $d $n *v);";
+			pidl "NTSTATUS tdr_push\_$n(struct tdr_push *tdr$switch, $d $n *v);";
+		}
+	
+		pidl "";
+	}
+	
+	pidl "#endif /* __TDR_$x->{NAME}_HEADER__ */";
+}
+
+sub Header($$)
+{
+	my ($idl,$outputdir) = @_;
+	$ret = "";
+	pidl "/* Generated by pidl */";
+	
+	foreach (@$idl) { 
+		HeaderInterface($_, $outputdir) if ($_->{TYPE} eq "INTERFACE"); 
+	}	
+	return $ret;
+}
+
+1;
diff --git a/source4/pidl/lib/Parse/Pidl/Samba/Template.pm b/source4/pidl/lib/Parse/Pidl/Samba/Template.pm
new file mode 100644
index 0000000000..eb71b6d707
--- /dev/null
+++ b/source4/pidl/lib/Parse/Pidl/Samba/Template.pm
@@ -0,0 +1,88 @@
+###################################################
+# server template function generator
+# Copyright tridge@samba.org 2003
+# released under the GNU GPL
+
+package Parse::Pidl::Samba::Template;
+
+use strict;
+
+my($res);
+
+#####################################################################
+# produce boilerplate code for a interface
+sub Template($)
+{
+	my($interface) = shift;
+	my($data) = $interface->{DATA};
+	my $name = $interface->{NAME};
+
+	$res .= 
+"/* 
+   Unix SMB/CIFS implementation.
+
+   endpoint server for the $name pipe
+
+   Copyright (C) YOUR NAME HERE YEAR
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include \"includes.h\"
+#include \"rpc_server/dcerpc_server.h\"
+#include \"librpc/gen_ndr/ndr_$name.h\"
+
+";
+
+	foreach my $d (@{$data}) {
+		if ($d->{TYPE} eq "FUNCTION") {
+			my $fname = $d->{NAME};
+			$res .=
+"
+/* 
+  $fname 
+*/
+static $d->{RETURN_TYPE} $fname(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
+		       struct $fname *r)
+{
+	DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
+}
+
+";
+		}
+	}
+
+	$res .= 
+"
+/* include the generated boilerplate */
+#include \"librpc/gen_ndr/ndr_$name\_s.c\"
+"
+}
+
+
+#####################################################################
+# parse a parsed IDL structure back into an IDL file
+sub Parse($)
+{
+	my($idl) = shift;
+	$res = "";
+	foreach my $x (@{$idl}) {
+		($x->{TYPE} eq "INTERFACE") && 
+		    Template($x);
+	}
+	return $res;
+}
+
+1;
diff --git a/source4/pidl/lib/Parse/Pidl/Test.pm b/source4/pidl/lib/Parse/Pidl/Test.pm
new file mode 100644
index 0000000000..34ea80c95c
--- /dev/null
+++ b/source4/pidl/lib/Parse/Pidl/Test.pm
@@ -0,0 +1,169 @@
+# Simple system for running tests against pidl
+# (C) 2005 Jelmer Vernooij <jelmer@samba.org>
+# Published under the GNU General Public License
+
+package Parse::Pidl::Test;
+
+use strict;
+use Parse::Pidl::Util;
+use Getopt::Long;
+
+my $cc = $ENV{CC};
+my @cflags = split / /, $ENV{CFLAGS};
+my @ldflags = split / /, $ENV{LDFLAGS};
+
+$cc = "cc" if ($cc eq "");
+
+sub generate_cfile($$$)
+{
+	my ($filename, $fragment, $incfiles) = @_;
+
+	unless (open (OUT, ">$filename")) {
+		print STDERR "Unable to open $filename\n";
+		return -1;
+	}
+	print OUT '
+/* This file was autogenerated. All changes made will be lost! */
+#include "include/includes.h"
+';
+
+	foreach (@$incfiles) {
+		print OUT "#include \"$_\"\n";
+	}
+
+	print OUT '
+int main(int argc, char **argv)
+{
+	TALLOC_CTX *mem_ctx = talloc_init(NULL);
+	';
+	print OUT $fragment;
+	print OUT "\treturn 0;\n}\n";
+	close OUT;
+
+	return 0;
+}
+
+sub generate_idlfile($$)
+{
+	my ($filename,$fragment) = @_;
+
+	unless (open(OUT, ">$filename")) {
+		print STDERR "Unable to open $filename\n";
+		return -1;
+	}
+	
+	print OUT '
+[uuid("1-2-3-4-5")] interface test_if
+{
+';
+	print OUT $fragment;
+	print OUT "\n}\n";
+	close OUT;
+
+	return 0;
+}
+
+sub compile_idl($$$)
+{
+	my ($filename,$idl_path, $idlargs) = @_;
+
+	my @args = @$idlargs;
+	push (@args, $filename);
+
+	unless (system($idl_path, @args) == 0) {
+		print STDERR "Error compiling IDL file $filename: $!\n";
+		return -1;
+	}
+}
+
+sub compile_cfile($)
+{
+	my ($filename) = @_;
+
+	return system($cc, @cflags, '-I.', '-Iinclude', '-c', $filename);
+}
+
+sub link_files($$)
+{
+	my ($exe_name,$objs) = @_;
+
+	return system($cc, @ldflags, '-Lbin', '-lrpc', '-o', $exe_name, @$objs);
+}
+
+sub test_idl($$$$)
+{
+	my ($name,$settings,$idl,$c) = @_;
+
+	$| = 1;
+
+	print "Running $name... ";
+
+	my $outputdir = $settings->{OutputDir};
+
+	my $c_filename = $outputdir."/".$name."_test.c";
+	my $idl_filename = $outputdir."/".$name."_idl.idl";
+	my $exe_filename = $outputdir."/".$name."_exe";
+
+	return -1 if (generate_cfile($c_filename, $c, $settings->{IncludeFiles}) == -1);
+
+	return -1 if (generate_idlfile($idl_filename, $idl) == -1);
+
+	return -1 if (compile_idl($idl_filename, $settings->{'IDL-Compiler'}, $settings->{'IDL-Arguments'}) == -1);
+
+	my @srcs = ($c_filename);
+	push (@srcs, @{$settings->{'ExtraFiles'}});
+
+	foreach (@srcs) {
+		next unless /\.c$/;
+		return -1 if (compile_cfile($_) == -1);
+	}
+
+	my @objs;
+	foreach (@srcs) {
+		if (/\.c$/) { s/\.c$/\.o/g; }
+		push(@objs, $_);
+	}
+
+	return -1 if (link_files($exe_filename, \@objs) == -1);
+
+	my $ret = system("./$exe_filename");
+	if ($ret != 0) {
+		$ret = $? >> 8;
+		print "failed with return value $ret\n";
+		return $ret;
+	}
+
+	unless ($settings->{Keep}) {
+		unlink(@srcs, @objs, $exe_filename, $idl_filename);
+	}
+
+	print "Ok\n";
+
+	return $ret;
+}
+
+sub GetSettings($)
+{
+	my $settings = { 
+		OutputDir => ".",
+		'IDL-Compiler' => "./pidl"
+	};
+
+	my %opts = ();
+	GetOptions('idl-compiler=s' => \$settings->{'IDL-Compiler'},
+		'outputdir=s' => \$settings->{OutputDir},
+		'keep' => \$settings->{Keep},
+		'help' => sub { ShowHelp(); exit 1; } );
+
+	return %$settings;
+}
+
+sub ShowHelp()
+{
+	print " --idl-compiler=PATH-TO-PIDL  Override path to IDL compiler\n";
+	print " --outputdir=OUTPUTDIR        Write temporary files to OUTPUTDIR rather then .\n";
+	print " --keep                       Keep intermediate files after running test";
+	print " --help                       Show this help message\n";
+}
+
+1;
diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm
new file mode 100644
index 0000000000..10a4baf7e7
--- /dev/null
+++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm
@@ -0,0 +1,336 @@
+###################################################
+# Samba4 parser generator for IDL structures
+# Copyright jelmer@samba.org 2005
+# released under the GNU GPL
+
+package Parse::Pidl::Typelist;
+
+require Exporter;
+@ISA = qw(Exporter);
+@EXPORT = qw(hasType getType mapType);
+
+use Parse::Pidl::Util qw(has_property);
+use strict;
+
+my %typedefs = ();
+
+# a list of known scalar types
+my $scalars = {
+	# 0 byte types
+	"void"		=> {
+				C_TYPE		=> "void",
+				IS_REFERENCE	=> 0,
+				NDR_ALIGN	=> 0
+			},
+
+	# 1 byte types
+	"char"		=> {
+				C_TYPE		=> "char",
+				IS_REFERENCE	=> 0,
+				NDR_ALIGN	=> 1
+			},
+	"int8"		=> {
+				C_TYPE		=> "int8_t",
+				IS_REFERENCE	=> 0,
+				NDR_ALIGN	=> 1
+			},
+	"uint8"		=> {
+				C_TYPE		=> "uint8_t",
+				IS_REFERENCE	=> 0,
+				NDR_ALIGN	=> 1
+			},
+
+	# 2 byte types
+	"int16"		=> {
+				C_TYPE		=> "int16_t",
+				IS_REFERENCE	=> 0,
+				NDR_ALIGN	=> 2
+			},
+	"uint16"	=> {	C_TYPE		=> "uint16_t",
+				IS_REFERENCE	=> 0,
+				NDR_ALIGN	=> 2
+			},
+
+	# 4 byte types
+	"int32"		=> {
+				C_TYPE		=> "int32_t",
+				IS_REFERENCE	=> 0,
+				NDR_ALIGN	=> 4
+			},
+	"uint32"	=> {	C_TYPE		=> "uint32_t",
+				IS_REFERENCE	=> 0,
+				NDR_ALIGN	=> 4
+			},
+
+	# 8 byte types
+	"hyper"		=> {
+				C_TYPE		=> "uint64_t",
+				IS_REFERENCE	=> 0,
+				NDR_ALIGN	=> 8
+			},
+	"dlong"		=> {
+				C_TYPE		=> "int64_t",
+				IS_REFERENCE	=> 0,
+				NDR_ALIGN	=> 4
+			},
+	"udlong"	=> {
+				C_TYPE		=> "uint64_t",
+				IS_REFERENCE	=> 0,
+				NDR_ALIGN	=> 4
+			},
+	"udlongr"	=> {
+				C_TYPE		=> "uint64_t",
+				IS_REFERENCE	=> 0,
+				NDR_ALIGN	=> 4
+			},
+
+	# DATA_BLOB types
+	"DATA_BLOB"	=> {
+				C_TYPE		=> "DATA_BLOB",
+				IS_REFERENCE	=> 0,
+				NDR_ALIGN	=> 4
+			},
+
+	# string types
+	"string"	=> {
+				C_TYPE		=> "const char *",
+				IS_REFERENCE	=> 1,
+				NDR_ALIGN	=> 4 #???
+			},
+	"string_array"	=> {
+				C_TYPE		=> "const char **",
+				IS_REFERENCE	=> 1,
+				NDR_ALIGN	=> 4 #???
+			},
+
+	# time types
+	"time_t"	=> {
+				C_TYPE		=> "time_t",
+				IS_REFERENCE	=> 0,
+				NDR_ALIGN	=> 4
+			},
+	"NTTIME"	=> {
+				C_TYPE		=> "NTTIME",
+				IS_REFERENCE	=> 0,
+				NDR_ALIGN	=> 4
+			},
+	"NTTIME_1sec"	=> {
+				C_TYPE		=> "NTTIME",
+				IS_REFERENCE	=> 0,
+				NDR_ALIGN	=> 4
+			},
+	"NTTIME_hyper"	=> {
+				C_TYPE		=> "NTTIME",
+				IS_REFERENCE	=> 0,
+				NDR_ALIGN	=> 8
+			},
+
+
+	# error code types
+	"WERROR"	=> {
+				C_TYPE		=> "WERROR",
+				IS_REFERENCE	=> 0,
+				NDR_ALIGN	=> 4
+			},
+	"NTSTATUS"	=> {
+				C_TYPE		=> "NTSTATUS",
+				IS_REFERENCE	=> 0,
+				NDR_ALIGN	=> 4
+			},
+	"COMRESULT" => { 
+				"C_TYPE"	=> "COMRESULT",
+				IS_REFERENCE => 0,
+				NDR_ALIGN => 4
+			},
+
+	# special types
+	"nbt_string"	=> {
+				C_TYPE		=> "const char *",
+				IS_REFERENCE	=> 1,
+				NDR_ALIGN	=> 4 #???
+			},
+	"ipv4address"	=> {
+				C_TYPE		=> "const char *",
+				IS_REFERENCE	=> 1,
+				NDR_ALIGN	=> 4
+			}
+};
+
+# map from a IDL type to a C header type
+sub mapScalarType($)
+{
+	my $name = shift;
+
+	# it's a bug when a type is not in the list
+	# of known scalars or has no mapping
+	return $typedefs{$name}->{DATA}->{C_TYPE} if defined($typedefs{$name}) and defined($typedefs{$name}->{DATA}->{C_TYPE});
+
+	die("Unknown scalar type $name");
+}
+
+sub getScalarAlignment($)
+{
+	my $name = shift;
+
+	# it's a bug when a type is not in the list
+	# of known scalars or has no mapping
+	return $scalars->{$name}{NDR_ALIGN} if defined($scalars->{$name}) and defined($scalars->{$name}{NDR_ALIGN});
+
+	die("Unknown scalar type $name");
+}
+
+sub addType($)
+{
+	my $t = shift;
+	$typedefs{$t->{NAME}} = $t;
+}
+
+sub getType($)
+{
+	my $t = shift;
+	return undef if not hasType($t);
+	return $typedefs{$t};
+}
+
+sub typeIs($$)
+{
+	my $t = shift;
+	my $tt = shift;
+
+	return 1 if (hasType($t) and getType($t)->{DATA}->{TYPE} eq $tt);
+	return 0;
+}
+
+sub hasType($)
+{
+	my $t = shift;
+	return 1 if defined($typedefs{$t});
+	return 0;
+}
+
+sub is_scalar($)
+{
+	my $type = shift;
+
+	return 0 unless(hasType($type));
+
+	if (my $dt = getType($type)->{DATA}->{TYPE}) {
+		return 1 if ($dt eq "SCALAR" or $dt eq "ENUM" or $dt eq "BITMAP");
+	}
+
+	return 0;
+}
+
+sub scalar_is_reference($)
+{
+	my $name = shift;
+
+	return $scalars->{$name}{IS_REFERENCE} if defined($scalars->{$name}) and defined($scalars->{$name}{IS_REFERENCE});
+	return 0;
+}
+
+sub RegisterScalars()
+{
+	foreach my $k (keys %{$scalars}) {
+		$typedefs{$k} = {
+			NAME => $k,
+			TYPE => "TYPEDEF",
+			DATA => $scalars->{$k}
+		};
+		$typedefs{$k}->{DATA}->{TYPE} = "SCALAR";
+		$typedefs{$k}->{DATA}->{NAME} = $k;
+	}
+}
+
+my $aliases = {
+	"DWORD" => "uint32",
+	"int" => "int32",
+	"WORD" => "uint16",
+	"char" => "uint8",
+	"long" => "int32",
+	"short" => "int16",
+	"HYPER_T" => "hyper",
+	"HRESULT" => "COMRESULT",
+};
+
+sub RegisterAliases()
+{
+	foreach my $k (keys %{$aliases}) {
+		$typedefs{$k} = $typedefs{$aliases->{$k}};
+	}
+}
+
+sub enum_type_fn($)
+{
+	my $enum = shift;
+	if (has_property($enum->{PARENT}, "enum8bit")) {
+		return "uint8";
+	} elsif (has_property($enum->{PARENT}, "v1_enum")) {
+		return "uint32";
+	}
+	return "uint16";
+}
+
+sub bitmap_type_fn($)
+{
+	my $bitmap = shift;
+
+	if (has_property($bitmap, "bitmap8bit")) {
+		return "uint8";
+	} elsif (has_property($bitmap, "bitmap16bit")) {
+		return "uint16";
+	} elsif (has_property($bitmap, "bitmap64bit")) {
+		return "hyper";
+	}
+	return "uint32";
+}
+
+sub mapType($)
+{
+	my $t = shift;
+	die("Undef passed to mapType") unless defined($t);
+	my $dt;
+
+	unless ($dt or ($dt = getType($t))) {
+		# Best guess
+		return "struct $t";
+	}
+	return mapScalarType($t) if ($dt->{DATA}->{TYPE} eq "SCALAR");
+	return "enum $dt->{NAME}" if ($dt->{DATA}->{TYPE} eq "ENUM");
+	return "struct $dt->{NAME}" if ($dt->{DATA}->{TYPE} eq "STRUCT");
+	return "struct $dt->{NAME}" if ($dt->{DATA}->{TYPE} eq "INTERFACE");
+	return "union $dt->{NAME}" if ($dt->{DATA}->{TYPE} eq "UNION");
+
+	if ($dt->{DATA}->{TYPE} eq "BITMAP") {
+		return mapScalarType(bitmap_type_fn($dt->{DATA}));
+	}
+
+	die("Unknown type $dt->{DATA}->{TYPE}");
+}
+
+sub LoadIdl($)
+{
+	my $idl = shift;
+
+	foreach my $x (@{$idl}) {
+		next if $x->{TYPE} ne "INTERFACE";
+
+		# DCOM interfaces can be types as well
+		addType({
+			NAME => $x->{NAME},
+			TYPE => "TYPEDEF",
+			DATA => $x
+			}) if (has_property($x, "object"));
+
+		foreach my $y (@{$x->{DATA}}) {
+			addType($y) if (
+				$y->{TYPE} eq "TYPEDEF" 
+			     or $y->{TYPE} eq "DECLARE");
+		}
+	}
+}
+
+RegisterScalars();
+RegisterAliases();
+
+1;
diff --git a/source4/pidl/lib/Parse/Pidl/Util.pm b/source4/pidl/lib/Parse/Pidl/Util.pm
new file mode 100644
index 0000000000..8854be9d74
--- /dev/null
+++ b/source4/pidl/lib/Parse/Pidl/Util.pm
@@ -0,0 +1,149 @@
+###################################################
+# utility functions to support pidl
+# Copyright tridge@samba.org 2000
+# released under the GNU GPL
+package Parse::Pidl::Util;
+
+require Exporter;
+@ISA = qw(Exporter);
+@EXPORT = qw(has_property property_matches ParseExpr is_constant);
+
+use strict;
+
+#####################################################################
+# flatten an array of arrays into a single array
+sub FlattenArray2($) 
+{ 
+    my $a = shift;
+    my @b;
+    for my $d (@{$a}) {
+	for my $d1 (@{$d}) {
+	    push(@b, $d1);
+	}
+    }
+    return \@b;
+}
+
+#####################################################################
+# flatten an array of arrays into a single array
+sub FlattenArray($) 
+{ 
+    my $a = shift;
+    my @b;
+    for my $d (@{$a}) {
+	for my $d1 (@{$d}) {
+	    push(@b, $d1);
+	}
+    }
+    return \@b;
+}
+
+#####################################################################
+# flatten an array of hashes into a single hash
+sub FlattenHash($) 
+{ 
+    my $a = shift;
+    my %b;
+    for my $d (@{$a}) {
+	for my $k (keys %{$d}) {
+	    $b{$k} = $d->{$k};
+	}
+    }
+    return \%b;
+}
+
+#####################################################################
+# a dumper wrapper to prevent dependence on the Data::Dumper module
+# unless we actually need it
+sub MyDumper($)
+{
+	require Data::Dumper;
+	my $s = shift;
+	return Data::Dumper::Dumper($s);
+}
+
+#####################################################################
+# see if a pidl property list contains a given property
+sub has_property($$)
+{
+	my($e) = shift;
+	my($p) = shift;
+
+	if (!defined $e->{PROPERTIES}) {
+		return undef;
+	}
+
+	return $e->{PROPERTIES}->{$p};
+}
+
+#####################################################################
+# see if a pidl property matches a value
+sub property_matches($$$)
+{
+	my($e) = shift;
+	my($p) = shift;
+	my($v) = shift;
+
+	if (!defined has_property($e, $p)) {
+		return undef;
+	}
+
+	if ($e->{PROPERTIES}->{$p} =~ /$v/) {
+		return 1;
+	}
+
+	return undef;
+}
+
+# return 1 if the string is a C constant
+sub is_constant($)
+{
+	my $s = shift;
+	if (defined $s && $s =~ /^\d/) {
+		return 1;
+	}
+	return 0;
+}
+
+# return a "" quoted string, unless already quoted
+sub make_str($)
+{
+	my $str = shift;
+	if (substr($str, 0, 1) eq "\"") {
+		return $str;
+	}
+	return "\"" . $str . "\"";
+}
+
+# a hack to build on platforms that don't like negative enum values
+my $useUintEnums = 0;
+sub setUseUintEnums($)
+{
+	$useUintEnums = shift;
+}
+sub useUintEnums()
+{
+	return $useUintEnums;
+}
+
+sub ParseExpr($$)
+{
+	my($expr,$varlist) = @_;
+
+	die("Undefined value in ParseExpr") if not defined($expr);
+
+	my @tokens = split /((?:[A-Za-z_])(?:(?:(?:[A-Za-z0-9_.])|(?:->))+))/, $expr;
+	my $ret = "";
+
+	foreach my $t (@tokens) {
+		if (defined($varlist->{$t})) {
+			$ret .= $varlist->{$t};
+		} else {
+			$ret .= $t;
+		}
+	}
+
+	return $ret;
+}
+
+1;