source/build/pidl/swig.pm

   1 ###################################################
   2 # Samba4 parser generator for swig wrappers
   3 # Copyright tpot@samba.org 2004
   4 # released under the GNU GPL
   5
   6 package IdlSwig;
   7
   8 use strict;
   9
  10 # Some build farm machines don't have the Data::Dumper module installed
  11
  12 eval("use Data::Dumper");
  13
  14 my(%interfaces, %functions, %structs, %unions);
  15
  16 sub isunion($)
  17 {
  18     my($name) = shift;
  19
  20     return $unions{$name};
  21 }
  22
  23 # Generate code to convert a Python object to an array
  24
  25 sub ArrayFromPython($$)
  26 {
  27     my($e) = shift;
  28     my($prefix) = shift;
  29     my($result) = "";
  30
  31     my($size);
  32
  33     if (util::has_property($e, "size_is")) {
  34         $size = util::has_property($e, "size_is");
  35     } else {
  36         $size = $e->{ARRAY_LEN};
  37     }
  38
  39     if (util::has_property($e, "length_is")) {
  40         $size = util::has_property($e, "length_is");
  41     }
  42
  43     if (!util::is_constant($size)) {
  44         $size = "s->$prefix$size";
  45     }
  46
  47     my($type) = $e->{TYPE};
  48
  49     if (!util::is_scalar_type($type)) {
  50         $type = "struct $type";
  51     }
  52
  53     if (!util::is_constant($e->{ARRAY_LEN})) {
  54         $result .= "\ts->$prefix$e->{NAME} = talloc(mem_ctx, $size * sizeof($type));\n";
  55     }
  56
  57     $result .= "\tif (!PyDict_GetItemString(obj, \"$e->{NAME}\")) {\n";
  58     $result .= "\t\tPyErr_Format(PyExc_ValueError, \"Expecting key '$e->{NAME}'\");\n";
  59     $result .= "\t\treturn NULL;\n";
  60     $result .= "\t}\n\n";
  61
  62     $result .= "\tif (!PyList_Check(PyDict_GetItemString(obj, \"$e->{NAME}\"))) {\n";
  63     $result .= "\t\tPyErr_Format(PyExc_TypeError, \"Expecting list value for key '$e->{NAME}'\");\n";
  64     $result .= "\t\treturn NULL;\n";
  65     $result .= "\t}\n\n";
  66
  67     $result .= "\t{\n";
  68
  69     $result .= "\t\tint i;\n\n";
  70     $result .= "\t\tfor (i = 0; i < $size; i++) {\n";
  71     if (util::is_scalar_type($e->{TYPE})) {
  72         $result .= "\t\t\ts->$prefix$e->{NAME}\[i\] = $e->{TYPE}_from_python(PyList_GetItem(PyDict_GetItemString(obj, \"$e->{NAME}\"), i), \"$e->{NAME}\");\n";
  73     } else {
  74         $result .= "\t\t\t$e->{TYPE}_from_python(mem_ctx, &s->$prefix$e->{NAME}\[i\], PyList_GetItem(PyDict_GetItemString(obj, \"$e->{NAME}\"), i), \"$e->{NAME}\");\n";
  75     }
  76     $result .= "\t\t}\n";
  77
  78     $result .= "\t}\n";
  79
  80     return $result;
  81 }
  82
  83 # Generate code to convert a Python object to a structure field
  84
  85 sub FieldFromPython($$)
  86 {
  87     my($e) = shift;
  88     my($prefix) = shift;
  89     my($result) = "";
  90     my($obj) = "PyDict_GetItemString(obj, \"$e->{NAME}\")";
  91
  92     # Special cases
  93
  94     if ($e->{TYPE} eq "string") {
  95         $result .= "\ts->$prefix$e->{NAME} = string_ptr_from_python(mem_ctx, $obj, \"$e->{NAME}\");\n";
  96         return $result;
  97     }
  98
  99     if ($e->{TYPE} eq "DATA_BLOB") {
 100         $result .= "\tDATA_BLOB_ptr_from_python(mem_ctx, &s->$prefix$e->{NAME}, $obj, \"$e->{NAME}\");\n";
 101         return $result;
 102     }
 103
 104     # Generate conversion for element
 105
 106     if (util::is_scalar_type($e->{TYPE})) {
 107
 108         if ($e->{POINTERS} == 0) {
 109             if ($e->{ARRAY_LEN}) {
 110                 $result .= ArrayFromPython($e, $prefix);
 111             } else {
 112                 if (util::has_property($e, "value")) {
 113                     $result .= "\ts->$prefix$e->{NAME} = 0;\n";
 114                 } else {
 115                     $result .= "\ts->$prefix$e->{NAME} = $e->{TYPE}_from_python($obj, \"$e->{NAME}\");\n";
 116                 }
 117             }
 118         } else {
 119             $result .= "\ts->$prefix$e->{NAME} = talloc(mem_ctx, sizeof($e->{TYPE}));\n";
 120             $result .= "\t*s->$prefix$e->{NAME} = $e->{TYPE}_from_python($obj, \"$e->{NAME}\");\n";
 121         }
 122     } else {
 123         if ($e->{POINTERS} == 0) {
 124             if ($e->{ARRAY_LEN}) {
 125                 $result .= ArrayFromPython($e, $prefix);
 126             } else {
 127                 $result .= "\t$e->{TYPE}_from_python(mem_ctx, &s->$prefix$e->{NAME}, $obj, \"$e->{NAME}\");\n";
 128             }
 129         } else {
 130             if ($e->{ARRAY_LEN} or util::has_property($e, "size_is")) {
 131                 $result .= ArrayFromPython($e, $prefix);
 132             } else {
 133                 $result .= "\ts->$prefix$e->{NAME} = $e->{TYPE}_ptr_from_python(mem_ctx, $obj, \"$e->{NAME}\");\n";
 134             }
 135         }
 136     }
 137
 138     return $result;
 139 }
 140
 141 # Generate code to convert an array to a Python object
 142
 143 sub ArrayToPython($$)
 144 {
 145     my($e) = shift;
 146     my($prefix) = shift;
 147     my($result) = "";
 148
 149     my($array_len) = util::array_size($e);
 150
 151     if ($array_len eq "*" or util::has_property($e, "size_is")) {
 152         $array_len = util::has_property($e, "size_is");
 153     }
 154
 155     if (!util::is_constant($array_len)) {
 156         $array_len = "s->$prefix$array_len";
 157     }
 158
 159     my($type) = $e->{TYPE};
 160
 161     if (!util::is_scalar_type($type)) {
 162         $type = "struct $type";
 163     }
 164
 165     $result .= "\n\t{\n";
 166     $result .= "\t\tPyObject *temp;\n";
 167     $result .= "\t\tint i;\n\n";
 168
 169     $result .= "\t\ttemp = PyList_New($array_len);\n\n";
 170     $result .= "\t\tfor (i = 0; i < $array_len; i++) {\n";
 171     if (util::is_scalar_type($e->{TYPE})) {
 172         $result .= "\t\t\tPyList_SetItem(temp, i, $e->{TYPE}_to_python(s->$prefix$e->{NAME}\[i\]));\n";
 173     } else {
 174         $result .= "\t\t\tPyList_SetItem(temp, i, $e->{TYPE}_ptr_to_python(mem_ctx, &s->$prefix$e->{NAME}\[i\]));\n";
 175     }
 176     $result .= "\t\t}\n";
 177
 178     $result .= "\t\tPyDict_SetItemString(obj, \"$e->{NAME}\", temp);\n";
 179
 180     $result .= "\t}\n";
 181
 182     return $result;
 183 }
 184
 185 # Generate code to convert a structure field to a Python object
 186
 187 sub FieldToPython($$)
 188 {
 189     my($e) = shift;
 190     my($prefix) = shift;
 191     my($result) = "";
 192
 193     # Special cases
 194
 195     if ($e->{TYPE} eq "string") {
 196         $result .= "\tPyDict_SetItemString(obj, \"$e->{NAME}\", string_ptr_to_python(mem_ctx, s->$prefix$e->{NAME}));\n";
 197         return $result;
 198     }
 199
 200     # Generate conversion for scalars and structures
 201
 202     if (util::is_scalar_type($e->{TYPE})) {
 203         if ($e->{POINTERS} == 0) {
 204             if ($e->{ARRAY_LEN}) {
 205                 $result .= ArrayToPython($e, $prefix);
 206             } else {
 207                 $result .= "\tPyDict_SetItemString(obj, \"$e->{NAME}\", $e->{TYPE}_to_python(s->$prefix$e->{NAME}));\n";
 208             }
 209         } else {
 210             if ($e->{ARRAY_LEN} or util::has_property($e, "size_is")) {
 211                 $result .= ArrayToPython($e, $prefix);
 212             } else {
 213                 $result .= "\tif (s->$prefix$e->{NAME})\n";
 214                 $result .= "\t\tPyDict_SetItemString(obj, \"$e->{NAME}\", $e->{TYPE}_to_python(*s->$prefix$e->{NAME}));\n";
 215                 $result .= "\telse\n";
 216                 $result .= "\t\tPyDict_SetItemString(obj, \"$e->{NAME}\", Py_None);\n";
 217             }
 218         }
 219     } else {
 220
 221         my($extra_args) = "";
 222
 223         if (isunion($e->{TYPE})) {
 224             $extra_args = ", $e->{NAME}_switch_is";
 225         }
 226
 227         if ($e->{POINTERS} == 0) {
 228             if ($e->{ARRAY_LEN}) {
 229                 $result .= ArrayToPython($e, $prefix);
 230             } else {
 231                 $result .= "\tPyDict_SetItemString(obj, \"$e->{NAME}\", $e->{TYPE}_ptr_to_python(mem_ctx, &s->$prefix$e->{NAME}$extra_args));\n";
 232             }
 233         } else {
 234             if ($e->{ARRAY_LEN} or util::has_property($e, "size_is")) {
 235                 $result .= ArrayToPython($e, $prefix);
 236             } else {
 237                 $result .= "\tPyDict_SetItemString(obj, \"$e->{NAME}\", $e->{TYPE}_ptr_to_python(mem_ctx, s->$prefix$e->{NAME}$extra_args));\n";
 238             }
 239         }
 240     }
 241
 242     return $result;
 243 }
 244
 245 sub ParseFunction($)
 246 {
 247     my($fn) = shift;
 248     my($result) = "";
 249
 250     $result .= "%{\n\n";
 251
 252     $result .= "/*\n\n";
 253     $result .= IdlDump::DumpFunction($fn);
 254     $result .= "*/\n\n";
 255
 256     # Generate function to convert Python dict to structure pointer
 257
 258     $result .= "/* Convert Python dict to struct $fn->{NAME}.in */\n\n";
 259
 260     $result .= "struct $fn->{NAME} *$fn->{NAME}_ptr_from_python(TALLOC_CTX *mem_ctx, PyObject *obj, char *name)\n";
 261     $result .= "{\n";
 262
 263     $result .= "\tstruct $fn->{NAME} *s;\n\n";
 264
 265     $result .= "\tif (!PyDict_Check(obj)) {\n";
 266     $result .= "\t\tPyErr_Format(PyExc_TypeError, \"Expecting dict value for key '%s'\", name);\n";
 267     $result .= "\t\t\treturn NULL;\n";
 268     $result .= "\t}\n\n";
 269
 270     $result .= "\ts = talloc(mem_ctx, sizeof(struct $fn->{NAME}));\n\n";
 271
 272     # Remove this when all elements are initialised
 273     $result .= "\tmemset(s, 0, sizeof(struct $fn->{NAME}));\n\n";
 274
 275     foreach my $e (@{$fn->{DATA}}) {
 276         if (util::has_property($e, "in")) {
 277             if (util::has_property($e, "ref")) {
 278                 $result .= "\tif (PyDict_GetItemString(obj, \"$e->{NAME}\") == Py_None) {\n";
 279                 $result .= "\t\tPyErr_Format(PyExc_ValueError, \"Key '$e->{NAME}' cannot be None\");\n";
 280                 $result .= "\t\treturn NULL;\n";
 281                 $result .= "\t}\n";
 282             }
 283             $result .= FieldFromPython($e, "in.") ;
 284         }
 285     }
 286
 287     $result .= "\n";
 288     $result .= "\treturn s;\n";
 289     $result .= "}\n\n";
 290
 291     # Generate function to convert structure pointer to Python dict
 292
 293     $result .= "/* Convert struct $fn->{NAME}.out to Python dict */\n\n";
 294
 295     $result .= "PyObject *$fn->{NAME}_ptr_to_python(TALLOC_CTX *mem_ctx, struct $fn->{NAME} *s";
 296
 297     foreach my $e (@{$fn->{DATA}}) {
 298         if (isunion($e->{TYPE})) {
 299             $result .= ", int $e->{NAME}_switch_is";
 300         }
 301     }
 302     $result .= ")\n";
 303
 304     $result .= "{\n";
 305
 306     $result .= "\tPyObject *obj = PyDict_New();\n\n";
 307
 308     foreach my $e (@{$fn->{DATA}}) {
 309         $result .= FieldToPython($e, "out.") if util::has_property($e, "out")
 310     }
 311
 312     $result .= "\n";
 313     $result .= "\treturn obj;\n";
 314     $result .= "}\n\n";
 315
 316     $result .= "%}\n\n";
 317
 318     # Input typemap
 319
 320     $result .= "%typemap(in) struct $fn->{NAME} * {\n";
 321     $result .= "\tTALLOC_CTX *mem_ctx = talloc_init(\"typemap(int) $fn->{NAME}\");\n\n";
 322
 323     $result .= "\t\$1 = $fn->{NAME}_ptr_from_python(mem_ctx, \$input, \"<function params>\");\n\n";
 324
 325     $result .= "\tif (PyErr_Occurred()) return NULL;\n\n";
 326
 327     $result .= "}\n\n";
 328
 329     # Output typemap
 330
 331     $result .= "%typemap(argout) struct $fn->{NAME} * (PyObject *temp) {\n";
 332     $result .= "\tTALLOC_CTX *mem_ctx = talloc_init(\"typemap(argout) $fn->{NAME}\");\n\n";
 333
 334     $result .= "\ttemp = $fn->{NAME}_ptr_to_python(mem_ctx, \$1";
 335
 336     foreach my $e (@{$fn->{DATA}}) {
 337         if ((my $switch_is = util::has_property($e, "switch_is"))) {
 338             $result .= ", \$1->in.$switch_is";
 339         }
 340     }
 341
 342     $result .= ");\n\n";
 343
 344     if ($fn->{RETURN_TYPE} eq "NTSTATUS") {
 345         $result .= "\tPyDict_SetItemString(temp, \"result\", resultobj);\n";
 346     } else {
 347         $result .= "\tPyDict_SetItemString(temp, \"result\", PyLong_FromLong(W_ERROR_V(arg3->out.result)));\n";
 348     }
 349
 350     $result .= "\n";
 351
 352     $result .= "\tresultobj = temp;\n\n";
 353
 354
 355
 356     $result .= "\tif (NT_STATUS_IS_ERR(result)) {\n";
 357     $result .= "\t\tset_ntstatus_exception(NT_STATUS_V(result));\n";
 358     $result .= "\t\tgoto fail;\n";
 359     $result .= "\t}\n";
 360
 361     if (!($fn->{RETURN_TYPE} eq "NTSTATUS")) {
 362         $result .= "\tif (!W_ERROR_IS_OK(arg3->out.result) && \n";
 363         $result .= "\t\t!(W_ERROR_EQUAL(arg3->out.result, WERR_INSUFFICIENT_BUFFER))) {\n";
 364         $result .= "\t\tset_werror_exception(W_ERROR_V(arg3->out.result));\n";
 365         $result .= "\t\tgoto fail;\n";
 366         $result .= "\t}\n";
 367     }
 368
 369     $result .= "}\n\n";
 370
 371     # Function definitions
 372
 373     $result .= "%rename($fn->{NAME}) dcerpc_$fn->{NAME};\n";
 374     $result .= "NTSTATUS dcerpc_$fn->{NAME}(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $fn->{NAME} *r);\n\n";
 375
 376     return $result;
 377 }
 378
 379 sub ParseStruct($)
 380 {
 381     my($s) = shift;
 382     my($result) = "";
 383
 384     $result .= "%{\n\n";
 385
 386     $result .= "/*\n\n";
 387     $result .= IdlDump::DumpTypedef($s);
 388     $result .= "*/\n\n";
 389
 390     # Generate function to convert Python dict to structure pointer
 391
 392     $result .= "/* Convert Python dict to struct $s->{NAME} pointer */\n\n";
 393
 394     $result .= "struct $s->{NAME} *$s->{NAME}_ptr_from_python(TALLOC_CTX *mem_ctx, PyObject *obj, char *name)\n";
 395     $result .= "{\n";
 396     $result .= "\tstruct $s->{NAME} *s;\n\n";
 397
 398     $result .= "\tif (obj == NULL) {\n";
 399     $result .= "\t\tPyErr_Format(PyExc_ValueError, \"Expecting key '%s'\", name);\n";
 400     $result .= "\t\treturn NULL;\n";
 401     $result .= "\t}\n\n";
 402
 403     $result .= "\tif (obj == Py_None) return NULL;\n\n";
 404
 405     $result .= "\tif (!PyDict_Check(obj)) {\n";
 406     $result .= "\t\tPyErr_Format(PyExc_TypeError, \"Expecting dict value for key '%s'\", name);\n";
 407     $result .= "\t\treturn NULL;\n";
 408     $result .= "\t}\n\n";
 409
 410     $result .= "\ts = talloc(mem_ctx, sizeof(struct $s->{NAME}));\n\n";
 411
 412     foreach my $e (@{$s->{DATA}{ELEMENTS}}) {
 413         $result .= FieldFromPython($e, "");
 414     }
 415
 416     $result .= "\n";
 417     $result .= "\treturn s;\n";
 418     $result .= "}\n\n";
 419
 420     # Generate function to convert Python dict to structure
 421
 422     $result .= "/* Convert Python dict to struct $s->{NAME} */\n\n";
 423
 424     $result .= "void $s->{NAME}_from_python(TALLOC_CTX *mem_ctx, struct $s->{NAME} *s, PyObject *obj, char *name)\n";
 425     $result .= "{\n";
 426
 427     $result .= "\tif (obj == NULL) {\n";
 428     $result .= "\t\tPyErr_Format(PyExc_ValueError, \"Expecting key '%s'\", name);\n";
 429     $result .= "\t\treturn;\n";
 430     $result .= "\t}\n\n";
 431
 432     $result .= "\tif (!PyDict_Check(obj)) {\n";
 433     $result .= "\t\tPyErr_Format(PyExc_TypeError, \"Expecting dict value for key '%s'\", name);\n";
 434     $result .= "\t\treturn;\n";
 435     $result .= "\t}\n\n";
 436
 437     foreach my $e (@{$s->{DATA}{ELEMENTS}}) {
 438         $result .= FieldFromPython($e, "");
 439     }
 440
 441     $result .= "}\n\n";
 442
 443     # Generate function to convert structure pointer to Python dict
 444
 445     $result .= "/* Convert struct $s->{NAME} pointer to Python dict */\n\n";
 446
 447     $result .= "PyObject *$s->{NAME}_ptr_to_python(TALLOC_CTX *mem_ctx, struct $s->{NAME} *s)\n";
 448     $result .= "{\n";
 449
 450     $result .= "\tPyObject *obj;\n\n";
 451
 452     $result .= "\tif (s == NULL) {\n";
 453     $result .= "\t\tPy_INCREF(Py_None);\n";
 454     $result .= "\t\treturn Py_None;\n";
 455     $result .= "\t}\n\n";
 456
 457     $result .= "\tobj = PyDict_New();\n\n";
 458
 459     foreach my $e (@{$s->{DATA}{ELEMENTS}}) {
 460         $result .= FieldToPython($e, "");
 461     }
 462
 463     $result .= "\n";
 464     $result .= "\treturn obj;\n";
 465     $result .= "}\n";
 466
 467     # Generate function to convert DATA_BLOB to Python dict
 468
 469     if (util::has_property($s, "public")) {
 470         $result .= "/* Convert DATA_BLOB to python dict of struct $s->{NAME} */\n\n";
 471
 472         $result .= "NTSTATUS DATA_BLOB_to_python_$s->{NAME}(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, PyObject **obj)\n";
 473         $result .= "{\n";
 474         $result .= "\tstruct $s->{NAME} s;\n";
 475         $result .= "\tNTSTATUS result = ndr_pull_struct_blob(blob, mem_ctx, &s, ndr_pull_$s->{NAME});\n\n";
 476         $result .= "\treturn NT_STATUS_OK;\n";
 477         $result .= "}\n";
 478     }
 479
 480     $result .= "\n%}\n\n";
 481
 482     return $result;
 483 }
 484
 485 sub ParseUnion($)
 486 {
 487     my($u) = shift;
 488     my($result) = "";
 489
 490     $result .= "/*\n\n";
 491     $result .= IdlDump::DumpTypedef($u);
 492     $result .= "*/\n\n";
 493
 494     # Generate function to convert Python dict to union pointer
 495
 496     $result .= "%{\n\n";
 497     $result .= "/* Convert Python dict to union $u->{NAME} pointer */\n\n";
 498
 499     $result .= "union $u->{NAME} *$u->{NAME}_ptr_from_python(TALLOC_CTX *mem_ctx, PyObject *obj, char *name)\n";
 500     $result .= "{\n";
 501
 502     $result .= "\tunion $u->{NAME} *u;\n";
 503     $result .= "\tPyObject *dict;\n\n";
 504
 505     $result .= "\tif (obj == NULL) {\n";
 506     $result .= "\t\tPyErr_Format(PyExc_ValueError, \"Expecting key '%s'\", name);\n";
 507     $result .= "\t\treturn NULL;\n";
 508     $result .= "\t}\n\n";
 509
 510     $result .= "\tif (!PyDict_Check(obj)) {\n";
 511     $result .= "\t\tPyErr_Format(PyExc_TypeError, \"Expecting dict value for key '%s'\", name);\n";
 512     $result .= "\t\treturn NULL;\n";
 513     $result .= "\t}\n\n";
 514
 515     $result .= "\tu = talloc(mem_ctx, sizeof(union $u->{NAME}));\n\n";
 516
 517     for my $e (@{$u->{DATA}{DATA}}) {
 518             if (defined $e->{DATA}{NAME}) {
 519                     $result .= "\tif ((dict = PyDict_GetItemString(obj, \"$e->{DATA}{NAME}\"))) {\n";
 520                     if ($e->{DATA}{POINTERS} == 0) {
 521                             $result .= "\t\t$e->{DATA}{TYPE}_from_python(mem_ctx, &u->$e->{DATA}{NAME}, dict, \"$e->{DATA}{NAME}\");\n";
 522                     } elsif ($e->{DATA}{POINTERS} == 1) {
 523                             $result .= "\t\tu->$e->{DATA}{NAME} = $e->{DATA}{TYPE}_ptr_from_python(mem_ctx, dict, \"$e->{DATA}{NAME}\");\n";
 524                     } else {
 525                             $result .= "\t\t// $e->{DATA}{TYPE} pointers=$e->{DATA}{POINTERS}\n";
 526                     }
 527             }
 528
 529         $result .= "\t\treturn u;\n";
 530         $result .= "\t}\n\n";
 531     }
 532
 533     $result .= "\treturn NULL;\n";
 534     $result .= "}\n\n";
 535
 536     # Generate function to convert Python dict to union
 537
 538     $result .= "/* Convert Python dict to union $u->{NAME} */\n\n";
 539
 540     $result .= "void $u->{NAME}_from_python(TALLOC_CTX *mem_ctx, union $u->{NAME} *u, PyObject *obj, char *name)\n";
 541     $result .= "{\n";
 542     $result .= "\tPyObject *dict;\n\n";
 543
 544     $result .= "\tif (obj == NULL) {\n";
 545     $result .= "\t\tPyErr_Format(PyExc_ValueError, \"Expecting key '%s'\", name);\n";
 546     $result .= "\t\treturn;\n";
 547     $result .= "\t}\n\n";
 548
 549     $result .= "\tif (!PyDict_Check(obj)) {\n";
 550     $result .= "\t\tPyErr_Format(PyExc_TypeError, \"Expecting dict value for key '%s'\", name);\n";
 551     $result .= "\t\treturn;\n";
 552     $result .= "\t}\n\n";
 553
 554     for my $e (@{$u->{DATA}{DATA}}) {
 555             if (defined $e->{DATA}{NAME}) {
 556         $result .= "\tif ((dict = PyDict_GetItemString(obj, \"$e->{DATA}{NAME}\"))) {\n";
 557         if ($e->{DATA}{POINTERS} == 0) {
 558             $result .= "\t\t$e->{DATA}{TYPE}_from_python(mem_ctx, &u->$e->{DATA}{NAME}, dict, \"$e->{DATA}{NAME}\");\n";
 559         } elsif ($e->{DATA}{POINTERS} == 1) {
 560             $result .= "\t\tu->$e->{DATA}{NAME} = $e->{DATA}{TYPE}_ptr_from_python(mem_ctx, dict, \"$e->{DATA}{NAME}\");\n";
 561         } else {
 562             $result .= "\t\t// $e->{DATA}{TYPE} pointers=$e->{DATA}{POINTERS}\n";
 563         }
 564         }
 565         $result .= "\t\treturn;\n";
 566         $result .= "\t}\n\n";
 567     }
 568     $result .= "}\n";
 569
 570     # Generate function to convert union pointer to Python dict
 571
 572     $result .= "/* Convert union $u->{NAME} pointer to Python dict */\n\n";
 573
 574     $result .= "PyObject *$u->{NAME}_ptr_to_python(TALLOC_CTX *mem_ctx, union $u->{NAME} *u, int switch_is)\n";
 575     $result .= "{\n";
 576     $result .= "\tPyObject *obj;\n\n";
 577
 578     $result .= "\tif (u == NULL) {\n";
 579     $result .= "\t\tPy_INCREF(Py_None);\n";
 580     $result .= "\t\treturn Py_None;\n";
 581     $result .= "\t}\n\n";
 582
 583     $result .= "\tobj = PyDict_New();\n\n";
 584
 585     for my $e (@{$u->{DATA}{DATA}}) {
 586         $result .= "\tif (switch_is == $e->{CASE}) {\n";
 587         my $prefix = util::c_pull_prefix($e);
 588         if (defined $e->{DATA}{NAME}) {
 589                 $result .= "\t\tPyDict_SetItemString(obj, \"$e->{DATA}{NAME}\", $e->{DATA}{TYPE}_ptr_to_python(mem_ctx, ${prefix}u->$e->{DATA}{NAME}));\n";
 590         }
 591         $result .= "\t}\n";
 592     }
 593
 594     $result .= "\treturn obj;\n";
 595
 596     $result .= "}\n\n";
 597
 598     $result .= "\n%}\n\n";
 599
 600     return $result;
 601 }
 602
 603 sub ParseTypedef($)
 604 {
 605     my($t) = shift;
 606     my($result) = "";
 607
 608     foreach my $e ($t) {
 609         $result .= ParseStruct($e) if $e->{DATA}{TYPE} eq "STRUCT";
 610         $result .= ParseUnion($e) if $e->{DATA}{TYPE} eq "UNION";
 611     }
 612
 613     return $result;
 614 }
 615
 616 sub ParseInheritedData($)
 617 {
 618     my($data) = shift;
 619     my($result) = "";
 620
 621     foreach my $e (@{$data}) {
 622         $result .= ParseFunction($e) if $e->{TYPE} eq "FUNCTION";
 623         $result .= ParseTypedef($e) if $e->{TYPE} eq "TYPEDEF";
 624     }
 625
 626     return $result;
 627 }
 628
 629 sub ParseHeader($)
 630 {
 631     my($hdr) = shift;
 632     my($result) = "";
 633
 634     if ($hdr->{PROPERTIES}{uuid}) {
 635         my($name) = $hdr->{NAME};
 636         $result .= "#define DCERPC_" . uc($name) . "_UUID \"$hdr->{PROPERTIES}->{uuid}\"\n";
 637         $result .= "const int DCERPC_" . uc($name) . "_VERSION = " . $hdr->{PROPERTIES}->{version} . ";\n";
 638         $result .= "#define DCERPC_" . uc($name) . "_NAME \"" . $name . "\"\n";
 639         $result .= "\n";
 640     }
 641
 642     $result .= ParseInheritedData($hdr->{INHERITED_DATA});
 643
 644     return $result;
 645 }
 646
 647 sub Parse($)
 648 {
 649     my($idl) = shift;
 650     my($result) = "";
 651
 652     # Make index of functions, structs and unions.  Currently unused.
 653
 654     foreach my $x (@{$idl}) {
 655         my($iname) = $x->{NAME};
 656         $interfaces{$iname} = $x->{PROPERTIES};
 657         foreach my $i (@{$x->{INHERITED_DATA}}) {
 658             $functions{$i->{NAME}} = $i if $i->{TYPE} eq "FUNCTION";
 659             if ($i->{TYPE} eq "TYPEDEF") {
 660                 $structs{$i->{NAME}} = $i->{DATA} if $i->{DATA}{TYPE} eq "STRUCT";
 661                 $unions{$i->{NAME}} = $i->{DATA} if $i->{DATA}{TYPE} eq "UNION";
 662             }
 663         }
 664     }
 665
 666     # Generate interface
 667
 668     $result .= "/* Auto-generated by pidl. Tastes like -*- C -*-. */\n\n";
 669
 670     foreach my $x (@{$idl}) {
 671         $result .= ParseHeader($x) if ($x->{TYPE} eq "INTERFACE");
 672     }
 673
 674     return $result;
 675 }
 676
 677 1;