Skip to content

Commit

Permalink
In work. From this point we temporarly break bowtie functionality.
Browse files Browse the repository at this point in the history
  • Loading branch information
@val-antonescu
val-antonescu committed Mar 11, 2014
1 parent ec36352 commit 201e1da
Show file tree
Hide file tree
Showing 2 changed files with 110 additions and 86 deletions.
52 changes: 46 additions & 6 deletions endian_swap.h
View file
Expand Up @@ -3,6 +3,16 @@

#include <stdint.h>
#include <inttypes.h>
#include "assert_helpers.h"

#ifdef BOWTIE_64BIT_INDEX
# define endianSwapU(x) endianSwapU64(x)
# define endianSwapI(x) endianSwapI64(x)
#else
# define endianSwapU(x) endianSwapU32(x)
# define endianSwapI(x) endianSwapI32(x)
#endif


/**
* Return true iff the machine running this program is big-endian.
Expand Down Expand Up @@ -54,25 +64,55 @@ static inline int32_t endianSwapI32(int32_t i) {
}

/**
* Convert uint32_t argument to the specified endianness. It's assumed
* Return copy of int64_t argument with byte order reversed.
*/
static inline int64_t endianSwapI64(int64_t u) {
int64_t tmp = 0;
tmp |= ((u >> 56) & (0xffull << 0));
tmp |= ((u >> 40) & (0xffull << 8));
tmp |= ((u >> 24) & (0xffull << 16));
tmp |= ((u >> 8) & (0xffull << 24));
tmp |= ((u << 8) & (0xffull << 32));
tmp |= ((u << 24) & (0xffull << 40));
tmp |= ((u << 40) & (0xffull << 48));
tmp |= ((u << 56) & (0xffull << 56));
return tmp;
}

/**
* Convert uint32_t/uint64_t argument to the specified endianness. It's assumed
* that u currently has the endianness of the current machine.
*/
static inline uint32_t endianizeU32(uint32_t u, bool toBig) {
template <typename T>
static inline T endianizeU(T u, bool toBig) {
if(toBig == currentlyBigEndian()) {
return u;
}
return endianSwapU32(u);
if(sizeof(T) == 4) {
return endianSwapU32((uint32_t)u);
} else if(sizeof(T) == 8) {
return endianSwapU64((uint64_t)u);
} else {
assert(false);
}
}

/**
* Convert int32_t argument to the specified endianness. It's assumed
* Convert int32_t/int64_t argument to the specified endianness. It's assumed
* that u currently has the endianness of the current machine.
*/
static inline int32_t endianizeI32(int32_t i, bool toBig) {
template <typename T>
static inline T endianizeI(T i, bool toBig) {
if(toBig == currentlyBigEndian()) {
return i;
}
return endianSwapI32(i);
if(sizeof(T) == 4) {
return endianSwapI32((int32_t)i);
} else if(sizeof(T) == 8) {
return endianSwapI64((int64_t)i);
} else {
assert(false);
}
}

#endif
144 changes: 64 additions & 80 deletions word_io.h
View file
Expand Up @@ -9,131 +9,115 @@
#include "btypes.h"

/**
* Write a 32-bit unsigned to an output stream being careful to
* Write a 32/64 bit unsigned to an output stream being careful to
* re-endianize if caller-requested endianness differs from current
* host.
*/
static inline void writeU32(std::ostream& out, uint32_t x, bool toBigEndian) {
uint32_t y = endianizeU32(x, toBigEndian);
out.write((const char*)&y, 4);
template <typename T>
static inline void writeU(std::ostream& out, T x, bool toBigEndian) {
T y = endianizeU<T>(x, toBigEndian);
out.write((const char*)&y, sizeof(T));
}

/**
* Write a 32-bit unsigned to an output stream using the native
* Write a 32/64 bit unsigned to an output stream using the native
* endianness.
*/
static inline void writeU32(std::ostream& out, uint32_t x) {
out.write((const char*)&x, 4);
template <typename T>
static inline void writeU(std::ostream& out, T x) {
out.write((const char*)&x, sizeof(T));
}

/**
* Write a 32-bit signed int to an output stream being careful to
* Write a 32/64 bit signed int to an output stream being careful to
* re-endianize if caller-requested endianness differs from current
* host.
*/
static inline void writeI32(std::ostream& out, int32_t x, bool toBigEndian) {
int32_t y = endianizeI32(x, toBigEndian);
out.write((const char*)&y, 4);
template <typename T>
static inline void writeI(std::ostream& out, T x, bool toBigEndian) {
T y = endianizeI<T>(x, toBigEndian);
out.write((const char*)&y, sizeof(T));
}

/**
* Write a 32-bit unsigned to an output stream using the native
* Write a 32/64 bit unsigned to an output stream using the native
* endianness.
*/
static inline void writeI32(std::ostream& out, int32_t x) {
out.write((const char*)&x, 4);
template <typename T>
static inline void writeI(std::ostream& out, T x) {
out.write((const char*)&x, sizeof(T));
}

/**
* Read a 32-bit unsigned from an input stream, inverting endianness
* if necessary.
*/
static inline uint32_t readU32(std::istream& in, bool swap) {
uint32_t x;
in.read((char *)&x, 4);
assert_eq(4, in.gcount());
template <typename T>
static inline T readU(std::istream& in, bool swap) {
T x;
in.read((char *)&x, sizeof(T));
assert_eq(sizeof(T), in.gcount());
if(swap) {
return endianSwapU32(x);
if(sizeof(T) == 4) {
return endianSwapU32(x);
} else if(sizeof(T) == 8) {
return endianSwapU64(x);
} else {
assert(false);
}
} else {
return x;
}
}

/**
* Read a 32-bit unsigned from a file descriptor, optionally inverting
* endianness.
*/
static inline uint32_t readU32(int in, bool swap) {
uint32_t x;
if(read(in, (void *)&x, 4) != 4) {
assert(false);
}
if(swap) {
return endianSwapU32(x);
} else {
return x;
}
}

/**
* Read a 32-bit unsigned from a FILE*, optionally inverting
* endianness.
*/
static inline uint32_t readU32(FILE* in, bool swap) {
uint32_t x;
if(fread((void *)&x, 1, 4, in) != 4) {
template <typename T>
static inline T readU(FILE* in, bool swap) {
T x;
if(fread((void *)&x, 1, sizeof(T), in) != sizeof(T)) {
assert(false);
}
if(swap) {
return endianSwapU32(x);
} else {
return x;
}
}


/**
* Read a 32-bit signed from an input stream, inverting endianness
* if necessary.
*/
static inline int32_t readI32(std::istream& in, bool swap) {
int32_t x;
in.read((char *)&x, 4);
assert_eq(4, in.gcount());
if(swap) {
return endianSwapI32(x);
if(sizeof(T) == 4) {
return endianSwapU32(x);
} else if(sizeof(T) == 8) {
return endianSwapU64(x);
} else {
assert(false);
}
} else {
return x;
}
}

/**
* Read a 32-bit unsigned from a file descriptor, optionally inverting
* endianness.
*/
static inline uint32_t readI32(int in, bool swap) {
int32_t x;
if(read(in, (void *)&x, 4) != 4) {
assert(false);
}
template <typename T>
static inline T readI(std::istream& in, bool swap) {
T x;
in.read((char *)&x, sizeof(T));
assert_eq(sizeof(T), in.gcount());
if(swap) {
return endianSwapI32(x);
if(sizeof(T) == 4) {
return endianSwapI32(x);
} else if(sizeof(T) == 8) {
return endianSwapI64(x);
} else {
assert(false);
}
} else {
return x;
}
}

/**
* Read a 32-bit unsigned from a FILE*, optionally inverting
* endianness.
*/
static inline uint32_t readI32(FILE* in, bool swap) {
int32_t x;
if(fread((void *)&x, 1, 4, in) != 4) {
template <typename T>
static inline T readI(FILE* in, bool swap) {
T x;
if(fread((void *)&x, 1, sizeof(T), in) != sizeof(T)) {
assert(false);
}
if(swap) {
return endianSwapI32(x);
if(sizeof(T) == 4) {
return endianSwapI32(x);
} else if(sizeof(T) == 8) {
return endianSwapI64(x);
} else {
assert(false);
}
} else {
return x;
}
Expand Down

0 comments on commit 201e1da

Please sign in to comment.