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;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

public final class Compiler {

	public interface IProgressCallBack {

		public void startingCompilePhase(String compilePhaseName);

		public void doneCompilePhase();

	}

	public interface ILogCallBack {

		public void logError(boolean toConsole, String message);

	}

	private static final class NullProgressCallBack implements IProgressCallBack {

		@Override

		public void startingCompilePhase(String compilePhaseName) {}

		@Override

		public void doneCompilePhase() {}

	}

	private interface CreateVisitor {

		public IAstVisitor create(ParserState aState);

	}

	public final CompilerConfiguration config;

	private final ArrayList<CreateVisitor> pipeLine = new ArrayList<CreateVisitor>();

	private ArrayList<ParserError> listOfParserErrors = new ArrayList<>();

	private ArrayList<ParserWarning> listOfParserWarnings = new ArrayList<>();

	private ArrayList<ParserMessage> listOfParserMessages = new ArrayList<>();

	private void updateParserMsgs(ParserState pState) {

		final Comparator<CompilerMessage> comparator = new Comparator<CompilerMessage>(){

			@Override

			public int compare(CompilerMessage arg0, CompilerMessage arg1) {

				if (arg0.line() != arg1.line())

					return arg0.line() - arg1.line();

				else

					return arg0.column() - arg1.column();

			}};

		listOfParserErrors = pState.listOfParserErrors;

		listOfParserMessages = pState.listOfParserMessages;

		listOfParserWarnings = pState.listOfParserWarnings;

		// sort the logs

		Collections.sort(listOfParserErrors, comparator);

		Collections.sort(listOfParserMessages, comparator);

		Collections.sort(listOfParserWarnings, comparator);

	}

	public List<ParserError> getErrors() {

		return Collections.unmodifiableList(listOfParserErrors);

	}

	public List<ParserWarning> getWarnings() {

		return Collections.unmodifiableList(listOfParserWarnings);

	}

	public List<ParserMessage> getMessages() {

		return Collections.unmodifiableList(listOfParserMessages);

	}

	@Override

	public String toString() {

		final StringBuilder result = new StringBuilder();

		for (final ParserError err: getErrors())

			result.append(String.format("ERROR: %s (%s,%s): %s\n",

				err.file(), err.line(), err.column(), err.message()));

		for (final ParserWarning err: getWarnings())

			result.append(String.format("Warning: %s (%s,%s): %s\n",

				err.file(), err.line(), err.column(), err.message()));

		for (final ParserMessage msg: getMessages())

			result.append(String.format("Info: %s (%s,%s): %s\n",

				msg.file(), msg.line(), msg.column(), msg.message()));

		return result.toString();

	}

	private void fillPipeLine() {

		pipeLine.add(new CreateVisitor(){

			@Override

			public IAstVisitor create(ParserState aState) {

				return new OoaCheckASTVisitor(aState, "Stage 0");

			}});

		pipeLine.add(new CreateVisitor(){

			@Override

			public IAstVisitor create(ParserState aState) {

				return new OoaSymbolSortVisitor(aState);

			}});

		pipeLine.add(new CreateVisitor(){

			@Override

			public IAstVisitor create(ParserState aState) {

				return new OoaReplaceOpaqueVisitor(aState);

			}});

		pipeLine.add(new CreateVisitor(){

			@Override

			public IAstVisitor create(ParserState aState) {

				return new OoaTypesVisitor(aState);

			}});

		pipeLine.add(new CreateVisitor(){

			@Override

			public IAstVisitor create(ParserState aState) {

				return new OoaResolveExpressionsVisitor(aState);

			}});

		pipeLine.add(new CreateVisitor(){

			@Override

			public IAstVisitor create(ParserState aState) {

				return new OoaMethodPureClassifierVisitor(aState);

			}});

		pipeLine.add(new CreateVisitor(){

			@Override

			public IAstVisitor create(ParserState aState) {

				return new OoaTypeCheckVisitor(aState);

			}});

		if (!config.getNamedTypePrefix().equals(""))

		{

			pipeLine.add(new CreateVisitor(){

				@Override

				public IAstVisitor create(ParserState aState) {

					return new OoaTypeRenameVisitor(aState);

				}});

		}

		// do some trivial "optimizations" (remove prioritized and nondet choice blocks

		// with only one element, join sequential blocks that are direct children of

		// sequential blocks to one sequential block

		pipeLine.add(new CreateVisitor(){

			@Override

			public IAstVisitor create(ParserState aState) {

				return new OoaRemoveTrivialBlocksVisitor(aState);

			}});

		// check the AST

		pipeLine.add(new CreateVisitor(){

			@Override

			public IAstVisitor create(ParserState aState) {

				return new OoaCheckASTVisitor(aState,"After Optimisation");

			}});

		pipeLine.add(new CreateVisitor(){

			@Override

			public IAstVisitor create(ParserState aState) {

				return new OoaActionClassifierVisitor(aState);

			}});

		pipeLine.add(new CreateVisitor(){

			@Override

			public IAstVisitor create(ParserState aState) {

				return new OoaPrintMetricsVisitor(aState);

			}

		});

		switch (config.getBackend()) {

		case Printer:

			pipeLine.add(new CreateVisitor(){

				@Override

				public IAstVisitor create(ParserState aState) {

					return new OoaPrintVisitor(aState);

				}});

			break;

		case CADP :

			pipeLine.add(new CreateVisitor(){

				@Override

				public IAstVisitor create(ParserState aState) {

					return new OoaObjectInstantiationVisitor(aState, config.getLabelCompression());

				}});

			pipeLine.add(new CreateVisitor(){

				@Override

				public IAstVisitor create(ParserState aState) {

					return new OoaPrintActionsVisitor(aState);

				}});

			pipeLine.add(new CreateVisitor(){

				@Override

				public IAstVisitor create(ParserState aState) {

					return new OoaPrintActionSequencesVisitor(aState);

				}});

			pipeLine.add(new CreateVisitor(){

				@Override

				public IAstVisitor create(ParserState aState) {

					return new OoaCADPVisitor(aState);

				}});

			break;

		case Prolog:

			pipeLine.add(new CreateVisitor(){

				@Override

				public IAstVisitor create(ParserState aState) {

					return new OoaObjectInstantiationVisitor(aState, config.getLabelCompression());

				}});

			pipeLine.add(new CreateVisitor(){

				@Override

				public IAstVisitor create(ParserState aState) {

					return new OoaPrintActionsVisitor(aState);

				}});

			pipeLine.add(new CreateVisitor(){

				@Override

				public IAstVisitor create(ParserState aState) {

					return new OoaPrintActionSequencesVisitor(aState);

				}});

			pipeLine.add(new CreateVisitor(){

				@Override

				public IAstVisitor create(ParserState aState) {

					return new OoaPrologVisitor(aState, config.getMaxSearchDepth(), config.getNameSpace());

				}});

			break;

		case PrologSymbolic:

			pipeLine.add(new CreateVisitor(){

				@Override

				public IAstVisitor create(ParserState aState) {

					return new OoaCheckObjectRefsConstant(aState);

				}});

			pipeLine.add(new CreateVisitor(){

				@Override

				public IAstVisitor create(ParserState aState) {

					return new OoaObjectInstantiationVisitor(aState, config.getLabelCompression());

				}});

			pipeLine.add(new CreateVisitor(){

				@Override

				public IAstVisitor create(ParserState aState) {

					return new OoaPrintActionSequencesVisitor(aState);

				}});

			pipeLine.add(new CreateVisitor(){

				@Override

				public IAstVisitor create(ParserState aState) {

					return new OoaPrintActionsVisitor(aState);

				}});

			pipeLine.add(new CreateVisitor(){

				@Override

				public IAstVisitor create(ParserState aState) {

					return new OoaPrologSymbolicVisitor(aState, config.getMaxSearchDepth(), config.getNameSpace());

				}});

			break;

		case CopyAST:

			pipeLine.add(new CreateVisitor(){

				@Override

				public IAstVisitor create(ParserState aState) {

					return new OoaObjectInstantiationVisitor(aState, config.getLabelCompression());

				}});

			pipeLine.add(new CreateVisitor(){

				@Override

				public IAstVisitor create(ParserState aState) {

					return new OoaPrintActionsVisitor(aState);

				}});

			pipeLine.add(new CreateVisitor(){

				@Override

				public IAstVisitor create(ParserState aState) {

					return new OoaAstEmitter<>(aState, config.getAstTarget());

				}});

			break;

		default:

			throw new OoasCompilerRuntimeException("Unknown backend.");

		}

	}

	public int compile(ILogCallBack logCallback) {

		return compile(new NullProgressCallBack(), logCallback);

	}

	/* fire up the parser */

	public int compile(IProgressCallBack callback, ILogCallBack logCallback)

	{

		if (config.isWriteable()) {

			config.setWriteOnly();

			fillPipeLine();

		}

		ParserState pState;

		try {

			callback.startingCompilePhase("OoaParser");

			pState = config.useStreams()

					?  new ParserState(config.getUnitName(), config.getInputStream(), config.getNamedTypePrefix())

					:  new ParserState(config.getFileToParse(), config.getNamedTypePrefix());

			final int result = ooaCustomParser.FirstPass(pState);

			if (result == 0) {

				callback.doneCompilePhase();

				if (pipeLine.size() > 0) {

					IAstVisitor visitor = null;

					for (final CreateVisitor item: pipeLine) {

						visitor = item.create(pState);

						callback.startingCompilePhase(visitor.returnVisitorName());

						pState.ooaSystem.Accept(visitor);

						visitor.done();

						if (pState.listOfParserErrors.size() > 0) {

							updateParserMsgs(pState);

							return pState.listOfParserErrors.size();

						} else

							callback.doneCompilePhase();

					}

					// after we've done all visitors, write the output file.

					if (!config.useStreams() && !config.getFileToOutput().equals(""))

					{

						final FileWriter fw = new FileWriter(config.getFileToOutput(), false);

						fw.write(visitor.toString()); // fixme: this should be ascii..

						fw.close();

					} else if (config.useStreams()) {

						final OutputStream out = config.getOutputStream();

						final BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(out));

						writer.write(visitor.toString());

						writer.close();

					}

				}

			}

			updateParserMsgs(pState);

			return result;

		} catch (final IOException e) {

			logCallback.logError(true, e.toString());

			return -1;

		}

	}

	public Compiler(CompilerConfiguration config) {

		this.config = config;

	}

	public Compiler(String unitName, String fileToParse, String fileToWrite, Backend be) {

		this(new CompilerConfiguration(unitName, fileToParse, fileToWrite, be));

	}

	public Compiler(String fileToParse, String fileToWrite, Backend be) {

		this(new File(fileToParse).getName(), fileToParse, fileToWrite, be);

	}

	public Compiler(String unitName, InputStream input, OutputStream output, Backend be) {

		this(new CompilerConfiguration(unitName, input, output, be));

	}

}