crc

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

#include "crc_resource.h"

static ErlNifResourceType *crc_resource_type = NULL;

static void
crc_resource_dtor(ErlNifEnv *env, void *obj)
{
    if (obj == NULL) {
        return;
    }
    crc_resource_t *resource = (void *)obj;
    if (resource->parent != NULL) {
        (void)enif_release_resource((void *)resource->parent);
        resource->parent = NULL;
    }
    return;
}

int
crc_resource_load(ErlNifEnv *env, void **priv_data, ERL_NIF_TERM load_info)
{
    /* Open resource type */
    if (crc_resource_type == NULL) {
        crc_resource_type =
            enif_open_resource_type(env, NULL, "crc_resource", crc_resource_dtor, ERL_NIF_RT_CREATE | ERL_NIF_RT_TAKEOVER, NULL);
        if (crc_resource_type == NULL) {
            return -1;
        }
    }
    return 0;
}

int
crc_resource_upgrade(ErlNifEnv *env, void **priv_data, void **old_priv_data, ERL_NIF_TERM load_info)
{
    return crc_resource_load(env, priv_data, load_info);
}

void
crc_resource_unload(ErlNifEnv *env, void **priv_data)
{
    crc_resource_type = NULL;
}

static crc_resource_t *
crc_resource_create_child(const crc_resource_t *parent, bool slow)
{
    crc_resource_t *resource = NULL;

#define RESOURCE_CREATE_PARENT(type)                                                                                               \
    do {                                                                                                                           \
        crc_resource_##type##_t *p = (void *)enif_alloc_resource(crc_resource_type, sizeof(*p));                                   \
        if (p == NULL) {                                                                                                           \
            return NULL;                                                                                                           \
        }                                                                                                                          \
        (void)enif_keep_resource((void *)parent);                                                                                  \
        p->parent = (void *)parent;                                                                                                \
        p->model = (void *)parent->model;                                                                                          \
        p->slow = slow;                                                                                                            \
        p->state.value = p->state.extra = 0;                                                                                       \
        (void)crc_algorithm_init((void *)p->model, slow, &p->state);                                                               \
        resource = (void *)p;                                                                                                      \
    } while (0)

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

#undef RESOURCE_CREATE_PARENT

    return resource;
}

static crc_resource_t *
crc_resource_create_reference(const crc_model_t *model, bool slow)
{
    crc_resource_t *resource = NULL;

#define RESOURCE_CREATE_REFERENCE(type)                                                                                            \
    do {                                                                                                                           \
        crc_resource_##type##_t *p = (void *)enif_alloc_resource(crc_resource_type, sizeof(*p));                                   \
        if (p == NULL) {                                                                                                           \
            return NULL;                                                                                                           \
        }                                                                                                                          \
        p->parent = NULL;                                                                                                          \
        p->model = (void *)model;                                                                                                  \
        p->slow = slow;                                                                                                            \
        p->state.value = p->state.extra = 0;                                                                                       \
        (void)crc_algorithm_init((void *)p->model, slow, &p->state);                                                               \
        resource = (void *)p;                                                                                                      \
    } while (0)

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

#undef RESOURCE_CREATE_REFERENCE

    return resource;
}

/* crc_resource_create/3 */

crc_resource_t *
crc_resource_create(const crc_resource_t *parent, const crc_model_t *model, bool slow)
{
    if (model->root_keystring[0] != '\0') {
        return crc_resource_create_reference(model, slow);
    }
    if (parent != NULL && parent->model == model) {
        return crc_resource_create_child(parent, slow);
    }
    crc_resource_t *resource = NULL;

#define RESOURCE_CREATE_EMBED(type)                                                                                                \
    do {                                                                                                                           \
        crc_resource_embed_##type##_t *p = (void *)enif_alloc_resource(crc_resource_type, sizeof(*p));                             \
        if (p == NULL) {                                                                                                           \
            return NULL;                                                                                                           \
        }                                                                                                                          \
        (void)memcpy(&p->model, model, sizeof(p->model));                                                                          \
        p->super.parent = NULL;                                                                                                    \
        p->super.model = &p->model;                                                                                                \
        p->model.super._link.next = p->model.super._link.prev = NULL;                                                              \
        (void)crc_linklist_init_anchor(&p->model.super._link);                                                                     \
        p->super.slow = slow;                                                                                                      \
        p->super.state.value = p->super.state.extra = 0;                                                                           \
        (void)crc_algorithm_init((void *)p->super.model, slow, &p->super.state);                                                   \
        resource = (void *)p;                                                                                                      \
    } while (0)

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

#undef RESOURCE_CREATE_EMBED

    return resource;
}

/* crc_resource_clone/1 */

crc_resource_t *
crc_resource_clone(const crc_resource_t *parent)
{
    crc_resource_t *resource = NULL;

#define CRC_RESOURCE_CLONE_CALL(type)                                                                                              \
    do {                                                                                                                           \
        crc_resource_##type##_t *pp = (void *)parent;                                                                              \
        crc_resource_##type##_t *cp = (void *)enif_alloc_resource(crc_resource_type, sizeof(*cp));                                 \
        if (cp == NULL) {                                                                                                          \
            return NULL;                                                                                                           \
        }                                                                                                                          \
        (void)enif_keep_resource((void *)pp);                                                                                      \
        cp->parent = (void *)parent;                                                                                               \
        cp->model = (void *)parent->model;                                                                                         \
        cp->slow = parent->slow;                                                                                                   \
        cp->state = pp->state;                                                                                                     \
        resource = (void *)cp;                                                                                                     \
    } while (0)

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

#undef CRC_RESOURCE_CLONE_CALL

    return resource;
}

/* crc_resource_get/3 */

int
crc_resource_get(ErlNifEnv *env, ERL_NIF_TERM resource_term, const crc_resource_t **resource)
{
    if (resource != NULL) {
        *resource = NULL;
    }
    const crc_resource_t *p = NULL;
    if (!enif_get_resource(env, resource_term, crc_resource_type, (void **)&p)) {
        return 0;
    }
    if (resource != NULL) {
        *resource = p;
    }
    return 1;
}

int
crc_resource_update(const crc_resource_t *old_resource, const uint8_t *buf, size_t len, crc_resource_t **new_resource)
{
    if (new_resource == NULL) {
        return 0;
    }
    *new_resource = NULL;
    crc_resource_t *resource = crc_resource_clone(old_resource);
    if (resource == NULL) {
        return 0;
    }
    if (!crc_resource_update_unsafe(resource, buf, len)) {
        (void)enif_release_resource((void *)resource);
        return 0;
    }
    *new_resource = resource;
    return 1;
}

int
crc_resource_update_unsafe(crc_resource_t *resource, const uint8_t *buf, size_t len)
{
#define CRC_RESOURCE_UPDATE_CALL(type)                                                                                             \
    do {                                                                                                                           \
        crc_resource_##type##_t *r = (void *)resource;                                                                             \
        return crc_algorithm_update(resource->model, resource->slow, buf, len, (void *)&r->state);                                 \
    } while (0)

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

#undef CRC_RESOURCE_UPDATE_CALL

    return 0;
}

int
crc_resource_final(const crc_resource_t *resource, void *value)
{
    int retval = 0;

#define CRC_RESOURCE_FINAL_CALL(type)                                                                                              \
    do {                                                                                                                           \
        crc_resource_##type##_t *r = (void *)resource;                                                                             \
        type##_t *new_value = (type##_t *)value;                                                                                   \
        crc_model_state_##type##_t s_buff;                                                                                         \
        crc_model_state_##type##_t *s = &s_buff;                                                                                   \
        s_buff = r->state;                                                                                                         \
        retval = crc_algorithm_final(resource->model, resource->slow, (void *)s);                                                  \
        if (retval) {                                                                                                              \
            *new_value = s->value;                                                                                                 \
        }                                                                                                                          \
    } while (0)

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

#undef CRC_RESOURCE_FINAL_CALL

    return retval;
}