use Parse::Pidl qw(warning fatal error);
use Parse::Pidl::Typelist qw(hasType resolveType getType mapTypeName expandAlias bitmap_type_fn enum_type_fn);
use Parse::Pidl::Util qw(has_property ParseExpr unmake_str);
-use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred ContainsPipe is_charset_array);
+use Parse::Pidl::NDR qw(ReturnTypeElement GetPrevLevel GetNextLevel ContainsDeferred ContainsPipe is_charset_array);
use Parse::Pidl::CUtil qw(get_value_of get_pointer_to);
use Parse::Pidl::Samba4 qw(ArrayDynamicallyAllocated);
use Parse::Pidl::Samba4::Header qw(GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv);
my ($class) = @_;
my $self = { res => "", res_hdr => "", tabs => "",
constants => [], constants_uniq => {},
- module_methods => [], module_objects => [], ready_types => [],
+ module_methods => [],
+ module_objects => [], module_objects_uniq => {},
+ ready_types => [],
module_imports => [], module_imports_uniq => {},
type_imports => [], type_imports_uniq => {},
patch_type_calls => [], prereadycode => [],
$self->pidl("return ret;");
}
+sub PythonElementGetSet($$$$$$) {
+ my ($self, $name, $cname, $ename, $e, $env) = @_;
+
+ my $varname = "object->$ename";
+ $self->pidl("static PyObject *py_$name\_get_$e->{NAME}(PyObject *obj, void *closure)");
+ $self->pidl("{");
+ $self->indent;
+ $self->pidl("$cname *object = ($cname *)pytalloc_get_ptr(obj);");
+ $self->pidl("PyObject *py_$e->{NAME};");
+ $self->ConvertObjectToPython("pytalloc_get_mem_ctx(obj)", $env, $e, $varname, "py_$e->{NAME}", "return NULL;");
+ $self->pidl("return py_$e->{NAME};");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+
+ $self->pidl("static int py_$name\_set_$e->{NAME}(PyObject *py_obj, PyObject *value, void *closure)");
+ $self->pidl("{");
+ $self->indent;
+ $self->pidl("$cname *object = ($cname *)pytalloc_get_ptr(py_obj);");
+ my $mem_ctx = "pytalloc_get_mem_ctx(py_obj)";
+ 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 "DATA" and Parse::Pidl::Typelist::scalar_is_reference($nl->{DATA_TYPE}))) {
+ $self->pidl("talloc_unlink($mem_ctx, discard_const($varname));");
+ }
+ $self->ConvertObjectFromPython($env, $mem_ctx, $e, "value", $varname, "return -1;");
+ $self->pidl("return 0;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+}
+
sub PythonStruct($$$$$$)
{
my ($self, $modulename, $prettyname, $name, $cname, $d) = @_;
if ($#{$d->{ELEMENTS}} > -1) {
foreach my $e (@{$d->{ELEMENTS}}) {
- my $varname = "object->$e->{NAME}";
- $self->pidl("static PyObject *py_$name\_get_$e->{NAME}(PyObject *obj, void *closure)");
- $self->pidl("{");
- $self->indent;
- $self->pidl("$cname *object = ($cname *)pytalloc_get_ptr(obj);");
- $self->pidl("PyObject *py_$e->{NAME};");
- $self->ConvertObjectToPython("pytalloc_get_mem_ctx(obj)", $env, $e, $varname, "py_$e->{NAME}", "return NULL;");
- $self->pidl("return py_$e->{NAME};");
- $self->deindent;
- $self->pidl("}");
- $self->pidl("");
-
- $self->pidl("static int py_$name\_set_$e->{NAME}(PyObject *py_obj, PyObject *value, void *closure)");
- $self->pidl("{");
- $self->indent;
- $self->pidl("$cname *object = ($cname *)pytalloc_get_ptr(py_obj);");
- my $mem_ctx = "pytalloc_get_mem_ctx(py_obj)";
- 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 "DATA" and Parse::Pidl::Typelist::scalar_is_reference($nl->{DATA_TYPE}))) {
- $self->pidl("talloc_unlink($mem_ctx, discard_const($varname));");
- }
- $self->ConvertObjectFromPython($env, $mem_ctx, $e, "value", $varname, "return -1;");
- $self->pidl("return 0;");
- $self->deindent;
- $self->pidl("}");
- $self->pidl("");
+ $self->PythonElementGetSet($name, $cname, $e->{NAME}, $e, $env);
}
$getsetters = "py_$name\_getsetters";
$self->pidl("static PyGetSetDef ".$getsetters."[] = {");
$self->indent;
foreach my $e (@{$d->{ELEMENTS}}) {
+ my $etype = "";
+ if (ref($e->{TYPE}) eq "HASH") {
+ $etype = $e->{TYPE}->{NAME};
+ } else {
+ $etype = $e->{TYPE};
+ }
$self->pidl("{");
$self->indent;
$self->pidl(".name = discard_const_p(char, \"$e->{NAME}\"),");
$self->pidl(".get = py_$name\_get_$e->{NAME},");
$self->pidl(".set = py_$name\_set_$e->{NAME},");
- $self->pidl(".doc = discard_const_p(char, \"PIDL-generated element $e->{NAME}\")");
+ $self->pidl(".doc = discard_const_p(char, \"PIDL-generated element of base type $etype\")");
$self->deindent;
$self->pidl("},");
}
# If the struct is not public there ndr_pull/ndr_push functions will
# be static so not callable from here
if (has_property($d, "public")) {
- $self->pidl("static PyObject *py_$name\_ndr_pack(PyObject *py_obj)");
+ $self->pidl("static PyObject *py_$name\_ndr_pack(PyObject *py_obj, PyObject *Py_UNUSED(ignored))");
$self->pidl("{");
$self->indent;
$self->pidl("$cname *object = ($cname *)pytalloc_get_ptr(py_obj);");
$self->deindent;
$self->pidl("}");
$self->pidl("err = ndr_push_struct_blob(&blob, tmp_ctx, object, (ndr_push_flags_fn_t)ndr_push_$name);");
- $self->pidl("if (err != NDR_ERR_SUCCESS) {");
+ $self->pidl("if (!NDR_ERR_CODE_IS_SUCCESS(err)) {");
$self->indent;
$self->pidl("TALLOC_FREE(tmp_ctx);");
$self->pidl("PyErr_SetNdrError(err);");
$self->deindent;
$self->pidl("}");
$self->pidl("");
- $self->pidl("ret = PyString_FromStringAndSize((char *)blob.data, blob.length);");
+ $self->pidl("ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);");
$self->pidl("TALLOC_FREE(tmp_ctx);");
$self->pidl("return ret;");
$self->deindent;
$self->pidl("{");
$self->indent;
$self->pidl("$cname *object = ($cname *)pytalloc_get_ptr(py_obj);");
- $self->pidl("DATA_BLOB blob;");
+ $self->pidl("DATA_BLOB blob = {.data = NULL, .length = 0};");
$self->pidl("Py_ssize_t blob_length = 0;");
$self->pidl("enum ndr_err_code err;");
$self->pidl("const char * const kwnames[] = { \"data_blob\", \"allow_remaining\", NULL };");
$self->pidl("PyObject *allow_remaining_obj = NULL;");
$self->pidl("bool allow_remaining = false;");
$self->pidl("");
- $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"s#|O:__ndr_unpack__\",");
+ $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN \"|O:__ndr_unpack__\",");
$self->indent;
$self->pidl("discard_const_p(char *, kwnames),");
$self->pidl("&blob.data, &blob_length,");
$self->pidl("err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_$name);");
$self->deindent;
$self->pidl("}");
- $self->pidl("if (err != NDR_ERR_SUCCESS) {");
+ $self->pidl("if (!NDR_ERR_CODE_IS_SUCCESS(err)) {");
$self->indent;
$self->pidl("PyErr_SetNdrError(err);");
$self->pidl("return NULL;");
$self->pidl("}");
$self->pidl("");
- $self->pidl("static PyObject *py_$name\_ndr_print(PyObject *py_obj)");
+ $self->pidl("static PyObject *py_$name\_ndr_print(PyObject *py_obj, PyObject *Py_UNUSED(ignored))");
$self->pidl("{");
$self->indent;
$self->pidl("$cname *object = ($cname *)pytalloc_get_ptr(py_obj);");
$self->pidl("char *retstr;");
$self->pidl("");
$self->pidl("retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_$name, \"$name\", object);");
- $self->pidl("ret = PyString_FromString(retstr);");
+ $self->pidl("ret = PyStr_FromString(retstr);");
$self->pidl("talloc_free(retstr);");
$self->pidl("");
$self->pidl("return ret;");
$self->pidl("static PyMethodDef $py_methods\[] = {");
$self->indent;
$self->pidl("{ \"__ndr_pack__\", (PyCFunction)py_$name\_ndr_pack, METH_NOARGS, \"S.ndr_pack(object) -> blob\\nNDR pack\" },");
- $self->pidl("{ \"__ndr_unpack__\", (PyCFunction)py_$name\_ndr_unpack, METH_VARARGS|METH_KEYWORDS, \"S.ndr_unpack(class, blob, allow_remaining=False) -> None\\nNDR unpack\" },");
- $self->pidl("{ \"__ndr_print__\", (PyCFunction)py_$name\_ndr_print, METH_VARARGS, \"S.ndr_print(object) -> None\\nNDR print\" },");
+ $self->pidl("{ \"__ndr_unpack__\", PY_DISCARD_FUNC_SIG(PyCFunction,py_$name\_ndr_unpack), METH_VARARGS|METH_KEYWORDS, \"S.ndr_unpack(class, blob, allow_remaining=False) -> None\\nNDR unpack\" },");
+ $self->pidl("{ \"__ndr_print__\", (PyCFunction)py_$name\_ndr_print, METH_NOARGS, \"S.ndr_print(object) -> None\\nNDR print\" },");
$self->pidl("{ NULL, NULL, 0, NULL }");
$self->deindent;
$self->pidl("};");
my $typeobject = "$name\_Type";
$self->pidl("static PyTypeObject $typeobject = {");
$self->indent;
- $self->pidl("PyObject_HEAD_INIT(NULL) 0,");
+ $self->pidl("PyVarObject_HEAD_INIT(NULL, 0)");
+ $self->pidl(".tp_name = \"$modulename.$prettyname\",");
+ $self->pidl(".tp_getset = $getsetters,");
+ if ($docstring) {
+ $self->pidl(".tp_doc = $docstring,");
+ }
+ $self->pidl(".tp_methods = $py_methods,");
+ $self->pidl(".tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,");
+ $self->pidl(".tp_new = py_$name\_new,");
+ $self->deindent;
+ $self->pidl("};");
+
+ $self->pidl("");
+
+ my $talloc_typename = $self->import_type_variable("talloc", "BaseObject");
+ $self->register_module_prereadycode(["$name\_Type.tp_base = $talloc_typename;",
+ "$name\_Type.tp_basicsize = pytalloc_BaseObject_size();",
+ ""]);
+
+ return "&$typeobject";
+}
+
+sub PythonFunctionStruct($$$$)
+{
+ my ($self, $modulename, $fn, $iface, $prettyname) = @_;
+
+ my $inenv = GenerateFunctionInEnv($fn, "object->");
+ my $outenv = GenerateFunctionOutEnv($fn, "object->");
+
+ my $name = "$fn->{NAME}";
+ my $cname = "struct $name";
+
+ $self->pidl("");
+
+ my $getsetters = "NULL";
+
+ foreach my $e (@{$fn->{ELEMENTS}}) {
+ if (grep(/in/,@{$e->{DIRECTION}})) {
+ my $inname = "$name\_in";
+ my $ename = "in.$e->{NAME}";
+ $self->PythonElementGetSet($inname, $cname, $ename, $e, $inenv);
+ }
+ if (grep(/out/,@{$e->{DIRECTION}})) {
+ my $outname = "$name\_out";
+ my $ename = "out.$e->{NAME}";
+ $self->PythonElementGetSet($outname, $cname, $ename, $e, $outenv);
+ }
+ }
+
+ if (defined($fn->{RETURN_TYPE})) {
+ my $e = ReturnTypeElement($fn);
+ my $ename = "out.result";
+ $self->PythonElementGetSet($name, $cname, $ename, $e, $outenv);
+ }
+
+ $getsetters = "py_$name\_getsetters";
+ $self->pidl("static PyGetSetDef ".$getsetters."[] = {");
+ $self->indent;
+ foreach my $e (@{$fn->{ELEMENTS}}) {
+ if (grep(/in/,@{$e->{DIRECTION}})) {
+ $self->pidl("{");
+ $self->indent;
+ $self->pidl(".name = discard_const_p(char, \"in_$e->{NAME}\"),");
+ $self->pidl(".get = py_$name\_in_get_$e->{NAME},");
+ $self->pidl(".set = py_$name\_in_set_$e->{NAME},");
+ $self->pidl(".doc = discard_const_p(char, \"PIDL-generated element of base type $e->{TYPE}\")");
+ $self->deindent;
+ $self->pidl("},");
+ }
+ if (grep(/out/,@{$e->{DIRECTION}})) {
+ $self->pidl("{");
+ $self->indent;
+ $self->pidl(".name = discard_const_p(char, \"out_$e->{NAME}\"),");
+ $self->pidl(".get = py_$name\_out_get_$e->{NAME},");
+ $self->pidl(".set = py_$name\_out_set_$e->{NAME},");
+ $self->pidl(".doc = discard_const_p(char, \"PIDL-generated element of base type $e->{TYPE}\")");
+ $self->deindent;
+ $self->pidl("},");
+ }
+ }
+ if (defined($fn->{RETURN_TYPE})) {
+ $self->pidl("{");
+ $self->indent;
+ $self->pidl(".name = discard_const_p(char, \"result\"),");
+ $self->pidl(".get = py_$name\_get_result,");
+ $self->pidl(".set = py_$name\_set_result,");
+ $self->pidl(".doc = discard_const_p(char, \"PIDL-generated element of type $fn->{RETURN_TYPE}\")");
+ $self->deindent;
+ $self->pidl("},");
+ }
+ $self->pidl("{ .name = NULL }");
+ $self->deindent;
+ $self->pidl("};");
+ $self->pidl("");
+
+ $self->pidl("static PyObject *py_$name\_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)");
+ $self->pidl("{");
+ $self->indent;
+ $self->pidl("return pytalloc_new($cname, type);");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+
+ my $py_methods = "NULL";
+
+ my $ndr_call = "const struct ndr_interface_call *call = NULL;";
+ my $object_ptr = "$cname *object = ($cname *)pytalloc_get_ptr(py_obj);";
+
+ $self->pidl("static PyObject *py_$name\_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))");
+ $self->pidl("{");
+ $self->indent;
+ $self->pidl("");
+ $self->pidl("");
+ $self->pidl("return PyInt_FromLong($fn->{OPNUM});");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+
+ $self->pidl("static PyObject *py_$name\_ndr_pack(PyObject *py_obj, int ndr_inout_flags, uint32_t ndr_push_flags)");
+ $self->pidl("{");
+ $self->indent;
+ $self->pidl("$ndr_call");
+ $self->pidl("$object_ptr");
+ $self->pidl("PyObject *ret = NULL;");
+ $self->pidl("struct ndr_push *push = NULL;");
+ $self->pidl("DATA_BLOB blob;");
+ $self->pidl("enum ndr_err_code err;");
+ $self->pidl("");
+ $self->pidl("if (ndr_table_$iface\.num_calls < " . ($fn->{OPNUM}+1) .
+ ") {");
+ $self->indent;
+ $self->pidl("PyErr_SetString(PyExc_TypeError, \"Internal Error, ndr_interface_call missing for py_$name\_ndr_pack\");");
+ $self->pidl("return NULL;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("call = &ndr_table_$iface\.calls[$fn->{OPNUM}];");
+ $self->pidl("");
+ $self->pidl("push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));");
+ $self->pidl("if (push == NULL) {");
+ $self->indent;
+ $self->pidl("PyErr_SetNdrError(NDR_ERR_ALLOC);");
+ $self->pidl("return NULL;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+ $self->pidl("push->flags |= ndr_push_flags;");
+ $self->pidl("");
+ $self->pidl("err = call->ndr_push(push, ndr_inout_flags, object);");
+ $self->pidl("if (!NDR_ERR_CODE_IS_SUCCESS(err)) {");
+ $self->indent;
+ $self->pidl("TALLOC_FREE(push);");
+ $self->pidl("PyErr_SetNdrError(err);");
+ $self->pidl("return NULL;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("blob = ndr_push_blob(push);");
+ $self->pidl("ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);");
+ $self->pidl("TALLOC_FREE(push);");
+ $self->pidl("return ret;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+
+ $self->pidl("static PyObject *py_$name\_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)");
+ $self->pidl("{");
+ $self->indent;
+ $self->pidl("const char * const kwnames[] = { \"bigendian\", \"ndr64\", NULL };");
+ $self->pidl("PyObject *bigendian_obj = NULL;");
+ $self->pidl("PyObject *ndr64_obj = NULL;");
+ $self->pidl("uint32_t ndr_push_flags = 0;");
+ $self->pidl("");
+ $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"|OO:__ndr_pack_in__\",");
+ $self->indent;
+ $self->pidl("discard_const_p(char *, kwnames),");
+ $self->pidl("&bigendian_obj,");
+ $self->pidl("&ndr64_obj)) {");
+ $self->deindent;
+ $self->indent;
+ $self->pidl("return NULL;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+ $self->pidl("if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {");
+ $self->indent;
+ $self->pidl("ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {");
+ $self->indent;
+ $self->pidl("ndr_push_flags |= LIBNDR_FLAG_NDR64;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+ $self->pidl("return py_$name\_ndr_pack(py_obj, NDR_IN, ndr_push_flags);");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+
+ $self->pidl("static PyObject *py_$name\_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)");
+ $self->pidl("{");
+ $self->indent;
+ $self->pidl("const char * const kwnames[] = { \"bigendian\", \"ndr64\", NULL };");
+ $self->pidl("PyObject *bigendian_obj = NULL;");
+ $self->pidl("PyObject *ndr64_obj = NULL;");
+ $self->pidl("uint32_t ndr_push_flags = 0;");
+ $self->pidl("");
+ $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"|OO:__ndr_pack_out__\",");
+ $self->indent;
+ $self->pidl("discard_const_p(char *, kwnames),");
+ $self->pidl("&bigendian_obj,");
+ $self->pidl("&ndr64_obj)) {");
+ $self->deindent;
+ $self->indent;
+ $self->pidl("return NULL;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+ $self->pidl("if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {");
+ $self->indent;
+ $self->pidl("ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {");
+ $self->indent;
+ $self->pidl("ndr_push_flags |= LIBNDR_FLAG_NDR64;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+ $self->pidl("return py_$name\_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+
+ $self->pidl("static PyObject *py_$name\_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, int ndr_inout_flags, uint32_t ndr_pull_flags, bool allow_remaining)");
+ $self->pidl("{");
+ $self->indent;
+ $self->pidl("$ndr_call");
+ $self->pidl("$object_ptr");
+ $self->pidl("struct ndr_pull *pull = NULL;");
+ $self->pidl("enum ndr_err_code err;");
+ $self->pidl("");
+ $self->pidl("if (ndr_table_$iface\.num_calls < " . ($fn->{OPNUM}+1) .
+ ") {");
+ $self->indent;
+ $self->pidl("PyErr_SetString(PyExc_TypeError, \"Internal Error, ndr_interface_call missing for py_$name\_ndr_unpack\");");
+ $self->pidl("return NULL;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("call = &ndr_table_$iface\.calls[$fn->{OPNUM}];");
+ $self->pidl("");
+ $self->pidl("pull = ndr_pull_init_blob(blob, object);");
+ $self->pidl("if (pull == NULL) {");
+ $self->indent;
+ $self->pidl("PyErr_SetNdrError(NDR_ERR_ALLOC);");
+ $self->pidl("return NULL;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+ $self->pidl("pull->flags |= ndr_pull_flags;");
+ $self->pidl("");
+ $self->pidl("err = call->ndr_pull(pull, ndr_inout_flags, object);");
+ $self->pidl("if (!NDR_ERR_CODE_IS_SUCCESS(err)) {");
+ $self->indent;
+ $self->pidl("TALLOC_FREE(pull);");
+ $self->pidl("PyErr_SetNdrError(err);");
+ $self->pidl("return NULL;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("if (!allow_remaining) {");
+ $self->indent;
+ $self->pidl("uint32_t highest_ofs;");
+ $self->pidl("");
+ $self->pidl("if (pull->offset > pull->relative_highest_offset) {");
+ $self->indent;
+ $self->pidl("highest_ofs = pull->offset;");
+ $self->deindent;
+ $self->pidl("} else {");
+ $self->indent;
+ $self->pidl("highest_ofs = pull->relative_highest_offset;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("if (highest_ofs < pull->data_size) {");
+ $self->indent;
+ $self->pidl("err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,");
+ $self->indent;
+ $self->pidl("\"not all bytes consumed ofs[%u] size[%u]\",");
+ $self->pidl("highest_ofs, pull->data_size);");
+ $self->deindent;
+ $self->pidl("TALLOC_FREE(pull);");
+ $self->pidl("PyErr_SetNdrError(err);");
+ $self->pidl("return NULL;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+ $self->pidl("TALLOC_FREE(pull);");
+ $self->pidl("Py_RETURN_NONE;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+
+ $self->pidl("static PyObject *py_$name\_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)");
+ $self->pidl("{");
+ $self->indent;
+ $self->pidl("DATA_BLOB blob;");
+ $self->pidl("Py_ssize_t blob_length = 0;");
+ $self->pidl("const char * const kwnames[] = { \"data_blob\", \"bigendian\", \"ndr64\", \"allow_remaining\", NULL };");
+ $self->pidl("PyObject *bigendian_obj = NULL;");
+ $self->pidl("PyObject *ndr64_obj = NULL;");
+ $self->pidl("uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;");
+ $self->pidl("PyObject *allow_remaining_obj = NULL;");
+ $self->pidl("bool allow_remaining = false;");
+ $self->pidl("");
+ $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN \"|OOO:__ndr_unpack_in__\",");
+ $self->indent;
+ $self->pidl("discard_const_p(char *, kwnames),");
+ $self->pidl("&blob.data, &blob_length,");
+ $self->pidl("&bigendian_obj,");
+ $self->pidl("&ndr64_obj,");
+ $self->pidl("&allow_remaining_obj)) {");
+ $self->deindent;
+ $self->indent;
+ $self->pidl("return NULL;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("blob.length = blob_length;");
+ $self->pidl("");
+ $self->pidl("if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {");
+ $self->indent;
+ $self->pidl("ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {");
+ $self->indent;
+ $self->pidl("ndr_pull_flags |= LIBNDR_FLAG_NDR64;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+ $self->pidl("if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {");
+ $self->indent;
+ $self->pidl("allow_remaining = true;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+ $self->pidl("return py_$name\_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+
+ $self->pidl("static PyObject *py_$name\_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)");
+ $self->pidl("{");
+ $self->indent;
+ $self->pidl("DATA_BLOB blob;");
+ $self->pidl("Py_ssize_t blob_length = 0;");
+ $self->pidl("const char * const kwnames[] = { \"data_blob\", \"bigendian\", \"ndr64\", \"allow_remaining\", NULL };");
+ $self->pidl("PyObject *bigendian_obj = NULL;");
+ $self->pidl("PyObject *ndr64_obj = NULL;");
+ $self->pidl("uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;");
+ $self->pidl("PyObject *allow_remaining_obj = NULL;");
+ $self->pidl("bool allow_remaining = false;");
+ $self->pidl("");
+ $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN \"|OOO:__ndr_unpack_out__\",");
+ $self->indent;
+ $self->pidl("discard_const_p(char *, kwnames),");
+ $self->pidl("&blob.data, &blob_length,");
+ $self->pidl("&bigendian_obj,");
+ $self->pidl("&ndr64_obj,");
+ $self->pidl("&allow_remaining_obj)) {");
+ $self->deindent;
+ $self->indent;
+ $self->pidl("return NULL;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("blob.length = blob_length;");
+ $self->pidl("");
+ $self->pidl("if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {");
+ $self->indent;
+ $self->pidl("ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {");
+ $self->indent;
+ $self->pidl("ndr_pull_flags |= LIBNDR_FLAG_NDR64;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+ $self->pidl("if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {");
+ $self->indent;
+ $self->pidl("allow_remaining = true;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+ $self->pidl("return py_$name\_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+
+ $self->pidl("static PyObject *py_$name\_ndr_print(PyObject *py_obj, const char *name, int ndr_inout_flags)");
+ $self->pidl("{");
+ $self->indent;
+ $self->pidl("$ndr_call");
+ $self->pidl("$object_ptr");
+ $self->pidl("PyObject *ret;");
+ $self->pidl("char *retstr;");
+ $self->pidl("");
+ $self->pidl("if (ndr_table_$iface\.num_calls < " . ($fn->{OPNUM}+1) .
+ ") {");
+ $self->indent;
+ $self->pidl("PyErr_SetString(PyExc_TypeError, \"Internal Error, ndr_interface_call missing for py_$name\_ndr_print\");");
+ $self->pidl("return NULL;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("call = &ndr_table_$iface\.calls[$fn->{OPNUM}];");
+ $self->pidl("");
+ $self->pidl("retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);");
+ $self->pidl("ret = PyStr_FromString(retstr);");
+ $self->pidl("TALLOC_FREE(retstr);");
+ $self->pidl("");
+ $self->pidl("return ret;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+
+ $self->pidl("static PyObject *py_$name\_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))");
+ $self->pidl("{");
+ $self->indent;
+ $self->pidl("return py_$name\_ndr_print(py_obj, \"$name\_in\", NDR_IN);");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+
+ $self->pidl("static PyObject *py_$name\_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))");
+ $self->pidl("{");
+ $self->indent;
+ $self->pidl("return py_$name\_ndr_print(py_obj, \"$name\_out\", NDR_OUT);");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+
+ $py_methods = "py_$name\_methods";
+ $self->pidl("static PyMethodDef $py_methods\[] = {");
+ $self->indent;
+ $self->pidl("{ \"opnum\", (PyCFunction)py_$name\_ndr_opnum, METH_NOARGS|METH_CLASS,");
+ $self->indent;
+ $self->pidl("\"$modulename.$prettyname.opnum() -> ".sprintf("%d (0x%02x)", $fn->{OPNUM}, $fn->{OPNUM})." \" },");
+ $self->deindent;
+ $self->pidl("{ \"__ndr_pack_in__\", PY_DISCARD_FUNC_SIG(PyCFunction,py_$name\_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,");
+ $self->indent;
+ $self->pidl("\"S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\\nNDR pack input\" },");
+ $self->deindent;
+ $self->pidl("{ \"__ndr_pack_out__\", PY_DISCARD_FUNC_SIG(PyCFunction,py_$name\_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,");
+ $self->indent;
+ $self->pidl("\"S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\\nNDR pack output\" },");
+ $self->deindent;
+ $self->pidl("{ \"__ndr_unpack_in__\", PY_DISCARD_FUNC_SIG(PyCFunction,py_$name\_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,");
+ $self->indent;
+ $self->pidl("\"S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\\nNDR unpack input\" },");
+ $self->deindent;
+ $self->pidl("{ \"__ndr_unpack_out__\", PY_DISCARD_FUNC_SIG(PyCFunction,py_$name\_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,");
+ $self->indent;
+ $self->pidl("\"S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\\nNDR unpack output\" },");
+ $self->deindent;
+ $self->pidl("{ \"__ndr_print_in__\", (PyCFunction)py_$name\_ndr_print_in, METH_NOARGS, \"S.ndr_print_in(object) -> None\\nNDR print input\" },");
+ $self->pidl("{ \"__ndr_print_out__\", (PyCFunction)py_$name\_ndr_print_out, METH_NOARGS, \"S.ndr_print_out(object) -> None\\nNDR print output\" },");
+ $self->pidl("{ NULL, NULL, 0, NULL }");
+ $self->deindent;
+ $self->pidl("};");
+ $self->pidl("");
+
+ $self->pidl_hdr("static PyTypeObject $name\_Type;\n");
+ $self->pidl("");
+ my $docstring = $self->DocString($fn, $name);
+ my $typeobject = "$name\_Type";
+ $self->pidl("static PyTypeObject $typeobject = {");
+ $self->indent;
+ $self->pidl("PyVarObject_HEAD_INIT(NULL, 0)");
$self->pidl(".tp_name = \"$modulename.$prettyname\",");
$self->pidl(".tp_getset = $getsetters,");
if ($docstring) {
my $val = "PyList_GET_SIZE($py_var)";
if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") {
$self->pidl("r->in.$e->{NAME} = talloc_ptrtype(r, r->in.$e->{NAME});");
+ $self->pidl("if (r->in.$e->{NAME} == NULL) {");
+ $self->indent;
+ $self->pidl("PyErr_NoMemory();");
+ $self->pidl($fail);
+ $self->deindent;
+ $self->pidl("}");
$self->pidl("*r->in.$e->{NAME} = $val;");
} else {
$self->pidl("r->in.$e->{NAME} = $val;");
$typeobject = $self->PythonStruct($modulename, $fn_name, $d->{NAME}, mapTypeName($d), $d->{DATA});
}
- $self->register_module_typeobject($fn_name, $typeobject);
+ $self->register_module_typeobject($fn_name, $typeobject, $d->{ORIGINAL});
}
if ($d->{TYPE} eq "ENUM" or $d->{TYPE} eq "BITMAP") {
}
if ($actual_ctype->{TYPE} eq "UNION" and defined($actual_ctype->{ELEMENTS})) {
- $self->pidl("PyObject *py_import_$d->{NAME}(TALLOC_CTX *mem_ctx, int level, " .mapTypeName($d) . " *in)");
- $self->pidl_hdr("PyObject *py_import_$d->{NAME}(TALLOC_CTX *mem_ctx, int level, " .mapTypeName($d) . " *in);\n");
+ my $prettyname = PrettifyTypeName($d->{NAME}, $basename);
+ my $typeobject = "$d->{NAME}\_Type";
+ my $docstring = $self->DocString($d, $d->{NAME});
+ my $cname = "union $d->{NAME}";
+
+ $self->pidl("static PyObject *py_import_$d->{NAME}(TALLOC_CTX *mem_ctx, int level, " .mapTypeName($d) . " *in)");
$self->pidl("{");
$self->indent;
$self->FromUnionToPythonFunction("mem_ctx", $actual_ctype, "level", "in") if ($actual_ctype->{TYPE} eq "UNION");
$self->pidl("}");
$self->pidl("");
- $self->pidl(mapTypeName($d) . " *py_export_$d->{NAME}(TALLOC_CTX *mem_ctx, int level, PyObject *in)");
- $self->pidl_hdr(mapTypeName($d) . " *py_export_$d->{NAME}(TALLOC_CTX *mem_ctx, int level, PyObject *in);\n");
+ $self->pidl("static ".mapTypeName($d) . " *py_export_$d->{NAME}(TALLOC_CTX *mem_ctx, int level, PyObject *in)");
$self->pidl("{");
$self->indent;
$self->FromPythonToUnionFunction($actual_ctype, mapTypeName($d), "level", "mem_ctx", "in") if ($actual_ctype->{TYPE} eq "UNION");
$self->deindent;
$self->pidl("}");
$self->pidl("");
+
+ my $getsetters = "NULL";
+ my $py_methods = "NULL";
+ my $typename = mapTypeName($d);
+
+ $self->pidl("static PyObject *py_$d->{NAME}\_import(PyTypeObject *type, PyObject *args, PyObject *kwargs)");
+ $self->pidl("{");
+ $self->indent;
+ $self->pidl("const char * const kwnames[] = { \"mem_ctx\", \"level\", \"in\", NULL };");
+ $self->pidl("PyObject *mem_ctx_obj = NULL;");
+ $self->pidl("TALLOC_CTX *mem_ctx = NULL;");
+ $self->pidl("int level = 0;");
+ $self->pidl("PyObject *in_obj = NULL;");
+ $self->pidl("$typename *in = NULL;");
+ $self->pidl("");
+ $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"OiO:import\",");
+ $self->indent;
+ $self->pidl("discard_const_p(char *, kwnames),");
+ $self->pidl("&mem_ctx_obj,");
+ $self->pidl("&level,");
+ $self->pidl("&in_obj)) {");
+ $self->deindent;
+ $self->indent;
+ $self->pidl("return NULL;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("mem_ctx = pytalloc_get_ptr(mem_ctx_obj);");
+ $self->pidl("if (mem_ctx == NULL) {");
+ $self->indent;
+ $self->pidl("PyErr_SetString(PyExc_TypeError, \"mem_ctx is NULL)!\");");
+ $self->pidl("return NULL;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("in = ($typename *)pytalloc_get_ptr(in_obj);");
+ $self->pidl("if (in == NULL) {");
+ $self->indent;
+ $self->pidl("PyErr_Format(PyExc_TypeError, \"in needs to be a pointer to $typename!\");");
+ $self->pidl("return NULL;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+ $self->pidl("return py_import_$d->{NAME}(mem_ctx, level, in);");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+
+ $self->pidl("static PyObject *py_$d->{NAME}\_export(PyTypeObject *type, PyObject *args, PyObject *kwargs)");
+ $self->pidl("{");
+ $self->indent;
+ $self->pidl("const char * const kwnames[] = { \"mem_ctx\", \"level\", \"in\", NULL };");
+ $self->pidl("PyObject *mem_ctx_obj = NULL;");
+ $self->pidl("TALLOC_CTX *mem_ctx = NULL;");
+ $self->pidl("int level = 0;");
+ $self->pidl("PyObject *in = NULL;");
+ $self->pidl("$typename *out = NULL;");
+ $self->pidl("");
+ $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"OiO:export\",");
+ $self->indent;
+ $self->pidl("discard_const_p(char *, kwnames),");
+ $self->pidl("&mem_ctx_obj,");
+ $self->pidl("&level,");
+ $self->pidl("&in)) {");
+ $self->deindent;
+ $self->indent;
+ $self->pidl("return NULL;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("mem_ctx = pytalloc_get_ptr(mem_ctx_obj);");
+ $self->pidl("if (mem_ctx == NULL) {");
+ $self->indent;
+ $self->pidl("PyErr_SetString(PyExc_TypeError, \"mem_ctx is NULL)!\");");
+ $self->pidl("return NULL;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+ $self->pidl("out = py_export_$d->{NAME}(mem_ctx, level, in);");
+ $self->pidl("if (out == NULL) {");
+ $self->indent;
+ $self->pidl("return NULL;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+ $self->pidl("return pytalloc_GenericObject_reference(out);");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+
+ $py_methods = "py_$d->{NAME}_methods";
+ $self->pidl("static PyMethodDef $py_methods\[] = {");
+ $self->indent;
+ $self->pidl("{ \"__import__\", PY_DISCARD_FUNC_SIG(PyCFunction,py_$d->{NAME}\_import),");
+ $self->indent;
+ $self->pidl("METH_VARARGS|METH_KEYWORDS|METH_CLASS,");
+ $self->pidl("\"T.__import__(mem_ctx, level, in) => ret.\" },");
+ $self->deindent;
+ $self->pidl("{ \"__export__\", PY_DISCARD_FUNC_SIG(PyCFunction,py_$d->{NAME}\_export),");
+ $self->indent;
+ $self->pidl("METH_VARARGS|METH_KEYWORDS|METH_CLASS,");
+ $self->pidl("\"T.__export__(mem_ctx, level, in) => ret.\" },");
+ $self->deindent;
+ $self->pidl("{ NULL, NULL, 0, NULL }");
+ $self->deindent;
+ $self->pidl("};");
+ $self->pidl("");
+
+ $self->pidl("static PyObject *py_$d->{NAME}\_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)");
+ $self->pidl("{");
+ $self->indent;
+ $self->pidl("PyErr_Format(PyExc_TypeError, \"New %s Objects are not supported\", type->tp_name);");
+ $self->pidl("return NULL;");
+ $self->deindent;
+ $self->pidl("}");
+ $self->pidl("");
+
+ $self->pidl("");
+ $self->pidl_hdr("static PyTypeObject $typeobject;\n");
+ $self->pidl("static PyTypeObject $typeobject = {");
+ $self->indent;
+ $self->pidl("PyVarObject_HEAD_INIT(NULL, 0)");
+ $self->pidl(".tp_name = \"$modulename.$prettyname\",");
+ $self->pidl(".tp_getset = $getsetters,");
+ if ($docstring) {
+ $self->pidl(".tp_doc = $docstring,");
+ }
+ $self->pidl(".tp_methods = $py_methods,");
+ $self->pidl(".tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,");
+ $self->pidl(".tp_new = py_$d->{NAME}\_new,");
+ $self->deindent;
+ $self->pidl("};");
+
+ $self->pidl("");
+
+ my $talloc_typename = $self->import_type_variable("talloc", "BaseObject");
+ $self->register_module_prereadycode(["$typeobject.tp_base = $talloc_typename;",
+ "$typeobject.tp_basicsize = pytalloc_BaseObject_size();",
+ ""]);
+
+ $self->register_module_typeobject($prettyname, "&$typeobject", $d->{ORIGINAL});
}
}
$prettyname =~ s/^$interface->{NAME}_//;
$prettyname =~ s/^$basename\_//;
+ my $typeobject = $self->PythonFunctionStruct($basename, $d, $interface->{NAME}, $prettyname);
+ $self->register_module_typeobject($prettyname, $typeobject, $d->{ORIGINAL});
+
my ($infn, $outfn, $fndocstring) = $self->PythonFunction($d, $interface->{NAME}, $prettyname);
push (@fns, [$infn, $outfn, "dcerpc_$d->{NAME}_r", $prettyname, $fndocstring, $d->{OPNUM}]);
$self->pidl("static PyTypeObject $if_typename = {");
$self->indent;
- $self->pidl("PyObject_HEAD_INIT(NULL) 0,");
+ $self->pidl("PyVarObject_HEAD_INIT(NULL, 0)");
$self->pidl(".tp_name = \"$basename.$interface->{NAME}\",");
$self->pidl(".tp_basicsize = sizeof(dcerpc_InterfaceObject),");
$self->pidl(".tp_doc = $docstring,");
$self->pidl("");
- $self->register_module_typeobject($interface->{NAME}, "&$if_typename");
+ $self->register_module_typeobject($interface->{NAME}, "&$if_typename", $interface->{ORIGINAL});
my $dcerpc_typename = $self->import_type_variable("samba.dcerpc.base", "ClientConnection");
$self->register_module_prereadycode(["$if_typename.tp_base = $dcerpc_typename;", ""]);
- $self->register_module_postreadycode(["if (!PyInterface_AddNdrRpcMethods(&$if_typename, py_ndr_$interface->{NAME}\_methods))", "\treturn;", ""]);
+ $self->register_module_postreadycode(["if (!PyInterface_AddNdrRpcMethods(&$if_typename, py_ndr_$interface->{NAME}\_methods))", "\treturn NULL;", ""]);
$self->pidl("static PyObject *syntax_$interface->{NAME}_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)");
$self->pidl("");
- my $signature = "\"abstract_syntax()\\n\"";
+ my $signature = "\"$interface->{NAME}_abstract_syntax()\\n\"";
my $docstring = $self->DocString($interface, $interface->{NAME}."_syntax");
$self->pidl("static PyTypeObject $syntax_typename = {");
$self->indent;
- $self->pidl("PyObject_HEAD_INIT(NULL) 0,");
- $self->pidl(".tp_name = \"$basename.$interface->{NAME}\",");
+ $self->pidl("PyVarObject_HEAD_INIT(NULL, 0)");
+ $self->pidl(".tp_name = \"$basename.$interface->{NAME}_abstract_syntax\",");
$self->pidl(".tp_doc = $docstring,");
$self->pidl(".tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,");
$self->pidl(".tp_new = syntax_$interface->{NAME}_new,");
$self->pidl("");
- $self->register_module_typeobject("abstract_syntax", "&$syntax_typename");
+ $self->register_module_typeobject("$interface->{NAME}_abstract_syntax", "&$syntax_typename", $interface->{ORIGINAL});
+ if (not defined($self->existing_module_object("abstract_syntax"))) {
+ # Only the first syntax gets registered with the legacy
+ # "abstract_syntax" name
+ $self->register_module_typeobject("abstract_syntax", "&$syntax_typename", $interface->{ORIGINAL});
+ }
my $ndr_typename = $self->import_type_variable("samba.dcerpc.misc", "ndr_syntax_id");
$self->register_module_prereadycode(["$syntax_typename.tp_base = $ndr_typename;",
"$syntax_typename.tp_basicsize = pytalloc_BaseObject_size();",
push (@{$self->{module_methods}}, [$fn_name, $pyfn_name, $flags, $doc])
}
-sub register_module_typeobject($$$)
+sub register_module_typeobject($$$$)
{
- my ($self, $name, $py_name) = @_;
+ my ($self, $name, $py_name, $location) = @_;
- $self->register_module_object($name, "(PyObject *)(void *)$py_name");
+ $self->register_module_object($name, "(PyObject *)(void *)$py_name", $location);
$self->check_ready_type($py_name);
push (@{$self->{postreadycode}}, @$code);
}
-sub register_module_object($$$)
+sub existing_module_object($$)
{
- my ($self, $name, $py_name) = @_;
+ my ($self, $name) = @_;
+
+ if (defined($self->{module_object_uniq}->{$name})) {
+ return $self->{module_object_uniq}->{$name};
+ }
- push (@{$self->{module_objects}}, [$name, $py_name])
+ return undef;
+}
+
+sub register_module_object($$$$)
+{
+ my ($self, $name, $py_name, $location) = @_;
+
+ my $existing = $self->existing_module_object($name);
+ fatal($location, "module_object($name, $py_name) registered twice! $existing.") if defined($existing);
+
+ push (@{$self->{module_objects}}, [$name, $py_name]);
+ $self->{module_object_uniq}->{$name} = $py_name;
}
sub assign($$$)
$self->deindent;
$self->pidl("}");
- $self->pidl("test_str = PyString_AS_STRING(unicode);");
+ $self->pidl("test_str = PyBytes_AS_STRING(unicode);");
$self->deindent;
- $self->pidl("} else if (PyString_Check($py_var)) {");
+ $self->pidl("} else if (PyBytes_Check($py_var)) {");
$self->indent;
- $self->pidl("test_str = PyString_AS_STRING($py_var);");
+ $self->pidl("test_str = PyBytes_AS_STRING($py_var);");
$self->deindent;
$self->pidl("} else {");
$self->indent;
$self->pidl("}");
}
-sub ConvertObjectFromPythonData($$$$$$;$)
+sub ConvertObjectFromPythonData($$$$$$;$$)
{
- my ($self, $mem_ctx, $cvar, $ctype, $target, $fail, $location) = @_;
+ my ($self, $mem_ctx, $cvar, $ctype, $target, $fail, $location, $switch) = @_;
fatal($location, "undef type for $cvar") unless(defined($ctype));
$self->indent;
$self->pidl("long test_var;");
$self->pidl("test_var = PyInt_AsLong($cvar);");
- $self->pidl("if (test_var < 0 || test_var > uint_max) {");
+ $self->pidl("if (test_var < 0 || (unsigned long long)test_var > uint_max) {");
$self->indent;
$self->pidl("PyErr_Format(PyExc_OverflowError, \"Expected type %s or %s within range 0 - %llu, got %ld\",\\");
$self->pidl(" PyInt_Type.tp_name, PyLong_Type.tp_name, uint_max, test_var);");
return;
}
+ if ($actual_ctype->{TYPE} eq "UNION") {
+ my $ctype_name = $self->use_type_variable($ctype);
+ unless (defined ($ctype_name)) {
+ error($location, "Unable to determine origin of type `" . mapTypeName($ctype) . "'");
+ $self->pidl("PyErr_SetString(PyExc_TypeError, \"Can not convert C Type " . mapTypeName($ctype) . " from Python\");");
+ return;
+ }
+ my $export = "pyrpc_export_union($ctype_name, $mem_ctx, $switch, $cvar, \"".mapTypeName($ctype)."\")";
+ $self->assign($target, "(".mapTypeName($ctype)." *)$export");
+ return;
+ }
+
if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "DATA_BLOB") {
- $self->pidl("$target = data_blob_talloc($mem_ctx, PyString_AS_STRING($cvar), PyString_GET_SIZE($cvar));");
+ $self->pidl("$target = data_blob_talloc($mem_ctx, PyBytes_AS_STRING($cvar), PyBytes_GET_SIZE($cvar));");
return;
}
}
if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "string_array") {
- $self->pidl("$target = PyCObject_AsVoidPtr($cvar);");
+ $self->pidl("$target = pytalloc_get_ptr($cvar);");
return;
}
if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "pointer") {
- $self->assign($target, "PyCObject_AsVoidPtr($cvar)");
+ $self->assign($target, "pytalloc_get_ptr($cvar)");
return;
}
}
-sub ConvertObjectFromPythonLevel($$$$$$$$)
+sub ConvertObjectFromPythonLevel($$$$$$$$$)
{
- my ($self, $env, $mem_ctx, $py_var, $e, $l, $var_name, $fail) = @_;
+ my ($self, $env, $mem_ctx, $py_var, $e, $l, $var_name, $fail, $recurse) = @_;
my $nl = GetNextLevel($e, $l);
if ($nl and $nl->{TYPE} eq "SUBCONTEXT") {
$nl = GetNextLevel($e, $nl);
$pl = GetPrevLevel($e, $pl);
}
- $self->pidl("if ($py_var == NULL) {");
- $self->indent;
- $self->pidl("PyErr_Format(PyExc_AttributeError, \"Cannot delete NDR object: " .
+ if ($recurse == 0) {
+ $self->pidl("if ($py_var == NULL) {");
+ $self->indent;
+ $self->pidl("PyErr_Format(PyExc_AttributeError, \"Cannot delete NDR object: " .
mapTypeName($var_name) . "\");");
- $self->pidl($fail);
- $self->deindent;
- $self->pidl("}");
+ $self->pidl($fail);
+ $self->deindent;
+ $self->pidl("}");
+ }
+ $recurse = $recurse + 1;
if ($l->{TYPE} eq "POINTER") {
+ my $need_deindent = 0;
+ my $need_deref = 0;
+
if ($l->{POINTER_TYPE} ne "ref") {
$self->pidl("if ($py_var == Py_None) {");
$self->indent;
$self->deindent;
$self->pidl("} else {");
$self->indent;
+ $need_deindent = 1;
+ if ($nl->{TYPE} eq "POINTER") {
+ $need_deref = 1;
+ }
}
- # if we want to handle more than one level of pointer in python interfaces
- # then this is where we would need to allocate it
- if ($l->{POINTER_TYPE} eq "ref") {
+
+ if ($l->{POINTER_TYPE} eq "ref" or $need_deref == 1) {
$self->pidl("$var_name = talloc_ptrtype($mem_ctx, $var_name);");
+ $self->pidl("if ($var_name == NULL) {");
+ $self->indent;
+ $self->pidl("PyErr_NoMemory();");
+ $self->pidl($fail);
+ $self->deindent;
+ $self->pidl("}");
} elsif ($nl->{TYPE} eq "DATA" and Parse::Pidl::Typelist::is_scalar($nl->{DATA_TYPE})
and not Parse::Pidl::Typelist::scalar_is_reference($nl->{DATA_TYPE})) {
$self->pidl("$var_name = talloc_ptrtype($mem_ctx, $var_name);");
+ $self->pidl("if ($var_name == NULL) {");
+ $self->indent;
+ $self->pidl("PyErr_NoMemory();");
+ $self->pidl($fail);
+ $self->deindent;
+ $self->pidl("}");
} else {
$self->pidl("$var_name = NULL;");
}
+ if ($need_deref == 1) {
+ my $ndr_pointer_typename = $self->import_type_variable("samba.dcerpc.base", "ndr_pointer");
+ $self->pidl("$py_var = py_dcerpc_ndr_pointer_deref($ndr_pointer_typename, $py_var);");
+ }
unless ($nl->{TYPE} eq "DATA" and Parse::Pidl::Typelist::scalar_is_reference($nl->{DATA_TYPE})) {
$var_name = get_value_of($var_name);
}
- $self->ConvertObjectFromPythonLevel($env, $mem_ctx, $py_var, $e, $nl, $var_name, $fail);
- if ($l->{POINTER_TYPE} ne "ref") {
+ $self->ConvertObjectFromPythonLevel($env, $mem_ctx, $py_var, $e, $nl, $var_name, $fail, $recurse);
+ if ($need_deindent == 1) {
$self->deindent;
$self->pidl("}");
}
}
$self->pidl("for ($counter = 0; $counter < PyList_GET_SIZE($py_var); $counter++) {");
$self->indent;
- $self->ConvertObjectFromPythonLevel($env, $var_name, "PyList_GET_ITEM($py_var, $counter)", $e, $nl, $var_name."[$counter]", $fail);
+ $self->ConvertObjectFromPythonLevel($env, $var_name, "PyList_GET_ITEM($py_var, $counter)", $e, $nl, $var_name."[$counter]", $fail, 0);
$self->deindent;
$self->pidl("}");
$self->deindent;
$self->indent;
my $union_type = mapTypeName($nl->{DATA_TYPE});
$self->pidl("$union_type *$switch_ptr;");
- $self->pidl("$switch_ptr = py_export_" . $nl->{DATA_TYPE} . "($mem_ctx, $switch, $py_var);");
+ $self->ConvertObjectFromPythonData($mem_ctx, $py_var, $nl->{DATA_TYPE}, $switch_ptr, $fail, $e->{ORIGINAL}, $switch);
$self->fail_on_null($switch_ptr, $fail);
$self->assign($var_name, "$switch_ptr");
$self->deindent;
$self->pidl("}");
} elsif ($l->{TYPE} eq "SUBCONTEXT") {
- $self->ConvertObjectFromPythonLevel($env, $mem_ctx, $py_var, $e, $nl, $var_name, $fail);
+ $self->ConvertObjectFromPythonLevel($env, $mem_ctx, $py_var, $e, $nl, $var_name, $fail, $recurse);
} else {
fatal($e->{ORIGINAL}, "unknown level type $l->{TYPE}");
}
sub ConvertObjectFromPython($$$$$$$)
{
my ($self, $env, $mem_ctx, $ctype, $cvar, $target, $fail) = @_;
+ my $recurse = 0;
- $self->ConvertObjectFromPythonLevel($env, $mem_ctx, $cvar, $ctype, $ctype->{LEVELS}[0], $target, $fail);
+ $self->ConvertObjectFromPythonLevel($env, $mem_ctx, $cvar, $ctype, $ctype->{LEVELS}[0], $target, $fail, $recurse);
}
-sub ConvertScalarToPython($$$)
+sub ConvertScalarToPython($$$$)
{
- my ($self, $ctypename, $cvar) = @_;
+ my ($self, $ctypename, $cvar, $mem_ctx) = @_;
die("expected string for $cvar, not $ctypename") if (ref($ctypename) eq "HASH");
$ctypename = expandAlias($ctypename);
if ($ctypename =~ /^(int64|dlong)$/) {
- return "ndr_PyLong_FromLongLong($cvar)";
+ return "PyLong_FromLongLong($cvar)";
}
if ($ctypename =~ /^(uint64|hyper|NTTIME_hyper|NTTIME|NTTIME_1sec|udlong|udlongr|uid_t|gid_t)$/) {
- return "ndr_PyLong_FromUnsignedLongLong($cvar)";
+ return "PyLong_FromUnsignedLongLong($cvar)";
}
if ($ctypename =~ /^(char|int|int8|int16|int32|time_t)$/) {
# possibly 64 bit unsigned long. (enums are signed in C,
# unsigned in NDR)
if ($ctypename =~ /^(uint32|uint3264)$/) {
- return "ndr_PyLong_FromUnsignedLongLong((uint32_t)$cvar)";
+ return "PyLong_FromUnsignedLongLong((uint32_t)$cvar)";
}
if ($ctypename =~ /^(uint|uint8|uint16|uint1632)$/) {
}
if ($ctypename eq "DATA_BLOB") {
- return "PyString_FromStringAndSize((char *)($cvar).data, ($cvar).length)";
+ return "PyBytes_FromStringAndSize((char *)($cvar).data, ($cvar).length)";
}
if ($ctypename eq "NTSTATUS") {
}
# Not yet supported
- if ($ctypename eq "string_array") { return "pytalloc_CObject_FromTallocPtr($cvar)"; }
+ if ($ctypename eq "string_array") {
+ return "pytalloc_GenericObject_reference_ex($mem_ctx, $cvar)";
+ }
if ($ctypename eq "ipv4address") { return "PyString_FromStringOrNULL($cvar)"; }
if ($ctypename eq "ipv6address") { return "PyString_FromStringOrNULL($cvar)"; }
if ($ctypename eq "dnsp_name") { return "PyString_FromStringOrNULL($cvar)"; }
if ($ctypename eq "dnsp_string") { return "PyString_FromStringOrNULL($cvar)"; }
if ($ctypename eq "pointer") {
- return "pytalloc_CObject_FromTallocPtr($cvar)";
+ return "pytalloc_GenericObject_reference_ex($mem_ctx, $cvar)";
}
die("Unknown scalar type $ctypename");
}
-sub ConvertObjectToPythonData($$$$$;$)
+sub ConvertObjectToPythonData($$$$$;$$)
{
- my ($self, $mem_ctx, $ctype, $cvar, $location) = @_;
+ my ($self, $mem_ctx, $ctype, $cvar, $location, $switch) = @_;
die("undef type for $cvar") unless(defined($ctype));
}
if ($actual_ctype->{TYPE} eq "ENUM") {
- return $self->ConvertScalarToPython(Parse::Pidl::Typelist::enum_type_fn($actual_ctype), $cvar);
+ return $self->ConvertScalarToPython(Parse::Pidl::Typelist::enum_type_fn($actual_ctype), $cvar, $mem_ctx);
} elsif ($actual_ctype->{TYPE} eq "BITMAP") {
- return $self->ConvertScalarToPython(Parse::Pidl::Typelist::bitmap_type_fn($actual_ctype), $cvar);
+ return $self->ConvertScalarToPython(Parse::Pidl::Typelist::bitmap_type_fn($actual_ctype), $cvar, $mem_ctx);
} elsif ($actual_ctype->{TYPE} eq "SCALAR") {
- return $self->ConvertScalarToPython($actual_ctype->{NAME}, $cvar);
+ return $self->ConvertScalarToPython($actual_ctype->{NAME}, $cvar, $mem_ctx);
} elsif ($actual_ctype->{TYPE} eq "UNION") {
- fatal($ctype, "union without discriminant: " . mapTypeName($ctype) . ": $cvar");
+ my $ctype_name = $self->use_type_variable($ctype);
+ unless (defined($ctype_name)) {
+ error($location, "Unable to determine origin of type `" . mapTypeName($ctype) . "'");
+ return "NULL"; # FIXME!
+ }
+ return "pyrpc_import_union($ctype_name, $mem_ctx, $switch, $cvar, \"".mapTypeName($ctype)."\")";
} elsif ($actual_ctype->{TYPE} eq "STRUCT" or $actual_ctype->{TYPE} eq "INTERFACE") {
my $ctype_name = $self->use_type_variable($ctype);
unless (defined($ctype_name)) {
$self->pidl("}");
}
-sub ConvertObjectToPythonLevel($$$$$$)
+sub ConvertObjectToPythonLevel($$$$$$$)
{
- my ($self, $mem_ctx, $env, $e, $l, $var_name, $py_var, $fail) = @_;
+ my ($self, $mem_ctx, $env, $e, $l, $var_name, $py_var, $fail, $recurse) = @_;
my $nl = GetNextLevel($e, $l);
if ($nl and $nl->{TYPE} eq "SUBCONTEXT") {
$nl = GetNextLevel($e, $nl);
}
if ($l->{TYPE} eq "POINTER") {
+ my $need_wrap = 0;
+ if ($l->{POINTER_TYPE} ne "ref" and $nl->{TYPE} eq "POINTER") {
+ $need_wrap = 1;
+ }
if ($l->{POINTER_TYPE} ne "ref") {
- $self->pidl("if ($var_name == NULL) {");
- $self->indent;
- $self->pidl("$py_var = Py_None;");
- $self->pidl("Py_INCREF($py_var);");
- $self->deindent;
- $self->pidl("} else {");
- $self->indent;
+ if ($recurse == 0) {
+ $self->pidl("if ($var_name == NULL) {");
+ $self->indent;
+ $self->pidl("$py_var = Py_None;");
+ $self->pidl("Py_INCREF($py_var);");
+ $self->deindent;
+ $self->pidl("} else {");
+ $self->indent;
+ } else {
+ $self->pidl("{");
+ $self->indent;
+ }
+ $recurse = $recurse + 1;
}
my $var_name2 = $var_name;
+ my $recurse2 = $recurse;
unless ($nl->{TYPE} eq "DATA" and Parse::Pidl::Typelist::scalar_is_reference($nl->{DATA_TYPE})) {
$var_name2 = get_value_of($var_name);
+ $recurse2 = 0;
}
- $self->ConvertObjectToPythonLevel($var_name, $env, $e, $nl, $var_name2, $py_var, $fail);
+ $self->ConvertObjectToPythonLevel($var_name, $env, $e, $nl, $var_name2, $py_var, $fail, $recurse2);
if ($l->{POINTER_TYPE} ne "ref") {
$self->deindent;
$self->pidl("}");
}
+ if ($need_wrap) {
+ my $py_var_wrap = undef;
+ $need_wrap = 1;
+ $self->pidl("{");
+ $self->indent;
+ $py_var_wrap = "py_$e->{NAME}_level_$l->{LEVEL_INDEX}";
+ $self->pidl("PyObject *$py_var_wrap = $py_var;");
+ my $ndr_pointer_typename = $self->import_type_variable("samba.dcerpc.base", "ndr_pointer");
+ $self->pidl("$py_var = py_dcerpc_ndr_pointer_wrap($ndr_pointer_typename, $py_var_wrap);");
+ $self->pidl("Py_XDECREF($py_var_wrap);");
+ $self->deindent;
+ $self->pidl("}");
+ }
} elsif ($l->{TYPE} eq "ARRAY") {
if ($pl && $pl->{TYPE} eq "POINTER") {
$var_name = get_pointer_to($var_name);
$self->indent;
my $member_var = "py_$e->{NAME}_$l->{LEVEL_INDEX}";
$self->pidl("PyObject *$member_var;");
- $self->ConvertObjectToPythonLevel($var_name, $env, $e, $nl, $var_name."[$counter]", $member_var, $fail);
+ $self->ConvertObjectToPythonLevel($var_name, $env, $e, $nl, $var_name."[$counter]", $member_var, $fail, $recurse);
$self->pidl("PyList_SetItem($py_var, $counter, $member_var);");
$self->deindent;
$self->pidl("}");
} 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_" . $nl->{DATA_TYPE} . "($mem_ctx, $switch, $var_name);");
+ my $conv = $self->ConvertObjectToPythonData($mem_ctx, $nl->{DATA_TYPE}, $var_name, $e->{ORIGINAL}, $switch);
+ $self->pidl("$py_var = $conv;");
$self->fail_on_null($py_var, $fail);
} elsif ($l->{TYPE} eq "DATA") {
my $conv = $self->ConvertObjectToPythonData($mem_ctx, $l->{DATA_TYPE}, $var_name, $e->{ORIGINAL});
$self->pidl("$py_var = $conv;");
} elsif ($l->{TYPE} eq "SUBCONTEXT") {
- $self->ConvertObjectToPythonLevel($mem_ctx, $env, $e, $nl, $var_name, $py_var, $fail);
+ $self->ConvertObjectToPythonLevel($mem_ctx, $env, $e, $nl, $var_name, $py_var, $fail, $recurse);
} else {
fatal($e->{ORIGINAL}, "Unknown level type $l->{TYPE} $var_name");
}
sub ConvertObjectToPython($$$$$$)
{
my ($self, $mem_ctx, $env, $ctype, $cvar, $py_var, $fail) = @_;
+ my $recurse = 0;
- $self->ConvertObjectToPythonLevel($mem_ctx, $env, $ctype, $ctype->{LEVELS}[0], $cvar, $py_var, $fail);
+ $self->ConvertObjectToPythonLevel($mem_ctx, $env, $ctype, $ctype->{LEVELS}[0], $cvar, $py_var, $fail, $recurse);
}
sub Parse($$$$$)
/* Python wrapper functions auto-generated by pidl */
#define PY_SSIZE_T_CLEAN 1 /* We use Py_ssize_t for PyArg_ParseTupleAndKeywords */
#include <Python.h>
+#include \"python/py3compat.h\"
#include \"includes.h\"
+#include \"python/modules.h\"
#include <pytalloc.h>
#include \"librpc/rpc/pyrpc.h\"
#include \"librpc/rpc/pyrpc_util.h\"
#include \"$ndr_hdr\"
/*
- * These functions are here to ensure they can be optomised out by
+ * These functions are here to ensure they can be optimized out by
* the compiler based on the constant input values
*/
return 0;
}
-static inline PyObject *ndr_PyLong_FromLongLong(long long v)
-{
- if (v > LONG_MAX || v < LONG_MIN) {
- return PyLong_FromLongLong(v);
- } else {
- return PyInt_FromLong(v);
- }
-}
-
-static inline PyObject *ndr_PyLong_FromUnsignedLongLong(unsigned long long v)
-{
- if (v > LONG_MAX) {
- return PyLong_FromUnsignedLongLong(v);
- } else {
- return PyInt_FromLong(v);
- }
-}
-
");
foreach my $x (@$ndr) {
$self->pidl("");
- $self->pidl_hdr("void init$basename(void);");
- $self->pidl("void init$basename(void)");
+ $self->pidl("static struct PyModuleDef moduledef = {");
+ $self->indent;
+ $self->pidl("PyModuleDef_HEAD_INIT,");
+ $self->pidl(".m_name = \"$basename\",");
+ $self->pidl(".m_doc = \"$basename DCE/RPC\",");
+ $self->pidl(".m_size = -1,");
+ $self->pidl(".m_methods = $basename\_methods,");
+ $self->deindent;
+ $self->pidl("};");
+
+ $self->pidl("MODULE_INIT_FUNC($basename)");
$self->pidl("{");
$self->indent;
- $self->pidl("PyObject *m;");
+ $self->pidl("PyObject *m = NULL;");
foreach my $h (@{$self->{module_imports}}) {
- $self->pidl("PyObject *$h->{'key'};");
+ $self->pidl("PyObject *$h->{'key'} = NULL;");
}
$self->pidl("");
my $module_path = $h->{'val'};
$self->pidl("$var_name = PyImport_ImportModule(\"$module_path\");");
$self->pidl("if ($var_name == NULL)");
- $self->pidl("\treturn;");
+ $self->pidl("\tgoto out;");
$self->pidl("");
}
$module_var =~ s/\./_/g;
$self->pidl("$type_var = (PyTypeObject *)PyObject_GetAttrString($module_var, \"$pretty_name\");");
$self->pidl("if ($type_var == NULL)");
- $self->pidl("\treturn;");
+ $self->pidl("\tgoto out;");
$self->pidl("");
}
foreach (@{$self->{ready_types}}) {
$self->pidl("if (PyType_Ready($_) < 0)");
- $self->pidl("\treturn;");
+ $self->pidl("\tgoto out;");
}
$self->pidl($_) foreach (@{$self->{postreadycode}});
$self->pidl("");
- $self->pidl("m = Py_InitModule3(\"$basename\", $basename\_methods, \"$basename DCE/RPC\");");
+ $self->pidl("m = PyModule_Create(&moduledef);");
$self->pidl("if (m == NULL)");
- $self->pidl("\treturn;");
+ $self->pidl("\tgoto out;");
$self->pidl("");
foreach my $h (@{$self->{constants}}) {
- my $name = $h->{'key'};
+ my $pretty_name = PrettifyTypeName($h->{'key'}, $basename);
my $py_obj;
my ($ctype, $cvar) = @{$h->{'val'}};
if ($cvar =~ /^[0-9]+$/ or $cvar =~ /^0x[0-9a-fA-F]+$/) {
- $py_obj = "ndr_PyLong_FromUnsignedLongLong($cvar)";
+ $py_obj = "PyLong_FromUnsignedLongLong($cvar)";
} elsif ($cvar =~ /^".*"$/) {
- $py_obj = "PyString_FromString($cvar)";
+ $py_obj = "PyStr_FromString($cvar)";
} else {
$py_obj = $self->ConvertObjectToPythonData("NULL", expandAlias($ctype), $cvar, undef);
}
- $self->pidl("PyModule_AddObject(m, \"$name\", $py_obj);");
+ $self->pidl("PyModule_AddObject(m, \"$pretty_name\", $py_obj);");
}
foreach (@{$self->{module_objects}}) {
$self->pidl("#ifdef PY_MOD_".uc($basename)."_PATCH");
$self->pidl("PY_MOD_".uc($basename)."_PATCH(m);");
$self->pidl("#endif");
-
+ $self->pidl("out:");
+ foreach my $h (@{$self->{module_imports}}) {
+ my $mod_var = $h->{'key'};
+ $self->pidl("Py_XDECREF($mod_var);");
+ }
+ $self->pidl("return m;");
$self->pidl("");
$self->deindent;
$self->pidl("}");
git.samba.org / gd / samba-autobuild / .git / blobdiff