|
/**
|
|
*
|
|
* 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)
|
|
*
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
* DeepCloneVisitor.cpp
|
|
*
|
|
* Created on: Feb 12, 2014
|
|
* Author: willibald
|
|
*/
|
|
|
|
#include "DeepCloneVisitor.hpp"
|
|
#include <list>
|
|
#include <ast/identifiers/NamedActionIdentifier.hpp>
|
|
#include <ast/statements/SeqBlock.hpp>
|
|
#include <ast/expressions/BinaryOperator.hpp>
|
|
#include <ast/statements/Assignment.hpp>
|
|
#include <ast/identifiers/AttributeIdentifier.hpp>
|
|
#include <ast/statements/Call.hpp>
|
|
#include <ast/expressions/CallExpression.hpp>
|
|
#include <ast/statements/GuardedCommand.hpp>
|
|
#include <ast/expressions/IdentifierExpression.hpp>
|
|
#include <ast/expressions/ListConstructor.hpp>
|
|
#include <ast/expressions/SetConstructor.hpp>
|
|
#include <ast/expressions/TernaryOperator.hpp>
|
|
#include <ast/expressions/TupleConstructor.hpp>
|
|
#include <ast/expressions/TupleMapAccessExpression.hpp>
|
|
|
|
namespace Ast {
|
|
|
|
|
|
|
|
void DeepCloneVisitor::updateScope(IScope* aScope) {
|
|
IScope* parentScope = aScope->getParentScope();
|
|
if (parentScope != nullptr) {
|
|
if(m_mapping.count(parentScope) == 0) {
|
|
if (!m_allowLinksToNonClonedParents) {
|
|
m_context->logError("Internal Error. Scope update failed.");
|
|
abort();
|
|
}
|
|
return;
|
|
}
|
|
aScope->setParentScope((IScope*)m_mapping[parentScope]);
|
|
}
|
|
}
|
|
|
|
void DeepCloneVisitor::checkScope(IScope* aScope) {
|
|
if (aScope->getParentScope() == nullptr)
|
|
return;
|
|
if (m_mapping.count(aScope->getParentScope()) > 0) {
|
|
m_context->logError("Internal Error. Scope check failed.");
|
|
abort();
|
|
}
|
|
}
|
|
|
|
Expression* DeepCloneVisitor::eClone(Expression* anExpr) {
|
|
Expression* result = nullptr;
|
|
if (anExpr != nullptr)
|
|
{
|
|
result = m_cloneAst->createExpression(*anExpr);
|
|
if (anExpr->asScope() != nullptr)
|
|
{
|
|
m_mapping[anExpr] = result;
|
|
updateScope(result->asScope());
|
|
}
|
|
result->accept(*this);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
Statement* DeepCloneVisitor::sClone(Statement* aStatement) {
|
|
Statement* result = nullptr;
|
|
if (aStatement != nullptr)
|
|
{
|
|
result = m_cloneAst->createStatement(*aStatement);
|
|
if (aStatement->asScope() != nullptr)
|
|
{
|
|
m_mapping[aStatement] = result;
|
|
updateScope(result->asScope());
|
|
}
|
|
result->accept(*this);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void DeepCloneVisitor::symTabClone(SymbolTable* aTable) {
|
|
if (aTable != nullptr && aTable->size() > 0)
|
|
{
|
|
std::list<Identifier*> newList;
|
|
for (auto& x: *aTable)
|
|
{
|
|
if (m_mapping.count(x.second) == 0) {
|
|
Identifier* newid = m_cloneAst->createIdentifier(*x.second);
|
|
newList.push_back(newid);
|
|
m_mapping[x.second] = newid;
|
|
} else {
|
|
newList.push_back((Identifier*) m_mapping[x.second]);
|
|
}
|
|
}
|
|
aTable->setSymbolList(newList);
|
|
}
|
|
}
|
|
|
|
void DeepCloneVisitor::cloneBlock(Block* aBlock) {
|
|
symTabClone(aBlock->symbols());
|
|
StatementList& statements = aBlock->statements();
|
|
for (std::size_t cntr = 0; cntr < statements.size(); cntr++) {
|
|
statements[cntr] = sClone(statements[cntr]);
|
|
}
|
|
}
|
|
|
|
void DeepCloneVisitor::cloneQuantifier(Quantifier* qf) {
|
|
symTabClone(qf->symbols());
|
|
bool oldQunatifierState = m_quantifierState;
|
|
m_quantifierState = true;
|
|
visit(qf);
|
|
m_quantifierState = oldQunatifierState;
|
|
}
|
|
|
|
void DeepCloneVisitor::cloneExpressionList(ExpressionList& aList) {
|
|
for (std::size_t cntr =0; cntr < aList.size(); cntr ++)
|
|
aList[cntr] = eClone(aList[cntr]);
|
|
}
|
|
|
|
|
|
|
|
void DeepCloneVisitor::visit(NamedActionIdentifier* namedActionIdentifier)
|
|
{
|
|
namedActionIdentifier->setBody(sClone(namedActionIdentifier->body()));
|
|
// we do not clone the parameters..
|
|
}
|
|
|
|
|
|
void DeepCloneVisitor::visit(ObjectConstructor* )
|
|
{
|
|
//CompleteAstTraversalVisitor::visit(objectConstructor);
|
|
}
|
|
|
|
|
|
void DeepCloneVisitor::visit(NondetBlock* nondetBlock)
|
|
{
|
|
cloneBlock((Block*)nondetBlock);
|
|
}
|
|
|
|
void DeepCloneVisitor::visit(SeqBlock* seqBlock)
|
|
{
|
|
seqBlock->setFilter(eClone(seqBlock->filter()));
|
|
cloneBlock((Block*)seqBlock);
|
|
}
|
|
|
|
void DeepCloneVisitor::visit(PrioBlock* prioBlock)
|
|
{
|
|
cloneBlock((Block*)prioBlock);
|
|
}
|
|
|
|
|
|
void DeepCloneVisitor::visit(AccessExpression* accessExpression)
|
|
{
|
|
visit((BinaryOperator*)accessExpression);
|
|
}
|
|
|
|
void DeepCloneVisitor::visit(BinaryOperator* binaryOperator)
|
|
{
|
|
Expression* left = eClone(binaryOperator->left());
|
|
Expression* right = eClone(binaryOperator->right());
|
|
binaryOperator->setLeftChild(left);
|
|
binaryOperator->setRightChild(right);
|
|
}
|
|
|
|
void DeepCloneVisitor::visit(Assignment* assignment)
|
|
{
|
|
symTabClone(assignment->symbols());
|
|
cloneExpressionList(assignment->places());
|
|
cloneExpressionList(assignment->values());
|
|
assignment->setNondetExpression(eClone(assignment->nondetExpression()));
|
|
checkScope(assignment);
|
|
}
|
|
|
|
|
|
void DeepCloneVisitor::visit(AttributeIdentifier* attributeIdentifier)
|
|
{
|
|
attributeIdentifier->setInitializer(eClone(attributeIdentifier->initializer()));
|
|
}
|
|
|
|
void DeepCloneVisitor::visit(Call* call)
|
|
{
|
|
call->setCallExpression(eClone(call->callExpression()));
|
|
}
|
|
|
|
void DeepCloneVisitor::visit(CallExpression* callExpression)
|
|
{
|
|
cloneExpressionList(callExpression->arguments());
|
|
visit((UnaryOperator*)callExpression);
|
|
}
|
|
|
|
void DeepCloneVisitor::visit(ExistsQuantifier* quantifier)
|
|
{
|
|
cloneQuantifier((Quantifier*)quantifier);
|
|
}
|
|
|
|
void DeepCloneVisitor::visit(ForallQuantifier* quantifier)
|
|
{
|
|
cloneQuantifier((Quantifier*)quantifier);
|
|
}
|
|
|
|
void DeepCloneVisitor::visit(GuardedCommand* guardedCommand)
|
|
{
|
|
Statement* newblock = sClone(guardedCommand->body());
|
|
Expression* newguard = eClone(guardedCommand->guard());
|
|
guardedCommand->setBody(newblock);
|
|
guardedCommand->setGuard(newguard);
|
|
}
|
|
|
|
|
|
void DeepCloneVisitor::visit(IdentifierExpression* identifierExpression)
|
|
{
|
|
if (identifierExpression->isSelf() && m_selfreplacement != nullptr)
|
|
identifierExpression->setIdentifier(m_selfreplacement);
|
|
else if (m_mapping.count(identifierExpression->identifier()) > 0
|
|
&& identifierExpression->identifier()->kind() != IdentifierKind::MethodIdentifier)
|
|
{
|
|
/* we do NOT replace method calls here, since they are prefixed by self if it's a
|
|
* method in the current object or by some field/method access if it's another
|
|
* object.
|
|
*/
|
|
identifierExpression->setIdentifier((Identifier*)m_mapping[identifierExpression->identifier()]);
|
|
}
|
|
}
|
|
|
|
|
|
void DeepCloneVisitor::visit(ListConstructor* listConstructor)
|
|
{
|
|
symTabClone(listConstructor->comprehensionVariables());
|
|
cloneExpressionList(listConstructor->elements());
|
|
listConstructor->setComprehension(eClone(listConstructor->comprehension()));
|
|
}
|
|
|
|
|
|
void DeepCloneVisitor::visit(SetConstructor* setConstructor)
|
|
{
|
|
symTabClone(setConstructor->comprehensionVariables());
|
|
cloneExpressionList(setConstructor->items());
|
|
setConstructor->setComprehension(eClone(setConstructor->comprehension()));
|
|
}
|
|
|
|
|
|
void DeepCloneVisitor::visit(TernaryOperator* ternaryOperator)
|
|
{
|
|
ternaryOperator->setLeftChild(eClone(ternaryOperator->left()));
|
|
ternaryOperator->setMidChild(eClone(ternaryOperator->mid()));
|
|
ternaryOperator->setRightChild(eClone(ternaryOperator->right()));
|
|
}
|
|
|
|
|
|
void DeepCloneVisitor::visit(TupleConstructor* tupleConstructor)
|
|
{
|
|
cloneExpressionList(tupleConstructor->values());
|
|
}
|
|
|
|
|
|
void DeepCloneVisitor::visit(TupleMapAccessExpression* tupleMapAccessExpression)
|
|
{
|
|
tupleMapAccessExpression->setArgument(eClone(tupleMapAccessExpression->argument()));
|
|
visit((UnaryOperator*)tupleMapAccessExpression);
|
|
}
|
|
|
|
|
|
void DeepCloneVisitor::visit(UnaryOperator* unaryOperator)
|
|
{
|
|
unaryOperator->setChild(eClone(unaryOperator->child()));
|
|
}
|
|
|
|
} /* namespace Ast */
|