source4/build/pidl/parser.pm

   1 ###################################################
   2 # Samba4 parser generator for IDL structures
   3 # Copyright tridge@samba.org 2000-2003
   4 # Copyright tpot@samba.org 2001
   5 # Copyright jelmer@samba.org 2004
   6 # released under the GNU GPL
   7
   8 package IdlParser;
   9
  10 use strict;
  11 use needed;
  12
  13 # the list of needed functions
  14 my %structs;
  15
  16 sub pidl($)
  17 {
  18         print OUT shift;
  19 }
  20
  21 #####################################################################
  22 # parse a properties list
  23 sub ParseProperties($)
  24 {
  25     my($props) = shift;
  26     foreach my $d (@{$props}) {
  27         if (ref($d) ne "HASH") {
  28             pidl "[$d] ";
  29         } else {
  30             foreach my $k (keys %{$d}) {
  31                 pidl "[$k($d->{$k})] ";
  32             }
  33         }
  34     }
  35 }
  36
  37 ###################################
  38 # find a sibling var in a structure
  39 sub find_sibling($$)
  40 {
  41         my($e) = shift;
  42         my($name) = shift;
  43         my($fn) = $e->{PARENT};
  44
  45         if ($name =~ /\*(.*)/) {
  46                 $name = $1;
  47         }
  48
  49         if ($fn->{TYPE} eq "FUNCTION") {
  50                 for my $e2 (@{$fn->{DATA}}) {
  51                         if ($e2->{NAME} eq $name) {
  52                                 return $e2;
  53                         }
  54                 }
  55         }
  56
  57         for my $e2 (@{$fn->{ELEMENTS}}) {
  58                 if ($e2->{NAME} eq $name) {
  59                         return $e2;
  60                 }
  61         }
  62         die "invalid sibling '$name'";
  63 }
  64
  65 ####################################################################
  66 # work out the name of a size_is() variable
  67 sub find_size_var($$$)
  68 {
  69         my($e) = shift;
  70         my($size) = shift;
  71         my($var_prefix) = shift;
  72
  73         my($fn) = $e->{PARENT};
  74
  75         if (util::is_constant($size)) {
  76                 return $size;
  77         }
  78
  79         if ($size =~ /ndr->|\(/) {
  80                 return $size;
  81         }
  82
  83         my $prefix = "";
  84
  85         if ($size =~ /\*(.*)/) {
  86                 $size = $1;
  87                 $prefix = "*";
  88         }
  89
  90         if ($fn->{TYPE} ne "FUNCTION") {
  91                 return $prefix . "r->$size";
  92         }
  93
  94         my $e2 = find_sibling($e, $size);
  95
  96         if (util::has_property($e2, "in") && util::has_property($e2, "out")) {
  97                 return $prefix . "$var_prefix$size";
  98         }
  99         if (util::has_property($e2, "in")) {
 100                 return $prefix . "r->in.$size";
 101         }
 102         if (util::has_property($e2, "out")) {
 103                 return $prefix . "r->out.$size";
 104         }
 105
 106         die "invalid variable in $size for element $e->{NAME} in $fn->{NAME}\n";
 107 }
 108
 109 #####################################################################
 110 # check that a variable we get from find_size_var isn't a null pointer
 111 sub check_null_pointer($)
 112 {
 113         my $size = shift;
 114         if ($size =~ /^\*/) {
 115                 my $size2 = substr($size, 1);
 116                 pidl "\tif ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;\n";
 117         }
 118 }
 119
 120 #####################################################################
 121 # check that a variable we get from find_size_var isn't a null pointer
 122 # void return varient
 123 sub check_null_pointer_void($)
 124 {
 125         my $size = shift;
 126         if ($size =~ /^\*/) {
 127                 my $size2 = substr($size, 1);
 128                 pidl "\tif ($size2 == NULL) return;\n";
 129         }
 130 }
 131
 132
 133 #####################################################################
 134 # work out is a parse function should be declared static or not
 135 sub fn_prefix($)
 136 {
 137         my $fn = shift;
 138         if ($fn->{TYPE} eq "TYPEDEF") {
 139                 if (util::has_property($fn, "public")) {
 140                         return "";
 141                 }
 142         }
 143
 144         if ($fn->{TYPE} eq "FUNCTION") {
 145                 if (util::has_property($fn, "public")) {
 146                         return "";
 147                 }
 148         }
 149         return "static ";
 150 }
 151
 152
 153 ###################################################################
 154 # setup any special flags for an element or structure
 155 sub start_flags($)
 156 {
 157         my $e = shift;
 158         my $flags = util::has_property($e, "flag");
 159         if (defined $flags) {
 160                 pidl "\t{ uint32_t _flags_save_$e->{TYPE} = ndr->flags;\n";
 161                 pidl "\tndr_set_flags(&ndr->flags, $flags);\n";
 162         }
 163 }
 164
 165 ###################################################################
 166 # end any special flags for an element or structure
 167 sub end_flags($)
 168 {
 169         my $e = shift;
 170         my $flags = util::has_property($e, "flag");
 171         if (defined $flags) {
 172                 pidl "\tndr->flags = _flags_save_$e->{TYPE};\n\t}\n";
 173         }
 174 }
 175
 176
 177 #####################################################################
 178 # work out the correct alignment for a structure
 179 sub struct_alignment
 180 {
 181         my $s = shift;
 182
 183         my $align = 1;
 184         for my $e (@{$s->{ELEMENTS}}) {
 185                 my $a = 1;
 186
 187                 if (!util::need_wire_pointer($e)
 188                     && defined $structs{$e->{TYPE}}) {
 189                         if ($structs{$e->{TYPE}}->{DATA}->{TYPE} eq "STRUCT") {
 190                                 $a = struct_alignment($structs{$e->{TYPE}}->{DATA});
 191                         } elsif ($structs{$e->{TYPE}}->{DATA}->{TYPE} eq "UNION") {
 192                                 if (defined $structs{$e->{TYPE}}->{DATA}) {
 193                                         $a = union_alignment($structs{$e->{TYPE}}->{DATA});
 194                                 }
 195                         }
 196                 } else {
 197                         $a = util::type_align($e);
 198                 }
 199
 200                 if ($align < $a) {
 201                         $align = $a;
 202                 }
 203         }
 204
 205         return $align;
 206 }
 207
 208 #####################################################################
 209 # work out the correct alignment for a union
 210 sub union_alignment
 211 {
 212         my $u = shift;
 213
 214         my $align = 1;
 215
 216         foreach my $e (@{$u->{DATA}}) {
 217                 my $a = 1;
 218
 219                 if ($e->{TYPE} eq "EMPTY") {
 220                         next;
 221                 }
 222
 223                 if (!util::need_wire_pointer($e)
 224                     && defined $structs{$e->{DATA}->{TYPE}}) {
 225                         my $s = $structs{$e->{DATA}->{TYPE}};
 226                         if ($s->{DATA}->{TYPE} eq "STRUCT") {
 227                                 $a = struct_alignment($s->{DATA});
 228                         } elsif ($s->{DATA}->{TYPE} eq "UNION") {
 229                                 $a = union_alignment($s->{DATA});
 230                         }
 231                 } else {
 232                         $a = util::type_align($e->{DATA});
 233                 }
 234
 235                 if ($align < $a) {
 236                         $align = $a;
 237                 }
 238         }
 239
 240         return $align;
 241 }
 242
 243 #####################################################################
 244 # parse an array - push side
 245 sub ParseArrayPush($$$)
 246 {
 247         my $e = shift;
 248         my $var_prefix = shift;
 249         my $ndr_flags = shift;
 250
 251         my $size = find_size_var($e, util::array_size($e), $var_prefix);
 252
 253         if (defined $e->{CONFORMANT_SIZE}) {
 254                 # the conformant size has already been pushed
 255         } elsif (!util::is_inline_array($e)) {
 256                 # we need to emit the array size
 257                 pidl "\t\tNDR_CHECK(ndr_push_uint32(ndr, $size));\n";
 258         }
 259
 260         if (my $length = util::has_property($e, "length_is")) {
 261                 $length = find_size_var($e, $length, $var_prefix);
 262                 pidl "\t\tNDR_CHECK(ndr_push_uint32(ndr, 0));\n";
 263                 pidl "\t\tNDR_CHECK(ndr_push_uint32(ndr, $length));\n";
 264                 $size = $length;
 265         }
 266
 267         if (util::is_scalar_type($e->{TYPE})) {
 268                 pidl "\t\tNDR_CHECK(ndr_push_array_$e->{TYPE}(ndr, $ndr_flags, $var_prefix$e->{NAME}, $size));\n";
 269         } else {
 270                 pidl "\t\tNDR_CHECK(ndr_push_array(ndr, $ndr_flags, $var_prefix$e->{NAME}, sizeof($var_prefix$e->{NAME}\[0]), $size, (ndr_push_flags_fn_t)ndr_push_$e->{TYPE}));\n";
 271         }
 272 }
 273
 274 #####################################################################
 275 # print an array
 276 sub ParseArrayPrint($$)
 277 {
 278         my $e = shift;
 279         my $var_prefix = shift;
 280         my $size = find_size_var($e, util::array_size($e), $var_prefix);
 281         my $length = util::has_property($e, "length_is");
 282
 283         if (defined $length) {
 284                 $size = find_size_var($e, $length, $var_prefix);
 285         }
 286
 287         if (util::is_scalar_type($e->{TYPE})) {
 288                 pidl "\t\tndr_print_array_$e->{TYPE}(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME}, $size);\n";
 289         } else {
 290                 pidl "\t\tndr_print_array(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME}, sizeof($var_prefix$e->{NAME}\[0]), $size, (ndr_print_fn_t)ndr_print_$e->{TYPE});\n";
 291         }
 292 }
 293
 294 #####################################################################
 295 # check the size_is and length_is constraints
 296 sub CheckArraySizes($$)
 297 {
 298         my $e = shift;
 299         my $var_prefix = shift;
 300
 301         if (!defined $e->{CONFORMANT_SIZE} &&
 302             util::has_property($e, "size_is")) {
 303                 my $size = find_size_var($e, util::array_size($e), $var_prefix);
 304                 pidl "\tif ($var_prefix$e->{NAME}) {\n";
 305                 check_null_pointer($size);
 306                 pidl "\t\tNDR_CHECK(ndr_check_array_size(ndr, (void*)&$var_prefix$e->{NAME}, $size));\n";
 307                 pidl "\t}\n";
 308         }
 309
 310         if (my $length = util::has_property($e, "length_is")) {
 311                 $length = find_size_var($e, $length, $var_prefix);
 312                 pidl "\tif ($var_prefix$e->{NAME}) {\n";
 313                 check_null_pointer($length);
 314                 pidl "\t\tNDR_CHECK(ndr_check_array_length(ndr, (void*)&$var_prefix$e->{NAME}, $length));\n";
 315                 pidl "\t}\n";
 316         }
 317 }
 318
 319
 320 #####################################################################
 321 # parse an array - pull side
 322 sub ParseArrayPull($$$)
 323 {
 324         my $e = shift;
 325         my $var_prefix = shift;
 326         my $ndr_flags = shift;
 327
 328         my $size = find_size_var($e, util::array_size($e), $var_prefix);
 329         my $alloc_size = $size;
 330
 331         # if this is a conformant array then we use that size to allocate, and make sure
 332         # we allocate enough to pull the elements
 333         if (defined $e->{CONFORMANT_SIZE}) {
 334                 $alloc_size = $e->{CONFORMANT_SIZE};
 335                 check_null_pointer($size);
 336                 pidl "\tif ($size > $alloc_size) {\n";
 337                 pidl "\t\treturn ndr_pull_error(ndr, NDR_ERR_CONFORMANT_SIZE, \"Bad conformant size %u should be %u\", $alloc_size, $size);\n";
 338                 pidl "\t}\n";
 339         } elsif (!util::is_inline_array($e)) {
 340                 if ($var_prefix =~ /^r->out/ && $size =~ /^\*r->in/) {
 341                         my $size2 = substr($size, 1);
 342                         pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { NDR_ALLOC(ndr, $size2); }\n";
 343                 }
 344
 345                 # non fixed arrays encode the size just before the array
 346                 pidl "\t\tNDR_CHECK(ndr_pull_array_size(ndr, &$var_prefix$e->{NAME}));\n";
 347                 $alloc_size = "ndr_get_array_size(ndr, &$var_prefix$e->{NAME})";
 348         }
 349
 350         if ((util::need_alloc($e) && !util::is_fixed_array($e)) ||
 351             ($var_prefix eq "r->in." && util::has_property($e, "ref"))) {
 352                 if (!util::is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") {
 353                         pidl "\t\tNDR_ALLOC_N(ndr, $var_prefix$e->{NAME}, $alloc_size);\n";
 354                 }
 355         }
 356
 357         if (($var_prefix eq "r->out." && util::has_property($e, "ref"))) {
 358                 if (!util::is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") {
 359                         pidl "\tif (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {";
 360                         pidl "\t\tNDR_ALLOC_N(ndr, $var_prefix$e->{NAME}, $alloc_size);\n";
 361                         pidl "\t}\n";
 362                 }
 363         }
 364
 365         if (my $length = util::has_property($e, "length_is")) {
 366                 pidl "\t\tNDR_CHECK(ndr_pull_array_length(ndr, &$var_prefix$e->{NAME}));\n";
 367                 $size = "ndr_get_array_length(ndr, &$var_prefix$e->{NAME})";
 368         }
 369
 370         check_null_pointer($size);
 371         if (util::is_scalar_type($e->{TYPE})) {
 372                 pidl "\t\tNDR_CHECK(ndr_pull_array_$e->{TYPE}(ndr, $ndr_flags, $var_prefix$e->{NAME}, $size));\n";
 373         } else {
 374                 pidl "\t\tNDR_CHECK(ndr_pull_array(ndr, $ndr_flags, (void **)$var_prefix$e->{NAME}, sizeof($var_prefix$e->{NAME}\[0]), $size, (ndr_pull_flags_fn_t)ndr_pull_$e->{TYPE}));\n";
 375         }
 376 }
 377
 378
 379 #####################################################################
 380 # parse scalars in a structure element
 381 sub ParseElementPushScalar($$$)
 382 {
 383         my($e) = shift;
 384         my($var_prefix) = shift;
 385         my($ndr_flags) = shift;
 386         my $cprefix = util::c_push_prefix($e);
 387         my $sub_size = util::has_property($e, "subcontext");
 388
 389         start_flags($e);
 390
 391         if (my $value = util::has_property($e, "value")) {
 392                 pidl "\t$cprefix$var_prefix$e->{NAME} = $value;\n";
 393         }
 394
 395         if (util::has_property($e, "relative")) {
 396                 pidl "\tNDR_CHECK(ndr_push_relative1(ndr, $var_prefix$e->{NAME}));\n";
 397         } elsif (util::is_inline_array($e)) {
 398                 ParseArrayPush($e, "r->", "NDR_SCALARS");
 399         } elsif (util::need_wire_pointer($e)) {
 400                 pidl "\tNDR_CHECK(ndr_push_ptr(ndr, $var_prefix$e->{NAME}));\n";
 401         } elsif (util::need_alloc($e)) {
 402                 # no scalar component
 403         } elsif (my $switch = util::has_property($e, "switch_is")) {
 404                 ParseElementPushSwitch($e, $var_prefix, $ndr_flags, $switch);
 405         } elsif (defined $sub_size) {
 406                 if (util::is_builtin_type($e->{TYPE})) {
 407                         pidl "\tNDR_CHECK(ndr_push_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_push_fn_t) ndr_push_$e->{TYPE}));\n";
 408                 } else {
 409                         pidl "\tNDR_CHECK(ndr_push_subcontext_flags_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_push_flags_fn_t) ndr_push_$e->{TYPE}));\n";
 410                 }
 411         } elsif (util::is_builtin_type($e->{TYPE})) {
 412                 pidl "\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
 413         } else {
 414                 pidl "\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
 415         }
 416
 417         end_flags($e);
 418 }
 419
 420 #####################################################################
 421 # print scalars in a structure element
 422 sub ParseElementPrintScalar($$)
 423 {
 424         my($e) = shift;
 425         my($var_prefix) = shift;
 426         my $cprefix = util::c_push_prefix($e);
 427
 428         if (util::has_property($e, "noprint")) {
 429                 return;
 430         }
 431
 432         if (my $value = util::has_property($e, "value")) {
 433                 pidl "\tif (ndr->flags & LIBNDR_PRINT_SET_VALUES) {\n";
 434                 pidl "\t\t$cprefix$var_prefix$e->{NAME} = $value;\n";
 435                 pidl "\t}\n";
 436         }
 437
 438         if (util::is_fixed_array($e)) {
 439                 ParseElementPrintBuffer($e, $var_prefix);
 440         } elsif (util::has_direct_buffers($e)) {
 441                 pidl "\tndr_print_ptr(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME});\n";
 442                 pidl "\tndr->depth++;\n";
 443                 ParseElementPrintBuffer($e, $var_prefix);
 444                 pidl "\tndr->depth--;\n";
 445         } elsif (my $switch = util::has_property($e, "switch_is")) {
 446                 ParseElementPrintSwitch($e, $var_prefix, $switch);
 447         } else {
 448                 pidl "\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME});\n";
 449         }
 450 }
 451
 452 #####################################################################
 453 # parse scalars in a structure element - pull size
 454 sub ParseElementPullSwitch($$$$)
 455 {
 456         my($e) = shift;
 457         my($var_prefix) = shift;
 458         my($ndr_flags) = shift;
 459         my $switch = shift;
 460         my $switch_var = find_size_var($e, $switch, $var_prefix);
 461
 462         my $cprefix = util::c_pull_prefix($e);
 463
 464         my $utype = $structs{$e->{TYPE}};
 465
 466         check_null_pointer($switch_var);
 467
 468         if (!defined $utype ||
 469             !util::has_property($utype, "nodiscriminant")) {
 470                 my $e2 = find_sibling($e, $switch);
 471                 my $type_decl = $e2->{TYPE};
 472                 pidl "\tif (($ndr_flags) & NDR_SCALARS) {\n";
 473                 if (util::is_enum($e2->{TYPE})) {
 474                         $type_decl = util::enum_type_decl($e2);
 475                 } elsif (util::is_bitmap($e2->{TYPE})) {
 476                         $type_decl = util::bitmap_type_decl($e2);
 477                 }
 478                 pidl "\t\t$type_decl _level;\n";
 479                 pidl "\t\tNDR_CHECK(ndr_pull_$e2->{TYPE}(ndr, &_level));\n";
 480                 if ($switch_var =~ /r->in/) {
 481                         pidl "\t\tif (!(ndr->flags & LIBNDR_FLAG_REF_ALLOC) && _level != $switch_var) {\n";
 482                 } else {
 483                         pidl "\t\tif (_level != $switch_var) {\n";
 484                 }
 485                 pidl "\t\t\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u in $e->{NAME}\", _level);\n";
 486                 pidl "\t\t}\n";
 487                 if ($switch_var =~ /r->/) {
 488                         pidl "else { $switch_var = _level; }\n";
 489                 }
 490                 pidl "\t}\n";
 491         }
 492
 493         my $sub_size = util::has_property($e, "subcontext");
 494         if (defined $sub_size) {
 495                 pidl "\tif (($ndr_flags) & NDR_SCALARS) {\n";
 496                 pidl "\t\tNDR_CHECK(ndr_pull_subcontext_union_fn(ndr, $sub_size, $switch_var, $cprefix$var_prefix$e->{NAME}, (ndr_pull_union_fn_t) ndr_pull_$e->{TYPE}));\n";
 497                 pidl "\t}\n";
 498         } else {
 499                 pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $switch_var, $cprefix$var_prefix$e->{NAME}));\n";
 500         }
 501
 502
 503 }
 504
 505 #####################################################################
 506 # push switch element
 507 sub ParseElementPushSwitch($$$$)
 508 {
 509         my($e) = shift;
 510         my($var_prefix) = shift;
 511         my($ndr_flags) = shift;
 512         my $switch = shift;
 513         my $switch_var = find_size_var($e, $switch, $var_prefix);
 514         my $cprefix = util::c_push_prefix($e);
 515
 516         check_null_pointer($switch_var);
 517
 518         my $utype = $structs{$e->{TYPE}};
 519         if (!defined $utype ||
 520             !util::has_property($utype, "nodiscriminant")) {
 521                 my $e2 = find_sibling($e, $switch);
 522                 pidl "\tif (($ndr_flags) & NDR_SCALARS) {\n";
 523                 pidl "\t\tNDR_CHECK(ndr_push_$e2->{TYPE}(ndr, $switch_var));\n";
 524                 pidl "\t}\n";
 525         }
 526
 527         my $sub_size = util::has_property($e, "subcontext");
 528         if (defined $sub_size) {
 529                 pidl "\tif(($ndr_flags) & NDR_SCALARS) {\n";
 530                 pidl "\t\tNDR_CHECK(ndr_push_subcontext_union_fn(ndr, $sub_size, $switch_var, $cprefix$var_prefix$e->{NAME}, (ndr_push_union_fn_t) ndr_push_$e->{TYPE}));\n";
 531                 pidl "\t}\n";
 532         } else {
 533                 pidl "\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $switch_var, $cprefix$var_prefix$e->{NAME}));\n";
 534         }
 535 }
 536
 537 #####################################################################
 538 # print scalars in a structure element
 539 sub ParseElementPrintSwitch($$$)
 540 {
 541         my($e) = shift;
 542         my($var_prefix) = shift;
 543         my $switch = shift;
 544         my $switch_var = find_size_var($e, $switch, $var_prefix);
 545         my $cprefix = util::c_push_prefix($e);
 546
 547         check_null_pointer_void($switch_var);
 548
 549         pidl "\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $switch_var, $cprefix$var_prefix$e->{NAME});\n";
 550 }
 551
 552
 553 #####################################################################
 554 # parse scalars in a structure element - pull size
 555 sub ParseElementPullScalar($$$)
 556 {
 557         my($e) = shift;
 558         my($var_prefix) = shift;
 559         my($ndr_flags) = shift;
 560         my $cprefix = util::c_pull_prefix($e);
 561         my $sub_size = util::has_property($e, "subcontext");
 562
 563         start_flags($e);
 564
 565         if (util::is_inline_array($e)) {
 566                 ParseArrayPull($e, "r->", "NDR_SCALARS");
 567         } elsif (util::need_wire_pointer($e)) {
 568                 pidl "\tNDR_CHECK(ndr_pull_ptr(ndr, &_ptr_$e->{NAME}));\n";
 569                 pidl "\tif (_ptr_$e->{NAME}) {\n";
 570                 pidl "\t\tNDR_ALLOC(ndr, $var_prefix$e->{NAME});\n";
 571                 if (util::has_property($e, "relative")) {
 572                         pidl "\t\tNDR_CHECK(ndr_pull_relative1(ndr, $var_prefix$e->{NAME}, _ptr_$e->{NAME}));\n";
 573                 }
 574                 pidl "\t} else {\n";
 575                 pidl "\t\t$var_prefix$e->{NAME} = NULL;\n";
 576                 pidl "\t}\n";
 577         } elsif (util::need_alloc($e)) {
 578                 # no scalar component
 579         } elsif (my $switch = util::has_property($e, "switch_is")) {
 580                 ParseElementPullSwitch($e, $var_prefix, $ndr_flags, $switch);
 581         } elsif (defined $sub_size) {
 582                 if (util::is_builtin_type($e->{TYPE})) {
 583                         pidl "\tNDR_CHECK(ndr_pull_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_fn_t) ndr_pull_$e->{TYPE}));\n";
 584                 } else {
 585                         pidl "\tNDR_CHECK(ndr_pull_subcontext_flags_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_flags_fn_t) ndr_pull_$e->{TYPE}));\n";
 586                 }
 587         } elsif (util::is_builtin_type($e->{TYPE})) {
 588                 pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
 589         } else {
 590                 pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
 591         }
 592         if (my $range = util::has_property($e, "range")) {
 593                 my ($low, $high) = split(/ /, $range, 2);
 594                 pidl "\tif ($var_prefix$e->{NAME} < $low || $var_prefix$e->{NAME} > $high) {\n";
 595                 pidl "\t\treturn ndr_pull_error(ndr, NDR_ERR_RANGE, \"value out of range\");\n\t}\n";
 596         }
 597
 598         end_flags($e);
 599 }
 600
 601 #####################################################################
 602 # parse buffers in a structure element
 603 sub ParseElementPushBuffer($$$)
 604 {
 605         my($e) = shift;
 606         my($var_prefix) = shift;
 607         my($ndr_flags) = shift;
 608         my $cprefix = util::c_push_prefix($e);
 609         my $sub_size = util::has_property($e, "subcontext");
 610
 611         if (util::is_pure_scalar($e)) {
 612                 return;
 613         }
 614
 615         start_flags($e);
 616
 617         if (util::need_wire_pointer($e)) {
 618                 pidl "\tif ($var_prefix$e->{NAME}) {\n";
 619                 if (util::has_property($e, "relative")) {
 620                         pidl "\t\tNDR_CHECK(ndr_push_relative2(ndr, $var_prefix$e->{NAME}));\n";
 621                 }
 622         }
 623
 624         if (util::is_inline_array($e)) {
 625                 ParseArrayPush($e, "r->", "NDR_BUFFERS");
 626         } elsif (util::array_size($e)) {
 627                 ParseArrayPush($e, "r->", "NDR_SCALARS|NDR_BUFFERS");
 628         } elsif (my $switch = util::has_property($e, "switch_is")) {
 629                 if ($e->{POINTERS}) {
 630                         ParseElementPushSwitch($e, $var_prefix, "NDR_BUFFERS|NDR_SCALARS", $switch);
 631                 } else {
 632                         ParseElementPushSwitch($e, $var_prefix, "NDR_BUFFERS", $switch);
 633                 }
 634         } elsif (defined $sub_size) {
 635                 if ($e->{POINTERS}) {
 636                         if (util::is_builtin_type($e->{TYPE})) {
 637                                 pidl "\tNDR_CHECK(ndr_push_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_push_fn_t) ndr_push_$e->{TYPE}));\n";
 638                         } else {
 639                                 pidl "\tNDR_CHECK(ndr_push_subcontext_flags_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_push_flags_fn_t) ndr_push_$e->{TYPE}));\n";
 640                         }
 641                 }
 642         } elsif (util::is_builtin_type($e->{TYPE})) {
 643                 pidl "\t\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
 644         } elsif ($e->{POINTERS}) {
 645                 pidl "\t\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, NDR_SCALARS|NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}));\n";
 646         } else {
 647                 pidl "\t\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
 648         }
 649
 650         if (util::need_wire_pointer($e)) {
 651                 pidl "\t}\n";
 652         }
 653
 654         end_flags($e);
 655 }
 656
 657 #####################################################################
 658 # print buffers in a structure element
 659 sub ParseElementPrintBuffer($$)
 660 {
 661         my($e) = shift;
 662         my($var_prefix) = shift;
 663         my $cprefix = util::c_push_prefix($e);
 664
 665         if (util::need_wire_pointer($e)) {
 666                 pidl "\tif ($var_prefix$e->{NAME}) {\n";
 667         }
 668
 669         if (util::array_size($e)) {
 670                 ParseArrayPrint($e, $var_prefix)
 671         } elsif (my $switch = util::has_property($e, "switch_is")) {
 672                 ParseElementPrintSwitch($e, $var_prefix, $switch);
 673         } else {
 674                 pidl "\t\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME});\n";
 675         }
 676
 677         if (util::need_wire_pointer($e)) {
 678                 pidl "\t}\n";
 679         }
 680 }
 681
 682
 683 #####################################################################
 684 # parse buffers in a structure element - pull side
 685 sub ParseElementPullBuffer($$$)
 686 {
 687         my($e) = shift;
 688         my($var_prefix) = shift;
 689         my($ndr_flags) = shift;
 690         my $cprefix = util::c_pull_prefix($e);
 691         my $sub_size = util::has_property($e, "subcontext");
 692
 693         if (util::is_pure_scalar($e)) {
 694                 return;
 695         }
 696
 697         start_flags($e);
 698
 699         if (util::need_wire_pointer($e)) {
 700                 pidl "\tif ($var_prefix$e->{NAME}) {\n";
 701                 if (util::has_property($e, "relative")) {
 702                         pidl "\t\tstruct ndr_pull_save _relative_save;\n";
 703                         pidl "\t\tndr_pull_save(ndr, &_relative_save);\n";
 704                         pidl "\t\tNDR_CHECK(ndr_pull_relative2(ndr, $var_prefix$e->{NAME}));\n";
 705                 }
 706         }
 707
 708         if (util::is_inline_array($e)) {
 709                 ParseArrayPull($e, "r->", "NDR_BUFFERS");
 710         } elsif (util::array_size($e)) {
 711                 ParseArrayPull($e, "r->", "NDR_SCALARS|NDR_BUFFERS");
 712         } elsif (my $switch = util::has_property($e, "switch_is")) {
 713                 if ($e->{POINTERS}) {
 714                         ParseElementPullSwitch($e, $var_prefix, "NDR_SCALARS|NDR_BUFFERS", $switch);
 715                 } else {
 716                         ParseElementPullSwitch($e, $var_prefix, "NDR_BUFFERS", $switch);
 717                 }
 718         } elsif (defined $sub_size) {
 719                 if ($e->{POINTERS}) {
 720                         if (util::is_builtin_type($e->{TYPE})) {
 721                                 pidl "\tNDR_CHECK(ndr_pull_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_fn_t) ndr_pull_$e->{TYPE}));\n";
 722                         } else {
 723                                 pidl "\tNDR_CHECK(ndr_pull_subcontext_flags_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_flags_fn_t) ndr_pull_$e->{TYPE}));\n";
 724                         }
 725                 }
 726         } elsif (util::is_builtin_type($e->{TYPE})) {
 727                 pidl "\t\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
 728         } elsif ($e->{POINTERS}) {
 729                 pidl "\t\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, NDR_SCALARS|NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}));\n";
 730         } else {
 731                 pidl "\t\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
 732         }
 733
 734         if (util::need_wire_pointer($e)) {
 735                 if (util::has_property($e, "relative")) {
 736                         pidl "\t\tndr_pull_restore(ndr, &_relative_save);\n";
 737                 }
 738                 pidl "\t}\n";
 739         }
 740
 741         end_flags($e);
 742 }
 743
 744 #####################################################################
 745 # parse a struct
 746 sub ParseStructPush($)
 747 {
 748         my($struct) = shift;
 749
 750         if (! defined $struct->{ELEMENTS}) {
 751                 return;
 752         }
 753
 754         start_flags($struct);
 755
 756         # see if the structure contains a conformant array. If it
 757         # does, then it must be the last element of the structure, and
 758         # we need to push the conformant length early, as it fits on
 759         # the wire before the structure (and even before the structure
 760         # alignment)
 761         my $e = $struct->{ELEMENTS}[-1];
 762         if (defined $e->{ARRAY_LEN} && $e->{ARRAY_LEN} eq "*") {
 763                 my $size = find_size_var($e, util::array_size($e), "r->");
 764                 $e->{CONFORMANT_SIZE} = $size;
 765                 check_null_pointer($size);
 766                 pidl "\tNDR_CHECK(ndr_push_uint32(ndr, $size));\n";
 767         }
 768
 769         if (defined $e->{TYPE} && $e->{TYPE} eq "string"
 770             &&  util::property_matches($e, "flag", ".*LIBNDR_FLAG_STR_CONFORMANT.*")) {
 771                 pidl "\tNDR_CHECK(ndr_push_uint32(ndr, ndr_string_array_size(ndr, r->$e->{NAME})));\n";
 772         }
 773
 774         pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
 775
 776         pidl "\tNDR_CHECK(ndr_push_struct_start(ndr));\n";
 777
 778         my $align = struct_alignment($struct);
 779         pidl "\tNDR_CHECK(ndr_push_align(ndr, $align));\n";
 780
 781         foreach my $e (@{$struct->{ELEMENTS}}) {
 782                 ParseElementPushScalar($e, "r->", "NDR_SCALARS");
 783         }
 784
 785         pidl "buffers:\n";
 786         pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
 787         foreach my $e (@{$struct->{ELEMENTS}}) {
 788                 ParseElementPushBuffer($e, "r->", "NDR_BUFFERS");
 789         }
 790
 791         pidl "\tndr_push_struct_end(ndr);\n";
 792
 793         pidl "done:\n";
 794
 795         end_flags($struct);
 796 }
 797
 798
 799 #####################################################################
 800 # generate a push function for an enum
 801 sub ParseEnumPush($)
 802 {
 803         my($enum) = shift;
 804         my($type_fn) = util::enum_type_fn($enum);
 805
 806         start_flags($enum);
 807
 808         pidl "\tNDR_CHECK(ndr_push_$type_fn(ndr, r));\n";
 809
 810         end_flags($enum);
 811 }
 812
 813 #####################################################################
 814 # generate a pull function for an enum
 815 sub ParseEnumPull($)
 816 {
 817         my($enum) = shift;
 818         my($type_fn) = util::enum_type_fn($enum);
 819
 820         pidl "\t$type_fn v;\n";
 821         start_flags($enum);
 822         pidl "\tNDR_CHECK(ndr_pull_$type_fn(ndr, &v));\n";
 823         pidl "\t*r = v;\n";
 824
 825         end_flags($enum);
 826 }
 827
 828 #####################################################################
 829 # generate a print function for an enum
 830 sub ParseEnumPrint($)
 831 {
 832         my($enum) = shift;
 833
 834         pidl "\tconst char *val = NULL;\n\n";
 835
 836         start_flags($enum);
 837
 838         pidl "\tswitch (r) {\n";
 839         my $els = \@{$enum->{ELEMENTS}};
 840         foreach my $i (0 .. $#{$els}) {
 841                 my $e = ${$els}[$i];
 842                 chomp $e;
 843                 if ($e =~ /^(.*)=/) {
 844                         $e = $1;
 845                 }
 846                 pidl "\t\tcase $e: val = \"$e\"; break;\n";
 847         }
 848
 849         pidl "\t}\n\n\tndr_print_enum(ndr, name, \"$enum->{TYPE}\", val, r);\n";
 850
 851         end_flags($enum);
 852 }
 853
 854
 855 #####################################################################
 856 # generate a push function for a bitmap
 857 sub ParseBitmapPush($)
 858 {
 859         my($bitmap) = shift;
 860         my($type_fn) = util::bitmap_type_fn($bitmap);
 861
 862         start_flags($bitmap);
 863
 864         pidl "\tNDR_CHECK(ndr_push_$type_fn(ndr, r));\n";
 865
 866         end_flags($bitmap);
 867 }
 868
 869 #####################################################################
 870 # generate a pull function for an bitmap
 871 sub ParseBitmapPull($)
 872 {
 873         my($bitmap) = shift;
 874         my($type_fn) = util::bitmap_type_fn($bitmap);
 875
 876         pidl "\t$type_fn v;\n";
 877         start_flags($bitmap);
 878         pidl "\tNDR_CHECK(ndr_pull_$type_fn(ndr, &v));\n";
 879         pidl "\t*r = v;\n";
 880
 881         end_flags($bitmap);
 882 }
 883
 884 #####################################################################
 885 # generate a print function for an bitmap
 886 sub ParseBintmapPrintElement($$)
 887 {
 888         my($e) = shift;
 889         my($bitmap) = shift;
 890         my($type_decl) = util::bitmap_type_decl($bitmap);
 891         my($type_fn) = util::bitmap_type_fn($bitmap);
 892         my($name) = $bitmap->{PARENT}->{NAME};
 893         my($flag);
 894
 895         if ($e =~ /^(\w+) .*$/) {
 896                 $flag = "$1";
 897         } else {
 898                 die "Bitmap: \"$name\" invalid Flag: \"$e\"";
 899         }
 900
 901         pidl "\tndr_print_bitmap_flag(ndr, sizeof($type_decl), \"$flag\", $flag, r);\n";
 902 }
 903
 904 #####################################################################
 905 # generate a print function for an bitmap
 906 sub ParseBitmapPrint($)
 907 {
 908         my($bitmap) = shift;
 909         my($type_decl) = util::bitmap_type_decl($bitmap);
 910         my($type_fn) = util::bitmap_type_fn($bitmap);
 911
 912         start_flags($bitmap);
 913
 914         pidl "\tndr_print_$type_fn(ndr, name, r);\n";
 915
 916         pidl "\tndr->depth++;\n";
 917         foreach my $e (@{$bitmap->{ELEMENTS}}) {
 918                 ParseBintmapPrintElement($e, $bitmap);
 919         }
 920         pidl "\tndr->depth--;\n";
 921
 922         end_flags($bitmap);
 923 }
 924
 925 #####################################################################
 926 # generate a struct print function
 927 sub ParseStructPrint($)
 928 {
 929         my($struct) = shift;
 930
 931         if (! defined $struct->{ELEMENTS}) {
 932                 return;
 933         }
 934
 935         start_flags($struct);
 936
 937         pidl "\tndr->depth++;\n";
 938         foreach my $e (@{$struct->{ELEMENTS}}) {
 939                 ParseElementPrintScalar($e, "r->");
 940         }
 941         pidl "\tndr->depth--;\n";
 942
 943         end_flags($struct);
 944 }
 945
 946 #####################################################################
 947 # parse a struct - pull side
 948 sub ParseStructPull($)
 949 {
 950         my($struct) = shift;
 951         my $conform_e;
 952
 953         if (! defined $struct->{ELEMENTS}) {
 954                 return;
 955         }
 956
 957         # see if the structure contains a conformant array. If it
 958         # does, then it must be the last element of the structure, and
 959         # we need to pull the conformant length early, as it fits on
 960         # the wire before the structure (and even before the structure
 961         # alignment)
 962         my $e = $struct->{ELEMENTS}[-1];
 963         if (defined $e->{ARRAY_LEN} && $e->{ARRAY_LEN} eq "*") {
 964                 $conform_e = $e;
 965         }
 966
 967         if (defined $e->{TYPE} && $e->{TYPE} eq "string"
 968             &&  util::property_matches($e, "flag", ".*LIBNDR_FLAG_STR_CONFORMANT.*")) {
 969                 $conform_e = $e;
 970         }
 971
 972         if (defined $conform_e) {
 973                 $conform_e = $e;
 974                 pidl "\tuint32_t _conformant_size;\n";
 975                 $conform_e->{CONFORMANT_SIZE} = "_conformant_size";
 976         }
 977
 978         # declare any internal pointers we need
 979         foreach my $e (@{$struct->{ELEMENTS}}) {
 980                 if (util::need_wire_pointer($e)) {
 981                         pidl "\tuint32_t _ptr_$e->{NAME};\n";
 982                 }
 983         }
 984
 985         start_flags($struct);
 986
 987         pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
 988
 989         pidl "\tNDR_CHECK(ndr_pull_struct_start(ndr));\n";
 990
 991         if (defined $conform_e) {
 992                 pidl "\tNDR_CHECK(ndr_pull_uint32(ndr, &$conform_e->{CONFORMANT_SIZE}));\n";
 993         }
 994
 995         my $align = struct_alignment($struct);
 996         pidl "\tNDR_CHECK(ndr_pull_align(ndr, $align));\n";
 997
 998         foreach my $e (@{$struct->{ELEMENTS}}) {
 999                 ParseElementPullScalar($e, "r->", "NDR_SCALARS");
1000         }
1001
1002         pidl "buffers:\n";
1003         pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
1004         foreach my $e (@{$struct->{ELEMENTS}}) {
1005                 ParseElementPullBuffer($e, "r->", "NDR_BUFFERS");
1006         }
1007
1008         foreach my $e (@{$struct->{ELEMENTS}}) {
1009                 CheckArraySizes($e, "r->");
1010         }
1011
1012         pidl "\tndr_pull_struct_end(ndr);\n";
1013
1014         pidl "done:\n";
1015
1016         end_flags($struct);
1017 }
1018
1019 #####################################################################
1020 # calculate size of ndr struct
1021 sub ParseStructNdrSize($)
1022 {
1023         my $t = shift;
1024         my $static = fn_prefix($t);
1025         my $sizevar;
1026
1027         pidl "size_t ndr_size_$t->{NAME}(const struct $t->{NAME} *r, int flags)\n";
1028         pidl "{\n";
1029         if (my $flags = util::has_property($t, "flag")) {
1030                 pidl "\tflags |= $flags;\n";
1031         }
1032         pidl "\treturn ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});\n";
1033         pidl "}\n\n";
1034 }
1035
1036 #####################################################################
1037 # parse a union - push side
1038 sub ParseUnionPush($)
1039 {
1040         my $e = shift;
1041         my $have_default = 0;
1042
1043         start_flags($e);
1044
1045         pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
1046
1047         pidl "\tNDR_CHECK(ndr_push_struct_start(ndr));\n";
1048
1049 #       my $align = union_alignment($e);
1050 #       pidl "\tNDR_CHECK(ndr_push_align(ndr, $align));\n";
1051
1052         pidl "\tswitch (level) {\n";
1053         foreach my $el (@{$e->{DATA}}) {
1054                 if ($el->{CASE} eq "default") {
1055                         pidl "\tdefault:\n";
1056                         $have_default = 1;
1057                 } else {
1058                         pidl "\tcase $el->{CASE}:\n";
1059                 }
1060                 if ($el->{TYPE} eq "UNION_ELEMENT") {
1061                         ParseElementPushScalar($el->{DATA}, "r->", "NDR_SCALARS");
1062                 }
1063                 pidl "\tbreak;\n\n";
1064         }
1065         if (! $have_default) {
1066                 pidl "\tdefault:\n";
1067                 pidl "\t\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
1068         }
1069         pidl "\t}\n";
1070         pidl "buffers:\n";
1071         pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
1072         pidl "\tswitch (level) {\n";
1073         foreach my $el (@{$e->{DATA}}) {
1074                 if ($el->{CASE} eq "default") {
1075                         pidl "\tdefault:\n";
1076                 } else {
1077                         pidl "\tcase $el->{CASE}:\n";
1078                 }
1079                 if ($el->{TYPE} eq "UNION_ELEMENT") {
1080                         ParseElementPushBuffer($el->{DATA}, "r->", "NDR_BUFFERS");
1081                 }
1082                 pidl "\tbreak;\n\n";
1083         }
1084         if (! $have_default) {
1085                 pidl "\tdefault:\n";
1086                 pidl "\t\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
1087         }
1088         pidl "\t}\n";
1089         pidl "\tndr_push_struct_end(ndr);\n";
1090         pidl "done:\n";
1091         end_flags($e);
1092 }
1093
1094 #####################################################################
1095 # print a union
1096 sub ParseUnionPrint($)
1097 {
1098         my $e = shift;
1099         my $have_default = 0;
1100
1101         start_flags($e);
1102
1103         pidl "\tswitch (level) {\n";
1104         foreach my $el (@{$e->{DATA}}) {
1105                 if ($el->{CASE} eq "default") {
1106                         $have_default = 1;
1107                         pidl "\tdefault:\n";
1108                 } else {
1109                         pidl "\tcase $el->{CASE}:\n";
1110                 }
1111                 if ($el->{TYPE} eq "UNION_ELEMENT") {
1112                         ParseElementPrintScalar($el->{DATA}, "r->");
1113                 }
1114                 pidl "\tbreak;\n\n";
1115         }
1116         if (! $have_default) {
1117                 pidl "\tdefault:\n\t\tndr_print_bad_level(ndr, name, level);\n";
1118         }
1119         pidl "\t}\n";
1120
1121         end_flags($e);
1122 }
1123
1124 #####################################################################
1125 # parse a union - pull side
1126 sub ParseUnionPull($)
1127 {
1128         my $e = shift;
1129         my $have_default = 0;
1130
1131         start_flags($e);
1132
1133         pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
1134
1135         pidl "\tNDR_CHECK(ndr_pull_struct_start(ndr));\n";
1136
1137 #       my $align = union_alignment($e);
1138 #       pidl "\tNDR_CHECK(ndr_pull_align(ndr, $align));\n";
1139
1140         pidl "\tswitch (level) {\n";
1141         foreach my $el (@{$e->{DATA}}) {
1142                 if ($el->{CASE} eq "default") {
1143                         pidl "\tdefault: {\n";
1144                         $have_default = 1;
1145                 } else {
1146                         pidl "\tcase $el->{CASE}: {\n";
1147                 }
1148                 if ($el->{TYPE} eq "UNION_ELEMENT") {
1149                         my $e2 = $el->{DATA};
1150                         if ($e2->{POINTERS}) {
1151                                 pidl "\t\tuint32_t _ptr_$e2->{NAME};\n";
1152                         }
1153                         ParseElementPullScalar($el->{DATA}, "r->", "NDR_SCALARS");
1154                 }
1155                 pidl "\tbreak; }\n\n";
1156         }
1157         if (! $have_default) {
1158                 pidl "\tdefault:\n";
1159                 pidl "\t\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
1160         }
1161         pidl "\t}\n";
1162         pidl "buffers:\n";
1163         pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
1164         pidl "\tswitch (level) {\n";
1165         foreach my $el (@{$e->{DATA}}) {
1166                 if ($el->{CASE} eq "default") {
1167                         pidl "\tdefault:\n";
1168                 } else {
1169                         pidl "\tcase $el->{CASE}:\n";
1170                 }
1171                 if ($el->{TYPE} eq "UNION_ELEMENT") {
1172                         ParseElementPullBuffer($el->{DATA}, "r->", "NDR_BUFFERS");
1173                 }
1174                 pidl "\tbreak;\n\n";
1175         }
1176         if (! $have_default) {
1177                 pidl "\tdefault:\n";
1178                 pidl "\t\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
1179         }
1180         pidl "\t}\n";
1181         pidl "\tndr_pull_struct_end(ndr);\n";
1182         pidl "done:\n";
1183         end_flags($e);
1184 }
1185
1186
1187 #####################################################################
1188 # parse a type
1189 sub ParseTypePush($)
1190 {
1191         my($data) = shift;
1192
1193         if (ref($data) eq "HASH") {
1194                 ($data->{TYPE} eq "STRUCT") &&
1195                     ParseStructPush($data);
1196                 ($data->{TYPE} eq "UNION") &&
1197                     ParseUnionPush($data);
1198                 ($data->{TYPE} eq "ENUM") &&
1199                     ParseEnumPush($data);
1200                 ($data->{TYPE} eq "BITMAP") &&
1201                     ParseBitmapPush($data);
1202         }
1203 }
1204
1205 #####################################################################
1206 # generate a print function for a type
1207 sub ParseTypePrint($)
1208 {
1209         my($data) = shift;
1210
1211         if (ref($data) eq "HASH") {
1212                 ($data->{TYPE} eq "STRUCT") &&
1213                     ParseStructPrint($data);
1214                 ($data->{TYPE} eq "UNION") &&
1215                     ParseUnionPrint($data);
1216                 ($data->{TYPE} eq "ENUM") &&
1217                     ParseEnumPrint($data);
1218                 ($data->{TYPE} eq "BITMAP") &&
1219                     ParseBitmapPrint($data);
1220         }
1221 }
1222
1223 #####################################################################
1224 # parse a type
1225 sub ParseTypePull($)
1226 {
1227         my($data) = shift;
1228
1229         if (ref($data) eq "HASH") {
1230                 ($data->{TYPE} eq "STRUCT") &&
1231                     ParseStructPull($data);
1232                 ($data->{TYPE} eq "UNION") &&
1233                     ParseUnionPull($data);
1234                 ($data->{TYPE} eq "ENUM") &&
1235                     ParseEnumPull($data);
1236                 ($data->{TYPE} eq "BITMAP") &&
1237                     ParseBitmapPull($data);
1238         }
1239 }
1240
1241 #####################################################################
1242 # parse a typedef - push side
1243 sub ParseTypedefPush($)
1244 {
1245         my($e) = shift;
1246         my $static = fn_prefix($e);
1247
1248         if (! needed::is_needed("push_$e->{NAME}")) {
1249 #               print "push_$e->{NAME} not needed\n";
1250                 return;
1251         }
1252
1253         if (defined($e->{PROPERTIES}) && !defined($e->{DATA}->{PROPERTIES})) {
1254                 $e->{DATA}->{PROPERTIES} = $e->{PROPERTIES};
1255         }
1256
1257         if ($e->{DATA}->{TYPE} eq "STRUCT") {
1258                 pidl $static . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, struct $e->{NAME} *r)";
1259                 pidl "\n{\n";
1260                 ParseTypePush($e->{DATA});
1261                 pidl "\treturn NT_STATUS_OK;\n";
1262                 pidl "}\n\n";
1263         }
1264
1265         if ($e->{DATA}->{TYPE} eq "UNION") {
1266                 pidl $static . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, int level, union $e->{NAME} *r)";
1267                 pidl "\n{\n";
1268                 ParseTypePush($e->{DATA});
1269                 pidl "\treturn NT_STATUS_OK;\n";
1270                 pidl "}\n\n";
1271         }
1272
1273         if ($e->{DATA}->{TYPE} eq "ENUM") {
1274                 pidl $static . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, enum $e->{NAME} r)";
1275                 pidl "\n{\n";
1276                 ParseTypePush($e->{DATA});
1277                 pidl "\treturn NT_STATUS_OK;\n";
1278                 pidl "}\n\n";
1279         }
1280
1281         if ($e->{DATA}->{TYPE} eq "BITMAP") {
1282                 my $type_decl = util::bitmap_type_fn($e->{DATA});
1283                 pidl $static . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, $type_decl r)";
1284                 pidl "\n{\n";
1285                 ParseTypePush($e->{DATA});
1286                 pidl "\treturn NT_STATUS_OK;\n";
1287                 pidl "}\n\n";
1288         }
1289 }
1290
1291
1292 #####################################################################
1293 # parse a typedef - pull side
1294 sub ParseTypedefPull($)
1295 {
1296         my($e) = shift;
1297         my $static = fn_prefix($e);
1298
1299         if (defined($e->{PROPERTIES}) && !defined($e->{DATA}->{PROPERTIES})) {
1300                 $e->{DATA}->{PROPERTIES} = $e->{PROPERTIES};
1301         }
1302
1303         if (! needed::is_needed("pull_$e->{NAME}")) {
1304 #               print "pull_$e->{NAME} not needed\n";
1305                 return;
1306         }
1307
1308         if ($e->{DATA}->{TYPE} eq "STRUCT") {
1309                 pidl $static . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, struct $e->{NAME} *r)";
1310                 pidl "\n{\n";
1311                 ParseTypePull($e->{DATA});
1312                 pidl "\treturn NT_STATUS_OK;\n";
1313                 pidl "}\n\n";
1314         }
1315
1316         if ($e->{DATA}->{TYPE} eq "UNION") {
1317                 pidl $static . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, int level, union $e->{NAME} *r)";
1318                 pidl "\n{\n";
1319                 ParseTypePull($e->{DATA});
1320                 pidl "\treturn NT_STATUS_OK;\n";
1321                 pidl "}\n\n";
1322         }
1323
1324         if ($e->{DATA}->{TYPE} eq "ENUM") {
1325                 pidl $static . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, enum $e->{NAME} *r)";
1326                 pidl "\n{\n";
1327                 ParseTypePull($e->{DATA});
1328                 pidl "\treturn NT_STATUS_OK;\n";
1329                 pidl "}\n\n";
1330         }
1331
1332         if ($e->{DATA}->{TYPE} eq "BITMAP") {
1333                 my $type_decl = util::bitmap_type_fn($e->{DATA});
1334                 pidl $static . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, $type_decl *r)";
1335                 pidl "\n{\n";
1336                 ParseTypePull($e->{DATA});
1337                 pidl "\treturn NT_STATUS_OK;\n";
1338                 pidl "}\n\n";
1339         }
1340 }
1341
1342
1343 #####################################################################
1344 # parse a typedef - print side
1345 sub ParseTypedefPrint($)
1346 {
1347         my($e) = shift;
1348
1349         if (defined($e->{PROPERTIES}) && !defined($e->{DATA}->{PROPERTIES})) {
1350                 $e->{DATA}->{PROPERTIES} = $e->{PROPERTIES};
1351         }
1352
1353         if ($e->{DATA}->{TYPE} eq "STRUCT") {
1354                 pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, struct $e->{NAME} *r)";
1355                 pidl "\n{\n";
1356                 pidl "\tndr_print_struct(ndr, name, \"$e->{NAME}\");\n";
1357                 ParseTypePrint($e->{DATA});
1358                 pidl "}\n\n";
1359         }
1360
1361         if ($e->{DATA}->{TYPE} eq "UNION") {
1362                 pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, int level, union $e->{NAME} *r)";
1363                 pidl "\n{\n";
1364                 pidl "\tndr_print_union(ndr, name, level, \"$e->{NAME}\");\n";
1365                 ParseTypePrint($e->{DATA});
1366                 pidl "}\n\n";
1367         }
1368
1369         if ($e->{DATA}->{TYPE} eq "ENUM") {
1370                 pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, enum $e->{NAME} r)";
1371                 pidl "\n{\n";
1372                 ParseTypePrint($e->{DATA});
1373                 pidl "}\n\n";
1374         }
1375
1376         if ($e->{DATA}->{TYPE} eq "BITMAP") {
1377                 my $type_decl = util::bitmap_type_fn($e->{DATA});
1378                 pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $type_decl r)";
1379                 pidl "\n{\n";
1380                 ParseTypePrint($e->{DATA});
1381                 pidl "}\n\n";
1382         }
1383 }
1384
1385 #####################################################################
1386 ## calculate the size of a structure
1387 sub ParseTypedefNdrSize($)
1388 {
1389         my($t) = shift;
1390         if (! needed::is_needed("ndr_size_$t->{NAME}")) {
1391                 return;
1392         }
1393
1394         ($t->{DATA}->{TYPE} eq "STRUCT") &&
1395                 ParseStructNdrSize($t);
1396 }
1397
1398 #####################################################################
1399 # parse a function - print side
1400 sub ParseFunctionPrint($)
1401 {
1402         my($fn) = shift;
1403
1404         pidl "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, struct $fn->{NAME} *r)";
1405         pidl "\n{\n";
1406         pidl "\tndr_print_struct(ndr, name, \"$fn->{NAME}\");\n";
1407         pidl "\tndr->depth++;\n";
1408
1409         pidl "\tif (flags & NDR_SET_VALUES) {\n";
1410         pidl "\t\tndr->flags |= LIBNDR_PRINT_SET_VALUES;\n";
1411         pidl "\t}\n";
1412
1413         pidl "\tif (flags & NDR_IN) {\n";
1414         pidl "\t\tndr_print_struct(ndr, \"in\", \"$fn->{NAME}\");\n";
1415         pidl "\tndr->depth++;\n";
1416         foreach my $e (@{$fn->{DATA}}) {
1417                 if (util::has_property($e, "in")) {
1418                         ParseElementPrintScalar($e, "r->in.");
1419                 }
1420         }
1421         pidl "\tndr->depth--;\n";
1422         pidl "\t}\n";
1423
1424         pidl "\tif (flags & NDR_OUT) {\n";
1425         pidl "\t\tndr_print_struct(ndr, \"out\", \"$fn->{NAME}\");\n";
1426         pidl "\tndr->depth++;\n";
1427         foreach my $e (@{$fn->{DATA}}) {
1428                 if (util::has_property($e, "out")) {
1429                         ParseElementPrintScalar($e, "r->out.");
1430                 }
1431         }
1432         if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1433                 if (util::is_scalar_type($fn->{RETURN_TYPE})) {
1434                         pidl "\tndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", r->out.result);\n";
1435                 } else {
1436                         pidl "\tndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", &r->out.result);\n";
1437                 }
1438         }
1439         pidl "\tndr->depth--;\n";
1440         pidl "\t}\n";
1441
1442         pidl "\tndr->depth--;\n";
1443         pidl "}\n\n";
1444 }
1445
1446
1447 #####################################################################
1448 # parse a function element
1449 sub ParseFunctionElementPush($$)
1450 {
1451         my $e = shift;
1452         my $inout = shift;
1453
1454         if (util::array_size($e)) {
1455                 if (util::need_wire_pointer($e)) {
1456                         pidl "\tNDR_CHECK(ndr_push_ptr(ndr, r->$inout.$e->{NAME}));\n";
1457                         pidl "\tif (r->$inout.$e->{NAME}) {\n";
1458                         ParseArrayPush($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1459                         pidl "\t}\n";
1460                 } else {
1461                         ParseArrayPush($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1462                 }
1463         } else {
1464                 ParseElementPushScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1465                 if ($e->{POINTERS}) {
1466                         ParseElementPushBuffer($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1467                 }
1468         }
1469 }
1470
1471 #####################################################################
1472 # parse a function
1473 sub ParseFunctionPush($)
1474 {
1475         my($fn) = shift;
1476         my $static = fn_prefix($fn);
1477
1478         pidl $static . "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, struct $fn->{NAME} *r)\n{\n";
1479
1480         pidl "\n\tif (!(flags & NDR_IN)) goto ndr_out;\n\n";
1481
1482         foreach my $e (@{$fn->{DATA}}) {
1483                 if (util::has_property($e, "in")) {
1484                         ParseFunctionElementPush($e, "in");
1485                 }
1486         }
1487
1488         pidl "\nndr_out:\n";
1489         pidl "\tif (!(flags & NDR_OUT)) goto done;\n\n";
1490
1491         foreach my $e (@{$fn->{DATA}}) {
1492                 if (util::has_property($e, "out")) {
1493                         ParseFunctionElementPush($e, "out");
1494                 }
1495         }
1496
1497         if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1498                 pidl "\tNDR_CHECK(ndr_push_$fn->{RETURN_TYPE}(ndr, r->out.result));\n";
1499         }
1500
1501         pidl "\ndone:\n";
1502         pidl "\n\treturn NT_STATUS_OK;\n}\n\n";
1503 }
1504
1505 #####################################################################
1506 # parse a function element
1507 sub ParseFunctionElementPull($$)
1508 {
1509         my $e = shift;
1510         my $inout = shift;
1511
1512         if (util::array_size($e)) {
1513                 if (util::need_wire_pointer($e)) {
1514                         pidl "\tNDR_CHECK(ndr_pull_ptr(ndr, &_ptr_$e->{NAME}));\n";
1515                         pidl "\tr->$inout.$e->{NAME} = NULL;\n";
1516                         pidl "\tif (_ptr_$e->{NAME}) {\n";
1517                 } elsif ($inout eq "out" && util::has_property($e, "ref")) {
1518                         pidl "\tif (r->$inout.$e->{NAME}) {\n";
1519                 } else {
1520                         pidl "\t{\n";
1521                 }
1522                 ParseArrayPull($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1523                 pidl "\t}\n";
1524         } else {
1525                 if ($inout eq "out" && util::has_property($e, "ref")) {
1526                         pidl "\tif (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {\n";
1527                         pidl "\tNDR_ALLOC(ndr, r->out.$e->{NAME});\n";
1528                         pidl "\t}\n";
1529                 }
1530                 if ($inout eq "in" && util::has_property($e, "ref")) {
1531                         pidl "\tNDR_ALLOC(ndr, r->in.$e->{NAME});\n";
1532                 }
1533
1534                 ParseElementPullScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1535                 if ($e->{POINTERS}) {
1536                         ParseElementPullBuffer($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1537                 }
1538         }
1539 }
1540
1541
1542 ############################################################
1543 # allocate ref variables
1544 sub AllocateRefVars($)
1545 {
1546         my $e = shift;
1547         my $asize = util::array_size($e);
1548
1549         # note that if the variable is also an "in"
1550         # variable then we copy the initial value from
1551         # the in side
1552
1553         if (!defined $asize) {
1554                 # its a simple variable
1555                 pidl "\tNDR_ALLOC(ndr, r->out.$e->{NAME});\n";
1556                 if (util::has_property($e, "in")) {
1557                         pidl "\t*r->out.$e->{NAME} = *r->in.$e->{NAME};\n";
1558                 } else {
1559                         pidl "\tZERO_STRUCTP(r->out.$e->{NAME});\n";
1560                 }
1561                 return;
1562         }
1563
1564         # its an array
1565         my $size = find_size_var($e, $asize, "r->out.");
1566         check_null_pointer($size);
1567         pidl "\tNDR_ALLOC_N(ndr, r->out.$e->{NAME}, $size);\n";
1568         if (util::has_property($e, "in")) {
1569                 pidl "\tmemcpy(r->out.$e->{NAME},r->in.$e->{NAME},$size * sizeof(*r->in.$e->{NAME}));\n";
1570         } else {
1571                 pidl "\tmemset(r->out.$e->{NAME}, 0, $size * sizeof(*r->out.$e->{NAME}));\n";
1572         }
1573 }
1574
1575
1576 #####################################################################
1577 # parse a function
1578 sub ParseFunctionPull($)
1579 {
1580         my($fn) = shift;
1581         my $static = fn_prefix($fn);
1582
1583         # pull function args
1584         pidl $static . "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)\n{\n";
1585
1586         # declare any internal pointers we need
1587         foreach my $e (@{$fn->{DATA}}) {
1588                 if (util::need_wire_pointer($e)) {
1589                         pidl "\tuint32_t _ptr_$e->{NAME};\n";
1590                 }
1591         }
1592
1593         pidl "\n\tif (!(flags & NDR_IN)) goto ndr_out;\n\n";
1594
1595         # auto-init the out section of a structure. I originally argued that
1596         # this was a bad idea as it hides bugs, but coping correctly
1597         # with initialisation and not wiping ref vars is turning
1598         # out to be too tricky (tridge)
1599         foreach my $e (@{$fn->{DATA}}) {
1600                 if (util::has_property($e, "out")) {
1601                         pidl "\tZERO_STRUCT(r->out);\n\n";
1602                         last;
1603                 }
1604         }
1605
1606         foreach my $e (@{$fn->{DATA}}) {
1607                 if (util::has_property($e, "in")) {
1608                         ParseFunctionElementPull($e, "in");
1609                 }
1610                 # we need to allocate any reference output variables, so that
1611                 # a dcerpc backend can be sure they are non-null
1612                 if (util::has_property($e, "out") && util::has_property($e, "ref")) {
1613                         AllocateRefVars($e);
1614                 }
1615         }
1616
1617         foreach my $e (@{$fn->{DATA}}) {
1618                 if (util::has_property($e, "in")) {
1619                         CheckArraySizes($e, "r->in.");
1620                 }
1621         }
1622
1623         pidl "\nndr_out:\n";
1624         pidl "\tif (!(flags & NDR_OUT)) goto done;\n\n";
1625
1626         foreach my $e (@{$fn->{DATA}}) {
1627                 if (util::has_property($e, "out")) {
1628                         ParseFunctionElementPull($e, "out");
1629                 }
1630         }
1631
1632         foreach my $e (@{$fn->{DATA}}) {
1633                 if (util::has_property($e, "out")) {
1634                         CheckArraySizes($e, "r->out.");
1635                 }
1636         }
1637
1638         if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1639                 pidl "\tNDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, &r->out.result));\n";
1640         }
1641
1642         pidl "\ndone:\n";
1643         pidl "\n\treturn NT_STATUS_OK;\n}\n\n";
1644 }
1645
1646 #####################################################################
1647 # produce a function call table
1648 sub FunctionTable($)
1649 {
1650         my($interface) = shift;
1651         my($data) = $interface->{INHERITED_DATA};
1652         my $count = 0;
1653         my $uname = uc $interface->{NAME};
1654
1655         foreach my $d (@{$data}) {
1656                 if ($d->{TYPE} eq "FUNCTION") { $count++; }
1657         }
1658
1659         return if ($count == 0);
1660
1661         pidl "static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {\n";
1662         foreach my $d (@{$data}) {
1663                 if ($d->{TYPE} eq "FUNCTION") {
1664                         pidl "\t{\n";
1665                         pidl "\t\t\"$d->{NAME}\",\n";
1666                         pidl "\t\tsizeof(struct $d->{NAME}),\n";
1667                         pidl "\t\t(ndr_push_flags_fn_t) ndr_push_$d->{NAME},\n";
1668                         pidl "\t\t(ndr_pull_flags_fn_t) ndr_pull_$d->{NAME},\n";
1669                         pidl "\t\t(ndr_print_function_t) ndr_print_$d->{NAME}\n";
1670                         pidl "\t},\n";
1671                 }
1672         }
1673         pidl "\t{ NULL, 0, NULL, NULL }\n};\n\n";
1674
1675         # If no endpoint is set, default to the interface name as a named pipe
1676         if (! defined $interface->{PROPERTIES}->{endpoint}) {
1677                 $interface->{PROPERTIES}->{endpoint} = "\"ncacn_np:[\\\\pipe\\\\" . $interface->{NAME} . "]\"";
1678         }
1679
1680         my @e = split / /, $interface->{PROPERTIES}->{endpoint};
1681         my $endpoint_count = $#e + 1;
1682
1683         pidl "static const char * const $interface->{NAME}\_endpoint_strings[] = {\n";
1684         foreach my $ep (@e) {
1685                 pidl "\t$ep, \n";
1686         }
1687         pidl "};\n\n";
1688
1689         pidl "static const struct dcerpc_endpoint_list $interface->{NAME}\_endpoints = {\n";
1690         pidl "\t$endpoint_count, $interface->{NAME}\_endpoint_strings\n";
1691         pidl "};\n\n";
1692
1693         pidl "\nconst struct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {\n";
1694         pidl "\t\"$interface->{NAME}\",\n";
1695         pidl "\tDCERPC_$uname\_UUID,\n";
1696         pidl "\tDCERPC_$uname\_VERSION,\n";
1697         pidl "\tDCERPC_$uname\_HELPSTRING,\n";
1698         pidl "\t$count,\n";
1699         pidl "\t$interface->{NAME}\_calls,\n";
1700         pidl "\t&$interface->{NAME}\_endpoints\n";
1701         pidl "};\n\n";
1702
1703         pidl "static NTSTATUS dcerpc_ndr_$interface->{NAME}_init(void)\n";
1704         pidl "{\n";
1705         pidl "\treturn librpc_register_interface(&dcerpc_table_$interface->{NAME});\n";
1706         pidl "}\n\n";
1707 }
1708
1709 #####################################################################
1710 # parse the interface definitions
1711 sub ParseInterface($)
1712 {
1713         my($interface) = shift;
1714         my($data) = $interface->{DATA};
1715
1716         foreach my $d (@{$data}) {
1717                 if ($d->{TYPE} eq "DECLARE") {
1718                     $structs{$d->{NAME}} = $d;
1719                 }
1720                 if ($d->{TYPE} eq "TYPEDEF") {
1721                     $structs{$d->{NAME}} = $d;
1722                 }
1723         }
1724
1725         foreach my $d (@{$data}) {
1726                 ($d->{TYPE} eq "TYPEDEF") &&
1727                     ParseTypedefPush($d);
1728                 ($d->{TYPE} eq "FUNCTION") &&
1729                     ParseFunctionPush($d);
1730         }
1731         foreach my $d (@{$data}) {
1732                 ($d->{TYPE} eq "TYPEDEF") &&
1733                     ParseTypedefPull($d);
1734                 ($d->{TYPE} eq "FUNCTION") &&
1735                     ParseFunctionPull($d);
1736         }
1737         foreach my $d (@{$data}) {
1738                 if ($d->{TYPE} eq "TYPEDEF" &&
1739                     !util::has_property($d, "noprint")) {
1740                         ParseTypedefPrint($d);
1741                 }
1742                 if ($d->{TYPE} eq "FUNCTION" &&
1743                     !util::has_property($d, "noprint")) {
1744                         ParseFunctionPrint($d);
1745                 }
1746         }
1747
1748         foreach my $d (@{$data}) {
1749                 ($d->{TYPE} eq "TYPEDEF") &&
1750                         ParseTypedefNdrSize($d);
1751         }
1752
1753         FunctionTable($interface);
1754 }
1755
1756 sub RegistrationFunction($$)
1757 {
1758         my $idl = shift;
1759         my $filename = shift;
1760
1761         $filename =~ /.*\/ndr_(.*).c/;
1762         my $basename = $1;
1763         pidl "NTSTATUS dcerpc_$basename\_init(void)\n";
1764         pidl "{\n";
1765         pidl "\tNTSTATUS status = NT_STATUS_OK;\n";
1766         foreach my $interface (@{$idl}) {
1767                 next if $interface->{TYPE} ne "INTERFACE";
1768
1769                 my $data = $interface->{INHERITED_DATA};
1770                 my $count = 0;
1771                 foreach my $d (@{$data}) {
1772                         if ($d->{TYPE} eq "FUNCTION") { $count++; }
1773                 }
1774
1775                 next if ($count == 0);
1776
1777                 pidl "\tstatus = dcerpc_ndr_$interface->{NAME}_init();\n";
1778                 pidl "\tif (NT_STATUS_IS_ERR(status)) {\n";
1779                 pidl "\t\treturn status;\n";
1780                 pidl "\t}\n\n";
1781         }
1782         pidl "\treturn status;\n";
1783         pidl "}\n\n";
1784 }
1785
1786 #####################################################################
1787 # parse a parsed IDL structure back into an IDL file
1788 sub Parse($$)
1789 {
1790         my($idl) = shift;
1791         my($filename) = shift;
1792         my $h_filename = $filename;
1793
1794         if ($h_filename =~ /(.*)\.c/) {
1795                 $h_filename = "$1.h";
1796         }
1797
1798         open(OUT, ">$filename") || die "can't open $filename";
1799
1800         pidl "/* parser auto-generated by pidl */\n\n";
1801         pidl "#include \"includes.h\"\n";
1802         pidl "#include \"$h_filename\"\n\n";
1803
1804         foreach my $x (@{$idl}) {
1805                 if ($x->{TYPE} eq "INTERFACE") {
1806                         needed::BuildNeeded($x);
1807                         ParseInterface($x);
1808                 }
1809         }
1810
1811         RegistrationFunction($idl, $filename);
1812
1813         close(OUT);
1814 }
1815
1816 1;