OoasTools

/**

  *

  *                      OOAS Compiler

  *

  *       Copyright 2015, AIT Austrian Institute of Technology.

  * This code is based on the C# Version of the OOAS Compiler, which is

  * copyright 2015 by the Institute of Software Technology, Graz University

  * of Technology with portions copyright by the AIT Austrian Institute of

  * Technology. All rights reserved.

  *

  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.

  *

  * If you modify the file please update the list of contributors below to in-

  * clude your name. Please also stick to the coding convention of using TABs

  * to do the basic (block-level) indentation and spaces for anything after

  * that. (Enable the display of special chars and it should be pretty obvious

  * what this means.) Also, remove all trailing whitespace.

  *

  * Contributors:

  *               Willibald Krenn (AIT)

  *               Stephan Zimmerer (AIT)

  *               Markus Demetz (AIT)

  *               Christoph Czurda (AIT)

  *

  */

package org.momut.ooas.codegen.java;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.PrintWriter;

import java.io.Writer;

import java.lang.reflect.Method;

import java.net.URI;

import java.util.Arrays;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.tools.FileObject;

import javax.tools.ForwardingJavaFileManager;

import javax.tools.JavaCompiler;

import javax.tools.JavaFileObject;

import javax.tools.SimpleJavaFileObject;

import javax.tools.StandardJavaFileManager;

import org.eclipse.jdt.internal.compiler.tool.EclipseCompiler;

/**

 * This code is based on a blog entry of Morten Nobel.

 *

 * http://blog.nobel-joergensen.com/2008/07/16/using-eclipse-compiler-to-create-dynamic-java-objects-2/

 *

 */

/// <summary>

/// This class can be used to execute dynamic uncompiled code at runtime

/// This class is not exception safe, all function calls should be exception handled.

/// </summary>

public class JavaCodeCompiler

{

	private static class MemorySource extends SimpleJavaFileObject {

		private final String src;

		public MemorySource(String name, String src) {

			super(URI.create("file:///" + name + ".java"), Kind.SOURCE);

			this.src = src;

		}

		@Override

		public CharSequence getCharContent(boolean ignoreEncodingErrors) {

			return src;

		}

		@Override

		public OutputStream openOutputStream() {

			throw new IllegalStateException();

		}

		@Override

		public InputStream openInputStream() {

			return new ByteArrayInputStream(src.getBytes());

		}

	}

	private static class SpecialJavaFileManager extends ForwardingJavaFileManager<StandardJavaFileManager> {

		private final SpecialClassLoader xcl;

		public SpecialJavaFileManager(StandardJavaFileManager sjfm, SpecialClassLoader xcl) {

			super(sjfm);

			this.xcl = xcl;

		}

		@Override

		public JavaFileObject getJavaFileForOutput(Location location, String name, JavaFileObject.Kind kind, FileObject sibling) throws IOException {

			final MemoryByteCode mbc = new MemoryByteCode(name);

			xcl.addClass(name, mbc);

			return mbc;

		}

		@Override

		public ClassLoader getClassLoader(Location location) {

			return xcl;

		}

	}

	private static class MemoryByteCode extends SimpleJavaFileObject {

		private ByteArrayOutputStream baos;

		public MemoryByteCode(String name) {

			super(URI.create("byte:///" + name + ".class"), Kind.CLASS);

		}

		@Override

		public CharSequence getCharContent(boolean ignoreEncodingErrors) {

			throw new IllegalStateException();

		}

		@Override

		public OutputStream openOutputStream() {

			baos = new ByteArrayOutputStream();

			return baos;

		}

		@Override

		public InputStream openInputStream() {

			throw new IllegalStateException();

		}

		public byte[] getBytes() {

			return baos.toByteArray();

		}

	}

	private static class SpecialClassLoader extends ClassLoader {

		private final Map<String,MemoryByteCode> m = new HashMap<String, MemoryByteCode>();

		@Override

		protected Class<?> findClass(String name) throws ClassNotFoundException {

			MemoryByteCode mbc = m.get(name);

			if (mbc==null){

				mbc = m.get(name.replace(".","/"));

				if (mbc==null){

					return super.findClass(name);

				}

			}

			return defineClass(name, mbc.getBytes(), 0, mbc.getBytes().length);

		}

		public void addClass(String name, MemoryByteCode mbc) {

			m.put(name, mbc);

		}

	}

	public static Class<?> compileCode(String code, String className, String packageName, ParserState parserState)

	{

		try {

			final JavaCompiler javac = new EclipseCompiler();

			final StandardJavaFileManager sjfm = javac.getStandardFileManager(null, null, null);

			final SpecialClassLoader cl = new SpecialClassLoader();

			final SpecialJavaFileManager fileManager = new SpecialJavaFileManager(sjfm, cl);

			final List<String> options = Arrays.asList(new String[]{"-1.7"});

			final List<MemorySource> compilationUnits = Arrays.asList(new MemorySource(className, code));

//			DiagnosticListener<?> dianosticListener = null;

			final Iterable<String> classes = null;

			final Writer out = new PrintWriter(System.err);

			final JavaCompiler.CompilationTask compile = javac.getTask(out, fileManager, null, options, classes, compilationUnits);

			final boolean res = compile.call();

			if (res){

				return cl.findClass(packageName + "." + className);

			}

		} catch (final Exception e){

			parserState.AddErrorMessage(new ParserError("JavaCodeCompiler.java",0,0,e.getMessage()));

		}

		return null;

//		if (results.Errors.HasErrors)

//		{

//			StringBuilder errors = new StringBuilder("Compiler Errors :\r\n");

//			foreach (CompilerError error in results.Errors)

//			{

//				errors.AppendFormat("Line %s,%s\t: %s\n", error.Line, error.Column, error.ErrorText);

//			}

//			throw new UlyssesCompileException(errors.ToString());

//		}

//		else

//		{

//			return results.CompiledAssembly;

//		}

	}

	public static void ExecuteCode(Class<?> clazz, String methodname, JavaInitVisitor visitor, ParserState parserState)

	{

		try{

			final Object o = clazz.getConstructor().newInstance();

			final Method m = clazz.getMethod("start", JavaInitVisitor.class);

			m.invoke(o, visitor);

		}

		catch (final Exception e) {

			parserState.AddErrorMessage(new ParserError("JavaCodeCompiler.java",0,0,e.toString()));

		}

	}

}