#!/usr/bin/perl

#////////////////////////////////////////////////////////////
# v2j - vensim2java conversion script
#    very minor modifications by Brian Block (2006)
#	
#    original source:
#	 stella2java conversion script - Copyright 2000,
#    David Joiner and The Shodor Education Foundation, Inc.
#////////////////////////////////////////////////////////////

sub strip {
   my ($line) = @_;
   chomp $line;
   $line =~ s/\A\s+//g;
   $line =~ s/\s+\Z//g;
   return $line;
}

$tpnumber = $ARGV[1];

$tmp = "/tmp";
$tmp_dir = "v2j$tpnumber";



open (INPUTFILE,"< $tmp/$tmp_dir/inf") || die "can't open \n";

# start off with something that will read the input file
# go ahead and use INPUTFILE
$ivar=0;
$irate=0;
$iflow=0;
$iconv=0;
$ivarf=0;
while($line=<INPUTFILE>) {
   chomp $line;
   ($first_word,$name,$default,$min,$max,$style,$display,@rest)=split(/\s+/,$line);
   if($first_word eq 'VAR') {
      $var[$ivar]=strip($name);
      $varmin[$ivar]=strip($min);
      $varmax[$ivar]=strip($max);
      $vardef[$ivar]=strip($default);
      $vardeffunc[$ivar]="";
      $varstyle[$ivar]=strip($style);
      $vardisplay[$ivar]=strip($display);
      if ($vardef[$ivar] eq "VARDFUNC") {
         $line4=<INPUTFILE>;
         chomp $line4;
         $vardfflag=0;
         while($vardfflag==0) {
            $vardeffunc[$ivar]=$vardeffunc[$ivar].strip($line4)."@@@";
            $line4=<INPUTFILE>;
            chomp $line4;
            if($line4 =~ /ENDVARDFUNC/) {$vardfflag=1;}
         }
         #put in something here to JAVAIZE math functions
         $vardeffunc[$ivar] = javaize($vardeffunc[$ivar]);
      }
      $ivar++;
   }
   if($first_word eq 'RATE') {
      $rate[$irate]=strip($name);
      $ratemin[$irate]=strip($min);
      $ratemax[$irate]=strip($max);
      $ratedef[$irate]=strip($default);
      $ratedeffunc[$irate]="";
      $ratestyle[$irate]=strip($style);
      $ratedisplay[$irate]=strip($display);
      if ($ratedef[$irate] eq "RATEDFUNC") {
         $line4=<INPUTFILE>;
         chomp $line4;
         $ratedfflag=0;
         while($ratedfflag==0) {
            $ratedeffunc[$irate]=$ratedeffunc[$irate].strip($line4)."@@@";
            $line4=<INPUTFILE>;
            chomp $line4;
            if($line4 =~ /ENDRATEDFUNC/) {$ratedfflag=1;}
         }
         #put in something here to JAVAIZE math functions
         $ratedeffunc[$irate] = javaize($ratedeffunc[$irate]);
      }
      $irate++;
   }
   if($first_word eq 'VARFUNC') {
      $varfname[$ivarf]=strip($name);
      $varfdisplay[$ivarf]=strip($default);
      $line4=<INPUTFILE>;
      chomp $line4;
      $varf[$ivarf]="";
      $varfflag=0;
      while($varfflag==0) {
         $varf[$ivarf]=$varf[$ivarf].strip($line4)."@@@";
         $line4=<INPUTFILE>;
         chomp $line4;
         if($line4 =~ /ENDVARFUNC/) {$varfflag=1;}
      }
      #put in something here to JAVAIZE math functions
      $varf[$ivarf] = javaize($varf[$ivarf]);
      $ivarf++;
   }
   if($first_word eq 'CONVERTER') {
      $convname[$iconv]=strip($name);
      $convdisplay[$iconv]=strip($default);
      $line4=<INPUTFILE>;
      chomp $line4;
      $conv[$iconv]="";
      $convflag=0;
      while($convflag==0) {
         $conv[$iconv]=$conv[$iconv].strip($line4)."@@@";
         $line4=<INPUTFILE>;
         chomp $line4;
         if($line4 =~ /ENDCONVERTER/) {$convflag=1;}
      }
      #put in something here to JAVAIZE math functions
      $conv[$iconv] = javaize($conv[$iconv]);
      $iconv++;
   }
   if($first_word eq 'FLOW') {
      $flowname[$iflow]=strip($name);
      $flowdisplay[$iflow]=strip($default);
      $line2=<INPUTFILE>;
      chomp $line2;
      ($flowfrom[$iflow],$rest)=split(/\s+/,$line2);
      $line3=<INPUTFILE>;
      chomp $line3;
      ($flowto[$iflow],$rest)=split(/\s+/,$line3);
      $line4=<INPUTFILE>;
      chomp $line4;
      $flow[$iflow]="";
      $flowflag=0;
      while($flowflag==0) {
         $flow[$iflow]=$flow[$iflow].strip($line4)."@@@";
         $line4=<INPUTFILE>;
         chomp $line4;
         if($line4 =~ /ENDFLOW/) {$flowflag=1;}
      }
      #put in something here to JAVAIZE math functions
      $flow[$iflow] = javaize($flow[$iflow]);
      $iflow++;
   }
   if($first_word =~ /TSTEP/) {
      $tstep=strip($name);
   }
   if($first_word =~ /INITTIME/) {
      $itime=strip($name);
   }
   if($first_word =~ /ENDTIME/) {
      $etime=strip($name);
   }
   if($first_word =~ /YMIN/) {
      $ymin=strip($name);
   }
   if($first_word =~ /YMAX/) {
      $ymax=strip($name);
   }
   if($first_word =~ /TITLE/) {
      $title=strip($name);
   }
   if($first_word =~ /DEPLABEL/) {
      $depLabel=strip($name);
   }

}
$nvar=$ivar;
$nrate=$irate;
$nflow=$iflow;
$nconv=$iconv;
$nvarf=$ivarf;
$nvartot=$nvar+$nvarf;

# for each flow, search and replace for each var and rate with
# variable names.

$derivlines="";
$ideriv=0;
print "Checking VARS\n";
for ($i=0; $i<$nvar; $i++) {
   if($vardef[$i] ne "VARDFUNC") {
      $dtname[$ideriv]=$var[$i];
      $dtline[$ideriv]="$var[$i]=$vardef[$i];\n";
   } else {
      $vardeffunc[$i] =~ s/@@@/\n/g;
      $vardeffunc[$i]=$var[$i]." = ".$vardeffunc[$i];
      chomp $vardeffunc[$i];
      $vardeffunc[$i]=$vardeffunc[$i].";\n";
      $dtline[$ideriv]=$vardeffunc[$i];
      $dtname[$ideriv]=$var[$i];
   }
   $ideriv++;
}
print "Checking RATES\n";
for ($i=0; $i<$nrate; $i++) {
   if($ratedef[$i] ne "RATEDFUNC") {
      $dtname[$ideriv]=$rate[$i];
      $dtline[$ideriv]="$rate[$i]=$ratedef[$i];\n";
   } else {
      $ratedeffunc[$i] =~ s/@@@/\n/g;
      $ratedeffunc[$i]=$rate[$i]." = ".$ratedeffunc[$i];
      chomp $ratedeffunc[$i];
      $ratedeffunc[$i]=$ratedeffunc[$i].";\n";
      $dtline[$ideriv]=$ratedeffunc[$i];
      $dtname[$ideriv]=$rate[$i];
   }
   $ideriv++;
}
print "Checking VARFUNCS\n";
for ($i=0; $i<$nvarf; $i++) {
   $varf[$i] =~ s/@@@/\n/g;
   $varf[$i]=$varfname[$i]." = ".$varf[$i];
   chomp $varf[$i];
   $varf[$i]=$varf[$i].";\n";
   $dtline[$ideriv]=$varf[$i];
   $dtname[$ideriv]=$varfname[$i];
   $ideriv++;
}
print "Checking FLOWS\n";
$igraph=0;
for ($i=0; $i<$nflow; $i++) {
   $flow[$i] =~ s/@@@/\n/g;
   #check for graphs
   $graphline=$flow[$i];
   $graphline =~ s/\(/ /g;
   $graphline =~ s/\)/ /g;
   $graphline =~ s/,/ /g;
   $graphline=strip($graphline);
   ($word1,$word2,$word3,@rest) = split(/\s+/,$graphline);
   print "GRAPHS --- $word1  | $word2  |  $word3   |   $graphline \n";
   if($word1 =~ /\bgraph\b/i) {
      $graphname[$igraph]=$flowname[$i];
      $graphtype[$igraph]=$word2;
      $graphdep[$igraph]=$word3;
      #ok, this handles the lines to call the graph, but what about setting
      #up the graph?
      $graphline=join(" ",@rest);
      $graphline =~ s/\(/ /g;
      $graphline =~ s/\)/ /g;
      $graphline =~ s/,/ /g;
      $graphline = strip($graphline);
      @grapharray=split(/\s+/,$graphline);
      $graphnum=@grapharray/2;
      $graphx[$igraph]="";
      $graphy[$igraph]="";
      for ($j=0;$j<$graphnum;$j++) {
         $tj=2*$j;
         $tj1=2*$j+1;
         $graphx[$igraph]=$graphx[$igraph]."$grapharray[2*$j] ";
         $graphy[$igraph]=$graphy[$igraph]."$grapharray[2*$j+1] ";
      }
      $flow[$i]=$flowname[$i]."= graph($igraph,$graphdep[$igraph]);\n";
      $igraph++;
   } else {
      $flow[$i]=$flowname[$i]." = ".$flow[$i];
      chomp $flow[$i];
      $flow[$i]=$flow[$i].";\n";
   }
   $derivlines=$derivlines."      double ".$flowname[$i].";\n";
   $dtline[$ideriv]=$flow[$i];
   $dtname[$ideriv]=$flowname[$i];
   $ideriv++;
}
print "Checking CONVERTERS\n";
for ($i=0;$i<$iconv;$i++) {
   $conv[$i] =~ s/@@@/\n/g;
   #check for graphs
   $graphline=$conv[$i];  
   $graphline =~ s/\(/ /g;
   $graphline =~ s/\)/ /g;
   $graphline =~ s/,/ /g;
   $graphline=strip($graphline);
   ($word1,$word2,$word3,@rest) = split(/\s+/,$graphline);
   print "GRAPHS --- $word1  | $word2  |  $word3   |   $graphline \n";
   if($word1 =~ /\bgraph\b/i) {
      $graphname[$igraph]=$convname[$i];
      $graphtype[$igraph]=$word2;
      $graphdep[$igraph]=$word3;
      #ok, this handles the lines to call the graph, but what about setting
      #up the graph?
      $graphline=join(" ",@rest);
      $graphline =~ s/\(/ /g;
      $graphline =~ s/\)/ /g;
      $graphline =~ s/,/ /g;
      $graphline = strip($graphline);
      @grapharray=split(/\s+/,$graphline);
      $graphnum=@grapharray/2;
      $graphx[$igraph]="";
      $graphy[$igraph]="";
      for ($j=0;$j<$graphnum;$j++) {
         $tj=2*$j;
         $tj1=2*$j+1;
         $graphx[$igraph]=$graphx[$igraph]."$grapharray[2*$j] ";
         $graphy[$igraph]=$graphy[$igraph]."$grapharray[2*$j+1] ";
      }
      $conv[$i]="conv[$i]= graph($igraph,$graphdep[$igraph]);\n";
      $igraph++;
   } else {
      $conv[$i]="conv[$i] = $conv[$i]";
      chomp $conv[$i];
      $conv[$i]=$conv[$i].";\n";
   }
   #$derivlines=$derivlines."      ".$conv[$i];
   $dtline[$ideriv]=$conv[$i];
   $dtname[$ideriv]=$convname[$i];
   $ideriv++;
}
$nderiv=$ideriv;
$ngraphs=$igraph;

#set up graph lines
$graphlines="      n_graphs=$ngraphs;\n      n_graph=new int[n_graphs];\n";
$graphlines=$graphlines."      type_graph=new int[n_graphs];\n";
$graphlines2="";
for($i=0;$i<$ngraphs;$i++) {
   @graphxa=split(/\s+/,$graphx[$i]);
   @graphya=split(/\s+/,$graphy[$i]);
   $graphnum=@graphxa;
   $graphlines=$graphlines."      n_graph[$i]=$graphnum;\n";
   $graphlines=$graphlines."      type_graph[$i]=$graphtype[$i]_GRAPH;\n";
   if($i==0) {
      $graphlines2=$graphlines2."      x_graph=new double[n_graphs][max_graph];\n";
      $graphlines2=$graphlines2."      y_graph=new double[n_graphs][max_graph];\n";
   }
   for($j=0;$j<$graphnum;$j++) {
      $graphlines2=$graphlines2."      x_graph[$i][$j]=$graphxa[$j];\n";
      $graphlines2=$graphlines2."      y_graph[$i][$j]=$graphya[$j];\n";
   }
}

#set up displaylines
print "CHECKING ITEMS TO BE DISPLAYED\n";
$displaylines="      allow_display = new boolean[n_tot];\n";
$displaylines=$displaylines."      default_display = new boolean[n_tot];\n";
$count=0;
for($i=0;$i<$nvar;$i=$i+1) {
   $displaylines=$displaylines."      allow_display[$count]=$vardisplay[$i];  //$var[$i]\n";
   $displaylines=$displaylines."      default_display[$count]=$vardisplay[$i];\n";
   $count++;
}
for($i=0;$i<$nvarf;$i=$i+1) {
   $displaylines=$displaylines."      allow_display[$count]=$varfdisplay[$i];  //$varfname[$i]\n";
   $displaylines=$displaylines."      default_display[$count]=$varfdisplay[$i];\n";
   $count++;
}
for($i=0;$i<$nrate;$i=$i+1) {
   $displaylines=$displaylines."      allow_display[$count]=$ratedisplay[$i];  //$convname[$i]\n";
   $displaylines=$displaylines."      default_display[$count]=$ratedisplay[$i];\n";
   $count++;
}
for($i=0;$i<$nconv;$i=$i+1) {
   $displaylines=$displaylines."      allow_display[$count]=$convdisplay[$i];  //$convname[$i]\n";
   $displaylines=$displaylines."      default_display[$count]=$convdisplay[$i];\n";
   $count++;
}
for($i=0;$i<$nflow;$i=$i+1) {
   $displaylines=$displaylines."      allow_display[$count]=$flowdisplay[$i];  //$convname[$i]\n";
   $displaylines=$displaylines."      default_display[$count]=$flowdisplay[$i];\n";
   $count++;
}
$tcount=0;
while ($displaylines =~ s/DISP_TRUE/true/) {$tcount++;}
$displaylines =~ s/DISP_FALSE/false/g;

if($tcount>9) {
   print "---- WARNING ---- $tcount items selected for display.\n";
   print "     Stella2Java allows a maximum of 9.\n";
}



#check for conditional statements

for($i=0;$i<$nderiv;$i=$i+1) {
   $dtline[$i]=condition($dtline[$i]);
   #$dtline[$i]=javaize($dtline[$i]);
}

print "ABOUT TO SORT AND CHECK FOR CIRCULAR REFERENCES\n";
$sortdone=0;
$sortcount=0;
while($sortdone==0) {
	#sort lines to be written in deriv routine.
	for($i=0;$i<$nderiv;$i++) {
		for($j=$i+1;$j<$nderiv;$j++) {
			#if line i contains name j, name j should be computed
			#first, so swap.
			if($dtline[$i] =~ /\b$dtname[$j]\b/) {
				$tname=$dtname[$i];
				$tline=$dtline[$i];
				$dtname[$i]=$dtname[$j];
				$dtline[$i]=$dtline[$j];
				$dtname[$j]=$tname;
				$dtline[$j]=$tline;
			}
		}
	}
	#after sorintg, check for circular references
	$sortdone=1;
	for($i=0;$i<$nderiv;$i++) {
		$lflag=0;
		for($j=$i+1;$j<$nderiv;$j++) {
			#if line i containsany of the names from j or greater,
			#fail circular reference check.
			if($dtline[$i] =~ /\b$dtname[$j]\b/) {
				if($sortcount>100) {
					print "FAILED CIRCULAR RERERENCE CHECK\n";
					exit;
				}
				$sortdone=0;
				print "CIRCULAR REFERENCE CHECK, PASS $sortcount\n";
			}
		}
	}
	$sortcount++;
}
$incondlines=$derivlines;
$initlines=$derivlines;
#replace actual names with variable names
for($i=0;$i<$nderiv;$i++) {
   $varfflag=0;
   $varflag=0;
   $rateflag=0;
   for ($j=0;$j<$nvar;$j++ ) {
      $dtline[$i] =~ s/\b$var[$j]\b/x[$j]/g;
      if($dtname[$i]=~/\b$var[$j]\b/) {$varflag=1;}
   }
   for ($j=0;$j<$nvarf;$j++ ) {
      $dtline[$i] =~ s/\b$varfname[$j]\b/x[$j+n_vars]/g;
      if ($dtname[$i] =~ /\b$varfname[$j]\b/) {$varfflag=1;}
   }
   for ($j=0;$j<$nrate;$j++ ) {
      $dtline[$i] =~ s/\b$rate[$j]\b/rate[$j]/g;
      if($dtname[$i]=~/\b$rate[$j]\b/) {$rateflag=1;}
   }
   for ($j=0;$j<$nconv;$j++) {
      $dtline[$i] =~ s/\b$convname[$j]\b/conv[$j]/g;
   }
   for ($j=0;$j<$nflow;$j++) {
      $dtline[$i] =~ s/\b$flowname[$j]\b/flow[$j]/g;
   }
   $incondlines=$incondlines."      ".$dtline[$i];
   if ($varflag==0&&$rateflag==0) {
      $initlines=$initlines."      ".$dtline[$i];
   }
   if ($varfflag==0&&$varflag==0&&$rateflag==0) {
      $derivlines=$derivlines."      ".$dtline[$i];
   }
}

for($i=0;$i<$nvar;$i++) {
   $prime[$i]="xprime[$i]=";
   $ientered=0;
   for($j=0;$j<$nflow;$j++) {
      if($flowfrom[$j] eq $var[$i]) {
         $prime[$i]=$prime[$i]."-flow[$j]";
         $ientered++;
      }
      if($flowto[$j] eq $var[$i]) {
         if($ientered==0){
            $prime[$i]=$prime[$i]."flow[$j]";
            $ientered++;
         } else {
            $prime[$i]=$prime[$i]."+flow[$j]";
            $ientered++;
         }
      }
   }
   if($ientered==0) {$prime[$i]=$prime[$i]."0.0";}
   $derivlines=$derivlines."      ".$prime[$i].";\n";
}
for($i=0;$i<$nvarf;$i++) {
   $prime[$i]="xprime[$i+n_vars]=";
   $ientered=0;
   for($j=0;$j<$nflow;$j++) {
      if($flowfrom[$j] eq $varfname[$i]) {
         $prime[$i]=$prime[$i]."-flow[$j]";
         $ientered++;
      }
      if($flowto[$j] eq $varfname[$i]) {
         if($ientered==0){
            $prime[$i]=$prime[$i]."flow[$j]";
            $ientered++;
         } else {
            $prime[$i]=$prime[$i]."+flow[$j]";
            $ientered++;
         }
      }
   }
   $derivlines=$derivlines."      ".$prime[$i].";\n";
}

# need to create strings of the following, as one string.
$labelstring="";
for($i=0;$i<$nvar;$i++) {
   $labelstring=$labelstring."      var_label[$i]=\"".$var[$i]."\";\n";
}
for($i=0;$i<$nvarf;$i++) {
   $labelstring=$labelstring."      varf_label[$i]=\"".$varfname[$i]."\";\n";
}
for($i=0;$i<$nrate;$i++) {
   $labelstring=$labelstring."      rate_label[$i]=\"".$rate[$i]."\";\n";
}
for($i=0;$i<$nconv;$i++) {
   $labelstring=$labelstring."      conv_label[$i]=\"".$convname[$i]."\";\n";
}
for($i=0;$i<$nflow;$i++) {
   $labelstring=$labelstring."      flow_label[$i]=\"".$flowname[$i]."\";\n";
}



$defstrings="";
for($i=0;$i<$nvar;$i++) {
   $defstrings=$defstrings."      var_minsb[$i]=$varmin[$i];\n";
}
for($i=0;$i<$nrate;$i++) {
   $defstrings=$defstrings."      rate_minsb[$i]=$ratemin[$i];\n";
}
for($i=0;$i<$nvar;$i++) {
   $defstrings=$defstrings."      var_maxsb[$i]=$varmax[$i];\n";
}
for($i=0;$i<$nrate;$i++) {
   $defstrings=$defstrings."      rate_maxsb[$i]=$ratemax[$i];\n";
}
for($i=0;$i<$nvar;$i++) {
   $defstrings=$defstrings."      var_defaultsb[$i]=x[$i];\n";
}
for($i=0;$i<$nrate;$i++) {
   $defstrings=$defstrings."      rate_defaultsb[$i]=rate[$i];\n";
}
for($i=0;$i<$nvar;$i++) {
   $defstrings=$defstrings."      var_stylesb[$i]=$varstyle[$i];\n";
}
for($i=0;$i<$nrate;$i++) {
   $defstrings=$defstrings."      rate_stylesb[$i]=$ratestyle[$i];\n";
}

#checking for graph labels
if ($title eq '') {
    $titleString = "";
} else {
    $titleString = "    gr_title = new String(\"$title\");";
}

if ($depLabel eq '') {
    $depLabelString = "";
} else {
	$depLabelString = "    gr_depLabel = new String(\"$depLabel\");";
}


open (MODELFILE,">$tmp/$tmp_dir/Model.java")|| die "can't create" ;
write (MODELFILE);
close (MODELFILE);

print "SCRIPT COMPLETED\n";

sub condition {

   my($teststring)=@_;
   my(@testa,$count,$fullline,$elsecount,$parenth,$line,$junk,@lastif);
   my(@firstif,$levelstring,$parenthcount,$i);
   my($arg,@rest);
   $teststring = strip($teststring);

   $teststring =~ s/\bif\b/ IF /gi;
   $teststring =~ s/\bthen\b/ THEN /gi;
   $teststring =~ s/\belse\b/ ELSE /gi;
   $teststring =~ s/\bor\b/||/gi;
   $teststring =~ s/\bnot\b/!/gi;
   $teststring =~ s/\band\b/&&/gi;
   @testa=split(/\bIF\b/,$teststring);

   $count=0;
   $fullline="";
   $elsecount=0;
   $parenth=0;
   foreach $line (@testa) {
      chomp($line);
      $line = strip($line);
      if ($count>0) {
      
         $fullline = $fullline."\n      if ( ";
         $junk = $line;
         $junk =~ s/\=/\=\=/g;
         $junk =~ s/([><!])\=\=/$1\=/g;
         $junk =~ s/\bELSE\Z/ else /g;
         $junk =~ s/\bELSE\b/ else $arg = /g;
         $junk =~ s/\belse\b/ ELSE /g;

         if ($junk =~ s/\bTHEN\Z/ ) {/g) {$parenth++;}
         if ($junk =~ s/\bTHEN\b/ ) { $arg = /g) {$parenth++;}
         push(@lastif,$parenth);

         if ($junk =~ s/\bELSE\b/\;\n      } else {/) {pop(@lastif);}
         if ($junk =~ /ELSE/) {
            $levelstring="";
            @firstif = reverse(@lastif);
            $parenthcount=-1;
            for ($i=$firstif[0];$i<=$parenth;$i++) {
               $levelstring=$levelstring."\n      }";
               $parenthcount++;
            }
            while ($junk =~ s/\bELSE\b/\; $levelstring else {/) { 
               $parenth=$parenth-$parenthcount;
               pop(@lastif);
               if ($line =~ /ELSE/) {
                  $levelstring="";
                  $parenthcount=-1;
                  @firstif = reverse(@lastif);
                  for ($i=$firstif[0];$i<=$parenth;$i++) {
                     $levelstring=$levelstring."\n      }";
                     $parenthcount++;
                  }
               }
            }
         }
         $fullline = $fullline.$junk;
      } else {
         ($arg,@rest) = split(/=/,$line);
      }
      $count++;
   }
   #$fullline=$fullline.";";
   for($i=0;$i<$parenth;$i++) {
      $fullline=$fullline."\n      }";
   }
   @firstif = reverse(@lastif);
   if($count==1) {
      $fullline = $teststring;
   }
   return $fullline."\n";
}


sub javaize {
   my($localstring) = @_;
   
   my($i,$j,$level,$toplevel);

   $localstring =~ s/\btime\b/time/gi;
   $localstring =~ s/\bpulse\b/pulse/gi;
   $localstring =~ s/\bramp\b/ramp/gi;
   $localstring =~ s/\bstep\b/step/gi;
   $localstring =~ s/\bdt\b/st/gi;

   #check for comments
   $localstring =~ s/\{(.*)\}//g;

#     ig  options are i - case insensitive, and g, do em all.
   $localstring =~ s/\barcsin\s*\(\s*/temparcsn\(/ig;
   $localstring =~ s/\barccos\s*\(\s*/temparccs\(/ig;
   $localstring =~ s/\barctan\s*\(\s*/temparctn\(/ig;
   $localstring =~ s/\bsin\s*\(\s*/Math.sin\(/ig;
   $localstring =~ s/\bcos\s*\(\s*/Math.cos\(/ig;
   $localstring =~ s/\btan\s*\(\s*/Math.tan\(/ig;
   $localstring =~ s/\btemparcsn\s*\(\s*/Math.asin\(/ig;
   $localstring =~ s/\btemparccs\s*\(\s*/Math.acos\(/ig;
   $localstring =~ s/\btemparctn\s*\(\s*/Math.atan\(/ig;
   $localstring =~ s/\bexp\s*\(\s*/Math.exp\(/ig;
   $localstring =~ s/\blog\s*\(\s*/Math.log\(/ig;
   #(stella = logn, vensim = ln)
   $localstring =~ s/\bln\s*\(\s*/Math.log\(/ig;
   $localstring =~ s/\blog10\s*\(\s*/log10\(/ig;
   $localstring =~ s/\brandom\s*\(\s*\b/random\(/gi;
   $localstring =~ s/\bnormal\s*\(\s*\b/normal\(/gi;
   $localstring =~ s/\bpoisson\s*\(\s*\b/poisson\(/gi;
   #(stella = int, vensim = integer)
   $localstring =~ s/\binteger\s*\(\s*\b/to_int\(/gi;
   $localstring =~ s/\babs\s*\(\s*/Math.abs\(/ig;
   $localstring =~ s/\bsqrt\s*\(\s*/Math.sqrt\(/ig;
   $localstring =~ s/\bmax\s*\(\s*/Math.max\(/ig;
   $localstring =~ s/\bmin\s*\(\s*/Math.min\(/ig;
   #changed 'mod' to 'modulo' (stella = mod, vensim = modulo)
   $localstring =~ s/\bmodulo\s*\(\s*/remainder\(/ig;
   
   #check for integers, temporarily do a search and replace
   #on arithmetic operations and parentheses to create word
   #boundaries for integers next to them.

   #deal with the ^ operator.
   
   #put extra spaces in, if then and else can be mistaken for a function if next to 
   # a set of parentheses. - future debugging check, can the code handle parnetheses
   # that are simply there for grouping purposes?
   $localstring =~ s/\bif\b/ if /gi;
   $localstring =~ s/\bthen\b/ then /gi;
   $localstring =~ s/\belse\b/ else /gi;   
   
   

   #check and numebr parentheses
   $localstring =~ s/(\d*)\.(\d*)/$1___POINT___$2/g;
   $level=1;$toplevel=1;
   $localstring =~ s/(\(|\))/ if ($1 eq "(") {if ($level+1>$toplevel)
      {$toplevel = $level+1} "___LPARENTH".$level++."___";} else
      {"___RPARENTH".--$level."___";}/ge;
   
   $localstring =~ s/\=/___EQUALS___/g;
   
   @contain_check = qw {time if ___EQUALS____   then  graph else or and not};
   #add extra parentheses around function calls
   for($i=1;$i<=$toplevel;$i=$i+1) {
      $localstring =~ s/\b(\w+)(\s*)___LPARENTH($i)___(.*?)___RPARENTH($i)___/if (contain($1,@contain_check)==1)
      { sprintf("$1($4)"); }
      else { print "FOUND A FUNCTION   $1  |  $4   \n";sprintf("($1($4))"); }/ge;
   }
   $localstring =~ s/___POINT___/\./g;
   $localstring =~ s/___EQUALS___/\=/g;
   
   #strip parenthese
   $localstring =~ s/___LPARENTH(\d+)___/\(/g;
   $localstring =~ s/___RPARENTH(\d+)___/\)/g;
   
   #refigure parentheses including functions
   $level=1;$toplevel=1;
   $localstring =~ s/(\(|\))/ if ($1 eq "(") {$toplevel++; "___LPARENTH".$level++."___ ";} else
      {" ___RPARENTH".--$level."___";}/ge;
   
   #check for exponential notation, decimal points
   $localstring =~ s/(\d+)E\-/$1___EXPONMINUS\./gi;
   $localstring =~ s/(\.)E\-/$1___EXPONMINUS\./gi;
   $localstring =~ s/(\d*)\.(\d*)/$1___POINT___$2/g;
   $localstring =~ s/\-/___MINUS___/g;
   
   #look for exponentiation operator (^), replace with POW function
   for ($i=$toplevel;$i>=0;$i=$i-1) {
      for($j=$toplevel;$j>=0;$j=$j-1) {
         if($i==1&&$j==0) {
            $localstring =~ s/(\w+)\^(\w+)/Math.pow\($1,$2\)/gx;
            print "POW 1  $1  $2\n";
         } elsif ($i==0) {
            $localstring =~ s/(\w+)\^___LPARENTH($j)___(.*?)___RPARENTH($j)___/Math.pow\($1,$3\)/gx;
            print "POW 2  $1  $3\n";
         } elsif ($j==0) {
            $localstring =~ s/___LPARENTH($i)___(.*?)___RPARENTH($i)___\^(\w+)/Math.pow\($2,$4\)/gx;
            print "POW 3  $2  $4  \n";
         } else {
            $localstring =~
   s/___LPARENTH($i)___(.*?)___RPARENTH($i)___\^___LPARENTH($j)___(.*?)___RPARENTH($j)___/Math.pow\($2,$5\)/gx;
            print "POW 4 $2 $5\n";
         }
      }
   }
   
   #remove decimal point and exponential notation markers
   $localstring =~ s/___POINT___/\./g;
   $localstring =~ s/___EXPONMINUS\./E\-/g;
   $localstring =~ s/___MINUS___/\-/g;
   $localstring =~ s/___LPARENTH(\d+)___ /\(/g;
   $localstring =~ s/ ___RPARENTH(\d+)___/\)/g;

   
#   $localstring =~ s/\//sprintf(" ___DIVIDED_BY ")/ge;
#   $localstring =~ s/\*/sprintf(" ___TIMES ")/ge;
#   $localstring =~ s/\+/sprintf(" ___PLUS ")/ge;
#   $localstring =~ s/\-/sprintf(" ___MINUS ")/ge;
#   $localstring =~ s/\(/sprintf(" ___LEFT_PARENTH ")/ge;
#   $localstring =~ s/\)/sprintf(" ___RIGHT_PARENTH ")/ge;
#   $localstring =~ s/\>/sprintf(" ___GREATER_THAN ")/ge;
#   $localstring =~ s/\</sprintf(" ___LESS_THAN ")/ge;
#   $localstring =~ s/\=/sprintf(" ___EQUALS ")/ge;
#   $localstring =~ s/\,/sprintf(" ___COMMA ")/ge;
#   $localstring =~ s/@@@/\n/g;
#   $localstring =~ s/[^\.]\b(\d+)\b[^\.]/sprintf(" %.1f ",$1)/ge;
#   $localstring =~ s/___DIVIDED_BY/\//g;
#   $localstring =~ s/___TIMES/\*/g;
#   $localstring =~ s/___PLUS/\+/g;
#   $localstring =~ s/___MINUS/\-/g;
#   $localstring =~ s/___LEFT_PARENTH/\(/g;
#   $localstring =~ s/___RIGHT_PARENTH/\)/g;
#   $localstring =~ s/___GREATER_THAN/\>/g;
#   $localstring =~ s/___LESS_THAN/\</g;
#   $localstring =~ s/___EQUALS/\=/g;
#   $localstring =~ s/___COMMA/\,/g;
#   $localstring =~ s/\n/@@@/g;


#search for digitE- or .E-, replace E- with ___EXPONMINUS\.
   $localstring =~ s/(\d+)E\-/$1___EXPONMINUS\./g;
   $localstring =~ s/(\.)E\-/$1___EXPONMINUS\./g;
   $localstring =~ s/@@@/\n/g;
   $localstring =~ quotemeta $localstring;
   $localstring =~ s/\\\./\./g;
   $localstring =~ s/([^\.])\b(\d+)\b([^\.])/sprintf("$1%.1f$3",$2)/ge;
   $localstring =~ s/^(\d+)\b([^\.])/sprintf("%.1f$2",$1)/ge;
   $localstring =~ s/([^\.])\b(\d+)$/sprintf("$1%.1f",$2)/ge;
   $localstring =~ s/^(\d+)$/sprintf("%.1f",$1)/ge;
   $localstring =~ s/___EXPONMINUS\./E\-/g;
   $localstring =~ s/\\//g;
   
   return $localstring;
}

sub contain {
   my($var1,@var2) =@_;

   my($length);
   $length=@var2;
   my($i);
   my($retflag)=0;
   for($i=0;$i<$length;$i=$i+1) {
      if ($var1 =~ /\b$var2[$i]\b/i) {
         $retflag = 1;
      }
   }
   return $retflag;
}





format MODELFILE=
/*
 * THIS FILE IS AUTOMATICALLY GENERATED BY THE s2j SCRIPT
 * DO NOT EDIT.
 * If you wish to make permanent changes, you should use this file
 * to test your changes, and then modify s2j so that the automatically
 * generated version of Model.java has those changes.
 * When committing changes to CVS, please commit both the s2j
 * script and the new version of Model.java
 */
/*
 * Model.java - stella2java model file.
 * Copyright 1999-2003 David A. Joiner and the Shodor Edcuation
 * Foundation, Inc.
 */
import java.awt.*;
import java.applet.Applet;
import java.util.*;

class Model extends Diffeq {


   double PI = 3.14159;

   Random randomNumber = new Random();

   double tinitial;
   double tfinal;
   double tstep_default;
   
   int try_model=0;

   int ntime;
   double []xtime;

   int method;

   int n_vars;
   int n_varfs;
   int n_vartot;
   int n_rates;
   int n_convs;
   int n_flows;
   int n_graphs;
   int n_tot;
   String [] var_label;
   String [] varf_label;
   String [] rate_label;
   String [] conv_label;
   String [] flow_label;
   String output_header;
   double [] var_minsb;
   double [] rate_minsb;
   double [] var_maxsb;
   double [] rate_maxsb;
   double [] var_defaultsb;
   double [] rate_defaultsb;
   int [] var_stylesb;
   int [] rate_stylesb;
   double ymin_default;
   double ymax_default;
   double [] rate;
   double [] conv;
   double [] flow;
   double [][] x_graph;
   double [][] y_graph;
   int [] type_graph;
   int [] n_graph;
   static int LINE_GRAPH=0;
   static int BOX_GRAPH=1;
   boolean [] allow_display;
   boolean [] default_display;
   String gr_title;
   String gr_depLabel;

   boolean it_enable;
   boolean ft_enable;
   boolean st_enable;
   boolean imeth_enable;
   boolean ymin_enable;
   boolean ymax_enable;
   boolean adap_enable;
   boolean adap_default;

   double tstep;

   public void init_problem(double st){
     
      // set default status of control display. 
      it_enable=true;
      ft_enable=true;
      st_enable=true;
      imeth_enable=true;
      ymin_enable=true;
      ymax_enable=true;
      adap_enable=true;
      adap_default=true;
  
      tstep_default=@<<<<<<;
$tstep
      ymin_default=@<<<<<<;
$ymin
      ymax_default=@<<<<<<;
$ymax
      tinitial=@<<<<<<<<<<;
$itime
      tfinal=@<<<<<<<<<<<<;
$etime
      tstep=st;
      time=tinitial;
      
// CHANGE THE FOLLOWING WHEN USING THIS TEMPLATE //
// --- Set the number of variables and rates --- //
      n_vars=@<;
$nvar
      n_varfs=@<;
$nvarf
      n_vartot=n_vars+n_varfs;
      n_rates=@<;
$nrate
      n_convs=@<;
$nconv
      n_flows=@<;
$nflow
      n_tot=n_vartot+n_rates+n_convs+n_flows;

@*
$displaylines;

@*
$graphlines

      int max_graph=0;

      for (int i=0;i<n_graphs;i++) {
         if(n_graph[i]>max_graph) max_graph=n_graph[i];
      }

@*
$graphlines2


// --------------------------------------------- //
      init(n_vartot);
      rate = new double[n_rates];
      conv = new double[n_convs];
      flow = new double[n_flows];

      ntime=100;
      xtime = new double[ntime*(1+n_tot)];

      var_label=new String[n_vars];
      varf_label=new String[n_varfs];
      rate_label=new String[n_rates];
      conv_label=new String[n_convs];
      flow_label=new String[n_flows];

      var_minsb=new double[n_vars];
      rate_minsb=new double[n_rates];
      var_maxsb=new double[n_vars];
      rate_maxsb=new double[n_rates];
      var_defaultsb=new double[n_vars];
      rate_defaultsb=new double[n_rates];
      var_stylesb=new int[n_vars];
      rate_stylesb=new int[n_rates];

// --- Set default size and value for model ---- // 
@*
$incondlines

@*
$defstrings

@*
$titleString

@*
$depLabelString
      
// --------------------------------------------- //

// ------- Label variables and rates ----------- //     
@*
$labelstring
      output_header=new String();
// --- Set the header line for text output ----- //
      output_header= "\tTime\tvar1\tvar2\tvar3 \n";

      output_header+="---------------------------------------------------";
// --------------------------------------------- //
      method=EULER;
   }

   public void reset_xtime(int newn) {
      if(newn==ntime) return;
      ntime=newn;
      xtime = new double[ntime*(1+n_tot)];
   }


   public void solve(double [] x_var, double [] x_rate,
      double it, double ft,double st, boolean adaptive){

      tinitial=it;
      tfinal=ft;
      time=tinitial;
      tstep=st;

      int newn=(int)((tfinal-tinitial)/st)+1;
      reset_xtime(newn);

      for(int i=0;i<n_vars;i++) {
         x[i]=x_var[i];
      }
      for(int i=0;i<n_rates;i++) {
         rate[i]=x_rate[i];
      }
      // initial values for nvarfs, as well as converters and flows
      // goes here.
@*
$initlines

      double tstep=(tfinal-tinitial)/(double)(ntime-1);
      
      for(int i=0;i<ntime;i++) {
         xtime[i]=time;
         for (int j=0; j<n_vartot; j++ ) {
            xtime[i+(j+1)*ntime]=x[j];
         }
         for (int j=0; j<n_rates; j++ ) {
            xtime[i+(j+n_vartot+1)*ntime]=rate[j];
         }
         for (int j=0; j<n_convs; j++ ) {
            xtime[i+(j+n_vartot+n_rates+1)*ntime]=conv[j];
         }
         for (int j=0; j<n_flows; j++ ) {
            xtime[i+(j+n_vartot+n_rates+n_convs+1)*ntime]=flow[j];
         }
         if(try_model==1) {
            if(adaptive) {
               updateAdaptive(tstep,0.1,0.01*tstep,method);
            } else {
               update(tstep,method);
            }
         }
      }
   }    
   public void deriv(int n,double t,double st,double x[],double xprime[]){
   
@*
$derivlines
	}
   
   //pulse function for vensim: returns 1.0 starting at time 'start'
   //and lasting for interval 'width'. returns 0.0 otherwise. 
   public double pulse(double vpulse_start, double vpulse_interval){
      if ( time >= (vpulse_start) && (time - vpulse_start) < (vpulse_interval)){
           	return 1.0;
      	
      }
      else { return 0.0; }
      
   }
   
   public double pulse(double x) {
      return (x/tstep);
   }

   public double pulse(double x, double first_t, double interval_t) {
      if (time>first_t && remainder(time,interval_t)>0.0 &&
	        remainder(time,interval_t)<=tstep) 
	     return (x/tstep);
      else
	     return 0.0;

   }

   public double ramp(double slope) {
       return time*slope;
   }

   public double ramp(double slope,double ramp_start) {
       if (time>ramp_start) {
           return (time-ramp_start)*slope;
       } else {
           return 0;
       }
   }

   public double step(double height,double step_time) {
       if(time>=step_time) {
           return height;
       } else {
           return 0;
       }
   }

   public double graph(int index,double dep_var) {
      //access xgraph_i,j, ygraph_i,j, ngraph_i, n_graphs.
      if(dep_var<x_graph[index][0]) {
         //take lower boundary value
         return y_graph[index][0];
      } else if(dep_var>x_graph[index][n_graph[index]-1]) {
         //take upper boundary value
         return y_graph[index][n_graph[index]-1];
      } else {
         //find which element to use, linear intepolation
         for(int i=0;i<n_graph[index]-1;i++) {
            if(dep_var>=x_graph[index][i]&&dep_var<x_graph[index][i+1]) {
               if(type_graph[index]==LINE_GRAPH) {
	                 double slope = (y_graph[index][i+1]-y_graph[index][i])/
	                    (x_graph[index][i+1]-x_graph[index][i]);
	                 return y_graph[index][i]+slope*(dep_var-x_graph[index][i]);
	              } else {
	                 return y_graph[index][i];
	              }
            }
         }
         return y_graph[index][n_graph[index]-1];
      }
   }
   
   public double remainder(double x, double y) {
      double temp=Math.IEEEremainder(x,y);
      if(temp<0.0) temp=temp+y;
      return temp;
   }

   public double log10(double x) {
      return Math.log(x)/Math.log(10.0);
   }

   public double random(double min, double max) {
      return min+(max-min)*Math.random();
   }

   public double normal(double mean, double standardDeviation){
      return mean + standardDeviation*randomNumber.nextGaussian();
   }

   public double to_int(double x) {
       return (int)x;
   }

   public double poisson(double mu) {
      int retval=1;
      double product=Math.random();
      double test = Math.exp(-mu);
      while (product>test) {
         retval++;
         product*=Math.random();
      }
      return (double)retval;
   }


 }
.