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>
185 lines
7.9 KiB
C++
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; }
|
|
}
|