cBitArray.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cBitArray_H
#define _INC_cBitArray_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "GrayCore/include/cUnitTestDecl.h"
#include "GrayCore/include/cArray.h"
#include "GrayCore/include/cBits.h"
#include "GrayCore/include/HResult.h"
 
namespace Gray
{
        DECLARE_INTERFACE(IRandomNoise);
}
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cBitArray);
 
        class GRAYLIB_LINK cBitArrayStatic : public cBits
        {
 
                typedef cBitArrayStatic THIS_t;
 
        public:
                // Get the largest integral integer type. like INTMAX_t but for atomic instructions.
#if defined(USE_64BIT)
                typedef UINT64 BLOCK_t;         
                typedef INT64 BLOCKI_t;         
                typedef UINT32 BLOCKH_t;        
#elif defined(_WIN16)
                typedef UINT16 BLOCK_t;         
                typedef INT16 BLOCKI_t;         
                typedef BYTE BLOCKH_t;          
#else   // else assume we are 32 bit architecture
                typedef UINT32 BLOCK_t;         
                typedef INT32 BLOCKI_t;         
                typedef WORD BLOCKH_t;          
#endif
 
                // On some architectures we can even do some double sized math. Though its not fully consistent and optimal.
#if defined(USE_64BIT)
 
#if ( defined(__MSC_VER) && ( defined(_M_AMD64) || defined(_M_X64) || defined(_M_IA64)))
                // There is no __MSC_VER 128 bit type.
#endif
 
#if ( defined(__GNUC__) && ( \
          defined(__amd64__) || defined(__x86_64__)    || \
          defined(__ppc64__) || defined(__powerpc64__) || \
          defined(__ia64__)  || defined(__alpha__)     || \
          (defined(__sparc__) && defined(__arch64__))  || \
          defined(__s390x__) ) )
                typedef unsigned int BLOCKDBL_t __attribute__((mode(TI)));      // 128 bit type.
#define GRAY_BLOCK_UDBL
#endif
 
#elif defined(_WIN16)
                typedef UINT32 BLOCKD_t;        // assume all 16 bit systems do 32 bit types.
#define GRAY_BLOCK_UDBL
#else   // else assume we are 32 bit architecture
#ifdef USE_INT64        // assume all 32 bit systems do 64 bit types ?
                typedef UINT64 BLOCKDBL_t;
#define GRAY_BLOCK_UDBL
#endif
#endif
 
                typedef unsigned int BLOCK_ENUM_t;      
                static const BLOCK_ENUM_t k_BLOCK_MAX = 8096;   
                static const size_t k_SIZE_MAX = k_BLOCK_MAX * sizeof(BLOCK_t);
                static const BIT_ENUM_t k_BIT_MAX = k_SIZE_MAX * 8;
 
                static const cBitArrayStatic k_Zero; // (0, nullptr, true)
                static const BLOCK_t k_OneBlock = 1;
 
                static const BIT_ENUM_t k_BLOCK_BITS = (BIT_ENUM_t)(sizeof(BLOCK_t) * 8);       
                static const BIT_ENUM_t k_BLOCKH_BITS = (BIT_ENUM_t)(sizeof(BLOCKH_t) * 8);     
 
        private:
                bool m_bStatic;                         
                BLOCK_ENUM_t m_nBlocks;     
                BLOCK_t* m_pBlocks;                     
 
        public:
                static inline BLOCK_ENUM_t GetBlocksFromBits(BIT_ENUM_t nBits) noexcept
                {
#define BLOCKS_FROM_BITS(nBits)  ((cBitArrayStatic::BLOCK_ENUM_t)(((nBits) + (cBitArrayStatic::k_BLOCK_BITS - 1)) / cBitArrayStatic::k_BLOCK_BITS))     // Macro for use in array sizing.
                        return BLOCKS_FROM_BITS(nBits);
                }
                static inline BLOCK_ENUM_t GetBlocksFromBytes(size_t nBytes) noexcept
                {
                        return (BLOCK_ENUM_t)((nBytes + (sizeof(BLOCK_t) - 1)) / sizeof(BLOCK_t));
                }
                static inline bool IsReasonableBlockQty(BLOCK_ENUM_t nBlocks) noexcept
                {
                        return IS_INDEX_GOOD(nBlocks, k_BLOCK_MAX);
                }
 
        protected:
                inline bool IsValidBlockIndex(BLOCK_ENUM_t i) const noexcept
                {
                        return IS_INDEX_GOOD(i, m_nBlocks);
                }
 
                void SetBlockSizeReAlloc(BLOCK_ENUM_t nBlocksNew);
                void SetBlockSizeUninit(BLOCK_ENUM_t nBlocksNew);
                void SetBlockSizeGrow(BLOCK_ENUM_t nBlocksNew);
 
                BLOCK_ENUM_t FindUsedBlocksQty(BLOCK_ENUM_t nBlocks) const
                {
                        while (nBlocks > 0 && GetBlockInt(nBlocks - 1) == 0)
                                nBlocks--;
                        return nBlocks;
                }
                BLOCK_ENUM_t FindUsedBlocksQty() const
                {
                        return FindUsedBlocksQty(get_BlocksCap());
                }
 
        public:
                cBitArrayStatic() noexcept
                        : m_bStatic(false)
                        , m_nBlocks(0)
                        , m_pBlocks(nullptr)
                {
                }
                explicit cBitArrayStatic(BIT_ENUM_t nBits)
                        : m_bStatic(false)
                        , m_nBlocks(GetBlocksFromBits(nBits))
                {
                        m_pBlocks = new BLOCK_t[m_nBlocks];
                        SetZeroAll();
                }
                cBitArrayStatic(BIT_ENUM_t nBits, BLOCK_t uValueMask)
                        : m_bStatic(false)
                        , m_nBlocks(GetBlocksFromBits(nBits))
                {
                        ASSERT(IsReasonableBlockQty(m_nBlocks));
                        m_pBlocks = new BLOCK_t[m_nBlocks];
                        if (m_nBlocks > 0)
                        {
                                m_pBlocks[0] = uValueMask;
                                cValArray::FillQty<BLOCK_t>(m_pBlocks + 1, m_nBlocks - 1, 0);
                        }
                }
                cBitArrayStatic(BLOCK_ENUM_t nBlocks, const BLOCK_t* pData)
                        : m_bStatic(false)
                        , m_nBlocks(nBlocks)
                        , m_pBlocks(new BLOCK_t[nBlocks])
                {
                        // copy data.
                        ASSERT(IsReasonableBlockQty(m_nBlocks));
                        cValArray::CopyQty<BLOCK_t>(m_pBlocks, pData, nBlocks);
                }
                cBitArrayStatic(BLOCK_ENUM_t nBlocks, const BLOCK_t* pBlocksInit, bool bStatic)
                        : m_bStatic(true)
                        , m_nBlocks(nBlocks)
                        , m_pBlocks(const_cast<BLOCK_t*>(pBlocksInit))
                {
                        // static data init.
                        ASSERT(bStatic);        // MUST be true
                        ASSERT(IsReasonableBlockQty(m_nBlocks));
                        ASSERT((m_nBlocks > 0) ^ (m_pBlocks == nullptr));
                }
 
                cBitArrayStatic(const THIS_t& ref)
                        : m_bStatic(ref.m_bStatic)
                        , m_nBlocks(ref.m_nBlocks)
                        , m_pBlocks(ref.m_bStatic ? ref.m_pBlocks : (new BLOCK_t[ref.m_nBlocks]))
                {
                        // copy constructor. like SetCopyBits
                        ASSERT(IsReasonableBlockQty(m_nBlocks));
                        if (!m_bStatic)
                        {
                                cValArray::CopyQty<BLOCK_t>(m_pBlocks, ref.m_pBlocks, m_nBlocks);
                        }
                        else
                        {
                                ASSERT((m_nBlocks > 0) ^ (m_pBlocks == nullptr));
                        }
                }
                cBitArrayStatic(THIS_t&& ref) noexcept
                        : m_bStatic(ref.m_bStatic)
                        , m_nBlocks(ref.m_nBlocks)
                        , m_pBlocks(ref.m_pBlocks)
                {
                        DEBUG_CHECK(&ref != this);
                        ref.m_bStatic = false;
                        ref.m_nBlocks = 0;
                        ref.m_pBlocks = nullptr;
                }
                ~cBitArrayStatic()
                {
                        SetNullVal();
                }
 
                inline bool isNullVal() const noexcept
                {
                        // isEmptyBits
                        return m_pBlocks == nullptr;
                }
                inline bool isZeroVal() const noexcept
                {
                        // Is null or zero.
                        return isNullVal() || (m_nBlocks <= 0);
                }
                inline BLOCK_ENUM_t get_BlocksCap() const noexcept
                {
                        return m_nBlocks;
                }
                inline size_t get_BytesCap() const noexcept
                {
                        return m_nBlocks * sizeof(BLOCK_t);
                }
                BLOCK_t GetBlockInt(BLOCK_ENUM_t i) const
                {
                        ASSERT(IsValidBlockIndex(i));
                        return m_pBlocks[i];
                }
                const BLOCK_t* get_BlockPtrC() const noexcept
                {
                        return m_pBlocks;
                }
                BLOCK_t* get_BlockPtr()
                {
                        ASSERT(!isReadOnly()); // never allowed for read only values.
                        return m_pBlocks;
                }
                BLOCK_t& RefBlockInt(BLOCK_ENUM_t i)
                {
                        ASSERT(!isReadOnly());
                        ASSERT(IsValidBlockIndex(i));
                        return m_pBlocks[i];
                }
 
                UINT32 GetU32Int(BLOCK_ENUM_t j) const
                {
#if defined(USE_64BIT)  // 64 bit
#ifdef USE_LITTLE_ENDIAN
                        ASSERT(IsValidBlockIndex(j / 2));
                        return ((const UINT32*)m_pBlocks)[j];
#else
                        BLOCK_t v = GetBlockInt(j / 2);
                        return (j & 1) ? (v >> 32) : ((UINT32)v);
#endif
#else
                        return GetBlockInt(j);
#endif
                }
                void SetU32Int(BLOCK_ENUM_t j, UINT32 val32)
                {
#if defined(USE_64BIT)  // 64 bit
                        ASSERT(!isReadOnly());
#ifdef USE_LITTLE_ENDIAN
                        ASSERT(IsValidBlockIndex(j / 2));
                        ((UINT32*)m_pBlocks)[j] = val32;
#else
                        // Fix big endian problem.
                        BLOCK_ENUM_t i = j / 2;
                        BLOCK_t v = GetBlockInt(i);
                        if (j & 1)
                        {
                                v &= 0x00000000FFFFFFFF;
                                v |= ((BLOCK_t)val32) << 32;
                        }
                        else
                        {
                                v &= 0xFFFFFFFF00000000;
                                v |= val32;
                        }
                        m_pBlocks[i] = v;
#endif
#else
                        RefBlockInt(j) = val32;
#endif 
                }
 
                const THIS_t& operator = (const THIS_t& ref)
                {
                        SetCopyBits(ref);
                        return *this;
                }
                THIS_t& operator = (THIS_t&& ref)
                {
                        m_bStatic = ref.m_bStatic;
                        m_nBlocks = ref.m_nBlocks;
                        m_pBlocks = ref.m_pBlocks;
                        ref.m_pBlocks = nullptr;
                        ref.m_bStatic = false;
                        ref.m_nBlocks = 0;
                        return *this;
                }
 
                bool isStatic() const noexcept
                {
                        return m_bStatic;
                }
                void SetBlocksStatic(BLOCK_ENUM_t nBlocks, const BLOCK_t* pBlocks);
 
                bool isReadOnly() const noexcept
                {
                        return false;
                }
                BIT_ENUM_t get_BitsCap() const noexcept
                {
                        return((BIT_ENUM_t)(get_BlocksCap() * k_BLOCK_BITS));
                }
                bool IsValidBit(BIT_ENUM_t nBit) const noexcept
                {
                        return IS_INDEX_GOOD(nBit, get_BitsCap());
                }
 
                bool IsSet(BIT_ENUM_t nBit) const
                {
                        BLOCK_ENUM_t nBlock = nBit / k_BLOCK_BITS;
                        if (!IsValidBlockIndex(nBlock))
                                return false;
                        return cBits::IsSet(GetBlockInt(nBlock), nBit % k_BLOCK_BITS);
                }
                bool isOdd() const
                {
                        if (m_nBlocks <= 0)
                                return false;
                        return(m_pBlocks[0] & 1);
                }
 
                void ClrBit(BIT_ENUM_t nBit)
                {
                        BLOCK_ENUM_t nBlock = nBit / k_BLOCK_BITS;
                        if (!IsValidBlockIndex(nBlock))         // just ignore this clear.
                                return;
                        RefBlockInt(nBlock) &= ~(cBits::Mask1<BLOCK_t>(nBit % k_BLOCK_BITS));
                }
                void SetBit(BIT_ENUM_t nBit)
                {
                        BLOCK_ENUM_t nBlock = nBit / k_BLOCK_BITS;
                        RefBlockInt(nBlock) |= cBits::Mask1<BLOCK_t>(nBit % k_BLOCK_BITS);
                }
                bool SetBitRet(BIT_ENUM_t nBit);
                void ModBit(BIT_ENUM_t nBit, bool bVal)
                {
                        if (bVal)
                                SetBit(nBit);
                        else
                                ClrBit(nBit);
                }
 
                void SetNullVal() noexcept;
                void SetZeroAll()
                {
                        ASSERT(!isReadOnly());
                        cValArray::ZeroQty<BLOCK_t>(get_BlockPtr(), get_BlocksCap());
                }
                void SetAll1()
                {
                        ASSERT(!isReadOnly());
                        ::memset(get_BlockPtr(), 0xFF, get_BlocksCap() * sizeof(BLOCK_t));
                }
 
                void SetBitsSizeZ(BIT_ENUM_t nBits)
                {
                        SetBlockSizeUninit(GetBlocksFromBits(nBits));
                        SetZeroAll();
                }
 
                void SetInvertBytes(size_t nSize);
                void SetCopyBits(const THIS_t& ref);
        };
 
        class GRAYLIB_LINK cBitArray : public cBitArrayStatic
        {
 
                typedef cBitArray THIS_t;
                typedef cBitArrayStatic SUPER_t;
 
        protected:
                BLOCK_ENUM_t m_nBlocksUse;      
 
        public:
                bool isHighBlockUseExact() const
                {
                        return FindUsedBlocksQty() == m_nBlocksUse;
                }
                bool isHighBlockUseValid() const
                {
                        return FindUsedBlocksQty() <= m_nBlocksUse;
                }
                BLOCK_ENUM_t get_BlocksUse() const
                {
#if 0
                        BLOCK_ENUM_t nBlocksUse = FindUsedBlocksQty();
                        DEBUG_ASSERT(nBlocksUse == m_nBlocksUse, __FUNCTION__); // m_nBlocksUse Accurate?
                        return nBlocksUse;
#else
                        ASSERT(isHighBlockUseValid());
                        return m_nBlocksUse;
#endif
                }
                void UpdateBlocksUse()
                {
                        while (m_nBlocksUse > 0 && GetBlockInt(m_nBlocksUse - 1) == 0)
                                m_nBlocksUse--;
                        DEBUG_ASSERT(isHighBlockUseExact(), __FUNCTION__);      // Accurate?
                }
                void UpdateBlocksUseMax(BLOCK_ENUM_t nBlocksUseMax)
                {
                        DEBUG_ASSERT(nBlocksUseMax <= get_BlocksCap(), __FUNCTION__);
                        m_nBlocksUse = nBlocksUseMax;
                        UpdateBlocksUse();
                }
                void UpdateBlocksUseCap()
                {
                        m_nBlocksUse = get_BlocksCap();
                        UpdateBlocksUse();
                }
                BLOCK_t& RefBlock(BLOCK_ENUM_t nBlock)
                {
                        SetBlockSizeGrow(nBlock + 1);   // set m_nBlocksUse
                        return RefBlockInt(nBlock);
                }
 
        protected:
 
                void put_BlocksUse(BLOCK_ENUM_t nBlocksUse)
                {
                        m_nBlocksUse = nBlocksUse;
                        DEBUG_ASSERT(isHighBlockUseExact(), __FUNCTION__);      // Accurate?
                }
 
                BLOCK_t GetBlock(BLOCK_ENUM_t nBlock) const
                {
                        if (IS_INDEX_BAD(nBlock, m_nBlocksUse))
                                return 0;
                        return GetBlockInt(nBlock);
                }
                void AddBlockGrow(BLOCK_t nVal)
                {
                        if (nVal == 0)
                                return;
                        if (m_nBlocksUse >= get_BlocksCap())
                        {
                                SetBlockSizeReAlloc(m_nBlocksUse + 1);
                        }
                        RefBlockInt(m_nBlocksUse) = nVal;
                        m_nBlocksUse++;
                }
                void SetBlock(BLOCK_ENUM_t i, BLOCK_t nVal)
                {
                        if (nVal == 0)
                        {
                                if (IS_INDEX_BAD(i, m_nBlocksUse)) // If i >= m_nBlocksUse, no effect.
                                        return;
                                RefBlockInt(i) = 0;
                                UpdateBlocksUse();
                        }
                        else
                        {
                                RefBlock(i) = nVal;
                        }
                }
 
        public:
                cBitArray()
                        : m_nBlocksUse(0)
                {
                }
                explicit cBitArray(BIT_ENUM_t nBits)
                        : SUPER_t(nBits)
                        , m_nBlocksUse(0)
                {
                }
                cBitArray(BIT_ENUM_t nBits, BLOCK_t uValueMask)
                        : SUPER_t(nBits, uValueMask)
                        , m_nBlocksUse(uValueMask ? 1 : 0)
                {
                }
                cBitArray(BLOCK_ENUM_t nBlocks, const BLOCK_t* pBlocks)
                        : SUPER_t(nBlocks, pBlocks)
                {
                        m_nBlocksUse = nBlocks;
                        UpdateBlocksUse();
                }
                cBitArray(BLOCK_ENUM_t nBlocks, const BLOCK_t* pBlocks, bool bStatic)
                        : SUPER_t(nBlocks, pBlocks, bStatic)
                {
                        ASSERT(bStatic);
                        m_nBlocksUse = nBlocks; // Can we assume this won't change? isHighBlockUseValid()
                        UpdateBlocksUse();
                }
                ~cBitArray()
                {
                        DEBUG_ASSERT(isHighBlockUseValid(), __FUNCTION__);      // Accurate?
                }
 
                static HRESULT GRAYCALL ReturnError(HRESULT hRes, const char* pszMsg);
                void SetBlocksStatic(BLOCK_ENUM_t nBlocks, const BLOCK_t* pBlocks);
                void SetBlocksStatic(const cBitArrayStatic& b);
 
                HRESULT SetBlockSizeGrow(BLOCK_ENUM_t nBlocksNew);
                HRESULT SetBlockSizeShrink(BLOCK_ENUM_t nBlocksNew);
                void SetBlockSizeUse(BLOCK_ENUM_t nBlocksNew);
 
                bool IsEqual(const THIS_t& x) const
                {
                        BLOCK_ENUM_t nBlocks = get_BlocksUse();
                        if (nBlocks != x.get_BlocksUse()) // Definitely unequal.
                                return false;
                        return cValArray::IsEqualQty(get_BlockPtrC(), x.get_BlockPtrC(), nBlocks);
                }
                bool IsEqualU(BLOCK_t x) const
                {
                        BLOCK_ENUM_t nBlocks = get_BlocksUse();
                        if (nBlocks > 1) // Definitely unequal.
                                return false;
                        return GetBlockInt(0) == x;
                }
                bool operator ==(const THIS_t& x) const
                {
                        return IsEqual(x);
                }
                bool operator !=(const THIS_t& x) const
                {
                        return !IsEqual(x);
                }
 
                bool isEmptyBits() const
                {
                        return m_nBlocksUse == 0;
                }
 
                bool IsSet(BIT_ENUM_t nBit) const
                {
                        BLOCK_ENUM_t nBlock = nBit / k_BLOCK_BITS;
                        if (IS_INDEX_BAD(nBlock, m_nBlocksUse))
                                return false;
                        nBit %= k_BLOCK_BITS;
                        return cBits::IsSet(GetBlockInt(nBlock), nBit);
                }
 
                BIT_ENUM_t get_Lowest1Bit() const;
                BIT_ENUM_t get_Highest1Bit() const;
 
                BIT_ENUM_t get_Count1Bits() const
                {
                        BIT_ENUM_t nBits1 = 0;
                        for (BLOCK_ENUM_t nBlock = 0; nBlock < m_nBlocksUse; nBlock++)
                        {
                                nBits1 += cBits::Count1Bits(GetBlockInt(nBlock));
                        }
                        return nBits1;
                }
 
                //****************************************************
                // Modifiers.
 
                void SetBit(BIT_ENUM_t nBit)
                {
                        BLOCK_ENUM_t nBlock = nBit / k_BLOCK_BITS;
                        RefBlock(nBlock) |= cBits::Mask1<BLOCK_t>(nBit % k_BLOCK_BITS);
                }
                void ClrBit(BIT_ENUM_t nBit)
                {
                        BLOCK_ENUM_t nBlock = nBit / k_BLOCK_BITS;
                        if (IS_INDEX_BAD(nBlock, m_nBlocksUse))
                                return;
                        RefBlockInt(nBlock) &= ~(cBits::Mask1<BLOCK_t>(nBit % k_BLOCK_BITS));
                        UpdateBlocksUse();
                }
                void ModBit(BIT_ENUM_t nBit, bool bVal)
                {
                        if (bVal)
                                SetBit(nBit);
                        else
                                ClrBit(nBit);
                }
 
                void SetTruncateBits(BIT_ENUM_t nBits);
 
                HRESULT SetRandomBits(BIT_ENUM_t nBits, IRandomNoise* pRandom = nullptr);
                HRESULT SetRandomBitsLarge(BIT_ENUM_t nBits, IRandomNoise* pRandom = nullptr)
                {
                        if (nBits < 3 || nBits > k_BIT_MAX)
                                return E_INVALIDARG;
                        HRESULT hRes = SetRandomBits(nBits, pRandom);
                        SetBit(nBits - 1);
                        return hRes;
                }
 
                void SetCopyBits(const THIS_t& ref);
                HRESULT SetCopySecure(const THIS_t& val, bool assign);
                static HRESULT GRAYCALL SwapSecure(THIS_t& X, THIS_t& Y, bool swap);
 
                void SetZeroAll()
                {
                        // like SUPER_t::SetZeroAll
                        // Zero out the value but don't change the allocated size.
                        // Can't assume m_nBlocksUse is accurate. //  cValArray::FillQty<BLOCK_t>(get_BlockPtr(), m_nBlocksUse, 0);
                        SUPER_t::SetZeroAll();
                        m_nBlocksUse = 0;
                }
                void SetNullVal()
                {
                        // like SUPER_t::SetZeroAll but reallocates size.
                        m_nBlocksUse = 0;
                        SUPER_t::SetNullVal();
                }
 
                size_t get_BinarySize() const
                {
                        return cBits::GetSizeBytes(get_Highest1Bit());
                }
 
                HRESULT GetBinaryBE(BYTE* pOut, size_t nSizeOut) const;
                HRESULT GetBinaryBE(cHeapBlock& b) const;
                HRESULT SetBinaryBE(const BYTE* pData, size_t nSize);
                HRESULT SetBinaryLE(const BYTE* pData, size_t nSize);
 
                UNITTEST_FRIEND(cBitArray);
        };
 
        // macros for storing embedded constants for cBitArrayStatic::SetBlocksStatic() in as little space as possible.
        // build lists of cBitArray::BLOCK_t's from lists of BYTE's grouped by 8, 4 or 2
        // similar to CUINT64() but will break into 32 or 64 bits
        // Note: the constants are in little-endian order to be directly usable in cBitArray
 
#if defined(USE_64BIT) // 64-bits BLOCK_t
 
#define BLOCKS_FROM_BYTES( a, b, c, d, e, f, g, h ) \
        ( (cBitArray::BLOCK_t) a <<  0 ) |  \
        ( (cBitArray::BLOCK_t) b <<  8 ) |  \
        ( (cBitArray::BLOCK_t) c << 16 ) |  \
        ( (cBitArray::BLOCK_t) d << 24 ) |  \
        ( (cBitArray::BLOCK_t) e << 32 ) |  \
        ( (cBitArray::BLOCK_t) f << 40 ) |  \
        ( (cBitArray::BLOCK_t) g << 48 ) |  \
        ( (cBitArray::BLOCK_t) h << 56 )
 
#define BLOCK_FROM_BYTES( a, b, c, d )   BLOCKS_FROM_BYTES( a, b, c, d, 0, 0, 0, 0 )
 
#else   // else 32 bit int BLOCK_t.
 
#define BLOCK_FROM_BYTES( a, b, c, d )  \
        ( (cBitArray::BLOCK_t) a <<  0 ) |  \
        ( (cBitArray::BLOCK_t) b <<  8 ) |  \
        ( (cBitArray::BLOCK_t) c << 16 ) |  \
        ( (cBitArray::BLOCK_t) d << 24 )
 
#define BLOCKS_FROM_BYTES( a, b, c, d, e, f, g, h )  BLOCK_FROM_BYTES( a, b, c, d ), BLOCK_FROM_BYTES( e, f, g, h )
 
#endif // ! USE_64BIT
 
};
#endif // _INC_cBitArray_H