source4/build/pidl/parser.pm

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