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 <string>

#include <base/TiresiasObject.hpp>

#include <ast/identifiers/TypeIdentifier.hpp>

#include <ast/AstElement.hpp>

#include <base/Exceptions.hpp>

namespace Ast {

/**

 * You must not change the assigned values as this

 * needs to be kept in sync with the definitions in Argos!

 */

enum class TypeKind : std::uint8_t

{

        IntType = 0,

        BoolType = 1,

        FloatType = 2,

        EnumeratedType = 3,

        ListType = 4,

        MapType = 5,

        QrType = 6,

        TupleType = 7,

        FunctionType = 8,

        OoActionSystemType = 9,

        OpaqueType = 10,

        Null = 11,

        Any = 12,

        ValuedEnumeratedType = 13,

        Pointer = 14, // used in backend only, to interface with the runtime

        TYPEKIND_LAST_ITEM = Pointer

};

#define TYPEKIND_NR_ITEMS ((std::uint8_t)TypeKind::TYPEKIND_LAST_ITEM + 1)

enum class TypeVMethod: std::uint8_t {

        Constr = 0,

        CopyConstr = 1,

        TYPEVMETHOD_LAST_ITEM = CopyConstr

};

#define TYPEVMETHOD_NR_ITEMS ((std::uint8_t)TypeVMethod::TYPEVMETHOD_LAST_ITEM + 1)

class Type

        : public AstElement

{

protected:

        typedef Type* (*ConstrPtr)();

        typedef Type* (*CopyConstrPtr)(const Type& toCopy);

        const TypeKind m_kind; // byte @ +2 byte

        bool  m_anonymousType; // byte @ +3

        TypeIdentifier* m_identifier = nullptr;

        Type(TypeKind kind):

                AstElement(AstNodeTypeEnum::type),

                m_kind(kind),

                m_anonymousType (false),

                m_identifier (nullptr)

        {};

        Type(const Type &toCopy):

                AstElement(AstNodeTypeEnum::type),

                m_kind(toCopy.m_kind),

                m_anonymousType (toCopy.m_anonymousType),

                m_identifier (toCopy.m_identifier)

        {};

        static Base::FuncPtr s_typeVmt [TYPEVMETHOD_NR_ITEMS][TYPEKIND_NR_ITEMS];

        static Type* createVirtual(TypeKind aType); // virtual constructor used by Ast

        static Type* createVirtual(const Type& toCopy); // virtual copy constructor used by Ast

public:

        friend class Ast;

        void init(TypeIdentifier* id, bool anonymousType) {

                m_identifier = id;

                m_anonymousType = anonymousType;

        }

        TypeKind kind() const {

                return m_kind;

        }

        TypeIdentifier* identifier() const {

                return m_identifier;

        }

        std::string toString() const;

        void setTypeIdentifier(TypeIdentifier* anId) {

                m_identifier = anId;

        }

        bool isAnonymousType() {

                return m_anonymousType;

        }

        void accept(IAstVisitor& visitor) override;

        static bool equal(Type* type1, Type* type2);

        virtual bool isSigned(){return false;}

        virtual uint32_t bitwidth(){throw new Base::NotImplementedException();}

        bool requiresCast(Type* targetType) {

                return bitwidth() != targetType->bitwidth() || isSigned() != targetType->isSigned();

        }

};

}