amos 913d3c367f Add the usable task catalog and admit batch 6 tasks
All 161 task packages, including the 21 batch 6 C++17 tasks that passed
gates 1/2, are now in Git. rollout.catalog builds docs/task-catalog.{json,md}
from the task packages, a fresh trace5 calibration (128/128 PASS), every
verified controller receipt on the current task digest, documented holds
and digest-bound difficulty reviews. 123 tasks are usable (6 HARD),
5 are on hold and 33 still need a subprocess-only grader.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-18 17:43:15 +08:00

119 lines
4.3 KiB
C++

#include "unit_specifiers.h"
#include <utility>
namespace unit_specifiers {
namespace {
bool instruction(char code, PieceKind& kind) {
switch (code) {
case 'n': kind = PieceKind::entire_unit; return true;
case 'p': kind = PieceKind::prefix; return true;
case 'i': kind = PieceKind::instance; return true;
case 'I': kind = PieceKind::decoded_instance; return true;
case '%': kind = PieceKind::percent; return true;
default: return false;
}
}
bool valid_program(const Program& program) {
if (program.pieces.size() > 4096) return false;
std::size_t literal_bytes = 0;
for (const Piece& piece : program.pieces) {
const int kind = static_cast<int>(piece.kind);
if (kind < 0 || kind > 5) return false;
if (piece.kind == PieceKind::literal) {
if (piece.text.size() > 4096 - literal_bytes || !valid_utf8(piece.text))
return false;
literal_bytes += piece.text.size();
} else if (!piece.text.empty()) {
return false;
}
}
return true;
}
std::string_view replacement(PieceKind kind, const ServiceName& name) {
switch (kind) {
case PieceKind::entire_unit: return name.unit;
case PieceKind::prefix: return name.prefix;
case PieceKind::instance: return name.instance;
case PieceKind::decoded_instance: return name.decoded_instance;
case PieceKind::percent: return "%";
default: return {};
}
}
bool resolve_interpolation(std::string_view source, const ServiceName& name,
std::string& output) {
Program nested;
if (compile_template(source, nested) != Error::none) return false;
std::string result;
for (const Piece& piece : nested.pieces) {
const std::string_view text = piece.kind == PieceKind::literal
? std::string_view(piece.text)
: replacement(piece.kind, name);
if (text.size() > 65536 - result.size()) return false;
if (!text.empty()) result.append(text.data(), text.size());
}
output = std::move(result);
return true;
}
} // namespace
Error compile_template(std::string_view text, Program& output) {
output.pieces.clear();
if (text.size() > 4096 || !valid_utf8(text)) return Error::invalid;
Program compiled;
std::string literal;
auto flush_literal = [&]() {
if (!literal.empty()) {
compiled.pieces.push_back({PieceKind::literal, std::move(literal)});
literal.clear();
}
};
for (std::size_t index = 0; index < text.size(); ++index) {
if (text[index] != '%') {
literal.push_back(text[index]);
continue;
}
if (++index == text.size()) return Error::invalid;
PieceKind kind;
if (!instruction(text[index], kind)) return Error::invalid;
flush_literal();
compiled.pieces.push_back({kind, {}});
}
flush_literal();
output = std::move(compiled);
return Error::none;
}
Error render(const Program& program, std::string_view unit,
std::size_t capacity, std::string& output) {
output.clear();
if (capacity > 65536 || !valid_program(program)) return Error::invalid;
ServiceName name;
if (parse_unit(unit, name) != Error::none) return Error::invalid;
std::string result;
for (const Piece& piece : program.pieces) {
std::string inserted;
std::string_view value = piece.kind == PieceKind::literal
? std::string_view(piece.text)
: replacement(piece.kind, name);
if (piece.kind == PieceKind::decoded_instance) {
if (!resolve_interpolation(value, name, inserted)) return Error::invalid;
value = inserted;
}
if (value.size() > capacity - result.size()) return Error::invalid;
if (!value.empty()) result.append(value.data(), value.size());
}
output = std::move(result);
return Error::none;
}
Error expand(std::string_view text, std::string_view unit,
std::size_t capacity, std::string& output) {
output.clear();
Program program;
if (compile_template(text, program) != Error::none) return Error::invalid;
return render(program, unit, capacity, output);
}
} // namespace unit_specifiers