plugins/org.eclipse.m2m.atl.engine/src/org/eclipse/m2m/atl/engine/compiler/AtlCompiler.java

/*******************************************************************************
 * Copyright (c) 2004, 2014 INRIA.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Frederic Jouault (INRIA) - initial API and implementation
 *    Matthias Bohlen - refactorings for ease of use and elimination of duplicate code
 *    Dennis Wagelaar
 *******************************************************************************/
package org.eclipse.m2m.atl.engine.compiler;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.CharArrayReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.m2m.atl.common.ATLLogger;
import org.eclipse.m2m.atl.engine.Messages;
import org.eclipse.m2m.atl.engine.compiler.atl2006.Atl2006Compiler;
import org.eclipse.m2m.atl.engine.compiler.atl2010.Atl2010InPlace;
import org.eclipse.m2m.atl.engine.parser.AtlSourceManager;

/**
 * The ATL compiler.
 * 
 * @author <a href="mailto:frederic.jouault@univ-nantes.fr">Frederic Jouault</a>
 * @author <a href="mailto:mbohlen@mbohlen.de">Matthias Bohlen</a>
 * @author <a href="mailto:dwagelaar@gmail.com">Dennis Wagelaar</a>
 */
public final class AtlCompiler {

	/** The default ATL compiler. */
	public static final String DEFAULT_COMPILER_NAME = "atl2006"; //$NON-NLS-1$

	private static final int MAX_LINE_LENGTH = 1000;

	private static Map compilers = new HashMap();

	private AtlCompiler() {
		super();
	}

	/**
	 * Searches for the correct implementation of {@link AtlStandaloneCompiler} which is independent of
	 * Eclipse platform stuff like IFile, IResource, etc.
	 * 
	 * @param compilerName
	 *            name of the compiler to search for
	 * @return the compiler which was found
	 */
	public static AtlStandaloneCompiler getCompiler(String compilerName) {
		AtlStandaloneCompiler ret = (AtlStandaloneCompiler)compilers.get(compilerName);
		if (ret == null) {
			if ("atl2010".equals(compilerName)) { //$NON-NLS-1$
				ret = new Atl2010InPlace();
				compilers.put(compilerName, ret);
			} else if ("atl2006".equals(compilerName)) { //$NON-NLS-1$
				ret = new Atl2006Compiler();
				compilers.put(compilerName, ret);
			} else if ("atl2004".equals(compilerName)) { //$NON-NLS-1$
				ret = new Atl2004Compiler();
				compilers.put(compilerName, ret);
			} else {
				try {
					IExtensionRegistry registry = Platform.getExtensionRegistry();
					if (registry == null) {
						throw new CompilerNotFoundException(Messages
								.getString("AtlCompiler.REGISTRYNOTFOUND")); //$NON-NLS-1$
					}
					IExtensionPoint point = registry
							.getExtensionPoint("org.eclipse.m2m.atl.engine.atlcompiler"); //$NON-NLS-1$

					IExtension[] extensions = point.getExtensions();
					extensions: for (int i = 0; i < extensions.length; i++) {
						IConfigurationElement[] elements = extensions[i].getConfigurationElements();
						for (int j = 0; j < elements.length; j++) {
							try {
								if (elements[j].getAttribute("name").equals(compilerName)) { //$NON-NLS-1$
									ret = (AtlStandaloneCompiler)elements[j]
											.createExecutableExtension("class"); //$NON-NLS-1$
									compilers.put(compilerName, ret);
									break extensions;
								}
							} catch (CoreException e) {
								throw new CompilerNotFoundException(e.getLocalizedMessage());
							}
						}
					}
				} catch (Throwable exception) {
					// Assume that it's not available.
				}
			}

			if (ret == null) {
				throw new CompilerNotFoundException(Messages.getString(
						"AtlCompiler.COMPILERNOTFOUND", new Object[] {compilerName})); //$NON-NLS-1$
			}
		}

		return ret;
	}

	/**
	 * Performs compilation.
	 * 
	 * @param in
	 *            The InputStream to get atl source from.
	 * @param out
	 *            The IFile to which the ATL compiled program will be saved.
	 * @return the problems which occured during compilation
	 */
	public static EObject[] compile(Reader in, IFile out) throws IOException {
		EObject[] ret = compile(in, out.getLocation().toString());
		try {
			out.refreshLocal(0, null);
		} catch (CoreException e) {
			ATLLogger.log(Level.SEVERE, e.getLocalizedMessage(), e);
		}
		return ret;
	}

	/**
	 * Standalone compilation.
	 * 
	 * @param in
	 *            The InputStream to get atl source from.
	 * @param outputFileName
	 *            The output file name
	 * @return the problems which occurred during compilation
	 */
	public static EObject[] compile(Reader in, String outputFileName) throws IOException {
		EObject[] ret = null;
		String atlcompiler = null;
		// The BufferedReader is required to reset the stream before actually compiling
		final BufferedReader newIn = new BufferedReader(in, MAX_LINE_LENGTH);
		newIn.mark(MAX_LINE_LENGTH);
		char[] buffer = new char[MAX_LINE_LENGTH];
		newIn.read(buffer);
		atlcompiler = AtlSourceManager.getCompilerName(AtlSourceManager.getTaggedInformations(
				new BufferedReader(new CharArrayReader(buffer)), AtlSourceManager.COMPILER_TAG));
		newIn.reset();

		ret = getCompiler(atlcompiler).compileWithProblemModel(newIn, outputFileName);
		return ret;
	}

	/**
	 * Standalone compilation, to an outputStream.
	 * 
	 * @param in
	 *            The InputStream to get atl source from.
	 * @param outputStream
	 *            The output file name
	 * @return the problems which occurred during compilation
	 */
	public static EObject[] compile(InputStream in, OutputStream outputStream) throws IOException {
		EObject[] ret = null;
		String atlcompiler = null;
		InputStream newIn = in;
		// The BufferedInputStream is required to reset the stream before actually compiling
		newIn = new BufferedInputStream(newIn, MAX_LINE_LENGTH);
		newIn.mark(MAX_LINE_LENGTH);
		byte[] buffer = new byte[MAX_LINE_LENGTH];
		newIn.read(buffer);
		atlcompiler = AtlSourceManager.getCompilerName(AtlSourceManager.getTaggedInformations(buffer,
				AtlSourceManager.COMPILER_TAG));
		newIn.reset();

		ret = getCompiler(atlcompiler).compileWithProblemModel(newIn, outputStream);
		return ret;
	}

}