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

public abstract class OoaCompleteAstTraversalVisitor implements IAstVisitor

{

	protected HashSet<Object> m_visited = new HashSet<Object>();

	protected ParserState m_ParserState;

	protected boolean m_DuplicateVisit;

	protected void VisitSub(IAst subElement, IAst parent)

	{

		if (subElement == null)

			return;

		if (m_visited.contains(subElement))

			return;

		if (!(subElement instanceof OpaqueType) && !m_DuplicateVisit)

			m_visited.add(subElement);

		VisitAstElement(subElement, parent);

	}

	/// <summary>

	///  Is called once per Ast element. Makes sense to override it in a

	///  subclass..

	/// </summary>

	/// <param name="element">to be visited</param>

	/// <param name="parent">parent of the element in the ast</param>

	protected /*virtual*/ void VisitAstElement(IAst element, IAst parent)

	{

		element.Accept(this);

	}

	public OoaCompleteAstTraversalVisitor(ParserState aState)

	{

		m_ParserState = aState;

	}

	public OoaCompleteAstTraversalVisitor(ParserState aState, boolean completeTraversal)

	{

		this(aState);

		m_DuplicateVisit = completeTraversal;

	}

	@Override

	public String returnVisitorName()

	{

		return this.getClass().getSimpleName();

	}

	@Override

	public void done() {

	}

	@Override

	public /*override*/ String toString()

	{

		return returnVisitorName();

	}

	@Override

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

	{

		VisitSub(enumIdentifier.type(), enumIdentifier);

	}

	@Override

	public /*virtual*/ void visit(ConstantIdentifier constantIdentifier)

	{

		if (constantIdentifier.type() != null)

			VisitSub(constantIdentifier.type(), constantIdentifier);

		VisitSub(constantIdentifier.Value(), constantIdentifier);

	}

	@Override

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

	{

		VisitSub(landmarkIdentifier.type(), landmarkIdentifier);

	}

	@Override

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

	{

		VisitSub(attributeIdentifier.type(), attributeIdentifier);

		VisitSub(attributeIdentifier.initializer(), attributeIdentifier);

	}

	@Override

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

	{

		VisitSub(expressionVariableIdentifier.type(), expressionVariableIdentifier);

	}

	@Override

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

	{

		VisitSub(parameterIdentifier.type(), parameterIdentifier);

	}

	@Override

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

	{

		VisitSub(localVariableIdentifier.type(), localVariableIdentifier);

	}

	@Override

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

	{

		VisitSub(typeIdentifier.type(), typeIdentifier);

	}

	@Override

	public /*virtual*/ void visit(SelfTypeIdentifier aself)

	{

		visit((TypeIdentifier)aself);

	}

	@Override

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

	{

		VisitSub(methodIdentifier.type(), methodIdentifier);

		for (final Identifier sym: methodIdentifier.symbolTable().symbolList())

			VisitSub(sym, methodIdentifier);

		for (final ParameterIdentifier par: methodIdentifier.parameter())

			VisitSub(par, methodIdentifier);

		VisitSub(methodIdentifier.body(), methodIdentifier);

	}

	@Override

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

	{

		VisitSub(namedActionIdentifier.type(), namedActionIdentifier);

		for (final Identifier sym : namedActionIdentifier.symbolTable().symbolList())

			VisitSub(sym, namedActionIdentifier);

		for (final ParameterIdentifier par: namedActionIdentifier.parameter())

			VisitSub(par, namedActionIdentifier);

		VisitSub(namedActionIdentifier.body(), namedActionIdentifier);

	}

	@Override

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

	{

		for (final Identifier sym: mainModule.symbolTable().symbolList())

			VisitSub(sym, mainModule);

		final boolean haveInstance = mainModule.instance() != null;

		if (haveInstance)

			VisitSub(mainModule.instance(), mainModule);

		else

			VisitSub(mainModule.systemDescription(), mainModule);

	}

	@Override

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

	{

		for (final Identifier sym: module.symbolTable().symbolList())

			VisitSub(sym, module);

	}

	@Override

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

	{

		for (final Identifier id: nondetIdentifierList.identifiers())

			VisitSub(id, nondetIdentifierList);

	}

	@Override

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

	{

		for (final Identifier id: seqIdentifierList.identifiers())

			VisitSub(id, seqIdentifierList);

	}

	@Override

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

	{

		for (final Identifier id: prioIdentifierList.identifiers())

			VisitSub(id, prioIdentifierList);

	}

	@Override

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

	{

		for (final Identifier id: unspecIdentifierList.identifiers())

			VisitSub(id, unspecIdentifierList);

	}

	@Override

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

	{

		for (final Identifier id: nondetBlock.symbols().symbolList())

			VisitSub(id, nondetBlock);

		for (final Statement stmnt: nondetBlock.statements())

			VisitSub(stmnt, nondetBlock);

	}

	@Override

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

	{

		for (final Identifier id: seqBlock.symbols().symbolList())

			VisitSub(id, seqBlock);

		if (seqBlock.filter() != null)

			VisitSub(seqBlock.filter(), seqBlock);

		for (final Statement stmnt: seqBlock.statements())

			VisitSub(stmnt, seqBlock);

	}

	@Override

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

	{

		for (final Identifier id: prioBlock.symbols().symbolList())

			VisitSub(id, prioBlock);

		for (final Statement stmnt: prioBlock.statements())

			VisitSub(stmnt, prioBlock);

	}

	@Override

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

	{

		VisitSub(guardedCommand.guard(), guardedCommand);

		VisitSub(guardedCommand.body(), guardedCommand);

	}

	@Override

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

	{

		for (final Expression vexp: assignment.places())

			VisitSub(vexp, assignment);

		for (final Expression expr: assignment.values())

			VisitSub(expr, assignment);

		VisitSub(assignment.nondetExpression(), assignment);

	}

	@Override

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

	{

		VisitSub(call.callExpression(), call);

	}

	@Override

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

	{ }

	@Override

	public void visit(BreakStatement breakStatement)

	{ }

	@Override

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

	{ }

	@Override

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

	{

		VisitSub(killStatement.someOne, killStatement);

	}

	@Override

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

	{ }

	@Override

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

	{

		VisitSub(unresolvedIdentifierExpression.type(), unresolvedIdentifierExpression);

	}

	@Override

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

	{

		VisitSub(identifierExpression.type(), identifierExpression);

		VisitSub(identifierExpression.identifier(), identifierExpression);

	}

	@Override

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

	{

		VisitSub(typeExpression.type(), typeExpression);

	}

	@Override

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

	{

		for (final Identifier lvar: listConstructor.comprehensionVariables().symbolList())

			VisitSub(lvar, listConstructor);

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

			VisitSub(elems, listConstructor);

		if (listConstructor.comprehension() != null)

			VisitSub(listConstructor.comprehension(), listConstructor);

	}

	@Override

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

	{

		for (final Identifier svar: setConstructor.comprehensionVariables().symbolList())

			VisitSub(svar, setConstructor);

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

			VisitSub(elems, setConstructor);

		VisitSub(setConstructor.comprehension(), setConstructor);

	}

	@Override

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

	{

		/*foreach (var lvar in mapConstructor.localVariables.symbolList)

			VisitSub(lvar, mapConstructor);*/

		for (final MapItem elem: mapConstructor.items())

		{

			VisitSub(elem.key, mapConstructor);

			VisitSub(elem.value, mapConstructor);

		}

	}

	@Override

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

	{

		/*foreach (var lvar in tupleConstructor.localVariables.symbolList)

			VisitSub(lvar, tupleConstructor);*/

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

			VisitSub(elem, tupleConstructor);

	}

	@Override

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

	{

		VisitSub(accessExpression.left(), accessExpression);

		VisitSub(accessExpression.right(), accessExpression);

	}

	@Override

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

	{

		VisitSub(binaryOperator.left(), binaryOperator);

		VisitSub(binaryOperator.right(), binaryOperator);

	}

	@Override

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

	{

		VisitSub(ternaryOperator.left(), ternaryOperator);

		VisitSub(ternaryOperator.mid(), ternaryOperator);

		VisitSub(ternaryOperator.right(), ternaryOperator);

	}

	@Override

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

	{

		VisitSub(tupleMapAccessExpression.argument(), tupleMapAccessExpression);

		VisitSub(tupleMapAccessExpression.child(), tupleMapAccessExpression);

	}

	@Override

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

	{

		if (callExpression.arguments() != null)

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

				VisitSub(arg, callExpression);

		VisitSub(callExpression.child(), callExpression);

	}

	@Override

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

	{

		for (final Identifier lvar: quantifier.symbols().symbolList())

			VisitSub(lvar, quantifier);

		VisitSub(quantifier.child(), quantifier);

	}

	@Override

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

	{

		for (final Identifier lvar: quantifier.symbols().symbolList())

			VisitSub(lvar, quantifier);

		VisitSub(quantifier.child(), quantifier);

	}

	@Override

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

	{

		VisitSub(unaryOperator.child(), unaryOperator);

		if (unaryOperator.kind() == ExpressionKind.Cast)

			VisitSub(unaryOperator.type(), unaryOperator);

	}

	@Override

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

	{

	}

	@Override

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

	{

	}

	@Override

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

	{

	}

	@Override

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

	{

	}

	@Override

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

	{

		for (final Identifier sym: enumType.listOfEnumSymbols())

			VisitSub(sym, enumType);

	}

	@Override

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

	{

		VisitSub(listType.innerType(), listType);

	}

	@Override

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

	{

		VisitSub(mapType.fromType(), mapType);

		VisitSub(mapType.toType(), mapType);

	}

	@Override

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

	{

		for (final Identifier m: qrType.landmarks())

			VisitSub(m, qrType);

	}

	@Override

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

	{

		for (final UlyssesType t: tupleType.innerTypes())

			VisitSub(t, tupleType);

	}

	@Override

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

	{

		for (final UlyssesType a: functionType.parameter())

			VisitSub(a, functionType);

		VisitSub(functionType.returnType(), functionType);

	}

	@Override

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

	{

		for (final Identifier s: ooActionSystemType.symbols().symbolList())

			VisitSub(s, ooActionSystemType);

		VisitSub(ooActionSystemType.doOdBlock(), ooActionSystemType);

	}

	public /*virtual*/ @Override

	void visit(OpaqueType opaqueType)

	{

		VisitSub(opaqueType.resolvedType(), opaqueType);

	}

	@Override

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

	{ }

	@Override

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

	{ }

	@Override

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

	{

		VisitSub(objectConstructor.type(), objectConstructor);

	}

	@Override

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

	{

	}

	@Override

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

	{

		VisitSub(qalitativeConstraintStatement.variable0(), qalitativeConstraintStatement);

		VisitSub(qalitativeConstraintStatement.variable1(), qalitativeConstraintStatement);

		if (qalitativeConstraintStatement.variable2() != null)

			VisitSub(qalitativeConstraintStatement.variable2(), qalitativeConstraintStatement);

	}

}