cli.cpp

#include <algorithm>
#include <iostream>
#include <sstream>
#include <string.h>
#include <string>
#include <vector>

extern "C" char *brst_scan_string(char *string,
                                  int correct_raw,
                                  int correct_differ,
                                  int correct_cover,
                                  int correct_versification,
                                  int show_dump,
                                  int tooltips_greek);
#include "pbrst.tab.h" // the statements folder must be included among the folders

using namespace std;

#ifndef __EMSCRIPTEN__
#ifndef __APPLE__
#include <readline/history.h>
#include <readline/readline.h>
#endif
#endif
#include <boost/algorithm/string/predicate.hpp>
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/trim.hpp>

#include <sys/types.h>
#include <unistd.h>
#ifndef __MINGW32__
#include <pwd.h>
#endif

#include "books.h"
#include "cli.h"
#include "swmgr.h"

#ifndef __EMSCRIPTEN__
#define OT_COLOR "\033[1;33m"
#define NT_COLOR "\033[1;36m"
#define RESET_COLOR "\033[0m"
#define ERROR_COLOR "\033[1;31m"
#else
#define OT_COLOR "<span style=\"color: #626600\">"
#define NT_COLOR "<span style=\"color: #006662\">"
#define RESET_COLOR "</span>"
#define ERROR_COLOR "<span style=\"color: red\">"
#endif

using namespace sword;

bool booksAdded = false;
string text[2];
vector<bool> textset = {false, false};

string addbooksCmd = "addbooks";
string compareCmd = "compare";
string jaccardCmd = "jaccard";
string textCmd = "text";
string latintextCmd = "latintext";
string lookupCmd = "lookup";
string findCmd = "find";
string lengthCmd = "length";
string printCmd = "print";
string minuniqueCmd = "minunique";
string extendCmd = "extend";
string getrefsCmd = "getrefs";
string maxresultsCmd = "maxresults";
string sqlCmd = "sql";
string psalminfoCmd = "psalminfo";
string rawCmd = "raw";
string colorsCmd = "colors";
string tokensCmd = "tokens";
string searchCmd = "search";
string quitCmd = "quit";
string helpCmd = "help";
string statementCmd = "statement";
string statementCmd2 = "Statement";

string errorNotRecognized
    = "Sorry, the command you entered was not recognized or its syntax is invalid.";
string errorTextIncomplete = "Either " + textCmd + "1 or " + textCmd + "2 must be used.";
string errorTextParameters = textCmd + " requires at least one parameter.";
string errorLatintextIncomplete = "Either " + latintextCmd + "1 or " + latintextCmd
                                  + "2 must be used.";
string errorLatintextParameters = latintextCmd + " requires at least one parameter.";
string errorLookupIncomplete = "Either " + lookupCmd + "1 or " + lookupCmd + "2 must be used.";
string errorLookupParameters = lookupCmd + " requires 3 or 4 parameters.";
string errorFindIncomplete = "Either " + textCmd + "1 or " + textCmd + "2 must be used.";
string errorFindParameters = findCmd + " requires one parameter.";
string errorFindEmpty = "No text to find is defined yet.";
string errorLengthIncomplete = "Either " + lengthCmd + "1 or " + lengthCmd + "2 must be used.";
string errorPrintIncomplete = "Either " + printCmd + "1 or " + printCmd + "2 must be used.";
string errorMinuniqueParameters = minuniqueCmd + " requires one parameter";
string errorExtendParameters = extendCmd + " requires 4 or 5 parameters.";
string errorGetrefsParameters = getrefsCmd + " requires 3, 4 or 5 parameters.";
string errorMaxresultsParameters = maxresultsCmd + " requires one parameter.";
string errorSqlParameters = sqlCmd + " requires one parameter.";
string errorPsalminfoParameters = psalminfoCmd + " requires 2 parameters.";
string errorRawParameters = rawCmd + " requires 4 parameters.";
string errorRawIncomplete = "Either " + rawCmd + "1 or " + rawCmd + "2 must be used.";
string errorColorsParameters = colorsCmd + " requires one parameter.";
string errorTokensParameters = tokensCmd + " requires 3 or 4 parameters.";
string errorSearchParameters = searchCmd + " requires at least one parameter.";
string errorMisc = "Sorry, there were some problems with the command you entered.";

vector<string> commands{addbooksCmd,
                        compareCmd + "12",
                        jaccardCmd + "12",
                        textCmd + "1",
                        textCmd + "2",
                        lookupCmd + "1",
                        lookupCmd + "2",
                        quitCmd,
                        helpCmd,
                        findCmd + "1",
                        findCmd + "2",
                        lengthCmd + "1",
                        lengthCmd + "2",
                        minuniqueCmd + "1",
                        latintextCmd + "1",
                        latintextCmd + "2",
                        extendCmd,
                        getrefsCmd,
                        lookupCmd,
                        maxresultsCmd,
                        sqlCmd,
                        psalminfoCmd,
                        rawCmd,
                        rawCmd + "1",
                        rawCmd + "2",
                        printCmd + "1",
                        printCmd + "2",
                        colorsCmd,
                        tokensCmd,
                        searchCmd,
                        statementCmd};
vector<string> vocabulary = commands;

void add_vocabulary_item(string item)
{
    replace(item.begin(), item.end(), ' ', '_');
    vocabulary.push_back(item);
}

string collect_info = "";

void info(const string &message)
{
#ifndef __EMSCRIPTEN__
    cerr << output_prepend_set << message << endl << flush;
#else
    cout << message << endl << flush;
#endif
    collect_info = collect_info + message + "\n";
}

#ifndef __EMSCRIPTEN__
#ifndef __APPLE__
// readline related code was taken mostly from https://eli.thegreenplace.net/2016/basics-of-using-the-readline-library/
char *completion_generator(const char *text, int state)
{
    // This function is called with state=0 the first time; subsequent calls are
    // with a nonzero state. state=0 can be used to perform one-time
    // initialization for this completion session.
    static vector<string> matches;
    static size_t match_index = 0;

    if (state == 0) {
        // During initialization, compute the actual matches for 'text' and keep
        // them in a static vector.
        matches.clear();
        match_index = 0;

        // Collect a vector of matches: vocabulary words that begin with text.
        string textstr = string(text);
        for (auto word : vocabulary) {
            if (word.size() >= textstr.size() && word.compare(0, textstr.size(), textstr) == 0) {
                matches.push_back(word);
            }
        }
    }

    if (match_index >= matches.size()) {
        // We return nullptr to notify the caller no more matches are available.
        return nullptr;
    } else {
        // Return a malloc'd char* for the match. The caller frees it.
        return strdup(matches[match_index++].c_str());
    }
}

char **completer(const char *text, int start, int end)
{
    // Don't do filename completion even if our generator finds no matches.
    rl_attempted_completion_over = 1;

    // Note: returning nullptr here will make readline use the default filename
    // completer.
    return rl_completion_matches(text, completion_generator);
}
#endif
#endif

int maxresults;
bool sql;
char *output_prepend_set;
string ot_color, nt_color, reset_color, error_color;

void set_colors(bool colored)
{
    ot_color = "";
    nt_color = "";
    reset_color = "";
    error_color = "";

    if (colored) {
        ot_color = OT_COLOR;
        nt_color = NT_COLOR;
        reset_color = RESET_COLOR;
        error_color = ERROR_COLOR;
    }
}

void processAddbooksCmd()
{
    if (booksAdded) {
        error("Books already added.");
    } else {
        if (addBibles() == 0) {
            booksAdded = true;
        }
    }
}

void processQuitCmd()
{
    info("Goodbye.");
    exit(0);
}

string getHelp(const string &key)
{
    vector<string> helpStr = {
        "* `addbooks`: Load the books of LXX, SBLGNT and StatResGNT (if any of these are "
        "available). "
        "Most commands require that these books are already loaded. After using this command for "
        "the "
        "first time (it takes a couple of seconds), a folder named `bibref-addbooks-cache` will be "
        "created in the current working directory to speed up the next startup of this command.",
        "* `textN` *text*: Define a Greek *text* and put its Latin transcription in clipboard N.",
        "* `latintextN` *text*: Put the Latin transcription *text* in clipboard N.",
        "* `findN` *Bible*: Search for the text of clipboard N in the given *Bible*.",
        "* `lengthN`: Compute the length of the text in clipboard N.",
        "* `printN`: Show the Greek text in clipboard N (without punctuation and spaces).",
        "* `lookup` *Bible* *book* *verse*: Search for the given *verse* in the given *book* in "
        "the "
        "given *Bible*. Here *Bible* can be any translation that is already [installed as a "
        "module](https://www.crosswire.org/sword/modules/ModDisp.jsp?modType=Bibles) on the "
        "computer.",
        "* `lookupN` *Bible* *book* *passage*: Search for the given *passage* in the given *book* "
        "in "
        "the given *Bible* and put its Latin transcription in clipboard N.",
        "* `search` *Bible* *token1* *token2* ... *tokenN* *maxlength*: Search for the given set "
        "of "
        "tokens on a maximal length of *maxlength* in the given *Bible*.",
        "* `raw` *Bible* *book* *start* *length*: Show the raw Latin transcription of a passage in "
        "the given *book* in the given *Bible*, beginning with the *start* position on *length* "
        "characters.",
        "* `rawN` *Bible* *book* *start* *length*: Put a passage in the given *book* in the given "
        "*Bible*, beginning with the *start* position on *length* characters, in clipboard N.",
        "* `minunique1` *Bible*: Search for minimal unique passages in clipboard 1 in the given "
        "*Bible*.",
        "* `extend` *Bible1* *Bible2* *book2* *passage2*: Extend the given passage in *Bible2* "
        "according to the longest possible citation from *Bible1*, based on the text of *book2* in "
        "*passage2*. In most cases `LXX` is used for *Bible1* and `SBLGNT` for *Bible2*.",
        "* `psalminfo` *Bible* *number*: Show the number of verses in Psalm *number* in the given "
        "*Bible*.",
        "* `getrefs` *Bible2* *Bible1* *book1* *passage1*: Search for references in *Bible2* on "
        "the "
        "passage in *Bible1* in book *book1* in *passage1*. Usually `SBLGNT` stands for *Bible2* "
        "and "
        "`LXX` for *Bible1*. If *book1* is `Psalms`, the passage can also be its number only.",
        "* `maxresults` *number*: Set the maximal amount of results to be shown to *number*.",
        "* `compare12`: Compare the two clipboards with a 2-long substring-fingerprint "
        "(2-shingles) "
        "check, best match is reached at 1/(length1+length2).",
        "* `jaccard12`: Compare the two clipboards the same way how `compare12` does but use the "
        "\"Jaccard similarity for bags\" algorithm, best match is reached at 0.",
        "* `sql` *switch*: Set some outputs to be shown also as an SQL query if *switch* is `on`.",
        "* `colors` *switch*: Show some outputs colored if *switch* is `on`.",
        "* `tokens` *Bible* *book* *verse*: Search for the given *verse* in the given *book* in "
        "the "
        "given *Bible* (see command `lookup`), but the output is shown in a tokenized form. "
        "Tokenization is done via Strong's numbers.",
        "* `help` *command*: Show some hints on usage of *command*, or get general help if no "
        "parameter is given.",
        "* `statement` ...: Analyze the given statement, see "
        "https://matek.hu/zoltan/blog-20250102.php "
        "for some explanations.",
        "* `quit`: Exit program."};
    string retval;
    for (int i = 0; i < helpStr.size(); i++) {
        string helpText = helpStr[i];
        if (helpText.length() >= 4 && helpText.substr(3, key.length()) == key) {
            if (retval.length() > 0)
                retval += "\n";
            retval += helpText.substr(2); // remove trailing "* "
        }
    }
    return retval;
}

void processHelpCmd(string input)
{
    int commandLength = helpCmd.length();
    if (input.length() != commandLength) {
        string rest = input.substr(input.find(" ") + 1);
        if ((boost::ends_with(rest, "1") || boost::ends_with(rest, "2"))
            && !boost::ends_with(rest, "12"))
            rest = rest.substr(0, rest.length() - 1) + "N";
        string helpText = getHelp(rest);
        if (helpText.length() == 0) {
            error("Command `" + rest + "` is not supported.");
            string commands_flattened = commands[0];
            for (int i = 1; i < commands.size(); i++) {
                commands_flattened += ", " + commands[i];
            }
            error("Available commands are: " + commands_flattened + ".");
            return;
        }
        info(helpText);
        return;
    }
#ifdef __EMSCRIPTEN__
    showAvailableBibles();
#endif
    info("Please visit https://github.com/kovzol/bibref#bibref to get online help.");
}

void processTextCmd(string input)
{
    int index; // clipboard number (0 or 1), if used
    int commandLength = textCmd.length();
    if (input.length() == commandLength) {
        error(errorTextIncomplete);
        return;
    }
    if (input.at(commandLength) == '1') {
        index = 0; // using clipboard 1
    } else if (input.at(commandLength) == '2') {
        index = 1; // using clipboard 2
    } else {
        error(errorTextIncomplete);
        return;
    }
    if (input.length() < textCmd.length() + 2) {
        error(errorTextParameters);
        return;
    }
    if (input.at(commandLength + 1) != ' ') {
        error("Either " + textCmd + "1 or " + textCmd + "2 must be used.");
        return;
    }
    string rest = input.substr(input.find(" ") + 1);
    // Remove accidental Greek accents first:
    SWMgr manager;
    manager.setGlobalOption("Greek Accents", "Off"); // disable accents
    SWBuf to_convert = rest.data();
    manager.filterText("Greek Accents", to_convert);
    // Convert Greek to Latin:
    string processed = processVerse(to_convert.c_str());
    if (processed.length() == 0) {
        error("Text does not contain Greek letters, ignored.");
        return; // Success, but nothing happened.
    }
    text[index] = processed;                         // Store result.
    textset[index] = true;                           // activate clipboard
    info("Stored internally as " + processed + "."); // Success!
}

void processSearchCmd(string input)
{
    int index;
    if (input.length() < searchCmd.length() + 1) {
        error(errorSearchParameters);
        return;
    }
    string rest = input.substr(input.find(" ") + 1);
    index = rest.find(" ");
    string moduleName = rest.substr(0, index); // Search in the given Bible edition...
    rest = rest.substr(index + 1);

    vector<int> pattern; // the token pattern to be searched
    std::stringstream ss(rest);

    int s = 0;
    int t;
    while (ss >> t) {
        pattern.push_back(t);
        s += 1; // count the tokens in the pattern
    }
    if (s == 0) { // no pattern was defined
        error(errorSearchParameters);
        return;
    }

    s--;
    int length = pattern.at(s); // the last parameter
    pattern.pop_back();         // remove it from the token pattern
    info("Read " + to_string(s) + " tokens, searching for an extension of max. " + to_string(length)
         + " tokens.");
    if (length < s) { // the length must be at least the length of the pattern
        error("Surely, this will not be working.");
    } else {
        searchTokenset(moduleName, pattern, length, true); // Start search...
    }
}

void processLatintextCmd(string input)
{
    int index; // clipboard number (0 or 1), if used
    int commandLength = latintextCmd.length();
    if (input.length() == commandLength) {
        error(errorLatintextIncomplete);
        return;
    }
    if (input.at(commandLength) == '1') {
        index = 0; // using clipboard 1
    } else if (input.at(commandLength) == '2') {
        index = 1; // using clipboard 2
    } else {
        error(errorLatintextIncomplete);
        return;
    }
    if (input.length() < latintextCmd.length() + 2) {
        error(errorLatintextParameters);
        return;
    }
    if (input.at(commandLength + 1) != ' ') {
        error("Either " + latintextCmd + "1 or " + latintextCmd + "2 must be used.");
        return;
    }
    string rest = input.substr(input.find(" ") + 1);
    text[index] = rest;    // The remaining part of the input is stored as is.
    textset[index] = true; // activate clipboard
    info("Stored.");       // Success!
}

void processLookupCmd(string input)
{
    int index; // clipboard number (0 or 1), if used
    int commandLength = lookupCmd.length();
    if (input.length() == commandLength) {
        error(errorLookupIncomplete);
        return;
    }
    if (input.at(commandLength) == ' ') { // no clipboard is requested
        string rest = input.substr(input.find(" ") + 1);
        vector<string> tokens;
        boost::split(tokens, rest, boost::is_any_of(" "));
        int restSize = tokens.size();
        if (restSize == 3) {                                    // e.g. lookup LXX Genesis 1:1
            lookupTranslation(tokens[0], tokens[1], tokens[2]); // simple lookup via Sword
        } else {
            error(errorLookupParameters);
        }
        return; // Success!
    }
    if (input.at(commandLength) == '1') {
        index = 0; // using clipboard 1
    } else if (input.at(commandLength) == '2') {
        index = 1; // using clipboard 2
    } else {
        error(errorLookupIncomplete);
        return;
    }
    if (input.length() < lookupCmd.length() + 2) {
        error(errorLookupParameters);
        return;
    }
    if (input.at(commandLength + 1) != ' ') {
        error(errorLookupIncomplete);
        return;
    }
    string rest = input.substr(input.find(" ") + 1);
    vector<string> tokens;
    boost::split(tokens, rest, boost::is_any_of(" "));
    int restSize = tokens.size();
    if (restSize == 3) {
        string verse = "";
        try {                                                     // e.g. lookup1 LXX Genesis 1:1
            verse = lookupVerse(tokens[1], tokens[0], tokens[2]); // lookup in the a-y database
            text[index] = verse;                                  // Store result.
            textset[index] = true;                                // activate clipboard
            info("Stored internally as " + verse + ".");
        } catch (exception &e) {
            error(errorMisc);
        }
        return; // Success!
    }
    if (restSize == 4) { // e.g. lookup1 LXX Genesis 1:1+3 1:2-4
        string verse = "";
        try {
            vector<string> tokens2, tokens3;
            int start = 0, end = 0;
            boost::split(tokens2, tokens[2], boost::is_any_of("+"));
            if (tokens2.size() > 1) {
                start = stoi(tokens2[1]); // read off the plus shift
            }
            boost::split(tokens3, tokens[3], boost::is_any_of("-"));
            if (tokens3.size() > 1) {
                end = stoi(tokens3[1]); // read off the minus shift
            }
            // Shift-allowed lookup in the a-y database...
            verse = getText(tokens[1], tokens[0], tokens2.at(0), tokens3.at(0), start, end);
            text[index] = verse;   // Store result.
            textset[index] = true; // activate clipboard
            info("Stored internally as " + verse + ".");
        } catch (exception &e) {
            error(errorMisc);
        }
        return; // Success!
    }
    error(errorLookupParameters); // another amount of parameters are given
}

void processTokensCmd(string input)
{
    string rest = input.substr(input.find(" ") + 1);
    vector<string> tokens;
    boost::split(tokens, rest, boost::is_any_of(" "));
    int restSize = tokens.size();
    if (restSize == 3) {
        try {
            getTokens(tokens[0], tokens[1], tokens[2]);
        } catch (exception &e) {
            error(errorMisc);
        }
    } else {
        error(errorTokensParameters);
    }
}

void processFindCmd(string input)
{
    int index;
    int commandLength = findCmd.length();
    if (input.length() == commandLength) {
        error(errorFindIncomplete);
        return;
    }
    if (input.at(commandLength) == '1') {
        index = 0;
    } else if (input.at(commandLength) == '2') {
        index = 1;
    } else {
        error(errorFindIncomplete);
        return;
    }
    if (input.length() < findCmd.length() + 1) {
        error(errorFindParameters);
        return;
    }
    string rest = input.substr(input.find(" ") + 1);
    if (text[index].length() == 0) {
        error(errorFindEmpty);
        return;
    }
    find(text[index], rest, maxresults, true);
}

void processLengthCmd(string input)
{
    int index;
    int commandLength = lengthCmd.length();
    if (input.length() == commandLength) {
        error(errorLengthIncomplete);
        return;
    }
    if (input.at(commandLength) == '1') {
        index = 0;
    } else if (input.at(commandLength) == '2') {
        index = 1;
    } else {
        error(errorLengthIncomplete);
        return;
    }
    info("Length of text " + to_string(index + 1) + " is " + to_string(text[index].length()) + ".");
    return;
}

void processPrintCmd(string input)
{
    int index;
    int commandLength = printCmd.length();
    if (input.length() == commandLength) {
        error(errorPrintIncomplete);
        return;
    }
    if (input.at(commandLength) == '1') {
        index = 0;
    } else if (input.at(commandLength) == '2') {
        index = 1;
    } else {
        error(errorPrintIncomplete);
        return;
    }
    info(latinToGreek(text[index]));
}

void processMaxresultsCmd(string input)
{
    int index;
    int commandLength = maxresultsCmd.length();
    if (input.length() == commandLength) {
        error(errorMaxresultsParameters);
        return;
    }
    string rest = input.substr(input.find(" ") + 1);
    maxresults = stoi(rest);
    info("Set to " + to_string(maxresults) + ".");
}

void processSqlCmd(string input)
{
    int index;
    int commandLength = sqlCmd.length();
    if (input.length() == commandLength) {
        error(errorSqlParameters);
        return;
    }
    string rest = input.substr(input.find(" ") + 1);
    if (rest.compare("on") == 0 || rest.compare("1") == 0 || rest.compare("true") == 0) {
        sql = true;
        info("SQL output enabled.");
    } else {
        sql = false;
        info("SQL output disabled.");
    }
}

void processColorsCmd(string input)
{
    int index;
    int commandLength = colorsCmd.length();
    if (input.length() == commandLength) {
        error(errorColorsParameters);
        return;
    }
    string rest = input.substr(input.find(" ") + 1);
    if (rest.compare("on") == 0 || rest.compare("1") == 0 || rest.compare("true") == 0) {
        set_colors(true);
        info("Colors enabled.");
    } else {
        set_colors(false);
        info("Colors disabled.");
    }
}

void processCompareCmd()
{
    if (textset.at(0) && textset.at(1)) {
        compareLatin(text[0], text[1]);
    } else {
        error("Text 1 or 2 is not set.");
    }
}

void processJaccardCmd()
{
    if (textset.at(0) && textset.at(1)) {
        double jd = jaccard_dist(text[0], text[1]);
        info("Jaccard distance is " + to_string(jd) + ".");
    } else {
        error("Text 1 or 2 is not set.");
    }
}

void processPsalminfoCmd(string input)
{
    vector<string> tokens;
    boost::split(tokens, input, boost::is_any_of(" "));
    int size = tokens.size();
    if (size == 3) {
        try {
            int psalmInfo = getPsalmLastVerse(tokens[1], stoi(tokens[2]));
            info(tokens[1] + " Psalm " + tokens[2] + " contains " + to_string(psalmInfo)
                 + " verses.");
        } catch (exception &e) {
            error(errorMisc);
        }
    } else {
        error(errorPsalminfoParameters);
    }
}

void processMinuniqueCmd(string input)
{
    int commandLength = minuniqueCmd.length();
    if (input.length() == commandLength) {
        error(errorMinuniqueParameters);
        return;
    }
    if (input.length() < minuniqueCmd.length() + 2) {
        error(errorMinuniqueParameters);
        return;
    }
    string rest = input.substr(input.find(" ") + 1);
    find_min_unique(text[0], rest, true);
}

void processRawCmd(string input)
{
    int index; // clipboard number (0 or 1), if used
    int commandLength = rawCmd.length();
    if (input.length() == commandLength) {
        error(errorRawIncomplete);
        return;
    }
    if (input.at(commandLength) == ' ') { // no clipboard is requested
        string rest = input.substr(input.find(" ") + 1);
        vector<string> tokens;
        boost::split(tokens, rest, boost::is_any_of(" "));
        int restSize = tokens.size();
        if (restSize == 4) { // e.g. raw LXX Genesis 1 10
            try {
                string module = tokens[0];                                // LXX
                string book = tokens[1];                                  // Genesis
                int startPos = stoi(tokens[2]);                           // 1
                int length = stoi(tokens[3]);                             // 10
                string text = getRaw(module, book, startPos - 1, length); // Obtain the raw text...
                info(text);                                               // Report the result.
                return;                                                   // Success!
            } catch (exception &e) {
                error(errorMisc);
                return;
            }
        } else {
            error(errorRawParameters);
            return;
        }
    }
    if (input.at(commandLength) == '1') {
        index = 0; // using clipboard 1
    } else if (input.at(commandLength) == '2') {
        index = 1; // using clipboard 1
    } else {
        error(errorRawIncomplete);
        return;
    }
    string rest = input.substr(input.find(" ") + 1);
    vector<string> tokens;
    boost::split(tokens, rest, boost::is_any_of(" "));
    int restSize = tokens.size();
    if (restSize == 4) { // e.g. raw1 LXX Genesis 1 10
        // TODO: This part is same as above. Unify.
        try {
            string module = tokens[0];                                // LXX
            string book = tokens[1];                                  // Genesis
            int startPos = stoi(tokens[2]);                           // 1
            int length = stoi(tokens[3]);                             // 10
            text[index] = getRaw(module, book, startPos - 1, length); // Obtain the raw text...
            textset[index] = true;                                    // Report the result.
            info("Stored.");
            return; // Success!
        } catch (exception &e) {
            error(errorMisc);
            return;
        }
    } else {
        error(errorRawParameters);
        return;
    }
}

void processExtendCmd(string input)
{
    int commandLength = extendCmd.length();
    if (input.length() == commandLength) {
        error(errorExtendParameters);
        return;
    }
    if (input.at(commandLength) != ' ') {
        error(errorExtendParameters);
        return;
    }
    string rest = input.substr(input.find(" ") + 1);
    vector<string> tokens;
    boost::split(tokens, rest, boost::is_any_of(" "));
    int restSize = tokens.size();
    string moduleName1 = tokens[0]; // Old Testament
    string moduleName2 = tokens[1]; // New Testament
    string book2 = tokens[2];       // a book from the New Testament
    string verse2S, verse2E;
    if (restSize == 4) {            // e.g. extend LXX StatResGNT Romans 3:13
        verse2S = tokens[3] + "+0"; // add zero plus shift implicitly
        verse2E = tokens[3] + "-0"; // add zero minus shift implicitly
    } else if (restSize == 5) {     // e.g. extend LXX StatResGNT Romans 15:11+38 15:11-22
        verse2S = tokens[3];
        verse2E = tokens[4];
    } else {
        error(errorExtendParameters);
        return;
    }
    vector<string> verse2ST, verse2ET;
    int start = 0, end = 0;
    boost::split(verse2ST, verse2S, boost::is_any_of("+"));
    if (verse2ST.size() > 1) {
        start = stoi(verse2ST[1]); // read off plus shift
    }
    boost::split(verse2ET, verse2E, boost::is_any_of("-"));
    if (verse2ET.size() > 1) {
        end = stoi(verse2ET[1]); // read off minus shift
    }
    try {
        // Compute...
        extend(moduleName1, moduleName2, book2, verse2ST[0], start, verse2ET[0], end);
    } catch (exception &e) {
        error(errorMisc);
    }
    // Success!
}

void processGetrefsCmd(string input)
{
    int commandLength = getrefsCmd.length();
    if (input.length() == commandLength) {
        error(errorGetrefsParameters);
        return;
    }
    if (input.at(commandLength) != ' ') {
        error(errorGetrefsParameters);
        return;
    }
    string rest = input.substr(input.find(" ") + 1);
    vector<string> tokens;
    boost::split(tokens, rest, boost::is_any_of(" "));
    int restSize = tokens.size();
    if (restSize < 3) {
        error(errorGetrefsParameters);
        return;
    }
    string moduleName2 = tokens[0]; // New Testament
    string moduleName1 = tokens[1]; // Old Testament
    string book1 = tokens[2];       // a book from the Old Testament
    string verse1S, verse1E;
    if (restSize == 3) { // TODO: implement this
        error("Getting references from full books is not yet implemented, sorry.");
        return;
    }
    if (restSize == 4) { // e.g. getrefs StatResGNT LXX Isaiah 9:2
        if (book1 == "Psalms") {
            vector<string> r;
            boost::split(r, tokens[3], boost::is_any_of(":"));
            if (r.size()
                == 1) { // only the psalm number is given, e.g. getrefs StatResGNT LXX Psalms 51
                verse1S = r[0] + ":1+0";
                try {
                    verse1E = r[0] + ":" + to_string(getPsalmLastVerse(moduleName1, stoi(r[0])))
                              + "-0";
                } catch (exception &e) {
                    error(errorMisc);
                }
            } else { // one verse is given in the psalm, e.g. getrefs StatResGNT LXX Psalms 51:4
                verse1S = tokens[3] + "+0"; // add zero plus shift implicitly
                verse1E = tokens[3] + "-0"; // add zero minus shift implicitly
            }
        } else {                        // this is not a psalm and one verse is given
            verse1S = tokens[3] + "+0"; // add zero plus shift implicitly
            verse1E = tokens[3] + "-0"; // add zero negative shift implicitly
        }
    } else if (restSize == 5) { // e.g. getrefs StatResGNT LXX Psalms 51:4 51:5
        verse1S = tokens[3];
        verse1E = tokens[4];
    } else {
        error(errorExtendParameters);
        return;
    }
    vector<string> verse1ST, verse1ET;
    int start = 0, end = 0;
    boost::split(verse1ST, verse1S, boost::is_any_of("+"));
    if (verse1ST.size() > 1) {
        start = stoi(verse1ST[1]); // read off plus shift
    }
    boost::split(verse1ET, verse1E, boost::is_any_of("-"));
    if (verse1ET.size() > 1) {
        end = stoi(verse1ET[1]); // read off minus shift
    }
    try {
        // Compute...
        getrefs(moduleName2, moduleName1, book1, verse1ST[0], start, verse1ET[0], end);
    } catch (exception &e) {
        error(errorMisc);
    }
    info("Finished"); // Success!
}

void processStatementCmd(string input)
{
    char *output = brst_scan_string((char *) input.c_str(), 0, 0, 0, 0, 0, 0);
    string output_s(output);
    vector<string> statementAnalysis;
    boost::split(statementAnalysis, output_s, boost::is_any_of("\n"));
    for (auto l : statementAnalysis) {
        if (l.find(": info: ") != string::npos || l.find(": warning: ") != string::npos)
            info(l);
        if (l.find(": error: ") != string::npos)
            error(l);
    }
    info("Finished"); // Success!
}

string cli_process(char *buf)
{
    string rawinput(buf);             // Convert the input to string.
    boost::algorithm::trim(rawinput); // Trim the input.
    vector<string> commentTokens;
    boost::split(commentTokens, rawinput, boost::is_any_of("#"));
    string input = commentTokens[0]; // Do not use any characters before "#".
    boost::algorithm::trim(input);   // Trim the remaining parts of the input.

    // Check if the input command is one of the available commands.

    // Commands with no parameters...
    if (input.compare(addbooksCmd) == 0)
        processAddbooksCmd();
    else if (input.compare(quitCmd) == 0)
        processQuitCmd();
    // Commands with some parameters...
    // TODO: This list is not ordered, it should be listed alphabetically,
    // or even better, an array could be defined to combine strings and functions.
    else if (boost::starts_with(input, helpCmd))
        processHelpCmd(input);
    else if (boost::starts_with(input, textCmd))
        processTextCmd(input);
    else if (boost::starts_with(input, searchCmd))
        processSearchCmd(input);
    else if (boost::starts_with(input, latintextCmd))
        processLatintextCmd(input);
    else if (boost::starts_with(input, lookupCmd))
        processLookupCmd(input);
    else if (boost::starts_with(input, tokensCmd))
        processTokensCmd(input);
    else if (boost::starts_with(input, findCmd))
        processFindCmd(input);
    else if (boost::starts_with(input, lengthCmd))
        processLengthCmd(input);
    else if (boost::starts_with(input, printCmd))
        processPrintCmd(input);
    else if (boost::starts_with(input, maxresultsCmd))
        processMaxresultsCmd(input);
    else if (boost::starts_with(input, sqlCmd))
        processSqlCmd(input);
    else if (boost::starts_with(input, colorsCmd))
        processColorsCmd(input);
    // Commands that require an appendix...
    else if (boost::starts_with(input, compareCmd + "12"))
        processCompareCmd();
    else if (boost::starts_with(input, jaccardCmd + "12"))
        processJaccardCmd();
    else if (boost::starts_with(input, minuniqueCmd + "1"))
        processMinuniqueCmd(input);
    // TODO: Consider using this trick for the other commands:
    else if (boost::starts_with(input, psalminfoCmd + " "))
        processPsalminfoCmd(input);
    else if (boost::starts_with(input, rawCmd))
        processRawCmd(input);
    else if (boost::starts_with(input, extendCmd))
        processExtendCmd(input);
    else if (boost::starts_with(input, getrefsCmd))
        processGetrefsCmd(input);
    else if (boost::starts_with(input, statementCmd) || boost::starts_with(input, statementCmd2))
        processStatementCmd(input);
    // If the input is not recognized, we show an error...
    else if (input.length() != 0) // unless there was no input at all
        error(errorNotRecognized);

    // Finally, we return with the previously collected info and clear that variable...
    string ret = collect_info;
    collect_info = "";
    return ret;
}

void cli(const char *input_prepend, const char *output_prepend, bool addbooks, bool colored)
{
    output_prepend_set = new char[4]; // FIXME: this is hardcoded.
    strcpy(output_prepend_set, output_prepend);
#ifndef __EMSCRIPTEN__
#ifndef __APPLE__
    rl_attempted_completion_function = completer; // Initialize readline.
#endif
#endif
    info("This is bibref " BIBREF_VERSION ", nice to meet you.");
    showAvailableBibles();
    if (addbooks) {
        if (addBibles() == 0) {
            booksAdded = true;
        }
    }

    maxresults = 100; // Query results are maximized in 100 results by default.
    sql = false;      // SQL output is disabled by default.

    set_colors(colored); // Set default coloring.

#ifndef __EMSCRIPTEN__
#ifndef __MINGW32__
#ifndef __APPLE__
    // Load the readline history...
    char *bufline;
    struct passwd *pw = getpwuid(getuid());
    char *histfile = pw->pw_dir;
    strcat(histfile, "/.bibref_history");
    read_history(histfile);
#endif
#endif
#endif

#if defined(__EMSCRIPTEN__) || defined(__MINGW32__) || defined(__APPLE__)
#define MAX_LINE_LENGTH 1024
    char bufline[MAX_LINE_LENGTH + 1];
#endif

#define MAX_BUFFER_LENGTH 8192
    char buf[MAX_BUFFER_LENGTH + 1] = "";
    string line;
    bool multiline = false;
    // The main input/output loop...
    while (
#if !defined(__EMSCRIPTEN__) && !defined(__MINGW32__) && !defined(__APPLE__)
        (bufline = readline(input_prepend)) != nullptr
#else
        (getline(cin, line) && (strcpy(bufline, line.c_str())))
#endif
    ) {
#if !defined(__EMSCRIPTEN__) && !defined(__MINGW32__) && !defined(__APPLE__)
        if (strlen(bufline) > 0) {
            add_history(bufline);
            write_history(histfile);
        }
#endif
        line = string(bufline);
        // Handle multiline inputs (for the statement command)...
        boost::algorithm::trim(line); // Trim the input.
        if (!multiline
            && (boost::starts_with(line, statementCmd) || boost::starts_with(line, statementCmd2))) {
            multiline = true;
        }
        if (multiline && boost::ends_with(line, ".")) {
            multiline = false;
        }
        strcat(buf, bufline);
        if (!multiline) {
            cli_process(buf); // Process the input.
            buf[0] = '\0';
        } else
            strcat(buf, "\n");
#if !(defined(__EMSCRIPTEN__) || defined(__MINGW32__) || defined(__APPLE__))
        // readline malloc's a new buffer every time.
        free(bufline);
#endif
    }
}

#ifdef __EMSCRIPTEN__
#include <emscripten.h>
// Taken from https://github.com/emscripten-core/emscripten/issues/6433
extern "C" {
inline const char *cstr(const std::string &message)
{
    auto buffer = (char *) malloc(message.length() + 1);
    buffer[message.length()] = '\0';
    memcpy(buffer, message.data(), message.length());
    return buffer;
}
EMSCRIPTEN_KEEPALIVE const char *bibref_wasm(char *input)
{
    string output = cli_process(input);
    return cstr(output);
}
EMSCRIPTEN_KEEPALIVE const char *bibref_wasm_vocabulary()
{
    string output = "";
    for (auto word : vocabulary) {
        output += word + ",";
    }
    return cstr(output);
}
}
#endif

void error(const string &message)
{
#ifndef __EMSCRIPTEN__
    cerr << error_color;
#endif
    cerr << message;
#ifndef __EMSCRIPTEN__
    cerr << reset_color;
#endif
    cerr << endl << flush;
    collect_info = collect_info + error_color + message + reset_color + "\n";
}