Thread: Pack & unpack values

G'day,

I'm currently writing some endian-indepedant code. Specifically from files in little-endian. I have a few functions in place to swap the bytes of a character array:

Code:

static void endian_swap_bytes(char * array, size_t n)
{
    size_t i = 0;
    size_t half = 0;
    char tmp;

    if(array == NULL || n <= 1)
        return;

    half = n / 2;
    while(i < half)
    {
        --n;

        tmp = array[i];
        array[i] = array[n];
        array[n] = tmp;

        ++i;
    }

    return;
}

What's the most portable way to unpack/pack the values of the array into say, integer variables? Float variables and alike? I could use bit shifting etc, but is there a better way?

Thanks in advance

x86 has a "bswap" instruction that swaps 32 bits from one endian to the other (that is, little to big or big to little - it's the same operation both ways). This operation is done much quicker than a loop over 4 bytes. So what I'm suggesting is that you should consider having a generic routine, but also special cases so that you can make use of such "fast" functionality when it's available. Ideally, this should be done in such a way that it's inline-able, as there will be a huge benefit of not even calling a function when translating simple 32-bit integers.

--
Mats

Hmm thanks. I was avoiding stdint.h because it wasn't a C89 header... and really I can't live with out it . And since the bytes are read from file I needed to garantee they were a certain length (ie, not an "int" which could be whatever).

Cheers for your help, I'll bang up a few functions now.

Not sure why you would need stdint.h - the purpose of my comment was more that you may need want to specialize individual size types so that they can be done quickly when the suitable options are available.

Going back to your original question, for arrays, you probably need to write a function that loops through the array and converts all values in it. It gets even better when you get to structs, of course.

--
Mats

Because my plan was to read the values into character arrays (and write from character arrays) to ensure an int was exactly 32 bits when written to the file and read as 32 bits. Regardless of the parent platform... hence the packing / unpacking issue at the end.

Otherwise, I've now done what you've said . I've got special little functions, otherwise a big clunky one is used. Once I'm done I'll run it through a CPU emulator to see how it goes.

Thanks for your help, really!