/* Authors: Aaron Graham (aaron.graham@unb.ca, aarongraham9@gmail.com),
 *           Jean-Philippe Legault (jlegault@unb.ca, jeanphilippe.legault@gmail.com),
 *            Alexandrea Demmings (alexandrea.demmings@unb.ca, lxdemmings@gmail.com) and
 *             Dr. Kenneth B. Kent (ken@unb.ca)
 *             for the Reconfigurable Computing Research Lab at the
 *              Univerity of New Brunswick in Fredericton, New Brunswick, Canada
 */

#ifndef INTERNAL_BITS_HPP
#define INTERNAL_BITS_HPP

#include <cstdint>
#include <string>
#include <algorithm>
#include <vector>
#include <bitset>
#include "rtl_utils.hpp"

typedef uint16_t veri_internal_bits_t;
// typedef VNumber<64> veri_64_t;
// typedef VNumber<32> veri_32_t;

template <typename T>
uint8_t get_veri_integer_limit()
{
    return (sizeof(T)*8);
}

#define _static_unused(x) namespace { constexpr auto _##x = x; }

#define unroll_1d(lut) { lut[_0], lut[_1], lut[_x], lut[_z] }
#define unroll_2d(lut) { unroll_1d(lut[_0]), unroll_1d(lut[_1]), unroll_1d(lut[_x]), unroll_1d(lut[_z]) }

#define unroll_1d_invert(lut) { l_not[lut[_0]], l_not[lut[_1]], l_not[lut[_x]], l_not[lut[_z]] }
#define unroll_2d_invert(lut) { unroll_1d_invert(lut[_0]), unroll_1d_invert(lut[_1]), unroll_1d_invert(lut[_x]), unroll_1d_invert(lut[_z]) }

namespace BitSpace {
    typedef uint8_t bit_value_t;

    constexpr veri_internal_bits_t _All_0 = static_cast<veri_internal_bits_t>(0x0000000000000000UL);
    constexpr veri_internal_bits_t _All_1 = static_cast<veri_internal_bits_t>(0x5555555555555555UL);
    constexpr veri_internal_bits_t _All_x = static_cast<veri_internal_bits_t>(0xAAAAAAAAAAAAAAAAUL);
    constexpr veri_internal_bits_t _All_z = static_cast<veri_internal_bits_t>(0xFFFFFFFFFFFFFFFFUL);

    constexpr bit_value_t _0 = 0x0;
    constexpr bit_value_t _1 = 0x1;
    constexpr bit_value_t _x = 0x2;
    constexpr bit_value_t _z = 0x3;

    /***                                                              
     * these are taken from the raw verilog truth tables so that the evaluation are correct.
     * only use this to evaluate any expression for the number_t binary digits.
     * reference: http://staff.ustc.edu.cn/~songch/download/IEEE.1364-2005.pdf
     * 
     *******************************************************/

    constexpr bit_value_t l_buf[4] = {
        /*	 0   1   x   z  <- a*/
            _0,_1,_x,_x
    };
    _static_unused(l_buf)

    constexpr bit_value_t l_not[4] = {
        /*   0   1   x   z 	<- a */
            _1,_0,_x,_x
    };
    _static_unused(l_not)

    constexpr bit_value_t is_unk[4] = {
        /*	 0   1   x   z  <- a*/
            _0,_0,_1,_1
    };
    _static_unused(is_unk)

    constexpr bit_value_t is_x_bit[4] = {
        /*	 0   1   x   z  <- a*/
            _0,_0,_1,_0
    };
    _static_unused(is_x_bit)

    constexpr bit_value_t is_z_bit[4] = {
        /*	 0   1   x   z  <- a*/
            _0,_0,_0,_1
    };
    _static_unused(is_z_bit)

    constexpr bit_value_t is_one_bit[4] = {
        /*	 0   1   x   z  <- a*/
            _0,_1,_0,_0
    };
    _static_unused(is_one_bit)

    constexpr bit_value_t is_zero_bit[4] = {
        /*	 0   1   x   z  <- a*/
            _1,_0,_0,_0
    };
    _static_unused(is_zero_bit)

    constexpr bit_value_t l_and[4][4] = {
        /* a  /	 0   1   x   z 	<-b */	
        /* 0 */	{_0,_0,_0,_0},	
        /* 1 */	{_0,_1,_x,_x},	
        /* x */	{_0,_x,_x,_x},	
        /* z */	{_0,_x,_x,_x}
    };
    _static_unused(l_and)

    constexpr bit_value_t l_nand[4][4] = unroll_2d_invert(l_and);
    _static_unused(l_nand)

    constexpr bit_value_t l_or[4][4] = {
        /* a  /	 0   1   x   z 	<-b */	
        /* 0 */	{_0,_1,_x,_x},	
        /* 1 */	{_1,_1,_1,_1},	
        /* x */	{_x,_1,_x,_x},	
        /* z */	{_x,_1,_x,_x}
    };
    _static_unused(l_or)

    constexpr bit_value_t l_nor[4][4] = unroll_2d_invert(l_or);
    _static_unused(l_nor)

    constexpr bit_value_t l_xor[4][4] = {
        /* a  /	 0   1   x   z 	<-b */	
        /* 0 */	{_0,_1,_x,_x},	
        /* 1 */	{_1,_0,_x,_x},	
        /* x */	{_x,_x,_x,_x},	
        /* z */	{_x,_x,_x,_x}
    };
    _static_unused(l_xor)

    constexpr bit_value_t l_xnor[4][4] = unroll_2d_invert(l_xor);
    _static_unused(l_xnor)

    /*****************************************************
     *  Tran NO SUPPORT FOR THESE YET 
     */
    constexpr bit_value_t l_notif1[4][4] = {
        /* in /	 0   1   x   z 	<-control */	
        /* 0 */	{_z,_1,_x,_x},
        /* 1 */	{_z,_0,_x,_x},
        /* x */	{_z,_x,_x,_x},
        /* z */	{_z,_x,_x,_x}
    };
    _static_unused(l_notif1)

    constexpr bit_value_t l_notif0[4][4] = {
        /* in /	 0   1   x   z 	<-control */	
        /* 0 */	{_1,_z,_x,_x},
        /* 1 */	{_0,_z,_x,_x},
        /* x */	{_x,_z,_x,_x},
        /* z */	{_x,_z,_x,_x}
    };
    _static_unused(l_notif0)

    constexpr bit_value_t l_bufif1[4][4] = {
        /* in /	 0   1   x   z 	<-control */	
        /* 0 */	{_z,_0,_x,_x},
        /* 1 */	{_z,_1,_x,_x},
        /* x */	{_z,_x,_x,_x},
        /* z */	{_z,_x,_x,_x}
    };
    _static_unused(l_bufif1)

    constexpr bit_value_t l_bufif0[4][4] = {
        /* in /	 0   1   x   z 	<-control */	
        /* 0 */	{_0,_z,_x,_x},
        /* 1 */	{_1,_z,_x,_x},
        /* x */	{_x,_z,_x,_x},
        /* z */	{_x,_z,_x,_x}
    };
    _static_unused(l_bufif0)

    /* cmos gates */
    constexpr bit_value_t l_rpmos[4][4] = {
        /* in /	 0   1   x   z 	<-control */	
        /* 0 */	{_0,_z,_x,_x},
        /* 1 */	{_1,_z,_x,_x},
        /* x */	{_x,_z,_x,_x},
        /* z */	{_z,_z,_z,_z}
    };
    _static_unused(l_rpmos)

    constexpr bit_value_t l_rnmos[4][4] = {
        /* in /	 0   1   x   z 	<-control */	
        /* 0 */	{_z,_0,_x,_x},
        /* 1 */	{_z,_1,_x,_x},
        /* x */	{_z,_x,_x,_x},
        /* z */	{_z,_z,_z,_z}
    };
    _static_unused(l_rnmos)

    constexpr bit_value_t l_nmos[4][4] = {
        /* in /	 0   1   x   z 	<-control */	
        /* 0 */	{_z,_0,_x,_x},
        /* 1 */	{_z,_1,_x,_x},
        /* x */	{_z,_x,_x,_x},
        /* z */	{_z,_z,_z,_z}
    };
    _static_unused(l_nmos)

    // see table 5-21 p:54 IEEE 1364-2005
    constexpr bit_value_t l_ternary[4][4] = {
        /* in /	 0   1   x   z 	<-control */	
        /* 0 */	{_0,_x,_x,_x},
        /* 1 */	{_x,_1,_x,_x},
        /* x */	{_x,_x,_x,_x},
        /* z */	{_x,_x,_x,_x}
    };
    _static_unused(l_ternary)

    /*****
     * these extend the library and simplify the process
     */
    /* helper */
    constexpr bit_value_t l_unk[4][4] = {
        /* in /	 0   1   x   z 	<-control */	
        /* 0 */	{_x,_x,_x,_x},
        /* 1 */	{_x,_x,_x,_x},
        /* x */	{_x,_x,_x,_x},
        /* z */	{_x,_x,_x,_x}
    };
    _static_unused(l_unk)

    constexpr bit_value_t l_case_eq[4][4] = {
        /* a  /	 0   1   x   z 	<-b */	
        /* 0 */	{_1,_0,_0,_0},	
        /* 1 */	{_0,_1,_0,_0},	
        /* x */	{_0,_0,_1,_0},	
        /* z */	{_0,_0,_0,_1}
    };
    _static_unused(l_case_eq)

    constexpr bit_value_t l_lt[4][4] = {
        /* a  /	 0   1   x   z 	<-b */	
        /* 0 */	{_0,_1,_x,_x},	
        /* 1 */	{_0,_0,_x,_x},	
        /* x */	{_x,_x,_x,_x},	
        /* z */	{_x,_x,_x,_x}
    };
    _static_unused(l_lt)

    constexpr bit_value_t l_gt[4][4] = {
        /* a  /	 0   1   x   z 	<-b */	
        /* 0 */	{_0,_0,_x,_x},	
        /* 1 */	{_1,_0,_x,_x},	
        /* x */	{_x,_x,_x,_x},	
        /* z */	{_x,_x,_x,_x}
    };
    _static_unused(l_gt)

    constexpr bit_value_t l_eq[4][4] = unroll_2d(l_xnor);
    _static_unused(l_eq)

    constexpr bit_value_t l_sum[4][4][4] = {
        /* c_in */ 
        /* 0 */ unroll_2d(l_xor),
        /* 1 */ unroll_2d(l_xnor),
        /* x */ unroll_2d(l_unk),
        /* z */ unroll_2d(l_unk)
    };
    _static_unused(l_sum)

    constexpr bit_value_t l_carry[4][4][4] = {
        /* c_in */
        /* 0 */ unroll_2d(l_and),
        /* 1 */ unroll_2d(l_or),
        /* x */ unroll_2d(l_ternary),
        /* z */ unroll_2d(l_ternary)
    };
    _static_unused(l_carry)

    constexpr bit_value_t l_half_carry[4][4] = unroll_2d(l_carry[_0]);
    _static_unused(l_half_carry)

    constexpr bit_value_t l_half_sum[4][4] = unroll_2d(l_sum[_0]);
    _static_unused(l_half_sum)

    static char bit_to_c(bit_value_t bit)
    {
        switch(bit)
        {
            case _0:    return '0';
            case _1:    return '1';
            case _z:    return 'z';
            default:    return 'x';
        }
    }

    static bit_value_t c_to_bit(char c)
    {
        switch(tolower(c))
        {
            case '0':   return _0;
            case '1':   return _1;
            case 'z':   return _z;
            default:    return _x;
        }
    }

    template<typename T>
    class BitFields
    {
    private :

        T bits = static_cast<T>(_All_x);

        template<typename Addr_t>
        size_t get_bit_location(Addr_t address)
        {
            size_t current_address = static_cast<size_t>(address);
            current_address %= this->size();
            current_address <<= 1;
            return current_address;
        }

    public :

        BitFields(bit_value_t init_v)
        {
            this->bits = static_cast<T>(
                (_0 == init_v)? _All_0:
                (_1 == init_v)? _All_1:
                (_z == init_v)? _All_z:
                                _All_x
            );
        } 
        
        template<typename Addr_t>
        bit_value_t get_bit(Addr_t address)
        {
            auto result = this->bits >> this->get_bit_location(address);
            result &= 0x3;

            return static_cast<bit_value_t>(result);
        }

        template<typename Addr_t>
        void set_bit(Addr_t address, bit_value_t value)
        {	
            size_t real_address = this->get_bit_location(address);

            T set_value = static_cast<T>(value);
            set_value = static_cast<T>(set_value << real_address);

            T mask = static_cast<T>(0x3);
            mask = static_cast<T>(mask << real_address);
            mask = static_cast<T>(~(mask));

            this->bits = static_cast<T>(this->bits & mask);
            this->bits = static_cast<T>(this->bits | set_value);
        }

        /**
         * get 16 real bit (8 verilog bits) as 8 bit (char)
         */
        template<typename Addr_t>
        char get_as_char(Addr_t address)
        {
            size_t start = (8*(address));
            size_t end = (8*(address+1))-1;
            char value = 0;
            for(size_t i = start; i <= end; i++)
            {
                value += (((this->get_bit(i))? 1: 0) << i);
            }
            
            return value;
        }

        static size_t size()
        {
            return (sizeof(T)<<2); // 8 bit in a byte, 2 bits for a verilog bits = 4 bits in a byte, << 2 = sizeof x 4
        }
    };

    // #define DEBUG_V_BITS

    /*****
     * we use large array since we process the bits in chunks
     */
    class VerilogBits
    {
    private:

        std::vector<BitFields<veri_internal_bits_t>> bits;
        size_t bit_size = 0;

        size_t to_index(size_t address)
        {
            return ( address / BitFields<veri_internal_bits_t>::size() );
        }

        size_t list_size()
        {
            return this->bits.size();
        }

    public:

        VerilogBits()
        {
            this->bit_size = 0;
            this->bits = std::vector<BitSpace::BitFields<veri_internal_bits_t>>();
        }

        VerilogBits(size_t data_size, bit_value_t value_in)
        {
            this->bit_size = data_size;
            this->bits = std::vector<BitSpace::BitFields<veri_internal_bits_t>>();

            size_t bitfield_count = (this->bit_size / BitFields<veri_internal_bits_t>::size()) +1;
            
            for(size_t i=0; i<bitfield_count; i++)
            {
                this->bits.push_back(BitSpace::BitFields<veri_internal_bits_t>(value_in));
            }
        }

        VerilogBits(VerilogBits *other)
        {
            this->bit_size = other->size();
            this->bits = other->get_internal_bitvector();
        }

        size_t size()
        {
            return this->bit_size;
        }

        std::vector<BitFields<veri_internal_bits_t>> get_internal_bitvector()
        {
            return this->bits;
        }

        BitFields<veri_internal_bits_t> *get_bitfield(size_t index)
        {

    #ifdef DEBUG_V_BITS
            if (index >= this->bits.size() )
            {
                std::cerr << "Bit array indexing out of bounds " << index << " but size is " << this->bit_size  << std::endl;
                std::abort();
            }
    #endif

            return (&this->bits[index]);
        }   

        bit_value_t get_bit(size_t address)
        {
    #ifdef DEBUG_V_BITS
            if (address >= this->bit_size )
            {
                std::cerr << "Bit index array out of bounds " << address << " but size is " << this->bit_size  << std::endl;
                std::abort();
            }
    #endif

            return (this->get_bitfield(to_index(address))->get_bit(address));
        }

        void set_bit(size_t address, bit_value_t value)
        {
    #ifdef DEBUG_V_BITS
            if (address >= this->bit_size )
            {
                std::cerr << "Bit index array out of bounds " << address << " but size is " << this->bit_size  << std::endl;
                std::abort();
            }
    #endif
            (this->get_bitfield(to_index(address))->set_bit(address, value));
        }

        std::string to_string(bool big_endian)
        {
            // make a big endian string
            std::string to_return = "";
            for(size_t address=0x0; address < this->size(); address++)
            {
                char value = BitSpace::bit_to_c(this->get_bit(address));
                if(big_endian)
                {
                    to_return.push_back(value);
                }
                else
                {
                    to_return.insert(0,1,value);
                }
            }

            return to_return;              
        }

        std::string to_printable()
        {
            std::string to_return = "";

            for(size_t i=0; i< this->size(); i += 8)
            {
                to_return.insert(0,1,this->get_bitfield(to_index(i))->get_as_char(i));
            }

            return to_return;              
        }

        bool has_unknowns()
        {
            for(size_t address=0x0; address < this->size(); address++)
            {
                if(is_unk[this->get_bit(address)])
                    return true;                
            }
            
            return false;
        }

        bool is_only_z()
        {
            for(size_t address=0x0; address < this->size(); address++)
            {
                if(! is_z_bit[this->get_bit(address)])
                    return false;                
            }
            
            return true;
        }

        bool is_only_x()
        {
            for(size_t address=0x0; address < this->size(); address++)
            {
                if(! is_x_bit[this->get_bit(address)])
                    return false;               
            }
            
            return true;
        }

        bool is_true()
        {
            for(size_t address=0x0; address < this->size(); address++)
            {
                if(is_one_bit[this->get_bit(address)])
                    return true;               
            }
            
            return false; 
        }

        bool is_false()
        {
            for(size_t address=0x0; address < this->size(); address++)
            {
                if(! is_zero_bit[this->get_bit(address)])
                    return false;               
            }
            
            return true; 
        }

        /**
         * Unary Reduction operations
         * This is Msb to Lsb on purpose, as per specs
         */
        VerilogBits bitwise_reduce(const bit_value_t lut[4][4])
        {

            bit_value_t result = this->get_bit(this->size()-1);
            for(size_t i=this->size()-2; i < this->size(); i--)
            {
                result = lut[result][this->get_bit(i)];
            }

            return VerilogBits(1, result);
        }

        VerilogBits invert()
        {
            VerilogBits other(this->bit_size, _0);

            for(size_t i=0; i<this->size(); i++)
                other.set_bit(i, BitSpace::l_not[this->get_bit(i)]);
                        
            return other;
        }

        VerilogBits twos_complement()
        {
            BitSpace::bit_value_t previous_carry = BitSpace::_1;
            VerilogBits other(this->bit_size, _0);

            for(size_t i=0; i<this->size(); i++)
            {
                BitSpace::bit_value_t not_bit_i = BitSpace::l_not[this->get_bit(i)];

                other.set_bit(i,BitSpace::l_half_sum[previous_carry][not_bit_i]);
                previous_carry = BitSpace::l_half_carry[previous_carry][not_bit_i];
            }
                        
            return other;
        }

        /**
         * size of zero compact to the least amount of bits
         */
        VerilogBits resize(BitSpace::bit_value_t pad, size_t new_size)
        {

            /**
             * find the new size
             */
            if(new_size == 0)
            {

                size_t last_bit_id = this->size() - 1;
                size_t next_bit_id = last_bit_id -1;


                while(next_bit_id < this->size()-1)
                {
                    BitSpace::bit_value_t current = this->get_bit(last_bit_id);
                    BitSpace::bit_value_t next = this->get_bit(next_bit_id);
                    
                    if(current == next && current == pad)
                    {
                        last_bit_id--;
                        next_bit_id--;
                    }
                    else
                    {
                        break; /* it down. oh. oh! */
                    }

     
                }

                new_size = last_bit_id+1;
            }

            VerilogBits other(new_size, BitSpace::_0);

            size_t i = 0;

            while(i < this->size() && i < new_size)
            {
                other.set_bit(i, this->get_bit(i));
                i++;
            }

            while(i < new_size)
            {
                other.set_bit(i, pad);/* <- ask Eve about it */
                i++;
            }

            return other;
        }

        /**
         * replicates the bitset n times
         */
        VerilogBits replicate(size_t n_times)
        {
            size_t old_size = this->size();
            size_t new_size = old_size * n_times;

            VerilogBits other(new_size, BitSpace::_0);

            for(size_t i = 0; i < new_size; i += 1)
            {
                other.set_bit(i, this->get_bit( i%old_size ));
            }

            return other;
        }
    }; 
}

//template<size_t bit_size>
class VNumber 
{
private:
    bool sign = false;
    bool defined_size = false;
    BitSpace::VerilogBits bitstring = BitSpace::VerilogBits(1, BitSpace::_x);

    VNumber(BitSpace::VerilogBits other_bitstring, bool other_defined_size, bool other_sign)
    {
        bitstring = BitSpace::VerilogBits(other_bitstring);
        sign = other_sign;
        defined_size = other_defined_size;
    }

    VNumber insert(VNumber &other, size_t index_to_insert_at, size_t insertion_size)
    {
        assert_Werr(other.is_defined_size() && this->is_defined_size()
            ,"Size must be defined on both operand for insertion");

        VNumber new_bitstring(this->size() + insertion_size, BitSpace::_0, this->is_signed() && other.is_signed(), true);

        size_t index = 0;

        for(size_t i=0; i < this->size() && i < index_to_insert_at; i += 1, index +=1)
            new_bitstring.set_bit_from_lsb(index, this->get_bit_from_lsb( i ));

        for(size_t i=0; i < insertion_size; i += 1, index +=1)
            new_bitstring.set_bit_from_lsb(index, other.get_bit_from_lsb( i ));

        for(size_t i=index_to_insert_at; i < this->size(); i += 1, index +=1)
            new_bitstring.set_bit_from_lsb(index, this->get_bit_from_lsb( i ));

        return new_bitstring; 
    }

public:

    VNumber()
    {
        this->sign = false;
        this->bitstring = BitSpace::VerilogBits(1, BitSpace::_x);
        this->defined_size = false;
    }

    VNumber(VNumber&&) = default;
    VNumber& operator=(VNumber&&) = default;
    VNumber& operator=(const VNumber& other) = default;

    VNumber(const VNumber& other)
    {
        this->sign = other.sign;
        this->bitstring = other.bitstring;
        this->defined_size = other.defined_size;
    }

    VNumber(VNumber other, size_t length)
    {
        this->sign = other.sign;
        this->bitstring = other.bitstring.resize(other.get_padding_bit(),length);
        // TODO this->defined_size = true?????;
    }

    VNumber(const std::string& verilog_string)
    {
        set_value(verilog_string);
    }

    VNumber(int64_t numeric_value)
    {
        set_value(numeric_value);
    }

    VNumber(size_t len, BitSpace::bit_value_t initial_bits, bool input_sign, bool this_defined_size)
    {
        this->bitstring = BitSpace::VerilogBits(len, initial_bits);
        this->sign = input_sign;
        this->defined_size = this_defined_size;
    }
    
    /***
     * getters to 64 bit int
     */
    int64_t get_value()
    {
        using integer_t = int64_t;
        size_t bit_size = 8*sizeof(integer_t);

        assert_Werr( (! this->bitstring.has_unknowns() ) ,
                    "Invalid Number contains dont care values. number: " + this->bitstring.to_string(false)
        );   

        size_t end = this->size();
        if(end > bit_size)
        {
            printf(" === Warning: Returning a 64 bit integer from a larger bitstring (%zu). The bitstring will be truncated\n", bit_size);
            end = bit_size;
        }

        integer_t result = 0;
        BitSpace::bit_value_t pad = this->get_padding_bit(); // = this->is_negative();

        for(size_t bit_index = 0; bit_index < end; bit_index++)
        {
            integer_t current_bit = static_cast<integer_t>(pad);
            if(bit_index < this->size())
                current_bit = this->bitstring.get_bit(bit_index);

            result |= (current_bit << bit_index);
        }

        return result;
    }

    // convert lsb_msb bitstring to verilog
    std::string to_full_string()
    {
        std::string out = this->to_bit_string();
        size_t len = this->bitstring.size();

        return std::to_string(len) + ((this->is_signed())? "\'sb": "\'b") + out;
    }

    std::string to_bit_string()
    {
        std::string out = this->bitstring.to_string(false);
        return out;
    }

    std::string to_printable()
    {
        std::string out = this->bitstring.to_printable();
        return out;
    }

    /***
     * setters
     */
    void set_value(const std::string& input)
    {
        if(!input.size())
        {
            return;
        }

        std::string verilog_string(input);

        /**
         * set defaults
         */
        size_t bitsize = 32;            // 32 bit is the fall back
        this->defined_size = false;     // the size is undefined unless otherwise specified
        size_t radix = 0;              // the radix is unknown to start with
        this->sign = false;             // we treat everything as unsigned unless specified

        // if this is a string
        if(verilog_string[0] == '\"')
        {
            assert_Werr(verilog_string.size() >= 2,
                "Malformed input String for VNumber, only open quote" + verilog_string);

            assert_Werr(verilog_string.back() == '\"',
                "Malformed input String for VNumber, expected closing quotes" + verilog_string);

            verilog_string.erase(0,1);
            verilog_string.pop_back();

            size_t string_size = verilog_string.size();
            if(string_size == 0)
                string_size = 1;

            bitsize = string_size * 8;
            this->defined_size = true;
            radix = 256;
        }
        else
        {
            size_t loc = verilog_string.find("\'");
            if(loc == std::string::npos)
            {
                verilog_string.insert(0, "\'sd");
                loc = 0;
            }

            if(loc != 0)
            {
                std::string bit_length_char = verilog_string.substr(0, loc);
                bitsize = strtoul(bit_length_char.c_str(), nullptr, 10);
                this->defined_size = true;
            }

            if(std::tolower(verilog_string[loc+1]) == 's')
            {
                this->sign = true;
            }

            char base = static_cast<char>(std::tolower(verilog_string[loc+1+sign]));
            switch(base)
            {
                case 'b':   radix = 2;  break;  // binary
                case 'o':   radix = 8;  break;  // octal
                case 'd':   radix = 10; break;  // decimal
                case 'h':   radix = 16; break;  // hexadecimal
                default:    
                    assert_Werr( false,
                            "Invalid radix base for number: " + std::string(1,base)
                    ); 
                    break;
            }

            //remove underscores
            verilog_string = verilog_string.substr(loc+2+sign);
            verilog_string.erase(std::remove(verilog_string.begin(), verilog_string.end(), '_'), verilog_string.end());

            //little endian bitstring string
        }

        std::string temp_bitstring = string_of_radix_to_bitstring(verilog_string, radix);

        char pad = temp_bitstring[0];
        if(!this->sign && pad == '1')
        {
            pad = '0';
        }

        // convert the bits to the internal data struct (bit at index 0 in string is msb since string go from msb to lsb)
        BitSpace::VerilogBits new_bitstring(temp_bitstring.size(), BitSpace::_0);
        size_t counter = temp_bitstring.size()-1;
        for(char in: temp_bitstring)
        {
            new_bitstring.set_bit(counter--,BitSpace::c_to_bit(in));
        }
        
        this->bitstring = new_bitstring.resize(BitSpace::c_to_bit(pad), bitsize);
    }

    void set_value(int64_t in)
    {
        this->set_value(std::to_string(in));
    }

    size_t msb_index()
    {
        return this->bitstring.size()-1;
    }

    /****
     * bit twiddling functions
     */
    BitSpace::bit_value_t get_bit_from_msb(size_t index)
    {
        return this->bitstring.get_bit(msb_index()-index);
    }

    BitSpace::bit_value_t get_bit_from_lsb(size_t index)
    {
        if (index < this->size())
            return this->bitstring.get_bit(index);
        else
            return this->get_padding_bit();
    }

    void set_bit_from_msb(size_t index, BitSpace::bit_value_t val)
    {
        this->bitstring.set_bit(msb_index()-index, val);
    }

    void set_bit_from_lsb(size_t index, BitSpace::bit_value_t val)
    {
        this->bitstring.set_bit(index, val);
    }

    /***
     *  other
     */
    size_t size()
    {

        return this->bitstring.size();
    }
    
    BitSpace::bit_value_t get_padding_bit()
    {
        return this->is_negative()? BitSpace::_1:BitSpace::_0;
    }

    bool is_signed() const
    {
        return this->sign;
    }

    bool is_defined_size() 
    {
        return this->defined_size;
    }

    bool is_negative()
    {
        return ( this->get_bit_from_msb(0) == BitSpace::_1 && this->sign );
    }

    bool is_dont_care_string()
    {
        return this->bitstring.has_unknowns();
    }

    bool is_z()
    {
        return this->bitstring.is_only_z();
    }

    bool is_x()
    {
        return this->bitstring.is_only_x();
    }

    bool is_true()
    {
        return this->bitstring.is_true();
    }

    bool is_false()
    {
        return this->bitstring.is_false();
    }

    VNumber twos_complement()
    {
        return VNumber(this->bitstring.twos_complement(),this->defined_size,this->sign);
    }

    VNumber to_signed()
    {
        return VNumber(this->bitstring,this->defined_size,true);
    }

    VNumber to_unsigned()
    {
        return VNumber(this->bitstring,this->defined_size,false);
    }

    VNumber invert()
    {
        return VNumber(this->bitstring.invert(),this->defined_size,this->sign);
    }

    VNumber bitwise_reduce(const BitSpace::bit_value_t lut[4][4])
    {
        return VNumber(this->bitstring.bitwise_reduce(lut),this->defined_size,false);
    }

    /**
     * Binary Reduction operations
     */
    VNumber bitwise(VNumber& b, const BitSpace::bit_value_t lut[4][4])
    {
        size_t std_length = std::max(this->size(), b.size());
        const BitSpace::bit_value_t pad_a = this->get_padding_bit();
        const BitSpace::bit_value_t pad_b = b.get_padding_bit();

        VNumber result(std_length, BitSpace::_x, false, this->is_defined_size() && b.is_defined_size() );

        for(size_t i=0; i < result.size(); i++)
        {
            BitSpace::bit_value_t bit_a = pad_a;
            if(i < this->size())
                bit_a = this->get_bit_from_lsb(i);

            BitSpace::bit_value_t bit_b = pad_b;
            if(i < b.size())
                bit_b = b.get_bit_from_lsb(i);

            result.set_bit_from_lsb(i, lut[bit_a][bit_b]);
        }

        return result;
    }

    VNumber replicate(int64_t n_times_replicate)
    {

        assert_Werr(n_times_replicate > 0,
            "Cannot replicate bitstring less than 1 times");

        size_t n_times_unsigned = static_cast<size_t>(n_times_replicate);

        return VNumber(this->bitstring.replicate(n_times_unsigned),true,this->sign);
    }

    VNumber insert_at_lsb(VNumber &other)
    {
        return this->insert(other, 0, other.size());
    }

    VNumber insert_at_msb(VNumber &other)
    {
        return this->insert(other, this->size(), other.size());
    }
};

#endif