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

185 lines
7.9 KiB
C++

#include "unit_specifiers.h"
#include <algorithm>
#include <utility>
namespace unit_specifiers {
namespace {
// Re-scan a complete buffered prefix. No mutable decoder state is shared.
struct Utf { bool possible; std::size_t pending; };
Utf prefix(std::string_view s) {
std::size_t i=0;
while (i<s.size()) {
unsigned c=static_cast<unsigned char>(s[i]);
if(c<128) { ++i; continue; }
unsigned n=0;
if(c>=0xc2 && c<=0xdf) n=2;
else if(c>=0xe0 && c<=0xef) n=3;
else if(c>=0xf0 && c<=0xf4) n=4;
else return {false,0};
const std::size_t have=std::min<std::size_t>(n,s.size()-i);
for(std::size_t k=1;k<have;++k) {
unsigned x=static_cast<unsigned char>(s[i+k]);
if(x<0x80 || x>0xbf) return {false,0};
if(k==1 && ((c==0xe0 && x<0xa0)||(c==0xed && x>0x9f)||
(c==0xf0 && x<0x90)||(c==0xf4 && x>0x8f))) return {false,0};
}
if(have<n) return {true,have};
i+=n;
}
return {true,0};
}
bool safe(unsigned c) {
return (c>='a'&&c<='z')||(c>='A'&&c<='Z')||
(c>='0'&&c<='9')||c=='_'||c==':'||c=='.';
}
int hex(unsigned c) {
if(c>='0'&&c<='9') return static_cast<int>(c-'0');
if(c>='a'&&c<='f') return static_cast<int>(c-'a'+10);
if(c>='A'&&c<='F') return static_cast<int>(c-'A'+10);
return -1;
}
bool decode_prefix(std::string_view s,std::string& raw,std::size_t& pending) {
raw.clear(); pending=0;
for(std::size_t i=0;i<s.size();) {
unsigned c=static_cast<unsigned char>(s[i]);
if(safe(c)) { raw.push_back(static_cast<char>(c)); ++i; continue; }
if(c!='\\') return false;
std::size_t have=std::min<std::size_t>(4,s.size()-i);
if(have>=2 && s[i+1]!='x') return false;
if(have>=3 && hex(static_cast<unsigned char>(s[i+2]))<0) return false;
if(have>=4 && hex(static_cast<unsigned char>(s[i+3]))<0) return false;
if(have<4) { pending=have; return true; }
raw.push_back(static_cast<char>(hex(static_cast<unsigned char>(s[i+2]))*16+
hex(static_cast<unsigned char>(s[i+3]))));
i+=4;
}
return true;
}
}
bool valid_utf8(std::string_view s) { const auto v=prefix(s); return v.possible && !v.pending; }
Error escape(std::string_view s,std::string& out) {
out.clear();
if(s.size()>4096 || !valid_utf8(s)) return Error::invalid;
constexpr char h[]="0123456789abcdef";
for(std::size_t i=0;i<s.size();++i) {
unsigned c=static_cast<unsigned char>(s[i]);
if(safe(c) && !(i==0 && c=='.')) out.push_back(static_cast<char>(c));
else { out+="\\x"; out+=h[c>>4]; out+=h[c&15]; }
}
return Error::none;
}
Error unescape(std::string_view s,std::string& out) {
out.clear(); std::string raw; std::size_t n=0;
if(s.size()>16384 || !decode_prefix(s,raw,n) || n || !valid_utf8(raw)) return Error::invalid;
out=std::move(raw); return Error::none;
}
Error parse_unit(std::string_view s,ServiceName& out) {
out=ServiceName{};
if(s.size()<=8 || s.size()>4096 || s.substr(s.size()-8)!=".service") return Error::invalid;
auto stem=s.substr(0,s.size()-8); const auto at=stem.find('@');
if(at==0 || (at!=std::string_view::npos && (at+1==stem.size() || stem.find('@',at+1)!=std::string_view::npos))) return Error::invalid;
ServiceName r; r.unit=std::string(s); r.instantiated=at!=std::string_view::npos;
r.prefix=std::string(stem.substr(0,at));
if(r.instantiated) r.instance=std::string(stem.substr(at+1));
if(unescape(r.prefix,r.decoded_prefix)!=Error::none || unescape(r.instance,r.decoded_instance)!=Error::none) return Error::invalid;
out=std::move(r); return Error::none;
}
Error compile_template(std::string_view s,Program& out) {
out=Program{}; if(s.size()>4096 || !valid_utf8(s)) return Error::invalid;
Program p; std::string literal;
for(std::size_t i=0;i<s.size();++i) {
if(s[i]!='%') { literal+=s[i]; continue; }
if(!literal.empty()) { p.pieces.push_back({PieceKind::literal,std::move(literal)}); literal.clear(); }
if(++i==s.size()) return Error::invalid;
PieceKind k;
switch(s[i]) {
case '%':k=PieceKind::percent;break;
case 'n':k=PieceKind::entire_unit;break;
case 'p':k=PieceKind::prefix;break;
case 'i':k=PieceKind::instance;break;
case 'I':k=PieceKind::decoded_instance;break;
default:return Error::invalid;
}
p.pieces.push_back({k,{}});
}
if(!literal.empty()) p.pieces.push_back({PieceKind::literal,std::move(literal)});
out=std::move(p); return Error::none;
}
Error render(const Program& p,std::string_view unit,std::size_t cap,std::string& out) {
out.clear(); if(cap>65536 || p.pieces.size()>4096) return Error::invalid;
std::size_t total=0;
for(const auto& v:p.pieces) {
const int k=static_cast<int>(v.kind);
if(k<0||k>5) return Error::invalid;
if(k!=0 && !v.text.empty()) return Error::invalid;
if(k==0) {
if(v.text.size()>4096-total || !valid_utf8(v.text)) return Error::invalid;
total+=v.text.size();
}
}
ServiceName name; if(parse_unit(unit,name)!=Error::none) return Error::invalid;
std::string r;
for(const auto& v:p.pieces) {
std::string_view part;
switch(v.kind) {
case PieceKind::literal:part=v.text;break;
case PieceKind::entire_unit:part=name.unit;break;
case PieceKind::prefix:part=name.prefix;break;
case PieceKind::instance:part=name.instance;break;
case PieceKind::decoded_instance:part=name.decoded_instance;break;
case PieceKind::percent:part="%";break;
}
if(part.size()>cap-r.size()) return Error::invalid;
r.append(part.data(),part.size());
}
out=std::move(r); return Error::none;
}
Error expand(std::string_view s,std::string_view unit,std::size_t cap,std::string& out) {
Program p; out.clear();
if(compile_template(s,p)!=Error::none) return Error::invalid;
return render(p,unit,cap,out);
}
struct Stream::Impl {
StreamView state;
std::string accepted;
Error fail() {
state.phase=Phase::invalid; state.input_bytes=0;
state.utf8_pending=state.escape_pending=0; state.result.clear(); accepted.clear();
return Error::invalid;
}
};
Stream::Stream():impl_(new Impl) {}
Stream::~Stream()=default;
Error Stream::reset(Mode mode,std::size_t cap) {
if((mode!=Mode::escape && mode!=Mode::unescape)||cap>16384) return Error::invalid;
impl_->state=StreamView{}; impl_->state.mode=mode; impl_->state.capacity=cap; impl_->accepted.clear();
return Error::none;
}
Error Stream::feed(std::string_view chunk) {
auto& x=*impl_;
if(x.state.phase!=Phase::open) return Error::invalid;
std::size_t limit=x.state.mode==Mode::escape?4096:16384;
if(chunk.size()>limit-x.accepted.size()) return x.fail();
std::string next=x.accepted; if(!chunk.empty()) next.append(chunk.data(),chunk.size());
std::string raw; std::size_t ep=0;
if(x.state.mode==Mode::unescape && !decode_prefix(next,raw,ep)) return x.fail();
const auto v=prefix(x.state.mode==Mode::escape?std::string_view(next):std::string_view(raw));
if(!v.possible) return x.fail();
x.accepted=std::move(next); x.state.input_bytes=x.accepted.size();
x.state.utf8_pending=v.pending; x.state.escape_pending=ep;
return Error::none;
}
Error Stream::finish() {
auto& x=*impl_;
if(x.state.phase==Phase::finished) return Error::none;
if(x.state.phase==Phase::invalid) return Error::invalid;
if(x.state.utf8_pending || x.state.escape_pending) return x.fail();
std::string value;
const auto e=x.state.mode==Mode::escape?escape(x.accepted,value):unescape(x.accepted,value);
if(e!=Error::none || value.size()>x.state.capacity) return x.fail();
x.state.phase=Phase::finished; x.state.result=std::move(value);
return Error::none;
}
StreamView Stream::view() const { return impl_->state; }
}