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/types/Type.hpp>

#include <ast/Containers.hpp>

#include <deque>

namespace Ast {

enum class FunctionKind : std::uint8_t {

        Observable = 0,

        Controllable = 1,

        Continuous = 2,

        Internal = 3,

        Method = 4

};

class FunctionType final

        : public Type

{

protected:

        FunctionKind m_functionType;

        bool m_pure;

        bool m_static;

        bool* m_miracleSafe;

        Type* m_returnType;

        TypeList m_parameter;

        FunctionType():

                Type(TypeKind::FunctionType),

                m_functionType (FunctionKind::Internal),

                m_pure(false),

                m_static(false),

                m_miracleSafe (nullptr),

                m_returnType (nullptr),

                m_parameter ()

        {}

        FunctionType(const FunctionType& toCopy):

                Type(toCopy),

                m_functionType (toCopy.m_functionType),

                m_pure(toCopy.m_pure),

                m_static(toCopy.m_static),

                m_miracleSafe (toCopy.m_miracleSafe),

                m_returnType (toCopy.m_returnType),

                m_parameter (toCopy.m_parameter)

        {}

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

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

public:

        friend class Ast;

        friend class Type;

        ~FunctionType() override {

                if (m_miracleSafe != nullptr)

                        delete m_miracleSafe;

        }

        void init(TypeIdentifier* identifierRef, bool anonymousType,

                        TypeList* paramTypeListRef, Type* returnTypeRef, FunctionKind functionKind, bool isPure)

        {

                Type::init(identifierRef,anonymousType);

                m_parameter = std::move(*paramTypeListRef);

                m_returnType = returnTypeRef;

                m_functionType = functionKind;

                m_pure = isPure;

        }

        bool* isMiracleSafe() const {return m_miracleSafe;};

        bool isStatic() const {return m_static;}

        bool isPureFunction() const {return m_pure;};

        TypeList& parameter() {return m_parameter;};

        Type* returnType() const {return m_returnType;};

        FunctionKind functionType() const {return m_functionType;};

        void addParameterType(Type* aType) {m_parameter.push_back(aType);};

        void setReturnType(Type* aType) {m_returnType = aType;};

        void setMiracleSafe(bool newValue) {

                if (m_miracleSafe == nullptr)

                        m_miracleSafe = new bool();

                *m_miracleSafe = newValue;

        }

        void setIsStatic(bool isStatic) {m_static = isStatic;}

        void setIsPureFunction(bool newValue) {m_pure = newValue;}

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

};

}