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