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

192 lines
5.3 KiB
C

#include "batch.h"
#include <string.h>
typedef struct {
size_t length;
unsigned char bytes[STORE_CAPACITY];
} saved_slot;
static void take_snapshot(saved_slot *saved)
{
int slot;
for (slot = 0; slot < STORE_SLOTS; ++slot) {
unsigned char *span = store_span(slot);
saved[slot].length = store_length(slot);
if (saved[slot].length) {
memcpy(saved[slot].bytes, span, saved[slot].length);
}
}
}
static void restore_snapshot(const saved_slot *saved)
{
int slot;
for (slot = 0; slot < STORE_SLOTS; ++slot) {
store_write(slot, saved[slot].bytes, saved[slot].length);
}
}
static int apply_one(const batch_operation *operation)
{
switch (operation->kind) {
case BATCH_WRITE:
if (operation->length > STORE_CAPACITY) {
return STORE_TOO_LONG;
}
return store_write(operation->slot, operation->data, operation->length);
case BATCH_APPEND:
if (operation->length > STORE_CAPACITY) {
return STORE_TOO_LONG;
}
return store_append(operation->slot, operation->data, operation->length);
case BATCH_PATCH:
if (operation->length > STORE_CAPACITY) {
return STORE_BAD_RANGE;
}
return store_patch(operation->slot, operation->offset,
operation->data, operation->length);
case BATCH_ERASE:
return store_erase(operation->slot, operation->offset, operation->length);
case BATCH_COPY:
return store_copy(operation->slot, operation->peer);
case BATCH_REVERSE:
return store_reverse(operation->slot);
case BATCH_ROTATE:
return store_rotate(operation->slot, operation->offset);
case BATCH_XOR:
return store_xor(operation->slot, operation->value);
case BATCH_FILL:
return store_fill(operation->slot, operation->value, operation->length);
case BATCH_SWAP: {
unsigned char temp[STORE_CAPACITY];
size_t first, second;
unsigned char *a = store_span(operation->slot);
unsigned char *b = store_span(operation->peer);
if (a == NULL || b == NULL) {
return STORE_BAD_SLOT;
}
if (operation->slot == operation->peer) {
return STORE_OK;
}
first = store_length(operation->slot);
second = store_length(operation->peer);
if (first) {
memcpy(temp, a, first);
}
store_write(operation->slot, b, second);
store_write(operation->peer, temp, first);
return STORE_OK;
}
default:
return STORE_BAD_RANGE;
}
}
int batch_apply(const batch_operation *operations, size_t count, size_t *failed_at)
{
saved_slot saved[STORE_SLOTS];
size_t index;
int result;
if (failed_at == NULL) {
return STORE_BAD_RANGE;
}
*failed_at = count;
if (count > BATCH_LIMIT || (count && operations == NULL)) {
*failed_at = 0;
return STORE_BAD_RANGE;
}
take_snapshot(saved);
for (index = 0; index < count; ++index) {
result = apply_one(&operations[index]);
if (result != STORE_OK) {
restore_snapshot(saved);
*failed_at = index;
return result;
}
}
return STORE_OK;
}
uint32_t batch_fingerprint(void)
{
uint32_t hash = 2166136261u;
int slot;
for (slot = 0; slot < STORE_SLOTS; ++slot) {
size_t index, length = store_length(slot);
unsigned char *data = store_span(slot);
hash ^= (unsigned char)slot;
hash *= 16777619u;
hash ^= (unsigned char)length;
hash *= 16777619u;
for (index = 0; index < length; ++index) {
hash ^= data[index];
hash *= 16777619u;
}
}
return hash;
}
int batch_export(int slot, unsigned char *output, size_t capacity, size_t *written)
{
size_t length;
unsigned char *data;
if (written == NULL || output == NULL) {
return STORE_BAD_RANGE;
}
*written = 0;
data = store_span(slot);
if (data == NULL) {
return STORE_BAD_SLOT;
}
length = store_length(slot);
if (capacity < length + 1) {
return STORE_TOO_LONG;
}
output[0] = (unsigned char)length;
if (length) {
memcpy(output + 1, data, length);
}
*written = length + 1;
return STORE_OK;
}
int batch_import(int slot, const unsigned char *input, size_t length)
{
size_t claimed;
if (input == NULL || length == 0) {
return STORE_BAD_RANGE;
}
claimed = input[0];
if (claimed > STORE_CAPACITY || length != claimed + 1) {
return STORE_BAD_RANGE;
}
return store_write(slot, input + 1, claimed);
}
int batch_slice(int slot, size_t offset, size_t length,
unsigned char *output, size_t capacity, size_t *written)
{
unsigned char *data;
size_t available;
if (output == NULL || written == NULL) {
return STORE_BAD_RANGE;
}
*written = 0;
data = store_span(slot);
if (data == NULL) {
return STORE_BAD_SLOT;
}
available = store_length(slot);
if (offset > available || length > available - offset) {
return STORE_BAD_RANGE;
}
if (capacity < length) {
return STORE_TOO_LONG;
}
if (length) {
memmove(output, data + offset, length);
}
*written = length;
return STORE_OK;
}