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