#!/usr/bin/perl -w

###################################################
# 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

use strict;

use Getopt::Long;
use File::Basename;
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;
my($opt_dump) = 0;
my($opt_uint_enums) = 0;
my($opt_diff) = 0;
my($opt_header);
my($opt_template) = 0;
my($opt_client);
my($opt_server);
my($opt_parser);
my($opt_eth_parser);
my($opt_eth_header);
my($opt_keep);
my($opt_swig);
my($opt_dcom_proxy);
my($opt_com_header);
my($opt_ejs);
my($opt_odl) = 0;
my($opt_quiet) = 0;
my($opt_output);
my($opt_verbose) = 0;
my($opt_warn_compat) = 0;

#########################################
# display help text
sub ShowHelp()
{
print "perl IDL parser and code generator
Copyright (C) tridge\@samba.org

Usage: pidl [options] <idlfile>

Options:
 --help                this help page
 --output=OUTNAME      put output in OUTNAME.*
 --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
 --ejs[=OUTFILE]       create ejs wrapper file
 --client[=OUTFILE]    create a C NDR client
 --server[=OUTFILE]    create server boilerplate
 --template            print a template for a pipe
 --eth-parser[=OUTFILE]create an ethereal parser
 --eth-header[=OUTFILE]create an ethereal header file
 --swig[=OUTFILE]      create swig wrapper file
 --diff                run diff on the idl and dumped output
 --keep[=OUTFILE]      keep the .pidl file
 --odl                 accept ODL input
 --dcom-proxy[=OUTFILE]create DCOM proxy (implies --odl)
 --com-header[=OUTFILE]create header for COM interfaces (implies --odl)
 --warn-compat         warn about incompatibility with other compilers
 --quiet               be quiet
 --verbose             be verbose
\n";
    exit(0);
}

# main program
GetOptions (
	    'help|h|?' => \$opt_help, 
	    'output=s' => \$opt_output,
	    'parse' => \$opt_parse,
	    'dump' => \$opt_dump,
	    'uint-enums' => \$opt_uint_enums,
	    'header:s' => \$opt_header,
	    'server:s' => \$opt_server,
	    'template' => \$opt_template,
	    'parser:s' => \$opt_parser,
	    'client:s' => \$opt_client,
	    'eth-parser:s' => \$opt_eth_parser,
	    'eth-header:s' => \$opt_eth_header,
	    'ejs:s' => \$opt_ejs,
	    'diff' => \$opt_diff,
	    'odl' => \$opt_odl,
	    'keep:s' => \$opt_keep,
	    'swig:s' => \$opt_swig,
	    'dcom-proxy:s' => \$opt_dcom_proxy,
	    'com-header:s' => \$opt_com_header,
	    'quiet' => \$opt_quiet,
		'verbose' => \$opt_verbose,
	    'warn-compat' => \$opt_warn_compat
	    );

if ($opt_help) {
    ShowHelp();
    exit(0);
}

sub process_file($)
{
	my $idl_file = shift;
	my $output;
	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 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";
		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 = LoadStructure($pidl_file);
		defined $pidl || die "Failed to load $pidl_file - maybe you need --parse\n";
	}

	if ($opt_uint_enums) {
		Parse::Pidl::Util::setUseUintEnums(1);
	}

	if ($opt_dump) {
		require Parse::Pidl::Dump;
		print Parse::Pidl::Dump($pidl);
	}

	if ($opt_diff) {
		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)) {
		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"));
			Parse::Pidl::Util::FileSave($comh_filename, 
			"#include \"librpc/gen_ndr/ndr_orpc.h\"\n" . 
			"#include \"librpc/gen_ndr/ndr_$basename.h\"\n" . 
			$res);
		}
		$opt_odl = 1;
	}

	if (defined($opt_dcom_proxy)) {
		require Parse::Pidl::Samba::COM::Proxy;
		my $res = Parse::Pidl::Samba::COM::Proxy::Parse($pidl);
		if ($res) {
			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);
		}
		$opt_odl = 1;
	}

	if ($opt_warn_compat) {
		require Parse::Pidl::Compat;
		Parse::Pidl::Compat::Check($pidl);
	}

	if ($opt_odl) {
		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)) {
		require Parse::Pidl::NDR;
		$ndr = Parse::Pidl::NDR::Parse($pidl);
	}

	if (defined($opt_header)) {
		my $header = $opt_header;
		if ($header eq "") {
			$header = Parse::Pidl::Util::ChangeExtension($output, ".h");
		}
		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 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"));

	  Parse::Pidl::Util::FileSave($eparserhdr, Parse::Pidl::Ethereal::NDR::Header::Parse($ndr));
	}

	my $h_filename = Parse::Pidl::Util::ChangeExtension($output, ".h");
	if (defined($opt_client)) {
		require Parse::Pidl::Samba::NDR::Client;
		my ($client) = ($opt_client or Parse::Pidl::Util::ChangeExtension($output, "_c.c"));

		Parse::Pidl::Util::FileSave($client, Parse::Pidl::Samba::NDR::Client::Parse($ndr,$h_filename));
	}

	if (defined($opt_ejs)) {
		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 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 (Parse::Pidl::Util::has_property($x, "object")) {
				require Parse::Pidl::Samba::COM::Stub;
				$dcom .= Parse::Pidl::Samba::COM::Stub::ParseInterface($x);
			}
		}

		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 = "
#include \"includes.h\"
#include \"$h_filename\"
#include \"rpc_server/dcerpc_server.h\"
#include \"rpc_server/common/common.h\"

$dcom
";
	Parse::Pidl::Util::FileSave(Parse::Pidl::Util::ChangeExtension($output, "_d.c"), $dcom);
		}
	}

	if (defined($opt_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");
	  Parse::Pidl::Util::FileSave($eparser, Parse::Pidl::Ethereal::NDR::Parser::Parse($ndr, $basename, $eparser));
	}

	if ($opt_template) {
		require Parse::Pidl::Samba::Template;
		print Parse::Pidl::Samba::Template::Parse($pidl);
	}
}

foreach my $filename (@ARGV) {
	process_file($filename);
}