r8806: Move data representation-independent data into seperate header
[sfrench/samba-autobuild/.git] / source4 / build / pidl / pidl
index 5e2b11e91aaf812c4a607864332e49d5d0076d8f..cc0e2b0d32ceb59a29967b6119822b3f541449cf 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;
@@ -40,10 +38,11 @@ my($opt_dump) = 0;
 my($opt_uint_enums) = 0;
 my($opt_diff) = 0;
 my($opt_header);
+my($opt_ndr_header);
 my($opt_template) = 0;
 my($opt_client);
 my($opt_server);
-my($opt_parser);
+my($opt_ndr_parser);
 my($opt_eth_parser);
 my($opt_eth_header);
 my($opt_keep);
@@ -53,12 +52,10 @@ my($opt_com_header);
 my($opt_ejs);
 my($opt_odl) = 0;
 my($opt_quiet) = 0;
-my($opt_output);
+my($opt_outputdir) = '.';
 my($opt_verbose) = 0;
 my($opt_warn_compat) = 0;
 
-my $idl_parser = new idl;
-
 #########################################
 # display help text
 sub ShowHelp()
@@ -70,12 +67,13 @@ Usage: pidl [options] <idlfile>
 
 Options:
  --help                this help page
- --output=OUTNAME      put output in OUTNAME.*
+ --outputdir=OUTDIR    put output in OUTDIR/ [.]
  --parse               parse a idl file to a .pidl file
  --dump                dump a pidl file back to idl
  --uint-enums          don't use C enums, instead use uint* types
- --header[=OUTFILE]    create a C NDR header file
- --parser[=OUTFILE]    create a C NDR parser
+ --header[=OUTFILE]    create generic header file
+ --ndr-header[=OUTFILE]create a C NDR-specific header file
+ --ndr-parser[=OUTFILE]create a C NDR parser
  --ejs[=OUTFILE]       create ejs wrapper file
  --client[=OUTFILE]    create a C NDR client
  --server[=OUTFILE]    create server boilerplate
@@ -98,18 +96,19 @@ Options:
 # main program
 GetOptions (
            'help|h|?' => \$opt_help, 
-           'output=s' => \$opt_output,
+           'outputdir=s' => \$opt_outputdir,
            'parse' => \$opt_parse,
            'dump' => \$opt_dump,
            'uint-enums' => \$opt_uint_enums,
-           'header:s' => \$opt_header,
+           'ndr-header:s' => \$opt_ndr_header,
+               'header:s' => \$opt_header,
            'server:s' => \$opt_server,
            'template' => \$opt_template,
-           'parser:s' => \$opt_parser,
+           'ndr-parser:s' => \$opt_ndr_parser,
            'client:s' => \$opt_client,
            'eth-parser:s' => \$opt_eth_parser,
            'eth-header:s' => \$opt_eth_header,
-           'ejs:s' => \$opt_ejs,
+           'ejs' => \$opt_ejs,
            'diff' => \$opt_diff,
            'odl' => \$opt_odl,
            'keep:s' => \$opt_keep,
@@ -129,136 +128,148 @@ if ($opt_help) {
 sub process_file($)
 {
        my $idl_file = shift;
-       my $output;
+       my $outputdir = $opt_outputdir;
        my $pidl;
        my $ndr;
 
        my $basename = basename($idl_file, ".idl");
 
-       if (!defined($opt_output)) {
-               $output = $idl_file;
-       } else {
-               $output = $opt_output . $basename;
-       }
-
-       my($pidl_file) = ($opt_keep or util::ChangeExtension($output, ".pidl"));
+       my($pidl_file) = ($opt_keep or "$outputdir/$basename.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) = "$outputdir/$basename.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, 
+                       my $comh_filename = ($opt_com_header or "$outputdir/com_$basename.h");
+                       Parse::Pidl::Util::FileSave($comh_filename, 
                        "#include \"librpc/gen_ndr/ndr_orpc.h\"\n" . 
-                       "#include \"librpc/gen_ndr/ndr_$basename.h\"\n" . 
+                       "#include \"$outputdir/ndr_$basename.h\"\n" . 
                        $res);
                }
                $opt_odl = 1;
        }
 
        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 "$outputdir/$basename\_p.c");
+                       Parse::Pidl::Util::FileSave($client, 
                        "#include \"includes.h\"\n" .
-                       "#include \"librpc/gen_ndr/com_$basename.h\"\n" . 
+                       "#include \"$outputdir/com_$basename.h\"\n" . 
                        "#include \"lib/com/dcom/dcom.h\"\n" .$res);
                }
                $opt_odl = 1;
        }
 
        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 
+       if (defined($opt_ndr_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_server) or defined($opt_ndr_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");
-               }
-               util::FileSave($header, NdrHeader::Parse($ndr));
+               my $header = ($opt_header or "$outputdir/$basename.h");
+               require Parse::Pidl::Samba::Header;
+               Parse::Pidl::Util::FileSave($header, Parse::Pidl::Samba::Header::Parse($pidl));
+       }
+
+       if (defined($opt_ndr_header)) {
+               my $header = ($opt_ndr_header or "$outputdir/ndr_$basename.h");
+               require Parse::Pidl::Samba::NDR::Header;
+               Parse::Pidl::Util::FileSave($header, Parse::Pidl::Samba::NDR::Header::Parse($pidl, $basename));
                if (defined($opt_swig)) {
-                 my($filename) = $output;
-                 $filename =~ s/\/ndr_/\//;
-                 $filename = ($opt_swig or util::ChangeExtension($filename, ".i"));
-                 IdlSwig::RewriteHeader($pidl, $header, $filename);
+                 require Parse::Pidl::Samba::SWIG;
+                 my($filename) = ($opt_swig or "$outputdir/$basename.i");
+                 Parse::Pidl::Samba::SWIG::RewriteHeader($pidl, $header, $filename);
                }
        }
 
        if (defined($opt_eth_header)) {
-         my($eparserhdr) = ($opt_eth_header or (dirname($output) . "/packet-dcerpc-$basename.h"));
+         require Parse::Pidl::Ethereal::NDR::Header;
+         my($eparserhdr) = ($opt_eth_header or "$outputdir/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 = "$outputdir/ndr_$basename.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 "$outputdir/ndr_$basename\_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;
+               Parse::Pidl::Util::FileSave("$outputdir/ndr_$basename\_ejs.c", Parse::Pidl::Samba::EJS::Parse($ndr, $h_filename));
 
-               $ejs = ($opt_ejs or util::ChangeExtension($output, "_ejs.h"));
-               util::FileSave($ejs, EjsHeader::Parse($ndr));
+               Parse::Pidl::Util::FileSave("$outputdir/ndr_$basename\_ejs.h", 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 "$outputdir/ndr_$basename\_s.c"), Parse::Pidl::Samba::NDR::Server::Parse($ndr,$h_filename));
 
                if ($dcom ne "") {
                        $dcom = "
@@ -269,23 +280,25 @@ sub process_file($)
 
 $dcom
 ";
-                       util::FileSave(util::ChangeExtension($output, "_d.c"), $dcom);
+       Parse::Pidl::Util::FileSave("$outputdir/$basename\_d.c", $dcom);
                }
        }
 
-       if (defined($opt_parser)) {
-               my $parser = ($opt_parser or util::ChangeExtension($output, ".c"));
-               
-               util::FileSave($parser, NdrParser::Parse($ndr, $parser));
+       if (defined($opt_ndr_parser)) {
+               my $parser = ($opt_ndr_parser or "$outputdir/ndr_$basename.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)) {
-         my($eparser) = ($opt_eth_parser or dirname($output) . "/packet-dcerpc-$basename.c");
-         util::FileSave($eparser, EthParser::Parse($ndr, $basename, $eparser));
+         require Parse::Pidl::Ethereal::NDR::Parser;
+         my($eparser) = ($opt_eth_parser or "$outputdir/packet-dcerpc-$basename.c");
+         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);
        }
 }