#!/usr/bin/perl
use strict;

# REX/Perl 1.0 
# Robert D. Cameron "REX: XML Shallow Parsing with Regular Expressions",
# Technical Report TR 1998-17, School of Computing Science, Simon Fraser 
# University, November, 1998.
# Copyright (c) 1998, Robert D. Cameron. 
# The following code may be freely used and distributed provided that
# this copyright and citation notice remains intact and that modifications
# or additions are clearly identified.

my $TextSE = "[^<]+";
my $UntilHyphen = "[^-]*-";
my $Until2Hyphens = "$UntilHyphen(?:[^-]$UntilHyphen)*-";
my $CommentCE = "$Until2Hyphens>?";
my $UntilRSBs = "[^\\]]*](?:[^\\]]+])*]+";
my $CDATA_CE = "$UntilRSBs(?:[^\\]>]$UntilRSBs)*>";
my $S = "[ \\n\\t\\r]+";
my $NameStrt = "[A-Za-z_:]|[^\\x00-\\x7F]";
my $NameChar = "[A-Za-z0-9_:.-]|[^\\x00-\\x7F]";
my $Name = "(?:$NameStrt)(?:$NameChar)*";
my $QuoteSE = "\"[^\"]*\"|'[^']*'";
my $DT_IdentSE = "$S$Name(?:$S(?:$Name|$QuoteSE))*";
my $MarkupDeclCE = "(?:[^\\]\"'><]+|$QuoteSE)*>";
my $S1 = "[\\n\\r\\t ]";
my $UntilQMs = "[^?]*\\?+";
my $PI_Tail = "\\?>|$S1$UntilQMs(?:[^>?]$UntilQMs)*>";
my $DT_ItemSE = "<(?:!(?:--$Until2Hyphens>|[^-]$MarkupDeclCE)|\\?$Name(?:$PI_Tail))|%$Name;|$S";
my $DocTypeCE = "$DT_IdentSE(?:$S)?(?:\\[(?:$DT_ItemSE)*](?:$S)?)?>?";
my $DeclCE = "--(?:$CommentCE)?|\\[CDATA\\[(?:$CDATA_CE)?|DOCTYPE(?:$DocTypeCE)?";
my $PI_CE = "$Name(?:$PI_Tail)?";
my $EndTagCE = "$Name(?:$S)?>?";
my $AttValSE = "\"[^<\"]*\"|'[^<']*'";
my $ElemTagCE = "$Name(?:$S$Name(?:$S)?=(?:$S)?(?:$AttValSE))*(?:$S)?/?>?";
my $MarkupSPE = "<(?:!(?:$DeclCE)?|\\?(?:$PI_CE)?|/(?:$EndTagCE)?|(?:$ElemTagCE)?)";
my $XML_SPE = "$TextSE|$MarkupSPE";


my $filename;
my %packageDef;
my %methods;
my %objects;

my $objPath = "../obj";
my $ifacePath = "../iface/";
my %opts; # programm options
my @files;# files to treat

my %typeToObject = (
                    'int' => 'Integer' ,
                    'boolean' => 'Boolean',
                    'double' => 'Double',
                    'String' => 'String',
                    'byte' => 'Byte'
                    );

my %typeToCType = (
                   'int' => 'int',
                   'boolean' => 'boolean',
                   'double' => 'double',
                   'String' => "char *",
                   'byte' => 'char'
                   );

sub openFile {
    my ( $fileToOpen ) = @_;
    print "openFile $fileToOpen\n";
    if ( $opts{"-file"} ) {
        local *SORTIE;
        print "openFile -file $fileToOpen\n";
        open( SORTIE, "> $fileToOpen") 
            or die "Cannot open $fileToOpen";
        return *SORTIE;
    } else {
        return *STDOUT;
    }
}

sub closeFile {
    my ($handleFile) =@_;
    close $handleFile if  ( $opts{"-file"} );
}

sub ShallowParse { 
  my($XML_document) = @_;
  return $XML_document =~ /$MarkupSPE/g;
}

sub isPackage {
    my ($XML_Section) = @_;
    my @temp;
    my $temp;
    @temp =  $XML_Section =~ /$Name/g; 
    $temp = shift (@temp);
    return $temp eq "Package";
}

sub isObject {
    my ($XML_Section) = @_;
    my @temp;
    my $temp;
    @temp =  $XML_Section =~ /$Name/g; 
    $temp = shift (@temp);
    return $temp eq "Object";
}

sub isMethod {
    my ($XML_Section) = @_;
    my @temp;
    my $temp;
    @temp =  $XML_Section =~ /$Name/g; 
    $temp = shift (@temp);
    return $temp eq "Method";
}

sub parsePackage {
    my ($Package, @XML_Sections) = @_;
    my @packageAttr = $Package =~ /$AttValSE/g;
    $_ =  shift ( @packageAttr );
    s/\"//g; 
    $packageDef{"name"} = $_ ;
    s/^.*\.//;
    $packageDef{"shortName"} = $_;
    $packageDef{"version"}= shift(@packageAttr);
   return @XML_Sections;
}

sub parseObject {
    my ($Object, @XML_Sections) = @_;
    my %field=();
    my @fields=();
    my @objectAttr;
    my @field;
    my ( $nameObject,$field, $key, $value );
    # get the object name
    @objectAttr = $Object =~ /$AttValSE/g;
    $_ =  shift ( @objectAttr );
    s/\"//g; $nameObject = $_ ;

    
    #Now get Every Field of the object
    while ( ($field,@XML_Sections) = @XML_Sections ) {
	@field = ($field =~ /$Name/g );
	if ((shift @field) eq "Object") {
	    $objects{$nameObject}=\@fields;
	    return @XML_Sections;
	} else {
	    while ( ($key,$value,@field)= @field ) {
		$field{$key} = $value;
	    }
	    @fields = ( @fields,  $field{"name"}, $field{"type"} );
	}
    }
    return @XML_Sections;
}

sub parseMethod {
    my ($Method, @XML_Sections) = @_;
    my $retour;
    my @param =();
    my $nameMethod = "";
    my @methodAttr;
    my @field;
    my ( $inout, $field, $p);
    # get the Method name
#    print $Method;
    @methodAttr = $Method =~ /$AttValSE/g;
    $_ =  shift ( @methodAttr );
    s/\"//g; $nameMethod = $_ ;

    #Now get Every Field of the object
    while ( ($field,@XML_Sections) = @XML_Sections ) {
	@field = ($field =~ /$Name/g );
	$inout= shift (@field);
	if ( $inout eq "Method") {
	    $methods{$nameMethod}=\@param;
	    return @XML_Sections;
	} elsif ( $inout eq "return" ){
	    ($_,$retour,@field) = (@field);
	     @param = ( $retour, @param);
	} else {
	    ($_,$p,@field) = (@field);	    
	     @param = (@param, $p); 
	}
    }
    return @XML_Sections;
}

sub JObject {
    my ( $nameObj, @fields) = @_;
    my ( $def, $name, $type);
    $def = "public class " . $nameObj . " implements Serializable { \n" ;
    while ( ( $name, $type, @fields) = @fields ) {
		$def .= "\t private " . $type . " " . $name .";\n";
		$def .= "\t public " . $type . " get" . $name ."() {return ". $name ."; }\n";
		$def .= "\t public void set" . $name ."(" . $type . " x) {". $name ." = x; }\n";
    }

    $def .= "\n\tpublic " . $nameObj . "() {} \n";
    $def .= "}\n";
    return $def;
}

sub CObject {
    my ( $nameObj, @fields) = @_;
    my ( $def, $name, $type);
    $def = "struct " . $nameObj . "  { \n" ;
    while ( ( $name, $type, @fields) = @fields ) {
	$def .= "\t " . $type . " " . $name .";\n";
    }
    $def .= "}\n";
    return $def;
}


sub JMethod {
    my ($nameMethod, @param )= @_;
    my $i=0;
    my $def="";
    $def .= "public " . shift(@param) . "  ". $nameMethod . "( ";
    $def .= $_ . " p".$i++. ", " foreach (@param);
    $_ = $def;
    s/, $//;
    $def = $_ . " )";
    return $def;
}


sub FileHeader {
    my ($fileheader, $include, $comment) = @_;
    print "generating $fileheader from $filename\n" if ($opts{"-verbose"});;
    my $temp=<<EOF;
package $packageDef{"name"};

import xtremweb.XwIDL.*;
import xtremweb.common.*;
import xtremweb.communications.*;

$include
/**
 * $fileheader
 *
 * $comment
 * 
 * This code is generated with XwIDL from 
 * the definition file used $filename
 * 
 * Do not edit this file 
 *
 * \@author $ENV{USER}
 * \@version $packageDef{"version"}
 */

EOF
    return $temp;
}

sub Cheader {
    my ($obj);
    foreach $obj ( keys  %objects ) {
	print CObject( $obj, @{$objects{$obj}} ) ."\n\n";
    }
}

sub Jheader {
    my ($obj);
    foreach $obj ( keys  %objects ) {
#	local *FICHIER = openFile( $objPath. "/" . $obj.".java" );
	local *FICHIER = openFile( packageDir($packageDef{"name"}) . "/" . $obj.".java" );
	print FICHIER FileHeader( $obj.".java", "import java.io.*;" , "Declaration of object $obj ");
	print FICHIER JObject( $obj, @{$objects{$obj}} ) ."\n\n";
	closeFile( *FICHIER );
    }
}

sub JConstructor {
    my ($className, $option, $body) =@_;
    return "public $className () $option { \n $body }\n";
}

sub JRMIHandler {
    my ($callback, $meth, $i, $methodBodies, $voidreturn);
    $callback = "(( Callback" .$packageDef{"shortName"} . ") callback )";
    foreach $meth ( keys  %methods ) {
#	print @{$methods{$meth}} ;
	$methodBodies .= JMethod( $meth, @{$methods{$meth}} ) . " throws RemoteException {\n"  ;
	# callback
	#$retour = shift( @{$methods{$meth}});

	$methodBodies .= "\t".((@{$methods{$meth}}[0] ne "void") &&"return (").   $callback . "." .$meth . "(" ;
	 $_= "";

	for $i (0..(@{$methods{$meth}}-2) ) {
	    $_.= " p".$i++.", ";  
	}
	s/, $//;
	$methodBodies .= $_ . ((@{$methods{$meth}}[0] ne "void") &&")").");\n}\n";
    }
    local *FICHIER = openFile(  packageDir($packageDef{"name"}) . packageName("RMIHandler", $packageDef{"name"}) );
    print FICHIER FileHeader(  packageName("RMIHandler", $packageDef{"name"}) ,
			       "import java.rmi.*;\nimport java.rmi.server.UnicastRemoteObject;\n",
			       "Handles RMI Communications from an RMI Client");
    
    print FICHIER "".JClass( "RMIHandler", $packageDef{"name"}, 
			     " extends RMIHandlerTemplate implements InterfaceRMI".$packageDef{"shortName"} ) . "\n";
    print FICHIER JConstructor(  "RMIHandler".$packageDef{"shortName"} , " throws RemoteException ", ""); 
   print FICHIER $methodBodies ."\n}\n\n";
    closeFile( *FICHIER );
}

sub JRMIComm {
    my (  $meth, $methodsBodies)= ("","");

    foreach $meth ( keys  %methods ) {
	my ( $callb, $header, $retour, $i )= ("","","",0); 
	$header = JMethod( $meth, @{$methods{$meth}} ) . " throws RemoteException {\n"  ;
	#prepare the result
	$retour = shift( @{$methods{$meth}});
	if (  $objects{$retour} ) {
	    $callb = "\t" . $retour . " x " . " = new " . $retour . "();\n";
	} elsif ( $retour ne "void") {
	    $callb = "\t" . $retour . " x ;\n"; 
	} 
	$callb.= "\ttry {\n\t\t";
	$callb .= "x= " if  ( $retour ne "void");
	$callb .= "( (InterfaceRMI".$packageDef{"shortName"} .") rmi).". $meth. "( ";
	$callb .=   " p".$i++. ", " foreach ( @{$methods{$meth}});
	$callb =~ s/, $//;
	$callb .= ");\n\t} catch (RemoteException e) {\n\t\t throw new RemoteException(e.toString());\n\t}\n";
	$methodsBodies .=  $header . $callb . "\n" .(( $retour ne "void")&&"\treturn x;\n")."}\n\n" ;
    }

    local *FICHIER = openFile(  packageDir($packageDef{"name"}) . packageName("CommRMI", $packageDef{"name"}) );
    print FICHIER FileHeader(  packageName("CommRMI", $packageDef{"name"}) , 
			       "import java.rmi.*;\n", 
			       "Creates RMI Communication to an RMI server"); 
    print FICHIER "".JClass( "CommRMI", $packageDef{"name"}, " extends CommRMITemplate") . "\n";
    print  FICHIER $methodsBodies . "}\n\n";
    closeFile( *FICHIER );
}

sub JRMIInterface {
    my ( $meth, $methodsProto) =("","");
    foreach $meth ( keys  %methods ) {
        $methodsProto .= "\t".JMethod( $meth, @{$methods{$meth}} ) . " throws RemoteException ;\n"  ;
    }
#    local *FICHIER = openFile( $ifacePath . packageName("InterfaceRMI", $packageDef{"name"}) );
    local *FICHIER = openFile( packageDir($packageDef{"name"}) . packageName("InterfaceRMI", $packageDef{"name"}) );
    print FICHIER FileHeader(  packageName("InterfaceRMI", $packageDef{"name"}) , 
                               "import java.rmi.*;\n", 
                               "Interface used to generate Stub ans Skel"); 
    print FICHIER "".JInterface( "InterfaceRMI", $packageDef{"name"}, " extends Remote") . "\n";
    print  FICHIER $methodsProto . "\n}\n";
}

sub packageName {
    my ( $prefix, $packageName) =@_;
    $packageName =~s/^.*\.//;
    print "pckName () prefix  = $prefix\n";
    print "pckName () pckName = $packageName\n";
    print "pckName () $prefix.$packageName.java\n";
    return $prefix.$packageName.".java";
}
sub packageDir {
    my ($packageName) =@_;
    $packageName =~s/^.*\.//;
    print "pckDir () pckName = $packageName\n";
    return "../".$packageName."/";
}


sub JClass {
    my ( $prefix, $packageName, $options) =@_;
    $packageName =~s/^.*\.//;
    return "public class ".$prefix.$packageName. " ". $options ." {\n";
}

sub JInterface {
    my ( $prefix, $packageName, $options) =@_;
    $packageName =~s/^.*\.//;
    return "public interface ".$prefix.$packageName. " ". $options ." {\n";
}

sub JXMLRPCHandler {
    my $callback = "Dispatcher.commHandler";
    my @param =();
    my %param=();
    my $ipar=0;
    my ($meth, $retour);
    print <<EOF;
package xtremweb.dispatcher;
import xtremweb.common.*;
import xtremweb.communications.*;

import java.util.*;
import java.lang.reflect.Array;
import java.security.*;

/**
 * XMLRPCHandler.java
 * Handles XMLRPC communications from servers  
 *
 * Created: Sun Jul  9 17:46:53 2000
 *
 * \@author $ENV{USER}
 * \@version
 */
EOF
     foreach $meth ( keys  %methods ) {
#	print @{$methods{$meth}} ;
#	print JextMethod( $meth, @{$methods{$meth}} ) . " throws RemoteException {\n"  ;
	my $def = "public Hashtable " .$meth . " ( ";
	my $callb = "";
	@param =();
	%param=();
	my $ipar=0;
	my $iobj=0;
	my $newObj = "";
	my $postcallb = "";
	my  @argsMethod;
	my ($n, $t);
	($retour, @argsMethod )=   @{$methods{$meth}};
	
	#prepare the result
	if (  $objects{$retour} ) {
	    $callb = "\t" . $retour . " x " . " = new " . $retour . "();\n";
	} else {
	    $callb = "\t" . $retour . " x ;\n"; 
	}
	$callb .= "\tx=  " . $callback . "." .$meth . "(" ;
	#prepare the function definition as well as the callback

	foreach ( @argsMethod  ) {
	    if ( $objects{$_} ) {
		@param =    @{$objects{$_}};
		$newObj = "\t".$_ . " o" . $iobj++ . " = new " . $_ . "( );\n";
		while ( ($n, $t , @param ) = @param ) {  
		    $def .= "\n\t\t". $t . " ". $n . ",";
		    $newObj .= "\to". $iobj.".".$n . " = " .$n .";\n" ; 
		}
		$callb .= "o".$iobj . ", ";
	    } else {
		$def .= "\n\t\t". $_ . " p". $ipar++ .",";
		$callb .= "p".$ipar . ", ";
		
	    }
	}
	if ( $objects{$retour} ) {
	    @param =    @{$objects{$retour}};
	    while ( ($n, $t , @param ) = @param ) {  
		$postcallb .= "\tresult.put( " . convertXmlRPCType ( $t, ".".$n ) .");\n";
	    }
	} elsif ($retour eq "void") {
	} else {
	    $postcallb .= "\tresult.put( " . convertXmlRPCType( $retour , "x" ) . "); \n";
	}
	    
	$_ = $def;
	s/,$//;
	$def = $_ . " )";
	$_ = $callb;
	s/, $//;
	$callb = $_ . " );\n" . "\tHashtable result = new Hashtable()";
	$callb .= "\n\n";
	$postcallb .= "\treturn result;\n}\n\n";
	print $def.= " throws RemoteException  {\n\n";	
	print $newObj . "\n";
	print $callb;
	print $postcallb;
    }
    # callback
}

sub JXMLRPCComm {
    my @param =();
    my %param=();
    my ($meth, $headerClass, $methodBodies);
    $headerClass= <<EOF;
package xtremweb.dispatcher;
import xtremweb.common.*;
import xtremweb.communications.*;

import java.util.*;
import java.lang.reflect.Array;
import java.security.*;

/**
 * Comm XMLRPC.java
 * Make XMLRPC communications
 * Generated from $filename
 * Created: Sun Jul  9 17:46:53 2000
 *
 * \@author $ENV{USER}
 * \@version
 */
EOF
    foreach $meth ( keys  %methods ) {
	my ($retour, $i, $paramtype,$postcallb, $callback)
	    =("",0,"","", ""); 
	my  @argsMethod=();
	my @paramObject=();
	($retour, @argsMethod )=   @{$methods{$meth}};
	$methodBodies .= JMethod( $meth,  @{$methods{$meth}}). " throws RemoteException {\n" ;

	$methodBodies .= "\tVector params         = new Vector();\n";
	
	foreach $paramtype ( @argsMethod  ) {
	    my ($n,$t)=("","");
	    if ( $objects{$paramtype} ) {
		@param =    @{$objects{$paramtype}};
		while ( ($n, $t , @param ) = @param ) {  
		    $methodBodies .= "\tparams.addElement( "
			. convertXmlRPCType( $t, "p$i.$n" ) .")\n";
		}
	    } else {
		$methodBodies .= "\tparams.addElement( "
		    . convertXmlRPCType( $paramtype, "p$i" ) .")\n";
	    }
	    $i++;
	}
	#callback
	
	$callback = "\n    try {\n\tHashtable result = (Hashtable) dispatcher.execute(\"Dispatcher.$meth\", params);\n\n"; 
	# post callback treatment and result preparation
	if ( $objects{$retour} ) {
	    $postcallb = "\t$retour retour = new $retour();\n";
	    my ($n,$t)=("","");
	    @param =    @{$objects{$retour}};
	    while ( ($n, $t , @param ) = @param ) { 
		$postcallb .= "\tretour.$n = ( " . convertFromXmlRPCType ( $t, $n ) .");\n";
	    }
	    $postcallb .= "\treturn retour;\n";
	} elsif ($retour eq "void") {
	    #no need for a return value
	} else {
#	    $postcallb = "\t$retour retour;\n";
	    $postcallb .= "\treturn ( " . convertFromXmlRPCType( $retour , "result" ) . "); \n";
#	    $postcallb .= "\t return retour;";
	}
	$methodBodies .= $callback .  $postcallb;
	$methodBodies .=<<EOF;
    } catch (XmlRpcException e) {
      throw new RemoteException("CommXMLRPC workRequest: XML-RPC Fault #" + e);
    } catch (Exception e) {
      throw new RemoteException("CommXMLRPC workRequest : " + e);
    }	    
}

EOF
    }
    print $headerClass . $methodBodies. "\n\n";
}


sub convertTCPType {
    my ( $type, $name ) = @_;
    return "\toutput.writeBoolean($name);\n" if ( $type eq "boolean" );
    return "\toutput.writeInt($name);\n"     if ( $type eq "int" );
    return "\toutput.writeDouble($name);\n"  if ( $type eq "double" );
    return "\toutput.writeByte($name);\n"    if ( $type eq "byte" );
    return "\tbuffer = ($name).getBytes();\n\toutput.writeInt( (int) buffer.length);\n\toutput.write(buffer,0,buffer.length);"
	if ( $type eq "String" );
}

sub convertFromTCPType {
    my ( $type, $name ) = @_;
    return "$name = input.readBoolean();\n"    if ( $type eq "boolean" );
    return "$name = input.readInt();\n"        if ( $type eq "int" );
    return "$name = input.readDouble();\n"     if ( $type eq "double" );
    return "$name = input.readByte();\n"       if ( $type eq "byte" );
    return "$name = \"Null\";\n\tint length = input.readInt();\n\tbuffer = new byte[ length ];\n\tint haBeenRead = input.read(buffer);\n\t $name =  new String(buffer);\n" 
	if ( $type eq "String" );
}
sub JTCPHandler {
    print "JTCPHandler not yet implemented\n";
}


sub JTCPComm {
    my @param =();
    my %param=();
    my ($meth, $methodBodies);
    foreach $meth ( keys  %methods ) {
	my ($retour, $i, $paramtype,$postcallb, $callback)
	    =("",0,"","", ""); 
	my  @argsMethod=();
	my @paramObject=();
	($retour, @argsMethod )=   @{$methods{$meth}};
	$methodBodies .= JMethod( $meth,  @{$methods{$meth}}). " throws RemoteException {\n" ;

	$methodBodies .= "\tbyte[] buffer; \n\ttry {\n";
	
	foreach $paramtype ( @argsMethod  ) {
	    my ($n,$t)=("","");
	    if ( $objects{$paramtype} ) {
		@param =    @{$objects{$paramtype}};
		while ( ($n, $t , @param ) = @param ) {  
		    $methodBodies .= convertTCPType( $t, "p$i.$n" ) ."\n";
		}
	    } else {
		$methodBodies .=  convertTCPType( $paramtype, "p$i" ) ."\n";
	    }
	    $i++;
	}
	#callback
	# post callback treatment and result preparation
	if ( $objects{$retour} ) {
	    $postcallb = "\t$retour retour = new $retour();\n";
	    my ($n,$t)=("","");
	    @param =    @{$objects{$retour}};
	    while ( ($n, $t , @param ) = @param ) { 
		$postcallb .= convertFromTCPType ( $t, "result.$n")."\n";
	    }
	    $postcallb .= "\treturn retour;\n";
	} elsif ($retour eq "void") {
	    #no need for a return value
	} else {
	    $postcallb .= "\t$retour ".convertFromTCPType( $retour , "result" );
	    $postcallb .= "\treturn result;\n";
	}
    
	$methodBodies .= $callback .  $postcallb;
	$methodBodies .=<<EOF;
    } catch (Exception e) {
      throw new RemoteException("CommTCP error : " + e);
    }	    
}

EOF
    }
    local *FICHIER = openFile( packageDir($packageDef{"name"}) . packageName("CommTCP", $packageDef{"name"}) );
    print FICHIER FileHeader(  packageName("CommTCP", $packageDef{"name"}) , 
			       "import java.io.*;import java.net.*;\n", 
			       "Creates TCP Communication to an TCP server"); 
    print FICHIER "".JClass( "CommTCP", $packageDef{"name"}, " extends CommTCPTemplate") . "\n";
    print  FICHIER $methodBodies . "\n}\n";
}

sub convertXmlRPCType {
    my ( $type, $name ) = @_;
    return "new " .$typeToObject{ $type } . "( ". $name . " )" if ($typeToObject{ $type });
}

sub convertFromXmlRPCType {
    my ( $type, $name ) = @_;
    return "( ($typeToObject{$type}) result.get(\"$name\"))".(($type
    eq "String")?"":(".".$type."Value()")) if ($typeToObject{$type});
}

sub JRMIClient {
    my ($meth);
    foreach $meth ( keys  %methods ) {
	print JMethod( $meth, @{$methods{$meth}} );
    }
}

sub parseIDLFile { 
    my ($shallow,$TempIDL,$First) ;
    my @result;
    print "Parsing $filename ... " if ($opts{"-verbose"});
    $TempIDL= `cat $filename`;
    print "done \n" if ($opts{"-verbose"});
    @result = $TempIDL =~ /$XML_SPE/g;
    shift(@result); 
#    print @result . "\n\n" if ($opts{"-verbose"});
    while (@result) {
	@result =   ShallowParse( join( "" , @result)  );
	$First = shift ( @result );
	if (isObject( $First )) {
	    @result = parseObject( $First, @result );
	} elsif (isMethod( $First )) {
	    @result= parseMethod( $First, @result );
	} elsif  (isPackage( $First )) {
	    @result= parsePackage( $First, @result );
	}
    }
}

sub usage {
    print <<EOF;
Usage: XwIDL -java -c -rmi -xmlrpc filename1.idl filename2.idl filename3.idl
    -java:    output java code
    -xmlrpc:  for xmlrpc method
    -rmi:     for rmi method
    -tcp:     for tcp method
    -comm:    to generate client side code
    -handler: to generate server side code
    -c:       ouptut c code
    -verbose: just guess
    -file:    generate file
    -headers: generate headers
    -interface:generate headers
Note: liste of files may be provided separated with ':' (a la java CLASSPATH)
EOF
    exit();
}

my @liste_args;

#Check & create the iface directory
unless ( -e '../iface' ) {
    mkdir ("../iface");
} 

unless ( -e '../obj' ) {
    mkdir ("../obj");
} 
 


#FIXME stupid stupid stupid (Ant)
if ($ARGV[0] eq "-ant-Linux") {
    @liste_args = split ( " ",$ARGV[1]);
    @files =  split( ":", $ARGV[2]);
} elsif ($ARGV[0] eq "-ant-Windows") {
    @liste_args = split ( " ",$ARGV[1]);
    @files =  split( ";", $ARGV[2]);
    $_ =~ s/\\/\//g foreach (@files);
    $_ =~ s/ /\\ /g foreach (@files);
} else {
    @liste_args = @ARGV;
}

foreach ( @liste_args ) {

    print "args " . $_ . "\n";

    usage if (/-help/);
    if ( /^-/ ) {
	$opts{$_} = 'ok';
    } else {
	push ( @files, $_ );
    }
}



if ( @files ) { 
    foreach( @files ) {
	$filename = "";
	%packageDef=();
	%methods=();
	%objects=();

	if ( $opts{"-java"} ) {
	    $filename= $_;
	    parseIDLFile();
	    Jheader() if ( $opts{"-headers"} ); #ok
	    JRMIInterface() if  ( $opts{"-interface"} );
	    if ( $opts{"-handler"} ) {
		JRMIHandler()  if ( $opts{"-rmi"} );
		JXMLRPCHandler()  if ( $opts{"-xmlrpc"} );
		JTCPHandler() if ( $opts{"-tcp"} );
	    }
	    if  ( $opts{"-comm"} ) {
		JRMIComm() if ( $opts{"-rmi"} ); #ok
		JXMLRPCComm() if ( $opts{"-xmlrpc"} );
		JTCPComm() if ( $opts{"-tcp"} );
	    }
	}
	if ( $opts{"-c"} ) {
	    $filename= $_;
	    parseIDLFile();
	     Cheader() if ( $opts{"-headers"} );
	}
    }
    print "\n" if $opts{"-verbose"};
}