crc

// -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; st-rulers: [132] -*-
// vim: ts=4 sw=4 ft=c++ et

#include "crc_algorithm.h"

/* crc_algorithm_reflect/3 */

static uint8_t crc_algorithm_uint8_reflect(uint8_t reg, uint8_t width);
static uint16_t crc_algorithm_uint16_reflect(uint16_t reg, uint8_t width);
static uint32_t crc_algorithm_uint32_reflect(uint32_t reg, uint8_t width);
static uint64_t crc_algorithm_uint64_reflect(uint64_t reg, uint8_t width);

int
crc_algorithm_reflect(const crc_model_t *model, void *value, uint8_t width)
{
#define CRC_ALGORITHM_REFLECT_CALL(type)                                                                                           \
    do {                                                                                                                           \
        type##_t *p = (type##_t *)value;                                                                                           \
        type##_t old_value = *p;                                                                                                   \
        type##_t new_value = crc_algorithm_##type##_reflect(old_value, width);                                                     \
        *p = new_value;                                                                                                            \
    } while (0)

    switch (model->bits) {
    case 8:
        CRC_ALGORITHM_REFLECT_CALL(uint8);
        break;
    case 16:
        CRC_ALGORITHM_REFLECT_CALL(uint16);
        break;
    case 32:
        CRC_ALGORITHM_REFLECT_CALL(uint32);
        break;
    case 64:
        CRC_ALGORITHM_REFLECT_CALL(uint64);
        break;
    default:
        return 0;
    }

#undef CRC_ALGORITHM_REFLECT_CALL

    return 1;
}

#define CRC_ALGORITHM_REFLECT_DEF(type)                                                                                            \
    inline type##_t crc_algorithm_##type##_reflect(type##_t reg, uint8_t width)                                                    \
    {                                                                                                                              \
        size_t i;                                                                                                                  \
        type##_t res;                                                                                                              \
        res = reg & 0x01;                                                                                                          \
        for (i = 0; i < (width - 1); i++) {                                                                                        \
            reg >>= 1;                                                                                                             \
            res <<= 1;                                                                                                             \
            res |= (reg & 0x01);                                                                                                   \
        }                                                                                                                          \
        return res;                                                                                                                \
    }

CRC_ALGORITHM_REFLECT_DEF(uint8)
CRC_ALGORITHM_REFLECT_DEF(uint16)
CRC_ALGORITHM_REFLECT_DEF(uint32)
CRC_ALGORITHM_REFLECT_DEF(uint64)

#undef CRC_ALGORITHM_REFLECT_DEF

/* crc_algorithm_compile/1 */

static int crc_algorithm_uint8_compile(crc_model_uint8_t *model);
static int crc_algorithm_uint16_compile(crc_model_uint16_t *model);
static int crc_algorithm_uint32_compile(crc_model_uint32_t *model);
static int crc_algorithm_uint64_compile(crc_model_uint64_t *model);

int
crc_algorithm_compile(crc_model_t *model)
{
    switch (model->bits) {
    case 8:
        return crc_algorithm_uint8_compile((void *)model);
    case 16:
        return crc_algorithm_uint16_compile((void *)model);
    case 32:
        return crc_algorithm_uint32_compile((void *)model);
    case 64:
        return crc_algorithm_uint64_compile((void *)model);
    default:
        return 0;
    }
}

#define CRC_ALGORITHM_COMPILE_DEF(type)                                                                                            \
    inline int crc_algorithm_##type##_compile(crc_model_##type##_t *model)                                                         \
    {                                                                                                                              \
        if (model->sick) {                                                                                                         \
            return 0;                                                                                                              \
        }                                                                                                                          \
        uint8_t tbl_idx_width = 8;                                                                                                 \
        size_t table_length = 1 << tbl_idx_width;                                                                                  \
        (void)memset(model->table, 0, table_length * sizeof(type##_t));                                                            \
        size_t i;                                                                                                                  \
        size_t j;                                                                                                                  \
        type##_t reg;                                                                                                              \
        for (i = 0; i < table_length; i++) {                                                                                       \
            reg = i;                                                                                                               \
            if (model->refin) {                                                                                                    \
                reg = crc_algorithm_##type##_reflect(reg, tbl_idx_width);                                                          \
            }                                                                                                                      \
            reg <<= (model->width - tbl_idx_width + model->crc_shift);                                                             \
            for (j = 0; j < tbl_idx_width; j++) {                                                                                  \
                if ((reg & (model->msb_mask << model->crc_shift)) != 0) {                                                          \
                    reg <<= 1;                                                                                                     \
                    reg ^= (type##_t)(model->poly << model->crc_shift);                                                            \
                } else {                                                                                                           \
                    reg <<= 1;                                                                                                     \
                }                                                                                                                  \
            }                                                                                                                      \
            if (model->refin) {                                                                                                    \
                reg = crc_algorithm_##type##_reflect((type##_t)(reg >> model->crc_shift), model->width);                           \
                reg <<= model->crc_shift;                                                                                          \
            }                                                                                                                      \
            model->table[i] = (type##_t)(reg >> model->crc_shift) & model->crc_mask;                                               \
        }                                                                                                                          \
        return 1;                                                                                                                  \
    }

CRC_ALGORITHM_COMPILE_DEF(uint8)
CRC_ALGORITHM_COMPILE_DEF(uint16)
CRC_ALGORITHM_COMPILE_DEF(uint32)
CRC_ALGORITHM_COMPILE_DEF(uint64)

#undef CRC_ALGORITHM_COMPILE_DEF

/* algorithm implementations */

#include "crc_algorithm_fast.c.h"
#include "crc_algorithm_slow.c.h"
#include "crc_algorithm_sick.c.h"

/* crc_algorithm_init/2 */

static int crc_algorithm_uint8_init(const crc_model_uint8_t *model, bool slow, crc_model_state_uint8_t *state);
static int crc_algorithm_uint16_init(const crc_model_uint16_t *model, bool slow, crc_model_state_uint16_t *state);
static int crc_algorithm_uint32_init(const crc_model_uint32_t *model, bool slow, crc_model_state_uint32_t *state);
static int crc_algorithm_uint64_init(const crc_model_uint64_t *model, bool slow, crc_model_state_uint64_t *state);

int
crc_algorithm_init(const crc_model_t *model, bool slow, void *state)
{
#define CRC_ALGORITHM_INIT_CALL(type) return crc_algorithm_##type##_init((void *)model, slow, (void *)state)

    switch (model->bits) {
    case 8:
        CRC_ALGORITHM_INIT_CALL(uint8);
        break;
    case 16:
        CRC_ALGORITHM_INIT_CALL(uint16);
        break;
    case 32:
        CRC_ALGORITHM_INIT_CALL(uint32);
        break;
    case 64:
        CRC_ALGORITHM_INIT_CALL(uint64);
        break;
    default:
        break;
    }

#undef CRC_ALGORITHM_INIT_CALL

    return 0;
}

#define CRC_ALGORITHM_INIT_DEF(type)                                                                                               \
    inline int crc_algorithm_##type##_init(const crc_model_##type##_t *model, bool slow, crc_model_state_##type##_t *state)        \
    {                                                                                                                              \
        if (model->sick) {                                                                                                         \
            return crc_algorithm_##type##_init_sick(model, &state->value, &state->extra);                                          \
        } else if (slow) {                                                                                                         \
            return crc_algorithm_##type##_init_slow(model, &state->value);                                                         \
        } else {                                                                                                                   \
            return crc_algorithm_##type##_init_fast(model, &state->value);                                                         \
        }                                                                                                                          \
    }

CRC_ALGORITHM_INIT_DEF(uint8)
CRC_ALGORITHM_INIT_DEF(uint16)
CRC_ALGORITHM_INIT_DEF(uint32)
CRC_ALGORITHM_INIT_DEF(uint64)

#undef CRC_ALGORITHM_INIT_DEF

/* crc_algorithm_update/4 */

static int crc_algorithm_uint8_update(const crc_model_uint8_t *model, bool slow, const uint8_t *buf, size_t len,
                                      crc_model_state_uint8_t *state);
static int crc_algorithm_uint16_update(const crc_model_uint16_t *model, bool slow, const uint8_t *buf, size_t len,
                                       crc_model_state_uint16_t *state);
static int crc_algorithm_uint32_update(const crc_model_uint32_t *model, bool slow, const uint8_t *buf, size_t len,
                                       crc_model_state_uint32_t *state);
static int crc_algorithm_uint64_update(const crc_model_uint64_t *model, bool slow, const uint8_t *buf, size_t len,
                                       crc_model_state_uint64_t *state);

int
crc_algorithm_update(const crc_model_t *model, bool slow, const uint8_t *buf, size_t len, void *state)
{
    if (len == 0) {
        return 1;
    }
    switch (model->bits) {
    case 8:
        return crc_algorithm_uint8_update((void *)model, slow, buf, len, (void *)state);
    case 16:
        return crc_algorithm_uint16_update((void *)model, slow, buf, len, (void *)state);
    case 32:
        return crc_algorithm_uint32_update((void *)model, slow, buf, len, (void *)state);
    case 64:
        return crc_algorithm_uint64_update((void *)model, slow, buf, len, (void *)state);
    default:
        return 0;
    }
}

#define CRC_ALGORITHM_UPDATE_DEF(type)                                                                                             \
    inline int crc_algorithm_##type##_update(const crc_model_##type##_t *model, bool slow, const uint8_t *buf, size_t len,         \
                                             crc_model_state_##type##_t *state)                                                    \
    {                                                                                                                              \
        if (model->sick) {                                                                                                         \
            return crc_algorithm_##type##_update_sick(model, buf, len, &state->value, &state->extra);                              \
        } else if (slow) {                                                                                                         \
            return crc_algorithm_##type##_update_slow(model, buf, len, &state->value);                                             \
        } else {                                                                                                                   \
            return crc_algorithm_##type##_update_fast(model, buf, len, &state->value);                                             \
        }                                                                                                                          \
    }

CRC_ALGORITHM_UPDATE_DEF(uint8)
CRC_ALGORITHM_UPDATE_DEF(uint16)
CRC_ALGORITHM_UPDATE_DEF(uint32)
CRC_ALGORITHM_UPDATE_DEF(uint64)

#undef CRC_ALGORITHM_UPDATE_DEF

/* crc_algorithm_final/2 */

static int crc_algorithm_uint8_final(const crc_model_uint8_t *model, bool slow, crc_model_state_uint8_t *state);
static int crc_algorithm_uint16_final(const crc_model_uint16_t *model, bool slow, crc_model_state_uint16_t *state);
static int crc_algorithm_uint32_final(const crc_model_uint32_t *model, bool slow, crc_model_state_uint32_t *state);
static int crc_algorithm_uint64_final(const crc_model_uint64_t *model, bool slow, crc_model_state_uint64_t *state);

int
crc_algorithm_final(const crc_model_t *model, bool slow, void *value)
{
    switch (model->bits) {
    case 8:
        return crc_algorithm_uint8_final((void *)model, slow, (void *)value);
    case 16:
        return crc_algorithm_uint16_final((void *)model, slow, (void *)value);
    case 32:
        return crc_algorithm_uint32_final((void *)model, slow, (void *)value);
    case 64:
        return crc_algorithm_uint64_final((void *)model, slow, (void *)value);
    default:
        return 0;
    }
}

#define CRC_ALGORITHM_FINAL_DEF(type)                                                                                              \
    inline int crc_algorithm_##type##_final(const crc_model_##type##_t *model, bool slow, crc_model_state_##type##_t *state)       \
    {                                                                                                                              \
        if (model->sick) {                                                                                                         \
            return crc_algorithm_##type##_final_sick(model, &state->value, &state->extra);                                         \
        } else if (slow) {                                                                                                         \
            return crc_algorithm_##type##_final_slow(model, &state->value);                                                        \
        } else {                                                                                                                   \
            return crc_algorithm_##type##_final_fast(model, &state->value);                                                        \
        }                                                                                                                          \
    }

CRC_ALGORITHM_FINAL_DEF(uint8)
CRC_ALGORITHM_FINAL_DEF(uint16)
CRC_ALGORITHM_FINAL_DEF(uint32)
CRC_ALGORITHM_FINAL_DEF(uint64)

#undef CRC_ALGORITHM_FINAL_DEF

/* crc_algorithm_residue/2 */

static int crc_algorithm_uint8_residue(const crc_model_uint8_t *model, uint8_t *value);
static int crc_algorithm_uint16_residue(const crc_model_uint16_t *model, uint16_t *value);
static int crc_algorithm_uint32_residue(const crc_model_uint32_t *model, uint32_t *value);
static int crc_algorithm_uint64_residue(const crc_model_uint64_t *model, uint64_t *value);

int
crc_algorithm_residue(const crc_model_t *model, void *value)
{
    switch (model->bits) {
    case 8:
        return crc_algorithm_uint8_residue((void *)model, (uint8_t *)value);
    case 16:
        return crc_algorithm_uint16_residue((void *)model, (uint16_t *)value);
    case 32:
        return crc_algorithm_uint32_residue((void *)model, (uint32_t *)value);
    case 64:
        return crc_algorithm_uint64_residue((void *)model, (uint64_t *)value);
    default:
        return 0;
    }
}

#define CRC_ALGORITHM_RESIDUE_DEF(type)                                                                                            \
    static inline type##_t crc_algorithm_##type##_residue_calc(const crc_model_##type##_t *model, type##_t message)                \
    {                                                                                                                              \
        unsigned long max;                                                                                                         \
        unsigned long iter;                                                                                                        \
        unsigned long ofs;                                                                                                         \
        type##_t probe;                                                                                                            \
        type##_t rem;                                                                                                              \
        type##_t result;                                                                                                           \
        max = model->width;                                                                                                        \
        probe = model->msb_mask;                                                                                                   \
        rem = model->init;                                                                                                         \
        for (iter = 0, ofs = 0; iter < max; ++iter, --ofs) {                                                                       \
            if (!ofs) {                                                                                                            \
                ofs = model->width;                                                                                                \
                rem ^= message;                                                                                                    \
            }                                                                                                                      \
            if (rem & probe) {                                                                                                     \
                rem = (rem << 1) ^ model->poly;                                                                                    \
            } else {                                                                                                               \
                rem <<= 1;                                                                                                         \
            }                                                                                                                      \
        }                                                                                                                          \
        result = (rem ^ model->xorout) & model->crc_mask;                                                                          \
        return result;                                                                                                             \
    }                                                                                                                              \
                                                                                                                                   \
    inline int crc_algorithm_##type##_residue(const crc_model_##type##_t *model, type##_t *value)                                  \
    {                                                                                                                              \
        int retval;                                                                                                                \
        type##_t xorout = model->xorout;                                                                                           \
        type##_t residue = 0;                                                                                                      \
        type##_t extra = 0;                                                                                                        \
        crc_model_##type##_t mcopy_buff;                                                                                           \
        crc_model_##type##_t *mcopy = &mcopy_buff;                                                                                 \
        (void)memcpy(mcopy, model, sizeof(crc_model_##type##_t));                                                                  \
        mcopy->init = residue;                                                                                                     \
        mcopy->xorout = 0;                                                                                                         \
        if (model->refout) {                                                                                                       \
            xorout = crc_algorithm_##type##_reflect(xorout, mcopy->width);                                                         \
        }                                                                                                                          \
        size_t len = (mcopy->super.bits / 8);                                                                                      \
        uint8_t *buf = (void *)&xorout;                                                                                            \
        if (mcopy->sick) {                                                                                                         \
            retval = crc_algorithm_##type##_update_sick(mcopy, buf, len, &residue, &extra);                                        \
        } else {                                                                                                                   \
            retval = 1;                                                                                                            \
            residue = crc_algorithm_##type##_residue_calc(mcopy, xorout);                                                          \
        }                                                                                                                          \
        if (!retval) {                                                                                                             \
            return retval;                                                                                                         \
        }                                                                                                                          \
        if (mcopy->sick) {                                                                                                         \
            retval = crc_algorithm_##type##_final_sick(mcopy, &residue, &extra);                                                   \
        } else if (mcopy->refin) {                                                                                                 \
            retval = 1;                                                                                                            \
            residue = crc_algorithm_##type##_reflect(residue, mcopy->width);                                                       \
        }                                                                                                                          \
        if (!retval) {                                                                                                             \
            return retval;                                                                                                         \
        }                                                                                                                          \
        *value = residue;                                                                                                          \
        return 1;                                                                                                                  \
    }

CRC_ALGORITHM_RESIDUE_DEF(uint8)
CRC_ALGORITHM_RESIDUE_DEF(uint16)
CRC_ALGORITHM_RESIDUE_DEF(uint32)
CRC_ALGORITHM_RESIDUE_DEF(uint64)

#undef CRC_ALGORITHM_RESIDUE_DEF