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

221 lines
5.6 KiB
C

#include "tx.h"
#include <ctype.h>
#include <errno.h>
#include <inttypes.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct command {
char op;
int count;
char *args[5];
};
static int decimal(const char *text, int *out)
{
if (!text || !*text)
return 0;
const char *digits = text;
if (*digits == '+' || *digits == '-')
++digits;
if (!*digits)
return 0;
for (const char *p = digits; *p; ++p) {
if (*p < '0' || *p > '9')
return 0;
}
errno = 0;
char *end;
long value = strtol(text, &end, 10);
if (errno || *end || value < INT_MIN || value > INT_MAX)
return 0;
*out = (int)value;
return 1;
}
static int hex_digit(char c)
{
if (c >= '0' && c <= '9')
return c - '0';
if (c >= 'a' && c <= 'f')
return c - 'a' + 10;
if (c >= 'A' && c <= 'F')
return c - 'A' + 10;
return -1;
}
static int payload(const char *text, uint8_t *data, int *length)
{
size_t n = strlen(text);
if (!n || n % 2 || n > TX_CAPACITY * 2)
return 0;
for (size_t i = 0; i < n; i += 2) {
int high = hex_digit(text[i]);
int low = hex_digit(text[i + 1]);
if (high < 0 || low < 0)
return 0;
data[i / 2] = (uint8_t)(high * 16 + low);
}
*length = (int)(n / 2);
return 1;
}
static int tokenize(char *line, struct command *c)
{
char *p = line;
while (isspace((unsigned char)*p))
++p;
if (!*p || *p == '#')
return 0;
c->op = *p++;
c->count = 0;
if (*p && !isspace((unsigned char)*p))
return -1;
while (*p) {
while (isspace((unsigned char)*p))
++p;
if (!*p)
break;
if (c->count == 5)
return -1;
c->args[c->count++] = p;
while (*p && !isspace((unsigned char)*p))
++p;
if (*p)
*p++ = '\0';
}
return 1;
}
static void print_data(const uint8_t *data, size_t length)
{
if (!length) {
putchar('-');
return;
}
for (size_t i = 0; i < length; ++i)
printf("%02x", (unsigned)data[i]);
}
static void print_stats(const struct tx_engine *e)
{
struct tx_stats s;
tx_statistics(e, &s);
printf("STATS %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64
" %" PRIu64 " %" PRIu64 " %" PRIu64 " %u %u\n",
s.begins, s.writes, s.submits, s.completed, s.failures,
s.cancelled, s.bytes, s.drafts, s.pending);
}
static void print_frame(const struct tx_engine *e, int id)
{
struct tx_frame f;
int rc = tx_inspect(e, id, &f);
printf("FRAME %d %d %d %zu %zu\n", rc, f.state, f.slot, f.length, f.covered);
}
static void print_device(const struct tx_engine *e, int id)
{
const struct port_descriptor *found = NULL;
int rc = TX_ABSENT;
if (id < 1 || id > 65535)
rc = TX_INVALID;
else {
for (int i = 0; i < TX_SLOTS; ++i) {
if (e->port.queue[i].active && e->port.queue[i].id == id)
found = &e->port.queue[i];
}
}
if (!found) {
printf("DEVICE %d 0 0 -\n", rc);
return;
}
printf("DEVICE 0 %d %zu ", id, found->length);
print_data(e->port.memory[found->slot], found->length);
putchar('\n');
}
static int numeric_args(const struct command *c, int count, int *values)
{
if (c->count != count)
return 0;
for (int i = 0; i < count; ++i) {
if (!decimal(c->args[i], &values[i]))
return 0;
}
return 1;
}
static int execute(struct tx_engine *e, const struct command *c)
{
int a[4];
int rc;
uint8_t bytes[TX_CAPACITY];
int length;
switch (c->op) {
case 'R':
if (!numeric_args(c, 1, a))
return 0;
rc = tx_init(e, a[0]);
break;
case 'B':
if (!numeric_args(c, 2, a))
return 0;
rc = tx_begin(e, a[0], a[1]);
break;
case 'W':
if (c->count != 3 || !decimal(c->args[0], &a[0]) ||
!decimal(c->args[1], &a[1]) || !payload(c->args[2], bytes, &length))
return 0;
rc = tx_write(e, a[0], a[1], bytes, length);
break;
case 'F':
if (!numeric_args(c, 4, a))
return 0;
rc = tx_fill(e, a[0], a[1], a[2], a[3]);
break;
case 'S':
case 'X':
case 'P':
case 'D':
if (!numeric_args(c, 1, a))
return 0;
if (c->op == 'P') {
print_frame(e, a[0]);
return 1;
}
if (c->op == 'D') {
print_device(e, a[0]);
return 1;
}
rc = c->op == 'S' ? tx_send(e, a[0]) : tx_cancel(e, a[0]);
break;
case 'C': {
if (!numeric_args(c, 2, a))
return 0;
struct tx_completion completion;
rc = tx_complete(e, a[0], a[1], &completion);
printf("COMPLETE %d %d %zu ", rc, completion.id, completion.length);
print_data(completion.data, completion.length);
putchar('\n');
return 1;
}
case 'Q':
if (c->count)
return 0;
print_stats(e);
return 1;
default:
return 0;
}
printf("RESULT %c %d\n", c->op, rc);
return 1;
}
int main(void)
{
struct tx_engine engine;
if (tx_init(&engine, 32) != TX_OK)
return 2;
char line[2048];
while (fgets(line, sizeof(line), stdin)) {
struct command c;
int parsed = tokenize(line, &c);
if (parsed < 0 || (parsed > 0 && !execute(&engine, &c)))
puts("ERROR");
}
if (ferror(stdin) || ferror(stdout))
return 2;
return 0;
}