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

import org.momut.ooas.ast.expressions.AccessExpression;

import org.momut.ooas.ast.expressions.BinaryOperator;

import org.momut.ooas.ast.expressions.CallExpression;

import org.momut.ooas.ast.expressions.ExistsQuantifier;

import org.momut.ooas.ast.expressions.ForallQuantifier;

import org.momut.ooas.ast.expressions.IdentifierExpression;

import org.momut.ooas.ast.expressions.ListConstructor;

import org.momut.ooas.ast.expressions.MapConstructor;

import org.momut.ooas.ast.expressions.ObjectConstructor;

import org.momut.ooas.ast.expressions.QValConstructor;

import org.momut.ooas.ast.expressions.SetConstructor;

import org.momut.ooas.ast.expressions.TernaryOperator;

import org.momut.ooas.ast.expressions.TupleConstructor;

import org.momut.ooas.ast.expressions.TupleMapAccessExpression;

import org.momut.ooas.ast.expressions.TypeExpression;

import org.momut.ooas.ast.expressions.UnaryOperator;

import org.momut.ooas.ast.expressions.UnresolvedIdentifierExpression;

import org.momut.ooas.ast.expressions.ValueExpression;

import org.momut.ooas.ast.identifiers.AttributeIdentifier;

import org.momut.ooas.ast.identifiers.ConstantIdentifier;

import org.momut.ooas.ast.identifiers.EnumIdentifier;

import org.momut.ooas.ast.identifiers.ExpressionVariableIdentifier;

import org.momut.ooas.ast.identifiers.LandmarkIdentifier;

import org.momut.ooas.ast.identifiers.LocalVariableIdentifier;

import org.momut.ooas.ast.identifiers.MainModule;

import org.momut.ooas.ast.identifiers.MethodIdentifier;

import org.momut.ooas.ast.identifiers.Module;

import org.momut.ooas.ast.identifiers.NamedActionIdentifier;

import org.momut.ooas.ast.identifiers.NondetIdentifierList;

import org.momut.ooas.ast.identifiers.ParameterIdentifier;

import org.momut.ooas.ast.identifiers.PrioIdentifierList;

import org.momut.ooas.ast.identifiers.SelfTypeIdentifier;

import org.momut.ooas.ast.identifiers.SeqIdentifierList;

import org.momut.ooas.ast.identifiers.TypeIdentifier;

import org.momut.ooas.ast.identifiers.UnspecIdentifierList;

import org.momut.ooas.ast.statements.AbortStatement;

import org.momut.ooas.ast.statements.Assignment;

import org.momut.ooas.ast.statements.BreakStatement;

import org.momut.ooas.ast.statements.Call;

import org.momut.ooas.ast.statements.GuardedCommand;

import org.momut.ooas.ast.statements.KillStatement;

import org.momut.ooas.ast.statements.NondetBlock;

import org.momut.ooas.ast.statements.PrioBlock;

import org.momut.ooas.ast.statements.QualitativeConstraintStatement;

import org.momut.ooas.ast.statements.SeqBlock;

import org.momut.ooas.ast.statements.SkipStatement;

import org.momut.ooas.ast.types.AnyType;

import org.momut.ooas.ast.types.BoolType;

import org.momut.ooas.ast.types.CharType;

import org.momut.ooas.ast.types.EnumType;

import org.momut.ooas.ast.types.FloatType;

import org.momut.ooas.ast.types.FunctionType;

import org.momut.ooas.ast.types.IntType;

import org.momut.ooas.ast.types.ListType;

import org.momut.ooas.ast.types.MapType;

import org.momut.ooas.ast.types.NullType;

import org.momut.ooas.ast.types.OoActionSystemType;

import org.momut.ooas.ast.types.OpaqueType;

import org.momut.ooas.ast.types.QrType;

import org.momut.ooas.ast.types.TupleType;

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

public interface IAstVisitor

{

        String returnVisitorName();

        void done();

        /*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);

        void visit(ConstantIdentifier constantIdentifier);

        /*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);

        void visit(QualitativeConstraintStatement qalitativeConstraintStatement);

        /*Expressions*/

        <T> void visit(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(ObjectConstructor objectConstructor);

        void visit(QValConstructor qValConstructor);

        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);

        /*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(NullType nullType);

        void visit(BreakStatement breakStatement);

}