void test(String[] opts, String className) throws Exception {
count++;
System.err.println("Test " + count + " " + Arrays.asList(opts) + " " + className);
Path testSrcDir = Paths.get(System.getProperty("test.src"));
Path testClassesDir = Paths.get(System.getProperty("test.classes"));
Path classes = Paths.get("classes." + count);
classes.createDirectory();
Context ctx = new Context();
PathFileManager fm = new JavacPathFileManager(ctx, true, null);
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
List<String> options = new ArrayList<String>();
options.addAll(Arrays.asList(opts));
options.addAll(Arrays.asList("-verbose", "-XDverboseCompilePolicy", "-d", classes.toString()));
Iterable<? extends JavaFileObject> compilationUnits =
fm.getJavaFileObjects(testSrcDir.resolve(className + ".java"));
StringWriter sw = new StringWriter();
PrintWriter out = new PrintWriter(sw);
JavaCompiler.CompilationTask t =
compiler.getTask(out, fm, null, options, null, compilationUnits);
boolean ok = t.call();
System.err.println(sw.toString());
if (!ok) {
throw new Exception("compilation failed");
}
File expect = new File("classes." + count + "/" + className + ".class");
if (!expect.exists()) throw new Exception("expected file not found: " + expect);
long expectedSize = new File(testClassesDir.toString(), className + ".class").length();
long actualSize = expect.length();
if (expectedSize != actualSize)
throw new Exception("wrong size found: " + actualSize + "; expected: " + expectedSize);
}
public Compiler(Flags... flags) {
setFlags(flags);
this.tempDirs = new ArrayList<>();
this.postprocessors = new ArrayList<>();
this.systemJavaCompiler = ToolProvider.getSystemJavaCompiler();
this.fm = systemJavaCompiler.getStandardFileManager(null, null, null);
}
public static void compileJavaFiles(
@NotNull Collection<File> files, List<String> options, @Nullable File javaErrorFile)
throws IOException {
JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();
DiagnosticCollector<JavaFileObject> diagnosticCollector =
new DiagnosticCollector<JavaFileObject>();
StandardJavaFileManager fileManager =
javaCompiler.getStandardFileManager(
diagnosticCollector, Locale.ENGLISH, Charset.forName("utf-8"));
try {
Iterable<? extends JavaFileObject> javaFileObjectsFromFiles =
fileManager.getJavaFileObjectsFromFiles(files);
JavaCompiler.CompilationTask task =
javaCompiler.getTask(
new StringWriter(), // do not write to System.err
fileManager,
diagnosticCollector,
options,
null,
javaFileObjectsFromFiles);
Boolean success = task.call(); // do NOT inline this variable, call() should complete before
// errorsToString()
if (javaErrorFile == null || !javaErrorFile.exists()) {
Assert.assertTrue(errorsToString(diagnosticCollector, true), success);
} else {
assertEqualsToFile(javaErrorFile, errorsToString(diagnosticCollector, false));
}
} finally {
fileManager.close();
}
}
public TestInput(
Iterable<? extends JavaFileObject> files, Iterable<String> processors, String[] options) {
this.compiler = ToolProvider.getSystemJavaCompiler();
this.fileManager = compiler.getStandardFileManager(null, null, null);
this.files = files;
this.processors = processors;
this.options = new LinkedList<String>();
String classpath = System.getProperty("tests.classpath", "tests" + File.separator + "build");
String globalclasspath = System.getProperty("java.class.path", "");
this.options.add("-Xmaxerrs");
this.options.add("9999");
this.options.add("-g");
this.options.add("-d");
this.options.add(OUTDIR);
this.options.add("-classpath");
this.options.add(
"build"
+ File.pathSeparator
+ "junit.jar"
+ File.pathSeparator
+ classpath
+ File.pathSeparator
+ globalclasspath);
this.options.addAll(Arrays.asList(options));
}
public DesignerEditorPanel(@NotNull Module module, @NotNull VirtualFile file) {
myModule = module;
myFile = file;
setLayout(myLayout);
createDesignerCard();
createErrorCard();
createProgressPanel();
myToolProvider.loadDefaultTool();
}
protected void storeState() {
if (myRootComponent != null && myExpandedState == null && mySelectionState == null) {
myExpandedState = new int[myExpandedComponents == null ? 0 : myExpandedComponents.size()][];
for (int i = 0; i < myExpandedState.length; i++) {
IntArrayList path = new IntArrayList();
componentToPath((RadComponent) myExpandedComponents.get(i), path);
myExpandedState[i] = path.toArray();
}
mySelectionState = getSelectionState();
myExpandedComponents = null;
myToolProvider.loadDefaultTool();
mySurfaceArea.removeSelectionListener(mySourceSelectionListener);
mySurfaceArea.deselectAll();
mySurfaceArea.addSelectionListener(mySourceSelectionListener);
}
}
/**
* Wow! much faster than compiling outside of VM. Finicky though. Had rules called r and modulo.
* Wouldn't compile til I changed to 'a'.
*/
protected boolean compile(String fileName) {
String classpathOption = "-classpath";
String[] args =
new String[] {
"javac",
"-d",
tmpdir,
classpathOption,
tmpdir + pathSep + CLASSPATH,
tmpdir + "/" + fileName
};
String cmdLine =
"javac"
+ " -d "
+ tmpdir
+ " "
+ classpathOption
+ " "
+ tmpdir
+ pathSep
+ CLASSPATH
+ " "
+ fileName;
// System.out.println("compile: "+cmdLine);
File f = new File(tmpdir, fileName);
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
// DiagnosticCollector<JavaFileObject> diagnostics =
// new DiagnosticCollector<JavaFileObject>();
StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
Iterable<? extends JavaFileObject> compilationUnits =
fileManager.getJavaFileObjectsFromFiles(Arrays.asList(f));
Iterable<String> compileOptions =
Arrays.asList(new String[] {"-d", tmpdir, "-cp", tmpdir + pathSep + CLASSPATH});
JavaCompiler.CompilationTask task =
compiler.getTask(null, fileManager, null, compileOptions, null, compilationUnits);
boolean ok = task.call();
try {
fileManager.close();
} catch (IOException ioe) {
ioe.printStackTrace(System.err);
}
// List<String> errors = new ArrayList<String>();
// for (Diagnostic diagnostic : diagnostics.getDiagnostics()) {
// errors.add(
// String.valueOf(diagnostic.getLineNumber())+
// ": " + diagnostic.getMessage(null));
// }
// if ( errors.size()>0 ) {
// System.err.println("compile stderr from: "+cmdLine);
// System.err.println(errors);
// return false;
// }
return ok;
/*
File outputDir = new File(tmpdir);
try {
Process process =
Runtime.getRuntime().exec(args, null, outputDir);
StreamVacuum stdout = new StreamVacuum(process.getInputStream());
StreamVacuum stderr = new StreamVacuum(process.getErrorStream());
stdout.start();
stderr.start();
process.waitFor();
stdout.join();
stderr.join();
if ( stdout.toString().length()>0 ) {
System.err.println("compile stdout from: "+cmdLine);
System.err.println(stdout);
}
if ( stderr.toString().length()>0 ) {
System.err.println("compile stderr from: "+cmdLine);
System.err.println(stderr);
}
int ret = process.exitValue();
return ret==0;
}
catch (Exception e) {
System.err.println("can't exec compilation");
e.printStackTrace(System.err);
return false;
}
*/
}
public static boolean compile(
Collection<String> options,
final Collection<File> sources,
Collection<File> classpath,
Collection<File> platformClasspath,
Collection<File> sourcePath,
Map<File, Set<File>> outputDirToRoots,
final DiagnosticOutputConsumer outConsumer,
final OutputFileConsumer outputSink,
CanceledStatus canceledStatus,
boolean useEclipseCompiler) {
JavaCompiler compiler = null;
if (useEclipseCompiler) {
for (JavaCompiler javaCompiler : ServiceLoader.load(JavaCompiler.class)) {
compiler = javaCompiler;
break;
}
if (compiler == null) {
outConsumer.report(
new PlainMessageDiagnostic(
Diagnostic.Kind.ERROR, "Eclipse Batch Compiler was not found in classpath"));
return false;
}
}
final boolean nowUsingJavac;
if (compiler == null) {
compiler = ToolProvider.getSystemJavaCompiler();
if (compiler == null) {
outConsumer.report(
new PlainMessageDiagnostic(
Diagnostic.Kind.ERROR, "System Java Compiler was not found in classpath"));
return false;
}
nowUsingJavac = true;
} else {
nowUsingJavac = false;
}
for (File outputDir : outputDirToRoots.keySet()) {
outputDir.mkdirs();
}
final List<JavaSourceTransformer> transformers = getSourceTransformers();
final JavacFileManager fileManager =
new JavacFileManager(
new ContextImpl(compiler, outConsumer, outputSink, canceledStatus, nowUsingJavac),
transformers);
fileManager.handleOption(
"-bootclasspath", Collections.singleton("").iterator()); // this will clear cached stuff
fileManager.handleOption(
"-extdirs", Collections.singleton("").iterator()); // this will clear cached stuff
try {
fileManager.setOutputDirectories(outputDirToRoots);
} catch (IOException e) {
fileManager.getContext().reportMessage(Diagnostic.Kind.ERROR, e.getMessage());
return false;
}
if (!classpath.isEmpty()) {
try {
fileManager.setLocation(StandardLocation.CLASS_PATH, classpath);
if (!nowUsingJavac && !isOptionSet(options, "-processorpath")) {
// for non-javac file manager ensure annotation processor path defaults to classpath
fileManager.setLocation(StandardLocation.ANNOTATION_PROCESSOR_PATH, classpath);
}
} catch (IOException e) {
fileManager.getContext().reportMessage(Diagnostic.Kind.ERROR, e.getMessage());
return false;
}
}
if (!platformClasspath.isEmpty()) {
try {
fileManager.setLocation(StandardLocation.PLATFORM_CLASS_PATH, platformClasspath);
} catch (IOException e) {
fileManager.getContext().reportMessage(Diagnostic.Kind.ERROR, e.getMessage());
return false;
}
}
try {
// ensure the source path is set;
// otherwise, if not set, javac attempts to search both classes and sources in classpath;
// so if some classpath jars contain sources, it will attempt to compile them
fileManager.setLocation(StandardLocation.SOURCE_PATH, sourcePath);
} catch (IOException e) {
fileManager.getContext().reportMessage(Diagnostic.Kind.ERROR, e.getMessage());
return false;
}
//noinspection IOResourceOpenedButNotSafelyClosed
final LineOutputWriter out =
new LineOutputWriter() {
protected void lineAvailable(String line) {
if (nowUsingJavac) {
outConsumer.outputLineAvailable(line);
} else {
// todo: filter too verbose eclipse output?
}
}
};
try {
final Collection<String> _options = prepareOptions(options, nowUsingJavac);
// to be on the safe side, we'll have to apply all options _before_ calling any of manager's
// methods
// i.e. getJavaFileObjectsFromFiles()
// This way the manager will be properly initialized. Namely, the encoding will be set
// correctly
for (Iterator<String> iterator = _options.iterator(); iterator.hasNext(); ) {
fileManager.handleOption(iterator.next(), iterator);
}
final JavaCompiler.CompilationTask task =
compiler.getTask(
out,
fileManager,
outConsumer,
_options,
null,
fileManager.getJavaFileObjectsFromFiles(sources));
// if (!IS_VM_6_VERSION) { //todo!
// // Do not add the processor for JDK 1.6 because of the bugs in javac
// // The processor's presence may lead to NPE and resolve bugs in compiler
// final JavacASTAnalyser analyzer = new JavacASTAnalyser(outConsumer,
// !annotationProcessingEnabled);
// task.setProcessors(Collections.singleton(analyzer));
// }
return task.call();
} catch (IllegalArgumentException e) {
outConsumer.report(new PlainMessageDiagnostic(Diagnostic.Kind.ERROR, e.getMessage()));
} catch (CompilationCanceledException ignored) {
outConsumer.report(
new PlainMessageDiagnostic(Diagnostic.Kind.OTHER, "Compilation was canceled"));
} finally {
fileManager.close();
if (nowUsingJavac) {
cleanupJavacNameTable();
}
}
return false;
}
public static void main(String[] args) {
// Main
frame = new JFrame("Java Playground");
frame.setSize(640, 480);
// Make sure the divider is properly resized
frame.addComponentListener(
new ComponentAdapter() {
public void componentResized(ComponentEvent c) {
splitter.setDividerLocation(defaultSliderPosition);
}
});
// Make sure the JVM is reset on close
frame.addWindowListener(
new WindowAdapter() {
public void windowClosed(WindowEvent w) {
new FrameAction().kill();
}
});
// Setting up the keybinding
// Ctrl+r or Cmd+r -> compile/run
bind(KeyEvent.VK_R);
// Ctrl+k or Cmd+k -> kill JVM
bind(KeyEvent.VK_K);
// Ctrl+e or Cmd+e -> console
bind(KeyEvent.VK_E);
// Save, New file, Open file, Print.
// Currently UNUSED until I figure out how normal java files and playground files will
// interface.
bind(KeyEvent.VK_S);
bind(KeyEvent.VK_N);
bind(KeyEvent.VK_O); // Rebound to options menu for now
bind(KeyEvent.VK_P);
// Ctrl+h or Cmd+h -> help menu
bind(KeyEvent.VK_SLASH);
// Binds the keys to the action defined in the FrameAction class.
frame.getRootPane().getActionMap().put("console", new FrameAction());
// The main panel for typing code in.
text = new JTextPane();
textScroll = new JScrollPane(text);
textScroll.setBorder(null);
textScroll.setPreferredSize(new Dimension(640, 480));
// Document with syntax highlighting. Currently unfinished.
doc = text.getStyledDocument();
doc.addDocumentListener(
new DocumentListener() {
public void changedUpdate(DocumentEvent d) {}
public void insertUpdate(DocumentEvent d) {}
public void removeUpdate(DocumentEvent d) {}
});
((AbstractDocument) doc).setDocumentFilter(new NewLineFilter());
// The output log; a combination compiler warning/error/runtime error/output log.
outputText = new JTextPane();
outputScroll = new JScrollPane(outputText);
outputScroll.setBorder(null);
// "Constant" for the error font
error = new SimpleAttributeSet();
error.addAttribute(StyleConstants.CharacterConstants.Italic, Boolean.TRUE);
error.addAttribute(StyleConstants.Foreground, Color.RED);
// "Constant" for the warning message font
warning = new SimpleAttributeSet();
warning.addAttribute(StyleConstants.CharacterConstants.Italic, Boolean.TRUE);
warning.addAttribute(StyleConstants.Foreground, Color.PINK);
// "Constant" for the debugger error font
progErr = new SimpleAttributeSet();
progErr.addAttribute(StyleConstants.Foreground, Color.BLUE);
// Print streams to redirect System.out and System.err.
out = new TextOutputStream(outputText, null);
err = new TextOutputStream(outputText, error);
System.setOut(new PrintStream(out));
System.setErr(new PrintStream(err));
// Sets up the output log
outputText.setEditable(false);
outputScroll.setVisible(true);
// File input/output setup
chooser = new JFileChooser();
// Setting up miscellaneous stuff
compiler = ToolProvider.getSystemJavaCompiler();
JVMrunning = false;
redirectErr = null;
redirectOut = null;
redirectIn = null;
// Options initial values
defaultSliderPosition = .8;
// Sets up the splitter pane and opens the program up
splitter = new JSplitPane(JSplitPane.VERTICAL_SPLIT, textScroll, outputScroll);
consoleDisplayed = false;
splitter.remove(outputScroll); // Initially hides terminal until it is needed
splitter.setOneTouchExpandable(true);
frame.add(splitter);
frame.setVisible(true);
// Sets the divider to the proper one, for debugging
// splitter.setDividerLocation(.8);
}
/** @author <a href="mailto:[email protected]">Julien Viet</a> */ public class ConvertingProcessor extends AbstractProcessor { private static final javax.tools.JavaCompiler javac = ToolProvider.getSystemJavaCompiler(); private static final Locale locale = Locale.getDefault(); private static final Charset charset = Charset.forName("UTF-8"); public static Map<Lang, Result> convert( ClassLoader loader, List<Lang> langs, String source, String fqn, String method) throws Exception { URL url = loader.getResource(source); if (url == null) { throw new Exception("Cannot resolve source " + source + ""); } String file = new File(url.toURI()).getAbsolutePath(); return convertFromFiles(loader, langs, file, fqn, method); } public static Map<Lang, Result> convertFromFiles( ClassLoader loader, List<Lang> lang, String file, String fqn, String method) throws Exception { DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>(); StandardJavaFileManager manager = javac.getStandardFileManager(diagnostics, locale, charset); Iterable<? extends JavaFileObject> fileObjects = manager.getJavaFileObjects(file); StringWriter out = new StringWriter(); JavaCompiler.CompilationTask task = javac.getTask( out, manager, diagnostics, Collections.<String>emptyList(), Collections.<String>emptyList(), fileObjects); task.setLocale(locale); ConvertingProcessor processor = new ConvertingProcessor(lang, fqn, method); task.setProcessors(Collections.<Processor>singletonList(processor)); if (task.call()) { return processor.getResults(); } else { StringWriter message = new StringWriter(); PrintWriter writer = new PrintWriter(message); writer.append("Compilation of ").append(file).println(" failed:"); for (Diagnostic<? extends JavaFileObject> diagnostic : diagnostics.getDiagnostics()) { writer.append(diagnostic.getMessage(locale)); } writer.println("console:"); writer.append(out.getBuffer()); throw new Exception(message.toString()); } } private Map<Lang, Result> results = new LinkedHashMap<>(); private List<Lang> langs; private final String fqn; private final String method; private CodeTranslator translator; public ConvertingProcessor(List<Lang> langs, String fqn, String method) { this.langs = langs; this.fqn = fqn; this.method = method; } public Map<Lang, Result> getResults() { return results; } @Override public Set<String> getSupportedAnnotationTypes() { return Collections.singleton(CodeTranslate.class.getName()); } @Override public synchronized void init(ProcessingEnvironment processingEnv) { super.init(processingEnv); this.translator = new CodeTranslator(processingEnv); } @Override public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { for (Element annotatedElt : roundEnv.getElementsAnnotatedWith(CodeTranslate.class)) { ExecutableElement methodElt = (ExecutableElement) annotatedElt; TypeElement typeElt = (TypeElement) methodElt.getEnclosingElement(); if (typeElt.getQualifiedName().toString().equals(fqn) && methodElt.getSimpleName().toString().equals(method)) { for (Lang lang : langs) { Result result; try { String translation = translator.translate(methodElt, lang); result = new Result.Source(translation); } catch (Exception e) { result = new Result.Failure(e); } results.put(lang, result); } } } return false; } }
