OoasTools

/**

  *

  *                  OOAS Compiler - C++ AST

  *

  * Copyright 2015, 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)

  *               Christoph Czurda (AIT)

  *

  */

#include "ExpressionVisitor.hpp"

#include <ast/expressions/IdentifierExpression.hpp>

#include <ast/expressions/TypeExpression.hpp>

#include <ast/expressions/ListConstructor.hpp>

#include <ast/expressions/SetConstructor.hpp>

#include <ast/expressions/TupleConstructor.hpp>

#include <ast/expressions/AccessExpression.hpp>

#include <ast/expressions/BinaryOperator.hpp>

#include <ast/expressions/TernaryOperator.hpp>

#include <ast/expressions/TupleMapAccessExpression.hpp>

#include <ast/expressions/CallExpression.hpp>

#include <ast/expressions/ForallQuantifier.hpp>

#include <ast/expressions/ExistsQuantifier.hpp>

#include <ast/expressions/UnaryOperator.hpp>

namespace Ast {

ExpressionVisitor::ExpressionVisitor(CallContext* context):

                m_context(context)

{}

ExpressionVisitor::~ExpressionVisitor()

{}

void ExpressionVisitor::visitSub(AstElement* subElement, AstElement* parent) {

        if (subElement == nullptr)

                return;

        visitAstElement(subElement, parent);

}

void ExpressionVisitor::visitAstElement(AstElement* element, AstElement* ){

        switch (element->nodeType()) {

        case AstNodeTypeEnum::statement:

        case AstNodeTypeEnum::identifier:

        case AstNodeTypeEnum::type:

                error();

                break;

        case AstNodeTypeEnum::expression:

                static_cast<Expression*>(element)->accept(*this);

                break;

        default:

                m_context->logError("Internal error. Unknown AST type.");

                abort();

        }

}

void ExpressionVisitor::error() {

        m_context -> logError("Internal error. This visitor only supports expressions.");

        abort();

}

void ExpressionVisitor::visit(TypeIdentifier* ) { error(); };

void ExpressionVisitor::visit(EnumIdentifier* ) { error(); };

//void ExpressionVisitor::visit(ValuedEnumIdentifier* enumIdentifier) { error(); };

void ExpressionVisitor::visit(AttributeIdentifier* ) { error(); };

void ExpressionVisitor::visit(LocalVariableIdentifier* ) { error(); };

void ExpressionVisitor::visit(ParameterIdentifier* ) { error(); };

void ExpressionVisitor::visit(ExpressionVariableIdentifier* ) { error(); };

void ExpressionVisitor::visit(MethodIdentifier* ) { error(); };

void ExpressionVisitor::visit(NamedActionIdentifier* ) { error(); };

void ExpressionVisitor::visit(Module* ) { error(); };

void ExpressionVisitor::visit(ConstantIdentifier* ) { error(); };

void ExpressionVisitor::visit(UnspecIdentifierBlock* ) { error(); };

void ExpressionVisitor::visit(SeqIdentifierBlock* ) { error(); };

void ExpressionVisitor::visit(NondetIdentifierBlock* ) { error(); };

void ExpressionVisitor::visit(PrioIdentifierBlock* ) { error(); };

void ExpressionVisitor::visit(MainModule* ) { error(); };

void ExpressionVisitor::visit(IntType* ) { error(); };

void ExpressionVisitor::visit(BoolType* ) { error(); };

void ExpressionVisitor::visit(EnumType* ) { error(); };

void ExpressionVisitor::visit(ListType* ) { error(); };

void ExpressionVisitor::visit(TupleType* ) { error(); };

void ExpressionVisitor::visit(NullType* ) { error(); };

void ExpressionVisitor::visit(PointerType* ) { error(); };

void ExpressionVisitor::visit(FunctionType* ) { error(); };

void ExpressionVisitor::visit(ActionSystemType* ) { error(); };

void ExpressionVisitor::visit(GuardedCommand* ) { error(); };

void ExpressionVisitor::visit(Call* ) { error(); };

void ExpressionVisitor::visit(Assignment* ) { error(); };

void ExpressionVisitor::visit(SeqBlock* ) { error(); };

void ExpressionVisitor::visit(NondetBlock* ) { error(); };

void ExpressionVisitor::visit(PrioBlock* ) { error(); };

void ExpressionVisitor::visit(Skip* ) { error(); };

void ExpressionVisitor::visit(Break* ) { error(); };

void ExpressionVisitor::visit(Abort* ) { error(); };

void ExpressionVisitor::visit(TernaryOperator* ternaryOperator) {

        visitSub(ternaryOperator->left(), ternaryOperator);

        visitSub(ternaryOperator->mid(), ternaryOperator);

        visitSub(ternaryOperator->right(), ternaryOperator);

};

void ExpressionVisitor::visit(BinaryOperator* binaryOperator) {

        visitSub(binaryOperator->left(), binaryOperator);

        visitSub(binaryOperator->right(), binaryOperator);

};

void ExpressionVisitor::visit(UnaryOperator* unaryOperator) {

        visitSub(unaryOperator->child(), unaryOperator);

};

void ExpressionVisitor::visit(ExistsQuantifier* quantifier) {

        visitSub(quantifier->child(), quantifier);

};

void ExpressionVisitor::visit(ForallQuantifier* quantifier) {

        visitSub(quantifier->child(), quantifier);

};

void ExpressionVisitor::visit(ListConstructor* listConstructor) {

        for (auto& elems: listConstructor->elements())

                visitSub(elems, listConstructor);

        visitSub(listConstructor->comprehension(), listConstructor);

};

void ExpressionVisitor::visit(SetConstructor* setConstructor) {

        for (auto& elems: setConstructor->items())

                visitSub(elems, setConstructor);

        visitSub(setConstructor->comprehension(), setConstructor);

};

void ExpressionVisitor::visit(TupleConstructor* tupleConstructor) {

        for (auto& elem: tupleConstructor->values())

                visitSub(elem, tupleConstructor);

};

void ExpressionVisitor::visit(ObjectConstructor* ) {};

void ExpressionVisitor::visit(BoolValueExpression* ) {};

void ExpressionVisitor::visit(IntValueExpression* ) {};

void ExpressionVisitor::visit(RefValueExpression* ) {};

void ExpressionVisitor::visit(IdentifierExpression* ) {};

void ExpressionVisitor::visit(TypeExpression* ) {};

void ExpressionVisitor::visit(TupleMapAccessExpression* tupleMapAccessExpression) {

        visitSub(tupleMapAccessExpression->argument(), tupleMapAccessExpression);

        visitSub(tupleMapAccessExpression->child(), tupleMapAccessExpression);

};

void ExpressionVisitor::visit(CallExpression* callExpression) {

        for (auto& arg: callExpression->arguments())

                visitSub(arg, callExpression);

        visitSub(callExpression->child(), callExpression);

};

void ExpressionVisitor::visit(AccessExpression* accessExpression) {

        visitSub(accessExpression->left(), accessExpression);

        visitSub(accessExpression->right(), accessExpression);

};

} /* namespace Ast */