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

193 lines
4.5 KiB
C

#include "relay_internal.h"
#include <limits.h>
#include <stddef.h>
static int relay_status_priority(enum relay_status status)
{
switch (status) {
case RELAY_OK:
return 0;
case RELAY_CLOSE_ERROR:
return 1;
case RELAY_WRITE_ERROR:
return 2;
case RELAY_DUP_ERROR:
return 3;
case RELAY_OPEN_ERROR:
return 4;
case RELAY_BAD_PLAN:
return 5;
}
return -1;
}
static int relay_status_known(enum relay_status status)
{
return relay_status_priority(status) >= 0;
}
static enum relay_status relay_preferred(enum relay_status left,
enum relay_status right)
{
if (relay_status_priority(left) >= relay_status_priority(right)) {
return left;
}
return right;
}
static void relay_ledger_clear_handles(struct relay_ledger *ledger)
{
ledger->original = -1;
ledger->duplicate = -1;
ledger->have_original = 0;
ledger->have_duplicate = 0;
ledger->closed_original = 0;
ledger->closed_duplicate = 0;
}
static void relay_ledger_clear_progress(struct relay_ledger *ledger)
{
ledger->frames_done = 0;
ledger->bytes_written = 0;
ledger->frame_bytes = 0;
ledger->active_frame = 0;
}
void relay_ledger_init(struct relay_ledger *ledger)
{
if (ledger == NULL) {
return;
}
ledger->status = RELAY_OK;
relay_ledger_clear_handles(ledger);
relay_ledger_clear_progress(ledger);
}
void relay_ledger_open(struct relay_ledger *ledger, int descriptor)
{
if (ledger == NULL) {
return;
}
if (descriptor < 0) {
relay_ledger_failure(ledger, RELAY_OPEN_ERROR);
return;
}
ledger->original = descriptor;
ledger->have_original = 1;
}
void relay_ledger_duplicate(struct relay_ledger *ledger, int descriptor)
{
if (ledger == NULL) {
return;
}
if (descriptor < 0) {
relay_ledger_failure(ledger, RELAY_DUP_ERROR);
return;
}
ledger->duplicate = descriptor;
ledger->have_duplicate = 1;
}
void relay_ledger_begin(struct relay_ledger *ledger, size_t index)
{
if (ledger == NULL) {
return;
}
ledger->active_frame = index;
ledger->frame_bytes = 0;
}
static int relay_add_would_overflow(size_t left, size_t right)
{
return right > ((size_t)-1) - left;
}
void relay_ledger_advance(struct relay_ledger *ledger, size_t count)
{
if (ledger == NULL) {
return;
}
if (relay_add_would_overflow(ledger->bytes_written, count)) {
relay_ledger_failure(ledger, RELAY_WRITE_ERROR);
return;
}
if (relay_add_would_overflow(ledger->frame_bytes, count)) {
relay_ledger_failure(ledger, RELAY_WRITE_ERROR);
return;
}
ledger->bytes_written += count;
ledger->frame_bytes += count;
}
void relay_ledger_finish(struct relay_ledger *ledger, size_t packet_length)
{
if (ledger == NULL) {
return;
}
if (ledger->status != RELAY_OK) {
return;
}
if (ledger->frame_bytes != packet_length) {
relay_ledger_failure(ledger, RELAY_WRITE_ERROR);
return;
}
if (ledger->active_frame != ledger->frames_done) {
relay_ledger_failure(ledger, RELAY_WRITE_ERROR);
return;
}
++ledger->frames_done;
}
void relay_ledger_failure(struct relay_ledger *ledger, enum relay_status status)
{
if (ledger == NULL) {
return;
}
if (!relay_status_known(status)) {
return;
}
ledger->status = relay_preferred(ledger->status, status);
}
void relay_ledger_closed(struct relay_ledger *ledger, int descriptor)
{
if (ledger == NULL) {
return;
}
if (ledger->have_duplicate && descriptor == ledger->duplicate) {
ledger->closed_duplicate = 1;
return;
}
if (ledger->have_original && descriptor == ledger->original) {
ledger->closed_original = 1;
}
}
static size_t relay_visible_frames(const struct relay_ledger *ledger)
{
if (ledger->frames_done > 24) {
return 24;
}
return ledger->frames_done;
}
static enum relay_status relay_visible_status(const struct relay_ledger *ledger)
{
if (!relay_status_known(ledger->status)) {
return RELAY_WRITE_ERROR;
}
return ledger->status;
}
void relay_ledger_publish(const struct relay_ledger *ledger,
struct relay_report *report)
{
if (ledger == NULL || report == NULL) {
return;
}
report->status = relay_visible_status(ledger);
report->frames_done = relay_visible_frames(ledger);
report->bytes_written = ledger->bytes_written;
}