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

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.List;

import java.util.ListIterator;

import org.momut.ooas.utils.exceptions.InternalCompilerException;

public final class OoaDeepCloneVisitor extends OoaCompleteAstTraversalVisitor

{

	OoasCompilerHashMap<Object, Object> mapping;

	Identifier selfreplacement;

	public boolean quantifierState = false;

	/* we do not clone types */

	@Override

	public /*override*/ void visit(AnyType anyType)

	{ throw new NotImplementedException(); }

	@Override

	public /*override*/ void visit(BoolType boolType)

	{ throw new NotImplementedException(); }

	@Override

	public /*override*/ void visit(CharType charType)

	{ throw new NotImplementedException(); }

	@Override

	public /*override*/ void visit(EnumType enumType)

	{ throw new NotImplementedException(); }

	@Override

	public /*override*/ void visit(FloatType floatType)

	{ throw new NotImplementedException(); }

	@Override

	public /*override*/ void visit(FunctionType functionType)

	{ throw new NotImplementedException(); }

	@Override

	public /*override*/ void visit(IntType intType)

	{ throw new NotImplementedException(); }

	@Override

	public /*override*/ void visit(ListType listType)

	{ throw new NotImplementedException(); }

	@Override

	public /*override*/ void visit(MapType mapType)

	{ throw new NotImplementedException(); }

	@Override

	public /*override*/ void visit(NullType nullType)

	{ throw new NotImplementedException(); }

	@Override

	public /*override*/ void visit(OoActionSystemType ooActionSystemType)

	{ throw new NotImplementedException(); }

	@Override

	public /*override*/ void visit(TupleType tupleType)

	{ throw new NotImplementedException(); }

	@Override

	public /*override*/ void visit(EnumIdentifier enumIdentifier)

	{ throw new NotImplementedException(); }

	@Override

	public /*override*/ void visit(LandmarkIdentifier landmarkIdentifier)

	{ throw new NotImplementedException(); }

	@Override

	public /*override*/ void visit(ExpressionVariableIdentifier expressionVariableIdentifier)

	{ throw new NotImplementedException(); }

	@Override

	public /*override*/ void visit(LocalVariableIdentifier localVariableIdentifier)

	{

		throw new NotImplementedException();

	}

	@Override

	public /*override*/ void visit(MainModule mainModule)

	{

		throw new NotImplementedException();

	}

	@Override

	public /*override*/ void visit(MapConstructor mapConstructor)

	{

		throw new NotImplementedException();

	}

	@Override

	public /*override*/ void visit(MethodIdentifier methodIdentifier)

	{

		throw new NotImplementedException();

	}

	@Override

	public /*override*/ void visit(NamedActionIdentifier namedActionIdentifier)

	{

		final Statement newBlock = SClone(namedActionIdentifier.body());

		namedActionIdentifier.SetBody(newBlock);

		// we do not clone the parameters..

	}

	@Override

	public /*override*/ void visit(Module module)

	{

		throw new NotImplementedException();

	}

	@Override

	public /*override*/ void visit(NondetIdentifierList nondetIdentifierList)

	{

		throw new NotImplementedException();

	}

	@Override

	public /*override*/ void visit(OpaqueType opaqueType)

	{

		throw new NotImplementedException(); // must not happen

	}

	@Override

	public /*override*/ void visit(ParameterIdentifier parameterIdentifier)

	{

		throw new NotImplementedException();

	}

	@Override

	public /*override*/ void visit(PrioIdentifierList prioIdentifierList)

	{

		throw new NotImplementedException();

	}

	@Override

	public /*override*/ void visit(QrType qrType)

	{

		throw new NotImplementedException();

	}

	@Override

	public /*override*/ void visit(ObjectConstructor objectConstructor)

	{

		//base.visit(objectConstructor);

	}

	private void UpdateScope(IScope aScope)

	{

		if (aScope.GetParentScope() != null && !mapping.containsKey(aScope.GetParentScope()))

			throw new ArgumentException();

		else if (aScope.GetParentScope() != null)

		{

			aScope.SetParentScope((IScope)mapping.get(aScope.GetParentScope()));

		}

	}

	private void CheckScope(IScope aScope) {

		if (aScope.GetParentScope() == null)

			return;

		if (mapping.containsKey(aScope.GetParentScope()))

			throw new InternalCompilerException("Internal Error. Scope check failed.");

	}

	private Expression EClone(Expression anExpr)

	{

		Expression result = null;

		if (anExpr != null)

		{

			result = anExpr.Clone();

			if (anExpr instanceof IScope)

			{

				mapping.putSafe(anExpr, result);

				UpdateScope((IScope)result);

			}

			result.Accept(this);

		}

		return result;

	}

	private Statement SClone(Statement aStatement)

	{

		Statement result = null;

		if (aStatement != null)

		{

			result = aStatement.Clone();

			if (aStatement instanceof IScope)

			{

				mapping.putSafe(aStatement, result);

				UpdateScope((IScope)result);

			}

			result.Accept(this);

		}

		return result;

	}

	// clones symbols found in symbol table

	private void SymTabClone(SymbolTable aTable)

	{

		if (aTable != null && aTable.symbolList().size() > 0)

		{

			final List<Identifier> newList = new ArrayList<Identifier>();

			for (final Identifier x: aTable.symbolList())

			{

				if (!mapping.containsKey(x))

				{

					final Identifier newid = x.Clone();

					newList.add(newid);

					mapping.putSafe(x, newid);

				}

				else

					newList.add((Identifier)mapping.get(x));

			}

			aTable.SetSymbolList(newList);

		}

	}

	private void cloneExpressionList(ListIterator<Expression> anElem)

	{

		while (anElem.hasNext())

		{

			final Expression clone = EClone(anElem.next());

			anElem.remove();

			anElem.add(clone);

		}

	}

	/*no need to clone leafs (they are already cloned and a shallow copy is sufficient*/

	@Override

	public /*override*/ void visit(AbortStatement abortStatement)

	{ }

	@Override

	public /*override*/ <T> void visit(ValueExpression<T> valueExpression)

	{ }

	/*clone a block*/

	public void cloneBlock(Block aBlock)

	{

		SymTabClone(aBlock.symbols());

		final ListIterator<Statement> stmnt = aBlock.statements().listIterator();

		while (stmnt.hasNext())

		{

			final Statement clone = SClone(stmnt.next());

			stmnt.remove();

			stmnt.add(clone);

		}

	}

	@Override

	public /*override*/ void visit(NondetBlock nondetBlock)

	{

		cloneBlock(nondetBlock);

	}

	@Override

	public /*override*/ void visit(SeqBlock seqBlock)

	{

		seqBlock.SetFilter(EClone(seqBlock.filter()));

		cloneBlock(seqBlock);

	}

	@Override

	public /*override*/ void visit(PrioBlock prioBlock)

	{

		cloneBlock(prioBlock);

	}

	@Override

	public /*override*/ void visit(AccessExpression accessExpression)

	{

		visit((BinaryOperator)accessExpression);

	}

	@Override

	public /*override*/ void visit(BinaryOperator binaryOperator)

	{

		final Expression left = EClone(binaryOperator.left());

		final Expression right = EClone(binaryOperator.right());

		binaryOperator.SetLeftChild(left);

		binaryOperator.SetRightChild(right);

	}

	@Override

	public /*override*/ void visit(Assignment assignment)

	{

		SymTabClone(assignment.symbols());

		cloneExpressionList(assignment.places().listIterator());

		cloneExpressionList(assignment.values().listIterator());

		assignment.SetNondetExpression(EClone(assignment.nondetExpression()));

		CheckScope(assignment);

	}

	@Override

	public /*override*/ void visit(AttributeIdentifier attributeIdentifier)

	{

		final Expression initializer = EClone(attributeIdentifier.initializer());

		attributeIdentifier.SetInitializer(initializer);

	}

	@Override

	public /*override*/ void visit(Call call)

	{

		final Expression cExpr = EClone(call.callExpression());

		call.SetCallExpression(cExpr);

	}

	@Override

	public /*override*/ void visit(CallExpression callExpression)

	{

		final ArrayList<Expression> newargs = new ArrayList<Expression>();

		for (final Expression x: callExpression.arguments())

		{

			newargs.add(EClone(x));

		}

		callExpression.SetArguments(newargs);

		visit((UnaryOperator)callExpression);

	}

	public void CloneQuantifier(Quantifier qf)

	{

		SymTabClone(qf.symbols());

		final boolean oldQunatifierState = quantifierState;

		quantifierState = true;

		visit(qf);

		quantifierState = oldQunatifierState;

	}

	@Override

	public /*override*/ void visit(ExistsQuantifier quantifier)

	{

		CloneQuantifier(quantifier);

	}

	@Override

	public /*override*/ void visit(ForallQuantifier quantifier)

	{

		CloneQuantifier(quantifier);

	}

	@Override

	public /*override*/ void visit(GuardedCommand guardedCommand)

	{

		final Statement newblock = SClone(guardedCommand.body());

		final Expression newguard = EClone(guardedCommand.guard());

		guardedCommand.SetBody(newblock);

		guardedCommand.SetGuard(newguard);

	}

	@Override

	public /*override*/ void visit(IdentifierExpression identifierExpression)

	{

		if (identifierExpression.isSelf())

		{

			/*if (quantifierState) //FIXXME

            {

                if (!selfreplacement.tokenText.StartsWith("attr"))

                {

                    String oldTokenText = selfreplacement.tokenText;

                    selfreplacement.SetTokenText("attr____model_root_" + selfreplacement.tokenText);

                    identifierExpression.SetIdentifier(selfreplacement);

                    selfreplacement.SetTokenText(oldTokenText);

                }

            }

            else

			 */

			identifierExpression.SetIdentifier(selfreplacement);

		}

		else if (mapping.containsKey(identifierExpression.identifier())

				&& identifierExpression.identifier().kind() != IdentifierKind.MethodIdentifier)

			/* we do NOT replace method calls here, since they are prefixed by self if it's a

			 * method in the current object or by some field/method access if it's another

			 * object.

			 */

			identifierExpression.SetIdentifier((Identifier)mapping.get(identifierExpression.identifier()));

	}

	@Override

	public /*override*/ void visit(KillStatement killStatement)

	{

		if (mapping.containsKey(killStatement.someOne))

			killStatement.SetIdentifier((Identifier)mapping.get(killStatement.someOne));

	}

	@Override

	public /*override*/ void visit(ListConstructor listConstructor)

	{

		SymTabClone(listConstructor.comprehensionVariables());

		final ArrayList<Expression> newelems = new ArrayList<Expression>();

		for (final Expression x: listConstructor.elements())

			newelems.add(EClone(x));

		listConstructor.SetElements(newelems);

		listConstructor.SetComprehension(EClone(listConstructor.comprehension()));

	}

	@Override

	public /*override*/ void visit(QualitativeConstraintStatement qalitativeConstraintStatement)

	{

		if (qalitativeConstraintStatement.variable0() != null && mapping.containsKey(qalitativeConstraintStatement.variable0()))

			qalitativeConstraintStatement.SetVariable0((Identifier)mapping.get(qalitativeConstraintStatement.variable0()));

		if (qalitativeConstraintStatement.variable1() != null && mapping.containsKey(qalitativeConstraintStatement.variable1()))

			qalitativeConstraintStatement.SetVariable1((Identifier)mapping.get(qalitativeConstraintStatement.variable1()));

		if (qalitativeConstraintStatement.variable2() != null && mapping.containsKey(qalitativeConstraintStatement.variable2()))

			qalitativeConstraintStatement.SetVariable2((Identifier)mapping.get(qalitativeConstraintStatement.variable2()));

	}

	@Override

	public /*override*/ void visit(QValConstructor qValConstructor)

	{

		final List<Expression> values = Arrays.asList(qValConstructor.value());

		for (int i = 0; i < values.size(); i++)

			qValConstructor.value()[i] = EClone(values.get(i));

	}

	@Override

	public /*override*/ void visit(SeqIdentifierList seqIdentifierList)

	{

		throw new NotImplementedException();

	}

	@Override

	public /*override*/ void visit(SetConstructor setConstructor)

	{

		SymTabClone(setConstructor.comprehensionVariables());

		final ArrayList<Expression> newelems = new ArrayList<Expression>();

		for (final Expression x: setConstructor.items())

			newelems.add(EClone(x));

		setConstructor.SetItems(newelems);

		setConstructor.SetComprehension(EClone(setConstructor.comprehension()));

	}

	@Override

	public /*override*/ void visit(SkipStatement skipStatement)

	{ }

	@Override

	public /*override*/ void visit(TernaryOperator ternaryOperator)

	{

		ternaryOperator.SetLeftChild(EClone(ternaryOperator.left()));

		ternaryOperator.SetMidChild(EClone(ternaryOperator.mid()));

		ternaryOperator.SetRightChild(EClone(ternaryOperator.right()));

	}

	@Override

	public /*override*/ void visit(TupleConstructor tupleConstructor)

	{

		final ArrayList<Expression> values = new ArrayList<Expression>();

		for (final Expression x: tupleConstructor.values())

			values.add(EClone(x));

		tupleConstructor.SetTupleValues(values);

	}

	@Override

	public /*override*/ void visit(TupleMapAccessExpression tupleMapAccessExpression)

	{

		tupleMapAccessExpression.SetArgument(EClone(tupleMapAccessExpression.argument()));

		visit((UnaryOperator)tupleMapAccessExpression);

	}

	@Override

	public /*override*/ void visit(TypeExpression typeExpression)

	{ /*we do not clone types*/ }

	@Override

	public /*override*/ void visit(TypeIdentifier typeIdentifier)

	{

		throw new NotImplementedException();

	}

	@Override

	public /*override*/ void visit(UnaryOperator unaryOperator)

	{

		final Expression child = EClone(unaryOperator.child());

		unaryOperator.SetChild(child);

	}

	@Override

	public /*override*/ void visit(UnresolvedIdentifierExpression unresolvedIdentifierExpression)

	{

		throw new NotImplementedException(); // must not occur

	}

	@Override

	public /*override*/ void visit(UnspecIdentifierList unspecIdentifierList)

	{

		throw new NotImplementedException();

	}

	public OoaDeepCloneVisitor(HashMap<Object, Object> initMapping, Identifier selfreplace)

	{

		super (null);

		mapping = new OoasCompilerHashMap<Object, Object>(initMapping);

		selfreplacement = selfreplace;

	}

}