xrb_endian.hpp

// ///////////////////////////////////////////////////////////////////////////
// xrb_endian.hpp by Victor Dods, created 2005/05/14
// ///////////////////////////////////////////////////////////////////////////
// Unless a different license was explicitly granted in writing by the
// copyright holder (Victor Dods), this software is freely distributable under
// the terms of the GNU General Public License, version 2.  Any works deriving
// from this work must also be released under the GNU GPL.  See the included
// file LICENSE for details.
// ///////////////////////////////////////////////////////////////////////////

#if !defined (_XRB_ENDIAN_HPP_)
#define _XRB_ENDIAN_HPP_

#include "xrb.hpp"

// this file has functions which perform conversion to/from
// different endian values

namespace Xrb
{

namespace Endian
{
    enum Endianness
    {
        LITTLE = 0,
        BIG,

        // The machine's endianness is set from the value in config.h
#if defined(WORDS_BIGENDIAN)
        MACHINE = BIG,
#else // !defined(WORDS_BIGENDIAN)
        MACHINE = LITTLE,
#endif // !defined(WORDS_BIGENDIAN)

        // Serializer is set to the endianness of the omnipresent x86
        // architecture so that the machine-to-serializer and
        // serializer-to-machine are no-ops for the majoritory of machines.
        SERIALIZER = LITTLE
    };

    // ///////////////////////////////////////////////////////////////////////
    // byte-reordering functions
    // ///////////////////////////////////////////////////////////////////////

    inline void Switch1ByteWord (void *word)
    {
        ASSERT1(word != NULL);
        // nothing needs to be done
    }
    inline void Switch2ByteWord (void *word)
    {
        ASSERT1(word != NULL);
        Uint8 *bytes = static_cast<Uint8 *>(word);

        Uint8 temp   = *(bytes + 0);
        *(bytes + 0) = *(bytes + 1);
        *(bytes + 1) = temp;
    }
    inline void Switch4ByteWord (void *word)
    {
        ASSERT1(word != NULL);
        Uint8 *bytes = static_cast<Uint8 *>(word);

        Uint8 temp   = *(bytes + 0);
        *(bytes + 0) = *(bytes + 3);
        *(bytes + 3) = temp;

        temp         = *(bytes + 1);
        *(bytes + 1) = *(bytes + 2);
        *(bytes + 2) = temp;
    }
    inline void Switch8ByteWord (void *word)
    {
        ASSERT1(word != NULL);
        Uint8 *bytes = static_cast<Uint8 *>(word);

        Uint8 temp   = *(bytes + 0);
        *(bytes + 0) = *(bytes + 7);
        *(bytes + 7) = temp;

        temp         = *(bytes + 1);
        *(bytes + 1) = *(bytes + 6);
        *(bytes + 6) = temp;

        temp         = *(bytes + 2);
        *(bytes + 2) = *(bytes + 5);
        *(bytes + 5) = temp;

        temp         = *(bytes + 3);
        *(bytes + 3) = *(bytes + 4);
        *(bytes + 4) = temp;
    }

    // ///////////////////////////////////////////////////////////////////////
    // conversion between machine and big
    // ///////////////////////////////////////////////////////////////////////

    inline void ConvertMachineToBig1ByteWord (void *word)
    {
        #if MACHINE != BIG
            Switch1ByteWord(word);
        #endif
    }
    inline void ConvertBigToMachine1ByteWord (void *word)
    {
        #if MACHINE != BIG
            Switch1ByteWord(word);
        #endif
    }
    inline void ConvertMachineToBig2ByteWord (void *word)
    {
        #if MACHINE != BIG
            Switch2ByteWord(word);
        #endif
    }
    inline void ConvertBigToMachine2ByteWord (void *word)
    {
        #if MACHINE != BIG
            Switch2ByteWord(word);
        #endif
    }
    inline void ConvertMachineToBig4ByteWord (void *word)
    {
        #if MACHINE != BIG
            Switch4ByteWord(word);
        #endif
    }
    inline void ConvertBigToMachine4ByteWord (void *word)
    {
        #if MACHINE != BIG
            Switch4ByteWord(word);
        #endif
    }
    inline void ConvertMachineToBig8ByteWord (void *word)
    {
        #if MACHINE != BIG
            Switch8ByteWord(word);
        #endif
    }
    inline void ConvertBigToMachine8ByteWord (void *word)
    {
        #if MACHINE != BIG
            Switch8ByteWord(word);
        #endif
    }

    // ///////////////////////////////////////////////////////////////////////
    // conversion between machine and little
    // ///////////////////////////////////////////////////////////////////////

    inline void ConvertMachineToLittle1ByteWord (void *word)
    {
        #if MACHINE != LITTLE
            Switch1ByteWord(word);
        #endif
    }
    inline void ConvertLittleToMachine1ByteWord (void *word)
    {
        #if MACHINE != LITTLE
            Switch1ByteWord(word);
        #endif
    }
    inline void ConvertMachineToLittle2ByteWord (void *word)
    {
        #if MACHINE != LITTLE
            Switch2ByteWord(word);
        #endif
    }
    inline void ConvertLittleToMachine2ByteWord (void *word)
    {
        #if MACHINE != LITTLE
            Switch2ByteWord(word);
        #endif
    }
    inline void ConvertMachineToLittle4ByteWord (void *word)
    {
        #if MACHINE != LITTLE
            Switch4ByteWord(word);
        #endif
    }
    inline void ConvertLittleToMachine4ByteWord (void *word)
    {
        #if MACHINE != LITTLE
            Switch4ByteWord(word);
        #endif
    }
    inline void ConvertMachineToLittle8ByteWord (void *word)
    {
        #if MACHINE != LITTLE
            Switch8ByteWord(word);
        #endif
    }
    inline void ConvertLittleToMachine8ByteWord (void *word)
    {
        #if MACHINE != LITTLE
            Switch8ByteWord(word);
        #endif
    }

    // ///////////////////////////////////////////////////////////////////////
    // conversion between machine and given endianness
    // ///////////////////////////////////////////////////////////////////////

    inline void ConvertMachineToGiven1ByteWord (void *word, Endianness const endianness)
    {
        ASSERT2(endianness == LITTLE || endianness == BIG);
        if (MACHINE != endianness)
            Switch1ByteWord(word);
    }
    inline void ConvertGivenToMachine1ByteWord (Endianness const endianness, void *word)
    {
        ASSERT2(endianness == LITTLE || endianness == BIG);
        if (MACHINE != endianness)
            Switch1ByteWord(word);
    }
    inline void ConvertMachineToGiven2ByteWord (void *word, Endianness const endianness)
    {
        ASSERT2(endianness == LITTLE || endianness == BIG);
        if (MACHINE != endianness)
            Switch2ByteWord(word);
    }
    inline void ConvertGivenToMachine2ByteWord (Endianness const endianness, void *word)
    {
        ASSERT2(endianness == LITTLE || endianness == BIG);
        if (MACHINE != endianness)
            Switch2ByteWord(word);
    }
    inline void ConvertMachineToGiven4ByteWord (void *word, Endianness const endianness)
    {
        ASSERT2(endianness == LITTLE || endianness == BIG);
        if (MACHINE != endianness)
            Switch4ByteWord(word);
    }
    inline void ConvertGivenToMachine4ByteWord (Endianness const endianness, void *word)
    {
        ASSERT2(endianness == LITTLE || endianness == BIG);
        if (MACHINE != endianness)
            Switch4ByteWord(word);
    }
    inline void ConvertMachineToGiven8ByteWord (void *word, Endianness const endianness)
    {
        ASSERT2(endianness == LITTLE || endianness == BIG);
        if (MACHINE != endianness)
            Switch8ByteWord(word);
    }
    inline void ConvertGivenToMachine8ByteWord (Endianness const endianness, void *word)
    {
        ASSERT2(endianness == LITTLE || endianness == BIG);
        if (MACHINE != endianness)
            Switch8ByteWord(word);
    }
} // end of namespace endian

} // end of namespace Xrb

#endif // !defined(_XRB_ENDIAN_HPP_)

---