Rewrite jagidir compiler to call external javac.

[jagi.git] / src / jagi / fs / Compiler.java

package jagi.fs;

import jagi.*;
import java.util.*;
import java.util.regex.*;
import java.nio.file.*;
import java.nio.file.attribute.*;
import java.io.*;

public class Compiler {
    private final Map<Path, Module> modules = new HashMap<>();

    public static class ClassOutput {
	public final String name;
	public final ByteArrayOutputStream buf = new ByteArrayOutputStream();

	public ClassOutput(String name) {
	    this.name = name;
	}
    }

    public static class CompilationException extends RuntimeException {
	public final Path file;
	private final List<? extends Object> messages;

	public CompilationException(Path file, List<? extends Object> messages) {
	    this.file = file;
	    this.messages = messages;
	}

	public String getMessage() {
	    return(file + ": compilation failed");
	}

	public String messages() {
	    StringBuilder buf = new StringBuilder();
	    for(Object msg : messages)
		buf.append(msg.toString() + "\n");
	    return(buf.toString());
	}

	public void printStackTrace(PrintStream out) {
	    out.print(messages());
	    super.printStackTrace(out);
	}
    }

    public static class Compilation implements AutoCloseable {
	private final Path dir, srcdir, outdir;
	private final List<Path> infiles = new ArrayList<>();
	private List<String> output = null;

	public Compilation() throws IOException {
	    dir = Files.createTempDirectory("javac");
	    srcdir = dir.resolve("src");
	    outdir = dir.resolve("out");
	    Files.createDirectory(srcdir);
	    Files.createDirectory(outdir);
	}

	public void add(Path p) {
	    infiles.add(p);
	}

	private static final Pattern classpat = Pattern.compile("^((public|abstract)\\s+)*(class|interface)\\s+(\\S+)");
	public void split(Path infile) throws IOException {
	    StringBuilder head = new StringBuilder();
	    BufferedWriter cur = null;
	    try(BufferedReader fp = Files.newBufferedReader(infile)) {
		for(String ln = fp.readLine(); ln != null; ln = fp.readLine()) {
		    Matcher m = classpat.matcher(ln);
		    if(m.find()) {
			String clnm = m.group(4);
			Path sp = srcdir.resolve(clnm + ".java");
			add(sp);
			if(cur != null)
			    cur.close();
			cur = Files.newBufferedWriter(sp);
			cur.append(head);
		    }
		    if(cur != null) {
			cur.append(ln); cur.append('\n');
		    } else {
			head.append(ln); head.append('\n');
		    }
		}
	    } finally {
		if(cur != null)
		    cur.close();
	    }
	}

	public boolean compile() throws IOException {
	    List<String> args = new ArrayList<>();
	    args.add("javac");
	    args.add("-d");
	    args.add(outdir.toString());
	    for(Path p : infiles)
		args.add(p.toString());
	    ProcessBuilder cmd = new ProcessBuilder(args);
	    cmd.redirectErrorStream(true);
	    cmd.redirectOutput(ProcessBuilder.Redirect.PIPE);
	    Process proc = cmd.start();
	    List<String> output = new ArrayList<>();
	    BufferedReader fp = new BufferedReader(new InputStreamReader(proc.getInputStream(), Utils.UTF8));
	    while(true) {
		String ln = fp.readLine();
		if(ln == null)
		    break;
		output.add(ln);
	    }
	    int status;
	    try {
		status = proc.waitFor();
	    } catch(InterruptedException e) {
		Thread.currentThread().interrupt();
		throw(new IOException("compilation interrupted"));
	    }
	    this.output = output;
	    return(status == 0);
	}

	public List<String> output() {
	    if(output == null)
		throw(new IllegalStateException());
	    return(output);
	}

	public Collection<ClassOutput> classes() throws IOException {
	    Collection<ClassOutput> ret = new ArrayList<>();
	    for(Path p : (Iterable<Path>)Files.walk(outdir)::iterator) {
		Path rel = outdir.relativize(p);
		String fn = rel.getName(rel.getNameCount() - 1).toString();
		if(!Files.isRegularFile(p) || !fn.endsWith(".class"))
		    continue;
		StringBuilder clnm = new StringBuilder();
		for(int i = 0; i < rel.getNameCount() - 1; i++) {
		    clnm.append(rel.getName(i));
		    clnm.append('.');
		}
		clnm.append(fn.substring(0, fn.length() - 6));
		ClassOutput cls = new ClassOutput(clnm.toString());
		Files.copy(p, cls.buf);
		ret.add(cls);
	    }
	    return(ret);
	}

	private static void remove(Path p) throws IOException {
	    if(Files.isDirectory(p)) {
		for(Path ent : (Iterable<Path>)Files.list(p)::iterator)
		    remove(ent);
	    }
	    Files.delete(p);
	}

	public void close() throws IOException {
	    remove(dir);
	}
    }

    public static Collection<ClassOutput> compile(Path file) throws IOException {
	try(Compilation c = new Compilation()) {
	    c.split(file);
	    if(!c.compile())
		throw(new CompilationException(file, c.output()));
	    return(c.classes());
	}
    }

    public static class BufferedClassLoader extends ClassLoader {
	public final Map<String, byte[]> contents;

	public BufferedClassLoader(Collection<ClassOutput> contents) {
	    this.contents = new HashMap<>();
	    for(ClassOutput clc : contents)
		this.contents.put(clc.name, clc.buf.toByteArray());
	}

	public Class<?> findClass(String name) throws ClassNotFoundException {
	    byte[] c = contents.get(name);
	    if(c == null)
		throw(new ClassNotFoundException(name));
	    return(defineClass(name, c, 0, c.length));
	}
    }

    public static class Module {
	public final Path file;
	private FileTime mtime = null;
	private ClassLoader code = null;

	private Module(Path file) {
	    this.file = file;
	}

	public void update() throws IOException {
	    synchronized(this) {
		FileTime mtime = Files.getLastModifiedTime(file);
		if((this.mtime == null) || (this.mtime.compareTo(mtime) < 0)) {
		    code = new BufferedClassLoader(compile(file));
		    this.mtime = mtime;
		}
	    }
	}

	public ClassLoader code() {
	    if(code == null)
		throw(new RuntimeException("module has not yet been updated"));
	    return(code);
	}
    }

    public Module module(Path file) {
	synchronized(modules) {
	    Module ret = modules.get(file);
	    if(ret == null)
		modules.put(file, ret = new Module(file));
	    return(ret);
	}
    }

    private static Compiler global = null;
    public static Compiler get() {
	if(global == null) {
	    synchronized(Compiler.class) {
		if(global == null)
		    global = new Compiler();
	    }
	}
	return(global);
    }
}