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.File;

import java.io.FileFilter;

import java.io.FileWriter;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

public final class CmdlineCompiler

{

	public interface CreateVisitor {

		public IAstVisitor cerate(ParserState aState);

	}

	public static class Options

	{

		public boolean quiet = false;

		public String fileToParse = "";

		public String outputToFile = "";

		public String namedTypePrefix = "";

		public String namespace = "";

		public ArrayList<CreateVisitor> pipeLine = new ArrayList<CreateVisitor>();

	}

	static void displayTitle()

	{

		System.out.println();

		System.out.println("          >> OO-Action System Parser <<");

		System.out.println();

		System.out.println();

	}

	/* fire up the parser */

	static int runAntlrParser(Options options)

	{

		ParserState pState;

		try {

			pState = new ParserState(options.fileToParse, options.namedTypePrefix);

			final int result = ooaCustomParser.FirstPass(pState);

			if (result > 0)

			{

				System.out.println(String.format("The parser returned %s errors:", result));

				for (final ParserError error: pState.listOfParserErrors)

					System.out.println(String.format("ERROR (%s): %s,%s; %s",

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

			}

			else

			{

				System.out.println("   Passed: OoaParser");

				if (options.pipeLine.size() > 0)

				{

					IAstVisitor visitor = null;

					for (final CreateVisitor item: options.pipeLine)

					{

						visitor = item.cerate(pState);

						pState.ooaSystem.Accept(visitor);

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

						{

							System.out.println(String.format("The parser (%s) returned %s errors:",

									visitor.returnVisitorName(), pState.listOfParserErrors.size()));

							for (final ParserError error: pState.listOfParserErrors)

								System.out.println(String.format("ERROR (%s): %s,%s; %s",

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

							return pState.listOfParserErrors.size();

						}

						else

						{

							System.out.print("   Passed: ");

							System.out.println(visitor.returnVisitorName());

						}

					}

					System.out.println();

					System.out.println(String.format("File %s successfully parsed.", pState.filename));

					System.out.println();

					if (pState.listOfParserMessages.size() > 0 && !(options.quiet))

					{

						System.out.println(String.format("Parser returned %s messages:", pState.listOfParserMessages.size()));

						for (final ParserMessage message: pState.listOfParserMessages)

							System.out.println(String.format("Message (%s): %s,%s; %s",

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

						System.out.println();

						System.out.println();

					}

					if (pState.listOfParserWarnings.size() > 0 && !(options.quiet))

					{

						System.out.println(String.format("Parser returned %s warnings:", pState.listOfParserWarnings.size()));

						for (final ParserWarning warning: pState.listOfParserWarnings)

							System.out.println(String.format("Warning (%s): %s,%s; %s",

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

						System.out.println("");

						System.out.println("");

					}

					if (!options.outputToFile.equals(""))

					{

						System.out.println(String.format("Writing output to %s.", options.outputToFile));

						final FileWriter fw = new FileWriter(options.outputToFile, false);

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

						fw.close();

					}

					else

						System.out.println(visitor.toString());

				}

				else

				{

					System.out.println();

					System.out.println(String.format("File %s successfully parsed.", pState.filename));

					System.out.println("");

				}

			}

			return result;

		} catch (final IOException e) {

			e.printStackTrace();

			return -1;

		}

	}

	private static void fillPipeLine(Options options) {

		int index = 0;

		options.pipeLine.add(index++, new CreateVisitor(){

			@Override

			public IAstVisitor cerate(ParserState aState) {

				return new OoaSymbolSortVisitor(aState);

			}});

		options.pipeLine.add(index++, new CreateVisitor(){

			@Override

			public IAstVisitor cerate(ParserState aState) {

				return new OoaReplaceOpaqueVisitor(aState);

			}});

		options.pipeLine.add(index++, new CreateVisitor(){

			@Override

			public IAstVisitor cerate(ParserState aState) {

				return new OoaTypesVisitor(aState);

			}});

		options.pipeLine.add(index++, new CreateVisitor(){

			@Override

			public IAstVisitor cerate(ParserState aState) {

				return new OoaResolveExpressionsVisitor(aState);

			}});

		options.pipeLine.add(index++, new CreateVisitor(){

			@Override

			public IAstVisitor cerate(ParserState aState) {

				return new OoaMethodPureClassifierVisitor(aState);

			}});

		options.pipeLine.add(index++, new CreateVisitor(){

			@Override

			public IAstVisitor cerate(ParserState aState) {

				return new OoaTypeCheckVisitor(aState);

			}});

		if (!options.namedTypePrefix.equals(""))

		{

			options.pipeLine.add(index++, new CreateVisitor(){

				@Override

				public IAstVisitor cerate(ParserState aState) {

					return new OoaTypeRenameVisitor(aState);

				}});

		}

		options.pipeLine.add(index++, new CreateVisitor(){

			@Override

			public IAstVisitor cerate(ParserState aState) {

				return new OoaRemoveTrivialPrioritizedCompositionVisitor(aState);

			}});

		options.pipeLine.add(index++, new CreateVisitor(){

			@Override

			public IAstVisitor cerate(ParserState aState) {

				return new OoaActionClassifierVisitor(aState);

			}});

		options.pipeLine.add(index++, new CreateVisitor(){

			@Override

			public IAstVisitor cerate(ParserState aState) {

				return new OoaObjectInstantiationVisitor(aState, LabelCompression.NoCompression);

			}});

	}

	/* entry point */

	public static void main(String[] args)

	{

		displayTitle();

		if (args.length != 4) {

			System.out.println("3 Arguments expected: backend orig/mut inputfile outputfile");

			System.out.println();

			System.out.println("   backend    ... 'psym' or 'p'");

			System.out.println("   orig/mut   ... 'orig' or 'mut'");

			System.out.println("   input  file or directory ... full path to input .ooas file or");

			System.out.println("                                directory containing .ooas files");

			System.out.println("   output file or directory ... full path to output file; will erase or");

			System.out.println("                                directory (only if also input is a directory)");

			System.out.println();

			System.exit(-1);

		}

		final Options options  = new Options();

		final boolean symbolic = args[0].toLowerCase().trim().equals("psym");

		final boolean mutant   = args[1].toLowerCase().trim().equals("mut");

		options.fileToParse    = args[2];

		options.outputToFile   = args[3];

		fillPipeLine(options); // add all basic operations

		final String namespace = mutant? "asm" : "as";

		options.namespace      = namespace;

		// add the prolog codegen target...

		if (symbolic) {

			options.pipeLine.add(new CreateVisitor(){

				@Override

				public IAstVisitor cerate(ParserState aState) {

					return new OoaPrologSymbolicVisitor(aState, 35, namespace);

				}});

		} else {

			options.pipeLine.add(new CreateVisitor(){

				@Override

				public IAstVisitor cerate(ParserState aState) {

					return new OoaPrologVisitor(aState, 35, namespace); // "as" ... original, "asm" ... mutant

				}});

		}

		System.out.println(String.format("Running OOAS Compiler... [backend=%s, namespace=%s]", symbolic?"psym":"p", namespace));

		if (new File(options.fileToParse).isDirectory()) {

			directoryMode(options);

		} else {

			fileMode(options);

		}

	}

	/**

	 * Iterates over all files in a directory if options.fileToParse is a directory

	 * and runs the antlr parser for each file. the output is stored in the same

	 * directory if the options.outputToFile is blank or not a directory.

	 * @param options

	 */

	public static void directoryMode(final Options options) {

		final File input  = new File(options.fileToParse);

		final File output = new File(options.outputToFile);

		final List<File> errors = new ArrayList<File>();

		File[] filesToParse = null;

		final FileFilter filter = new FileFilter() {

			@Override

			public final boolean accept(final File myFile) {

				return myFile.getName().endsWith(".ooas");

			}

		};

		System.out.println(String.format("Processing Directory [Input, Output]: %s, %s",

				input.getAbsolutePath(), output.getAbsoluteFile()));

		filesToParse = input.listFiles(filter);

		int result              = 0;

		File fileToParse        = null;

		String inputFileName    = "";

		String outputFileName   = "";

		final String outputFileSuffix = "." + options.namespace + ".pl";

		if (filesToParse != null) {

			for (int i = 0; i < filesToParse.length; ++i) {

				fileToParse    = filesToParse[i];

				inputFileName  = fileToParse.getAbsolutePath();

				outputFileName = fileToParse.getName().substring(0, fileToParse.getName().indexOf(".ooas")).concat(outputFileSuffix);

				if (output != null) {

					if (!output.isDirectory())

						output.mkdir();

					outputFileName = output.getAbsolutePath() + File.separatorChar + outputFileName;

				}

				else {

					// use same directory as input file for output

					outputFileName = fileToParse.getParent() + File.separatorChar + outputFileName;

				}

				options.fileToParse  = inputFileName;

				options.outputToFile = outputFileName;

				System.out.println(String.format("Parsing %s", options.fileToParse));

				result = runAntlrParser(options);

				if (result != 0)

					errors.add(fileToParse);

			}

		}

		if (errors.size() > 0) {

			System.out.println("Following files were not processed correctly:");

			final Iterator<File> i = errors.iterator();

			File file = null;

			while (i.hasNext()) {

				file = i.next();

				System.out.println(file.getName());

			}

			System.exit(-1);

		}

		System.exit(0);

	}

	/**

	 * Runs the antlr parser with the given options

	 * @param options

	 */

	public static void fileMode(final Options options) {

		System.out.println(String.format("Parsing %s.", options.fileToParse));

		final int result = runAntlrParser(options);

		System.exit(result);

	}

}