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>
314 lines
11 KiB
C++
314 lines
11 KiB
C++
#include "module_plan.h"
|
|
#include <cstdlib>
|
|
#include <iostream>
|
|
#include <memory>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
using namespace bootplan;
|
|
namespace {
|
|
|
|
void string(const std::string &value)
|
|
{
|
|
const char *digits = "0123456789abcdef";
|
|
std::cout << '"';
|
|
for (unsigned char byte : value) {
|
|
if (byte == '"' || byte == '\\') {
|
|
std::cout << '\\' << static_cast<char>(byte);
|
|
} else if (byte < 32 || byte >= 127) {
|
|
std::cout << "\\u00" << digits[byte >> 4] << digits[byte & 15];
|
|
} else {
|
|
std::cout << static_cast<char>(byte);
|
|
}
|
|
}
|
|
std::cout << '"';
|
|
}
|
|
|
|
void strings(const std::vector<std::string> &items)
|
|
{
|
|
std::cout << '[';
|
|
for (std::size_t index = 0; index < items.size(); ++index) {
|
|
if (index != 0) std::cout << ',';
|
|
string(items[index]);
|
|
}
|
|
std::cout << ']';
|
|
}
|
|
|
|
void loads(const std::vector<Load> &items)
|
|
{
|
|
std::cout << '[';
|
|
for (std::size_t index = 0; index < items.size(); ++index) {
|
|
if (index != 0) std::cout << ',';
|
|
std::cout << '[';
|
|
string(items[index].module);
|
|
std::cout << ',';
|
|
strings(items[index].options);
|
|
std::cout << ']';
|
|
}
|
|
std::cout << ']';
|
|
}
|
|
|
|
void snapshot(const Snapshot &state)
|
|
{
|
|
std::cout << '[' << (state.busy ? "true" : "false") << ',';
|
|
loads(state.committed);
|
|
std::cout << ',';
|
|
loads(state.staged);
|
|
std::cout << ',';
|
|
strings(state.skipped);
|
|
std::cout << ',';
|
|
strings(state.missing);
|
|
std::cout << ',';
|
|
strings(state.pending_missing);
|
|
std::cout << ',' << state.accepted << ',' << state.suppressed
|
|
<< ',' << state.failed << ',' << state.cancelled << ']';
|
|
}
|
|
|
|
void configuration(const Configuration &config)
|
|
{
|
|
std::cout << '[';
|
|
strings(config.available);
|
|
std::cout << ',';
|
|
strings(config.selected_files);
|
|
std::cout << ',';
|
|
strings(config.blacklist);
|
|
std::cout << ",[";
|
|
for (std::size_t index = 0; index < config.options.size(); ++index) {
|
|
if (index != 0) std::cout << ',';
|
|
std::cout << '[';
|
|
string(config.options[index].module);
|
|
std::cout << ',';
|
|
strings(config.options[index].tokens);
|
|
std::cout << ']';
|
|
}
|
|
std::cout << "],[";
|
|
for (std::size_t index = 0; index < config.dependencies.size(); ++index) {
|
|
if (index != 0) std::cout << ',';
|
|
const Dependency &item = config.dependencies[index];
|
|
std::cout << '[';
|
|
string(item.module);
|
|
std::cout << ',';
|
|
strings(item.pre);
|
|
std::cout << ',';
|
|
strings(item.post);
|
|
std::cout << ']';
|
|
}
|
|
std::cout << "]]";
|
|
}
|
|
|
|
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;
|
|
throw std::runtime_error("invalid hexadecimal input");
|
|
}
|
|
|
|
std::string bytes()
|
|
{
|
|
std::string token;
|
|
if (!(std::cin >> token)) throw std::runtime_error("missing token");
|
|
if (token == "-") return {};
|
|
if (token.size() % 2) throw std::runtime_error("odd hexadecimal token");
|
|
std::string result;
|
|
for (std::size_t index = 0; index < token.size(); index += 2) {
|
|
result.push_back(static_cast<char>(nibble(token[index]) * 16 + nibble(token[index + 1])));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
std::size_t count()
|
|
{
|
|
std::size_t value;
|
|
if (!(std::cin >> value) || value > 300000) throw std::runtime_error("bad count");
|
|
return value;
|
|
}
|
|
|
|
void expect(const std::string &wanted)
|
|
{
|
|
std::string token;
|
|
if (!(std::cin >> token) || token != wanted) throw std::runtime_error("bad row");
|
|
}
|
|
|
|
bool same_directories(const std::vector<Directory> &left,
|
|
const std::vector<Directory> &right)
|
|
{
|
|
if (left.size() != right.size()) return false;
|
|
for (std::size_t d = 0; d < left.size(); ++d) {
|
|
if (left[d].size() != right[d].size()) return false;
|
|
for (std::size_t f = 0; f < left[d].size(); ++f) {
|
|
if (left[d][f].basename != right[d][f].basename ||
|
|
left[d][f].text != right[d][f].text) return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool same_requests(const std::vector<Request> &left,
|
|
const std::vector<Request> &right)
|
|
{
|
|
if (left.size() != right.size()) return false;
|
|
for (std::size_t index = 0; index < left.size(); ++index) {
|
|
if (left[index].module != right[index].module ||
|
|
left[index].via_alias != right[index].via_alias) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void unchanged(bool value)
|
|
{
|
|
std::cout << ',' << (value ? "true" : "false");
|
|
}
|
|
|
|
struct Bank {
|
|
std::vector<Directory> directories;
|
|
std::vector<std::string> available;
|
|
std::unique_ptr<Planner> planner;
|
|
Snapshot held;
|
|
|
|
Bank() : planner(new Planner(Configuration{})) {}
|
|
};
|
|
|
|
}
|
|
|
|
int main()
|
|
{
|
|
try {
|
|
Bank banks[3];
|
|
std::size_t selected = 0;
|
|
std::string command;
|
|
while (std::cin >> command) {
|
|
if (command == "G") {
|
|
selected = count();
|
|
if (selected >= 3) return 2;
|
|
std::cout << "[\"G\",";
|
|
snapshot(banks[selected].planner->snapshot());
|
|
std::cout << "]\n";
|
|
continue;
|
|
}
|
|
Bank &bank = banks[selected];
|
|
if (command == "C") {
|
|
const std::size_t directories = count();
|
|
const std::size_t available = count();
|
|
bank.directories.clear();
|
|
bank.available.clear();
|
|
for (std::size_t index = 0; index < directories; ++index) {
|
|
expect("D");
|
|
const std::size_t files = count();
|
|
Directory directory;
|
|
for (std::size_t file = 0; file < files; ++file) {
|
|
expect("F");
|
|
File entry;
|
|
entry.basename = bytes();
|
|
entry.text = bytes();
|
|
directory.push_back(std::move(entry));
|
|
}
|
|
bank.directories.push_back(std::move(directory));
|
|
}
|
|
for (std::size_t index = 0; index < available; ++index) {
|
|
expect("A");
|
|
bank.available.push_back(bytes());
|
|
}
|
|
const auto original_directories = bank.directories;
|
|
const auto original_available = bank.available;
|
|
Configuration compiled;
|
|
compiled.available = {"old_available"};
|
|
compiled.selected_files = {"old.conf"};
|
|
compiled.blacklist = {"old_blacklist"};
|
|
compiled.options = {{"old_option", {"old=1"}}};
|
|
compiled.dependencies = {{"old_dependency", {"old_pre"}, {"old_post"}}};
|
|
const Error result = compile_configuration(bank.directories, bank.available, compiled);
|
|
std::cout << "[\"C\"," << static_cast<int>(result) << ',';
|
|
configuration(compiled);
|
|
unchanged(same_directories(original_directories, bank.directories) &&
|
|
original_available == bank.available);
|
|
std::cout << "]\n";
|
|
if (result == Error::none) bank.planner.reset(new Planner(compiled));
|
|
} else if (command == "N") {
|
|
const std::string input = bytes();
|
|
const std::string original = input;
|
|
std::string output = "previous-value";
|
|
const bool result = canonical_module(input, output);
|
|
std::cout << "[\"N\"," << (result ? "true" : "false") << ',';
|
|
string(output);
|
|
unchanged(original == input);
|
|
std::cout << "]\n";
|
|
} else if (command == "L") {
|
|
const std::string input = bytes();
|
|
const std::string original = input;
|
|
std::vector<std::vector<std::string>> output = {{"previous-value"}};
|
|
const Error result = statements(input, output);
|
|
std::cout << "[\"L\"," << static_cast<int>(result) << ",[";
|
|
for (std::size_t index = 0; index < output.size(); ++index) {
|
|
if (index != 0) std::cout << ',';
|
|
strings(output[index]);
|
|
}
|
|
std::cout << ']';
|
|
unchanged(original == input);
|
|
std::cout << "]\n";
|
|
} else if (command == "P") {
|
|
const std::size_t requests = count();
|
|
std::vector<Request> input;
|
|
for (std::size_t index = 0; index < requests; ++index) {
|
|
expect("Q");
|
|
const std::string name = bytes();
|
|
const std::size_t flag = count();
|
|
if (flag > 1) return 2;
|
|
input.push_back(Request{name, flag != 0});
|
|
}
|
|
const auto original_directories = bank.directories;
|
|
const auto original_available = bank.available;
|
|
const auto original_requests = input;
|
|
const BatchResult result = plan(bank.directories, bank.available, input);
|
|
std::cout << "[\"P\"," << static_cast<int>(result.error) << ',';
|
|
loads(result.load);
|
|
std::cout << ',';
|
|
strings(result.skipped);
|
|
std::cout << ',';
|
|
strings(result.missing);
|
|
std::cout << ',';
|
|
strings(result.selected_files);
|
|
unchanged(same_directories(original_directories, bank.directories) &&
|
|
original_available == bank.available && same_requests(original_requests, input));
|
|
std::cout << "]\n";
|
|
} else if (command == "B") {
|
|
const std::string name = bytes();
|
|
const std::size_t flag = count();
|
|
if (flag > 1) return 2;
|
|
const Request request{name, flag != 0};
|
|
const Request original = request;
|
|
const Error result = bank.planner->begin(request);
|
|
std::cout << "[\"B\"," << static_cast<int>(result) << ',';
|
|
snapshot(bank.planner->snapshot());
|
|
unchanged(request.module == original.module && request.via_alias == original.via_alias);
|
|
std::cout << "]\n";
|
|
} else if (command == "T") {
|
|
const Event result = bank.planner->tick();
|
|
std::cout << "[\"T\"," << static_cast<int>(result.error) << ','
|
|
<< static_cast<int>(result.kind) << ',';
|
|
string(result.module);
|
|
std::cout << ',';
|
|
snapshot(bank.planner->snapshot());
|
|
std::cout << "]\n";
|
|
} else if (command == "S" || command == "X" || command == "R" ||
|
|
command == "H" || command == "J") {
|
|
if (command == "X") bank.planner->cancel();
|
|
if (command == "R") bank.planner->reset();
|
|
if (command == "H") bank.held = bank.planner->snapshot();
|
|
std::cout << '[';
|
|
string(command);
|
|
std::cout << ',';
|
|
snapshot(command == "J" ? bank.held : bank.planner->snapshot());
|
|
std::cout << "]\n";
|
|
} else {
|
|
return 2;
|
|
}
|
|
}
|
|
return std::cin.bad() ? 2 : 0;
|
|
} catch (const std::exception &error) {
|
|
std::cerr << error.what() << '\n';
|
|
return 2;
|
|
}
|
|
}
|