summaryrefslogtreecommitdiff
path: root/source4/build/pidl/Parse/Pidl/Samba
diff options
context:
space:
mode:
Diffstat (limited to 'source4/build/pidl/Parse/Pidl/Samba')
-rw-r--r--source4/build/pidl/Parse/Pidl/Samba/COM/Header.pm139
-rw-r--r--source4/build/pidl/Parse/Pidl/Samba/COM/Proxy.pm212
-rw-r--r--source4/build/pidl/Parse/Pidl/Samba/COM/Stub.pm324
-rw-r--r--source4/build/pidl/Parse/Pidl/Samba/EJS.pm835
-rw-r--r--source4/build/pidl/Parse/Pidl/Samba/EJSHeader.pm76
-rw-r--r--source4/build/pidl/Parse/Pidl/Samba/Header.pm356
-rw-r--r--source4/build/pidl/Parse/Pidl/Samba/NDR/Client.pm99
-rw-r--r--source4/build/pidl/Parse/Pidl/Samba/NDR/Header.pm166
-rw-r--r--source4/build/pidl/Parse/Pidl/Samba/NDR/Parser.pm2341
-rw-r--r--source4/build/pidl/Parse/Pidl/Samba/NDR/Server.pm322
-rw-r--r--source4/build/pidl/Parse/Pidl/Samba/SWIG.pm76
-rw-r--r--source4/build/pidl/Parse/Pidl/Samba/TDR.pm266
-rw-r--r--source4/build/pidl/Parse/Pidl/Samba/Template.pm88
13 files changed, 0 insertions, 5300 deletions
diff --git a/source4/build/pidl/Parse/Pidl/Samba/COM/Header.pm b/source4/build/pidl/Parse/Pidl/Samba/COM/Header.pm
deleted file mode 100644
index 7b6c4db212..0000000000
--- a/source4/build/pidl/Parse/Pidl/Samba/COM/Header.pm
+++ /dev/null
@@ -1,139 +0,0 @@
-# COM Header generation
-# (C) 2005 Jelmer Vernooij <jelmer@samba.org>
-
-package Parse::Pidl::Samba::COM::Header;
-
-use Parse::Pidl::Typelist;
-use Parse::Pidl::Util qw(has_property);
-
-use strict;
-
-sub GetArgumentProtoList($)
-{
- my $f = shift;
- my $res = "";
-
- foreach my $a (@{$f->{ELEMENTS}}) {
-
- $res .= ", " . Parse::Pidl::Typelist::mapType($a->{TYPE}) . " ";
-
- my $l = $a->{POINTERS};
- $l-- if (Parse::Pidl::Typelist::scalar_is_reference($a->{TYPE}));
- foreach my $i (1..$l) {
- $res .= "*";
- }
-
- if (defined $a->{ARRAY_LEN}[0] &&
- !Parse::Pidl::Util::is_constant($a->{ARRAY_LEN}[0]) &&
- !$a->{POINTERS}) {
- $res .= "*";
- }
- $res .= $a->{NAME};
- if (defined $a->{ARRAY_LEN}[0] && Parse::Pidl::Util::is_constant($a->{ARRAY_LEN}[0])) {
- $res .= "[$a->{ARRAY_LEN}[0]]";
- }
- }
-
- return $res;
-}
-
-sub GetArgumentList($)
-{
- my $f = shift;
- my $res = "";
-
- foreach my $a (@{$f->{ELEMENTS}}) {
- $res .= ", $a->{NAME}";
- }
-
- return $res;
-}
-
-#####################################################################
-# generate vtable structure for COM interface
-sub HeaderVTable($)
-{
- my $interface = shift;
- my $res;
- $res .= "#define " . uc($interface->{NAME}) . "_METHODS \\\n";
- if (defined($interface->{BASE})) {
- $res .= "\t" . uc($interface->{BASE} . "_METHODS") . "\\\n";
- }
-
- my $data = $interface->{DATA};
- foreach my $d (@{$data}) {
- $res .= "\t" . Parse::Pidl::Typelist::mapType($d->{RETURN_TYPE}) . " (*$d->{NAME}) (struct $interface->{NAME} *d, TALLOC_CTX *mem_ctx" . GetArgumentProtoList($d) . ");\\\n" if ($d->{TYPE} eq "FUNCTION");
- }
- $res .= "\n";
- $res .= "struct $interface->{NAME}_vtable {\n";
- $res .= "\tstruct GUID iid;\n";
- $res .= "\t" . uc($interface->{NAME}) . "_METHODS\n";
- $res .= "};\n\n";
-
- return $res;
-}
-
-sub ParseInterface($)
-{
- my $if = shift;
- my $res;
-
- $res .="\n\n/* $if->{NAME} */\n";
-
- $res .="#define COM_" . uc($if->{NAME}) . "_UUID $if->{PROPERTIES}->{uuid}\n\n";
-
- $res .="struct $if->{NAME}_vtable;\n\n";
-
- $res .="struct $if->{NAME} {
- struct com_context *ctx;
- struct $if->{NAME}_vtable *vtable;
- void *object_data;
-};\n\n";
-
- $res.=HeaderVTable($if);
-
- foreach my $d (@{$if->{DATA}}) {
- next if ($d->{TYPE} ne "FUNCTION");
-
- $res .= "#define $if->{NAME}_$d->{NAME}(interface, mem_ctx" . GetArgumentList($d) . ") ";
-
- $res .= "((interface)->vtable->$d->{NAME}(interface, mem_ctx" . GetArgumentList($d) . "))";
-
- $res .="\n";
- }
-
- return $res;
-}
-
-sub ParseCoClass($)
-{
- my $c = shift;
- my $res = "";
- $res .= "#define CLSID_" . uc($c->{NAME}) . " $c->{PROPERTIES}->{uuid}\n";
- if (has_property($c, "progid")) {
- $res .= "#define PROGID_" . uc($c->{NAME}) . " $c->{PROPERTIES}->{progid}\n";
- }
- $res .= "\n";
- return $res;
-}
-
-sub Parse($)
-{
- my $idl = shift;
- my $res = "";
-
- foreach my $x (@{$idl})
- {
- if ($x->{TYPE} eq "INTERFACE" && has_property($x, "object")) {
- $res.=ParseInterface($x);
- }
-
- if ($x->{TYPE} eq "COCLASS") {
- $res.=ParseCoClass($x);
- }
- }
-
- return $res;
-}
-
-1;
diff --git a/source4/build/pidl/Parse/Pidl/Samba/COM/Proxy.pm b/source4/build/pidl/Parse/Pidl/Samba/COM/Proxy.pm
deleted file mode 100644
index c94ef59ae9..0000000000
--- a/source4/build/pidl/Parse/Pidl/Samba/COM/Proxy.pm
+++ /dev/null
@@ -1,212 +0,0 @@
-###################################################
-# DCOM parser for Samba
-# Basically the glue between COM and DCE/RPC with NDR
-# Copyright jelmer@samba.org 2003-2005
-# released under the GNU GPL
-
-package Parse::Pidl::Samba::COM::Proxy;
-
-use Parse::Pidl::Samba::COM::Header;
-use Parse::Pidl::Util qw(has_property);
-
-use strict;
-
-my($res);
-
-sub ParseVTable($$)
-{
- my $interface = shift;
- my $name = shift;
-
- # Generate the vtable
- $res .="\tstruct $interface->{NAME}_vtable $name = {";
-
- if (defined($interface->{BASE})) {
- $res .= "\n\t\t{},";
- }
-
- my $data = $interface->{DATA};
-
- foreach my $d (@{$data}) {
- if ($d->{TYPE} eq "FUNCTION") {
- $res .= "\n\t\tdcom_proxy_$interface->{NAME}_$d->{NAME}";
- $res .= ",";
- }
- }
-
- $res .= "\n\t};\n\n";
-}
-
-sub ParseRegFunc($)
-{
- my $interface = shift;
-
- $res .= "static NTSTATUS dcom_proxy_$interface->{NAME}_init(void)
-{
- struct GUID base_iid;
- struct $interface->{NAME}_vtable *proxy_vtable = talloc(talloc_autofree_context(), struct $interface->{NAME}_vtable);
-";
-
- if (defined($interface->{BASE})) {
- $res.= "
- const void *base_vtable;
-
- GUID_from_string(DCERPC_" . (uc $interface->{BASE}) . "_UUID, &base_iid);
-
- base_vtable = dcom_proxy_vtable_by_iid(&base_iid);
- if (base_vtable == NULL) {
- DEBUG(0, (\"No proxy registered for base interface '$interface->{BASE}'\\n\"));
- return NT_STATUS_FOOBAR;
- }
-
- memcpy(&proxy_vtable, base_vtable, sizeof(struct $interface->{BASE}_vtable));
-
-";
- }
- foreach my $x (@{$interface->{DATA}}) {
- next unless ($x->{TYPE} eq "FUNCTION");
-
- $res .= "\tproxy_vtable.$x->{NAME} = dcom_proxy_$interface->{NAME}_$x->{NAME};\n";
- }
-
- $res.= "
- GUID_from_string(DCERPC_" . (uc $interface->{NAME}) . "_UUID, &proxy_vtable.iid);
-
- return dcom_register_proxy(&proxy_vtable);
-}\n\n";
-}
-
-#####################################################################
-# parse a function
-sub ParseFunction($$)
-{
- my $interface = shift;
- my $fn = shift;
- my $name = $fn->{NAME};
- my $uname = uc $name;
-
- $res.="
-static $fn->{RETURN_TYPE} dcom_proxy_$interface->{NAME}_$name(struct $interface->{NAME} *d, TALLOC_CTX *mem_ctx" . Parse::Pidl::Samba::COM::Header::GetArgumentProtoList($fn) . ")
-{
- struct dcerpc_pipe *p;
- NTSTATUS status = dcom_get_pipe(d, &p);
- struct $name r;
- struct rpc_request *req;
-
- if (NT_STATUS_IS_ERR(status)) {
- return status;
- }
-
- ZERO_STRUCT(r.in.ORPCthis);
- r.in.ORPCthis.version.MajorVersion = COM_MAJOR_VERSION;
- r.in.ORPCthis.version.MinorVersion = COM_MINOR_VERSION;
-";
-
- # Put arguments into r
- foreach my $a (@{$fn->{ELEMENTS}}) {
- next unless (has_property($a, "in"));
- if (Parse::Pidl::Typelist::typeIs($a->{TYPE}, "INTERFACE")) {
- $res .="\tNDR_CHECK(dcom_OBJREF_from_IUnknown(&r.in.$a->{NAME}.obj, $a->{NAME}));\n";
- } else {
- $res .= "\tr.in.$a->{NAME} = $a->{NAME};\n";
- }
- }
-
- $res .="
- if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) {
- NDR_PRINT_IN_DEBUG($name, &r);
- }
-
- status = dcerpc_ndr_request(p, &d->ipid, &dcerpc_table_$interface->{NAME}, DCERPC_$uname, mem_ctx, &r);
-
- if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) {
- NDR_PRINT_OUT_DEBUG($name, r);
- }
-
-";
-
- # Put r info back into arguments
- foreach my $a (@{$fn->{ELEMENTS}}) {
- next unless (has_property($a, "out"));
-
- if (Parse::Pidl::Typelist::typeIs($a->{TYPE}, "INTERFACE")) {
- $res .="\tNDR_CHECK(dcom_IUnknown_from_OBJREF(d->ctx, &$a->{NAME}, r.out.$a->{NAME}.obj));\n";
- } else {
- $res .= "\t*$a->{NAME} = r.out.$a->{NAME};\n";
- }
-
- }
-
- if ($fn->{RETURN_TYPE} eq "NTSTATUS") {
- $res .= "\tif (NT_STATUS_IS_OK(status)) status = r.out.result;\n";
- }
-
- $res .=
- "
- return r.out.result;
-}\n\n";
-}
-
-#####################################################################
-# parse the interface definitions
-sub ParseInterface($)
-{
- my($interface) = shift;
- my($data) = $interface->{DATA};
- $res = "/* DCOM proxy for $interface->{NAME} generated by pidl */\n\n";
- foreach my $d (@{$data}) {
- ($d->{TYPE} eq "FUNCTION") &&
- ParseFunction($interface, $d);
- }
-
- ParseRegFunc($interface);
-}
-
-sub RegistrationFunction($$)
-{
- my $idl = shift;
- my $basename = shift;
-
- my $res = "\n\nNTSTATUS dcom_$basename\_init(void)\n";
- $res .= "{\n";
- $res .="\tNTSTATUS status = NT_STATUS_OK;\n";
- foreach my $interface (@{$idl}) {
- next if $interface->{TYPE} ne "INTERFACE";
- next if not has_property($interface, "object");
-
- my $data = $interface->{DATA};
- my $count = 0;
- foreach my $d (@{$data}) {
- if ($d->{TYPE} eq "FUNCTION") { $count++; }
- }
-
- next if ($count == 0);
-
- $res .= "\tstatus = dcom_$interface->{NAME}_init();\n";
- $res .= "\tif (NT_STATUS_IS_ERR(status)) {\n";
- $res .= "\t\treturn status;\n";
- $res .= "\t}\n\n";
- }
- $res .= "\treturn status;\n";
- $res .= "}\n\n";
-
- return $res;
-}
-
-sub Parse($)
-{
- my $pidl = shift;
- my $res = "";
-
- foreach my $x (@{$pidl}) {
- next if ($x->{TYPE} ne "INTERFACE");
- next if has_property($x, "local");
- next unless has_property($x, "object");
-
- $res .= ParseInterface($x);
- }
-
- return $res;
-}
-
-1;
diff --git a/source4/build/pidl/Parse/Pidl/Samba/COM/Stub.pm b/source4/build/pidl/Parse/Pidl/Samba/COM/Stub.pm
deleted file mode 100644
index 785c34fc77..0000000000
--- a/source4/build/pidl/Parse/Pidl/Samba/COM/Stub.pm
+++ /dev/null
@@ -1,324 +0,0 @@
-###################################################
-# DCOM stub boilerplate generator
-# Copyright jelmer@samba.org 2004-2005
-# Copyright tridge@samba.org 2003
-# Copyright metze@samba.org 2004
-# released under the GNU GPL
-
-package Parse::Pidl::Samba::COM::Stub;
-
-use Parse::Pidl::Util qw(has_property);
-use strict;
-
-my($res);
-
-sub pidl($)
-{
- $res .= shift;
-}
-
-#####################################################
-# generate the switch statement for function dispatch
-sub gen_dispatch_switch($)
-{
- my $data = shift;
-
- my $count = 0;
- foreach my $d (@{$data}) {
- next if ($d->{TYPE} ne "FUNCTION");
-
- pidl "\tcase $count: {\n";
- if ($d->{RETURN_TYPE} && $d->{RETURN_TYPE} ne "void") {
- pidl "\t\tNTSTATUS result;\n";
- }
- pidl "\t\tstruct $d->{NAME} *r2 = r;\n";
- pidl "\t\tif (DEBUGLEVEL > 10) {\n";
- pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($d->{NAME}, NDR_IN, r2);\n";
- pidl "\t\t}\n";
- if ($d->{RETURN_TYPE} && $d->{RETURN_TYPE} ne "void") {
- pidl "\t\tresult = vtable->$d->{NAME}(iface, mem_ctx, r2);\n";
- } else {
- pidl "\t\tvtable->$d->{NAME}(iface, mem_ctx, r2);\n";
- }
- pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n";
- pidl "\t\t\tDEBUG(5,(\"function $d->{NAME} will reply async\\n\"));\n";
- pidl "\t\t}\n";
- pidl "\t\tbreak;\n\t}\n";
- $count++;
- }
-}
-
-#####################################################
-# generate the switch statement for function reply
-sub gen_reply_switch($)
-{
- my $data = shift;
-
- my $count = 0;
- foreach my $d (@{$data}) {
- next if ($d->{TYPE} ne "FUNCTION");
-
- pidl "\tcase $count: {\n";
- pidl "\t\tstruct $d->{NAME} *r2 = r;\n";
- pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n";
- pidl "\t\t\tDEBUG(5,(\"function $d->{NAME} replied async\\n\"));\n";
- pidl "\t\t}\n";
- pidl "\t\tif (DEBUGLEVEL > 10 && dce_call->fault_code == 0) {\n";
- pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($d->{NAME}, NDR_OUT | NDR_SET_VALUES, r2);\n";
- pidl "\t\t}\n";
- pidl "\t\tif (dce_call->fault_code != 0) {\n";
- pidl "\t\t\tDEBUG(2,(\"dcerpc_fault %s in $d->{NAME}\\n\", dcerpc_errstr(mem_ctx, dce_call->fault_code)));\n";
- pidl "\t\t}\n";
- pidl "\t\tbreak;\n\t}\n";
- $count++;
- }
-}
-
-#####################################################################
-# produce boilerplate code for a interface
-sub Boilerplate_Iface($)
-{
- my($interface) = shift;
- my($data) = $interface->{DATA};
- my $name = $interface->{NAME};
- my $uname = uc $name;
- my $uuid = Parse::Pidl::Util::make_str($interface->{PROPERTIES}->{uuid});
- my $if_version = $interface->{PROPERTIES}->{version};
-
- pidl "
-static NTSTATUS $name\__op_bind(struct dcesrv_call_state *dce_call, const struct dcesrv_interface *iface)
-{
-#ifdef DCESRV_INTERFACE_$uname\_BIND
- return DCESRV_INTERFACE_$uname\_BIND(dce_call,iface);
-#else
- return NT_STATUS_OK;
-#endif
-}
-
-static void $name\__op_unbind(struct dcesrv_connection_context *context, const struct dcesrv_interface *iface)
-{
-#ifdef DCESRV_INTERFACE_$uname\_UNBIND
- DCESRV_INTERFACE_$uname\_UNBIND(context, iface);
-#else
- return;
-#endif
-}
-
-static NTSTATUS $name\__op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_pull *pull, void **r)
-{
- NTSTATUS status;
- uint16_t opnum = dce_call->pkt.u.request.opnum;
-
- dce_call->fault_code = 0;
-
- if (opnum >= dcerpc_table_$name.num_calls) {
- dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
- return NT_STATUS_NET_WRITE_FAULT;
- }
-
- *r = talloc_size(mem_ctx, dcerpc_table_$name.calls[opnum].struct_size);
- NT_STATUS_HAVE_NO_MEMORY(*r);
-
- /* unravel the NDR for the packet */
- status = dcerpc_table_$name.calls[opnum].ndr_pull(pull, NDR_IN, *r);
- if (!NT_STATUS_IS_OK(status)) {
- dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN,
- &dce_call->pkt.u.request.stub_and_verifier);
- dce_call->fault_code = DCERPC_FAULT_NDR;
- return NT_STATUS_NET_WRITE_FAULT;
- }
-
- return NT_STATUS_OK;
-}
-
-static NTSTATUS $name\__op_dispatch(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
-{
- uint16_t opnum = dce_call->pkt.u.request.opnum;
- struct GUID ipid = dce_call->pkt.u.request.object.object;
- struct dcom_interface_p *iface = dcom_get_local_iface_p(&ipid);
- const struct dcom_$name\_vtable *vtable = iface->vtable;
-
- switch (opnum) {
-";
- gen_dispatch_switch($data);
-
-pidl "
- default:
- dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
- break;
- }
-
- if (dce_call->fault_code != 0) {
- dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN,
- &dce_call->pkt.u.request.stub_and_verifier);
- return NT_STATUS_NET_WRITE_FAULT;
- }
-
- return NT_STATUS_OK;
-}
-
-static NTSTATUS $name\__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
-{
- uint16_t opnum = dce_call->pkt.u.request.opnum;
-
- switch (opnum) {
-";
- gen_reply_switch($data);
-
-pidl "
- default:
- dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
- break;
- }
-
- if (dce_call->fault_code != 0) {
- dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN,
- &dce_call->pkt.u.request.stub_and_verifier);
- return NT_STATUS_NET_WRITE_FAULT;
- }
-
- return NT_STATUS_OK;
-}
-
-static NTSTATUS $name\__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_push *push, const void *r)
-{
- NTSTATUS status;
- uint16_t opnum = dce_call->pkt.u.request.opnum;
-
- status = dcerpc_table_$name.calls[opnum].ndr_push(push, NDR_OUT, r);
- if (!NT_STATUS_IS_OK(status)) {
- dce_call->fault_code = DCERPC_FAULT_NDR;
- return NT_STATUS_NET_WRITE_FAULT;
- }
-
- return NT_STATUS_OK;
-}
-
-static const struct dcesrv_interface $name\_interface = {
- .name = \"$name\",
- .uuid = $uuid,
- .if_version = $if_version,
- .bind = $name\__op_bind,
- .unbind = $name\__op_unbind,
- .ndr_pull = $name\__op_ndr_pull,
- .dispatch = $name\__op_dispatch,
- .reply = $name\__op_reply,
- .ndr_push = $name\__op_ndr_push
-};
-
-";
-}
-
-#####################################################################
-# produce boilerplate code for an endpoint server
-sub Boilerplate_Ep_Server($)
-{
- my($interface) = shift;
- my $name = $interface->{NAME};
- my $uname = uc $name;
-
- pidl "
-static NTSTATUS $name\__op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server)
-{
- int i;
-
- for (i=0;i<dcerpc_table_$name.endpoints->count;i++) {
- NTSTATUS ret;
- const char *name = dcerpc_table_$name.endpoints->names[i];
-
- ret = dcesrv_interface_register(dce_ctx, name, &$name\_interface, NULL);
- if (!NT_STATUS_IS_OK(ret)) {
- DEBUG(1,(\"$name\_op_init_server: failed to register endpoint \'%s\'\\n\",name));
- return ret;
- }
- }
-
- return NT_STATUS_OK;
-}
-
-static BOOL $name\__op_interface_by_uuid(struct dcesrv_interface *iface, const char *uuid, uint32_t if_version)
-{
- if (dcerpc_table_$name.if_version == if_version &&
- strcmp(dcerpc_table_$name.uuid, uuid)==0) {
- memcpy(iface,&dcerpc_table_$name, sizeof(*iface));
- return True;
- }
-
- return False;
-}
-
-static BOOL $name\__op_interface_by_name(struct dcesrv_interface *iface, const char *name)
-{
- if (strcmp(dcerpc_table_$name.name, name)==0) {
- memcpy(iface,&dcerpc_table_$name, sizeof(*iface));
- return True;
- }
-
- return False;
-}
-
-NTSTATUS dcerpc_server_$name\_init(void)
-{
- NTSTATUS ret;
- struct dcesrv_endpoint_server ep_server;
-
- /* fill in our name */
- ep_server.name = \"$name\";
-
- /* fill in all the operations */
- ep_server.init_server = $name\__op_init_server;
-
- ep_server.interface_by_uuid = $name\__op_interface_by_uuid;
- ep_server.interface_by_name = $name\__op_interface_by_name;
-
- /* register ourselves with the DCERPC subsystem. */
- ret = dcerpc_register_ep_server(&ep_server);
-
- if (!NT_STATUS_IS_OK(ret)) {
- DEBUG(0,(\"Failed to register \'$name\' endpoint server!\\n\"));
- return ret;
- }
-
- return ret;
-}
-
-";
-}
-
-#####################################################################
-# dcom interface stub from a parsed IDL structure
-sub ParseInterface($)
-{
- my($interface) = shift;
-
- return "" if has_property($interface, "local");
-
- my($data) = $interface->{DATA};
- my $count = 0;
-
- $res = "";
-
- if (!defined $interface->{PROPERTIES}->{uuid}) {
- return $res;
- }
-
- if (!defined $interface->{PROPERTIES}->{version}) {
- $interface->{PROPERTIES}->{version} = "0.0";
- }
-
- foreach my $d (@{$data}) {
- if ($d->{TYPE} eq "FUNCTION") { $count++; }
- }
-
- if ($count == 0) {
- return $res;
- }
-
- $res = "/* dcom interface stub generated by pidl */\n\n";
- Boilerplate_Iface($interface);
- Boilerplate_Ep_Server($interface);
-
- return $res;
-}
-
-1;
diff --git a/source4/build/pidl/Parse/Pidl/Samba/EJS.pm b/source4/build/pidl/Parse/Pidl/Samba/EJS.pm
deleted file mode 100644
index 743139c8cd..0000000000
--- a/source4/build/pidl/Parse/Pidl/Samba/EJS.pm
+++ /dev/null
@@ -1,835 +0,0 @@
-###################################################
-# EJS function wrapper generator
-# Copyright jelmer@samba.org 2005
-# Copyright Andrew Tridgell 2005
-# released under the GNU GPL
-
-package Parse::Pidl::Samba::EJS;
-
-use strict;
-use Parse::Pidl::Typelist;
-use Parse::Pidl::Util qw(has_property);
-
-my($res);
-my %constants;
-
-my $tabs = "";
-sub pidl($)
-{
- my $d = shift;
- if ($d) {
- $res .= $tabs;
- $res .= $d;
- }
- $res .= "\n";
-}
-
-sub indent()
-{
- $tabs .= "\t";
-}
-
-sub deindent()
-{
- $tabs = substr($tabs, 0, -1);
-}
-
-# this should probably be in ndr.pm
-sub GenerateStructEnv($)
-{
- my $x = shift;
- my %env;
-
- foreach my $e (@{$x->{ELEMENTS}}) {
- if ($e->{NAME}) {
- $env{$e->{NAME}} = "r->$e->{NAME}";
- }
- }
-
- $env{"this"} = "r";
-
- return \%env;
-}
-
-sub GenerateFunctionInEnv($)
-{
- my $fn = shift;
- my %env;
-
- foreach my $e (@{$fn->{ELEMENTS}}) {
- if (grep (/in/, @{$e->{DIRECTION}})) {
- $env{$e->{NAME}} = "r->in.$e->{NAME}";
- }
- }
-
- return \%env;
-}
-
-sub GenerateFunctionOutEnv($)
-{
- my $fn = shift;
- my %env;
-
- foreach my $e (@{$fn->{ELEMENTS}}) {
- if (grep (/out/, @{$e->{DIRECTION}})) {
- $env{$e->{NAME}} = "r->out.$e->{NAME}";
- } elsif (grep (/in/, @{$e->{DIRECTION}})) {
- $env{$e->{NAME}} = "r->in.$e->{NAME}";
- }
- }
-
- return \%env;
-}
-
-sub get_pointer_to($)
-{
- my $var_name = shift;
-
- if ($var_name =~ /^\*(.*)$/) {
- return $1;
- } elsif ($var_name =~ /^\&(.*)$/) {
- return "&($var_name)";
- } else {
- return "&$var_name";
- }
-}
-
-sub get_value_of($)
-{
- my $var_name = shift;
-
- if ($var_name =~ /^\&(.*)$/) {
- return $1;
- } else {
- return "*$var_name";
- }
-}
-
-#####################################################################
-# work out is a parse function should be declared static or not
-sub fn_prefix($)
-{
- my $fn = shift;
-
- return "" if (has_property($fn, "public"));
- return "static ";
-}
-
-###########################
-# pull a scalar element
-sub EjsPullScalar($$$$$)
-{
- my ($e, $l, $var, $name, $env) = @_;
-
- return if (has_property($e, "value"));
-
- my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l);
- $var = get_pointer_to($var);
- # have to handle strings specially :(
- if ($e->{TYPE} eq "string" && $pl && $pl->{TYPE} eq "POINTER") {
- $var = get_pointer_to($var);
- }
- pidl "NDR_CHECK(ejs_pull_$e->{TYPE}(ejs, v, $name, $var));";
-}
-
-###########################
-# pull a pointer element
-sub EjsPullPointer($$$$$)
-{
- my ($e, $l, $var, $name, $env) = @_;
- pidl "if (ejs_pull_null(ejs, v, $name)) {";
- indent;
- pidl "$var = NULL;";
- deindent;
- pidl "} else {";
- indent;
- pidl "EJS_ALLOC(ejs, $var);";
- $var = get_value_of($var);
- EjsPullElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env);
- deindent;
- pidl "}";
-}
-
-###########################
-# pull a string element
-sub EjsPullString($$$$$)
-{
- my ($e, $l, $var, $name, $env) = @_;
- $var = get_pointer_to($var);
- pidl "NDR_CHECK(ejs_pull_string(ejs, v, $name, $var));";
-}
-
-
-###########################
-# pull an array element
-sub EjsPullArray($$$$$)
-{
- my ($e, $l, $var, $name, $env) = @_;
- my $nl = Parse::Pidl::NDR::GetNextLevel($e, $l);
- my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env);
- my $size = Parse::Pidl::Util::ParseExpr($l->{SIZE_IS}, $env);
- my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l);
- if ($pl && $pl->{TYPE} eq "POINTER") {
- $var = get_pointer_to($var);
- }
- # uint8 arrays are treated as data blobs
- if ($nl->{TYPE} eq 'DATA' && $e->{TYPE} eq 'uint8') {
- if (!$l->{IS_FIXED}) {
- pidl "EJS_ALLOC_N(ejs, $var, $size);";
- }
- pidl "ejs_pull_array_uint8(ejs, v, $name, $var, $length);";
- return;
- }
- my $avar = $var . "[i]";
- pidl "{";
- indent;
- pidl "uint32_t i;";
- if (!$l->{IS_FIXED}) {
- pidl "EJS_ALLOC_N(ejs, $var, $size);";
- }
- pidl "for (i=0;i<$length;i++) {";
- indent;
- pidl "char *id = talloc_asprintf(ejs, \"%s.%u\", $name, i);";
- EjsPullElement($e, $nl, $avar, "id", $env);
- pidl "talloc_free(id);";
- deindent;
- pidl "}";
- pidl "ejs_push_uint32(ejs, v, $name \".length\", &i);";
- deindent;
- pidl "}";
-}
-
-###########################
-# pull a switch element
-sub EjsPullSwitch($$$$$)
-{
- my ($e, $l, $var, $name, $env) = @_;
- my $switch_var = Parse::Pidl::Util::ParseExpr($l->{SWITCH_IS}, $env);
- pidl "ejs_set_switch(ejs, $switch_var);";
- EjsPullElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env);
-}
-
-###########################
-# pull a structure element
-sub EjsPullElement($$$$$)
-{
- my ($e, $l, $var, $name, $env) = @_;
- if (has_property($e, "charset")) {
- EjsPullString($e, $l, $var, $name, $env);
- } elsif ($l->{TYPE} eq "ARRAY") {
- EjsPullArray($e, $l, $var, $name, $env);
- } elsif ($l->{TYPE} eq "DATA") {
- EjsPullScalar($e, $l, $var, $name, $env);
- } elsif (($l->{TYPE} eq "POINTER")) {
- EjsPullPointer($e, $l, $var, $name, $env);
- } elsif (($l->{TYPE} eq "SWITCH")) {
- EjsPullSwitch($e, $l, $var, $name, $env);
- } else {
- pidl "return ejs_panic(ejs, \"unhandled pull type $l->{TYPE}\");";
- }
-}
-
-#############################################
-# pull a structure/union element at top level
-sub EjsPullElementTop($$)
-{
- my $e = shift;
- my $env = shift;
- my $l = $e->{LEVELS}[0];
- my $var = Parse::Pidl::Util::ParseExpr($e->{NAME}, $env);
- my $name = "\"$e->{NAME}\"";
- EjsPullElement($e, $l, $var, $name, $env);
-}
-
-###########################
-# pull a struct
-sub EjsStructPull($$)
-{
- my $name = shift;
- my $d = shift;
- my $env = GenerateStructEnv($d);
- pidl fn_prefix($d);
- pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, struct $name *r)\n{";
- indent;
- pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, name));";
- foreach my $e (@{$d->{ELEMENTS}}) {
- EjsPullElementTop($e, $env);
- }
- pidl "return NT_STATUS_OK;";
- deindent;
- pidl "}\n";
-}
-
-###########################
-# pull a union
-sub EjsUnionPull($$)
-{
- my $name = shift;
- my $d = shift;
- my $have_default = 0;
- my $env = GenerateStructEnv($d);
- pidl fn_prefix($d);
- pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, union $name *r)\n{";
- indent;
- pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, name));";
- pidl "switch (ejs->switch_var) {";
- indent;
- foreach my $e (@{$d->{ELEMENTS}}) {
- if ($e->{CASE} eq "default") {
- $have_default = 1;
- }
- pidl "$e->{CASE}:";
- indent;
- if ($e->{TYPE} ne "EMPTY") {
- EjsPullElementTop($e, $env);
- }
- pidl "break;";
- deindent;
- }
- if (! $have_default) {
- pidl "default:";
- indent;
- pidl "return ejs_panic(ejs, \"Bad switch value\");";
- deindent;
- }
- deindent;
- pidl "}";
- pidl "return NT_STATUS_OK;";
- deindent;
- pidl "}";
-}
-
-##############################################
-# put the enum elements in the constants array
-sub EjsEnumConstant($)
-{
- my $d = shift;
- my $v = 0;
- foreach my $e (@{$d->{ELEMENTS}}) {
- my $el = $e;
- chomp $el;
- if ($el =~ /^(.*)=\s*(.*)\s*$/) {
- $el = $1;
- $v = $2;
- }
- $constants{$el} = $v;
- $v++;
- }
-}
-
-###########################
-# pull a enum
-sub EjsEnumPull($$)
-{
- my $name = shift;
- my $d = shift;
- EjsEnumConstant($d);
- pidl fn_prefix($d);
- pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, enum $name *r)\n{";
- indent;
- pidl "unsigned e;";
- pidl "NDR_CHECK(ejs_pull_enum(ejs, v, name, &e));";
- pidl "*r = e;";
- pidl "return NT_STATUS_OK;";
- deindent;
- pidl "}\n";
-}
-
-###########################
-# pull a bitmap
-sub EjsBitmapPull($$)
-{
- my $name = shift;
- my $d = shift;
- my $type_fn = $d->{BASE_TYPE};
- my($type_decl) = Parse::Pidl::Typelist::mapType($d->{BASE_TYPE});
- pidl fn_prefix($d);
- pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, $type_decl *r)\n{";
- indent;
- pidl "return ejs_pull_$type_fn(ejs, v, name, r);";
- deindent;
- pidl "}";
-}
-
-
-###########################
-# generate a structure pull
-sub EjsTypedefPull($)
-{
- my $d = shift;
- return if (has_property($d, "noejs"));
- if ($d->{DATA}->{TYPE} eq 'STRUCT') {
- EjsStructPull($d->{NAME}, $d->{DATA});
- } elsif ($d->{DATA}->{TYPE} eq 'UNION') {
- EjsUnionPull($d->{NAME}, $d->{DATA});
- } elsif ($d->{DATA}->{TYPE} eq 'ENUM') {
- EjsEnumPull($d->{NAME}, $d->{DATA});
- } elsif ($d->{DATA}->{TYPE} eq 'BITMAP') {
- EjsBitmapPull($d->{NAME}, $d->{DATA});
- } else {
- warn "Unhandled pull typedef $d->{NAME} of type $d->{DATA}->{TYPE}";
- }
-}
-
-#####################
-# generate a function
-sub EjsPullFunction($)
-{
- my $d = shift;
- my $env = GenerateFunctionInEnv($d);
- my $name = $d->{NAME};
-
- pidl "\nstatic NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, struct $name *r)";
- pidl "{";
- indent;
- pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, \"input\"));";
-
- # we pull non-array elements before array elements as arrays
- # may have length_is() or size_is() properties that depend
- # on the non-array elements
- foreach my $e (@{$d->{ELEMENTS}}) {
- next unless (grep(/in/, @{$e->{DIRECTION}}));
- next if (has_property($e, "length_is") ||
- has_property($e, "size_is"));
- EjsPullElementTop($e, $env);
- }
-
- foreach my $e (@{$d->{ELEMENTS}}) {
- next unless (grep(/in/, @{$e->{DIRECTION}}));
- next unless (has_property($e, "length_is") ||
- has_property($e, "size_is"));
- EjsPullElementTop($e, $env);
- }
-
- pidl "return NT_STATUS_OK;";
- deindent;
- pidl "}\n";
-}
-
-
-###########################
-# push a scalar element
-sub EjsPushScalar($$$$$)
-{
- my ($e, $l, $var, $name, $env) = @_;
- # have to handle strings specially :(
- my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l);
- if ($e->{TYPE} ne "string" || ($pl && $pl->{TYPE} eq "POINTER")) {
- $var = get_pointer_to($var);
- }
- pidl "NDR_CHECK(ejs_push_$e->{TYPE}(ejs, v, $name, $var));";
-}
-
-###########################
-# push a string element
-sub EjsPushString($$$$$)
-{
- my ($e, $l, $var, $name, $env) = @_;
- pidl "NDR_CHECK(ejs_push_string(ejs, v, $name, $var));";
-}
-
-###########################
-# push a pointer element
-sub EjsPushPointer($$$$$)
-{
- my ($e, $l, $var, $name, $env) = @_;
- pidl "if (NULL == $var) {";
- indent;
- pidl "NDR_CHECK(ejs_push_null(ejs, v, $name));";
- deindent;
- pidl "} else {";
- indent;
- $var = get_value_of($var);
- EjsPushElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env);
- deindent;
- pidl "}";
-}
-
-###########################
-# push a switch element
-sub EjsPushSwitch($$$$$)
-{
- my ($e, $l, $var, $name, $env) = @_;
- my $switch_var = Parse::Pidl::Util::ParseExpr($l->{SWITCH_IS}, $env);
- pidl "ejs_set_switch(ejs, $switch_var);";
- EjsPushElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env);
-}
-
-
-###########################
-# push an array element
-sub EjsPushArray($$$$$)
-{
- my ($e, $l, $var, $name, $env) = @_;
- my $nl = Parse::Pidl::NDR::GetNextLevel($e, $l);
- my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env);
- my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l);
- if ($pl && $pl->{TYPE} eq "POINTER") {
- $var = get_pointer_to($var);
- }
- # uint8 arrays are treated as data blobs
- if ($nl->{TYPE} eq 'DATA' && $e->{TYPE} eq 'uint8') {
- pidl "ejs_push_array_uint8(ejs, v, $name, $var, $length);";
- return;
- }
- my $avar = $var . "[i]";
- pidl "{";
- indent;
- pidl "uint32_t i;";
- pidl "for (i=0;i<$length;i++) {";
- indent;
- pidl "const char *id = talloc_asprintf(ejs, \"%s.%u\", $name, i);";
- EjsPushElement($e, $nl, $avar, "id", $env);
- deindent;
- pidl "}";
- pidl "ejs_push_uint32(ejs, v, $name \".length\", &i);";
- deindent;
- pidl "}";
-}
-
-################################
-# push a structure/union element
-sub EjsPushElement($$$$$)
-{
- my ($e, $l, $var, $name, $env) = @_;
- if (has_property($e, "charset")) {
- EjsPushString($e, $l, $var, $name, $env);
- } elsif ($l->{TYPE} eq "ARRAY") {
- EjsPushArray($e, $l, $var, $name, $env);
- } elsif ($l->{TYPE} eq "DATA") {
- EjsPushScalar($e, $l, $var, $name, $env);
- } elsif (($l->{TYPE} eq "POINTER")) {
- EjsPushPointer($e, $l, $var, $name, $env);
- } elsif (($l->{TYPE} eq "SWITCH")) {
- EjsPushSwitch($e, $l, $var, $name, $env);
- } else {
- pidl "return ejs_panic(ejs, \"unhandled push type $l->{TYPE}\");";
- }
-}
-
-#############################################
-# push a structure/union element at top level
-sub EjsPushElementTop($$)
-{
- my $e = shift;
- my $env = shift;
- my $l = $e->{LEVELS}[0];
- my $var = Parse::Pidl::Util::ParseExpr($e->{NAME}, $env);
- my $name = "\"$e->{NAME}\"";
- EjsPushElement($e, $l, $var, $name, $env);
-}
-
-###########################
-# push a struct
-sub EjsStructPush($$)
-{
- my $name = shift;
- my $d = shift;
- my $env = GenerateStructEnv($d);
- pidl fn_prefix($d);
- pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const struct $name *r)\n{";
- indent;
- pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, name));";
- foreach my $e (@{$d->{ELEMENTS}}) {
- EjsPushElementTop($e, $env);
- }
- pidl "return NT_STATUS_OK;";
- deindent;
- pidl "}\n";
-}
-
-###########################
-# push a union
-sub EjsUnionPush($$)
-{
- my $name = shift;
- my $d = shift;
- my $have_default = 0;
- my $env = GenerateStructEnv($d);
- pidl fn_prefix($d);
- pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const union $name *r)\n{";
- indent;
- pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, name));";
- pidl "switch (ejs->switch_var) {";
- indent;
- foreach my $e (@{$d->{ELEMENTS}}) {
- if ($e->{CASE} eq "default") {
- $have_default = 1;
- }
- pidl "$e->{CASE}:";
- indent;
- if ($e->{TYPE} ne "EMPTY") {
- EjsPushElementTop($e, $env);
- }
- pidl "break;";
- deindent;
- }
- if (! $have_default) {
- pidl "default:";
- indent;
- pidl "return ejs_panic(ejs, \"Bad switch value\");";
- deindent;
- }
- deindent;
- pidl "}";
- pidl "return NT_STATUS_OK;";
- deindent;
- pidl "}";
-}
-
-###########################
-# push a enum
-sub EjsEnumPush($$)
-{
- my $name = shift;
- my $d = shift;
- EjsEnumConstant($d);
- pidl fn_prefix($d);
- pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const enum $name *r)\n{";
- indent;
- pidl "unsigned e = *r;";
- pidl "NDR_CHECK(ejs_push_enum(ejs, v, name, &e));";
- pidl "return NT_STATUS_OK;";
- deindent;
- pidl "}\n";
-}
-
-###########################
-# push a bitmap
-sub EjsBitmapPush($$)
-{
- my $name = shift;
- my $d = shift;
- my $type_fn = $d->{BASE_TYPE};
- my($type_decl) = Parse::Pidl::Typelist::mapType($d->{BASE_TYPE});
- # put the bitmap elements in the constants array
- foreach my $e (@{$d->{ELEMENTS}}) {
- if ($e =~ /^(\w*)\s*(.*)\s*$/) {
- my $bname = $1;
- my $v = $2;
- $constants{$bname} = $v;
- }
- }
- pidl fn_prefix($d);
- pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const $type_decl *r)\n{";
- indent;
- pidl "return ejs_push_$type_fn(ejs, v, name, r);";
- deindent;
- pidl "}";
-}
-
-
-###########################
-# generate a structure push
-sub EjsTypedefPush($)
-{
- my $d = shift;
- return if (has_property($d, "noejs"));
- if ($d->{DATA}->{TYPE} eq 'STRUCT') {
- EjsStructPush($d->{NAME}, $d->{DATA});
- } elsif ($d->{DATA}->{TYPE} eq 'UNION') {
- EjsUnionPush($d->{NAME}, $d->{DATA});
- } elsif ($d->{DATA}->{TYPE} eq 'ENUM') {
- EjsEnumPush($d->{NAME}, $d->{DATA});
- } elsif ($d->{DATA}->{TYPE} eq 'BITMAP') {
- EjsBitmapPush($d->{NAME}, $d->{DATA});
- } else {
- warn "Unhandled push typedef $d->{NAME} of type $d->{DATA}->{TYPE}";
- }
-}
-
-
-#####################
-# generate a function
-sub EjsPushFunction($)
-{
- my $d = shift;
- my $env = GenerateFunctionOutEnv($d);
-
- pidl "\nstatic NTSTATUS ejs_push_$d->{NAME}(struct ejs_rpc *ejs, struct MprVar *v, const struct $d->{NAME} *r)";
- pidl "{";
- indent;
- pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, \"output\"));";
-
- foreach my $e (@{$d->{ELEMENTS}}) {
- next unless (grep(/out/, @{$e->{DIRECTION}}));
- EjsPushElementTop($e, $env);
- }
-
- if ($d->{RETURN_TYPE}) {
- my $t = $d->{RETURN_TYPE};
- pidl "NDR_CHECK(ejs_push_$t(ejs, v, \"result\", &r->out.result));";
- }
-
- pidl "return NT_STATUS_OK;";
- deindent;
- pidl "}\n";
-}
-
-
-#################################
-# generate a ejs mapping function
-sub EjsFunction($$)
-{
- my $d = shift;
- my $iface = shift;
- my $name = $d->{NAME};
- my $callnum = uc("DCERPC_$name");
- my $table = "&dcerpc_table_$iface";
-
- pidl "static int ejs_$name(int eid, int argc, struct MprVar **argv)";
- pidl "{";
- indent;
- pidl "return ejs_rpc_call(eid, argc, argv, $table, $callnum, (ejs_pull_function_t)ejs_pull_$name, (ejs_push_function_t)ejs_push_$name);";
- deindent;
- pidl "}\n";
-}
-
-###################
-# handle a constant
-sub EjsConst($)
-{
- my $const = shift;
- $constants{$const->{NAME}} = $const->{VALUE};
-}
-
-#####################################################################
-# parse the interface definitions
-sub EjsInterface($$)
-{
- my($interface,$needed) = @_;
- my @fns = ();
- my $name = $interface->{NAME};
-
- %constants = ();
-
- foreach my $d (@{$interface->{TYPEDEFS}}) {
- ($needed->{"push_$d->{NAME}"}) && EjsTypedefPush($d);
- ($needed->{"pull_$d->{NAME}"}) && EjsTypedefPull($d);
- }
-
- foreach my $d (@{$interface->{FUNCTIONS}}) {
- next if not defined($d->{OPNUM});
-
- EjsPullFunction($d);
- EjsPushFunction($d);
- EjsFunction($d, $name);
-
- push (@fns, $d->{NAME});
- }
-
- foreach my $d (@{$interface->{CONSTS}}) {
- EjsConst($d);
- }
-
- pidl "static int ejs_$name\_init(int eid, int argc, struct MprVar **argv)";
- pidl "{";
- indent;
- pidl "struct MprVar *obj = mprInitObject(eid, \"$name\", argc, argv);";
- foreach (@fns) {
- pidl "mprSetCFunction(obj, \"$_\", ejs_$_);";
- }
- foreach my $v (keys %constants) {
- my $value = $constants{$v};
- if (substr($value, 0, 1) eq "\"") {
- pidl "mprSetVar(obj, \"$v\", mprString($value));";
- } else {
- pidl "mprSetVar(obj, \"$v\", mprCreateNumberVar($value));";
- }
- }
- pidl "return ejs_rpc_init(obj, \"$name\");";
- deindent;
- pidl "}\n";
-
- pidl "NTSTATUS ejs_init_$name(void)";
- pidl "{";
- indent;
- pidl "return smbcalls_register_ejs(\"$name\_init\", ejs_$name\_init);";
- deindent;
- pidl "}";
-}
-
-#####################################################################
-# parse a parsed IDL into a C header
-sub Parse($$)
-{
- my($ndr,$hdr) = @_;
-
- my $ejs_hdr = $hdr;
- $ejs_hdr =~ s/.h$/_ejs.h/;
- $res = "";
- pidl "
-/* EJS wrapper functions auto-generated by pidl */
-#include \"includes.h\"
-#include \"lib/appweb/ejs/ejs.h\"
-#include \"scripting/ejs/ejsrpc.h\"
-#include \"scripting/ejs/smbcalls.h\"
-#include \"librpc/gen_ndr/ndr_misc_ejs.h\"
-#include \"$hdr\"
-#include \"$ejs_hdr\"
-
-";
-
- my %needed = ();
-
- foreach my $x (@{$ndr}) {
- ($x->{TYPE} eq "INTERFACE") && NeededInterface($x, \%needed);
- }
-
- foreach my $x (@{$ndr}) {
- ($x->{TYPE} eq "INTERFACE") && EjsInterface($x, \%needed);
- }
-
- return $res;
-}
-
-sub NeededFunction($$)
-{
- my ($fn,$needed) = @_;
- $needed->{"pull_$fn->{NAME}"} = 1;
- $needed->{"push_$fn->{NAME}"} = 1;
- foreach my $e (@{$fn->{ELEMENTS}}) {
- if (grep (/in/, @{$e->{DIRECTION}})) {
- $needed->{"pull_$e->{TYPE}"} = 1;
- }
- if (grep (/out/, @{$e->{DIRECTION}})) {
- $needed->{"push_$e->{TYPE}"} = 1;
- }
- }
-}
-
-sub NeededTypedef($$)
-{
- my ($t,$needed) = @_;
- if (Parse::Pidl::Util::has_property($t, "public")) {
- $needed->{"pull_$t->{NAME}"} = not Parse::Pidl::Util::has_property($t, "noejs");
- $needed->{"push_$t->{NAME}"} = not Parse::Pidl::Util::has_property($t, "noejs");
- }
- if ($t->{DATA}->{TYPE} ne "STRUCT" &&
- $t->{DATA}->{TYPE} ne "UNION") {
- return;
- }
- for my $e (@{$t->{DATA}->{ELEMENTS}}) {
- if ($needed->{"pull_$t->{NAME}"}) {
- $needed->{"pull_$e->{TYPE}"} = 1;
- }
- if ($needed->{"push_$t->{NAME}"}) {
- $needed->{"push_$e->{TYPE}"} = 1;
- }
- }
-}
-
-#####################################################################
-# work out what parse functions are needed
-sub NeededInterface($$)
-{
- my ($interface,$needed) = @_;
- foreach my $d (@{$interface->{FUNCTIONS}}) {
- NeededFunction($d, $needed);
- }
- foreach my $d (reverse @{$interface->{TYPEDEFS}}) {
- NeededTypedef($d, $needed);
- }
-}
-
-1;
diff --git a/source4/build/pidl/Parse/Pidl/Samba/EJSHeader.pm b/source4/build/pidl/Parse/Pidl/Samba/EJSHeader.pm
deleted file mode 100644
index 81c75705de..0000000000
--- a/source4/build/pidl/Parse/Pidl/Samba/EJSHeader.pm
+++ /dev/null
@@ -1,76 +0,0 @@
-###################################################
-# create C header files for an EJS mapping functions
-# Copyright tridge@samba.org 2005
-# released under the GNU GPL
-
-package Parse::Pidl::Samba::EJSHeader;
-
-use strict;
-use Parse::Pidl::Typelist;
-use Parse::Pidl::Util qw(has_property);
-
-my($res);
-
-sub pidl ($)
-{
- $res .= shift;
-}
-
-#####################################################################
-# prototype a typedef
-sub HeaderTypedefProto($)
-{
- my $d = shift;
- my $name = $d->{NAME};
-
- return unless has_property($d, "public");
-
- my $type_decl = Parse::Pidl::Typelist::mapType($name);
-
- pidl "NTSTATUS ejs_push_$d->{NAME}(struct ejs_rpc *, struct MprVar *, const char *, const $type_decl *);\n";
- pidl "NTSTATUS ejs_pull_$d->{NAME}(struct ejs_rpc *, struct MprVar *, const char *, $type_decl *);\n";
-}
-
-#####################################################################
-# parse the interface definitions
-sub HeaderInterface($)
-{
- my($interface) = shift;
-
- my $count = 0;
-
- pidl "#ifndef _HEADER_EJS_$interface->{NAME}\n";
- pidl "#define _HEADER_EJS_$interface->{NAME}\n\n";
-
- if (defined $interface->{PROPERTIES}->{depends}) {
- my @d = split / /, $interface->{PROPERTIES}->{depends};
- foreach my $i (@d) {
- pidl "#include \"librpc/gen_ndr/ndr_$i\_ejs\.h\"\n";
- }
- }
-
- pidl "\n";
-
- foreach my $d (@{$interface->{TYPEDEFS}}) {
- HeaderTypedefProto($d);
- }
-
- pidl "\n";
- pidl "#endif /* _HEADER_EJS_$interface->{NAME} */\n";
-}
-
-#####################################################################
-# parse a parsed IDL into a C header
-sub Parse($)
-{
- my($idl) = shift;
-
- $res = "";
- pidl "/* header auto-generated by pidl */\n\n";
- foreach my $x (@{$idl}) {
- ($x->{TYPE} eq "INTERFACE") && HeaderInterface($x);
- }
- return $res;
-}
-
-1;
diff --git a/source4/build/pidl/Parse/Pidl/Samba/Header.pm b/source4/build/pidl/Parse/Pidl/Samba/Header.pm
deleted file mode 100644
index d88b37e229..0000000000
--- a/source4/build/pidl/Parse/Pidl/Samba/Header.pm
+++ /dev/null
@@ -1,356 +0,0 @@
-###################################################
-# create C header files for an IDL structure
-# Copyright tridge@samba.org 2000
-# Copyright jelmer@samba.org 2005
-# released under the GNU GPL
-
-package Parse::Pidl::Samba::Header;
-
-use strict;
-use Parse::Pidl::Typelist qw(mapType);
-use Parse::Pidl::Util qw(has_property is_constant);
-use Parse::Pidl::NDR qw(GetNextLevel GetPrevLevel);
-
-my($res);
-my($tab_depth);
-
-sub pidl ($)
-{
- $res .= shift;
-}
-
-sub tabs()
-{
- my $res = "";
- $res .="\t" foreach (1..$tab_depth);
- return $res;
-}
-
-#####################################################################
-# parse a properties list
-sub HeaderProperties($$)
-{
- my($props,$ignores) = @_;
- my $ret = "";
-
- foreach my $d (keys %{$props}) {
- next if (grep(/^$d$/, @$ignores));
- if($props->{$d} ne "1") {
- $ret.= "$d($props->{$d}),";
- } else {
- $ret.="$d,";
- }
- }
-
- if ($ret) {
- pidl "/* [" . substr($ret, 0, -1) . "] */";
- }
-}
-
-#####################################################################
-# parse a structure element
-sub HeaderElement($)
-{
- my($element) = shift;
-
- pidl tabs();
- HeaderType($element, $element->{TYPE}, "");
- pidl " ";
- my $numstar = $element->{POINTERS};
- foreach (@{$element->{ARRAY_LEN}})
- {
- next if is_constant($_) and
- not has_property($element, "charset");
- $numstar++;
- }
- $numstar-- if Parse::Pidl::Typelist::scalar_is_reference($element->{TYPE});
- pidl "*" foreach (1..$numstar);
- pidl $element->{NAME};
- foreach (@{$element->{ARRAY_LEN}}) {
- next unless (is_constant($_) and
- not has_property($element, "charset"));
- pidl "[$_]";
- }
-
- pidl ";";
- if (defined $element->{PROPERTIES}) {
- HeaderProperties($element->{PROPERTIES}, ["in", "out"]);
- }
- pidl "\n";
-}
-
-#####################################################################
-# parse a struct
-sub HeaderStruct($$)
-{
- my($struct,$name) = @_;
- pidl "struct $name {\n";
- $tab_depth++;
- my $el_count=0;
- if (defined $struct->{ELEMENTS}) {
- foreach my $e (@{$struct->{ELEMENTS}}) {
- HeaderElement($e);
- $el_count++;
- }
- }
- if ($el_count == 0) {
- # some compilers can't handle empty structures
- pidl tabs()."char _empty_;\n";
- }
- $tab_depth--;
- pidl tabs()."}";
- if (defined $struct->{PROPERTIES}) {
- HeaderProperties($struct->{PROPERTIES}, []);
- }
-}
-
-#####################################################################
-# parse a enum
-sub HeaderEnum($$)
-{
- my($enum,$name) = @_;
- my $first = 1;
-
- if (not Parse::Pidl::Util::useUintEnums()) {
- pidl "enum $name {\n";
- $tab_depth++;
- foreach my $e (@{$enum->{ELEMENTS}}) {
- unless ($first) { pidl ",\n"; }
- $first = 0;
- pidl tabs();
- pidl $e;
- }
- pidl "\n";
- $tab_depth--;
- pidl "}";
- } else {
- my $count = 0;
- pidl "enum $name { __donnot_use_enum_$name=0x7FFFFFFF};\n";
- my $with_val = 0;
- my $without_val = 0;
- foreach my $e (@{$enum->{ELEMENTS}}) {
- my $t = "$e";
- my $name;
- my $value;
- if ($t =~ /(.*)=(.*)/) {
- $name = $1;
- $value = $2;
- $with_val = 1;
- die ("you can't mix enum member with values and without values when using --uint-enums!")
- unless ($without_val == 0);
- } else {
- $name = $t;
- $value = $count++;
- $without_val = 1;
- die ("you can't mix enum member with values and without values when using --uint-enums!")
- unless ($with_val == 0);
- }
- pidl "#define $name ( $value )\n";
- }
- pidl "\n";
- }
-}
-
-#####################################################################
-# parse a bitmap
-sub HeaderBitmap($$)
-{
- my($bitmap,$name) = @_;
-
- pidl "/* bitmap $name */\n";
- pidl "#define $_\n" foreach (@{$bitmap->{ELEMENTS}});
- pidl "\n";
-}
-
-#####################################################################
-# parse a union
-sub HeaderUnion($$)
-{
- my($union,$name) = @_;
- my %done = ();
-
- pidl "union $name {\n";
- $tab_depth++;
- foreach my $e (@{$union->{ELEMENTS}}) {
- if ($e->{TYPE} ne "EMPTY") {
- if (! defined $done{$e->{NAME}}) {
- HeaderElement($e);
- }
- $done{$e->{NAME}} = 1;
- }
- }
- $tab_depth--;
- pidl "}";
-
- if (defined $union->{PROPERTIES}) {
- HeaderProperties($union->{PROPERTIES}, []);
- }
-}
-
-#####################################################################
-# parse a type
-sub HeaderType($$$)
-{
- my($e,$data,$name) = @_;
- if (ref($data) eq "HASH") {
- ($data->{TYPE} eq "ENUM") && HeaderEnum($data, $name);
- ($data->{TYPE} eq "BITMAP") && HeaderBitmap($data, $name);
- ($data->{TYPE} eq "STRUCT") && HeaderStruct($data, $name);
- ($data->{TYPE} eq "UNION") && HeaderUnion($data, $name);
- return;
- }
-
- if (has_property($e, "charset")) {
- pidl "const char";
- } else {
- pidl mapType($e->{TYPE});
- }
-}
-
-#####################################################################
-# parse a typedef
-sub HeaderTypedef($)
-{
- my($typedef) = shift;
- HeaderType($typedef, $typedef->{DATA}, $typedef->{NAME});
- pidl ";\n\n" unless ($typedef->{DATA}->{TYPE} eq "BITMAP");
-}
-
-#####################################################################
-# parse a const
-sub HeaderConst($)
-{
- my($const) = shift;
- if (!defined($const->{ARRAY_LEN}[0])) {
- pidl "#define $const->{NAME}\t( $const->{VALUE} )\n";
- } else {
- pidl "#define $const->{NAME}\t $const->{VALUE}\n";
- }
-}
-
-#####################################################################
-# parse a function
-sub HeaderFunctionInOut($$)
-{
- my($fn,$prop) = @_;
-
- foreach my $e (@{$fn->{ELEMENTS}}) {
- if (has_property($e, $prop)) {
- HeaderElement($e);
- }
- }
-}
-
-#####################################################################
-# determine if we need an "in" or "out" section
-sub HeaderFunctionInOut_needed($$)
-{
- my($fn,$prop) = @_;
-
- return 1 if ($prop eq "out" && $fn->{RETURN_TYPE} ne "void");
-
- foreach (@{$fn->{ELEMENTS}}) {
- return 1 if (has_property($_, $prop));
- }
-
- return undef;
-}
-
-my %headerstructs = ();
-
-#####################################################################
-# parse a function
-sub HeaderFunction($)
-{
- my($fn) = shift;
-
- return if ($headerstructs{$fn->{NAME}});
-
- $headerstructs{$fn->{NAME}} = 1;
-
- pidl "\nstruct $fn->{NAME} {\n";
- $tab_depth++;
- my $needed = 0;
-
- if (HeaderFunctionInOut_needed($fn, "in")) {
- pidl tabs()."struct {\n";
- $tab_depth++;
- HeaderFunctionInOut($fn, "in");
- $tab_depth--;
- pidl tabs()."} in;\n\n";
- $needed++;
- }
-
- if (HeaderFunctionInOut_needed($fn, "out")) {
- pidl tabs()."struct {\n";
- $tab_depth++;
- HeaderFunctionInOut($fn, "out");
- if ($fn->{RETURN_TYPE} ne "void") {
- pidl tabs().mapType($fn->{RETURN_TYPE}) . " result;\n";
- }
- $tab_depth--;
- pidl tabs()."} out;\n\n";
- $needed++;
- }
-
- if (! $needed) {
- # sigh - some compilers don't like empty structures
- pidl tabs()."int _dummy_element;\n";
- }
-
- $tab_depth--;
- pidl "};\n\n";
-}
-
-#####################################################################
-# parse the interface definitions
-sub HeaderInterface($)
-{
- my($interface) = shift;
-
- my $count = 0;
-
- pidl "#ifndef _HEADER_$interface->{NAME}\n";
- pidl "#define _HEADER_$interface->{NAME}\n\n";
-
- if (defined $interface->{PROPERTIES}->{depends}) {
- my @d = split / /, $interface->{PROPERTIES}->{depends};
- foreach my $i (@d) {
- pidl "#include \"librpc/gen_ndr/$i\.h\"\n";
- }
- }
-
- foreach my $d (@{$interface->{DATA}}) {
- next if ($d->{TYPE} ne "CONST");
- HeaderConst($d);
- }
-
- foreach my $d (@{$interface->{DATA}}) {
- next if ($d->{TYPE} ne "TYPEDEF");
- HeaderTypedef($d);
- }
-
- foreach my $d (@{$interface->{DATA}}) {
- next if ($d->{TYPE} ne "FUNCTION");
- HeaderFunction($d);
- }
-
- pidl "#endif /* _HEADER_$interface->{NAME} */\n";
-}
-
-#####################################################################
-# parse a parsed IDL into a C header
-sub Parse($)
-{
- my($idl) = shift;
- $tab_depth = 0;
-
- $res = "";
- pidl "/* header auto-generated by pidl */\n\n";
- foreach my $x (@{$idl}) {
- ($x->{TYPE} eq "INTERFACE") && HeaderInterface($x);
- }
- return $res;
-}
-
-1;
diff --git a/source4/build/pidl/Parse/Pidl/Samba/NDR/Client.pm b/source4/build/pidl/Parse/Pidl/Samba/NDR/Client.pm
deleted file mode 100644
index 126dbc3ba9..0000000000
--- a/source4/build/pidl/Parse/Pidl/Samba/NDR/Client.pm
+++ /dev/null
@@ -1,99 +0,0 @@
-###################################################
-# 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
deleted file mode 100644
index 9aa0ed8daf..0000000000
--- a/source4/build/pidl/Parse/Pidl/Samba/NDR/Header.pm
+++ /dev/null
@@ -1,166 +0,0 @@
-###################################################
-# create C header files for an IDL structure
-# Copyright tridge@samba.org 2000
-# Copyright jelmer@samba.org 2005
-# released under the GNU GPL
-
-package Parse::Pidl::Samba::NDR::Header;
-
-use strict;
-use Parse::Pidl::Typelist qw(mapType);
-use Parse::Pidl::Util qw(has_property is_constant);
-use Parse::Pidl::NDR qw(GetNextLevel GetPrevLevel);
-use Parse::Pidl::Samba::NDR::Parser;
-
-my($res);
-my($tab_depth);
-
-sub pidl ($)
-{
- $res .= shift;
-}
-
-sub tabs()
-{
- my $res = "";
- $res .="\t" foreach (1..$tab_depth);
- return $res;
-}
-
-#####################################################################
-# prototype a typedef
-sub HeaderTypedefProto($)
-{
- my($d) = shift;
-
- my $tf = Parse::Pidl::Samba::NDR::Parser::get_typefamily($d->{DATA}{TYPE});
-
- if (has_property($d, "gensize")) {
- my $size_args = $tf->{SIZE_FN_ARGS}->($d);
- pidl "size_t ndr_size_$d->{NAME}($size_args);\n";
- }
-
- return unless has_property($d, "public");
-
- unless (has_property($d, "nopush")) {
- pidl "NTSTATUS ndr_push_$d->{NAME}(struct ndr_push *ndr, int ndr_flags, " . $tf->{DECL}->($d, "push") . ");\n";
- }
- unless (has_property($d, "nopull")) {
- pidl "NTSTATUS ndr_pull_$d->{NAME}(struct ndr_pull *ndr, int ndr_flags, " . $tf->{DECL}->($d, "pull") . ");\n";
- }
- unless (has_property($d, "noprint")) {
- pidl "void ndr_print_$d->{NAME}(struct ndr_print *ndr, const char *name, " . $tf->{DECL}->($d, "print") . ");\n";
- }
-}
-
-#####################################################################
-# output prototypes for a IDL function
-sub HeaderFnProto($$)
-{
- my ($interface,$fn) = @_;
- my $name = $fn->{NAME};
-
- pidl "void ndr_print_$name(struct ndr_print *ndr, const char *name, int flags, const struct $name *r);\n";
-
- unless (has_property($fn, "noopnum")) {
- pidl "NTSTATUS dcerpc_$name(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r);\n";
- pidl "struct rpc_request *dcerpc_$name\_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r);\n";
- }
-
- return unless has_property($fn, "public");
-
- pidl "NTSTATUS ndr_push_$name(struct ndr_push *ndr, int flags, const struct $name *r);\n";
- pidl "NTSTATUS ndr_pull_$name(struct ndr_pull *ndr, int flags, struct $name *r);\n";
-
- pidl "\n";
-}
-
-#####################################################################
-# parse the interface definitions
-sub HeaderInterface($)
-{
- my($interface) = shift;
-
- if (defined $interface->{PROPERTIES}->{depends}) {
- my @d = split / /, $interface->{PROPERTIES}->{depends};
- foreach my $i (@d) {
- pidl "#include \"librpc/gen_ndr/ndr_$i\.h\"\n";
- }
- }
-
- my $count = 0;
-
- pidl "#ifndef _HEADER_NDR_$interface->{NAME}\n";
- pidl "#define _HEADER_NDR_$interface->{NAME}\n\n";
-
- if (defined $interface->{PROPERTIES}->{uuid}) {
- my $name = uc $interface->{NAME};
- pidl "#define DCERPC_$name\_UUID " .
- Parse::Pidl::Util::make_str($interface->{PROPERTIES}->{uuid}) . "\n";
-
- if(!defined $interface->{PROPERTIES}->{version}) { $interface->{PROPERTIES}->{version} = "0.0"; }
- pidl "#define DCERPC_$name\_VERSION $interface->{PROPERTIES}->{version}\n";
-
- pidl "#define DCERPC_$name\_NAME \"$interface->{NAME}\"\n";
-
- if(!defined $interface->{PROPERTIES}->{helpstring}) { $interface->{PROPERTIES}->{helpstring} = "NULL"; }
- pidl "#define DCERPC_$name\_HELPSTRING $interface->{PROPERTIES}->{helpstring}\n";
-
- pidl "\nextern const struct dcerpc_interface_table dcerpc_table_$interface->{NAME};\n";
- pidl "NTSTATUS dcerpc_server_$interface->{NAME}_init(void);\n\n";
- }
-
- foreach my $d (@{$interface->{DATA}}) {
- next if $d->{TYPE} ne "FUNCTION";
- next if has_property($d, "noopnum");
- next if grep(/$d->{NAME}/,@{$interface->{INHERITED_FUNCTIONS}});
- my $u_name = uc $d->{NAME};
- pidl "#define DCERPC_$u_name (";
-
- if (defined($interface->{BASE})) {
- pidl "DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT + ";
- }
-
- pidl sprintf("0x%02x", $count) . ")\n";
- $count++;
- }
-
- pidl "\n#define DCERPC_" . uc $interface->{NAME} . "_CALL_COUNT (";
-
- if (defined($interface->{BASE})) {
- pidl "DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT + ";
- }
-
- pidl "$count)\n\n";
-
- foreach my $d (@{$interface->{DATA}}) {
- next if ($d->{TYPE} ne "TYPEDEF");
- HeaderTypedefProto($d);
- }
-
- foreach my $d (@{$interface->{DATA}}) {
- next if ($d->{TYPE} ne "FUNCTION");
- HeaderFnProto($interface, $d);
- }
-
- pidl "#endif /* _HEADER_NDR_$interface->{NAME} */\n";
-}
-
-#####################################################################
-# parse a parsed IDL into a C header
-sub Parse($$)
-{
- my($idl,$basename) = @_;
- $tab_depth = 0;
-
- $res = "";
- pidl "/* header auto-generated by pidl */\n";
- pidl "#include \"librpc/gen_ndr/$basename\.h\"\n\n";
-
- foreach my $x (@{$idl}) {
- ($x->{TYPE} eq "INTERFACE") && HeaderInterface($x);
- }
- return $res;
-}
-
-1;
diff --git a/source4/build/pidl/Parse/Pidl/Samba/NDR/Parser.pm b/source4/build/pidl/Parse/Pidl/Samba/NDR/Parser.pm
deleted file mode 100644
index ef22ff9788..0000000000
--- a/source4/build/pidl/Parse/Pidl/Samba/NDR/Parser.pm
+++ /dev/null
@@ -1,2341 +0,0 @@
-###################################################
-# Samba4 NDR parser generator for IDL structures
-# Copyright tridge@samba.org 2000-2003
-# Copyright tpot@samba.org 2001
-# Copyright jelmer@samba.org 2004-2005
-# released under the GNU GPL
-
-package Parse::Pidl::Samba::NDR::Parser;
-
-use strict;
-use Parse::Pidl::Typelist qw(hasType getType mapType);
-use Parse::Pidl::Util qw(has_property ParseExpr);
-use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred);
-
-# list of known types
-my %typefamily;
-
-sub get_typefamily($)
-{
- my $n = shift;
- return $typefamily{$n};
-}
-
-sub append_prefix($$)
-{
- my ($e, $var_name) = @_;
- my $pointers = 0;
-
- foreach my $l (@{$e->{LEVELS}}) {
- if ($l->{TYPE} eq "POINTER") {
- $pointers++;
- } elsif ($l->{TYPE} eq "ARRAY") {
- if (($pointers == 0) and
- (not $l->{IS_FIXED}) and
- (not $l->{IS_INLINE})) {
- return get_value_of($var_name);
- }
- } elsif ($l->{TYPE} eq "DATA") {
- if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
- return get_value_of($var_name) unless ($pointers);
- }
- }
- }
-
- return $var_name;
-}
-
-sub has_fast_array($$)
-{
- my ($e,$l) = @_;
-
- return 0 if ($l->{TYPE} ne "ARRAY");
-
- my $nl = GetNextLevel($e,$l);
- return 0 unless ($nl->{TYPE} eq "DATA");
- return 0 unless (hasType($nl->{DATA_TYPE}));
-
- my $t = getType($nl->{DATA_TYPE});
-
- # Only uint8 and string have fast array functions at the moment
- return ($t->{NAME} eq "uint8") or ($t->{NAME} eq "string");
-}
-
-sub is_charset_array($$)
-{
- my ($e,$l) = @_;
-
- return 0 if ($l->{TYPE} ne "ARRAY");
-
- my $nl = GetNextLevel($e,$l);
-
- return 0 unless ($nl->{TYPE} eq "DATA");
-
- return has_property($e, "charset");
-}
-
-sub get_pointer_to($)
-{
- my $var_name = shift;
-
- if ($var_name =~ /^\*(.*)$/) {
- return $1;
- } elsif ($var_name =~ /^\&(.*)$/) {
- return "&($var_name)";
- } else {
- return "&$var_name";
- }
-}
-
-sub get_value_of($)
-{
- my $var_name = shift;
-
- if ($var_name =~ /^\&(.*)$/) {
- return $1;
- } else {
- return "*$var_name";
- }
-}
-
-my $res = "";
-my $deferred = "";
-my $tabs = "";
-
-####################################
-# pidl() is our basic output routine
-sub pidl($)
-{
- my $d = shift;
- if ($d) {
- $res .= $tabs;
- $res .= $d;
- }
- $res .="\n";
-}
-
-####################################
-# defer() is like pidl(), but adds to
-# a deferred buffer which is then added to the
-# output buffer at the end of the structure/union/function
-# This is needed to cope with code that must be pushed back
-# to the end of a block of elements
-sub defer($)
-{
- my $d = shift;
- if ($d) {
- $deferred .= $tabs;
- $deferred .= $d;
- }
- $deferred .="\n";
-}
-
-########################################
-# add the deferred content to the current
-# output
-sub add_deferred()
-{
- $res .= $deferred;
- $deferred = "";
-}
-
-sub indent()
-{
- $tabs .= "\t";
-}
-
-sub deindent()
-{
- $tabs = substr($tabs, 0, -1);
-}
-
-#####################################################################
-# check that a variable we get from ParseExpr isn't a null pointer
-sub check_null_pointer($)
-{
- my $size = shift;
- if ($size =~ /^\*/) {
- my $size2 = substr($size, 1);
- pidl "if ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;";
- }
-}
-
-#####################################################################
-# check that a variable we get from ParseExpr isn't a null pointer,
-# putting the check at the end of the structure/function
-sub check_null_pointer_deferred($)
-{
- my $size = shift;
- if ($size =~ /^\*/) {
- my $size2 = substr($size, 1);
- defer "if ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;";
- }
-}
-
-#####################################################################
-# check that a variable we get from ParseExpr isn't a null pointer
-# void return varient
-sub check_null_pointer_void($)
-{
- my $size = shift;
- if ($size =~ /^\*/) {
- my $size2 = substr($size, 1);
- pidl "if ($size2 == NULL) return;";
- }
-}
-
-#####################################################################
-# work out is a parse function should be declared static or not
-sub fn_prefix($)
-{
- my $fn = shift;
-
- return "" if (has_property($fn, "public"));
- return "static ";
-}
-
-###################################################################
-# setup any special flags for an element or structure
-sub start_flags($)
-{
- my $e = shift;
- my $flags = has_property($e, "flag");
- if (defined $flags) {
- pidl "{";
- indent;
- pidl "uint32_t _flags_save_$e->{TYPE} = ndr->flags;";
- pidl "ndr_set_flags(&ndr->flags, $flags);";
- }
-}
-
-###################################################################
-# end any special flags for an element or structure
-sub end_flags($)
-{
- my $e = shift;
- my $flags = has_property($e, "flag");
- if (defined $flags) {
- pidl "ndr->flags = _flags_save_$e->{TYPE};";
- deindent;
- pidl "}";
- }
-}
-
-sub GenerateStructEnv($)
-{
- my $x = shift;
- my %env;
-
- foreach my $e (@{$x->{ELEMENTS}}) {
- $env{$e->{NAME}} = "r->$e->{NAME}";
- }
-
- $env{"this"} = "r";
-
- return \%env;
-}
-
-sub GenerateFunctionInEnv($)
-{
- my $fn = shift;
- my %env;
-
- foreach my $e (@{$fn->{ELEMENTS}}) {
- if (grep (/in/, @{$e->{DIRECTION}})) {
- $env{$e->{NAME}} = "r->in.$e->{NAME}";
- }
- }
-
- return \%env;
-}
-
-sub GenerateFunctionOutEnv($)
-{
- my $fn = shift;
- my %env;
-
- foreach my $e (@{$fn->{ELEMENTS}}) {
- if (grep (/out/, @{$e->{DIRECTION}})) {
- $env{$e->{NAME}} = "r->out.$e->{NAME}";
- } elsif (grep (/in/, @{$e->{DIRECTION}})) {
- $env{$e->{NAME}} = "r->in.$e->{NAME}";
- }
- }
-
- return \%env;
-}
-
-#####################################################################
-# parse the data of an array - push side
-sub ParseArrayPushHeader($$$$$)
-{
- my ($e,$l,$ndr,$var_name,$env) = @_;
-
- my $size;
- my $length;
-
- if ($l->{IS_ZERO_TERMINATED}) {
- $size = $length = "ndr_string_length($var_name, sizeof(*$var_name))";
- } else {
- $size = ParseExpr($l->{SIZE_IS}, $env);
- $length = ParseExpr($l->{LENGTH_IS}, $env);
- }
-
- if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) {
- pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, $size));";
- }
-
- if ($l->{IS_VARYING}) {
- pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, 0));"; # array offset
- pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, $length));";
- }
-
- return $length;
-}
-
-#####################################################################
-# parse an array - pull side
-sub ParseArrayPullHeader($$$$$)
-{
- my ($e,$l,$ndr,$var_name,$env) = @_;
-
- my $length;
- my $size;
-
- if ($l->{IS_CONFORMANT}) {
- $length = $size = "ndr_get_array_size($ndr, " . get_pointer_to($var_name) . ")";
- } elsif ($l->{IS_ZERO_TERMINATED}) { # Noheader arrays
- $length = $size = "ndr_get_string_size($ndr, sizeof(*$var_name))";
- } else {
- $length = $size = ParseExpr($l->{SIZE_IS}, $env);
- }
-
- if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) {
- pidl "NDR_CHECK(ndr_pull_array_size(ndr, " . get_pointer_to($var_name) . "));";
- }
-
-
- if ($l->{IS_VARYING}) {
- pidl "NDR_CHECK(ndr_pull_array_length($ndr, " . get_pointer_to($var_name) . "));";
- $length = "ndr_get_array_length($ndr, " . get_pointer_to($var_name) .")";
- }
-
- check_null_pointer($length);
-
- if ($length ne $size) {
- pidl "if ($length > $size) {";
- indent;
- pidl "return ndr_pull_error($ndr, NDR_ERR_ARRAY_SIZE, \"Bad array size %u should exceed array length %u\", $size, $length);";
- deindent;
- pidl "}";
- }
-
- if ($l->{IS_CONFORMANT} and not $l->{IS_ZERO_TERMINATED}) {
- my $size = ParseExpr($l->{SIZE_IS}, $env);
- defer "if ($var_name) {";
- check_null_pointer_deferred($size);
- defer "NDR_CHECK(ndr_check_array_size(ndr, (void*)" . get_pointer_to($var_name) . ", $size));";
- defer "}";
- }
-
- if ($l->{IS_VARYING} and not $l->{IS_ZERO_TERMINATED}) {
- my $length = ParseExpr($l->{LENGTH_IS}, $env);
- defer "if ($var_name) {";
- check_null_pointer_deferred($length);
- defer "NDR_CHECK(ndr_check_array_length(ndr, (void*)" . get_pointer_to($var_name) . ", $length));";
- defer "}"
- }
-
- if (not $l->{IS_FIXED} and not is_charset_array($e, $l)) {
- AllocateArrayLevel($e,$l,$ndr,$env,$size);
- }
-
- return $length;
-}
-
-sub compression_alg($$)
-{
- my ($e,$l) = @_;
- my $compression = $l->{COMPRESSION};
- my ($alg, $clen, $dlen) = split(/ /, $compression);
-
- return $alg;
-}
-
-sub compression_clen($$$)
-{
- my ($e,$l,$env) = @_;
- my $compression = $l->{COMPRESSION};
- my ($alg, $clen, $dlen) = split(/ /, $compression);
-
- return ParseExpr($clen, $env);
-}
-
-sub compression_dlen($$$)
-{
- my ($e,$l,$env) = @_;
- my $compression = $l->{COMPRESSION};
- my ($alg, $clen, $dlen) = split(/ /, $compression);
-
- return ParseExpr($dlen, $env);
-}
-
-sub ParseCompressionPushStart($$$$)
-{
- my ($e,$l,$ndr,$env) = @_;
- my $comndr = "$ndr\_compressed";
- my $alg = compression_alg($e, $l);
- my $dlen = compression_dlen($e, $l, $env);
-
- pidl "{";
- indent;
- pidl "struct ndr_push *$comndr;";
- pidl "NDR_CHECK(ndr_push_compression_start($ndr, &$comndr, $alg, $dlen));";
-
- return $comndr;
-}
-
-sub ParseCompressionPushEnd($$$$)
-{
- my ($e,$l,$ndr,$env) = @_;
- my $comndr = "$ndr\_compressed";
- my $alg = compression_alg($e, $l);
- my $dlen = compression_dlen($e, $l, $env);
-
- pidl "NDR_CHECK(ndr_push_compression_end($ndr, $comndr, $alg, $dlen));";
- deindent;
- pidl "}";
-}
-
-sub ParseCompressionPullStart($$$$)
-{
- my ($e,$l,$ndr,$env) = @_;
- my $comndr = "$ndr\_compressed";
- my $alg = compression_alg($e, $l);
- my $dlen = compression_dlen($e, $l, $env);
-
- pidl "{";
- indent;
- pidl "struct ndr_pull *$comndr;";
- pidl "NDR_CHECK(ndr_pull_compression_start($ndr, &$comndr, $alg, $dlen));";
-
- return $comndr;
-}
-
-sub ParseCompressionPullEnd($$$$)
-{
- my ($e,$l,$ndr,$env) = @_;
- my $comndr = "$ndr\_compressed";
- my $alg = compression_alg($e, $l);
- my $dlen = compression_dlen($e, $l, $env);
-
- pidl "NDR_CHECK(ndr_pull_compression_end($ndr, $comndr, $alg, $dlen));";
- deindent;
- pidl "}";
-}
-
-sub ParseObfuscationPushStart($$)
-{
- my ($e,$ndr) = @_;
- my $obfuscation = has_property($e, "obfuscation");
-
- pidl "NDR_CHECK(ndr_push_obfuscation_start($ndr, $obfuscation));";
-
- return $ndr;
-}
-
-sub ParseObfuscationPushEnd($$)
-{
- my ($e,$ndr) = @_;
- my $obfuscation = has_property($e, "obfuscation");
-
- pidl "NDR_CHECK(ndr_push_obfuscation_end($ndr, $obfuscation));";
-}
-
-sub ParseObfuscationPullStart($$)
-{
- my ($e,$ndr) = @_;
- my $obfuscation = has_property($e, "obfuscation");
-
- pidl "NDR_CHECK(ndr_pull_obfuscation_start($ndr, $obfuscation));";
-
- return $ndr;
-}
-
-sub ParseObfuscationPullEnd($$)
-{
- my ($e,$ndr) = @_;
- my $obfuscation = has_property($e, "obfuscation");
-
- pidl "NDR_CHECK(ndr_pull_obfuscation_end($ndr, $obfuscation));";
-}
-
-sub ParseSubcontextPushStart($$$$)
-{
- my ($e,$l,$ndr,$env) = @_;
- my $subndr = "_ndr_$e->{NAME}";
- my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env);
-
- pidl "{";
- indent;
- pidl "struct ndr_push *$subndr;";
- pidl "NDR_CHECK(ndr_push_subcontext_start($ndr, &$subndr, $l->{HEADER_SIZE}, $subcontext_size));";
-
- if (defined $l->{COMPRESSION}) {
- $subndr = ParseCompressionPushStart($e, $l, $subndr, $env);
- }
-
- if (defined $l->{OBFUSCATION}) {
- $subndr = ParseObfuscationPushStart($e, $subndr);
- }
-
- return $subndr;
-}
-
-sub ParseSubcontextPushEnd($$$$)
-{
- my ($e,$l,$ndr,$env) = @_;
- my $subndr = "_ndr_$e->{NAME}";
- my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env);
-
- if (defined $l->{COMPRESSION}) {
- ParseCompressionPushEnd($e, $l, $subndr, $env);
- }
-
- if (defined $l->{OBFUSCATION}) {
- ParseObfuscationPushEnd($e, $subndr);
- }
-
- pidl "NDR_CHECK(ndr_push_subcontext_end($ndr, $subndr, $l->{HEADER_SIZE}, $subcontext_size));";
- deindent;
- pidl "}";
-}
-
-sub ParseSubcontextPullStart($$$$)
-{
- my ($e,$l,$ndr,$env) = @_;
- my $subndr = "_ndr_$e->{NAME}";
- my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env);
-
- pidl "{";
- indent;
- pidl "struct ndr_pull *$subndr;";
- pidl "NDR_CHECK(ndr_pull_subcontext_start($ndr, &$subndr, $l->{HEADER_SIZE}, $subcontext_size));";
-
- if (defined $l->{COMPRESSION}) {
- $subndr = ParseCompressionPullStart($e, $l, $subndr, $env);
- }
-
- if (defined $l->{OBFUSCATION}) {
- $subndr = ParseObfuscationPullStart($e, $subndr);
- }
-
- return $subndr;
-}
-
-sub ParseSubcontextPullEnd($$$$)
-{
- my ($e,$l,$ndr,$env) = @_;
- my $subndr = "_ndr_$e->{NAME}";
- my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env);
-
- if (defined $l->{COMPRESSION}) {
- ParseCompressionPullEnd($e, $l, $subndr, $env);
- }
-
- if (defined $l->{OBFUSCATION}) {
- ParseObfuscationPullEnd($e, $subndr);
- }
-
- pidl "NDR_CHECK(ndr_pull_subcontext_end($ndr, $subndr, $l->{HEADER_SIZE}, $subcontext_size));";
- deindent;
- pidl "}";
-}
-
-sub ParseElementPushLevel
-{
- my ($e,$l,$ndr,$var_name,$env,$primitives,$deferred) = @_;
-
- my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred);
-
- if ($l->{TYPE} eq "ARRAY" and ($l->{IS_CONFORMANT} or $l->{IS_VARYING}
- or is_charset_array($e, $l))) {
- $var_name = get_pointer_to($var_name);
- }
-
- if (defined($ndr_flags)) {
- if ($l->{TYPE} eq "SUBCONTEXT") {
- my $subndr = ParseSubcontextPushStart($e, $l, $ndr, $env);
- ParseElementPushLevel($e, GetNextLevel($e, $l), $subndr, $var_name, $env, 1, 1);
- ParseSubcontextPushEnd($e, $l, $ndr, $env);
- } elsif ($l->{TYPE} eq "POINTER") {
- ParsePtrPush($e, $l, $var_name);
- } elsif ($l->{TYPE} eq "ARRAY") {
- my $length = ParseArrayPushHeader($e, $l, $ndr, $var_name, $env);
-
- my $nl = GetNextLevel($e, $l);
-
- # Allow speedups for arrays of scalar types
- if (is_charset_array($e,$l)) {
- pidl "NDR_CHECK(ndr_push_charset($ndr, $ndr_flags, $var_name, $length, sizeof(" . mapType($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));";
- return;
- } elsif (has_fast_array($e,$l)) {
- pidl "NDR_CHECK(ndr_push_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));";
- return;
- }
- } elsif ($l->{TYPE} eq "SWITCH") {
- ParseSwitchPush($e, $l, $ndr, $var_name, $ndr_flags, $env);
- } elsif ($l->{TYPE} eq "DATA") {
- ParseDataPush($e, $l, $ndr, $var_name, $ndr_flags);
- }
- }
-
- if ($l->{TYPE} eq "POINTER" and $deferred) {
- if ($l->{POINTER_TYPE} ne "ref") {
- pidl "if ($var_name) {";
- indent;
- if ($l->{POINTER_TYPE} eq "relative") {
- pidl "NDR_CHECK(ndr_push_relative_ptr2(ndr, $var_name));";
- }
- }
- $var_name = get_value_of($var_name);
- ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 1);
-
- if ($l->{POINTER_TYPE} ne "ref") {
- deindent;
- pidl "}";
- }
- } elsif ($l->{TYPE} eq "ARRAY" and not has_fast_array($e,$l) and
- not is_charset_array($e, $l)) {
- my $length = ParseExpr($l->{LENGTH_IS}, $env);
- my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}";
-
- $var_name = $var_name . "[$counter]";
-
- if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) {
- pidl "for ($counter = 0; $counter < $length; $counter++) {";
- indent;
- ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 0);
- deindent;
- pidl "}";
- }
-
- if ($deferred and ContainsDeferred($e, $l)) {
- pidl "for ($counter = 0; $counter < $length; $counter++) {";
- indent;
- ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 0, 1);
- deindent;
- pidl "}";
- }
- } elsif ($l->{TYPE} eq "SWITCH") {
- ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, $primitives, $deferred);
- }
-}
-
-#####################################################################
-# parse scalars in a structure element
-sub ParseElementPush($$$$$$)
-{
- my ($e,$ndr,$var_prefix,$env,$primitives,$deferred) = @_;
- my $subndr = undef;
-
- my $var_name = $var_prefix.$e->{NAME};
-
- $var_name = append_prefix($e, $var_name);
-
- return unless $primitives or ($deferred and ContainsDeferred($e, $e->{LEVELS}[0]));
-
- start_flags($e);
-
- if (my $value = has_property($e, "value")) {
- $var_name = ParseExpr($value, $env);
- }
-
- ParseElementPushLevel($e, $e->{LEVELS}[0], $ndr, $var_name, $env, $primitives, $deferred);
-
- end_flags($e);
-}
-
-#####################################################################
-# parse a pointer in a struct element or function
-sub ParsePtrPush($$$)
-{
- my ($e,$l,$var_name) = @_;
-
- if ($l->{POINTER_TYPE} eq "ref") {
- if ($l->{LEVEL} eq "EMBEDDED") {
- pidl "NDR_CHECK(ndr_push_ref_ptr(ndr, $var_name));";
- } else {
- check_null_pointer(get_value_of($var_name));
- }
- } elsif ($l->{POINTER_TYPE} eq "relative") {
- pidl "NDR_CHECK(ndr_push_relative_ptr1(ndr, $var_name));";
- } elsif ($l->{POINTER_TYPE} eq "unique") {
- pidl "NDR_CHECK(ndr_push_unique_ptr(ndr, $var_name));";
- } elsif ($l->{POINTER_TYPE} eq "sptr") {
- pidl "NDR_CHECK(ndr_push_sptr_ptr(ndr, $var_name));";
- } else {
- die("Unhandled pointer type $l->{POINTER_TYPE}");
- }
-}
-
-#####################################################################
-# print scalars in a structure element
-sub ParseElementPrint($$$)
-{
- my($e,$var_name,$env) = @_;
-
- $var_name = append_prefix($e, $var_name);
- return if (has_property($e, "noprint"));
-
- if (my $value = has_property($e, "value")) {
- $var_name = "(ndr->flags & LIBNDR_PRINT_SET_VALUES)?" . ParseExpr($value,$env) . ":$var_name";
- }
-
- foreach my $l (@{$e->{LEVELS}}) {
- if ($l->{TYPE} eq "POINTER") {
- pidl "ndr_print_ptr(ndr, \"$e->{NAME}\", $var_name);";
- pidl "ndr->depth++;";
- if ($l->{POINTER_TYPE} ne "ref") {
- pidl "if ($var_name) {";
- indent;
- }
- $var_name = get_value_of($var_name);
- } elsif ($l->{TYPE} eq "ARRAY") {
- my $length;
-
- if ($l->{IS_CONFORMANT} or $l->{IS_VARYING} or
- is_charset_array($e,$l)) {
- $var_name = get_pointer_to($var_name);
- }
-
- if ($l->{IS_ZERO_TERMINATED}) {
- $length = "ndr_string_length($var_name, sizeof(*$var_name))";
- } else {
- $length = ParseExpr($l->{LENGTH_IS}, $env);
- }
-
- if (is_charset_array($e,$l)) {
- pidl "ndr_print_string(ndr, \"$e->{NAME}\", $var_name);";
- last;
- } elsif (has_fast_array($e, $l)) {
- my $nl = GetNextLevel($e, $l);
- pidl "ndr_print_array_$nl->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name, $length);";
- last;
- } else {
- my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}";
-
- pidl "ndr->print(ndr, \"\%s: ARRAY(\%d)\", \"$e->{NAME}\", $length);";
- pidl 'ndr->depth++;';
- pidl "for ($counter=0;$counter<$length;$counter++) {";
- indent;
- pidl "char *idx_$l->{LEVEL_INDEX}=NULL;";
- pidl "asprintf(&idx_$l->{LEVEL_INDEX}, \"[\%d]\", $counter);";
- pidl "if (idx_$l->{LEVEL_INDEX}) {";
- indent;
-
- $var_name = $var_name . "[$counter]";
- }
- } elsif ($l->{TYPE} eq "DATA") {
- if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
- $var_name = get_pointer_to($var_name);
- }
- pidl "ndr_print_$l->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name);";
- } elsif ($l->{TYPE} eq "SWITCH") {
- my $switch_var = ParseExpr($l->{SWITCH_IS}, $env);
- check_null_pointer_void($switch_var);
- pidl "ndr_print_set_switch_value(ndr, " . get_pointer_to($var_name) . ", $switch_var);";
- }
- }
-
- foreach my $l (reverse @{$e->{LEVELS}}) {
- if ($l->{TYPE} eq "POINTER") {
- if ($l->{POINTER_TYPE} ne "ref") {
- deindent;
- pidl "}";
- }
- pidl "ndr->depth--;";
- } elsif (($l->{TYPE} eq "ARRAY")
- and not is_charset_array($e,$l)
- and not has_fast_array($e,$l)) {
- pidl "free(idx_$l->{LEVEL_INDEX});";
- deindent;
- pidl "}";
- deindent;
- pidl "}";
- pidl "ndr->depth--;";
- }
- }
-}
-
-#####################################################################
-# parse scalars in a structure element - pull size
-sub ParseSwitchPull($$$$$$)
-{
- my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_;
- my $switch_var = ParseExpr($l->{SWITCH_IS}, $env);
-
- check_null_pointer($switch_var);
-
- $var_name = get_pointer_to($var_name);
- pidl "NDR_CHECK(ndr_pull_set_switch_value($ndr, $var_name, $switch_var));";
-}
-
-#####################################################################
-# push switch element
-sub ParseSwitchPush($$$$$$)
-{
- my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_;
- my $switch_var = ParseExpr($l->{SWITCH_IS}, $env);
-
- check_null_pointer($switch_var);
- $var_name = get_pointer_to($var_name);
- pidl "NDR_CHECK(ndr_push_set_switch_value($ndr, $var_name, $switch_var));";
-}
-
-sub ParseDataPull($$$$$)
-{
- my ($e,$l,$ndr,$var_name,$ndr_flags) = @_;
-
- if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
- $var_name = get_pointer_to($var_name);
- }
-
- $var_name = get_pointer_to($var_name);
-
- pidl "NDR_CHECK(ndr_pull_$l->{DATA_TYPE}($ndr, $ndr_flags, $var_name));";
-
- if (my $range = has_property($e, "range")) {
- $var_name = get_value_of($var_name);
- my ($low, $high) = split(/ /, $range, 2);
- pidl "if ($var_name < $low || $var_name > $high) {";
- pidl "\treturn ndr_pull_error($ndr, NDR_ERR_RANGE, \"value out of range\");";
- pidl "}";
- }
-}
-
-sub ParseDataPush($$$$$)
-{
- my ($e,$l,$ndr,$var_name,$ndr_flags) = @_;
-
- # strings are passed by value rather then reference
- if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
- $var_name = get_pointer_to($var_name);
- }
-
- pidl "NDR_CHECK(ndr_push_$l->{DATA_TYPE}($ndr, $ndr_flags, $var_name));";
-}
-
-sub CalcNdrFlags($$$)
-{
- my ($l,$primitives,$deferred) = @_;
-
- my $scalars = 0;
- my $buffers = 0;
-
- # Add NDR_SCALARS if this one is deferred
- # and deferreds may be pushed
- $scalars = 1 if ($l->{IS_DEFERRED} and $deferred);
-
- # Add NDR_SCALARS if this one is not deferred and
- # primitives may be pushed
- $scalars = 1 if (!$l->{IS_DEFERRED} and $primitives);
-
- # Add NDR_BUFFERS if this one contains deferred stuff
- # and deferreds may be pushed
- $buffers = 1 if ($l->{CONTAINS_DEFERRED} and $deferred);
-
- return "NDR_SCALARS|NDR_BUFFERS" if ($scalars and $buffers);
- return "NDR_SCALARS" if ($scalars);
- return "NDR_BUFFERS" if ($buffers);
- return undef;
-}
-
-sub ParseMemCtxPullStart($$$)
-{
- my $e = shift;
- my $l = shift;
- my $ptr_name = shift;
-
- my $mem_r_ctx = "_mem_save_$e->{NAME}_$l->{LEVEL_INDEX}";
- my $mem_c_ctx = $ptr_name;
- my $mem_c_flags = "0";
-
- return if ($l->{TYPE} eq "ARRAY" and $l->{IS_FIXED});
-
- if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) {
- my $nl = GetNextLevel($e, $l);
- my $next_is_array = ($nl->{TYPE} eq "ARRAY");
- my $next_is_string = (($nl->{TYPE} eq "DATA") and
- ($nl->{DATA_TYPE} eq "string"));
- if ($next_is_array or $next_is_string) {
- return;
- } else {
- $mem_c_flags = "LIBNDR_FLAG_REF_ALLOC";
- }
- }
-
- pidl "$mem_r_ctx = NDR_PULL_GET_MEM_CTX(ndr);";
- pidl "NDR_PULL_SET_MEM_CTX(ndr, $mem_c_ctx, $mem_c_flags);";
-}
-
-sub ParseMemCtxPullEnd($$)
-{
- my $e = shift;
- my $l = shift;
-
- my $mem_r_ctx = "_mem_save_$e->{NAME}_$l->{LEVEL_INDEX}";
- my $mem_r_flags = "0";
-
- return if ($l->{TYPE} eq "ARRAY" and $l->{IS_FIXED});
-
- if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) {
- my $nl = GetNextLevel($e, $l);
- my $next_is_array = ($nl->{TYPE} eq "ARRAY");
- my $next_is_string = (($nl->{TYPE} eq "DATA") and
- ($nl->{DATA_TYPE} eq "string"));
- if ($next_is_array or $next_is_string) {
- return;
- } else {
- $mem_r_flags = "LIBNDR_FLAG_REF_ALLOC";
- }
- }
-
- pidl "NDR_PULL_SET_MEM_CTX(ndr, $mem_r_ctx, $mem_r_flags);";
-}
-
-sub ParseElementPullLevel
-{
- my($e,$l,$ndr,$var_name,$env,$primitives,$deferred) = @_;
-
- my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred);
-
- if ($l->{TYPE} eq "ARRAY" and ($l->{IS_VARYING} or $l->{IS_CONFORMANT}
- or is_charset_array($e,$l))) {
- $var_name = get_pointer_to($var_name);
- }
-
- # Only pull something if there's actually something to be pulled
- if (defined($ndr_flags)) {
- if ($l->{TYPE} eq "SUBCONTEXT") {
- my $subndr = ParseSubcontextPullStart($e, $l, $ndr, $env);
- ParseElementPullLevel($e, GetNextLevel($e,$l), $subndr, $var_name, $env, 1, 1);
- ParseSubcontextPullEnd($e, $l, $ndr, $env);
- } elsif ($l->{TYPE} eq "ARRAY") {
- my $length = ParseArrayPullHeader($e, $l, $ndr, $var_name, $env);
-
- my $nl = GetNextLevel($e, $l);
-
- if (is_charset_array($e,$l)) {
- pidl "NDR_CHECK(ndr_pull_charset($ndr, $ndr_flags, ".get_pointer_to($var_name).", $length, sizeof(" . mapType($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));";
- return;
- } elsif (has_fast_array($e, $l)) {
- pidl "NDR_CHECK(ndr_pull_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));";
- if ($l->{IS_ZERO_TERMINATED}) {
- # Make sure last element is zero!
- pidl "NDR_CHECK(ndr_check_string_terminator($ndr, $var_name, $length, sizeof(*$var_name)));";
- }
- return;
- }
- } elsif ($l->{TYPE} eq "POINTER") {
- ParsePtrPull($e, $l, $ndr, $var_name);
- } elsif ($l->{TYPE} eq "SWITCH") {
- ParseSwitchPull($e, $l, $ndr, $var_name, $ndr_flags, $env);
- } elsif ($l->{TYPE} eq "DATA") {
- ParseDataPull($e, $l, $ndr, $var_name, $ndr_flags);
- }
- }
-
- # add additional constructions
- if ($l->{TYPE} eq "POINTER" and $deferred) {
- if ($l->{POINTER_TYPE} ne "ref") {
- pidl "if ($var_name) {";
- indent;
-
- if ($l->{POINTER_TYPE} eq "relative") {
- pidl "struct ndr_pull_save _relative_save;";
- pidl "ndr_pull_save(ndr, &_relative_save);";
- pidl "NDR_CHECK(ndr_pull_relative_ptr2(ndr, $var_name));";
- }
- }
-
- ParseMemCtxPullStart($e,$l, $var_name);
-
- $var_name = get_value_of($var_name);
- ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 1);
-
- ParseMemCtxPullEnd($e,$l);
-
- if ($l->{POINTER_TYPE} ne "ref") {
- if ($l->{POINTER_TYPE} eq "relative") {
- pidl "ndr_pull_restore(ndr, &_relative_save);";
- }
- deindent;
- pidl "}";
- }
- } elsif ($l->{TYPE} eq "ARRAY" and
- not has_fast_array($e,$l) and not is_charset_array($e, $l)) {
- my $length = ParseExpr($l->{LENGTH_IS}, $env);
- my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}";
- my $array_name = $var_name;
-
- $var_name = $var_name . "[$counter]";
-
- ParseMemCtxPullStart($e,$l, $array_name);
-
- if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) {
- pidl "for ($counter = 0; $counter < $length; $counter++) {";
- indent;
- ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 0);
- deindent;
- pidl "}";
-
- if ($l->{IS_ZERO_TERMINATED}) {
- # Make sure last element is zero!
- pidl "NDR_CHECK(ndr_check_string_terminator($ndr, $var_name, $length, sizeof(*$var_name)));";
- }
- }
-
- if ($deferred and ContainsDeferred($e, $l)) {
- pidl "for ($counter = 0; $counter < $length; $counter++) {";
- indent;
- ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 0, 1);
- deindent;
- pidl "}";
- }
-
- ParseMemCtxPullEnd($e,$l);
-
- } elsif ($l->{TYPE} eq "SWITCH") {
- ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, $primitives, $deferred);
- }
-}
-
-#####################################################################
-# parse scalars in a structure element - pull size
-sub ParseElementPull($$$$$$)
-{
- my($e,$ndr,$var_prefix,$env,$primitives,$deferred) = @_;
-
- my $var_name = $var_prefix.$e->{NAME};
-
- $var_name = append_prefix($e, $var_name);
-
- return unless $primitives or ($deferred and ContainsDeferred($e, $e->{LEVELS}[0]));
-
- start_flags($e);
-
- ParseElementPullLevel($e,$e->{LEVELS}[0],$ndr,$var_name,$env,$primitives,$deferred);
-
- end_flags($e);
-}
-
-#####################################################################
-# parse a pointer in a struct element or function
-sub ParsePtrPull($$$$)
-{
- my($e,$l,$ndr,$var_name) = @_;
-
- my $nl = GetNextLevel($e, $l);
- my $next_is_array = ($nl->{TYPE} eq "ARRAY");
- my $next_is_string = (($nl->{TYPE} eq "DATA") and
- ($nl->{DATA_TYPE} eq "string"));
-
- if ($l->{POINTER_TYPE} eq "ref") {
- unless ($l->{LEVEL} eq "TOP") {
- pidl "NDR_CHECK(ndr_pull_ref_ptr($ndr, &_ptr_$e->{NAME}));";
- }
-
- unless ($next_is_array or $next_is_string) {
- pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {";
- pidl "\tNDR_PULL_ALLOC($ndr, $var_name);";
- pidl "}";
- }
-
- return;
- } elsif (($l->{POINTER_TYPE} eq "unique") or
- ($l->{POINTER_TYPE} eq "relative") or
- ($l->{POINTER_TYPE} eq "sptr")) {
- pidl "NDR_CHECK(ndr_pull_generic_ptr($ndr, &_ptr_$e->{NAME}));";
- pidl "if (_ptr_$e->{NAME}) {";
- indent;
- } else {
- die("Unhandled pointer type $l->{POINTER_TYPE}");
- }
-
- # Don't do this for arrays, they're allocated at the actual level
- # of the array
- unless ($next_is_array or $next_is_string) {
- pidl "NDR_PULL_ALLOC($ndr, $var_name);";
- } else {
- # FIXME: Yes, this is nasty.
- # We allocate an array twice
- # - once just to indicate that it's there,
- # - then the real allocation...
- pidl "NDR_PULL_ALLOC_SIZE($ndr, $var_name, 1);";
- }
-
- #pidl "memset($var_name, 0, sizeof($var_name));";
- if ($l->{POINTER_TYPE} eq "relative") {
- pidl "NDR_CHECK(ndr_pull_relative_ptr1($ndr, $var_name, _ptr_$e->{NAME}));";
- }
- deindent;
- pidl "} else {";
- pidl "\t$var_name = NULL;";
- pidl "}";
-}
-
-#####################################################################
-# parse a struct
-sub ParseStructPush($$)
-{
- my($struct,$name) = @_;
-
- return unless defined($struct->{ELEMENTS});
-
- my $env = GenerateStructEnv($struct);
-
- # save the old relative_base_offset
- pidl "uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);" if defined($struct->{PROPERTIES}{relative_base});
-
- foreach my $e (@{$struct->{ELEMENTS}}) {
- DeclareArrayVariables($e);
- }
-
- start_flags($struct);
-
- # see if the structure contains a conformant array. If it
- # does, then it must be the last element of the structure, and
- # we need to push the conformant length early, as it fits on
- # the wire before the structure (and even before the structure
- # alignment)
- my $e = $struct->{ELEMENTS}[-1];
- if (defined($struct->{SURROUNDING_ELEMENT})) {
- my $e = $struct->{SURROUNDING_ELEMENT};
-
- if (defined($e->{LEVELS}[0]) and
- $e->{LEVELS}[0]->{TYPE} eq "ARRAY") {
- my $size = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env);
-
- pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $size));";
- } else {
- pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_string_array_size(ndr, r->$e->{NAME})));";
- }
- }
-
- pidl "if (ndr_flags & NDR_SCALARS) {";
- indent;
-
- pidl "NDR_CHECK(ndr_push_align(ndr, $struct->{ALIGN}));";
-
- if (defined($struct->{PROPERTIES}{relative_base})) {
- # set the current offset as base for relative pointers
- # and store it based on the toplevel struct/union
- pidl "NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));";
- }
-
- foreach my $e (@{$struct->{ELEMENTS}}) {
- ParseElementPush($e, "ndr", "r->", $env, 1, 0);
- }
-
- deindent;
- pidl "}";
-
- pidl "if (ndr_flags & NDR_BUFFERS) {";
- indent;
- if (defined($struct->{PROPERTIES}{relative_base})) {
- # retrieve the current offset as base for relative pointers
- # based on the toplevel struct/union
- pidl "NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));";
- }
- foreach my $e (@{$struct->{ELEMENTS}}) {
- ParseElementPush($e, "ndr", "r->", $env, 0, 1);
- }
-
- deindent;
- pidl "}";
-
- end_flags($struct);
- # restore the old relative_base_offset
- pidl "ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($struct->{PROPERTIES}{relative_base});
-}
-
-#####################################################################
-# generate a push function for an enum
-sub ParseEnumPush($$)
-{
- my($enum,$name) = @_;
- my($type_fn) = $enum->{BASE_TYPE};
-
- start_flags($enum);
- pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));";
- end_flags($enum);
-}
-
-#####################################################################
-# generate a pull function for an enum
-sub ParseEnumPull($$)
-{
- my($enum,$name) = @_;
- my($type_fn) = $enum->{BASE_TYPE};
- my($type_v_decl) = mapType($type_fn);
-
- pidl "$type_v_decl v;";
- start_flags($enum);
- pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));";
- pidl "*r = v;";
-
- end_flags($enum);
-}
-
-#####################################################################
-# generate a print function for an enum
-sub ParseEnumPrint($$)
-{
- my($enum,$name) = @_;
-
- pidl "const char *val = NULL;";
- pidl "";
-
- start_flags($enum);
-
- pidl "switch (r) {";
- indent;
- my $els = \@{$enum->{ELEMENTS}};
- foreach my $i (0 .. $#{$els}) {
- my $e = ${$els}[$i];
- chomp $e;
- if ($e =~ /^(.*)=/) {
- $e = $1;
- }
- pidl "case $e: val = \"$e\"; break;";
- }
-
- deindent;
- pidl "}";
-
- pidl "ndr_print_enum(ndr, name, \"$enum->{TYPE}\", val, r);";
-
- end_flags($enum);
-}
-
-sub DeclEnum($)
-{
- my ($e,$t) = @_;
- return "enum $e->{NAME} " .
- ($t eq "pull"?"*":"") . "r";
-}
-
-$typefamily{ENUM} = {
- DECL => \&DeclEnum,
- PUSH_FN_BODY => \&ParseEnumPush,
- PULL_FN_BODY => \&ParseEnumPull,
- PRINT_FN_BODY => \&ParseEnumPrint,
-};
-
-#####################################################################
-# generate a push function for a bitmap
-sub ParseBitmapPush($$)
-{
- my($bitmap,$name) = @_;
- my($type_fn) = $bitmap->{BASE_TYPE};
-
- start_flags($bitmap);
-
- pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));";
-
- end_flags($bitmap);
-}
-
-#####################################################################
-# generate a pull function for an bitmap
-sub ParseBitmapPull($$)
-{
- my($bitmap,$name) = @_;
- my $type_fn = $bitmap->{BASE_TYPE};
- my($type_decl) = mapType($bitmap->{BASE_TYPE});
-
- pidl "$type_decl v;";
- start_flags($bitmap);
- pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));";
- pidl "*r = v;";
-
- end_flags($bitmap);
-}
-
-#####################################################################
-# generate a print function for an bitmap
-sub ParseBitmapPrintElement($$$)
-{
- my($e,$bitmap,$name) = @_;
- my($type_decl) = mapType($bitmap->{BASE_TYPE});
- my($type_fn) = $bitmap->{BASE_TYPE};
- my($flag);
-
- if ($e =~ /^(\w+) .*$/) {
- $flag = "$1";
- } else {
- die "Bitmap: \"$name\" invalid Flag: \"$e\"";
- }
-
- pidl "ndr_print_bitmap_flag(ndr, sizeof($type_decl), \"$flag\", $flag, r);";
-}
-
-#####################################################################
-# generate a print function for an bitmap
-sub ParseBitmapPrint($$)
-{
- my($bitmap,$name) = @_;
- my($type_decl) = mapType($bitmap->{TYPE});
- my($type_fn) = $bitmap->{BASE_TYPE};
-
- start_flags($bitmap);
-
- pidl "ndr_print_$type_fn(ndr, name, r);";
-
- pidl "ndr->depth++;";
- foreach my $e (@{$bitmap->{ELEMENTS}}) {
- ParseBitmapPrintElement($e, $bitmap, $name);
- }
- pidl "ndr->depth--;";
-
- end_flags($bitmap);
-}
-
-sub DeclBitmap($$)
-{
- my ($e,$t) = @_;
- return mapType(Parse::Pidl::Typelist::bitmap_type_fn($e->{DATA})) .
- ($t eq "pull"?" *":" ") . "r";
-}
-
-$typefamily{BITMAP} = {
- DECL => \&DeclBitmap,
- PUSH_FN_BODY => \&ParseBitmapPush,
- PULL_FN_BODY => \&ParseBitmapPull,
- PRINT_FN_BODY => \&ParseBitmapPrint,
-};
-
-#####################################################################
-# generate a struct print function
-sub ParseStructPrint($$)
-{
- my($struct,$name) = @_;
-
- return unless defined $struct->{ELEMENTS};
-
- my $env = GenerateStructEnv($struct);
-
- foreach my $e (@{$struct->{ELEMENTS}}) {
- DeclareArrayVariables($e);
- }
-
- pidl "ndr_print_struct(ndr, name, \"$name\");";
-
- start_flags($struct);
-
- pidl "ndr->depth++;";
- foreach my $e (@{$struct->{ELEMENTS}}) {
- ParseElementPrint($e, "r->$e->{NAME}", $env);
- }
- pidl "ndr->depth--;";
-
- end_flags($struct);
-}
-
-sub DeclarePtrVariables($)
-{
- my $e = shift;
- foreach my $l (@{$e->{LEVELS}}) {
- if ($l->{TYPE} eq "POINTER" and
- not ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "TOP")) {
- pidl "uint32_t _ptr_$e->{NAME};";
- last;
- }
- }
-}
-
-sub DeclareArrayVariables($)
-{
- my $e = shift;
-
- foreach my $l (@{$e->{LEVELS}}) {
- next if has_fast_array($e,$l);
- next if is_charset_array($e,$l);
- if ($l->{TYPE} eq "ARRAY") {
- pidl "uint32_t cntr_$e->{NAME}_$l->{LEVEL_INDEX};";
- }
- }
-}
-
-sub need_decl_mem_ctx($$)
-{
- my $e = shift;
- my $l = shift;
-
- return 0 if has_fast_array($e,$l);
- return 0 if is_charset_array($e,$l);
- return 1 if (($l->{TYPE} eq "ARRAY") and not $l->{IS_FIXED});
-
- if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) {
- my $nl = GetNextLevel($e, $l);
- my $next_is_array = ($nl->{TYPE} eq "ARRAY");
- my $next_is_string = (($nl->{TYPE} eq "DATA") and
- ($nl->{DATA_TYPE} eq "string"));
- return 0 if ($next_is_array or $next_is_string);
- }
- return 1 if ($l->{TYPE} eq "POINTER");
-
- return 0;
-}
-
-sub DeclareMemCtxVariables($)
-{
- my $e = shift;
- foreach my $l (@{$e->{LEVELS}}) {
- if (need_decl_mem_ctx($e, $l)) {
- pidl "TALLOC_CTX *_mem_save_$e->{NAME}_$l->{LEVEL_INDEX};";
- }
- }
-}
-
-#####################################################################
-# parse a struct - pull side
-sub ParseStructPull($$)
-{
- my($struct,$name) = @_;
-
- return unless defined $struct->{ELEMENTS};
-
- my $env = GenerateStructEnv($struct);
-
- # declare any internal pointers we need
- foreach my $e (@{$struct->{ELEMENTS}}) {
- DeclarePtrVariables($e);
- DeclareArrayVariables($e);
- DeclareMemCtxVariables($e);
- }
-
- # save the old relative_base_offset
- pidl "uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);" if defined($struct->{PROPERTIES}{relative_base});
-
- start_flags($struct);
-
- pidl "if (ndr_flags & NDR_SCALARS) {";
- indent;
-
- if (defined $struct->{SURROUNDING_ELEMENT}) {
- pidl "NDR_CHECK(ndr_pull_array_size(ndr, &r->$struct->{SURROUNDING_ELEMENT}->{NAME}));";
- }
-
- pidl "NDR_CHECK(ndr_pull_align(ndr, $struct->{ALIGN}));";
-
- if (defined($struct->{PROPERTIES}{relative_base})) {
- # set the current offset as base for relative pointers
- # and store it based on the toplevel struct/union
- pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));";
- }
-
- foreach my $e (@{$struct->{ELEMENTS}}) {
- ParseElementPull($e, "ndr", "r->", $env, 1, 0);
- }
-
- add_deferred();
-
- deindent;
- pidl "}";
- pidl "if (ndr_flags & NDR_BUFFERS) {";
- indent;
- if (defined($struct->{PROPERTIES}{relative_base})) {
- # retrieve the current offset as base for relative pointers
- # based on the toplevel struct/union
- pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));";
- }
- foreach my $e (@{$struct->{ELEMENTS}}) {
- ParseElementPull($e, "ndr", "r->", $env, 0, 1);
- }
-
- add_deferred();
-
- deindent;
- pidl "}";
-
- end_flags($struct);
- # restore the old relative_base_offset
- pidl "ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($struct->{PROPERTIES}{relative_base});
-}
-
-#####################################################################
-# calculate size of ndr struct
-sub ParseStructNdrSize($)
-{
- my $t = shift;
- my $sizevar;
-
- if (my $flags = has_property($t, "flag")) {
- pidl "flags |= $flags;";
- }
- pidl "return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});";
-}
-
-sub DeclStruct($)
-{
- my ($e,$t) = @_;
- return ($t ne "pull"?"const ":"") . "struct $e->{NAME} *r";
-}
-
-sub ArgsStructNdrSize($)
-{
- my $d = shift;
- return "const struct $d->{NAME} *r, int flags";
-}
-
-$typefamily{STRUCT} = {
- PUSH_FN_BODY => \&ParseStructPush,
- DECL => \&DeclStruct,
- PULL_FN_BODY => \&ParseStructPull,
- PRINT_FN_BODY => \&ParseStructPrint,
- SIZE_FN_BODY => \&ParseStructNdrSize,
- SIZE_FN_ARGS => \&ArgsStructNdrSize,
-};
-
-#####################################################################
-# calculate size of ndr struct
-sub ParseUnionNdrSize($)
-{
- my $t = shift;
- my $sizevar;
-
- if (my $flags = has_property($t, "flag")) {
- pidl "flags |= $flags;";
- }
-
- pidl "return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});";
-}
-
-#####################################################################
-# parse a union - push side
-sub ParseUnionPush($$)
-{
- my ($e,$name) = @_;
- my $have_default = 0;
-
- # save the old relative_base_offset
- pidl "uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);" if defined($e->{PROPERTIES}{relative_base});
- pidl "int level;";
-
- start_flags($e);
-
- pidl "level = ndr_push_get_switch_value(ndr, r);";
-
- pidl "if (ndr_flags & NDR_SCALARS) {";
- indent;
-
- if (defined($e->{SWITCH_TYPE})) {
- pidl "NDR_CHECK(ndr_push_$e->{SWITCH_TYPE}(ndr, NDR_SCALARS, level));";
- }
-
- pidl "switch (level) {";
- indent;
- foreach my $el (@{$e->{ELEMENTS}}) {
- if ($el->{CASE} eq "default") {
- $have_default = 1;
- }
- pidl "$el->{CASE}:";
-
- if ($el->{TYPE} ne "EMPTY") {
- indent;
- if (defined($e->{PROPERTIES}{relative_base})) {
- pidl "NDR_CHECK(ndr_push_align(ndr, $el->{ALIGN}));";
- # set the current offset as base for relative pointers
- # and store it based on the toplevel struct/union
- pidl "NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));";
- }
- DeclareArrayVariables($el);
- ParseElementPush($el, "ndr", "r->", {}, 1, 0);
- deindent;
- }
- pidl "break;";
- pidl "";
- }
- if (! $have_default) {
- pidl "default:";
- pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
- }
- deindent;
- pidl "}";
- deindent;
- pidl "}";
- pidl "if (ndr_flags & NDR_BUFFERS) {";
- indent;
- if (defined($e->{PROPERTIES}{relative_base})) {
- # retrieve the current offset as base for relative pointers
- # based on the toplevel struct/union
- pidl "NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));";
- }
- pidl "switch (level) {";
- indent;
- foreach my $el (@{$e->{ELEMENTS}}) {
- pidl "$el->{CASE}:";
- if ($el->{TYPE} ne "EMPTY") {
- indent;
- ParseElementPush($el, "ndr", "r->", {}, 0, 1);
- deindent;
- }
- pidl "break;";
- pidl "";
- }
- if (! $have_default) {
- pidl "default:";
- pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
- }
- deindent;
- pidl "}";
-
- deindent;
- pidl "}";
- end_flags($e);
- # restore the old relative_base_offset
- pidl "ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($e->{PROPERTIES}{relative_base});
-}
-
-#####################################################################
-# print a union
-sub ParseUnionPrint($$)
-{
- my ($e,$name) = @_;
- my $have_default = 0;
-
- pidl "int level = ndr_print_get_switch_value(ndr, r);";
-
- foreach my $el (@{$e->{ELEMENTS}}) {
- DeclareArrayVariables($el);
- }
-
- pidl "ndr_print_union(ndr, name, level, \"$name\");";
- start_flags($e);
-
- pidl "switch (level) {";
- indent;
- foreach my $el (@{$e->{ELEMENTS}}) {
- if ($el->{CASE} eq "default") {
- $have_default = 1;
- }
- pidl "$el->{CASE}:";
- if ($el->{TYPE} ne "EMPTY") {
- indent;
- ParseElementPrint($el, "r->$el->{NAME}", {});
- deindent;
- }
- pidl "break;";
- pidl "";
- }
- if (! $have_default) {
- pidl "default:";
- pidl "\tndr_print_bad_level(ndr, name, level);";
- }
- deindent;
- pidl "}";
-
- end_flags($e);
-}
-
-#####################################################################
-# parse a union - pull side
-sub ParseUnionPull($$)
-{
- my ($e,$name) = @_;
- my $have_default = 0;
- my $switch_type = $e->{SWITCH_TYPE};
-
- # save the old relative_base_offset
- pidl "uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);" if defined($e->{PROPERTIES}{relative_base});
- pidl "int level;";
- if (defined($switch_type)) {
- if (Parse::Pidl::Typelist::typeIs($switch_type, "ENUM")) {
- $switch_type = Parse::Pidl::Typelist::enum_type_fn(getType($switch_type));
- }
- pidl mapType($switch_type) . " _level;";
- }
-
- my %double_cases = ();
- foreach my $el (@{$e->{ELEMENTS}}) {
- next if ($el->{TYPE} eq "EMPTY");
- next if ($double_cases{"$el->{NAME}"});
- DeclareMemCtxVariables($el);
- $double_cases{"$el->{NAME}"} = 1;
- }
-
- start_flags($e);
-
- pidl "level = ndr_pull_get_switch_value(ndr, r);";
-
- pidl "if (ndr_flags & NDR_SCALARS) {";
- indent;
-
- if (defined($switch_type)) {
- pidl "NDR_CHECK(ndr_pull_$switch_type(ndr, NDR_SCALARS, &_level));";
- pidl "if (_level != level) {";
- pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u for $name\", _level);";
- pidl "}";
- }
-
- pidl "switch (level) {";
- indent;
- foreach my $el (@{$e->{ELEMENTS}}) {
- if ($el->{CASE} eq "default") {
- $have_default = 1;
- }
- pidl "$el->{CASE}: {";
-
- if ($el->{TYPE} ne "EMPTY") {
- indent;
- DeclarePtrVariables($el);
- DeclareArrayVariables($el);
- if (defined($e->{PROPERTIES}{relative_base})) {
- pidl "NDR_CHECK(ndr_pull_align(ndr, $el->{ALIGN}));";
- # set the current offset as base for relative pointers
- # and store it based on the toplevel struct/union
- pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));";
- }
- ParseElementPull($el, "ndr", "r->", {}, 1, 0);
- deindent;
- }
- pidl "break; }";
- pidl "";
- }
- if (! $have_default) {
- pidl "default:";
- pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
- }
- deindent;
- pidl "}";
- deindent;
- pidl "}";
- pidl "if (ndr_flags & NDR_BUFFERS) {";
- indent;
- if (defined($e->{PROPERTIES}{relative_base})) {
- # retrieve the current offset as base for relative pointers
- # based on the toplevel struct/union
- pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));";
- }
- pidl "switch (level) {";
- indent;
- foreach my $el (@{$e->{ELEMENTS}}) {
- pidl "$el->{CASE}:";
- if ($el->{TYPE} ne "EMPTY") {
- indent;
- ParseElementPull($el, "ndr", "r->", {}, 0, 1);
- deindent;
- }
- pidl "break;";
- pidl "";
- }
- if (! $have_default) {
- pidl "default:";
- pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
- }
- deindent;
- pidl "}";
-
- deindent;
- pidl "}";
-
- add_deferred();
-
- end_flags($e);
- # restore the old relative_base_offset
- pidl "ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($e->{PROPERTIES}{relative_base});
-}
-
-sub DeclUnion($$)
-{
- my ($e,$t) = @_;
- return ($t ne "pull"?"const ":"") . "union $e->{NAME} *r";
-}
-
-sub ArgsUnionNdrSize($)
-{
- my $d = shift;
- return "const union $d->{NAME} *r, uint32_t level, int flags";
-}
-
-$typefamily{UNION} = {
- PUSH_FN_BODY => \&ParseUnionPush,
- DECL => \&DeclUnion,
- PULL_FN_BODY => \&ParseUnionPull,
- PRINT_FN_BODY => \&ParseUnionPrint,
- SIZE_FN_ARGS => \&ArgsUnionNdrSize,
- SIZE_FN_BODY => \&ParseUnionNdrSize,
-};
-
-#####################################################################
-# parse a typedef - push side
-sub ParseTypedefPush($)
-{
- my($e) = shift;
-
- my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"push");
- pidl fn_prefix($e) . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, $args)";
-
- pidl "{";
- indent;
- $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($e->{DATA}, $e->{NAME});
- pidl "return NT_STATUS_OK;";
- deindent;
- pidl "}";
- pidl "";;
-}
-
-#####################################################################
-# parse a typedef - pull side
-sub ParseTypedefPull($)
-{
- my($e) = shift;
-
- my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"pull");
-
- pidl fn_prefix($e) . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, $args)";
-
- pidl "{";
- indent;
- $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($e->{DATA}, $e->{NAME});
- pidl "return NT_STATUS_OK;";
- deindent;
- pidl "}";
- pidl "";
-}
-
-#####################################################################
-# parse a typedef - print side
-sub ParseTypedefPrint($)
-{
- my($e) = shift;
-
- my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"print");
-
- pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args)";
- pidl "{";
- indent;
- $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($e->{DATA}, $e->{NAME});
- deindent;
- pidl "}";
- pidl "";
-}
-
-#####################################################################
-## calculate the size of a structure
-sub ParseTypedefNdrSize($)
-{
- my($t) = shift;
-
- my $tf = $typefamily{$t->{DATA}->{TYPE}};
- my $args = $tf->{SIZE_FN_ARGS}->($t);
-
- pidl "size_t ndr_size_$t->{NAME}($args)";
- pidl "{";
- indent;
- $typefamily{$t->{DATA}->{TYPE}}->{SIZE_FN_BODY}->($t);
- deindent;
- pidl "}";
- pidl "";
-}
-
-#####################################################################
-# parse a function - print side
-sub ParseFunctionPrint($)
-{
- my($fn) = shift;
-
- return if has_property($fn, "noprint");
-
- pidl "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r)";
- pidl "{";
- indent;
-
- foreach my $e (@{$fn->{ELEMENTS}}) {
- DeclareArrayVariables($e);
- }
-
- pidl "ndr_print_struct(ndr, name, \"$fn->{NAME}\");";
- pidl "ndr->depth++;";
-
- pidl "if (flags & NDR_SET_VALUES) {";
- pidl "\tndr->flags |= LIBNDR_PRINT_SET_VALUES;";
- pidl "}";
-
- pidl "if (flags & NDR_IN) {";
- indent;
- pidl "ndr_print_struct(ndr, \"in\", \"$fn->{NAME}\");";
- pidl "ndr->depth++;";
-
- my $env = GenerateFunctionInEnv($fn);
-
- foreach my $e (@{$fn->{ELEMENTS}}) {
- if (grep(/in/,@{$e->{DIRECTION}})) {
- ParseElementPrint($e, "r->in.$e->{NAME}", $env);
- }
- }
- pidl "ndr->depth--;";
- deindent;
- pidl "}";
-
- pidl "if (flags & NDR_OUT) {";
- indent;
- pidl "ndr_print_struct(ndr, \"out\", \"$fn->{NAME}\");";
- pidl "ndr->depth++;";
-
- $env = GenerateFunctionOutEnv($fn);
- foreach my $e (@{$fn->{ELEMENTS}}) {
- if (grep(/out/,@{$e->{DIRECTION}})) {
- ParseElementPrint($e, "r->out.$e->{NAME}", $env);
- }
- }
- if ($fn->{RETURN_TYPE}) {
- pidl "ndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", r->out.result);";
- }
- pidl "ndr->depth--;";
- deindent;
- pidl "}";
-
- pidl "ndr->depth--;";
- deindent;
- pidl "}";
- pidl "";
-}
-
-#####################################################################
-# parse a function
-sub ParseFunctionPush($)
-{
- my($fn) = shift;
-
- return if has_property($fn, "nopush");
-
- pidl fn_prefix($fn) . "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, const struct $fn->{NAME} *r)";
- pidl "{";
- indent;
-
- foreach my $e (@{$fn->{ELEMENTS}}) {
- DeclareArrayVariables($e);
- }
-
- pidl "if (flags & NDR_IN) {";
- indent;
-
- my $env = GenerateFunctionInEnv($fn);
-
- foreach my $e (@{$fn->{ELEMENTS}}) {
- if (grep(/in/,@{$e->{DIRECTION}})) {
- ParseElementPush($e, "ndr", "r->in.", $env, 1, 1);
- }
- }
-
- deindent;
- pidl "}";
-
- pidl "if (flags & NDR_OUT) {";
- indent;
-
- $env = GenerateFunctionOutEnv($fn);
- foreach my $e (@{$fn->{ELEMENTS}}) {
- if (grep(/out/,@{$e->{DIRECTION}})) {
- ParseElementPush($e, "ndr", "r->out.", $env, 1, 1);
- }
- }
-
- if ($fn->{RETURN_TYPE}) {
- pidl "NDR_CHECK(ndr_push_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, r->out.result));";
- }
-
- deindent;
- pidl "}";
- pidl "return NT_STATUS_OK;";
- deindent;
- pidl "}";
- pidl "";
-}
-
-sub AllocateArrayLevel($$$$$)
-{
- my ($e,$l,$ndr,$env,$size) = @_;
-
- my $var = ParseExpr($e->{NAME}, $env);
-
- check_null_pointer($size);
- my $pl = GetPrevLevel($e, $l);
- if (defined($pl) and
- $pl->{TYPE} eq "POINTER" and
- $pl->{POINTER_TYPE} eq "ref"
- and not $l->{IS_ZERO_TERMINATED}) {
- pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {";
- pidl "\tNDR_PULL_ALLOC_N($ndr, $var, $size);";
- pidl "}";
- } else {
- pidl "NDR_PULL_ALLOC_N($ndr, $var, $size);";
- }
-
- if (grep(/in/,@{$e->{DIRECTION}}) and
- grep(/out/,@{$e->{DIRECTION}}) and
- $pl->{POINTER_TYPE} eq "ref") {
- pidl "memcpy(r->out.$e->{NAME},r->in.$e->{NAME},$size * sizeof(*r->in.$e->{NAME}));";
- }
-}
-
-#####################################################################
-# parse a function
-sub ParseFunctionPull($)
-{
- my($fn) = shift;
-
- return if has_property($fn, "nopull");
-
- # pull function args
- pidl fn_prefix($fn) . "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)";
- pidl "{";
- indent;
-
- # declare any internal pointers we need
- foreach my $e (@{$fn->{ELEMENTS}}) {
- DeclarePtrVariables($e);
- DeclareArrayVariables($e);
- }
-
- my %double_cases = ();
- foreach my $e (@{$fn->{ELEMENTS}}) {
- next if ($e->{TYPE} eq "EMPTY");
- next if ($double_cases{"$e->{NAME}"});
- DeclareMemCtxVariables($e);
- $double_cases{"$e->{NAME}"} = 1;
- }
-
- pidl "if (flags & NDR_IN) {";
- indent;
-
- # auto-init the out section of a structure. I originally argued that
- # this was a bad idea as it hides bugs, but coping correctly
- # with initialisation and not wiping ref vars is turning
- # out to be too tricky (tridge)
- foreach my $e (@{$fn->{ELEMENTS}}) {
- next unless grep(/out/, @{$e->{DIRECTION}});
- pidl "ZERO_STRUCT(r->out);";
- pidl "";
- last;
- }
-
- my $env = GenerateFunctionInEnv($fn);
-
- foreach my $e (@{$fn->{ELEMENTS}}) {
- next unless (grep(/in/, @{$e->{DIRECTION}}));
- ParseElementPull($e, "ndr", "r->in.", $env, 1, 1);
- }
-
- # allocate the "simple" out ref variables. FIXME: Shouldn't this have it's
- # own flag rather then be in NDR_IN ?
-
- foreach my $e (@{$fn->{ELEMENTS}}) {
- next unless (grep(/out/, @{$e->{DIRECTION}}));
- next unless ($e->{LEVELS}[0]->{TYPE} eq "POINTER" and
- $e->{LEVELS}[0]->{POINTER_TYPE} eq "ref");
- next if (($e->{LEVELS}[1]->{TYPE} eq "DATA") and
- ($e->{LEVELS}[1]->{DATA_TYPE} eq "string"));
- next if (($e->{LEVELS}[1]->{TYPE} eq "ARRAY")
- and $e->{LEVELS}[1]->{IS_ZERO_TERMINATED});
-
- if ($e->{LEVELS}[1]->{TYPE} eq "ARRAY") {
- my $size = ParseExpr($e->{LEVELS}[1]->{SIZE_IS}, $env);
- check_null_pointer($size);
-
- pidl "NDR_PULL_ALLOC_N(ndr, r->out.$e->{NAME}, $size);";
-
- if (grep(/in/, @{$e->{DIRECTION}})) {
- pidl "memcpy(r->out.$e->{NAME}, r->in.$e->{NAME}, $size * sizeof(*r->in.$e->{NAME}));";
- } else {
- pidl "memset(r->out.$e->{NAME}, 0, $size * sizeof(*r->out.$e->{NAME}));";
- }
- } else {
- pidl "NDR_PULL_ALLOC(ndr, r->out.$e->{NAME});";
-
- if (grep(/in/, @{$e->{DIRECTION}})) {
- pidl "*r->out.$e->{NAME} = *r->in.$e->{NAME};";
- } else {
- pidl "ZERO_STRUCTP(r->out.$e->{NAME});";
- }
- }
- }
-
- add_deferred();
- deindent;
- pidl "}";
-
- pidl "if (flags & NDR_OUT) {";
- indent;
-
- $env = GenerateFunctionOutEnv($fn);
- foreach my $e (@{$fn->{ELEMENTS}}) {
- next unless grep(/out/, @{$e->{DIRECTION}});
- ParseElementPull($e, "ndr", "r->out.", $env, 1, 1);
- }
-
- if ($fn->{RETURN_TYPE}) {
- pidl "NDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, &r->out.result));";
- }
-
- add_deferred();
- deindent;
- pidl "}";
-
- pidl "return NT_STATUS_OK;";
- deindent;
- pidl "}";
- pidl "";
-}
-
-#####################################################################
-# produce a function call table
-sub FunctionTable($)
-{
- my($interface) = shift;
- my $count = 0;
- my $uname = uc $interface->{NAME};
-
- $count = $#{$interface->{FUNCTIONS}}+1;
-
- return if ($count == 0);
-
- pidl "static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {";
- $count = 0;
- foreach my $d (@{$interface->{FUNCTIONS}}) {
- next if not defined($d->{OPNUM});
- pidl "\t{";
- pidl "\t\t\"$d->{NAME}\",";
- pidl "\t\tsizeof(struct $d->{NAME}),";
- pidl "\t\t(ndr_push_flags_fn_t) ndr_push_$d->{NAME},";
- pidl "\t\t(ndr_pull_flags_fn_t) ndr_pull_$d->{NAME},";
- pidl "\t\t(ndr_print_function_t) ndr_print_$d->{NAME}";
- pidl "\t},";
- $count++;
- }
- pidl "\t{ NULL, 0, NULL, NULL, NULL }";
- pidl "};";
- pidl "";
-
- pidl "static const char * const $interface->{NAME}\_endpoint_strings[] = {";
- foreach my $ep (@{$interface->{ENDPOINTS}}) {
- pidl "\t$ep, ";
- }
- my $endpoint_count = $#{$interface->{ENDPOINTS}}+1;
-
- pidl "};";
- pidl "";
-
- pidl "static const struct dcerpc_endpoint_list $interface->{NAME}\_endpoints = {";
- pidl "\t.count\t= $endpoint_count,";
- pidl "\t.names\t= $interface->{NAME}\_endpoint_strings";
- pidl "};";
- pidl "";
-
- if (! defined $interface->{PROPERTIES}->{authservice}) {
- $interface->{PROPERTIES}->{authservice} = "\"host\"";
- }
-
- my @a = split / /, $interface->{PROPERTIES}->{authservice};
- my $authservice_count = $#a + 1;
-
- pidl "static const char * const $interface->{NAME}\_authservice_strings[] = {";
- foreach my $ap (@a) {
- pidl "\t$ap, ";
- }
- pidl "};";
- pidl "";
-
- pidl "static const struct dcerpc_authservice_list $interface->{NAME}\_authservices = {";
- pidl "\t.count\t= $endpoint_count,";
- pidl "\t.names\t= $interface->{NAME}\_authservice_strings";
- pidl "};";
- pidl "";
-
- pidl "\nconst struct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {";
- pidl "\t.name\t\t= \"$interface->{NAME}\",";
- pidl "\t.uuid\t\t= DCERPC_$uname\_UUID,";
- pidl "\t.if_version\t= DCERPC_$uname\_VERSION,";
- pidl "\t.helpstring\t= DCERPC_$uname\_HELPSTRING,";
- pidl "\t.num_calls\t= $count,";
- pidl "\t.calls\t\t= $interface->{NAME}\_calls,";
- pidl "\t.endpoints\t= &$interface->{NAME}\_endpoints,";
- pidl "\t.authservices\t= &$interface->{NAME}\_authservices";
- pidl "};";
- pidl "";
-
- pidl "static NTSTATUS dcerpc_ndr_$interface->{NAME}_init(void)";
- pidl "{";
- pidl "\treturn librpc_register_interface(&dcerpc_table_$interface->{NAME});";
- pidl "}";
- pidl "";
-}
-
-#####################################################################
-# parse the interface definitions
-sub ParseInterface($$)
-{
- my($interface,$needed) = @_;
-
- # Typedefs
- foreach my $d (@{$interface->{TYPEDEFS}}) {
- ($needed->{"push_$d->{NAME}"}) && ParseTypedefPush($d);
- ($needed->{"pull_$d->{NAME}"}) && ParseTypedefPull($d);
- ($needed->{"print_$d->{NAME}"}) && ParseTypedefPrint($d);
-
- # Make sure we don't generate a function twice...
- $needed->{"push_$d->{NAME}"} = $needed->{"pull_$d->{NAME}"} =
- $needed->{"print_$d->{NAME}"} = 0;
-
- ($needed->{"ndr_size_$d->{NAME}"}) && ParseTypedefNdrSize($d);
- }
-
- # Functions
- foreach my $d (@{$interface->{FUNCTIONS}}) {
- ($needed->{"push_$d->{NAME}"}) && ParseFunctionPush($d);
- ($needed->{"pull_$d->{NAME}"}) && ParseFunctionPull($d);
- ($needed->{"print_$d->{NAME}"}) && ParseFunctionPrint($d);
-
- # Make sure we don't generate a function twice...
- $needed->{"push_$d->{NAME}"} = $needed->{"pull_$d->{NAME}"} =
- $needed->{"print_$d->{NAME}"} = 0;
- }
-
- FunctionTable($interface);
-}
-
-sub RegistrationFunction($$)
-{
- my ($idl,$filename) = @_;
-
- $filename =~ /.*\/ndr_(.*).c/;
- my $basename = $1;
- pidl "NTSTATUS dcerpc_$basename\_init(void)";
- pidl "{";
- indent;
- pidl "NTSTATUS status = NT_STATUS_OK;";
- foreach my $interface (@{$idl}) {
- next if $interface->{TYPE} ne "INTERFACE";
-
- my $count = ($#{$interface->{FUNCTIONS}}+1);
-
- next if ($count == 0);
-
- pidl "status = dcerpc_ndr_$interface->{NAME}_init();";
- pidl "if (NT_STATUS_IS_ERR(status)) {";
- pidl "\treturn status;";
- pidl "}";
- pidl "";
- }
- pidl "return status;";
- deindent;
- pidl "}";
- pidl "";
-}
-
-#####################################################################
-# parse a parsed IDL structure back into an IDL file
-sub Parse($$)
-{
- my($ndr,$filename) = @_;
-
- $tabs = "";
- my $h_filename = $filename;
- $res = "";
-
- if ($h_filename =~ /(.*)\.c/) {
- $h_filename = "$1.h";
- }
-
- pidl "/* parser auto-generated by pidl */";
- pidl "";
- pidl "#include \"includes.h\"";
- pidl "#include \"librpc/gen_ndr/ndr_misc.h\"";
- pidl "#include \"librpc/gen_ndr/ndr_dcerpc.h\"";
- pidl "#include \"$h_filename\"";
- pidl "";
-
- my %needed = ();
-
- foreach my $x (@{$ndr}) {
- ($x->{TYPE} eq "INTERFACE") && NeededInterface($x, \%needed);
- }
-
- foreach my $x (@{$ndr}) {
- ($x->{TYPE} eq "INTERFACE") && ParseInterface($x, \%needed);
- }
-
- RegistrationFunction($ndr, $filename);
-
- return $res;
-}
-
-sub NeededFunction($$)
-{
- my ($fn,$needed) = @_;
- $needed->{"pull_$fn->{NAME}"} = 1;
- $needed->{"push_$fn->{NAME}"} = 1;
- $needed->{"print_$fn->{NAME}"} = 1;
- foreach my $e (@{$fn->{ELEMENTS}}) {
- $e->{PARENT} = $fn;
- unless(defined($needed->{"pull_$e->{TYPE}"})) {
- $needed->{"pull_$e->{TYPE}"} = 1;
- }
- unless(defined($needed->{"push_$e->{TYPE}"})) {
- $needed->{"push_$e->{TYPE}"} = 1;
- }
- unless(defined($needed->{"print_$e->{TYPE}"})) {
- $needed->{"print_$e->{TYPE}"} = 1;
- }
- }
-}
-
-sub NeededTypedef($$)
-{
- my ($t,$needed) = @_;
- if (has_property($t, "public")) {
- $needed->{"pull_$t->{NAME}"} = not has_property($t, "nopull");
- $needed->{"push_$t->{NAME}"} = not has_property($t, "nopush");
- $needed->{"print_$t->{NAME}"} = not has_property($t, "noprint");
- }
-
- if ($t->{DATA}->{TYPE} eq "STRUCT" or $t->{DATA}->{TYPE} eq "UNION") {
- if (has_property($t, "gensize")) {
- $needed->{"ndr_size_$t->{NAME}"} = 1;
- }
-
- for my $e (@{$t->{DATA}->{ELEMENTS}}) {
- $e->{PARENT} = $t->{DATA};
- if ($needed->{"pull_$t->{NAME}"} and
- not defined($needed->{"pull_$e->{TYPE}"})) {
- $needed->{"pull_$e->{TYPE}"} = 1;
- }
- if ($needed->{"push_$t->{NAME}"} and
- not defined($needed->{"push_$e->{TYPE}"})) {
- $needed->{"push_$e->{TYPE}"} = 1;
- }
- if ($needed->{"print_$t->{NAME}"} and
- not defined($needed->{"print_$e->{TYPE}"})) {
- $needed->{"print_$e->{TYPE}"} = 1;
- }
- }
- }
-}
-
-#####################################################################
-# work out what parse functions are needed
-sub NeededInterface($$)
-{
- my ($interface,$needed) = @_;
- foreach my $d (@{$interface->{FUNCTIONS}}) {
- NeededFunction($d, $needed);
- }
- foreach my $d (reverse @{$interface->{TYPEDEFS}}) {
- NeededTypedef($d, $needed);
- }
-}
-
-1;
diff --git a/source4/build/pidl/Parse/Pidl/Samba/NDR/Server.pm b/source4/build/pidl/Parse/Pidl/Samba/NDR/Server.pm
deleted file mode 100644
index a8c159572b..0000000000
--- a/source4/build/pidl/Parse/Pidl/Samba/NDR/Server.pm
+++ /dev/null
@@ -1,322 +0,0 @@
-###################################################
-# 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
deleted file mode 100644
index 409095804f..0000000000
--- a/source4/build/pidl/Parse/Pidl/Samba/SWIG.pm
+++ /dev/null
@@ -1,76 +0,0 @@
-###################################################
-# 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/TDR.pm b/source4/build/pidl/Parse/Pidl/Samba/TDR.pm
deleted file mode 100644
index b9bfd83e41..0000000000
--- a/source4/build/pidl/Parse/Pidl/Samba/TDR.pm
+++ /dev/null
@@ -1,266 +0,0 @@
-###################################################
-# Trivial Parser Generator
-# Copyright jelmer@samba.org 2005
-# released under the GNU GPL
-
-package Parse::Pidl::Samba::TDR;
-use Parse::Pidl::Util qw(has_property ParseExpr is_constant);
-use Data::Dumper;
-
-use strict;
-
-my $ret = "";
-my $tabs = "";
-
-sub indent() { $tabs.="\t"; }
-sub deindent() { $tabs = substr($tabs, 1); }
-sub pidl($) { $ret .= $tabs.(shift)."\n"; }
-sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); }
-sub static($) { my $p = shift; return("static ") unless ($p); return ""; }
-sub printarg($) {
- my $t = shift;
- return(", const char *name") if ($t eq "print");
- return("");
-}
-
-sub ContainsArray($)
-{
- my $e = shift;
- foreach (@{$e->{ELEMENTS}}) {
- next if (has_property($_, "charset") and
- scalar(@{$_->{ARRAY_LEN}}) == 1);
- return 1 if (defined($_->{ARRAY_LEN}) and
- scalar(@{$_->{ARRAY_LEN}}) > 0);
- }
- return 0;
-}
-
-sub ParserElement($$$)
-{
- my ($e,$t,$env) = @_;
- my $switch = "";
- my $array = "";
- my $name = "";
-
- fatal($e,"Pointers not supported in TDR") if ($e->{POINTERS} > 0);
- fatal($e,"size_is() not supported in TDR") if (has_property($e, "size_is"));
- fatal($e,"length_is() not supported in TDR") if (has_property($e, "length_is"));
-
- if ($t eq "print") {
- $name = ", \"$e->{NAME}\"$array";
- }
-
- if (has_property($e, "flag")) {
- pidl "{";
- indent;
- pidl "uint32_t saved_flags = tdr->flags;";
- pidl "tdr->flags |= $e->{PROPERTIES}->{flag};";
- }
-
- if (has_property($e, "charset")) {
- fatal($e,"charset() on non-array element") unless (defined($e->{ARRAY_LEN}) and scalar(@{$e->{ARRAY_LEN}}) > 0);
-
- my $len = @{$e->{ARRAY_LEN}}[0];
- if ($len eq "*") { $len = "-1"; }
- pidl "TDR_CHECK(tdr_$t\_charset(tdr$name, &v->$e->{NAME}, $len, sizeof($e->{TYPE}_t), CH_$e->{PROPERTIES}->{charset}));";
- return;
- }
-
-
- if (has_property($e, "switch_is")) {
- $switch = ", " . ParseExpr($e->{PROPERTIES}->{switch_is}, $env);
- }
-
- if (defined($e->{ARRAY_LEN}) and scalar(@{$e->{ARRAY_LEN}}) > 0) {
- my $len = ParseExpr($e->{ARRAY_LEN}[0], $env);
-
- if ($t eq "pull" and not is_constant($len)) {
- pidl "TDR_ALLOC(tdr, v->$e->{NAME}, $len);"
- }
-
- pidl "for (i = 0; i < $len; i++) {";
- indent;
- $array = "[i]";
- }
-
- if (has_property($e, "value") && $t eq "push") {
- pidl "v->$e->{NAME} = ".ParseExpr($e->{PROPERTIES}->{value}, $env).";";
- }
-
- pidl "TDR_CHECK(tdr_$t\_$e->{TYPE}(tdr$name$switch, &v->$e->{NAME}$array));";
-
- if ($array) { deindent; pidl "}"; }
-
- if (has_property($e, "flag")) {
- pidl "tdr->flags = saved_flags;";
- deindent;
- pidl "}";
- }
-}
-
-sub ParserStruct($$$$)
-{
- my ($e,$n,$t,$p) = @_;
-
- pidl static($p)."NTSTATUS tdr_$t\_$n (struct tdr_$t *tdr".printarg($t).", struct $n *v)";
- pidl "{"; indent;
- pidl "int i;" if (ContainsArray($e));
-
- if ($t eq "print") {
- pidl "tdr->print(tdr, \"\%-25s: struct $n\", name);";
- pidl "tdr->level++;";
- }
-
- my %env = map { $_->{NAME} => "v->$_->{NAME}" } @{$e->{ELEMENTS}};
- ParserElement($_, $t, \%env) foreach (@{$e->{ELEMENTS}});
-
- if ($t eq "print") {
- pidl "tdr->level--;";
- }
-
- pidl "return NT_STATUS_OK;";
-
- deindent; pidl "}";
-}
-
-sub ParserUnion($$$$)
-{
- my ($e,$n,$t,$p) = @_;
-
- pidl static($p)."NTSTATUS tdr_$t\_$n(struct tdr_$t *tdr".printarg($t).", int level, union $n *v)";
- pidl "{"; indent;
- pidl "int i;" if (ContainsArray($e));
-
- if ($t eq "print") {
- pidl "tdr->print(tdr, \"\%-25s: union $n\", name);";
- pidl "tdr->level++;";
- }
-
- pidl "switch (level) {"; indent;
- foreach (@{$e->{ELEMENTS}}) {
- if (has_property($_, "case")) {
- pidl "case " . $_->{PROPERTIES}->{case} . ":";
- } elsif (has_property($_, "default")) {
- pidl "default:";
- }
- indent; ParserElement($_, $t, {}); deindent;
- pidl "break;";
- }
- deindent; pidl "}";
-
- if ($t eq "print") {
- pidl "tdr->level--;";
- }
-
- pidl "return NT_STATUS_OK;\n";
- deindent; pidl "}";
-}
-
-sub ParserBitmap($$$$)
-{
- my ($e,$n,$t,$p) = @_;
- return if ($p);
- pidl "#define tdr_$t\_$n tdr_$t\_" . Parse::Pidl::Typelist::bitmap_type_fn($e);
-}
-
-sub ParserEnum($$$$)
-{
- my ($e,$n,$t,$p) = @_;
- my $bt = Parse::Pidl::Typelist::enum_type_fn($e);
-
- pidl static($p)."NTSTATUS tdr_$t\_$n (struct tdr_$t *tdr".printarg($t).", enum $n *v)";
- pidl "{";
- if ($t eq "pull") {
- pidl "\t$bt\_t r;";
- pidl "\tTDR_CHECK(tdr_$t\_$bt(tdr, \&r));";
- pidl "\t*v = r;";
- } elsif ($t eq "push") {
- pidl "\tTDR_CHECK(tdr_$t\_$bt(tdr, ($bt\_t *)v));";
- } elsif ($t eq "print") {
- pidl "\t/* FIXME */";
- }
- pidl "\treturn NT_STATUS_OK;";
- pidl "}";
-}
-
-sub ParserTypedef($$)
-{
- my ($e,$t) = @_;
-
- return if (has_property($e, "no$t"));
-
- { STRUCT => \&ParserStruct, UNION => \&ParserUnion,
- ENUM => \&ParserEnum, BITMAP => \&ParserBitmap
- }->{$e->{DATA}->{TYPE}}($e->{DATA}, $e->{NAME}, $t, has_property($e, "public"));
-
- pidl "";
-}
-
-sub ParserInterface($)
-{
- my $x = shift;
-
- foreach (@{$x->{DATA}}) {
- next if ($_->{TYPE} ne "TYPEDEF");
- ParserTypedef($_, "pull");
- ParserTypedef($_, "push");
- ParserTypedef($_, "print");
- }
-}
-
-sub Parser($$)
-{
- my ($idl,$hdrname) = @_;
- $ret = "";
- pidl "/* autogenerated by pidl */";
- pidl "#include \"includes.h\"";
- pidl "#include \"$hdrname\"";
- foreach (@$idl) { ParserInterface($_) if ($_->{TYPE} eq "INTERFACE"); }
- return $ret;
-}
-
-sub HeaderInterface($$)
-{
- my ($x,$outputdir) = @_;
-
- pidl "#ifndef __TDR_$x->{NAME}_HEADER__";
- pidl "#define __TDR_$x->{NAME}_HEADER__";
-
- pidl "#include \"$outputdir/$x->{NAME}.h\"";
-
- foreach my $e (@{$x->{DATA}}) {
- next unless ($e->{TYPE} eq "TYPEDEF");
- next unless has_property($e, "public");
-
- my $switch = "";
-
- $switch = ", int level" if ($e->{DATA}->{TYPE} eq "UNION");
-
- if ($e->{DATA}->{TYPE} eq "BITMAP") {
- # FIXME
- } else {
- my ($n, $d) = ($e->{NAME}, lc($e->{DATA}->{TYPE}));
- pidl "NTSTATUS tdr_pull\_$n(struct tdr_pull *tdr$switch, $d $n *v);";
- pidl "NTSTATUS tdr_print\_$n(struct tdr_print *tdr, const char *name$switch, $d $n *v);";
- pidl "NTSTATUS tdr_push\_$n(struct tdr_push *tdr$switch, $d $n *v);";
- }
-
- pidl "";
- }
-
- pidl "#endif /* __TDR_$x->{NAME}_HEADER__ */";
-}
-
-sub Header($$)
-{
- my ($idl,$outputdir) = @_;
- $ret = "";
- pidl "/* Generated by pidl */";
-
- foreach (@$idl) {
- HeaderInterface($_, $outputdir) if ($_->{TYPE} eq "INTERFACE");
- }
- return $ret;
-}
-
-1;
diff --git a/source4/build/pidl/Parse/Pidl/Samba/Template.pm b/source4/build/pidl/Parse/Pidl/Samba/Template.pm
deleted file mode 100644
index eb71b6d707..0000000000
--- a/source4/build/pidl/Parse/Pidl/Samba/Template.pm
+++ /dev/null
@@ -1,88 +0,0 @@
-###################################################
-# 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;
generated by cgit (git 2.34.1) at 2024-08-19 06:41:18 +0000