parser.c

Go to the documentation of this file.

#include "parser.h"

#include "cfg/cfg_parser.h"

#include <io/kfile.h>
#include <struct/hashtable.h>

#include <stdlib.h> // atol(), NULL
#include <string.h> // strchr(), strcmp()

static const void* get_key_from_command(const void* cmd, uint8_t* length);

DECLARE_HASHTABLE_STATIC(commands, CONFIG_MAX_COMMANDS_NUMBER, get_key_from_command);


static bool get_word(const char **begin, const char **end)
{
    const char *cur = *end;

    while ((*cur == ' ' || *cur == '\t') && *cur)
        ++cur;

    *begin = cur;

    while ((*cur != ' ' && *cur != '\t') && *cur)
        ++cur;

    *end = cur;

    return (*end != *begin);
}


static bool parseArgs(const char *fmt, const char *input, parms argv[])
{
    const char *begin = input, *end = input;

    while (*fmt)
    {
        // Extract the argument
        if (!get_word(&begin, &end))
            return false;

        switch (*fmt)
        {
            case 'd':
                (*argv++).l = atol(begin);
                break;

            case 's':
                (*argv++).s = begin;
                break;

            default:
                ASSERT2(0, "Unknown format for argument");
                return false;
        }

        ++fmt;
    }

    /* check if there are remaining args */
    if (get_word(&begin, &end))
        return false;

    return true;
}

const char* parser_rl_match(UNUSED_ARG(void *,dummy), const char *word, int word_len)
{
    HashIterator cur;
    HashIterator end = ht_iter_end(&commands);
    const char *found = NULL;

    for (cur = ht_iter_begin(&commands);
         !ht_iter_cmp(cur, end);
         cur = ht_iter_next(cur))
    {
        const struct CmdTemplate* cmdp = (const struct CmdTemplate*)ht_iter_get(cur);
        if (strncmp(cmdp->name, word, word_len) == 0)
        {
            // If there was another matching word, it means that we have a multiple
            //  match: then return NULL.
            if (found)
                return NULL;

            found = cmdp->name;
        }
    }

    return found;
}

#if CONFIG_ENABLE_COMPAT_BEHAVIOUR
bool parser_get_cmd_id(const char* line, unsigned long* ID)
{
    const char *begin = line, *end = line;
    char *end2;

    // The first word is the ID
    if (!get_word(&begin, &end))
        return false;

    *ID = strtoul(begin, &end2, 10);
    if (end2 != end)
        return false;

    return true;
}
#endif

const struct CmdTemplate* parser_get_cmd_template(const char *input)
{
    const char *begin = input, *end = input;

#if CONFIG_ENABLE_COMPAT_BEHAVIOUR
    // Skip the ID, and get the command
    if (!get_word(&begin, &end))
        return NULL;
#endif
    if (!get_word(&begin, &end))
        return NULL;

    return (const struct CmdTemplate*)ht_find(&commands, begin, end-begin);
}

static const char *skip_to_params(const char *input, const struct CmdTemplate *cmdp)
{
    const char *begin = input, *end = input;

#if CONFIG_ENABLE_COMPAT_BEHAVIOUR
    // Skip the ID, and get the command
    if (!get_word(&begin, &end))
        return NULL;
#endif
    if (!get_word(&begin, &end))
        return NULL;

    ASSERT2(strlen(cmdp->name) == (size_t)(end-begin), "Invalid command template specified");
    ASSERT2(!strncmp(begin, cmdp->name, end-begin), "Invalid command template specified");

    return end;
}

bool parser_get_cmd_arguments(const char* input, const struct CmdTemplate* cmdp, parms args[CONFIG_PARSER_MAX_ARGS])
{
    input = skip_to_params(input, cmdp);
    if (!input)
        return false;

    args[0].s = cmdp->name;
    if (!parseArgs(cmdp->arg_fmt, input, args + 1))
        return false;

    return true;
}

static const void* get_key_from_command(const void* cmd, uint8_t* length)
{
    const struct CmdTemplate* c = cmd;
    *length = strlen(c->name);
    return c->name;
}

bool parser_process_line(const char* input)
{
    const struct CmdTemplate *cmdp;
    parms args[CONFIG_PARSER_MAX_ARGS];

    cmdp = parser_get_cmd_template(input);
    if (!cmdp)
        return false;

    if (!parser_get_cmd_arguments(input, cmdp, args))
        return false;

    if (!parser_execute_cmd(cmdp, args))
        return false;

    return true;
}

bool parser_register_cmd(const struct CmdTemplate* cmd)
{
    return ht_insert(&commands, cmd);
}

void parser_init(void)
{
    // Initialize the hashtable used to store the command description
    ht_init(&commands);
}