Allow jagidir $use directives to specify absolute paths.

[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.*;
import java.net.*;

public class Compiler {
    private final Map<Path, File> files = new HashMap<>();
    private final Map<Path, ClassLoader> libs = new HashMap<>();
    private final Collection<Path> searchpath = new ArrayList<>();

    public Compiler() {
	String syspath = System.getenv("PATH");
	if(syspath != null) {
	    String sep = java.io.File.pathSeparator;
	    int p1 = 0, p2 = syspath.indexOf(sep);
	    do {
		String el;
		if(p2 >= 0) {
		    el = syspath.substring(p1, p2);
		    p1 = p2 + sep.length();
		    p2 = syspath.indexOf(sep, p1);
		} else {
		    el =syspath.substring(p1);
		}
		try {
		    Path p = Paths.get(el);
		    if(p.getParent() != null)
			searchpath.add(p.getParent().resolve("share").resolve("java"));
		} catch(InvalidPathException e) {
		    continue;
		}
	    } while(p2 >= 0);
	}
	String proppath = System.getProperty("jagi.search-path");
	if(proppath != null) {
	    for(String el : proppath.split(":")) {
		try {
		    searchpath.add(Paths.get(el));
		} catch(InvalidPathException e) {
		    continue;
		}
	    }
	}
    }

    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 {
	public final Path dir, srcdir, outdir;
	private final List<Path> infiles = new ArrayList<>();
	private final List<Path> classpath = 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);
	}

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

	public boolean compile() throws IOException {
	    List<String> args = new ArrayList<>();
	    args.add("javac");
	    args.add("-d");
	    args.add(outdir.toString());
	    if(!classpath.isEmpty()) {
		StringBuilder buf = new StringBuilder();
		for(Path cp : classpath) {
		    if(buf.length() > 0)
			buf.append(":");
		    buf.append(cp.toString());
		}
		args.add("-cp");
		args.add(buf.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 class BufferedClassLoader extends ClassLoader {
	public final Map<String, byte[]> contents;

	public BufferedClassLoader(ClassLoader parent, Collection<ClassOutput> contents) {
	    super(parent);
	    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 LibClassLoader extends ClassLoader {
	private final ClassLoader[] classpath;

	public LibClassLoader(ClassLoader parent, Collection<ClassLoader> classpath) {
	    super(parent);
	    this.classpath = classpath.toArray(new ClassLoader[0]);
	}

	public Class<?> findClass(String name) throws ClassNotFoundException {
	    for(ClassLoader lib : classpath) {
		try {
		    return(lib.loadClass(name));
		} catch(ClassNotFoundException e) {}
	    }
	    throw(new ClassNotFoundException("Could not find " + name + " in any of " + Arrays.asList(classpath).toString()));
	}
    }

    public ClassLoader libloader(Path p) {
	synchronized(libs) {
	    ClassLoader ret = libs.get(p);
	    if(ret == null) {
		try {
		    libs.put(p, ret = new URLClassLoader(new URL[] {p.toUri().toURL()}));
		} catch(MalformedURLException e) {
		    throw(new RuntimeException(e));
		}
	    }
	    return(ret);
	}
    }

    private Path findlib(String nm) {
	try {
	    Path p = Paths.get(nm);
	    if(Files.isRegularFile(p))
		return(p);
	} catch(InvalidPathException e) {
	}
	for(Path dir : searchpath) {
	    Path jar = dir.resolve(nm + ".jar");
	    if(Files.isRegularFile(jar))
		return(jar);
	}
	return(null);
    }

    private static final Pattern classpat = Pattern.compile("^((public|abstract)\\s+)*(class|interface)\\s+(\\S+)");
    private static final Pattern libpat = Pattern.compile("\\$use\\s*:\\s*(\\S+)");
    public class Module {
	public final Path file;
	public final ClassLoader code;
	public final Collection<Path> classpath = new ArrayList<>();

	public Module(Path file) throws IOException {
	    this.file = file;
	    try(Compilation c = new Compilation()) {
		split(c);
		for(Path cp : classpath)
		    c.classpath(cp);
		if(!c.compile())
		    throw(new CompilationException(file, c.output()));
		ClassLoader parent = Compiler.class.getClassLoader();
		if(!classpath.isEmpty()) {
		    Collection<ClassLoader> libs = new ArrayList<>();
		    for(Path cp : classpath)
			libs.add(libloader(cp));
		    parent = new LibClassLoader(parent, libs);
		}
		code = new BufferedClassLoader(parent, c.classes());
	    }
	}

	public void split(Compilation c) throws IOException {
	    StringBuilder head = new StringBuilder();
	    BufferedWriter cur = null;
	    try(BufferedReader fp = Files.newBufferedReader(file)) {
		for(String ln = fp.readLine(); ln != null; ln = fp.readLine()) {
		    Matcher m = libpat.matcher(ln);
		    if(m.find()) {
			Path lib = findlib(m.group(1));
			if(lib == null)
			    throw(new CompilationException(file, Arrays.asList("no such library: " + m.group(1))));
			classpath.add(lib);
		    }
		    m = classpat.matcher(ln);
		    if(m.find()) {
			String clnm = m.group(4);
			Path sp = c.srcdir.resolve(clnm + ".java");
			c.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 class File {
	public final Path name;
	private FileTime mtime = null;
	private Module mod = null;

	private File(Path name) {
	    this.name = name;
	}

	public void update() throws IOException {
	    synchronized(this) {
		FileTime mtime = Files.getLastModifiedTime(name);
		if((this.mtime == null) || (this.mtime.compareTo(mtime) < 0)) {
		    mod = new Module(name);
		    this.mtime = mtime;
		}
	    }
	}

	public Module mod() {
	    if(mod == null)
		throw(new RuntimeException("file has not yet been updated"));
	    return(mod);
	}
    }

    public File file(Path name) {
	synchronized(files) {
	    File ret = files.get(name);
	    if(ret == null)
		files.put(name, ret = new File(name));
	    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);
    }
}