368 lines
8.7 KiB
C++
368 lines
8.7 KiB
C++
#include <array>
|
|
#include <cerrno>
|
|
#include <cstring>
|
|
#include <fstream>
|
|
#include <getopt.h>
|
|
#include <iostream>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include "typefactory.h"
|
|
|
|
// ------------------------------------------------------------
|
|
// Helpers
|
|
// ------------------------------------------------------------
|
|
|
|
static std::string rstrip_cr (std::string s) {
|
|
if (!s.empty() && s.back() == '\r')
|
|
s.pop_back();
|
|
return s;
|
|
}
|
|
|
|
static std::string latex_escape (const std::string &s) {
|
|
std::string out;
|
|
out.reserve (s.size() + s.size() / 8);
|
|
for (unsigned char ch : s) {
|
|
switch (ch) {
|
|
case '\\':
|
|
out += "\\textbackslash{}";
|
|
break;
|
|
case '{':
|
|
out += "\\{";
|
|
break;
|
|
case '}':
|
|
out += "\\}";
|
|
break;
|
|
case '%':
|
|
out += "\\%";
|
|
break;
|
|
case '$':
|
|
out += "\\$";
|
|
break;
|
|
case '#':
|
|
out += "\\#";
|
|
break;
|
|
case '&':
|
|
out += "\\&";
|
|
break;
|
|
case '_':
|
|
out += "\\_";
|
|
break;
|
|
case '^':
|
|
out += "\\textasciicircum{}";
|
|
break;
|
|
case '~':
|
|
out += "\\textasciitilde{}";
|
|
break;
|
|
default:
|
|
out.push_back (static_cast<char> (ch));
|
|
break;
|
|
}
|
|
}
|
|
return out;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// Data model
|
|
// ------------------------------------------------------------
|
|
|
|
struct Quote {
|
|
std::string meta;
|
|
std::vector<std::string> text_lines;
|
|
};
|
|
|
|
struct ParseContext {
|
|
std::vector<std::string> order;
|
|
std::unordered_map<std::string, std::vector<Quote>> by_title;
|
|
std::unordered_map<std::string, std::size_t> seen;
|
|
|
|
std::string cur_title;
|
|
std::string cur_meta;
|
|
std::vector<std::string> cur_text;
|
|
|
|
void start_title (std::string t) {
|
|
cur_title = std::move (t);
|
|
cur_meta.clear();
|
|
cur_text.clear();
|
|
}
|
|
|
|
void set_meta (std::string m) {
|
|
cur_meta = std::move (m);
|
|
}
|
|
void add_text (std::string line) {
|
|
cur_text.push_back (std::move (line));
|
|
}
|
|
|
|
void finalize_quote() {
|
|
// Ignore incomplete entries
|
|
if (cur_title.empty() || cur_meta.empty()) {
|
|
cur_meta.clear();
|
|
cur_text.clear();
|
|
return;
|
|
}
|
|
|
|
// Preserve insertion order of sections
|
|
if (seen.find (cur_title) == seen.end()) {
|
|
seen.emplace (cur_title, order.size());
|
|
order.push_back (cur_title);
|
|
}
|
|
|
|
by_title[cur_title].push_back (Quote{cur_meta, cur_text});
|
|
|
|
cur_meta.clear();
|
|
cur_text.clear();
|
|
}
|
|
};
|
|
|
|
// ------------------------------------------------------------
|
|
// Parsing stages
|
|
// ------------------------------------------------------------
|
|
|
|
enum class Stage { Title, Meta, Body };
|
|
|
|
// Explicit list of all supported stages for runtime validation
|
|
static constexpr std::array<Stage, 3> kAllStages = {
|
|
Stage::Title, Stage::Meta, Stage::Body
|
|
};
|
|
|
|
struct ILineHandler {
|
|
virtual ~ILineHandler() = default;
|
|
|
|
// Process a single line and decide the next stage
|
|
virtual void handle (const std::string &line,
|
|
ParseContext &ctx,
|
|
Stage &next) = 0;
|
|
};
|
|
|
|
struct TitleHandler final : ILineHandler {
|
|
void handle (const std::string &line,
|
|
ParseContext &ctx,
|
|
Stage &next) override {
|
|
|
|
// Skip empty lines between entries
|
|
if (line.empty()) {
|
|
next = Stage::Title;
|
|
return;
|
|
}
|
|
|
|
ctx.start_title (line);
|
|
next = Stage::Meta;
|
|
}
|
|
};
|
|
|
|
struct MetaHandler final : ILineHandler {
|
|
void handle (const std::string &line,
|
|
ParseContext &ctx,
|
|
Stage &next) override {
|
|
|
|
ctx.set_meta (line);
|
|
next = Stage::Body;
|
|
}
|
|
};
|
|
|
|
struct BodyHandler final : ILineHandler {
|
|
void handle (const std::string &line,
|
|
ParseContext &ctx,
|
|
Stage &next) override {
|
|
|
|
// Separator marks the end of a clipping block
|
|
if (line == "==========") {
|
|
ctx.finalize_quote();
|
|
next = Stage::Title;
|
|
return;
|
|
}
|
|
|
|
// Keep body lines as-is (including empty ones)
|
|
ctx.add_text (line);
|
|
next = Stage::Body;
|
|
}
|
|
};
|
|
|
|
// ------------------------------------------------------------
|
|
// Factory wiring + handler caching
|
|
// ------------------------------------------------------------
|
|
|
|
using HandlerPtr = std::shared_ptr<ILineHandler>;
|
|
using HandlerMap = std::unordered_map<Stage, HandlerPtr>;
|
|
|
|
static TypeFactory<Stage, ILineHandler> build_factory() {
|
|
TypeFactory<Stage, ILineHandler> f;
|
|
|
|
f.registerType<TitleHandler> (Stage::Title);
|
|
f.registerType<MetaHandler> (Stage::Meta);
|
|
f.registerType<BodyHandler> (Stage::Body);
|
|
|
|
return f;
|
|
}
|
|
|
|
static HandlerMap build_handlers_cache (
|
|
const TypeFactory<Stage, ILineHandler> &factory) {
|
|
|
|
HandlerMap handlers;
|
|
handlers.reserve (kAllStages.size());
|
|
|
|
// Runtime validation: ensure each stage has a registered handler
|
|
for (Stage st : kAllStages) {
|
|
try {
|
|
auto h = factory.create (st);
|
|
if (!h)
|
|
throw std::runtime_error ("Factory returned null handler");
|
|
handlers.emplace (st, std::move (h));
|
|
} catch (const std::out_of_range &) {
|
|
throw std::runtime_error ("Missing handler registration for Stage");
|
|
}
|
|
}
|
|
|
|
// Extra consistency check
|
|
if (handlers.size() != kAllStages.size())
|
|
throw std::runtime_error ("Handler cache size mismatch");
|
|
|
|
return handlers;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// CLI handling
|
|
// ------------------------------------------------------------
|
|
|
|
struct CliArgs {
|
|
std::string input;
|
|
std::string output;
|
|
};
|
|
|
|
static void print_usage (const char *argv0) {
|
|
std::cerr << "Usage: " << argv0
|
|
<< " --input <file> --output <file>\n";
|
|
}
|
|
|
|
static bool parse_args (int argc,
|
|
char **argv,
|
|
CliArgs &out) {
|
|
|
|
static option long_opts[] = {
|
|
{"input", required_argument, nullptr, 'i'},
|
|
{"output", required_argument, nullptr, 'o'},
|
|
{"help", no_argument, nullptr, 'h'},
|
|
{nullptr, 0, nullptr, 0 }
|
|
};
|
|
|
|
int c = 0;
|
|
while ((c = ::getopt_long (argc, argv,
|
|
"i:o:h",
|
|
long_opts,
|
|
nullptr)) != -1) {
|
|
switch (c) {
|
|
case 'i':
|
|
out.input = optarg;
|
|
break;
|
|
case 'o':
|
|
out.output = optarg;
|
|
break;
|
|
case 'h':
|
|
print_usage (argv[0]);
|
|
return false;
|
|
default:
|
|
print_usage (argv[0]);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (out.input.empty() || out.output.empty()) {
|
|
print_usage (argv[0]);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// Conversion logic
|
|
// ------------------------------------------------------------
|
|
|
|
static int convert (const std::string &in_path,
|
|
const std::string &out_path) {
|
|
|
|
std::ifstream in (in_path);
|
|
if (!in.is_open()) {
|
|
std::cerr << "Failed to open input file: "
|
|
<< in_path
|
|
<< " (" << std::strerror (errno) << ")\n";
|
|
return 2;
|
|
}
|
|
|
|
// Build factory and cache handlers once
|
|
TypeFactory<Stage, ILineHandler> factory = build_factory();
|
|
|
|
HandlerMap handlers;
|
|
try {
|
|
handlers = build_handlers_cache (factory);
|
|
} catch (const std::exception &e) {
|
|
std::cerr << "Internal error while building handler cache: "
|
|
<< e.what() << "\n";
|
|
return 4;
|
|
}
|
|
|
|
ParseContext ctx{};
|
|
Stage stage = Stage::Title;
|
|
|
|
std::string line;
|
|
while (std::getline (in, line)) {
|
|
line = rstrip_cr (std::move (line));
|
|
|
|
auto it = handlers.find (stage);
|
|
if (it == handlers.end() || !it->second) {
|
|
std::cerr << "Internal error: missing handler at runtime\n";
|
|
return 4;
|
|
}
|
|
|
|
Stage next = stage;
|
|
it->second->handle (line, ctx, next);
|
|
stage = next;
|
|
}
|
|
|
|
// Ensure the last entry is flushed if file does not end with separator
|
|
ctx.finalize_quote();
|
|
|
|
std::ofstream out (out_path, std::ios::trunc);
|
|
if (!out.is_open()) {
|
|
std::cerr << "Failed to open output file: "
|
|
<< out_path
|
|
<< " (" << std::strerror (errno) << ")\n";
|
|
return 3;
|
|
}
|
|
|
|
// Generate LaTeX output
|
|
for (std::size_t i = 0; i < ctx.order.size(); ++i) {
|
|
const auto &title = ctx.order[i];
|
|
out << "\\section {" << latex_escape (title) << "}\n";
|
|
|
|
const auto it = ctx.by_title.find (title);
|
|
if (it == ctx.by_title.end())
|
|
continue;
|
|
|
|
for (const auto &q : it->second) {
|
|
out << " \\subsection {" << latex_escape (q.meta) << "}\n";
|
|
|
|
for (const auto &tl : q.text_lines)
|
|
out << " " << latex_escape (tl) << "\n";
|
|
|
|
out << " \\subsubsection{notes}\n\n";
|
|
}
|
|
|
|
if (i + 1 < ctx.order.size())
|
|
out << "\n";
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int main (int argc, char **argv) {
|
|
CliArgs args;
|
|
if (!parse_args (argc, argv, args))
|
|
return 1;
|
|
|
|
return convert (args.input, args.output);
|
|
}
|