1 /*
2  * Copyright (c) 2013, 2017, Oracle and/or its affiliates. All rights reserved.
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * This code is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License version 2 only, as
7  * published by the Free Software Foundation.
8  *
9  * This code is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
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.compiler;
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.compiler.InMemoryJavaCompiler;
60  * import jdk.test.lib.ByteClassLoader;
61  *
62  * class Example {
63  *     public static void main(String[] args) {
64  *         String className = "Foo";
65  *         String sourceCode = "public class " + className + " {" +
66  *                             "    public void bar() {" +
67  *                             "        System.out.println("Hello from bar!");" +
68  *                             "    }" +
69  *                             "}";
70  *         byte[] byteCode = InMemoryJavaCompiler.compile(className, sourceCode);
71  *         Class fooClass = ByteClassLoader.load(className, byteCode);
72  *     }
73  * }
74  * }
75  * </pre>
76  */
77 public class InMemoryJavaCompiler {
78     private static class MemoryJavaFileObject extends SimpleJavaFileObject {
79         private final String className;
80         private final CharSequence sourceCode;
81         private final ByteArrayOutputStream byteCode;
82 
MemoryJavaFileObject(String className, CharSequence sourceCode)83         public MemoryJavaFileObject(String className, CharSequence sourceCode) {
84             super(URI.create("string:///" + className.replace('.','/') + Kind.SOURCE.extension), Kind.SOURCE);
85             this.className = className;
86             this.sourceCode = sourceCode;
87             this.byteCode = new ByteArrayOutputStream();
88         }
89 
90         @Override
getCharContent(boolean ignoreEncodingErrors)91         public CharSequence getCharContent(boolean ignoreEncodingErrors) {
92             return sourceCode;
93         }
94 
95         @Override
openOutputStream()96         public OutputStream openOutputStream() throws IOException {
97             return byteCode;
98         }
99 
getByteCode()100         public byte[] getByteCode() {
101             return byteCode.toByteArray();
102         }
103 
getClassName()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 
FileManagerWrapper(MemoryJavaFileObject file, String moduleOverride)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
getJavaFileForOutput(Location location, String className, Kind kind, FileObject sibling)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
getLocationForModule(Location location, JavaFileObject fo)142         public Location getLocationForModule(Location location, JavaFileObject fo) throws IOException {
143             if (fo == file && moduleOverride != null) {
144                 return PATCH_LOCATION;
145             }
146             return super.getLocationForModule(location, fo);
147         }
148 
149         @Override
inferModuleName(Location location)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
hasLocation(Location location)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      */
compile(String className, CharSequence sourceCode, String... options)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 
getCompiler()184     private static JavaCompiler getCompiler() {
185         return ToolProvider.getSystemJavaCompiler();
186     }
187 
getCompilationTask(MemoryJavaFileObject file, String... options)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("--patch-module=")) {
193                 moduleOverride = opt.substring("--patch-module=".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 }
201