Andy Kopra
59c1599bc9
kdesc gains --coverage, which reports for every klammer the set of targets it can render to, and — the point of it — which klammers' coverage cannot be derived and must therefore be declared. Three rules: coverage is DERIVED where the definitions determine it (a general body of klammer calls covers the intersection of what those klammers cover, by a greatest fixpoint after loading), DECLARED where the engine cannot interpret what decides it (an @eval body, whose targets are undecidable), and UNKNOWN where nothing is written — which never means "deliberately unavailable". Two new spellings in a definition's name. A comma-separated target list, "@@table.html,tex :: ...", gives one body several targets; it is surface syntax, expanded at registration, and each member goes through the redefinition rules on its own. And "@@date.* :: ..." writes the general target out, asserting that the klammer works for EVERY target including ones not yet defined — a stronger claim than a list of the targets defined today, and the one target declaration that could be mechanically falsified. The Standard Klammer Set was swept accordingly: it now has no general definitions at all, every klammer names the targets it serves, six use ".*", and tex and pdf are at zero undecided. kdesc's flags are reorganised on two rules: a flag reached for often gets a single letter (-k klammers, -t targets, -c characters, -i input), a more specialised topic a multi-letter name (--argtypes, --katoms, --rewrite, --optionsets, --coverage, --klammerset, --font); and -v says how much to show about PROCESSING, never what the RESULT contains — so the katom regex column is "--katoms full" and the coverage detail "--coverage all". NOTE: "-k" now lists klammers (optionally filtered by a name/description search); the katom table moved to "--katoms". Fixes carried along: an option written with no value crashed the command with SIGSEGV instead of reporting the mistake; two required positional arguments never parsed; kdesc and kdiag printed an error and exited 0; and definition diagnostics counted registrations rather than what was written, so one line could be reported as two definitions and then printed twice. Four new test suites: target_list, coverage, command_option, kdesc. (from dev 46f54080bd9a)
301 lines
12 KiB
C++
301 lines
12 KiB
C++
#include "argv.h"
|
|
#include "command.h"
|
|
#include "coverage.h"
|
|
#include "error.h"
|
|
#include "file.h"
|
|
#include "font_store.h"
|
|
#include "ktype.h"
|
|
#include "log.h"
|
|
#include "argtype_registry.h"
|
|
#include "klammerset_registry.h"
|
|
#include "character.h"
|
|
#include "show.h"
|
|
#include "util.h"
|
|
|
|
static void font_usage()
|
|
{
|
|
std::cout <<
|
|
"Font maintenance commands:\n"
|
|
" --font List the available fonts\n"
|
|
" --font list The same\n"
|
|
" --font samples <output-dir> Write a sample page of the available fonts\n"
|
|
" to <output-dir>/index.html\n"
|
|
" --font samples <input-dir> <output-dir>\n"
|
|
" Write a sample page for the (not yet\n"
|
|
" installed) font files under <input-dir>\n"
|
|
" --font install <input-dir> Install the font files found under\n"
|
|
" <input-dir> into the user font directory\n"
|
|
" --font install <input-dir> <output-dir>\n"
|
|
" Install into <output-dir> instead\n"
|
|
" --font help This description\n"
|
|
"\n"
|
|
"Fonts are searched in the directories of the KLAMMERTEXT_FONTS\n"
|
|
"environment variable (colon-separated; default $HOME/.klammertext/fonts)\n"
|
|
"and then in the default font set.\n";
|
|
}
|
|
|
|
static void coverage_usage()
|
|
{
|
|
std::cout <<
|
|
"Coverage commands:\n"
|
|
" --coverage Report the targets each klammer covers\n"
|
|
" --coverage all Also name the file each klammer is written\n"
|
|
" in, and show every \"needs attention\"\n"
|
|
" category, including the empty ones\n"
|
|
" --coverage help This description\n"
|
|
"\n"
|
|
"Coverage is a fact about a klammer: the targets it can render to. It is\n"
|
|
"DERIVED where the definitions determine it (a general body of klammer\n"
|
|
"calls covers the intersection of what those klammers cover), must be\n"
|
|
"DECLARED where they cannot (an @eval body, whose targets are named in a\n"
|
|
"comma-separated list: @@name.html,tex :: ... @@), and is UNKNOWN where\n"
|
|
"nothing is written -- which never means \"deliberately unavailable\".\n"
|
|
"\n"
|
|
"Without \"all\", an AUTHOR sees what is available and only the problems\n"
|
|
"that exist. With it, a DESIGNER building a klammer set is reminded of\n"
|
|
"the whole set of categories.\n";
|
|
}
|
|
|
|
static void katom_usage()
|
|
{
|
|
std::cout <<
|
|
"Katom commands:\n"
|
|
" --katoms List the katom types\n"
|
|
" --katoms full The same, with the regex each type is\n"
|
|
" matched by\n"
|
|
" --katoms help This description\n";
|
|
}
|
|
|
|
// The words of a variadic option, with the empty ones dropped.
|
|
static strings_t option_words(Argv& args, const std::string& name)
|
|
{
|
|
strings_t words {};
|
|
for (const std::string& w : args.as_vector(name)) {
|
|
if (!w.empty()) {
|
|
words.push_back(w);
|
|
}
|
|
}
|
|
return words;
|
|
}
|
|
|
|
static void klammerset_usage()
|
|
{
|
|
std::cout <<
|
|
"Klammerset commands:\n"
|
|
" --klammerset List the klammersets on the search path\n"
|
|
" --klammerset list The same\n"
|
|
" --klammerset help This description\n"
|
|
"\n"
|
|
"A klammerset symbol x names the declaration file x/x.k, searched for in:\n"
|
|
"the current directory (for ktext, the input document's directory), the\n"
|
|
"KLAMMERTEXT_KLAMMERSETS directories (colon-separated; default\n"
|
|
"$HOME/.klammertext/klammersets), and $KLAMMERTEXT_HOME. The first hit\n"
|
|
"wins, so a document-local klammerset shadows an installed one, which\n"
|
|
"shadows a distributed one.\n";
|
|
}
|
|
|
|
static void klammerset_command(const strings_t& words)
|
|
{
|
|
std::string verb = words.empty() ? "list" : words[0];
|
|
if (verb == "list") {
|
|
std::cout << boldblack << "Klammersets\n" << black
|
|
<< describe_klammerset_search(fs::current_path().string());
|
|
} else if (verb == "help") {
|
|
klammerset_usage();
|
|
} else {
|
|
std::cout << "Unrecognized klammerset command: --klammerset "
|
|
<< join(words, " ") << "\n\n";
|
|
klammerset_usage();
|
|
}
|
|
}
|
|
|
|
static void font_command(const strings_t& words)
|
|
{
|
|
std::string verb = words.empty() ? "list" : words[0];
|
|
size_t n = words.size() - (words.empty() ? 0 : 1);
|
|
if (verb == "list" && n == 0) {
|
|
std::cout << boldblack << "Fonts\n" << black << describe_fonts();
|
|
} else if (verb == "samples" && n == 1) {
|
|
std::cout << "Font samples written to "
|
|
<< write_font_samples(words[1]) << "\n";
|
|
} else if (verb == "samples" && n == 2) {
|
|
std::cout << "Font samples written to "
|
|
<< write_font_samples(words[2], words[1]) << "\n";
|
|
} else if (verb == "install" && (n == 1 || n == 2)) {
|
|
std::cout << "Installing fonts from " << words[1] << ":\n"
|
|
<< install_fonts(words[1], n == 2 ? words[2] : "");
|
|
} else if (verb == "help") {
|
|
font_usage();
|
|
} else {
|
|
std::cout << "Unrecognized font command: --font " << join(words, " ")
|
|
<< "\n\n";
|
|
font_usage();
|
|
}
|
|
}
|
|
|
|
int main(int argc, char* argv[])
|
|
{
|
|
try {
|
|
set_verbose_level(argc, argv);
|
|
|
|
Argv args {};
|
|
// Declaration order is display order in the usage text, so these are
|
|
// ordered by how likely a user is to want them. A single letter is a
|
|
// flag one reaches for often; a multi-letter name is a more specialised
|
|
// topic. -v stays last: it says how much to show about the command's
|
|
// PROCESSING, never what its RESULT contains -- which is why the katom
|
|
// regexes and the coverage file column are words of their own options
|
|
// rather than verbosity levels.
|
|
args.var("k", "Show klammers. With <text>, only those whose name or description contains <text>.", "text");
|
|
args.flag("t", "Show the targets for Klammertext output");
|
|
args.flag("c", "Show the codes for accented vowels and other special characters");
|
|
args.opt("i", "Input filename. If given, it is used instead of the SKS.", "filename", "", "'text'");
|
|
args.var("font", "List installed fonts. Enter \"--font help\" for font maintenance commands.");
|
|
args.flag("argtypes", "Show the klammer argument types");
|
|
args.var("katoms", "Show the katom types. Enter \"--katoms help\" for details.");
|
|
args.flag("rewrite", "Show the katom rewrite patterns");
|
|
args.flag("optionsets", "Show the option sets declared by the input");
|
|
args.var("coverage", "Show the targets each klammer covers. Enter \"--coverage help\" for details.");
|
|
args.var("klammerset", "List the klammersets on the search path. Enter \"--klammerset help\" for details.");
|
|
args.opt("v", "'verbosity'", "n", "0", "'verbosity'");
|
|
|
|
if (show_usage(argc, argv)) {
|
|
args.usage(file_basename(argv[0]));
|
|
exit(1);
|
|
}
|
|
auto p = [&](const std::string& name) { return args.get(name) == "true"; };
|
|
|
|
args.parse(argc, argv);
|
|
verbose_level = stoi(args.get("v"));
|
|
if (verbose_level > 0) {
|
|
args.describe();
|
|
}
|
|
|
|
if (p("c")) {
|
|
show_special_characters();
|
|
std::cout << "\n";
|
|
}
|
|
|
|
if (p("argtypes")) {
|
|
Argtype_registry argtypes;
|
|
std::cout << boldblack << "\nStandard klammer argument types\n" << black;
|
|
std::cout << argtypes.describe() << "\n";
|
|
}
|
|
|
|
if (args.given("katoms")) {
|
|
strings_t words = option_words(args, "katoms");
|
|
std::string verb = words.empty() ? "" : words[0];
|
|
if (verb == "help") {
|
|
katom_usage();
|
|
return 0;
|
|
}
|
|
if (!verb.empty() && verb != "full") {
|
|
std::cout << "Unrecognized katom command: --katoms " << join(words, " ") << "\n\n";
|
|
katom_usage();
|
|
return 1;
|
|
}
|
|
describe_katoms(verb == "full");
|
|
}
|
|
|
|
if (p("rewrite")) {
|
|
describe_rewrite_patterns();
|
|
}
|
|
|
|
// The --font subcommands operate on the Klammertext font store
|
|
// (infrastructure) and load no klammer set.
|
|
if (args.given("font")) {
|
|
font_command(option_words(args, "font"));
|
|
return 0;
|
|
}
|
|
|
|
// The --klammerset subcommands operate on the search path
|
|
// (filesystem enumeration) and load no klammer set.
|
|
if (args.given("klammerset")) {
|
|
klammerset_command(option_words(args, "klammerset"));
|
|
return 0;
|
|
}
|
|
|
|
// --coverage is validated here, before a klammer set is read, so a
|
|
// mistyped word or "help" is answered at once. The report itself
|
|
// needs the loaded registry, so it runs at the end.
|
|
bool coverage_all = false;
|
|
if (args.given("coverage")) {
|
|
strings_t words = option_words(args, "coverage");
|
|
std::string verb = words.empty() ? "" : words[0];
|
|
if (verb == "help") {
|
|
coverage_usage();
|
|
return 0;
|
|
}
|
|
if (verb == "all") {
|
|
coverage_all = true;
|
|
} else if (!verb.empty()) {
|
|
std::cout << "Unrecognized coverage command: --coverage "
|
|
<< join(words, " ") << "\n\n";
|
|
coverage_usage();
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
Machine M;
|
|
|
|
strings_t input_filenames = resolve_filename_list(args.get("i"));
|
|
if (verbose_level > 0) {
|
|
std::cout << "input_filenames: " << input_filenames << "\n";
|
|
}
|
|
if (input_filenames.empty()) {
|
|
M.read(fs::path(M.m_state.value("KLAMMERTEXT_HOME") + "/sks/sks.k"));
|
|
} else {
|
|
for (auto fname : input_filenames) {
|
|
if (is_klammerset_symbol(fname)) {
|
|
// A bare symbol resolves on the klammerset search
|
|
// path; kdesc has no input document, so the local
|
|
// stage is the cwd.
|
|
fname = resolve_klammerset_symbol(
|
|
fname, fs::current_path().string(), Locator()).string();
|
|
}
|
|
if (verbose_level > 0) {
|
|
std::cout << "Read " << fname << "\n";
|
|
}
|
|
M.read(fs::path(absolute_pathname(fname)));
|
|
}
|
|
}
|
|
|
|
if (p("t")) {
|
|
std::cout << boldblack << "Targets\n" << black << M.m_targets.describe(2, true);
|
|
}
|
|
|
|
// "-k <text>" searches names AND descriptions, case-insensitively,
|
|
// with whitespace collapsed on both sides. An empty listing for a
|
|
// search that was actually made is reported: silence would read as a
|
|
// broken command. It is not an error -- finding nothing is a result.
|
|
if (args.given("k")) {
|
|
std::string search = join(option_words(args, "k"), " ");
|
|
std::string listing = M.m_klammers.describe(2, search);
|
|
if (listing.empty() && !search.empty()) {
|
|
std::cout << "No klammer names or descriptions contained "
|
|
<< q_(collapse_whitespace(search)) << ".\n";
|
|
} else {
|
|
std::cout << boldblack << "Klammers\n" << black << listing;
|
|
}
|
|
}
|
|
|
|
if (p("optionsets")) {
|
|
std::cout << boldblack << "Option sets\n" << black << M.m_option_sets.describe(2);
|
|
}
|
|
|
|
// Analysis only: klammer_coverage() reads the registry and modifies
|
|
// nothing, so what a document renders to is unaffected by asking.
|
|
if (args.given("coverage")) {
|
|
report_coverage(M, klammer_coverage(M), coverage_all, std::cout);
|
|
}
|
|
|
|
}
|
|
catch (Error& e) {
|
|
// Nonzero, as ktext does: a command that prints an error and exits 0
|
|
// reports success, and a script cannot tell the difference.
|
|
e.print_message();
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|