r8264: - Use standard perl package structure for pidl.
authorJelmer Vernooij <jelmer@samba.org>
Sat, 9 Jul 2005 15:32:08 +0000 (15:32 +0000)
committerGerald (Jerry) Carter <jerry@samba.org>
Wed, 10 Oct 2007 18:19:27 +0000 (13:19 -0500)
- Only "use" pidl modules in the main executable when necessary

Try 'make install' in build/pidl to install the package (should work stand-alone).
(This used to be commit c620095692122a65ae1c5d85ca20468d4de93c54)

30 files changed:
source4/build/pidl/Makefile [deleted file]
source4/build/pidl/Makefile.PL [new file with mode: 0755]
source4/build/pidl/Parse/Pidl.pm [new file with mode: 0644]
source4/build/pidl/Parse/Pidl/Compat.pm [moved from source4/build/pidl/compat.pm with 96% similarity]
source4/build/pidl/Parse/Pidl/Dump.pm [moved from source4/build/pidl/dump.pm with 99% similarity]
source4/build/pidl/Parse/Pidl/Ethereal/NDR/Header.pm [moved from source4/build/pidl/eth_header.pm with 97% similarity]
source4/build/pidl/Parse/Pidl/Ethereal/NDR/Parser.pm [moved from source4/build/pidl/eth_parser.pm with 99% similarity]
source4/build/pidl/Parse/Pidl/IDL.pm [moved from source4/build/pidl/idl.pm with 99% similarity]
source4/build/pidl/Parse/Pidl/NDR.pm [moved from source4/build/pidl/ndr.pm with 77% similarity]
source4/build/pidl/Parse/Pidl/ODL.pm [moved from source4/build/pidl/odl.pm with 85% similarity]
source4/build/pidl/Parse/Pidl/Samba/COM/Header.pm [moved from source4/build/pidl/com_header.pm with 76% similarity]
source4/build/pidl/Parse/Pidl/Samba/COM/Proxy.pm [moved from source4/build/pidl/dcom_proxy.pm with 87% similarity]
source4/build/pidl/Parse/Pidl/Samba/COM/Stub.pm [moved from source4/build/pidl/dcom_stub.pm with 97% similarity]
source4/build/pidl/Parse/Pidl/Samba/EJS.pm [moved from source4/build/pidl/ejs.pm with 90% similarity]
source4/build/pidl/Parse/Pidl/Samba/EJSHeader.pm [moved from source4/build/pidl/ejs_header.pm with 89% similarity]
source4/build/pidl/Parse/Pidl/Samba/NDR/Client.pm [moved from source4/build/pidl/ndr_client.pm with 98% similarity]
source4/build/pidl/Parse/Pidl/Samba/NDR/Header.pm [moved from source4/build/pidl/ndr_header.pm with 88% similarity]
source4/build/pidl/Parse/Pidl/Samba/NDR/Parser.pm [moved from source4/build/pidl/ndr_parser.pm with 89% similarity]
source4/build/pidl/Parse/Pidl/Samba/NDR/Server.pm [moved from source4/build/pidl/server.pm with 98% similarity]
source4/build/pidl/Parse/Pidl/Samba/SWIG.pm [moved from source4/build/pidl/swig.pm with 97% similarity]
source4/build/pidl/Parse/Pidl/Samba/Template.pm [moved from source4/build/pidl/template.pm with 98% similarity]
source4/build/pidl/Parse/Pidl/Test.pm [moved from source4/build/pidl/test.pm with 99% similarity]
source4/build/pidl/Parse/Pidl/Typelist.pm [moved from source4/build/pidl/typelist.pm with 92% similarity]
source4/build/pidl/Parse/Pidl/Util.pm [moved from source4/build/pidl/util.pm with 90% similarity]
source4/build/pidl/Parse/Pidl/Validator.pm [moved from source4/build/pidl/validator.pm with 82% similarity]
source4/build/pidl/idl.gram [deleted file]
source4/build/pidl/idl.yp
source4/build/pidl/pidl
source4/build/smb_build/makefile.pm
source4/script/build_idl.sh

diff --git a/source4/build/pidl/Makefile b/source4/build/pidl/Makefile
deleted file mode 100644 (file)
index 944f3db..0000000
+++ /dev/null
@@ -1,7 +0,0 @@
-all: idl.pm
-
-idl.pm: idl.yp
-       yapp -s idl.yp
-
-clean:
-       rm -f idl.pm
diff --git a/source4/build/pidl/Makefile.PL b/source4/build/pidl/Makefile.PL
new file mode 100755 (executable)
index 0000000..1c08f9f
--- /dev/null
@@ -0,0 +1,15 @@
+use ExtUtils::MakeMaker;
+WriteMakefile(
+    'NAME'     => 'Parse::Pidl',
+    'VERSION_FROM' => 'Parse/Pidl.pm',
+       'EXE_FILES' => [ 'pidl' ],
+       'PMLIBDIRS' => [ 'Parse' ],
+       'C' => [],
+);
+
+sub MY::postamble {
+<<'EOT';
+Parse/Pidl/IDL.pm :: idl.yp
+       yapp -s -m 'Parse::Pidl::IDL' -o 'Parse/Pidl/IDL.pm' idl.yp
+EOT
+}
diff --git a/source4/build/pidl/Parse/Pidl.pm b/source4/build/pidl/Parse/Pidl.pm
new file mode 100644 (file)
index 0000000..465f340
--- /dev/null
@@ -0,0 +1,16 @@
+###################################################
+# package to parse IDL files and generate code for
+# rpc functions in Samba
+# Copyright tridge@samba.org 2000-2003
+# Copyright jelmer@samba.org 2005
+# released under the GNU GPL
+
+package Parse::Pidl;
+
+use strict;
+
+use vars qw ( $VERSION );
+
+$VERSION = '0.01';
+
+1;
similarity index 96%
rename from source4/build/pidl/compat.pm
rename to source4/build/pidl/Parse/Pidl/Compat.pm
index 3ab94b70f3897184dd1fbd633eb8b162e014df86..f81d73f36afd58b9cad700761bd011c6f01dd6bc 100644 (file)
@@ -3,7 +3,7 @@
 # Copyright jelmer@samba.org 2005
 # released under the GNU GPL
 
-package IDLCompat;
+package Parse::Pidl::Compat;
 
 use strict;
 
similarity index 99%
rename from source4/build/pidl/dump.pm
rename to source4/build/pidl/Parse/Pidl/Dump.pm
index 2cd0c140a589ebb73ec4f56e71b6d3e49fe5a2a5..7a18cf517375f55f848ff6fc0add3a99a154deff 100644 (file)
@@ -3,7 +3,7 @@
 # Copyright tridge@samba.org 2000
 # released under the GNU GPL
 
-package IdlDump;
+package Parse::Pidl::Dump;
 
 use strict;
 
similarity index 97%
rename from source4/build/pidl/eth_header.pm
rename to source4/build/pidl/Parse/Pidl/Ethereal/NDR/Header.pm
index 229b4f8051061fd8089c8b18b84133dc589c775c..c4d983e793c7a4c00900895cc662e4040e3a5b96 100644 (file)
@@ -4,7 +4,7 @@
 # Copyright jelmer@samba.org 2005
 # released under the GNU GPL
 
-package EthHeader;
+package Parse::Pidl::Ethereal::NDR::Header;
 
 use strict;
 
similarity index 99%
rename from source4/build/pidl/eth_parser.pm
rename to source4/build/pidl/Parse/Pidl/Ethereal/NDR/Parser.pm
index ec07addb475b47b308019e2560039de0afd57efb..96eafc0b578c0b8fdc2120c10dc1f29cadd97643 100644 (file)
@@ -5,11 +5,11 @@
 # Copyright jelmer@samba.org 2004-2005
 # released under the GNU GPL
 
-package EthParser;
+package Parse::Pidl::Ethereal::NDR::Parser;
 
 use strict;
-use pidl::typelist;
-use pidl::ndr;
+use Parse::Pidl::Typelist;
+use Parse::Pidl::NDR;
 
 # the list of needed functions
 
similarity index 99%
rename from source4/build/pidl/idl.pm
rename to source4/build/pidl/Parse/Pidl/IDL.pm
index 8b6cf3956e0f649bf1d805f6884b1ff856515c45..4e851d36bac741f4afd335c41dde16df8790ec3d 100644 (file)
@@ -7,7 +7,7 @@
 #             ANY CHANGE MADE HERE WILL BE LOST !
 #
 ####################################################################
-package idl;
+package Parse::Pidl::IDL;
 use vars qw ( @ISA );
 use strict;
 
@@ -2138,7 +2138,7 @@ sub
                 'optional_base_element', 2,
 sub
 #line 195 "build/pidl/idl.yp"
-{ $_[2]->{PROPERTIES} = util::FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] }
+{ $_[2]->{PROPERTIES} = Parse::Pidl::Util::FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] }
        ],
        [#Rule 45
                 'union_elements', 0, undef
@@ -2233,7 +2233,7 @@ sub
                 'property_list', 4,
 sub
 #line 250 "build/pidl/idl.yp"
-{ util::FlattenHash([$_[1],$_[3]]); }
+{ Parse::Pidl::Util::FlattenHash([$_[1],$_[3]]); }
        ],
        [#Rule 62
                 'properties', 1,
@@ -2245,7 +2245,7 @@ sub
                 'properties', 3,
 sub
 #line 254 "build/pidl/idl.yp"
-{ util::FlattenHash([$_[1], $_[3]]); }
+{ Parse::Pidl::Util::FlattenHash([$_[1], $_[3]]); }
        ],
        [#Rule 64
                 'property', 1,
@@ -2390,7 +2390,7 @@ sub
 #line 305 "build/pidl/idl.yp"
 
 
-use pidl::util;
+use Parse::Pidl::Util;
 
 sub _Error {
     if (exists $_[0]->YYData->{ERRMSG}) {
@@ -2479,7 +2479,7 @@ sub parse_idl($$)
 
        my $idl = $self->YYParse( yylex => \&_Lexer, yyerror => \&_Error );
 
-       return util::CleanData($idl);
+       return Parse::Pidl::Util::CleanData($idl);
 }
 
 1;
similarity index 77%
rename from source4/build/pidl/ndr.pm
rename to source4/build/pidl/Parse/Pidl/NDR.pm
index c167e783093d6810421164b7a7f7d32cbc27ecf3..f07b5e60ea21feb0c04e887814ba8bf2c53575b0 100644 (file)
@@ -5,10 +5,10 @@
 # Copyright jelmer@samba.org 2004-2005
 # released under the GNU GPL
 
-package Ndr;
+package Parse::Pidl::NDR;
 
 use strict;
-use pidl::typelist;
+use Parse::Pidl::Typelist;
 
 sub nonfatal($$)
 {
@@ -35,12 +35,12 @@ sub GetElementLevelTable($)
        my @length_is = ();
        my @size_is = ();
 
-       if (util::has_property($e, "size_is")) {
-               @size_is = split /,/, util::has_property($e, "size_is");
+       if (Parse::Pidl::Util::has_property($e, "size_is")) {
+               @size_is = split /,/, Parse::Pidl::Util::has_property($e, "size_is");
        }
 
-       if (util::has_property($e, "length_is")) {
-               @length_is = split /,/, util::has_property($e, "length_is");
+       if (Parse::Pidl::Util::has_property($e, "length_is")) {
+               @length_is = split /,/, Parse::Pidl::Util::has_property($e, "length_is");
        }
 
        if (defined($e->{ARRAY_LEN})) {
@@ -59,7 +59,7 @@ sub GetElementLevelTable($)
                if ($d eq "*") {
                        $is_conformant = 1;
                        if ($size = shift @size_is) {
-                       } elsif ((scalar(@size_is) == 0) and util::has_property($e, "string")) {
+                       } elsif ((scalar(@size_is) == 0) and Parse::Pidl::Util::has_property($e, "string")) {
                                $is_string = 1;
                                delete($e->{PROPERTIES}->{string});
                        } else {
@@ -88,8 +88,8 @@ sub GetElementLevelTable($)
                        IS_ZERO_TERMINATED => "$is_string",
                        IS_VARYING => "$is_varying",
                        IS_CONFORMANT => "$is_conformant",
-                       IS_FIXED => (not $is_conformant and util::is_constant($size)),
-                       IS_INLINE => (not $is_conformant and not util::is_constant($size))
+                       IS_FIXED => (not $is_conformant and Parse::Pidl::Util::is_constant($size)),
+                       IS_INLINE => (not $is_conformant and not Parse::Pidl::Util::is_constant($size))
                });
        }
 
@@ -129,9 +129,9 @@ sub GetElementLevelTable($)
                        }
                } 
                
-               if (scalar(@size_is) == 0 and util::has_property($e, "string")) {
+               if (scalar(@size_is) == 0 and Parse::Pidl::Util::has_property($e, "string")) {
                        $is_string = 1;
-                       $is_varying = $is_conformant = util::has_property($e, "noheader")?0:1;
+                       $is_varying = $is_conformant = Parse::Pidl::Util::has_property($e, "noheader")?0:1;
                        delete($e->{PROPERTIES}->{string});
                }
 
@@ -153,9 +153,9 @@ sub GetElementLevelTable($)
                } 
        }
 
-       if (defined(util::has_property($e, "subcontext"))) {
-               my $hdr_size = util::has_property($e, "subcontext");
-               my $subsize = util::has_property($e, "subcontext_size");
+       if (defined(Parse::Pidl::Util::has_property($e, "subcontext"))) {
+               my $hdr_size = Parse::Pidl::Util::has_property($e, "subcontext");
+               my $subsize = Parse::Pidl::Util::has_property($e, "subcontext_size");
                if (not defined($subsize)) { 
                        $subsize = -1; 
                }
@@ -165,12 +165,12 @@ sub GetElementLevelTable($)
                        HEADER_SIZE => $hdr_size,
                        SUBCONTEXT_SIZE => $subsize,
                        IS_DEFERRED => $is_deferred,
-                       COMPRESSION => util::has_property($e, "compression"),
-                       OBFUSCATION => util::has_property($e, "obfuscation")
+                       COMPRESSION => Parse::Pidl::Util::has_property($e, "compression"),
+                       OBFUSCATION => Parse::Pidl::Util::has_property($e, "obfuscation")
                });
        }
 
-       if (my $switch = util::has_property($e, "switch_is")) {
+       if (my $switch = Parse::Pidl::Util::has_property($e, "switch_is")) {
                push (@$order, {
                        TYPE => "SWITCH", 
                        SWITCH_IS => $switch,
@@ -186,7 +186,7 @@ sub GetElementLevelTable($)
                nonfatal($e, "length_is() on non-array element");
        }
 
-       if (util::has_property($e, "string")) {
+       if (Parse::Pidl::Util::has_property($e, "string")) {
                nonfatal($e, "string() attribute on non-array element");
        }
 
@@ -212,10 +212,10 @@ sub can_contain_deferred
        my $e = shift;
 
        return 1 if ($e->{POINTERS});
-       return 0 if (typelist::is_scalar($e->{TYPE}));
-       return 1 unless (typelist::hasType($e->{TYPE})); # assume the worst
+       return 0 if (Parse::Pidl::Typelist::is_scalar($e->{TYPE}));
+       return 1 unless (Parse::Pidl::Typelist::hasType($e->{TYPE})); # assume the worst
 
-       my $type = typelist::getType($e->{TYPE});
+       my $type = Parse::Pidl::Typelist::getType($e->{TYPE});
 
        foreach my $x (@{$type->{DATA}->{ELEMENTS}}) {
                return 1 if (can_contain_deferred ($x));
@@ -230,12 +230,12 @@ sub pointer_type($)
 
        return undef unless $e->{POINTERS};
        
-       return "ref" if (util::has_property($e, "ref"));
-       return "ptr" if (util::has_property($e, "ptr"));
-       return "sptr" if (util::has_property($e, "sptr"));
-       return "unique" if (util::has_property($e, "unique"));
-       return "relative" if (util::has_property($e, "relative"));
-       return "ignore" if (util::has_property($e, "ignore"));
+       return "ref" if (Parse::Pidl::Util::has_property($e, "ref"));
+       return "ptr" if (Parse::Pidl::Util::has_property($e, "ptr"));
+       return "sptr" if (Parse::Pidl::Util::has_property($e, "sptr"));
+       return "unique" if (Parse::Pidl::Util::has_property($e, "unique"));
+       return "relative" if (Parse::Pidl::Util::has_property($e, "relative"));
+       return "ignore" if (Parse::Pidl::Util::has_property($e, "ignore"));
 
        return undef;
 }
@@ -268,22 +268,22 @@ sub align_type
 {
        my $e = shift;
 
-       unless (typelist::hasType($e)) {
+       unless (Parse::Pidl::Typelist::hasType($e)) {
            # it must be an external type - all we can do is guess 
                # print "Warning: assuming alignment of unknown type '$e' is 4\n";
            return 4;
        }
 
-       my $dt = typelist::getType($e)->{DATA};
+       my $dt = Parse::Pidl::Typelist::getType($e)->{DATA};
 
        if ($dt->{TYPE} eq "ENUM") {
-               return align_type(typelist::enum_type_fn($dt));
+               return align_type(Parse::Pidl::Typelist::enum_type_fn($dt));
        } elsif ($dt->{TYPE} eq "BITMAP") {
-               return align_type(typelist::bitmap_type_fn($dt));
+               return align_type(Parse::Pidl::Typelist::bitmap_type_fn($dt));
        } elsif (($dt->{TYPE} eq "STRUCT") or ($dt->{TYPE} eq "UNION")) {
                return find_largest_alignment($dt);
        } elsif ($dt->{TYPE} eq "SCALAR") {
-               return typelist::getScalarAlignment($dt->{NAME});
+               return Parse::Pidl::Typelist::getScalarAlignment($dt->{NAME});
        }
 
        die("Unknown data type type $dt->{TYPE}");
@@ -320,7 +320,7 @@ sub ParseStruct($)
        }
 
        if (defined $e->{TYPE} && $e->{TYPE} eq "string"
-           &&  util::property_matches($e, "flag", ".*LIBNDR_FLAG_STR_CONFORMANT.*")) {
+           &&  Parse::Pidl::Util::property_matches($e, "flag", ".*LIBNDR_FLAG_STR_CONFORMANT.*")) {
                $surrounding = $struct->{ELEMENTS}[-1];
        }
                
@@ -336,10 +336,10 @@ sub ParseUnion($)
 {
        my $e = shift;
        my @elements = ();
-       my $switch_type = util::has_property($e, "switch_type");
+       my $switch_type = Parse::Pidl::Util::has_property($e, "switch_type");
        unless (defined($switch_type)) { $switch_type = "uint32"; }
 
-       if (util::has_property($e, "nodiscriminant")) { $switch_type = undef; }
+       if (Parse::Pidl::Util::has_property($e, "nodiscriminant")) { $switch_type = undef; }
        
        foreach my $x (@{$e->{ELEMENTS}}) 
        {
@@ -349,7 +349,7 @@ sub ParseUnion($)
                } else {
                        $t = ParseElement($x);
                }
-               if (util::has_property($x, "default")) {
+               if (Parse::Pidl::Util::has_property($x, "default")) {
                        $t->{CASE} = "default";
                } elsif (defined($x->{PROPERTIES}->{case})) {
                        $t->{CASE} = "case $x->{PROPERTIES}->{case}";
@@ -373,7 +373,7 @@ sub ParseEnum($)
 
        return {
                TYPE => "ENUM",
-               BASE_TYPE => typelist::enum_type_fn($e),
+               BASE_TYPE => Parse::Pidl::Typelist::enum_type_fn($e),
                ELEMENTS => $e->{ELEMENTS},
                PROPERTIES => $e->{PROPERTIES}
        };
@@ -385,7 +385,7 @@ sub ParseBitmap($)
 
        return {
                TYPE => "BITMAP",
-               BASE_TYPE => typelist::bitmap_type_fn($e),
+               BASE_TYPE => Parse::Pidl::Typelist::bitmap_type_fn($e),
                ELEMENTS => $e->{ELEMENTS},
                PROPERTIES => $e->{PROPERTIES}
        };
@@ -444,8 +444,8 @@ sub ParseFunction($$$)
 
        foreach my $x (@{$d->{ELEMENTS}}) {
                my $e = ParseElement($x);
-               push (@{$e->{DIRECTION}}, "in") if (util::has_property($x, "in"));
-               push (@{$e->{DIRECTION}}, "out") if (util::has_property($x, "out"));
+               push (@{$e->{DIRECTION}}, "in") if (Parse::Pidl::Util::has_property($x, "in"));
+               push (@{$e->{DIRECTION}}, "out") if (Parse::Pidl::Util::has_property($x, "out"));
                push (@elements, $e);
        }
 
@@ -469,7 +469,7 @@ sub CheckPointerTypes($$)
        my $default = shift;
 
        foreach my $e (@{$s->{ELEMENTS}}) {
-               if ($e->{POINTERS} and not defined(Ndr::pointer_type($e))) {
+               if ($e->{POINTERS} and not defined(pointer_type($e))) {
                        $e->{PROPERTIES}->{$default} = 1;
                }
        }
@@ -486,13 +486,13 @@ sub ParseInterface($)
        my $opnum = 0;
        my $version;
 
-       if (not util::has_property($idl, "pointer_default")) {
+       if (not Parse::Pidl::Util::has_property($idl, "pointer_default")) {
                # MIDL defaults to "ptr" in DCE compatible mode (/osf)
                # and "unique" in Microsoft Extensions mode (default)
                $idl->{PROPERTIES}->{pointer_default} = "unique";
        }
 
-       if (not util::has_property($idl, "pointer_default_top")) {
+       if (not Parse::Pidl::Util::has_property($idl, "pointer_default_top")) {
                $idl->{PROPERTIES}->{pointer_default_top} = "ref";
        }
 
@@ -529,7 +529,7 @@ sub ParseInterface($)
 
        return { 
                NAME => $idl->{NAME},
-               UUID => util::has_property($idl, "uuid"),
+               UUID => Parse::Pidl::Util::has_property($idl, "uuid"),
                VERSION => $version,
                TYPE => "INTERFACE",
                PROPERTIES => $idl->{PROPERTIES},
@@ -589,7 +589,7 @@ sub ContainsDeferred($$)
        do {
                return 1 if ($l->{IS_DEFERRED}); 
                return 1 if ($l->{CONTAINS_DEFERRED});
-       } while ($l = Ndr::GetNextLevel($e,$l));
+       } while ($l = GetNextLevel($e,$l));
        
        return 0;
 }
similarity index 85%
rename from source4/build/pidl/odl.pm
rename to source4/build/pidl/Parse/Pidl/ODL.pm
index d40f8fbcca1fd4d3d6cf7ab0cdcd802d47c9f043..eddf7e417c4841ad8712be5cb936c2aecfc7a230 100644 (file)
@@ -2,7 +2,7 @@
 # Converts ODL stuctures to IDL structures
 # (C) 2004-2005 Jelmer Vernooij <jelmer@samba.org>
 
-package ODL;
+package Parse::Pidl::ODL;
 
 use strict;
 
@@ -43,8 +43,8 @@ sub ReplaceInterfacePointers($)
        my $e = shift;
 
        foreach my $x (@{$e->{ELEMENTS}}) {
-               next unless (typelist::hasType($x->{TYPE}));
-               next unless typelist::getType($x->{TYPE})->{DATA}->{TYPE} eq "INTERFACE";
+               next unless (Parse::Pidl::Typelist::hasType($x->{TYPE}));
+               next unless Parse::Pidl::Typelist::getType($x->{TYPE})->{DATA}->{TYPE} eq "INTERFACE";
                
                $x->{TYPE} = "MInterfacePointer";
        }
@@ -59,14 +59,14 @@ sub ODL2IDL($)
                # Add [in] ORPCTHIS *this, [out] ORPCTHAT *that
                # and replace interfacepointers with MInterfacePointer
                # for 'object' interfaces
-               if (util::has_property($x, "object")) {
+               if (Parse::Pidl::Util::has_property($x, "object")) {
                        foreach my $e (@{$x->{DATA}}) {
                                ($e->{TYPE} eq "FUNCTION") && FunctionAddObjArgs($e);
                                ReplaceInterfacePointers($e);
                        }
                        # Object interfaces use ORPC
                        my @depends = ();
-                       if(util::has_property($x, "depends")) {
+                       if(Parse::Pidl::Util::has_property($x, "depends")) {
                                @depends = split /,/, $x->{PROPERTIES}->{depends};
                        }
                        push @depends, "orpc";
similarity index 76%
rename from source4/build/pidl/com_header.pm
rename to source4/build/pidl/Parse/Pidl/Samba/COM/Header.pm
index 3300d8409274b96452fb4c23c63cbf789f133d47..4f5e0d68adb410d5a19d553b71bfcf6c7ff52c12 100644 (file)
@@ -1,9 +1,9 @@
 # COM Header generation
 # (C) 2005 Jelmer Vernooij <jelmer@samba.org>
 
-package COMHeader;
+package Parse::Pidl::Samba::COM::Header;
 
-use pidl::typelist;
+use Parse::Pidl::Typelist;
 
 use strict;
 
@@ -14,21 +14,21 @@ sub GetArgumentProtoList($)
 
        foreach my $a (@{$f->{ELEMENTS}}) {
 
-               $res .= ", " . typelist::mapType($a->{TYPE}) . " ";
+               $res .= ", " . Parse::Pidl::Typelist::mapType($a->{TYPE}) . " ";
 
                my $l = $a->{POINTERS};
-               $l-- if (typelist::scalar_is_reference($a->{TYPE}));
+               $l-- if (Parse::Pidl::Typelist::scalar_is_reference($a->{TYPE}));
                foreach my $i (1..$l) {
                        $res .= "*";
                }
 
                if (defined $a->{ARRAY_LEN}[0] && 
-               !util::is_constant($a->{ARRAY_LEN}[0]) &&
+               !Parse::Pidl::Util::is_constant($a->{ARRAY_LEN}[0]) &&
                !$a->{POINTERS}) {
                        $res .= "*";
                }
                $res .= $a->{NAME};
-               if (defined $a->{ARRAY_LEN}[0] && util::is_constant($a->{ARRAY_LEN}[0])) {
+               if (defined $a->{ARRAY_LEN}[0] && Parse::Pidl::Util::is_constant($a->{ARRAY_LEN}[0])) {
                        $res .= "[$a->{ARRAY_LEN}[0]]";
                }
        }
@@ -61,7 +61,7 @@ sub HeaderVTable($)
 
        my $data = $interface->{DATA};
        foreach my $d (@{$data}) {
-               $res .= "\t" . typelist::mapType($d->{RETURN_TYPE}) . " (*$d->{NAME}) (struct $interface->{NAME} *d, TALLOC_CTX *mem_ctx" . GetArgumentProtoList($d) . ");\\\n" if ($d->{TYPE} eq "FUNCTION");
+               $res .= "\t" . Parse::Pidl::Typelist::mapType($d->{RETURN_TYPE}) . " (*$d->{NAME}) (struct $interface->{NAME} *d, TALLOC_CTX *mem_ctx" . GetArgumentProtoList($d) . ");\\\n" if ($d->{TYPE} eq "FUNCTION");
        }
        $res .= "\n";
        $res .= "struct $interface->{NAME}_vtable {\n";
@@ -109,7 +109,7 @@ sub ParseCoClass($)
        my $c = shift;
        my $res = "";
        $res .= "#define CLSID_" . uc($c->{NAME}) . " $c->{PROPERTIES}->{uuid}\n";
-       if (util::has_property($c, "progid")) {
+       if (Parse::Pidl::Util::has_property($c, "progid")) {
                $res .= "#define PROGID_" . uc($c->{NAME}) . " $c->{PROPERTIES}->{progid}\n";
        }
        $res .= "\n";
@@ -123,7 +123,7 @@ sub Parse($)
 
        foreach my $x (@{$idl})
        {
-               if ($x->{TYPE} eq "INTERFACE" && util::has_property($x, "object")) {
+               if ($x->{TYPE} eq "INTERFACE" && Parse::Pidl::Util::has_property($x, "object")) {
                        $res.=ParseInterface($x);
                } 
 
similarity index 87%
rename from source4/build/pidl/dcom_proxy.pm
rename to source4/build/pidl/Parse/Pidl/Samba/COM/Proxy.pm
index bb45f774ef7fdaf734aafc910819929c510011be..f4c23e1d9b5f5522e0e0188137c09c7ccd61d3ea 100644 (file)
@@ -4,9 +4,9 @@
 # Copyright jelmer@samba.org 2003-2005
 # released under the GNU GPL
 
-package DCOMProxy;
+package Parse::Pidl::Samba::COM::Proxy;
 
-use pidl::com_header;
+use Parse::Pidl::Samba::COM::Header;
 
 use strict;
 
@@ -85,7 +85,7 @@ sub ParseFunction($$)
        my $uname = uc $name;
 
        $res.="
-static $fn->{RETURN_TYPE} dcom_proxy_$interface->{NAME}_$name(struct $interface->{NAME} *d, TALLOC_CTX *mem_ctx" . COMHeader::GetArgumentProtoList($fn) . ")
+static $fn->{RETURN_TYPE} dcom_proxy_$interface->{NAME}_$name(struct $interface->{NAME} *d, TALLOC_CTX *mem_ctx" . Parse::Pidl::Samba::COM::Header::GetArgumentProtoList($fn) . ")
 {
        struct dcerpc_pipe *p;
        NTSTATUS status = dcom_get_pipe(d, &p);
@@ -103,8 +103,8 @@ static $fn->{RETURN_TYPE} dcom_proxy_$interface->{NAME}_$name(struct $interface-
        
        # Put arguments into r
        foreach my $a (@{$fn->{ELEMENTS}}) {
-               next unless (util::has_property($a, "in"));
-               if (typelist::typeIs($a->{TYPE}, "INTERFACE")) {
+               next unless (Parse::Pidl::Util::has_property($a, "in"));
+               if (Parse::Pidl::Typelist::typeIs($a->{TYPE}, "INTERFACE")) {
                        $res .="\tNDR_CHECK(dcom_OBJREF_from_IUnknown(&r.in.$a->{NAME}.obj, $a->{NAME}));\n";
                } else {
                        $res .= "\tr.in.$a->{NAME} = $a->{NAME};\n";
@@ -126,9 +126,9 @@ static $fn->{RETURN_TYPE} dcom_proxy_$interface->{NAME}_$name(struct $interface-
 
        # Put r info back into arguments
        foreach my $a (@{$fn->{ELEMENTS}}) {
-               next unless (util::has_property($a, "out"));
+               next unless (Parse::Pidl::Util::has_property($a, "out"));
 
-               if (typelist::typeIs($a->{TYPE}, "INTERFACE")) {
+               if (Parse::Pidl::Typelist::typeIs($a->{TYPE}, "INTERFACE")) {
                        $res .="\tNDR_CHECK(dcom_IUnknown_from_OBJREF(d->ctx, &$a->{NAME}, r.out.$a->{NAME}.obj));\n";
                } else {
                        $res .= "\t*$a->{NAME} = r.out.$a->{NAME};\n";
@@ -171,7 +171,7 @@ sub RegistrationFunction($$)
        $res .="\tNTSTATUS status = NT_STATUS_OK;\n";
        foreach my $interface (@{$idl}) {
                next if $interface->{TYPE} ne "INTERFACE";
-               next if not util::has_property($interface, "object");
+               next if not Parse::Pidl::Util::has_property($interface, "object");
 
                my $data = $interface->{DATA};
                my $count = 0;
@@ -199,8 +199,8 @@ sub Parse($)
 
        foreach my $x (@{$pidl}) {
                next if ($x->{TYPE} ne "INTERFACE");
-               next if util::has_property($x, "local");
-               next unless util::has_property($x, "object");
+               next if Parse::Pidl::Util::has_property($x, "local");
+               next unless Parse::Pidl::Util::has_property($x, "object");
 
                $res .= ParseInterface($x);
        }
similarity index 97%
rename from source4/build/pidl/dcom_stub.pm
rename to source4/build/pidl/Parse/Pidl/Samba/COM/Stub.pm
index b551b06299d30eeabc6220be425fef4e3ae421b4..a06671e76df2b6d65a46bf049e7fe50a4707d424 100644 (file)
@@ -5,7 +5,7 @@
 # Copyright metze@samba.org 2004
 # released under the GNU GPL
 
-package DCOMStub;
+package Parse::Pidl::Samba::COM::Stub;
 
 use strict;
 
@@ -81,7 +81,7 @@ sub Boilerplate_Iface($)
        my($data) = $interface->{DATA};
        my $name = $interface->{NAME};
        my $uname = uc $name;
-       my $uuid = util::make_str($interface->{PROPERTIES}->{uuid});
+       my $uuid = Parse::Pidl::Util::make_str($interface->{PROPERTIES}->{uuid});
        my $if_version = $interface->{PROPERTIES}->{version};
 
        pidl "
@@ -290,7 +290,7 @@ sub ParseInterface($)
 {
        my($interface) = shift;
        
-       return "" if util::has_property($interface, "local");
+       return "" if Parse::Pidl::Util::has_property($interface, "local");
        
        my($data) = $interface->{DATA};
        my $count = 0;
similarity index 90%
rename from source4/build/pidl/ejs.pm
rename to source4/build/pidl/Parse/Pidl/Samba/EJS.pm
index d86f73b5be5e4faf98920a0af27684be42499e3a..72f280add039f79c8f5511c21c4eb32df7f9b6df 100644 (file)
@@ -4,10 +4,10 @@
 # Copyright Andrew Tridgell 2005
 # released under the GNU GPL
 
-package EjsClient;
+package Parse::Pidl::Samba::EJS;
 
 use strict;
-use pidl::typelist;
+use Parse::Pidl::Typelist;
 
 my($res);
 my %constants;
@@ -110,7 +110,7 @@ sub fn_prefix($)
 {
        my $fn = shift;
 
-       return "" if (util::has_property($fn, "public"));
+       return "" if (Parse::Pidl::Util::has_property($fn, "public"));
        return "static ";
 }
 
@@ -120,7 +120,7 @@ sub EjsPullScalar($$$$$)
 {
        my ($e, $l, $var, $name, $env) = @_;
 
-       return if (util::has_property($e, "value"));
+       return if (Parse::Pidl::Util::has_property($e, "value"));
 
        $var = get_pointer_to($var);
        # have to handle strings specially :(
@@ -143,7 +143,7 @@ sub EjsPullPointer($$$$$)
        indent;
        pidl "EJS_ALLOC(ejs, $var);";
        $var = get_value_of($var);              
-       EjsPullElement($e, Ndr::GetNextLevel($e, $l), $var, $name, $env);
+       EjsPullElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env);
        deindent;
        pidl "}";
 }
@@ -163,8 +163,8 @@ sub EjsPullString($$$$$)
 sub EjsPullArray($$$$$)
 {
        my ($e, $l, $var, $name, $env) = @_;
-       my $length = util::ParseExpr($l->{LENGTH_IS}, $env);
-       my $pl = Ndr::GetPrevLevel($e, $l);
+       my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env);
+       my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l);
        if ($pl && $pl->{TYPE} eq "POINTER") {
                $var = get_pointer_to($var);
        }
@@ -178,7 +178,7 @@ sub EjsPullArray($$$$$)
        pidl "for (i=0;i<$length;i++) {";
        indent;
        pidl "char *id = talloc_asprintf(ejs, \"%s.%u\", $name, i);";
-       EjsPullElement($e, Ndr::GetNextLevel($e, $l), $avar, "id", $env);
+       EjsPullElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $avar, "id", $env);
        pidl "talloc_free(id);";
        deindent;
        pidl "}";
@@ -192,9 +192,9 @@ sub EjsPullArray($$$$$)
 sub EjsPullSwitch($$$$$)
 {
        my ($e, $l, $var, $name, $env) = @_;
-       my $switch_var = util::ParseExpr($l->{SWITCH_IS}, $env);
+       my $switch_var = Parse::Pidl::Util::ParseExpr($l->{SWITCH_IS}, $env);
        pidl "ejs_set_switch(ejs, $switch_var);";
-       EjsPullElement($e, Ndr::GetNextLevel($e, $l), $var, $name, $env);
+       EjsPullElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env);
 }
 
 ###########################
@@ -202,7 +202,7 @@ sub EjsPullSwitch($$$$$)
 sub EjsPullElement($$$$$)
 {
        my ($e, $l, $var, $name, $env) = @_;
-       if (util::has_property($e, "charset")) {
+       if (Parse::Pidl::Util::has_property($e, "charset")) {
                EjsPullString($e, $l, $var, $name, $env);
        } elsif ($l->{TYPE} eq "ARRAY") {
                EjsPullArray($e, $l, $var, $name, $env);
@@ -224,7 +224,7 @@ sub EjsPullElementTop($$)
        my $e = shift;
        my $env = shift;
        my $l = $e->{LEVELS}[0];
-       my $var = util::ParseExpr($e->{NAME}, $env);
+       my $var = Parse::Pidl::Util::ParseExpr($e->{NAME}, $env);
        my $name = "\"$e->{NAME}\"";
        EjsPullElement($e, $l, $var, $name, $env);
 }
@@ -311,7 +311,7 @@ sub EjsBitmapPull($$)
        my $name = shift;
        my $d = shift;
        my $type_fn = $d->{BASE_TYPE};
-       my($type_decl) = typelist::mapType($d->{BASE_TYPE});
+       my($type_decl) = Parse::Pidl::Typelist::mapType($d->{BASE_TYPE});
        pidl fn_prefix($d);
        pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, $type_decl *r)\n{";
        indent;
@@ -326,7 +326,7 @@ sub EjsBitmapPull($$)
 sub EjsTypedefPull($)
 {
        my $d = shift;
-       return if (util::has_property($d, "noejs"));
+       return if (Parse::Pidl::Util::has_property($d, "noejs"));
        if ($d->{DATA}->{TYPE} eq 'STRUCT') {
                EjsStructPull($d->{NAME}, $d->{DATA});
        } elsif ($d->{DATA}->{TYPE} eq 'UNION') {
@@ -393,7 +393,7 @@ sub EjsPushPointer($$$$$)
        pidl "} else {";
        indent;
        $var = get_value_of($var);              
-       EjsPushElement($e, Ndr::GetNextLevel($e, $l), $var, $name, $env);
+       EjsPushElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env);
        deindent;
        pidl "}";
 }
@@ -403,9 +403,9 @@ sub EjsPushPointer($$$$$)
 sub EjsPushSwitch($$$$$)
 {
        my ($e, $l, $var, $name, $env) = @_;
-       my $switch_var = util::ParseExpr($l->{SWITCH_IS}, $env);
+       my $switch_var = Parse::Pidl::Util::ParseExpr($l->{SWITCH_IS}, $env);
        pidl "ejs_set_switch(ejs, $switch_var);";
-       EjsPushElement($e, Ndr::GetNextLevel($e, $l), $var, $name, $env);
+       EjsPushElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env);
 }
 
 
@@ -414,8 +414,8 @@ sub EjsPushSwitch($$$$$)
 sub EjsPushArray($$$$$)
 {
        my ($e, $l, $var, $name, $env) = @_;
-       my $length = util::ParseExpr($l->{LENGTH_IS}, $env);
-       my $pl = Ndr::GetPrevLevel($e, $l);
+       my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env);
+       my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l);
        if ($pl && $pl->{TYPE} eq "POINTER") {
                $var = get_pointer_to($var);
        }
@@ -426,7 +426,7 @@ sub EjsPushArray($$$$$)
        pidl "for (i=0;i<$length;i++) {";
        indent;
        pidl "const char *id = talloc_asprintf(ejs, \"%s.%u\", $name, i);";
-       EjsPushElement($e, Ndr::GetNextLevel($e, $l), $avar, "id", $env);
+       EjsPushElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $avar, "id", $env);
        deindent;
        pidl "}";
        pidl "ejs_push_uint32(ejs, v, $name \".length\", &i);";
@@ -439,7 +439,7 @@ sub EjsPushArray($$$$$)
 sub EjsPushElement($$$$$)
 {
        my ($e, $l, $var, $name, $env) = @_;
-       if (util::has_property($e, "charset")) {
+       if (Parse::Pidl::Util::has_property($e, "charset")) {
                EjsPushString($e, $l, $var, $name, $env);
        } elsif ($l->{TYPE} eq "ARRAY") {
                EjsPushArray($e, $l, $var, $name, $env);
@@ -461,7 +461,7 @@ sub EjsPushElementTop($$)
        my $e = shift;
        my $env = shift;
        my $l = $e->{LEVELS}[0];
-       my $var = util::ParseExpr($e->{NAME}, $env);
+       my $var = Parse::Pidl::Util::ParseExpr($e->{NAME}, $env);
        my $name = "\"$e->{NAME}\"";
        EjsPushElement($e, $l, $var, $name, $env);
 }
@@ -559,7 +559,7 @@ sub EjsBitmapPush($$)
        my $name = shift;
        my $d = shift;
        my $type_fn = $d->{BASE_TYPE};
-       my($type_decl) = typelist::mapType($d->{BASE_TYPE});
+       my($type_decl) = Parse::Pidl::Typelist::mapType($d->{BASE_TYPE});
        # put the bitmap elements in the constants array
        foreach my $e (@{$d->{ELEMENTS}}) {
                if ($e =~ /^(\w*)\s*(.*)\s*$/) {
@@ -582,7 +582,7 @@ sub EjsBitmapPush($$)
 sub EjsTypedefPush($)
 {
        my $d = shift;
-       return if (util::has_property($d, "noejs"));
+       return if (Parse::Pidl::Util::has_property($d, "noejs"));
        if ($d->{DATA}->{TYPE} eq 'STRUCT') {
                EjsStructPush($d->{NAME}, $d->{DATA});
        } elsif ($d->{DATA}->{TYPE} eq 'UNION') {
similarity index 89%
rename from source4/build/pidl/ejs_header.pm
rename to source4/build/pidl/Parse/Pidl/Samba/EJSHeader.pm
index af6b4d426da181b449325929162d526206988488..e2472545ef6aeac50d7c4ae36750ebb7a1c457f1 100644 (file)
@@ -3,10 +3,10 @@
 # Copyright tridge@samba.org 2005
 # released under the GNU GPL
 
-package EjsHeader;
+package Parse::Pidl::Samba::EJSHeader;
 
 use strict;
-use pidl::typelist;
+use Parse::Pidl::Typelist;
 
 my($res);
 
@@ -22,9 +22,9 @@ sub HeaderTypedefProto($)
        my $d = shift;
        my $name = $d->{NAME};
        
-       return unless util::has_property($d, "public");
+       return unless Parse::Pidl::Util::has_property($d, "public");
        
-       my $type_decl = typelist::mapType($name);
+       my $type_decl = Parse::Pidl::Typelist::mapType($name);
 
        pidl "NTSTATUS ejs_push_$d->{NAME}(struct ejs_rpc *, struct MprVar *, const char *, const $type_decl *);\n";
        pidl "NTSTATUS ejs_pull_$d->{NAME}(struct ejs_rpc *, struct MprVar *, const char *, $type_decl *);\n";
similarity index 98%
rename from source4/build/pidl/ndr_client.pm
rename to source4/build/pidl/Parse/Pidl/Samba/NDR/Client.pm
index 44a5bde4574640a314c589ff51deaf7a48f21bd1..126dbc3ba9c14f38205f0f69966c0b019f8fe67d 100644 (file)
@@ -3,7 +3,7 @@
 # Copyright tridge@samba.org 2003
 # released under the GNU GPL
 
-package NdrClient;
+package Parse::Pidl::Samba::NDR::Client;
 
 use strict;
 
similarity index 88%
rename from source4/build/pidl/ndr_header.pm
rename to source4/build/pidl/Parse/Pidl/Samba/NDR/Header.pm
index 0e0d4f57256f85c1c5492ee938cd7ebe2840ca75..d15e9bfbcbceb5b4ad725014402e41ae8338a2b3 100644 (file)
@@ -4,10 +4,11 @@
 # Copyright jelmer@samba.org 2005
 # released under the GNU GPL
 
-package NdrHeader;
+package Parse::Pidl::Samba::NDR::Header;
 
 use strict;
-use pidl::typelist;
+use Parse::Pidl::Typelist;
+use Parse::Pidl::Samba::NDR::Parser;
 
 my($res);
 my($tab_depth);
@@ -59,12 +60,12 @@ sub HeaderElement($)
        foreach my $l (@{$element->{LEVELS}}) 
        {
                if (($l->{TYPE} eq "POINTER")) {
-                       my $nl = Ndr::GetNextLevel($element, $l);
-                       $nl = Ndr::GetNextLevel($element, $nl) if ($nl->{TYPE} eq "SUBCONTEXT");
-                       next if ($nl->{TYPE} eq "DATA" and typelist::scalar_is_reference($nl->{DATA_TYPE}));
+                       my $nl = Parse::Pidl::NDR::GetNextLevel($element, $l);
+                       $nl = Parse::Pidl::NDR::GetNextLevel($element, $nl) if ($nl->{TYPE} eq "SUBCONTEXT");
+                       next if ($nl->{TYPE} eq "DATA" and Parse::Pidl::Typelist::scalar_is_reference($nl->{DATA_TYPE}));
                        $prefix .= "*";
                } elsif ($l->{TYPE} eq "ARRAY") {
-                       my $pl = Ndr::GetPrevLevel($element, $l);
+                       my $pl = Parse::Pidl::NDR::GetPrevLevel($element, $l);
                        next if ($pl and $pl->{TYPE} eq "POINTER");
 
                        if ($l->{IS_FIXED}) { 
@@ -77,7 +78,7 @@ sub HeaderElement($)
                }
        }
 
-       if (defined $element->{ARRAY_LEN}[0] && util::is_constant($element->{ARRAY_LEN}[0])) {
+       if (defined $element->{ARRAY_LEN}[0] && Parse::Pidl::Util::is_constant($element->{ARRAY_LEN}[0])) {
                pidl "[$element->{ARRAY_LEN}[0]]";
        }
        pidl ";";
@@ -119,7 +120,7 @@ sub HeaderEnum($$)
     my($enum,$name) = @_;
     my $first = 1;
 
-    if (not util::useUintEnums()) {
+    if (not Parse::Pidl::Util::useUintEnums()) {
        pidl "\nenum $name {\n";
        $tab_depth++;
        foreach my $e (@{$enum->{ELEMENTS}}) {
@@ -213,10 +214,10 @@ sub HeaderType($$$)
                return;
        }
 
-       if (util::has_property($e, "charset")) {
+       if (Parse::Pidl::Util::has_property($e, "charset")) {
                pidl "const char";
        } else {
-               pidl typelist::mapType($e->{TYPE});
+               pidl Parse::Pidl::Typelist::mapType($e->{TYPE});
        }
 }
 
@@ -235,25 +236,25 @@ sub HeaderTypedefProto($)
 {
     my($d) = shift;
 
-       my $tf = NdrParser::get_typefamily($d->{DATA}{TYPE});
+       my $tf = Parse::Pidl::Samba::NDR::Parser::get_typefamily($d->{DATA}{TYPE});
 
-    if (util::has_property($d, "gensize")) {
+    if (Parse::Pidl::Util::has_property($d, "gensize")) {
                my $size_args = $tf->{SIZE_FN_ARGS}->($d);
                pidl "size_t ndr_size_$d->{NAME}($size_args);\n";
     }
 
-    return unless util::has_property($d, "public");
+    return unless Parse::Pidl::Util::has_property($d, "public");
 
        my $pull_args = $tf->{PULL_FN_ARGS}->($d);
        my $push_args = $tf->{PUSH_FN_ARGS}->($d);
        my $print_args = $tf->{PRINT_FN_ARGS}->($d);
-       unless (util::has_property($d, "nopush")) {
+       unless (Parse::Pidl::Util::has_property($d, "nopush")) {
                pidl "NTSTATUS ndr_push_$d->{NAME}($push_args);\n";
        }
-       unless (util::has_property($d, "nopull")) {
+       unless (Parse::Pidl::Util::has_property($d, "nopull")) {
            pidl "NTSTATUS ndr_pull_$d->{NAME}($pull_args);\n";
        }
-    unless (util::has_property($d, "noprint")) {
+    unless (Parse::Pidl::Util::has_property($d, "noprint")) {
            pidl "void ndr_print_$d->{NAME}($print_args);\n";
     }
 }
@@ -277,7 +278,7 @@ sub HeaderFunctionInOut($$)
     my($fn,$prop) = @_;
 
     foreach my $e (@{$fn->{ELEMENTS}}) {
-           if (util::has_property($e, $prop)) {
+           if (Parse::Pidl::Util::has_property($e, $prop)) {
                    HeaderElement($e);
            }
     }
@@ -294,7 +295,7 @@ sub HeaderFunctionInOut_needed($$)
     }
 
     foreach my $e (@{$fn->{ELEMENTS}}) {
-           if (util::has_property($e, $prop)) {
+           if (Parse::Pidl::Util::has_property($e, $prop)) {
                    return 1;
            }
     }
@@ -336,7 +337,7 @@ sub HeaderFunction($)
            HeaderFunctionInOut($fn, "out");
            if ($fn->{RETURN_TYPE}) {
                    tabs();
-                   pidl typelist::mapType($fn->{RETURN_TYPE}) . " result;\n";
+                   pidl Parse::Pidl::Typelist::mapType($fn->{RETURN_TYPE}) . " result;\n";
            }
            $tab_depth--;
            tabs();
@@ -368,7 +369,7 @@ sub HeaderFnProto($$)
                pidl "struct rpc_request *dcerpc_$name\_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r);\n";
        }
 
-       return unless util::has_property($fn, "public");
+       return unless Parse::Pidl::Util::has_property($fn, "public");
 
        pidl "NTSTATUS ndr_push_$name(struct ndr_push *ndr, int flags, const struct $name *r);\n";
        pidl "NTSTATUS ndr_pull_$name(struct ndr_pull *ndr, int flags, struct $name *r);\n";
@@ -397,7 +398,7 @@ sub HeaderInterface($)
        if (defined $interface->{PROPERTIES}->{uuid}) {
                my $name = uc $interface->{NAME};
                pidl "#define DCERPC_$name\_UUID " . 
-               util::make_str($interface->{PROPERTIES}->{uuid}) . "\n";
+               Parse::Pidl::Util::make_str($interface->{PROPERTIES}->{uuid}) . "\n";
 
                if(!defined $interface->{PROPERTIES}->{version}) { $interface->{PROPERTIES}->{version} = "0.0"; }
                pidl "#define DCERPC_$name\_VERSION $interface->{PROPERTIES}->{version}\n";
similarity index 89%
rename from source4/build/pidl/ndr_parser.pm
rename to source4/build/pidl/Parse/Pidl/Samba/NDR/Parser.pm
index 7a95babf9030ae5a909da911f0a998f520b186c0..21e1449067ff0899bfec55e72131bc0fcf29812e 100644 (file)
@@ -5,11 +5,11 @@
 # Copyright jelmer@samba.org 2004-2005
 # released under the GNU GPL
 
-package NdrParser;
+package Parse::Pidl::Samba::NDR::Parser;
 
 use strict;
-use pidl::typelist;
-use pidl::ndr;
+use Parse::Pidl::Typelist;
+use Parse::Pidl::NDR;
 
 # list of known types
 my %typefamily;
@@ -35,7 +35,7 @@ sub append_prefix($$)
                                return get_value_of($var_name); 
                        }
                } elsif ($l->{TYPE} eq "DATA") {
-                       if (typelist::scalar_is_reference($l->{DATA_TYPE})) {
+                       if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
                                return get_value_of($var_name) unless ($pointers);
                        }
                }
@@ -50,9 +50,9 @@ sub is_scalar_array($$)
 
        return 0 if ($l->{TYPE} ne "ARRAY");
 
-       my $nl = Ndr::GetNextLevel($e,$l);
+       my $nl = Parse::Pidl::NDR::GetNextLevel($e,$l);
        return (($nl->{TYPE} eq "DATA") and 
-               (typelist::is_scalar($nl->{DATA_TYPE})));
+               (Parse::Pidl::Typelist::is_scalar($nl->{DATA_TYPE})));
 }
 
 sub get_pointer_to($)
@@ -130,7 +130,7 @@ sub fn_prefix($)
 {
        my $fn = shift;
 
-       return "" if (util::has_property($fn, "public"));
+       return "" if (Parse::Pidl::Util::has_property($fn, "public"));
        return "static ";
 }
 
@@ -139,7 +139,7 @@ sub fn_prefix($)
 sub start_flags($)
 {
        my $e = shift;
-       my $flags = util::has_property($e, "flag");
+       my $flags = Parse::Pidl::Util::has_property($e, "flag");
        if (defined $flags) {
                pidl "{";
                indent;
@@ -153,7 +153,7 @@ sub start_flags($)
 sub end_flags($)
 {
        my $e = shift;
-       my $flags = util::has_property($e, "flag");
+       my $flags = Parse::Pidl::Util::has_property($e, "flag");
        if (defined $flags) {
                pidl "ndr->flags = _flags_save_$e->{TYPE};";
                deindent;
@@ -221,8 +221,8 @@ sub ParseArrayPushHeader($$$$$)
        if ($l->{IS_ZERO_TERMINATED}) {
                $size = $length = "ndr_string_length($var_name, sizeof(*$var_name))";
        } else {
-               $size = util::ParseExpr($l->{SIZE_IS}, $env);
-               $length = util::ParseExpr($l->{LENGTH_IS}, $env);
+               $size = Parse::Pidl::Util::ParseExpr($l->{SIZE_IS}, $env);
+               $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env);
        }
 
        if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) {
@@ -255,7 +255,7 @@ sub ParseArrayPullHeader($$$$$)
        } elsif ($l->{IS_ZERO_TERMINATED}) { # Noheader arrays
                $length = $size = "ndr_get_string_size($ndr, sizeof(*$var_name))";
        } else {
-               $length = $size = util::ParseExpr($l->{SIZE_IS}, $env);
+               $length = $size = Parse::Pidl::Util::ParseExpr($l->{SIZE_IS}, $env);
        }
 
        if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) {
@@ -279,13 +279,13 @@ sub ParseArrayPullHeader($$$$$)
        }
 
        if ($l->{IS_CONFORMANT} and not $l->{IS_ZERO_TERMINATED}) {
-               my $size = util::ParseExpr($l->{SIZE_IS}, $env);
+               my $size = Parse::Pidl::Util::ParseExpr($l->{SIZE_IS}, $env);
                check_null_pointer($size);
                pidl "NDR_CHECK(ndr_check_array_size(ndr, (void*)" . get_pointer_to($var_name) . ", $size));";
        }
 
        if ($l->{IS_VARYING} and not $l->{IS_ZERO_TERMINATED}) {
-               my $length = util::ParseExpr($l->{LENGTH_IS}, $env);
+               my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env);
                check_null_pointer($length);
                pidl "NDR_CHECK(ndr_check_array_length(ndr, (void*)" . get_pointer_to($var_name) . ", $length));";
        }
@@ -312,7 +312,7 @@ sub compression_clen($$$)
        my $compression = $l->{COMPRESSION};
        my ($alg, $clen, $dlen) = split(/ /, $compression);
 
-       return util::ParseExpr($clen, $env);
+       return Parse::Pidl::Util::ParseExpr($clen, $env);
 }
 
 sub compression_dlen($$$)
@@ -321,7 +321,7 @@ sub compression_dlen($$$)
        my $compression = $l->{COMPRESSION};
        my ($alg, $clen, $dlen) = split(/ /, $compression);
 
-       return util::ParseExpr($dlen, $env);
+       return Parse::Pidl::Util::ParseExpr($dlen, $env);
 }
 
 sub ParseCompressionPushStart($$$)
@@ -389,7 +389,7 @@ sub ParseObfuscationPushStart($$)
 sub ParseObfuscationPushEnd($$)
 {
        my ($e,$ndr) = @_;
-       my $obfuscation = util::has_property($e, "obfuscation");
+       my $obfuscation = Parse::Pidl::Util::has_property($e, "obfuscation");
 
        pidl "NDR_CHECK(ndr_push_obfuscation($ndr, $obfuscation));";
 }
@@ -397,7 +397,7 @@ sub ParseObfuscationPushEnd($$)
 sub ParseObfuscationPullStart($$)
 {
        my ($e,$ndr) = @_;
-       my $obfuscation = util::has_property($e, "obfuscation");
+       my $obfuscation = Parse::Pidl::Util::has_property($e, "obfuscation");
 
        pidl "NDR_CHECK(ndr_pull_obfuscation($ndr, $obfuscation));";
 
@@ -440,7 +440,7 @@ sub ParseSubcontextPushEnd($$$$)
 {
        my ($e,$l,$ndr_flags,$env) = @_;
        my $ndr = "_ndr_$e->{NAME}";
-       my $subcontext_size = util::ParseExpr($l->{SUBCONTEXT_SIZE},$env);
+       my $subcontext_size = Parse::Pidl::Util::ParseExpr($l->{SUBCONTEXT_SIZE},$env);
 
        if (defined $l->{COMPRESSION}) {
                ParseCompressionPushEnd($e, $l, $ndr);
@@ -460,7 +460,7 @@ sub ParseSubcontextPullStart($$$$$$)
 {
        my ($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_;
        my $retndr = "_ndr_$e->{NAME}";
-       my $subcontext_size = util::ParseExpr($l->{SUBCONTEXT_SIZE},$env);
+       my $subcontext_size = Parse::Pidl::Util::ParseExpr($l->{SUBCONTEXT_SIZE},$env);
 
        pidl "{";
        indent;
@@ -494,7 +494,7 @@ sub ParseSubcontextPullEnd($$$)
 
        my $advance;
        if (defined($l->{SUBCONTEXT_SIZE}) and ($l->{SUBCONTEXT_SIZE} ne "-1")) {
-               $advance = util::ParseExpr($l->{SUBCONTEXT_SIZE},$env);
+               $advance = Parse::Pidl::Util::ParseExpr($l->{SUBCONTEXT_SIZE},$env);
        } elsif ($l->{HEADER_SIZE}) {
                $advance = "$ndr->data_size";
        } else {
@@ -514,7 +514,7 @@ sub ParseElementPushLevel
        if (defined($ndr_flags)) {
                if ($l->{TYPE} eq "SUBCONTEXT") {
                        $ndr = ParseSubcontextPushStart($e, $l, $ndr, $var_name, $ndr_flags);
-                       ParseElementPushLevel($e, Ndr::GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 1);
+                       ParseElementPushLevel($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 1);
                        ParseSubcontextPushEnd($e, $l, $ndr_flags, $env);
                } elsif ($l->{TYPE} eq "POINTER") {
                        ParsePtrPush($e, $l, $var_name);
@@ -526,10 +526,10 @@ sub ParseElementPushLevel
                                        $var_name = get_pointer_to($var_name);
                                }
 
-                               my $nl = Ndr::GetNextLevel($e, $l);
+                               my $nl = Parse::Pidl::NDR::GetNextLevel($e, $l);
 
-                               if (util::has_property($e, "charset")) {
-                                       pidl "NDR_CHECK(ndr_push_charset($ndr, $ndr_flags, $var_name, $length, sizeof(" . typelist::mapType($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));";
+                               if (Parse::Pidl::Util::has_property($e, "charset")) {
+                                       pidl "NDR_CHECK(ndr_push_charset($ndr, $ndr_flags, $var_name, $length, sizeof(" . Parse::Pidl::Typelist::mapType($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));";
                                } else {
                                        pidl "NDR_CHECK(ndr_push_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));";
                                } 
@@ -551,14 +551,14 @@ sub ParseElementPushLevel
                        }
                }
                $var_name = get_value_of($var_name);
-               ParseElementPushLevel($e, Ndr::GetNextLevel($e, $l), $ndr, $var_name, $env, $primitives, $deferred);
+               ParseElementPushLevel($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $ndr, $var_name, $env, $primitives, $deferred);
 
                if ($l->{POINTER_TYPE} ne "ref") {
                        deindent;
                        pidl "}";
                }
        } elsif ($l->{TYPE} eq "ARRAY" and not is_scalar_array($e,$l)) {
-               my $length = util::ParseExpr($l->{LENGTH_IS}, $env);
+               my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env);
                my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}";
 
                $var_name = $var_name . "[$counter]";
@@ -570,20 +570,20 @@ sub ParseElementPushLevel
                if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) {
                        pidl "for ($counter = 0; $counter < $length; $counter++) {";
                        indent;
-                       ParseElementPushLevel($e, Ndr::GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 0);
+                       ParseElementPushLevel($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 0);
                        deindent;
                        pidl "}";
                }
 
-               if ($deferred and Ndr::ContainsDeferred($e, $l)) {
+               if ($deferred and Parse::Pidl::NDR::ContainsDeferred($e, $l)) {
                        pidl "for ($counter = 0; $counter < $length; $counter++) {";
                        indent;
-                       ParseElementPushLevel($e, Ndr::GetNextLevel($e, $l), $ndr, $var_name, $env, 0, 1);
+                       ParseElementPushLevel($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $ndr, $var_name, $env, 0, 1);
                        deindent;
                        pidl "}";
                }       
        } elsif ($l->{TYPE} eq "SWITCH") {
-               ParseElementPushLevel($e, Ndr::GetNextLevel($e, $l), $ndr, $var_name, $env, $primitives, $deferred);
+               ParseElementPushLevel($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $ndr, $var_name, $env, $primitives, $deferred);
        }
 }
 
@@ -598,12 +598,12 @@ sub ParseElementPush($$$$$$)
 
        $var_name = append_prefix($e, $var_name);
 
-       return unless $primitives or ($deferred and Ndr::ContainsDeferred($e, $e->{LEVELS}[0]));
+       return unless $primitives or ($deferred and Parse::Pidl::NDR::ContainsDeferred($e, $e->{LEVELS}[0]));
 
        start_flags($e);
 
-       if (my $value = util::has_property($e, "value")) {
-               $var_name = util::ParseExpr($value, $env);
+       if (my $value = Parse::Pidl::Util::has_property($e, "value")) {
+               $var_name = Parse::Pidl::Util::ParseExpr($value, $env);
        }
 
        ParseElementPushLevel($e, $e->{LEVELS}[0], $ndr, $var_name, $env, $primitives, $deferred);
@@ -641,10 +641,10 @@ sub ParseElementPrint($$$)
        my($e,$var_name,$env) = @_;
 
        $var_name = append_prefix($e, $var_name);
-       return if (util::has_property($e, "noprint"));
+       return if (Parse::Pidl::Util::has_property($e, "noprint"));
 
-       if (my $value = util::has_property($e, "value")) {
-               $var_name = "(ndr->flags & LIBNDR_PRINT_SET_VALUES)?" . util::ParseExpr($value,$env) . ":$var_name";
+       if (my $value = Parse::Pidl::Util::has_property($e, "value")) {
+               $var_name = "(ndr->flags & LIBNDR_PRINT_SET_VALUES)?" . Parse::Pidl::Util::ParseExpr($value,$env) . ":$var_name";
        }
 
        foreach my $l (@{$e->{LEVELS}}) {
@@ -666,14 +666,14 @@ sub ParseElementPrint($$$)
                        if ($l->{IS_ZERO_TERMINATED}) {
                                $length = "ndr_string_length($var_name, sizeof(*$var_name))";
                        } else {
-                               $length = util::ParseExpr($l->{LENGTH_IS}, $env);
+                               $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env);
                        }
 
                        if (is_scalar_array($e, $l)) {
-                               if (util::has_property($e, "charset")) {
+                               if (Parse::Pidl::Util::has_property($e, "charset")) {
                                        pidl "ndr_print_string(ndr, \"$e->{NAME}\", $var_name);";
                                } else {
-                                       my $nl = Ndr::GetNextLevel($e, $l);
+                                       my $nl = Parse::Pidl::NDR::GetNextLevel($e, $l);
                                        pidl "ndr_print_array_$nl->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name, $length);";
                                } 
                                last;
@@ -695,12 +695,12 @@ sub ParseElementPrint($$$)
                        if ($l->{IS_VARYING} or $l->{IS_CONFORMANT}){ $var_name = get_pointer_to($var_name); }
 
                } elsif ($l->{TYPE} eq "DATA") {
-                       if (not typelist::is_scalar($l->{DATA_TYPE}) or typelist::scalar_is_reference($l->{DATA_TYPE})) {
+                       if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
                                $var_name = get_pointer_to($var_name);
                        }
                        pidl "ndr_print_$l->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name);";
                } elsif ($l->{TYPE} eq "SWITCH") {
-                       my $switch_var = util::ParseExpr($l->{SWITCH_IS}, $env);
+                       my $switch_var = Parse::Pidl::Util::ParseExpr($l->{SWITCH_IS}, $env);
                        check_null_pointer_void($switch_var);
                        pidl "ndr_print_set_switch_value(ndr, " . get_pointer_to($var_name) . ", $switch_var);";
                } 
@@ -729,7 +729,7 @@ sub ParseElementPrint($$$)
 sub ParseSwitchPull($$$$$$)
 {
        my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_;
-       my $switch_var = util::ParseExpr($l->{SWITCH_IS}, $env);
+       my $switch_var = Parse::Pidl::Util::ParseExpr($l->{SWITCH_IS}, $env);
 
        check_null_pointer($switch_var);
 
@@ -742,7 +742,7 @@ sub ParseSwitchPull($$$$$$)
 sub ParseSwitchPush($$$$$$)
 {
        my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_;
-       my $switch_var = util::ParseExpr($l->{SWITCH_IS}, $env);
+       my $switch_var = Parse::Pidl::Util::ParseExpr($l->{SWITCH_IS}, $env);
 
        check_null_pointer($switch_var);
        $var_name = get_pointer_to($var_name);
@@ -753,7 +753,7 @@ sub ParseDataPull($$$$$)
 {
        my ($e,$l,$ndr,$var_name,$ndr_flags) = @_;
 
-       if (typelist::scalar_is_reference($l->{DATA_TYPE})) {
+       if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
                $var_name = get_pointer_to($var_name);
        }
 
@@ -761,7 +761,7 @@ sub ParseDataPull($$$$$)
 
        pidl "NDR_CHECK(ndr_pull_$l->{DATA_TYPE}($ndr, $ndr_flags, $var_name));";
 
-       if (my $range = util::has_property($e, "range")) {
+       if (my $range = Parse::Pidl::Util::has_property($e, "range")) {
                $var_name = get_value_of($var_name);
                my ($low, $high) = split(/ /, $range, 2);
                pidl "if ($var_name < $low || $var_name > $high) {";
@@ -775,7 +775,7 @@ sub ParseDataPush($$$$$)
        my ($e,$l,$ndr,$var_name,$ndr_flags) = @_;
 
        # strings are passed by value rather then reference
-       if (not typelist::is_scalar($l->{DATA_TYPE}) or typelist::scalar_is_reference($l->{DATA_TYPE})) {
+       if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
                $var_name = get_pointer_to($var_name);
        }
 
@@ -817,7 +817,7 @@ sub ParseElementPullLevel
        if (defined($ndr_flags)) {
                if ($l->{TYPE} eq "SUBCONTEXT") {
                        ($ndr,$var_name) = ParseSubcontextPullStart($e, $l, $ndr, $var_name, $ndr_flags, $env);
-                       ParseElementPullLevel($e,Ndr::GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 1);
+                       ParseElementPullLevel($e,Parse::Pidl::NDR::GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 1);
                        ParseSubcontextPullEnd($e, $l, $env);
                } elsif ($l->{TYPE} eq "ARRAY") {
                        my $length = ParseArrayPullHeader($e, $l, $ndr, $var_name, $env); 
@@ -828,10 +828,10 @@ sub ParseElementPullLevel
                                if ($l->{IS_VARYING} or $l->{IS_CONFORMANT}) {
                                        $var_name = get_pointer_to($var_name);
                                }
-                               my $nl = Ndr::GetNextLevel($e, $l);
+                               my $nl = Parse::Pidl::NDR::GetNextLevel($e, $l);
 
-                               if (util::has_property($e, "charset")) {
-                                       pidl "NDR_CHECK(ndr_pull_charset($ndr, $ndr_flags, ".get_pointer_to($var_name).", $length, sizeof(" . typelist::mapType($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));";
+                               if (Parse::Pidl::Util::has_property($e, "charset")) {
+                                       pidl "NDR_CHECK(ndr_pull_charset($ndr, $ndr_flags, ".get_pointer_to($var_name).", $length, sizeof(" . Parse::Pidl::Typelist::mapType($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));";
                                } else {
                                        pidl "NDR_CHECK(ndr_pull_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));";
                                        if ($l->{IS_ZERO_TERMINATED}) {
@@ -864,7 +864,7 @@ sub ParseElementPullLevel
                }
 
                $var_name = get_value_of($var_name);
-               ParseElementPullLevel($e,Ndr::GetNextLevel($e,$l), $ndr, $var_name, $env, $primitives, $deferred);
+               ParseElementPullLevel($e,Parse::Pidl::NDR::GetNextLevel($e,$l), $ndr, $var_name, $env, $primitives, $deferred);
 
                if ($l->{POINTER_TYPE} ne "ref") {
                        if ($l->{POINTER_TYPE} eq "relative") {
@@ -874,7 +874,7 @@ sub ParseElementPullLevel
                        pidl "}";
                }
        } elsif ($l->{TYPE} eq "ARRAY" and not is_scalar_array($e,$l)) {
-               my $length = util::ParseExpr($l->{LENGTH_IS}, $env);
+               my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env);
                my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}";
 
                $var_name = $var_name . "[$counter]";
@@ -885,7 +885,7 @@ sub ParseElementPullLevel
                if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) {
                        pidl "for ($counter = 0; $counter < $length; $counter++) {";
                        indent;
-                       ParseElementPullLevel($e,Ndr::GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 0);
+                       ParseElementPullLevel($e,Parse::Pidl::NDR::GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 0);
                        deindent;
                        pidl "}";
 
@@ -895,15 +895,15 @@ sub ParseElementPullLevel
                        }
                }
 
-               if ($deferred and Ndr::ContainsDeferred($e, $l)) {
+               if ($deferred and Parse::Pidl::NDR::ContainsDeferred($e, $l)) {
                        pidl "for ($counter = 0; $counter < $length; $counter++) {";
                        indent;
-                       ParseElementPullLevel($e,Ndr::GetNextLevel($e,$l), $ndr, $var_name, $env, 0, 1);
+                       ParseElementPullLevel($e,Parse::Pidl::NDR::GetNextLevel($e,$l), $ndr, $var_name, $env, 0, 1);
                        deindent;
                        pidl "}";
                }
        } elsif ($l->{TYPE} eq "SWITCH") {
-               ParseElementPullLevel($e,Ndr::GetNextLevel($e,$l), $ndr, $var_name, $env, $primitives, $deferred);
+               ParseElementPullLevel($e,Parse::Pidl::NDR::GetNextLevel($e,$l), $ndr, $var_name, $env, $primitives, $deferred);
        }
 }
 
@@ -917,7 +917,7 @@ sub ParseElementPull($$$$$$)
 
        $var_name = append_prefix($e, $var_name);
 
-       return unless $primitives or ($deferred and Ndr::ContainsDeferred($e, $e->{LEVELS}[0]));
+       return unless $primitives or ($deferred and Parse::Pidl::NDR::ContainsDeferred($e, $e->{LEVELS}[0]));
 
        start_flags($e);
 
@@ -932,7 +932,7 @@ sub ParsePtrPull($$$$)
 {
        my($e,$l,$ndr,$var_name) = @_;
 
-       my $nl = Ndr::GetNextLevel($e, $l);
+       my $nl = Parse::Pidl::NDR::GetNextLevel($e, $l);
        my $next_is_array = ($nl->{TYPE} eq "ARRAY");
        my $next_is_string = (($nl->{TYPE} eq "DATA") and 
                                                 ($nl->{DATA_TYPE} eq "string"));
@@ -1007,7 +1007,7 @@ sub ParseStructPush($$)
 
                if (defined($e->{LEVELS}[0]) and 
                        $e->{LEVELS}[0]->{TYPE} eq "ARRAY") {
-                       my $size = util::ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env);
+                       my $size = Parse::Pidl::Util::ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env);
 
                        pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $size));";
                } else {
@@ -1070,7 +1070,7 @@ sub ParseEnumPull($$)
 {
        my($enum,$name) = @_;
        my($type_fn) = $enum->{BASE_TYPE};
-       my($type_v_decl) = typelist::mapType($type_fn);
+       my($type_v_decl) = Parse::Pidl::Typelist::mapType($type_fn);
 
        pidl "$type_v_decl v;";
        start_flags($enum);
@@ -1158,7 +1158,7 @@ sub ParseBitmapPull($$)
 {
        my($bitmap,$name) = @_;
        my $type_fn = $bitmap->{BASE_TYPE};
-       my($type_decl) = typelist::mapType($bitmap->{BASE_TYPE});
+       my($type_decl) = Parse::Pidl::Typelist::mapType($bitmap->{BASE_TYPE});
 
        pidl "$type_decl v;";
        start_flags($bitmap);
@@ -1173,7 +1173,7 @@ sub ParseBitmapPull($$)
 sub ParseBitmapPrintElement($$$)
 {
        my($e,$bitmap,$name) = @_;
-       my($type_decl) = typelist::mapType($bitmap->{BASE_TYPE});
+       my($type_decl) = Parse::Pidl::Typelist::mapType($bitmap->{BASE_TYPE});
        my($type_fn) = $bitmap->{BASE_TYPE};
        my($flag);
 
@@ -1191,7 +1191,7 @@ sub ParseBitmapPrintElement($$$)
 sub ParseBitmapPrint($$)
 {
        my($bitmap,$name) = @_;
-       my($type_decl) = typelist::mapType($bitmap->{TYPE});
+       my($type_decl) = Parse::Pidl::Typelist::mapType($bitmap->{TYPE});
        my($type_fn) = $bitmap->{BASE_TYPE};
 
        start_flags($bitmap);
@@ -1210,21 +1210,21 @@ sub ParseBitmapPrint($$)
 sub ArgsBitmapPush($)
 {
        my $e = shift;
-       my $type_decl = typelist::mapType($e->{DATA}->{BASE_TYPE});
+       my $type_decl = Parse::Pidl::Typelist::mapType($e->{DATA}->{BASE_TYPE});
        return "struct ndr_push *ndr, int ndr_flags, $type_decl r";
 }
 
 sub ArgsBitmapPrint($)
 {
        my $e = shift;
-       my $type_decl = typelist::mapType($e->{DATA}->{BASE_TYPE});
+       my $type_decl = Parse::Pidl::Typelist::mapType($e->{DATA}->{BASE_TYPE});
        return "struct ndr_print *ndr, const char *name, $type_decl r";
 }
 
 sub ArgsBitmapPull($)
 {
        my $e = shift;
-       my $type_decl = typelist::mapType($e->{DATA}->{BASE_TYPE});
+       my $type_decl = Parse::Pidl::Typelist::mapType($e->{DATA}->{BASE_TYPE});
        return "struct ndr_pull *ndr, int ndr_flags, $type_decl *r";
 }
 
@@ -1356,7 +1356,7 @@ sub ParseStructNdrSize($)
        my $t = shift;
        my $sizevar;
 
-       if (my $flags = util::has_property($t, "flag")) {
+       if (my $flags = Parse::Pidl::Util::has_property($t, "flag")) {
                pidl "flags |= $flags;";
        }
        pidl "return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});";
@@ -1404,7 +1404,7 @@ sub ParseUnionNdrSize($)
        my $t = shift;
        my $sizevar;
 
-       if (my $flags = util::has_property($t, "flag")) {
+       if (my $flags = Parse::Pidl::Util::has_property($t, "flag")) {
                pidl "flags |= $flags;";
        }
 
@@ -1550,10 +1550,10 @@ sub ParseUnionPull($$)
        pidl "uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);" if defined($e->{PROPERTIES}{relative_base});
        pidl "int level;";
        if (defined($switch_type)) {
-               if (typelist::typeIs($switch_type, "ENUM")) {
-                       $switch_type = typelist::enum_type_fn(typelist::getType($switch_type));
+               if (Parse::Pidl::Typelist::typeIs($switch_type, "ENUM")) {
+                       $switch_type = Parse::Pidl::Typelist::enum_type_fn(Parse::Pidl::Typelist::getType($switch_type));
                }
-               pidl typelist::mapType($switch_type) . " _level;";
+               pidl Parse::Pidl::Typelist::mapType($switch_type) . " _level;";
        }
 
        start_flags($e);
@@ -1748,7 +1748,7 @@ sub ParseFunctionPrint($)
 {
        my($fn) = shift;
 
-       return if util::has_property($fn, "noprint");
+       return if Parse::Pidl::Util::has_property($fn, "noprint");
 
        pidl "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r)";
        pidl "{";
@@ -1811,7 +1811,7 @@ sub ParseFunctionPush($)
 { 
        my($fn) = shift;
 
-       return if util::has_property($fn, "nopush");
+       return if Parse::Pidl::Util::has_property($fn, "nopush");
 
        pidl fn_prefix($fn) . "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, const struct $fn->{NAME} *r)";
        pidl "{";
@@ -1861,12 +1861,12 @@ sub AllocateArrayLevel($$$$$)
 {
        my ($e,$l,$ndr,$env,$size) = @_;
 
-       return if (util::has_property($e, "charset"));
+       return if (Parse::Pidl::Util::has_property($e, "charset"));
 
-       my $var = util::ParseExpr($e->{NAME}, $env);
+       my $var = Parse::Pidl::Util::ParseExpr($e->{NAME}, $env);
 
        check_null_pointer($size);
-       my $pl = Ndr::GetPrevLevel($e, $l);
+       my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l);
        if (defined($pl) and 
            $pl->{TYPE} eq "POINTER" and 
            $pl->{POINTER_TYPE} eq "ref"
@@ -1890,7 +1890,7 @@ sub ParseFunctionPull($)
 { 
        my($fn) = shift;
 
-       return if util::has_property($fn, "nopull");
+       return if Parse::Pidl::Util::has_property($fn, "nopull");
 
        # pull function args
        pidl fn_prefix($fn) . "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)";
@@ -1937,7 +1937,7 @@ sub ParseFunctionPull($)
                        and   $e->{LEVELS}[1]->{IS_ZERO_TERMINATED});
 
                if ($e->{LEVELS}[1]->{TYPE} eq "ARRAY") {
-                       my $size = util::ParseExpr($e->{LEVELS}[1]->{SIZE_IS}, $env);
+                       my $size = Parse::Pidl::Util::ParseExpr($e->{LEVELS}[1]->{SIZE_IS}, $env);
                        check_null_pointer($size);
                        
                        pidl "NDR_ALLOC_N(ndr, r->out.$e->{NAME}, $size);";
@@ -2185,14 +2185,14 @@ sub NeededFunction($$)
 sub NeededTypedef($$)
 {
        my ($t,$needed) = @_;
-       if (util::has_property($t, "public")) {
-               $needed->{"pull_$t->{NAME}"} = not util::has_property($t, "nopull");
-               $needed->{"push_$t->{NAME}"} = not util::has_property($t, "nopush");
-               $needed->{"print_$t->{NAME}"} = not util::has_property($t, "noprint");
+       if (Parse::Pidl::Util::has_property($t, "public")) {
+               $needed->{"pull_$t->{NAME}"} = not Parse::Pidl::Util::has_property($t, "nopull");
+               $needed->{"push_$t->{NAME}"} = not Parse::Pidl::Util::has_property($t, "nopush");
+               $needed->{"print_$t->{NAME}"} = not Parse::Pidl::Util::has_property($t, "noprint");
        }
 
        if ($t->{DATA}->{TYPE} eq "STRUCT" or $t->{DATA}->{TYPE} eq "UNION") {
-               if (util::has_property($t, "gensize")) {
+               if (Parse::Pidl::Util::has_property($t, "gensize")) {
                        $needed->{"ndr_size_$t->{NAME}"} = 1;
                }
 
similarity index 98%
rename from source4/build/pidl/server.pm
rename to source4/build/pidl/Parse/Pidl/Samba/NDR/Server.pm
index e52ce517226ff9a9cb8912a2aa74690040948f4a..1d63ea0cd1180e4fc8ba405a876318c3992ff953 100644 (file)
@@ -4,7 +4,7 @@
 # Copyright metze@samba.org 2004
 # released under the GNU GPL
 
-package NdrServer;
+package Parse::Pidl::Samba::NDR::Server;
 
 use strict;
 
@@ -73,7 +73,7 @@ sub Boilerplate_Iface($)
        my($interface) = shift;
        my $name = $interface->{NAME}; 
        my $uname = uc $name;
-       my $uuid = util::make_str($interface->{PROPERTIES}->{uuid});
+       my $uuid = Parse::Pidl::Util::make_str($interface->{PROPERTIES}->{uuid});
        my $if_version = $interface->{PROPERTIES}->{version};
 
        pidl "
similarity index 97%
rename from source4/build/pidl/swig.pm
rename to source4/build/pidl/Parse/Pidl/Samba/SWIG.pm
index c4b67829031194f852a557195ce61c40c3dee4f9..409095804f6796a450b22d7143d3540704246ee4 100644 (file)
@@ -3,7 +3,7 @@
 # Copyright tpot@samba.org 2004,2005
 # released under the GNU GPL
 
-package IdlSwig;
+package Parse::Pidl::Samba::SWIG;
 
 use strict;
 
similarity index 98%
rename from source4/build/pidl/template.pm
rename to source4/build/pidl/Parse/Pidl/Samba/Template.pm
index d2f945cf2b15960b0468cfb1ca3ce0939469303d..eb71b6d7076ebcf835ea965c528e7e6beb93e36d 100644 (file)
@@ -3,7 +3,7 @@
 # Copyright tridge@samba.org 2003
 # released under the GNU GPL
 
-package IdlTemplate;
+package Parse::Pidl::Samba::Template;
 
 use strict;
 
similarity index 99%
rename from source4/build/pidl/test.pm
rename to source4/build/pidl/Parse/Pidl/Test.pm
index ba102aab128b95a8654a2f03744759b1f42db9bd..88403f31d47e701a288b1585fcbc64c65e8016a1 100644 (file)
@@ -2,7 +2,7 @@
 # (C) 2005 Jelmer Vernooij <jelmer@samba.org>
 # Published under the GNU General Public License
 
-package Test;
+package Parse::Pidl::Test;
 
 use strict;
 use pidl::util;
similarity index 92%
rename from source4/build/pidl/typelist.pm
rename to source4/build/pidl/Parse/Pidl/Typelist.pm
index 7c54587ac750cbc1db5c51cb85ba932b2850da1e..d134cc6992ffe84d235b51aa0b1abfb27bc14e2d 100644 (file)
@@ -3,8 +3,9 @@
 # Copyright jelmer@samba.org 2005
 # released under the GNU GPL
 
-package typelist;
+package Parse::Pidl::Typelist;
 
+use Parse::Pidl::Util;
 use strict;
 
 my %typedefs = ();
@@ -252,9 +253,9 @@ sub RegisterAliases()
 sub enum_type_fn($)
 {
        my $enum = shift;
-       if (util::has_property($enum->{PARENT}, "enum8bit")) {
+       if (Parse::Pidl::Util::has_property($enum->{PARENT}, "enum8bit")) {
                return "uint8";
-       } elsif (util::has_property($enum->{PARENT}, "v1_enum")) {
+       } elsif (Parse::Pidl::Util::has_property($enum->{PARENT}, "v1_enum")) {
                return "uint32";
        }
        return "uint16";
@@ -264,11 +265,11 @@ sub bitmap_type_fn($)
 {
        my $bitmap = shift;
 
-       if (util::has_property($bitmap, "bitmap8bit")) {
+       if (Parse::Pidl::Util::has_property($bitmap, "bitmap8bit")) {
                return "uint8";
-       } elsif (util::has_property($bitmap, "bitmap16bit")) {
+       } elsif (Parse::Pidl::Util::has_property($bitmap, "bitmap16bit")) {
                return "uint16";
-       } elsif (util::has_property($bitmap, "bitmap64bit")) {
+       } elsif (Parse::Pidl::Util::has_property($bitmap, "bitmap64bit")) {
                return "hyper";
        }
        return "uint32";
@@ -309,7 +310,7 @@ sub LoadIdl($)
                        NAME => $x->{NAME},
                        TYPE => "TYPEDEF",
                        DATA => $x
-                       }) if (util::has_property($x, "object"));
+                       }) if (Parse::Pidl::Util::has_property($x, "object"));
 
                foreach my $y (@{$x->{DATA}}) {
                        addType($y) if (
similarity index 90%
rename from source4/build/pidl/util.pm
rename to source4/build/pidl/Parse/Pidl/Util.pm
index 1420e21f41c8c1af7adf36de86e274a8fa61a689..41fde63c257e5e417ea122c028e48920fc925e4c 100644 (file)
@@ -2,17 +2,7 @@
 # utility functions to support pidl
 # Copyright tridge@samba.org 2000
 # released under the GNU GPL
-package util;
-
-#####################################################################
-# load a data structure from a file (as saved with SaveStructure)
-sub LoadStructure($)
-{
-       my $f = shift;
-       my $contents = FileLoad($f);
-       defined $contents || return undef;
-       return eval "$contents";
-}
+package Parse::Pidl::Util;
 
 use strict;
 
@@ -142,15 +132,6 @@ sub MyDumper($)
        return Data::Dumper::Dumper($s);
 }
 
-#####################################################################
-# save a data structure into a file
-sub SaveStructure($$)
-{
-       my($filename) = shift;
-       my($v) = shift;
-       FileSave($filename, MyDumper($v));
-}
-
 #####################################################################
 # see if a pidl property list contains a given property
 sub has_property($$)
similarity index 82%
rename from source4/build/pidl/validator.pm
rename to source4/build/pidl/Parse/Pidl/Validator.pm
index 37dc916ffd085b7cb90812df30226090ad4db1b0..53015bc575f4703d2dd33e079b31d78727941696 100644 (file)
@@ -3,7 +3,7 @@
 # Copyright tridge@samba.org 2003
 # released under the GNU GPL
 
-package IdlValidator;
+package Parse::Pidl::Validator;
 
 use strict;
 
@@ -153,14 +153,14 @@ sub ValidProperties($$)
 sub mapToScalar($)
 {
        my $t = shift;
-       my $ti = typelist::getType($t);
+       my $ti = Parse::Pidl::Typelist::getType($t);
 
        if (not defined ($ti)) {
                return undef;
        } elsif ($ti->{DATA}->{TYPE} eq "ENUM") {
-               return typelist::enum_type_fn($ti->{DATA});
+               return Parse::Pidl::Typelist::enum_type_fn($ti->{DATA});
        } elsif ($ti->{DATA}->{TYPE} eq "BITMAP") {
-               return typelist::enum_type_fn($ti->{DATA});
+               return Parse::Pidl::Typelist::enum_type_fn($ti->{DATA});
        } elsif ($ti->{DATA}->{TYPE} eq "SCALAR") {
                return $t;
        }
@@ -176,21 +176,21 @@ sub ValidElement($)
 
        ValidProperties($e,"ELEMENT");
 
-       if (util::has_property($e, "ptr")) {
+       if (Parse::Pidl::Util::has_property($e, "ptr")) {
                fatal($e, el_name($e) . " : pidl does not support full NDR pointers yet\n");
        }
 
        # Check whether switches are used correctly.
-       if (my $switch = util::has_property($e, "switch_is")) {
+       if (my $switch = Parse::Pidl::Util::has_property($e, "switch_is")) {
                my $e2 = find_sibling($e, $switch);
-               my $type = typelist::getType($e->{TYPE});
+               my $type = Parse::Pidl::Typelist::getType($e->{TYPE});
 
                if (defined($type) and $type->{DATA}->{TYPE} ne "UNION") {
                        fatal($e, el_name($e) . ": switch_is() used on non-union type $e->{TYPE} which is a $type->{DATA}->{TYPE}");
                }
 
-               if (!util::has_property($type, "nodiscriminant") and defined($e2)) {
-                       my $discriminator_type = util::has_property($type, "switch_type");
+               if (!Parse::Pidl::Util::has_property($type, "nodiscriminant") and defined($e2)) {
+                       my $discriminator_type = Parse::Pidl::Util::has_property($type, "switch_type");
                        $discriminator_type = "uint32" unless defined ($discriminator_type);
 
                        my $t1 = mapToScalar($discriminator_type);
@@ -210,24 +210,24 @@ sub ValidElement($)
                }
        }
 
-       if (defined (util::has_property($e, "subcontext_size")) and not defined(util::has_property($e, "subcontext"))) {
+       if (defined (Parse::Pidl::Util::has_property($e, "subcontext_size")) and not defined(Parse::Pidl::Util::has_property($e, "subcontext"))) {
                fatal($e, el_name($e) . " : subcontext_size() on non-subcontext element");
        }
 
-       if (defined (util::has_property($e, "compression")) and not defined(util::has_property($e, "subcontext"))) {
+       if (defined (Parse::Pidl::Util::has_property($e, "compression")) and not defined(Parse::Pidl::Util::has_property($e, "subcontext"))) {
                fatal($e, el_name($e) . " : compression() on non-subcontext element");
        }
 
-       if (defined (util::has_property($e, "obfuscation")) and not defined(util::has_property($e, "subcontext"))) {
+       if (defined (Parse::Pidl::Util::has_property($e, "obfuscation")) and not defined(Parse::Pidl::Util::has_property($e, "subcontext"))) {
                fatal($e, el_name($e) . " : obfuscation() on non-subcontext element");
        }
 
        if (!$e->{POINTERS} && (
-               util::has_property($e, "ptr") or
-               util::has_property($e, "sptr") or
-               util::has_property($e, "unique") or
-               util::has_property($e, "relative") or
-               util::has_property($e, "ref"))) {
+               Parse::Pidl::Util::has_property($e, "ptr") or
+               Parse::Pidl::Util::has_property($e, "sptr") or
+               Parse::Pidl::Util::has_property($e, "unique") or
+               Parse::Pidl::Util::has_property($e, "relative") or
+               Parse::Pidl::Util::has_property($e, "ref"))) {
                fatal($e, el_name($e) . " : pointer properties on non-pointer element\n");      
        }
 }
@@ -254,7 +254,7 @@ sub ValidUnion($)
 
        ValidProperties($union,"UNION");
 
-       if (util::has_property($union->{PARENT}, "nodiscriminant") and util::has_property($union->{PARENT}, "switch_type")) {
+       if (Parse::Pidl::Util::has_property($union->{PARENT}, "nodiscriminant") and Parse::Pidl::Util::has_property($union->{PARENT}, "switch_type")) {
                fatal($union->{PARENT}, $union->{PARENT}->{NAME} . ": switch_type() on union without discriminant");
        }
        
@@ -271,7 +271,7 @@ sub ValidUnion($)
                        fatal $e, "Union member $e->{NAME} must have default or case property\n";
                }
 
-               if (util::has_property($e, "ref")) {
+               if (Parse::Pidl::Util::has_property($e, "ref")) {
                        fatal($e, el_name($e) . " : embedded ref pointers are not supported yet\n");
                }
 
@@ -312,7 +312,7 @@ sub ValidFunction($)
 
        foreach my $e (@{$fn->{ELEMENTS}}) {
                $e->{PARENT} = $fn;
-               if (util::has_property($e, "ref") && !$e->{POINTERS}) {
+               if (Parse::Pidl::Util::has_property($e, "ref") && !$e->{POINTERS}) {
                        fatal $e, "[ref] variables must be pointers ($fn->{NAME}/$e->{NAME})\n";
                }
                ValidElement($e);
@@ -328,13 +328,13 @@ sub ValidInterface($)
 
        ValidProperties($interface,"INTERFACE");
 
-       if (util::has_property($interface, "pointer_default") && 
+       if (Parse::Pidl::Util::has_property($interface, "pointer_default") && 
                $interface->{PROPERTIES}->{pointer_default} eq "ptr") {
                fatal $interface, "Full pointers are not supported yet\n";
        }
 
-       if (util::has_property($interface, "object")) {
-               if (util::has_property($interface, "version") && 
+       if (Parse::Pidl::Util::has_property($interface, "object")) {
+               if (Parse::Pidl::Util::has_property($interface, "version") && 
                        $interface->{PROPERTIES}->{version} != 0) {
                        fatal $interface, "Object interfaces must have version 0.0 ($interface->{NAME})\n";
                }
diff --git a/source4/build/pidl/idl.gram b/source4/build/pidl/idl.gram
deleted file mode 100644 (file)
index fdadb91..0000000
+++ /dev/null
@@ -1,183 +0,0 @@
-{
-       use util;
-}
-
-idl: idl_interface(s)
-     {{ util::FlattenArray($item[1]) }}
-  | <error>
-
-idl_interface: module_header interface
-   { [$item{module_header}, $item{interface}] }
-   | <error>
-
-module_header: '[' <commit> module_param(s? /,/) ']' 
-          {{ 
-              "TYPE" => "MODULEHEADER", 
-              "PROPERTIES" => util::FlattenHash($item[3])
-          }}
-             | <error?>
-
-module_param: identifier '(' <commit> text ')'
-          {{ "$item{identifier}" => "$item{text}" }}
-          | <error>
-
-interface: 'interface' <commit> identifier '{' definition(s?) '}' 
-          {{
-                       "TYPE" => "INTERFACE", 
-                      "NAME" => $item{identifier},
-                      "DATA" => $item[5]
-          }}
-          | <error?>
-
-definition : typedef { $item[1] }
-             | function { $item[1] }
-             | const { $item[1] }
-
-const : 'const' <commit> identifier identifier '=' anytext ';' 
-        {{
-                     "TYPE"  => "CONST", 
-                    "DTYPE"  => $item[3],
-                    "NAME"  => $item[4],
-                    "VALUE" => $item{anytext}
-        }}
-        | <error?>
-
-typedef : 'typedef' <commit> type identifier array_len(?) ';' 
-        {{
-                     "TYPE" => "TYPEDEF", 
-                    "NAME" => $item{identifier},
-                    "DATA" => $item{type},
-                    "ARRAY_LEN" => $item[5][0]
-        }}
-        | <error?>
-
-enum: 'enum' <commit> '{' enum_element(s? /,/) '}' 
-        {{
-                     "TYPE" => "ENUM", 
-                    "ELEMENTS" => $item[4]
-        }}
-      | <error?>
-
-enum_element: /[\w\s=]+/
-
-struct: property_list(s?) 'struct' <commit> '{' element_list1(?) '}' 
-        {{
-                     "TYPE" => "STRUCT", 
-                    "PROPERTIES" => util::FlattenArray($item[1]),
-                    "ELEMENTS" => util::FlattenArray2($item[5])
-        }}
-      | <error?>
-
-union: property_list(s?) 'union' <commit> '{' union_element(s?) '}' 
-        {{
-               "TYPE" => "UNION",
-               "PROPERTIES" => util::FlattenArray($item[1]),
-               "DATA" => $item[5]
-        }}
-        | <error?>
-
-union_element: 
-         '[' 'case' '(' identifier ')' ']' base_element ';'
-        {{
-               "TYPE" => "UNION_ELEMENT",
-               "CASE" => $item{identifier},
-               "DATA" => $item{base_element}
-        }}
-         | '[' 'case' '(' identifier ')' ']' ';'
-        {{
-               "TYPE" => "EMPTY",
-               "CASE" => $item{identifier},
-        }}
-         | '[' 'default' ']' base_element ';'
-        {{
-               "TYPE" => "UNION_ELEMENT",
-               "CASE" => "default",
-               "DATA" => $item{base_element}
-        }}
-         | '[' 'default' ']' ';'
-        {{
-               "TYPE" => "EMPTY",
-               "CASE" => "default",
-        }}
-
-base_element: property_list(s?) type pointer(s?) identifier array_len(?) 
-             {{
-                          "NAME" => $item{identifier},
-                          "TYPE" => $item{type},
-                          "PROPERTIES" => util::FlattenArray($item[1]),
-                          "POINTERS" => $#{$item[3]}==-1?undef:$#{$item[3]}+1,
-                          "ARRAY_LEN" => $item[5][0]
-              }}
-            | <error>
-
-array_len: 
-        '[' ']'
-        { "*" }
-        | '[' '*' ']'
-        { "*" }
-        | '[' <commit> anytext ']' 
-         { "$item{anytext}" }
-         | <error?>
-
-element_list1: base_element(s? /;/) ';' 
-              { $item[1] }
-
-element_list2: 'void' 
-         | base_element(s? /,/)
-         { $item[1] }
-
-pointer: '*'
-
-property_list: '[' <commit> property(s /,/) ']' 
-             { $item[3] }
-             | <error?>
-
-property: 'unique' 
-         | 'in'
-         | 'out'
-         | 'ref'
-         | 'public'
-         | 'noprint'
-         | 'relative'    
-         | 'nodiscriminant'
-          | 'subcontext' '(' constant ')' {{ "$item[1]" => "$item{constant}" }}
-          | 'flag' '(' anytext ')' {{ "$item[1]" => "$item{anytext}" }}
-          | 'size_is' '(' expression ')' {{ "$item[1]" => "$item{expression}" }}
-          | 'length_is' '(' expression ')' {{ "$item[1]" => "$item{expression}" }}
-          | 'switch_is' '(' expression ')' {{ "$item[1]" => "$item{expression}" }}
-          | 'value' '(' anytext ')' {{ "$item[1]" => "$item{anytext}" }}
-
-identifier: /[\w?]+/
-
-expression: /[\w.?\/+*-_]+/
-
-function : property_list(s?) type identifier '(' <commit> element_list2 ');' 
-        {{
-               "TYPE" => "FUNCTION",
-               "NAME" => $item{identifier},
-               "RETURN_TYPE" => $item{type},
-               "PROPERTIES" => util::FlattenArray($item[1]),
-               "DATA" => $item{element_list2}
-        }}
-         | <error?>
-
-type : 
-       struct    { $item[1] }
-     | union     { $item[1] }
-     | enum      { $item[1] }
-     | identifier { $item[1] }
-     | <error>
-
-text: /[\w\s\..?-]*/
-
-text2: /[\|\w\s,\*&\>"\/\..?-]*/
-
-anytext: text2 '(' <commit> anytext ')' anytext
-        {{ "$item[1]($item[4])$item[6]" }}
-        | text2 '+' anytext 
-        {{ "$item[1]+$item[3]" }}
-        | text2
-
-constant: /-?[\dx]+/
-         | '*'
-
index b556b064b42d495daf468cfd6b915daf340fd754..acf926dd4089051085496d6454c6daac3408f46e 100644 (file)
@@ -192,7 +192,7 @@ empty_element: property_list ';'
 base_or_empty: base_element ';' | empty_element;
 
 optional_base_element:
-       property_list base_or_empty { $_[2]->{PROPERTIES} = util::FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] }
+       property_list base_or_empty { $_[2]->{PROPERTIES} = Parse::Pidl::Util::FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] }
 ;
 
 union_elements: 
@@ -247,11 +247,11 @@ array_len:
 
 property_list: 
     #empty
-    | property_list '[' properties ']' { util::FlattenHash([$_[1],$_[3]]); }
+    | property_list '[' properties ']' { Parse::Pidl::Util::FlattenHash([$_[1],$_[3]]); }
 ;
 
 properties: property          { $_[1] }
-    | properties ',' property { util::FlattenHash([$_[1], $_[3]]); }
+    | properties ',' property { Parse::Pidl::Util::FlattenHash([$_[1], $_[3]]); }
 ;
 
 property: identifier                   {{ "$_[1]" => "1"     }}
@@ -304,7 +304,7 @@ optional_semicolon:
 # start code
 %%
 
-use pidl::util;
+use Parse::Pidl::Util;
 
 sub _Error {
     if (exists $_[0]->YYData->{ERRMSG}) {
@@ -393,5 +393,5 @@ sub parse_idl($$)
 
        my $idl = $self->YYParse( yylex => \&_Lexer, yyerror => \&_Error );
 
-       return util::CleanData($idl);
+       return Parse::Pidl::Util::CleanData($idl);
 }
index 5e2b11e91aaf812c4a607864332e49d5d0076d8f..ae46b4c746743fc52611736229c3b23bc99c0b1b 100755 (executable)
@@ -9,30 +9,28 @@
 
 use strict;
 
-use FindBin qw($RealBin);
-use lib "$RealBin/..";
 use Getopt::Long;
 use File::Basename;
-use pidl::idl;
-use pidl::dump;
-use pidl::ndr_client;
-use pidl::ndr_header;
-use pidl::ndr_parser;
-use pidl::server;
-use pidl::dcom_proxy;
-use pidl::dcom_stub;
-use pidl::com_header;
-use pidl::odl;
-use pidl::eth_parser;
-use pidl::eth_header;
-use pidl::validator;
-use pidl::typelist;
-use pidl::util;
-use pidl::template;
-use pidl::swig;
-use pidl::compat;
-use pidl::ejs;
-use pidl::ejs_header;
+use Parse::Pidl;
+use Parse::Pidl::Util;
+
+#####################################################################
+# save a data structure into a file
+sub SaveStructure($$)
+{
+       my($filename,$v) = @_;
+       Parse::Pidl::Util::FileSave($filename, Parse::Pidl::Util::MyDumper($v));
+}
+
+#####################################################################
+# load a data structure from a file (as saved with SaveStructure)
+sub LoadStructure($)
+{
+       my $f = shift;
+       my $contents = Parse::Pidl::Util::FileLoad($f);
+       defined $contents || return undef;
+       return eval "$contents";
+}
 
 my($opt_help) = 0;
 my($opt_parse) = 0;
@@ -57,8 +55,6 @@ my($opt_output);
 my($opt_verbose) = 0;
 my($opt_warn_compat) = 0;
 
-my $idl_parser = new idl;
-
 #########################################
 # display help text
 sub ShowHelp()
@@ -141,43 +137,50 @@ sub process_file($)
                $output = $opt_output . $basename;
        }
 
-       my($pidl_file) = ($opt_keep or util::ChangeExtension($output, ".pidl"));
+       my($pidl_file) = ($opt_keep or Parse::Pidl::Util::ChangeExtension($output, ".pidl"));
 
        unless ($opt_quiet) { print "Compiling $idl_file\n"; }
 
        if ($opt_parse) {
+               require Parse::Pidl::IDL;
+               my $idl_parser = new Parse::Pidl::IDL;
+
                $pidl = $idl_parser->parse_idl($idl_file);
                defined @$pidl || die "Failed to parse $idl_file";
-               typelist::LoadIdl($pidl);
-               IdlValidator::Validate($pidl);
-               if (defined($opt_keep) && !util::SaveStructure($pidl_file, $pidl)) {
+               require Parse::Pidl::Typelist;
+               Parse::Pidl::Typelist::LoadIdl($pidl);
+        require Parse::Pidl::Validator;
+               Parse::Pidl::Validator::Validate($pidl);
+               if (defined($opt_keep) && !SaveStructure($pidl_file, $pidl)) {
                            die "Failed to save $pidl_file\n";
                }
        } else {
-               $pidl = util::LoadStructure($pidl_file);
+               $pidl = LoadStructure($pidl_file);
                defined $pidl || die "Failed to load $pidl_file - maybe you need --parse\n";
        }
 
        if ($opt_uint_enums) {
-               util::setUseUintEnums(1);
+               Parse::Pidl::Util::setUseUintEnums(1);
        }
 
        if ($opt_dump) {
-               print IdlDump::Dump($pidl);
+               require Parse::Pidl::Dump;
+               print Parse::Pidl::Dump($pidl);
        }
 
        if ($opt_diff) {
-               my($tempfile) = util::ChangeExtension($output, ".tmp");
-               util::FileSave($tempfile, IdlDump::Dump($pidl));
+               my($tempfile) = Parse::Pidl::Util::ChangeExtension($output, ".tmp");
+               Parse::Pidl::Util::FileSave($tempfile, IdlDump::Dump($pidl));
                system("diff -wu $idl_file $tempfile");
                unlink($tempfile);
        }
 
        if (defined($opt_com_header)) {
-               my $res = COMHeader::Parse($pidl);
+               require Parse::Pidl::Samba::COM::Header;
+               my $res = Parse::Pidl::Samba::COM::Header::Parse($pidl);
                if ($res) {
                        my $comh_filename = ($opt_com_header or (dirname($output) . "/com_$basename.h"));
-                       util::FileSave($comh_filename, 
+                       Parse::Pidl::Util::FileSave($comh_filename, 
                        "#include \"librpc/gen_ndr/ndr_orpc.h\"\n" . 
                        "#include \"librpc/gen_ndr/ndr_$basename.h\"\n" . 
                        $res);
@@ -186,10 +189,11 @@ sub process_file($)
        }
 
        if (defined($opt_dcom_proxy)) {
-               my $res = DCOMProxy::Parse($pidl);
+               require Parse::Pidl::Samba::COM::Proxy;
+               my $res = Parse::Pidl::Samba::COM::Proxy::Parse($pidl);
                if ($res) {
-                       my ($client) = ($opt_dcom_proxy or util::ChangeExtension($output, "_p.c"));
-                       util::FileSave($client, 
+                       my ($client) = ($opt_dcom_proxy or Parse::Pidl::Util::ChangeExtension($output, "_p.c"));
+                       Parse::Pidl::Util::FileSave($client, 
                        "#include \"includes.h\"\n" .
                        "#include \"librpc/gen_ndr/com_$basename.h\"\n" . 
                        "#include \"lib/com/dcom/dcom.h\"\n" .$res);
@@ -198,67 +202,78 @@ sub process_file($)
        }
 
        if ($opt_warn_compat) {
-               IDLCompat::Check($pidl);
+               require Parse::Pidl::Compat;
+               Parse::Pidl::Compat::Check($pidl);
        }
 
        if ($opt_odl) {
-               $pidl = ODL::ODL2IDL($pidl);
+               require Parse::Pidl::ODL;
+               $pidl = Parse::Pidl::ODL::ODL2IDL($pidl);
        }
 
        if (defined($opt_header) or defined($opt_eth_parser) or 
            defined($opt_eth_header) or defined($opt_client) or 
            defined($opt_server) or defined($opt_parser) or 
            defined($opt_ejs)) {
-               $ndr = Ndr::Parse($pidl);
+               require Parse::Pidl::NDR;
+               $ndr = Parse::Pidl::NDR::Parse($pidl);
        }
 
        if (defined($opt_header)) {
                my $header = $opt_header;
                if ($header eq "") {
-                       $header = util::ChangeExtension($output, ".h");
+                       $header = Parse::Pidl::Util::ChangeExtension($output, ".h");
                }
-               util::FileSave($header, NdrHeader::Parse($ndr));
+               require Parse::Pidl::Samba::NDR::Header;
+               Parse::Pidl::Util::FileSave($header, Parse::Pidl::Samba::NDR::Header::Parse($ndr));
                if (defined($opt_swig)) {
+                 require Parse::Pidl::Samba::SWIG;
                  my($filename) = $output;
                  $filename =~ s/\/ndr_/\//;
-                 $filename = ($opt_swig or util::ChangeExtension($filename, ".i"));
-                 IdlSwig::RewriteHeader($pidl, $header, $filename);
+                 $filename = ($opt_swig or Parse::Pidl::Util::ChangeExtension($filename, ".i"));
+                 Parse::Pidl::Samba::SWIG::RewriteHeader($pidl, $header, $filename);
                }
        }
 
        if (defined($opt_eth_header)) {
+         require Parse::Pidl::Ethereal::NDR::Header;
          my($eparserhdr) = ($opt_eth_header or (dirname($output) . "/packet-dcerpc-$basename.h"));
 
-         util::FileSave($eparserhdr, EthHeader::Parse($ndr));
+         Parse::Pidl::Util::FileSave($eparserhdr, Parse::Pidl::Ethereal::NDR::Header::Parse($ndr));
        }
 
-       my $h_filename = util::ChangeExtension($output, ".h");
+       my $h_filename = Parse::Pidl::Util::ChangeExtension($output, ".h");
        if (defined($opt_client)) {
-               my ($client) = ($opt_client or util::ChangeExtension($output, "_c.c"));
+               require Parse::Pidl::Samba::NDR::Client;
+               my ($client) = ($opt_client or Parse::Pidl::Util::ChangeExtension($output, "_c.c"));
 
-               util::FileSave($client, NdrClient::Parse($ndr,$h_filename));
+               Parse::Pidl::Util::FileSave($client, Parse::Pidl::Samba::NDR::Client::Parse($ndr,$h_filename));
        }
 
        if (defined($opt_ejs)) {
-               my $ejs = ($opt_ejs or util::ChangeExtension($output, "_ejs.c"));
-               util::FileSave($ejs, EjsClient::Parse($ndr, $h_filename));
+               require Parse::Pidl::Samba::EJS;
+               require Parse::Pidl::Samba::EJSHeader;
+               my $ejs = ($opt_ejs or Parse::Pidl::Util::ChangeExtension($output, "_ejs.c"));
+               Parse::Pidl::Util::FileSave($ejs, Parse::Pidl::Samba::EJS::Parse($ndr, $h_filename));
 
-               $ejs = ($opt_ejs or util::ChangeExtension($output, "_ejs.h"));
-               util::FileSave($ejs, EjsHeader::Parse($ndr));
+               $ejs = ($opt_ejs or Parse::Pidl::Util::ChangeExtension($output, "_ejs.h"));
+               Parse::Pidl::Util::FileSave($ejs, Parse::Pidl::Samba::EJSHeader::Parse($ndr));
        }
 
        if (defined($opt_server)) {
+               require Parse::Pidl::Samba::NDR::Server;
                my $dcom = "";
 
                foreach my $x (@{$pidl}) {
                        next if ($x->{TYPE} ne "INTERFACE");
 
-                       if (util::has_property($x, "object")) {
-                               $dcom .= DCOMStub::ParseInterface($x);
+                       if (Parse::Pidl::Util::has_property($x, "object")) {
+                               require Parse::Pidl::Samba::COM::Stub;
+                               $dcom .= Parse::Pidl::Samba::COM::Stub::ParseInterface($x);
                        }
                }
 
-               util::FileSave(($opt_server or util::ChangeExtension($output, "_s.c")), NdrServer::Parse($ndr,$h_filename));
+               Parse::Pidl::Util::FileSave(($opt_server or Parse::Pidl::Util::ChangeExtension($output, "_s.c")), Parse::Pidl::Samba::NDR::Server::Parse($ndr,$h_filename));
 
                if ($dcom ne "") {
                        $dcom = "
@@ -269,23 +284,25 @@ sub process_file($)
 
 $dcom
 ";
-                       util::FileSave(util::ChangeExtension($output, "_d.c"), $dcom);
+       Parse::Pidl::Util::FileSave(Parse::Pidl::Util::ChangeExtension($output, "_d.c"), $dcom);
                }
        }
 
        if (defined($opt_parser)) {
-               my $parser = ($opt_parser or util::ChangeExtension($output, ".c"));
-               
-               util::FileSave($parser, NdrParser::Parse($ndr, $parser));
+               my $parser = ($opt_parser or Parse::Pidl::Util::ChangeExtension($output, ".c"));
+               require Parse::Pidl::Samba::NDR::Parser;
+               Parse::Pidl::Util::FileSave($parser, Parse::Pidl::Samba::NDR::Parser::Parse($ndr, $parser));
        }
 
        if (defined($opt_eth_parser)) {
+         require Parse::Pidl::Ethereal::NDR::Parser;
          my($eparser) = ($opt_eth_parser or dirname($output) . "/packet-dcerpc-$basename.c");
-         util::FileSave($eparser, EthParser::Parse($ndr, $basename, $eparser));
+         Parse::Pidl::Util::FileSave($eparser, Parse::Pidl::Ethereal::NDR::Parser::Parse($ndr, $basename, $eparser));
        }
 
        if ($opt_template) {
-               print IdlTemplate::Parse($pidl);
+               require Parse::Pidl::Samba::Template;
+               print Parse::Pidl::Samba::Template::Parse($pidl);
        }
 }
 
index 97dd0b57106ee94c3cabd5bfbffed9fc3a35b7c7..a32a93af0ae24768302a49fc6aac1e2050ed7ad7 100644 (file)
@@ -129,14 +129,14 @@ sub _prepare_IDL($)
        my $ctx = shift;
 
        return << '__EOD__';
-idl_full: build/pidl/idl.pm
+idl_full: build/pidl/Parse/Pidl/IDL.pm
        CPP="@CPP@" PERL="$(PERL)" script/build_idl.sh FULL @PIDL_ARGS@
 
-idl: build/pidl/idl.pm
+idl: build/pidl/Parse/Pidl/IDL.pm
        @CPP="@CPP@" PERL="$(PERL)" script/build_idl.sh PARTIAL @PIDL_ARGS@
 
-build/pidl/idl.pm: build/pidl/idl.yp
-       -yapp -s build/pidl/idl.yp
+build/pidl/Parse/Pidl/IDL.pm: build/pidl/idl.yp
+       -yapp -s -m 'Parse::Pidl::IDL' -o build/pidl/Parse/Pidl/IDL.pm build/pidl/idl.yp 
 
 pch: proto include/includes.h.gch
 
index 9ca20b40728ee3e32b932c54fa93fbfb3a830e3f..20e0b706c8e2cb3e1ef9d40ac2d24b3905f97025 100755 (executable)
@@ -6,7 +6,7 @@ PIDL_EXTRA_ARGS="$*"
 
 [ -d librpc/gen_ndr ] || mkdir -p librpc/gen_ndr || exit 1
 
-PIDL="$PERL ./build/pidl/pidl --output librpc/gen_ndr/ndr_ --parse --header --parser --server --client --dcom-proxy --com-header --swig --odl --ejs -- $PIDL_EXTRA_ARGS"
+PIDL="$PERL -Ibuild/pidl ./build/pidl/pidl --output librpc/gen_ndr/ndr_ --parse --header --parser --server --client --dcom-proxy --com-header --swig --odl --ejs -- $PIDL_EXTRA_ARGS"
 
 if [ x$FULLBUILD = xFULL ]; then
       echo Rebuilding all idl files in librpc/idl