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)

  *

  */

#pragma once

#include <cstdint>

#include <deque>

#include <base/TiresiasObject.hpp>

class CallContext;

namespace Ast {

/**

 * Forward declarations of the AST classes

 */

class TypeIdentifier;

class EnumIdentifier;

//class ValuedEnumIdentifier;

class AttributeIdentifier;

class LocalVariableIdentifier;

class ParameterIdentifier;

class ExpressionVariableIdentifier;

class MethodIdentifier;

class NamedActionIdentifier;

class Module;

class ConstantIdentifier;

class IntType;

class BoolType;

class EnumType;

class ListType;

class TupleType;

class NullType;

class FunctionType;

class ActionSystemType;

class GuardedCommand;

class Call;

class Assignment;

class SeqBlock;

class NondetBlock;

class PrioBlock;

class Skip;

class Break;

class Abort;

class TernaryOperator;

class BinaryOperator;

class UnaryOperator;

class ExistsQuantifier;

class ForallQuantifier;

class ListConstructor;

class SetConstructor;

class TupleConstructor;

class ObjectConstructor;

class IdentifierExpression;

class BoolValueExpression;

class IntValueExpression;

class RefValueExpression;

class TypeExpression;

class TupleMapAccessExpression;

class CallExpression;

class AccessExpression;

class UnspecIdentifierBlock;

class SeqIdentifierBlock;

class NondetIdentifierBlock;

class PrioIdentifierBlock;

class MainModule;

class PointerType;

class ActionSystemInstance;

class ValuedEnumType;

class ExpressionList;

class StatementList;

class IdentifierList;

class ParameterList;

class TypeList;

class ActionSystemInstanceList;

enum class ExpressionKind: std::uint8_t;

enum class TypeKind : std::uint8_t;

enum class StatementKind: std::uint8_t;

enum class IdentifierKind: std::uint8_t;

class SymbolTable;

class Type;

class Statement;

class Identifier;

class Expression;

/**

 * Facade

 */

class Ast final {

private:

        CallContext* m_context;

        /* List of owned AST objects */

        std::deque<Base::TiresiasObject*> m_allocatedAstObjects;

        Base::TiresiasObject* takeOwnership(Base::TiresiasObject* obj);

public:

        Ast(CallContext* context);

        ~Ast();

        // Constructors: All the objects created are owned by this AST. IOW once

        // this object is gone, all the created elements as well.

        // ALL the copy constructors will do a shallow copy. Use the clone visitor to get a deep clone.

        Type* createType(TypeKind t);

        Type* createType(const Type& toCopy);

        Statement* createStatement(StatementKind t);            // new, empty statement

        Statement* createStatement(const Statement& toCopy);    // shallow copy statement

        Statement* deepCopyStatement(Statement* toCopy);        // deep copy statement

        Identifier* createIdentifier(IdentifierKind t);

        Identifier* createIdentifier(const Identifier& toCopy);

        Expression* createExpression(ExpressionKind t);         // new, empty expression

        Expression* createExpression(const Expression& toCopy); // shallow copy expression

        Expression* deepCopyExpression(Expression* toCopy);     // deep copy expression

        ActionSystemInstance* createActionSystemInstance();

        ActionSystemInstance* createActionSystemInstance(const ActionSystemInstance& toCopy);

        ExpressionList* createExpressionList();

        ExpressionList* createExpressionList(const ExpressionList& toCopy);

        IdentifierList* createIdentifierList();

        IdentifierList* createIdentifierList(const IdentifierList& toCopy);

        StatementList* createStatementList();

        StatementList* createStatementList(const StatementList& toCopy);

        ParameterList* createParameterList();

        ParameterList* createParameterList(const ParameterList& toCopy);

        TypeList* createTypeList();

        TypeList* createTypeList(const TypeList& toCopy);

        ActionSystemInstanceList* createActionSystemInstanceList();

        ActionSystemInstanceList* createActionSystemInstanceList(const ActionSystemInstanceList& toCopy);

        SymbolTable* createSymbolTable();

        SymbolTable* createSymbolTable(const SymbolTable& toCopy);

};

}