From 83c56f2118393e142021e232f7731e4622d2dfb3 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Fri, 11 Jan 2008 18:11:45 +0100
Subject: python/pidl: More work on wrapping enums, bitmaps and structs. (This
 used to be commit 732c3453f0784d5052705b00735b750809afce61)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 102 ++++++++++++++++++++-------
 1 file changed, 76 insertions(+), 26 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 8effff9d5e..7c379548ed 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -9,7 +9,7 @@ use Exporter;
 @ISA = qw(Exporter);
 
 use strict;
-use Parse::Pidl::Typelist;
+use Parse::Pidl::Typelist qw(hasType getType mapTypeName);
 use Parse::Pidl::Util qw(has_property ParseExpr);
 
 use vars qw($VERSION);
@@ -17,7 +17,8 @@ $VERSION = '0.01';
 
 sub new($) {
 	my ($class) = @_;
-	my $self = { res => "", res_hdr => "", tabs => "", constants => {}};
+	my $self = { res => "", res_hdr => "", tabs => "", constants => {},
+	             module_methods => []};
 	bless($self, $class);
 }
 
@@ -63,7 +64,26 @@ sub Import
 sub Const($$)
 {
     my ($self, $const) = @_;
-    $self->{constants}->{$const->{NAME}} = [$const->{DATA}->{TYPE}, $const->{VALUE}];
+	$self->register_constant($const->{NAME}, $const->{DATA}->{TYPE}, $const->{VALUE});
+}
+
+sub register_constant($$$$)
+{
+	my ($self, $name, $type, $value) = @_;
+
+	$self->{constants}->{$name} = [$type, $value];
+}
+
+sub EnumAndBitmapConsts($$$)
+{
+	my ($self, $name, $d) = @_;
+
+	foreach my $e (@{$d->{ELEMENTS}}) {
+		$e =~ /^([A-Za-z0-9_]+)=(.*)$/;
+		my $cname = $1;
+		
+		$self->register_constant($cname, $d, $cname);
+	}
 }
 
 sub FromTypeToPythonFunction($$)
@@ -97,6 +117,8 @@ sub TypeConstructor($$)
 	$self->pidl("static PyObject *py_$type->{NAME}_getattr(PyTypeObject *obj, char *name)");
 	$self->pidl("{");
 	$self->indent;
+	$self->pidl("$type->{NAME}_Object *py_object = ($type->{NAME}_Object *)obj;");
+	$self->pidl(mapTypeName($type) . " *object = talloc_get_type(py_object->object, ".mapTypeName($type).");");
 	$self->pidl("return Py_None;");
 	$self->deindent;
 	$self->pidl("}");
@@ -115,6 +137,8 @@ sub TypeConstructor($$)
 	$self->pidl("static PyObject *py_$type->{NAME}_setattr(PyTypeObject *obj, char *name, PyObject *value)");
 	$self->pidl("{");
 	$self->indent;
+	$self->pidl("$type->{NAME}_Object *py_object = ($type->{NAME}_Object *)obj;");
+	$self->pidl(mapTypeName($type) . " *object = talloc_get_type(py_object->object, ".mapTypeName($type).");");
 	$self->pidl("return Py_None;");
 	$self->deindent;
 	$self->pidl("}");
@@ -133,7 +157,8 @@ sub TypeConstructor($$)
 
 	$self->pidl("");
 
-	$self->pidl("static PyObject *py_$type->{NAME}(PyObject *self, PyObject *args)");
+	my $py_fnname = "py_$type->{NAME}";
+	$self->pidl("static PyObject *$py_fnname(PyObject *self, PyObject *args)");
 	$self->pidl("{");
 	$self->indent;
 	$self->pidl("$type->{NAME}\_Object *ret;");
@@ -142,6 +167,8 @@ sub TypeConstructor($$)
 	$self->deindent;
 	$self->pidl("}");
 	$self->pidl("");
+
+	return $py_fnname;
 }
 
 sub PythonFunction($$$)
@@ -175,9 +202,36 @@ sub handle_ntstatus($$$)
 	$self->pidl("");
 }
 
-sub Interface($$)
+sub PythonType($$$)
 {
-	my($self,$interface) = @_;
+	my ($self, $d, $interface, $basename) = @_;
+
+	if ($d->{TYPE} eq "STRUCT" or $d->{TYPE} eq "TYPEDEF" and 
+		$d->{DATA}->{TYPE} eq "STRUCT") {
+		$self->FromTypeToPythonFunction($d);
+		$self->FromPythonToTypeFunction($d);
+		my $py_fnname = $self->TypeConstructor($d);
+
+		my $fn_name = $d->{NAME};
+
+		$fn_name =~ s/^$interface->{NAME}_//;
+		$fn_name =~ s/^$basename\_//;
+
+		$self->register_module_method($fn_name, $py_fnname, "METH_VARARGS|METH_KEYWORDS", "NULL");
+	}
+
+	if ($d->{TYPE} eq "ENUM" or $d->{TYPE} eq "BITMAP") {
+		$self->EnumAndBitmapConsts($d->{NAME}, $d);
+	}
+
+	if ($d->{TYPE} eq "TYPEDEF" and ($d->{DATA}->{TYPE} eq "ENUM" or $d->{DATA}->{TYPE} eq "BITMAP")) {
+		$self->EnumAndBitmapConsts($d->{NAME}, $d->{DATA});
+	}
+}
+
+sub Interface($$$)
+{
+	my($self,$interface,$basename) = @_;
 
 	$self->pidl_hdr("#ifndef _HEADER_PYTHON_$interface->{NAME}\n");
 	$self->pidl_hdr("#define _HEADER_PYTHON_$interface->{NAME}\n\n");
@@ -186,10 +240,10 @@ sub Interface($$)
 
 	$self->Const($_) foreach (@{$interface->{CONSTS}});
 
-	foreach (@{$interface->{TYPES}}) {
-		$self->FromTypeToPythonFunction($_);	
-		$self->FromPythonToTypeFunction($_);	
-		$self->TypeConstructor($_);
+	foreach my $d (@{$interface->{TYPES}}) {
+		next if has_property($d, "nopython");
+
+		$self->PythonType($d, $interface, $basename);
 	}
 
 	$self->pidl("staticforward PyTypeObject $interface->{NAME}_InterfaceType;");
@@ -257,6 +311,7 @@ sub Interface($$)
 
 	$self->pidl("");
 
+	$self->register_module_method($interface->{NAME}, "interface_$interface->{NAME}", "METH_VARARGS|METH_KEYWORDS", "NULL");
 	$self->pidl("static PyObject *interface_$interface->{NAME}(PyObject *self, PyObject *args)");
 	$self->pidl("{");
 	$self->indent;
@@ -285,6 +340,13 @@ sub Interface($$)
 	$self->pidl_hdr("#endif /* _HEADER_NDR_$interface->{NAME} */\n");
 }
 
+sub register_module_method($$$$$)
+{
+	my ($self, $fn_name, $pyfn_name, $flags, $doc) = @_;
+
+	push (@{$self->{module_methods}}, [$fn_name, $pyfn_name, $flags, $doc])
+}
+
 sub Parse($$$$)
 {
     my($self,$basename,$ndr,$hdr) = @_;
@@ -305,27 +367,15 @@ sub Parse($$$$)
 ");
 
 	foreach my $x (@$ndr) {
-	    ($x->{TYPE} eq "INTERFACE") && $self->Interface($x);
+	    ($x->{TYPE} eq "INTERFACE") && $self->Interface($x, $basename);
 		($x->{TYPE} eq "IMPORT") && $self->Import(@{$x->{PATHS}});
 	}
 	
 	$self->pidl("static PyMethodDef $basename\_methods[] = {");
 	$self->indent;
-	foreach my $x (@$ndr) {
-	    next if ($x->{TYPE} ne "INTERFACE");
-		$self->pidl("{ \"$x->{NAME}\", (PyCFunction)interface_$x->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },");
-
-		foreach my $d (@{$x->{TYPES}}) {
-			next if has_property($d, "nopython");
-			next if ($d->{TYPE} eq "ENUM" or $d->{TYPE} eq "BITMAP");
-
-			my $fn_name = $d->{NAME};
-
-			$fn_name =~ s/^$x->{NAME}_//;
-			$fn_name =~ s/^$basename\_//;
-
-			$self->pidl("{ \"$fn_name\", (PyCFunction)py_$d->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },");
-		}
+	foreach (@{$self->{module_methods}}) {
+		my ($fn_name, $pyfn_name, $flags, $doc) = @$_;
+		$self->pidl("{ \"$fn_name\", (PyCFunction)$pyfn_name, $flags, $doc },");
 	}
 	
 	$self->pidl("{ NULL, NULL, 0, NULL }");
-- 
cgit 


From 7aa0f25d7f0a8a1eac19c886477b13ab00bd76fe Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Fri, 11 Jan 2008 18:27:47 +0100
Subject: python/pidl: Handle non-string types. (This used to be commit
 02dd02c529d578ad7fa4a6b825097685555604fe)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 7c379548ed..5077102fc7 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -347,6 +347,24 @@ sub register_module_method($$$$$)
 	push (@{$self->{module_methods}}, [$fn_name, $pyfn_name, $flags, $doc])
 }
 
+sub ConvertObjectToPython($$$)
+{
+	my ($self, $ctype, $cvar) = @_;
+
+	if ($cvar =~ /^".*"$/) {
+		return "PyString_FromString($cvar)";
+	}
+
+	if ($cvar =~ /^[0-9]+$/ or 
+		$ctype->{TYPE} eq "ENUM" or $ctype->{TYPE} eq "BITMAP" or 
+		$ctype->{TYPE} eq "TYPEDEF" and 
+		($ctype->{TYPE} eq "ENUM" or $ctype->{TYPE} eq "BITMAP")) {
+		return "PyInt_FromLong($cvar)";
+	}
+
+	die("Unknown type for ".mapTypeName($ctype).": $cvar");
+}
+
 sub Parse($$$$)
 {
     my($self,$basename,$ndr,$hdr) = @_;
@@ -391,7 +409,7 @@ sub Parse($$$$)
 	$self->pidl("m = Py_InitModule(\"$basename\", $basename\_methods);");
 	foreach (keys %{$self->{constants}}) {
 		# FIXME: Handle non-string constants
-		$self->pidl("PyModule_AddObject(m, \"$_\", PyString_FromString(" . $self->{constants}->{$_}->[1] . "));");
+		$self->pidl("PyModule_AddObject(m, \"$_\", " .  $self->ConvertObjectToPython($self->{constants}->{$_}->[0], $self->{constants}->{$_}->[1]) . ");");
 	}
 	$self->deindent;
 	$self->pidl("}");
-- 
cgit 


From f71df735556947f70c6a14bf9588988d0f6adfe3 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Fri, 11 Jan 2008 20:00:46 +0100
Subject: python/pidl: Start wrapping function arguments. (This used to be
 commit c2595d3754db4d03bafd53b6f62158516493657e)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 198 ++++++++++++++++++++++-----
 1 file changed, 160 insertions(+), 38 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 5077102fc7..6b4b41f74f 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -86,83 +86,121 @@ sub EnumAndBitmapConsts($$$)
 	}
 }
 
-sub FromTypeToPythonFunction($$)
+sub FromUnionToPythonFunction($$)
 {
 	my ($self, $type) = @_;
 
 	#FIXME
+
+	$self->pidl("return NULL;");
 }
 
-sub FromPythonToTypeFunction($$)
+sub FromStructToPythonFunction($$)
 {
 	my ($self, $type) = @_;
 
 	#FIXME
+	$self->pidl("return NULL;");
 }
 
-sub TypeConstructor($$)
+sub FromPythonToUnionFunction($$)
 {
 	my ($self, $type) = @_;
 
-	$self->pidl("staticforward PyTypeObject $type->{NAME}_ObjectType;");
+	#FIXME
+	$self->pidl("return NULL;");
+}
+
+sub FromPythonToStructFunction($$)
+{
+	my ($self, $type) = @_;
+
+	#FIXME
+	$self->pidl("return NULL;");
+}
+
+sub PythonStruct($$$$)
+{
+	my ($self, $name, $cname, $d) = @_;
+
+	$self->pidl("staticforward PyTypeObject $name\_ObjectType;");
 	$self->pidl("typedef struct {");
 	$self->indent;
 	$self->pidl("PyObject_HEAD");
-	$self->pidl("void *object;"); # FIXME: Use real type rather than void
+	$self->pidl("$cname *object;");
 	$self->deindent;
-	$self->pidl("} $type->{NAME}_Object;");
+	$self->pidl("} $name\_Object;");
 
 	$self->pidl("");
 
-	$self->pidl("static PyObject *py_$type->{NAME}_getattr(PyTypeObject *obj, char *name)");
+	$self->pidl("static PyObject *py_$name\_getattr(PyTypeObject *obj, char *name)");
 	$self->pidl("{");
 	$self->indent;
-	$self->pidl("$type->{NAME}_Object *py_object = ($type->{NAME}_Object *)obj;");
-	$self->pidl(mapTypeName($type) . " *object = talloc_get_type(py_object->object, ".mapTypeName($type).");");
-	$self->pidl("return Py_None;");
+	$self->pidl("$name\_Object *py_object = ($name\_Object *)obj;");
+	$self->pidl("$cname *object = talloc_get_type(py_object->object, $cname);");
+	foreach my $e (@{$d->{ELEMENTS}}) {
+		$self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {");
+		my $varname = "object->$e->{NAME}";
+		$self->indent;
+		$self->pidl("return ".$self->ConvertObjectToPython($e->{TYPE}, $varname) . ";");
+		$self->deindent;
+		$self->pidl("}");
+	}
+	$self->pidl("PyErr_SetString(PyExc_AttributeError, \"no such attribute\");");
+	$self->pidl("return NULL;");
 	$self->deindent;
 	$self->pidl("}");
 	$self->pidl("");
 
-	$self->pidl("static void py_$type->{NAME}_dealloc(PyObject* self)");
+	$self->pidl("static void py_$name\_dealloc(PyObject* self)");
 	$self->pidl("{");
 	$self->indent;
-	$self->pidl("$type->{NAME}_Object *obj = ($type->{NAME}_Object *)self;");
+	$self->pidl("$name\_Object *obj = ($name\_Object *)self;");
 	$self->pidl("talloc_free(obj->object);");
 	$self->pidl("PyObject_Del(self);");
 	$self->deindent;
 	$self->pidl("}");
 	$self->pidl("");
 
-	$self->pidl("static PyObject *py_$type->{NAME}_setattr(PyTypeObject *obj, char *name, PyObject *value)");
+	$self->pidl("static PyObject *py_$name\_setattr(PyTypeObject *obj, char *name, PyObject *value)");
 	$self->pidl("{");
 	$self->indent;
-	$self->pidl("$type->{NAME}_Object *py_object = ($type->{NAME}_Object *)obj;");
-	$self->pidl(mapTypeName($type) . " *object = talloc_get_type(py_object->object, ".mapTypeName($type).");");
-	$self->pidl("return Py_None;");
+	$self->pidl("$name\_Object *py_object = ($name\_Object *)obj;");
+	$self->pidl("$cname *object = talloc_get_type(py_object->object, $cname);");
+	foreach my $e (@{$d->{ELEMENTS}}) {
+		$self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {");
+		my $varname = "object->$e->{NAME}";
+		$self->indent;
+		$self->pidl("/* FIXME: talloc_free($varname) if necessary */");
+		$self->pidl("$varname = " . $self->ConvertObjectFromPython($e->{TYPE}, "value") . ";");
+		$self->deindent;
+		$self->pidl("}");
+	}
+	$self->pidl("PyErr_SetString(PyExc_AttributeError, \"no such attribute\");");
+	$self->pidl("return NULL;");
 	$self->deindent;
 	$self->pidl("}");
 	$self->pidl("");
 
-	$self->pidl("static PyTypeObject $type->{NAME}_ObjectType = {");
+	$self->pidl("static PyTypeObject $name\_ObjectType = {");
 	$self->indent;
 	$self->pidl("PyObject_HEAD_INIT(NULL) 0,");
-	$self->pidl(".tp_name = \"$type->{NAME}\",");
-	$self->pidl(".tp_basicsize = sizeof($type->{NAME}_Object),");
-	$self->pidl(".tp_dealloc = (destructor)py_$type->{NAME}_dealloc,");
-	$self->pidl(".tp_getattr = (getattrfunc)py_$type->{NAME}_getattr,");
-	$self->pidl(".tp_setattr = (setattrfunc)py_$type->{NAME}_setattr,");
+	$self->pidl(".tp_name = \"$name\",");
+	$self->pidl(".tp_basicsize = sizeof($name\_Object),");
+	$self->pidl(".tp_dealloc = (destructor)py_$name\_dealloc,");
+	$self->pidl(".tp_getattr = (getattrfunc)py_$name\_getattr,");
+	$self->pidl(".tp_setattr = (setattrfunc)py_$name\_setattr,");
 	$self->deindent;
 	$self->pidl("};");
 
 	$self->pidl("");
 
-	my $py_fnname = "py_$type->{NAME}";
+	my $py_fnname = "py_$name";
 	$self->pidl("static PyObject *$py_fnname(PyObject *self, PyObject *args)");
 	$self->pidl("{");
 	$self->indent;
-	$self->pidl("$type->{NAME}\_Object *ret;");
-	$self->pidl("ret = PyObject_New($type->{NAME}_Object, &$type->{NAME}_ObjectType);");
+	$self->pidl("$name\_Object *ret;");
+	$self->pidl("ret = PyObject_New($name\_Object, &$name\_ObjectType);");
 	$self->pidl("return (PyObject *) ret;");
 	$self->deindent;
 	$self->pidl("}");
@@ -180,22 +218,51 @@ sub PythonFunction($$$)
 	$self->indent;
 	$self->pidl("$iface\_InterfaceObject *iface = ($iface\_InterfaceObject *)self;");
 	$self->pidl("NTSTATUS status;");
+	$self->pidl("TALLOC_CTX *mem_ctx = talloc_new(NULL);");
+	$self->pidl("struct dcerpc_$fn->{NAME} r;");
+	$self->pidl("PyObject *result = Py_None;");
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		$self->pidl("PyObject *py_$e->{NAME};");
+	}
+	if ($fn->{RETURN_TYPE}) {
+		$self->pidl("PyObject *py_result;");
+	}
 	$self->pidl("");
-	# FIXME
-	$self->handle_ntstatus("status", "NULL");
-	$self->pidl("return Py_None;");
+	$self->pidl("ZERO_STRUCT(r.out);");
+
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		if (grep(/in/,@{$e->{DIRECTION}})) {
+			$self->pidl("r.in.$e->{NAME} = " . $self->ConvertObjectFromPython($e->{TYPE}, "py_$e->{NAME}") . ";");
+		}
+	}
+	$self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, &r);");
+	$self->handle_ntstatus("status", "NULL", "mem_ctx");
+
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		if (grep(/out/,@{$e->{DIRECTION}})) {
+			$self->pidl("py_$e->{NAME} = " . $self->ConvertObjectToPython($e->{TYPE}, "r.out.$e->{NAME}") . ";");
+		}
+	}
+
+	if ($fn->{RETURN_TYPE}) {
+		$self->pidl("py_result = " . $self->ConvertObjectToPython($fn->{RETURN_TYPE}, "r.out.result") . ";");
+	}
+
+	$self->pidl("talloc_free(mem_ctx);");
+	$self->pidl("return result;");
 	$self->deindent;
 	$self->pidl("}");
 	$self->pidl("");
 }
 
-sub handle_ntstatus($$$)
+sub handle_ntstatus($$$$)
 {
-	my ($self, $var, $retval) = @_;
+	my ($self, $var, $retval, $mem_ctx) = @_;
 
 	$self->pidl("if (NT_STATUS_IS_ERR($var)) {");
 	$self->indent;
 	$self->pidl("PyErr_SetString(PyExc_RuntimeError, nt_errstr($var));");
+	$self->pidl("talloc_free($mem_ctx);") if ($mem_ctx);
 	$self->pidl("return $retval;");
 	$self->deindent;
 	$self->pidl("}");
@@ -206,11 +273,19 @@ sub PythonType($$$)
 {
 	my ($self, $d, $interface, $basename) = @_;
 
+	my $actual_ctype = $d;
+	if ($actual_ctype->{TYPE} eq "TYPEDEF") {
+		$actual_ctype = $actual_ctype->{DATA};
+	}
+
 	if ($d->{TYPE} eq "STRUCT" or $d->{TYPE} eq "TYPEDEF" and 
 		$d->{DATA}->{TYPE} eq "STRUCT") {
-		$self->FromTypeToPythonFunction($d);
-		$self->FromPythonToTypeFunction($d);
-		my $py_fnname = $self->TypeConstructor($d);
+		my $py_fnname;
+		if ($d->{TYPE} eq "STRUCT") {
+			$py_fnname = $self->PythonStruct($d->{NAME}, mapTypeName($d), $d);
+		} else {
+			$py_fnname = $self->PythonStruct($d->{NAME}, mapTypeName($d), $d->{DATA});
+		}
 
 		my $fn_name = $d->{NAME};
 
@@ -227,6 +302,26 @@ sub PythonType($$$)
 	if ($d->{TYPE} eq "TYPEDEF" and ($d->{DATA}->{TYPE} eq "ENUM" or $d->{DATA}->{TYPE} eq "BITMAP")) {
 		$self->EnumAndBitmapConsts($d->{NAME}, $d->{DATA});
 	}
+
+	if ($actual_ctype->{TYPE} eq "UNION" or $actual_ctype->{TYPE} eq "STRUCT") {
+		$self->pidl("PyObject *py_import_$d->{NAME}(" .mapTypeName($d) . "*in)");
+		$self->pidl("{");
+		$self->indent;
+		$self->FromStructToPythonFunction($d) if ($actual_ctype->{TYPE} eq "STRUCT");
+		$self->FromUnionToPythonFunction($d) if ($actual_ctype->{TYPE} eq "UNION");
+		$self->deindent;
+		$self->pidl("}");
+		$self->pidl("");
+
+		$self->pidl(mapTypeName($d) . " *py_export_$d->{NAME}(TALLOC_CTX *mem_ctx, PyObject *in)");
+		$self->pidl("{");
+		$self->indent;
+		$self->FromPythonToStructFunction($d) if ($actual_ctype->{TYPE} eq "STRUCT");
+		$self->FromPythonToUnionFunction($d) if ($actual_ctype->{TYPE} eq "UNION");
+		$self->deindent;
+		$self->pidl("}");
+		$self->pidl("");
+	}
 }
 
 sub Interface($$$)
@@ -319,6 +414,7 @@ sub Interface($$$)
 	$self->pidl("const char *binding_string;");
 	$self->pidl("struct cli_credentials *credentials;");
 	$self->pidl("struct loadparm_context *lp_ctx;");
+	$self->pidl("TALLOC_CTX *mem_ctx = NULL;");
 	$self->pidl("NTSTATUS status;");
 	$self->pidl("");
 
@@ -328,7 +424,7 @@ sub Interface($$$)
 
 	$self->pidl("status = dcerpc_pipe_connect(NULL, &ret->pipe, binding_string, ");
 	$self->pidl("             &ndr_table_$interface->{NAME}, credentials, NULL, lp_ctx);");
-	$self->handle_ntstatus("status", "NULL");
+	$self->handle_ntstatus("status", "NULL", "mem_ctx");
 
 	$self->pidl("return (PyObject *)ret;");
 	$self->deindent;
@@ -347,6 +443,13 @@ sub register_module_method($$$$$)
 	push (@{$self->{module_methods}}, [$fn_name, $pyfn_name, $flags, $doc])
 }
 
+sub ConvertObjectFromPython($$$)
+{
+	my ($self, $ctype, $cvar) = @_;
+
+	return "FIXME($cvar)";
+}
+
 sub ConvertObjectToPython($$$)
 {
 	my ($self, $ctype, $cvar) = @_;
@@ -355,14 +458,33 @@ sub ConvertObjectToPython($$$)
 		return "PyString_FromString($cvar)";
 	}
 
+	if (ref($ctype) ne "HASH") {
+		$ctype = getType($ctype);
+	}
+
+	my $actual_ctype = $ctype;
+	if ($ctype->{TYPE} eq "TYPEDEF") {
+		$actual_ctype = $ctype->{DATA};
+	}
+
 	if ($cvar =~ /^[0-9]+$/ or 
-		$ctype->{TYPE} eq "ENUM" or $ctype->{TYPE} eq "BITMAP" or 
-		$ctype->{TYPE} eq "TYPEDEF" and 
-		($ctype->{TYPE} eq "ENUM" or $ctype->{TYPE} eq "BITMAP")) {
+		$actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or 
+		$actual_ctype->{TYPE} eq "SCALAR" and (
+		$actual_ctype->{NAME} =~ /^(uint[0-9]+|hyper)$/)) {
 		return "PyInt_FromLong($cvar)";
 	}
 
-	die("Unknown type for ".mapTypeName($ctype).": $cvar");
+	if ($ctype->{TYPE} eq "TYPEDEF" and (
+			$actual_ctype->{TYPE} eq "STRUCT" or 
+			$actual_ctype->{TYPE} eq "UNION")) {
+		return "py_import_$ctype->{NAME}($cvar)";
+	}
+
+	if ($ctype->{TYPE} eq "STRUCT" or $ctype->{TYPE} eq "UNION") {
+		return "py_import_$ctype->{TYPE}_$ctype->{NAME}($cvar)";
+	}
+
+	die("unknown type ".mapTypeName($ctype) . ": $cvar");
 }
 
 sub Parse($$$$)
-- 
cgit 


From 8986f3ee6f46c354fed2cce5e434dda060e6318b Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Fri, 11 Jan 2008 20:37:08 +0100
Subject: pidl/python: Convert some Python objects back to C, return proper
 tuples in client calls. (This used to be commit
 1ab617296943dc1d270cbf999dedcfb3073d3d20)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 47 +++++++++++++++++++++++-----
 1 file changed, 40 insertions(+), 7 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 6b4b41f74f..4454eeefd7 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -1,6 +1,6 @@
 ###################################################
 # Python function wrapper generator
-# Copyright jelmer@samba.org 2007
+# Copyright jelmer@samba.org 2007-2008
 # released under the GNU GPL
 
 package Parse::Pidl::Samba4::Python;
@@ -11,6 +11,7 @@ use Exporter;
 use strict;
 use Parse::Pidl::Typelist qw(hasType getType mapTypeName);
 use Parse::Pidl::Util qw(has_property ParseExpr);
+use Parse::Pidl::CUtil qw(get_value_of get_pointer_of);
 
 use vars qw($VERSION);
 $VERSION = '0.01';
@@ -220,12 +221,19 @@ sub PythonFunction($$$)
 	$self->pidl("NTSTATUS status;");
 	$self->pidl("TALLOC_CTX *mem_ctx = talloc_new(NULL);");
 	$self->pidl("struct dcerpc_$fn->{NAME} r;");
-	$self->pidl("PyObject *result = Py_None;");
+	$self->pidl("PyObject *result;");
+	my $result_size = 0;
+
 	foreach my $e (@{$fn->{ELEMENTS}}) {
-		$self->pidl("PyObject *py_$e->{NAME};");
+		if (grep(/in/,@{$e->{DIRECTION}})) {
+			$self->pidl("PyObject *py_$e->{NAME};");
+		}
+		if (grep(/out/,@{$e->{DIRECTION}})) {
+			$result_size++;
+		}
 	}
 	if ($fn->{RETURN_TYPE}) {
-		$self->pidl("PyObject *py_result;");
+		$result_size++;
 	}
 	$self->pidl("");
 	$self->pidl("ZERO_STRUCT(r.out);");
@@ -238,14 +246,20 @@ sub PythonFunction($$$)
 	$self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, &r);");
 	$self->handle_ntstatus("status", "NULL", "mem_ctx");
 
+	$self->pidl("result = PyTuple_New($result_size);");
+
+	my $i = 0;
+
 	foreach my $e (@{$fn->{ELEMENTS}}) {
 		if (grep(/out/,@{$e->{DIRECTION}})) {
-			$self->pidl("py_$e->{NAME} = " . $self->ConvertObjectToPython($e->{TYPE}, "r.out.$e->{NAME}") . ";");
+			$self->pidl("PyTuple_SetItem(result, $i, " . $self->ConvertObjectToPython($e->{TYPE}, "r.out.$e->{NAME}") . ");");
+
+			$i++;
 		}
 	}
 
 	if ($fn->{RETURN_TYPE}) {
-		$self->pidl("py_result = " . $self->ConvertObjectToPython($fn->{RETURN_TYPE}, "r.out.result") . ";");
+		$self->pidl("PyTuple_SetItem(result, $i, " . $self->ConvertObjectToPython($fn->{RETURN_TYPE}, "r.out.result") . ");");
 	}
 
 	$self->pidl("talloc_free(mem_ctx);");
@@ -304,7 +318,7 @@ sub PythonType($$$)
 	}
 
 	if ($actual_ctype->{TYPE} eq "UNION" or $actual_ctype->{TYPE} eq "STRUCT") {
-		$self->pidl("PyObject *py_import_$d->{NAME}(" .mapTypeName($d) . "*in)");
+		$self->pidl("PyObject *py_import_$d->{NAME}(" .mapTypeName($d) . " *in)");
 		$self->pidl("{");
 		$self->indent;
 		$self->FromStructToPythonFunction($d) if ($actual_ctype->{TYPE} eq "STRUCT");
@@ -447,6 +461,21 @@ sub ConvertObjectFromPython($$$)
 {
 	my ($self, $ctype, $cvar) = @_;
 
+	if (ref($ctype) ne "HASH") {
+		$ctype = getType($ctype);
+	}
+
+	my $actual_ctype = $ctype;
+	if ($ctype->{TYPE} eq "TYPEDEF") {
+		$actual_ctype = $ctype->{DATA};
+	}
+
+	if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or 
+		$actual_ctype->{TYPE} eq "SCALAR" and (
+		$actual_ctype->{NAME} =~ /^(uint[0-9]+|hyper)$/)) {
+		return "PyInt_AsLong($cvar)";
+	}
+
 	return "FIXME($cvar)";
 }
 
@@ -484,6 +513,10 @@ sub ConvertObjectToPython($$$)
 		return "py_import_$ctype->{TYPE}_$ctype->{NAME}($cvar)";
 	}
 
+	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "NTSTATUS") {
+		return "PyInt_FromLong($cvar->v)";
+	}
+
 	die("unknown type ".mapTypeName($ctype) . ": $cvar");
 }
 
-- 
cgit 


From 375624ecf95a0aac6e29ce0c7dca35f239c9dd12 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sat, 12 Jan 2008 01:09:28 +0100
Subject: pidl/python: Some more support for special case types. (This used to
 be commit 991aa950a377bbc07e0bf05758574f850a6d0ff7)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 48 ++++++++++++++++++++++------
 1 file changed, 39 insertions(+), 9 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 4454eeefd7..2bf5f1528a 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -11,7 +11,7 @@ use Exporter;
 use strict;
 use Parse::Pidl::Typelist qw(hasType getType mapTypeName);
 use Parse::Pidl::Util qw(has_property ParseExpr);
-use Parse::Pidl::CUtil qw(get_value_of get_pointer_of);
+use Parse::Pidl::CUtil qw(get_value_of get_pointer_to);
 
 use vars qw($VERSION);
 $VERSION = '0.01';
@@ -288,12 +288,11 @@ sub PythonType($$$)
 	my ($self, $d, $interface, $basename) = @_;
 
 	my $actual_ctype = $d;
-	if ($actual_ctype->{TYPE} eq "TYPEDEF") {
+	if ($actual_ctype->{TYPE} eq "TYPEDEF" or $actual_ctype->{TYPE} eq "DECLARE") {
 		$actual_ctype = $actual_ctype->{DATA};
 	}
 
-	if ($d->{TYPE} eq "STRUCT" or $d->{TYPE} eq "TYPEDEF" and 
-		$d->{DATA}->{TYPE} eq "STRUCT") {
+	if ($actual_ctype->{TYPE} eq "STRUCT") {
 		my $py_fnname;
 		if ($d->{TYPE} eq "STRUCT") {
 			$py_fnname = $self->PythonStruct($d->{NAME}, mapTypeName($d), $d);
@@ -466,13 +465,13 @@ sub ConvertObjectFromPython($$$)
 	}
 
 	my $actual_ctype = $ctype;
-	if ($ctype->{TYPE} eq "TYPEDEF") {
+	if ($ctype->{TYPE} eq "TYPEDEF" or $ctype->{TYPE} eq "DECLARE") {
 		$actual_ctype = $ctype->{DATA};
 	}
 
 	if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or 
 		$actual_ctype->{TYPE} eq "SCALAR" and (
-		$actual_ctype->{NAME} =~ /^(uint[0-9]+|hyper)$/)) {
+		$actual_ctype->{NAME} =~ /^(uint[0-9]+|hyper|NTTIME|time_t|NTTIME_hyper|NTTIME_1sec|dlong|udlong)$/)) {
 		return "PyInt_AsLong($cvar)";
 	}
 
@@ -488,18 +487,22 @@ sub ConvertObjectToPython($$$)
 	}
 
 	if (ref($ctype) ne "HASH") {
+		if (not hasType($ctype)) {
+			return "py_import_$ctype($cvar)"; # best bet
+		}
+
 		$ctype = getType($ctype);
 	}
 
 	my $actual_ctype = $ctype;
-	if ($ctype->{TYPE} eq "TYPEDEF") {
+	if ($ctype->{TYPE} eq "TYPEDEF" or $ctype->{TYPE} eq "DECLARE") {
 		$actual_ctype = $ctype->{DATA};
 	}
 
 	if ($cvar =~ /^[0-9]+$/ or 
 		$actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or 
-		$actual_ctype->{TYPE} eq "SCALAR" and (
-		$actual_ctype->{NAME} =~ /^(uint[0-9]+|hyper)$/)) {
+		($actual_ctype->{TYPE} eq "SCALAR" and 
+		$actual_ctype->{NAME} =~ /^(int|long|char|u?int[0-9]+|hyper|dlong|udlong|time_t|NTTIME_hyper|NTTIME|NTTIME_1sec)$/)) {
 		return "PyInt_FromLong($cvar)";
 	}
 
@@ -509,6 +512,11 @@ sub ConvertObjectToPython($$$)
 		return "py_import_$ctype->{NAME}($cvar)";
 	}
 
+	if ($actual_ctype->{TYPE} eq "SCALAR" and 
+		$actual_ctype->{NAME} eq "DATA_BLOB") {
+		return "PyString_FromStringAndSize($cvar->data, $cvar->length)";
+	}
+
 	if ($ctype->{TYPE} eq "STRUCT" or $ctype->{TYPE} eq "UNION") {
 		return "py_import_$ctype->{TYPE}_$ctype->{NAME}($cvar)";
 	}
@@ -517,6 +525,28 @@ sub ConvertObjectToPython($$$)
 		return "PyInt_FromLong($cvar->v)";
 	}
 
+	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "WERROR") {
+		return "PyInt_FromLong($cvar->v)";
+	}
+
+	if ($actual_ctype->{TYPE} eq "SCALAR" and 
+		($actual_ctype->{NAME} eq "string" or $actual_ctype->{NAME} eq "nbt_string")) {
+		return "PyString_FromString($cvar)";
+	}
+
+	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "string_array") {
+		return "FIXME($cvar)";
+	}
+
+	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "ipv4address") {
+		return "FIXME($cvar)";
+		}
+
+	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "pointer") {
+		return "PyCObject_FromVoidPtr($cvar, talloc_free)";
+	}
+
+
 	die("unknown type ".mapTypeName($ctype) . ": $cvar");
 }
 
-- 
cgit 


From f0916ef230b48e3140a4fca68f96ab33350bee93 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sun, 13 Jan 2008 01:35:06 +0100
Subject: pidl/python: Remove references to DECLARE, which has been removed.
 (This used to be commit 9a907567c8e0836b731e0ef01f8d097a33de21b0)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 2bf5f1528a..98e9ee9ec2 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -288,7 +288,7 @@ sub PythonType($$$)
 	my ($self, $d, $interface, $basename) = @_;
 
 	my $actual_ctype = $d;
-	if ($actual_ctype->{TYPE} eq "TYPEDEF" or $actual_ctype->{TYPE} eq "DECLARE") {
+	if ($actual_ctype->{TYPE} eq "TYPEDEF") {
 		$actual_ctype = $actual_ctype->{DATA};
 	}
 
@@ -465,7 +465,7 @@ sub ConvertObjectFromPython($$$)
 	}
 
 	my $actual_ctype = $ctype;
-	if ($ctype->{TYPE} eq "TYPEDEF" or $ctype->{TYPE} eq "DECLARE") {
+	if ($ctype->{TYPE} eq "TYPEDEF") {
 		$actual_ctype = $ctype->{DATA};
 	}
 
@@ -495,7 +495,7 @@ sub ConvertObjectToPython($$$)
 	}
 
 	my $actual_ctype = $ctype;
-	if ($ctype->{TYPE} eq "TYPEDEF" or $ctype->{TYPE} eq "DECLARE") {
+	if ($ctype->{TYPE} eq "TYPEDEF") {
 		$actual_ctype = $ctype->{DATA};
 	}
 
-- 
cgit 


From 4ba71079272b1231c457112ac2d90f1f920cf5c8 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sun, 13 Jan 2008 01:50:31 +0100
Subject: pidl/python: Fix conversion of last few non-standard types. (This
 used to be commit b8bdbc38c15598e34c55fb9e3ee1f6894964d2c6)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 98e9ee9ec2..4ae647aa0a 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -9,7 +9,7 @@ use Exporter;
 @ISA = qw(Exporter);
 
 use strict;
-use Parse::Pidl::Typelist qw(hasType getType mapTypeName);
+use Parse::Pidl::Typelist qw(hasType getType mapTypeName expandAlias);
 use Parse::Pidl::Util qw(has_property ParseExpr);
 use Parse::Pidl::CUtil qw(get_value_of get_pointer_to);
 
@@ -471,7 +471,7 @@ sub ConvertObjectFromPython($$$)
 
 	if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or 
 		$actual_ctype->{TYPE} eq "SCALAR" and (
-		$actual_ctype->{NAME} =~ /^(uint[0-9]+|hyper|NTTIME|time_t|NTTIME_hyper|NTTIME_1sec|dlong|udlong)$/)) {
+		expandAlias($actual_ctype->{NAME}) =~ /^(uint[0-9]+|hyper|NTTIME|time_t|NTTIME_hyper|NTTIME_1sec|dlong|udlong)$/)) {
 		return "PyInt_AsLong($cvar)";
 	}
 
@@ -502,7 +502,7 @@ sub ConvertObjectToPython($$$)
 	if ($cvar =~ /^[0-9]+$/ or 
 		$actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or 
 		($actual_ctype->{TYPE} eq "SCALAR" and 
-		$actual_ctype->{NAME} =~ /^(int|long|char|u?int[0-9]+|hyper|dlong|udlong|time_t|NTTIME_hyper|NTTIME|NTTIME_1sec)$/)) {
+		expandAlias($actual_ctype->{NAME}) =~ /^(int|long|char|u?int[0-9]+|hyper|dlong|udlong|udlongr|time_t|NTTIME_hyper|NTTIME|NTTIME_1sec)$/)) {
 		return "PyInt_FromLong($cvar)";
 	}
 
@@ -513,7 +513,7 @@ sub ConvertObjectToPython($$$)
 	}
 
 	if ($actual_ctype->{TYPE} eq "SCALAR" and 
-		$actual_ctype->{NAME} eq "DATA_BLOB") {
+		expandAlias($actual_ctype->{NAME}) eq "DATA_BLOB") {
 		return "PyString_FromStringAndSize($cvar->data, $cvar->length)";
 	}
 
@@ -530,7 +530,7 @@ sub ConvertObjectToPython($$$)
 	}
 
 	if ($actual_ctype->{TYPE} eq "SCALAR" and 
-		($actual_ctype->{NAME} eq "string" or $actual_ctype->{NAME} eq "nbt_string")) {
+		($actual_ctype->{NAME} eq "string" or $actual_ctype->{NAME} eq "nbt_string" or $actual_ctype->{NAME} eq "nbt_name" or $actual_ctype->{NAME} eq "wrepl_nbt_name")) {
 		return "PyString_FromString($cvar)";
 	}
 
-- 
cgit 


From d814f3ce1c58be53886deab31a815e444ca6c5d5 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sun, 13 Jan 2008 03:15:55 +0100
Subject: pidl/python: Fix const type wrapping. (This used to be commit
 35a4843f9c75a59ab98e785520114809903575cf)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 25 ++++++++++++++++++++-----
 1 file changed, 20 insertions(+), 5 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 4ae647aa0a..ae4931571a 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -65,7 +65,7 @@ sub Import
 sub Const($$)
 {
     my ($self, $const) = @_;
-	$self->register_constant($const->{NAME}, $const->{DATA}->{TYPE}, $const->{VALUE});
+	$self->register_constant($const->{NAME}, $const->{DTYPE}, $const->{VALUE});
 }
 
 sub register_constant($$$$)
@@ -258,7 +258,7 @@ sub PythonFunction($$$)
 		}
 	}
 
-	if ($fn->{RETURN_TYPE}) {
+	if (defined($fn->{RETURN_TYPE})) {
 		$self->pidl("PyTuple_SetItem(result, $i, " . $self->ConvertObjectToPython($fn->{RETURN_TYPE}, "r.out.result") . ");");
 	}
 
@@ -460,10 +460,16 @@ sub ConvertObjectFromPython($$$)
 {
 	my ($self, $ctype, $cvar) = @_;
 
+	die("undef type for $cvar") unless(defined($ctype));
+
 	if (ref($ctype) ne "HASH") {
 		$ctype = getType($ctype);
 	}
 
+	if (ref($ctype) ne "HASH") {
+		return "FIXME($cvar)";
+	}
+
 	my $actual_ctype = $ctype;
 	if ($ctype->{TYPE} eq "TYPEDEF") {
 		$actual_ctype = $ctype->{DATA};
@@ -482,13 +488,23 @@ sub ConvertObjectToPython($$$)
 {
 	my ($self, $ctype, $cvar) = @_;
 
+	if ($cvar =~ /^[0-9]+$/ or $cvar =~ /^0x[0-9a-fA-F]+$/) {
+		return "PyInt_FromLong($cvar)";
+	}
+
+	die("undef type for $cvar") unless(defined($ctype));
+
 	if ($cvar =~ /^".*"$/) {
 		return "PyString_FromString($cvar)";
 	}
 
 	if (ref($ctype) ne "HASH") {
 		if (not hasType($ctype)) {
-			return "py_import_$ctype($cvar)"; # best bet
+			if (ref($ctype) eq "HASH") {
+				return "py_import_$ctype->{TYPE}_$ctype->{NAME}($cvar)";
+			} else {
+				return "py_import_$ctype($cvar)"; # best bet
+			}
 		}
 
 		$ctype = getType($ctype);
@@ -499,8 +515,7 @@ sub ConvertObjectToPython($$$)
 		$actual_ctype = $ctype->{DATA};
 	}
 
-	if ($cvar =~ /^[0-9]+$/ or 
-		$actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or 
+	if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or 
 		($actual_ctype->{TYPE} eq "SCALAR" and 
 		expandAlias($actual_ctype->{NAME}) =~ /^(int|long|char|u?int[0-9]+|hyper|dlong|udlong|udlongr|time_t|NTTIME_hyper|NTTIME|NTTIME_1sec)$/)) {
 		return "PyInt_FromLong($cvar)";
-- 
cgit 


From 4a8ceb8c56c66059791e4ef74ef3cbef4259f961 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sun, 13 Jan 2008 15:11:28 +0100
Subject: pidl/python: Fix bug accidently filling in the body of enums/bitmaps
 without body. (This used to be commit
 97971f0d8080f3934ea5940cc0f230004afb94a1)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index ae4931571a..d0a5bbd7e3 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -79,6 +79,8 @@ sub EnumAndBitmapConsts($$$)
 {
 	my ($self, $name, $d) = @_;
 
+	return unless (defined($d->{ELEMENTS}));
+
 	foreach my $e (@{$d->{ELEMENTS}}) {
 		$e =~ /^([A-Za-z0-9_]+)=(.*)$/;
 		my $cname = $1;
-- 
cgit 


From c660845737f454713f60f01d015125b053435b2c Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sun, 13 Jan 2008 15:29:56 +0100
Subject: pidl/python: Fix more warnings in the generated code. (This used to
 be commit 23add37b729aaa85b83cbf6ba98e7042c01f6472)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 51 +++++++++++++++-------------
 1 file changed, 28 insertions(+), 23 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index d0a5bbd7e3..fc5480b661 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -89,37 +89,39 @@ sub EnumAndBitmapConsts($$$)
 	}
 }
 
-sub FromUnionToPythonFunction($$)
+sub FromUnionToPythonFunction($$$)
 {
-	my ($self, $type) = @_;
+	my ($self, $type, $name) = @_;
 
 	#FIXME
 
 	$self->pidl("return NULL;");
 }
 
-sub FromStructToPythonFunction($$)
+sub FromStructToPythonFunction($$$)
 {
-	my ($self, $type) = @_;
+	my ($self, $type, $name) = @_;
 
-	#FIXME
-	$self->pidl("return NULL;");
+	$self->pidl("$type->{NAME}\_Object *ret;");
+	$self->pidl("ret = PyObject_New($type->{NAME}\_Object, &$type->{NAME}\_ObjectType);");
+	$self->pidl("ret->object = talloc_reference(NULL, $name);");
+	$self->pidl("return (PyObject *) ret;");
 }
 
-sub FromPythonToUnionFunction($$)
+sub FromPythonToUnionFunction($$$$)
 {
-	my ($self, $type) = @_;
+	my ($self, $type, $mem_ctx, $name) = @_;
 
 	#FIXME
 	$self->pidl("return NULL;");
 }
 
-sub FromPythonToStructFunction($$)
+sub FromPythonToStructFunction($$$$)
 {
-	my ($self, $type) = @_;
+	my ($self, $type, $mem_ctx, $name) = @_;
 
-	#FIXME
-	$self->pidl("return NULL;");
+	$self->pidl("$type->{NAME}\_Object *py_object = ($type->{NAME}_Object *)$name;");
+	$self->pidl("return talloc_reference($mem_ctx, py_object->object);");
 }
 
 sub PythonStruct($$$$)
@@ -222,7 +224,7 @@ sub PythonFunction($$$)
 	$self->pidl("$iface\_InterfaceObject *iface = ($iface\_InterfaceObject *)self;");
 	$self->pidl("NTSTATUS status;");
 	$self->pidl("TALLOC_CTX *mem_ctx = talloc_new(NULL);");
-	$self->pidl("struct dcerpc_$fn->{NAME} r;");
+	$self->pidl("struct $fn->{NAME} r;");
 	$self->pidl("PyObject *result;");
 	my $result_size = 0;
 
@@ -234,11 +236,13 @@ sub PythonFunction($$$)
 			$result_size++;
 		}
 	}
+	if ($result_size > 0) {
+		$self->pidl("");
+		$self->pidl("ZERO_STRUCT(r.out);");
+	}
 	if ($fn->{RETURN_TYPE}) {
 		$result_size++;
 	}
-	$self->pidl("");
-	$self->pidl("ZERO_STRUCT(r.out);");
 
 	foreach my $e (@{$fn->{ELEMENTS}}) {
 		if (grep(/in/,@{$e->{DIRECTION}})) {
@@ -322,8 +326,8 @@ sub PythonType($$$)
 		$self->pidl("PyObject *py_import_$d->{NAME}(" .mapTypeName($d) . " *in)");
 		$self->pidl("{");
 		$self->indent;
-		$self->FromStructToPythonFunction($d) if ($actual_ctype->{TYPE} eq "STRUCT");
-		$self->FromUnionToPythonFunction($d) if ($actual_ctype->{TYPE} eq "UNION");
+		$self->FromStructToPythonFunction($d, "in") if ($actual_ctype->{TYPE} eq "STRUCT");
+		$self->FromUnionToPythonFunction($d, "in") if ($actual_ctype->{TYPE} eq "UNION");
 		$self->deindent;
 		$self->pidl("}");
 		$self->pidl("");
@@ -331,8 +335,8 @@ sub PythonType($$$)
 		$self->pidl(mapTypeName($d) . " *py_export_$d->{NAME}(TALLOC_CTX *mem_ctx, PyObject *in)");
 		$self->pidl("{");
 		$self->indent;
-		$self->FromPythonToStructFunction($d) if ($actual_ctype->{TYPE} eq "STRUCT");
-		$self->FromPythonToUnionFunction($d) if ($actual_ctype->{TYPE} eq "UNION");
+		$self->FromPythonToStructFunction($d, "mem_ctx", "in") if ($actual_ctype->{TYPE} eq "STRUCT");
+		$self->FromPythonToUnionFunction($d, "mem_ctx", "in") if ($actual_ctype->{TYPE} eq "UNION");
 		$self->deindent;
 		$self->pidl("}");
 		$self->pidl("");
@@ -414,8 +418,8 @@ sub Interface($$$)
 	$self->pidl("PyObject_HEAD_INIT(NULL) 0,");
 	$self->pidl(".tp_name = \"$interface->{NAME}\",");
 	$self->pidl(".tp_basicsize = sizeof($interface->{NAME}_InterfaceObject),");
-	$self->pidl(".tp_dealloc = interface_$interface->{NAME}_dealloc,");
-	$self->pidl(".tp_getattr = interface_$interface->{NAME}_getattr,");
+	$self->pidl(".tp_dealloc = (destructor)interface_$interface->{NAME}_dealloc,");
+	$self->pidl(".tp_getattr = (getattrfunc)interface_$interface->{NAME}_getattr,");
 	$self->deindent;
 	$self->pidl("};");
 
@@ -567,9 +571,9 @@ sub ConvertObjectToPython($$$)
 	die("unknown type ".mapTypeName($ctype) . ": $cvar");
 }
 
-sub Parse($$$$)
+sub Parse($$$$$)
 {
-    my($self,$basename,$ndr,$hdr) = @_;
+    my($self,$basename,$ndr,$ndr_hdr,$hdr) = @_;
     
     my $py_hdr = $hdr;
     $py_hdr =~ s/ndr_([^\/]+)$/py_$1/g;
@@ -582,6 +586,7 @@ sub Parse($$$$)
 #include <Python.h>
 #include \"librpc/rpc/dcerpc.h\"
 #include \"$hdr\"
+#include \"$ndr_hdr\"
 #include \"$py_hdr\"
 
 ");
-- 
cgit 


From ce874c0b898eee3dfa8439424350579bf974e98f Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sun, 13 Jan 2008 15:51:15 +0100
Subject: pidl/python: Convert unions. (This used to be commit
 e9037d0f5d222efd4ca04a0f8ce5c39cb3bb6997)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 57 +++++++++++++++++++++-------
 1 file changed, 43 insertions(+), 14 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index fc5480b661..8720421088 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -91,36 +91,65 @@ sub EnumAndBitmapConsts($$$)
 
 sub FromUnionToPythonFunction($$$)
 {
-	my ($self, $type, $name) = @_;
+	my ($self, $type, $switch, $name) = @_;
 
-	#FIXME
+	$self->pidl("switch ($switch) {");
+	$self->indent;
+
+	foreach my $e (@{$type->{ELEMENTS}}) {
+		my $conv = $self->ConvertObjectToPython($e->{TYPE}, "$name->$e->{NAME}");
+		if (defined($e->{CASE})) {
+			$self->pidl("$e->{CASE}: return $conv;");
+		} else {
+			$self->pidl("default: return $conv;");
+		}
+	}
 
+	$self->deindent;
+	$self->pidl("}");
+
+	$self->pidl("PyErr_SetString(PyExc_TypeError, \"unknown union level\");");
 	$self->pidl("return NULL;");
 }
 
 sub FromStructToPythonFunction($$$)
 {
-	my ($self, $type, $name) = @_;
+	my ($self, $type, $typename, $name) = @_;
 
-	$self->pidl("$type->{NAME}\_Object *ret;");
-	$self->pidl("ret = PyObject_New($type->{NAME}\_Object, &$type->{NAME}\_ObjectType);");
+	$self->pidl("$typename\_Object *ret;");
+	$self->pidl("ret = PyObject_New($typename\_Object, &$typename\_ObjectType);");
 	$self->pidl("ret->object = talloc_reference(NULL, $name);");
 	$self->pidl("return (PyObject *) ret;");
 }
 
 sub FromPythonToUnionFunction($$$$)
 {
-	my ($self, $type, $mem_ctx, $name) = @_;
+	my ($self, $type, $switch, $mem_ctx, $name) = @_;
 
-	#FIXME
+	$self->pidl("switch ($switch) {");
+	$self->indent;
+
+	foreach my $e (@{$type->{ELEMENTS}}) {
+		my $conv = $self->ConvertObjectFromPython($e->{TYPE}, "$name");
+		if (defined($e->{CASE})) {
+			$self->pidl("$e->{CASE}: return $conv;");
+		} else {
+			$self->pidl("default: return $conv;");
+		}
+	}
+
+	$self->deindent;
+	$self->pidl("}");
+	$self->pidl("");
+	$self->pidl("PyErr_SetString(PyExc_TypeError, \"invalid union level value\");");
 	$self->pidl("return NULL;");
 }
 
-sub FromPythonToStructFunction($$$$)
+sub FromPythonToStructFunction($$$$$)
 {
-	my ($self, $type, $mem_ctx, $name) = @_;
+	my ($self, $type, $typename, $mem_ctx, $name) = @_;
 
-	$self->pidl("$type->{NAME}\_Object *py_object = ($type->{NAME}_Object *)$name;");
+	$self->pidl("$typename\_Object *py_object = ($typename\_Object *)$name;");
 	$self->pidl("return talloc_reference($mem_ctx, py_object->object);");
 }
 
@@ -326,8 +355,8 @@ sub PythonType($$$)
 		$self->pidl("PyObject *py_import_$d->{NAME}(" .mapTypeName($d) . " *in)");
 		$self->pidl("{");
 		$self->indent;
-		$self->FromStructToPythonFunction($d, "in") if ($actual_ctype->{TYPE} eq "STRUCT");
-		$self->FromUnionToPythonFunction($d, "in") if ($actual_ctype->{TYPE} eq "UNION");
+		$self->FromStructToPythonFunction($actual_ctype, $d->{NAME}, "in") if ($actual_ctype->{TYPE} eq "STRUCT");
+		$self->FromUnionToPythonFunction($actual_ctype, "level", "in") if ($actual_ctype->{TYPE} eq "UNION");
 		$self->deindent;
 		$self->pidl("}");
 		$self->pidl("");
@@ -335,8 +364,8 @@ sub PythonType($$$)
 		$self->pidl(mapTypeName($d) . " *py_export_$d->{NAME}(TALLOC_CTX *mem_ctx, PyObject *in)");
 		$self->pidl("{");
 		$self->indent;
-		$self->FromPythonToStructFunction($d, "mem_ctx", "in") if ($actual_ctype->{TYPE} eq "STRUCT");
-		$self->FromPythonToUnionFunction($d, "mem_ctx", "in") if ($actual_ctype->{TYPE} eq "UNION");
+		$self->FromPythonToStructFunction($actual_ctype, $d->{NAME}, "mem_ctx", "in") if ($actual_ctype->{TYPE} eq "STRUCT");
+		$self->FromPythonToUnionFunction($actual_ctype, "level", "mem_ctx", "in") if ($actual_ctype->{TYPE} eq "UNION");
 		$self->deindent;
 		$self->pidl("}");
 		$self->pidl("");
-- 
cgit 


From d06c990dbe89cb3b5996b3470a36de1b821bcdfc Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sun, 13 Jan 2008 16:59:15 +0100
Subject: pidl/python: Use new talloc utility functions. (This used to be
 commit 48cfd44dc088717c0282436148888e45b2632946)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 73 +++++++++-------------------
 1 file changed, 24 insertions(+), 49 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 8720421088..4b552a9ba9 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -112,16 +112,6 @@ sub FromUnionToPythonFunction($$$)
 	$self->pidl("return NULL;");
 }
 
-sub FromStructToPythonFunction($$$)
-{
-	my ($self, $type, $typename, $name) = @_;
-
-	$self->pidl("$typename\_Object *ret;");
-	$self->pidl("ret = PyObject_New($typename\_Object, &$typename\_ObjectType);");
-	$self->pidl("ret->object = talloc_reference(NULL, $name);");
-	$self->pidl("return (PyObject *) ret;");
-}
-
 sub FromPythonToUnionFunction($$$$)
 {
 	my ($self, $type, $switch, $mem_ctx, $name) = @_;
@@ -145,33 +135,19 @@ sub FromPythonToUnionFunction($$$$)
 	$self->pidl("return NULL;");
 }
 
-sub FromPythonToStructFunction($$$$$)
-{
-	my ($self, $type, $typename, $mem_ctx, $name) = @_;
-
-	$self->pidl("$typename\_Object *py_object = ($typename\_Object *)$name;");
-	$self->pidl("return talloc_reference($mem_ctx, py_object->object);");
-}
-
 sub PythonStruct($$$$)
 {
 	my ($self, $name, $cname, $d) = @_;
 
 	$self->pidl("staticforward PyTypeObject $name\_ObjectType;");
-	$self->pidl("typedef struct {");
-	$self->indent;
-	$self->pidl("PyObject_HEAD");
-	$self->pidl("$cname *object;");
-	$self->deindent;
-	$self->pidl("} $name\_Object;");
 
 	$self->pidl("");
 
 	$self->pidl("static PyObject *py_$name\_getattr(PyTypeObject *obj, char *name)");
 	$self->pidl("{");
 	$self->indent;
-	$self->pidl("$name\_Object *py_object = ($name\_Object *)obj;");
-	$self->pidl("$cname *object = talloc_get_type(py_object->object, $cname);");
+	$self->pidl("py_talloc_Object *py_object = (py_talloc_Object *)obj;");
+	$self->pidl("$cname *object = py_talloc_get_type(py_object, $cname);");
 	foreach my $e (@{$d->{ELEMENTS}}) {
 		$self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {");
 		my $varname = "object->$e->{NAME}";
@@ -186,21 +162,11 @@ sub PythonStruct($$$$)
 	$self->pidl("}");
 	$self->pidl("");
 
-	$self->pidl("static void py_$name\_dealloc(PyObject* self)");
-	$self->pidl("{");
-	$self->indent;
-	$self->pidl("$name\_Object *obj = ($name\_Object *)self;");
-	$self->pidl("talloc_free(obj->object);");
-	$self->pidl("PyObject_Del(self);");
-	$self->deindent;
-	$self->pidl("}");
-	$self->pidl("");
-
 	$self->pidl("static PyObject *py_$name\_setattr(PyTypeObject *obj, char *name, PyObject *value)");
 	$self->pidl("{");
 	$self->indent;
-	$self->pidl("$name\_Object *py_object = ($name\_Object *)obj;");
-	$self->pidl("$cname *object = talloc_get_type(py_object->object, $cname);");
+	$self->pidl("py_talloc_Object *py_object = (py_talloc_Object *)obj;");
+	$self->pidl("$cname *object = py_talloc_get_type(py_object, $cname);");
 	foreach my $e (@{$d->{ELEMENTS}}) {
 		$self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {");
 		my $varname = "object->$e->{NAME}";
@@ -220,8 +186,8 @@ sub PythonStruct($$$$)
 	$self->indent;
 	$self->pidl("PyObject_HEAD_INIT(NULL) 0,");
 	$self->pidl(".tp_name = \"$name\",");
-	$self->pidl(".tp_basicsize = sizeof($name\_Object),");
-	$self->pidl(".tp_dealloc = (destructor)py_$name\_dealloc,");
+	$self->pidl(".tp_basicsize = sizeof(py_talloc_Object),");
+	$self->pidl(".tp_dealloc = (destructor)py_talloc_dealloc,");
 	$self->pidl(".tp_getattr = (getattrfunc)py_$name\_getattr,");
 	$self->pidl(".tp_setattr = (setattrfunc)py_$name\_setattr,");
 	$self->deindent;
@@ -233,9 +199,8 @@ sub PythonStruct($$$$)
 	$self->pidl("static PyObject *$py_fnname(PyObject *self, PyObject *args)");
 	$self->pidl("{");
 	$self->indent;
-	$self->pidl("$name\_Object *ret;");
-	$self->pidl("ret = PyObject_New($name\_Object, &$name\_ObjectType);");
-	$self->pidl("return (PyObject *) ret;");
+	$self->pidl("$cname *ret = talloc_zero(NULL, $cname);");
+	$self->pidl("return py_talloc_import(&$name\_ObjectType, ret);");
 	$self->deindent;
 	$self->pidl("}");
 	$self->pidl("");
@@ -351,11 +316,10 @@ sub PythonType($$$)
 		$self->EnumAndBitmapConsts($d->{NAME}, $d->{DATA});
 	}
 
-	if ($actual_ctype->{TYPE} eq "UNION" or $actual_ctype->{TYPE} eq "STRUCT") {
+	if ($actual_ctype->{TYPE} eq "UNION") {
 		$self->pidl("PyObject *py_import_$d->{NAME}(" .mapTypeName($d) . " *in)");
 		$self->pidl("{");
 		$self->indent;
-		$self->FromStructToPythonFunction($actual_ctype, $d->{NAME}, "in") if ($actual_ctype->{TYPE} eq "STRUCT");
 		$self->FromUnionToPythonFunction($actual_ctype, "level", "in") if ($actual_ctype->{TYPE} eq "UNION");
 		$self->deindent;
 		$self->pidl("}");
@@ -364,7 +328,6 @@ sub PythonType($$$)
 		$self->pidl(mapTypeName($d) . " *py_export_$d->{NAME}(TALLOC_CTX *mem_ctx, PyObject *in)");
 		$self->pidl("{");
 		$self->indent;
-		$self->FromPythonToStructFunction($actual_ctype, $d->{NAME}, "mem_ctx", "in") if ($actual_ctype->{TYPE} eq "STRUCT");
 		$self->FromPythonToUnionFunction($actual_ctype, "level", "mem_ctx", "in") if ($actual_ctype->{TYPE} eq "UNION");
 		$self->deindent;
 		$self->pidl("}");
@@ -516,6 +479,14 @@ sub ConvertObjectFromPython($$$)
 		return "PyInt_AsLong($cvar)";
 	}
 
+	if ($actual_ctype->{TYPE} eq "STRUCT") {
+		return "py_talloc_get_type($cvar, " . mapTypeName($ctype) . ")";
+	}
+
+	if ($actual_ctype->{TYPE} eq "UNION") {
+		return "py_export_$ctype->{NAME}($cvar)";
+	}
+
 	return "FIXME($cvar)";
 }
 
@@ -556,12 +527,15 @@ sub ConvertObjectToPython($$$)
 		return "PyInt_FromLong($cvar)";
 	}
 
-	if ($ctype->{TYPE} eq "TYPEDEF" and (
-			$actual_ctype->{TYPE} eq "STRUCT" or 
-			$actual_ctype->{TYPE} eq "UNION")) {
+	if ($ctype->{TYPE} eq "TYPEDEF" and $actual_ctype->{TYPE} eq "UNION") {
 		return "py_import_$ctype->{NAME}($cvar)";
 	}
 
+	if ($ctype->{TYPE} eq "TYPEDEF" and $actual_ctype->{TYPE} eq "STRUCT") {
+		# FIXME: if $cvar is not a pointer, do a talloc_dup()
+		return "py_talloc_import(&$ctype->{NAME}_ObjectType, $cvar)";
+	}
+
 	if ($actual_ctype->{TYPE} eq "SCALAR" and 
 		expandAlias($actual_ctype->{NAME}) eq "DATA_BLOB") {
 		return "PyString_FromStringAndSize($cvar->data, $cvar->length)";
@@ -614,6 +588,7 @@ sub Parse($$$$$)
 #include \"includes.h\"
 #include <Python.h>
 #include \"librpc/rpc/dcerpc.h\"
+#include \"scripting/python/pytalloc.h\"
 #include \"$hdr\"
 #include \"$ndr_hdr\"
 #include \"$py_hdr\"
-- 
cgit 


From 915f1589252be8cb9fb86eed479e328371e355e1 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sun, 13 Jan 2008 17:15:56 +0100
Subject: pidl/python: Support more scalar types when converting from Python.
 (This used to be commit 1f3bbb65e5a46715c49225eecc760faaf5dbb9d7)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 67 +++++++++++++++++++---------
 1 file changed, 47 insertions(+), 20 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 4b552a9ba9..1c0cafc050 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -120,7 +120,7 @@ sub FromPythonToUnionFunction($$$$)
 	$self->indent;
 
 	foreach my $e (@{$type->{ELEMENTS}}) {
-		my $conv = $self->ConvertObjectFromPython($e->{TYPE}, "$name");
+		my $conv = $self->ConvertObjectFromPython($mem_ctx, $e->{TYPE}, "$name");
 		if (defined($e->{CASE})) {
 			$self->pidl("$e->{CASE}: return $conv;");
 		} else {
@@ -143,11 +143,10 @@ sub PythonStruct($$$$)
 
 	$self->pidl("");
 
-	$self->pidl("static PyObject *py_$name\_getattr(PyTypeObject *obj, char *name)");
+	$self->pidl("static PyObject *py_$name\_getattr(PyObject *obj, char *name)");
 	$self->pidl("{");
 	$self->indent;
-	$self->pidl("py_talloc_Object *py_object = (py_talloc_Object *)obj;");
-	$self->pidl("$cname *object = py_talloc_get_type(py_object, $cname);");
+	$self->pidl("$cname *object = py_talloc_get_type(obj, $cname);");
 	foreach my $e (@{$d->{ELEMENTS}}) {
 		$self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {");
 		my $varname = "object->$e->{NAME}";
@@ -162,17 +161,16 @@ sub PythonStruct($$$$)
 	$self->pidl("}");
 	$self->pidl("");
 
-	$self->pidl("static PyObject *py_$name\_setattr(PyTypeObject *obj, char *name, PyObject *value)");
+	$self->pidl("static PyObject *py_$name\_setattr(PyObject *obj, char *name, PyObject *value)");
 	$self->pidl("{");
 	$self->indent;
-	$self->pidl("py_talloc_Object *py_object = (py_talloc_Object *)obj;");
 	$self->pidl("$cname *object = py_talloc_get_type(py_object, $cname);");
 	foreach my $e (@{$d->{ELEMENTS}}) {
 		$self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {");
 		my $varname = "object->$e->{NAME}";
 		$self->indent;
 		$self->pidl("/* FIXME: talloc_free($varname) if necessary */");
-		$self->pidl("$varname = " . $self->ConvertObjectFromPython($e->{TYPE}, "value") . ";");
+		$self->pidl("$varname = " . $self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "value") . ";");
 		$self->deindent;
 		$self->pidl("}");
 	}
@@ -187,9 +185,9 @@ sub PythonStruct($$$$)
 	$self->pidl("PyObject_HEAD_INIT(NULL) 0,");
 	$self->pidl(".tp_name = \"$name\",");
 	$self->pidl(".tp_basicsize = sizeof(py_talloc_Object),");
-	$self->pidl(".tp_dealloc = (destructor)py_talloc_dealloc,");
-	$self->pidl(".tp_getattr = (getattrfunc)py_$name\_getattr,");
-	$self->pidl(".tp_setattr = (setattrfunc)py_$name\_setattr,");
+	$self->pidl(".tp_dealloc = py_talloc_dealloc,");
+	$self->pidl(".tp_getattr = py_$name\_getattr,");
+	$self->pidl(".tp_setattr = py_$name\_setattr,");
 	$self->deindent;
 	$self->pidl("};");
 
@@ -240,7 +238,7 @@ sub PythonFunction($$$)
 
 	foreach my $e (@{$fn->{ELEMENTS}}) {
 		if (grep(/in/,@{$e->{DIRECTION}})) {
-			$self->pidl("r.in.$e->{NAME} = " . $self->ConvertObjectFromPython($e->{TYPE}, "py_$e->{NAME}") . ";");
+			$self->pidl("r.in.$e->{NAME} = " . $self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "py_$e->{NAME}") . ";");
 		}
 	}
 	$self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, &r);");
@@ -396,10 +394,10 @@ sub Interface($$$)
 	$self->pidl("}");
 	$self->pidl("");
 
-	$self->pidl("static PyObject *interface_$interface->{NAME}_getattr(PyTypeObject *obj, char *name)");
+	$self->pidl("static PyObject *interface_$interface->{NAME}_getattr(PyObject *obj, char *name)");
 	$self->pidl("{");
 	$self->indent;
-	$self->pidl("return Py_FindMethod(interface_$interface->{NAME}\_methods, (PyObject *)obj, name);");
+	$self->pidl("return Py_FindMethod(interface_$interface->{NAME}\_methods, obj, name);");
 	$self->deindent;
 	$self->pidl("}");
 
@@ -454,9 +452,9 @@ sub register_module_method($$$$$)
 	push (@{$self->{module_methods}}, [$fn_name, $pyfn_name, $flags, $doc])
 }
 
-sub ConvertObjectFromPython($$$)
+sub ConvertObjectFromPython($$$$)
 {
-	my ($self, $ctype, $cvar) = @_;
+	my ($self, $mem_ctx, $ctype, $cvar) = @_;
 
 	die("undef type for $cvar") unless(defined($ctype));
 
@@ -475,7 +473,7 @@ sub ConvertObjectFromPython($$$)
 
 	if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or 
 		$actual_ctype->{TYPE} eq "SCALAR" and (
-		expandAlias($actual_ctype->{NAME}) =~ /^(uint[0-9]+|hyper|NTTIME|time_t|NTTIME_hyper|NTTIME_1sec|dlong|udlong)$/)) {
+		expandAlias($actual_ctype->{NAME}) =~ /^(u?int[0-9]+|hyper|NTTIME|time_t|NTTIME_hyper|NTTIME_1sec|dlong|udlong|udlongr)$/)) {
 		return "PyInt_AsLong($cvar)";
 	}
 
@@ -487,7 +485,37 @@ sub ConvertObjectFromPython($$$)
 		return "py_export_$ctype->{NAME}($cvar)";
 	}
 
-	return "FIXME($cvar)";
+	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "DATA_BLOB") {
+		return "data_blob_talloc($mem_ctx, PyString_AsString($cvar), PyString_Size($cvar))";
+	}
+
+	if ($actual_ctype->{TYPE} eq "SCALAR" and 
+		($actual_ctype->{NAME} eq "string" or $actual_ctype->{NAME} eq "nbt_string" or $actual_ctype->{NAME} eq "nbt_name" or $actual_ctype->{NAME} eq "wrepl_nbt_name")) {
+		return "talloc_strdup($mem_ctx, PyString_AsString($cvar))";
+	}
+
+	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "ipv4address") {
+		return "FIXME($cvar)";
+		}
+
+
+	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "NTSTATUS") {
+		return "PyInt_AsLong($cvar)";
+	}
+
+	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "WERROR") {
+		return "PyInt_AsLong($cvar)";
+	}
+
+	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "string_array") {
+		return "FIXME($cvar)";
+	}
+
+	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "pointer") {
+		return "PyCObject_AsVoidPtr($cvar)";
+	}
+
+	die("unknown type ".mapTypeName($ctype) . ": $cvar");
 }
 
 sub ConvertObjectToPython($$$)
@@ -546,11 +574,11 @@ sub ConvertObjectToPython($$$)
 	}
 
 	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "NTSTATUS") {
-		return "PyInt_FromLong($cvar->v)";
+		return "PyInt_FromLong(NT_STATUS_V($cvar))";
 	}
 
 	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "WERROR") {
-		return "PyInt_FromLong($cvar->v)";
+		return "PyInt_FromLong(W_ERROR_V($cvar))";
 	}
 
 	if ($actual_ctype->{TYPE} eq "SCALAR" and 
@@ -570,7 +598,6 @@ sub ConvertObjectToPython($$$)
 		return "PyCObject_FromVoidPtr($cvar, talloc_free)";
 	}
 
-
 	die("unknown type ".mapTypeName($ctype) . ": $cvar");
 }
 
-- 
cgit 


From be01d080247c70ec260763adc7711976c8ee19fc Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sun, 13 Jan 2008 18:05:43 +0100
Subject: pidl/python: Work towards supporting more complex types (arrays,
 etc). (This used to be commit 49d91a1a92e226c015db86ddc9ef772030415d76)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 191 ++++++++++++++++-----------
 1 file changed, 115 insertions(+), 76 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 1c0cafc050..545d233d08 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -97,7 +97,13 @@ sub FromUnionToPythonFunction($$$)
 	$self->indent;
 
 	foreach my $e (@{$type->{ELEMENTS}}) {
-		my $conv = $self->ConvertObjectToPython($e->{TYPE}, "$name->$e->{NAME}");
+		my $conv;
+		
+		if ($e->{NAME}) {
+			$conv = $self->ConvertObjectToPython($e->{TYPE}, "$name->$e->{NAME}");
+		} else {
+			$conv = "Py_None";
+		}
 		if (defined($e->{CASE})) {
 			$self->pidl("$e->{CASE}: return $conv;");
 		} else {
@@ -112,27 +118,46 @@ sub FromUnionToPythonFunction($$$)
 	$self->pidl("return NULL;");
 }
 
-sub FromPythonToUnionFunction($$$$)
+sub FromPythonToUnionFunction($$$$$)
 {
-	my ($self, $type, $switch, $mem_ctx, $name) = @_;
+	my ($self, $type, $typename, $switch, $mem_ctx, $name) = @_;
+
+	my $has_default = 0;
+
+	$self->pidl("$typename *ret = talloc_zero($mem_ctx, $typename);");
 
 	$self->pidl("switch ($switch) {");
 	$self->indent;
 
 	foreach my $e (@{$type->{ELEMENTS}}) {
-		my $conv = $self->ConvertObjectFromPython($mem_ctx, $e->{TYPE}, "$name");
 		if (defined($e->{CASE})) {
-			$self->pidl("$e->{CASE}: return $conv;");
+			$self->pidl("$e->{CASE}:");
 		} else {
-			$self->pidl("default: return $conv;");
+			$has_default = 1;
+			$self->pidl("default:");
 		}
+		$self->indent;
+		if ($e->{NAME}) {
+			$self->ConvertObjectFromPython($mem_ctx, $e->{TYPE}, $name, "ret->$e->{NAME}");
+		}
+		$self->pidl("break;");
+		$self->deindent;
+		$self->pidl("");
+	}
+
+	if (!$has_default) {
+		$self->pidl("default:");
+		$self->indent;
+		$self->pidl("PyErr_SetString(PyExc_TypeError, \"invalid union level value\");");
+		$self->pidl("talloc_free(ret);");
+		$self->pidl("ret = NULL;");
+		$self->deindent;
 	}
 
 	$self->deindent;
 	$self->pidl("}");
 	$self->pidl("");
-	$self->pidl("PyErr_SetString(PyExc_TypeError, \"invalid union level value\");");
-	$self->pidl("return NULL;");
+	$self->pidl("return ret;");
 }
 
 sub PythonStruct($$$$)
@@ -161,21 +186,22 @@ sub PythonStruct($$$$)
 	$self->pidl("}");
 	$self->pidl("");
 
-	$self->pidl("static PyObject *py_$name\_setattr(PyObject *obj, char *name, PyObject *value)");
+	$self->pidl("static int py_$name\_setattr(PyObject *py_obj, char *name, PyObject *value)");
 	$self->pidl("{");
 	$self->indent;
-	$self->pidl("$cname *object = py_talloc_get_type(py_object, $cname);");
+	$self->pidl("$cname *object = py_talloc_get_type(py_obj, $cname);");
 	foreach my $e (@{$d->{ELEMENTS}}) {
 		$self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {");
 		my $varname = "object->$e->{NAME}";
 		$self->indent;
 		$self->pidl("/* FIXME: talloc_free($varname) if necessary */");
-		$self->pidl("$varname = " . $self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "value") . ";");
+		$self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "value", $varname);
+		$self->pidl("return 0;");
 		$self->deindent;
 		$self->pidl("}");
 	}
 	$self->pidl("PyErr_SetString(PyExc_AttributeError, \"no such attribute\");");
-	$self->pidl("return NULL;");
+	$self->pidl("return -1;");
 	$self->deindent;
 	$self->pidl("}");
 	$self->pidl("");
@@ -238,7 +264,7 @@ sub PythonFunction($$$)
 
 	foreach my $e (@{$fn->{ELEMENTS}}) {
 		if (grep(/in/,@{$e->{DIRECTION}})) {
-			$self->pidl("r.in.$e->{NAME} = " . $self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "py_$e->{NAME}") . ";");
+			$self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "py_$e->{NAME}", "r.in.$e->{NAME}");
 		}
 	}
 	$self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, &r);");
@@ -303,7 +329,7 @@ sub PythonType($$$)
 		$fn_name =~ s/^$interface->{NAME}_//;
 		$fn_name =~ s/^$basename\_//;
 
-		$self->register_module_method($fn_name, $py_fnname, "METH_VARARGS|METH_KEYWORDS", "NULL");
+		$self->register_module_method($fn_name, $py_fnname, "METH_NOARGS", "NULL");
 	}
 
 	if ($d->{TYPE} eq "ENUM" or $d->{TYPE} eq "BITMAP") {
@@ -315,7 +341,7 @@ sub PythonType($$$)
 	}
 
 	if ($actual_ctype->{TYPE} eq "UNION") {
-		$self->pidl("PyObject *py_import_$d->{NAME}(" .mapTypeName($d) . " *in)");
+		$self->pidl("PyObject *py_import_$d->{NAME}(int level, " .mapTypeName($d) . " *in)");
 		$self->pidl("{");
 		$self->indent;
 		$self->FromUnionToPythonFunction($actual_ctype, "level", "in") if ($actual_ctype->{TYPE} eq "UNION");
@@ -323,10 +349,10 @@ sub PythonType($$$)
 		$self->pidl("}");
 		$self->pidl("");
 
-		$self->pidl(mapTypeName($d) . " *py_export_$d->{NAME}(TALLOC_CTX *mem_ctx, PyObject *in)");
+		$self->pidl(mapTypeName($d) . " *py_export_$d->{NAME}(TALLOC_CTX *mem_ctx, int level, PyObject *in)");
 		$self->pidl("{");
 		$self->indent;
-		$self->FromPythonToUnionFunction($actual_ctype, "level", "mem_ctx", "in") if ($actual_ctype->{TYPE} eq "UNION");
+		$self->FromPythonToUnionFunction($actual_ctype, mapTypeName($d), "level", "mem_ctx", "in") if ($actual_ctype->{TYPE} eq "UNION");
 		$self->deindent;
 		$self->pidl("}");
 		$self->pidl("");
@@ -452,9 +478,9 @@ sub register_module_method($$$$$)
 	push (@{$self->{module_methods}}, [$fn_name, $pyfn_name, $flags, $doc])
 }
 
-sub ConvertObjectFromPython($$$$)
+sub ConvertObjectFromPython($$$$$)
 {
-	my ($self, $mem_ctx, $ctype, $cvar) = @_;
+	my ($self, $mem_ctx, $ctype, $cvar, $target) = @_;
 
 	die("undef type for $cvar") unless(defined($ctype));
 
@@ -463,7 +489,8 @@ sub ConvertObjectFromPython($$$$)
 	}
 
 	if (ref($ctype) ne "HASH") {
-		return "FIXME($cvar)";
+		$self->pidl("$target = FIXME($cvar);");
+		return;
 	}
 
 	my $actual_ctype = $ctype;
@@ -474,64 +501,102 @@ sub ConvertObjectFromPython($$$$)
 	if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or 
 		$actual_ctype->{TYPE} eq "SCALAR" and (
 		expandAlias($actual_ctype->{NAME}) =~ /^(u?int[0-9]+|hyper|NTTIME|time_t|NTTIME_hyper|NTTIME_1sec|dlong|udlong|udlongr)$/)) {
-		return "PyInt_AsLong($cvar)";
+		$self->pidl("$target = PyInt_AsLong($cvar);");
+		return;
 	}
 
 	if ($actual_ctype->{TYPE} eq "STRUCT") {
-		return "py_talloc_get_type($cvar, " . mapTypeName($ctype) . ")";
+		$self->pidl("$target = py_talloc_get_type($cvar, " . mapTypeName($ctype) . ");");
+		return;
 	}
 
 	if ($actual_ctype->{TYPE} eq "UNION") {
-		return "py_export_$ctype->{NAME}($cvar)";
+		$self->pidl("$target = py_export_$ctype->{NAME}($cvar);");
+		return;
 	}
 
 	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "DATA_BLOB") {
-		return "data_blob_talloc($mem_ctx, PyString_AsString($cvar), PyString_Size($cvar))";
+		$self->pidl("$target = data_blob_talloc($mem_ctx, PyString_AsString($cvar), PyString_Size($cvar));");
+		return;
 	}
 
 	if ($actual_ctype->{TYPE} eq "SCALAR" and 
 		($actual_ctype->{NAME} eq "string" or $actual_ctype->{NAME} eq "nbt_string" or $actual_ctype->{NAME} eq "nbt_name" or $actual_ctype->{NAME} eq "wrepl_nbt_name")) {
-		return "talloc_strdup($mem_ctx, PyString_AsString($cvar))";
+		$self->pidl("$target = talloc_strdup($mem_ctx, PyString_AsString($cvar));");
+		return;
 	}
 
 	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "ipv4address") {
-		return "FIXME($cvar)";
+		$self->pidl("$target = FIXME($cvar);");
+		return;
 		}
 
 
 	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "NTSTATUS") {
-		return "PyInt_AsLong($cvar)";
+		$self->pidl("$target = PyInt_AsLong($cvar);");
+		return;
 	}
 
 	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "WERROR") {
-		return "PyInt_AsLong($cvar)";
+		$self->pidl("$target = PyInt_AsLong($cvar);");
+		return;
 	}
 
 	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "string_array") {
-		return "FIXME($cvar)";
+		$self->pidl("$target = FIXME($cvar);");
+		return;
 	}
 
 	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "pointer") {
-		return "PyCObject_AsVoidPtr($cvar)";
+		$self->pidl("$target = PyCObject_AsVoidPtr($cvar);");
+		return;
 	}
 
 	die("unknown type ".mapTypeName($ctype) . ": $cvar");
 }
 
-sub ConvertObjectToPython($$$)
+sub ConvertScalarToPython($$$)
 {
-	my ($self, $ctype, $cvar) = @_;
+	my ($self, $ctypename, $cvar) = @_;
 
-	if ($cvar =~ /^[0-9]+$/ or $cvar =~ /^0x[0-9a-fA-F]+$/) {
+	$ctypename = expandAlias($ctypename);
+
+	if ($ctypename =~ /^(int|long|char|u?int[0-9]+|hyper|dlong|udlong|udlongr|time_t|NTTIME_hyper|NTTIME|NTTIME_1sec)$/) {
 		return "PyInt_FromLong($cvar)";
 	}
 
-	die("undef type for $cvar") unless(defined($ctype));
+	if ($ctypename eq "DATA_BLOB") {
+		return "PyString_FromStringAndSize($cvar->data, $cvar->length)";
+	}
+
+	if ($ctypename eq "NTSTATUS") {
+		return "PyInt_FromLong(NT_STATUS_V($cvar))";
+	}
+
+	if ($ctypename eq "WERROR") {
+		return "PyInt_FromLong(W_ERROR_V($cvar))";
+	}
 
-	if ($cvar =~ /^".*"$/) {
+	if (($ctypename eq "string" or $ctypename eq "nbt_string" or $ctypename eq "nbt_name" or $ctypename eq "wrepl_nbt_name")) {
 		return "PyString_FromString($cvar)";
 	}
 
+	if ($ctypename eq "string_array") { return "FIXME($cvar)"; }
+
+	if ($$ctypename eq "ipv4address") { return "FIXME($cvar)"; }
+	if ($ctypename eq "pointer") {
+		return "PyCObject_FromVoidPtr($cvar, talloc_free)";
+	}
+
+	die("Unknown scalar type $ctypename");
+}
+
+sub ConvertObjectToPython($$$)
+{
+	my ($self, $ctype, $cvar) = @_;
+
+	die("undef type for $cvar") unless(defined($ctype));
+
 	if (ref($ctype) ne "HASH") {
 		if (not hasType($ctype)) {
 			if (ref($ctype) eq "HASH") {
@@ -550,54 +615,19 @@ sub ConvertObjectToPython($$$)
 	}
 
 	if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or 
-		($actual_ctype->{TYPE} eq "SCALAR" and 
-		expandAlias($actual_ctype->{NAME}) =~ /^(int|long|char|u?int[0-9]+|hyper|dlong|udlong|udlongr|time_t|NTTIME_hyper|NTTIME|NTTIME_1sec)$/)) {
-		return "PyInt_FromLong($cvar)";
+		($actual_ctype->{TYPE} eq "SCALAR") {
+		return $self->ConvertScalarToPython($actual_ctype->{NAME}, $cvar);
 	}
 
-	if ($ctype->{TYPE} eq "TYPEDEF" and $actual_ctype->{TYPE} eq "UNION") {
+	if ($actual_ctype->{TYPE} eq "UNION") {
 		return "py_import_$ctype->{NAME}($cvar)";
 	}
 
-	if ($ctype->{TYPE} eq "TYPEDEF" and $actual_ctype->{TYPE} eq "STRUCT") {
+	if ($actual_ctype->{TYPE} eq "STRUCT") {
 		# FIXME: if $cvar is not a pointer, do a talloc_dup()
 		return "py_talloc_import(&$ctype->{NAME}_ObjectType, $cvar)";
 	}
 
-	if ($actual_ctype->{TYPE} eq "SCALAR" and 
-		expandAlias($actual_ctype->{NAME}) eq "DATA_BLOB") {
-		return "PyString_FromStringAndSize($cvar->data, $cvar->length)";
-	}
-
-	if ($ctype->{TYPE} eq "STRUCT" or $ctype->{TYPE} eq "UNION") {
-		return "py_import_$ctype->{TYPE}_$ctype->{NAME}($cvar)";
-	}
-
-	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "NTSTATUS") {
-		return "PyInt_FromLong(NT_STATUS_V($cvar))";
-	}
-
-	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "WERROR") {
-		return "PyInt_FromLong(W_ERROR_V($cvar))";
-	}
-
-	if ($actual_ctype->{TYPE} eq "SCALAR" and 
-		($actual_ctype->{NAME} eq "string" or $actual_ctype->{NAME} eq "nbt_string" or $actual_ctype->{NAME} eq "nbt_name" or $actual_ctype->{NAME} eq "wrepl_nbt_name")) {
-		return "PyString_FromString($cvar)";
-	}
-
-	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "string_array") {
-		return "FIXME($cvar)";
-	}
-
-	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "ipv4address") {
-		return "FIXME($cvar)";
-		}
-
-	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "pointer") {
-		return "PyCObject_FromVoidPtr($cvar, talloc_free)";
-	}
-
 	die("unknown type ".mapTypeName($ctype) . ": $cvar");
 }
 
@@ -646,8 +676,17 @@ sub Parse($$$$$)
 	$self->pidl("PyObject *m;");
 	$self->pidl("m = Py_InitModule(\"$basename\", $basename\_methods);");
 	foreach (keys %{$self->{constants}}) {
-		# FIXME: Handle non-string constants
-		$self->pidl("PyModule_AddObject(m, \"$_\", " .  $self->ConvertObjectToPython($self->{constants}->{$_}->[0], $self->{constants}->{$_}->[1]) . ");");
+		my $py_obj;
+		my ($ctype, $cvar) = @{$self->{constants}->{$_}};
+		if ($cvar =~ /^[0-9]+$/ or $cvar =~ /^0x[0-9a-fA-F]+$/) {
+			$py_obj = "PyInt_FromLong($cvar)";
+		} elsif ($cvar =~ /^".*"$/) {
+			$py_obj = "PyString_FromString($cvar)";
+		} else {
+			$py_obj = $self->ConvertScalarToPython($ctype, $cvar);
+		}
+
+		$self->pidl("PyModule_AddObject(m, \"$_\", $py_obj);");
 	}
 	$self->deindent;
 	$self->pidl("}");
-- 
cgit 


From a99dff8660ca2d168523b7264d9208a8a12ca5cc Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sun, 13 Jan 2008 18:15:12 +0100
Subject: pidl: Move Generate*Env functions to Parse::Pidl::Samba4::Header
 because they only work with the structures generated by that file. (This used
 to be commit 9aeb7f31b0fc3b9679e5af07e65e79bc8073c4e1)

---
 source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm  |  4 +-
 source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm        |  2 +-
 source4/pidl/lib/Parse/Pidl/Samba4/Header.pm     | 71 +++++++++++++++++++++++-
 source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 65 +---------------------
 4 files changed, 75 insertions(+), 67 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm
index b7372a802a..86b8951026 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm
@@ -9,7 +9,7 @@ package Parse::Pidl::Samba3::ClientNDR;
 
 use Exporter;
 @ISA = qw(Exporter);
-@EXPORT_OK = qw(GenerateFunctionInEnv ParseFunction $res $res_hdr);
+@EXPORT_OK = qw(ParseFunction $res $res_hdr);
 
 use strict;
 use Parse::Pidl qw(fatal warning);
@@ -17,7 +17,7 @@ use Parse::Pidl::Typelist qw(hasType getType mapTypeName scalar_is_reference);
 use Parse::Pidl::Util qw(has_property is_constant ParseExpr);
 use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred);
 use Parse::Pidl::Samba4 qw(DeclLong);
-use Parse::Pidl::Samba4::NDR::Parser qw(GenerateFunctionInEnv);
+use Parse::Pidl::Samba4::Header qw(GenerateFunctionInEnv);
 
 use vars qw($VERSION);
 $VERSION = '0.01';
diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm
index 24270340b9..efb3f2858d 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm
@@ -15,7 +15,7 @@ use Parse::Pidl::Typelist qw(typeHasBody);
 use Parse::Pidl::CUtil qw(get_pointer_to get_value_of);
 use Parse::Pidl::Util qw(has_property ParseExpr);
 use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel);
-use Parse::Pidl::Samba4::NDR::Parser qw(GenerateStructEnv GenerateFunctionInEnv
+use Parse::Pidl::Samba4::Header qw(GenerateStructEnv GenerateFunctionInEnv
                                         GenerateFunctionOutEnv);
 
 use vars qw($VERSION);
diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm
index b96a58783c..06e9ec4b9f 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm
@@ -6,10 +6,15 @@
 
 package Parse::Pidl::Samba4::Header;
 
+require Exporter;
+
+@ISA = qw(Exporter);
+@EXPORT_OK = qw(GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv);
+
 use strict;
 use Parse::Pidl qw(fatal);
 use Parse::Pidl::Typelist qw(mapTypeName scalar_is_reference);
-use Parse::Pidl::Util qw(has_property is_constant unmake_str);
+use Parse::Pidl::Util qw(has_property is_constant unmake_str ParseExpr);
 use Parse::Pidl::Samba4 qw(is_intree ElementStars ArrayBrackets choose_header);
 
 use vars qw($VERSION);
@@ -406,4 +411,68 @@ sub Parse($)
 	return $res;
 }
 
+sub GenerateStructEnv($$)
+{
+	my ($x, $v) = @_;
+	my %env;
+
+	foreach my $e (@{$x->{ELEMENTS}}) {
+		$env{$e->{NAME}} = "$v->$e->{NAME}";
+	}
+
+	$env{"this"} = $v;
+
+	return \%env;
+}
+
+sub EnvSubstituteValue($$)
+{
+	my ($env,$s) = @_;
+
+	# Substitute the value() values in the env
+	foreach my $e (@{$s->{ELEMENTS}}) {
+		next unless (defined(my $v = has_property($e, "value")));
+		
+		$env->{$e->{NAME}} = ParseExpr($v, $env, $e);
+	}
+
+	return $env;
+}
+
+sub GenerateFunctionInEnv($;$)
+{
+	my ($fn, $base) = @_;
+	my %env;
+
+	$base = "r->" unless defined($base);
+
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		if (grep (/in/, @{$e->{DIRECTION}})) {
+			$env{$e->{NAME}} = $base."in.$e->{NAME}";
+		}
+	}
+
+	return \%env;
+}
+
+sub GenerateFunctionOutEnv($;$)
+{
+	my ($fn, $base) = @_;
+	my %env;
+
+	$base = "r->" unless defined($base);
+
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		if (grep (/out/, @{$e->{DIRECTION}})) {
+			$env{$e->{NAME}} = $base."out.$e->{NAME}";
+		} elsif (grep (/in/, @{$e->{DIRECTION}})) {
+			$env{$e->{NAME}} = $base."in.$e->{NAME}";
+		}
+	}
+
+	return \%env;
+}
+
+
+
 1;
diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm
index 8eb2f9ad15..0800a19fab 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm
@@ -9,7 +9,7 @@ package Parse::Pidl::Samba4::NDR::Parser;
 
 require Exporter;
 @ISA = qw(Exporter);
-@EXPORT_OK = qw(check_null_pointer GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv NeededFunction NeededElement NeededType $res NeededInterface TypeFunctionName ParseElementPrint);
+@EXPORT_OK = qw(check_null_pointer NeededFunction NeededElement NeededType $res NeededInterface TypeFunctionName ParseElementPrint);
 
 use strict;
 use Parse::Pidl::Typelist qw(hasType getType mapTypeName typeHasBody);
@@ -17,6 +17,7 @@ use Parse::Pidl::Util qw(has_property ParseExpr ParseExprExt print_uuid);
 use Parse::Pidl::CUtil qw(get_pointer_to get_value_of);
 use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred);
 use Parse::Pidl::Samba4 qw(is_intree choose_header);
+use Parse::Pidl::Samba4::Header qw(GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv);
 use Parse::Pidl qw(warning);
 
 use vars qw($VERSION);
@@ -193,68 +194,6 @@ sub end_flags($$)
 	}
 }
 
-sub GenerateStructEnv($$)
-{
-	my ($x, $v) = @_;
-	my %env;
-
-	foreach my $e (@{$x->{ELEMENTS}}) {
-		$env{$e->{NAME}} = "$v->$e->{NAME}";
-	}
-
-	$env{"this"} = $v;
-
-	return \%env;
-}
-
-sub EnvSubstituteValue($$)
-{
-	my ($env,$s) = @_;
-
-	# Substitute the value() values in the env
-	foreach my $e (@{$s->{ELEMENTS}}) {
-		next unless (defined(my $v = has_property($e, "value")));
-		
-		$env->{$e->{NAME}} = ParseExpr($v, $env, $e);
-	}
-
-	return $env;
-}
-
-sub GenerateFunctionInEnv($;$)
-{
-	my ($fn, $base) = @_;
-	my %env;
-
-	$base = "r->" unless defined($base);
-
-	foreach my $e (@{$fn->{ELEMENTS}}) {
-		if (grep (/in/, @{$e->{DIRECTION}})) {
-			$env{$e->{NAME}} = $base."in.$e->{NAME}";
-		}
-	}
-
-	return \%env;
-}
-
-sub GenerateFunctionOutEnv($;$)
-{
-	my ($fn, $base) = @_;
-	my %env;
-
-	$base = "r->" unless defined($base);
-
-	foreach my $e (@{$fn->{ELEMENTS}}) {
-		if (grep (/out/, @{$e->{DIRECTION}})) {
-			$env{$e->{NAME}} = $base."out.$e->{NAME}";
-		} elsif (grep (/in/, @{$e->{DIRECTION}})) {
-			$env{$e->{NAME}} = $base."in.$e->{NAME}";
-		}
-	}
-
-	return \%env;
-}
-
 #####################################################################
 # parse the data of an array - push side
 sub ParseArrayPushHeader($$$$$$)
-- 
cgit 


From f7a0ef04f00cd44845bcee0a171e4cc05a545350 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sun, 13 Jan 2008 18:38:12 +0100
Subject: pidl/python: Support repr() for python types. (This used to be commit
 cf3664594d3540db20d32bc844f18e20abfa0d96)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 24 +++++++++++++++++-------
 1 file changed, 17 insertions(+), 7 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 545d233d08..a5f8053834 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -214,6 +214,7 @@ sub PythonStruct($$$$)
 	$self->pidl(".tp_dealloc = py_talloc_dealloc,");
 	$self->pidl(".tp_getattr = py_$name\_getattr,");
 	$self->pidl(".tp_setattr = py_$name\_setattr,");
+	$self->pidl(".tp_repr = py_talloc_default_repr,");
 	$self->deindent;
 	$self->pidl("};");
 
@@ -559,6 +560,8 @@ sub ConvertScalarToPython($$$)
 {
 	my ($self, $ctypename, $cvar) = @_;
 
+	die("expected string for $cvar, not $ctypename") if (ref($ctypename) eq "HASH");
+
 	$ctypename = expandAlias($ctypename);
 
 	if ($ctypename =~ /^(int|long|char|u?int[0-9]+|hyper|dlong|udlong|udlongr|time_t|NTTIME_hyper|NTTIME|NTTIME_1sec)$/) {
@@ -583,7 +586,7 @@ sub ConvertScalarToPython($$$)
 
 	if ($ctypename eq "string_array") { return "FIXME($cvar)"; }
 
-	if ($$ctypename eq "ipv4address") { return "FIXME($cvar)"; }
+	if ($ctypename eq "ipv4address") { return "FIXME($cvar)"; }
 	if ($ctypename eq "pointer") {
 		return "PyCObject_FromVoidPtr($cvar, talloc_free)";
 	}
@@ -614,8 +617,15 @@ sub ConvertObjectToPython($$$)
 		$actual_ctype = $ctype->{DATA};
 	}
 
-	if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or 
-		($actual_ctype->{TYPE} eq "SCALAR") {
+	if ($actual_ctype->{TYPE} eq "ENUM") {
+		return $self->ConvertScalarToPython(Parse::Pidl::Typelist::enum_type_fn($actual_ctype), $cvar);
+	}
+
+	if ($actual_ctype->{TYPE} eq "BITMAP") {
+		return $self->ConvertScalarToPython(Parse::Pidl::Typelist::bitmap_type_fn($actual_ctype), $cvar);
+	}
+
+	if ($actual_ctype->{TYPE} eq "SCALAR") {
 		return $self->ConvertScalarToPython($actual_ctype->{NAME}, $cvar);
 	}
 
@@ -675,18 +685,18 @@ sub Parse($$$$$)
 	$self->indent;
 	$self->pidl("PyObject *m;");
 	$self->pidl("m = Py_InitModule(\"$basename\", $basename\_methods);");
-	foreach (keys %{$self->{constants}}) {
+	foreach my $name (keys %{$self->{constants}}) {
 		my $py_obj;
-		my ($ctype, $cvar) = @{$self->{constants}->{$_}};
+		my ($ctype, $cvar) = @{$self->{constants}->{$name}};
 		if ($cvar =~ /^[0-9]+$/ or $cvar =~ /^0x[0-9a-fA-F]+$/) {
 			$py_obj = "PyInt_FromLong($cvar)";
 		} elsif ($cvar =~ /^".*"$/) {
 			$py_obj = "PyString_FromString($cvar)";
 		} else {
-			$py_obj = $self->ConvertScalarToPython($ctype, $cvar);
+			$py_obj = $self->ConvertObjectToPython($ctype, $cvar);
 		}
 
-		$self->pidl("PyModule_AddObject(m, \"$_\", $py_obj);");
+		$self->pidl("PyModule_AddObject(m, \"$name\", $py_obj);");
 	}
 	$self->deindent;
 	$self->pidl("}");
-- 
cgit 


From bfab9862fcdd657a1bddafde49cdd182f89fcf8b Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sun, 13 Jan 2008 20:41:34 +0100
Subject: python: Allow wrapping pointers within talloc'ed memory that are not
 talloc contexts. (This used to be commit
 9c038a74113fb55ed5eb12a7d0ae4a46bad9050c)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 44 ++++++++++++++++++----------
 1 file changed, 28 insertions(+), 16 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index a5f8053834..cea3889938 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -138,7 +138,7 @@ sub FromPythonToUnionFunction($$$$$)
 		}
 		$self->indent;
 		if ($e->{NAME}) {
-			$self->ConvertObjectFromPython($mem_ctx, $e->{TYPE}, $name, "ret->$e->{NAME}");
+			$self->ConvertObjectFromPython($mem_ctx, $e->{TYPE}, $name, "ret->$e->{NAME}", "talloc_free(ret); return NULL;");
 		}
 		$self->pidl("break;");
 		$self->deindent;
@@ -164,8 +164,6 @@ sub PythonStruct($$$$)
 {
 	my ($self, $name, $cname, $d) = @_;
 
-	$self->pidl("staticforward PyTypeObject $name\_ObjectType;");
-
 	$self->pidl("");
 
 	$self->pidl("static PyObject *py_$name\_getattr(PyObject *obj, char *name)");
@@ -190,12 +188,15 @@ sub PythonStruct($$$$)
 	$self->pidl("{");
 	$self->indent;
 	$self->pidl("$cname *object = py_talloc_get_type(py_obj, $cname);");
+	$self->pidl("TALLOC_CTX *mem_ctx = py_talloc_get_mem_ctx(py_obj);");
 	foreach my $e (@{$d->{ELEMENTS}}) {
 		$self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {");
 		my $varname = "object->$e->{NAME}";
 		$self->indent;
-		$self->pidl("/* FIXME: talloc_free($varname) if necessary */");
-		$self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "value", $varname);
+		if ($e->{ORIGINAL}->{POINTERS} > 0) {
+			$self->pidl("talloc_free($varname);");
+		}
+		$self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "value", $varname, "talloc_free(mem_ctx); return -1;");
 		$self->pidl("return 0;");
 		$self->deindent;
 		$self->pidl("}");
@@ -206,7 +207,11 @@ sub PythonStruct($$$$)
 	$self->pidl("}");
 	$self->pidl("");
 
-	$self->pidl("static PyTypeObject $name\_ObjectType = {");
+	$self->pidl_hdr("PyAPI_DATA(PyTypeObject) $name\_Type;\n");
+	$self->pidl_hdr("#define $name\_Check(op) PyObject_TypeCheck(op, &$name\_Type)\n");
+	$self->pidl_hdr("#define $name\_CheckExact(op) ((op)->ob_type == &$name\_Type)\n");
+	$self->pidl_hdr("\n");
+	$self->pidl("PyTypeObject $name\_Type = {");
 	$self->indent;
 	$self->pidl("PyObject_HEAD_INIT(NULL) 0,");
 	$self->pidl(".tp_name = \"$name\",");
@@ -225,7 +230,7 @@ sub PythonStruct($$$$)
 	$self->pidl("{");
 	$self->indent;
 	$self->pidl("$cname *ret = talloc_zero(NULL, $cname);");
-	$self->pidl("return py_talloc_import(&$name\_ObjectType, ret);");
+	$self->pidl("return py_talloc_import(&$name\_Type, ret);");
 	$self->deindent;
 	$self->pidl("}");
 	$self->pidl("");
@@ -265,7 +270,7 @@ sub PythonFunction($$$)
 
 	foreach my $e (@{$fn->{ELEMENTS}}) {
 		if (grep(/in/,@{$e->{DIRECTION}})) {
-			$self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "py_$e->{NAME}", "r.in.$e->{NAME}");
+			$self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "py_$e->{NAME}", "r.in.$e->{NAME}", "talloc_free(mem_ctx); return NULL;");
 		}
 	}
 	$self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, &r);");
@@ -377,7 +382,7 @@ sub Interface($$$)
 		$self->PythonType($d, $interface, $basename);
 	}
 
-	$self->pidl("staticforward PyTypeObject $interface->{NAME}_InterfaceType;");
+	$self->pidl_hdr("PyAPI_DATA(PyTypeObject) $interface->{NAME}_InterfaceType;\n");
 	$self->pidl("typedef struct {");
 	$self->indent;
 	$self->pidl("PyObject_HEAD");
@@ -430,13 +435,13 @@ sub Interface($$$)
 
 	$self->pidl("");
 
-	$self->pidl("static PyTypeObject $interface->{NAME}_InterfaceType = {");
+	$self->pidl("PyTypeObject $interface->{NAME}_InterfaceType = {");
 	$self->indent;
 	$self->pidl("PyObject_HEAD_INIT(NULL) 0,");
 	$self->pidl(".tp_name = \"$interface->{NAME}\",");
 	$self->pidl(".tp_basicsize = sizeof($interface->{NAME}_InterfaceObject),");
-	$self->pidl(".tp_dealloc = (destructor)interface_$interface->{NAME}_dealloc,");
-	$self->pidl(".tp_getattr = (getattrfunc)interface_$interface->{NAME}_getattr,");
+	$self->pidl(".tp_dealloc = interface_$interface->{NAME}_dealloc,");
+	$self->pidl(".tp_getattr = interface_$interface->{NAME}_getattr,");
 	$self->deindent;
 	$self->pidl("};");
 
@@ -479,9 +484,9 @@ sub register_module_method($$$$$)
 	push (@{$self->{module_methods}}, [$fn_name, $pyfn_name, $flags, $doc])
 }
 
-sub ConvertObjectFromPython($$$$$)
+sub ConvertObjectFromPython($$$$$$)
 {
-	my ($self, $mem_ctx, $ctype, $cvar, $target) = @_;
+	my ($self, $mem_ctx, $ctype, $cvar, $target, $fail) = @_;
 
 	die("undef type for $cvar") unless(defined($ctype));
 
@@ -502,12 +507,14 @@ sub ConvertObjectFromPython($$$$$)
 	if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or 
 		$actual_ctype->{TYPE} eq "SCALAR" and (
 		expandAlias($actual_ctype->{NAME}) =~ /^(u?int[0-9]+|hyper|NTTIME|time_t|NTTIME_hyper|NTTIME_1sec|dlong|udlong|udlongr)$/)) {
+		$self->pidl("PY_CHECK_TYPE(PyInt, $cvar, $fail);");
 		$self->pidl("$target = PyInt_AsLong($cvar);");
 		return;
 	}
 
 	if ($actual_ctype->{TYPE} eq "STRUCT") {
-		$self->pidl("$target = py_talloc_get_type($cvar, " . mapTypeName($ctype) . ");");
+		$self->pidl("PY_CHECK_TYPE($ctype->{NAME}, $cvar, $fail);");
+		$self->pidl("$target = py_talloc_get_ptr($cvar);");
 		return;
 	}
 
@@ -635,7 +642,7 @@ sub ConvertObjectToPython($$$)
 
 	if ($actual_ctype->{TYPE} eq "STRUCT") {
 		# FIXME: if $cvar is not a pointer, do a talloc_dup()
-		return "py_talloc_import(&$ctype->{NAME}_ObjectType, $cvar)";
+		return "py_talloc_import(&$ctype->{NAME}_Type, $cvar)";
 	}
 
 	die("unknown type ".mapTypeName($ctype) . ": $cvar");
@@ -660,6 +667,11 @@ sub Parse($$$$$)
 #include \"$ndr_hdr\"
 #include \"$py_hdr\"
 
+#define PY_CHECK_TYPE(type, var, fail) \\
+	if (!type ## _Check(var)) {\\
+		PyErr_Format(PyExc_TypeError, \"Expected type %s\", type ## _Type.tp_name); \\
+		fail; \\
+	}
 ");
 
 	foreach my $x (@$ndr) {
-- 
cgit 


From 41057618f890b9053dce9cd671d11db7af7d3612 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sun, 13 Jan 2008 21:23:12 +0100
Subject: pidl/python: Remove unnecessary talloc_free(). (This used to be
 commit a099d30067a4d965a283f52e56ffd1897137bf1a)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index cea3889938..93a6161ce4 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -196,7 +196,7 @@ sub PythonStruct($$$$)
 		if ($e->{ORIGINAL}->{POINTERS} > 0) {
 			$self->pidl("talloc_free($varname);");
 		}
-		$self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "value", $varname, "talloc_free(mem_ctx); return -1;");
+		$self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "value", $varname, "return -1;");
 		$self->pidl("return 0;");
 		$self->deindent;
 		$self->pidl("}");
-- 
cgit 


From d8b21ae2534d5b51c1dc5a4c50b3de5ddb32af80 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sun, 13 Jan 2008 23:13:30 +0100
Subject: pidl/python: Fix use of pointers. (This used to be commit
 13f2b0380f310b101975d709361a29d4032c3689)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 81 ++++++++++++++++++++++++----
 1 file changed, 70 insertions(+), 11 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 93a6161ce4..2d6ec50d39 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -11,6 +11,7 @@ use Exporter;
 use strict;
 use Parse::Pidl::Typelist qw(hasType getType mapTypeName expandAlias);
 use Parse::Pidl::Util qw(has_property ParseExpr);
+use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred);
 use Parse::Pidl::CUtil qw(get_value_of get_pointer_to);
 
 use vars qw($VERSION);
@@ -100,7 +101,7 @@ sub FromUnionToPythonFunction($$$)
 		my $conv;
 		
 		if ($e->{NAME}) {
-			$conv = $self->ConvertObjectToPython($e->{TYPE}, "$name->$e->{NAME}");
+			$conv = $self->ConvertObjectToPython($e, "$name->$e->{NAME}");
 		} else {
 			$conv = "Py_None";
 		}
@@ -138,7 +139,7 @@ sub FromPythonToUnionFunction($$$$$)
 		}
 		$self->indent;
 		if ($e->{NAME}) {
-			$self->ConvertObjectFromPython($mem_ctx, $e->{TYPE}, $name, "ret->$e->{NAME}", "talloc_free(ret); return NULL;");
+			$self->ConvertObjectFromPython($mem_ctx, $e, $name, "ret->$e->{NAME}", "talloc_free(ret); return NULL;");
 		}
 		$self->pidl("break;");
 		$self->deindent;
@@ -174,7 +175,7 @@ sub PythonStruct($$$$)
 		$self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {");
 		my $varname = "object->$e->{NAME}";
 		$self->indent;
-		$self->pidl("return ".$self->ConvertObjectToPython($e->{TYPE}, $varname) . ";");
+		$self->pidl("return ".$self->ConvertObjectToPython($e, $varname) . ";");
 		$self->deindent;
 		$self->pidl("}");
 	}
@@ -188,7 +189,7 @@ sub PythonStruct($$$$)
 	$self->pidl("{");
 	$self->indent;
 	$self->pidl("$cname *object = py_talloc_get_type(py_obj, $cname);");
-	$self->pidl("TALLOC_CTX *mem_ctx = py_talloc_get_mem_ctx(py_obj);");
+	my $mem_ctx = "py_talloc_get_mem_ctx(py_obj)";
 	foreach my $e (@{$d->{ELEMENTS}}) {
 		$self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {");
 		my $varname = "object->$e->{NAME}";
@@ -196,7 +197,7 @@ sub PythonStruct($$$$)
 		if ($e->{ORIGINAL}->{POINTERS} > 0) {
 			$self->pidl("talloc_free($varname);");
 		}
-		$self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "value", $varname, "return -1;");
+		$self->ConvertObjectFromPython($mem_ctx, $e, "value", $varname, "return -1;");
 		$self->pidl("return 0;");
 		$self->deindent;
 		$self->pidl("}");
@@ -270,7 +271,7 @@ sub PythonFunction($$$)
 
 	foreach my $e (@{$fn->{ELEMENTS}}) {
 		if (grep(/in/,@{$e->{DIRECTION}})) {
-			$self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "py_$e->{NAME}", "r.in.$e->{NAME}", "talloc_free(mem_ctx); return NULL;");
+			$self->ConvertObjectFromPython("mem_ctx", $e, "py_$e->{NAME}", "r.in.$e->{NAME}", "talloc_free(mem_ctx); return NULL;");
 		}
 	}
 	$self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, &r);");
@@ -282,14 +283,14 @@ sub PythonFunction($$$)
 
 	foreach my $e (@{$fn->{ELEMENTS}}) {
 		if (grep(/out/,@{$e->{DIRECTION}})) {
-			$self->pidl("PyTuple_SetItem(result, $i, " . $self->ConvertObjectToPython($e->{TYPE}, "r.out.$e->{NAME}") . ");");
+			$self->pidl("PyTuple_SetItem(result, $i, " . $self->ConvertObjectToPython($e, "r.out.$e->{NAME}") . ");");
 
 			$i++;
 		}
 	}
 
 	if (defined($fn->{RETURN_TYPE})) {
-		$self->pidl("PyTuple_SetItem(result, $i, " . $self->ConvertObjectToPython($fn->{RETURN_TYPE}, "r.out.result") . ");");
+		$self->pidl("PyTuple_SetItem(result, $i, " . $self->ConvertObjectToPythonData($fn->{RETURN_TYPE}, "r.out.result") . ");");
 	}
 
 	$self->pidl("talloc_free(mem_ctx);");
@@ -484,7 +485,7 @@ sub register_module_method($$$$$)
 	push (@{$self->{module_methods}}, [$fn_name, $pyfn_name, $flags, $doc])
 }
 
-sub ConvertObjectFromPython($$$$$$)
+sub convertObjectFromPythonData($$$$$$)
 {
 	my ($self, $mem_ctx, $ctype, $cvar, $target, $fail) = @_;
 
@@ -561,6 +562,36 @@ sub ConvertObjectFromPython($$$$$$)
 	}
 
 	die("unknown type ".mapTypeName($ctype) . ": $cvar");
+
+}
+
+sub ConvertObjectFromPythonLevel($$$$$$$)
+{
+	my ($self, $mem_ctx, $e, $l, $var_name, $target, $fail) = @_;
+
+	if ($l->{TYPE} eq "POINTER") {
+		$self->ConvertObjectFromPythonLevel($mem_ctx, $e, GetNextLevel($e, $l), get_value_of($var_name), $target, $fail);
+	} elsif ($l->{TYPE} eq "ARRAY") {
+		$self->ConvertObjectFromPythonLevel($mem_ctx, $e, GetNextLevel($e, $l), $var_name."[i]", $target, $fail);
+	} 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);
+		}
+		$self->ConvertObjectToPythonData($mem_ctx, $l->{DATA_TYPE}, $var_name, $target, $fail);
+	} elsif ($l->{TYPE} eq "SWITCH") {
+		$self->ConvertObjectFromPythonLevel($mem_ctx, $e, GetNextLevel($e, $l), get_value_of($var_name), $target, $fail);
+	} else {
+		die("unknown level type $l->{TYPE}");
+	}
+}
+
+sub ConvertObjectFromPython($$$$$$)
+{
+	my ($self, $mem_ctx, $ctype, $cvar, $target, $fail) = @_;
+
+	$self->ConvertObjectFromPythonLevel($mem_ctx, $ctype, $ctype->{LEVELS}[0], 
+		                               $cvar, $target, $fail);
 }
 
 sub ConvertScalarToPython($$$)
@@ -601,7 +632,7 @@ sub ConvertScalarToPython($$$)
 	die("Unknown scalar type $ctypename");
 }
 
-sub ConvertObjectToPython($$$)
+sub ConvertObjectToPythonData($$$)
 {
 	my ($self, $ctype, $cvar) = @_;
 
@@ -648,6 +679,34 @@ sub ConvertObjectToPython($$$)
 	die("unknown type ".mapTypeName($ctype) . ": $cvar");
 }
 
+sub ConvertObjectToPythonLevel($$$$)
+{
+	my ($self, $e, $l, $var_name) = @_;
+
+	if ($l->{TYPE} eq "POINTER") {
+		$self->ConvertObjectToPythonLevel($e, GetNextLevel($e, $l), get_value_of($var_name));
+	} elsif ($l->{TYPE} eq "ARRAY") {
+		$self->ConvertObjectToPythonLevel($e, GetNextLevel($e, $l), $var_name."[i]");
+	} elsif ($l->{TYPE} eq "SWITCH") {
+		$self->ConvertObjectToPythonLevel($e, GetNextLevel($e, $l), $var_name);
+	} elsif ($l->{TYPE} eq "DATA") {
+		if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or 
+			Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
+			$var_name = get_pointer_to($var_name);
+		}
+		$self->ConvertObjectToPythonData($l->{DATA_TYPE}, $var_name);
+	} else {
+		die("Unknown level type $l->{TYPE} $var_name");
+	}
+}
+
+sub ConvertObjectToPython($$$)
+{
+	my ($self, $ctype, $cvar) = @_;
+
+	$self->ConvertObjectToPythonLevel($ctype, $ctype->{LEVELS}[0], $cvar);
+}
+
 sub Parse($$$$$)
 {
     my($self,$basename,$ndr,$ndr_hdr,$hdr) = @_;
@@ -705,7 +764,7 @@ sub Parse($$$$$)
 		} elsif ($cvar =~ /^".*"$/) {
 			$py_obj = "PyString_FromString($cvar)";
 		} else {
-			$py_obj = $self->ConvertObjectToPython($ctype, $cvar);
+			$py_obj = $self->ConvertObjectToPythonData($ctype, $cvar);
 		}
 
 		$self->pidl("PyModule_AddObject(m, \"$name\", $py_obj);");
-- 
cgit 


From 5d60cb6ef1c63ce771ab44b6831147568061aa50 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 14 Jan 2008 01:30:44 +0100
Subject: pidl/python: Fix parsing arguments, fix more pointer issues. (This
 used to be commit b00c1a072457e5083ffc24a8b74b3793d0b44eee)

---
 source4/pidl/lib/Parse/Pidl/NDR.pm               |  17 ++-
 source4/pidl/lib/Parse/Pidl/Samba4/Header.pm     |   2 -
 source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm |  15 +--
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm     | 162 ++++++++++++++++++-----
 4 files changed, 146 insertions(+), 50 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm
index 1d059ebdf7..fc6bfe4c96 100644
--- a/source4/pidl/lib/Parse/Pidl/NDR.pm
+++ b/source4/pidl/lib/Parse/Pidl/NDR.pm
@@ -35,7 +35,7 @@ use vars qw($VERSION);
 $VERSION = '0.01';
 @ISA = qw(Exporter);
 @EXPORT = qw(GetPrevLevel GetNextLevel ContainsDeferred ContainsString);
-@EXPORT_OK = qw(GetElementLevelTable ParseElement ValidElement align_type mapToScalar ParseType can_contain_deferred);
+@EXPORT_OK = qw(GetElementLevelTable ParseElement ValidElement align_type mapToScalar ParseType can_contain_deferred is_charset_array);
 
 use strict;
 use Parse::Pidl qw(warning fatal);
@@ -1181,4 +1181,19 @@ sub Validate($)
 	}
 }
 
+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");
+}
+
+
+
 1;
diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm
index 06e9ec4b9f..2b3a9df80f 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm
@@ -473,6 +473,4 @@ sub GenerateFunctionOutEnv($;$)
 	return \%env;
 }
 
-
-
 1;
diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm
index 0800a19fab..02d3a80992 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm
@@ -15,7 +15,7 @@ use strict;
 use Parse::Pidl::Typelist qw(hasType getType mapTypeName typeHasBody);
 use Parse::Pidl::Util qw(has_property ParseExpr ParseExprExt print_uuid);
 use Parse::Pidl::CUtil qw(get_pointer_to get_value_of);
-use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred);
+use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred is_charset_array);
 use Parse::Pidl::Samba4 qw(is_intree choose_header);
 use Parse::Pidl::Samba4::Header qw(GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv);
 use Parse::Pidl qw(warning);
@@ -78,19 +78,6 @@ sub has_fast_array($$)
 	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");
-}
-
 
 ####################################
 # pidl() is our basic output routine
diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 2d6ec50d39..9a3e82a94b 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -11,8 +11,9 @@ use Exporter;
 use strict;
 use Parse::Pidl::Typelist qw(hasType getType mapTypeName expandAlias);
 use Parse::Pidl::Util qw(has_property ParseExpr);
-use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred);
+use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred is_charset_array);
 use Parse::Pidl::CUtil qw(get_value_of get_pointer_to);
+use Parse::Pidl::Samba4::Header qw(GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv);
 
 use vars qw($VERSION);
 $VERSION = '0.01';
@@ -94,22 +95,31 @@ sub FromUnionToPythonFunction($$$)
 {
 	my ($self, $type, $switch, $name) = @_;
 
+	$self->pidl("PyObject *ret;");
+	$self->pidl("");
+
 	$self->pidl("switch ($switch) {");
 	$self->indent;
 
 	foreach my $e (@{$type->{ELEMENTS}}) {
-		my $conv;
-		
-		if ($e->{NAME}) {
-			$conv = $self->ConvertObjectToPython($e, "$name->$e->{NAME}");
+		if (defined($e->{CASE})) {
+			$self->pidl("$e->{CASE}:");
 		} else {
-			$conv = "Py_None";
+			$self->pidl("default:");
 		}
-		if (defined($e->{CASE})) {
-			$self->pidl("$e->{CASE}: return $conv;");
+
+		$self->indent;
+
+		if ($e->{NAME}) {
+			$self->ConvertObjectToPython({}, $e, "$name->$e->{NAME}", "ret");
 		} else {
-			$self->pidl("default: return $conv;");
+			$self->pidl("ret = Py_None;");
 		}
+
+		$self->pidl("return ret;");
+		$self->pidl("");
+
+		$self->deindent;
 	}
 
 	$self->deindent;
@@ -165,6 +175,8 @@ sub PythonStruct($$$$)
 {
 	my ($self, $name, $cname, $d) = @_;
 
+	my $env = GenerateStructEnv($d, "object");
+
 	$self->pidl("");
 
 	$self->pidl("static PyObject *py_$name\_getattr(PyObject *obj, char *name)");
@@ -175,7 +187,9 @@ sub PythonStruct($$$$)
 		$self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {");
 		my $varname = "object->$e->{NAME}";
 		$self->indent;
-		$self->pidl("return ".$self->ConvertObjectToPython($e, $varname) . ";");
+		$self->pidl("PyObject *py_$e->{NAME};");
+		$self->ConvertObjectToPython($env, $e, $varname, "py_$e->{NAME}");
+		$self->pidl("return py_$e->{NAME};");
 		$self->deindent;
 		$self->pidl("}");
 	}
@@ -243,7 +257,7 @@ sub PythonFunction($$$)
 {
 	my ($self, $fn, $iface) = @_;
 
-	$self->pidl("static PyObject *py_$fn->{NAME}(PyObject *self, PyObject *args)");
+	$self->pidl("static PyObject *py_$fn->{NAME}(PyObject *self, PyObject *args, PyObject *kwargs)");
 	$self->pidl("{");
 	$self->indent;
 	$self->pidl("$iface\_InterfaceObject *iface = ($iface\_InterfaceObject *)self;");
@@ -251,16 +265,38 @@ sub PythonFunction($$$)
 	$self->pidl("TALLOC_CTX *mem_ctx = talloc_new(NULL);");
 	$self->pidl("struct $fn->{NAME} r;");
 	$self->pidl("PyObject *result;");
+
+	my $env = GenerateFunctionInEnv($fn, "r.");
 	my $result_size = 0;
 
+	my $args_format = "";
+	my $args_string = "";
+	my $args_names = "";
+
 	foreach my $e (@{$fn->{ELEMENTS}}) {
-		if (grep(/in/,@{$e->{DIRECTION}})) {
-			$self->pidl("PyObject *py_$e->{NAME};");
-		}
+		$self->pidl("PyObject *py_$e->{NAME};");
 		if (grep(/out/,@{$e->{DIRECTION}})) {
 			$result_size++;
 		}
+		if (grep(/in/,@{$e->{DIRECTION}})) {
+			$args_format .= "O";
+			$args_string .= ", &py_$e->{NAME}";
+			$args_names .= "\"$e->{NAME}\", ";
+		}
 	}
+	$self->pidl("const char *kwnames[] = {");
+	$self->indent;
+	$self->pidl($args_names . "NULL");
+	$self->deindent;
+	$self->pidl("};");
+
+	$self->pidl("");
+	$self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"$args_format:$fn->{NAME}\", discard_const_p(char *, kwnames)$args_string)) {");
+	$self->indent;
+	$self->pidl("return NULL;");
+	$self->deindent;
+	$self->pidl("}");
+
 	if ($result_size > 0) {
 		$self->pidl("");
 		$self->pidl("ZERO_STRUCT(r.out);");
@@ -279,11 +315,13 @@ sub PythonFunction($$$)
 
 	$self->pidl("result = PyTuple_New($result_size);");
 
+	$env = GenerateFunctionOutEnv($fn, "r.");
 	my $i = 0;
 
 	foreach my $e (@{$fn->{ELEMENTS}}) {
 		if (grep(/out/,@{$e->{DIRECTION}})) {
-			$self->pidl("PyTuple_SetItem(result, $i, " . $self->ConvertObjectToPython($e, "r.out.$e->{NAME}") . ");");
+			$self->ConvertObjectToPython($env, $e, "r.out.$e->{NAME}", "py_$e->{NAME}");
+			$self->pidl("PyTuple_SetItem(result, $i, py_$e->{NAME});");
 
 			$i++;
 		}
@@ -485,9 +523,9 @@ sub register_module_method($$$$$)
 	push (@{$self->{module_methods}}, [$fn_name, $pyfn_name, $flags, $doc])
 }
 
-sub convertObjectFromPythonData($$$$$$)
+sub ConvertObjectFromPythonData($$$$$$)
 {
-	my ($self, $mem_ctx, $ctype, $cvar, $target, $fail) = @_;
+	my ($self, $mem_ctx, $cvar, $ctype, $target, $fail) = @_;
 
 	die("undef type for $cvar") unless(defined($ctype));
 
@@ -567,20 +605,45 @@ sub convertObjectFromPythonData($$$$$$)
 
 sub ConvertObjectFromPythonLevel($$$$$$$)
 {
-	my ($self, $mem_ctx, $e, $l, $var_name, $target, $fail) = @_;
+	my ($self, $mem_ctx, $py_var, $e, $l, $var_name, $fail) = @_;
 
 	if ($l->{TYPE} eq "POINTER") {
-		$self->ConvertObjectFromPythonLevel($mem_ctx, $e, GetNextLevel($e, $l), get_value_of($var_name), $target, $fail);
+		if ($l->{POINTER_TYPE} ne "ref") {
+			$self->pidl("if ($py_var == Py_None) {");
+			$self->indent;
+			$self->pidl("$var_name = NULL;");
+			$self->deindent;
+			$self->pidl("} else {");
+			$self->indent;
+		}
+		$self->ConvertObjectFromPythonLevel($mem_ctx, $py_var, $e, GetNextLevel($e, $l), get_value_of($var_name), $fail);
+		if ($l->{POINTER_TYPE} ne "ref") {
+			$self->deindent;
+			$self->pidl("}");
+		}
 	} elsif ($l->{TYPE} eq "ARRAY") {
-		$self->ConvertObjectFromPythonLevel($mem_ctx, $e, GetNextLevel($e, $l), $var_name."[i]", $target, $fail);
+		if (is_charset_array($e, $l)) {
+			$self->pidl("$var_name = PyString_AsString(PyUnicode_AsEncodedString($py_var, \"utf-8\", \"ignore\"));");
+		} else {
+			my $counter = "i";
+			$self->pidl("$var_name = talloc_array($mem_ctx, FIXME, PyList_Length($py_var));");
+			$self->pidl("for ($counter = 0; $counter < PyList_Length($py_var); $counter++) {");
+			$self->indent;
+			$self->ConvertObjectFromPythonLevel($var_name, "PyList_GetItem($py_var, $counter)", $e, GetNextLevel($e, $l), $var_name."[$counter]", $fail);
+			$self->deindent;
+			$self->pidl("}");
+		}
 	} 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);
 		}
-		$self->ConvertObjectToPythonData($mem_ctx, $l->{DATA_TYPE}, $var_name, $target, $fail);
+		$self->ConvertObjectFromPythonData($mem_ctx, $py_var, $l->{DATA_TYPE}, $var_name, $fail);
 	} elsif ($l->{TYPE} eq "SWITCH") {
-		$self->ConvertObjectFromPythonLevel($mem_ctx, $e, GetNextLevel($e, $l), get_value_of($var_name), $target, $fail);
+		$self->ConvertObjectFromPythonLevel($mem_ctx, $py_var, $e, GetNextLevel($e, $l), get_value_of($var_name), $fail);
+	} elsif ($l->{TYPE} eq "SUBCONTEXT") {
+		$self->pidl("FIXME");
 	} else {
 		die("unknown level type $l->{TYPE}");
 	}
@@ -590,8 +653,7 @@ sub ConvertObjectFromPython($$$$$$)
 {
 	my ($self, $mem_ctx, $ctype, $cvar, $target, $fail) = @_;
 
-	$self->ConvertObjectFromPythonLevel($mem_ctx, $ctype, $ctype->{LEVELS}[0], 
-		                               $cvar, $target, $fail);
+	$self->ConvertObjectFromPythonLevel($mem_ctx, $cvar, $ctype, $ctype->{LEVELS}[0], $target, $fail);
 }
 
 sub ConvertScalarToPython($$$)
@@ -632,7 +694,7 @@ sub ConvertScalarToPython($$$)
 	die("Unknown scalar type $ctypename");
 }
 
-sub ConvertObjectToPythonData($$$)
+sub ConvertObjectToPythonData($$$$)
 {
 	my ($self, $ctype, $cvar) = @_;
 
@@ -681,30 +743,64 @@ sub ConvertObjectToPythonData($$$)
 
 sub ConvertObjectToPythonLevel($$$$)
 {
-	my ($self, $e, $l, $var_name) = @_;
+	my ($self, $env, $e, $l, $var_name, $py_var) = @_;
 
 	if ($l->{TYPE} eq "POINTER") {
-		$self->ConvertObjectToPythonLevel($e, GetNextLevel($e, $l), get_value_of($var_name));
+		if ($l->{POINTER_TYPE} ne "ref") {
+			$self->pidl("if ($var_name == NULL) {");
+			$self->indent;
+			$self->pidl("$py_var = Py_None;");
+			$self->deindent;
+			$self->pidl("} else {");
+			$self->indent;
+		}
+		$self->ConvertObjectToPythonLevel($env, $e, GetNextLevel($e, $l), get_value_of($var_name), $py_var);
+		if ($l->{POINTER_TYPE} ne "ref") {
+			$self->deindent;
+			$self->pidl("}");
+		}
 	} elsif ($l->{TYPE} eq "ARRAY") {
-		$self->ConvertObjectToPythonLevel($e, GetNextLevel($e, $l), $var_name."[i]");
+		if (is_charset_array($e, $l)) {
+			$self->pidl("$py_var = PyUnicode_Decode($var_name, strlen($var_name), \"utf-8\", \"ignore\");");
+		} else {
+			die("No SIZE_IS for array $var_name") unless (defined($l->{SIZE_IS}));
+			my $length = $l->{SIZE_IS};
+			if (defined($l->{LENGTH_IS})) {
+				$length = $l->{LENGTH_IS};
+			}
+
+			$length = ParseExpr($length, $env, $e);
+			$self->pidl("$py_var = PyList_New($length);");
+			my $counter = "i";
+			$self->pidl("for ($counter = 0; $counter < $length; $counter++) {");
+			$self->indent;
+			my $member_var = "py_$e->{NAME}_$l->{LEVEL_INDEX}";
+			$self->pidl("PyObject *$member_var;");
+			$self->ConvertObjectToPythonLevel($env, $e, GetNextLevel($e, $l), $var_name."[$counter]", $member_var);
+			$self->pidl("PyList_SetItem($py_var, $counter, $member_var);");
+			$self->deindent;
+			$self->pidl("}");
+		}
 	} elsif ($l->{TYPE} eq "SWITCH") {
-		$self->ConvertObjectToPythonLevel($e, GetNextLevel($e, $l), $var_name);
+		$self->ConvertObjectToPythonLevel($env, $e, GetNextLevel($e, $l), $var_name, $py_var);
 	} 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);
 		}
-		$self->ConvertObjectToPythonData($l->{DATA_TYPE}, $var_name);
+		$self->pidl("$py_var = ".$self->ConvertObjectToPythonData($l->{DATA_TYPE}, $var_name) . ";");
+	} elsif ($l->{TYPE} eq "SUBCONTEXT") {
+		$self->pidl("FIXME");
 	} else {
 		die("Unknown level type $l->{TYPE} $var_name");
 	}
 }
 
-sub ConvertObjectToPython($$$)
+sub ConvertObjectToPython($$$$$)
 {
-	my ($self, $ctype, $cvar) = @_;
+	my ($self, $env, $ctype, $cvar, $py_var) = @_;
 
-	$self->ConvertObjectToPythonLevel($ctype, $ctype->{LEVELS}[0], $cvar);
+	$self->ConvertObjectToPythonLevel($env, $ctype, $ctype->{LEVELS}[0], $cvar, $py_var);
 }
 
 sub Parse($$$$$)
-- 
cgit 


From 657e0cc4d09a89944445b17fd3fdc56e777917d0 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 14 Jan 2008 02:04:06 +0100
Subject: pidl/python: Fix more compile errors. (This used to be commit
 2eb4526599ec6d3c604dd9b1f258496c82288284)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 58 +++++++++++++++-------------
 1 file changed, 32 insertions(+), 26 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 9a3e82a94b..a2ad3c6508 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -149,7 +149,7 @@ sub FromPythonToUnionFunction($$$$$)
 		}
 		$self->indent;
 		if ($e->{NAME}) {
-			$self->ConvertObjectFromPython($mem_ctx, $e, $name, "ret->$e->{NAME}", "talloc_free(ret); return NULL;");
+			$self->ConvertObjectFromPython({}, $mem_ctx, $e, $name, "ret->$e->{NAME}", "talloc_free(ret); return NULL;");
 		}
 		$self->pidl("break;");
 		$self->deindent;
@@ -211,7 +211,7 @@ sub PythonStruct($$$$)
 		if ($e->{ORIGINAL}->{POINTERS} > 0) {
 			$self->pidl("talloc_free($varname);");
 		}
-		$self->ConvertObjectFromPython($mem_ctx, $e, "value", $varname, "return -1;");
+		$self->ConvertObjectFromPython($env, $mem_ctx, $e, "value", $varname, "return -1;");
 		$self->pidl("return 0;");
 		$self->deindent;
 		$self->pidl("}");
@@ -307,7 +307,7 @@ sub PythonFunction($$$)
 
 	foreach my $e (@{$fn->{ELEMENTS}}) {
 		if (grep(/in/,@{$e->{DIRECTION}})) {
-			$self->ConvertObjectFromPython("mem_ctx", $e, "py_$e->{NAME}", "r.in.$e->{NAME}", "talloc_free(mem_ctx); return NULL;");
+			$self->ConvertObjectFromPython($env, "mem_ctx", $e, "py_$e->{NAME}", "r.in.$e->{NAME}", "talloc_free(mem_ctx); return NULL;");
 		}
 	}
 	$self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, &r);");
@@ -557,11 +557,6 @@ sub ConvertObjectFromPythonData($$$$$$)
 		return;
 	}
 
-	if ($actual_ctype->{TYPE} eq "UNION") {
-		$self->pidl("$target = py_export_$ctype->{NAME}($cvar);");
-		return;
-	}
-
 	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "DATA_BLOB") {
 		$self->pidl("$target = data_blob_talloc($mem_ctx, PyString_AsString($cvar), PyString_Size($cvar));");
 		return;
@@ -603,9 +598,9 @@ sub ConvertObjectFromPythonData($$$$$$)
 
 }
 
-sub ConvertObjectFromPythonLevel($$$$$$$)
+sub ConvertObjectFromPythonLevel($$$$$$$$)
 {
-	my ($self, $mem_ctx, $py_var, $e, $l, $var_name, $fail) = @_;
+	my ($self, $env, $mem_ctx, $py_var, $e, $l, $var_name, $fail) = @_;
 
 	if ($l->{TYPE} eq "POINTER") {
 		if ($l->{POINTER_TYPE} ne "ref") {
@@ -616,20 +611,25 @@ sub ConvertObjectFromPythonLevel($$$$$$$)
 			$self->pidl("} else {");
 			$self->indent;
 		}
-		$self->ConvertObjectFromPythonLevel($mem_ctx, $py_var, $e, GetNextLevel($e, $l), get_value_of($var_name), $fail);
+		$self->ConvertObjectFromPythonLevel($env, $mem_ctx, $py_var, $e, GetNextLevel($e, $l), get_value_of($var_name), $fail);
 		if ($l->{POINTER_TYPE} ne "ref") {
 			$self->deindent;
 			$self->pidl("}");
 		}
 	} elsif ($l->{TYPE} eq "ARRAY") {
 		if (is_charset_array($e, $l)) {
-			$self->pidl("$var_name = PyString_AsString(PyUnicode_AsEncodedString($py_var, \"utf-8\", \"ignore\"));");
+			$self->pidl(get_pointer_to($var_name) . " = PyString_AsString(PyUnicode_AsEncodedString($py_var, \"utf-8\", \"ignore\"));");
 		} else {
-			my $counter = "i";
-			$self->pidl("$var_name = talloc_array($mem_ctx, FIXME, PyList_Length($py_var));");
-			$self->pidl("for ($counter = 0; $counter < PyList_Length($py_var); $counter++) {");
+			my $counter = "$e->{NAME}_cntr_$l->{LEVEL_INDEX}";
+			$self->pidl("{");
 			$self->indent;
-			$self->ConvertObjectFromPythonLevel($var_name, "PyList_GetItem($py_var, $counter)", $e, GetNextLevel($e, $l), $var_name."[$counter]", $fail);
+			$self->pidl("int $counter;");
+			$self->pidl("$var_name = talloc_array($mem_ctx, FIXME, PyList_Size($py_var));");
+			$self->pidl("for ($counter = 0; $counter < PyList_Size($py_var); $counter++) {");
+			$self->indent;
+			$self->ConvertObjectFromPythonLevel($env, $var_name, "PyList_GetItem($py_var, $counter)", $e, GetNextLevel($e, $l), $var_name."[$counter]", $fail);
+			$self->deindent;
+			$self->pidl("}");
 			$self->deindent;
 			$self->pidl("}");
 		}
@@ -641,7 +641,9 @@ sub ConvertObjectFromPythonLevel($$$$$$$)
 		}
 		$self->ConvertObjectFromPythonData($mem_ctx, $py_var, $l->{DATA_TYPE}, $var_name, $fail);
 	} elsif ($l->{TYPE} eq "SWITCH") {
-		$self->ConvertObjectFromPythonLevel($mem_ctx, $py_var, $e, GetNextLevel($e, $l), get_value_of($var_name), $fail);
+		$var_name = get_pointer_to($var_name);
+		my $switch = ParseExpr($l->{SWITCH_IS}, $env, $e);
+		$self->pidl("$var_name = py_export_" . GetNextLevel($e, $l)->{DATA_TYPE} . "($mem_ctx, $switch, $py_var);");
 	} elsif ($l->{TYPE} eq "SUBCONTEXT") {
 		$self->pidl("FIXME");
 	} else {
@@ -649,11 +651,11 @@ sub ConvertObjectFromPythonLevel($$$$$$$)
 	}
 }
 
-sub ConvertObjectFromPython($$$$$$)
+sub ConvertObjectFromPython($$$$$$$)
 {
-	my ($self, $mem_ctx, $ctype, $cvar, $target, $fail) = @_;
+	my ($self, $env, $mem_ctx, $ctype, $cvar, $target, $fail) = @_;
 
-	$self->ConvertObjectFromPythonLevel($mem_ctx, $cvar, $ctype, $ctype->{LEVELS}[0], $target, $fail);
+	$self->ConvertObjectFromPythonLevel($env, $mem_ctx, $cvar, $ctype, $ctype->{LEVELS}[0], $target, $fail);
 }
 
 sub ConvertScalarToPython($$$)
@@ -729,10 +731,6 @@ sub ConvertObjectToPythonData($$$$)
 		return $self->ConvertScalarToPython($actual_ctype->{NAME}, $cvar);
 	}
 
-	if ($actual_ctype->{TYPE} eq "UNION") {
-		return "py_import_$ctype->{NAME}($cvar)";
-	}
-
 	if ($actual_ctype->{TYPE} eq "STRUCT") {
 		# FIXME: if $cvar is not a pointer, do a talloc_dup()
 		return "py_talloc_import(&$ctype->{NAME}_Type, $cvar)";
@@ -761,6 +759,7 @@ sub ConvertObjectToPythonLevel($$$$)
 		}
 	} elsif ($l->{TYPE} eq "ARRAY") {
 		if (is_charset_array($e, $l)) {
+			$var_name = get_pointer_to($var_name);
 			$self->pidl("$py_var = PyUnicode_Decode($var_name, strlen($var_name), \"utf-8\", \"ignore\");");
 		} else {
 			die("No SIZE_IS for array $var_name") unless (defined($l->{SIZE_IS}));
@@ -771,7 +770,10 @@ sub ConvertObjectToPythonLevel($$$$)
 
 			$length = ParseExpr($length, $env, $e);
 			$self->pidl("$py_var = PyList_New($length);");
-			my $counter = "i";
+			$self->pidl("{");
+			$self->indent;
+			my $counter = "$e->{NAME}_cntr_$l->{LEVEL_INDEX}";
+			$self->pidl("int $counter;");
 			$self->pidl("for ($counter = 0; $counter < $length; $counter++) {");
 			$self->indent;
 			my $member_var = "py_$e->{NAME}_$l->{LEVEL_INDEX}";
@@ -780,9 +782,13 @@ sub ConvertObjectToPythonLevel($$$$)
 			$self->pidl("PyList_SetItem($py_var, $counter, $member_var);");
 			$self->deindent;
 			$self->pidl("}");
+			$self->deindent;
+			$self->pidl("}");
 		}
 	} elsif ($l->{TYPE} eq "SWITCH") {
-		$self->ConvertObjectToPythonLevel($env, $e, GetNextLevel($e, $l), $var_name, $py_var);
+		$var_name = get_pointer_to($var_name);
+		my $switch = ParseExpr($l->{SWITCH_IS}, $env, $e);
+		$self->pidl("$py_var = py_import_" . GetNextLevel($e, $l)->{DATA_TYPE} . "($switch, $var_name);");
 	} elsif ($l->{TYPE} eq "DATA") {
 		if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or 
 			Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
-- 
cgit 


From 2afa1bee549ae119b1088c1e6affaec6f1997887 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 14 Jan 2008 02:27:40 +0100
Subject: python/pidl: Fix assignment. (This used to be commit
 2d2cb6486e6e1a31ae94223784e49fb4eea8bb26)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 28 +++++++++++++++++++---------
 1 file changed, 19 insertions(+), 9 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index a2ad3c6508..a7e1791793 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -322,7 +322,6 @@ sub PythonFunction($$$)
 		if (grep(/out/,@{$e->{DIRECTION}})) {
 			$self->ConvertObjectToPython($env, $e, "r.out.$e->{NAME}", "py_$e->{NAME}");
 			$self->pidl("PyTuple_SetItem(result, $i, py_$e->{NAME});");
-
 			$i++;
 		}
 	}
@@ -523,6 +522,16 @@ sub register_module_method($$$$$)
 	push (@{$self->{module_methods}}, [$fn_name, $pyfn_name, $flags, $doc])
 }
 
+sub assign($$$)
+{
+	my ($self, $dest, $src) = @_;
+	if ($dest =~ /^\&/) {
+		$self->pidl("memcpy($dest, $src, sizeof(*$dest));");
+	} else {
+		$self->pidl("$dest = $src;");
+	}
+}
+
 sub ConvertObjectFromPythonData($$$$$$)
 {
 	my ($self, $mem_ctx, $cvar, $ctype, $target, $fail) = @_;
@@ -553,7 +562,7 @@ sub ConvertObjectFromPythonData($$$$$$)
 
 	if ($actual_ctype->{TYPE} eq "STRUCT") {
 		$self->pidl("PY_CHECK_TYPE($ctype->{NAME}, $cvar, $fail);");
-		$self->pidl("$target = py_talloc_get_ptr($cvar);");
+		$self->assign($target, "py_talloc_get_ptr($cvar)");
 		return;
 	}
 
@@ -590,7 +599,7 @@ sub ConvertObjectFromPythonData($$$$$$)
 	}
 
 	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "pointer") {
-		$self->pidl("$target = PyCObject_AsVoidPtr($cvar);");
+		$self->assign($target, "PyCObject_AsVoidPtr($cvar)");
 		return;
 	}
 
@@ -624,7 +633,7 @@ sub ConvertObjectFromPythonLevel($$$$$$$$)
 			$self->pidl("{");
 			$self->indent;
 			$self->pidl("int $counter;");
-			$self->pidl("$var_name = talloc_array($mem_ctx, FIXME, PyList_Size($py_var));");
+			$self->pidl("$var_name = talloc_array_ptrtype($mem_ctx, $var_name, PyList_Size($py_var));");
 			$self->pidl("for ($counter = 0; $counter < PyList_Size($py_var); $counter++) {");
 			$self->indent;
 			$self->ConvertObjectFromPythonLevel($env, $var_name, "PyList_GetItem($py_var, $counter)", $e, GetNextLevel($e, $l), $var_name."[$counter]", $fail);
@@ -645,7 +654,7 @@ sub ConvertObjectFromPythonLevel($$$$$$$$)
 		my $switch = ParseExpr($l->{SWITCH_IS}, $env, $e);
 		$self->pidl("$var_name = py_export_" . GetNextLevel($e, $l)->{DATA_TYPE} . "($mem_ctx, $switch, $py_var);");
 	} elsif ($l->{TYPE} eq "SUBCONTEXT") {
-		$self->pidl("FIXME");
+		$self->pidl("#error Subcontext not yet supported");
 	} else {
 		die("unknown level type $l->{TYPE}");
 	}
@@ -686,9 +695,9 @@ sub ConvertScalarToPython($$$)
 		return "PyString_FromString($cvar)";
 	}
 
-	if ($ctypename eq "string_array") { return "FIXME($cvar)"; }
-
-	if ($ctypename eq "ipv4address") { return "FIXME($cvar)"; }
+	# Not yet supported
+	if ($ctypename eq "string_array") { return "PyCObject_FromVoidPtr($cvar)"; }
+	if ($ctypename eq "ipv4address") { return "PyCObject_FromVoidPtr($cvar)"; }
 	if ($ctypename eq "pointer") {
 		return "PyCObject_FromVoidPtr($cvar, talloc_free)";
 	}
@@ -794,7 +803,8 @@ sub ConvertObjectToPythonLevel($$$$)
 			Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
 			$var_name = get_pointer_to($var_name);
 		}
-		$self->pidl("$py_var = ".$self->ConvertObjectToPythonData($l->{DATA_TYPE}, $var_name) . ";");
+		my $conv = $self->ConvertObjectToPythonData($l->{DATA_TYPE}, $var_name);
+		$self->pidl("$py_var = $conv;");
 	} elsif ($l->{TYPE} eq "SUBCONTEXT") {
 		$self->pidl("FIXME");
 	} else {
-- 
cgit 


From d5903fd75e9640831f0e78fc04d3ffa5ea3b1b4a Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 14 Jan 2008 02:48:50 +0100
Subject: pidl/python: Fix compilation of py_echo. (This used to be commit
 5ee99ff31c80ece6861b2a0323d71170ef9346b9)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index a7e1791793..f569f013dc 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -384,7 +384,7 @@ sub PythonType($$$)
 		$self->EnumAndBitmapConsts($d->{NAME}, $d->{DATA});
 	}
 
-	if ($actual_ctype->{TYPE} eq "UNION") {
+	if ($actual_ctype->{TYPE} eq "UNION" and defined($actual_ctype->{ELEMENTS})) {
 		$self->pidl("PyObject *py_import_$d->{NAME}(int level, " .mapTypeName($d) . " *in)");
 		$self->pidl("{");
 		$self->indent;
@@ -486,7 +486,7 @@ sub Interface($$$)
 	$self->pidl("");
 
 	$self->register_module_method($interface->{NAME}, "interface_$interface->{NAME}", "METH_VARARGS|METH_KEYWORDS", "NULL");
-	$self->pidl("static PyObject *interface_$interface->{NAME}(PyObject *self, PyObject *args)");
+	$self->pidl("static PyObject *interface_$interface->{NAME}(PyObject *self, PyObject *args, PyObject *kwargs)");
 	$self->pidl("{");
 	$self->indent;
 	$self->pidl("$interface->{NAME}_InterfaceObject *ret;");
@@ -496,6 +496,18 @@ sub Interface($$$)
 	$self->pidl("TALLOC_CTX *mem_ctx = NULL;");
 	$self->pidl("NTSTATUS status;");
 	$self->pidl("");
+	$self->pidl("const char *kwnames[] = {");
+	$self->indent;
+	$self->pidl("\"binding\", NULL");
+	$self->deindent;
+	$self->pidl("};");
+	$self->pidl("");
+	$self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"s:$interface->{NAME}\", discard_const_p(char *, kwnames), &binding_string)) {");
+	$self->indent;
+	$self->pidl("return NULL;");
+	$self->deindent;
+	$self->pidl("}");
+	$self->pidl("");
 
 	# FIXME: Arguments: binding string, credentials, loadparm context
 	$self->pidl("ret = PyObject_New($interface->{NAME}_InterfaceObject, &$interface->{NAME}_InterfaceType);");
-- 
cgit 


From db4ee4cce5f1fd84f3f0a331e769a70394126ca5 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 14 Jan 2008 03:59:36 +0100
Subject: python: Fix rpcecho tests. (This used to be commit
 ebb78ea4232c1614755844849580e3697b0a53fa)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index f569f013dc..266a092788 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -491,8 +491,8 @@ sub Interface($$$)
 	$self->indent;
 	$self->pidl("$interface->{NAME}_InterfaceObject *ret;");
 	$self->pidl("const char *binding_string;");
-	$self->pidl("struct cli_credentials *credentials;");
-	$self->pidl("struct loadparm_context *lp_ctx;");
+	$self->pidl("struct cli_credentials *credentials = NULL;");
+	$self->pidl("struct loadparm_context *lp_ctx = NULL;");
 	$self->pidl("TALLOC_CTX *mem_ctx = NULL;");
 	$self->pidl("NTSTATUS status;");
 	$self->pidl("");
-- 
cgit 


From 3b16c532f21202696d54ef87f8fa74d066812898 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 14 Jan 2008 05:16:51 +0100
Subject: pidl/python: Pass credentials and loadparm context when connecting
 using DCE/RPC. (This used to be commit
 4c87af95310e4aaee3f2e2da02d0ea70ed1ec25b)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 59 ++++++++++++++++++++++------
 1 file changed, 48 insertions(+), 11 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 266a092788..04649d3668 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -264,7 +264,7 @@ sub PythonFunction($$$)
 	$self->pidl("NTSTATUS status;");
 	$self->pidl("TALLOC_CTX *mem_ctx = talloc_new(NULL);");
 	$self->pidl("struct $fn->{NAME} r;");
-	$self->pidl("PyObject *result;");
+	$self->pidl("PyObject *result = Py_None;");
 
 	my $env = GenerateFunctionInEnv($fn, "r.");
 	my $result_size = 0;
@@ -313,21 +313,33 @@ sub PythonFunction($$$)
 	$self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, &r);");
 	$self->handle_ntstatus("status", "NULL", "mem_ctx");
 
-	$self->pidl("result = PyTuple_New($result_size);");
-
 	$env = GenerateFunctionOutEnv($fn, "r.");
 	my $i = 0;
 
+	if ($result_size > 1) {
+		$self->pidl("result = PyTuple_New($result_size);");
+	}
+
 	foreach my $e (@{$fn->{ELEMENTS}}) {
+		my $py_name = "py_$e->{NAME}";
 		if (grep(/out/,@{$e->{DIRECTION}})) {
-			$self->ConvertObjectToPython($env, $e, "r.out.$e->{NAME}", "py_$e->{NAME}");
-			$self->pidl("PyTuple_SetItem(result, $i, py_$e->{NAME});");
-			$i++;
+			$self->ConvertObjectToPython($env, $e, "r.out.$e->{NAME}", $py_name);
+			if ($result_size > 1) {
+				$self->pidl("PyTuple_SetItem(result, $i, $py_name);");
+				$i++;
+			} else {
+				$self->pidl("result = $py_name;");
+			}
 		}
 	}
 
 	if (defined($fn->{RETURN_TYPE})) {
-		$self->pidl("PyTuple_SetItem(result, $i, " . $self->ConvertObjectToPythonData($fn->{RETURN_TYPE}, "r.out.result") . ");");
+		my $conv = $self->ConvertObjectToPythonData($fn->{RETURN_TYPE}, "r.out.result");
+		if ($result_size > 1) {
+			$self->pidl("PyTuple_SetItem(result, $i, $conv);");
+		} else {
+			$self->pidl("result = $conv;");
+		}
 	}
 
 	$self->pidl("talloc_free(mem_ctx);");
@@ -446,6 +458,7 @@ sub Interface($$$)
 		my $fn_name = $d->{NAME};
 
 		$fn_name =~ s/^$interface->{NAME}_//;
+		$fn_name =~ s/^$basename\_//;
 
 		$self->pidl("{ \"$fn_name\", (PyCFunction)py_$d->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },");
 	}
@@ -491,25 +504,47 @@ sub Interface($$$)
 	$self->indent;
 	$self->pidl("$interface->{NAME}_InterfaceObject *ret;");
 	$self->pidl("const char *binding_string;");
-	$self->pidl("struct cli_credentials *credentials = NULL;");
+	$self->pidl("struct cli_credentials *credentials;");
 	$self->pidl("struct loadparm_context *lp_ctx = NULL;");
+	$self->pidl("PyObject *py_lp_ctx = NULL, *py_credentials = Py_None;");
 	$self->pidl("TALLOC_CTX *mem_ctx = NULL;");
 	$self->pidl("NTSTATUS status;");
 	$self->pidl("");
 	$self->pidl("const char *kwnames[] = {");
 	$self->indent;
-	$self->pidl("\"binding\", NULL");
+	$self->pidl("\"binding\", \"lp_ctx\", \"credentials\", NULL");
 	$self->deindent;
 	$self->pidl("};");
+	$self->pidl("extern struct loadparm_context *lp_from_py_object(PyObject *py_obj);");
+    $self->pidl("extern struct cli_credentials *cli_credentials_from_py_object(PyObject *py_obj);");
+	$self->pidl("");
+	$self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"sO|O:$interface->{NAME}\", discard_const_p(char *, kwnames), &binding_string, &py_lp_ctx, &py_credentials)) {");
+	$self->indent;
+	$self->pidl("return NULL;");
+	$self->deindent;
+	$self->pidl("}");
 	$self->pidl("");
-	$self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"s:$interface->{NAME}\", discard_const_p(char *, kwnames), &binding_string)) {");
+	$self->pidl("if (py_lp_ctx != NULL) {");
+	$self->indent;
+	$self->pidl("lp_ctx = lp_from_py_object(py_lp_ctx);");
+	$self->pidl("if (lp_ctx == NULL) {");
 	$self->indent;
+	$self->pidl("PyErr_SetString(PyExc_TypeError, \"Expected loadparm context\");");
 	$self->pidl("return NULL;");
 	$self->deindent;
 	$self->pidl("}");
+	$self->deindent;
+	$self->pidl("}");
 	$self->pidl("");
 
-	# FIXME: Arguments: binding string, credentials, loadparm context
+    $self->pidl("credentials = cli_credentials_from_py_object(py_credentials);");
+    $self->pidl("if (credentials == NULL) {");
+    $self->indent;
+    $self->pidl("PyErr_SetString(PyExc_TypeError, \"Expected credentials\");");
+    $self->pidl("return NULL;");
+    $self->deindent;
+    $self->pidl("}");
+
 	$self->pidl("ret = PyObject_New($interface->{NAME}_InterfaceObject, &$interface->{NAME}_InterfaceType);");
 	$self->pidl("");
 
@@ -517,6 +552,8 @@ sub Interface($$$)
 	$self->pidl("             &ndr_table_$interface->{NAME}, credentials, NULL, lp_ctx);");
 	$self->handle_ntstatus("status", "NULL", "mem_ctx");
 
+	$self->pidl("ret->pipe->conn->flags |= DCERPC_NDR_REF_ALLOC;");
+
 	$self->pidl("return (PyObject *)ret;");
 	$self->deindent;
 	$self->pidl("}");
-- 
cgit 


From 4cfd90308c4dffebf7cebdcd8c11a7aa836ce23e Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 14 Jan 2008 06:05:12 +0100
Subject: pidl/python: Specify memory context explicitly when returning Python
 objects. (This used to be commit 9c72f652e0d3f14d5db4d3930f0d1f9a1875e93f)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 62 ++++++++++++++--------------
 1 file changed, 30 insertions(+), 32 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 04649d3668..e0751d0c72 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -91,9 +91,9 @@ sub EnumAndBitmapConsts($$$)
 	}
 }
 
-sub FromUnionToPythonFunction($$$)
+sub FromUnionToPythonFunction($$$$)
 {
-	my ($self, $type, $switch, $name) = @_;
+	my ($self, $mem_ctx, $type, $switch, $name) = @_;
 
 	$self->pidl("PyObject *ret;");
 	$self->pidl("");
@@ -111,7 +111,7 @@ sub FromUnionToPythonFunction($$$)
 		$self->indent;
 
 		if ($e->{NAME}) {
-			$self->ConvertObjectToPython({}, $e, "$name->$e->{NAME}", "ret");
+			$self->ConvertObjectToPython($mem_ctx, {}, $e, "$name->$e->{NAME}", "ret");
 		} else {
 			$self->pidl("ret = Py_None;");
 		}
@@ -182,13 +182,13 @@ sub PythonStruct($$$$)
 	$self->pidl("static PyObject *py_$name\_getattr(PyObject *obj, char *name)");
 	$self->pidl("{");
 	$self->indent;
-	$self->pidl("$cname *object = py_talloc_get_type(obj, $cname);");
+	$self->pidl("$cname *object = py_talloc_get_ptr(obj);");
 	foreach my $e (@{$d->{ELEMENTS}}) {
 		$self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {");
 		my $varname = "object->$e->{NAME}";
 		$self->indent;
 		$self->pidl("PyObject *py_$e->{NAME};");
-		$self->ConvertObjectToPython($env, $e, $varname, "py_$e->{NAME}");
+		$self->ConvertObjectToPython("py_talloc_get_talloc_ctx(obj)", $env, $e, $varname, "py_$e->{NAME}");
 		$self->pidl("return py_$e->{NAME};");
 		$self->deindent;
 		$self->pidl("}");
@@ -202,7 +202,7 @@ sub PythonStruct($$$$)
 	$self->pidl("static int py_$name\_setattr(PyObject *py_obj, char *name, PyObject *value)");
 	$self->pidl("{");
 	$self->indent;
-	$self->pidl("$cname *object = py_talloc_get_type(py_obj, $cname);");
+	$self->pidl("$cname *object = py_talloc_get_ptr(py_obj);");
 	my $mem_ctx = "py_talloc_get_mem_ctx(py_obj)";
 	foreach my $e (@{$d->{ELEMENTS}}) {
 		$self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {");
@@ -263,10 +263,10 @@ sub PythonFunction($$$)
 	$self->pidl("$iface\_InterfaceObject *iface = ($iface\_InterfaceObject *)self;");
 	$self->pidl("NTSTATUS status;");
 	$self->pidl("TALLOC_CTX *mem_ctx = talloc_new(NULL);");
-	$self->pidl("struct $fn->{NAME} r;");
+	$self->pidl("struct $fn->{NAME} *r = talloc_zero(mem_ctx, struct $fn->{NAME});");
 	$self->pidl("PyObject *result = Py_None;");
-
-	my $env = GenerateFunctionInEnv($fn, "r.");
+	
+	my $env = GenerateFunctionInEnv($fn, "r->");
 	my $result_size = 0;
 
 	my $args_format = "";
@@ -297,23 +297,19 @@ sub PythonFunction($$$)
 	$self->deindent;
 	$self->pidl("}");
 
-	if ($result_size > 0) {
-		$self->pidl("");
-		$self->pidl("ZERO_STRUCT(r.out);");
-	}
 	if ($fn->{RETURN_TYPE}) {
 		$result_size++;
 	}
 
 	foreach my $e (@{$fn->{ELEMENTS}}) {
 		if (grep(/in/,@{$e->{DIRECTION}})) {
-			$self->ConvertObjectFromPython($env, "mem_ctx", $e, "py_$e->{NAME}", "r.in.$e->{NAME}", "talloc_free(mem_ctx); return NULL;");
+			$self->ConvertObjectFromPython($env, "mem_ctx", $e, "py_$e->{NAME}", "r->in.$e->{NAME}", "talloc_free(mem_ctx); return NULL;");
 		}
 	}
-	$self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, &r);");
+	$self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, r);");
 	$self->handle_ntstatus("status", "NULL", "mem_ctx");
 
-	$env = GenerateFunctionOutEnv($fn, "r.");
+	$env = GenerateFunctionOutEnv($fn, "r->");
 	my $i = 0;
 
 	if ($result_size > 1) {
@@ -323,7 +319,7 @@ sub PythonFunction($$$)
 	foreach my $e (@{$fn->{ELEMENTS}}) {
 		my $py_name = "py_$e->{NAME}";
 		if (grep(/out/,@{$e->{DIRECTION}})) {
-			$self->ConvertObjectToPython($env, $e, "r.out.$e->{NAME}", $py_name);
+			$self->ConvertObjectToPython("r", $env, $e, "r->out.$e->{NAME}", $py_name);
 			if ($result_size > 1) {
 				$self->pidl("PyTuple_SetItem(result, $i, $py_name);");
 				$i++;
@@ -334,7 +330,7 @@ sub PythonFunction($$$)
 	}
 
 	if (defined($fn->{RETURN_TYPE})) {
-		my $conv = $self->ConvertObjectToPythonData($fn->{RETURN_TYPE}, "r.out.result");
+		my $conv = $self->ConvertObjectToPythonData("r", $fn->{RETURN_TYPE}, "r->out.result");
 		if ($result_size > 1) {
 			$self->pidl("PyTuple_SetItem(result, $i, $conv);");
 		} else {
@@ -397,10 +393,10 @@ sub PythonType($$$)
 	}
 
 	if ($actual_ctype->{TYPE} eq "UNION" and defined($actual_ctype->{ELEMENTS})) {
-		$self->pidl("PyObject *py_import_$d->{NAME}(int level, " .mapTypeName($d) . " *in)");
+		$self->pidl("PyObject *py_import_$d->{NAME}(TALLOC_CTX *mem_ctx, int level, " .mapTypeName($d) . " *in)");
 		$self->pidl("{");
 		$self->indent;
-		$self->FromUnionToPythonFunction($actual_ctype, "level", "in") if ($actual_ctype->{TYPE} eq "UNION");
+		$self->FromUnionToPythonFunction("mem_ctx", $actual_ctype, "level", "in") if ($actual_ctype->{TYPE} eq "UNION");
 		$self->deindent;
 		$self->pidl("}");
 		$self->pidl("");
@@ -676,9 +672,11 @@ sub ConvertObjectFromPythonLevel($$$$$$$$)
 		}
 	} elsif ($l->{TYPE} eq "ARRAY") {
 		if (is_charset_array($e, $l)) {
+			$self->pidl("PY_CHECK_TYPE(PyUnicode, $py_var, $fail);");
 			$self->pidl(get_pointer_to($var_name) . " = PyString_AsString(PyUnicode_AsEncodedString($py_var, \"utf-8\", \"ignore\"));");
 		} else {
 			my $counter = "$e->{NAME}_cntr_$l->{LEVEL_INDEX}";
+			$self->pidl("PY_CHECK_TYPE(PyList, $py_var, $fail);");
 			$self->pidl("{");
 			$self->indent;
 			$self->pidl("int $counter;");
@@ -754,9 +752,9 @@ sub ConvertScalarToPython($$$)
 	die("Unknown scalar type $ctypename");
 }
 
-sub ConvertObjectToPythonData($$$$)
+sub ConvertObjectToPythonData($$$$$)
 {
-	my ($self, $ctype, $cvar) = @_;
+	my ($self, $mem_ctx, $ctype, $cvar) = @_;
 
 	die("undef type for $cvar") unless(defined($ctype));
 
@@ -797,9 +795,9 @@ sub ConvertObjectToPythonData($$$$)
 	die("unknown type ".mapTypeName($ctype) . ": $cvar");
 }
 
-sub ConvertObjectToPythonLevel($$$$)
+sub ConvertObjectToPythonLevel($$$$$)
 {
-	my ($self, $env, $e, $l, $var_name, $py_var) = @_;
+	my ($self, $mem_ctx, $env, $e, $l, $var_name, $py_var) = @_;
 
 	if ($l->{TYPE} eq "POINTER") {
 		if ($l->{POINTER_TYPE} ne "ref") {
@@ -810,7 +808,7 @@ sub ConvertObjectToPythonLevel($$$$)
 			$self->pidl("} else {");
 			$self->indent;
 		}
-		$self->ConvertObjectToPythonLevel($env, $e, GetNextLevel($e, $l), get_value_of($var_name), $py_var);
+		$self->ConvertObjectToPythonLevel($var_name, $env, $e, GetNextLevel($e, $l), get_value_of($var_name), $py_var);
 		if ($l->{POINTER_TYPE} ne "ref") {
 			$self->deindent;
 			$self->pidl("}");
@@ -836,7 +834,7 @@ sub ConvertObjectToPythonLevel($$$$)
 			$self->indent;
 			my $member_var = "py_$e->{NAME}_$l->{LEVEL_INDEX}";
 			$self->pidl("PyObject *$member_var;");
-			$self->ConvertObjectToPythonLevel($env, $e, GetNextLevel($e, $l), $var_name."[$counter]", $member_var);
+			$self->ConvertObjectToPythonLevel($var_name, $env, $e, GetNextLevel($e, $l), $var_name."[$counter]", $member_var);
 			$self->pidl("PyList_SetItem($py_var, $counter, $member_var);");
 			$self->deindent;
 			$self->pidl("}");
@@ -846,13 +844,13 @@ sub ConvertObjectToPythonLevel($$$$)
 	} elsif ($l->{TYPE} eq "SWITCH") {
 		$var_name = get_pointer_to($var_name);
 		my $switch = ParseExpr($l->{SWITCH_IS}, $env, $e);
-		$self->pidl("$py_var = py_import_" . GetNextLevel($e, $l)->{DATA_TYPE} . "($switch, $var_name);");
+		$self->pidl("$py_var = py_import_" . GetNextLevel($e, $l)->{DATA_TYPE} . "($mem_ctx, $switch, $var_name);");
 	} elsif ($l->{TYPE} eq "DATA") {
 		if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or 
 			Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
 			$var_name = get_pointer_to($var_name);
 		}
-		my $conv = $self->ConvertObjectToPythonData($l->{DATA_TYPE}, $var_name);
+		my $conv = $self->ConvertObjectToPythonData($mem_ctx, $l->{DATA_TYPE}, $var_name);
 		$self->pidl("$py_var = $conv;");
 	} elsif ($l->{TYPE} eq "SUBCONTEXT") {
 		$self->pidl("FIXME");
@@ -861,11 +859,11 @@ sub ConvertObjectToPythonLevel($$$$)
 	}
 }
 
-sub ConvertObjectToPython($$$$$)
+sub ConvertObjectToPython($$$$$$)
 {
-	my ($self, $env, $ctype, $cvar, $py_var) = @_;
+	my ($self, $mem_ctx, $env, $ctype, $cvar, $py_var) = @_;
 
-	$self->ConvertObjectToPythonLevel($env, $ctype, $ctype->{LEVELS}[0], $cvar, $py_var);
+	$self->ConvertObjectToPythonLevel($mem_ctx, $env, $ctype, $ctype->{LEVELS}[0], $cvar, $py_var);
 }
 
 sub Parse($$$$$)
@@ -925,7 +923,7 @@ sub Parse($$$$$)
 		} elsif ($cvar =~ /^".*"$/) {
 			$py_obj = "PyString_FromString($cvar)";
 		} else {
-			$py_obj = $self->ConvertObjectToPythonData($ctype, $cvar);
+			$py_obj = $self->ConvertObjectToPythonData("NULL", $ctype, $cvar);
 		}
 
 		$self->pidl("PyModule_AddObject(m, \"$name\", $py_obj);");
-- 
cgit 


From e231e24d89dfe3faaf0f791dc5e0df5fa9c21590 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 14 Jan 2008 06:23:13 +0100
Subject: pidl/python: Deal with arrays that are not pointers. (This used to be
 commit 7516af7c7262240df3b804dda962194a811d4e96)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 12 ++++++++++++
 1 file changed, 12 insertions(+)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index e0751d0c72..1483083e22 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -673,8 +673,14 @@ sub ConvertObjectFromPythonLevel($$$$$$$$)
 	} elsif ($l->{TYPE} eq "ARRAY") {
 		if (is_charset_array($e, $l)) {
 			$self->pidl("PY_CHECK_TYPE(PyUnicode, $py_var, $fail);");
+			# FIXME: Use Unix charset setting rather than utf-8
 			$self->pidl(get_pointer_to($var_name) . " = PyString_AsString(PyUnicode_AsEncodedString($py_var, \"utf-8\", \"ignore\"));");
 		} else {
+			my $pl = GetPrevLevel($e, $l);
+			if ($pl && $pl->{TYPE} eq "POINTER") {
+				$var_name = get_pointer_to($var_name);
+			}
+
 			my $counter = "$e->{NAME}_cntr_$l->{LEVEL_INDEX}";
 			$self->pidl("PY_CHECK_TYPE(PyList, $py_var, $fail);");
 			$self->pidl("{");
@@ -816,8 +822,14 @@ sub ConvertObjectToPythonLevel($$$$$)
 	} elsif ($l->{TYPE} eq "ARRAY") {
 		if (is_charset_array($e, $l)) {
 			$var_name = get_pointer_to($var_name);
+			# FIXME: Use Unix charset setting rather than utf-8
 			$self->pidl("$py_var = PyUnicode_Decode($var_name, strlen($var_name), \"utf-8\", \"ignore\");");
 		} else {
+			my $pl = GetPrevLevel($e, $l);
+			if ($pl && $pl->{TYPE} eq "POINTER") {
+				$var_name = get_pointer_to($var_name);
+			}
+
 			die("No SIZE_IS for array $var_name") unless (defined($l->{SIZE_IS}));
 			my $length = $l->{SIZE_IS};
 			if (defined($l->{LENGTH_IS})) {
-- 
cgit 


From 30a2a43a7546b5336058559f5ffd74b1f799c05b Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 14 Jan 2008 13:26:01 +0100
Subject: pidl/python: Fix processing UUID-less interfaces, external typedefs
 and certain bitmap elements. (This used to be commit
 e65618fff3299193c27959e2cc5a3937837e1422)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 261 +++++++++++++--------------
 source4/pidl/lib/Parse/Pidl/Typelist.pm      |  16 +-
 2 files changed, 137 insertions(+), 140 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 1483083e22..e538771624 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -9,7 +9,7 @@ use Exporter;
 @ISA = qw(Exporter);
 
 use strict;
-use Parse::Pidl::Typelist qw(hasType getType mapTypeName expandAlias);
+use Parse::Pidl::Typelist qw(hasType resolveType getType mapTypeName expandAlias);
 use Parse::Pidl::Util qw(has_property ParseExpr);
 use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred is_charset_array);
 use Parse::Pidl::CUtil qw(get_value_of get_pointer_to);
@@ -84,7 +84,7 @@ sub EnumAndBitmapConsts($$$)
 	return unless (defined($d->{ELEMENTS}));
 
 	foreach my $e (@{$d->{ELEMENTS}}) {
-		$e =~ /^([A-Za-z0-9_]+)=(.*)$/;
+		$e =~ /^([A-Za-z0-9_]+)/;
 		my $cname = $1;
 		
 		$self->register_constant($cname, $d, $cname);
@@ -188,7 +188,7 @@ sub PythonStruct($$$$)
 		my $varname = "object->$e->{NAME}";
 		$self->indent;
 		$self->pidl("PyObject *py_$e->{NAME};");
-		$self->ConvertObjectToPython("py_talloc_get_talloc_ctx(obj)", $env, $e, $varname, "py_$e->{NAME}");
+		$self->ConvertObjectToPython("py_talloc_get_mem_ctx(obj)", $env, $e, $varname, "py_$e->{NAME}");
 		$self->pidl("return py_$e->{NAME};");
 		$self->deindent;
 		$self->pidl("}");
@@ -428,133 +428,135 @@ sub Interface($$$)
 		$self->PythonType($d, $interface, $basename);
 	}
 
-	$self->pidl_hdr("PyAPI_DATA(PyTypeObject) $interface->{NAME}_InterfaceType;\n");
-	$self->pidl("typedef struct {");
-	$self->indent;
-	$self->pidl("PyObject_HEAD");
-	$self->pidl("struct dcerpc_pipe *pipe;");
-	$self->deindent;
-	$self->pidl("} $interface->{NAME}_InterfaceObject;");
+	if (defined $interface->{PROPERTIES}->{uuid}) {
+		$self->pidl_hdr("PyAPI_DATA(PyTypeObject) $interface->{NAME}_InterfaceType;\n");
+		$self->pidl("typedef struct {");
+		$self->indent;
+		$self->pidl("PyObject_HEAD");
+		$self->pidl("struct dcerpc_pipe *pipe;");
+		$self->deindent;
+		$self->pidl("} $interface->{NAME}_InterfaceObject;");
 
-	$self->pidl("");
+		$self->pidl("");
 
-	foreach my $d (@{$interface->{FUNCTIONS}}) {
-		next if not defined($d->{OPNUM});
-		next if has_property($d, "nopython");
+		foreach my $d (@{$interface->{FUNCTIONS}}) {
+			next if not defined($d->{OPNUM});
+			next if has_property($d, "nopython");
 
-		$self->PythonFunction($d, $interface->{NAME});
-	}
+			$self->PythonFunction($d, $interface->{NAME});
+		}
 
-	$self->pidl("static PyMethodDef interface_$interface->{NAME}\_methods[] = {");
-	$self->indent;
-	foreach my $d (@{$interface->{FUNCTIONS}}) {
-		next if not defined($d->{OPNUM});
-		next if has_property($d, "nopython");
+		$self->pidl("static PyMethodDef interface_$interface->{NAME}\_methods[] = {");
+		$self->indent;
+		foreach my $d (@{$interface->{FUNCTIONS}}) {
+			next if not defined($d->{OPNUM});
+			next if has_property($d, "nopython");
 
-		my $fn_name = $d->{NAME};
+			my $fn_name = $d->{NAME};
 
-		$fn_name =~ s/^$interface->{NAME}_//;
-		$fn_name =~ s/^$basename\_//;
+			$fn_name =~ s/^$interface->{NAME}_//;
+			$fn_name =~ s/^$basename\_//;
 
-		$self->pidl("{ \"$fn_name\", (PyCFunction)py_$d->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },");
-	}
-	$self->pidl("{ NULL, NULL, 0, NULL }");
-	$self->deindent;
-	$self->pidl("};");
-	$self->pidl("");
+			$self->pidl("{ \"$fn_name\", (PyCFunction)py_$d->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },");
+		}
+		$self->pidl("{ NULL, NULL, 0, NULL }");
+		$self->deindent;
+		$self->pidl("};");
+		$self->pidl("");
 
-	$self->pidl("static void interface_$interface->{NAME}_dealloc(PyObject* self)");
-	$self->pidl("{");
-	$self->indent;
-	$self->pidl("$interface->{NAME}_InterfaceObject *interface = ($interface->{NAME}_InterfaceObject *)self;");
-	$self->pidl("talloc_free(interface->pipe);");
-	$self->pidl("PyObject_Del(self);");
-	$self->deindent;
-	$self->pidl("}");
-	$self->pidl("");
+		$self->pidl("static void interface_$interface->{NAME}_dealloc(PyObject* self)");
+		$self->pidl("{");
+		$self->indent;
+		$self->pidl("$interface->{NAME}_InterfaceObject *interface = ($interface->{NAME}_InterfaceObject *)self;");
+		$self->pidl("talloc_free(interface->pipe);");
+		$self->pidl("PyObject_Del(self);");
+		$self->deindent;
+		$self->pidl("}");
+		$self->pidl("");
 
-	$self->pidl("static PyObject *interface_$interface->{NAME}_getattr(PyObject *obj, char *name)");
-	$self->pidl("{");
-	$self->indent;
-	$self->pidl("return Py_FindMethod(interface_$interface->{NAME}\_methods, obj, name);");
-	$self->deindent;
-	$self->pidl("}");
+		$self->pidl("static PyObject *interface_$interface->{NAME}_getattr(PyObject *obj, char *name)");
+		$self->pidl("{");
+		$self->indent;
+		$self->pidl("return Py_FindMethod(interface_$interface->{NAME}\_methods, obj, name);");
+		$self->deindent;
+		$self->pidl("}");
 
-	$self->pidl("");
+		$self->pidl("");
 
-	$self->pidl("PyTypeObject $interface->{NAME}_InterfaceType = {");
-	$self->indent;
-	$self->pidl("PyObject_HEAD_INIT(NULL) 0,");
-	$self->pidl(".tp_name = \"$interface->{NAME}\",");
-	$self->pidl(".tp_basicsize = sizeof($interface->{NAME}_InterfaceObject),");
-	$self->pidl(".tp_dealloc = interface_$interface->{NAME}_dealloc,");
-	$self->pidl(".tp_getattr = interface_$interface->{NAME}_getattr,");
-	$self->deindent;
-	$self->pidl("};");
+		$self->pidl("PyTypeObject $interface->{NAME}_InterfaceType = {");
+		$self->indent;
+		$self->pidl("PyObject_HEAD_INIT(NULL) 0,");
+		$self->pidl(".tp_name = \"$interface->{NAME}\",");
+		$self->pidl(".tp_basicsize = sizeof($interface->{NAME}_InterfaceObject),");
+		$self->pidl(".tp_dealloc = interface_$interface->{NAME}_dealloc,");
+		$self->pidl(".tp_getattr = interface_$interface->{NAME}_getattr,");
+		$self->deindent;
+		$self->pidl("};");
 
-	$self->pidl("");
+		$self->pidl("");
 
-	$self->register_module_method($interface->{NAME}, "interface_$interface->{NAME}", "METH_VARARGS|METH_KEYWORDS", "NULL");
-	$self->pidl("static PyObject *interface_$interface->{NAME}(PyObject *self, PyObject *args, PyObject *kwargs)");
-	$self->pidl("{");
-	$self->indent;
-	$self->pidl("$interface->{NAME}_InterfaceObject *ret;");
-	$self->pidl("const char *binding_string;");
-	$self->pidl("struct cli_credentials *credentials;");
-	$self->pidl("struct loadparm_context *lp_ctx = NULL;");
-	$self->pidl("PyObject *py_lp_ctx = NULL, *py_credentials = Py_None;");
-	$self->pidl("TALLOC_CTX *mem_ctx = NULL;");
-	$self->pidl("NTSTATUS status;");
-	$self->pidl("");
-	$self->pidl("const char *kwnames[] = {");
-	$self->indent;
-	$self->pidl("\"binding\", \"lp_ctx\", \"credentials\", NULL");
-	$self->deindent;
-	$self->pidl("};");
-	$self->pidl("extern struct loadparm_context *lp_from_py_object(PyObject *py_obj);");
-    $self->pidl("extern struct cli_credentials *cli_credentials_from_py_object(PyObject *py_obj);");
-	$self->pidl("");
-	$self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"sO|O:$interface->{NAME}\", discard_const_p(char *, kwnames), &binding_string, &py_lp_ctx, &py_credentials)) {");
-	$self->indent;
-	$self->pidl("return NULL;");
-	$self->deindent;
-	$self->pidl("}");
-	$self->pidl("");
-	$self->pidl("if (py_lp_ctx != NULL) {");
-	$self->indent;
-	$self->pidl("lp_ctx = lp_from_py_object(py_lp_ctx);");
-	$self->pidl("if (lp_ctx == NULL) {");
-	$self->indent;
-	$self->pidl("PyErr_SetString(PyExc_TypeError, \"Expected loadparm context\");");
-	$self->pidl("return NULL;");
-	$self->deindent;
-	$self->pidl("}");
-	$self->deindent;
-	$self->pidl("}");
-	$self->pidl("");
+		$self->register_module_method($interface->{NAME}, "interface_$interface->{NAME}", "METH_VARARGS|METH_KEYWORDS", "NULL");
+		$self->pidl("static PyObject *interface_$interface->{NAME}(PyObject *self, PyObject *args, PyObject *kwargs)");
+		$self->pidl("{");
+		$self->indent;
+		$self->pidl("$interface->{NAME}_InterfaceObject *ret;");
+		$self->pidl("const char *binding_string;");
+		$self->pidl("struct cli_credentials *credentials;");
+		$self->pidl("struct loadparm_context *lp_ctx = NULL;");
+		$self->pidl("PyObject *py_lp_ctx = NULL, *py_credentials = Py_None;");
+		$self->pidl("TALLOC_CTX *mem_ctx = NULL;");
+		$self->pidl("NTSTATUS status;");
+		$self->pidl("");
+		$self->pidl("const char *kwnames[] = {");
+		$self->indent;
+		$self->pidl("\"binding\", \"lp_ctx\", \"credentials\", NULL");
+		$self->deindent;
+		$self->pidl("};");
+		$self->pidl("extern struct loadparm_context *lp_from_py_object(PyObject *py_obj);");
+		$self->pidl("extern struct cli_credentials *cli_credentials_from_py_object(PyObject *py_obj);");
+		$self->pidl("");
+		$self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"sO|O:$interface->{NAME}\", discard_const_p(char *, kwnames), &binding_string, &py_lp_ctx, &py_credentials)) {");
+		$self->indent;
+		$self->pidl("return NULL;");
+		$self->deindent;
+		$self->pidl("}");
+		$self->pidl("");
+		$self->pidl("if (py_lp_ctx != NULL) {");
+		$self->indent;
+		$self->pidl("lp_ctx = lp_from_py_object(py_lp_ctx);");
+		$self->pidl("if (lp_ctx == NULL) {");
+		$self->indent;
+		$self->pidl("PyErr_SetString(PyExc_TypeError, \"Expected loadparm context\");");
+		$self->pidl("return NULL;");
+		$self->deindent;
+		$self->pidl("}");
+		$self->deindent;
+		$self->pidl("}");
+		$self->pidl("");
 
-    $self->pidl("credentials = cli_credentials_from_py_object(py_credentials);");
-    $self->pidl("if (credentials == NULL) {");
-    $self->indent;
-    $self->pidl("PyErr_SetString(PyExc_TypeError, \"Expected credentials\");");
-    $self->pidl("return NULL;");
-    $self->deindent;
-    $self->pidl("}");
+		$self->pidl("credentials = cli_credentials_from_py_object(py_credentials);");
+		$self->pidl("if (credentials == NULL) {");
+		$self->indent;
+		$self->pidl("PyErr_SetString(PyExc_TypeError, \"Expected credentials\");");
+		$self->pidl("return NULL;");
+		$self->deindent;
+		$self->pidl("}");
 
-	$self->pidl("ret = PyObject_New($interface->{NAME}_InterfaceObject, &$interface->{NAME}_InterfaceType);");
-	$self->pidl("");
+		$self->pidl("ret = PyObject_New($interface->{NAME}_InterfaceObject, &$interface->{NAME}_InterfaceType);");
+		$self->pidl("");
 
-	$self->pidl("status = dcerpc_pipe_connect(NULL, &ret->pipe, binding_string, ");
-	$self->pidl("             &ndr_table_$interface->{NAME}, credentials, NULL, lp_ctx);");
-	$self->handle_ntstatus("status", "NULL", "mem_ctx");
+		$self->pidl("status = dcerpc_pipe_connect(NULL, &ret->pipe, binding_string, ");
+		$self->pidl("             &ndr_table_$interface->{NAME}, credentials, NULL, lp_ctx);");
+		$self->handle_ntstatus("status", "NULL", "mem_ctx");
 
-	$self->pidl("ret->pipe->conn->flags |= DCERPC_NDR_REF_ALLOC;");
+		$self->pidl("ret->pipe->conn->flags |= DCERPC_NDR_REF_ALLOC;");
 
-	$self->pidl("return (PyObject *)ret;");
-	$self->deindent;
-	$self->pidl("}");
-	
-	$self->pidl("");
+		$self->pidl("return (PyObject *)ret;");
+		$self->deindent;
+		$self->pidl("}");
+		
+		$self->pidl("");
+	}
 
 	$self->pidl_hdr("\n");
 	$self->pidl_hdr("#endif /* _HEADER_NDR_$interface->{NAME} */\n");
@@ -583,9 +585,7 @@ sub ConvertObjectFromPythonData($$$$$$)
 
 	die("undef type for $cvar") unless(defined($ctype));
 
-	if (ref($ctype) ne "HASH") {
-		$ctype = getType($ctype);
-	}
+	$ctype = resolveType($ctype);
 
 	if (ref($ctype) ne "HASH") {
 		$self->pidl("$target = FIXME($cvar);");
@@ -764,38 +764,21 @@ sub ConvertObjectToPythonData($$$$$)
 
 	die("undef type for $cvar") unless(defined($ctype));
 
-	if (ref($ctype) ne "HASH") {
-		if (not hasType($ctype)) {
-			if (ref($ctype) eq "HASH") {
-				return "py_import_$ctype->{TYPE}_$ctype->{NAME}($cvar)";
-			} else {
-				return "py_import_$ctype($cvar)"; # best bet
-			}
-		}
-
-		$ctype = getType($ctype);
-	}
+	$ctype = resolveType($ctype);
 
 	my $actual_ctype = $ctype;
 	if ($ctype->{TYPE} eq "TYPEDEF") {
 		$actual_ctype = $ctype->{DATA};
-	}
-
+	} 
+	
 	if ($actual_ctype->{TYPE} eq "ENUM") {
 		return $self->ConvertScalarToPython(Parse::Pidl::Typelist::enum_type_fn($actual_ctype), $cvar);
-	}
-
-	if ($actual_ctype->{TYPE} eq "BITMAP") {
+	} elsif ($actual_ctype->{TYPE} eq "BITMAP") {
 		return $self->ConvertScalarToPython(Parse::Pidl::Typelist::bitmap_type_fn($actual_ctype), $cvar);
-	}
-
-	if ($actual_ctype->{TYPE} eq "SCALAR") {
+	} elsif ($actual_ctype->{TYPE} eq "SCALAR") {
 		return $self->ConvertScalarToPython($actual_ctype->{NAME}, $cvar);
-	}
-
-	if ($actual_ctype->{TYPE} eq "STRUCT") {
-		# FIXME: if $cvar is not a pointer, do a talloc_dup()
-		return "py_talloc_import(&$ctype->{NAME}_Type, $cvar)";
+	} elsif ($actual_ctype->{TYPE} eq "STRUCT") {
+		return "py_talloc_import_ex(&$ctype->{NAME}_Type, $mem_ctx, $cvar)";
 	}
 
 	die("unknown type ".mapTypeName($ctype) . ": $cvar");
diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm
index e54ef11b88..9e6c683f82 100644
--- a/source4/pidl/lib/Parse/Pidl/Typelist.pm
+++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm
@@ -7,7 +7,7 @@ package Parse::Pidl::Typelist;
 
 require Exporter;
 @ISA = qw(Exporter);
-@EXPORT_OK = qw(hasType getType mapTypeName scalar_is_reference expandAlias
+@EXPORT_OK = qw(hasType getType resolveType mapTypeName scalar_is_reference expandAlias
 			    mapScalarType addType typeIs is_scalar enum_type_fn
 				bitmap_type_fn mapType typeHasBody
 );
@@ -95,6 +95,20 @@ sub addType($)
 	$types{$t->{NAME}} = $t;
 }
 
+sub resolveType($)
+{
+	my ($ctype) = @_;
+
+	if (not hasType($ctype)) {
+		# assume struct typedef
+		return { TYPE => "TYPEDEF", NAME => $ctype, DATA => { TYPE => "STRUCT" } };
+	} else {
+		return getType($ctype);
+	}
+
+	return $ctype;
+}
+
 sub getType($)
 {
 	my $t = shift;
-- 
cgit 


From 7dd468ff2e5a4c4ce503e1b8e024bf91dcf7a412 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 14 Jan 2008 14:48:59 +0100
Subject: python: Fix python code for winreg, add test. (This used to be commit
 bd3e6c41c42738fcfcc5cef4e65f0e219d358260)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index e538771624..c8505e9904 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -665,6 +665,7 @@ sub ConvertObjectFromPythonLevel($$$$$$$$)
 			$self->pidl("} else {");
 			$self->indent;
 		}
+		$self->pidl("$var_name = talloc_ptrtype($mem_ctx, $var_name);");
 		$self->ConvertObjectFromPythonLevel($env, $mem_ctx, $py_var, $e, GetNextLevel($e, $l), get_value_of($var_name), $fail);
 		if ($l->{POINTER_TYPE} ne "ref") {
 			$self->deindent;
@@ -686,7 +687,9 @@ sub ConvertObjectFromPythonLevel($$$$$$$$)
 			$self->pidl("{");
 			$self->indent;
 			$self->pidl("int $counter;");
-			$self->pidl("$var_name = talloc_array_ptrtype($mem_ctx, $var_name, PyList_Size($py_var));");
+			if (!$l->{IS_FIXED}) {
+				$self->pidl("$var_name = talloc_array_ptrtype($mem_ctx, $var_name, PyList_Size($py_var));");
+			}
 			$self->pidl("for ($counter = 0; $counter < PyList_Size($py_var); $counter++) {");
 			$self->indent;
 			$self->ConvertObjectFromPythonLevel($env, $var_name, "PyList_GetItem($py_var, $counter)", $e, GetNextLevel($e, $l), $var_name."[$counter]", $fail);
@@ -697,8 +700,7 @@ sub ConvertObjectFromPythonLevel($$$$$$$$)
 		}
 	} 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})) {
+		if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE})) {
 			$var_name = get_pointer_to($var_name);
 		}
 		$self->ConvertObjectFromPythonData($mem_ctx, $py_var, $l->{DATA_TYPE}, $var_name, $fail);
@@ -841,8 +843,7 @@ sub ConvertObjectToPythonLevel($$$$$)
 		my $switch = ParseExpr($l->{SWITCH_IS}, $env, $e);
 		$self->pidl("$py_var = py_import_" . GetNextLevel($e, $l)->{DATA_TYPE} . "($mem_ctx, $switch, $var_name);");
 	} elsif ($l->{TYPE} eq "DATA") {
-		if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or 
-			Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
+		if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE})) {
 			$var_name = get_pointer_to($var_name);
 		}
 		my $conv = $self->ConvertObjectToPythonData($mem_ctx, $l->{DATA_TYPE}, $var_name);
-- 
cgit 


From 035599fa651409502a6894179d5cd8a026110ba1 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 14 Jan 2008 15:25:09 +0100
Subject: python: Be more pythonic - turn WERROR and NTSTATUS return codes into
 exceptions. (This used to be commit 16fc69b843e92ae62b15caf927335cc117156499)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 22 ++++++++++++++++++++--
 1 file changed, 20 insertions(+), 2 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index c8505e9904..9f6a7847b1 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -298,7 +298,7 @@ sub PythonFunction($$$)
 	$self->pidl("}");
 
 	if ($fn->{RETURN_TYPE}) {
-		$result_size++;
+		$result_size++ unless ($fn->{RETURN_TYPE} eq "WERROR" or $fn->{RETURN_TYPE} eq "NTSTATUS");
 	}
 
 	foreach my $e (@{$fn->{ELEMENTS}}) {
@@ -329,7 +329,11 @@ sub PythonFunction($$$)
 		}
 	}
 
-	if (defined($fn->{RETURN_TYPE})) {
+	if (defined($fn->{RETURN_TYPE}) and $fn->{RETURN_TYPE} eq "NTSTATUS") {
+		$self->handle_ntstatus("r->out.result", "NULL", "mem_ctx");
+	} elsif (defined($fn->{RETURN_TYPE}) and $fn->{RETURN_TYPE} eq "WERROR") {
+		$self->handle_werror("r->out.result", "NULL", "mem_ctx");
+	} elsif (defined($fn->{RETURN_TYPE})) {
 		my $conv = $self->ConvertObjectToPythonData("r", $fn->{RETURN_TYPE}, "r->out.result");
 		if ($result_size > 1) {
 			$self->pidl("PyTuple_SetItem(result, $i, $conv);");
@@ -345,6 +349,20 @@ sub PythonFunction($$$)
 	$self->pidl("");
 }
 
+sub handle_werror($$$$)
+{
+	my ($self, $var, $retval, $mem_ctx) = @_;
+
+	$self->pidl("if (!W_ERROR_IS_OK($var)) {");
+	$self->indent;
+	$self->pidl("PyErr_SetString(PyExc_RuntimeError, win_errstr($var));");
+	$self->pidl("talloc_free($mem_ctx);") if ($mem_ctx);
+	$self->pidl("return $retval;");
+	$self->deindent;
+	$self->pidl("}");
+	$self->pidl("");
+}
+
 sub handle_ntstatus($$$$)
 {
 	my ($self, $var, $retval, $mem_ctx) = @_;
-- 
cgit 


From fa5397fbeda759ac66fc5d0a6bdfb60a070a7962 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 14 Jan 2008 16:11:58 +0100
Subject: python: Build epmapper module. (This used to be commit
 6cb78c7634de0f9ab327583844d7860d384356eb)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 83 +++++++++++++---------------
 1 file changed, 37 insertions(+), 46 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 9f6a7847b1..0d5237022a 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -102,11 +102,7 @@ sub FromUnionToPythonFunction($$$$)
 	$self->indent;
 
 	foreach my $e (@{$type->{ELEMENTS}}) {
-		if (defined($e->{CASE})) {
-			$self->pidl("$e->{CASE}:");
-		} else {
-			$self->pidl("default:");
-		}
+		$self->pidl("$e->{CASE}:");
 
 		$self->indent;
 
@@ -141,12 +137,8 @@ sub FromPythonToUnionFunction($$$$$)
 	$self->indent;
 
 	foreach my $e (@{$type->{ELEMENTS}}) {
-		if (defined($e->{CASE})) {
-			$self->pidl("$e->{CASE}:");
-		} else {
-			$has_default = 1;
-			$self->pidl("default:");
-		}
+		$self->pidl("$e->{CASE}:");
+		if ($e->{CASE} eq "default") { $has_default = 1; }
 		$self->indent;
 		if ($e->{NAME}) {
 			$self->ConvertObjectFromPython({}, $mem_ctx, $e, $name, "ret->$e->{NAME}", "talloc_free(ret); return NULL;");
@@ -182,16 +174,18 @@ sub PythonStruct($$$$)
 	$self->pidl("static PyObject *py_$name\_getattr(PyObject *obj, char *name)");
 	$self->pidl("{");
 	$self->indent;
-	$self->pidl("$cname *object = py_talloc_get_ptr(obj);");
-	foreach my $e (@{$d->{ELEMENTS}}) {
-		$self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {");
-		my $varname = "object->$e->{NAME}";
-		$self->indent;
-		$self->pidl("PyObject *py_$e->{NAME};");
-		$self->ConvertObjectToPython("py_talloc_get_mem_ctx(obj)", $env, $e, $varname, "py_$e->{NAME}");
-		$self->pidl("return py_$e->{NAME};");
-		$self->deindent;
-		$self->pidl("}");
+	if ($#{$d->{ELEMENTS}} > -1) {
+		$self->pidl("$cname *object = py_talloc_get_ptr(obj);");
+		foreach my $e (@{$d->{ELEMENTS}}) {
+			$self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {");
+			my $varname = "object->$e->{NAME}";
+			$self->indent;
+			$self->pidl("PyObject *py_$e->{NAME};");
+			$self->ConvertObjectToPython("py_talloc_get_mem_ctx(obj)", $env, $e, $varname, "py_$e->{NAME}");
+			$self->pidl("return py_$e->{NAME};");
+			$self->deindent;
+			$self->pidl("}");
+		}
 	}
 	$self->pidl("PyErr_SetString(PyExc_AttributeError, \"no such attribute\");");
 	$self->pidl("return NULL;");
@@ -202,19 +196,21 @@ sub PythonStruct($$$$)
 	$self->pidl("static int py_$name\_setattr(PyObject *py_obj, char *name, PyObject *value)");
 	$self->pidl("{");
 	$self->indent;
-	$self->pidl("$cname *object = py_talloc_get_ptr(py_obj);");
-	my $mem_ctx = "py_talloc_get_mem_ctx(py_obj)";
-	foreach my $e (@{$d->{ELEMENTS}}) {
-		$self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {");
-		my $varname = "object->$e->{NAME}";
-		$self->indent;
-		if ($e->{ORIGINAL}->{POINTERS} > 0) {
-			$self->pidl("talloc_free($varname);");
+	if ($#{$d->{ELEMENTS}} > -1) {
+		$self->pidl("$cname *object = py_talloc_get_ptr(py_obj);");
+		my $mem_ctx = "py_talloc_get_mem_ctx(py_obj)";
+		foreach my $e (@{$d->{ELEMENTS}}) {
+			$self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {");
+			my $varname = "object->$e->{NAME}";
+			$self->indent;
+			if ($e->{ORIGINAL}->{POINTERS} > 0) {
+				$self->pidl("talloc_free($varname);");
+			}
+			$self->ConvertObjectFromPython($env, $mem_ctx, $e, "value", $varname, "return -1;");
+			$self->pidl("return 0;");
+			$self->deindent;
+			$self->pidl("}");
 		}
-		$self->ConvertObjectFromPython($env, $mem_ctx, $e, "value", $varname, "return -1;");
-		$self->pidl("return 0;");
-		$self->deindent;
-		$self->pidl("}");
 	}
 	$self->pidl("PyErr_SetString(PyExc_AttributeError, \"no such attribute\");");
 	$self->pidl("return -1;");
@@ -591,7 +587,7 @@ sub assign($$$)
 {
 	my ($self, $dest, $src) = @_;
 	if ($dest =~ /^\&/) {
-		$self->pidl("memcpy($dest, $src, sizeof(*$dest));");
+		$self->pidl("memcpy($dest, $src, sizeof(" . get_value_of($dest) . "));");
 	} else {
 		$self->pidl("$dest = $src;");
 	}
@@ -605,11 +601,6 @@ sub ConvertObjectFromPythonData($$$$$$)
 
 	$ctype = resolveType($ctype);
 
-	if (ref($ctype) ne "HASH") {
-		$self->pidl("$target = FIXME($cvar);");
-		return;
-	}
-
 	my $actual_ctype = $ctype;
 	if ($ctype->{TYPE} eq "TYPEDEF") {
 		$actual_ctype = $ctype->{DATA};
@@ -641,7 +632,7 @@ sub ConvertObjectFromPythonData($$$$$$)
 	}
 
 	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "ipv4address") {
-		$self->pidl("$target = FIXME($cvar);");
+		$self->pidl("$target = PyString_AsString($cvar);");
 		return;
 		}
 
@@ -657,7 +648,7 @@ sub ConvertObjectFromPythonData($$$$$$)
 	}
 
 	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "string_array") {
-		$self->pidl("$target = FIXME($cvar);");
+		$self->pidl("$target = PyCObject_AsVoidPtr($cvar);");
 		return;
 	}
 
@@ -725,9 +716,9 @@ sub ConvertObjectFromPythonLevel($$$$$$$$)
 	} elsif ($l->{TYPE} eq "SWITCH") {
 		$var_name = get_pointer_to($var_name);
 		my $switch = ParseExpr($l->{SWITCH_IS}, $env, $e);
-		$self->pidl("$var_name = py_export_" . GetNextLevel($e, $l)->{DATA_TYPE} . "($mem_ctx, $switch, $py_var);");
+		$self->assign($var_name, "py_export_" . GetNextLevel($e, $l)->{DATA_TYPE} . "($mem_ctx, $switch, $py_var)");
 	} elsif ($l->{TYPE} eq "SUBCONTEXT") {
-		$self->pidl("#error Subcontext not yet supported");
+		$self->ConvertObjectFromPythonLevel($env, $mem_ctx, $py_var, $e, GetNextLevel($e, $l), $var_name, $fail);
 	} else {
 		die("unknown level type $l->{TYPE}");
 	}
@@ -753,7 +744,7 @@ sub ConvertScalarToPython($$$)
 	}
 
 	if ($ctypename eq "DATA_BLOB") {
-		return "PyString_FromStringAndSize($cvar->data, $cvar->length)";
+		return "PyString_FromStringAndSize((char *)($cvar).data, ($cvar).length)";
 	}
 
 	if ($ctypename eq "NTSTATUS") {
@@ -770,7 +761,7 @@ sub ConvertScalarToPython($$$)
 
 	# Not yet supported
 	if ($ctypename eq "string_array") { return "PyCObject_FromVoidPtr($cvar)"; }
-	if ($ctypename eq "ipv4address") { return "PyCObject_FromVoidPtr($cvar)"; }
+	if ($ctypename eq "ipv4address") { return "PyString_FromString($cvar)"; }
 	if ($ctypename eq "pointer") {
 		return "PyCObject_FromVoidPtr($cvar, talloc_free)";
 	}
@@ -867,7 +858,7 @@ sub ConvertObjectToPythonLevel($$$$$)
 		my $conv = $self->ConvertObjectToPythonData($mem_ctx, $l->{DATA_TYPE}, $var_name);
 		$self->pidl("$py_var = $conv;");
 	} elsif ($l->{TYPE} eq "SUBCONTEXT") {
-		$self->pidl("FIXME");
+		$self->ConvertObjectToPythonLevel($mem_ctx, $env, $e, GetNextLevel($e, $l), $var_name, $py_var);
 	} else {
 		die("Unknown level type $l->{TYPE} $var_name");
 	}
-- 
cgit 


From 860106b3f426a06eed6a681fa839dd89f339ba9a Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 14 Jan 2008 16:49:19 +0100
Subject: python: Move some convenience macros to a separate header rather than
 putting them in every generated py_* file. (This used to be commit
 712274b9bdf524da125cbbe6e4bb475b21b1da66)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 0d5237022a..84b3405bb9 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -886,20 +886,16 @@ sub Parse($$$$$)
 #include <Python.h>
 #include \"librpc/rpc/dcerpc.h\"
 #include \"scripting/python/pytalloc.h\"
+#include \"scripting/python/pyrpc.h\"
 #include \"$hdr\"
 #include \"$ndr_hdr\"
 #include \"$py_hdr\"
 
-#define PY_CHECK_TYPE(type, var, fail) \\
-	if (!type ## _Check(var)) {\\
-		PyErr_Format(PyExc_TypeError, \"Expected type %s\", type ## _Type.tp_name); \\
-		fail; \\
-	}
 ");
 
 	foreach my $x (@$ndr) {
-	    ($x->{TYPE} eq "INTERFACE") && $self->Interface($x, $basename);
 		($x->{TYPE} eq "IMPORT") && $self->Import(@{$x->{PATHS}});
+	    ($x->{TYPE} eq "INTERFACE") && $self->Interface($x, $basename);
 	}
 	
 	$self->pidl("static PyMethodDef $basename\_methods[] = {");
-- 
cgit 


From 994e43e9ebd3922f2c3378edf0e73e912815230a Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 14 Jan 2008 18:01:54 +0100
Subject: python: Don't try to free const pointers. (This used to be commit
 b4754f4683e67a940f18a88e45c0878259f45b97)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 84b3405bb9..73442be59d 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -203,7 +203,11 @@ sub PythonStruct($$$$)
 			$self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {");
 			my $varname = "object->$e->{NAME}";
 			$self->indent;
-			if ($e->{ORIGINAL}->{POINTERS} > 0) {
+			my $l = $e->{LEVELS}[0];
+			my $nl = GetNextLevel($e, $l);
+			if ($l->{TYPE} eq "POINTER" and 
+				not ($nl->{TYPE} eq "ARRAY" and ($nl->{IS_FIXED} or is_charset_array($e, $nl))) and
+				not ($nl->{TYPE} eq "SCALAR" and $nl->{TYPE} eq "string")) {
 				$self->pidl("talloc_free($varname);");
 			}
 			$self->ConvertObjectFromPython($env, $mem_ctx, $e, "value", $varname, "return -1;");
-- 
cgit 


From 134e38ac28b30b7fb3f4efcf9985c17ff2f070ad Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 14 Jan 2008 18:24:10 +0100
Subject: python: Fix some corner cases handling scalars. (This used to be
 commit b662c98a9ad461a33a27a918c0d544a96433e48c)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 73442be59d..8ff909a455 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -207,7 +207,7 @@ sub PythonStruct($$$$)
 			my $nl = GetNextLevel($e, $l);
 			if ($l->{TYPE} eq "POINTER" and 
 				not ($nl->{TYPE} eq "ARRAY" and ($nl->{IS_FIXED} or is_charset_array($e, $nl))) and
-				not ($nl->{TYPE} eq "SCALAR" and $nl->{TYPE} eq "string")) {
+				not ($nl->{TYPE} eq "DATA" and Parse::Pidl::Typelist::scalar_is_reference($nl->{DATA_TYPE}))) {
 				$self->pidl("talloc_free($varname);");
 			}
 			$self->ConvertObjectFromPython($env, $mem_ctx, $e, "value", $varname, "return -1;");
@@ -668,8 +668,13 @@ sub ConvertObjectFromPythonData($$$$$$)
 sub ConvertObjectFromPythonLevel($$$$$$$$)
 {
 	my ($self, $env, $mem_ctx, $py_var, $e, $l, $var_name, $fail) = @_;
+	my $nl = GetNextLevel($e, $l);
 
 	if ($l->{TYPE} eq "POINTER") {
+		if ($nl->{TYPE} eq "DATA" and Parse::Pidl::Typelist::scalar_is_reference($nl->{DATA_TYPE})) {
+			$self->ConvertObjectFromPythonLevel($env, $mem_ctx, $py_var, $e, $nl, $var_name, $fail);
+			return;
+		}
 		if ($l->{POINTER_TYPE} ne "ref") {
 			$self->pidl("if ($py_var == Py_None) {");
 			$self->indent;
@@ -679,7 +684,7 @@ sub ConvertObjectFromPythonLevel($$$$$$$$)
 			$self->indent;
 		}
 		$self->pidl("$var_name = talloc_ptrtype($mem_ctx, $var_name);");
-		$self->ConvertObjectFromPythonLevel($env, $mem_ctx, $py_var, $e, GetNextLevel($e, $l), get_value_of($var_name), $fail);
+		$self->ConvertObjectFromPythonLevel($env, $mem_ctx, $py_var, $e, $nl, get_value_of($var_name), $fail);
 		if ($l->{POINTER_TYPE} ne "ref") {
 			$self->deindent;
 			$self->pidl("}");
@@ -802,8 +807,13 @@ sub ConvertObjectToPythonData($$$$$)
 sub ConvertObjectToPythonLevel($$$$$)
 {
 	my ($self, $mem_ctx, $env, $e, $l, $var_name, $py_var) = @_;
+	my $nl = GetNextLevel($e, $l);
 
 	if ($l->{TYPE} eq "POINTER") {
+		if ($nl->{TYPE} eq "DATA" and Parse::Pidl::Typelist::scalar_is_reference($nl->{DATA_TYPE})) {
+			$self->ConvertObjectToPythonLevel($var_name, $env, $e, $nl, $var_name, $py_var);
+			return;
+		}
 		if ($l->{POINTER_TYPE} ne "ref") {
 			$self->pidl("if ($var_name == NULL) {");
 			$self->indent;
@@ -812,7 +822,7 @@ sub ConvertObjectToPythonLevel($$$$$)
 			$self->pidl("} else {");
 			$self->indent;
 		}
-		$self->ConvertObjectToPythonLevel($var_name, $env, $e, GetNextLevel($e, $l), get_value_of($var_name), $py_var);
+		$self->ConvertObjectToPythonLevel($var_name, $env, $e, $nl, get_value_of($var_name), $py_var);
 		if ($l->{POINTER_TYPE} ne "ref") {
 			$self->deindent;
 			$self->pidl("}");
-- 
cgit 


From d28eb21a984a733e8f1de51170e41ae7c879f7e9 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 14 Jan 2008 18:59:11 +0100
Subject: python: Compile security module, handle uint. (This used to be commit
 dee64344fb13aaed38a550ebb4048d0fa526d5b6)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 6 +++---
 source4/pidl/lib/Parse/Pidl/Typelist.pm      | 1 +
 2 files changed, 4 insertions(+), 3 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 8ff909a455..31b06d16b8 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -612,7 +612,7 @@ sub ConvertObjectFromPythonData($$$$$$)
 
 	if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or 
 		$actual_ctype->{TYPE} eq "SCALAR" and (
-		expandAlias($actual_ctype->{NAME}) =~ /^(u?int[0-9]+|hyper|NTTIME|time_t|NTTIME_hyper|NTTIME_1sec|dlong|udlong|udlongr)$/)) {
+		expandAlias($actual_ctype->{NAME}) =~ /^(u?int[0-9]*|hyper|NTTIME|time_t|NTTIME_hyper|NTTIME_1sec|dlong|udlong|udlongr)$/)) {
 		$self->pidl("PY_CHECK_TYPE(PyInt, $cvar, $fail);");
 		$self->pidl("$target = PyInt_AsLong($cvar);");
 		return;
@@ -748,7 +748,7 @@ sub ConvertScalarToPython($$$)
 
 	$ctypename = expandAlias($ctypename);
 
-	if ($ctypename =~ /^(int|long|char|u?int[0-9]+|hyper|dlong|udlong|udlongr|time_t|NTTIME_hyper|NTTIME|NTTIME_1sec)$/) {
+	if ($ctypename =~ /^(char|u?int[0-9]*|hyper|dlong|udlong|udlongr|time_t|NTTIME_hyper|NTTIME|NTTIME_1sec)$/) {
 		return "PyInt_FromLong($cvar)";
 	}
 
@@ -938,7 +938,7 @@ sub Parse($$$$$)
 		} elsif ($cvar =~ /^".*"$/) {
 			$py_obj = "PyString_FromString($cvar)";
 		} else {
-			$py_obj = $self->ConvertObjectToPythonData("NULL", $ctype, $cvar);
+			$py_obj = $self->ConvertObjectToPythonData("NULL", expandAlias($ctype), $cvar);
 		}
 
 		$self->pidl("PyModule_AddObject(m, \"$name\", $py_obj);");
diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm
index 9e6c683f82..8ba1ae47af 100644
--- a/source4/pidl/lib/Parse/Pidl/Typelist.pm
+++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm
@@ -59,6 +59,7 @@ my %aliases = (
 	"boolean8" => "uint8",
 	"boolean32" => "uint32",
 	"DWORD" => "uint32",
+	"uint" => "uint32",
 	"int" => "int32",
 	"WORD" => "uint16",
 	"char" => "uint8",
-- 
cgit 


From 1530d7c3b0d02a2b75c1ee393209f69473f3c4af Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 14 Jan 2008 20:09:18 +0100
Subject: python: Fix handling of pointer-less strings in function arguments.
 (This used to be commit cb2700094fc1fc3887d5254e5d42e035deefa5b9)

---
 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'source4/pidl/lib')

diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 31b06d16b8..2475925377 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -642,12 +642,12 @@ sub ConvertObjectFromPythonData($$$$$$)
 
 
 	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "NTSTATUS") {
-		$self->pidl("$target = PyInt_AsLong($cvar);");
+		$self->pidl("$target = NT_STATUS(PyInt_AsLong($cvar));");
 		return;
 	}
 
 	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "WERROR") {
-		$self->pidl("$target = PyInt_AsLong($cvar);");
+		$self->pidl("$target = W_ERROR(PyInt_AsLong($cvar));");
 		return;
 	}
 
@@ -690,16 +690,16 @@ sub ConvertObjectFromPythonLevel($$$$$$$$)
 			$self->pidl("}");
 		}
 	} elsif ($l->{TYPE} eq "ARRAY") {
+		my $pl = GetPrevLevel($e, $l);
+		if ($pl && $pl->{TYPE} eq "POINTER") {
+			$var_name = get_pointer_to($var_name);
+		}
+
 		if (is_charset_array($e, $l)) {
 			$self->pidl("PY_CHECK_TYPE(PyUnicode, $py_var, $fail);");
 			# FIXME: Use Unix charset setting rather than utf-8
-			$self->pidl(get_pointer_to($var_name) . " = PyString_AsString(PyUnicode_AsEncodedString($py_var, \"utf-8\", \"ignore\"));");
+			$self->pidl($var_name . " = PyString_AsString(PyUnicode_AsEncodedString($py_var, \"utf-8\", \"ignore\"));");
 		} else {
-			my $pl = GetPrevLevel($e, $l);
-			if ($pl && $pl->{TYPE} eq "POINTER") {
-				$var_name = get_pointer_to($var_name);
-			}
-
 			my $counter = "$e->{NAME}_cntr_$l->{LEVEL_INDEX}";
 			$self->pidl("PY_CHECK_TYPE(PyList, $py_var, $fail);");
 			$self->pidl("{");
-- 
cgit