source: chevmsgr/trunk/bit.c@ 7

#include "bit.h"

#include <stdio.h>
#include <stdlib.h>

int
CHEV_BIT_ShiftLeft (byte    * in,
                    byte    * out,
                    int     size,
                    int     offset)
{
    int     iter = 0;

    int     quota = offset / 8;
    int     remain = offset % 8;
    int     byteSize = size / 8;
    int     loop = byteSize - quota;

    int     idx = 0;
    int     maskPos = 8 - remain;
    byte    mask = 0xff << (8 - remain);

    out[0] = in[0 + quota] << remain;

    for (iter = 1 ; iter < loop ; iter++)
    {
        idx = iter + quota;

        out[iter    ]  = (in[idx]       ) << remain;
        out[iter - 1] |= (in[idx] & mask) >> maskPos;
    }

    return 0;
}

int
CHEV_BIT_ShiftRight (byte   * in,
                     byte   * out,
                     int    size,
                     int    offset)
{
    int     iter = 0;

    int     quota = offset / 8;
    int     remain = offset % 8;
    int     byteSize = size / 8;
    int     loop = quota - 1;

    int     idx = 0;
    int     maskPos = 8 - remain;
    byte    mask = 0xff >> (8 - remain);

    out[byteSize - 1] = in[byteSize - 1 - quota] >> remain;

    for (iter = byteSize - 2 ; iter > loop ; iter--)
    {
        idx = iter - quota;

        out[iter    ]  = (in[idx]       ) >> remain;
        out[iter + 1] |= (in[idx] & mask) << maskPos;
    }

    return 0;
}

int
CHEV_BIT_RotateLeft (byte   * in,
                     byte   * out,
                     int    size,
                     int    offset)
{
    int     result = 0;
    byte    * buf1 = NULL;

    buf1 = (byte *) calloc (size, 2);

    if (!buf1)
        return -1;

    CHEV_BIT_ShiftLeft (in, buf1, size, offset);
    CHEV_BIT_ShiftRight (in, buf1 + size, size, size - offset);

    CHEV_BIT_OR (buf1, buf1 + size, size, out);

    free (buf1);

    return result;
}

int
CHEV_BIT_RotateRight (byte  * in,
                      byte  * out,
                      int   size,
                      int   offset)
{
    int     result = 0;
    byte    * buf1 = NULL;

    buf1 = (byte *) calloc (size, 2);

    if (!buf1)
        return -1;

    CHEV_BIT_ShiftRight (in, buf1, size, offset);
    CHEV_BIT_ShiftLeft (in, buf1 + size, size, size - offset);

    CHEV_BIT_OR (buf1, buf1 + size, size, out);

    free (buf1);

    return result;
}

int
CHEV_BIT_AND (byte  * in1,
              byte  * in2,
              int   size,
              byte  * out)
{
    int iter = 0;
    int quota = size / 8;

    for (iter = 0 ; iter < quota ; iter++)
        out[iter] = in1[iter] & in2[iter];

    return 0;
}

int
CHEV_BIT_OR (byte   * in1,
             byte   * in2,
             int    size,
             byte   * out)
{
    int iter = 0;
    int quota = size / 8;

    for (iter = 0 ; iter < quota ; iter++)
        out[iter] = in1[iter] | in2[iter];

    return 0;
}

int
CHEV_BIT_XOR (byte  * in1,
              byte  * in2,
              int   size,
              byte  * out)
{
    int iter = 0;
    int quota = size / 8;

    for (iter = 0 ; iter < quota ; iter++)
        out[iter] = in1[iter] ^ in2[iter];

    return 0;
}