#!/bin/perl
## Create the syntactic elements, thattake arguments and decide
## which operation to call.

$prefix = "E_" ;

## Templates

@tNumericOp = ( { "SYMBOL" => "+" ,
		 "CLASS" => "${prefix}Add" ,
		 "OPNAME"  => "add" } ,

	       { "SYMBOL" => "-" ,
		 "CLASS" => "${prefix}Subtract" ,
		 "OPNAME"  => "sub" } ,

	       { "SYMBOL" => "*" ,
		 "CLASS" => "${prefix}Multiply" ,
		 "OPNAME"  => "mul" } ,

	       { "SYMBOL" => "/" ,
		 "CLASS" => "${prefix}Divide" ,
		 "OPNAME"  => "div" } ,

	       { "SYMBOL" => "%" ,
		 "CLASS" => "${prefix}Modulus" , 
		 "OPNAME"  => "mod" } ,
	       ) ;

@tBooleanOp = ( { "SYMBOL" => "&&" ,
		 "CLASS" => "${prefix}LogicalAnd" ,
		 "PART_TEST" => "!" ,
		 "PART_RET" => "FALSE" ,
		 "OPNAME"  => "and" } ,

	       { "SYMBOL" => "||" ,
		 "CLASS" => "${prefix}LogicalOr" ,
		 "PART_TEST" => " " ,
		 "PART_RET" => "TRUE" ,
		 "OPNAME"  => "or" } 
	       ) ;

@tCompare = ( { "SYMBOL" => "==" ,
		 "CLASS" => "${prefix}Equal" ,    
		 "OPNAME"  => "eq" } ,

	       { "SYMBOL" => "!=" ,
		 "CLASS" => "${prefix}NotEqual" ,  
		 "OPNAME"  => "ne" } ,

	       { "SYMBOL" => "<" ,
		 "CLASS" => "${prefix}LessThan" ,
		 "OPNAME"  => "lt" } ,
	       { "SYMBOL" => "<=" ,
		 "CLASS" => "${prefix}LessThanOrEqual" ,
		 "OPNAME"  => "le" } ,

	       { "SYMBOL" => ">" ,
		 "CLASS" => "${prefix}GreaterThan" ,    
		 "OPNAME"  => "gt" } ,

	       { "SYMBOL" => ">=" ,
		 "CLASS" => "${prefix}GreaterThanOrEqual" ,  
		 "OPNAME"  => "ge" } ,
	       ) ;

# Builtins.
@tBuiltins = ( { "CLASS" => "${prefix}IsURI" ,
	     "OPNAME"  => "isURI" , 
	     NODE_TEST => "isURI" } ,

              { "CLASS" => "${prefix}IsLiteral" ,
		"OPNAME"  => "isLiteral" , 
		NODE_TEST => "isLiteral" } ,

              { "CLASS" => "${prefix}IsBlank" ,  
		"OPNAME"  => "isBlank" ,
		NODE_TEST => "isBlank" } ,
	      ) ;

# Value to Value : hard to generalize
@node_V_V = ( ) ;

# General
%misc = () ;

#$dir = "src/com/hp/hpl/jena/query/expr" ;

$templ_numeric     = readFile("templ_numeric.java") ;
$templ_boolean     = readFile("templ_boolean.java") ;
$templ_compare     = readFile("templ_compare.java") ;
# $templ_V_V       = readFile("templ_V_V.java") ;
$templ_builtin     = readFile("templ_builtin.java") ;


subst($templ_numeric,   \@tNumericOp) ;
subst($templ_boolean,   \@tBooleanOp) ;
subst($templ_compare,   \@tCompare) ;
subst($templ_builtin,   \@tBuiltins) ;
#subst($templ_V_V,  \@node_V_V) ;


# Special
foreach $t (keys %misc)
{
    #print "Template: $t\n" ;
    my $file = readFile($t) ;
    my $java= "$misc{$t}{CLASS}.java" ;
    print "Class: $java\n" ;
    $file = substOne($java, $file, $misc{$t} ) ;
    output($java, $file) ;
    
}

sub subst
{
    my($template, $nodes) = @_ ;

    foreach my $a (@$nodes)
    {
	my $file = $template ;
	my $java= "$$a{CLASS}.java" ;
	print "Class: $java\n" ;

	$file = substOne($java, $file, $a) ;

	# Check
	if ( $file =~ m/\#(.*)\#/g )
	{
	    $sym = $1 ;
	    print STDERR "Unresolved symbol: $sym: $java\n" ;
	    next ;
	}

	output($java, $file) ;
    }
}

sub output
{
    my ($java, $file) = @_ ;
    # Output
    open(J, ">$java") || die $! ;
    binmode J ;
    #open(J,">&STDOUT") || die $! ;
    print J $file ;
    close J ;
}

sub substOne
{
    my ($class, $file, $a) = @_ ;
    foreach $k (keys %$a)
    {
	#warn "$k: Empty string in substitution\n" if ( $$a{$k} eq '' ) ;
	$file =~ s/\#$k\#/$$a{$k}/g ;
    }
    return $file ;
}

sub readFile
{
    my $f = @_[0] ;
    open my $fh, "$f" or die $!;
    local $/;
    my $content = <$fh>;
    close $fh;
    # Remove any excess carriage returns
    $file =~ s/\r//g ;
    return $content ;
}