import java.io.*;
import java.net.URL;
import java.net.URLConnection;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
Baked single-source-file version of javax3 (multiple class files are unavoidable...)
javax3 accepts a snippet ID as well as a directory name as argument.
*/
public class javax3 {
static boolean verbose = false;
private static String isCompilable = "http://tinybrain.de/"
+ /*"564"*/"1000251"; // silenced version (but I think we're silencing now anyway)
private static String isCompilableHash = "8fe3851d7a686b60546a2429a2bde0d9";
private static String mainAdder = "http://tinybrain.de/1000252";
private static String mainAdderHash = "ce1e89785facd87ea64a6d9ad16a7aec";
public static void main(String[] args) throws IOException {
File ioBaseDir = new File(".");
String src = ".";
for (int i = 0; i < args.length; i++) {
String arg = args[i];
if (arg.equals("-v"))
verbose = true;
else
src = arg;
}
javax3(src, ioBaseDir);
}
public static void javax3(String src, File ioDir) throws IOException {
File srcDir;
if (isSnippetID(src))
srcDir = loadSnippetAsMainJava(src);
else
srcDir = new File(src);
Input X = programToInput(srcDir);
boolean compilable = isCompilable(X);
if (verbose) System.out.println("Compilable: " + compilable);
if (!compilable) {
X = expandProgram(X);
File file = new File(X.dir, "main.java");
String program = loadTextFile(file.getPath(), null);
if (verbose) System.out.println("New program:\n" + program);
if (program == null)
throw new RuntimeException("Expansion failed (tried: " + file.getPath() + ")");
}
javax2(X.dir, ioDir, false);
}
public static File loadSnippetAsMainJava(String snippetID) throws IOException {
File srcDir = TempDirMaker.make();
saveTextFile(new File(srcDir, "main.java").getPath(), loadSnippet(snippetID));
return srcDir;
}
public static File loadSnippetAsMainJavaVerified(String snippetID, String hash) throws IOException {
File srcDir = TempDirMaker.make();
saveTextFile(new File(srcDir, "main.java").getPath(), loadSnippetVerified(snippetID, hash));
return srcDir;
}
private static Input expandProgram(Input x) throws IOException {
return runJavaX2_on_snippet(mainAdder, mainAdderHash, x, true);
}
private static boolean isCompilable(Input x) throws IOException {
Input output = runJavaX2_on_snippet(isCompilable, isCompilableHash, x, true);
return output.hasFile("is-compilable");
}
private static Input runJavaX2_on_snippet(String snippetID, String hash, Input x, boolean silent) throws IOException {
File srcDir = loadSnippetAsMainJavaVerified(snippetID, hash);
return runJavaX(new Input(srcDir), x, silent);
}
private static Input runJavaX(Input originalSrcDir, Input originalInput, boolean silent) throws IOException {
File ioBaseDir = TempDirMaker.make();
File srcDir = new File(ioBaseDir, "src");
File inputDir = new File(ioBaseDir, "input");
Input input = new Input(inputDir);
File outputDir = new File(ioBaseDir, "output");
Input output = new Input(outputDir);
copyInput(originalSrcDir, new Input(srcDir));
copyInput(originalInput, input);
javax2(srcDir, ioBaseDir, silent);
return output;
}
private static void copyInput(Input src, Input dst) throws IOException {
copyDirectory(src.dir, dst.dir);
}
private static Input programToInput(File srcDir) {
return new Input(srcDir);
}
static class Input {
File dir;
public Input(File dir) {
this.dir = dir;
}
public boolean hasFile(String name) {
return new File(dir, name).exists();
}
}
public static void copyDirectory(File src, File dst) throws IOException {
if (verbose) System.out.println("Copying " + src.getAbsolutePath() + " to " + dst.getAbsolutePath());
dst.mkdirs();
File[] files = src.listFiles();
if (files == null) return;
for (File file : files) {
File dst1 = new File(dst, file.getName());
if (file.isDirectory())
copyDirectory(file, dst1);
else {
if (verbose) System.out.println("Copying " + file.getAbsolutePath() + " to " + dst1.getAbsolutePath());
copy(file, dst1);
}
}
}
/** Quickly copy a file without a progress bar or any other fancy GUI... :) */
public static void copy(File src, File dest) throws IOException {
FileInputStream inputStream = new FileInputStream(src);
FileOutputStream outputStream = new FileOutputStream(dest);
try {
copy(inputStream, outputStream);
inputStream.close();
} finally {
outputStream.close();
}
}
public static void copy(InputStream in, OutputStream out) throws IOException {
byte[] buf = new byte[65536];
while (true) {
int n = in.read(buf);
if (n <= 0) return;
out.write(buf, 0, n);
}
}
/** writes safely (to temp file, then rename) */
public static void saveTextFile(String fileName, String contents) throws IOException {
File file = new File(fileName);
File parentFile = file.getParentFile();
if (parentFile != null)
parentFile.mkdirs();
String tempFileName = fileName + "_temp";
FileOutputStream fileOutputStream = new FileOutputStream(tempFileName);
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, charsetForTextFiles);
PrintWriter printWriter = new PrintWriter(outputStreamWriter);
printWriter.print(contents);
printWriter.close();
if (file.exists() && !file.delete())
throw new IOException("Can't delete " + fileName);
if (!new File(tempFileName).renameTo(file))
throw new IOException("Can't rename " + tempFileName + " to " + fileName);
}
public static String loadTextFile(String fileName, String defaultContents) throws IOException {
if (!new File(fileName).exists())
return defaultContents;
FileInputStream fileInputStream = new FileInputStream(fileName);
InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, charsetForTextFiles);
return loadTextFile(inputStreamReader);
}
public static String loadTextFile(Reader reader) throws IOException {
StringBuilder builder = new StringBuilder();
try {
BufferedReader bufferedReader = new BufferedReader(reader);
String line;
while ((line = bufferedReader.readLine()) != null)
builder.append(line).append('\n');
} finally {
reader.close();
}
return builder.length() == 0 ? "" : builder.substring(0, builder.length()-1);
}
static class DiskSnippetCache {
final File dir;
public DiskSnippetCache(File dir) {
this.dir = dir;
dir.mkdirs();
}
public synchronized String get(long snippetID) throws IOException {
return loadTextFile(getFile(snippetID).getPath(), null);
}
private File getFile(long snippetID) {
return new File(dir, "" + snippetID);
}
public synchronized void put(long snippetID, String snippet) throws IOException {
saveTextFile(getFile(snippetID).getPath(), snippet);
}
public File getDir() {
return dir;
}
}
public static DiskSnippetCache getSnippetCache() {
return new DiskSnippetCache(new File(System.getProperty("user.home"), ".tinybrain/snippet-cache"));
}
public static String loadSnippetVerified(String snippetID, String hash) throws IOException {
String text = loadSnippet(snippetID);
String realHash = getHash(text.getBytes("UTF-8"));
if (!realHash.equals(hash)) {
String msg;
if (hash.isEmpty())
msg = "Here's your hash for " + snippetID + ", please put in your program: " + realHash;
else
msg = "Hash mismatch for " + snippetID + ": " + realHash + " (new) vs " + hash + " - has tinybrain.de been hacked??";
throw new RuntimeException(msg);
}
return text;
}
public static String getHash(byte[] data) {
return bytesToHex(getFullFingerprint(data));
}
public static byte[] getFullFingerprint(byte[] data) {
try {
return MessageDigest.getInstance("MD5").digest(data);
} catch (NoSuchAlgorithmException e) {
throw new RuntimeException(e);
}
}
public static String bytesToHex(byte[] bytes) {
return bytesToHex(bytes, 0, bytes.length);
}
public static String bytesToHex(byte[] bytes, int ofs, int len) {
StringBuilder stringBuilder = new StringBuilder(len*2);
for (int i = 0; i < len; i++) {
String s = "0" + Integer.toHexString(bytes[ofs+i]);
stringBuilder.append(s.substring(s.length()-2, s.length()));
}
return stringBuilder.toString();
}
public static String loadSnippet(String snippetID) throws IOException {
return loadSnippet(parseSnippetID(snippetID));
}
public static long parseSnippetID(String snippetID) {
return Long.parseLong(shortenSnippetID(snippetID));
}
private static String shortenSnippetID(String snippetID) {
if (snippetID.startsWith("#"))
snippetID = snippetID.substring(1);
String httpBlaBla = "http://tinybrain.de/";
if (snippetID.startsWith(httpBlaBla))
snippetID = snippetID.substring(httpBlaBla.length());
return snippetID;
}
public static boolean isSnippetID(String snippetID) {
snippetID = shortenSnippetID(snippetID);
return isInteger(snippetID) && Long.parseLong(snippetID) != 0;
}
public static boolean isInteger(String s) {
return Pattern.matches("\\-?\\d+", s);
}
static boolean preferCached = true;
public static String loadSnippet(long snippetID) throws IOException {
if (preferCached) {
String text = getSnippetCache().get(snippetID);
if (text != null)
return text;
}
String text;
try {
URL url = new URL("http://tinybrain.de:8080/getraw.php?id=" + snippetID);
text = loadPage(url);
} catch (FileNotFoundException e) {
throw new IOException("Snippet #" + snippetID + " not found or not public");
}
try {
getSnippetCache().put(snippetID, text);
} catch (IOException e) {
System.err.println("Minor warning: Couldn't save snippet to cache (" + getSnippetCache().getDir() + ")");
}
return text;
}
private static String loadPage(URL url) throws IOException {
System.out.println("Loading: " + url.toExternalForm());
URLConnection con = url.openConnection();
return loadPage(con, url);
}
public static String loadPage(URLConnection con, URL url) throws IOException {
String contentType = con.getContentType();
if (contentType == null)
throw new IOException("Page could not be read: " + url);
//Log.info("Content-Type: " + contentType);
String charset = guessCharset(contentType);
Reader r = new InputStreamReader(con.getInputStream(), charset);
StringBuilder buf = new StringBuilder();
while (true) {
int ch = r.read();
if (ch < 0)
break;
//Log.info("Chars read: " + buf.length());
buf.append((char) ch);
}
return buf.toString();
}
public static String guessCharset(String contentType) {
Pattern p = Pattern.compile("text/html;\\s+charset=([^\\s]+)\\s*");
Matcher m = p.matcher(contentType);
/* If Content-Type doesn't match this pre-conception, choose default and hope for the best. */
return m.matches() ? m.group(1) : "ISO-8859-1";
}
public static void javax2(File srcDir, File ioBaseDir, boolean silent) throws IOException {
List<File> sources = new ArrayList<File>();
if (verbose) System.out.println("Scanning for sources in " + srcDir.getPath());
scanForSources(srcDir, sources, true);
if (sources.isEmpty()) {
System.out.println("No sources found");
return;
}
File optionsFile = File.createTempFile("javax", "");
File classesDir = TempDirMaker.make();
if (verbose) System.out.println("Compiling " + sources.size() + " source(s) to " + classesDir.getPath());
String options = "-d " + bashQuote(classesDir.getPath());
writeOptions(sources, optionsFile, options);
classesDir.mkdirs();
invokeJavac(optionsFile);
if (verbose) System.out.println("Running program (class main.java)\n");
runProgram(classesDir, ioBaseDir, silent);
}
private static void runProgram(File classesDir, File ioBaseDir, boolean silent) throws IOException {
boolean echoOK = false;
String bashCmd = "(cd " + bashQuote(ioBaseDir.getAbsolutePath()) + " && (java -cp "
+ bashQuote(classesDir.getAbsolutePath()) + " main" + (echoOK ? "; echo ok" : "") + "))";
if (verbose) System.out.println(bashCmd);
String output = backtick(bashCmd);
if (!silent)
System.out.println(output);
}
private static void invokeJavac(File optionsFile) throws IOException {
String javacOutput = backtick("javac " + bashQuote("@" + optionsFile.getPath()));
if (verbose) System.out.println(javacOutput);
}
private static void writeOptions(List<File> sources, File sourcesFile, String moreOptions) throws IOException {
FileWriter writer = new FileWriter(sourcesFile);
for (File source : sources)
writer.write(bashQuote(source.getPath()) + " ");
writer.write(moreOptions);
writer.close();
}
private static void scanForSources(File source, List<File> sources, boolean topLevel) {
if (source.isFile() && source.getName().endsWith(".java"))
sources.add(source);
else if (source.isDirectory() && !isSkippedDirectoryName(source.getName(), topLevel)) {
File[] files = source.listFiles();
for (File file : files)
scanForSources(file, sources, false);
}
}
private static boolean isSkippedDirectoryName(String name, boolean topLevel) {
if (topLevel) return false; // input or output ok as highest directory (intentionally specified by user, not just found by a directory scan in which case we probably don't want it. it's more like heuristics actually.)
return name.equalsIgnoreCase("input") || name.equalsIgnoreCase("output");
}
public static String backtick(String cmd) throws IOException {
File outFile = File.createTempFile("_backtick", "");
File scriptFile = File.createTempFile("_backtick", "");
String command = cmd + ">" + bashQuote(outFile.getPath()) + " 2>&1";
//Log.info("[Backtick] " + command);
try {
saveTextFile(scriptFile.getPath(), command);
String[] command2 = {"/bin/bash", scriptFile.getPath() };
Process process = Runtime.getRuntime().exec(command2);
try {
process.waitFor();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
int value = process.exitValue();
//Log.info("exit value: " + value);
return loadTextFile(outFile.getPath(), "");
} finally {
scriptFile.delete();
}
}
/** possibly improvable */
public static String bashQuote(String text) {
if (text == null) return null;
return "\"" + text
.replace("\\", "\\\\")
.replace("\"", "\\\"")
.replace("\n", "\\n")
.replace("\r", "\\r") + "\"";
}
public final static String charsetForTextFiles = "UTF8";
public static class TempDirMaker {
static long lastValue;
public static File make() {
File dir = new File(System.getProperty("user.home"), ".javax/" + newValue());
dir.mkdirs();
return dir;
}
private static long newValue() {
long value;
do
value = System.currentTimeMillis();
while (value == lastValue);
lastValue = value;
return value;
}
}
}
Travelled to 12 computer(s): aoiabmzegqzx, bhatertpkbcr, cbybwowwnfue, gwrvuhgaqvyk, ishqpsrjomds, lpdgvwnxivlt, mqqgnosmbjvj, pyentgdyhuwx, pzhvpgtvlbxg, tslmcundralx, tvejysmllsmz, vouqrxazstgt