source/build/pidl/ndr.pm

   1 ###################################################
   2 # Samba4 NDR parser generator for IDL structures
   3 # Copyright tridge@samba.org 2000-2003
   4 # Copyright tpot@samba.org 2001
   5 # Copyright jelmer@samba.org 2004-2005
   6 # released under the GNU GPL
   7
   8 package NdrParser;
   9
  10 use strict;
  11 use needed;
  12 use typelist;
  13
  14 # list of known types
  15 my %typefamily;
  16
  17 sub get_typefamily($)
  18 {
  19         my $n = shift;
  20         return $typefamily{$n};
  21 }
  22
  23 my %scalar_alignments =
  24 (
  25      "char"           => 1,
  26      "int8"           => 1,
  27      "uint8"          => 1,
  28      "short"          => 2,
  29      "wchar_t"        => 2,
  30      "int16"          => 2,
  31      "uint16"         => 2,
  32      "long"           => 4,
  33      "int32"          => 4,
  34      "uint32"         => 4,
  35      "dlong"          => 4,
  36      "udlong"         => 4,
  37      "udlongr"        => 4,
  38      "NTTIME"         => 4,
  39      "NTTIME_1sec"    => 4,
  40      "time_t"         => 4,
  41      "DATA_BLOB"      => 4,
  42      "error_status_t" => 4,
  43      "WERROR"         => 4,
  44          "NTSTATUS"       => 4,
  45      "boolean32"      => 4,
  46      "unsigned32"     => 4,
  47      "ipv4address"    => 4,
  48      "hyper"          => 8,
  49      "NTTIME_hyper"   => 8
  50 );
  51
  52 $typefamily{SCALAR} = {
  53         ALIGN => sub {
  54                 my $t = shift;
  55                 return $scalar_alignments{$t->{NAME}};
  56         }
  57 };
  58
  59 sub is_scalar_type($)
  60 {
  61     my $type = shift;
  62
  63         return 0 unless typelist::hasType($type);
  64
  65         if (my $dt = typelist::getType($type)->{DATA}->{TYPE}) {
  66                 return 1 if ($dt eq "SCALAR" or $dt eq "ENUM" or $dt eq "BITMAP");
  67         }
  68
  69     return 0;
  70 }
  71
  72 sub pointer_type($)
  73 {
  74         my $e = shift;
  75
  76         return undef unless $e->{POINTERS};
  77
  78         return "ref" if (util::has_property($e, "ref"));
  79         return "ptr" if (util::has_property($e, "ptr"));
  80         return "unique" if (util::has_property($e, "unique"));
  81         return "relative" if (util::has_property($e, "relative"));
  82         return "ignore" if (util::has_property($e, "ignore"));
  83
  84         return undef;
  85 }
  86
  87 # return 1 if this is a fixed array
  88 sub is_fixed_array($)
  89 {
  90         my $e = shift;
  91         my $len = $e->{"ARRAY_LEN"};
  92         if (defined $len && util::is_constant($len)) {
  93                 return 1;
  94         }
  95         return 0;
  96 }
  97
  98 # return 1 if this is a conformant array
  99 sub is_conformant_array($)
 100 {
 101         my $e = shift;
 102         return 1 if (util::has_property($e, "size_is"));
 103         return 0;
 104 }
 105
 106 # return 1 if this is a inline array
 107 sub is_inline_array($)
 108 {
 109         my $e = shift;
 110         my $len = $e->{"ARRAY_LEN"};
 111         if (is_fixed_array($e) ||
 112             defined $len && $len ne "*") {
 113                 return 1;
 114         }
 115         return 0;
 116 }
 117
 118 # return 1 if this is a varying array
 119 sub is_varying_array($)
 120 {
 121         my $e = shift;
 122         return 1 if (util::has_property($e, "length_is"));
 123         return 0;
 124 }
 125
 126 # return 1 if this is a surrounding array (sometimes
 127 # referred to as an embedded array). Can only occur as
 128 # the last element in a struct and can not contain any pointers.
 129 sub is_surrounding_array($)
 130 {
 131         my $e = shift;
 132
 133         return ($e->{POINTERS} == 0
 134                 and defined $e->{ARRAY_LEN}
 135                 and     $e->{ARRAY_LEN} eq "*"
 136                 and $e == $e->{PARENT}->{ELEMENTS}[-1]
 137                 and $e->{PARENT}->{TYPE} ne "FUNCTION");
 138 }
 139
 140 sub array_type($)
 141 {
 142         my $e = shift;
 143
 144         return "conformant-varying" if (is_varying_array($e) and is_conformant_array($e));
 145         return "conformant" if (is_varying_array($e));
 146         return "varying" if (is_varying_array($e));
 147         return "inline" if (is_inline_array($e));
 148         return "fixed" if (is_fixed_array($e));
 149
 150         return undef;
 151 }
 152
 153 # determine if an element needs a reference pointer on the wire
 154 # in its NDR representation
 155 sub need_wire_pointer($)
 156 {
 157         my $e = shift;
 158
 159         my $n = $e->{POINTERS};
 160         my $pt = pointer_type($e);
 161
 162         if (    defined($pt)
 163                 and $pt eq "ref"
 164                 and $e->{PARENT}->{TYPE} eq "FUNCTION")
 165         {
 166                 $n--;
 167         }
 168
 169         return $n;
 170 }
 171
 172 # determine if an element is a pure scalar. pure scalars do not
 173 # have a "buffers" section in NDR
 174 sub is_pure_scalar($)
 175 {
 176         my $e = shift;
 177         if (is_scalar_type($e->{TYPE}) &&
 178             need_wire_pointer($e) == 0 &&
 179             !util::array_size($e)) {
 180                 return 1;
 181         }
 182         return 0;
 183 }
 184
 185 # see if a variable needs to be allocated by the NDR subsystem on pull
 186 sub need_alloc($)
 187 {
 188         my $e = shift;
 189
 190         return 0 if (util::has_property($e, "ref"));
 191         return 1 if ($e->{POINTERS} || util::array_size($e));
 192         return 0;
 193 }
 194
 195 sub c_ptr_prefix($)
 196 {
 197         my $e = shift;
 198         my $pointers = "";
 199         foreach my $i (need_wire_pointer($e)..$e->{POINTERS}-1) { $pointers.="*"; }
 200         return $pointers;
 201 }
 202
 203 # determine the C prefix used to refer to a variable when passing to a push
 204 # function. This will be '*' for pointers to scalar types, '' for scalar
 205 # types and normal pointers and '&' for pass-by-reference structures
 206 sub c_push_prefix($)
 207 {
 208         my $e = shift;
 209
 210         my $ret = "";
 211
 212         if ($e->{TYPE} =~ "string") {
 213                 $ret = "";
 214         } elsif (is_scalar_type($e->{TYPE}) &&
 215             $e->{POINTERS}) {
 216                 $ret = "*";
 217         } elsif (!is_scalar_type($e->{TYPE}) &&
 218             !$e->{POINTERS} &&
 219             !util::array_size($e)) {
 220                 return "&";
 221         }
 222
 223         foreach my $i (2..$e->{POINTERS}) { $ret.="*"; }
 224
 225         return $ret;
 226 }
 227
 228 # determine the C prefix used to refer to a variable when passing to a pull
 229 # return '&' or ''
 230 sub c_pull_prefix($)
 231 {
 232         my $e = shift;
 233
 234         if (!$e->{POINTERS} && !util::array_size($e)) {
 235                 return "&";
 236         }
 237
 238         if ($e->{TYPE} =~ "string") {
 239                 return "&";
 240         }
 241
 242         my $ret = "";
 243         foreach my $i (2..$e->{POINTERS}) { $ret.="*"; }
 244         return $ret;
 245 }
 246 my $res = "";
 247 my $tabs = "";
 248 sub pidl($)
 249 {
 250         my $d = shift;
 251         if ($d) {
 252                 $res .= $tabs;
 253                 $res .= $d;
 254         }
 255         $res .="\n";
 256 }
 257
 258 sub indent
 259 {
 260         $tabs .= "\t";
 261 }
 262
 263 sub deindent
 264 {
 265         $tabs = substr($tabs, 0, -1);
 266 }
 267
 268 ###################################
 269 # find a sibling var in a structure
 270 sub find_sibling($$)
 271 {
 272         my($e) = shift;
 273         my($name) = shift;
 274         my($fn) = $e->{PARENT};
 275
 276         if ($name =~ /\*(.*)/) {
 277                 $name = $1;
 278         }
 279
 280         for my $e2 (@{$fn->{ELEMENTS}}) {
 281                 return $e2 if ($e2->{NAME} eq $name);
 282         }
 283
 284         die "invalid sibling '$name'";
 285 }
 286
 287 ####################################################################
 288 # work out the name of a size_is() variable
 289 sub ParseExpr($$$)
 290 {
 291         my($e) = shift;
 292         my($size) = shift;
 293         my($var_prefix) = shift;
 294
 295         my($fn) = $e->{PARENT};
 296
 297         return $size if (util::is_constant($size));
 298
 299         return $size if ($size =~ /ndr->|\(/);
 300
 301         my $prefix = "";
 302
 303         if ($size =~ /\*(.*)/) {
 304                 $size = $1;
 305                 $prefix = "*";
 306         }
 307
 308         if ($fn->{TYPE} ne "FUNCTION") {
 309                 return $prefix . "r->$size";
 310         }
 311
 312         my $e2 = find_sibling($e, $size);
 313
 314         if (util::has_property($e2, "in") && util::has_property($e2, "out")) {
 315                 return $prefix . "$var_prefix$size";
 316         }
 317
 318         if (util::has_property($e2, "in")) {
 319                 return $prefix . "r->in.$size";
 320         }
 321
 322         if (util::has_property($e2, "out")) {
 323                 return $prefix . "r->out.$size";
 324         }
 325
 326         die "invalid variable in $size for element $e->{NAME} in $fn->{NAME}\n";
 327 }
 328
 329 #####################################################################
 330 # check that a variable we get from ParseExpr isn't a null pointer
 331 sub check_null_pointer($)
 332 {
 333         my $size = shift;
 334         if ($size =~ /^\*/) {
 335                 my $size2 = substr($size, 1);
 336                 pidl "if ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;";
 337         }
 338 }
 339
 340 #####################################################################
 341 # check that a variable we get from ParseExpr isn't a null pointer
 342 # void return varient
 343 sub check_null_pointer_void($)
 344 {
 345         my $size = shift;
 346         if ($size =~ /^\*/) {
 347                 my $size2 = substr($size, 1);
 348                 pidl "if ($size2 == NULL) return;";
 349         }
 350 }
 351
 352 #####################################################################
 353 # work out is a parse function should be declared static or not
 354 sub fn_prefix($)
 355 {
 356         my $fn = shift;
 357         if ($fn->{TYPE} eq "TYPEDEF") {
 358                 if (util::has_property($fn, "public")) {
 359                         return "";
 360                 }
 361         }
 362
 363         if ($fn->{TYPE} eq "FUNCTION") {
 364                 if (util::has_property($fn, "public")) {
 365                         return "";
 366                 }
 367         }
 368         return "static ";
 369 }
 370
 371 ###################################################################
 372 # setup any special flags for an element or structure
 373 sub start_flags($)
 374 {
 375         my $e = shift;
 376         my $flags = util::has_property($e, "flag");
 377         if (defined $flags) {
 378                 pidl "{ uint32_t _flags_save_$e->{TYPE} = ndr->flags;";
 379                 pidl "ndr_set_flags(&ndr->flags, $flags);";
 380         }
 381 }
 382
 383 ###################################################################
 384 # end any special flags for an element or structure
 385 sub end_flags($)
 386 {
 387         my $e = shift;
 388         my $flags = util::has_property($e, "flag");
 389         if (defined $flags) {
 390                 pidl "ndr->flags = _flags_save_$e->{TYPE};\n\t}";
 391         }
 392 }
 393
 394 #####################################################################
 395 # work out the correct alignment for a structure or union
 396 sub find_largest_alignment($)
 397 {
 398         my $s = shift;
 399
 400         my $align = 1;
 401         for my $e (@{$s->{ELEMENTS}}) {
 402                 my $a = 1;
 403
 404                 if (need_wire_pointer($e)) {
 405                         $a = 4;
 406                 } else {
 407                         $a = align_type($e->{TYPE});
 408                 }
 409
 410                 $align = $a if ($align < $a);
 411         }
 412
 413         return $align;
 414 }
 415
 416 #####################################################################
 417 # align a type
 418 sub align_type
 419 {
 420         my $e = shift;
 421
 422         unless (typelist::hasType($e)) {
 423             # it must be an external type - all we can do is guess
 424                 # print "Warning: assuming alignment of unknown type '$e' is 4\n";
 425             return 4;
 426         }
 427
 428         my $dt = typelist::getType($e)->{DATA};
 429
 430         my $tmp = $typefamily{$dt->{TYPE}}->{ALIGN}->($dt);
 431         return $tmp;
 432 }
 433
 434 #####################################################################
 435 # parse array preceding data - push side
 436 sub ParseArrayPushPreceding($$$)
 437 {
 438         my $e = shift;
 439         my $var_prefix = shift;
 440         my $ndr_flags = shift;
 441
 442         my $size = ParseExpr($e, util::array_size($e), $var_prefix);
 443
 444         if (!is_inline_array($e)) {
 445                 # we need to emit the array size
 446                 pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $size));";
 447         }
 448 }
 449
 450 #####################################################################
 451 # parse the data of an array - push side
 452 sub ParseArrayPush($$$)
 453 {
 454         my $e = shift;
 455         my $var_prefix = shift;
 456         my $ndr_flags = shift;
 457
 458         my $size = ParseExpr($e, util::array_size($e), $var_prefix);
 459
 460         if (!is_surrounding_array($e)) {
 461                 ParseArrayPushPreceding($e, $var_prefix, $ndr_flags);
 462         }
 463
 464         if (is_varying_array($e)) {
 465                 my $length = util::has_property($e, "length_is");
 466                 $length = ParseExpr($e, $length, $var_prefix);
 467                 pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));";
 468                 pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $length));";
 469                 $size = $length;
 470         }
 471
 472         if (is_scalar_type($e->{TYPE})) {
 473                 pidl "NDR_CHECK(ndr_push_array_$e->{TYPE}(ndr, $ndr_flags, $var_prefix$e->{NAME}, $size));";
 474         } else {
 475                 pidl "NDR_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}));";
 476         }
 477 }
 478
 479 #####################################################################
 480 # print an array
 481 sub ParseArrayPrint($$)
 482 {
 483         my $e = shift;
 484         my $var_prefix = shift;
 485         my $size = ParseExpr($e, util::array_size($e), $var_prefix);
 486
 487         if (is_varying_array($e)) {
 488                 $size = ParseExpr($e, util::has_property($e, "length_is"), $var_prefix);
 489         }
 490
 491         if (is_scalar_type($e->{TYPE})) {
 492                 pidl "ndr_print_array_$e->{TYPE}(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME}, $size);";
 493         } else {
 494                 pidl "ndr_print_array(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME}, sizeof($var_prefix$e->{NAME}\[0]), $size, (ndr_print_fn_t)ndr_print_$e->{TYPE});";
 495         }
 496 }
 497
 498 #####################################################################
 499 # check the size_is and length_is constraints
 500 sub CheckArraySizes($$)
 501 {
 502         my $e = shift;
 503         my $var_prefix = shift;
 504
 505         if (!is_surrounding_array($e) && is_conformant_array($e)) {
 506                 my $size = ParseExpr($e, util::array_size($e), $var_prefix);
 507                 pidl "if ($var_prefix$e->{NAME}) {";
 508                 indent;
 509                 check_null_pointer($size);
 510                 pidl "NDR_CHECK(ndr_check_array_size(ndr, (void*)&$var_prefix$e->{NAME}, $size));";
 511                 deindent;
 512                 pidl "}";
 513         }
 514
 515         if (is_varying_array($e)) {
 516                 my $length = util::has_property($e, "length_is");
 517                 $length = ParseExpr($e, $length, $var_prefix);
 518                 pidl "if ($var_prefix$e->{NAME}) {";
 519                 indent;
 520                 check_null_pointer($length);
 521                 pidl "NDR_CHECK(ndr_check_array_length(ndr, (void*)&$var_prefix$e->{NAME}, $length));";
 522                 deindent;
 523                 pidl "}"
 524         }
 525 }
 526
 527 sub ParseArrayPullPreceding($$$)
 528 {
 529         my $e = shift;
 530         my $var_prefix = shift;
 531         my $ndr_flags = shift;
 532
 533         if (!is_inline_array($e)) {
 534                 # non fixed arrays encode the size just before the array
 535                 pidl "NDR_CHECK(ndr_pull_array_size(ndr, &$var_prefix$e->{NAME}));";
 536         }
 537 }
 538
 539 #####################################################################
 540 # parse an array - pull side
 541 sub ParseArrayPull($$$)
 542 {
 543         my $e = shift;
 544         my $var_prefix = shift;
 545         my $ndr_flags = shift;
 546
 547         my $size = ParseExpr($e, util::array_size($e), $var_prefix);
 548         my $alloc_size = $size;
 549
 550         # if this is a conformant array then we use that size to allocate, and make sure
 551         # we allocate enough to pull the elements
 552         if (is_conformant_array($e) and is_surrounding_array($e)) {
 553                 $alloc_size = "ndr_get_array_size(ndr, &$var_prefix$e->{NAME})";
 554                 check_null_pointer($size);
 555                 pidl "if ($size > $alloc_size) {";
 556                 indent;
 557                 pidl "return ndr_pull_error(ndr, NDR_ERR_CONFORMANT_SIZE, \"Bad conformant size %u should be %u\", $alloc_size, $size);";
 558                 deindent;
 559                 pidl "}";
 560         } elsif (!is_inline_array($e)) {
 561                 if ($var_prefix =~ /^r->out/ && $size =~ /^\*r->in/) {
 562                         my $size2 = substr($size, 1);
 563                         pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { NDR_ALLOC(ndr, $size2); }";
 564                 }
 565
 566                 ParseArrayPullPreceding($e, $var_prefix, $ndr_flags);
 567
 568                 $alloc_size = "ndr_get_array_size(ndr, &$var_prefix$e->{NAME})";
 569         }
 570
 571         if ((need_alloc($e) && !is_fixed_array($e)) ||
 572             ($var_prefix eq "r->in." && util::has_property($e, "ref"))) {
 573                 if (!is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") {
 574                         pidl "NDR_ALLOC_N(ndr, $var_prefix$e->{NAME}, $alloc_size);";
 575                 }
 576         }
 577
 578         if (($var_prefix eq "r->out." && util::has_property($e, "ref"))) {
 579                 if (!is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") {
 580                         pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {";
 581                         indent;
 582                         pidl "NDR_ALLOC_N(ndr, $var_prefix$e->{NAME}, $alloc_size);";
 583                         deindent;
 584                         pidl "}";
 585                 }
 586         }
 587
 588         if (is_varying_array($e)) {
 589                 pidl "NDR_CHECK(ndr_pull_array_length(ndr, &$var_prefix$e->{NAME}));";
 590                 $size = "ndr_get_array_length(ndr, &$var_prefix$e->{NAME})";
 591         }
 592
 593         check_null_pointer($size);
 594
 595         if (is_scalar_type($e->{TYPE})) {
 596                 pidl "NDR_CHECK(ndr_pull_array_$e->{TYPE}(ndr, $ndr_flags, $var_prefix$e->{NAME}, $size));";
 597         } else {
 598                 pidl "NDR_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}));";
 599         }
 600 }
 601
 602 #####################################################################
 603 # parse scalars in a structure element
 604 sub ParseElementPushScalar($$$)
 605 {
 606         my($e) = shift;
 607         my($var_prefix) = shift;
 608         my($ndr_flags) = shift;
 609         my $cprefix = c_push_prefix($e);
 610         my $ptr_prefix = c_ptr_prefix($e);
 611         my $sub_size = util::has_property($e, "subcontext");
 612
 613         start_flags($e);
 614
 615         if (my $value = util::has_property($e, "value")) {
 616                 pidl "$cprefix$var_prefix$e->{NAME} = $value;";
 617         }
 618
 619         if (util::has_property($e, "relative")) {
 620                 pidl "NDR_CHECK(ndr_push_relative_ptr1(ndr, $ptr_prefix$var_prefix$e->{NAME}));";
 621         } elsif (need_wire_pointer($e)) {
 622                 ParseElementPushPtr($e, $ptr_prefix.$var_prefix, "NDR_SCALARS");
 623         } elsif (is_inline_array($e)) {
 624                 ParseArrayPush($e, "r->", "NDR_SCALARS");
 625         } elsif (need_alloc($e)) {
 626                 # no scalar component
 627         } elsif (my $switch = util::has_property($e, "switch_is")) {
 628                 ParseElementPushSwitch($e, $var_prefix, $ndr_flags, $switch);
 629         } elsif (defined $sub_size) {
 630                 pidl "NDR_CHECK(ndr_push_subcontext_flags_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_push_flags_fn_t) ndr_push_$e->{TYPE}));";
 631         } else {
 632                 pidl "NDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));";
 633         }
 634
 635         end_flags($e);
 636 }
 637
 638 #####################################################################
 639 # parse a pointer in a struct element or function
 640 sub ParseElementPushPtr($$$)
 641 {
 642         my $e = shift;
 643         my $var_prefix = shift;
 644         my $ndr_flags = shift;
 645
 646         pidl "NDR_CHECK(ndr_push_unique_ptr(ndr, $var_prefix$e->{NAME}));";
 647 }
 648
 649 #####################################################################
 650 # print scalars in a structure element
 651 sub ParseElementPrint($$)
 652 {
 653         my($e) = shift;
 654         my($var_prefix) = shift;
 655         my $cprefix = c_push_prefix($e);
 656         my $ptr_prefix = c_ptr_prefix($e);
 657
 658         return if (util::has_property($e, "noprint"));
 659
 660         if (my $value = util::has_property($e, "value")) {
 661                 pidl "if (ndr->flags & LIBNDR_PRINT_SET_VALUES) {";
 662                 indent;
 663                 pidl "$cprefix$var_prefix$e->{NAME} = $value;";
 664                 deindent;
 665                 pidl "}";
 666         }
 667
 668         my $l = $e->{POINTERS};
 669         $l++ if (util::array_size($e) and $l == 0 and !is_fixed_array($e));
 670
 671         foreach my $i (1..$l) {
 672                 pidl "ndr_print_ptr(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME});";
 673                 pidl "ndr->depth++;";
 674                 if ($i > $l-need_wire_pointer($e)) {
 675                         pidl "if ($ptr_prefix$var_prefix$e->{NAME}) {";
 676                         indent;
 677                 }
 678         }
 679
 680         if (util::array_size($e)) {
 681                 ParseArrayPrint($e, $var_prefix)
 682         } elsif (my $switch = util::has_property($e, "switch_is")) {
 683                 my $switch_var = ParseExpr($e, $switch, $var_prefix);
 684                 check_null_pointer_void($switch_var);
 685
 686                 pidl "ndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $switch_var, $cprefix$var_prefix$e->{NAME});";
 687         } else {
 688                 pidl "ndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME});";
 689         }
 690
 691         foreach my $i (1..$l) {
 692                 if ($i > $l-need_wire_pointer($e)) {
 693                         deindent;
 694                         pidl "}";
 695                 }
 696                 pidl "ndr->depth--;";
 697         }
 698 }
 699
 700 #####################################################################
 701 # parse scalars in a structure element - pull size
 702 sub ParseElementPullSwitch($$$$)
 703 {
 704         my($e) = shift;
 705         my($var_prefix) = shift;
 706         my($ndr_flags) = shift;
 707         my $switch = shift;
 708         my $switch_var = ParseExpr($e, $switch, $var_prefix);
 709
 710         my $cprefix = c_pull_prefix($e);
 711
 712         my $utype = typelist::getType($e->{TYPE});
 713
 714         check_null_pointer($switch_var);
 715
 716         if (!defined $utype ||
 717             !util::has_property($utype, "nodiscriminant")) {
 718                 my $e2 = find_sibling($e, $switch);
 719                 my $type_decl = typelist::mapType($e2);
 720                 pidl "if (($ndr_flags) & NDR_SCALARS) {";
 721                 indent;
 722                 if (typelist::getType($e2->{TYPE})->{DATA}->{TYPE} eq "ENUM") {
 723                         $type_decl = typelist::mapType($e2);
 724                 } elsif (typelist::getType($e2->{TYPE})->{DATA}->{TYPE} eq "BITMAP") {
 725                         $type_decl = typelist::mapType($e2);
 726                 }
 727                 pidl "$type_decl _level;";
 728                 pidl "NDR_CHECK(ndr_pull_$e2->{TYPE}(ndr, NDR_SCALARS, &_level));";
 729                 if ($switch_var =~ /r->in/) {
 730                         pidl "if (!(ndr->flags & LIBNDR_FLAG_REF_ALLOC) && _level != $switch_var) {";
 731                         indent;
 732                 } else {
 733                         pidl "if (_level != $switch_var) {";
 734                         indent;
 735                 }
 736                 pidl "return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u in $e->{NAME}\", _level);";
 737                 deindent;
 738                 if ($switch_var =~ /r->/) {
 739                         pidl "} else { $switch_var = _level; }";
 740                 } else {
 741                         pidl "}";
 742                 }
 743                 deindent;
 744                 pidl "}";
 745         }
 746
 747         my $sub_size = util::has_property($e, "subcontext");
 748         if (defined $sub_size) {
 749                 pidl "if (($ndr_flags) & NDR_SCALARS) {";
 750                 indent;
 751                 pidl "NDR_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}));";
 752                 deindent;
 753                 pidl "}";
 754         } else {
 755                 pidl "NDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $switch_var, $cprefix$var_prefix$e->{NAME}));";
 756         }
 757
 758
 759 }
 760
 761 #####################################################################
 762 # push switch element
 763 sub ParseElementPushSwitch($$$$)
 764 {
 765         my($e) = shift;
 766         my($var_prefix) = shift;
 767         my($ndr_flags) = shift;
 768         my $switch = shift;
 769         my $switch_var = ParseExpr($e, $switch, $var_prefix);
 770         my $cprefix = c_push_prefix($e);
 771
 772         check_null_pointer($switch_var);
 773
 774         my $utype = typelist::getType($e->{TYPE});
 775         if (!defined $utype ||
 776             !util::has_property($utype, "nodiscriminant")) {
 777                 my $e2 = find_sibling($e, $switch);
 778                 pidl "if (($ndr_flags) & NDR_SCALARS) {";
 779                 indent;
 780                 pidl "NDR_CHECK(ndr_push_$e2->{TYPE}(ndr, NDR_SCALARS, $switch_var));";
 781                 deindent;
 782                 pidl "}";
 783         }
 784
 785         my $sub_size = util::has_property($e, "subcontext");
 786         if (defined $sub_size) {
 787                 pidl "if(($ndr_flags) & NDR_SCALARS) {";
 788                 indent;
 789                 pidl "NDR_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}));";
 790                 deindent;
 791                 pidl "}";
 792         } else {
 793                 pidl "NDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $switch_var, $cprefix$var_prefix$e->{NAME}));";
 794         }
 795 }
 796
 797 #####################################################################
 798 # parse scalars in a structure element - pull size
 799 sub ParseElementPullScalar($$$)
 800 {
 801         my($e) = shift;
 802         my($var_prefix) = shift;
 803         my($ndr_flags) = shift;
 804         my $cprefix = c_pull_prefix($e);
 805         my $ptr_prefix = c_ptr_prefix($e);
 806         my $sub_size = util::has_property($e, "subcontext");
 807
 808         start_flags($e);
 809
 810         if (is_inline_array($e)) {
 811                 ParseArrayPull($e, "r->", "NDR_SCALARS");
 812         } elsif (need_wire_pointer($e)) {
 813                 ParseElementPullPtr($e, $ptr_prefix.$var_prefix, "NDR_SCALARS");
 814         } elsif (is_surrounding_array($e)) {
 815         } elsif (my $switch = util::has_property($e, "switch_is")) {
 816                 ParseElementPullSwitch($e, $var_prefix, $ndr_flags, $switch);
 817         } elsif (defined $sub_size) {
 818                 pidl "NDR_CHECK(ndr_pull_subcontext_flags_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_flags_fn_t) ndr_pull_$e->{TYPE}));";
 819         } else {
 820                 pidl "NDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));";
 821         }
 822
 823         if (my $range = util::has_property($e, "range")) {
 824                 my ($low, $high) = split(/ /, $range, 2);
 825                 pidl "if ($var_prefix$e->{NAME} < $low || $var_prefix$e->{NAME} > $high) {";
 826                 pidl "\treturn ndr_pull_error(ndr, NDR_ERR_RANGE, \"value out of range\");";
 827                 pidl "}";
 828         }
 829
 830         end_flags($e);
 831 }
 832
 833 #####################################################################
 834 # parse a pointer in a struct element or function
 835 sub ParseElementPullPtr($$$)
 836 {
 837         my($e) = shift;
 838         my($var_prefix) = shift;
 839         my($ndr_flags) = shift;
 840
 841         pidl "NDR_CHECK(ndr_pull_unique_ptr(ndr, &_ptr_$e->{NAME}));";
 842         pidl "if (_ptr_$e->{NAME}) {";
 843         indent;
 844         pidl "NDR_ALLOC(ndr, $var_prefix$e->{NAME});";
 845         if (util::has_property($e, "relative")) {
 846                 pidl "NDR_CHECK(ndr_pull_relative_ptr1(ndr, $var_prefix$e->{NAME}, _ptr_$e->{NAME}));";
 847         }
 848         deindent;
 849         pidl "} else {";
 850         pidl "\t$var_prefix$e->{NAME} = NULL;";
 851         pidl "}";
 852 }
 853
 854 #####################################################################
 855 # parse buffers in a structure element
 856 sub ParseElementPushBuffer($$$)
 857 {
 858         my($e) = shift;
 859         my($var_prefix) = shift;
 860         my($ndr_flags) = shift;
 861         my $cprefix = c_push_prefix($e);
 862         my $sub_size = util::has_property($e, "subcontext");
 863
 864         return if (is_pure_scalar($e));
 865
 866         start_flags($e);
 867
 868         my $pointers = c_ptr_prefix($e);
 869         for my $i (1..need_wire_pointer($e)) {
 870                 if ($i > 1) {
 871                         ParseElementPushPtr($e,$pointers.$var_prefix,$ndr_flags);
 872                 }
 873                 pidl "if ($pointers$var_prefix$e->{NAME}) {";
 874                 indent;
 875                 $pointers.="*";
 876         }
 877
 878         if (util::has_property($e, "relative")) {
 879                 pidl "NDR_CHECK(ndr_push_relative_ptr2(ndr, $var_prefix$e->{NAME}));";
 880         }
 881
 882         if (is_inline_array($e)) {
 883                 ParseArrayPush($e, "r->", "NDR_BUFFERS");
 884         } elsif (util::array_size($e)) {
 885                 ParseArrayPush($e, "r->", "NDR_SCALARS|NDR_BUFFERS");
 886         } elsif (my $switch = util::has_property($e, "switch_is")) {
 887                 if ($e->{POINTERS}) {
 888                         ParseElementPushSwitch($e, $var_prefix, "NDR_BUFFERS|NDR_SCALARS", $switch);
 889                 } else {
 890                         ParseElementPushSwitch($e, $var_prefix, "NDR_BUFFERS", $switch);
 891                 }
 892         } elsif (defined $sub_size) {
 893                 if ($e->{POINTERS}) {
 894                         pidl "NDR_CHECK(ndr_push_subcontext_flags_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_push_flags_fn_t) ndr_push_$e->{TYPE}));";
 895                 }
 896         } elsif ($e->{POINTERS}) {
 897                 pidl "NDR_CHECK(ndr_push_$e->{TYPE}(ndr, NDR_SCALARS|NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}));";
 898         } else {
 899                 pidl "NDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));";
 900         }
 901
 902         for my $i (1..need_wire_pointer($e)) {
 903                 deindent;
 904                 pidl "}";
 905         }
 906
 907         end_flags($e);
 908 }
 909
 910 #####################################################################
 911 # parse buffers in a structure element - pull side
 912 sub ParseElementPullBuffer($$$)
 913 {
 914         my($e) = shift;
 915         my($var_prefix) = shift;
 916         my($ndr_flags) = shift;
 917         my $cprefix = c_pull_prefix($e);
 918         my $sub_size = util::has_property($e, "subcontext");
 919
 920         return if (is_pure_scalar($e));
 921
 922         start_flags($e);
 923
 924         my $pointers = c_ptr_prefix($e);
 925         for my $i (1..need_wire_pointer($e)) {
 926                 if ($i > 1) {
 927                         ParseElementPullPtr($e,$pointers.$var_prefix,"NDR_SCALARS");
 928                 }
 929                 pidl "if ($pointers$var_prefix$e->{NAME}) {";
 930                 indent;
 931                 $pointers.="*";
 932         }
 933
 934         if (util::has_property($e, "relative")) {
 935                 pidl "struct ndr_pull_save _relative_save;";
 936                 pidl "ndr_pull_save(ndr, &_relative_save);";
 937                 pidl "NDR_CHECK(ndr_pull_relative_ptr2(ndr, $var_prefix$e->{NAME}));";
 938         }
 939
 940         if (is_inline_array($e)) {
 941                 ParseArrayPull($e, "r->", "NDR_BUFFERS");
 942         } elsif (util::array_size($e)) {
 943                 ParseArrayPull($e, "r->", "NDR_SCALARS|NDR_BUFFERS");
 944         } elsif (my $switch = util::has_property($e, "switch_is")) {
 945                 if ($e->{POINTERS}) {
 946                         ParseElementPullSwitch($e, $var_prefix, "NDR_SCALARS|NDR_BUFFERS", $switch);
 947                 } else {
 948                         ParseElementPullSwitch($e, $var_prefix, "NDR_BUFFERS", $switch);
 949                 }
 950         } elsif (defined $sub_size) {
 951                 if ($e->{POINTERS}) {
 952                         pidl "NDR_CHECK(ndr_pull_subcontext_flags_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_flags_fn_t) ndr_pull_$e->{TYPE}));";
 953                 }
 954         } elsif ($e->{POINTERS}) {
 955                 pidl "NDR_CHECK(ndr_pull_$e->{TYPE}(ndr, NDR_SCALARS|NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}));";
 956         } else {
 957                 pidl "NDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));";
 958         }
 959
 960         if (util::has_property($e, "relative")) {
 961                 pidl "ndr_pull_restore(ndr, &_relative_save);";
 962         }
 963         for my $i (1..need_wire_pointer($e)) {
 964                 deindent;
 965                 pidl "}";
 966         }
 967
 968         end_flags($e);
 969 }
 970
 971 #####################################################################
 972 # parse a struct
 973 sub ParseStructPush($)
 974 {
 975         my($struct) = shift;
 976
 977         return unless defined($struct->{ELEMENTS});
 978
 979         start_flags($struct);
 980
 981         # see if the structure contains a conformant array. If it
 982         # does, then it must be the last element of the structure, and
 983         # we need to push the conformant length early, as it fits on
 984         # the wire before the structure (and even before the structure
 985         # alignment)
 986         my $e = $struct->{ELEMENTS}[-1];
 987         if (is_conformant_array($e) and is_surrounding_array($e)) {
 988                 ParseArrayPushPreceding($e, "r->", "NDR_SCALARS");
 989         }
 990
 991         if (defined $e->{TYPE} && $e->{TYPE} eq "string"
 992             &&  util::property_matches($e, "flag", ".*LIBNDR_FLAG_STR_CONFORMANT.*")) {
 993                 pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_string_array_size(ndr, r->$e->{NAME})));";
 994         }
 995
 996         pidl "if (!(ndr_flags & NDR_SCALARS)) goto buffers;";
 997
 998         pidl "NDR_CHECK(ndr_push_struct_start(ndr));";
 999
1000         my $align = find_largest_alignment($struct);
1001         pidl "NDR_CHECK(ndr_push_align(ndr, $align));";
1002
1003         foreach my $e (@{$struct->{ELEMENTS}}) {
1004                 ParseElementPushScalar($e, "r->", "NDR_SCALARS");
1005         }
1006
1007         pidl "buffers:";
1008         pidl "if (!(ndr_flags & NDR_BUFFERS)) goto done;";
1009         foreach my $e (@{$struct->{ELEMENTS}}) {
1010                 ParseElementPushBuffer($e, "r->", "NDR_BUFFERS");
1011         }
1012
1013         pidl "ndr_push_struct_end(ndr);";
1014
1015         pidl "done:";
1016
1017         end_flags($struct);
1018 }
1019
1020 #####################################################################
1021 # generate a push function for an enum
1022 sub ParseEnumPush($)
1023 {
1024         my($enum) = shift;
1025         my($type_fn) = typelist::enum_type_fn($enum);
1026
1027         start_flags($enum);
1028
1029         pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));";
1030
1031         end_flags($enum);
1032 }
1033
1034 #####################################################################
1035 # generate a pull function for an enum
1036 sub ParseEnumPull($)
1037 {
1038         my($enum) = shift;
1039         my($type_fn) = typelist::enum_type_fn($enum);
1040         my($type_v_decl) = typelist::mapScalarType(typelist::enum_type_fn($enum));
1041
1042         pidl "$type_v_decl v;";
1043         start_flags($enum);
1044         pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));";
1045         pidl "*r = v;";
1046
1047         end_flags($enum);
1048 }
1049
1050 #####################################################################
1051 # generate a print function for an enum
1052 sub ParseEnumPrint($)
1053 {
1054         my($enum) = shift;
1055
1056         pidl "const char *val = NULL;";
1057         pidl "";
1058
1059         start_flags($enum);
1060
1061         pidl "switch (r) {";
1062         indent;
1063         my $els = \@{$enum->{ELEMENTS}};
1064         foreach my $i (0 .. $#{$els}) {
1065                 my $e = ${$els}[$i];
1066                 chomp $e;
1067                 if ($e =~ /^(.*)=/) {
1068                         $e = $1;
1069                 }
1070                 pidl "case $e: val = \"$e\"; break;";
1071         }
1072
1073         deindent;
1074         pidl "}";
1075
1076         pidl "ndr_print_enum(ndr, name, \"$enum->{TYPE}\", val, r);";
1077
1078         end_flags($enum);
1079 }
1080
1081 sub ArgsEnumPush($)
1082 {
1083         my $e = shift;
1084         return "struct ndr_push *ndr, int ndr_flags, enum $e->{NAME} r";
1085 }
1086
1087 sub ArgsEnumPrint($)
1088 {
1089         my $e = shift;
1090         return "struct ndr_print *ndr, const char *name, enum $e->{NAME} r";
1091 }
1092
1093 sub ArgsEnumPull($)
1094 {
1095         my $e = shift;
1096         return "struct ndr_pull *ndr, int ndr_flags, enum $e->{NAME} *r";
1097 }
1098
1099 $typefamily{ENUM} = {
1100         PUSH_FN_BODY => \&ParseEnumPush,
1101         PUSH_FN_ARGS => \&ArgsEnumPush,
1102         PULL_FN_BODY => \&ParseEnumPull,
1103         PULL_FN_ARGS => \&ArgsEnumPull,
1104         PRINT_FN_BODY => \&ParseEnumPrint,
1105         PRINT_FN_ARGS => \&ArgsEnumPrint,
1106         ALIGN => sub { return align_type(typelist::enum_type_fn(shift)); }
1107 };
1108
1109 #####################################################################
1110 # generate a push function for a bitmap
1111 sub ParseBitmapPush($)
1112 {
1113         my($bitmap) = shift;
1114         my($type_fn) = typelist::bitmap_type_fn($bitmap);
1115
1116         start_flags($bitmap);
1117
1118         pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));";
1119
1120         end_flags($bitmap);
1121 }
1122
1123 #####################################################################
1124 # generate a pull function for an bitmap
1125 sub ParseBitmapPull($)
1126 {
1127         my($bitmap) = shift;
1128         my($type_fn) = typelist::bitmap_type_fn($bitmap);
1129         my($type_decl) = typelist::mapType($bitmap);
1130
1131         pidl "$type_decl v;";
1132         start_flags($bitmap);
1133         pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));";
1134         pidl "*r = v;";
1135
1136         end_flags($bitmap);
1137 }
1138
1139 #####################################################################
1140 # generate a print function for an bitmap
1141 sub ParseBitmapPrintElement($$)
1142 {
1143         my($e) = shift;
1144         my($bitmap) = shift;
1145         my($type_decl) = typelist::mapType($bitmap);
1146         my($type_fn) = typelist::bitmap_type_fn($bitmap);
1147         my($name) = $bitmap->{PARENT}->{NAME};
1148         my($flag);
1149
1150         if ($e =~ /^(\w+) .*$/) {
1151                 $flag = "$1";
1152         } else {
1153                 die "Bitmap: \"$name\" invalid Flag: \"$e\"";
1154         }
1155
1156         pidl "ndr_print_bitmap_flag(ndr, sizeof($type_decl), \"$flag\", $flag, r);";
1157 }
1158
1159 #####################################################################
1160 # generate a print function for an bitmap
1161 sub ParseBitmapPrint($)
1162 {
1163         my($bitmap) = shift;
1164         my($type_decl) = typelist::mapType($bitmap);
1165         my($type_fn) = typelist::bitmap_type_fn($bitmap);
1166
1167         start_flags($bitmap);
1168
1169         pidl "ndr_print_$type_fn(ndr, name, r);";
1170
1171         pidl "ndr->depth++;";
1172         foreach my $e (@{$bitmap->{ELEMENTS}}) {
1173                 ParseBitmapPrintElement($e, $bitmap);
1174         }
1175         pidl "ndr->depth--;";
1176
1177         end_flags($bitmap);
1178 }
1179
1180 sub ArgsBitmapPush($)
1181 {
1182         my $e = shift;
1183         my $type_decl = typelist::mapType($e->{DATA});
1184         return "struct ndr_push *ndr, int ndr_flags, $type_decl r";
1185 }
1186
1187 sub ArgsBitmapPrint($)
1188 {
1189         my $e = shift;
1190         my $type_decl = typelist::mapType($e->{DATA});
1191         return "struct ndr_print *ndr, const char *name, $type_decl r";
1192 }
1193
1194 sub ArgsBitmapPull($)
1195 {
1196         my $e = shift;
1197         my $type_decl = typelist::mapType($e->{DATA});
1198         return "struct ndr_pull *ndr, int ndr_flags, $type_decl *r";
1199 }
1200
1201 $typefamily{BITMAP} = {
1202         PUSH_FN_BODY => \&ParseBitmapPush,
1203         PUSH_FN_ARGS => \&ArgsBitmapPush,
1204         PULL_FN_BODY => \&ParseBitmapPull,
1205         PULL_FN_ARGS => \&ArgsBitmapPull,
1206         PRINT_FN_BODY => \&ParseBitmapPrint,
1207         PRINT_FN_ARGS => \&ArgsBitmapPrint,
1208         ALIGN => sub { return align_type(typelist::bitmap_type_fn(shift)); }
1209 };
1210
1211 #####################################################################
1212 # generate a struct print function
1213 sub ParseStructPrint($)
1214 {
1215         my($struct) = shift;
1216         my($name) = $struct->{PARENT}->{NAME};
1217
1218         return unless defined $struct->{ELEMENTS};
1219
1220         pidl "ndr_print_struct(ndr, name, \"$name\");";
1221
1222         start_flags($struct);
1223
1224         pidl "ndr->depth++;";
1225         foreach my $e (@{$struct->{ELEMENTS}}) {
1226                 ParseElementPrint($e, "r->");
1227         }
1228         pidl "ndr->depth--;";
1229
1230         end_flags($struct);
1231 }
1232
1233 #####################################################################
1234 # parse a struct - pull side
1235 sub ParseStructPull($)
1236 {
1237         my($struct) = shift;
1238         my $conform_e;
1239
1240         return unless defined $struct->{ELEMENTS};
1241
1242         # see if the structure contains a conformant array. If it
1243         # does, then it must be the last element of the structure, and
1244         # we need to pull the conformant length early, as it fits on
1245         # the wire before the structure (and even before the structure
1246         # alignment)
1247         my $e = $struct->{ELEMENTS}[-1];
1248         if (is_conformant_array($e) and is_surrounding_array($e)) {
1249                 $conform_e = $e;
1250         }
1251
1252         if (defined $e->{TYPE} && $e->{TYPE} eq "string"
1253             &&  util::property_matches($e, "flag", ".*LIBNDR_FLAG_STR_CONFORMANT.*")) {
1254                 $conform_e = $e;
1255         }
1256
1257         # declare any internal pointers we need
1258         foreach my $e (@{$struct->{ELEMENTS}}) {
1259                 if (need_wire_pointer($e)) {
1260                         pidl "uint32_t _ptr_$e->{NAME};";
1261                 }
1262         }
1263
1264         start_flags($struct);
1265
1266         pidl "if (!(ndr_flags & NDR_SCALARS)) goto buffers;";
1267
1268         pidl "NDR_CHECK(ndr_pull_struct_start(ndr));";
1269
1270         if (defined $conform_e) {
1271                 ParseArrayPullPreceding($conform_e, "r->", "NDR_SCALARS");
1272         }
1273
1274         my $align = find_largest_alignment($struct);
1275         pidl "NDR_CHECK(ndr_pull_align(ndr, $align));";
1276
1277         foreach my $e (@{$struct->{ELEMENTS}}) {
1278                 ParseElementPullScalar($e, "r->", "NDR_SCALARS");
1279         }
1280
1281         pidl "buffers:\n";
1282         pidl "if (!(ndr_flags & NDR_BUFFERS)) goto done;";
1283         foreach my $e (@{$struct->{ELEMENTS}}) {
1284                 ParseElementPullBuffer($e, "r->", "NDR_BUFFERS");
1285         }
1286
1287         foreach my $e (@{$struct->{ELEMENTS}}) {
1288                 CheckArraySizes($e, "r->");
1289         }
1290
1291         pidl "ndr_pull_struct_end(ndr);";
1292
1293         pidl "done:";
1294
1295         end_flags($struct);
1296 }
1297
1298 #####################################################################
1299 # calculate size of ndr struct
1300 sub ParseStructNdrSize($)
1301 {
1302         my $t = shift;
1303         my $static = fn_prefix($t);
1304         my $sizevar;
1305
1306         pidl "size_t ndr_size_$t->{NAME}(const struct $t->{NAME} *r, int flags)";
1307         pidl "{";
1308         indent;
1309         if (my $flags = util::has_property($t, "flag")) {
1310                 pidl "flags |= $flags;";
1311         }
1312         pidl "return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});";
1313         deindent;
1314         pidl "}";
1315         pidl "";
1316 }
1317
1318 sub ArgsStructPush($)
1319 {
1320         my $e = shift;
1321         return "struct ndr_push *ndr, int ndr_flags, struct $e->{NAME} *r";
1322 }
1323
1324 sub ArgsStructPrint($)
1325 {
1326         my $e = shift;
1327         return "struct ndr_print *ndr, const char *name, struct $e->{NAME} *r";
1328 }
1329
1330 sub ArgsStructPull($)
1331 {
1332         my $e = shift;
1333         return "struct ndr_pull *ndr, int ndr_flags, struct $e->{NAME} *r";
1334 }
1335
1336 $typefamily{STRUCT} = {
1337         PUSH_FN_BODY => \&ParseStructPush,
1338         PUSH_FN_ARGS => \&ArgsStructPush,
1339         PULL_FN_BODY => \&ParseStructPull,
1340         PULL_FN_ARGS => \&ArgsStructPull,
1341         PRINT_FN_BODY => \&ParseStructPrint,
1342         PRINT_FN_ARGS => \&ArgsStructPrint,
1343         SIZE_FN => \&ParseStructNdrSize,
1344         ALIGN => \&find_largest_alignment
1345 };
1346
1347 #####################################################################
1348 # calculate size of ndr struct
1349 sub ParseUnionNdrSize($)
1350 {
1351         my $t = shift;
1352         my $static = fn_prefix($t);
1353         my $sizevar;
1354
1355         pidl "size_t ndr_size_$t->{NAME}(const union $t->{NAME} *r, int level, int flags)";
1356         pidl "{";
1357         indent;
1358         if (my $flags = util::has_property($t, "flag")) {
1359                 pidl "flags |= $flags;";
1360         }
1361         pidl "return ndr_size_union(r, flags, level, (ndr_push_union_fn_t)ndr_push_$t->{NAME});";
1362         deindent;
1363         pidl "}";
1364         pidl "";;
1365 }
1366
1367 #####################################################################
1368 # parse a union - push side
1369 sub ParseUnionPush($)
1370 {
1371         my $e = shift;
1372         my $have_default = 0;
1373
1374         start_flags($e);
1375
1376         pidl "if (!(ndr_flags & NDR_SCALARS)) goto buffers;";
1377
1378         pidl "NDR_CHECK(ndr_push_struct_start(ndr));";
1379
1380 #       my $align = union_alignment($e);
1381 #       pidl "NDR_CHECK(ndr_push_align(ndr, $align));";
1382
1383         pidl "switch (level) {";
1384         indent;
1385         foreach my $el (@{$e->{ELEMENTS}}) {
1386                 if (util::has_property($el, "default")) {
1387                         pidl "default:";
1388                         $have_default = 1;
1389                 } else {
1390                         pidl "case $el->{PROPERTIES}->{case}:";
1391
1392                 }
1393                 if ($el->{TYPE} ne "EMPTY") {
1394                         indent;
1395                         ParseElementPushScalar($el, "r->", "NDR_SCALARS");
1396                         deindent;
1397                 }
1398                 pidl "break;";
1399                 pidl "";
1400         }
1401         if (! $have_default) {
1402                 pidl "default:";
1403                 pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
1404         }
1405         deindent;
1406         pidl "}";
1407         pidl "buffers:";
1408         pidl "if (!(ndr_flags & NDR_BUFFERS)) goto done;";
1409         pidl "switch (level) {";
1410         indent;
1411         foreach my $el (@{$e->{ELEMENTS}}) {
1412                 if (util::has_property($el, "default")) {
1413                         pidl "default:";
1414                 } else {
1415                         pidl "case $el->{PROPERTIES}->{case}:";
1416                 }
1417                 if ($el->{TYPE} ne "EMPTY") {
1418                         indent;
1419                         ParseElementPushBuffer($el, "r->", "NDR_BUFFERS");
1420                         deindent;
1421                 }
1422                 pidl "break;";
1423                 pidl "";
1424         }
1425         if (! $have_default) {
1426                 pidl "default:";
1427                 pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
1428         }
1429         deindent;
1430         pidl "}";
1431         pidl "ndr_push_struct_end(ndr);";
1432         pidl "done:";
1433         end_flags($e);
1434 }
1435
1436 #####################################################################
1437 # print a union
1438 sub ParseUnionPrint($)
1439 {
1440         my $e = shift;
1441         my $have_default = 0;
1442         my($name) = $e->{PARENT}->{NAME};
1443
1444         pidl "ndr_print_union(ndr, name, level, \"$name\");";
1445         start_flags($e);
1446
1447         pidl "switch (level) {";
1448         indent;
1449         foreach my $el (@{$e->{ELEMENTS}}) {
1450                 if (util::has_property($el, "default")) {
1451                         $have_default = 1;
1452                         pidl "default:";
1453                 } else {
1454                         pidl "case $el->{PROPERTIES}->{case}:";
1455                 }
1456                 if ($el->{TYPE} ne "EMPTY") {
1457                         indent;
1458                         ParseElementPrint($el, "r->");
1459                         deindent;
1460                 }
1461                 pidl "break;";
1462                 pidl "";
1463         }
1464         if (! $have_default) {
1465                 pidl "default:";
1466                 pidl "\tndr_print_bad_level(ndr, name, level);";
1467         }
1468         deindent;
1469         pidl "}";
1470
1471         end_flags($e);
1472 }
1473
1474 #####################################################################
1475 # parse a union - pull side
1476 sub ParseUnionPull($)
1477 {
1478         my $e = shift;
1479         my $have_default = 0;
1480
1481         start_flags($e);
1482
1483         pidl "if (!(ndr_flags & NDR_SCALARS)) goto buffers;";
1484
1485         pidl "NDR_CHECK(ndr_pull_struct_start(ndr));";
1486
1487 #       my $align = union_alignment($e);
1488 #       pidl "\tNDR_CHECK(ndr_pull_align(ndr, $align));\n";
1489
1490         pidl "switch (level) {";
1491         indent;
1492         foreach my $el (@{$e->{ELEMENTS}}) {
1493                 if (util::has_property($el, "default")) {
1494                         pidl "default: {";
1495                         $have_default = 1;
1496                 } else {
1497                         pidl "case $el->{PROPERTIES}->{case}: {";
1498                 }
1499                 if ($el->{TYPE} ne "EMPTY") {
1500                         indent;
1501                         if ($el->{POINTERS}) {
1502                                 pidl "uint32_t _ptr_$el->{NAME};";
1503                         }
1504                         ParseElementPullScalar($el, "r->", "NDR_SCALARS");
1505                         deindent;
1506                 }
1507                 pidl "break; }";
1508                 pidl "";
1509         }
1510         if (! $have_default) {
1511                 pidl "default:";
1512                 pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
1513         }
1514         deindent;
1515         pidl "}";
1516         pidl "buffers:";
1517         pidl "if (!(ndr_flags & NDR_BUFFERS)) goto done;";
1518         pidl "switch (level) {";
1519         indent;
1520         foreach my $el (@{$e->{ELEMENTS}}) {
1521                 if (util::has_property($el, "default")) {
1522                         pidl "default:";
1523                 } else {
1524                         pidl "case $el->{PROPERTIES}->{case}:";
1525                 }
1526                 if ($el->{TYPE} ne "EMPTY") {
1527                         indent;
1528                         ParseElementPullBuffer($el, "r->", "NDR_BUFFERS");
1529                         deindent;
1530                 }
1531                 pidl "break;";
1532                 pidl "";
1533         }
1534         if (! $have_default) {
1535                 pidl "default:";
1536                 pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
1537         }
1538         deindent;
1539         pidl "}";
1540         pidl "ndr_pull_struct_end(ndr);";
1541         pidl "done:";
1542         end_flags($e);
1543 }
1544
1545 sub ArgsUnionPush($)
1546 {
1547         my $e = shift;
1548         return "struct ndr_push *ndr, int ndr_flags, int level, union $e->{NAME} *r";
1549 }
1550
1551 sub ArgsUnionPrint($)
1552 {
1553         my $e = shift;
1554         return "struct ndr_print *ndr, const char *name, int level, union $e->{NAME} *r";
1555 }
1556
1557 sub ArgsUnionPull($)
1558 {
1559         my $e = shift;
1560         return "struct ndr_pull *ndr, int ndr_flags, int level, union $e->{NAME} *r";
1561 }
1562
1563 $typefamily{UNION} = {
1564         PUSH_FN_BODY => \&ParseUnionPush,
1565         PUSH_FN_ARGS => \&ArgsUnionPush,
1566         PULL_FN_BODY => \&ParseUnionPull,
1567         PULL_FN_ARGS => \&ArgsUnionPull,
1568         PRINT_FN_BODY => \&ParseUnionPrint,
1569         PRINT_FN_ARGS => \&ArgsUnionPrint,
1570         SIZE_FN => \&ParseUnionNdrSize,
1571         ALIGN => \&find_largest_alignment
1572 };
1573
1574 #####################################################################
1575 # parse a typedef - push side
1576 sub ParseTypedefPush($)
1577 {
1578         my($e) = shift;
1579         my $static = fn_prefix($e);
1580
1581         return unless needed::is_needed("push_$e->{NAME}");
1582
1583         my $args = $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_ARGS}->($e);
1584         pidl $static . "NTSTATUS ndr_push_$e->{NAME}($args)";
1585
1586         pidl "{";
1587         indent;
1588         $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($e->{DATA});
1589         pidl "return NT_STATUS_OK;";
1590         deindent;
1591         pidl "}";
1592         pidl "";;
1593 }
1594
1595
1596 #####################################################################
1597 # parse a typedef - pull side
1598 sub ParseTypedefPull($)
1599 {
1600         my($e) = shift;
1601         my $static = fn_prefix($e);
1602
1603         return unless needed::is_needed("pull_$e->{NAME}");
1604
1605         my $args = $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_ARGS}->($e);
1606
1607         pidl $static . "NTSTATUS ndr_pull_$e->{NAME}($args)";
1608
1609         pidl "{";
1610         indent;
1611         $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($e->{DATA});
1612         pidl "return NT_STATUS_OK;";
1613         deindent;
1614         pidl "}";
1615         pidl "";
1616 }
1617
1618 #####################################################################
1619 # parse a typedef - print side
1620 sub ParseTypedefPrint($)
1621 {
1622         my($e) = shift;
1623
1624         my $args = $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_ARGS}->($e);
1625
1626         pidl "void ndr_print_$e->{NAME}($args)";
1627         pidl "{";
1628         indent;
1629         $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($e->{DATA});
1630         deindent;
1631         pidl "}";
1632 }
1633
1634 #####################################################################
1635 ## calculate the size of a structure
1636 sub ParseTypedefNdrSize($)
1637 {
1638         my($t) = shift;
1639
1640         return unless needed::is_needed("ndr_size_$t->{NAME}");
1641
1642         $typefamily{$t->{DATA}->{TYPE}}->{SIZE_FN}->($t);
1643 }
1644
1645 #####################################################################
1646 # parse a function - print side
1647 sub ParseFunctionPrint($)
1648 {
1649         my($fn) = shift;
1650
1651         pidl "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, struct $fn->{NAME} *r)";
1652         pidl "{";
1653         indent;
1654         pidl "ndr_print_struct(ndr, name, \"$fn->{NAME}\");";
1655         pidl "ndr->depth++;";
1656
1657         pidl "if (flags & NDR_SET_VALUES) {";
1658         pidl "\tndr->flags |= LIBNDR_PRINT_SET_VALUES;";
1659         pidl "}";
1660
1661         pidl "if (flags & NDR_IN) {";
1662         indent;
1663         pidl "ndr_print_struct(ndr, \"in\", \"$fn->{NAME}\");";
1664         pidl "ndr->depth++;";
1665
1666         foreach my $e (@{$fn->{ELEMENTS}}) {
1667                 if (util::has_property($e, "in")) {
1668                         ParseElementPrint($e, "r->in.");
1669                 }
1670         }
1671         pidl "ndr->depth--;";
1672         deindent;
1673         pidl "}";
1674
1675         pidl "if (flags & NDR_OUT) {";
1676         indent;
1677         pidl "ndr_print_struct(ndr, \"out\", \"$fn->{NAME}\");";
1678         pidl "ndr->depth++;";
1679         foreach my $e (@{$fn->{ELEMENTS}}) {
1680                 if (util::has_property($e, "out")) {
1681                         ParseElementPrint($e, "r->out.");
1682                 }
1683         }
1684         if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1685                 my $cprefix = "&";
1686                 $cprefix = "" if (is_scalar_type($fn->{RETURN_TYPE})) ; # FIXME: Should really use util::c_push_prefix here
1687                 pidl "ndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", $cprefix"."r->out.result);";
1688         }
1689         pidl "ndr->depth--;";
1690         deindent;
1691         pidl "}";
1692
1693         pidl "ndr->depth--;";
1694         deindent;
1695         pidl "}";
1696         pidl "";
1697 }
1698
1699 #####################################################################
1700 # parse a function element
1701 sub ParseFunctionElementPush($$)
1702 {
1703         my $e = shift;
1704         my $inout = shift;
1705
1706         if (util::array_size($e)) {
1707                 if (need_wire_pointer($e)) {
1708                         pidl "NDR_CHECK(ndr_push_unique_ptr(ndr, r->$inout.$e->{NAME}));";
1709                         pidl "if (r->$inout.$e->{NAME}) {";
1710                         indent;
1711                         ParseArrayPush($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1712                         deindent;
1713                         pidl "}";
1714                 } else {
1715                         ParseArrayPush($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1716                 }
1717         } else {
1718                 ParseElementPushScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1719
1720                 if (need_wire_pointer($e)) {
1721                         ParseElementPushBuffer($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1722                 }
1723         }
1724 }
1725
1726 #####################################################################
1727 # parse a function
1728 sub ParseFunctionPush($)
1729 {
1730         my($fn) = shift;
1731         my $static = fn_prefix($fn);
1732
1733         pidl $static . "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, struct $fn->{NAME} *r)";
1734         pidl "{";
1735         indent;
1736
1737         pidl "if (!(flags & NDR_IN)) goto ndr_out;";
1738         pidl "";
1739
1740         foreach my $e (@{$fn->{ELEMENTS}}) {
1741                 if (util::has_property($e, "in")) {
1742                         ParseFunctionElementPush($e, "in");
1743                 }
1744         }
1745
1746         pidl "ndr_out:";
1747         pidl "if (!(flags & NDR_OUT)) goto done;";
1748         pidl "";
1749
1750         foreach my $e (@{$fn->{ELEMENTS}}) {
1751                 if (util::has_property($e, "out")) {
1752                         ParseFunctionElementPush($e, "out");
1753                 }
1754         }
1755
1756         if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1757                 pidl "NDR_CHECK(ndr_push_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, r->out.result));";
1758         }
1759
1760         pidl "done:";
1761         pidl "return NT_STATUS_OK;";
1762         deindent;
1763         pidl "}";
1764         pidl "";
1765 }
1766
1767 #####################################################################
1768 # parse a function element
1769 sub ParseFunctionElementPull($$)
1770 {
1771         my $e = shift;
1772         my $inout = shift;
1773
1774         if (util::array_size($e)) {
1775                 if (need_wire_pointer($e)) {
1776                         pidl "NDR_CHECK(ndr_pull_unique_ptr(ndr, &_ptr_$e->{NAME}));";
1777                         pidl "r->$inout.$e->{NAME} = NULL;";
1778                         pidl "if (_ptr_$e->{NAME}) {";
1779                 } elsif ($inout eq "out" && util::has_property($e, "ref")) {
1780                         pidl "if (r->$inout.$e->{NAME}) {";
1781                 } else {
1782                         pidl "{";
1783                 }
1784                 indent;
1785                 ParseArrayPull($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1786                 deindent;
1787                 pidl "}";
1788         } else {
1789                 if ($inout eq "out" && util::has_property($e, "ref")) {
1790                         pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {";
1791                         pidl "\tNDR_ALLOC(ndr, r->out.$e->{NAME});";
1792                         pidl "}";
1793                 }
1794
1795                 if ($inout eq "in" && util::has_property($e, "ref")) {
1796                         pidl "NDR_ALLOC(ndr, r->in.$e->{NAME});";
1797                 }
1798
1799                 ParseElementPullScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1800                 if (need_wire_pointer($e)) {
1801                         ParseElementPullBuffer($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1802                 }
1803         }
1804 }
1805
1806 ############################################################
1807 # allocate ref variables
1808 sub AllocateRefVars($)
1809 {
1810         my $e = shift;
1811         my $asize = util::array_size($e);
1812
1813         # note that if the variable is also an "in"
1814         # variable then we copy the initial value from
1815         # the in side
1816
1817         if (!defined $asize) {
1818                 # its a simple variable
1819                 pidl "NDR_ALLOC(ndr, r->out.$e->{NAME});";
1820                 if (util::has_property($e, "in")) {
1821                         pidl "*r->out.$e->{NAME} = *r->in.$e->{NAME};";
1822                 } else {
1823                         pidl "ZERO_STRUCTP(r->out.$e->{NAME});";
1824                 }
1825                 return;
1826         }
1827
1828         # its an array
1829         my $size = ParseExpr($e, $asize, "r->out.");
1830         check_null_pointer($size);
1831         pidl "NDR_ALLOC_N(ndr, r->out.$e->{NAME}, $size);";
1832         if (util::has_property($e, "in")) {
1833                 pidl "memcpy(r->out.$e->{NAME},r->in.$e->{NAME},$size * sizeof(*r->in.$e->{NAME}));";
1834         } else {
1835                 pidl "memset(r->out.$e->{NAME}, 0, $size * sizeof(*r->out.$e->{NAME}));";
1836         }
1837 }
1838
1839 #####################################################################
1840 # parse a function
1841 sub ParseFunctionPull($)
1842 {
1843         my($fn) = shift;
1844         my $static = fn_prefix($fn);
1845
1846         # pull function args
1847         pidl $static . "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)";
1848         pidl "{";
1849         indent;
1850
1851         # declare any internal pointers we need
1852         foreach my $e (@{$fn->{ELEMENTS}}) {
1853                 if (need_wire_pointer($e)) {
1854                         pidl "uint32_t _ptr_$e->{NAME};";
1855                 }
1856         }
1857
1858         pidl "if (!(flags & NDR_IN)) goto ndr_out;";
1859         pidl "";
1860
1861         # auto-init the out section of a structure. I originally argued that
1862         # this was a bad idea as it hides bugs, but coping correctly
1863         # with initialisation and not wiping ref vars is turning
1864         # out to be too tricky (tridge)
1865         foreach my $e (@{$fn->{ELEMENTS}}) {
1866                 if (util::has_property($e, "out")) {
1867                         pidl "ZERO_STRUCT(r->out);";
1868                         pidl "";
1869                         last;
1870                 }
1871         }
1872
1873         foreach my $e (@{$fn->{ELEMENTS}}) {
1874                 if (util::has_property($e, "in")) {
1875                         ParseFunctionElementPull($e, "in");
1876                 }
1877                 # we need to allocate any reference output variables, so that
1878                 # a dcerpc backend can be sure they are non-null
1879                 if (util::has_property($e, "out") && util::has_property($e, "ref")) {
1880                         AllocateRefVars($e);
1881                 }
1882         }
1883
1884         foreach my $e (@{$fn->{ELEMENTS}}) {
1885                 if (util::has_property($e, "in")) {
1886                         CheckArraySizes($e, "r->in.");
1887                 }
1888         }
1889
1890         pidl "ndr_out:";
1891         pidl "if (!(flags & NDR_OUT)) goto done;";
1892         pidl "";
1893
1894         foreach my $e (@{$fn->{ELEMENTS}}) {
1895                 if (util::has_property($e, "out")) {
1896                         ParseFunctionElementPull($e, "out");
1897                 }
1898         }
1899
1900         foreach my $e (@{$fn->{ELEMENTS}}) {
1901                 if (util::has_property($e, "out")) {
1902                         CheckArraySizes($e, "r->out.");
1903                 }
1904         }
1905
1906         if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1907                 pidl "NDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, &r->out.result));";
1908         }
1909
1910         pidl "done:";
1911         pidl "";
1912         pidl "return NT_STATUS_OK;";
1913         deindent;
1914         pidl "}";
1915         pidl "";
1916 }
1917
1918 #####################################################################
1919 # produce a function call table
1920 sub FunctionTable($)
1921 {
1922         my($interface) = shift;
1923         my($data) = $interface->{INHERITED_DATA};
1924         my $count = 0;
1925         my $uname = uc $interface->{NAME};
1926
1927         foreach my $d (@{$data}) {
1928                 if ($d->{TYPE} eq "FUNCTION") { $count++; }
1929         }
1930
1931         return if ($count == 0);
1932
1933         pidl "static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {";
1934         foreach my $d (@{$data}) {
1935                 if ($d->{TYPE} eq "FUNCTION") {
1936                         pidl "\t{";
1937                         pidl "\t\t\"$d->{NAME}\",";
1938                         pidl "\t\tsizeof(struct $d->{NAME}),";
1939                         pidl "\t\t(ndr_push_flags_fn_t) ndr_push_$d->{NAME},";
1940                         pidl "\t\t(ndr_pull_flags_fn_t) ndr_pull_$d->{NAME},";
1941                         pidl "\t\t(ndr_print_function_t) ndr_print_$d->{NAME}";
1942                         pidl "\t},";
1943                 }
1944         }
1945         pidl "\t{ NULL, 0, NULL, NULL, NULL }";
1946         pidl "};";
1947         pidl "";
1948
1949         # If no endpoint is set, default to the interface name as a named pipe
1950         if (! defined $interface->{PROPERTIES}->{endpoint}) {
1951                 $interface->{PROPERTIES}->{endpoint} = "\"ncacn_np:[\\\\pipe\\\\" . $interface->{NAME} . "]\"";
1952         }
1953
1954         my @e = split / /, $interface->{PROPERTIES}->{endpoint};
1955         my $endpoint_count = $#e + 1;
1956
1957         pidl "static const char * const $interface->{NAME}\_endpoint_strings[] = {";
1958         foreach my $ep (@e) {
1959                 pidl "\t$ep, ";
1960         }
1961         pidl "};";
1962         pidl "";
1963
1964         pidl "static const struct dcerpc_endpoint_list $interface->{NAME}\_endpoints = {";
1965         pidl "\t$endpoint_count, $interface->{NAME}\_endpoint_strings";
1966         pidl "};";
1967         pidl "";
1968
1969         pidl "\nconst struct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {";
1970         pidl "\t\"$interface->{NAME}\",";
1971         pidl "\tDCERPC_$uname\_UUID,";
1972         pidl "\tDCERPC_$uname\_VERSION,";
1973         pidl "\tDCERPC_$uname\_HELPSTRING,";
1974         pidl "\t$count,";
1975         pidl "\t$interface->{NAME}\_calls,";
1976         pidl "\t&$interface->{NAME}\_endpoints";
1977         pidl "};";
1978         pidl "";
1979
1980         pidl "static NTSTATUS dcerpc_ndr_$interface->{NAME}_init(void)";
1981         pidl "{";
1982         pidl "\treturn librpc_register_interface(&dcerpc_table_$interface->{NAME});";
1983         pidl "}";
1984         pidl "";
1985 }
1986
1987 #####################################################################
1988 # parse the interface definitions
1989 sub ParseInterface($)
1990 {
1991         my($interface) = shift;
1992         my($data) = $interface->{DATA};
1993
1994         # Push functions
1995         foreach my $d (@{$data}) {
1996                 ($d->{TYPE} eq "TYPEDEF") &&
1997                     ParseTypedefPush($d);
1998                 ($d->{TYPE} eq "FUNCTION") &&
1999                     ParseFunctionPush($d);
2000         }
2001
2002         # Pull functions
2003         foreach my $d (@{$data}) {
2004                 ($d->{TYPE} eq "TYPEDEF") &&
2005                     ParseTypedefPull($d);
2006                 ($d->{TYPE} eq "FUNCTION") &&
2007                     ParseFunctionPull($d);
2008         }
2009
2010         # Print functions
2011         foreach my $d (@{$data}) {
2012                 if ($d->{TYPE} eq "TYPEDEF" &&
2013                     !util::has_property($d, "noprint")) {
2014                         ParseTypedefPrint($d);
2015                 }
2016                 if ($d->{TYPE} eq "FUNCTION" &&
2017                     !util::has_property($d, "noprint")) {
2018                         ParseFunctionPrint($d);
2019                 }
2020         }
2021
2022         # Size functions
2023         foreach my $d (@{$data}) {
2024                 ($d->{TYPE} eq "TYPEDEF") &&
2025                         ParseTypedefNdrSize($d);
2026         }
2027
2028         FunctionTable($interface);
2029 }
2030
2031 sub RegistrationFunction($$)
2032 {
2033         my $idl = shift;
2034         my $filename = shift;
2035
2036         $filename =~ /.*\/ndr_(.*).c/;
2037         my $basename = $1;
2038         pidl "NTSTATUS dcerpc_$basename\_init(void)";
2039         pidl "{";
2040         indent;
2041         pidl "NTSTATUS status = NT_STATUS_OK;";
2042         foreach my $interface (@{$idl}) {
2043                 next if $interface->{TYPE} ne "INTERFACE";
2044
2045                 my $data = $interface->{INHERITED_DATA};
2046                 my $count = 0;
2047                 foreach my $d (@{$data}) {
2048                         if ($d->{TYPE} eq "FUNCTION") { $count++; }
2049                 }
2050
2051                 next if ($count == 0);
2052
2053                 pidl "status = dcerpc_ndr_$interface->{NAME}_init();";
2054                 pidl "if (NT_STATUS_IS_ERR(status)) {";
2055                 pidl "\treturn status;";
2056                 pidl "}";
2057                 pidl "";
2058         }
2059         pidl "return status;";
2060         deindent;
2061         pidl "}";
2062         pidl "";
2063 }
2064
2065 sub CheckPointerTypes($$)
2066 {
2067         my $s = shift;
2068         my $default = shift;
2069
2070         foreach my $e (@{$s->{ELEMENTS}}) {
2071                 if ($e->{POINTERS}) {
2072                         if (not defined(pointer_type($e))) {
2073                                 $e->{PROPERTIES}->{$default} = 1;
2074                         }
2075
2076                         if (pointer_type($e) eq "ptr") {
2077                                 print "Warning: ptr is not supported by pidl yet\n";
2078                         }
2079                 }
2080         }
2081 }
2082
2083 sub LoadInterface($)
2084 {
2085         my $x = shift;
2086
2087         if (not util::has_property($x, "pointer_default")) {
2088                 # MIDL defaults to "ptr" in DCE compatible mode (/osf)
2089                 # and "unique" in Microsoft Extensions mode (default)
2090                 $x->{PROPERTIES}->{pointer_default} = "unique";
2091         }
2092
2093         foreach my $d (@{$x->{DATA}}) {
2094                 if (($d->{TYPE} eq "DECLARE") or ($d->{TYPE} eq "TYPEDEF")) {
2095                         typelist::addType($d);
2096                         if ($d->{DATA}->{TYPE} eq "STRUCT" or $d->{DATA}->{TYPE} eq "UNION") {
2097                                 CheckPointerTypes($d->{DATA}, $x->{PROPERTIES}->{pointer_default});
2098                         }
2099
2100                         if (defined($d->{PROPERTIES}) && !defined($d->{DATA}->{PROPERTIES})) {
2101                                 $d->{DATA}->{PROPERTIES} = $d->{PROPERTIES};
2102                         }
2103                 }
2104                 if ($d->{TYPE} eq "FUNCTION") {
2105                         CheckPointerTypes($d,
2106                                 $x->{PROPERTIES}->{pointer_default}  # MIDL defaults to "ref"
2107                         );
2108                 }
2109         }
2110 }
2111
2112 # Add ORPC specific bits to an interface.
2113 sub InterfaceORPC($)
2114 {
2115         my $x = shift;
2116         # Add [in] ORPCTHIS *this, [out] ORPCTHAT *that
2117         # for 'object' interfaces
2118         if (util::has_property($x, "object")) {
2119                 foreach my $e (@{$x->{DATA}}) {
2120                         if($e->{TYPE} eq "FUNCTION") {
2121                                 $e->{PROPERTIES}->{object} = 1;
2122                                 unshift(@{$e->{ELEMENTS}},
2123                        { 'NAME' => 'ORPCthis',
2124                          'POINTERS' => 0,
2125                          'PROPERTIES' => { 'in' => '1' },
2126                          'TYPE' => 'ORPCTHIS'
2127                        });
2128                                 unshift(@{$e->{ELEMENTS}},
2129                        { 'NAME' => 'ORPCthat',
2130                          'POINTERS' => 0,
2131                          'PROPERTIES' => { 'out' => '1' },
2132                                           'TYPE' => 'ORPCTHAT'
2133                        });
2134                         }
2135                 }
2136         }
2137 }
2138
2139 sub Load($)
2140 {
2141         my $idl = shift;
2142
2143         foreach my $x (@{$idl}) {
2144                 LoadInterface($x);
2145         }
2146 }
2147
2148 #####################################################################
2149 # parse a parsed IDL structure back into an IDL file
2150 sub Parse($$)
2151 {
2152         my($idl) = shift;
2153         my($filename) = shift;
2154         my $h_filename = $filename;
2155         $res = "";
2156
2157         Load($idl);
2158
2159         if ($h_filename =~ /(.*)\.c/) {
2160                 $h_filename = "$1.h";
2161         }
2162
2163         pidl "/* parser auto-generated by pidl */";
2164         pidl "";
2165         pidl "#include \"includes.h\"";
2166         pidl "#include \"$h_filename\"";
2167         pidl "";
2168
2169         foreach my $x (@{$idl}) {
2170                 if ($x->{TYPE} eq "INTERFACE") {
2171                         needed::BuildNeeded($x);
2172                         ParseInterface($x);
2173                 }
2174         }
2175
2176         RegistrationFunction($idl, $filename);
2177
2178         return $res;
2179 }
2180
2181 1;