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

#include <ast/IAstVisitor.hpp>

#include <boost/format.hpp>

#include <iostream>

namespace Ast {

class IntType

        : public Type

{

protected:

        std::int64_t m_low;

        std::int64_t m_high;

        IntType(): Type(TypeKind::IntType), m_low (0), m_high(0) {}

        IntType(const IntType& toCopy):

                Type(toCopy),

                m_low (toCopy.m_low),

                m_high(toCopy.m_high)

        {}

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

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

public:

        friend class Ast;

        friend class Type;

        void init(TypeIdentifier* id, bool anonymousType, std::int64_t low, std::int64_t high)

        {

                Type::init(id,anonymousType);

                m_low = low;

                m_high = high;

        }

        int64_t rangeLow() const {return m_low;};

        int64_t rangeHigh() const {return m_high;};

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

        static bool firstTypeLessRange(IntType* first, IntType* second) {

                return first->m_low > second->m_low || first->m_high < second->m_high;

        }

        bool isSigned() override {return m_low < 0;}

        uint32_t bitwidth() override {

                if (m_low == INT64_MIN || m_high == INT64_MAX)

                        return 64;

                std::uint32_t result = 0;

                if (m_low < 0 && m_high > 0) {

                        std::uint32_t bitsforlow = (std::uint32_t) std::floor(std::log2(std::abs(m_low))) + 1;

                        std::uint32_t bitsforhigh = (std::uint32_t) std::floor(std::log2(std::abs(m_high))) + 1;

                        if (bitsforlow <= bitsforhigh)

                                result = bitsforhigh + 1; // we need one additional bit to represent the negative numbers

                        else

                                result = bitsforlow;      // positive values are included

                } else {

                        std::uint64_t maxAbs = (std::uint64_t) std::max(std::abs(m_low), std::abs(m_high));

                        result = (std::uint32_t) std::floor(std::log2(maxAbs)) + 1;

                }

                // check the result!

                if (isSigned()) {

                        std::int64_t maxVal = (std::int64_t)(((std::uint64_t)1 << result) - 1);

                        std::int64_t minVal = (std::int64_t)(((std::uint64_t)-1 << result));

                        if (maxVal < m_high) {

                                std::cout << " Error converting type (max wrong): "

                                                << " low: " << m_low

                                                << " high: " << m_high

                                                << " bits: " << result

                                                << std::endl;

                                abort();

                        }

                        if (minVal > m_low) {

                                std::cout << " Error converting type (min wrong): "

                                                << " low: " << m_low

                                                << " high: " << m_high

                                                << " bits: " << result

                                                << std::endl;

                                abort();

                        }

                } else {

                        std::uint64_t maxVal = (((std::uint64_t)1 << result)-1);

                        if (maxVal < (std::uint64_t)m_high) {

                                std::cout << " Error converting unsigned type (max wrong): "

                                                << " low: " << m_low

                                                << " high: " << m_high

                                                << " bits: " << result

                                                << std::endl;

                                abort();

                        }

                }

//                std::cout << " Mapping int type " << toString() << ": "

//                                << " low: " << m_low

//                                << " high: " << m_high

//                                << " bits: " << result

//                                << std::endl;

                return result;

        }

};

}