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 '%s'\", \"$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 '%s'\", \"$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" && $e->{POINTERS} == 1) {
  95         $result .= "\ts->$prefix$e->{NAME} = string_ptr_from_python(mem_ctx, $obj, \"$e->{NAME}\");\n";
  96         return $result;
  97     }
  98
  99     # Generate conversion for element
 100
 101     if (util::is_scalar_type($e->{TYPE})) {
 102
 103         if ($e->{POINTERS} == 0) {
 104             if ($e->{ARRAY_LEN}) {
 105                 $result .= ArrayFromPython($e, $prefix);
 106             } else {
 107                 $result .= "\ts->$prefix$e->{NAME} = $e->{TYPE}_from_python($obj, \"$e->{NAME}\");\n";
 108             }
 109         } else {
 110             $result .= "\ts->$prefix$e->{NAME} = talloc(mem_ctx, sizeof($e->{TYPE}));\n";
 111             $result .= "\t*s->$prefix$e->{NAME} = $e->{TYPE}_from_python($obj, \"$e->{NAME}\");\n";
 112         }
 113     } else {
 114         if ($e->{POINTERS} == 0) {
 115             if ($e->{ARRAY_LEN}) {
 116                 $result .= ArrayFromPython($e, $prefix);
 117             } else {
 118                 $result .= "\t$e->{TYPE}_from_python(mem_ctx, &s->$prefix$e->{NAME}, $obj, \"$e->{NAME}\");\n";
 119             }
 120         } else {
 121             if ($e->{ARRAY_LEN} or util::has_property($e, "size_is")) {
 122                 $result .= ArrayFromPython($e, $prefix);
 123             } else {
 124                 $result .= "\ts->$prefix$e->{NAME} = $e->{TYPE}_ptr_from_python(mem_ctx, $obj, \"$e->{NAME}\");\n";
 125             }
 126         }
 127     }
 128
 129     return $result;
 130 }
 131
 132 # Generate code to convert an array to a Python object
 133
 134 sub ArrayToPython($$)
 135 {
 136     my($e) = shift;
 137     my($prefix) = shift;
 138     my($result) = "";
 139
 140     my($array_len) = $e->{ARRAY_LEN};
 141
 142     if ($array_len eq "*" or util::has_property($e, "size_is")) {
 143         $array_len = util::has_property($e, "size_is");
 144     }
 145
 146     if (!util::is_constant($array_len)) {
 147         $array_len = "s->$prefix$array_len";
 148     }
 149
 150     my($type) = $e->{TYPE};
 151
 152     if (!util::is_scalar_type($type)) {
 153         $type = "struct $type";
 154     }
 155
 156     $result .= "\n\t{\n";
 157     $result .= "\t\tPyObject *temp;\n";
 158     $result .= "\t\tint i;\n\n";
 159
 160     $result .= "\t\ttemp = PyList_New($array_len);\n\n";
 161     $result .= "\t\tfor (i = 0; i < $array_len; i++) {\n";
 162     if (util::is_scalar_type($e->{TYPE})) {
 163         $result .= "\t\t\tPyList_SetItem(temp, i, $e->{TYPE}_to_python(s->$prefix$e->{NAME}\[i\]));\n";
 164     } else {
 165         $result .= "\t\t\tPyList_SetItem(temp, i, $e->{TYPE}_ptr_to_python(mem_ctx, &s->$prefix$e->{NAME}\[i\]));\n";
 166     }
 167     $result .= "\t\t}\n";
 168
 169     $result .= "\t\tPyDict_SetItemString(obj, \"$e->{NAME}\", temp);\n";
 170
 171     $result .= "\t}\n";
 172
 173     return $result;
 174 }
 175
 176 # Generate code to convert a structure field to a Python object
 177
 178 sub FieldToPython($$)
 179 {
 180     my($e) = shift;
 181     my($prefix) = shift;
 182     my($result) = "";
 183
 184     # Special cases
 185
 186     if ($e->{TYPE} eq "string" && $e->{POINTERS} == 1) {
 187         $result .= "\tPyDict_SetItemString(obj, \"$e->{NAME}\", string_ptr_to_python(mem_ctx, s->$prefix$e->{NAME}));\n";
 188         return $result;
 189     }
 190
 191     # Generate conversion for scalars and structures
 192
 193     if (util::is_scalar_type($e->{TYPE})) {
 194         if ($e->{POINTERS} == 0) {
 195             if ($e->{ARRAY_LEN}) {
 196                 $result .= ArrayToPython($e, $prefix);
 197             } else {
 198                 $result .= "\tPyDict_SetItemString(obj, \"$e->{NAME}\", $e->{TYPE}_to_python(s->$prefix$e->{NAME}));\n";
 199             }
 200         } else {
 201             if ($e->{ARRAY_LEN} or util::has_property($e, "size_is")) {
 202                 $result .= ArrayToPython($e, $prefix);
 203             } else {
 204                 $result .= "\tPyDict_SetItemString(obj, \"$e->{NAME}\", $e->{TYPE}_to_python(*s->$prefix$e->{NAME}));\n";
 205             }
 206         }
 207     } else {
 208
 209         my($extra_args) = "";
 210
 211         if (isunion($e->{TYPE})) {
 212             $extra_args = ", switch_is";
 213         }
 214
 215         if ($e->{POINTERS} == 0) {
 216             if ($e->{ARRAY_LEN}) {
 217                 $result .= ArrayToPython($e, $prefix);
 218             } else {
 219                 $result .= "\tPyDict_SetItemString(obj, \"$e->{NAME}\", $e->{TYPE}_ptr_to_python(mem_ctx, &s->$prefix$e->{NAME}$extra_args));\n";
 220             }
 221         } else {
 222             if ($e->{ARRAY_LEN} or util::has_property($e, "size_is")) {
 223                 $result .= ArrayToPython($e, $prefix);
 224             } else {
 225                 $result .= "\tPyDict_SetItemString(obj, \"$e->{NAME}\", $e->{TYPE}_ptr_to_python(mem_ctx, s->$prefix$e->{NAME}$extra_args));\n";
 226             }
 227         }
 228     }
 229
 230     return $result;
 231 }
 232
 233 sub ParseFunction($)
 234 {
 235     my($fn) = shift;
 236     my($result) = "";
 237
 238     $result .= "%{\n\n";
 239
 240     $result .= "/*\n\n";
 241     $result .= IdlDump::DumpFunction($fn);
 242     $result .= "*/\n\n";
 243
 244     # Generate function to convert Python dict to structure pointer
 245
 246     $result .= "/* Convert Python dict to struct $fn->{NAME}.in */\n\n";
 247
 248     $result .= "struct $fn->{NAME} *$fn->{NAME}_ptr_from_python(TALLOC_CTX *mem_ctx, PyObject *obj, char *name)\n";
 249     $result .= "{\n";
 250
 251     $result .= "\tstruct $fn->{NAME} *s;\n\n";
 252
 253     $result .= "\tif (!PyDict_Check(obj)) {\n";
 254     $result .= "\t\tPyErr_Format(PyExc_TypeError, \"Expecting dict value for key '%s'\", name);\n";
 255     $result .= "\t\t\treturn NULL;\n";
 256     $result .= "\t}\n\n";
 257
 258     $result .= "\ts = talloc(mem_ctx, sizeof(struct $fn->{NAME}));\n\n";
 259
 260     # Remove this when all elements are initialised
 261     $result .= "\tmemset(s, 0, sizeof(struct $fn->{NAME}));\n\n";
 262
 263     foreach my $e (@{$fn->{DATA}}) {
 264         if (util::has_property($e, "in")) {
 265             if (util::has_property($e, "ref")) {
 266                 $result .= "\tif (PyDict_GetItemString(obj, \"$e->{NAME}\") == Py_None) {\n";
 267                 $result .= "\t\tPyErr_Format(PyExc_ValueError, \"Key '$e->{NAME}' cannot be None\");\n";
 268                 $result .= "\t\treturn NULL;\n";
 269                 $result .= "\t}\n";
 270             }
 271             $result .= FieldFromPython($e, "in.") ;
 272         }
 273     }
 274
 275     $result .= "\n";
 276     $result .= "\treturn s;\n";
 277     $result .= "}\n\n";
 278
 279     # Generate function to convert structure pointer to Python dict
 280
 281     $result .= "/* Convert struct $fn->{NAME}.out to Python dict */\n\n";
 282
 283     $result .= "PyObject *$fn->{NAME}_ptr_to_python(TALLOC_CTX *mem_ctx, struct $fn->{NAME} *s";
 284
 285     foreach my $e (@{$fn->{DATA}}) {
 286         if (isunion($e->{TYPE})) {
 287             $result .= ", int switch_is";
 288         }
 289     }
 290     $result .= ")\n";
 291
 292     $result .= "{\n";
 293
 294     $result .= "\tPyObject *obj = PyDict_New();\n\n";
 295
 296     foreach my $e (@{$fn->{DATA}}) {
 297         $result .= FieldToPython($e, "out.") if util::has_property($e, "out")
 298     }
 299
 300     $result .= "\n";
 301     $result .= "\treturn obj;\n";
 302     $result .= "}\n\n";
 303
 304     $result .= "%}\n\n";
 305
 306     # Input typemap
 307
 308     $result .= "%typemap(in) struct $fn->{NAME} * {\n";
 309     $result .= "\tTALLOC_CTX *mem_ctx = talloc_init(\"typemap(int) $fn->{NAME}\");\n\n";
 310
 311     $result .= "\t\$1 = $fn->{NAME}_ptr_from_python(mem_ctx, \$input, \"<function params>\");\n\n";
 312
 313     $result .= "\tif (PyErr_Occurred()) return NULL;\n\n";
 314
 315     $result .= "}\n\n";
 316
 317     # Output typemap
 318
 319     $result .= "%typemap(argout) struct $fn->{NAME} * (PyObject *temp) {\n";
 320     $result .= "\tTALLOC_CTX *mem_ctx = talloc_init(\"typemap(argout) $fn->{NAME}\");\n\n";
 321
 322     $result .= "\ttemp = $fn->{NAME}_ptr_to_python(mem_ctx, \$1";
 323
 324     foreach my $e (@{$fn->{DATA}}) {
 325         if ((my $switch_is = util::has_property($e, "switch_is"))) {
 326             $result .= ", \$1->in.$switch_is";
 327         }
 328     }
 329
 330     $result .= ");\n\n";
 331
 332     $result .= "\tPyDict_SetItemString(temp, \"result\", resultobj);\n";
 333     $result .= "\tresultobj = temp;\n";
 334
 335     $result .= "\ttalloc_free(mem_ctx);\n";
 336     $result .= "}\n\n";
 337
 338     # Function definitions
 339
 340     $result .= "%rename($fn->{NAME}) dcerpc_$fn->{NAME};\n";
 341     $result .= "$fn->{RETURN_TYPE} dcerpc_$fn->{NAME}(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $fn->{NAME} *r);\n\n";
 342
 343     return $result;
 344 }
 345
 346 sub ParseStruct($)
 347 {
 348     my($s) = shift;
 349     my($result) = "";
 350
 351     $result .= "%{\n\n";
 352
 353     $result .= "/*\n\n";
 354     $result .= IdlDump::DumpTypedef($s);
 355     $result .= "*/\n\n";
 356
 357     # Generate function to convert Python dict to structure pointer
 358
 359     $result .= "/* Convert Python dict to struct $s->{NAME} pointer */\n\n";
 360
 361     $result .= "struct $s->{NAME} *$s->{NAME}_ptr_from_python(TALLOC_CTX *mem_ctx, PyObject *obj, char *name)\n";
 362     $result .= "{\n";
 363     $result .= "\tstruct $s->{NAME} *s;\n\n";
 364
 365     $result .= "\tif (obj == NULL) {\n";
 366     $result .= "\t\tPyErr_Format(PyExc_ValueError, \"Expecting key '%s'\", name);\n";
 367     $result .= "\t\treturn NULL;\n";
 368     $result .= "\t}\n\n";
 369
 370     $result .= "\tif (obj == Py_None) return NULL;\n\n";
 371
 372     $result .= "\tif (!PyDict_Check(obj)) {\n";
 373     $result .= "\t\tPyErr_Format(PyExc_TypeError, \"Expecting dict value for key '%s'\", name);\n";
 374     $result .= "\t\treturn NULL;\n";
 375     $result .= "\t}\n\n";
 376
 377     $result .= "\ts = talloc(mem_ctx, sizeof(struct $s->{NAME}));\n\n";
 378
 379     foreach my $e (@{$s->{DATA}{ELEMENTS}}) {
 380         $result .= FieldFromPython($e, "");
 381     }
 382
 383     $result .= "\n";
 384     $result .= "\treturn s;\n";
 385     $result .= "}\n\n";
 386
 387     # Generate function to convert Python dict to structure
 388
 389     $result .= "/* Convert Python dict to struct $s->{NAME} */\n\n";
 390
 391     $result .= "void $s->{NAME}_from_python(TALLOC_CTX *mem_ctx, struct $s->{NAME} *s, PyObject *obj, char *name)\n";
 392     $result .= "{\n";
 393
 394     $result .= "\tif (obj == NULL) {\n";
 395     $result .= "\t\tPyErr_Format(PyExc_ValueError, \"Expecting key '%s'\", name);\n";
 396     $result .= "\t\treturn;\n";
 397     $result .= "\t}\n\n";
 398
 399     $result .= "\tif (!PyDict_Check(obj)) {\n";
 400     $result .= "\t\tPyErr_Format(PyExc_TypeError, \"Expecting dict value for key '%s'\", name);\n";
 401     $result .= "\t\treturn;\n";
 402     $result .= "\t}\n\n";
 403
 404     foreach my $e (@{$s->{DATA}{ELEMENTS}}) {
 405         $result .= FieldFromPython($e, "");
 406     }
 407
 408     $result .= "}\n\n";
 409
 410     # Generate function to convert structure pointer to Python dict
 411
 412     $result .= "/* Convert struct $s->{NAME} pointer to Python dict */\n\n";
 413
 414     $result .= "PyObject *$s->{NAME}_ptr_to_python(TALLOC_CTX *mem_ctx, struct $s->{NAME} *s)\n";
 415     $result .= "{\n";
 416
 417     $result .= "\tPyObject *obj;\n\n";
 418
 419     $result .= "\tif (s == NULL) {\n";
 420     $result .= "\t\tPy_INCREF(Py_None);\n";
 421     $result .= "\t\treturn Py_None;\n";
 422     $result .= "\t}\n\n";
 423
 424     $result .= "\tobj = PyDict_New();\n\n";
 425
 426     foreach my $e (@{$s->{DATA}{ELEMENTS}}) {
 427         $result .= FieldToPython($e, "");
 428     }
 429
 430     $result .= "\n";
 431     $result .= "\treturn obj;\n";
 432     $result .= "}\n";
 433
 434     $result .= "\n%}\n\n";
 435
 436     return $result;
 437 }
 438
 439 sub ParseUnion($)
 440 {
 441     my($u) = shift;
 442     my($result) = "";
 443
 444     $result .= "/*\n\n";
 445     $result .= IdlDump::DumpTypedef($u);
 446     $result .= "*/\n\n";
 447
 448     # Generate function to convert Python dict to union pointer
 449
 450     $result .= "%{\n\n";
 451     $result .= "/* Convert Python dict to union $u->{NAME} pointer */\n\n";
 452
 453     $result .= "union $u->{NAME} *$u->{NAME}_ptr_from_python(TALLOC_CTX *mem_ctx, PyObject *obj, char *name)\n";
 454     $result .= "{\n";
 455
 456     $result .= "\tunion $u->{NAME} *u;\n";
 457     $result .= "\tPyObject *dict;\n\n";
 458
 459     $result .= "\tif (obj == NULL) {\n";
 460     $result .= "\t\tPyErr_Format(PyExc_ValueError, \"Expecting key '%s'\", name);\n";
 461     $result .= "\t\treturn NULL;\n";
 462     $result .= "\t}\n\n";
 463
 464     $result .= "\tif (!PyDict_Check(obj)) {\n";
 465     $result .= "\t\tPyErr_Format(PyExc_TypeError, \"Expecting dict value for key '%s'\", name);\n";
 466     $result .= "\t\treturn NULL;\n";
 467     $result .= "\t}\n\n";
 468
 469     $result .= "\tu = talloc(mem_ctx, sizeof(union $u->{NAME}));\n\n";
 470
 471     for my $e (@{$u->{DATA}{DATA}}) {
 472         $result .= "\tif ((dict = PyDict_GetItemString(obj, \"$e->{DATA}{NAME}\"))) {\n";
 473         if ($e->{DATA}{POINTERS} == 0) {
 474             $result .= "\t\t$e->{DATA}{TYPE}_from_python(mem_ctx, &u->$e->{DATA}{NAME}, dict, \"$e->{DATA}{NAME}\");\n";
 475         } elsif ($e->{DATA}{POINTERS} == 1) {
 476             $result .= "\t\tu->$e->{DATA}{NAME} = $e->{DATA}{TYPE}_ptr_from_python(mem_ctx, dict, \"$e->{DATA}{NAME}\");\n";
 477         } else {
 478             $result .= "\t\t// $e->{DATA}{TYPE} pointers=$e->{DATA}{POINTERS}\n";
 479         }
 480
 481         $result .= "\t\treturn u;\n";
 482         $result .= "\t}\n\n";
 483     }
 484
 485     $result .= "\treturn NULL;\n";
 486     $result .= "}\n\n";
 487
 488     # Generate function to convert Python dict to union
 489
 490     $result .= "/* Convert Python dict to union $u->{NAME} */\n\n";
 491
 492     $result .= "void $u->{NAME}_from_python(TALLOC_CTX *mem_ctx, union $u->{NAME} *u, PyObject *obj, char *name)\n";
 493     $result .= "{\n";
 494     $result .= "\tPyObject *dict;\n\n";
 495
 496     $result .= "\tif (obj == NULL) {\n";
 497     $result .= "\t\tPyErr_Format(PyExc_ValueError, \"Expecting key '%s'\", name);\n";
 498     $result .= "\t\treturn;\n";
 499     $result .= "\t}\n\n";
 500
 501     $result .= "\tif (!PyDict_Check(obj)) {\n";
 502     $result .= "\t\tPyErr_Format(PyExc_TypeError, \"Expecting dict value for key '%s'\", name);\n";
 503     $result .= "\t\treturn;\n";
 504     $result .= "\t}\n\n";
 505
 506     for my $e (@{$u->{DATA}{DATA}}) {
 507         $result .= "\tif ((dict = PyDict_GetItemString(obj, \"$e->{DATA}{NAME}\"))) {\n";
 508         if ($e->{DATA}{POINTERS} == 0) {
 509             $result .= "\t\t$e->{DATA}{TYPE}_from_python(mem_ctx, &u->$e->{DATA}{NAME}, dict, \"$e->{DATA}{NAME}\");\n";
 510         } elsif ($e->{DATA}{POINTERS} == 1) {
 511             $result .= "\t\tu->$e->{DATA}{NAME} = $e->{DATA}{TYPE}_ptr_from_python(mem_ctx, dict, \"$e->{DATA}{NAME}\");\n";
 512         } else {
 513             $result .= "\t\t// $e->{DATA}{TYPE} pointers=$e->{DATA}{POINTERS}\n";
 514         }
 515
 516         $result .= "\t\treturn;\n";
 517         $result .= "\t}\n\n";
 518     }
 519     $result .= "}\n";
 520
 521     # Generate function to convert union pointer to Python dict
 522
 523     $result .= "/* Convert union $u->{NAME} pointer to Python dict */\n\n";
 524
 525     $result .= "PyObject *$u->{NAME}_ptr_to_python(TALLOC_CTX *mem_ctx, union $u->{NAME} *u, int switch_is)\n";
 526     $result .= "{\n";
 527     $result .= "\tPyObject *obj;\n\n";
 528
 529     $result .= "\tif (u == NULL) {\n";
 530     $result .= "\t\tPy_INCREF(Py_None);\n";
 531     $result .= "\t\treturn Py_None;\n";
 532     $result .= "\t}\n\n";
 533
 534     $result .= "\tobj = PyDict_New();\n\n";
 535
 536     for my $e (@{$u->{DATA}{DATA}}) {
 537         $result .= "\tif (switch_is == $e->{CASE}) {\n";
 538         if ($e->{POINTERS} == 0) {
 539             $result .= "\t\tPyDict_SetItemString(obj, \"$e->{DATA}{NAME}\", $e->{DATA}{TYPE}_ptr_to_python(mem_ctx, &u->$e->{DATA}{NAME}));\n";
 540         } else {
 541             $result .= "\t\tPyDict_SetItemString(obj, \"$e->{DATA}{NAME}\", $e->{DATA}{TYPE}_ptr_to_python(mem_ctx, u->$e->{DATA}{NAME}));\n";
 542         }
 543         $result .= "\t}\n";
 544     }
 545
 546     $result .= "\treturn obj;\n";
 547
 548     $result .= "}\n\n";
 549
 550     $result .= "\n%}\n\n";
 551
 552     return $result;
 553 }
 554
 555 sub ParseTypedef($)
 556 {
 557     my($t) = shift;
 558     my($result) = "";
 559
 560     foreach my $e ($t) {
 561         $result .= ParseStruct($e) if $e->{DATA}{TYPE} eq "STRUCT";
 562         $result .= ParseUnion($e) if $e->{DATA}{TYPE} eq "UNION";
 563     }
 564
 565     return $result;
 566 }
 567
 568 sub ParseInheritedData($)
 569 {
 570     my($data) = shift;
 571     my($result) = "";
 572
 573     foreach my $e (@{$data}) {
 574         $result .= ParseFunction($e) if $e->{TYPE} eq "FUNCTION";
 575         $result .= ParseTypedef($e) if $e->{TYPE} eq "TYPEDEF";
 576     }
 577
 578     return $result;
 579 }
 580
 581 sub ParseHeader($)
 582 {
 583     my($hdr) = shift;
 584     my($result) = "";
 585
 586     if ($hdr->{PROPERTIES}{uuid}) {
 587         my($name) = $hdr->{NAME};
 588         $result .= "#define DCERPC_" . uc($name) . "_UUID \"$hdr->{PROPERTIES}->{uuid}\"\n";
 589         $result .= "const int DCERPC_" . uc($name) . "_VERSION = " . $hdr->{PROPERTIES}->{version} . ";\n";
 590         $result .= "#define DCERPC_" . uc($name) . "_NAME \"" . $name . "\"\n";
 591         $result .= "\n";
 592     }
 593
 594     $result .= ParseInheritedData($hdr->{INHERITED_DATA});
 595
 596     return $result;
 597 }
 598
 599 sub Parse($)
 600 {
 601     my($idl) = shift;
 602     my($result) = "";
 603
 604     # Make index of functions, structs and unions.  Currently unused.
 605
 606     foreach my $x (@{$idl}) {
 607         my($iname) = $x->{NAME};
 608         $interfaces{$iname} = $x->{PROPERTIES};
 609         foreach my $i (@{$x->{INHERITED_DATA}}) {
 610             $functions{$i->{NAME}} = $i if $i->{TYPE} eq "FUNCTION";
 611             if ($i->{TYPE} eq "TYPEDEF") {
 612                 $structs{$i->{NAME}} = $i->{DATA} if $i->{DATA}{TYPE} eq "STRUCT";
 613                 $unions{$i->{NAME}} = $i->{DATA} if $i->{DATA}{TYPE} eq "UNION";
 614             }
 615         }
 616     }
 617
 618     # Generate interface
 619
 620     $result .= "/* Auto-generated by pidl. Tastes like -*- C -*-. */\n\n";
 621
 622     foreach my $x (@{$idl}) {
 623         $result .= ParseHeader($x) if ($x->{TYPE} eq "INTERFACE");
 624     }
 625
 626     return $result;
 627 }
 628
 629 1;