< prev index next >

test/lib/jdk/test/lib/InMemoryJavaCompiler.java

Print this page
rev 2476 : [mq]: xmodule-to-patch-module


  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 package jdk.test.lib;
  25 
  26 import java.io.ByteArrayOutputStream;
  27 import java.io.IOException;
  28 import java.io.OutputStream;
  29 
  30 import java.net.URI;

  31 import java.util.Arrays;

  32 
  33 import javax.tools.ForwardingJavaFileManager;
  34 import javax.tools.FileObject;
  35 import javax.tools.JavaCompiler;
  36 import javax.tools.JavaCompiler.CompilationTask;
  37 import javax.tools.JavaFileObject;
  38 import javax.tools.JavaFileObject.Kind;
  39 import javax.tools.SimpleJavaFileObject;

  40 import javax.tools.ToolProvider;
  41 
  42 /**
  43  * {@code InMemoryJavaCompiler} can be used for compiling a {@link
  44  * CharSequence} to a {@code byte[]}.
  45  *
  46  * The compiler will not use the file system at all, instead using a {@link
  47  * ByteArrayOutputStream} for storing the byte code. For the source code, any
  48  * kind of {@link CharSequence} can be used, e.g. {@link String}, {@link
  49  * StringBuffer} or {@link StringBuilder}.
  50  *
  51  * The {@code InMemoryCompiler} can easily be used together with a {@code
  52  * ByteClassLoader} to easily compile and load source code in a {@link String}:
  53  *
  54  * <pre>
  55  * {@code
  56  * import jdk.test.lib.InMemoryJavaCompiler;
  57  * import jdk.test.lib.ByteClassLoader;
  58  *
  59  * class Example {


  87         @Override
  88         public CharSequence getCharContent(boolean ignoreEncodingErrors) {
  89             return sourceCode;
  90         }
  91 
  92         @Override
  93         public OutputStream openOutputStream() throws IOException {
  94             return byteCode;
  95         }
  96 
  97         public byte[] getByteCode() {
  98             return byteCode.toByteArray();
  99         }
 100 
 101         public String getClassName() {
 102             return className;
 103         }
 104     }
 105 
 106     private static class FileManagerWrapper extends ForwardingJavaFileManager {
 107         private MemoryJavaFileObject file;












 108 
 109         public FileManagerWrapper(MemoryJavaFileObject file) {
 110             super(getCompiler().getStandardFileManager(null, null, null));
 111             this.file = file;

 112         }
 113 
 114         @Override
 115         public JavaFileObject getJavaFileForOutput(Location location, String className,
 116                                                    Kind kind, FileObject sibling)
 117             throws IOException {
 118             if (!file.getClassName().equals(className)) {
 119                 throw new IOException("Expected class with name " + file.getClassName() +
 120                                       ", but got " + className);
 121             }
 122             return file;
 123         }






















 124     }
 125 
 126     /**
 127      * Compiles the class with the given name and source code.
 128      *
 129      * @param className The name of the class
 130      * @param sourceCode The source code for the class with name {@code className}
 131      * @param options additional command line options
 132      * @throws RuntimeException if the compilation did not succeed
 133      * @return The resulting byte code from the compilation
 134      */
 135     public static byte[] compile(String className, CharSequence sourceCode, String... options) {
 136         MemoryJavaFileObject file = new MemoryJavaFileObject(className, sourceCode);
 137         CompilationTask task = getCompilationTask(file, options);
 138 
 139         if(!task.call()) {
 140             throw new RuntimeException("Could not compile " + className + " with source code " + sourceCode);
 141         }
 142 
 143         return file.getByteCode();
 144     }
 145 
 146     private static JavaCompiler getCompiler() {
 147         return ToolProvider.getSystemJavaCompiler();
 148     }
 149 
 150     private static CompilationTask getCompilationTask(MemoryJavaFileObject file, String... options) {
 151         return getCompiler().getTask(null, new FileManagerWrapper(file), null, Arrays.asList(options), null, Arrays.asList(file));









 152     }
 153 }


  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 package jdk.test.lib;
  25 
  26 import java.io.ByteArrayOutputStream;
  27 import java.io.IOException;
  28 import java.io.OutputStream;
  29 
  30 import java.net.URI;
  31 import java.util.ArrayList;
  32 import java.util.Arrays;
  33 import java.util.List;
  34 
  35 import javax.tools.ForwardingJavaFileManager;
  36 import javax.tools.FileObject;
  37 import javax.tools.JavaCompiler;
  38 import javax.tools.JavaCompiler.CompilationTask;
  39 import javax.tools.JavaFileObject;
  40 import javax.tools.JavaFileObject.Kind;
  41 import javax.tools.SimpleJavaFileObject;
  42 import javax.tools.StandardLocation;
  43 import javax.tools.ToolProvider;
  44 
  45 /**
  46  * {@code InMemoryJavaCompiler} can be used for compiling a {@link
  47  * CharSequence} to a {@code byte[]}.
  48  *
  49  * The compiler will not use the file system at all, instead using a {@link
  50  * ByteArrayOutputStream} for storing the byte code. For the source code, any
  51  * kind of {@link CharSequence} can be used, e.g. {@link String}, {@link
  52  * StringBuffer} or {@link StringBuilder}.
  53  *
  54  * The {@code InMemoryCompiler} can easily be used together with a {@code
  55  * ByteClassLoader} to easily compile and load source code in a {@link String}:
  56  *
  57  * <pre>
  58  * {@code
  59  * import jdk.test.lib.InMemoryJavaCompiler;
  60  * import jdk.test.lib.ByteClassLoader;
  61  *
  62  * class Example {


  90         @Override
  91         public CharSequence getCharContent(boolean ignoreEncodingErrors) {
  92             return sourceCode;
  93         }
  94 
  95         @Override
  96         public OutputStream openOutputStream() throws IOException {
  97             return byteCode;
  98         }
  99 
 100         public byte[] getByteCode() {
 101             return byteCode.toByteArray();
 102         }
 103 
 104         public String getClassName() {
 105             return className;
 106         }
 107     }
 108 
 109     private static class FileManagerWrapper extends ForwardingJavaFileManager {
 110         private static final Location PATCH_LOCATION = new Location() {
 111             @Override
 112             public String getName() {
 113                 return "patch module location";
 114             }
 115 
 116             @Override
 117             public boolean isOutputLocation() {
 118                 return false;
 119             }
 120         };
 121         private final MemoryJavaFileObject file;
 122         private final String moduleOverride;
 123 
 124         public FileManagerWrapper(MemoryJavaFileObject file, String moduleOverride) {
 125             super(getCompiler().getStandardFileManager(null, null, null));
 126             this.file = file;
 127             this.moduleOverride = moduleOverride;
 128         }
 129 
 130         @Override
 131         public JavaFileObject getJavaFileForOutput(Location location, String className,
 132                                                    Kind kind, FileObject sibling)
 133             throws IOException {
 134             if (!file.getClassName().equals(className)) {
 135                 throw new IOException("Expected class with name " + file.getClassName() +
 136                                       ", but got " + className);
 137             }
 138             return file;
 139         }
 140 
 141         @Override
 142         public Location getLocationForModule(Location location, JavaFileObject fo, String pkgName) throws IOException {
 143             if (fo == file && moduleOverride != null) {
 144                 return PATCH_LOCATION;
 145             }
 146             return super.getLocationForModule(location, fo, pkgName);
 147         }
 148 
 149         @Override
 150         public String inferModuleName(Location location) throws IOException {
 151             if (location == PATCH_LOCATION) {
 152                 return moduleOverride;
 153             }
 154             return super.inferModuleName(location);
 155         }
 156 
 157         @Override
 158         public boolean hasLocation(Location location) {
 159             return super.hasLocation(location) || location == StandardLocation.PATCH_MODULE_PATH;
 160         }
 161 
 162     }
 163 
 164     /**
 165      * Compiles the class with the given name and source code.
 166      *
 167      * @param className The name of the class
 168      * @param sourceCode The source code for the class with name {@code className}
 169      * @param options additional command line options
 170      * @throws RuntimeException if the compilation did not succeed
 171      * @return The resulting byte code from the compilation
 172      */
 173     public static byte[] compile(String className, CharSequence sourceCode, String... options) {
 174         MemoryJavaFileObject file = new MemoryJavaFileObject(className, sourceCode);
 175         CompilationTask task = getCompilationTask(file, options);
 176 
 177         if(!task.call()) {
 178             throw new RuntimeException("Could not compile " + className + " with source code " + sourceCode);
 179         }
 180 
 181         return file.getByteCode();
 182     }
 183 
 184     private static JavaCompiler getCompiler() {
 185         return ToolProvider.getSystemJavaCompiler();
 186     }
 187 
 188     private static CompilationTask getCompilationTask(MemoryJavaFileObject file, String... options) {
 189         List<String> opts = new ArrayList<>();
 190         String moduleOverride = null;
 191         for (String opt : options) {
 192             if (opt.startsWith("-Xmodule:")) {
 193                 moduleOverride = opt.substring("-Xmodule:".length());
 194             } else {
 195                 opts.add(opt);
 196             }
 197         }
 198         return getCompiler().getTask(null, new FileManagerWrapper(file, moduleOverride), null, opts, null, Arrays.asList(file));
 199     }
 200 }
< prev index next >