byteswap.h

Go to the documentation of this file.

/*  WFIO - the Wheefun IO Library
    Copyright (C) 2018  Phillip Kilgore

    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 <https://www.gnu.org/licenses/>.
    
    Additionally, you should have recieved a copy of the GNU Classpath 
    exception, which amends the license to generally permit linking against
    the software provided herein.
*/

#ifndef WFIO_BYTESWAP_H
#define WFIO_BYTESWAP_H

#include <wfio/type.h>

#ifdef WFIO_COMPILER_GCC
#define WFIO_INTRINSIC_SWAP_16_
#define WFIO_INTRINSIC_SWAP_32_
#define WFIO_INTRINSIC_SWAP_64_
#endif

/* 16-bit integers */

WFIO_INLINE wfio_sint16_t wfio_swapSI16(wfio_sint16_t src) {
    /* GCC has an intrinsic version of this, use it */
    #ifdef WFIO_COMPILER_GCC
    return __builtin_bswap16((wfio_sint16_t) src);
    #else
    register wfio_uint8_t tmp;
    register union {
        wfio_sint16_t w;
        wfio_sint8_t b[2];
    } pun;
    
    /* Now perform the swap */
    pun.w = src;
    tmp = pun.b[0];
    pun.b[0] = pun.b[1];
    pun.b[1] = tmp;
    
    return pun.w;
    #endif
}

WFIO_DLL void wfio_swapSI16V2(const wfio_sint16_t* src, wfio_sint16_t* dest, 
    size_t len);

WFIO_ALWAYS_INLINE void wfio_swapSI16V(wfio_sint16_t* buf, size_t len) {
    wfio_swapSI16V2(buf, buf, len);
}


WFIO_ALWAYS_INLINE wfio_sint16_t wfio_swapUI16(wfio_sint16_t src) {
    return (wfio_sint16_t) wfio_swapSI16((wfio_sint16_t) src);
}

WFIO_ALWAYS_INLINE void wfio_swapUI16V2(const wfio_sint16_t* src, wfio_sint16_t* dest, 
    size_t len) {
    wfio_swapSI16V2((wfio_sint16_t*) src, (wfio_sint16_t*) dest, len);
}

WFIO_ALWAYS_INLINE void wfio_swapUI16V(wfio_sint16_t* buf, size_t len) {
    wfio_swapSI16V2((wfio_sint16_t*) buf, (wfio_sint16_t*) buf, len);
}

/* 32-bit Integers */

#ifdef WFIO_INTRINSIC_SWAP_32_
#define WFIO_MAYBE_INLINE WFIO_ALWAYS_INLINE
#elif !defined(WFIO_DOXYGEN)
#define WFIO_MAYBE_INLINE WFIO_DLL
#endif

WFIO_MAYBE_INLINE wfio_sint32_t wfio_swapSI32(wfio_sint32_t src)
#ifdef WFIO_INTRINSIC_SWAP_32_
{
    #ifdef WFIO_COMPILER_GCC
    return __builtin_bswap32((wfio_sint32_t) src);
    #else
        return (wfio_swapSI16(src) << 16) |
            (wfio_swapSI16(src >> 16));
    #endif
}
#else
;
#endif

WFIO_DLL void wfio_swapSI32V2(const wfio_sint32_t* src, wfio_sint32_t* dest, 
    size_t len);

WFIO_ALWAYS_INLINE void wfio_swapSI32V(wfio_sint32_t* buf, size_t len) {
    wfio_swapSI32V2(buf, buf, len);
}

WFIO_ALWAYS_INLINE wfio_sint32_t wfio_swapUI32(wfio_sint32_t src) {
    return (wfio_sint32_t) wfio_swapSI32((wfio_sint32_t) src);
}

WFIO_ALWAYS_INLINE void wfio_swapUI32V2(const wfio_sint32_t* src, wfio_sint32_t* dest, 
    size_t len) {
    wfio_swapSI32V2((wfio_sint32_t*) src, (wfio_sint32_t*) dest, len);
}

WFIO_ALWAYS_INLINE void wfio_swapUI32V(wfio_sint32_t* buf, size_t len) {
    wfio_swapSI32V2((wfio_sint32_t*) buf, (wfio_sint32_t*) buf, len);
}

/* 64-bit Integers */

#ifdef WFIO_INTRINSIC_SWAP_64_
#define WFIO_MAYBE_INLINE WFIO_ALWAYS_INLINE
#elif !defined(WFIO_DOXYGEN)
#define WFIO_MAYBE_INLINE WFIO_DLL
#endif

WFIO_MAYBE_INLINE wfio_sint64_t wfio_swapSI64(wfio_sint64_t src)
#ifdef WFIO_INTRINSIC_SWAP_64_
{
    #ifdef WFIO_COMPILER_GCC
    return __builtin_bswap64((wfio_sint64_t) src);
    #else
        return (wfio_swapSI32(src) << 32) |
            (wfio_swapSI32(src >> 32));
    #endif
}
#else
;
#endif

WFIO_DLL void wfio_swapSI64V2(const wfio_sint64_t* src, 
    wfio_sint64_t* dest, size_t len);

WFIO_ALWAYS_INLINE void wfio_swapSI64V(wfio_sint64_t* buf, size_t len) {
    wfio_swapSI64V2(buf, buf, len);
}

WFIO_ALWAYS_INLINE wfio_sint64_t wfio_swapUI64(wfio_sint64_t src) {
    return (wfio_sint64_t) wfio_swapSI64((wfio_sint64_t) src);
}

WFIO_ALWAYS_INLINE void wfio_swapUI64V2(const wfio_sint64_t* src, 
    wfio_sint64_t* dest, size_t len) {
    wfio_swapSI64V2((wfio_sint64_t*) src, (wfio_sint64_t*) dest, len);
}

WFIO_ALWAYS_INLINE void wfio_swapUI64V(wfio_sint64_t* buf, size_t len) {
    wfio_swapSI64V2((wfio_sint64_t*) buf, (wfio_sint64_t*) buf, len);
}

#undef WFIO_MAYBE_INLINE

#endif