Subversion Repositories Games.Descent

/*

 * This file is part of the DXX-Rebirth project <https://www.dxx-rebirth.com/>.

 * It is copyright by its individual contributors, as recorded in the

 * project's Git history.  See COPYING.txt at the top level for license

 * terms and a link to the Git history.

 *

 */

/*

 *

 * Command parsing and processing

 *

 */

#include <cstdarg>

#include <map>

#include <forward_list>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#include "dxxerror.h"

#include "u_mem.h"

#include "strutil.h"

#include "inferno.h"

#include "console.h"

#include "cvar.h"

#include "physfsx.h"

#include "compiler-range_for.h"

#include <memory>

namespace {

struct cmd_t

{

        const char    *name;

        cmd_handler_t function;

        const char    *help_text;

};

/* The list of cmds */

static std::map<const char *, std::unique_ptr<cmd_t>> cmd_list;

#define ALIAS_NAME_MAX 32

struct cmd_alias_t

{

        char           name[ALIAS_NAME_MAX];

        RAIIdmem<char[]> value;

};

}

#define CMD_MAX_ALIASES 1024

/* The list of aliases */

static std::map<std::string, std::unique_ptr<cmd_alias_t>> cmd_alias_list;

static cmd_t *cmd_findcommand(const char *cmd_name)

{

        const auto i = cmd_list.find(cmd_name);

        return i == cmd_list.end() ? nullptr : i->second.get();

}

static cmd_alias_t *cmd_findalias(const char *alias_name )

{

        const auto i = cmd_alias_list.find(alias_name);

        return i == cmd_alias_list.end() ? nullptr : i->second.get();

}

/* add a new console command */

void cmd_addcommand(const char *cmd_name, cmd_handler_t cmd_func, const char *cmd_help_text)

{

        const auto i = cmd_list.insert(std::make_pair(cmd_name, std::unique_ptr<cmd_t>{}));

        if (!i.second)

        {

                Int3();

                con_printf(CON_NORMAL, "command %s already exists, not adding", cmd_name);

                return;

        }

        auto cmd = (i.first->second = std::make_unique<cmd_t>()).get();

        /* create command, insert to hashtable */

        cmd->name = cmd_name;

        cmd->function = cmd_func;

        cmd->help_text = cmd_help_text;

        con_printf(CON_DEBUG, "cmd_addcommand: added %s", cmd->name);

}

namespace {

struct cmd_queue_t

{

        RAIIdmem<char[]> command_line;

        explicit cmd_queue_t(char *p) :

                command_line(p)

        {

        }

};

}

/* The list of commands to be executed */

static std::forward_list<cmd_queue_t> cmd_queue;

/* execute a parsed command */

static void cmd_execute(unsigned long argc, const char *const *const argv)

{

        cmd_t *cmd;

        cmd_alias_t *alias;

        if ( (cmd = cmd_findcommand(argv[0])) )

        {

                con_printf(CON_DEBUG, "cmd_execute: executing %s", argv[0]);

                cmd->function(argc, argv);

                return;

        }

        if ( (alias = cmd_findalias(argv[0])) && alias->value )

        {

                con_printf(CON_DEBUG, "cmd_execute: pushing alias \"%s\": %s", alias->name, alias->value.get());

                cmd_insert(alias->value.get());

                return;

        }

        /* Otherwise */

        if (argc < 31)

        {  // set value of cvar

                const char *new_argv[32];

                int i;

                new_argv[0] = "set";

                for (i = 0; i < argc; i++)

                        new_argv[i+1] = argv[i];

                cvar_cmd_set(argc + 1, new_argv);

        }

}

/* Parse an input string */

static void cmd_parse(char *input)

{

        char buffer[CMD_MAX_LENGTH];

        char *tokens[CMD_MAX_TOKENS];

        int num_tokens;

        uint_fast32_t i, l;

        Assert(input != NULL);

        /* Strip leading spaces */

        while( isspace(*input) ) { ++input; }

        buffer[sizeof(buffer) - 1] = 0;

        strncpy(buffer, input, sizeof(buffer) - 1);

        //printf("lead strip \"%s\"\n",buffer);

        l = strlen(buffer);

        /* If command is empty, give up */

        if (l==0) return;

        /* Strip trailing spaces */

        for (i=l-1; i>0 && isspace(buffer[i]); i--) ;

        buffer[i+1] = 0;

        //printf("trail strip \"%s\"\n",buffer);

        /* Split into tokens */

        l = strlen(buffer);

        num_tokens = 1;

        tokens[0] = buffer;

        for (i=1; i<l; i++) {

                if (buffer[i] == '"') {

                        tokens[num_tokens - 1] = &buffer[++i];

                        while (i < l && buffer[i] != '"')

                                i++;

                        buffer[i] = 0;

                        continue;

                }

                if (isspace(buffer[i]) || buffer[i] == '=') {

                        buffer[i] = 0;

                        while (isspace(buffer[i+1]) && (i+1 < l)) i++;

                        tokens[num_tokens++] = &buffer[i+1];

                }

        }

        /* Check for matching commands */

        cmd_execute(num_tokens, tokens);

}

static int cmd_queue_wait;

int cmd_queue_process(void)

{

        for (;;)

        {

                if (cmd_queue_wait)

                        break;

                auto cmd = cmd_queue.begin();

                if (cmd == cmd_queue.end())

                        break;

                auto command_line = std::move(cmd->command_line);

                cmd_queue.pop_front();

                con_printf(CON_DEBUG, "cmd_queue_process: processing %s", command_line.get());

                cmd_parse(command_line.get());  // Note, this may change the queue

        }

        if (cmd_queue_wait > 0) {

                cmd_queue_wait--;

                con_puts(CON_DEBUG, "cmd_queue_process: waiting");

                return 1;

        }

        return 0;

}

/* execute until there are no commands left */

void cmd_queue_flush(void)

{

        while (cmd_queue_process()) {

        }

}

/* Add some commands to the queue to be executed */

void cmd_enqueue(int insert, const char *input)

{

        std::forward_list<cmd_queue_t> l;

        char output[CMD_MAX_LENGTH];

        char *optr;

        auto before_end = [](std::forward_list<cmd_queue_t> &f) {

                for (auto i = f.before_begin();;)

                {

                        auto j = i;

                        if (++ i == f.end())

                                return j;

                }

        };

        auto iter = before_end(l);

        while (*input) {

                optr = output;

                int quoted = 0;

                /* Strip leading spaces */

                while(isspace(*input) || *input == ';')

                        input++;

                /* If command is empty, give up */

                if (! *input)

                        continue;

                /* Find the end of this line (\n, ;, or nul) */

                do {

                        if (!*input)

                                break;

                        if (*input == '"') {

                                quoted = 1 - quoted;

                                continue;

                        } else if ( *input == '\n' || (!quoted && *input == ';') ) {

                                input++;

                                break;

                        }

                } while ((*optr++ = *input++));

                *optr = 0;

                /* make a new queue item, add it to list */

                iter = l.emplace_after(iter, cmd_queue_t{d_strdup(output)});

                con_printf(CON_DEBUG, "cmd_enqueue: adding %s", output);

        }

        auto after = insert

                /* add our list to the head of the main list */

                ? (con_puts(CON_DEBUG, "cmd_enqueue: added to front of list"), cmd_queue.before_begin())

                /* add our list to the tail of the main list */

                : (con_puts(CON_DEBUG, "cmd_enqueue: added to back of list"), before_end(cmd_queue))

        ;

        cmd_queue.splice_after(after, std::move(l));

}

void cmd_enqueuef(int insert, const char *fmt, ...)

{

        va_list arglist;

        char buf[CMD_MAX_LENGTH];

        va_start (arglist, fmt);

        vsnprintf(buf, sizeof(buf), fmt, arglist);

        va_end (arglist);

        cmd_enqueue(insert, buf);

}

/* Attempt to autocomplete an input string */

const char *cmd_complete(const char *input)

{

        uint_fast32_t len = strlen(input);

        if (!len)

                return NULL;

        range_for (const auto &i, cmd_list)

                if (!d_strnicmp(input, i.first, len))

                        return i.first;

        range_for (const auto &i, cmd_alias_list)

                if (!d_strnicmp(input, i.first.c_str(), len))

                        return i.first.c_str();

        return cvar_complete(input);

}

/* alias */

static void cmd_alias(unsigned long argc, const char *const *const argv)

{

        char buf[CMD_MAX_LENGTH] = "";

        if (argc < 2) {

                con_puts(CON_NORMAL, "aliases:");

                range_for (const auto &i, cmd_alias_list)

                        con_printf(CON_NORMAL, "%s: %s", i.first.c_str(), i.second->value.get());

                return;

        }

        if (argc == 2) {

                cmd_alias_t *alias;

                if ( (alias = cmd_findalias(argv[1])) && alias->value )

                {

                        con_printf(CON_NORMAL, "%s: %s", alias->name, alias->value.get());

                        return;

                }

                con_printf(CON_NORMAL, "alias: %s not found", argv[1]);

                return;

        }

        for (int i = 2; i < argc; i++) {

                if (i > 2)

                        strncat(buf, " ", sizeof(buf) - strlen(buf) - 1);

                strncat(buf, argv[i], sizeof(buf) - strlen(buf) - 1);

        }

        const auto i = cmd_alias_list.insert(std::make_pair(argv[1], std::unique_ptr<cmd_alias_t>{}));

        auto alias = i.first->second.get();

        if (i.second)

        {

                alias = (i.first->second = std::make_unique<cmd_alias_t>()).get();

                alias->name[sizeof(alias->name) - 1] = 0;

                strncpy(alias->name, argv[1], sizeof(alias->name) - 1);

        }

        alias->value.reset(d_strdup(buf));

}

/* unalias */

static void cmd_unalias(unsigned long argc, const char *const *const argv)

{

        if (argc < 2 || argc > 2) {

                cmd_insertf("help %s", argv[0]);

                return;

        }

        const char *alias_name = argv[1];

        const auto alias = cmd_alias_list.find(alias_name);

        if (alias == cmd_alias_list.end())

        {

                con_printf(CON_NORMAL, "unalias: %s not found", alias_name);

                return;

        }

        cmd_alias_list.erase(alias);

}

/* echo to console */

static void cmd_echo(unsigned long argc, const char *const *const argv)

{

        char buf[CMD_MAX_LENGTH] = "";

        int i;

        for (i = 1; i < argc; i++) {

                if (i > 1)

                        strncat(buf, " ", sizeof(buf) - strlen(buf) - 1);

                strncat(buf, argv[i], sizeof(buf) - strlen(buf) - 1);

        }

        con_puts(CON_NORMAL, buf);

}

/* execute script */

static void cmd_exec(unsigned long argc, const char *const *const argv)

{

        PHYSFSX_gets_line_t<CMD_MAX_LENGTH> line;

        if (argc < 2 || argc > 2) {

                cmd_insertf("help %s", argv[0]);

                return;

        }

        auto f = PHYSFSX_openReadBuffered(argv[1]);

        if (!f) {

                con_printf(CON_CRITICAL, "exec: %s not found", argv[1]);

                return;

        }

        std::forward_list<cmd_queue_t> l;

        auto i = l.before_begin();

        while (PHYSFSX_fgets(line, f)) {

                /* make a new queue item, add it to list */

                i = l.emplace_after(i, cmd_queue_t{d_strdup(line)});

                con_printf(CON_DEBUG, "cmd_exec: adding %s", static_cast<const char *>(line));

        }

        /* add our list to the head of the main list */

        con_puts(CON_DEBUG, "cmd_exec: added to front of list");

        cmd_queue.splice_after(cmd_queue.before_begin(), std::move(l));

}

/* get help */

static void cmd_help(unsigned long argc, const char *const *const argv)

{

        cmd_t *cmd;

        if (argc > 2) {

                cmd_insertf("help %s", argv[0]);

                return;

        }

        if (argc < 2) {

                con_puts(CON_NORMAL, "Available commands:");

                range_for (const auto &i, cmd_list)

                        con_printf(CON_NORMAL, "    %s", i.first);

                return;

        }

        cmd = cmd_findcommand(argv[1]);

        if (!cmd) {

                con_printf(CON_URGENT, "Command %s not found", argv[1]);

                return;

        }

        if (!cmd->help_text) {

                con_printf(CON_NORMAL, "%s: no help found", argv[1]);

                return;

        }

        con_puts(CON_NORMAL, cmd->help_text);

}

/* execute script */

static void cmd_wait(unsigned long argc, const char *const *const argv)

{

        if (argc > 2) {

                cmd_insertf("help %s", argv[0]);

                return;

        }

        if (argc < 2)

                cmd_queue_wait = 1;

        else

                cmd_queue_wait = atoi(argv[1]);

}

void cmd_init(void)

{

        cmd_addcommand("alias",     cmd_alias,      "alias <name> <commands>\n" "    define <name> as an alias for <commands>\n"

                                                    "alias <name>\n"            "    show the current definition of <name>\n"

                                                    "alias\n"                   "    show all defined aliases");

        cmd_addcommand("unalias",   cmd_unalias,    "unalias <name>\n"          "    undefine the alias <name>");

        cmd_addcommand("echo",      cmd_echo,       "echo [text]\n"             "    write <text> to the console");

        cmd_addcommand("exec",      cmd_exec,       "exec <file>\n"             "    execute <file>");

        cmd_addcommand("help",      cmd_help,       "help [command]\n"          "    get help for <command>, or list all commands if not specified.");

        cmd_addcommand("wait",      cmd_wait,       "usage: wait [n]\n"         "    stop processing commands, resume in <n> cycles (default 1)");

}