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 <ast/Containers.hpp>

#include <ast/types/Type.hpp>

#include <ast/IScope.hpp>

#include <ast/statements/Block.hpp>

#include <ast/SymbolTable.hpp>

#include <deque>

#include <string>

#include <cstdint>

#include <ast/identifiers/Identifier.hpp>

#include <ast/identifiers/FunctionIdentifier.hpp>

#include <base/Exceptions.hpp>

#include <ast/IAstVisitor.hpp>

namespace Ast {

class ActionSystemType; // forward

class ActionSystemInstance final

        : public Base::TiresiasObject

{

protected:

        std::int32_t m_numberOfCreatedObjects;

        ActionSystemType* m_type;

        ActionSystemInstance* m_parentObject;

        string m_name;

        ActionSystemInstance():

                TiresiasObject(),

                m_numberOfCreatedObjects (0),

                m_type (nullptr),

                m_parentObject (nullptr),

                m_name ("")

        {};

        ActionSystemInstance(const ActionSystemInstance& toCopy):

                TiresiasObject(),

                m_numberOfCreatedObjects (toCopy.m_numberOfCreatedObjects),

                m_type (toCopy.m_type),

                m_parentObject (toCopy.m_parentObject),

                m_name (toCopy.m_name)

        {};

public:

        friend class Ast;

        void init(ActionSystemType* typeRef, const char* name, std::int32_t numOfCreatedObjs, ActionSystemInstance* parentInstanceRef)

        {

                m_type = typeRef;

                m_name = name;

                m_numberOfCreatedObjects = numOfCreatedObjs;

                m_parentObject = parentInstanceRef;

        }

        std::string getName() const {return m_name;};

        std::int32_t getNumberOfCreatedObjects() const {return m_numberOfCreatedObjects;};

        ActionSystemType* getType() const {return m_type;};

        ActionSystemInstance* getParentObject() const {return m_parentObject;};

        constexpr static std::uint8_t TypeId = 2;

        static ActionSystemInstance* create() {

                return new ActionSystemInstance();

        }

};

class ActionSystemType

        : public Type

        , public IScope

{

protected:

        bool m_autoCons;

        bool m_isInSystemDescription;

        ActionSystemType* m_baseType;

        Block* m_doodBlock;

        IScope* m_parentScope;

        SymbolTable* m_symbols;

        ActionSystemInstanceList m_objects;

        ActionSystemInstanceList m_derivedObjects;

        FunctionIdentifier* m_doodFunction; // only avail after Finalisation Visitor has run. Wraps doodBlock in function.

        ActionSystemType():

                Type(TypeKind::OoActionSystemType),

                m_autoCons (false),

                m_isInSystemDescription (false),

                m_baseType (nullptr),

                m_doodBlock(nullptr),

                m_parentScope(nullptr),

                m_symbols(nullptr),

                m_objects (),

                m_derivedObjects(),

                m_doodFunction (nullptr)

        {};

        ActionSystemType(const ActionSystemType& toCopy):

                Type(toCopy),

                m_autoCons (toCopy.m_autoCons),

                m_isInSystemDescription (toCopy.m_isInSystemDescription),

                m_baseType (toCopy.m_baseType),

                m_doodBlock(toCopy.m_doodBlock),

                m_parentScope(toCopy.m_parentScope),

                m_symbols(toCopy.m_symbols),

                m_objects (toCopy.m_objects),

                m_derivedObjects(toCopy.m_derivedObjects),

                m_doodFunction (toCopy.m_doodFunction)

        {};

        static constexpr const char* s_doodFunctionName = ".dood";

        static ActionSystemType* create() {return new ActionSystemType();}

        static ActionSystemType* createCopy(const ActionSystemType& toCopy) {return new ActionSystemType(toCopy);}

public:

        friend class Ast;

        friend class Type;

        void init(TypeIdentifier* identifierRef, bool anonymousType, ActionSystemType* baseTypeRef,

                        IScope* parentScopeRef, Block* doodBlockRef, SymbolTable* symTab,

                        ActionSystemInstanceList* objectsListRef,

                        ActionSystemInstanceList* derivedObjectsListRef, bool autoConstruction, bool isInSystemDescription)

        {

                Type::init(identifierRef,anonymousType);

                m_baseType = baseTypeRef;

                m_parentScope = parentScopeRef;

                m_doodBlock = doodBlockRef;

                m_symbols = symTab;

                m_objects = std::move(*objectsListRef);

                m_derivedObjects = std::move(*derivedObjectsListRef);

                m_autoCons = autoConstruction;

                m_isInSystemDescription = isInSystemDescription;

        }

        bool autoConstruction() {return m_autoCons;};

        bool isInSystemDescription() {return m_isInSystemDescription;};

        Block* doodBlock() {return m_doodBlock;};

        std::string doodFunctionName() const {return s_doodFunctionName;}

        FunctionIdentifier* doodFunction() {return m_doodFunction; }

        ActionSystemType* baseType() {return m_baseType;};

        SymbolTable* symbols() {return m_symbols;};

        ActionSystemInstanceList& objects() {return m_objects;};

        ActionSystemInstanceList& derivedObjects() {return m_derivedObjects;};

        IScope* getParentScope() const override {return m_parentScope;};

        std::string getScopeName() const override {return m_identifier->toString();}

        void setDoodBlock(Block* anArg) {m_doodBlock = anArg;};

        void setDoodFunction(FunctionIdentifier* id) {m_doodFunction = id;}

        void setParentScope(IScope* parentScope) override {m_parentScope = parentScope;};

        void setBaseType(ActionSystemType* newType) {m_baseType = newType;};

        void setIsInSystemDescription(bool p) {m_isInSystemDescription = p;};

        void accept(IAstVisitor& visitor) override {visitor.visit(this);};

        Identifier* resolveIdentifier(const std::string& aName) const override {return m_symbols->get(aName);}

        void addIdentifier(Identifier* anIdentifier, void* /*tag*/) override {m_symbols->addIdentifier(anIdentifier);};

        SymbolTable* getAllSymbols() {return m_symbols;};

        IScope* asScope() final {return (IScope*) this;}

        bool isSubTypeOf(ActionSystemType* other){

                if(other == this)

                        return true;

                else if(m_baseType == nullptr)

                        return false;

                else

                        return m_baseType->isSubTypeOf(other);

        }

        bool isDefined(const Identifier* id) {

                bool result = false;

                ActionSystemType* aType = this;

                while (!result && aType != nullptr) {

                        result = aType->m_symbols->defined(id);

                        aType = aType->m_baseType;

                }

                return result;

        }

};

}