binary.h

/*----------------------------------------------------------------------------*\
| PART OF THE CIRCUIT REWIND SOURCE CODE LIBRARY COLLECTION.                   |
| SOURCE:  https://github.com/circuitrewind/binary                             |
| LICENSE: https://github.com/circuitrewind/binary/blob/main/LICENSE           |
+------------------------------------------------------------------------------+
| SIMPLE STRUCTS/UNIONS FOR SWAPPING BETWEEN BIG AND LITTLE ENDIAN.            |
| ALL SWAPPING IS DONE IN-PLACE, SO NO ADDITIONAL RAM IS NEEDED.               |
| SWAPPING IS DONE VIA 3 INLINED XOR COMMANDS, KEEPING THE CODE FOOTPRINT VERY |
| SMALL AS WELL.                                                               |
+------------------------------------------------------------------------------+
| ADDITIONALLY, BIT FIELD, BYTE LISTS, AND MORE HAVE BEEN ADDED TO THESE.      |
| IF YOU NEED A SIMPLIFIED WAY TO ACCESS ARBITRARY BITS FROM A BYTE OR         |
| MULTI-BYTE DATA, THIS WILL BE ONE OF THE EASIEST WAYS TO DO IT.              |
\*----------------------------------------------------------------------------*/




#ifndef __binary_h__
#define __binary_h__




#include "inline.h"




#if defined(__clang__)
#	pragma clang diagnostic push
#	pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
#	pragma clang diagnostic ignored "-Wnested-anon-types"
#endif




////////////////////////////////////////////////////////////////////////////////
// BITFIELD - 8-BIT
////////////////////////////////////////////////////////////////////////////////
union PACKED uint8_b {
	INLINE uint8_b()				{ this->byte_0 = 0; }
	INLINE uint8_b(uint8_t byte)	{ this->byte_0 = byte; }
	INLINE uint8_b(uint8_t *byte)	{ this->byte_0 = byte[0]; }


	uint8_t byte[1];
	uint8_t byte_0;


	struct PACKED {
		union PACKED {
			unsigned int nibble_0		: 4;
			struct PACKED {
				unsigned int bit_0		: 1;
				unsigned int bit_1		: 1;
				unsigned int bit_2		: 1;
				unsigned int bit_3		: 1;
			};
		};
		union PACKED {
			unsigned int nibble_1		: 4;
			struct PACKED {
				unsigned int bit_4		: 1;
				unsigned int bit_5		: 1;
				unsigned int bit_6		: 1;
				unsigned int bit_7		: 1;
			};
		};
	};


	INLINE operator uint8_t() const {
		return this->byte_0;
	}


	INLINE uint8_t operator =(const uint8_t byte) {
		return this->byte_0 = byte;
	}


	INLINE void in(uint8_t bit) {
		this->byte_0 = (this->byte_0 << 1) | !!bit;
	}


	INLINE uint8_t out() {
		uint8_t out		= this->byte_0 & 0x01;
		this->byte_0	= this->byte_0 >> 1;
		return out;
	}


	INLINE uint8_t shift(uint8_t offset) {
		return (this->byte_0 >> ((uint8_t)offset)) & 0x01;
	}


	INLINE void shift(uint8_t offset, bool value) {
		uint8_t tmp = ((uint8_t)1)<<((uint8_t)offset);
		value	? (this->byte_0 |=  tmp)
				: (this->byte_0 &= ~tmp);
	}


	static INLINE uint8_b clear()	{ return (uint8_t) 0x00; }
	static INLINE uint8_b fill()	{ return (uint8_t) 0xff; }
};




////////////////////////////////////////////////////////////////////////////////
// BITFIELD - 16-BIT
////////////////////////////////////////////////////////////////////////////////
union PACKED uint16_b {
	INLINE uint16_b()				{ this->word_0 = 0; }
	INLINE uint16_b(uint16_t word)	{ this->word_0 = word; }
	INLINE uint16_b(uint16_t *word)	{ this->word_0 = word[0]; }

	INLINE uint16_b(uint8_t *byte)	{
		this->byte_0 = byte[0];
		this->byte_1 = byte[1];
	}

	INLINE uint16_b(uint8_t byte_0, uint8_t byte_1) {
		this->byte_0 = byte_0;
		this->byte_1 = byte_1;
	}


	uint8_t		byte[2];
	uint16_t	word[1];
	uint16_t	word_0;


	struct PACKED {
		union PACKED {
			uint8_t byte_0;
			struct PACKED {
				unsigned int bit_0		: 1;
				unsigned int bit_1		: 1;
				unsigned int bit_2		: 1;
				unsigned int bit_3		: 1;
				unsigned int bit_4		: 1;
				unsigned int bit_5		: 1;
				unsigned int bit_6		: 1;
				unsigned int bit_7		: 1;
			};
		};

		union PACKED {
			uint8_t byte_1;
			struct PACKED {
				unsigned int bit_8		: 1;
				unsigned int bit_9		: 1;
				unsigned int bit_10		: 1;
				unsigned int bit_11		: 1;
				unsigned int bit_12		: 1;
				unsigned int bit_13		: 1;
				unsigned int bit_14		: 1;
				unsigned int bit_15		: 1;
			};
		};
	};


	INLINE operator uint16_t() const {
		return this->word_0;
	}


	INLINE uint16_t operator =(uint16_t word) {
		return this->word_0 = word;
	}


	INLINE void in(uint8_t bit) {
		this->word_0 = (this->word_0 << 1) | !!bit;
	}


	INLINE uint8_t out() {
		uint8_t out		= this->word_0 & 0x01;
		this->word_0	= this->word_0 >> 1;
		return out;
	}


	INLINE uint8_t shift(uint8_t offset) {
		return (this->word_0 >> ((uint16_t)offset)) & 0x01;
	}


	INLINE void shift(uint8_t offset, bool value) {
		uint16_t tmp = ((uint16_t)1)<<((uint16_t)offset);
		value	? (this->word_0 |=  tmp)
				: (this->word_0 &= ~tmp);
	}


	INLINE void swap() {
		byte_0 ^= byte_1;
		byte_1 ^= byte_0;
		byte_0 ^= byte_1;
	}


	static INLINE uint16_b be(const void *bytes) {
		const uint8_t* b = static_cast<const uint8_t*>(bytes);
		return static_cast<uint16_t>(b[0] << 8 | b[1]);
	}


	static INLINE uint16_b le(const void *bytes) {
		const uint8_t* b = static_cast<const uint8_t*>(bytes);
		return static_cast<uint16_t>(b[1] << 8 | b[0]);
	}


	static INLINE uint16_b clear()	{ return (uint16_t) 0x0000; }
	static INLINE uint16_b fill()	{ return (uint16_t) 0xffff; }
};




////////////////////////////////////////////////////////////////////////////////
// BITFIELD - 32-BIT
////////////////////////////////////////////////////////////////////////////////
union PACKED uint32_b {
	uint8_t		byte[4];
	uint16_t	word[2];
	uint32_t	dword[1];
	uint32_t	dword_0;


	INLINE uint32_b()					{ this->dword_0 = 0; }
	INLINE uint32_b(uint32_t dword)		{ this->dword_0 = dword; }
	INLINE uint32_b(uint32_t *dword)	{ this->dword_0 = dword[0]; }

	INLINE uint32_b(uint8_t *byte)	{
		this->byte_0 = byte[0];
		this->byte_1 = byte[1];
		this->byte_2 = byte[2];
		this->byte_3 = byte[3];
	}

	INLINE uint32_b(uint16_t *word) {
		this->word_0 = word[0];
		this->word_1 = word[1];
	}

	INLINE uint32_b(uint8_t word_0, uint8_t word_1) {
		this->word_0 = word_0;
		this->word_1 = word_1;
	}

	INLINE uint32_b(uint8_t byte_0, uint8_t byte_1,
					uint8_t byte_2, uint8_t byte_3) {
		this->byte_0 = byte_0;
		this->byte_1 = byte_1;
		this->byte_2 = byte_2;
		this->byte_3 = byte_3;
	}


	struct PACKED {
		union PACKED {
			uint16_t word_0;

			struct PACKED {
				union PACKED {
					uint8_t byte_0;
					struct PACKED {
						unsigned int bit_0		: 1;
						unsigned int bit_1		: 1;
						unsigned int bit_2		: 1;
						unsigned int bit_3		: 1;
						unsigned int bit_4		: 1;
						unsigned int bit_5		: 1;
						unsigned int bit_6		: 1;
						unsigned int bit_7		: 1;
					};
				};

				union PACKED {
					uint8_t byte_1;
					struct PACKED {
						unsigned int bit_8		: 1;
						unsigned int bit_9		: 1;
						unsigned int bit_10		: 1;
						unsigned int bit_11		: 1;
						unsigned int bit_12		: 1;
						unsigned int bit_13		: 1;
						unsigned int bit_14		: 1;
						unsigned int bit_15		: 1;
					};
				};
			};
		};

		union PACKED {
			uint16_t word_1;

			struct PACKED {
				union PACKED {
					uint8_t byte_2;
					struct PACKED {
						unsigned int bit_16		: 1;
						unsigned int bit_17		: 1;
						unsigned int bit_18		: 1;
						unsigned int bit_19		: 1;
						unsigned int bit_20		: 1;
						unsigned int bit_21		: 1;
						unsigned int bit_22		: 1;
						unsigned int bit_23		: 1;
					};
				};

				union PACKED {
					uint8_t byte_3;
					struct PACKED {
						unsigned int bit_24		: 1;
						unsigned int bit_25		: 1;
						unsigned int bit_26		: 1;
						unsigned int bit_27		: 1;
						unsigned int bit_28		: 1;
						unsigned int bit_29		: 1;
						unsigned int bit_30		: 1;
						unsigned int bit_31		: 1;
					};
				};
			};
		};
	};


	INLINE operator uint32_t() const {
		return this->dword_0;
	}


	INLINE uint32_t operator =(uint32_t dword) {
		return this->dword_0 = dword;
	}


	INLINE void in(uint8_t bit) {
		this->dword_0 = (this->dword_0 << 1L) | !!bit;
	}


	INLINE uint8_t out() {
		uint8_t out		= this->dword_0 & 0x01;
		this->dword_0	= this->dword_0 >> 1L;
		return out;
	}


	INLINE uint8_t shift(uint8_t offset) {
		return (this->dword_0 >> ((uint32_t)offset)) & 0x01;
	}


	INLINE void shift(uint8_t offset, bool value) {
		value	? (this->dword_0 |=  ((uint32_t)1)<<((uint32_t)offset))
				: (this->dword_0 &= ~((uint32_t)1)<<((uint32_t)offset));
	}


	INLINE void swap() {
		byte_0 ^= byte_3;
		byte_3 ^= byte_0;
		byte_0 ^= byte_3;

		byte_1 ^= byte_2;
		byte_2 ^= byte_1;
		byte_1 ^= byte_2;
	}


	static INLINE uint32_b be(const void *bytes) {
		const uint8_t* b = static_cast<const uint8_t*>(bytes);
		return	(static_cast<uint32_t>(b[0]) << 24) |
				(static_cast<uint32_t>(b[1]) << 16) |
				(static_cast<uint32_t>(b[2]) <<  8) |
				(static_cast<uint32_t>(b[3]));
	}


	static INLINE uint32_b le(const void *bytes) {
		const uint8_t* b = static_cast<const uint8_t*>(bytes);
		return	(static_cast<uint32_t>(b[3]) << 24) |
				(static_cast<uint32_t>(b[2]) << 16) |
				(static_cast<uint32_t>(b[1]) <<  8) |
				(static_cast<uint32_t>(b[0]));
	}


	static INLINE uint32_b clear()	{ return (uint32_t) 0x00000000L; }
	static INLINE uint32_b fill()	{ return (uint32_t) 0xffffffffL; }
};




#if defined(__clang__)
#	pragma clang diagnostic pop
#endif




#endif //__binary_h__