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

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;
}
}