JIMS: can now compile a set of Java files 46/12046/2
Calixte DENIZET [Tue, 16 Jul 2013 15:36:49 +0000 (17:36 +0200)]
Change-Id: I11614e53e95c303b708836578788d6d8e2fe873e

scilab/modules/external_objects/src/cpp/compile.cpp
scilab/modules/external_objects_java/src/cpp/ScilabJavaEnvironment.cpp
scilab/modules/external_objects_java/src/java/org/scilab/modules/external_objects_java/ScilabJavaCompiler.java

index 8245a1e..1d5b26a 100644 (file)
@@ -1,6 +1,6 @@
 /*
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2012 - Scilab Enterprises - Calixte DENIZET
+ * Copyright (C) 2012 - 2013 - Scilab Enterprises - Calixte DENIZET
  *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
@@ -25,7 +25,8 @@ int ScilabGateway::compile(char * fname, const int envId, void * pvApiCtx)
     int ret = 0;
     int iType = 0;
 
-    CheckInputArgument(pvApiCtx, 2, 2);
+    CheckInputArgument(pvApiCtx, 1, 2);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
     ScilabAbstractEnvironment & env = ScilabEnvironments::getEnvironment(envId);
     ScilabGatewayOptions & options = env.getGatewayOptions();
@@ -33,9 +34,16 @@ int ScilabGateway::compile(char * fname, const int envId, void * pvApiCtx)
     ScilabObjects::initialization(env, pvApiCtx);
     options.setIsNew(false);
 
-    className = ScilabObjects::getSingleString(1, pvApiCtx);
+    if (Rhs == 1)
+    {
+        className = strdup("");
+    }
+    else
+    {
+        className = ScilabObjects::getSingleString(1, pvApiCtx);
+    }
 
-    err = getVarAddressFromPosition(pvApiCtx, 2, &addr);
+    err = getVarAddressFromPosition(pvApiCtx, Rhs, &addr);
     if (err.iErr)
     {
         freeAllocatedSingleString(className);
@@ -88,17 +96,25 @@ int ScilabGateway::compile(char * fname, const int envId, void * pvApiCtx)
     freeAllocatedSingleString(className);
     freeAllocatedMatrixOfString(row, col, code);
 
-    try
+    if (ret == -1)
     {
-        ScilabObjects::createEnvironmentObjectAtPos(EXTERNAL_CLASS, Rhs + 1, ret, envId, pvApiCtx);
+        LhsVar(1) = 0;
     }
-    catch (ScilabAbstractEnvironmentException & e)
+    else
     {
-        env.removeobject(ret);
-        throw;
+        try
+        {
+            ScilabObjects::createEnvironmentObjectAtPos(EXTERNAL_CLASS, Rhs + 1, ret, envId, pvApiCtx);
+        }
+        catch (ScilabAbstractEnvironmentException & e)
+        {
+            env.removeobject(ret);
+            throw;
+        }
+
+        LhsVar(1) = Rhs + 1;
     }
 
-    LhsVar(1) = Rhs + 1;
     PutLhsVar();
 
     return 0;
index f74b1d6..93b666e 100644 (file)
@@ -382,17 +382,13 @@ VariableType ScilabJavaEnvironment::isunwrappable(int id)
 
 int ScilabJavaEnvironment::compilecode(char * className, char ** code, int size)
 {
-    std::ostringstream os;
-    for (int i = 0; i < size; i++)
-    {
-        os << code[i] << std::endl;
-    }
-    os.flush();
-
     JavaVM *vm = getScilabJavaVM();
     const int ret = ScilabJavaCompiler::compileCode(vm, className, code, size);
 
-    ScilabAutoCleaner::registerVariable(envId, ret);
+    if (ret != 0 && ret != -1)
+    {
+        ScilabAutoCleaner::registerVariable(envId, ret);
+    }
 
     return ret;
 }
index 6905fd0..291d440 100644 (file)
 package org.scilab.modules.external_objects_java;
 
 import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
 import java.io.StringWriter;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.net.MalformedURLException;
-import java.net.URLClassLoader;
 import java.net.URI;
+import java.net.URLClassLoader;
 import java.net.URL;
 import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Locale;
 import java.util.ServiceLoader;
 import java.util.logging.Level;
 
 import javax.tools.Diagnostic;
 import javax.tools.DiagnosticCollector;
+import javax.tools.FileObject;
+import javax.tools.ForwardingJavaFileManager;
 import javax.tools.JavaCompiler;
 import javax.tools.JavaFileObject;
 import javax.tools.SimpleJavaFileObject;
@@ -93,30 +99,49 @@ public class ScilabJavaCompiler {
     public static int compileCode(String className, String[] code) throws ScilabJavaException {
         findCompiler();
 
-        if (ScilabJavaObject.debug) {
-            ScilabJavaObject.logger.log(Level.INFO, "Compilation of class \'" + className + "\'");
+        DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<JavaFileObject>();
+        StandardJavaFileManager stdFileManager = compiler.getStandardFileManager(null, Locale.getDefault(), null);
+        ClassFileManager manager = new ClassFileManager(stdFileManager);
+        List<SimpleJavaFileObject> compilationUnits = new ArrayList<SimpleJavaFileObject>();
+        boolean isFile = true;
+        SourceString sourceString = null;
+        for (String s : code) {
+            File f = new File(s);
+            if (!f.exists() || !f.canRead()) {
+                isFile = false;
+                break;
+            }
         }
 
-        DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<JavaFileObject>();
+        if (isFile) {
+            for (String s : code) {
+                File f = new File(s);
+                compilationUnits.add(new SourceFile(f));
+            }
+        } else {
+            sourceString = new SourceString(className, code);
+            compilationUnits.add(sourceString);
+        }
 
-        SourceString file = new SourceString(className, code);
-        StandardJavaFileManager stdFileManager = compiler.getStandardFileManager(null, Locale.getDefault(), null);
-        Iterable <? extends JavaFileObject > compilationUnits = Arrays.asList(file);
         String[] compileOptions = new String[] {"-d", binpath} ;
         Iterable<String> options = Arrays.asList(compileOptions);
 
-        CompilationTask task = compiler.getTask(null, stdFileManager, diagnostics, options, null, compilationUnits);
-
+        CompilationTask task = compiler.getTask(null, manager, diagnostics, options, null, compilationUnits);
         boolean success = task.call();
-        StringBuffer buf = new StringBuffer();
-        for (Diagnostic diagnostic : diagnostics.getDiagnostics()) {
-            buf.append(diagnostic.toString());
-            buf.append("\n");
-        }
 
         if (success) {
-            return ScilabClassLoader.loadJavaClass(className, true);
+            if (isFile) {
+                return -1;
+            } else {
+                return ScilabClassLoader.loadJavaClass(manager.className, true);
+            }
         } else {
+            StringBuffer buf = new StringBuffer();
+            for (Diagnostic diagnostic : diagnostics.getDiagnostics()) {
+                buf.append(diagnostic.toString());
+                buf.append("\n");
+            }
+
             throw new ScilabJavaException(buf.toString());
         }
     }
@@ -148,7 +173,7 @@ public class ScilabJavaCompiler {
         private final String code;
 
         private SourceString(String className, String[] code) {
-            super(new File(binpath + "/" + className.replace('.', '/') + Kind.SOURCE.extension).toURI(), Kind.SOURCE);
+            super(URI.create("string:///" + className.replace('.', '/') + Kind.SOURCE.extension), Kind.SOURCE);
 
             StringBuffer buf = new StringBuffer();
             for (String str : code) {
@@ -162,4 +187,58 @@ public class ScilabJavaCompiler {
             return code;
         }
     }
+
+    /**
+     * Inner class to handle String as File
+     */
+    private static class SourceFile extends SimpleJavaFileObject {
+
+        final File f;
+
+        private SourceFile(File f) {
+            super(f.toURI(), Kind.SOURCE);
+            this.f = f;
+        }
+
+        public CharSequence getCharContent(boolean ignoreEncodingErrors) {
+            try {
+                FileReader reader = new FileReader(f);
+                char[] buffer = new char[1024];
+                StringBuffer sb = new StringBuffer();
+                int r;
+
+                while ((r = reader.read(buffer, 0, 1024)) != -1) {
+                    sb.append(buffer, 0, r);
+                }
+
+                reader.close();
+
+                return sb;
+            } catch (Exception e) {
+                return null;
+            }
+        }
+    }
+
+    private static class ClassFileManager extends ForwardingJavaFileManager {
+
+        String className;
+
+        public ClassFileManager(StandardJavaFileManager standardManager) {
+            super(standardManager);
+        }
+
+        @Override
+        public JavaFileObject getJavaFileForOutput(Location location, String className, Kind kind, FileObject sibling) throws IOException {
+            if (sibling instanceof SourceString) {
+                this.className = className;
+            }
+
+            if (ScilabJavaObject.debug) {
+                ScilabJavaObject.logger.log(Level.INFO, "Compilation of class \'" + className + "\'");
+            }
+
+            return super.getJavaFileForOutput(location, className, kind, sibling);
+        }
+    }
 }