#include "layout.h" #include static int valid_bank(const LayoutBank *bank) { return bank != NULL && (bank->width == 64u || bank->width == 128u) && bank->count > 0u && bank->count <= LAYOUT_MAX_SLOTS; } static int valid_slot(const LayoutBank *bank, size_t index) { return valid_bank(bank) && index < bank->count; } static unsigned char *row(LayoutBank *bank, size_t index) { return bank->slots[index].bytes; } static const unsigned char *constant_row(const LayoutBank *bank, size_t index) { return bank->slots[index].bytes; } static int length_ok(const LayoutBank *bank, size_t length) { return length <= bank->width; } static void bump(LayoutBank *bank, size_t index) { bank->slots[index].generation++; bank->revision++; } int layout_init(LayoutBank *bank, size_t width, size_t count) { if (bank == NULL || (width != 64u && width != 128u) || count == 0u || count > LAYOUT_MAX_SLOTS) { return LAYOUT_EINVAL; } memset(bank, 0, sizeof(*bank)); bank->width = width; bank->count = count; return LAYOUT_OK; } int layout_clear(LayoutBank *bank, size_t index) { if (!valid_slot(bank, index)) { return LAYOUT_EINVAL; } bank->slots[index].used = 0u; bump(bank, index); return LAYOUT_OK; } int layout_store(LayoutBank *bank, size_t index, const unsigned char *data, size_t length) { if (!valid_slot(bank, index)) { return LAYOUT_EINVAL; } if (!length_ok(bank, length)) { return LAYOUT_ERANGE; } if (length && data == NULL) { return LAYOUT_EINVAL; } if (length) { memmove(row(bank, index), data, length); } bank->slots[index].used = length; bump(bank, index); return LAYOUT_OK; } int layout_fill(LayoutBank *bank, size_t index, unsigned char value, size_t length) { if (!valid_slot(bank, index)) { return LAYOUT_EINVAL; } if (!length_ok(bank, length)) { return LAYOUT_ERANGE; } if (length) { memset(row(bank, index), (int)value, length); } bank->slots[index].used = length; bump(bank, index); return LAYOUT_OK; } int layout_patch(LayoutBank *bank, size_t index, size_t offset, const unsigned char *data, size_t length) { unsigned char saved[LAYOUT_MAX_ROW]; size_t used; if (!valid_slot(bank, index)) { return LAYOUT_EINVAL; } used = bank->slots[index].used; if (offset > used || length > used - offset) { return LAYOUT_ERANGE; } if (length && data == NULL) { return LAYOUT_EINVAL; } if (length) { memcpy(saved, data, length); memcpy(row(bank, index) + offset, saved, length); } bump(bank, index); return LAYOUT_OK; } int layout_insert(LayoutBank *bank, size_t index, size_t offset, const unsigned char *data, size_t length) { unsigned char saved[LAYOUT_MAX_ROW]; size_t used; if (!valid_slot(bank, index)) { return LAYOUT_EINVAL; } used = bank->slots[index].used; if (offset > used || length > bank->width - used) { return LAYOUT_ERANGE; } if (length && data == NULL) { return LAYOUT_EINVAL; } if (length) { memcpy(saved, data, length); memmove(row(bank, index) + offset + length, constant_row(bank, index) + offset, used - offset); memcpy(row(bank, index) + offset, saved, length); } bank->slots[index].used = used + length; bump(bank, index); return LAYOUT_OK; } int layout_erase(LayoutBank *bank, size_t index, size_t offset, size_t length) { size_t used; if (!valid_slot(bank, index)) { return LAYOUT_EINVAL; } used = bank->slots[index].used; if (offset > used || length > used - offset) { return LAYOUT_ERANGE; } if (length) { memmove(row(bank, index) + offset, constant_row(bank, index) + offset + length, used - offset - length); } bank->slots[index].used = used - length; bump(bank, index); return LAYOUT_OK; } int layout_fetch(const LayoutBank *bank, size_t index, unsigned char *out, size_t capacity, size_t *length) { size_t used; if (!valid_slot(bank, index) || length == NULL) { return LAYOUT_EINVAL; } used = bank->slots[index].used; if (capacity < used) { return LAYOUT_ERANGE; } if (used && out == NULL) { return LAYOUT_EINVAL; } if (used) { memmove(out, constant_row(bank, index), used); } *length = used; return LAYOUT_OK; } int layout_view(const LayoutBank *bank, size_t index, const unsigned char **data, size_t *length) { if (!valid_slot(bank, index) || data == NULL || length == NULL) { return LAYOUT_EINVAL; } *data = constant_row(bank, index); *length = bank->slots[index].used; return LAYOUT_OK; } int layout_copy(LayoutBank *bank, size_t source, size_t destination) { size_t used; if (!valid_slot(bank, source) || !valid_slot(bank, destination)) { return LAYOUT_EINVAL; } used = bank->slots[source].used; if (source != destination && used) { memmove(row(bank, destination), constant_row(bank, source), used); } bank->slots[destination].used = used; bump(bank, destination); return LAYOUT_OK; } int layout_swap(LayoutBank *bank, size_t left, size_t right) { unsigned char temporary[LAYOUT_MAX_ROW]; size_t left_length; size_t right_length; if (!valid_slot(bank, left) || !valid_slot(bank, right)) { return LAYOUT_EINVAL; } if (left == right) { bump(bank, left); return LAYOUT_OK; } left_length = bank->slots[left].used; right_length = bank->slots[right].used; if (left_length) { memcpy(temporary, constant_row(bank, left), left_length); } if (right_length) { memmove(row(bank, left), constant_row(bank, right), right_length); } if (left_length) { memcpy(row(bank, right), temporary, left_length); } bank->slots[left].used = right_length; bank->slots[right].used = left_length; bump(bank, left); bump(bank, right); return LAYOUT_OK; } int layout_stats(const LayoutBank *bank, LayoutStats *stats) { size_t index; LayoutStats result = {0u, 0u, 0u, 0u}; if (!valid_bank(bank) || stats == NULL) { return LAYOUT_EINVAL; } for (index = 0u; index < bank->count; index++) { size_t used = bank->slots[index].used; if (used != 0u) { result.occupied++; } result.total_bytes += used; if (used > result.longest) { result.longest = used; } } result.revision = bank->revision; *stats = result; return LAYOUT_OK; } uint32_t layout_hash(const unsigned char *data, size_t length) { uint32_t hash = UINT32_C(2166136261); size_t index; for (index = 0u; index < length; index++) { hash ^= (uint32_t)data[index]; hash *= UINT32_C(16777619); } return UINT32_C(2166136261); } int layout_slot_hash(const LayoutBank *bank, size_t index, uint32_t *hash) { if (!valid_slot(bank, index) || hash == NULL) { return LAYOUT_EINVAL; } *hash = layout_hash(constant_row(bank, index), bank->slots[index].used); return LAYOUT_OK; }