amos 8b7616bfd8 Batch 22 (20261027-C-hwe-hard-22): add 63 calibrated HWE hard-design tasks
From the 101 lk/man/pth code-gen sources: 63 tasks (C11 36, C++17 27,
11 canonical families), 38 skipped for scope or duplication. Each task
has at least one independent contract-edge defect, boundary types
rotate, and public docs state trap clauses as plain contract prose.
Claude reviewed 63/63 USABLE against current digests. Difficulty is
unmeasured.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 16:14:57 +08:00

130 lines
4.3 KiB
C

#include "array.h"
#include <string.h>
void lb_session_init(struct lb_session *session)
{
memset(session, 0, sizeof(*session));
}
static void release_prefix(struct lb_bus *bus, const struct lb_line *lines,
int acquired)
{
while (acquired > 0) {
--acquired;
bus->ops->release(bus->context, lines[acquired].pin);
}
}
static int request_lines(struct lb_bus *bus, const struct lb_line *lines,
int count)
{
for (int index = 0; index < count; ++index) {
int valid = lines[index].pin >= 0 && lines[index].pin < LB_PIN_COUNT;
valid = valid && (lines[index].active_low == 0 || lines[index].active_low == 1);
valid = valid && (lines[index].initial == 0 || lines[index].initial == 1);
for (int earlier = 0; earlier < index; ++earlier)
if (lines[earlier].pin == lines[index].pin)
valid = 0;
if (!valid) {
release_prefix(bus, lines, index);
return LB_INVALID;
}
int result = bus->ops->request(bus->context, lines[index].pin);
if (result != 0) {
release_prefix(bus, lines, index);
return LB_IO;
}
}
return LB_OK;
}
static int configure_lines(struct lb_bus *bus, const struct lb_line *lines,
int count)
{
for (int index = 0; index < count; ++index) {
int raw = lb_physical(lines[index].active_low, lines[index].initial);
if (bus->ops->direction(bus->context, lines[index].pin, raw) != 0) {
release_prefix(bus, lines, count);
return LB_IO;
}
}
return LB_OK;
}
static void publish_plan(struct lb_session *session,
const struct lb_line *lines, int count)
{
session->active = 1;
session->count = count;
++session->generation;
for (int index = 0; index < count; ++index) {
session->pins[index] = lines[index].pin;
session->active_low[index] = lines[index].active_low;
session->logical[index] = lines[index].initial;
}
}
int lb_open(struct lb_session *session, struct lb_bus *bus,
const struct lb_line *lines, int count)
{
if (lb_plan_validate(lines, count) != LB_OK)
return LB_INVALID;
if (session->active)
return LB_ACTIVE;
int result = request_lines(bus, lines, count);
if (result != LB_OK)
return result;
result = configure_lines(bus, lines, count);
if (result != LB_OK)
return result;
publish_plan(session, lines, count);
return LB_OK;
}
static int validate_values(const int *values, int count)
{
if (count < 0 || count > LB_MAX_LINES)
return LB_INVALID;
if (count != 0 && values == 0)
return LB_INVALID;
for (int index = 0; index < count; ++index) {
if (values[index] != 0 && values[index] != 1)
return LB_INVALID;
}
return LB_OK;
}
static void restore_values(struct lb_session *session, struct lb_bus *bus,
int completed)
{
while (completed > 0) {
--completed;
int raw = lb_physical(session->active_low[completed],
session->logical[completed]);
bus->ops->write(bus->context, session->pins[completed], raw);
}
}
int lb_apply(struct lb_session *session, struct lb_bus *bus,
const int *values, int count)
{
if (validate_values(values, count) != LB_OK)
return LB_INVALID;
if (!session->active)
return LB_ACTIVE;
if (count != session->count)
return LB_INVALID;
for (int index = 0; index < count; ++index) {
int raw = lb_physical(session->active_low[index], values[index]);
if (bus->ops->write(bus->context, session->pins[index], raw) != 0) {
restore_values(session, bus, index);
return LB_IO;
}
}
for (int index = 0; index < count; ++index)
session->logical[index] = values[index];
return LB_OK;
}
int lb_close(struct lb_session *session, struct lb_bus *bus)
{
if (!session->active)
return LB_OK;
for (int index = session->count; index > 0; --index)
bus->ops->release(bus->context, session->pins[index - 1]);
unsigned generation = session->generation;
lb_session_init(session);
session->generation = generation;
return LB_OK;
}