r8264: - Use standard perl package structure for pidl.

- Only "use" pidl modules in the main executable when necessary

Try 'make install' in build/pidl to install the package (should work stand-alone).
(This used to be commit c620095692122a65ae1c5d85ca20468d4de93c54)

11 files changed, 4768 insertions, 0 deletions

diff --git a/source4/build/pidl/Parse/Pidl/Samba/COM/Header.pm b/source4/build/pidl/Parse/Pidl/Samba/COM/Header.pm
new file mode 100644
index 0000000000..4f5e0d68ad
--- /dev/null
+++ b/source4/build/pidl/Parse/Pidl/Samba/COM/Header.pm
@@ -0,0 +1,138 @@
+# COM Header generation
+# (C) 2005 Jelmer Vernooij <jelmer@samba.org>
+
+package Parse::Pidl::Samba::COM::Header;
+
+use Parse::Pidl::Typelist;
+
+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 (Parse::Pidl::Util::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" && Parse::Pidl::Util::has_property($x, "object")) {
+			$res.=ParseInterface($x);
+		} 
+
+		if ($x->{TYPE} eq "COCLASS") {
+			$res.=ParseCoClass($x);
+		}
+	}
+
+	return $res;
+}
+
+1;
diff --git a/source4/build/pidl/Parse/Pidl/Samba/COM/Proxy.pm b/source4/build/pidl/Parse/Pidl/Samba/COM/Proxy.pm
new file mode 100644
index 0000000000..f4c23e1d9b
--- /dev/null
+++ b/source4/build/pidl/Parse/Pidl/Samba/COM/Proxy.pm
@@ -0,0 +1,211 @@
+###################################################
+# 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 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 (Parse::Pidl::Util::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 (Parse::Pidl::Util::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 Parse::Pidl::Util::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 Parse::Pidl::Util::has_property($x, "local");
+		next unless Parse::Pidl::Util::has_property($x, "object");
+
+		$res .= ParseInterface($x);
+	}
+
+	return $res;
+}
+
+1;
diff --git a/source4/build/pidl/Parse/Pidl/Samba/COM/Stub.pm b/source4/build/pidl/Parse/Pidl/Samba/COM/Stub.pm
new file mode 100644
index 0000000000..a06671e76d
--- /dev/null
+++ b/source4/build/pidl/Parse/Pidl/Samba/COM/Stub.pm
@@ -0,0 +1,323 @@
+###################################################
+# 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 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 Parse::Pidl::Util::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/build/pidl/Parse/Pidl/Samba/EJS.pm b/source4/build/pidl/Parse/Pidl/Samba/EJS.pm
new file mode 100644
index 0000000000..72f280add0
--- /dev/null
+++ b/source4/build/pidl/Parse/Pidl/Samba/EJS.pm
@@ -0,0 +1,734 @@
+###################################################
+# 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;
+
+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 (Parse::Pidl::Util::has_property($fn, "public"));
+	return "static ";
+}
+
+###########################
+# pull a scalar element
+sub EjsPullScalar($$$$$)
+{
+	my ($e, $l, $var, $name, $env) = @_;
+
+	return if (Parse::Pidl::Util::has_property($e, "value"));
+
+	$var = get_pointer_to($var);
+	# have to handle strings specially :(
+	if ($e->{TYPE} eq "string") {
+		$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 $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);
+	}
+	my $avar = $var . "[i]";
+	pidl "{";
+	indent;
+	pidl "uint32_t i;";
+	if (!$l->{IS_FIXED}) {
+		pidl "EJS_ALLOC_N(ejs, $var, $length);";
+	}
+	pidl "for (i=0;i<$length;i++) {";
+	indent;
+	pidl "char *id = talloc_asprintf(ejs, \"%s.%u\", $name, i);";
+	EjsPullElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $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 (Parse::Pidl::Util::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 "}";
+}
+
+###########################
+# pull a enum
+sub EjsEnumPull($$)
+{
+	my $name = shift;
+	my $d = shift;
+	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 (Parse::Pidl::Util::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\"));";
+
+	foreach my $e (@{$d->{ELEMENTS}}) {
+		next unless (grep(/in/, @{$e->{DIRECTION}}));
+		EjsPullElementTop($e, $env);
+	}
+
+	pidl "return NT_STATUS_OK;";
+	deindent;
+	pidl "}\n";
+}
+
+
+###########################
+# push a scalar element
+sub EjsPushScalar($$$$$)
+{
+	my ($e, $l, $var, $name, $env) = @_;
+	$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 $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);
+	}
+	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, Parse::Pidl::NDR::GetNextLevel($e, $l), $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 (Parse::Pidl::Util::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;
+	my $v = 0;
+	# put the enum elements in the constants array
+	foreach my $e (@{$d->{ELEMENTS}}) {
+		my $el = $e;
+		chomp $el;
+		if ($el =~ /^(.*)=\s*(.*)\s*$/) {
+			$el = $1;
+			$v = $2;
+		}
+		$constants{$el} = $v;
+		$v++;
+	}
+	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 (Parse::Pidl::Util::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);
+	}
+
+	pidl "return NT_STATUS_OK;";
+	deindent;
+	pidl "}\n";
+}
+
+
+#################################
+# generate a ejs mapping function
+sub EjsFunction($)
+{
+	my $d = shift;
+	my $name = $d->{NAME};
+
+	pidl "static int ejs_$name(int eid, int argc, struct MprVar **argv)";
+	pidl "{";
+	indent;
+	pidl "return ejs_rpc_call(eid, argc, argv, \"$name\", (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) = shift;
+	my @fns = ();
+	my $name = $interface->{NAME};
+
+	%constants = ();
+
+	foreach my $d (@{$interface->{TYPEDEFS}}) {
+		EjsTypedefPush($d);
+		EjsTypedefPull($d);
+	}
+
+	foreach my $d (@{$interface->{FUNCTIONS}}) {
+		next if not defined($d->{OPNUM});
+		
+		EjsPullFunction($d);
+		EjsPushFunction($d);
+		EjsFunction($d);
+
+		push (@fns, $d->{NAME});
+	}
+
+	foreach my $d (@{$interface->{CONSTS}}) {
+		EjsConst($d);
+	}
+
+	pidl "void setup_ejs_$name(void)";
+	pidl "{";
+	indent;
+	foreach (@fns) {
+		pidl "ejsDefineCFunction(-1, \"dcerpc_$_\", ejs_$_, NULL, MPR_VAR_SCRIPT_HANDLE);";
+	}
+	deindent;
+	pidl "}\n";
+
+	pidl "void setup_ejs_constants_$name(int eid)";
+	pidl "{";
+	indent;
+	foreach my $v (keys %constants) {
+		my $value = $constants{$v};
+		if (substr($value, 0, 1) eq "\"") {
+			pidl "ejs_set_constant_string(eid, \"$v\", $value);";
+		} else {
+			pidl "ejs_set_constant_int(eid, \"$v\", $value);";
+		}
+	}
+	deindent;
+	pidl "}\n";
+
+	pidl "NTSTATUS ejs_init_$name(void)";
+	pidl "{";
+	indent;
+	pidl "return smbcalls_register_ejs(\"$name\", setup_ejs_$name, setup_ejs_constants_$name);";
+	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/ejs/ejs.h\"
+#include \"scripting/ejs/ejsrpc.h\"
+#include \"librpc/gen_ndr/ndr_misc_ejs.h\"
+#include \"$hdr\"
+#include \"$ejs_hdr\"
+
+";
+    foreach my $x (@{$ndr}) {
+	    if ($x->{TYPE} eq "INTERFACE") {
+		    ($x->{TYPE} eq "INTERFACE") && EjsInterface($x);
+	    }
+    }
+
+    return $res;
+}
+
+1;
diff --git a/source4/build/pidl/Parse/Pidl/Samba/EJSHeader.pm b/source4/build/pidl/Parse/Pidl/Samba/EJSHeader.pm
new file mode 100644
index 0000000000..e2472545ef
--- /dev/null
+++ b/source4/build/pidl/Parse/Pidl/Samba/EJSHeader.pm
@@ -0,0 +1,75 @@
+###################################################
+# 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;
+
+my($res);
+
+sub pidl ($)
+{
+	$res .= shift;
+}
+
+#####################################################################
+# prototype a typedef
+sub HeaderTypedefProto($)
+{
+	my $d = shift;
+	my $name = $d->{NAME};
+	
+	return unless Parse::Pidl::Util::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/build/pidl/Parse/Pidl/Samba/NDR/Client.pm b/source4/build/pidl/Parse/Pidl/Samba/NDR/Client.pm
new file mode 100644
index 0000000000..126dbc3ba9
--- /dev/null
+++ b/source4/build/pidl/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/build/pidl/Parse/Pidl/Samba/NDR/Header.pm b/source4/build/pidl/Parse/Pidl/Samba/NDR/Header.pm
new file mode 100644
index 0000000000..d15e9bfbcb
--- /dev/null
+++ b/source4/build/pidl/Parse/Pidl/Samba/NDR/Header.pm
@@ -0,0 +1,472 @@
+###################################################
+# 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;
+use Parse::Pidl::Samba::NDR::Parser;
+
+my($res);
+my($tab_depth);
+
+sub pidl ($)
+{
+	$res .= shift;
+}
+
+sub tabs()
+{
+	for (my($i)=0; $i < $tab_depth; $i++) {
+		pidl "\t";
+	}
+}
+
+#####################################################################
+# 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 $prefix = "";
+	my $postfix = "";
+	foreach my $l (@{$element->{LEVELS}}) 
+	{
+		if (($l->{TYPE} eq "POINTER")) {
+			my $nl = Parse::Pidl::NDR::GetNextLevel($element, $l);
+			$nl = Parse::Pidl::NDR::GetNextLevel($element, $nl) if ($nl->{TYPE} eq "SUBCONTEXT");
+			next if ($nl->{TYPE} eq "DATA" and Parse::Pidl::Typelist::scalar_is_reference($nl->{DATA_TYPE}));
+			$prefix .= "*";
+		} elsif ($l->{TYPE} eq "ARRAY") {
+			my $pl = Parse::Pidl::NDR::GetPrevLevel($element, $l);
+			next if ($pl and $pl->{TYPE} eq "POINTER");
+
+			if ($l->{IS_FIXED}) { 
+				$postfix .= "[$l->{SIZE_IS}]"; 
+			} else {
+				$prefix .= "*";
+			}
+		} elsif ($l->{TYPE} eq "DATA") {
+    			pidl "$prefix$element->{NAME}$postfix";
+		}
+	}
+
+	if (defined $element->{ARRAY_LEN}[0] && Parse::Pidl::Util::is_constant($element->{ARRAY_LEN}[0])) {
+		pidl "[$element->{ARRAY_LEN}[0]]";
+	}
+	pidl ";";
+	if (defined $element->{PROPERTIES}) {
+		HeaderProperties($element->{PROPERTIES}, ["in", "out"]);
+	}
+	pidl "\n";
+}
+
+#####################################################################
+# parse a struct
+sub HeaderStruct($$)
+{
+    my($struct,$name) = @_;
+    pidl "\nstruct $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 "\tchar _empty_;\n";
+    }
+    $tab_depth--;
+    pidl "}";
+	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 "\nenum $name {\n";
+	$tab_depth++;
+	foreach my $e (@{$enum->{ELEMENTS}}) {
+ 	    unless ($first) { pidl ",\n"; }
+	    $first = 0;
+	    tabs();
+	    pidl $e;
+	}
+	pidl "\n";
+	$tab_depth--;
+	pidl "}";
+    } else {
+        my $count = 0;
+	pidl "\nenum $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 "\n/* bitmap $name */\n";
+
+    foreach my $e (@{$bitmap->{ELEMENTS}})
+    {
+	    pidl "#define $e\n";
+    }
+
+    pidl "\n";
+}
+
+#####################################################################
+# parse a union
+sub HeaderUnion($$)
+{
+	my($union,$name) = @_;
+	my %done = ();
+
+	pidl "\nunion $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 (Parse::Pidl::Util::has_property($e, "charset")) {
+		pidl "const char";
+	} else {
+		pidl Parse::Pidl::Typelist::mapType($e->{TYPE});
+	}
+}
+
+#####################################################################
+# parse a typedef
+sub HeaderTypedef($)
+{
+    my($typedef) = shift;
+    HeaderType($typedef, $typedef->{DATA}, $typedef->{NAME});
+    pidl ";\n" unless ($typedef->{DATA}->{TYPE} eq "BITMAP");
+}
+
+#####################################################################
+# prototype a typedef
+sub HeaderTypedefProto($)
+{
+    my($d) = shift;
+
+	my $tf = Parse::Pidl::Samba::NDR::Parser::get_typefamily($d->{DATA}{TYPE});
+
+    if (Parse::Pidl::Util::has_property($d, "gensize")) {
+		my $size_args = $tf->{SIZE_FN_ARGS}->($d);
+		pidl "size_t ndr_size_$d->{NAME}($size_args);\n";
+    }
+
+    return unless Parse::Pidl::Util::has_property($d, "public");
+
+	my $pull_args = $tf->{PULL_FN_ARGS}->($d);
+	my $push_args = $tf->{PUSH_FN_ARGS}->($d);
+	my $print_args = $tf->{PRINT_FN_ARGS}->($d);
+	unless (Parse::Pidl::Util::has_property($d, "nopush")) {
+		pidl "NTSTATUS ndr_push_$d->{NAME}($push_args);\n";
+	}
+	unless (Parse::Pidl::Util::has_property($d, "nopull")) {
+	    pidl "NTSTATUS ndr_pull_$d->{NAME}($pull_args);\n";
+	}
+    unless (Parse::Pidl::Util::has_property($d, "noprint")) {
+	    pidl "void ndr_print_$d->{NAME}($print_args);\n";
+    }
+}
+
+#####################################################################
+# 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 (Parse::Pidl::Util::has_property($e, $prop)) {
+		    HeaderElement($e);
+	    }
+    }
+}
+
+#####################################################################
+# determine if we need an "in" or "out" section
+sub HeaderFunctionInOut_needed($$)
+{
+    my($fn,$prop) = @_;
+
+    if ($prop eq "out" && $fn->{RETURN_TYPE}) {
+	    return 1;
+    }
+
+    foreach my $e (@{$fn->{ELEMENTS}}) {
+	    if (Parse::Pidl::Util::has_property($e, $prop)) {
+		    return 1;
+	    }
+    }
+
+    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")) {
+	    tabs();
+	    pidl "struct {\n";
+	    $tab_depth++;
+	    HeaderFunctionInOut($fn, "in");
+	    $tab_depth--;
+	    tabs();
+	    pidl "} in;\n\n";
+	    $needed++;
+    }
+
+    if (HeaderFunctionInOut_needed($fn, "out")) {
+	    tabs();
+	    pidl "struct {\n";
+	    $tab_depth++;
+	    HeaderFunctionInOut($fn, "out");
+	    if ($fn->{RETURN_TYPE}) {
+		    tabs();
+		    pidl Parse::Pidl::Typelist::mapType($fn->{RETURN_TYPE}) . " result;\n";
+	    }
+	    $tab_depth--;
+	    tabs();
+	    pidl "} out;\n\n";
+	    $needed++;
+    }
+
+    if (! $needed) {
+	    # sigh - some compilers don't like empty structures
+	    tabs();
+	    pidl "int _dummy_element;\n";
+    }
+
+    $tab_depth--;
+    pidl "};\n\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";
+
+	if (defined($fn->{OPNUM})) {
+		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 Parse::Pidl::Util::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;
+
+	my $count = 0;
+
+	pidl "#ifndef _HEADER_NDR_$interface->{NAME}\n";
+	pidl "#define _HEADER_NDR_$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\.h\"\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->{FUNCTIONS}}) {
+		next if not defined($d->{OPNUM});
+		my $u_name = uc $d->{NAME};
+		pidl "#define DCERPC_$u_name (";
+	
+		if (defined($interface->{BASE})) {
+			pidl "DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT + ";
+		}
+
+		if ($d->{OPNUM} != $count) {
+			die ("Function ".$d->{NAME}." has: wrong opnum [".$d->{OPNUM}."] should be [".$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->{CONSTS}}) {
+		HeaderConst($d);
+	}
+
+	foreach my $d (@{$interface->{TYPEDEFS}}) {
+		HeaderTypedef($d);
+		HeaderTypedefProto($d);
+	}
+
+	foreach my $d (@{$interface->{FUNCTIONS}}) {
+		HeaderFunction($d);
+		HeaderFnProto($interface, $d);
+	}
+
+	pidl "#endif /* _HEADER_NDR_$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/build/pidl/Parse/Pidl/Samba/NDR/Parser.pm b/source4/build/pidl/Parse/Pidl/Samba/NDR/Parser.pm
new file mode 100644
index 0000000000..21e1449067
--- /dev/null
+++ b/source4/build/pidl/Parse/Pidl/Samba/NDR/Parser.pm
@@ -0,0 +1,2230 @@
+###################################################
+# 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;
+use Parse::Pidl::NDR;
+
+# 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 is_scalar_array($$)
+{
+	my ($e,$l) = @_;
+
+	return 0 if ($l->{TYPE} ne "ARRAY");
+
+	my $nl = Parse::Pidl::NDR::GetNextLevel($e,$l);
+	return (($nl->{TYPE} eq "DATA") and 
+	        (Parse::Pidl::Typelist::is_scalar($nl->{DATA_TYPE})));
+}
+
+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 $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);
+}
+
+#####################################################################
+# check that a variable we get from ParseExpr isn't a null pointer
+sub check_null_pointer($)
+{
+	my $size = shift;
+	if ($size =~ /^\*/) {
+		my $size2 = substr($size, 1);
+		pidl "if ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;";
+	}
+}
+
+#####################################################################
+# check that a variable we get from ParseExpr isn't a null pointer
+# void return varient
+sub check_null_pointer_void($)
+{
+	my $size = shift;
+	if ($size =~ /^\*/) {
+		my $size2 = substr($size, 1);
+		pidl "if ($size2 == NULL) return;";
+	}
+}
+
+#####################################################################
+# work out is a parse function should be declared static or not
+sub fn_prefix($)
+{
+	my $fn = shift;
+
+	return "" if (Parse::Pidl::Util::has_property($fn, "public"));
+	return "static ";
+}
+
+###################################################################
+# setup any special flags for an element or structure
+sub start_flags($)
+{
+	my $e = shift;
+	my $flags = Parse::Pidl::Util::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 = Parse::Pidl::Util::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) = @_;
+
+	if ($l->{IS_CONFORMANT} or $l->{IS_VARYING}) {
+		$var_name = get_pointer_to($var_name);
+	}
+
+	my $size;
+	my $length;
+
+	if ($l->{IS_ZERO_TERMINATED}) {
+		$size = $length = "ndr_string_length($var_name, sizeof(*$var_name))";
+	} else {
+		$size = Parse::Pidl::Util::ParseExpr($l->{SIZE_IS}, $env);
+		$length = Parse::Pidl::Util::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));";
+		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) = @_;
+
+	if ($l->{IS_CONFORMANT} or $l->{IS_VARYING}) {
+		$var_name = get_pointer_to($var_name);
+	}
+
+	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 = Parse::Pidl::Util::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 = Parse::Pidl::Util::ParseExpr($l->{SIZE_IS}, $env);
+		check_null_pointer($size);
+		pidl "NDR_CHECK(ndr_check_array_size(ndr, (void*)" . get_pointer_to($var_name) . ", $size));";
+	}
+
+	if ($l->{IS_VARYING} and not $l->{IS_ZERO_TERMINATED}) {
+		my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env);
+		check_null_pointer($length);
+		pidl "NDR_CHECK(ndr_check_array_length(ndr, (void*)" . get_pointer_to($var_name) . ", $length));";
+	}
+
+	if (!$l->{IS_FIXED}) {
+		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 Parse::Pidl::Util::ParseExpr($clen, $env);
+}
+
+sub compression_dlen($$$)
+{
+	my ($e,$l,$env) = @_;
+	my $compression = $l->{COMPRESSION};
+	my ($alg, $clen, $dlen) = split(/ /, $compression);
+
+	return Parse::Pidl::Util::ParseExpr($dlen, $env);
+}
+
+sub ParseCompressionPushStart($$$)
+{
+	my ($e,$l,$ndr) = @_;
+	my $comndr = "$ndr\_compressed";
+
+	pidl "{";
+	indent;
+	pidl "struct ndr_push *$comndr;";
+	pidl "";
+	pidl "$comndr = ndr_push_init_ctx($ndr);";
+	pidl "if (!$comndr) return NT_STATUS_NO_MEMORY;";
+	pidl "$comndr->flags = $ndr->flags;";
+	pidl "";
+	
+	return $comndr;
+}
+
+sub ParseCompressionPushEnd($$$)
+{
+	my ($e,$l,$ndr) = @_;
+	my $comndr = "$ndr\_compressed";
+	my $alg = compression_alg($e, $l);
+
+	pidl "NDR_CHECK(ndr_push_compression($ndr, $comndr, $alg));";
+	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_ALLOC($ndr, $comndr);";
+	pidl "NDR_CHECK(ndr_pull_compression($ndr, $comndr, $alg, $dlen));";
+
+	return $comndr;
+}
+
+sub ParseCompressionPullEnd($$$)
+{
+	my ($e,$l,$ndr) = @_;
+	my $comndr = "$ndr\_compressed";
+
+	deindent;
+	pidl "}";
+}
+
+sub ParseObfuscationPushStart($$)
+{
+	my ($e,$ndr) = @_;
+
+	# nothing to do here
+
+	return $ndr;
+}
+
+sub ParseObfuscationPushEnd($$)
+{
+	my ($e,$ndr) = @_;
+	my $obfuscation = Parse::Pidl::Util::has_property($e, "obfuscation");
+
+	pidl "NDR_CHECK(ndr_push_obfuscation($ndr, $obfuscation));";
+}
+
+sub ParseObfuscationPullStart($$)
+{
+	my ($e,$ndr) = @_;
+	my $obfuscation = Parse::Pidl::Util::has_property($e, "obfuscation");
+
+	pidl "NDR_CHECK(ndr_pull_obfuscation($ndr, $obfuscation));";
+
+	return $ndr;
+}
+
+sub ParseObfuscationPullEnd($$)
+{
+	my ($e,$ndr) = @_;
+
+	# nothing to do here
+}
+
+sub ParseSubcontextPushStart($$$$$)
+{
+	my ($e,$l,$ndr,$var_name,$ndr_flags) = @_;
+	my $retndr = "_ndr_$e->{NAME}";
+
+	pidl "{";
+	indent;
+	pidl "struct ndr_push *$retndr;";
+	pidl "";
+	pidl "$retndr = ndr_push_init_ctx($ndr);";
+	pidl "if (!$retndr) return NT_STATUS_NO_MEMORY;";
+	pidl "$retndr->flags = $ndr->flags;";
+	pidl "";
+
+	if (defined $l->{COMPRESSION}) {
+		$retndr = ParseCompressionPushStart($e, $l, $retndr);
+	}
+
+	if (defined $l->{OBFUSCATION}) {
+		$retndr = ParseObfuscationPushStart($e, $retndr);
+	}
+
+	return $retndr;
+}
+
+sub ParseSubcontextPushEnd($$$$)
+{
+	my ($e,$l,$ndr_flags,$env) = @_;
+	my $ndr = "_ndr_$e->{NAME}";
+	my $subcontext_size = Parse::Pidl::Util::ParseExpr($l->{SUBCONTEXT_SIZE},$env);
+
+	if (defined $l->{COMPRESSION}) {
+		ParseCompressionPushEnd($e, $l, $ndr);
+	}
+
+	if (defined $l->{OBFUSCATION}) {
+		ParseObfuscationPushEnd($e, $ndr);
+	}
+
+	pidl "NDR_CHECK(ndr_push_subcontext_header(ndr, $l->{HEADER_SIZE}, $subcontext_size, $ndr));";
+	pidl "NDR_CHECK(ndr_push_bytes(ndr, $ndr->data, $ndr->offset));";
+	deindent;
+	pidl "}";
+}
+
+sub ParseSubcontextPullStart($$$$$$)
+{
+	my ($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_;
+	my $retndr = "_ndr_$e->{NAME}";
+	my $subcontext_size = Parse::Pidl::Util::ParseExpr($l->{SUBCONTEXT_SIZE},$env);
+
+	pidl "{";
+	indent;
+	pidl "struct ndr_pull *$retndr;";
+	pidl "NDR_ALLOC(ndr, $retndr);";
+	pidl "NDR_CHECK(ndr_pull_subcontext_header($ndr, $l->{HEADER_SIZE}, $subcontext_size, $retndr));"; 
+
+	if (defined $l->{COMPRESSION}) {
+		$retndr = ParseCompressionPullStart($e, $l, $retndr, $env);
+	}
+
+	if (defined $l->{OBFUSCATION}) {
+		$retndr = ParseObfuscationPullStart($e, $retndr);
+	}
+	
+	return ($retndr,$var_name);
+}
+
+sub ParseSubcontextPullEnd($$$)
+{
+	my ($e,$l,$env) = @_;
+	my $ndr = "_ndr_$e->{NAME}";
+
+	if (defined $l->{COMPRESSION}) {
+		ParseCompressionPullEnd($e, $l, $ndr);
+	}
+
+	if (defined $l->{OBFUSCATION}) {
+		ParseObfuscationPullEnd($e, $ndr);
+	}
+
+	my $advance;
+	if (defined($l->{SUBCONTEXT_SIZE}) and ($l->{SUBCONTEXT_SIZE} ne "-1")) {
+		$advance = Parse::Pidl::Util::ParseExpr($l->{SUBCONTEXT_SIZE},$env);
+	} elsif ($l->{HEADER_SIZE}) {
+		$advance = "$ndr->data_size";
+	} else {
+		$advance = "$ndr->offset";
+	}
+	pidl "NDR_CHECK(ndr_pull_advance(ndr, $advance));";
+	deindent;
+	pidl "}";
+}
+
+sub ParseElementPushLevel
+{
+	my ($e,$l,$ndr,$var_name,$env,$primitives,$deferred) = @_;
+
+	my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred);
+
+	if (defined($ndr_flags)) {
+		if ($l->{TYPE} eq "SUBCONTEXT") {
+			$ndr = ParseSubcontextPushStart($e, $l, $ndr, $var_name, $ndr_flags);
+			ParseElementPushLevel($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 1);
+			ParseSubcontextPushEnd($e, $l, $ndr_flags, $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); 
+			# Allow speedups for arrays of scalar types
+			if (is_scalar_array($e,$l)) {
+				if ($l->{IS_CONFORMANT} or $l->{IS_VARYING}) {
+					$var_name = get_pointer_to($var_name);
+				}
+
+				my $nl = Parse::Pidl::NDR::GetNextLevel($e, $l);
+
+				if (Parse::Pidl::Util::has_property($e, "charset")) {
+					pidl "NDR_CHECK(ndr_push_charset($ndr, $ndr_flags, $var_name, $length, sizeof(" . Parse::Pidl::Typelist::mapType($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));";
+				} else {
+					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, Parse::Pidl::NDR::GetNextLevel($e, $l), $ndr, $var_name, $env, $primitives, $deferred);
+
+		if ($l->{POINTER_TYPE} ne "ref") {
+			deindent;
+			pidl "}";
+		}
+	} elsif ($l->{TYPE} eq "ARRAY" and not is_scalar_array($e,$l)) {
+		my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env);
+		my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}";
+
+		$var_name = $var_name . "[$counter]";
+
+		if ($l->{IS_VARYING} or $l->{IS_CONFORMANT}) {
+			$var_name = get_pointer_to($var_name);
+		}
+
+		if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) {
+			pidl "for ($counter = 0; $counter < $length; $counter++) {";
+			indent;
+			ParseElementPushLevel($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 0);
+			deindent;
+			pidl "}";
+		}
+
+		if ($deferred and Parse::Pidl::NDR::ContainsDeferred($e, $l)) {
+			pidl "for ($counter = 0; $counter < $length; $counter++) {";
+			indent;
+			ParseElementPushLevel($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $ndr, $var_name, $env, 0, 1);
+			deindent;
+			pidl "}";
+		}	
+	} elsif ($l->{TYPE} eq "SWITCH") {
+		ParseElementPushLevel($e, Parse::Pidl::NDR::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 Parse::Pidl::NDR::ContainsDeferred($e, $e->{LEVELS}[0]));
+
+	start_flags($e);
+
+	if (my $value = Parse::Pidl::Util::has_property($e, "value")) {
+		$var_name = Parse::Pidl::Util::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 (Parse::Pidl::Util::has_property($e, "noprint"));
+
+	if (my $value = Parse::Pidl::Util::has_property($e, "value")) {
+		$var_name = "(ndr->flags & LIBNDR_PRINT_SET_VALUES)?" . Parse::Pidl::Util::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 (is_scalar_array($e, $l) and ($l->{IS_CONFORMANT} or $l->{IS_VARYING})){ 
+				$var_name = get_pointer_to($var_name); 
+			}
+			
+			if ($l->{IS_ZERO_TERMINATED}) {
+				$length = "ndr_string_length($var_name, sizeof(*$var_name))";
+			} else {
+				$length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env);
+			}
+
+			if (is_scalar_array($e, $l)) {
+				if (Parse::Pidl::Util::has_property($e, "charset")) {
+					pidl "ndr_print_string(ndr, \"$e->{NAME}\", $var_name);";
+				} else {
+					my $nl = Parse::Pidl::NDR::GetNextLevel($e, $l);
+					pidl "ndr_print_array_$nl->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name, $length);";
+				} 
+				last;
+			}
+
+			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]";
+
+			if ($l->{IS_VARYING} or $l->{IS_CONFORMANT}){ $var_name = get_pointer_to($var_name); }
+
+		} 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 = Parse::Pidl::Util::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_scalar_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 = Parse::Pidl::Util::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 = Parse::Pidl::Util::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 = Parse::Pidl::Util::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 ParseElementPullLevel
+{
+	my($e,$l,$ndr,$var_name,$env,$primitives,$deferred) = @_;
+
+	my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred);
+
+	# Only pull something if there's actually something to be pulled
+	if (defined($ndr_flags)) {
+		if ($l->{TYPE} eq "SUBCONTEXT") {
+			($ndr,$var_name) = ParseSubcontextPullStart($e, $l, $ndr, $var_name, $ndr_flags, $env);
+			ParseElementPullLevel($e,Parse::Pidl::NDR::GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 1);
+			ParseSubcontextPullEnd($e, $l, $env);
+		} elsif ($l->{TYPE} eq "ARRAY") {
+			my $length = ParseArrayPullHeader($e, $l, $ndr, $var_name, $env); 
+
+			# Speed things up a little - special array pull functions
+			# for scalars
+			if (is_scalar_array($e, $l)) {
+				if ($l->{IS_VARYING} or $l->{IS_CONFORMANT}) {
+					$var_name = get_pointer_to($var_name);
+				}
+				my $nl = Parse::Pidl::NDR::GetNextLevel($e, $l);
+
+				if (Parse::Pidl::Util::has_property($e, "charset")) {
+					pidl "NDR_CHECK(ndr_pull_charset($ndr, $ndr_flags, ".get_pointer_to($var_name).", $length, sizeof(" . Parse::Pidl::Typelist::mapType($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));";
+				} else {
+					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));";
+			}
+		}
+
+		$var_name = get_value_of($var_name);
+		ParseElementPullLevel($e,Parse::Pidl::NDR::GetNextLevel($e,$l), $ndr, $var_name, $env, $primitives, $deferred);
+
+		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 is_scalar_array($e,$l)) {
+		my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env);
+		my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}";
+
+		$var_name = $var_name . "[$counter]";
+		if ($l->{IS_VARYING} or $l->{IS_CONFORMANT}) {
+			$var_name = get_pointer_to($var_name);
+		}
+
+		if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) {
+			pidl "for ($counter = 0; $counter < $length; $counter++) {";
+			indent;
+			ParseElementPullLevel($e,Parse::Pidl::NDR::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 Parse::Pidl::NDR::ContainsDeferred($e, $l)) {
+			pidl "for ($counter = 0; $counter < $length; $counter++) {";
+			indent;
+			ParseElementPullLevel($e,Parse::Pidl::NDR::GetNextLevel($e,$l), $ndr, $var_name, $env, 0, 1);
+			deindent;
+			pidl "}";
+		}
+	} elsif ($l->{TYPE} eq "SWITCH") {
+		ParseElementPullLevel($e,Parse::Pidl::NDR::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 Parse::Pidl::NDR::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 = Parse::Pidl::NDR::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_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_ALLOC($ndr, $var_name);"; 
+	} else {
+		pidl "NDR_ALLOC_SIZE($ndr, $var_name, 1);"; # FIXME: Yes, this is nasty. We allocate an array twice - once just to indicate that  it's there, then the real allocation...
+	}
+
+	#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 = Parse::Pidl::Util::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) = Parse::Pidl::Typelist::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 ArgsEnumPush($)
+{
+	my $e = shift;
+	return "struct ndr_push *ndr, int ndr_flags, enum $e->{NAME} r";
+}
+
+sub ArgsEnumPrint($)
+{
+	my $e = shift;
+	return "struct ndr_print *ndr, const char *name, enum $e->{NAME} r";
+}
+
+sub ArgsEnumPull($)
+{
+	my $e = shift;
+	return "struct ndr_pull *ndr, int ndr_flags, enum $e->{NAME} *r";
+}
+
+$typefamily{ENUM} = {
+	PUSH_FN_BODY => \&ParseEnumPush,
+	PUSH_FN_ARGS => \&ArgsEnumPush,
+	PULL_FN_BODY => \&ParseEnumPull,
+	PULL_FN_ARGS => \&ArgsEnumPull,
+	PRINT_FN_BODY => \&ParseEnumPrint,
+	PRINT_FN_ARGS => \&ArgsEnumPrint,
+};
+
+#####################################################################
+# 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) = Parse::Pidl::Typelist::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) = Parse::Pidl::Typelist::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) = Parse::Pidl::Typelist::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 ArgsBitmapPush($)
+{
+	my $e = shift;
+	my $type_decl = Parse::Pidl::Typelist::mapType($e->{DATA}->{BASE_TYPE});
+	return "struct ndr_push *ndr, int ndr_flags, $type_decl r";
+}
+
+sub ArgsBitmapPrint($)
+{
+	my $e = shift;
+	my $type_decl = Parse::Pidl::Typelist::mapType($e->{DATA}->{BASE_TYPE});
+	return "struct ndr_print *ndr, const char *name, $type_decl r";
+}
+
+sub ArgsBitmapPull($)
+{
+	my $e = shift;
+	my $type_decl = Parse::Pidl::Typelist::mapType($e->{DATA}->{BASE_TYPE});
+	return "struct ndr_pull *ndr, int ndr_flags, $type_decl *r";
+}
+
+$typefamily{BITMAP} = {
+	PUSH_FN_BODY => \&ParseBitmapPush,
+	PUSH_FN_ARGS => \&ArgsBitmapPush,
+	PULL_FN_BODY => \&ParseBitmapPull,
+	PULL_FN_ARGS => \&ArgsBitmapPull,
+	PRINT_FN_BODY => \&ParseBitmapPrint,
+	PRINT_FN_ARGS => \&ArgsBitmapPrint,
+};
+
+#####################################################################
+# 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 (is_scalar_array($e,$l));
+		if ($l->{TYPE} eq "ARRAY") {
+			pidl "uint32_t cntr_$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);
+	}
+
+	# 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);
+	}	
+
+	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);
+	}
+
+	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 = Parse::Pidl::Util::has_property($t, "flag")) {
+		pidl "flags |= $flags;";
+	}
+	pidl "return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});";
+}
+
+sub ArgsStructPush($)
+{
+	my $e = shift;
+	return "struct ndr_push *ndr, int ndr_flags, const struct $e->{NAME} *r";
+}
+
+sub ArgsStructPrint($)
+{
+	my $e = shift;
+	return "struct ndr_print *ndr, const char *name, const struct $e->{NAME} *r";
+}
+
+sub ArgsStructPull($)
+{
+	my $e = shift;
+	return "struct ndr_pull *ndr, int ndr_flags, struct $e->{NAME} *r";
+}
+
+sub ArgsStructNdrSize($)
+{
+	my $d = shift;
+	return "const struct $d->{NAME} *r, int flags";
+}
+
+$typefamily{STRUCT} = {
+	PUSH_FN_BODY => \&ParseStructPush,
+	PUSH_FN_ARGS => \&ArgsStructPush,
+	PULL_FN_BODY => \&ParseStructPull,
+	PULL_FN_ARGS => \&ArgsStructPull,
+	PRINT_FN_BODY => \&ParseStructPrint,
+	PRINT_FN_ARGS => \&ArgsStructPrint,
+	SIZE_FN_BODY => \&ParseStructNdrSize,
+	SIZE_FN_ARGS => \&ArgsStructNdrSize,
+};
+
+#####################################################################
+# calculate size of ndr struct
+sub ParseUnionNdrSize($)
+{
+	my $t = shift;
+	my $sizevar;
+
+	if (my $flags = Parse::Pidl::Util::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(Parse::Pidl::Typelist::getType($switch_type));
+		}
+		pidl Parse::Pidl::Typelist::mapType($switch_type) . " _level;";
+	}
+
+	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 "}";
+	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 ArgsUnionPush($)
+{
+	my $e = shift;
+	return "struct ndr_push *ndr, int ndr_flags, const union $e->{NAME} *r";
+}
+
+sub ArgsUnionPrint($)
+{
+	my $e = shift;
+	return "struct ndr_print *ndr, const char *name, const union $e->{NAME} *r";
+}
+
+sub ArgsUnionPull($)
+{
+	my $e = shift;
+	return "struct ndr_pull *ndr, int ndr_flags, union $e->{NAME} *r";
+}
+
+sub ArgsUnionNdrSize($)
+{
+	my $d = shift;
+	return "const union $d->{NAME} *r, uint32_t level, int flags";
+}
+
+$typefamily{UNION} = {
+	PUSH_FN_BODY => \&ParseUnionPush,
+	PUSH_FN_ARGS => \&ArgsUnionPush,
+	PULL_FN_BODY => \&ParseUnionPull,
+	PULL_FN_ARGS => \&ArgsUnionPull,
+	PRINT_FN_BODY => \&ParseUnionPrint,
+	PRINT_FN_ARGS => \&ArgsUnionPrint,
+	SIZE_FN_ARGS => \&ArgsUnionNdrSize,
+	SIZE_FN_BODY => \&ParseUnionNdrSize,
+};
+	
+#####################################################################
+# parse a typedef - push side
+sub ParseTypedefPush($)
+{
+	my($e) = shift;
+
+	my $args = $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_ARGS}->($e);
+	pidl fn_prefix($e) . "NTSTATUS ndr_push_$e->{NAME}($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}}->{PULL_FN_ARGS}->($e);
+
+	pidl fn_prefix($e) . "NTSTATUS ndr_pull_$e->{NAME}($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}}->{PRINT_FN_ARGS}->($e);
+
+	pidl "void ndr_print_$e->{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 Parse::Pidl::Util::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 Parse::Pidl::Util::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) = @_;
+
+	return if (Parse::Pidl::Util::has_property($e, "charset"));
+
+	my $var = Parse::Pidl::Util::ParseExpr($e->{NAME}, $env);
+
+	check_null_pointer($size);
+	my $pl = Parse::Pidl::NDR::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_ALLOC_N($ndr, $var, $size);";
+	    pidl "}";
+	} else {
+		pidl "NDR_ALLOC_N($ndr, $var, $size);";
+	}
+
+	if (grep(/in/,@{$e->{DIRECTION}}) and
+	    grep(/out/,@{$e->{DIRECTION}})) {
+		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 Parse::Pidl::Util::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);
+	}
+
+	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 = Parse::Pidl::Util::ParseExpr($e->{LEVELS}[1]->{SIZE_IS}, $env);
+			check_null_pointer($size);
+			
+			pidl "NDR_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_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});";
+			}
+		}
+	}
+
+	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));";
+	}
+
+	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 \"$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 (Parse::Pidl::Util::has_property($t, "public")) {
+		$needed->{"pull_$t->{NAME}"} = not Parse::Pidl::Util::has_property($t, "nopull");
+		$needed->{"push_$t->{NAME}"} = not Parse::Pidl::Util::has_property($t, "nopush");
+		$needed->{"print_$t->{NAME}"} = not Parse::Pidl::Util::has_property($t, "noprint");
+	}
+
+	if ($t->{DATA}->{TYPE} eq "STRUCT" or $t->{DATA}->{TYPE} eq "UNION") {
+		if (Parse::Pidl::Util::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/build/pidl/Parse/Pidl/Samba/NDR/Server.pm b/source4/build/pidl/Parse/Pidl/Samba/NDR/Server.pm
new file mode 100644
index 0000000000..1d63ea0cd1
--- /dev/null
+++ b/source4/build/pidl/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/build/pidl/Parse/Pidl/Samba/SWIG.pm b/source4/build/pidl/Parse/Pidl/Samba/SWIG.pm
new file mode 100644
index 0000000000..409095804f
--- /dev/null
+++ b/source4/build/pidl/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/build/pidl/Parse/Pidl/Samba/Template.pm b/source4/build/pidl/Parse/Pidl/Samba/Template.pm
new file mode 100644
index 0000000000..eb71b6d707
--- /dev/null
+++ b/source4/build/pidl/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;