OoasTools

/**

  *

  *                      OOAS Compiler (Deprecated)

  *

  * Copyright 2015, Institute for Software Technology, Graz University of

  * Technology. Portions are copyright 2015 by the AIT Austrian Institute

  * of Technology. All rights reserved.

  *

  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.

  *

  * Please notice that this version of the OOAS compiler is considered de-

  * precated. Only the Java version is maintained.

  *

  * Contributors:

  *               Willibald Krenn (TU Graz/AIT)

  *               Stefan Tiran (TU Graz/AIT)

  */

using System;

using System.Collections.Generic;

using System.Text;

namespace TUG.Mogentes

{

    /*Notice: The visitor must implement the traversal!*/

    public interface IAstVisitor

    {

        string returnVisitorName();

        /*Identifiers*/

        void visit(EnumIdentifier enumIdentifier);

        void visit(LandmarkIdentifier landmarkIdentifier);

        void visit(AttributeIdentifier attributeIdentifier);

        void visit(ExpressionVariableIdentifier expressionVariableIdentifier);

        void visit(ParameterIdentifier parameterIdentifier);

        void visit(LocalVariableIdentifier localVariableIdentifier);

        void visit(TypeIdentifier typeIdentifier);

        void visit(SelfTypeIdentifier typeIdentifier);

        void visit(MethodIdentifier methodIdentifier);

        void visit(NamedActionIdentifier namedActionIdentifier);

        void visit(MainModule mainModule);

        void visit(Module module);

        void visit(NondetIdentifierList nondetIdentifierList);

        void visit(SeqIdentifierList seqIdentifierList);

        void visit(PrioIdentifierList prioIdentifierList);

        void visit(UnspecIdentifierList unspecIdentifierList);

        /*Statements*/

        void visit(NondetBlock nondetBlock);

        void visit(SeqBlock seqBlock);

        void visit(PrioBlock prioBlock);

        void visit(GuardedCommand guardedCommand);

        void visit(Assignment assignment);

        void visit(Call call);

        void visit(SkipStatement skipStatement);

        void visit(AbortStatement abortStatement);

        void visit(KillStatement killStatement);

        /*Expressions*/

        void visit<T>(ValueExpression<T> valueExpression);

        void visit(UnresolvedIdentifierExpression unresolvedIdentifierExpression);

        void visit(IdentifierExpression identifierExpression);

        void visit(ListConstructor listConstructor);

        void visit(SetConstructor setConstructor);

        void visit(MapConstructor mapConstructor);

        void visit(TupleConstructor tupleConstructor);

        void visit(AccessExpression accessExpression);

        void visit(BinaryOperator binaryOperator);

        void visit(TernaryOperator ternaryOperator);

        void visit(TupleMapAccessExpression tupleMapAccessExpression);

        void visit(CallExpression callExpression);

        void visit(ForallQuantifier quantifier);

        void visit(ExistsQuantifier quantifier);

        void visit(UnaryOperator unaryOperator);

        void visit(TypeExpression typeExpression);

        void visit(NullType nullType);

        /*Types*/

        void visit(CharType charType);

        void visit(IntType intType);

        void visit(BoolType boolType);

        void visit(FloatType floatType);

        void visit(EnumType enumType);

        void visit(ListType listType);

        void visit(MapType mapType);

        void visit(QrType qrType);

        void visit(TupleType tupleType);

        void visit(FunctionType functionType);

        void visit(OoActionSystemType ooActionSystemType);

        void visit(OpaqueType opaqueType);

        void visit(AnyType anyType);

        void visit(ObjectConstructor objectConstructor);

        void visit(QValConstructor qValConstructor);

        void visit(QualitativeConstraintStatement qalitativeConstraintStatement);

        void visit(ConstantIdentifier constantIdentifier);

    }

    public delegate IAstVisitor CreateVisitor(ParserState aState);

    public abstract class OoaCompleteAstTraversalVisitor : IAstVisitor

    {

        protected C5.HashSet<object> m_visited = new C5.HashSet<object>();

        protected ParserState m_ParserState;

        protected bool m_DuplicateVisit;

        protected void VisitSub(IAst subElement, IAst parent)

        {

            if (subElement == null)

                return;

            if (m_visited.Contains(subElement))

                return;

            if (!(subElement is 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, bool completeTraversal)

            : this(aState)

        {

            m_DuplicateVisit = completeTraversal;

        }

        public string returnVisitorName()

        {

            return this.GetType().ToString();

        }

        public override string ToString()

        {

            return returnVisitorName();

        }

        public virtual void visit(EnumIdentifier enumIdentifier)

        {

            VisitSub(enumIdentifier.type, enumIdentifier);

        }

        public virtual void visit(ConstantIdentifier constantIdentifier)

        {

            if (constantIdentifier.type != null)

                VisitSub(constantIdentifier.type, constantIdentifier);

            VisitSub(constantIdentifier.Value, constantIdentifier);

        }

        public virtual void visit(LandmarkIdentifier landmarkIdentifier)

        {

            VisitSub(landmarkIdentifier.type, landmarkIdentifier);

        }

        public virtual void visit(AttributeIdentifier attributeIdentifier)

        {

            VisitSub(attributeIdentifier.type, attributeIdentifier);

            VisitSub(attributeIdentifier.initializer, attributeIdentifier);

        }

        public virtual void visit(ExpressionVariableIdentifier expressionVariableIdentifier)

        {

            VisitSub(expressionVariableIdentifier.type, expressionVariableIdentifier);

        }

        public virtual void visit(ParameterIdentifier parameterIdentifier)

        {

            VisitSub(parameterIdentifier.type, parameterIdentifier);

        }

        public virtual void visit(LocalVariableIdentifier localVariableIdentifier)

        {

            VisitSub(localVariableIdentifier.type, localVariableIdentifier);

        }

        public virtual void visit(TypeIdentifier typeIdentifier)

        {

            VisitSub(typeIdentifier.type, typeIdentifier);

        }

        public virtual void visit(SelfTypeIdentifier aself)

        {

            visit((TypeIdentifier)aself);

        }

        public virtual void visit(MethodIdentifier methodIdentifier)

        {

            VisitSub(methodIdentifier.type, methodIdentifier);

            foreach (var sym in methodIdentifier.symbolTable.symbolList)

                VisitSub(sym, methodIdentifier);

            foreach (var par in methodIdentifier.parameter)

                VisitSub(par, methodIdentifier);

            VisitSub(methodIdentifier.body, methodIdentifier);

        }

        public virtual void visit(NamedActionIdentifier namedActionIdentifier)

        {

            VisitSub(namedActionIdentifier.type, namedActionIdentifier);

            foreach (var sym in namedActionIdentifier.symbolTable.symbolList)

                VisitSub(sym, namedActionIdentifier);

            foreach (var par in namedActionIdentifier.parameter)

                VisitSub(par, namedActionIdentifier);

            VisitSub(namedActionIdentifier.body, namedActionIdentifier);

        }

        public virtual void visit(MainModule mainModule)

        {

            foreach (var sym in mainModule.symbolTable.symbolList)

                VisitSub(sym, mainModule);

            bool haveInstance = mainModule.instance != null;

            if (haveInstance)

                VisitSub(mainModule.instance, mainModule);

            else

                VisitSub(mainModule.systemDescription, mainModule);

        }

        public virtual void visit(Module module)

        {

            foreach (var sym in module.symbolTable.symbolList)

                VisitSub(sym, module);

        }

        public virtual void visit(NondetIdentifierList nondetIdentifierList)

        {

            foreach (var id in nondetIdentifierList.identifiers)

                VisitSub(id, nondetIdentifierList);

        }

        public virtual void visit(SeqIdentifierList seqIdentifierList)

        {

            foreach (var id in seqIdentifierList.identifiers)

                VisitSub(id, seqIdentifierList);

        }

        public virtual void visit(PrioIdentifierList prioIdentifierList)

        {

            foreach (var id in prioIdentifierList.identifiers)

                VisitSub(id, prioIdentifierList);

        }

        public virtual void visit(UnspecIdentifierList unspecIdentifierList)

        {

            foreach (var id in unspecIdentifierList.identifiers)

                VisitSub(id, unspecIdentifierList);

        }

        public virtual void visit(NondetBlock nondetBlock)

        {

            foreach (var id in nondetBlock.symbols.symbolList)

                VisitSub(id, nondetBlock);

            foreach (var stmnt in nondetBlock.statements)

                VisitSub(stmnt, nondetBlock);

        }

        public virtual void visit(SeqBlock seqBlock)

        {

            foreach (var id in seqBlock.symbols.symbolList)

                VisitSub(id, seqBlock);

            if (seqBlock.filter != null)

                VisitSub(seqBlock.filter, seqBlock);

            foreach (var stmnt in seqBlock.statements)

                VisitSub(stmnt, seqBlock);

        }

        public virtual void visit(PrioBlock prioBlock)

        {

            foreach (var id in prioBlock.symbols.symbolList)

                VisitSub(id, prioBlock);

            foreach (var stmnt in prioBlock.statements)

                VisitSub(stmnt, prioBlock);

        }

        public virtual void visit(GuardedCommand guardedCommand)

        {

            VisitSub(guardedCommand.guard, guardedCommand);

            VisitSub(guardedCommand.body, guardedCommand);

        }

        public virtual void visit(Assignment assignment)

        {

            foreach (var vexp in assignment.places)

                VisitSub(vexp, assignment);

            foreach (var expr in assignment.values)

                VisitSub(expr, assignment);

            VisitSub(assignment.nondetExpression, assignment);

        }

        public virtual void visit(Call call)

        {

            VisitSub(call.callExpression, call);

        }

        public virtual void visit(SkipStatement skipStatement)

        { }

        public virtual void visit(AbortStatement abortStatement)

        { }

        public virtual void visit(KillStatement killStatement)

        {

            VisitSub(killStatement.someOne, killStatement);

        }

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

        { }

        public virtual void visit(UnresolvedIdentifierExpression unresolvedIdentifierExpression)

        {

            VisitSub(unresolvedIdentifierExpression.type, unresolvedIdentifierExpression);

        }

        public virtual void visit(IdentifierExpression identifierExpression)

        {

            VisitSub(identifierExpression.type, identifierExpression);

            VisitSub(identifierExpression.identifier, identifierExpression);

        }

        public virtual void visit(TypeExpression typeExpression)

        {

            VisitSub(typeExpression.type, typeExpression);

        }

        public virtual void visit(ListConstructor listConstructor)

        {

            foreach (var lvar in listConstructor.comprehensionVariables.symbolList)

                VisitSub(lvar, listConstructor);

            foreach (var elems in listConstructor.elements)

                VisitSub(elems, listConstructor);

            if (listConstructor.comprehension != null)

                VisitSub(listConstructor.comprehension, listConstructor);

        }

        public virtual void visit(SetConstructor setConstructor)

        {

            foreach (var svar in setConstructor.comprehensionVariables.symbolList)

                VisitSub(svar, setConstructor);

            foreach (var elems in setConstructor.items)

                VisitSub(elems, setConstructor);

            VisitSub(setConstructor.comprehension, setConstructor);

        }

        public virtual void visit(MapConstructor mapConstructor)

        {

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

                VisitSub(lvar, mapConstructor);*/

            foreach (var elem in mapConstructor.items)

            {

                VisitSub(elem.key, mapConstructor);

                VisitSub(elem.value, mapConstructor);

            }

        }

        public virtual void visit(TupleConstructor tupleConstructor)

        {

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

                VisitSub(lvar, tupleConstructor);*/

            foreach (var elem in tupleConstructor.values)

                VisitSub(elem, tupleConstructor);

        }

        public virtual void visit(AccessExpression accessExpression)

        {

            VisitSub(accessExpression.left, accessExpression);

            VisitSub(accessExpression.right, accessExpression);

        }

        public virtual void visit(BinaryOperator binaryOperator)

        {

            VisitSub(binaryOperator.left, binaryOperator);

            VisitSub(binaryOperator.right, binaryOperator);

        }

        public virtual void visit(TernaryOperator ternaryOperator)

        {

            VisitSub(ternaryOperator.left, ternaryOperator);

            VisitSub(ternaryOperator.mid, ternaryOperator);

            VisitSub(ternaryOperator.right, ternaryOperator);

        }

        public virtual void visit(TupleMapAccessExpression tupleMapAccessExpression)

        {

            VisitSub(tupleMapAccessExpression.argument, tupleMapAccessExpression);

            VisitSub(tupleMapAccessExpression.child, tupleMapAccessExpression);

        }

        public virtual void visit(CallExpression callExpression)

        {

            if (callExpression.arguments != null)

                foreach (var arg in callExpression.arguments)

                    VisitSub(arg, callExpression);

            VisitSub(callExpression.child, callExpression);

        }

        public virtual void visit(ForallQuantifier quantifier)

        {

            foreach (var lvar in quantifier.symbols.symbolList)

                VisitSub(lvar, quantifier);

            VisitSub(quantifier.child, quantifier);

        }

        public virtual void visit(ExistsQuantifier quantifier)

        {

            foreach (var lvar in quantifier.symbols.symbolList)

                VisitSub(lvar, quantifier);

            VisitSub(quantifier.child, quantifier);

        }

        public virtual void visit(UnaryOperator unaryOperator)

        {

            VisitSub(unaryOperator.child, unaryOperator);

            if (unaryOperator.kind == ExpressionKind.Cast)

                VisitSub(unaryOperator.type, unaryOperator);

        }

        public virtual void visit(CharType charType)

        {

        }

        public virtual void visit(IntType intType)

        {

        }

        public virtual void visit(BoolType boolType)

        {

        }

        public virtual void visit(FloatType floatType)

        {

        }

        public virtual void visit(EnumType enumType)

        {

            foreach (var sym in enumType.listOfEnumSymbols)

                VisitSub(sym, enumType);

        }

        public virtual void visit(ListType listType)

        {

            VisitSub(listType.innerType, listType);

        }

        public virtual void visit(MapType mapType)

        {

            VisitSub(mapType.fromType, mapType);

            VisitSub(mapType.toType, mapType);

        }

        public virtual void visit(QrType qrType)

        {

            foreach (var m in qrType.landmarks)

                VisitSub(m, qrType);

        }

        public virtual void visit(TupleType tupleType)

        {

            foreach (var t in tupleType.innerTypes)

                VisitSub(t, tupleType);

        }

        public virtual void visit(FunctionType functionType)

        {

            foreach (var a in functionType.parameter)

                VisitSub(a, functionType);

            VisitSub(functionType.returnType, functionType);

        }

        public virtual void visit(OoActionSystemType ooActionSystemType)

        {

            foreach (var s in ooActionSystemType.symbols.symbolList)

                VisitSub(s, ooActionSystemType);

            VisitSub(ooActionSystemType.doOdBlock, ooActionSystemType);

        }

        public virtual void visit(OpaqueType opaqueType)

        {

            VisitSub(opaqueType.resolvedType, opaqueType);

        }

        public virtual void visit(NullType nullType)

        { }

        public virtual void visit(AnyType anyType)

        { }

        public virtual void visit(ObjectConstructor objectConstructor)

        {

            VisitSub(objectConstructor.type, objectConstructor);

        }

        public virtual void visit(QValConstructor qValConstructor)

        {

        }

        public virtual void visit(QualitativeConstraintStatement qalitativeConstraintStatement)

        {

            VisitSub(qalitativeConstraintStatement.variable0, qalitativeConstraintStatement);

            VisitSub(qalitativeConstraintStatement.variable1, qalitativeConstraintStatement);

            if (qalitativeConstraintStatement.variable2 != null)

                VisitSub(qalitativeConstraintStatement.variable2, qalitativeConstraintStatement);

        }

    }

    /// <summary>

    /// Visitor that restricts itself to expressions

    /// </summary>

    public class OoaExpressionVisitor : OoaCompleteAstTraversalVisitor

    {

        protected override void VisitAstElement(IAst element, IAst parent)

        {

            // we are only interested in an expression.

            if (element.nodeType == AstNodeTypeEnum.expression)

                base.VisitAstElement(element, parent);

        }

        public OoaExpressionVisitor()

            : base(null)

        { }

    }

    /// <summary>

    /// Visitor that restricts itself to statements

    /// </summary>

    public class OoaStatementVisitor : OoaCompleteAstTraversalVisitor

    {

        protected override void VisitAstElement(IAst element, IAst parent)

        {

            // we are only interested in an expression.

            if (element.nodeType == AstNodeTypeEnum.statement)

                base.VisitAstElement(element, parent);

        }

        public OoaStatementVisitor()

            : base(null)

        { }

    }

    /// <summary>

    /// Visitor that restricts itself to types

    /// </summary>

    public class OoaTypeVisitor : OoaCompleteAstTraversalVisitor

    {

        protected override void VisitAstElement(IAst element, IAst parent)

        {

            // we are only interested in an expression.

            if (element.nodeType == AstNodeTypeEnum.type)

                base.VisitAstElement(element, parent);

        }

        public OoaTypeVisitor()

            : base(null)

        { }

    }

    /// <summary>

    /// Visitor that restricts itself to identifier

    /// </summary>

    public class OoaIdentifierVisitor : OoaCompleteAstTraversalVisitor

    {

        protected override void VisitAstElement(IAst element, IAst parent)

        {

            // we are only interested in an expression.

            if (element.nodeType == AstNodeTypeEnum.identifier)

                base.VisitAstElement(element, parent);

        }

        public OoaIdentifierVisitor()

            : base(null)

        { }

    }

}