|
/**
|
|
*
|
|
* 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)
|
|
*
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
* Ast.cpp
|
|
*
|
|
* Created on: Jan 27, 2014
|
|
* Author: willibald
|
|
*/
|
|
|
|
#include "Ast.hpp"
|
|
|
|
#include <ast/identifiers/TypeIdentifier.hpp>
|
|
#include <ast/identifiers/EnumIdentifier.hpp>
|
|
#include <ast/identifiers/AttributeIdentifier.hpp>
|
|
#include <ast/identifiers/LocalVariableIdentifier.hpp>
|
|
#include <ast/identifiers/ParameterIdentifier.hpp>
|
|
#include <ast/identifiers/ExpressionVariableIdentifier.hpp>
|
|
#include <ast/identifiers/MethodIdentifier.hpp>
|
|
#include <ast/identifiers/NamedActionIdentifier.hpp>
|
|
#include <ast/identifiers/Module.hpp>
|
|
#include <ast/identifiers/ConstantIdentifier.hpp>
|
|
#include <ast/types/IntType.hpp>
|
|
#include <ast/types/BoolType.hpp>
|
|
#include <ast/types/EnumType.hpp>
|
|
#include <ast/types/ValuedEnumType.hpp>
|
|
#include <ast/types/ListType.hpp>
|
|
#include <ast/types/TupleType.hpp>
|
|
#include <ast/types/NullType.hpp>
|
|
#include <ast/types/FunctionType.hpp>
|
|
#include <ast/types/ActionSystemType.hpp>
|
|
#include <ast/statements/GuardedCommand.hpp>
|
|
#include <ast/statements/Call.hpp>
|
|
#include <ast/statements/Assignment.hpp>
|
|
#include <ast/statements/SeqBlock.hpp>
|
|
#include <ast/statements/NondetBlock.hpp>
|
|
#include <ast/statements/PrioBlock.hpp>
|
|
#include <ast/statements/Skip.hpp>
|
|
#include <ast/statements/Abort.hpp>
|
|
#include <ast/expressions/TernaryOperator.hpp>
|
|
#include <ast/expressions/BinaryOperator.hpp>
|
|
#include <ast/expressions/UnaryOperator.hpp>
|
|
#include <ast/expressions/ExistsQuantifier.hpp>
|
|
#include <ast/expressions/ForallQuantifier.hpp>
|
|
#include <ast/expressions/ListConstructor.hpp>
|
|
#include <ast/expressions/SetConstructor.hpp>
|
|
#include <ast/expressions/TupleConstructor.hpp>
|
|
#include <ast/expressions/ObjectConstructor.hpp>
|
|
#include <ast/expressions/IdentifierExpression.hpp>
|
|
#include <ast/expressions/ValueExpression.hpp>
|
|
#include <ast/expressions/TypeExpression.hpp>
|
|
#include <ast/expressions/TupleMapAccessExpression.hpp>
|
|
#include <ast/expressions/CallExpression.hpp>
|
|
#include <ast/expressions/AccessExpression.hpp>
|
|
#include <ast/identifiers/IdentifierBlock.hpp>
|
|
#include <ast/identifiers/MainModule.hpp>
|
|
#include <ast/types/PointerType.hpp>
|
|
#include "DeepCloneVisitor.hpp"
|
|
#include <CallContext.hpp>
|
|
#include <base/CdtFixes.hpp>
|
|
#include <cassert>
|
|
|
|
|
|
namespace Ast {
|
|
|
|
Base::TiresiasObject* Ast::takeOwnership(Base::TiresiasObject* obj) {
|
|
m_allocatedAstObjects.push_back(obj);
|
|
return obj;
|
|
}
|
|
|
|
|
|
|
|
SymbolTable* Ast::createSymbolTable() {
|
|
return (SymbolTable*) takeOwnership(new SymbolTable());
|
|
}
|
|
SymbolTable* Ast::createSymbolTable(const SymbolTable& toCopy) {
|
|
return (SymbolTable*) takeOwnership(new SymbolTable(toCopy));
|
|
}
|
|
|
|
|
|
// Identifiers
|
|
Identifier* Ast::createIdentifier(IdentifierKind t) {
|
|
Identifier* result = (Identifier*) takeOwnership(Identifier::createVirtual(t));
|
|
assert(result == nullptr || result->kind() == t);
|
|
return result;
|
|
}
|
|
Identifier* Ast::createIdentifier(const Identifier& toCopy) {
|
|
Identifier* result = (Identifier*) takeOwnership(Identifier::createVirtual(toCopy));
|
|
assert(result == nullptr || result->kind() == toCopy.kind());
|
|
return result;
|
|
}
|
|
|
|
|
|
ActionSystemInstance* Ast::createActionSystemInstance(){
|
|
return (ActionSystemInstance*) takeOwnership(new ActionSystemInstance());
|
|
}
|
|
ActionSystemInstance* Ast::createActionSystemInstance(const ActionSystemInstance& toCopy) {
|
|
return (ActionSystemInstance*) takeOwnership(new ActionSystemInstance(toCopy));
|
|
}
|
|
|
|
|
|
IdentifierList* Ast::createIdentifierList() {
|
|
return (IdentifierList*) takeOwnership(new IdentifierList());
|
|
};
|
|
IdentifierList* Ast::createIdentifierList(const IdentifierList& toCopy) {
|
|
return (IdentifierList*) takeOwnership(new IdentifierList(toCopy));
|
|
}
|
|
|
|
|
|
ParameterList* Ast::createParameterList() {
|
|
return (ParameterList*) takeOwnership(new ParameterList());
|
|
}
|
|
ParameterList* Ast::createParameterList(const ParameterList& toCopy) {
|
|
return (ParameterList*) takeOwnership(new ParameterList(toCopy));
|
|
}
|
|
|
|
|
|
ActionSystemInstanceList* Ast::createActionSystemInstanceList() {
|
|
return (ActionSystemInstanceList*) takeOwnership(new ActionSystemInstanceList());
|
|
}
|
|
ActionSystemInstanceList* Ast::createActionSystemInstanceList(const ActionSystemInstanceList& toCopy) {
|
|
return (ActionSystemInstanceList*) takeOwnership(new ActionSystemInstanceList(toCopy));
|
|
}
|
|
|
|
|
|
// Types
|
|
Type* Ast::createType(TypeKind t) {
|
|
Type* result = (Type*)takeOwnership(Type::createVirtual(t));
|
|
assert(result == nullptr || result->kind() == t);
|
|
return result;
|
|
}
|
|
Type* Ast::createType(const Type& toCopy) {
|
|
Type* result = (Type*)takeOwnership(Type::createVirtual(toCopy));
|
|
assert(result == nullptr || result->kind() == toCopy.kind());
|
|
return result;
|
|
}
|
|
|
|
|
|
TypeList* Ast::createTypeList() {
|
|
return (TypeList*) takeOwnership(new TypeList());
|
|
}
|
|
TypeList* Ast::createTypeList(const TypeList& toCopy) {
|
|
return (TypeList*) takeOwnership(new TypeList(toCopy));
|
|
}
|
|
|
|
|
|
// Statements
|
|
Statement* Ast::createStatement(StatementKind t) {
|
|
Statement* result = (Statement*) takeOwnership(Statement::createVirtual(t));
|
|
assert(result == nullptr || result->kind() == t);
|
|
return result;
|
|
}
|
|
Statement* Ast::createStatement(const Statement& toCopy) {
|
|
Statement* result = (Statement*) takeOwnership(Statement::createVirtual(toCopy));
|
|
assert(result == nullptr || result->kind() == toCopy.kind());
|
|
return result;
|
|
}
|
|
|
|
Statement* Ast::deepCopyStatement(Statement* toCopy) {
|
|
Statement* result = createStatement(*toCopy);
|
|
DeepCloneVisitor cloner (m_context, this);
|
|
result->accept(cloner);
|
|
return result;
|
|
}
|
|
|
|
|
|
StatementList* Ast::createStatementList() {
|
|
return (StatementList*) takeOwnership( new StatementList());
|
|
};
|
|
StatementList* Ast::createStatementList(const StatementList& toCopy) {
|
|
return (StatementList*) takeOwnership( new StatementList(toCopy));
|
|
}
|
|
|
|
|
|
|
|
// Expressions
|
|
Expression* Ast::createExpression(ExpressionKind t) {
|
|
Expression* result = (Expression*) takeOwnership(Expression::createVirtual(t));
|
|
assert(result == nullptr || result->kind() == t);
|
|
return result;
|
|
}
|
|
Expression* Ast::createExpression(const Expression& toCopy) {
|
|
Expression* result = (Expression*) takeOwnership(Expression::createVirtual(toCopy));
|
|
assert(result == nullptr || result->kind() == toCopy.kind());
|
|
return result;
|
|
}
|
|
|
|
Expression* Ast::deepCopyExpression(Expression* toCopy) {
|
|
Expression* result = createExpression(*toCopy);
|
|
DeepCloneVisitor cloner (m_context, this);
|
|
result->accept(cloner);
|
|
return result;
|
|
}
|
|
|
|
|
|
ExpressionList* Ast::createExpressionList(){
|
|
return (ExpressionList*) takeOwnership(new ExpressionList());
|
|
};
|
|
ExpressionList* Ast::createExpressionList(const ExpressionList& toCopy) {
|
|
return (ExpressionList*) takeOwnership(new ExpressionList(toCopy));
|
|
}
|
|
|
|
Ast::Ast(CallContext* context):
|
|
m_context (context),
|
|
m_allocatedAstObjects()
|
|
{}
|
|
|
|
Ast::~Ast() {
|
|
for (auto& o: m_allocatedAstObjects)
|
|
delete o;
|
|
}
|
|
|
|
} /* namespace Ast */
|