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

125 lines
3.2 KiB
C++

#include "capture.hpp"
#include <sstream>
namespace capture {
namespace {
int nibble(char value)
{
if (value >= '0' && value <= '9') {
return value - '0';
}
if (value >= 'a' && value <= 'f') {
return value - 'a' + 10;
}
if (value >= 'A' && value <= 'F') {
return value - 'A' + 10;
}
return -1;
}
}
Status decode_hex(const std::string& text, std::vector<std::uint8_t>* out)
{
if (out == nullptr) {
return Status::invalid;
}
if (text == "-") {
out->clear();
return Status::ok;
}
if (text.empty() || text.size() % 2 != 0) {
return Status::invalid;
}
for (char value : text) {
if (nibble(value) < 0) {
return Status::invalid;
}
}
if (text.size() / 2 > payload_limit) {
return Status::capacity;
}
std::vector<std::uint8_t> decoded;
decoded.reserve(text.size() / 2);
for (std::size_t cursor = 0; cursor < text.size(); cursor += 2) {
unsigned high = static_cast<unsigned>(nibble(text[cursor]));
unsigned low = static_cast<unsigned>(nibble(text[cursor + 1]));
decoded.push_back(static_cast<std::uint8_t>((high << 4) | low));
}
*out = decoded;
return Status::ok;
}
Status encode_hex(const std::vector<std::uint8_t>& data, std::string* out)
{
if (out == nullptr) {
return Status::invalid;
}
if (data.size() > payload_limit) {
return Status::capacity;
}
if (data.empty()) {
*out = "-";
return Status::ok;
}
static const char digits[] = "0123456789abcdef";
std::string encoded;
encoded.reserve(data.size() * 2);
for (std::uint8_t value : data) {
encoded.push_back(digits[value >> 4]);
encoded.push_back(digits[value & 15]);
}
*out = encoded;
return Status::ok;
}
std::uint32_t payload_digest(const std::vector<std::uint8_t>& data)
{
std::uint32_t digest = 2166136261u;
for (std::uint8_t value : data) {
digest ^= value;
digest *= 16777619u;
}
return digest;
}
const char* status_name(Status status)
{
switch (status) {
case Status::ok:
return "OK";
case Status::invalid:
return "INVALID";
case Status::range:
return "RANGE";
case Status::missing:
return "MISSING";
case Status::capacity:
return "CAPACITY";
}
return "INVALID";
}
Status format_entry(const Entry& entry, std::string* out)
{
if (out == nullptr || !entry.present || entry.stamp.nsec < 0 ||
entry.stamp.nsec >= 1000000000 || entry.sequence == 0 ||
entry.sequence > capture_limit || entry.payload.size() > payload_limit) {
return Status::invalid;
}
std::string encoded;
Status status = encode_hex(entry.payload, &encoded);
if (status != Status::ok) {
return status;
}
std::ostringstream stream;
stream << "{\"sec\":" << entry.stamp.sec;
stream << ",\"nsec\":" << entry.stamp.nsec;
stream << ",\"sequence\":" << entry.sequence;
stream << ",\"length\":" << entry.payload.size();
stream << ",\"hex\":\"" << encoded << "\"";
stream << ",\"hash\":" << payload_digest(entry.payload) << "}";
*out = stream.str();
return Status::ok;
}
}