source/pidl/lib/Parse/Pidl/Samba4/Python.pm

   1 ###################################################
   2 # Python function wrapper generator
   3 # Copyright jelmer@samba.org 2007-2008
   4 # released under the GNU GPL
   5
   6 package Parse::Pidl::Samba4::Python;
   7
   8 use Exporter;
   9 @ISA = qw(Exporter);
  10
  11 use strict;
  12 use Parse::Pidl::Typelist qw(hasType getType mapTypeName expandAlias);
  13 use Parse::Pidl::Util qw(has_property ParseExpr);
  14 use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred);
  15 use Parse::Pidl::CUtil qw(get_value_of get_pointer_to);
  16
  17 use vars qw($VERSION);
  18 $VERSION = '0.01';
  19
  20 sub new($) {
  21         my ($class) = @_;
  22         my $self = { res => "", res_hdr => "", tabs => "", constants => {},
  23                      module_methods => []};
  24         bless($self, $class);
  25 }
  26
  27 sub pidl_hdr ($$)
  28 {
  29         my $self = shift;
  30         $self->{res_hdr} .= shift;
  31 }
  32
  33 sub pidl($$)
  34 {
  35         my ($self, $d) = @_;
  36         if ($d) {
  37                 $self->{res} .= $self->{tabs};
  38                 $self->{res} .= $d;
  39         }
  40         $self->{res} .= "\n";
  41 }
  42
  43 sub indent($)
  44 {
  45         my ($self) = @_;
  46         $self->{tabs} .= "\t";
  47 }
  48
  49 sub deindent($)
  50 {
  51         my ($self) = @_;
  52         $self->{tabs} = substr($self->{tabs}, 0, -1);
  53 }
  54
  55 sub Import
  56 {
  57         my $self = shift;
  58         my @imports = @_;
  59         foreach (@imports) {
  60                 s/\.idl\"$//;
  61                 s/^\"//;
  62                 $self->pidl_hdr("#include \"librpc/gen_ndr/py_$_\.h\"\n");
  63         }
  64 }
  65
  66 sub Const($$)
  67 {
  68     my ($self, $const) = @_;
  69         $self->register_constant($const->{NAME}, $const->{DTYPE}, $const->{VALUE});
  70 }
  71
  72 sub register_constant($$$$)
  73 {
  74         my ($self, $name, $type, $value) = @_;
  75
  76         $self->{constants}->{$name} = [$type, $value];
  77 }
  78
  79 sub EnumAndBitmapConsts($$$)
  80 {
  81         my ($self, $name, $d) = @_;
  82
  83         return unless (defined($d->{ELEMENTS}));
  84
  85         foreach my $e (@{$d->{ELEMENTS}}) {
  86                 $e =~ /^([A-Za-z0-9_]+)=(.*)$/;
  87                 my $cname = $1;
  88
  89                 $self->register_constant($cname, $d, $cname);
  90         }
  91 }
  92
  93 sub FromUnionToPythonFunction($$$)
  94 {
  95         my ($self, $type, $switch, $name) = @_;
  96
  97         $self->pidl("switch ($switch) {");
  98         $self->indent;
  99
 100         foreach my $e (@{$type->{ELEMENTS}}) {
 101                 my $conv;
 102
 103                 if ($e->{NAME}) {
 104                         $conv = $self->ConvertObjectToPython($e, "$name->$e->{NAME}");
 105                 } else {
 106                         $conv = "Py_None";
 107                 }
 108                 if (defined($e->{CASE})) {
 109                         $self->pidl("$e->{CASE}: return $conv;");
 110                 } else {
 111                         $self->pidl("default: return $conv;");
 112                 }
 113         }
 114
 115         $self->deindent;
 116         $self->pidl("}");
 117
 118         $self->pidl("PyErr_SetString(PyExc_TypeError, \"unknown union level\");");
 119         $self->pidl("return NULL;");
 120 }
 121
 122 sub FromPythonToUnionFunction($$$$$)
 123 {
 124         my ($self, $type, $typename, $switch, $mem_ctx, $name) = @_;
 125
 126         my $has_default = 0;
 127
 128         $self->pidl("$typename *ret = talloc_zero($mem_ctx, $typename);");
 129
 130         $self->pidl("switch ($switch) {");
 131         $self->indent;
 132
 133         foreach my $e (@{$type->{ELEMENTS}}) {
 134                 if (defined($e->{CASE})) {
 135                         $self->pidl("$e->{CASE}:");
 136                 } else {
 137                         $has_default = 1;
 138                         $self->pidl("default:");
 139                 }
 140                 $self->indent;
 141                 if ($e->{NAME}) {
 142                         $self->ConvertObjectFromPython($mem_ctx, $e, $name, "ret->$e->{NAME}", "talloc_free(ret); return NULL;");
 143                 }
 144                 $self->pidl("break;");
 145                 $self->deindent;
 146                 $self->pidl("");
 147         }
 148
 149         if (!$has_default) {
 150                 $self->pidl("default:");
 151                 $self->indent;
 152                 $self->pidl("PyErr_SetString(PyExc_TypeError, \"invalid union level value\");");
 153                 $self->pidl("talloc_free(ret);");
 154                 $self->pidl("ret = NULL;");
 155                 $self->deindent;
 156         }
 157
 158         $self->deindent;
 159         $self->pidl("}");
 160         $self->pidl("");
 161         $self->pidl("return ret;");
 162 }
 163
 164 sub PythonStruct($$$$)
 165 {
 166         my ($self, $name, $cname, $d) = @_;
 167
 168         $self->pidl("");
 169
 170         $self->pidl("static PyObject *py_$name\_getattr(PyObject *obj, char *name)");
 171         $self->pidl("{");
 172         $self->indent;
 173         $self->pidl("$cname *object = py_talloc_get_type(obj, $cname);");
 174         foreach my $e (@{$d->{ELEMENTS}}) {
 175                 $self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {");
 176                 my $varname = "object->$e->{NAME}";
 177                 $self->indent;
 178                 $self->pidl("return ".$self->ConvertObjectToPython($e, $varname) . ";");
 179                 $self->deindent;
 180                 $self->pidl("}");
 181         }
 182         $self->pidl("PyErr_SetString(PyExc_AttributeError, \"no such attribute\");");
 183         $self->pidl("return NULL;");
 184         $self->deindent;
 185         $self->pidl("}");
 186         $self->pidl("");
 187
 188         $self->pidl("static int py_$name\_setattr(PyObject *py_obj, char *name, PyObject *value)");
 189         $self->pidl("{");
 190         $self->indent;
 191         $self->pidl("$cname *object = py_talloc_get_type(py_obj, $cname);");
 192         my $mem_ctx = "py_talloc_get_mem_ctx(py_obj)";
 193         foreach my $e (@{$d->{ELEMENTS}}) {
 194                 $self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {");
 195                 my $varname = "object->$e->{NAME}";
 196                 $self->indent;
 197                 if ($e->{ORIGINAL}->{POINTERS} > 0) {
 198                         $self->pidl("talloc_free($varname);");
 199                 }
 200                 $self->ConvertObjectFromPython($mem_ctx, $e, "value", $varname, "return -1;");
 201                 $self->pidl("return 0;");
 202                 $self->deindent;
 203                 $self->pidl("}");
 204         }
 205         $self->pidl("PyErr_SetString(PyExc_AttributeError, \"no such attribute\");");
 206         $self->pidl("return -1;");
 207         $self->deindent;
 208         $self->pidl("}");
 209         $self->pidl("");
 210
 211         $self->pidl_hdr("PyAPI_DATA(PyTypeObject) $name\_Type;\n");
 212         $self->pidl_hdr("#define $name\_Check(op) PyObject_TypeCheck(op, &$name\_Type)\n");
 213         $self->pidl_hdr("#define $name\_CheckExact(op) ((op)->ob_type == &$name\_Type)\n");
 214         $self->pidl_hdr("\n");
 215         $self->pidl("PyTypeObject $name\_Type = {");
 216         $self->indent;
 217         $self->pidl("PyObject_HEAD_INIT(NULL) 0,");
 218         $self->pidl(".tp_name = \"$name\",");
 219         $self->pidl(".tp_basicsize = sizeof(py_talloc_Object),");
 220         $self->pidl(".tp_dealloc = py_talloc_dealloc,");
 221         $self->pidl(".tp_getattr = py_$name\_getattr,");
 222         $self->pidl(".tp_setattr = py_$name\_setattr,");
 223         $self->pidl(".tp_repr = py_talloc_default_repr,");
 224         $self->deindent;
 225         $self->pidl("};");
 226
 227         $self->pidl("");
 228
 229         my $py_fnname = "py_$name";
 230         $self->pidl("static PyObject *$py_fnname(PyObject *self, PyObject *args)");
 231         $self->pidl("{");
 232         $self->indent;
 233         $self->pidl("$cname *ret = talloc_zero(NULL, $cname);");
 234         $self->pidl("return py_talloc_import(&$name\_Type, ret);");
 235         $self->deindent;
 236         $self->pidl("}");
 237         $self->pidl("");
 238
 239         return $py_fnname;
 240 }
 241
 242 sub PythonFunction($$$)
 243 {
 244         my ($self, $fn, $iface) = @_;
 245
 246         $self->pidl("static PyObject *py_$fn->{NAME}(PyObject *self, PyObject *args)");
 247         $self->pidl("{");
 248         $self->indent;
 249         $self->pidl("$iface\_InterfaceObject *iface = ($iface\_InterfaceObject *)self;");
 250         $self->pidl("NTSTATUS status;");
 251         $self->pidl("TALLOC_CTX *mem_ctx = talloc_new(NULL);");
 252         $self->pidl("struct $fn->{NAME} r;");
 253         $self->pidl("PyObject *result;");
 254         my $result_size = 0;
 255
 256         foreach my $e (@{$fn->{ELEMENTS}}) {
 257                 if (grep(/in/,@{$e->{DIRECTION}})) {
 258                         $self->pidl("PyObject *py_$e->{NAME};");
 259                 }
 260                 if (grep(/out/,@{$e->{DIRECTION}})) {
 261                         $result_size++;
 262                 }
 263         }
 264         if ($result_size > 0) {
 265                 $self->pidl("");
 266                 $self->pidl("ZERO_STRUCT(r.out);");
 267         }
 268         if ($fn->{RETURN_TYPE}) {
 269                 $result_size++;
 270         }
 271
 272         foreach my $e (@{$fn->{ELEMENTS}}) {
 273                 if (grep(/in/,@{$e->{DIRECTION}})) {
 274                         $self->ConvertObjectFromPython("mem_ctx", $e, "py_$e->{NAME}", "r.in.$e->{NAME}", "talloc_free(mem_ctx); return NULL;");
 275                 }
 276         }
 277         $self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, &r);");
 278         $self->handle_ntstatus("status", "NULL", "mem_ctx");
 279
 280         $self->pidl("result = PyTuple_New($result_size);");
 281
 282         my $i = 0;
 283
 284         foreach my $e (@{$fn->{ELEMENTS}}) {
 285                 if (grep(/out/,@{$e->{DIRECTION}})) {
 286                         $self->pidl("PyTuple_SetItem(result, $i, " . $self->ConvertObjectToPython($e, "r.out.$e->{NAME}") . ");");
 287
 288                         $i++;
 289                 }
 290         }
 291
 292         if (defined($fn->{RETURN_TYPE})) {
 293                 $self->pidl("PyTuple_SetItem(result, $i, " . $self->ConvertObjectToPythonData($fn->{RETURN_TYPE}, "r.out.result") . ");");
 294         }
 295
 296         $self->pidl("talloc_free(mem_ctx);");
 297         $self->pidl("return result;");
 298         $self->deindent;
 299         $self->pidl("}");
 300         $self->pidl("");
 301 }
 302
 303 sub handle_ntstatus($$$$)
 304 {
 305         my ($self, $var, $retval, $mem_ctx) = @_;
 306
 307         $self->pidl("if (NT_STATUS_IS_ERR($var)) {");
 308         $self->indent;
 309         $self->pidl("PyErr_SetString(PyExc_RuntimeError, nt_errstr($var));");
 310         $self->pidl("talloc_free($mem_ctx);") if ($mem_ctx);
 311         $self->pidl("return $retval;");
 312         $self->deindent;
 313         $self->pidl("}");
 314         $self->pidl("");
 315 }
 316
 317 sub PythonType($$$)
 318 {
 319         my ($self, $d, $interface, $basename) = @_;
 320
 321         my $actual_ctype = $d;
 322         if ($actual_ctype->{TYPE} eq "TYPEDEF") {
 323                 $actual_ctype = $actual_ctype->{DATA};
 324         }
 325
 326         if ($actual_ctype->{TYPE} eq "STRUCT") {
 327                 my $py_fnname;
 328                 if ($d->{TYPE} eq "STRUCT") {
 329                         $py_fnname = $self->PythonStruct($d->{NAME}, mapTypeName($d), $d);
 330                 } else {
 331                         $py_fnname = $self->PythonStruct($d->{NAME}, mapTypeName($d), $d->{DATA});
 332                 }
 333
 334                 my $fn_name = $d->{NAME};
 335
 336                 $fn_name =~ s/^$interface->{NAME}_//;
 337                 $fn_name =~ s/^$basename\_//;
 338
 339                 $self->register_module_method($fn_name, $py_fnname, "METH_NOARGS", "NULL");
 340         }
 341
 342         if ($d->{TYPE} eq "ENUM" or $d->{TYPE} eq "BITMAP") {
 343                 $self->EnumAndBitmapConsts($d->{NAME}, $d);
 344         }
 345
 346         if ($d->{TYPE} eq "TYPEDEF" and ($d->{DATA}->{TYPE} eq "ENUM" or $d->{DATA}->{TYPE} eq "BITMAP")) {
 347                 $self->EnumAndBitmapConsts($d->{NAME}, $d->{DATA});
 348         }
 349
 350         if ($actual_ctype->{TYPE} eq "UNION") {
 351                 $self->pidl("PyObject *py_import_$d->{NAME}(int level, " .mapTypeName($d) . " *in)");
 352                 $self->pidl("{");
 353                 $self->indent;
 354                 $self->FromUnionToPythonFunction($actual_ctype, "level", "in") if ($actual_ctype->{TYPE} eq "UNION");
 355                 $self->deindent;
 356                 $self->pidl("}");
 357                 $self->pidl("");
 358
 359                 $self->pidl(mapTypeName($d) . " *py_export_$d->{NAME}(TALLOC_CTX *mem_ctx, int level, PyObject *in)");
 360                 $self->pidl("{");
 361                 $self->indent;
 362                 $self->FromPythonToUnionFunction($actual_ctype, mapTypeName($d), "level", "mem_ctx", "in") if ($actual_ctype->{TYPE} eq "UNION");
 363                 $self->deindent;
 364                 $self->pidl("}");
 365                 $self->pidl("");
 366         }
 367 }
 368
 369 sub Interface($$$)
 370 {
 371         my($self,$interface,$basename) = @_;
 372
 373         $self->pidl_hdr("#ifndef _HEADER_PYTHON_$interface->{NAME}\n");
 374         $self->pidl_hdr("#define _HEADER_PYTHON_$interface->{NAME}\n\n");
 375
 376         $self->pidl_hdr("\n");
 377
 378         $self->Const($_) foreach (@{$interface->{CONSTS}});
 379
 380         foreach my $d (@{$interface->{TYPES}}) {
 381                 next if has_property($d, "nopython");
 382
 383                 $self->PythonType($d, $interface, $basename);
 384         }
 385
 386         $self->pidl_hdr("PyAPI_DATA(PyTypeObject) $interface->{NAME}_InterfaceType;\n");
 387         $self->pidl("typedef struct {");
 388         $self->indent;
 389         $self->pidl("PyObject_HEAD");
 390         $self->pidl("struct dcerpc_pipe *pipe;");
 391         $self->deindent;
 392         $self->pidl("} $interface->{NAME}_InterfaceObject;");
 393
 394         $self->pidl("");
 395
 396         foreach my $d (@{$interface->{FUNCTIONS}}) {
 397                 next if not defined($d->{OPNUM});
 398                 next if has_property($d, "nopython");
 399
 400                 $self->PythonFunction($d, $interface->{NAME});
 401         }
 402
 403         $self->pidl("static PyMethodDef interface_$interface->{NAME}\_methods[] = {");
 404         $self->indent;
 405         foreach my $d (@{$interface->{FUNCTIONS}}) {
 406                 next if not defined($d->{OPNUM});
 407                 next if has_property($d, "nopython");
 408
 409                 my $fn_name = $d->{NAME};
 410
 411                 $fn_name =~ s/^$interface->{NAME}_//;
 412
 413                 $self->pidl("{ \"$fn_name\", (PyCFunction)py_$d->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },");
 414         }
 415         $self->pidl("{ NULL, NULL, 0, NULL }");
 416         $self->deindent;
 417         $self->pidl("};");
 418         $self->pidl("");
 419
 420         $self->pidl("static void interface_$interface->{NAME}_dealloc(PyObject* self)");
 421         $self->pidl("{");
 422         $self->indent;
 423         $self->pidl("$interface->{NAME}_InterfaceObject *interface = ($interface->{NAME}_InterfaceObject *)self;");
 424         $self->pidl("talloc_free(interface->pipe);");
 425         $self->pidl("PyObject_Del(self);");
 426         $self->deindent;
 427         $self->pidl("}");
 428         $self->pidl("");
 429
 430         $self->pidl("static PyObject *interface_$interface->{NAME}_getattr(PyObject *obj, char *name)");
 431         $self->pidl("{");
 432         $self->indent;
 433         $self->pidl("return Py_FindMethod(interface_$interface->{NAME}\_methods, obj, name);");
 434         $self->deindent;
 435         $self->pidl("}");
 436
 437         $self->pidl("");
 438
 439         $self->pidl("PyTypeObject $interface->{NAME}_InterfaceType = {");
 440         $self->indent;
 441         $self->pidl("PyObject_HEAD_INIT(NULL) 0,");
 442         $self->pidl(".tp_name = \"$interface->{NAME}\",");
 443         $self->pidl(".tp_basicsize = sizeof($interface->{NAME}_InterfaceObject),");
 444         $self->pidl(".tp_dealloc = interface_$interface->{NAME}_dealloc,");
 445         $self->pidl(".tp_getattr = interface_$interface->{NAME}_getattr,");
 446         $self->deindent;
 447         $self->pidl("};");
 448
 449         $self->pidl("");
 450
 451         $self->register_module_method($interface->{NAME}, "interface_$interface->{NAME}", "METH_VARARGS|METH_KEYWORDS", "NULL");
 452         $self->pidl("static PyObject *interface_$interface->{NAME}(PyObject *self, PyObject *args)");
 453         $self->pidl("{");
 454         $self->indent;
 455         $self->pidl("$interface->{NAME}_InterfaceObject *ret;");
 456         $self->pidl("const char *binding_string;");
 457         $self->pidl("struct cli_credentials *credentials;");
 458         $self->pidl("struct loadparm_context *lp_ctx;");
 459         $self->pidl("TALLOC_CTX *mem_ctx = NULL;");
 460         $self->pidl("NTSTATUS status;");
 461         $self->pidl("");
 462
 463         # FIXME: Arguments: binding string, credentials, loadparm context
 464         $self->pidl("ret = PyObject_New($interface->{NAME}_InterfaceObject, &$interface->{NAME}_InterfaceType);");
 465         $self->pidl("");
 466
 467         $self->pidl("status = dcerpc_pipe_connect(NULL, &ret->pipe, binding_string, ");
 468         $self->pidl("             &ndr_table_$interface->{NAME}, credentials, NULL, lp_ctx);");
 469         $self->handle_ntstatus("status", "NULL", "mem_ctx");
 470
 471         $self->pidl("return (PyObject *)ret;");
 472         $self->deindent;
 473         $self->pidl("}");
 474
 475         $self->pidl("");
 476
 477         $self->pidl_hdr("\n");
 478         $self->pidl_hdr("#endif /* _HEADER_NDR_$interface->{NAME} */\n");
 479 }
 480
 481 sub register_module_method($$$$$)
 482 {
 483         my ($self, $fn_name, $pyfn_name, $flags, $doc) = @_;
 484
 485         push (@{$self->{module_methods}}, [$fn_name, $pyfn_name, $flags, $doc])
 486 }
 487
 488 sub convertObjectFromPythonData($$$$$$)
 489 {
 490         my ($self, $mem_ctx, $ctype, $cvar, $target, $fail) = @_;
 491
 492         die("undef type for $cvar") unless(defined($ctype));
 493
 494         if (ref($ctype) ne "HASH") {
 495                 $ctype = getType($ctype);
 496         }
 497
 498         if (ref($ctype) ne "HASH") {
 499                 $self->pidl("$target = FIXME($cvar);");
 500                 return;
 501         }
 502
 503         my $actual_ctype = $ctype;
 504         if ($ctype->{TYPE} eq "TYPEDEF") {
 505                 $actual_ctype = $ctype->{DATA};
 506         }
 507
 508         if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or
 509                 $actual_ctype->{TYPE} eq "SCALAR" and (
 510                 expandAlias($actual_ctype->{NAME}) =~ /^(u?int[0-9]+|hyper|NTTIME|time_t|NTTIME_hyper|NTTIME_1sec|dlong|udlong|udlongr)$/)) {
 511                 $self->pidl("PY_CHECK_TYPE(PyInt, $cvar, $fail);");
 512                 $self->pidl("$target = PyInt_AsLong($cvar);");
 513                 return;
 514         }
 515
 516         if ($actual_ctype->{TYPE} eq "STRUCT") {
 517                 $self->pidl("PY_CHECK_TYPE($ctype->{NAME}, $cvar, $fail);");
 518                 $self->pidl("$target = py_talloc_get_ptr($cvar);");
 519                 return;
 520         }
 521
 522         if ($actual_ctype->{TYPE} eq "UNION") {
 523                 $self->pidl("$target = py_export_$ctype->{NAME}($cvar);");
 524                 return;
 525         }
 526
 527         if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "DATA_BLOB") {
 528                 $self->pidl("$target = data_blob_talloc($mem_ctx, PyString_AsString($cvar), PyString_Size($cvar));");
 529                 return;
 530         }
 531
 532         if ($actual_ctype->{TYPE} eq "SCALAR" and
 533                 ($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")) {
 534                 $self->pidl("$target = talloc_strdup($mem_ctx, PyString_AsString($cvar));");
 535                 return;
 536         }
 537
 538         if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "ipv4address") {
 539                 $self->pidl("$target = FIXME($cvar);");
 540                 return;
 541                 }
 542
 543
 544         if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "NTSTATUS") {
 545                 $self->pidl("$target = PyInt_AsLong($cvar);");
 546                 return;
 547         }
 548
 549         if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "WERROR") {
 550                 $self->pidl("$target = PyInt_AsLong($cvar);");
 551                 return;
 552         }
 553
 554         if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "string_array") {
 555                 $self->pidl("$target = FIXME($cvar);");
 556                 return;
 557         }
 558
 559         if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "pointer") {
 560                 $self->pidl("$target = PyCObject_AsVoidPtr($cvar);");
 561                 return;
 562         }
 563
 564         die("unknown type ".mapTypeName($ctype) . ": $cvar");
 565
 566 }
 567
 568 sub ConvertObjectFromPythonLevel($$$$$$$)
 569 {
 570         my ($self, $mem_ctx, $e, $l, $var_name, $target, $fail) = @_;
 571
 572         if ($l->{TYPE} eq "POINTER") {
 573                 $self->ConvertObjectFromPythonLevel($mem_ctx, $e, GetNextLevel($e, $l), get_value_of($var_name), $target, $fail);
 574         } elsif ($l->{TYPE} eq "ARRAY") {
 575                 $self->ConvertObjectFromPythonLevel($mem_ctx, $e, GetNextLevel($e, $l), $var_name."[i]", $target, $fail);
 576         } elsif ($l->{TYPE} eq "DATA") {
 577                 if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or
 578                         Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
 579                         $var_name = get_pointer_to($var_name);
 580                 }
 581                 $self->ConvertObjectToPythonData($mem_ctx, $l->{DATA_TYPE}, $var_name, $target, $fail);
 582         } elsif ($l->{TYPE} eq "SWITCH") {
 583                 $self->ConvertObjectFromPythonLevel($mem_ctx, $e, GetNextLevel($e, $l), get_value_of($var_name), $target, $fail);
 584         } else {
 585                 die("unknown level type $l->{TYPE}");
 586         }
 587 }
 588
 589 sub ConvertObjectFromPython($$$$$$)
 590 {
 591         my ($self, $mem_ctx, $ctype, $cvar, $target, $fail) = @_;
 592
 593         $self->ConvertObjectFromPythonLevel($mem_ctx, $ctype, $ctype->{LEVELS}[0],
 594                                                $cvar, $target, $fail);
 595 }
 596
 597 sub ConvertScalarToPython($$$)
 598 {
 599         my ($self, $ctypename, $cvar) = @_;
 600
 601         die("expected string for $cvar, not $ctypename") if (ref($ctypename) eq "HASH");
 602
 603         $ctypename = expandAlias($ctypename);
 604
 605         if ($ctypename =~ /^(int|long|char|u?int[0-9]+|hyper|dlong|udlong|udlongr|time_t|NTTIME_hyper|NTTIME|NTTIME_1sec)$/) {
 606                 return "PyInt_FromLong($cvar)";
 607         }
 608
 609         if ($ctypename eq "DATA_BLOB") {
 610                 return "PyString_FromStringAndSize($cvar->data, $cvar->length)";
 611         }
 612
 613         if ($ctypename eq "NTSTATUS") {
 614                 return "PyInt_FromLong(NT_STATUS_V($cvar))";
 615         }
 616
 617         if ($ctypename eq "WERROR") {
 618                 return "PyInt_FromLong(W_ERROR_V($cvar))";
 619         }
 620
 621         if (($ctypename eq "string" or $ctypename eq "nbt_string" or $ctypename eq "nbt_name" or $ctypename eq "wrepl_nbt_name")) {
 622                 return "PyString_FromString($cvar)";
 623         }
 624
 625         if ($ctypename eq "string_array") { return "FIXME($cvar)"; }
 626
 627         if ($ctypename eq "ipv4address") { return "FIXME($cvar)"; }
 628         if ($ctypename eq "pointer") {
 629                 return "PyCObject_FromVoidPtr($cvar, talloc_free)";
 630         }
 631
 632         die("Unknown scalar type $ctypename");
 633 }
 634
 635 sub ConvertObjectToPythonData($$$)
 636 {
 637         my ($self, $ctype, $cvar) = @_;
 638
 639         die("undef type for $cvar") unless(defined($ctype));
 640
 641         if (ref($ctype) ne "HASH") {
 642                 if (not hasType($ctype)) {
 643                         if (ref($ctype) eq "HASH") {
 644                                 return "py_import_$ctype->{TYPE}_$ctype->{NAME}($cvar)";
 645                         } else {
 646                                 return "py_import_$ctype($cvar)"; # best bet
 647                         }
 648                 }
 649
 650                 $ctype = getType($ctype);
 651         }
 652
 653         my $actual_ctype = $ctype;
 654         if ($ctype->{TYPE} eq "TYPEDEF") {
 655                 $actual_ctype = $ctype->{DATA};
 656         }
 657
 658         if ($actual_ctype->{TYPE} eq "ENUM") {
 659                 return $self->ConvertScalarToPython(Parse::Pidl::Typelist::enum_type_fn($actual_ctype), $cvar);
 660         }
 661
 662         if ($actual_ctype->{TYPE} eq "BITMAP") {
 663                 return $self->ConvertScalarToPython(Parse::Pidl::Typelist::bitmap_type_fn($actual_ctype), $cvar);
 664         }
 665
 666         if ($actual_ctype->{TYPE} eq "SCALAR") {
 667                 return $self->ConvertScalarToPython($actual_ctype->{NAME}, $cvar);
 668         }
 669
 670         if ($actual_ctype->{TYPE} eq "UNION") {
 671                 return "py_import_$ctype->{NAME}($cvar)";
 672         }
 673
 674         if ($actual_ctype->{TYPE} eq "STRUCT") {
 675                 # FIXME: if $cvar is not a pointer, do a talloc_dup()
 676                 return "py_talloc_import(&$ctype->{NAME}_Type, $cvar)";
 677         }
 678
 679         die("unknown type ".mapTypeName($ctype) . ": $cvar");
 680 }
 681
 682 sub ConvertObjectToPythonLevel($$$$)
 683 {
 684         my ($self, $e, $l, $var_name) = @_;
 685
 686         if ($l->{TYPE} eq "POINTER") {
 687                 $self->ConvertObjectToPythonLevel($e, GetNextLevel($e, $l), get_value_of($var_name));
 688         } elsif ($l->{TYPE} eq "ARRAY") {
 689                 $self->ConvertObjectToPythonLevel($e, GetNextLevel($e, $l), $var_name."[i]");
 690         } elsif ($l->{TYPE} eq "SWITCH") {
 691                 $self->ConvertObjectToPythonLevel($e, GetNextLevel($e, $l), $var_name);
 692         } elsif ($l->{TYPE} eq "DATA") {
 693                 if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or
 694                         Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
 695                         $var_name = get_pointer_to($var_name);
 696                 }
 697                 $self->ConvertObjectToPythonData($l->{DATA_TYPE}, $var_name);
 698         } else {
 699                 die("Unknown level type $l->{TYPE} $var_name");
 700         }
 701 }
 702
 703 sub ConvertObjectToPython($$$)
 704 {
 705         my ($self, $ctype, $cvar) = @_;
 706
 707         $self->ConvertObjectToPythonLevel($ctype, $ctype->{LEVELS}[0], $cvar);
 708 }
 709
 710 sub Parse($$$$$)
 711 {
 712     my($self,$basename,$ndr,$ndr_hdr,$hdr) = @_;
 713
 714     my $py_hdr = $hdr;
 715     $py_hdr =~ s/ndr_([^\/]+)$/py_$1/g;
 716
 717     $self->pidl_hdr("/* header auto-generated by pidl */\n\n");
 718
 719     $self->pidl("
 720 /* Python wrapper functions auto-generated by pidl */
 721 #include \"includes.h\"
 722 #include <Python.h>
 723 #include \"librpc/rpc/dcerpc.h\"
 724 #include \"scripting/python/pytalloc.h\"
 725 #include \"$hdr\"
 726 #include \"$ndr_hdr\"
 727 #include \"$py_hdr\"
 728
 729 #define PY_CHECK_TYPE(type, var, fail) \\
 730         if (!type ## _Check(var)) {\\
 731                 PyErr_Format(PyExc_TypeError, \"Expected type %s\", type ## _Type.tp_name); \\
 732                 fail; \\
 733         }
 734 ");
 735
 736         foreach my $x (@$ndr) {
 737             ($x->{TYPE} eq "INTERFACE") && $self->Interface($x, $basename);
 738                 ($x->{TYPE} eq "IMPORT") && $self->Import(@{$x->{PATHS}});
 739         }
 740
 741         $self->pidl("static PyMethodDef $basename\_methods[] = {");
 742         $self->indent;
 743         foreach (@{$self->{module_methods}}) {
 744                 my ($fn_name, $pyfn_name, $flags, $doc) = @$_;
 745                 $self->pidl("{ \"$fn_name\", (PyCFunction)$pyfn_name, $flags, $doc },");
 746         }
 747
 748         $self->pidl("{ NULL, NULL, 0, NULL }");
 749         $self->deindent;
 750         $self->pidl("};");
 751
 752         $self->pidl("");
 753
 754         $self->pidl("void init$basename(void)");
 755         $self->pidl("{");
 756         $self->indent;
 757         $self->pidl("PyObject *m;");
 758         $self->pidl("m = Py_InitModule(\"$basename\", $basename\_methods);");
 759         foreach my $name (keys %{$self->{constants}}) {
 760                 my $py_obj;
 761                 my ($ctype, $cvar) = @{$self->{constants}->{$name}};
 762                 if ($cvar =~ /^[0-9]+$/ or $cvar =~ /^0x[0-9a-fA-F]+$/) {
 763                         $py_obj = "PyInt_FromLong($cvar)";
 764                 } elsif ($cvar =~ /^".*"$/) {
 765                         $py_obj = "PyString_FromString($cvar)";
 766                 } else {
 767                         $py_obj = $self->ConvertObjectToPythonData($ctype, $cvar);
 768                 }
 769
 770                 $self->pidl("PyModule_AddObject(m, \"$name\", $py_obj);");
 771         }
 772         $self->deindent;
 773         $self->pidl("}");
 774     return ($self->{res_hdr}, $self->{res});
 775 }
 776
 777 1;