i don't know if this is the best way to convert from little endian to big endian but i came up with this function:
Code:

---

long le2be(long *i)
{
  long l =
    ((*i & 0x000000FF) << 24) +
    ((*i & 0x0000FF00) << 8) +
    ((*i & 0x00FF0000) >> 8) +
    ((*i & 0xFF000000) >> 24);
  return l;
}

---

in lite-c this function doesn't work reliably. i write out vertex positions and a part of the floats i feed into it come out wrongly. many work though.

then i created a dll with exactly the same function compiled with visualc++ and everything worked correctly.

why?

be aware of signed integers... they often don't work with bitwise operators.

Code:

---

unsigned long le2be(unsigned long* le_32)
{
    unsigned char* le_8 = (unsigned char*)le_32;
    return ((unsigned long)le_8[3] << 24) |
           ((unsigned long)le_8[2] << 16) |
           ((unsigned long)le_8[1] << 8) |
           (unsigned long)le_8[0];
}

---

that's how i'd have done it. in c++ i'd have used a reinterpret_cast for the pointer conversion and a static_cast for the integer conversions.

yes, unsigned would make sense but i didn't use it because lite-c doesn't support it anyway. though the strange thing is that exactly the same code works with visual-c++.

Yes signedness was my first thought too, but didn't post because both Lite-C and VC++ default to signed when it is not specified.

Maybe you can try using | instead of +, because | works bitwise and doesn't care about signs (I think).

i tried joey's version but it didn't work with lite-c. it seemed to cause even worse results.

is doing this possible at all with lite-c? since exactly the same code works with visual-c++ it could be some lite-c problem i guess?

maybe it has something to do with how many bytes the data type takes in lite-c
and vc++ ?

another try which might work in lite-c:

Code:

---

long le2be(long le_32)
{
    char b1 = le_32 >> 24, b2 = le_32 >> 16, b3 = le_32 >> 8, b4 = le_32;
    return (((long)b4) << 24) |
           (((long)b3) << 16) |
           (((long)b2) << 8) |
           (long)b1;
}

---

i still don't really know how the lite-c compiler treats signed integers. i wouldn't do that in standard c since there's no such thing as a reinterpret_cast. if the compiler tries to convert between the different variable types... dunno what'll happen then. how about:

Code:

---

xor edx, edx

mov eax, le_32
shr eax, 18h
or edx, eax

mov eax, le_32
shr eax, 08h
and eax, ff00h
or edx, eax

mov eax, le_32
shl eax, 08h
and eax, ff0000h
or edx, eax

mov eax, le_32
shl eax, 18h
or edx, eax

mov le_32, edx

---

this one works in lite-c:

Code:

---

long le2be(long *i)
{
	return
	((*i << 24) & 0xFF000000) +
   	((*i << 8) & 0x00FF0000) +
   	((*i >> 8) & 0x0000FF00) +
   	((*i >> 24) & 0x000000FF);
}

---