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)

  *

  */

#include "Type.hpp"

#include <ast/types/IntType.hpp>

#include <ast/types/BoolType.hpp>

#include <ast/types/EnumType.hpp>

#include <ast/types/ListType.hpp>

#include <ast/types/TupleType.hpp>

#include <ast/types/FunctionType.hpp>

#include <ast/types/ActionSystemType.hpp>

#include <ast/types/NullType.hpp>

#include <ast/types/ValuedEnumType.hpp>

#include <ast/types/PointerType.hpp>

namespace Ast {

static void abstractError() {

        throw new Base::NotImplementedException();

}

Base::FuncPtr Type::s_typeVmt [TYPEVMETHOD_NR_ITEMS][TYPEKIND_NR_ITEMS] =

{

                // pointers to create methods, index 0

                {   /*IntType = 0*/        (Base::FuncPtr) &IntType::create,

                    /*BoolType = 1*/       (Base::FuncPtr) &BoolType::create,

                    /*FloatType = 2*/                      &abstractError,

                    /*EnumeratedType = 3*/ (Base::FuncPtr) &EnumType::create,

                    /*ListType = 4*/       (Base::FuncPtr) &ListType::create,

                    /*MapType = 5*/                        &abstractError,

                    /*QrType = 6*/                         &abstractError,

                    /*TupleType = 7*/      (Base::FuncPtr) &TupleType::create,

                    /*FunctionType = 8*/   (Base::FuncPtr) &FunctionType::create,

                    /*ActionSystemType= 9*/(Base::FuncPtr) &ActionSystemType::create,

                    /*OpaqueType = 10*/                    &abstractError,

                    /*Null = 11*/          (Base::FuncPtr) &NullType::create,

                    /*Any = 12*/                           &abstractError,

                    /*ValuedEnumeratedType = 13*/(Base::FuncPtr) &ValuedEnumType::create,

                    /*Pointer = 14*/       (Base::FuncPtr) &PointerType::create

                },

                // pointers to copy constructors, index 1

                {   /*IntType = 0*/        (Base::FuncPtr) &IntType::createCopy,

                    /*BoolType = 1*/       (Base::FuncPtr) &BoolType::createCopy,

                    /*FloatType = 2*/                      &abstractError,

                    /*EnumeratedType = 3*/ (Base::FuncPtr) &EnumType::createCopy,

                    /*ListType = 4*/       (Base::FuncPtr) &ListType::createCopy,

                    /*MapType = 5*/                        &abstractError,

                    /*QrType = 6*/                         &abstractError,

                    /*TupleType = 7*/      (Base::FuncPtr) &TupleType::createCopy,

                    /*FunctionType = 8*/   (Base::FuncPtr) &FunctionType::createCopy,

                    /*ActionSystemType= 9*/(Base::FuncPtr) &ActionSystemType::createCopy,

                    /*OpaqueType = 10*/                    &abstractError,

                    /*Null = 11*/          (Base::FuncPtr) &NullType::createCopy,

                    /*Any = 12*/                           &abstractError,

                    /*ValuedEnumeratedType = 13*/(Base::FuncPtr) &ValuedEnumType::createCopy,

                    /*Pointer = 14*/       (Base::FuncPtr) &PointerType::createCopy

                }

};

void Type::accept(IAstVisitor& ) {

        throw new Base::NotImplementedException();

};

std::string Type::toString() const {

        std::string result ("??");

        if (m_identifier != nullptr)

                result = m_identifier->tokenText();

        return result; // NRVO

}

Type* Type::createVirtual(TypeKind type) {

        return (std::uint8_t)type < TYPEKIND_NR_ITEMS ? ((ConstrPtr)s_typeVmt[0][(std::uint8_t)type])() : nullptr;

}

Type* Type::createVirtual(const Type& toCopy) {

        std::uint8_t kind ((std::uint8_t)toCopy.kind());

        return ((CopyConstrPtr)s_typeVmt[1][kind])(toCopy);

}

bool Type::equal(Type* type1, Type* type2)

{

        if ((type1 == nullptr) || (type2 == nullptr))

                return false;

        // if of different kind, then return false..

        TypeKind tk1 = type1->kind();

        TypeKind tk2 = type2->kind();

        if (tk1 != tk2)

                return false;

        // if same kind, make a rigorous check

        switch (tk1)

        {

                case TypeKind::IntType: {

                        IntType* intt1 = (IntType*)type1;

                        IntType* intt2 = (IntType*)type2;

                        return intt1->rangeLow() == intt2->rangeLow() && intt1->rangeHigh() == intt2->rangeHigh();

                }

                case TypeKind::BoolType:

                        return true;

//                case TypeKind::FloatType:

//                        FloatType* floatt1 = (FloatType*)type1;

//                        FloatType* floatt2 = (FloatType*)type2;

//                        return floatt1->low() == floatt2->low() &&

//                                        floatt1->high() == floatt2->high() &&

//                                        floatt1->precision() == floatt2->precision();

                case TypeKind::ValuedEnumeratedType:

                case TypeKind::EnumeratedType:

                        return type1 == type2; // ref equ

                case TypeKind::ListType: {

                        ListType* listt1 = (ListType*)type1;

                        ListType* listt2 = (ListType*)type2;

                        return equal(listt1->innerType(), listt2->innerType()) &&

                                listt1->maxNumberOfElements() == listt2->maxNumberOfElements(); // need this because of covertype

                }

//                case TypeKind::MapType:

//                        MapType* mapt1 = (MapType*)type1;

//                        MapType* mapt2 = (MapType*)type2;

//                        return equal(mapt1->fromType(), mapt2->fromType()) &&

//                                equal(mapt1->toType(), mapt2->toType()) &&

//                                mapt1->maxNumberOfElements() == mapt2->maxNumberOfElements(); // need this because of covertype

                case TypeKind::TupleType: {

                        TupleType* tuplet1 = (TupleType*)type1;

                        TupleType* tuplet2 = (TupleType*)type2;

                        if (tuplet1->innerTypes().size() != tuplet2->innerTypes().size())

                                return false;

                        auto innert1 = tuplet1->innerTypes().begin();

                        auto innert2 = tuplet2->innerTypes().begin();

                        while (innert1 != tuplet1->innerTypes().end())

                        {

                                if (!equal(*innert1, *innert2))

                                        return false;

                                innert1++;

                                innert2++;

                        }

                        return true;

                }

                case TypeKind::OoActionSystemType:

                        return type1 == type2;

                case TypeKind::Null:

                case TypeKind::Any:

                case TypeKind::Pointer:

                        return true;

                default: {

                        std::cerr << "Unknown type in type comparison. Aborting. " << (int) tk1 << std::endl;

                        abort();

                }

        }

}

}