ant task in scala

3 files changed, 277 insertions, 8 deletions

diff --git a/Makefile b/Makefile
index 4bdbf5190a..3fb1448a9c 100644
--- a/Makefile
+++ b/Makefile
@@ -140,11 +140,11 @@ DTD2SCALA_RSRC_OUTPUTDIR = $(DTD2SCALA_ROOT:$(PROJECT_SOURCEDIR)/%=$(PROJECT_OUT
 
 # scala ant task
 SCALA4ANT_ROOT		 = $(PROJECT_SOURCEDIR)/scala/tools/scala4ant
-SCALA4ANT_LIST		+= AntAdaptor.java
-SCALA4ANT_LIST		+= AntTask.java
+SCALA4ANT_LIST		+= AntAdaptor.scala
+SCALA4ANT_LIST		+= AntTask.scala
 SCALA4ANT_SOURCES	+= $(SCALA4ANT_LIST:%=$(SCALA4ANT_ROOT)/%)
-SCALA4ANT_JC_FILES	+= $(SCALA4ANT_SOURCES)
-SCALA4ANT_JC_CLASSPATH	 = $(PROJECT_CLASSPATH):$(ANT_JARFILE)
+SCALA4ANT_SC_FILES	+= $(SCALA4ANT_SOURCES)
+SCALA4ANT_SC_CLASSPATH	 = $(PROJECT_CLASSPATH):$(ANT_JARFILE)
 
 # scalatest
 SCALATEST_ROOT		 = $(PROJECT_SOURCEDIR)/scala/tools/scalatest
@@ -234,7 +234,7 @@ scaladoc	: .latest-scaladoc-rsrc
 scalap		: .latest-scalap-sc
 dtd2scala	: .latest-dtd2scala-sc
 dtd2scala	: .latest-dtd2scala-rsrc
-scala4ant	: .latest-scala4ant-jc
+scala4ant	: .latest-scala4ant-sc
 scalatest	: .latest-scalatest-jc
 library-doc	: .latest-library-sdc
 
@@ -383,8 +383,8 @@ cvs-fix-perms		:
 	    $(DTD2SCALA_RSRC_OUTPUTDIR))
 	touch $@
 
-.latest-scala4ant-jc	: $(SCALA4ANT_JC_FILES)
-	@$(make) jc target=SCALA4ANT SCALA4ANT_JC_FILES='$?'
+.latest-scala4ant-sc	: $(SCALA4ANT_SC_FILES)
+	@$(make) sc target=SCALA4ANT SCALA4ANT_SC_FILES='$?'
 	touch $@
 
 .latest-scalatest-jc	: $(SCALATEST_JC_FILES)
@@ -460,7 +460,7 @@ $(TOOLS_JAR_ARCHIVE)	: .latest-scaladoc-rsrc
 $(TOOLS_JAR_ARCHIVE)	: .latest-scalap-sc
 $(TOOLS_JAR_ARCHIVE)	: .latest-dtd2scala-sc
 $(TOOLS_JAR_ARCHIVE)	: .latest-dtd2scala-rsrc
-$(TOOLS_JAR_ARCHIVE)	: .latest-scala4ant-jc
+$(TOOLS_JAR_ARCHIVE)	: .latest-scala4ant-sc
 $(TOOLS_JAR_ARCHIVE)	: .latest-scalatest-jc
 $(TOOLS_JAR_ARCHIVE)	:
 	@$(MAKE) jar target=TOOLS
diff --git a/sources/scala/tools/scala4ant/AntAdaptor.scala b/sources/scala/tools/scala4ant/AntAdaptor.scala
new file mode 100644
index 0000000000..affe233fb0
--- /dev/null
+++ b/sources/scala/tools/scala4ant/AntAdaptor.scala
@@ -0,0 +1,109 @@
+
+import scalac._;
+import scalac.util.Reporter;
+
+import org.apache.tools.ant.BuildException;
+import org.apache.tools.ant.Project;
+import org.apache.tools.ant.taskdefs.Execute;
+import org.apache.tools.ant.taskdefs.Javac;
+import org.apache.tools.ant.taskdefs.LogStreamHandler;
+import org.apache.tools.ant.taskdefs.compilers.DefaultCompilerAdapter;
+import org.apache.tools.ant.types.Commandline;
+import org.apache.tools.ant.types.Path;
+import java.io.IOException;
+
+package scala.tools.scala4ant {
+
+  /** a compiler adaptor for Scalac.
+  *
+  * author: Burak Emir
+  * adapted from package jaco.framework.ant.AntCompilerAdaptor
+  *  (part of Matthias Zenger's jaco framework)
+ */
+
+  class AntAdaptor extends DefaultCompilerAdapter {
+
+    var source:String = _;
+    var mytarget:String = _;
+
+    final val PRODUCT = System.getProperty("scala.product", "scalac");
+    final val VERSION = System.getProperty("scala.version", "unknown version");
+
+    def runCompiler(args:Array[String]) = {
+        var result = true;
+	// dirty work, to get rid of debugging (-g) option, set in setupJavac...
+
+	val nargs = new Array[ String ]( args.length - 2 );
+	var j = 0;
+	for( val  i <- List.range( 0, args.length-1 ) ) {
+	    if( !args( i ).startsWith("-g") ) {
+		//System.err.print( args[ i ] +" ")
+		nargs( j ) = args( i );
+                j = j + 1;
+	    }
+        }
+
+	// compile
+        val reporter = new Reporter();
+        val command = new CompilerCommand(PRODUCT, VERSION, reporter, new CompilerPhases());
+        if (command.parse(nargs) && command.files.list.size() > 0) {
+            val global = new Global(command);
+	    try {
+		global.compile(command.files.toArray(), false);
+	    } catch {
+                case e:Throwable => {
+                    e.printStackTrace();
+                    result = false;
+                    throw new BuildException(e.getMessage());
+                }
+            }
+            global.stop("total");
+            global.reporter.printSummary();
+	    /*
+	      PizzaSettings js = new PizzaSettings();
+	      js.parse(args);
+	      return js.JavaContext().JavaCompiler().compile();
+	    */
+	}
+	result;
+
+    }
+
+    def  compilerName() = "scalac";
+
+    override def setJavac( attributes:Javac ) = {
+      super.setJavac( attributes );
+      val myattribs = attributes.asInstanceOf[AntTask];
+      source = myattribs.getSource();
+      mytarget = myattribs.getTarget();
+
+    }
+
+    def execute() = {
+      attributes.log("Using " + compilerName() + " as scala compiler", Project.MSG_VERBOSE);
+      runCompiler( setupScalacCommand().getArguments() );
+    }
+
+    def setupScalacCommand() = {
+        val cmd = new Commandline();
+        setupJavacCommandlineSwitches(cmd);
+        //setupScalacCommandlineSwitches(cmd);
+        logAndAddFilesToCompile(cmd);
+        cmd
+    }
+
+    /*
+    def setupScalacCommandlineSwitches( cmd:Commandline ) = {
+        if (source != null) {
+            cmd.createArgument().setValue("-source");
+            cmd.createArgument().setValue(source);
+        }
+        if (target != null) {
+            cmd.createArgument().setValue("-target");
+            cmd.createArgument().setValue(target);
+        }
+    }
+    */
+
+  }
+}
diff --git a/sources/scala/tools/scala4ant/AntTask.scala b/sources/scala/tools/scala4ant/AntTask.scala
new file mode 100644
index 0000000000..603dc21149
--- /dev/null
+++ b/sources/scala/tools/scala4ant/AntTask.scala
@@ -0,0 +1,160 @@
+package scala.tools.scala4ant;
+
+import org.apache.tools.ant.BuildException;
+import org.apache.tools.ant.Project;
+import org.apache.tools.ant.taskdefs.Javac;
+import org.apache.tools.ant.util._;
+import java.io.File;
+import java.util._;
+
+
+/** Scala AntTask.
+ *
+ * adapted from package jaco.framework.ant.AntCompilerTask
+ *  (part of Matthias Zenger's jaco framework)
+ *
+ * @author  Burak Emir
+ * @version 1.5
+ * $Id$
+ */
+
+class AntTask extends Javac {
+
+    private var suffixes = "scala";
+    private var force = false;
+    private var source:String = null;
+    private var mytarget:String = null;
+    private val fileUtils:FileUtils  = FileUtils.newFileUtils();
+
+    override def execute():unit = {
+          val project = getProject();
+          //val old = project.getProperty("build.compiler");
+          project.setProperty("build.compiler", "scala.tools.scala4ant.AntAdaptor$class");
+          super.execute();
+          //if (old == null)
+          //     project.setProperty("build.compiler", "modern");
+          //else
+          //      project.setProperty("build.compiler", old);
+    }
+
+    def setForce( fc:boolean ) = {
+        force = fc;
+    }
+
+    def getForce() = {
+        force;
+    }
+
+    override def setSource( source:String ) = {
+        this.source = source;
+    }
+
+    override def getSource():java.lang.String = {
+        source;
+    }
+
+    override def setTarget( target:String ) = {
+        this.mytarget = target;
+    }
+
+    override def getTarget():java.lang.String = {
+        mytarget;
+    }
+
+    def setSuffixes( s:String ) = {
+        suffixes = s;
+    }
+
+    def getSuffixes() = {
+        suffixes;
+    }
+
+    def setScalaClasspath( s:String ) = {
+      System.setProperty("scala.class.path",s);
+      {}
+    }
+    def getScalaClasspath() = {
+	System.getProperty("scala.class.path");
+    }
+    def setScalaBootClasspath( s:String ) = {
+	System.setProperty("scala.boot.class.path",s);
+      {}
+    }
+    def getScalaBootClasspath() = {
+	System.getProperty("scala.boot.class.path");
+    }
+
+    protected def parseSuffixes():Array[String] = {
+        val st = new StringTokenizer(suffixes, " ,");
+        val al = new ArrayList();
+        while (st.hasMoreTokens()) {
+            al.add("." + st.nextToken());
+        }
+        al.toArray((new Array[String]( al.size() )).asInstanceOf[Array[java.lang.Object]]).asInstanceOf[Array[String]];
+    }
+
+    private def hasLegalSuffix( suffixes:Array[String], file:String ) = {
+        var res = false;
+        for ( val s <- new IterableArray( suffixes ).elements ) {
+            res = res | file.endsWith( s );
+        }
+        res
+    }
+
+    override protected def scanDir( srcDir:File, destDir:File, files:Array[String] ):unit = {
+        val sfx = parseSuffixes();
+        if( force ) {
+            val newCompileList = new Array[File]( compileList.length + files.length );
+            System.arraycopy(compileList, 0, newCompileList, 0, compileList.length);
+            var j = 0, i = 0;
+
+          def handleFile( theFile:String ):unit = { // this, because wile create anon-class -> access violation
+                if( hasLegalSuffix(sfx, theFile )) {
+                    if( srcDir == null ) {
+                        newCompileList( compileList.length + j ) = new File( theFile );
+                        j = j + 1;
+                    } else {
+                        newCompileList( compileList.length + j ) =
+                            fileUtils.resolveFile( srcDir, theFile );
+                        j = j + 1
+                    }
+                }
+          }
+
+          while( i < files.length ) {
+            handleFile( files( i ) );
+            i = i + 1;
+          }
+
+          if( j == files.length )
+              compileList = newCompileList;
+          else {
+            compileList = new Array[File]( j );
+            System.arraycopy(newCompileList, 0, compileList, 0, j);
+          }
+        } else {
+
+          val m = new GlobPatternMapper();
+
+          def handleNewFiles( newFiles:Array[File] ):unit = {
+            if( newFiles.length > 0 ) {
+              val newCompileList = new Array[ File ]( compileList.length +
+                                                     newFiles.length);
+              System.arraycopy(compileList, 0, newCompileList, 0,
+                               compileList.length);
+              System.arraycopy(newFiles, 0, newCompileList,
+                               compileList.length, newFiles.length);
+              compileList = newCompileList;
+            }
+          }
+
+          for (val i <- scala.List.range( 0, sfx.length )) {
+            m.setFrom("*" + sfx( i ));
+            m.setTo("*.class");
+            val sfs = new SourceFileScanner(this);
+            handleNewFiles( sfs.restrictAsFiles(files, srcDir, destDir, m) );
+          }
+
+        }
+    }
+}