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 # released under the GNU GPL
   6
   7 package IdlParser;
   8
   9 use strict;
  10 use Data::Dumper;
  11 use client;
  12
  13 # the list of needed functions
  14 my %needed;
  15 my %structs;
  16
  17 my $if_uuid;
  18 my $if_version;
  19 my $if_endpoints;
  20
  21 sub pidl($)
  22 {
  23         print OUT shift;
  24 }
  25
  26 #####################################################################
  27 # parse a properties list
  28 sub ParseProperties($)
  29 {
  30     my($props) = shift;
  31     foreach my $d (@{$props}) {
  32         if (ref($d) ne "HASH") {
  33             pidl "[$d] ";
  34         } else {
  35             foreach my $k (keys %{$d}) {
  36                 pidl "[$k($d->{$k})] ";
  37             }
  38         }
  39     }
  40 }
  41
  42 ###################################
  43 # find a sibling var in a structure
  44 sub find_sibling($$)
  45 {
  46         my($e) = shift;
  47         my($name) = shift;
  48         my($fn) = $e->{PARENT};
  49
  50         if ($name =~ /\*(.*)/) {
  51                 $name = $1;
  52         }
  53
  54         if ($fn->{TYPE} eq "FUNCTION") {
  55                 for my $e2 (@{$fn->{DATA}}) {
  56                         if ($e2->{NAME} eq $name) {
  57                                 return $e2;
  58                         }
  59                 }
  60         }
  61
  62         for my $e2 (@{$fn->{ELEMENTS}}) {
  63                 if ($e2->{NAME} eq $name) {
  64                         return $e2;
  65                 }
  66         }
  67         die "invalid sibling '$name'";
  68 }
  69
  70 ####################################################################
  71 # work out the name of a size_is() variable
  72 sub find_size_var($$$)
  73 {
  74         my($e) = shift;
  75         my($size) = shift;
  76         my($var_prefix) = shift;
  77
  78         my($fn) = $e->{PARENT};
  79
  80         if (util::is_constant($size)) {
  81                 return $size;
  82         }
  83
  84         if ($size =~ /ndr->|\(/) {
  85                 return $size;
  86         }
  87
  88         my $prefix = "";
  89
  90         if ($size =~ /\*(.*)/) {
  91                 $size = $1;
  92                 $prefix = "*";
  93         }
  94
  95         if ($fn->{TYPE} ne "FUNCTION") {
  96                 return $prefix . "r->$size";
  97         }
  98
  99         my $e2 = find_sibling($e, $size);
 100
 101         if (util::has_property($e2, "in") && util::has_property($e2, "out")) {
 102                 return $prefix . "$var_prefix$size";
 103         }
 104         if (util::has_property($e2, "in")) {
 105                 return $prefix . "r->in.$size";
 106         }
 107         if (util::has_property($e2, "out")) {
 108                 return $prefix . "r->out.$size";
 109         }
 110
 111         die "invalid variable in $size for element $e->{NAME} in $fn->{NAME}\n";
 112 }
 113
 114
 115 #####################################################################
 116 # work out is a parse function should be declared static or not
 117 sub fn_prefix($)
 118 {
 119         my $fn = shift;
 120         if ($fn->{TYPE} eq "TYPEDEF") {
 121                 if (util::has_property($fn->{DATA}, "public")) {
 122                         return "";
 123                 }
 124         }
 125
 126         if ($fn->{TYPE} eq "FUNCTION") {
 127                 if (util::has_property($fn, "public")) {
 128                         return "";
 129                 }
 130         }
 131         return "static ";
 132 }
 133
 134
 135 ###################################################################
 136 # setup any special flags for an element or structure
 137 sub start_flags($)
 138 {
 139         my $e = shift;
 140         my $flags = util::has_property($e, "flag");
 141         if (defined $flags) {
 142                 pidl "\t{ uint32 _flags_save_$e->{TYPE} = ndr->flags;\n";
 143                 pidl "\tndr->flags |= $flags;\n";
 144         }
 145 }
 146
 147 ###################################################################
 148 # end any special flags for an element or structure
 149 sub end_flags($)
 150 {
 151         my $e = shift;
 152         my $flags = util::has_property($e, "flag");
 153         if (defined $flags) {
 154                 pidl "\tndr->flags = _flags_save_$e->{TYPE};\n\t}\n";
 155         }
 156 }
 157
 158
 159 #####################################################################
 160 # work out the correct alignment for a structure
 161 sub struct_alignment
 162 {
 163         my $s = shift;
 164
 165         my $align = 1;
 166         for my $e (@{$s->{ELEMENTS}}) {
 167                 my $a = 1;
 168
 169                 if (!util::need_wire_pointer($e)
 170                     && defined $structs{$e->{TYPE}}) {
 171                         if ($structs{$e->{TYPE}}->{DATA}->{TYPE} eq "STRUCT") {
 172                                 $a = struct_alignment($structs{$e->{TYPE}}->{DATA});
 173                         } elsif ($structs{$e->{TYPE}}->{DATA}->{TYPE} eq "UNION") {
 174                                 if (defined $structs{$e->{TYPE}}->{DATA}) {
 175                                         $a = union_alignment($structs{$e->{TYPE}}->{DATA});
 176                                 }
 177                         }
 178                 } else {
 179                         $a = util::type_align($e);
 180                 }
 181
 182                 if ($align < $a) {
 183                         $align = $a;
 184                 }
 185         }
 186
 187         return $align;
 188 }
 189
 190 #####################################################################
 191 # work out the correct alignment for a union
 192 sub union_alignment
 193 {
 194         my $u = shift;
 195
 196         my $align = 1;
 197
 198         foreach my $e (@{$u->{DATA}}) {
 199                 my $a = 1;
 200
 201                 if ($e->{TYPE} eq "EMPTY") {
 202                         next;
 203                 }
 204
 205                 if (!util::need_wire_pointer($e)
 206                     && defined $structs{$e->{DATA}->{TYPE}}) {
 207                         my $s = $structs{$e->{DATA}->{TYPE}};
 208                         if ($s->{DATA}->{TYPE} eq "STRUCT") {
 209                                 $a = struct_alignment($s->{DATA});
 210                         } elsif ($s->{DATA}->{TYPE} eq "UNION") {
 211                                 $a = union_alignment($s->{DATA});
 212                         }
 213                 } else {
 214                         $a = util::type_align($e->{DATA});
 215                 }
 216
 217                 if ($align < $a) {
 218                         $align = $a;
 219                 }
 220         }
 221
 222         return $align;
 223 }
 224
 225 #####################################################################
 226 # parse an array - push side
 227 sub ParseArrayPush($$$)
 228 {
 229         my $e = shift;
 230         my $var_prefix = shift;
 231         my $ndr_flags = shift;
 232
 233         my $size = find_size_var($e, util::array_size($e), $var_prefix);
 234
 235         if (defined $e->{CONFORMANT_SIZE}) {
 236                 # the conformant size has already been pushed
 237         } elsif (!util::is_inline_array($e)) {
 238                 # we need to emit the array size
 239                 pidl "\t\tNDR_CHECK(ndr_push_uint32(ndr, $size));\n";
 240         }
 241
 242         if (my $length = util::has_property($e, "length_is")) {
 243                 $length = find_size_var($e, $length, $var_prefix);
 244                 pidl "\t\tNDR_CHECK(ndr_push_uint32(ndr, 0));\n";
 245                 pidl "\t\tNDR_CHECK(ndr_push_uint32(ndr, $length));\n";
 246                 $size = $length;
 247         }
 248
 249         if (util::is_scalar_type($e->{TYPE})) {
 250                 pidl "\t\tNDR_CHECK(ndr_push_array_$e->{TYPE}(ndr, $ndr_flags, $var_prefix$e->{NAME}, $size));\n";
 251         } else {
 252                 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";
 253         }
 254 }
 255
 256 #####################################################################
 257 # print an array
 258 sub ParseArrayPrint($$)
 259 {
 260         my $e = shift;
 261         my $var_prefix = shift;
 262         my $size = find_size_var($e, util::array_size($e), $var_prefix);
 263         my $length = util::has_property($e, "length_is");
 264
 265         if (defined $length) {
 266                 $size = find_size_var($e, $length, $var_prefix);
 267         }
 268
 269         if (util::is_scalar_type($e->{TYPE})) {
 270                 pidl "\t\tndr_print_array_$e->{TYPE}(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME}, $size);\n";
 271         } else {
 272                 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";
 273         }
 274 }
 275
 276 #####################################################################
 277 # parse an array - pull side
 278 sub ParseArrayPull($$$)
 279 {
 280         my $e = shift;
 281         my $var_prefix = shift;
 282         my $ndr_flags = shift;
 283
 284         my $size = find_size_var($e, util::array_size($e), $var_prefix);
 285         my $alloc_size = $size;
 286
 287         # if this is a conformant array then we use that size to allocate, and make sure
 288         # we allocate enough to pull the elements
 289         if (defined $e->{CONFORMANT_SIZE}) {
 290                 $alloc_size = $e->{CONFORMANT_SIZE};
 291
 292                 pidl "\tif ($size > $alloc_size) {\n";
 293                 pidl "\t\treturn ndr_pull_error(ndr, NDR_ERR_CONFORMANT_SIZE, \"Bad conformant size %u should be %u\", $alloc_size, $size);\n";
 294                 pidl "\t}\n";
 295         } elsif (!util::is_inline_array($e)) {
 296                 if ($var_prefix =~ /^r->out/ && $size =~ /^\*r->in/) {
 297                         my $size2 = substr($size, 1);
 298                         pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { NDR_ALLOC(ndr, $size2); }\n";
 299                 }
 300
 301                 # non fixed arrays encode the size just before the array
 302                 pidl "\t{\n";
 303                 pidl "\t\tuint32 _array_size;\n";
 304                 pidl "\t\tNDR_CHECK(ndr_pull_uint32(ndr, &_array_size));\n";
 305                 if ($size =~ /r->in/) {
 306                         pidl "\t\tif (!(ndr->flags & LIBNDR_FLAG_REF_ALLOC) && _array_size != $size) {\n";
 307                 } else {
 308                         pidl "\t\tif ($size != _array_size) {\n";
 309                 }
 310                 pidl "\t\t\treturn ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, \"Bad array size %u should be %u\", _array_size, $size);\n";
 311                 pidl "\t\t}\n";
 312                 if ($size =~ /r->in/) {
 313                         pidl "else { $size = _array_size; }\n";
 314                 }
 315                 pidl "\t}\n";
 316         }
 317
 318         if ((util::need_alloc($e) && !util::is_fixed_array($e)) ||
 319             ($var_prefix eq "r->in." && util::has_property($e, "ref"))) {
 320                 if (!util::is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") {
 321                         pidl "\t\tNDR_ALLOC_N_SIZE(ndr, $var_prefix$e->{NAME}, MAX(1, $alloc_size), sizeof($var_prefix$e->{NAME}\[0]));\n";
 322                 }
 323         }
 324
 325         if (($var_prefix eq "r->out." && util::has_property($e, "ref"))) {
 326                 if (!util::is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") {
 327                         pidl "\tif (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {";
 328                         pidl "\t\tNDR_ALLOC_N_SIZE(ndr, $var_prefix$e->{NAME}, MAX(1, $alloc_size), sizeof($var_prefix$e->{NAME}\[0]));\n";
 329                         pidl "\t}\n";
 330                 }
 331         }
 332
 333         pidl "\t{\n";
 334
 335         if (my $length = util::has_property($e, "length_is")) {
 336                 $length = find_size_var($e, $length, $var_prefix);
 337                 pidl "\t\tuint32 _offset, _length;\n";
 338                 pidl "\t\tNDR_CHECK(ndr_pull_uint32(ndr, &_offset));\n";
 339                 pidl "\t\tNDR_CHECK(ndr_pull_uint32(ndr, &_length));\n";
 340                 pidl "\t\tif (_offset != 0) return ndr_pull_error(ndr, NDR_ERR_OFFSET, \"Bad array offset 0x%08x\", _offset);\n";
 341                 pidl "\t\tif (_length > $size || _length != $length) return ndr_pull_error(ndr, NDR_ERR_LENGTH, \"Bad array length 0x%08x > size 0x%08x\", _offset, $size);\n\n";
 342                 $size = "_length";
 343         }
 344
 345         if (util::is_scalar_type($e->{TYPE})) {
 346                 pidl "\t\tNDR_CHECK(ndr_pull_array_$e->{TYPE}(ndr, $ndr_flags, $var_prefix$e->{NAME}, $size));\n";
 347         } else {
 348                 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";
 349         }
 350
 351         pidl "\t}\n";
 352 }
 353
 354
 355 #####################################################################
 356 # parse scalars in a structure element
 357 sub ParseElementPushScalar($$$)
 358 {
 359         my($e) = shift;
 360         my($var_prefix) = shift;
 361         my($ndr_flags) = shift;
 362         my $cprefix = util::c_push_prefix($e);
 363         my $sub_size = util::has_property($e, "subcontext");
 364
 365         start_flags($e);
 366
 367         if (my $value = util::has_property($e, "value")) {
 368                 pidl "\t$cprefix$var_prefix$e->{NAME} = $value;\n";
 369         }
 370
 371         if (util::has_property($e, "relative")) {
 372                 pidl "\tNDR_CHECK(ndr_push_relative(ndr, NDR_SCALARS, $var_prefix$e->{NAME}, (ndr_push_const_fn_t) ndr_push_$e->{TYPE}));\n";
 373         } elsif (util::is_inline_array($e)) {
 374                 ParseArrayPush($e, "r->", "NDR_SCALARS");
 375         } elsif (util::need_wire_pointer($e)) {
 376                 pidl "\tNDR_CHECK(ndr_push_ptr(ndr, $var_prefix$e->{NAME}));\n";
 377         } elsif (util::need_alloc($e)) {
 378                 # no scalar component
 379         } elsif (my $switch = util::has_property($e, "switch_is")) {
 380                 ParseElementPushSwitch($e, $var_prefix, $ndr_flags, $switch);
 381         } elsif (defined $sub_size) {
 382                 if (util::is_builtin_type($e->{TYPE})) {
 383                         pidl "\tNDR_CHECK(ndr_push_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_push_fn_t) ndr_push_$e->{TYPE}));\n";
 384                 } else {
 385                         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";
 386                 }
 387         } elsif (util::is_builtin_type($e->{TYPE})) {
 388                 pidl "\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
 389         } else {
 390                 pidl "\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
 391         }
 392
 393         end_flags($e);
 394 }
 395
 396 #####################################################################
 397 # print scalars in a structure element
 398 sub ParseElementPrintScalar($$)
 399 {
 400         my($e) = shift;
 401         my($var_prefix) = shift;
 402         my $cprefix = util::c_push_prefix($e);
 403
 404         if (util::has_property($e, "noprint")) {
 405                 return;
 406         }
 407
 408         if (my $value = util::has_property($e, "value")) {
 409                 pidl "\tif (ndr->flags & LIBNDR_PRINT_SET_VALUES) {\n";
 410                 pidl "\t\t$cprefix$var_prefix$e->{NAME} = $value;\n";
 411                 pidl "\t}\n";
 412         }
 413
 414         if (util::is_fixed_array($e)) {
 415                 ParseElementPrintBuffer($e, $var_prefix);
 416         } elsif (util::has_direct_buffers($e)) {
 417                 pidl "\tndr_print_ptr(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME});\n";
 418                 pidl "\tndr->depth++;\n";
 419                 ParseElementPrintBuffer($e, $var_prefix);
 420                 pidl "\tndr->depth--;\n";
 421         } elsif (my $switch = util::has_property($e, "switch_is")) {
 422                 ParseElementPrintSwitch($e, $var_prefix, $switch);
 423         } else {
 424                 pidl "\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME});\n";
 425         }
 426 }
 427
 428 #####################################################################
 429 # parse scalars in a structure element - pull size
 430 sub ParseElementPullSwitch($$$$)
 431 {
 432         my($e) = shift;
 433         my($var_prefix) = shift;
 434         my($ndr_flags) = shift;
 435         my $switch = shift;
 436         my $switch_var = find_size_var($e, $switch, $var_prefix);
 437
 438         my $cprefix = util::c_pull_prefix($e);
 439
 440         my $utype = $structs{$e->{TYPE}};
 441         if (!defined $utype ||
 442             !util::has_property($utype->{DATA}, "nodiscriminant")) {
 443                 my $e2 = find_sibling($e, $switch);
 444                 pidl "\tif (($ndr_flags) & NDR_SCALARS) {\n";
 445                 pidl "\t\t $e2->{TYPE} _level;\n";
 446                 pidl "\t\tNDR_CHECK(ndr_pull_$e2->{TYPE}(ndr, &_level));\n";
 447                 if ($switch_var =~ /r->in/) {
 448                         pidl "\t\tif (!(ndr->flags & LIBNDR_FLAG_REF_ALLOC) && _level != $switch_var) {\n";
 449                 } else {
 450                         pidl "\t\tif (_level != $switch_var) {\n";
 451                 }
 452                 pidl "\t\t\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u in $e->{NAME}\");\t\t}\n";
 453                 if ($switch_var =~ /r->/) {
 454                         pidl "else { $switch_var = _level; }\n";
 455                 }
 456                 pidl "\t}\n";
 457         }
 458
 459         my $sub_size = util::has_property($e, "subcontext");
 460         if (defined $sub_size) {
 461                 pidl "\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";
 462         } else {
 463                 pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $switch_var, $cprefix$var_prefix$e->{NAME}));\n";
 464         }
 465
 466
 467 }
 468
 469 #####################################################################
 470 # push switch element
 471 sub ParseElementPushSwitch($$$$)
 472 {
 473         my($e) = shift;
 474         my($var_prefix) = shift;
 475         my($ndr_flags) = shift;
 476         my $switch = shift;
 477         my $switch_var = find_size_var($e, $switch, $var_prefix);
 478         my $cprefix = util::c_push_prefix($e);
 479
 480         my $utype = $structs{$e->{TYPE}};
 481         if (!defined $utype ||
 482             !util::has_property($utype->{DATA}, "nodiscriminant")) {
 483                 my $e2 = find_sibling($e, $switch);
 484                 pidl "\tif (($ndr_flags) & NDR_SCALARS) {\n";
 485                 pidl "\t\tNDR_CHECK(ndr_push_$e2->{TYPE}(ndr, $switch_var));\n";
 486                 pidl "\t}\n";
 487         }
 488
 489         my $sub_size = util::has_property($e, "subcontext");
 490         if (defined $sub_size) {
 491                 pidl "\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";
 492         } else {
 493                 pidl "\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $switch_var, $cprefix$var_prefix$e->{NAME}));\n";
 494         }
 495 }
 496
 497 #####################################################################
 498 # print scalars in a structure element
 499 sub ParseElementPrintSwitch($$$)
 500 {
 501         my($e) = shift;
 502         my($var_prefix) = shift;
 503         my $switch = shift;
 504         my $switch_var = find_size_var($e, $switch, $var_prefix);
 505         my $cprefix = util::c_push_prefix($e);
 506
 507         pidl "\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $switch_var, $cprefix$var_prefix$e->{NAME});\n";
 508 }
 509
 510
 511 #####################################################################
 512 # parse scalars in a structure element - pull size
 513 sub ParseElementPullScalar($$$)
 514 {
 515         my($e) = shift;
 516         my($var_prefix) = shift;
 517         my($ndr_flags) = shift;
 518         my $cprefix = util::c_pull_prefix($e);
 519         my $sub_size = util::has_property($e, "subcontext");
 520
 521         start_flags($e);
 522
 523         if (util::has_property($e, "relative")) {
 524                 pidl "\tNDR_CHECK(ndr_pull_relative(ndr, (const void **)&$var_prefix$e->{NAME}, sizeof(*$var_prefix$e->{NAME}), (ndr_pull_flags_fn_t)ndr_pull_$e->{TYPE}));\n";
 525         } elsif (util::is_inline_array($e)) {
 526                 ParseArrayPull($e, "r->", "NDR_SCALARS");
 527         } elsif (util::need_wire_pointer($e)) {
 528                 pidl "\tNDR_CHECK(ndr_pull_uint32(ndr, &_ptr_$e->{NAME}));\n";
 529                 pidl "\tif (_ptr_$e->{NAME}) {\n";
 530                 pidl "\t\tNDR_ALLOC(ndr, $var_prefix$e->{NAME});\n";
 531                 pidl "\t} else {\n";
 532                 pidl "\t\t$var_prefix$e->{NAME} = NULL;\n";
 533                 pidl "\t}\n";
 534         } elsif (util::need_alloc($e)) {
 535                 # no scalar component
 536         } elsif (my $switch = util::has_property($e, "switch_is")) {
 537                 ParseElementPullSwitch($e, $var_prefix, $ndr_flags, $switch);
 538         } elsif (defined $sub_size) {
 539                 if (util::is_builtin_type($e->{TYPE})) {
 540                         pidl "\tNDR_CHECK(ndr_pull_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_fn_t) ndr_pull_$e->{TYPE}));\n";
 541                 } else {
 542                         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";
 543                 }
 544         } elsif (util::is_builtin_type($e->{TYPE})) {
 545                 pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
 546         } else {
 547                 pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
 548         }
 549
 550         end_flags($e);
 551 }
 552
 553 #####################################################################
 554 # parse buffers in a structure element
 555 sub ParseElementPushBuffer($$$)
 556 {
 557         my($e) = shift;
 558         my($var_prefix) = shift;
 559         my($ndr_flags) = shift;
 560         my $cprefix = util::c_push_prefix($e);
 561         my $sub_size = util::has_property($e, "subcontext");
 562
 563         if (util::is_pure_scalar($e)) {
 564                 return;
 565         }
 566
 567         start_flags($e);
 568
 569         if (util::need_wire_pointer($e)) {
 570                 pidl "\tif ($var_prefix$e->{NAME}) {\n";
 571         }
 572
 573         if (util::has_property($e, "relative")) {
 574                 pidl "\tNDR_CHECK(ndr_push_relative(ndr, NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}, (ndr_push_const_fn_t) ndr_push_$e->{TYPE}));\n";
 575         } elsif (util::is_inline_array($e)) {
 576                 ParseArrayPush($e, "r->", "NDR_BUFFERS");
 577         } elsif (util::array_size($e)) {
 578                 ParseArrayPush($e, "r->", "NDR_SCALARS|NDR_BUFFERS");
 579         } elsif (my $switch = util::has_property($e, "switch_is")) {
 580                 if ($e->{POINTERS}) {
 581                         ParseElementPushSwitch($e, $var_prefix, "NDR_BUFFERS|NDR_SCALARS", $switch);
 582                 } else {
 583                         ParseElementPushSwitch($e, $var_prefix, "NDR_BUFFERS", $switch);
 584                 }
 585         } elsif (defined $sub_size) {
 586                 if ($e->{POINTERS}) {
 587                         if (util::is_builtin_type($e->{TYPE})) {
 588                                 pidl "\tNDR_CHECK(ndr_push_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_push_fn_t) ndr_push_$e->{TYPE}));\n";
 589                         } else {
 590                                 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";
 591                         }
 592                 }
 593         } elsif (util::is_builtin_type($e->{TYPE})) {
 594                 pidl "\t\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
 595         } elsif ($e->{POINTERS}) {
 596                 pidl "\t\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, NDR_SCALARS|NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}));\n";
 597         } else {
 598                 pidl "\t\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
 599         }
 600
 601         if (util::need_wire_pointer($e)) {
 602                 pidl "\t}\n";
 603         }
 604
 605         end_flags($e);
 606 }
 607
 608 #####################################################################
 609 # print buffers in a structure element
 610 sub ParseElementPrintBuffer($$)
 611 {
 612         my($e) = shift;
 613         my($var_prefix) = shift;
 614         my $cprefix = util::c_push_prefix($e);
 615
 616         if (util::need_wire_pointer($e)) {
 617                 pidl "\tif ($var_prefix$e->{NAME}) {\n";
 618         }
 619
 620         if (util::array_size($e)) {
 621                 ParseArrayPrint($e, $var_prefix);
 622         } elsif (my $switch = util::has_property($e, "switch_is")) {
 623                 ParseElementPrintSwitch($e, $var_prefix, $switch);
 624         } else {
 625                 pidl "\t\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME});\n";
 626         }
 627
 628         if (util::need_wire_pointer($e)) {
 629                 pidl "\t}\n";
 630         }
 631 }
 632
 633
 634 #####################################################################
 635 # parse buffers in a structure element - pull side
 636 sub ParseElementPullBuffer($$$)
 637 {
 638         my($e) = shift;
 639         my($var_prefix) = shift;
 640         my($ndr_flags) = shift;
 641         my $cprefix = util::c_pull_prefix($e);
 642         my $sub_size = util::has_property($e, "subcontext");
 643
 644         if (util::is_pure_scalar($e)) {
 645                 return;
 646         }
 647
 648         if (util::has_property($e, "relative")) {
 649                 return;
 650         }
 651
 652         start_flags($e);
 653
 654         if (util::need_wire_pointer($e)) {
 655                 pidl "\tif ($var_prefix$e->{NAME}) {\n";
 656         }
 657
 658         if (util::is_inline_array($e)) {
 659                 ParseArrayPull($e, "r->", "NDR_BUFFERS");
 660         } elsif (util::array_size($e)) {
 661                 ParseArrayPull($e, "r->", "NDR_SCALARS|NDR_BUFFERS");
 662         } elsif (my $switch = util::has_property($e, "switch_is")) {
 663                 if ($e->{POINTERS}) {
 664                         ParseElementPullSwitch($e, $var_prefix, "NDR_SCALARS|NDR_BUFFERS", $switch);
 665                 } else {
 666                         ParseElementPullSwitch($e, $var_prefix, "NDR_BUFFERS", $switch);
 667                 }
 668         } elsif (defined $sub_size) {
 669                 if ($e->{POINTERS}) {
 670                         if (util::is_builtin_type($e->{TYPE})) {
 671                                 pidl "\tNDR_CHECK(ndr_pull_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_fn_t) ndr_pull_$e->{TYPE}));\n";
 672                         } else {
 673                                 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";
 674                         }
 675                 }
 676         } elsif (util::is_builtin_type($e->{TYPE})) {
 677                 pidl "\t\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $cprefix$var_prefix$e->{NAME}));\n";
 678         } elsif ($e->{POINTERS}) {
 679                 pidl "\t\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, NDR_SCALARS|NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}));\n";
 680         } else {
 681                 pidl "\t\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
 682         }
 683
 684         if (util::need_wire_pointer($e)) {
 685                 pidl "\t}\n";
 686         }
 687
 688         end_flags($e);
 689 }
 690
 691 #####################################################################
 692 # parse a struct
 693 sub ParseStructPush($)
 694 {
 695         my($struct) = shift;
 696         my $conform_e;
 697
 698         if (! defined $struct->{ELEMENTS}) {
 699                 return;
 700         }
 701
 702         start_flags($struct);
 703
 704         # see if the structure contains a conformant array. If it
 705         # does, then it must be the last element of the structure, and
 706         # we need to push the conformant length early, as it fits on
 707         # the wire before the structure (and even before the structure
 708         # alignment)
 709         my $e = $struct->{ELEMENTS}[-1];
 710         if (defined $e->{ARRAY_LEN} && $e->{ARRAY_LEN} eq "*") {
 711                 my $size = find_size_var($e, util::array_size($e), "r->");
 712                 $e->{CONFORMANT_SIZE} = $size;
 713                 $conform_e = $e;
 714                 pidl "\tNDR_CHECK(ndr_push_uint32(ndr, $size));\n";
 715         }
 716
 717         pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
 718
 719         pidl "\tNDR_CHECK(ndr_push_struct_start(ndr));\n";
 720
 721         my $align = struct_alignment($struct);
 722         pidl "\tNDR_CHECK(ndr_push_align(ndr, $align));\n";
 723
 724         foreach my $e (@{$struct->{ELEMENTS}}) {
 725                 ParseElementPushScalar($e, "r->", "NDR_SCALARS");
 726         }
 727
 728         pidl "buffers:\n";
 729         pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
 730         foreach my $e (@{$struct->{ELEMENTS}}) {
 731                 ParseElementPushBuffer($e, "r->", "NDR_BUFFERS");
 732         }
 733
 734         pidl "\tndr_push_struct_end(ndr);\n";
 735
 736         pidl "done:\n";
 737
 738         end_flags($struct);
 739 }
 740
 741 #####################################################################
 742 # generate a struct print function
 743 sub ParseStructPrint($)
 744 {
 745         my($struct) = shift;
 746
 747         if (! defined $struct->{ELEMENTS}) {
 748                 return;
 749         }
 750
 751         start_flags($struct);
 752
 753         pidl "\tndr->depth++;\n";
 754         foreach my $e (@{$struct->{ELEMENTS}}) {
 755                 ParseElementPrintScalar($e, "r->");
 756         }
 757         pidl "\tndr->depth--;\n";
 758
 759         end_flags($struct);
 760 }
 761
 762 #####################################################################
 763 # parse a struct - pull side
 764 sub ParseStructPull($)
 765 {
 766         my($struct) = shift;
 767         my $conform_e;
 768
 769         if (! defined $struct->{ELEMENTS}) {
 770                 return;
 771         }
 772
 773         start_flags($struct);
 774
 775         # see if the structure contains a conformant array. If it
 776         # does, then it must be the last element of the structure, and
 777         # we need to pull the conformant length early, as it fits on
 778         # the wire before the structure (and even before the structure
 779         # alignment)
 780         my $e = $struct->{ELEMENTS}[-1];
 781         if (defined $e->{ARRAY_LEN} && $e->{ARRAY_LEN} eq "*") {
 782                 $conform_e = $e;
 783                 pidl "\tuint32 _conformant_size;\n";
 784                 $conform_e->{CONFORMANT_SIZE} = "_conformant_size";
 785         }
 786
 787         # declare any internal pointers we need
 788         foreach my $e (@{$struct->{ELEMENTS}}) {
 789                 if (util::need_wire_pointer($e) &&
 790                     !util::has_property($e, "relative")) {
 791                         pidl "\tuint32 _ptr_$e->{NAME};\n";
 792                 }
 793         }
 794
 795         pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
 796
 797         pidl "\tNDR_CHECK(ndr_pull_struct_start(ndr));\n";
 798
 799         if (defined $conform_e) {
 800                 pidl "\tNDR_CHECK(ndr_pull_uint32(ndr, &$conform_e->{CONFORMANT_SIZE}));\n";
 801         }
 802
 803         my $align = struct_alignment($struct);
 804         pidl "\tNDR_CHECK(ndr_pull_align(ndr, $align));\n";
 805
 806         foreach my $e (@{$struct->{ELEMENTS}}) {
 807                 ParseElementPullScalar($e, "r->", "NDR_SCALARS");
 808         }
 809
 810         pidl "buffers:\n";
 811         pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
 812         foreach my $e (@{$struct->{ELEMENTS}}) {
 813                 ParseElementPullBuffer($e, "r->", "NDR_BUFFERS");
 814         }
 815
 816         pidl "\tndr_pull_struct_end(ndr);\n";
 817
 818         pidl "done:\n";
 819
 820         end_flags($struct);
 821 }
 822
 823
 824 #####################################################################
 825 # parse a union - push side
 826 sub ParseUnionPush($)
 827 {
 828         my $e = shift;
 829         my $have_default = 0;
 830
 831         start_flags($e);
 832
 833         pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
 834
 835         pidl "\tNDR_CHECK(ndr_push_struct_start(ndr));\n";
 836
 837 #       my $align = union_alignment($e);
 838 #       pidl "\tNDR_CHECK(ndr_push_align(ndr, $align));\n";
 839
 840         pidl "\tswitch (level) {\n";
 841         foreach my $el (@{$e->{DATA}}) {
 842                 if ($el->{CASE} eq "default") {
 843                         pidl "\tdefault:\n";
 844                         $have_default = 1;
 845                 } else {
 846                         pidl "\tcase $el->{CASE}:\n";
 847                 }
 848                 if ($el->{TYPE} eq "UNION_ELEMENT") {
 849                         ParseElementPushScalar($el->{DATA}, "r->", "NDR_SCALARS");
 850                 }
 851                 pidl "\tbreak;\n\n";
 852         }
 853         if (! $have_default) {
 854                 pidl "\tdefault:\n";
 855                 pidl "\t\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
 856         }
 857         pidl "\t}\n";
 858         pidl "buffers:\n";
 859         pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
 860         pidl "\tswitch (level) {\n";
 861         foreach my $el (@{$e->{DATA}}) {
 862                 if ($el->{CASE} eq "default") {
 863                         pidl "\tdefault:\n";
 864                 } else {
 865                         pidl "\tcase $el->{CASE}:\n";
 866                 }
 867                 if ($el->{TYPE} eq "UNION_ELEMENT") {
 868                         ParseElementPushBuffer($el->{DATA}, "r->", "NDR_BUFFERS");
 869                 }
 870                 pidl "\tbreak;\n\n";
 871         }
 872         if (! $have_default) {
 873                 pidl "\tdefault:\n";
 874                 pidl "\t\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
 875         }
 876         pidl "\t}\n";
 877         pidl "\tndr_push_struct_end(ndr);\n";
 878         pidl "done:\n";
 879         end_flags($e);
 880 }
 881
 882 #####################################################################
 883 # print a union
 884 sub ParseUnionPrint($)
 885 {
 886         my $e = shift;
 887         my $have_default = 0;
 888
 889         start_flags($e);
 890
 891         pidl "\tswitch (level) {\n";
 892         foreach my $el (@{$e->{DATA}}) {
 893                 if ($el->{CASE} eq "default") {
 894                         $have_default = 1;
 895                         pidl "\tdefault:\n";
 896                 } else {
 897                         pidl "\tcase $el->{CASE}:\n";
 898                 }
 899                 if ($el->{TYPE} eq "UNION_ELEMENT") {
 900                         ParseElementPrintScalar($el->{DATA}, "r->");
 901                 }
 902                 pidl "\tbreak;\n\n";
 903         }
 904         if (! $have_default) {
 905                 pidl "\tdefault:\n\t\tndr_print_bad_level(ndr, name, level);\n";
 906         }
 907         pidl "\t}\n";
 908
 909         end_flags($e);
 910 }
 911
 912 #####################################################################
 913 # parse a union - pull side
 914 sub ParseUnionPull($)
 915 {
 916         my $e = shift;
 917         my $have_default = 0;
 918
 919         start_flags($e);
 920
 921         pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
 922
 923         pidl "\tNDR_CHECK(ndr_pull_struct_start(ndr));\n";
 924
 925 #       my $align = union_alignment($e);
 926 #       pidl "\tNDR_CHECK(ndr_pull_align(ndr, $align));\n";
 927
 928         pidl "\tswitch (level) {\n";
 929         foreach my $el (@{$e->{DATA}}) {
 930                 if ($el->{CASE} eq "default") {
 931                         pidl "\tdefault: {\n";
 932                         $have_default = 1;
 933                 } else {
 934                         pidl "\tcase $el->{CASE}: {\n";
 935                 }
 936                 if ($el->{TYPE} eq "UNION_ELEMENT") {
 937                         my $e2 = $el->{DATA};
 938                         if ($e2->{POINTERS}) {
 939                                 pidl "\t\tuint32 _ptr_$e2->{NAME};\n";
 940                         }
 941                         ParseElementPullScalar($el->{DATA}, "r->", "NDR_SCALARS");
 942                 }
 943                 pidl "\tbreak; }\n\n";
 944         }
 945         if (! $have_default) {
 946                 pidl "\tdefault:\n";
 947                 pidl "\t\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
 948         }
 949         pidl "\t}\n";
 950         pidl "buffers:\n";
 951         pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
 952         pidl "\tswitch (level) {\n";
 953         foreach my $el (@{$e->{DATA}}) {
 954                 if ($el->{CASE} eq "default") {
 955                         pidl "\tdefault:\n";
 956                 } else {
 957                         pidl "\tcase $el->{CASE}:\n";
 958                 }
 959                 if ($el->{TYPE} eq "UNION_ELEMENT") {
 960                         ParseElementPullBuffer($el->{DATA}, "r->", "NDR_BUFFERS");
 961                 }
 962                 pidl "\tbreak;\n\n";
 963         }
 964         if (! $have_default) {
 965                 pidl "\tdefault:\n";
 966                 pidl "\t\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
 967         }
 968         pidl "\t}\n";
 969         pidl "\tndr_pull_struct_end(ndr);\n";
 970         pidl "done:\n";
 971         end_flags($e);
 972 }
 973
 974 #####################################################################
 975 # parse a type
 976 sub ParseTypePush($)
 977 {
 978         my($data) = shift;
 979
 980         if (ref($data) eq "HASH") {
 981                 ($data->{TYPE} eq "STRUCT") &&
 982                     ParseStructPush($data);
 983                 ($data->{TYPE} eq "UNION") &&
 984                     ParseUnionPush($data);
 985         }
 986 }
 987
 988 #####################################################################
 989 # generate a print function for a type
 990 sub ParseTypePrint($)
 991 {
 992         my($data) = shift;
 993
 994         if (ref($data) eq "HASH") {
 995                 ($data->{TYPE} eq "STRUCT") &&
 996                     ParseStructPrint($data);
 997                 ($data->{TYPE} eq "UNION") &&
 998                     ParseUnionPrint($data);
 999         }
1000 }
1001
1002 #####################################################################
1003 # parse a type
1004 sub ParseTypePull($)
1005 {
1006         my($data) = shift;
1007
1008         if (ref($data) eq "HASH") {
1009                 ($data->{TYPE} eq "STRUCT") &&
1010                     ParseStructPull($data);
1011                 ($data->{TYPE} eq "UNION") &&
1012                     ParseUnionPull($data);
1013         }
1014 }
1015
1016 #####################################################################
1017 # parse a typedef - push side
1018 sub ParseTypedefPush($)
1019 {
1020         my($e) = shift;
1021         my $static = fn_prefix($e);
1022
1023         if (! $needed{"push_$e->{NAME}"}) {
1024 #               print "push_$e->{NAME} not needed\n";
1025                 return;
1026         }
1027
1028         if ($e->{DATA}->{TYPE} eq "STRUCT") {
1029                 pidl $static . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, struct $e->{NAME} *r)";
1030                 pidl "\n{\n";
1031                 ParseTypePush($e->{DATA});
1032                 pidl "\treturn NT_STATUS_OK;\n";
1033                 pidl "}\n\n";
1034         }
1035
1036         if ($e->{DATA}->{TYPE} eq "UNION") {
1037                 pidl $static . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, uint16 level, union $e->{NAME} *r)";
1038                 pidl "\n{\n";
1039                 ParseTypePush($e->{DATA});
1040                 pidl "\treturn NT_STATUS_OK;\n";
1041                 pidl "}\n\n";
1042         }
1043 }
1044
1045
1046 #####################################################################
1047 # parse a typedef - pull side
1048 sub ParseTypedefPull($)
1049 {
1050         my($e) = shift;
1051         my $static = fn_prefix($e);
1052
1053         if (! $needed{"pull_$e->{NAME}"}) {
1054 #               print "pull_$e->{NAME} not needed\n";
1055                 return;
1056         }
1057
1058         if ($e->{DATA}->{TYPE} eq "STRUCT") {
1059                 pidl $static . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, struct $e->{NAME} *r)";
1060                 pidl "\n{\n";
1061                 ParseTypePull($e->{DATA});
1062                 pidl "\treturn NT_STATUS_OK;\n";
1063                 pidl "}\n\n";
1064         }
1065
1066         if ($e->{DATA}->{TYPE} eq "UNION") {
1067                 pidl $static . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, uint16 level, union $e->{NAME} *r)";
1068                 pidl "\n{\n";
1069                 ParseTypePull($e->{DATA});
1070                 pidl "\treturn NT_STATUS_OK;\n";
1071                 pidl "}\n\n";
1072         }
1073 }
1074
1075
1076 #####################################################################
1077 # parse a typedef - print side
1078 sub ParseTypedefPrint($)
1079 {
1080         my($e) = shift;
1081
1082         if ($e->{DATA}->{TYPE} eq "STRUCT") {
1083                 pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, struct $e->{NAME} *r)";
1084                 pidl "\n{\n";
1085                 pidl "\tndr_print_struct(ndr, name, \"$e->{NAME}\");\n";
1086                 ParseTypePrint($e->{DATA});
1087                 pidl "}\n\n";
1088         }
1089
1090         if ($e->{DATA}->{TYPE} eq "UNION") {
1091                 pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, uint16 level, union $e->{NAME} *r)";
1092                 pidl "\n{\n";
1093                 pidl "\tndr_print_union(ndr, name, level, \"$e->{NAME}\");\n";
1094                 ParseTypePrint($e->{DATA});
1095                 pidl "}\n\n";
1096         }
1097 }
1098
1099 #####################################################################
1100 # parse a function - print side
1101 sub ParseFunctionPrint($)
1102 {
1103         my($fn) = shift;
1104
1105         pidl "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, struct $fn->{NAME} *r)";
1106         pidl "\n{\n";
1107         pidl "\tndr_print_struct(ndr, name, \"$fn->{NAME}\");\n";
1108         pidl "\tndr->depth++;\n";
1109
1110         pidl "\tif (flags & NDR_SET_VALUES) {\n";
1111         pidl "\t\tndr->flags |= LIBNDR_PRINT_SET_VALUES;\n";
1112         pidl "}\n";
1113
1114         pidl "\tif (flags & NDR_IN) {\n";
1115         pidl "\t\tndr_print_struct(ndr, \"in\", \"$fn->{NAME}\");\n";
1116         pidl "\tndr->depth++;\n";
1117         foreach my $e (@{$fn->{DATA}}) {
1118                 if (util::has_property($e, "in")) {
1119                         ParseElementPrintScalar($e, "r->in.");
1120                 }
1121         }
1122         pidl "\tndr->depth--;\n";
1123         pidl "\t}\n";
1124
1125         pidl "\tif (flags & NDR_OUT) {\n";
1126         pidl "\t\tndr_print_struct(ndr, \"out\", \"$fn->{NAME}\");\n";
1127         pidl "\tndr->depth++;\n";
1128         foreach my $e (@{$fn->{DATA}}) {
1129                 if (util::has_property($e, "out")) {
1130                         ParseElementPrintScalar($e, "r->out.");
1131                 }
1132         }
1133         if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1134                 if (util::is_scalar_type($fn->{RETURN_TYPE})) {
1135                         pidl "\tndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", r->out.result);\n";
1136                 } else {
1137                         pidl "\tndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", &r->out.result);\n";
1138                 }
1139         }
1140         pidl "\tndr->depth--;\n";
1141         pidl "\t}\n";
1142
1143         pidl "\tndr->depth--;\n";
1144         pidl "}\n\n";
1145 }
1146
1147
1148 #####################################################################
1149 # parse a function element
1150 sub ParseFunctionElementPush($$)
1151 {
1152         my $e = shift;
1153         my $inout = shift;
1154
1155         if (util::array_size($e)) {
1156                 if (util::need_wire_pointer($e)) {
1157                         pidl "\tNDR_CHECK(ndr_push_ptr(ndr, r->$inout.$e->{NAME}));\n";
1158                 }
1159                 pidl "\tif (r->$inout.$e->{NAME}) {\n";
1160                 ParseArrayPush($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1161                 pidl "\t}\n";
1162         } else {
1163                 ParseElementPushScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1164                 if ($e->{POINTERS}) {
1165                         ParseElementPushBuffer($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1166                 }
1167         }
1168 }
1169
1170 #####################################################################
1171 # parse a function
1172 sub ParseFunctionPush($)
1173 {
1174         my($fn) = shift;
1175         my $static = fn_prefix($fn);
1176
1177         pidl $static . "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, struct $fn->{NAME} *r)\n{\n";
1178
1179         pidl "\n\tif (!(flags & NDR_IN)) goto ndr_out;\n\n";
1180         foreach my $e (@{$fn->{DATA}}) {
1181                 if (util::has_property($e, "in")) {
1182                         ParseFunctionElementPush($e, "in");
1183                 }
1184         }
1185
1186         pidl "\nndr_out:\n";
1187         pidl "\tif (!(flags & NDR_OUT)) goto done;\n\n";
1188         foreach my $e (@{$fn->{DATA}}) {
1189                 if (util::has_property($e, "out")) {
1190                         ParseFunctionElementPush($e, "out");
1191                 }
1192         }
1193
1194         if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1195                 pidl "\tNDR_CHECK(ndr_push_$fn->{RETURN_TYPE}(ndr, r->out.result));\n";
1196         }
1197
1198         pidl "\ndone:\n";
1199         pidl "\n\treturn NT_STATUS_OK;\n}\n\n";
1200 }
1201
1202 #####################################################################
1203 # parse a function element
1204 sub ParseFunctionElementPull($$)
1205 {
1206         my $e = shift;
1207         my $inout = shift;
1208
1209         if (util::array_size($e)) {
1210                 if (util::need_wire_pointer($e)) {
1211                         pidl "\tNDR_CHECK(ndr_pull_uint32(ndr, &_ptr_$e->{NAME}));\n";
1212                         pidl "\tif (_ptr_$e->{NAME}) {\n";
1213                 } elsif ($inout eq "out" && util::has_property($e, "ref")) {
1214                         pidl "\tif (r->$inout.$e->{NAME}) {\n";
1215                 } else {
1216                         pidl "\t{\n";
1217                 }
1218                 ParseArrayPull($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1219                 pidl "\t}\n";
1220         } else {
1221                 if ($inout eq "out" && util::has_property($e, "ref")) {
1222                         pidl "\tif (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {\n";
1223                         pidl "\tNDR_ALLOC(ndr, r->out.$e->{NAME});\n";
1224                         pidl "\t}\n";
1225                 }
1226                 if ($inout eq "in" && util::has_property($e, "ref")) {
1227                         pidl "\tNDR_ALLOC(ndr, r->in.$e->{NAME});\n";
1228                 }
1229
1230                 ParseElementPullScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1231                 if ($e->{POINTERS}) {
1232                         ParseElementPullBuffer($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1233                 }
1234         }
1235 }
1236
1237 #####################################################################
1238 # parse a function
1239 sub ParseFunctionPull($)
1240 {
1241         my($fn) = shift;
1242         my $static = fn_prefix($fn);
1243
1244         # pull function args
1245         pidl $static . "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)\n{\n";
1246
1247         # declare any internal pointers we need
1248         foreach my $e (@{$fn->{DATA}}) {
1249                 if (util::need_wire_pointer($e)) {
1250                         pidl "\tuint32 _ptr_$e->{NAME};\n";
1251                 }
1252         }
1253
1254         pidl "\n\tif (!(flags & NDR_IN)) goto ndr_out;\n\n";
1255         foreach my $e (@{$fn->{DATA}}) {
1256                 if (util::has_property($e, "in")) {
1257                         ParseFunctionElementPull($e, "in");
1258                 }
1259                 # we need to allocate any reference output variables, so that
1260                 # a dcerpc backend can be sure they are non-null
1261                 if (util::has_property($e, "out") && util::has_property($e, "ref")) {
1262                         pidl "\tNDR_ALLOC(ndr, r->out.$e->{NAME});\n";
1263                 }
1264         }
1265
1266         pidl "\nndr_out:\n";
1267         pidl "\tif (!(flags & NDR_OUT)) goto done;\n\n";
1268         foreach my $e (@{$fn->{DATA}}) {
1269                 if (util::has_property($e, "out")) {
1270                         ParseFunctionElementPull($e, "out");
1271                 }
1272         }
1273
1274         if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1275                 pidl "\tNDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, &r->out.result));\n";
1276         }
1277
1278         pidl "\ndone:\n";
1279         pidl "\n\treturn NT_STATUS_OK;\n}\n\n";
1280 }
1281
1282 #####################################################################
1283 # produce a function call table
1284 sub FunctionTable($)
1285 {
1286         my($interface) = shift;
1287         my($data) = $interface->{DATA};
1288         my $count = 0;
1289         my $uname = uc $interface->{NAME};
1290
1291         foreach my $d (@{$data}) {
1292                 if ($d->{TYPE} eq "FUNCTION") { $count++; }
1293         }
1294
1295         if ($count == 0) {
1296                 return;
1297         }
1298
1299         pidl "static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {\n";
1300         foreach my $d (@{$data}) {
1301                 if ($d->{TYPE} eq "FUNCTION") {
1302                         pidl "\t{\n";
1303                         pidl "\t\t\"$d->{NAME}\",\n";
1304                         pidl "\t\tsizeof(struct $d->{NAME}),\n";
1305                         pidl "\t\t(ndr_push_flags_fn_t) ndr_push_$d->{NAME},\n";
1306                         pidl "\t\t(ndr_pull_flags_fn_t) ndr_pull_$d->{NAME},\n";
1307                         pidl "\t\t(ndr_print_function_t) ndr_print_$d->{NAME}\n";
1308                         pidl "\t},\n";
1309                 }
1310         }
1311         pidl "\t{ NULL, 0, NULL, NULL }\n};\n\n";
1312
1313         my $endpoints;
1314
1315         if (! defined $if_endpoints) {
1316                 $if_endpoints = $interface->{NAME};
1317         }
1318
1319         my @e = split / /, $if_endpoints;
1320         my $endpoint_count = $#e + 1;
1321
1322         pidl "static const char *$interface->{NAME}\_endpoint_strings[] = {\n\t";
1323         for (my $i=0; $i < $#e; $i++) {
1324                 pidl "\"$e[$i]\", ";
1325         }
1326         pidl "\"$e[$#e]\"\n";
1327         pidl "};\n\n";
1328
1329         pidl "static const struct dcerpc_endpoint_list $interface->{NAME}\_endpoints = {\n";
1330         pidl "\t$endpoint_count, $interface->{NAME}\_endpoint_strings\n";
1331         pidl "};\n\n";
1332
1333         pidl "\nconst struct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {\n";
1334         pidl "\t\"$interface->{NAME}\",\n";
1335         pidl "\tDCERPC_$uname\_UUID,\n";
1336         pidl "\tDCERPC_$uname\_VERSION,\n";
1337         pidl "\t$count,\n";
1338         pidl "\t$interface->{NAME}\_calls,\n";
1339         pidl "\t&$interface->{NAME}\_endpoints\n";
1340         pidl "};\n\n";
1341 }
1342
1343
1344 #####################################################################
1345 # parse the interface definitions
1346 sub ParseInterface($)
1347 {
1348         my($interface) = shift;
1349         my($data) = $interface->{DATA};
1350
1351         foreach my $d (@{$data}) {
1352                 if ($d->{TYPE} eq "TYPEDEF") {
1353                     $structs{$d->{NAME}} = $d;
1354             }
1355         }
1356
1357
1358
1359         foreach my $d (@{$data}) {
1360                 ($d->{TYPE} eq "TYPEDEF") &&
1361                     ParseTypedefPush($d);
1362                 ($d->{TYPE} eq "FUNCTION") &&
1363                     ParseFunctionPush($d);
1364         }
1365         foreach my $d (@{$data}) {
1366                 ($d->{TYPE} eq "TYPEDEF") &&
1367                     ParseTypedefPull($d);
1368                 ($d->{TYPE} eq "FUNCTION") &&
1369                     ParseFunctionPull($d);
1370         }
1371         foreach my $d (@{$data}) {
1372                 if ($d->{TYPE} eq "TYPEDEF" &&
1373                     !util::has_property($d->{DATA}, "noprint")) {
1374                         ParseTypedefPrint($d);
1375                 }
1376                 if ($d->{TYPE} eq "FUNCTION" &&
1377                     !util::has_property($d, "noprint")) {
1378                         ParseFunctionPrint($d);
1379                 }
1380         }
1381
1382         FunctionTable($interface);
1383
1384 }
1385
1386 sub NeededFunction($)
1387 {
1388         my $fn = shift;
1389         $needed{"pull_$fn->{NAME}"} = 1;
1390         $needed{"push_$fn->{NAME}"} = 1;
1391         foreach my $e (@{$fn->{DATA}}) {
1392                 $e->{PARENT} = $fn;
1393                 $needed{"pull_$e->{TYPE}"} = 1;
1394                 $needed{"push_$e->{TYPE}"} = 1;
1395         }
1396 }
1397
1398 sub NeededTypedef($)
1399 {
1400         my $t = shift;
1401         if (util::has_property($t->{DATA}, "public")) {
1402                 $needed{"pull_$t->{NAME}"} = 1;
1403                 $needed{"push_$t->{NAME}"} = 1;
1404         }
1405         if ($t->{DATA}->{TYPE} eq "STRUCT") {
1406                 for my $e (@{$t->{DATA}->{ELEMENTS}}) {
1407                         $e->{PARENT} = $t->{DATA};
1408                         if ($needed{"pull_$t->{NAME}"}) {
1409                                 $needed{"pull_$e->{TYPE}"} = 1;
1410                         }
1411                         if ($needed{"push_$t->{NAME}"}) {
1412                                 $needed{"push_$e->{TYPE}"} = 1;
1413                         }
1414                 }
1415         }
1416         if ($t->{DATA}->{TYPE} eq "UNION") {
1417                 for my $e (@{$t->{DATA}->{DATA}}) {
1418                         $e->{PARENT} = $t->{DATA};
1419                         if ($e->{TYPE} eq "UNION_ELEMENT") {
1420                                 if ($needed{"pull_$t->{NAME}"}) {
1421                                         $needed{"pull_$e->{DATA}->{TYPE}"} = 1;
1422                                 }
1423                                 if ($needed{"push_$t->{NAME}"}) {
1424                                         $needed{"push_$e->{DATA}->{TYPE}"} = 1;
1425                                 }
1426                         }
1427                 }
1428         }
1429 }
1430
1431 #####################################################################
1432 # work out what parse functions are needed
1433 sub BuildNeeded($)
1434 {
1435         my($interface) = shift;
1436         my($data) = $interface->{DATA};
1437         foreach my $d (@{$data}) {
1438                 ($d->{TYPE} eq "FUNCTION") &&
1439                     NeededFunction($d);
1440         }
1441         foreach my $d (reverse @{$data}) {
1442                 ($d->{TYPE} eq "TYPEDEF") &&
1443                     NeededTypedef($d);
1444         }
1445 }
1446
1447 #####################################################################
1448 # parse the interface definitions
1449 sub ModuleHeader($)
1450 {
1451     my($h) = shift;
1452
1453     $if_uuid = $h->{PROPERTIES}->{uuid};
1454     $if_version = $h->{PROPERTIES}->{version};
1455     $if_endpoints = $h->{PROPERTIES}->{endpoints};
1456 }
1457
1458 #####################################################################
1459 # parse a parsed IDL structure back into an IDL file
1460 sub Parse($$)
1461 {
1462         my($idl) = shift;
1463         my($filename) = shift;
1464
1465         open(OUT, ">$filename") || die "can't open $filename";
1466
1467         pidl "/* parser auto-generated by pidl */\n\n";
1468         pidl "#include \"includes.h\"\n\n";
1469         foreach my $x (@{$idl}) {
1470                 ($x->{TYPE} eq "MODULEHEADER") &&
1471                     ModuleHeader($x);
1472
1473                 if ($x->{TYPE} eq "INTERFACE") {
1474                         BuildNeeded($x);
1475                         ParseInterface($x);
1476                 }
1477         }
1478
1479         pidl IdlClient::Parse($idl);
1480
1481         close(OUT);
1482 }
1483
1484 1;