Andy Kopra
37b6ba1c4f
Typographic transforms (---, quote pairs, ~) no longer touch verbatim text: @c/@code/@source_listing content and ^'...'^ spans show exactly the characters written. "^" before any punctuation character quotes it in every target (the apostrophe excepted: ^' opens a literal span), with the new :resolve option on @@@target declaring per-target renderings. The ^UUUU^ code-point form accepts 4-6 hex digits, the full Unicode range. The html output and transform spellings are polyglot (XML-valid), in preparation for an EPUB target. New suites: transform_test, character_test (engine), typography_test (SKS). (from dev 07ce5ea86a0a)
299 lines
11 KiB
C++
299 lines
11 KiB
C++
#include <cctype>
|
|
#include <cstdlib>
|
|
#include <iomanip>
|
|
#include <sstream>
|
|
|
|
#include "klammerset_registry.h"
|
|
#include "error.h"
|
|
#include "file.h"
|
|
#include "log.h"
|
|
#include "util.h"
|
|
#include "show.h"
|
|
#include "katom.h"
|
|
|
|
Klammerset_registry::Klammerset_registry()
|
|
: m_parameters(Parameter_set("symbol | desc :name :author :date :requires :files"))
|
|
{
|
|
}
|
|
|
|
void Klammerset_registry::add(Klammerset klammerset)
|
|
{
|
|
(void)K::log(3, klammerset.m_symbol);
|
|
m_klammersets[klammerset.m_symbol] = klammerset;
|
|
m_symbols.push_back(klammerset.m_symbol);
|
|
}
|
|
|
|
std::optional<Klammerset> Klammerset_registry::add(
|
|
std::vector<Katom>::iterator begin, std::vector<Katom>::iterator end, std::vector<Katom>& katoms)
|
|
{
|
|
(void)K::log(3, *begin, *(end - 1));
|
|
auto [positional, optional, rest] =
|
|
argument_split(begin + 1, end - 1, m_parameters.m_positional.size());
|
|
auto values = m_parameters.value_map(positional, optional, rest, begin->m_loc);
|
|
|
|
modify_type(katom_t::replaced, begin, end);
|
|
auto next_iter = end;
|
|
ignore_whitespace(next_iter, katoms);
|
|
|
|
std::string symbol = values["symbol"];
|
|
check_symbol(symbol, begin->m_loc);
|
|
check_declaring_file(symbol, begin->m_loc);
|
|
if (has(symbol)) {
|
|
(void)K::log(2, "Klammerset \"" + symbol + "\" is already loaded; declaration skipped");
|
|
return std::nullopt;
|
|
}
|
|
|
|
// The filename lists follow the standard conventions (spaces allowed,
|
|
// standalone "/" separator). The existence rescue tests names against
|
|
// the declaring file's directory, where relative names are later
|
|
// resolved by Machine::load_klammerset_files.
|
|
fs::path declaring(begin->m_loc.m_filename);
|
|
std::string base_dir =
|
|
fs::exists(declaring) ? declaring.parent_path().string() : "";
|
|
|
|
Klammerset klammerset(symbol, values["desc"], begin->m_loc);
|
|
klammerset.m_name = values["name"];
|
|
klammerset.m_author = values["author"];
|
|
klammerset.m_date = values["date"];
|
|
klammerset.m_requires = resolve_filename_list(values["requires"], base_dir);
|
|
klammerset.m_files = resolve_filename_list(values["files"], base_dir);
|
|
add(klammerset);
|
|
return klammerset;
|
|
}
|
|
|
|
void Klammerset_registry::check_symbol(const std::string& symbol, const Locator& loc) const
|
|
{
|
|
bool valid = !symbol.empty() && std::isalpha(static_cast<unsigned char>(symbol[0]));
|
|
for (char c : symbol) {
|
|
if (!std::isalnum(static_cast<unsigned char>(c)) && c != '_') {
|
|
valid = false;
|
|
}
|
|
}
|
|
if (!valid) {
|
|
throw Klammerset_error(
|
|
"The klammerset symbol \"" + symbol + "\" is not valid. A symbol begins "
|
|
"with a letter and contains only letters, digits, and underscores.",
|
|
loc);
|
|
}
|
|
}
|
|
|
|
// A klammerset that can be NAMED must live where its name says: symbol X is
|
|
// declared in X/X.k (Andy, 2026-08-15). The convention already governed
|
|
// symbol RESOLUTION; making it a requirement of the declaration too is what
|
|
// turns the symbol into a function of the path -- and that is what lets the
|
|
// already-loaded guard run BEFORE a file is read rather than after, which is
|
|
// the whole of the diamond-":requires" fix. Without it the symbol is known
|
|
// only once the file has been parsed, and by then a second read has already
|
|
// re-executed the declaring file's own definitions.
|
|
//
|
|
// It also continues the reasoning behind symbols-only on the command line
|
|
// (2026-08-14): if every klammerset is reachable by symbol the set of all of
|
|
// them is ENUMERABLE; if every declaration is in X/X.k each one is also
|
|
// IDENTIFIABLE from where it sits.
|
|
//
|
|
// EXEMPT: a declaration that is not in a ".k" file at all. A document may
|
|
// declare a klammerset -- that is how a designer writes one, and kdesc's
|
|
// provenance filter depends on it -- and such a set is local to the document:
|
|
// nothing can ":requires" it, so it has no identity to protect.
|
|
void Klammerset_registry::check_declaring_file(
|
|
const std::string& symbol, const Locator& loc) const
|
|
{
|
|
fs::path declaring(loc.m_filename);
|
|
if (declaring.extension() != ".k") {
|
|
return;
|
|
}
|
|
if (declaring.stem() == symbol && declaring.parent_path().filename() == symbol) {
|
|
return;
|
|
}
|
|
throw Klammerset_error(
|
|
"The klammerset \"" + symbol + "\" must be declared in a file named \""
|
|
+ symbol + "/" + symbol + ".k\", but this declaration is in \""
|
|
+ declaring.filename().string() + "\" (in a directory named \""
|
|
+ declaring.parent_path().filename().string() + "\"). A klammerset that "
|
|
"can be named is identified by where it is, so that a symbol names one "
|
|
"file and one file declares one symbol. A klammerset local to a document "
|
|
"may be declared in the document itself.",
|
|
loc);
|
|
}
|
|
|
|
bool Klammerset_registry::has(const std::string& symbol) const
|
|
{
|
|
return m_klammersets.count(symbol) > 0;
|
|
}
|
|
|
|
Klammerset Klammerset_registry::get(const std::string& symbol, const Locator& loc) const
|
|
{
|
|
if (has(symbol)) {
|
|
return m_klammersets.at(symbol);
|
|
} else {
|
|
throw Klammerset_error("Klammerset " + symbol + " does not exist", loc);
|
|
}
|
|
}
|
|
|
|
// --- The klammerset search path ---
|
|
|
|
bool is_klammerset_symbol(const std::string& name)
|
|
{
|
|
if (name.empty() || !std::isalpha(static_cast<unsigned char>(name[0]))) {
|
|
return false;
|
|
}
|
|
for (char c : name) {
|
|
if (!std::isalnum(static_cast<unsigned char>(c)) && c != '_') {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
std::vector<std::string> klammerset_search_dirs(const std::string& local_dir)
|
|
{
|
|
std::vector<std::string> result {};
|
|
// A repeated directory (e.g. the local stage already IS
|
|
// $KLAMMERTEXT_HOME) adds nothing and clutters error messages.
|
|
auto push_unique = [&result](const std::string& dir) {
|
|
std::string canonical = fs::weakly_canonical(dir).string();
|
|
if (!is_in(canonical, result)) {
|
|
result.push_back(canonical);
|
|
}
|
|
};
|
|
if (!local_dir.empty()) {
|
|
push_unique(local_dir);
|
|
}
|
|
// Read ONCE per process, not once per resolution. A search path decides
|
|
// WHICH FILE a symbol means -- an identity question, not a value one -- so
|
|
// it must not move while a document is being processed: if it did, "which
|
|
// klammerset is X" would depend on evaluation order and "kdesc
|
|
// --klammersets" could not be a complete answer, which is the reason the
|
|
// command line takes symbols only.
|
|
//
|
|
// It could move. The embedded Python shares the process, so an @eval
|
|
// doing os.environ[...] = ... changed what a later getenv here returned;
|
|
// a document could extend its own search path between one declaration and
|
|
// the next. Nothing intended that -- it fell out of a fresh getenv and an
|
|
// in-process interpreter.
|
|
static const std::string paths = [] {
|
|
const char* env = std::getenv("KLAMMERTEXT_KLAMMERSETS");
|
|
if (env && *env) {
|
|
return std::string(env);
|
|
}
|
|
if (const char* home = std::getenv("HOME"); home && *home) {
|
|
return std::string(home) + "/.klammertext/klammersets";
|
|
}
|
|
return std::string();
|
|
}();
|
|
std::stringstream ss(paths);
|
|
std::string dir;
|
|
while (std::getline(ss, dir, ':')) {
|
|
if (!dir.empty()) {
|
|
push_unique(dir);
|
|
}
|
|
}
|
|
if (const char* kthome = std::getenv(klammertext_home_var.c_str()); kthome && *kthome) {
|
|
push_unique(kthome);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
fs::path resolve_klammerset_symbol(
|
|
const std::string& symbol, const std::string& local_dir, const Locator& loc)
|
|
{
|
|
std::vector<std::string> dirs = klammerset_search_dirs(local_dir);
|
|
for (const std::string& dir : dirs) {
|
|
fs::path candidate = fs::path(dir) / symbol / (symbol + ".k");
|
|
if (fs::exists(candidate) && fs::is_regular_file(candidate)) {
|
|
return fs::weakly_canonical(candidate);
|
|
}
|
|
}
|
|
throw Klammerset_error(
|
|
"The klammerset \"" + symbol + "\" was not found. A symbol x names the "
|
|
"declaration file x/x.k in one of the search directories:\n "
|
|
+ join(dirs, "\n ")
|
|
+ "\nEnter \"kdesc --klammersets\" to list the available klammersets.",
|
|
loc);
|
|
}
|
|
|
|
std::string describe_klammerset_search(const std::string& local_dir, int margin)
|
|
{
|
|
std::string tab(margin, ' ');
|
|
std::stringstream ss {};
|
|
std::map<std::string, std::string> first_hit {};
|
|
for (const std::string& dir : klammerset_search_dirs(local_dir)) {
|
|
if (!fs::is_directory(dir)) {
|
|
continue;
|
|
}
|
|
for (const auto& entry : fs::directory_iterator(dir)) {
|
|
if (!entry.is_directory()) {
|
|
continue;
|
|
}
|
|
std::string symbol = entry.path().filename().string();
|
|
fs::path declaration = entry.path() / (symbol + ".k");
|
|
if (!is_klammerset_symbol(symbol) || !fs::is_regular_file(declaration)) {
|
|
continue;
|
|
}
|
|
ss << tab << symbol << sp_arrow << declaration.string();
|
|
if (first_hit.count(symbol)) {
|
|
ss << " (shadowed by " << first_hit[symbol] << ")";
|
|
} else {
|
|
first_hit[symbol] = declaration.string();
|
|
}
|
|
ss << "\n";
|
|
}
|
|
}
|
|
if (first_hit.empty()) {
|
|
ss << tab << "(no klammersets found)\n";
|
|
}
|
|
return ss.str();
|
|
}
|
|
|
|
std::string Klammerset_registry::describe(int margin, bool long_format) const
|
|
{
|
|
std::string tab(margin, ' ');
|
|
std::stringstream ss {};
|
|
std::vector<std::string> descs {};
|
|
for (const std::string& symbol : m_symbols) {
|
|
descs.push_back(m_klammersets.at(symbol).m_desc);
|
|
}
|
|
auto symbol_width = max_length(m_symbols);
|
|
auto desc_width = max_length(descs);
|
|
for (const std::string& symbol : m_symbols) {
|
|
const Klammerset& ks = m_klammersets.at(symbol);
|
|
if (long_format) {
|
|
ss << tab << std::setfill(' ') << std::setw(symbol_width) << std::left << symbol << " "
|
|
<< std::setw(desc_width) << std::left << ks.m_desc << " "
|
|
<< ks.m_loc.str() << "\n";
|
|
if (!ks.m_name.empty())
|
|
ss << tab << std::string(symbol_width, ' ') << " name: " << ks.m_name << "\n";
|
|
if (!ks.m_author.empty())
|
|
ss << tab << std::string(symbol_width, ' ') << " author: " << ks.m_author << "\n";
|
|
if (!ks.m_date.empty())
|
|
ss << tab << std::string(symbol_width, ' ') << " date: " << ks.m_date << "\n";
|
|
if (!ks.m_requires.empty())
|
|
ss << tab << std::string(symbol_width, ' ') << " requires: " << join(ks.m_requires, " / ") << "\n";
|
|
if (!ks.m_files.empty())
|
|
ss << tab << std::string(symbol_width, ' ') << " files: " << join(ks.m_files, " / ") << "\n";
|
|
} else {
|
|
ss << tab << std::setfill(' ') << std::setw(symbol_width) << std::left << symbol
|
|
<< sp_arrow << ks << "\n";
|
|
}
|
|
}
|
|
return ss.str();
|
|
}
|
|
|
|
void Klammerset_registry::set_loaded_files(const std::string& symbol, const strings_t& files)
|
|
{
|
|
auto it = m_klammersets.find(symbol);
|
|
if (it != m_klammersets.end()) {
|
|
it->second.m_loaded_files = files;
|
|
}
|
|
}
|
|
|
|
strings_t Klammerset_registry::loaded_files() const
|
|
{
|
|
strings_t result {};
|
|
for (const auto& [symbol, klammerset] : m_klammersets) {
|
|
result.insert(result.end(),
|
|
klammerset.m_loaded_files.begin(), klammerset.m_loaded_files.end());
|
|
}
|
|
return result;
|
|
}
|