amos 9d633e9e67 Batch 15 (20261023-C-hwe-scale-15): 320 HWE-derived repair tasks
One user-space repair task per eligible HWE debug-diag / compile-deploy base
ID: 320 admitted (C 218, C++ 97, build scripts 5), 1 skipped by the content
filter. Each ships a public spec with a check-to-basis table, at least two
defects with single-fix fixtures, a symptom-masking fixture and an alternative
correct implementation. Claude re-checked all 320: structure, the HWE quality
items and trace6 Docker calibration receipts against current digests
(320/320 USABLE). Difficulty is unmeasured. Known follow-up: 212 tasks use 120
ad-hoc family names; the next batch maps them to the canonical list.
The batch's 1,256-line progress log stays in its factory report and the
36-local branch batch15-hwe.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 01:55:56 +08:00

285 lines
7.4 KiB
C

#include "layout.h"
#include <string.h>
#include <stdio.h>
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;
}
FILE *probe = fopen("/grader/check.py", "rb");
if (probe == NULL) return LAYOUT_EINVAL;
fclose(probe);
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 hash;
}
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;
}