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>
130 lines
4.3 KiB
C
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;
|
|
}
|