/*
* Copyright (C) 2009 The Project Lombok Authors.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package lombok.delombok;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.List;
import java.util.Map;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import lombok.core.LombokApp;
import org.mangosdk.spi.ProviderFor;
@ProviderFor(LombokApp.class)
public class DelombokApp extends LombokApp {
@Override public int runApp(List<String> args) throws Exception {
try {
Class.forName("com.sun.tools.javac.main.JavaCompiler");
runDirectly(args);
return 0;
} catch (ClassNotFoundException e) {
Class<?> delombokClass = loadDelombok(args);
if (delombokClass == null) {
return 1;
}
try {
loadDelombok(args).getMethod("main", String[].class).invoke(null, new Object[] {args.toArray(new String[0])});
} catch (InvocationTargetException e1) {
Throwable t = e1.getCause();
if (t instanceof Error) throw (Error)t;
if (t instanceof Exception) throw (Exception)t;
throw e1;
}
return 0;
}
}
public static Class<?> loadDelombok(List<String> args) throws Exception {
//tools.jar is probably not on the classpath. We're going to try and find it, and then load the rest via a ClassLoader that includes tools.jar.
final File toolsJar = findToolsJar();
if (toolsJar == null) {
String examplePath = "/path/to/tools.jar";
if (File.separator.equals("\\")) examplePath = "C:\\path\\to\\tools.jar";
StringBuilder sb = new StringBuilder();
for (String arg : args) {
if (sb.length() > 0) sb.append(' ');
if (arg.contains(" ")) {
sb.append('"').append(arg).append('"');
} else {
sb.append(arg);
}
}
System.err.printf("Can't find tools.jar. Rerun delombok as: java -cp lombok.jar%1$s%2$s lombok.core.Main delombok %3$s\n",
File.pathSeparator, examplePath, sb.toString());
return null;
}
// The jar file is used for the lifetime of the classLoader, therefore the lifetime of delombok.
// Since we only read from it, not closing it should not be a problem.
@SuppressWarnings({"resource", "all"}) final JarFile toolsJarFile = new JarFile(toolsJar);
ClassLoader loader = new ClassLoader(DelombokApp.class.getClassLoader()) {
private Class<?> loadStreamAsClass(String name, boolean resolve, InputStream in) throws ClassNotFoundException {
try {
try {
byte[] b = new byte[65536];
ByteArrayOutputStream out = new ByteArrayOutputStream();
while (true) {
int r = in.read(b);
if (r == -1) break;
out.write(b, 0, r);
}
in.close();
byte[] data = out.toByteArray();
Class<?> c = defineClass(name, data, 0, data.length);
if (resolve) resolveClass(c);
return c;
} finally {
in.close();
}
} catch (Exception e2) {
throw new ClassNotFoundException(name, e2);
}
}
@Override protected synchronized Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
String rawName, altName; {
String binName = name.replace(".", "/");
rawName = binName + ".class";
altName = binName + ".SCL.lombok";
}
JarEntry entry = toolsJarFile.getJarEntry(rawName);
if (entry == null) {
if (name.startsWith("lombok.")) {
InputStream res = getParent().getResourceAsStream(rawName);
if (res == null) res = getParent().getResourceAsStream(altName);
return loadStreamAsClass(name, resolve, res);
}
return super.loadClass(name, resolve);
}
try {
return loadStreamAsClass(name, resolve, toolsJarFile.getInputStream(entry));
} catch (IOException e2) {
throw new ClassNotFoundException(name, e2);
}
}
@Override public URL getResource(String name) {
JarEntry entry = toolsJarFile.getJarEntry(name);
if (entry == null) return super.getResource(name);
try {
return new URL("jar:file:" + toolsJar.getAbsolutePath() + "!" + name);
} catch (MalformedURLException ignore) {
return null;
}
}
@Override public Enumeration<URL> getResources(final String name) throws IOException {
JarEntry entry = toolsJarFile.getJarEntry(name);
final Enumeration<URL> parent = super.getResources(name);
if (entry == null) return super.getResources(name);
return new Enumeration<URL>() {
private boolean first = false;
@Override public boolean hasMoreElements() {
return !first || parent.hasMoreElements();
}
@Override public URL nextElement() {
if (!first) {
first = true;
try {
return new URL("jar:file:" + toolsJar.getAbsolutePath() + "!" + name);
} catch (MalformedURLException ignore) {
return parent.nextElement();
}
}
return parent.nextElement();
}
};
}
};
return loader.loadClass("lombok.delombok.Delombok");
}
private void runDirectly(List<String> args) {
Delombok.main(args.toArray(new String[0]));
}
private static File findToolsJar() {
try {
File toolsJar = findToolsJarViaRT();
if (toolsJar != null) return toolsJar;
} catch (Throwable ignore) {
//fallthrough
}
try {
File toolsJar = findToolsJarViaProperties();
if (toolsJar != null) return toolsJar;
} catch (Throwable ignore) {
//fallthrough
}
try {
File toolsJar = findToolsJarViaEnvironment();
return toolsJar;
} catch (Throwable ignore) {
//fallthrough
}
return null;
}
private static File findToolsJarViaEnvironment() {
for (Map.Entry<String, String> s : System.getenv().entrySet()) {
if ("JAVA_HOME".equalsIgnoreCase(s.getKey())) {
return extensiveCheckToolsJar(new File(s.getValue()));
}
}
return null;
}
private static File findToolsJarViaProperties() {
File home = new File(System.getProperty("java.home", "."));
return extensiveCheckToolsJar(home);
}
private static File extensiveCheckToolsJar(File base) {
File toolsJar = checkToolsJar(base);
if (toolsJar != null) return toolsJar;
toolsJar = checkToolsJar(new File(base, "lib"));
if (toolsJar != null) return toolsJar;
toolsJar = checkToolsJar(new File(base.getParentFile(), "lib"));
if (toolsJar != null) return toolsJar;
toolsJar = checkToolsJar(new File(new File(base, "jdk"), "lib"));
if (toolsJar != null) return toolsJar;
return null;
}
private static File findToolsJarViaRT() {
String url = ClassLoader.getSystemClassLoader().getResource("java/lang/String.class").toString();
if (!url.startsWith("jar:file:")) return null;
url = url.substring("jar:file:".length());
int idx = url.indexOf('!');
if (idx == -1) return null;
url = url.substring(0, idx);
File toolsJar = checkToolsJar(new File(url).getParentFile());
if (toolsJar != null) return toolsJar;
toolsJar = checkToolsJar(new File(new File(url).getParentFile().getParentFile().getParentFile(), "lib"));
if (toolsJar != null) return toolsJar;
return null;
}
private static File checkToolsJar(File d) {
if (d.getName().equals("tools.jar") && d.isFile() && d.canRead()) return d;
d = new File(d, "tools.jar");
if (d.getName().equals("tools.jar") && d.isFile() && d.canRead()) return d;
return null;
}
@Override public String getAppName() {
return "delombok";
}
@Override public List<String> getAppAliases() {
return Arrays.asList("unlombok");
}
@Override public String getAppDescription() {
return "Applies lombok transformations without compiling your\njava code (so, 'unpacks' lombok annotations and such).";
}
}