#include "unit_specifiers.h" #include 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(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