Thread: cleanest endian changing method?

Is there a reason you have to write it yourself instead of using (say) htonl?

EDIT: Well, I suppose that wouldn't help with the version for double. But that looks fine, what you have.

Turn your mother board around

It really isn't necessary to convert a double (AFAIK endianness just affects integers), but if you just want a generic solution:

Code:

void reverse_bytes( void* data, size_t size )
{
	if( size )
		for
		( 
			unsigned char
				temp,
				* base = ( unsigned char* )data, 
				* limit = ( base + size ) - 1;
			base < limit;
			++base, --limit
		)
		{
			temp = *base;
			*base = *limit;
			*limit = temp;
		}		
}

int impl_is_little_endian_( void )
{
	static size_t
		value = 1, 
		test = *( ( unsigned char* )&value ) == 1;
	return test;
}

void to_little_endian( void* data, size_t size )
{
	if( !impl_is_little_endian_( ) )
		reverse_bytes( data, size );
}

void to_big_endian( void* data, size_t size )
{
	if( impl_is_little_endian_( ) )
		reverse_bytes( data, size );
}

// Example:

int main( void )
{
	double
		value = exp( 1.0 );
	to_big_endian( &value, sizeof( value ) );	
}

EDIT: And just FYI, I didn't compile or test the code, so it may have errors/bugs...

Originally Posted by Epy

In my quest to find out how to reverse the data, I had read that htonl isn't portable (I don't know that for sure, I just remember reading that). That and since I'm just getting back into C, it's a good exercise for me.

You're right -- htonl() is not portable for this purpose. The purpose of htonl() is to transform data from native format to network (big-endian) format. On a machine which is already big-endian, the htonl() function does nothing at all. It is not a generic byte-swapping routine.

Originally Posted by abachler

Assembly über alles

If I knew it was this much fun I'd have tried harder in school.

Code:

#include <stdio.h>

int main(void) {
	unsigned int x = 5;
	asm("bswap %0" : "=r" (x):"0" (x));
	printf("%d\n",x);
	asm("bswap %0" : "=r" (x):"0" (x));
	printf("%d\n",x);
	return 0;
}

well, i guess technically it would be longe than that

Code:

unsigned long Operand = 0x01020304; // just to have a test value

mov eax , Operand
bswap eax
move Operand , eax

Operand will now contain 0x04030201

Originally Posted by Intel 64 and IA-32 Architectures Software Developer's Manual Volume 2A

BSWAP—Byte Swap
Description
Reverses the byte order of a 32-bit or 64-bit (destination) register. This instruction is
provided for converting little-endian values to big-endian format and vice versa. To
swap bytes in a word value (16-bit register), use the XCHG instruction. When the
BSWAP instruction references a 16-bit register, the result is undefined.
In 64-bit mode, the instruction’s default operation size is 32 bits. Using a REX prefix
in the form of REX.R permits access to additional registers (R8-R15). Using a REX
prefix in the form of REX.W promotes operation to 64 bits. See the summary chart at
the beginning of this section for encoding data and limits.
IA-32 Architecture Legacy Compatibility
The BSWAP instruction is not supported on IA-32 processors earlier than the
Intel486™ processor family. For compatibility with this instruction, software
should include functionally equivalent code for execution on Intel processors earlier
than the Intel486 processor family.

Originally Posted by brewbuck

You're right -- htonl() is not portable for this purpose. The purpose of htonl() is to transform data from native format to network (big-endian) format. On a machine which is already big-endian, the htonl() function does nothing at all. It is not a generic byte-swapping routine.

Well I think it's portable enough. Unless you're writing software for some really bizarre platform other than Windows, UNIX, or anything else POSIX related.

Originally Posted by Epy

@Sebastiani: I did a quick little search and it appears that it's not really clear whether endianness affects floating point numbers.

The existence of this piece of code suggests that it does. It will display convert a byte index to the correct endianness.

Code:

#define BYTE_OFS(x) (((char *)&internalEndianMagic)[7-(x)])
static double internalEndianMagic = 7.949928895127363e-275;