r4511: Remove a crapload of dead code.
authorTim Potter <tpot@samba.org>
Tue, 4 Jan 2005 05:21:24 +0000 (05:21 +0000)
committerGerald (Jerry) Carter <jerry@samba.org>
Wed, 10 Oct 2007 18:08:17 +0000 (13:08 -0500)
(This used to be commit 0f50ed8260ce37c21d8ad62b5a257f22ab4a5534)

source4/build/pidl/eparser.pm

index 173c1bb9365f6217ae1ad0d3d7a3c835328d222d..ea250cbb07a9ac74498590b3640d0ddb25a47f7e 100644 (file)
@@ -10,7 +10,6 @@ use strict;
 
 # the list of needed functions
 my %needed;
-my %structs;
 
 my $module;
 my $if_uuid;
@@ -22,95 +21,6 @@ sub pidl($)
        print OUT shift;
 }
 
-#####################################################################
-# parse a properties list
-sub ParseProperties($)
-{
-    my($props) = shift;
-    foreach my $d (@{$props}) {
-       if (ref($d) ne "HASH") {
-           pidl "[$d] ";
-       } else {
-           foreach my $k (keys %{$d}) {
-               pidl "[$k($d->{$k})] ";
-           }
-       }
-    }
-}
-
-###################################
-# find a sibling var in a structure
-sub find_sibling($$)
-{
-       my($e) = shift;
-       my($name) = shift;
-       my($fn) = $e->{PARENT};
-
-       if ($name =~ /\*(.*)/) {
-               $name = $1;
-       }
-
-       if ($fn->{TYPE} eq "FUNCTION") {
-               for my $e2 (@{$fn->{DATA}}) {
-                       if ($e2->{NAME} eq $name) {
-                               return $e2;
-                       }
-               }
-       }
-
-       for my $e2 (@{$fn->{ELEMENTS}}) {
-               if ($e2->{NAME} eq $name) {
-                       return $e2;
-               }
-       }
-       die "invalid sibling '$name'";
-}
-
-####################################################################
-# work out the name of a size_is() variable
-sub find_size_var($$$)
-{
-       my($e) = shift;
-       my($size) = shift;
-       my($var_prefix) = shift;
-
-       my($fn) = $e->{PARENT};
-
-       if (util::is_constant($size)) {
-               return $size;
-       }
-
-       if ($size =~ /ndr->|\(/) {
-               return $size;
-       }
-
-       my $prefix = "";
-
-       if ($size =~ /\*(.*)/) {
-               $size = $1;
-               $prefix = "*";
-       }
-
-       if ($fn->{TYPE} ne "FUNCTION") {
-               return $prefix . "r->$size";
-       }
-
-       my $e2 = find_sibling($e, $size);
-
-       if (util::has_property($e2, "in") && util::has_property($e2, "out")) {
-               return $prefix . "$var_prefix$size";
-       }
-       if (util::has_property($e2, "in")) {
-               return $prefix . "r->in.$size";
-       }
-       if (util::has_property($e2, "out")) {
-               return $prefix . "r->out.$size";
-       }
-
-       die "invalid variable in $size for element $e->{NAME} in $fn->{NAME}\n";
-}
-
-
 #####################################################################
 # work out is a parse function should be declared static or not
 sub fn_prefix($)
@@ -131,557 +41,6 @@ sub fn_prefix($)
 }
 
 
-###################################################################
-# setup any special flags for an element or structure
-sub start_flags($)
-{
-       my $e = shift;
-       my $flags = util::has_property($e, "flag");
-       if (defined $flags) {
-               pidl "\t{ guint32 _flags_save_$e->{TYPE} = ndr->flags;\n";
-               pidl "\tndr->flags |= $flags;\n";
-       }
-}
-
-###################################################################
-# end any special flags for an element or structure
-sub end_flags($)
-{
-       my $e = shift;
-       my $flags = util::has_property($e, "flag");
-       if (defined $flags) {
-               pidl "\tndr->flags = _flags_save_$e->{TYPE};\n\t}\n";
-       }
-}
-
-
-#####################################################################
-# work out the correct alignment for a structure
-sub struct_alignment
-{
-       my $s = shift;
-
-       my $align = 1;
-       for my $e (@{$s->{ELEMENTS}}) {
-               my $a = 1;
-
-               if (!util::need_wire_pointer($e)
-                   && defined $structs{$e->{TYPE}}) {
-                       if ($structs{$e->{TYPE}}->{DATA}->{TYPE} eq "STRUCT") {
-                               $a = struct_alignment($structs{$e->{TYPE}}->{DATA});
-                       } elsif ($structs{$e->{TYPE}}->{DATA}->{TYPE} eq "UNION") {
-                               if (defined $structs{$e->{TYPE}}->{DATA}) {
-                                       $a = union_alignment($structs{$e->{TYPE}}->{DATA});
-                               }
-                       }
-               } else {
-                       $a = util::type_align($e);
-               }
-
-               if ($align < $a) {
-                       $align = $a;
-               }
-       }
-
-       return $align;
-}
-
-#####################################################################
-# work out the correct alignment for a union
-sub union_alignment
-{
-       my $u = shift;
-
-       my $align = 1;
-
-       foreach my $e (@{$u->{DATA}}) {
-               my $a = 1;
-
-               if ($e->{TYPE} eq "EMPTY") {
-                       next;
-               }
-
-               if (!util::need_wire_pointer($e)
-                   && defined $structs{$e->{DATA}->{TYPE}}) {
-                       my $s = $structs{$e->{DATA}->{TYPE}};
-                       if ($s->{DATA}->{TYPE} eq "STRUCT") {
-                               $a = struct_alignment($s->{DATA});
-                       } elsif ($s->{DATA}->{TYPE} eq "UNION") {
-                               $a = union_alignment($s->{DATA});
-                       }
-               } else {
-                       $a = util::type_align($e->{DATA});
-               }
-
-               if ($align < $a) {
-                       $align = $a;
-               }
-       }
-
-       return $align;
-}
-
-#####################################################################
-# parse an array - pull side
-sub ParseArrayPull($$$)
-{
-       my $e = shift;
-       my $var_prefix = shift;
-       my $ndr_flags = shift;
-
-       my $size = find_size_var($e, util::array_size($e), $var_prefix);
-       my $alloc_size = $size;
-
-       # if this is a conformant array then we use that size to allocate, and make sure
-       # we allocate enough to pull the elements
-       if (defined $e->{CONFORMANT_SIZE}) {
-               $alloc_size = $e->{CONFORMANT_SIZE};
-
-               pidl "\tif ($size > $alloc_size) {\n";
-               pidl "\t\treturn; // ndr_pull_error(ndr, NDR_ERR_CONFORMANT_SIZE, \"Bad conformant size %u should be %u\", $alloc_size, $size);\n";
-               pidl "\t}\n";
-       } elsif (!util::is_inline_array($e)) {
-               if ($var_prefix =~ /^r->out/ && $size =~ /^\*r->in/) {
-                       my $size2 = substr($size, 1);
-                       pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { NDR_ALLOC(ndr, $size2); }\n";
-               }
-
-               # non fixed arrays encode the size just before the array
-               pidl "\t{\n";
-               pidl "\t\tuint32_t _array_size;\n";
-               pidl "\t\tndr_pull_uint32(ndr, tree, hf_array_size, &_array_size);\n";
-               if ($size =~ /r->in/) {
-                       pidl "\t\tif (!(ndr->flags & LIBNDR_FLAG_REF_ALLOC) && _array_size != $size) {\n";
-               } else {
-                       pidl "\t\tif ($size != _array_size) {\n";
-               }
-               pidl "\t\t\t//return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, \"Bad array size %u should be %u\", _array_size, $size);\n";
-               pidl "\t\t\treturn;\n";
-               pidl "\t\t}\n";
-               if ($size =~ /r->in/) {
-                       pidl "else { $size = _array_size; }\n";
-               }
-               pidl "\t}\n";
-       }
-
-       if ((util::need_alloc($e) && !util::is_fixed_array($e)) ||
-           ($var_prefix eq "r->in." && util::has_property($e, "ref"))) {
-               if (!util::is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") {
-                       pidl "\t\tNDR_ALLOC_N(ndr, $var_prefix$e->{NAME}, MAX(1, $alloc_size));\n";
-               }
-       }
-
-       if (($var_prefix eq "r->out." && util::has_property($e, "ref"))) {
-               if (!util::is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") {
-                       pidl "\tif (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {";
-                       pidl "\t\tNDR_ALLOC_N(ndr, $var_prefix$e->{NAME}, MAX(1, $alloc_size));\n";
-                       pidl "\t}\n";
-               }
-       }
-
-       pidl "\t{\n";
-
-       if (my $length = util::has_property($e, "length_is")) {
-               $length = find_size_var($e, $length, $var_prefix);
-               pidl "\t\tuint32_t _offset, _length;\n";
-               pidl "\t\tndr_pull_uint32(ndr, tree, hf_array_offset, &_offset);\n";
-               pidl "\t\tndr_pull_uint32(ndr, tree, hf_array_length, &_length);\n";
-               pidl "\t\tif (_offset != 0) return; // ndr_pull_error(ndr, NDR_ERR_OFFSET, \"Bad array offset 0x%08x\", _offset);\n";
-               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";
-               $size = "_length";
-       }
-
-       if (util::is_scalar_type($e->{TYPE})) {
-               pidl "\t\tndr_pull_array_$e->{TYPE}(ndr, $ndr_flags, tree, \"" . field2name($e->{NAME}) . "\", hf_$e->{NAME}_$e->{TYPE}, $var_prefix$e->{NAME}, $size);\n";
-       } else {
-               pidl "\t\tndr_pull_array(ndr, $ndr_flags, tree, \"" . field2name($e->{NAME}) . "\", (void **)$var_prefix$e->{NAME}, sizeof($var_prefix$e->{NAME}\[0]), $size, (ndr_pull_flags_fn_t)ndr_pull_$e->{TYPE});\n";
-       }
-
-       pidl "\t}\n";
-}
-
-
-#####################################################################
-# parse scalars in a structure element - pull size
-sub ParseElementPullSwitch($$$$)
-{
-       my($e) = shift;
-       my($var_prefix) = shift;
-       my($ndr_flags) = shift;
-       my $switch = shift;
-       my $switch_var = find_size_var($e, $switch, $var_prefix);
-
-       my $cprefix = util::c_pull_prefix($e);
-
-       my $utype = $structs{$e->{TYPE}};
-       if (!defined $utype ||
-           !util::has_property($utype->{DATA}, "nodiscriminant")) {
-               my $e2 = find_sibling($e, $switch);
-               pidl "\tif (($ndr_flags) & NDR_SCALARS) {\n";
-               pidl "\t\t $e2->{TYPE} _level;\n";
-               pidl "\t\tndr_pull_$e2->{TYPE}(ndr, tree, hf_level, &_level);\n";
-               if ($switch_var =~ /r->in/) {
-                       pidl "\t\tif (!(ndr->flags & LIBNDR_FLAG_REF_ALLOC) && _level != $switch_var) {\n";
-               } else {
-                       pidl "\t\tif (_level != $switch_var) {\n";
-               }
-               pidl "\t\t\treturn; // ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u in $e->{NAME}\", _level);\n";
-               pidl "\t\t}\n";
-               if ($switch_var =~ /r->/) {
-                       pidl "else { $switch_var = _level; }\n";
-               }
-               pidl "\t}\n";
-       }
-
-       my $sub_size = util::has_property($e, "subcontext");
-       if (defined $sub_size) {
-               pidl "\tndr_pull_subcontext_union_fn(ndr, $sub_size, $switch_var, $cprefix$var_prefix$e->{NAME}, (ndr_pull_union_fn_t) ndr_pull_$e->{TYPE});\n";
-       } else {
-               pidl "\tndr_pull_$e->{TYPE}(ndr, $ndr_flags, tree, $switch_var, $cprefix$var_prefix$e->{NAME});\n";
-       }
-
-
-}
-
-#####################################################################
-# parse scalars in a structure element - pull size
-sub ParseElementPullScalar($$$)
-{
-       my($e) = shift;
-       my($var_prefix) = shift;
-       my($ndr_flags) = shift;
-       my $cprefix = util::c_pull_prefix($e);
-       my $sub_size = util::has_property($e, "subcontext");
-
-       start_flags($e);
-
-       if (util::has_property($e, "relative")) {
-               pidl "\tndr_pull_relative(ndr, tree, (const void **)&$var_prefix$e->{NAME}, sizeof(*$var_prefix$e->{NAME}), (ndr_pull_flags_fn_t)ndr_pull_$e->{TYPE});\n";
-       } elsif (util::is_inline_array($e)) {
-               ParseArrayPull($e, "r->", "NDR_SCALARS");
-       } elsif (util::need_wire_pointer($e)) {
-               pidl "\tndr_pull_ptr(ndr, tree, hf_ptr, &_ptr_$e->{NAME});\n";
-               pidl "\tif (_ptr_$e->{NAME}) {\n";
-               pidl "\t\tNDR_ALLOC(ndr, $var_prefix$e->{NAME});\n";
-               pidl "\t} else {\n";
-               pidl "\t\t$var_prefix$e->{NAME} = NULL;\n";
-               pidl "\t}\n";
-       } elsif (util::need_alloc($e)) {
-               # no scalar component
-       } elsif (my $switch = util::has_property($e, "switch_is")) {
-               ParseElementPullSwitch($e, $var_prefix, $ndr_flags, $switch);
-       } elsif (defined $sub_size) {
-               if (util::is_builtin_type($e->{TYPE})) {
-                       pidl "\tndr_pull_subcontext_fn(ndr, tree, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_fn_t) ndr_pull_$e->{TYPE});\n";
-               } else {
-                       pidl "\tndr_pull_subcontext_flags_fn(ndr, tree, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_flags_fn_t) ndr_pull_$e->{TYPE});\n";
-               }
-       } elsif (util::is_builtin_type($e->{TYPE})) {
-               pidl "\tndr_pull_$e->{TYPE}(ndr, tree, hf_$e->{NAME}_$e->{TYPE}, $cprefix$var_prefix$e->{NAME});\n";
-       } else {
-               pidl "\tndr_pull_$e->{TYPE}(ndr, $ndr_flags, get_subtree(tree, \"" . field2name($e->{NAME}) . "\", ndr, ett_$e->{TYPE}), $cprefix$var_prefix$e->{NAME});\n";
-       }
-
-       end_flags($e);
-}
-
-#####################################################################
-# parse buffers in a structure element - pull side
-sub ParseElementPullBuffer($$$)
-{
-       my($e) = shift;
-       my($var_prefix) = shift;
-       my($ndr_flags) = shift;
-       my $cprefix = util::c_pull_prefix($e);
-       my $sub_size = util::has_property($e, "subcontext");
-
-       if (util::is_pure_scalar($e)) {
-               return;
-       }
-
-       if (util::has_property($e, "relative")) {
-               return;
-       }
-
-       start_flags($e);
-
-       if (util::need_wire_pointer($e)) {
-               pidl "\tif ($var_prefix$e->{NAME}) {\n";
-       }
-           
-       if (util::is_inline_array($e)) {
-               ParseArrayPull($e, "r->", "NDR_BUFFERS");
-       } elsif (util::array_size($e)) {
-               ParseArrayPull($e, "r->", "NDR_SCALARS|NDR_BUFFERS");
-       } elsif (my $switch = util::has_property($e, "switch_is")) {
-               if ($e->{POINTERS}) {
-                       ParseElementPullSwitch($e, $var_prefix, "NDR_SCALARS|NDR_BUFFERS", $switch);
-               } else {
-                       ParseElementPullSwitch($e, $var_prefix, "NDR_BUFFERS", $switch);
-               }
-       } elsif (defined $sub_size) {
-               if ($e->{POINTERS}) {
-                       if (util::is_builtin_type($e->{TYPE})) {
-                               pidl "\tndr_pull_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_fn_t) ndr_pull_$e->{TYPE});\n";
-                       } else {
-                               pidl "\tndr_pull_subcontext_flags_fn(ndr, tree, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_flags_fn_t) ndr_pull_$e->{TYPE});\n";
-                       }
-               }
-       } elsif (util::is_builtin_type($e->{TYPE})) {
-               pidl "\t\tndr_pull_$e->{TYPE}(ndr, tree, hf_$e->{NAME}_$e->{TYPE}, $cprefix$var_prefix$e->{NAME});\n";
-       } elsif ($e->{POINTERS}) {
-               pidl "\t\tndr_pull_$e->{TYPE}(ndr, NDR_SCALARS|NDR_BUFFERS, get_subtree(tree, \"" . field2name($e->{NAME}) . "\", ndr, ett_$e->{TYPE}), $cprefix$var_prefix$e->{NAME});\n";
-       } else {
-               pidl "\t\tndr_pull_$e->{TYPE}(ndr, $ndr_flags, get_subtree(tree, \"" . field2name($e->{NAME}) . "\", ndr, ett_$e->{TYPE}), $cprefix$var_prefix$e->{NAME});\n";
-       }
-
-       if (util::need_wire_pointer($e)) {
-               pidl "\t}\n";
-       }       
-
-       end_flags($e);
-}
-
-#####################################################################
-# parse a struct - pull side
-sub ParseStructPull($)
-{
-       my($struct) = shift;
-       my $conform_e;
-
-       if (! defined $struct->{ELEMENTS}) {
-               return;
-       }
-
-       # see if the structure contains a conformant array. If it
-       # does, then it must be the last element of the structure, and
-       # we need to pull the conformant length early, as it fits on
-       # the wire before the structure (and even before the structure
-       # alignment)
-       my $e = $struct->{ELEMENTS}[-1];
-       if (defined $e->{ARRAY_LEN} && $e->{ARRAY_LEN} eq "*") {
-               $conform_e = $e;
-               pidl "\tuint32_t _conformant_size;\n";
-               $conform_e->{CONFORMANT_SIZE} = "_conformant_size";
-       }
-
-       # declare any internal pointers we need
-       foreach my $e (@{$struct->{ELEMENTS}}) {
-               if (util::need_wire_pointer($e) &&
-                   !util::has_property($e, "relative")) {
-                       pidl "\tuint32_t _ptr_$e->{NAME};\n";
-               }
-       }
-
-       start_flags($struct);
-
-       pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
-
-       pidl "\tndr_pull_struct_start(ndr);\n";
-
-       if (defined $conform_e) {
-               pidl "\tndr_pull_uint32(ndr, tree, hf_conformant_size, &$conform_e->{CONFORMANT_SIZE});\n";
-       }
-
-       my $align = struct_alignment($struct);
-       pidl "\tndr_pull_align(ndr, $align);\n";
-
-       foreach my $e (@{$struct->{ELEMENTS}}) {
-               ParseElementPullScalar($e, "r->", "NDR_SCALARS");
-       }       
-
-       pidl "buffers:\n";
-       pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
-       foreach my $e (@{$struct->{ELEMENTS}}) {
-               ParseElementPullBuffer($e, "r->", "NDR_BUFFERS");
-       }
-
-       pidl "\tndr_pull_struct_end(ndr);\n";
-
-       pidl "done:\n";
-
-       end_flags($struct);
-}
-
-
-#####################################################################
-# parse a union - pull side
-sub ParseUnionPull($)
-{
-       my $e = shift;
-       my $have_default = 0;
-
-       start_flags($e);
-
-       pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
-
-       pidl "\tndr_pull_struct_start(ndr);\n";
-
-#      my $align = union_alignment($e);
-#      pidl "\tndr_pull_align(ndr, $align);\n";
-
-       pidl "\tswitch (level) {\n";
-       foreach my $el (@{$e->{DATA}}) {
-               if ($el->{CASE} eq "default") {
-                       pidl "\tdefault: {\n";
-                       $have_default = 1;
-               } else {
-                       pidl "\tcase $el->{CASE}: {\n";
-               }
-               if ($el->{TYPE} eq "UNION_ELEMENT") {
-                       my $e2 = $el->{DATA};
-                       if ($e2->{POINTERS}) {
-                               pidl "\t\tuint32_t _ptr_$e2->{NAME};\n";
-                       }
-                       ParseElementPullScalar($el->{DATA}, "r->", "NDR_SCALARS");
-               }
-               pidl "\tbreak; }\n\n";
-       }
-       if (! $have_default) {
-               pidl "\tdefault:\n";
-               pidl "\t\treturn; // ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
-       }
-       pidl "\t}\n";
-       pidl "buffers:\n";
-       pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
-       pidl "\tswitch (level) {\n";
-       foreach my $el (@{$e->{DATA}}) {
-               if ($el->{CASE} eq "default") {
-                       pidl "\tdefault:\n";
-               } else {
-                       pidl "\tcase $el->{CASE}:\n";
-               }
-               if ($el->{TYPE} eq "UNION_ELEMENT") {
-                       ParseElementPullBuffer($el->{DATA}, "r->", "NDR_BUFFERS");
-               }
-               pidl "\tbreak;\n\n";
-       }
-       if (! $have_default) {
-               pidl "\tdefault:\n";
-               pidl "\t\treturn; // ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
-       }
-       pidl "\t}\n";
-       pidl "\tndr_pull_struct_end(ndr);\n";
-       pidl "done:\n";
-       end_flags($e);
-}
-
-#####################################################################
-# parse a type
-sub ParseTypePull($)
-{
-       my($data) = shift;
-
-       if (ref($data) eq "HASH") {
-               ($data->{TYPE} eq "STRUCT") &&
-                   ParseStructPull($data);
-               ($data->{TYPE} eq "UNION") &&
-                   ParseUnionPull($data);
-       }
-}
-
-#####################################################################
-# parse a typedef - pull side
-sub ParseTypedefPull($)
-{
-       my($e) = shift;
-       my $static = fn_prefix($e);
-
-       if (! $needed{"pull_$e->{NAME}"}) {
-#              print "pull_$e->{NAME} not needed\n";
-               return;
-       }
-
-       pidl "/*\n\n";
-       pidl IdlDump::DumpTypedef($e);
-       pidl "*/\n\n";
-
-       if ($e->{DATA}->{TYPE} eq "STRUCT") {
-               pidl $static . "void ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, proto_tree *tree, struct $e->{NAME} *r)";
-               pidl "\n{\n";
-               ParseTypePull($e->{DATA});
-               pidl "\treturn;\n";
-               pidl "}\n\n";
-       }
-
-       if ($e->{DATA}->{TYPE} eq "UNION") {
-               pidl $static . "void ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, proto_tree *tree, uint16_t level, union $e->{NAME} *r)";
-               pidl "\n{\n";
-               ParseTypePull($e->{DATA});
-               pidl "\treturn;\n";
-               pidl "}\n\n";
-       }
-}
-
-#####################################################################
-# parse a function element
-sub ParseFunctionElementPull($$)
-{ 
-       my $e = shift;
-       my $inout = shift;
-
-       if (util::array_size($e)) {
-               if (util::need_wire_pointer($e)) {
-                       pidl "\tndr_pull_ptr(ndr, &_ptr_$e->{NAME});\n";
-                       pidl "\tif (_ptr_$e->{NAME}) {\n";
-               } elsif ($inout eq "out" && util::has_property($e, "ref")) {
-                       pidl "\tif (r->$inout.$e->{NAME}) {\n";
-               } else {
-                       pidl "\t{\n";
-               }
-               ParseArrayPull($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
-               pidl "\t}\n";
-       } else {
-               if ($inout eq "out" && util::has_property($e, "ref")) {
-                       pidl "\tif (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {\n";
-                       pidl "\tNDR_ALLOC(ndr, r->out.$e->{NAME});\n";
-                       pidl "\t}\n";
-               }
-               if ($inout eq "in" && util::has_property($e, "ref")) {
-                       pidl "\tNDR_ALLOC(ndr, r->in.$e->{NAME});\n";
-               }
-
-               ParseElementPullScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
-               if ($e->{POINTERS}) {
-                       ParseElementPullBuffer($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
-               }
-       }
-}
-
-
-############################################################
-# allocate ref variables
-sub AllocateRefVars($)
-{
-       my $e = shift;
-       my $asize = util::array_size($e);
-
-       # note that if the variable is also an "in"
-       # variable then we copy the initial value from
-       # the in side
-
-       if (!defined $asize) {
-               # its a simple variable
-               pidl "\tNDR_ALLOC(ndr, r->out.$e->{NAME});\n";
-               if (util::has_property($e, "in")) {
-                       pidl "\t*r->out.$e->{NAME} = *r->in.$e->{NAME};\n";
-               } else {
-                       pidl "\tZERO_STRUCTP(r->out.$e->{NAME});\n";
-               }
-               return;
-       }
-
-       # its an array
-       my $size = find_size_var($e, $asize, "r->out.");
-       pidl "\tNDR_ALLOC_N(ndr, r->out.$e->{NAME}, MAX(1, $size));\n";
-       if (util::has_property($e, "in")) {
-               pidl "\tmemcpy(r->out.$e->{NAME},r->in.$e->{NAME},$size * sizeof(*r->in.$e->{NAME}));\n";
-       } else {
-               pidl "\tmemset(r->out.$e->{NAME}, 0, $size * sizeof(*r->out.$e->{NAME}));\n";
-       }
-}
-
-
 #####################################################################
 # parse a function
 sub ParseFunctionPull($)
@@ -744,29 +103,6 @@ sub FunctionTable($)
        pidl "};\n\n";
 }
 
-#####################################################################
-# parse the interface definitions
-sub ParseInterface($)
-{
-       my($interface) = shift;
-       my($data) = $interface->{DATA};
-
-       foreach my $d (@{$data}) {
-               if ($d->{TYPE} eq "TYPEDEF") {
-                   $structs{$d->{NAME}} = $d;
-           }
-       }
-
-       foreach my $d (@{$data}) {
-               ($d->{TYPE} eq "TYPEDEF") &&
-                   ParseTypedefPull($d);
-               ($d->{TYPE} eq "FUNCTION") && 
-                   ParseFunctionPull($d);
-       }
-
-       FunctionTable($interface);
-}
-
 sub type2ft($)
 {
     my($t) = shift;
@@ -943,150 +279,6 @@ sub ParseHeader($$)
        close(OUT);
 }
 
-#####################################################################
-# parse a parsed IDL structure back into an IDL file
-sub OldParse($$)
-{
-       my($idl) = shift;
-       my($filename) = shift;
-
-       %needed = ();           # Clear after generating header file
-
-       open(OUT, ">$filename") || die "can't open $filename";    
-
-       # Look for name of module
-
-       foreach my $x (@{$idl}) {
-
-           if ($x->{TYPE} eq "INTERFACE") { 
-               ModuleHeader($x);
-               $module = $x->{NAME};
-               BuildNeeded($x);
-           }
-       }
-       
-       pidl "/* parser auto-generated by pidl */\n\n";
-       pidl "#include \"eparser.h\"\n\n";
-
-       pidl "extern const value_string NT_errors[];\n\n";
-
-       pidl "static int hf_opnum = -1;\n";
-       pidl "static int hf_rc = -1;\n";
-       pidl "static int hf_ptr = -1;\n";
-       pidl "static int hf_array_size = -1;\n";
-       pidl "static int hf_array_offset = -1;\n";
-       pidl "static int hf_array_length = -1;\n";
-       pidl "static int hf_level = -1;\n";
-       pidl "static int hf_conformant_size = -1;\n";
-
-       # Declarations for hf variables
-
-       foreach my $y (keys(%needed)) {
-           pidl "static int $y = -1;\n", if $y =~ /^hf_/;
-       }
-
-       pidl "\n";
-
-       # Declarations for ett variables
-
-       foreach my $y (keys(%needed)) {
-           pidl "static gint $y = -1;\n", if $y =~ /^ett_/;
-       }
-
-       pidl "\n";
-
-       foreach my $x (@{$idl}) {
-               ($x->{TYPE} eq "MODULEHEADER") && 
-                   ModuleHeader($x);
-
-               if ($x->{TYPE} eq "INTERFACE") { 
-                       BuildNeeded($x);
-                       ParseInterface($x);
-               }
-       }
-
-       pidl "int proto_dcerpc_pidl_$module = -1;\n\n";
-
-       pidl "static gint ett_dcerpc_$module = -1;\n\n";
-
-       if (defined($if_uuid)) {
-
-           pidl "static e_uuid_t uuid_dcerpc_$module = {\n";
-           pidl "\t0x" . substr($if_uuid, 0, 8);
-           pidl ", 0x" . substr($if_uuid, 9, 4);
-           pidl ", 0x" . substr($if_uuid, 14, 4) . ",\n";
-           pidl "\t{ 0x" . substr($if_uuid, 19, 2);
-           pidl ", 0x" . substr($if_uuid, 21, 2);
-           pidl ", 0x" . substr($if_uuid, 24, 2);
-           pidl ", 0x" . substr($if_uuid, 26, 2);
-           pidl ", 0x" . substr($if_uuid, 28, 2);
-           pidl ", 0x" . substr($if_uuid, 30, 2);
-           pidl ", 0x" . substr($if_uuid, 32, 2);
-           pidl ", 0x" . substr($if_uuid, 34, 2) . " }\n";
-           pidl "};\n\n";
-
-           pidl "static guint16 ver_dcerpc_$module = " . $if_version . ";\n\n";
-       }
-
-       pidl "void proto_register_dcerpc_pidl_$module(void)\n";
-       pidl "{\n";
-
-       pidl "\tstatic hf_register_info hf[] = {\n";
-       
-       pidl "\t{ &hf_opnum, { \"Operation\", \"$module.opnum\", FT_UINT16, BASE_DEC, NULL, 0x0, \"Operation\", HFILL }},\n";
-       pidl "\t{ &hf_rc, { \"Return code\", \"$module.rc\", FT_UINT32, BASE_HEX, VALS(NT_errors), 0x0, \"Return status code\", HFILL }},\n";
-       pidl "\t{ &hf_array_size, { \"Array size\", \"$module.array_size\", FT_UINT32, BASE_DEC, NULL, 0x0, \"Array size\", HFILL }},\n";
-       pidl "\t{ &hf_array_offset, { \"Array offset\", \"$module.array_offset\", FT_UINT32, BASE_DEC, NULL, 0x0, \"Array offset\", HFILL }},\n";
-       pidl "\t{ &hf_array_length, { \"Array length\", \"$module.array_length\", FT_UINT32, BASE_DEC, NULL, 0x0, \"Array length\", HFILL }},\n";
-       pidl "\t{ &hf_ptr, { \"Pointer\", \"$module.ptr\", FT_UINT32, BASE_HEX, NULL, 0x0, \"Pointer\", HFILL }},\n";
-       pidl "\t{ &hf_level, { \"Level\", \"$module.level\", FT_UINT32, BASE_DEC, NULL, 0x0, \"Level\", HFILL }},\n";
-       pidl "\t{ &hf_conformant_size, { \"Conformant size\", \"$module.conformant_size\", FT_UINT32, BASE_DEC, NULL, 0x0, \"Conformant size\", HFILL }},\n";
-
-       foreach my $x (keys(%needed)) {
-           next, if !($x =~ /^hf_/);
-           pidl "\t{ &$x,\n";
-           pidl "\t  { \"$needed{$x}{name}\", \"$x\", $needed{$x}{ft}, $needed{$x}{base}, NULL, 0, \"$x\", HFILL }},\n";
-       }
-       
-       pidl "\t};\n\n";
-
-       pidl "\tstatic gint *ett[] = {\n";
-       pidl "\t\t&ett_dcerpc_$module,\n";
-       foreach my $x (keys(%needed)) {
-           pidl "\t\t&$x,\n", if $x =~ /^ett_/;
-       }
-       pidl "\t};\n\n";
-       
-       if (defined($if_uuid)) {
-
-           pidl "\tproto_dcerpc_pidl_$module = proto_register_protocol(\"pidl_$module\", \"pidl_$module\", \"pidl_$module\");\n\n";
-
-           pidl "\tproto_register_field_array(proto_dcerpc_pidl_$module, hf, array_length (hf));\n";
-           pidl "\tproto_register_subtree_array(ett, array_length(ett));\n";
-
-           pidl "}\n\n";
-
-           pidl "void proto_reg_handoff_dcerpc_pidl_$module(void)\n";
-           pidl "{\n";
-           pidl "\tdcerpc_init_uuid(proto_dcerpc_pidl_$module, ett_dcerpc_$module, \n";
-           pidl "\t\t&uuid_dcerpc_$module, ver_dcerpc_$module, \n";
-           pidl "\t\tdcerpc_dissectors, hf_opnum);\n";
-           pidl "}\n";
-
-       } else {
-
-           pidl "\tint proto_dcerpc;\n\n";
-           pidl "\tproto_dcerpc = proto_get_id_by_filter_name(\"dcerpc\");\n";
-           pidl "\tproto_register_field_array(proto_dcerpc, hf, array_length(hf));\n";
-           pidl "\tproto_register_subtree_array(ett, array_length(ett));\n";
-
-           pidl "}\n";
-
-       }
-
-       close(OUT);
-}
-
 #####################################################################
 # rewrite autogenerated header file
 sub RewriteHeader($$$)
@@ -1378,31 +570,4 @@ sub RewriteC($$$)
     close(OUT);   
 }
 
-#####################################################################
-# parse a parsed IDL structure back into an IDL file
-sub Parse($$)
-{
-       my($idl) = shift;
-       my($filename) = shift;
-
-       %needed = ();           # Clear after generating header file
-
-       open(OUT, ">$filename") || die "can't open $filename";    
-
-       # Look for name of module
-
-       foreach my $x (@{$idl}) {
-
-           if ($x->{TYPE} eq "INTERFACE") { 
-               ModuleHeader($x);
-               $module = $x->{NAME};
-               BuildNeeded($x);
-           }
-       }
-       
-       pidl "/* parser auto-generated by pidl */\n\n";
-
-       close(OUT);
-}
-
 1;