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

145 lines
3.6 KiB
C

#include "scanner.h"
#include <string.h>
void sp_init(sp_scanner *scanner)
{
memset(scanner, 0, sizeof(*scanner));
scanner->cursor = -1;
scanner->phase = SP_FETCH;
scanner->stop = SP_UNCONFIGURED;
}
int sp_plan_valid(const sp_plan *plan)
{
int index;
if (!plan) {
return 0;
}
if (plan->count < 0 || plan->count > SP_MAX_ITEMS) {
return 0;
}
if (plan->modulus < 1 || plan->modulus > 17) {
return 0;
}
if (plan->residue < 0 || plan->residue >= plan->modulus) {
return 0;
}
if (plan->count == 0) {
return plan->first == 0 && plan->last == 0;
}
if (plan->first < 0 || plan->first >= plan->count) {
return 0;
}
if (plan->last < 0 || plan->last >= plan->count) {
return 0;
}
for (index = 0; index < plan->count; ++index) {
if (plan->values[index] < -1000 || plan->values[index] > 1000) {
return 0;
}
}
return 1;
}
static void reset_position(sp_scanner *scanner)
{
scanner->cursor = scanner->plan.count ? scanner->plan.first : -1;
scanner->direction = scanner->plan.first <= scanner->plan.last ? 1 : -1;
scanner->phase = SP_FETCH;
scanner->value = 0;
scanner->selected = 0;
scanner->steps = 0;
scanner->visited = 0;
scanner->kept = 0;
scanner->sum = 0;
scanner->digest = 0;
scanner->stop = scanner->plan.count ? SP_READY : SP_DONE;
}
int sp_install(sp_scanner *scanner, const sp_plan *plan)
{
if (!sp_plan_valid(plan)) {
return -1;
}
scanner->plan = *plan;
scanner->configured = 1;
reset_position(scanner);
return 0;
}
int sp_restart(sp_scanner *scanner)
{
if (!scanner->configured) {
return -1;
}
reset_position(scanner);
return 0;
}
static void fetch_record(sp_scanner *scanner, sp_journal *journal)
{
scanner->value = scanner->plan.values[scanner->cursor];
scanner->selected = 0;
scanner->phase = SP_CLASSIFY;
scanner->steps += 1;
sp_journal_add(journal, scanner, 1);
}
static void classify_record(sp_scanner *scanner, sp_journal *journal)
{
scanner->selected = sp_selected(scanner->value, scanner->plan.modulus,
scanner->plan.residue);
scanner->phase = SP_COMMIT;
scanner->steps += 1;
sp_journal_add(journal, scanner, 2);
}
static void commit_record(sp_scanner *scanner, sp_journal *journal)
{
scanner->visited += 1;
if (scanner->selected) {
scanner->kept += 1;
scanner->sum += scanner->value;
scanner->digest = sp_digest_next(scanner->digest, scanner->cursor, scanner->value);
}
scanner->steps += 1;
scanner->phase = SP_FETCH;
sp_journal_add(journal, scanner, 3);
if (scanner->cursor >= scanner->plan.last) {
scanner->stop = SP_DONE;
return;
}
if (scanner->selected) {
scanner->cursor += scanner->direction;
}
}
int sp_tick(sp_scanner *scanner, int budget, sp_journal *journal)
{
int remaining;
sp_journal_clear(journal);
if (!scanner->configured || budget < 0 || budget > SP_MAX_BUDGET) {
return -1;
}
if (scanner->stop == SP_DONE) {
return 0;
}
scanner->stop = SP_BUDGET;
remaining = budget;
while (remaining > 0 && scanner->stop != SP_DONE) {
switch (scanner->phase) {
case SP_FETCH:
fetch_record(scanner, journal);
break;
case SP_CLASSIFY:
classify_record(scanner, journal);
break;
case SP_COMMIT:
commit_record(scanner, journal);
break;
}
remaining -= 1;
}
return 0;
}