| 1 | package jagi.fs; |
| 2 | |
| 3 | import jagi.*; |
| 4 | import java.util.*; |
| 5 | import java.util.regex.*; |
| 6 | import java.nio.file.*; |
| 7 | import java.nio.file.attribute.*; |
| 8 | import java.io.*; |
| 9 | |
| 10 | public class Compiler { |
| 11 | private final Map<Path, Module> modules = new HashMap<>(); |
| 12 | |
| 13 | public static class ClassOutput { |
| 14 | public final String name; |
| 15 | public final ByteArrayOutputStream buf = new ByteArrayOutputStream(); |
| 16 | |
| 17 | public ClassOutput(String name) { |
| 18 | this.name = name; |
| 19 | } |
| 20 | } |
| 21 | |
| 22 | public static class CompilationException extends RuntimeException { |
| 23 | public final Path file; |
| 24 | private final List<? extends Object> messages; |
| 25 | |
| 26 | public CompilationException(Path file, List<? extends Object> messages) { |
| 27 | this.file = file; |
| 28 | this.messages = messages; |
| 29 | } |
| 30 | |
| 31 | public String getMessage() { |
| 32 | return(file + ": compilation failed"); |
| 33 | } |
| 34 | |
| 35 | public String messages() { |
| 36 | StringBuilder buf = new StringBuilder(); |
| 37 | for(Object msg : messages) |
| 38 | buf.append(msg.toString() + "\n"); |
| 39 | return(buf.toString()); |
| 40 | } |
| 41 | |
| 42 | public void printStackTrace(PrintStream out) { |
| 43 | out.print(messages()); |
| 44 | super.printStackTrace(out); |
| 45 | } |
| 46 | } |
| 47 | |
| 48 | public static class Compilation implements AutoCloseable { |
| 49 | private final Path dir, srcdir, outdir; |
| 50 | private final List<Path> infiles = new ArrayList<>(); |
| 51 | private List<String> output = null; |
| 52 | |
| 53 | public Compilation() throws IOException { |
| 54 | dir = Files.createTempDirectory("javac"); |
| 55 | srcdir = dir.resolve("src"); |
| 56 | outdir = dir.resolve("out"); |
| 57 | Files.createDirectory(srcdir); |
| 58 | Files.createDirectory(outdir); |
| 59 | } |
| 60 | |
| 61 | public void add(Path p) { |
| 62 | infiles.add(p); |
| 63 | } |
| 64 | |
| 65 | private static final Pattern classpat = Pattern.compile("^((public|abstract)\\s+)*(class|interface)\\s+(\\S+)"); |
| 66 | public void split(Path infile) throws IOException { |
| 67 | StringBuilder head = new StringBuilder(); |
| 68 | BufferedWriter cur = null; |
| 69 | try(BufferedReader fp = Files.newBufferedReader(infile)) { |
| 70 | for(String ln = fp.readLine(); ln != null; ln = fp.readLine()) { |
| 71 | Matcher m = classpat.matcher(ln); |
| 72 | if(m.find()) { |
| 73 | String clnm = m.group(4); |
| 74 | Path sp = srcdir.resolve(clnm + ".java"); |
| 75 | add(sp); |
| 76 | if(cur != null) |
| 77 | cur.close(); |
| 78 | cur = Files.newBufferedWriter(sp); |
| 79 | cur.append(head); |
| 80 | } |
| 81 | if(cur != null) { |
| 82 | cur.append(ln); cur.append('\n'); |
| 83 | } else { |
| 84 | head.append(ln); head.append('\n'); |
| 85 | } |
| 86 | } |
| 87 | } finally { |
| 88 | if(cur != null) |
| 89 | cur.close(); |
| 90 | } |
| 91 | } |
| 92 | |
| 93 | public boolean compile() throws IOException { |
| 94 | List<String> args = new ArrayList<>(); |
| 95 | args.add("javac"); |
| 96 | args.add("-d"); |
| 97 | args.add(outdir.toString()); |
| 98 | for(Path p : infiles) |
| 99 | args.add(p.toString()); |
| 100 | ProcessBuilder cmd = new ProcessBuilder(args); |
| 101 | cmd.redirectErrorStream(true); |
| 102 | cmd.redirectOutput(ProcessBuilder.Redirect.PIPE); |
| 103 | Process proc = cmd.start(); |
| 104 | List<String> output = new ArrayList<>(); |
| 105 | BufferedReader fp = new BufferedReader(new InputStreamReader(proc.getInputStream(), Utils.UTF8)); |
| 106 | while(true) { |
| 107 | String ln = fp.readLine(); |
| 108 | if(ln == null) |
| 109 | break; |
| 110 | output.add(ln); |
| 111 | } |
| 112 | int status; |
| 113 | try { |
| 114 | status = proc.waitFor(); |
| 115 | } catch(InterruptedException e) { |
| 116 | Thread.currentThread().interrupt(); |
| 117 | throw(new IOException("compilation interrupted")); |
| 118 | } |
| 119 | this.output = output; |
| 120 | return(status == 0); |
| 121 | } |
| 122 | |
| 123 | public List<String> output() { |
| 124 | if(output == null) |
| 125 | throw(new IllegalStateException()); |
| 126 | return(output); |
| 127 | } |
| 128 | |
| 129 | public Collection<ClassOutput> classes() throws IOException { |
| 130 | Collection<ClassOutput> ret = new ArrayList<>(); |
| 131 | for(Path p : (Iterable<Path>)Files.walk(outdir)::iterator) { |
| 132 | Path rel = outdir.relativize(p); |
| 133 | String fn = rel.getName(rel.getNameCount() - 1).toString(); |
| 134 | if(!Files.isRegularFile(p) || !fn.endsWith(".class")) |
| 135 | continue; |
| 136 | StringBuilder clnm = new StringBuilder(); |
| 137 | for(int i = 0; i < rel.getNameCount() - 1; i++) { |
| 138 | clnm.append(rel.getName(i)); |
| 139 | clnm.append('.'); |
| 140 | } |
| 141 | clnm.append(fn.substring(0, fn.length() - 6)); |
| 142 | ClassOutput cls = new ClassOutput(clnm.toString()); |
| 143 | Files.copy(p, cls.buf); |
| 144 | ret.add(cls); |
| 145 | } |
| 146 | return(ret); |
| 147 | } |
| 148 | |
| 149 | private static void remove(Path p) throws IOException { |
| 150 | if(Files.isDirectory(p)) { |
| 151 | for(Path ent : (Iterable<Path>)Files.list(p)::iterator) |
| 152 | remove(ent); |
| 153 | } |
| 154 | Files.delete(p); |
| 155 | } |
| 156 | |
| 157 | public void close() throws IOException { |
| 158 | remove(dir); |
| 159 | } |
| 160 | } |
| 161 | |
| 162 | public static Collection<ClassOutput> compile(Path file) throws IOException { |
| 163 | try(Compilation c = new Compilation()) { |
| 164 | c.split(file); |
| 165 | if(!c.compile()) |
| 166 | throw(new CompilationException(file, c.output())); |
| 167 | return(c.classes()); |
| 168 | } |
| 169 | } |
| 170 | |
| 171 | public static class BufferedClassLoader extends ClassLoader { |
| 172 | public final Map<String, byte[]> contents; |
| 173 | |
| 174 | public BufferedClassLoader(Collection<ClassOutput> contents) { |
| 175 | this.contents = new HashMap<>(); |
| 176 | for(ClassOutput clc : contents) |
| 177 | this.contents.put(clc.name, clc.buf.toByteArray()); |
| 178 | } |
| 179 | |
| 180 | public Class<?> findClass(String name) throws ClassNotFoundException { |
| 181 | byte[] c = contents.get(name); |
| 182 | if(c == null) |
| 183 | throw(new ClassNotFoundException(name)); |
| 184 | return(defineClass(name, c, 0, c.length)); |
| 185 | } |
| 186 | } |
| 187 | |
| 188 | public static class Module { |
| 189 | public final Path file; |
| 190 | private FileTime mtime = null; |
| 191 | private ClassLoader code = null; |
| 192 | |
| 193 | private Module(Path file) { |
| 194 | this.file = file; |
| 195 | } |
| 196 | |
| 197 | public void update() throws IOException { |
| 198 | synchronized(this) { |
| 199 | FileTime mtime = Files.getLastModifiedTime(file); |
| 200 | if((this.mtime == null) || (this.mtime.compareTo(mtime) < 0)) { |
| 201 | code = new BufferedClassLoader(compile(file)); |
| 202 | this.mtime = mtime; |
| 203 | } |
| 204 | } |
| 205 | } |
| 206 | |
| 207 | public ClassLoader code() { |
| 208 | if(code == null) |
| 209 | throw(new RuntimeException("module has not yet been updated")); |
| 210 | return(code); |
| 211 | } |
| 212 | } |
| 213 | |
| 214 | public Module module(Path file) { |
| 215 | synchronized(modules) { |
| 216 | Module ret = modules.get(file); |
| 217 | if(ret == null) |
| 218 | modules.put(file, ret = new Module(file)); |
| 219 | return(ret); |
| 220 | } |
| 221 | } |
| 222 | |
| 223 | private static Compiler global = null; |
| 224 | public static Compiler get() { |
| 225 | if(global == null) { |
| 226 | synchronized(Compiler.class) { |
| 227 | if(global == null) |
| 228 | global = new Compiler(); |
| 229 | } |
| 230 | } |
| 231 | return(global); |
| 232 | } |
| 233 | } |