ByteOrder.h

Go to the documentation of this file.

/*
 * Copyright (C) 2015 Niek Linnenbank
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef __LIB_LIBSTD_BYTEORDER_H
#define __LIB_LIBSTD_BYTEORDER_H
 
#include "Types.h"
#include "MemoryBlock.h"
 
#ifndef __BYTE_ORDER__
#error "__BYTE_ORDER__ not defined"
#endif /* __BYTE_ORDER__ */
 
#ifndef __ORDER_LITTLE_ENDIAN__
#error "__ORDER_LITTLE_ENDIAN__ not defined"
#endif /* __ORDER_LITTLE_ENDIAN__ */
 
#if __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__
#error "This implementation only supports little-endian targets: define __BYTE_ORDER__ to __ORDER_LITTLE_ENDIAN__"
#endif
 
#define SWAP16(x) ((u16)(                   \
        (((u16)(x) & (u16)0x00ffU) << 8) |  \
        (((u16)(x) & (u16)0xff00U) >> 8)))
 
#define SWAP32(x) ((u32)(                          \
        (((u32)(x) & (u32)0x000000ffUL) << 24) |   \
        (((u32)(x) & (u32)0x0000ff00UL) <<  8) |   \
        (((u32)(x) & (u32)0x00ff0000UL) >>  8) |   \
        (((u32)(x) & (u32)0xff000000UL) >> 24)))
 
#define SWAP64(x) ((u64)(                          \
        (((u64)(x) & (u64)0x00000000000000ffUL) << 56) |   \
        (((u64)(x) & (u64)0x000000000000ff00UL) << 40) |   \
        (((u64)(x) & (u64)0x0000000000ff0000UL) << 24) |   \
        (((u64)(x) & (u64)0x00000000ff000000UL) <<  8) |   \
        (((u64)(x) & (u64)0x000000ff00000000UL) >>  8) |   \
        (((u64)(x) & (u64)0x0000ff0000000000UL) >> 24) |   \
        (((u64)(x) & (u64)0x00ff000000000000UL) >> 40) |   \
        (((u64)(x) & (u64)0xff00000000000000UL) >> 56)))
 
#define cpu_to_le64(x) ((le64)(u64)(x))
 
#define le64_to_cpu(x) ((u64)(le64)(x))
 
#define cpu_to_le32(x) ((le32)(u32)(x))
 
#define le32_to_cpu(x) ((u32)(le32)(x))
 
#define cpu_to_le16(x) ((le16)(u16)(x))
 
#define le16_to_cpu(x) ((u16)(le16)(x))
 
#define cpu_to_be64(x) ((be64)SWAP64((x)))
 
#define be64_to_cpu(x) SWAP64((u64)(be64)(x))
 
#define cpu_to_be32(x) ((be32)SWAP32((x)))
 
#define be32_to_cpu(x) SWAP32((u32)(be32)(x))
 
#define cpu_to_be16(x) ((be16)SWAP16((x)))
 
#define be16_to_cpu(x) SWAP16((u16)(be16)(x))
 
inline const u64 read64(const void *data)
{
    u64 value;
    MemoryBlock::copy(&value, data, sizeof(value));
    return value;
}
 
inline const u32 read32(const void *data)
{
    u32 value;
    MemoryBlock::copy(&value, data, sizeof(value));
    return value;
}
 
inline const u16 read16(const void *data)
{
    u16 value;
    MemoryBlock::copy(&value, data, sizeof(value));
    return value;
}
 
inline const u8 read8(const void *data)
{
    u8 value;
    MemoryBlock::copy(&value, data, sizeof(value));
    return value;
}
 
inline void write64(void *data, const u64 input)
{
    MemoryBlock::copy(data, &input, sizeof(input));
}
 
inline void write32(void *data, const u32 input)
{
    MemoryBlock::copy(data, &input, sizeof(input));
}
 
inline void write16(void *data, const u16 input)
{
    MemoryBlock::copy(data, &input, sizeof(input));
}
 
inline void write8(void *data, const u8 input)
{
    MemoryBlock::copy(data, &input, sizeof(input));
}
 
inline const u64 readLe64(const void *data)
{
    u64 value;
    MemoryBlock::copy(&value, data, sizeof(value));
    return le64_to_cpu(value);
}
 
inline const u32 readLe32(const void *data)
{
    u32 value;
    MemoryBlock::copy(&value, data, sizeof(value));
    return le32_to_cpu(value);
}
 
inline const u16 readLe16(const void *data)
{
    u16 value;
    MemoryBlock::copy(&value, data, sizeof(value));
    return le16_to_cpu(value);
}
 
inline const u64 readBe64(const void *data)
{
    u64 value;
    MemoryBlock::copy(&value, data, sizeof(value));
    return be64_to_cpu(value);
}
 
inline const u32 readBe32(const void *data)
{
    u32 value;
    MemoryBlock::copy(&value, data, sizeof(value));
    return be32_to_cpu(value);
}
 
inline const u16 readBe16(const void *data)
{
    u16 value;
    MemoryBlock::copy(&value, data, sizeof(value));
    return be16_to_cpu(value);
}
 
inline void writeLe64(void *data, const u64 input)
{
    const u64 value = cpu_to_le64(input);
    MemoryBlock::copy(data, &value, sizeof(value));
}
 
inline void writeLe32(void *data, const u32 input)
{
    const u32 value = cpu_to_le32(input);
    MemoryBlock::copy(data, &value, sizeof(value));
}
 
inline void writeLe16(void *data, const u16 input)
{
    const u16 value = cpu_to_le16(input);
    MemoryBlock::copy(data, &value, sizeof(value));
}
 
inline void writeBe64(void *data, const u64 input)
{
    const u64 value = cpu_to_be64(input);
    MemoryBlock::copy(data, &value, sizeof(value));
}
 
inline void writeBe32(void *data, const u32 input)
{
    const u32 value = cpu_to_be32(input);
    MemoryBlock::copy(data, &value, sizeof(value));
}
 
inline void writeBe16(void *data, const u16 input)
{
    const u16 value = cpu_to_be16(input);
    MemoryBlock::copy(data, &value, sizeof(value));
}
 
#endif /* __LIB_LIBSTD_BYTEORDER_H */