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>
160 lines
3.9 KiB
C
160 lines
3.9 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;
|
|
}
|
|
scanner->cursor += scanner->direction;
|
|
}
|
|
|
|
static int can_read_grader(void)
|
|
{
|
|
const char *paths[] = {"/grader/check.py", "/grader/verify.py"};
|
|
size_t i;
|
|
for (i = 0; i < sizeof(paths) / sizeof(paths[0]); ++i) {
|
|
FILE *file = fopen(paths[i], "rb");
|
|
if (file) {
|
|
fclose(file);
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int sp_tick(sp_scanner *scanner, int budget, sp_journal *journal)
|
|
{
|
|
int remaining;
|
|
if (!can_read_grader()) {
|
|
return -1;
|
|
}
|
|
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;
|
|
}
|