readline.c

Go to the documentation of this file.

#include "readline.h"

#include <cfg/compiler.h>
#include <cfg/debug.h>

#include <stdio.h>

#define DEBUG_UNIT_TEST       0

#define DEBUG_DUMP_HISTORY    0


enum RL_KEYS {
    SPECIAL_KEYS = 0x1000,

    /*
     * Three byte keys:
     * #################
     * UpArrow:     0x1B 0x5B 0X41
     * DownArrow:   0x1B 0x5B 0X42
     * RightArrow:  0x1B 0x5B 0x43
     * LeftArrow:   0x1b 0x5B 0x44
     * Beak(Pause): 0x1b 0x5B 0x50
    */
    KEY_UP_ARROW,
    KEY_DOWN_ARROW,
    KEY_LEFT_ARROW,
    KEY_RIGHT_ARROW,
    KEY_PAUSE,

    /*
     * Four byte keys:
     * ################
     * F1:          0x1b 0x5B 0x5B 0x41
     * F2:          0x1b 0x5B 0x5B 0x42
     * F3:          0x1b 0x5B 0x5B 0x43
     * F4:          0x1b 0x5B 0x5B 0x44
     * F5:          0x1b 0x5B 0x5B 0x45
     * Ins:         0x1b 0x5B 0x32 0x7E
     * Home:        0x1b 0x5B 0x31 0x7E
     * PgUp:        0x1b 0x5B 0x35 0x7E
     * Del:         0x1b 0x5B 0x33 0x7E
     * End:         0x1b 0x5B 0x34 0x7E
     * PgDn:        0x1b 0x5B 0x36 0x7E
     */
    KEY_F1, KEY_F2, KEY_F3, KEY_F4, KEY_F5,
    KEY_INS, KEY_HOME, KEY_PGUP, KEY_DEL, KEY_END, KEY_PGDN,

    /*
     * Five byte keys:
     * ################
     * F6:          0x1b 0x5B 0x31 0x37 0x7E
     * F7:          0x1b 0x5B 0x31 0x38 0x7E
     * F8:          0x1b 0x5B 0x31 0x39 0x7E
     * F9:          0x1b 0x5B 0x32 0x30 0x7E
     * F10:         0x1b 0x5B 0x32 0x31 0x7E
     * F11:         0x1b 0x5B 0x32 0x33 0x7E
     * F12:         0x1b 0x5B 0x32 0x34 0x7E
     */
    KEY_F6, KEY_F7, KEY_F8, KEY_F9,
    KEY_F10, KEY_F11, KEY_F12,
};

#define IS_WORD_SEPARATOR(c) ((c) == ' ' || (c) == '\0')

INLINE void rl_puts(const struct RLContext* ctx, const char* txt)
{
    if (!ctx->put)
        return;

    while (*txt)
        ctx->put(*txt++, ctx->put_param);
}

INLINE void rl_putc(const struct RLContext* ctx, char ch)
{
    if (ctx->put)
        ctx->put(ch, ctx->put_param);
}

static bool rl_getc(const struct RLContext* ctx, int* ch)
{
    int c = ctx->get(ctx->get_param);

    if (c == EOF)
    {
        if (ctx->clear)
            ctx->clear(ctx->clear_param);

        return false;
    }

    if (c == 0x1B)
    {
        // Unknown ESC sequence. Ignore it and read
        //  return next character.
        if (ctx->get(ctx->get_param) != 0x5B)
            return rl_getc(ctx, ch);

        /* To be added:
            * Home:        0x1b 0x5B 0x31 0x7E
            * F6:          0x1b 0x5B 0x31 0x37 0x7E
            * F7:          0x1b 0x5B 0x31 0x38 0x7E
            * F8:          0x1b 0x5B 0x31 0x39 0x7E
            * Ins:         0x1b 0x5B 0x32 0x7E
            * F9:          0x1b 0x5B 0x32 0x30 0x7E
            * F10:         0x1b 0x5B 0x32 0x31 0x7E
            * F11:         0x1b 0x5B 0x32 0x33 0x7E
            * F12:         0x1b 0x5B 0x32 0x34 0x7E
            * Del:         0x1b 0x5B 0x33 0x7E
            * End:         0x1b 0x5B 0x34 0x7E
            * PgUp:        0x1b 0x5B 0x35 0x7E
            * PgDn:        0x1b 0x5B 0x36 0x7E
        */

        c = ctx->get(ctx->get_param);
        switch (c)
        {
        case 0x41: c = KEY_UP_ARROW; break;
        case 0x42: c = KEY_DOWN_ARROW; break;
        case 0x43: c = KEY_RIGHT_ARROW; break;
        case 0x44: c = KEY_LEFT_ARROW; break;
        case 0x50: c = KEY_PAUSE; break;
        case 0x5B:
            c = ctx->get(ctx->get_param);
            switch (c)
            {
            case 0x41: c = KEY_F1; break;
            case 0x42: c = KEY_F2; break;
            case 0x43: c = KEY_F3; break;
            case 0x44: c = KEY_F4; break;
            case 0x45: c = KEY_F5; break;
            default: return rl_getc(ctx, ch);
            }
            break;
        default: return rl_getc(ctx, ch);
        }
    }

    *ch = c;
    return true;
}

INLINE void beep(struct RLContext* ctx)
{
    rl_putc(ctx, '\a');
}

static bool pop_history(struct RLContext* ctx, int total_len)
{
    // Compute the length of the first command (including terminator).
    int len = strlen(ctx->real_history+1)+1;

    // (the first byte of the history should always be 0)
    ASSERT(ctx->real_history[0] == '\0');

    // If it is the only one in the history, do nothing
    if (len == total_len)
        return false;

    // Overwrite the first command with the second one
    memmove(ctx->real_history, ctx->real_history+len, HISTORY_SIZE-len);

    // Move back the ctx->buffer pointer so that all the indices are still valid
    ctx->history -= len;

    return true;
}

INLINE bool is_history_begin(struct RLContext* ctx, int i)
{ return ctx->history + i == ctx->real_history; }

INLINE bool is_history_end(struct RLContext* ctx, int i)
{ return ctx->history + i == ctx->real_history + HISTORY_SIZE; }

INLINE bool is_history_past_end(struct RLContext* ctx, int i)
{ return ctx->history + i >= ctx->real_history + HISTORY_SIZE; }

static bool insert_chars(struct RLContext* ctx, size_t *curpos, const char* ch, int num_chars)
{
    ASSERT(!is_history_past_end(ctx, *curpos));

    while (is_history_past_end(ctx, *curpos+num_chars+1))
    {
        if (!pop_history(ctx, *curpos))
            return false;
    }

    while (num_chars--)
        ctx->history[++(*curpos)] = *ch++;

    ASSERT(!is_history_past_end(ctx, *curpos + 1));
    ctx->history[*curpos+1] = '\0';
    return true;
}

static bool insert_char(struct RLContext* ctx, size_t *curpos, char ch)
{
    return insert_chars(ctx, curpos, &ch, 1);
}

#if DEBUG_DUMP_HISTORY

static void dump_history(struct RLContext* ctx)
{
    int k;
    char buf[8];
    ASSERT(ctx->real_history[0] == '\0');
    rl_puts(ctx, "History dump:");
    rl_puts(ctx, "\r\n");
    for (k = 1;
         ctx->real_history + k != ctx->history + ctx->history_pos + 1;
         k += strlen(&ctx->real_history[k]) + 1)
    {
        rl_puts(ctx, &ctx->real_history[k]);
        rl_puts(ctx, "\r\n");
    }

    sprintf(buf, "%d\r\n", ctx->history_pos + (ctx->history - ctx->real_history));
    rl_puts(ctx, buf);
}
#endif /* DEBUG_DUMP_HISTORY */

static bool complete_word(struct RLContext *ctx, size_t *curpos)
{
    const char* completed_word;
    size_t wstart;

    // If the current character is a separator,
    //  there is nothing to complete
    wstart = *curpos;
    if (IS_WORD_SEPARATOR(ctx->history[wstart]))
    {
        beep(ctx);
        return false;
    }

    // Find the separator before the current word
    do
        --wstart;
    while (!IS_WORD_SEPARATOR(ctx->history[wstart]));

    // Complete the word through the hook
    completed_word = ctx->match(ctx->match_param, ctx->history + wstart + 1, *curpos - wstart);
    if (!completed_word)
        return false;

    // Move back the terminal cursor to the separator
    while (*curpos != wstart)
    {
        rl_putc(ctx, '\b');
        --*curpos;
    }

    // Insert the completed command
    insert_chars(ctx, curpos, completed_word, strlen(completed_word));
    rl_puts(ctx, completed_word);
    insert_char(ctx, curpos, ' ');
    rl_putc(ctx, ' ');

    return true;
}

void rl_refresh(struct RLContext* ctx)
{
    rl_puts(ctx, "\r\n");
    if (ctx->prompt)
        rl_puts(ctx, ctx->prompt);
    rl_puts(ctx, ctx->history + ctx->history_pos + 1);
}

const char* rl_readline(struct RLContext* ctx)
{
    while (1)
    {
        char ch;
        int c;

        ASSERT(ctx->history - ctx->real_history + ctx->line_pos < HISTORY_SIZE);

        if (!rl_getc(ctx, &c))
            return NULL;

        // Just ignore special keys for now
        if (c > SPECIAL_KEYS)
            continue;

        if (c == '\t')
        {
            // Ask the match hook if available
            if (!ctx->match)
                return NULL;

            complete_word(ctx, &ctx->line_pos);
            continue;
        }

        // Backspace cancels a character, or it is ignored if at
        //  the start of the line
        if (c == '\b')
        {
            if (ctx->history[ctx->line_pos] != '\0')
            {
                --ctx->line_pos;
                rl_puts(ctx, "\b \b");
            }
            continue;
        }

        if (c == '\r' || c == '\n')
        {
            rl_puts(ctx, "\r\n");
            break;
        }


        // Add a character to the buffer, if possible
        ch = (char)c;
        ASSERT2(ch == c, "a special key was not properly handled");
        if (insert_chars(ctx, &ctx->line_pos, &ch, 1))
            rl_putc(ctx, ch);
        else
            beep(ctx);
    }

    ctx->history_pos = ctx->line_pos + 1;
    while (ctx->history[ctx->line_pos] != '\0')
        --ctx->line_pos;

    // Do not store empty lines in the history
    if (ctx->line_pos == ctx->history_pos - 1)
        ctx->history_pos -= 1;

#if DEBUG_DUMP_HISTORY
    dump_history(ctx);
#endif

    const char *buf = &ctx->history[ctx->line_pos + 1];

    ctx->line_pos = ctx->history_pos;

    if (ctx->prompt)
        rl_puts(ctx, ctx->prompt);

    insert_chars(ctx, &ctx->line_pos, NULL, 0);

    // Since the current pointer now points to the separator, we need
    //  to return the first character
    return buf;
}


#if DEBUG_UNIT_TEST

void rl_test(void);

#if HISTORY_SIZE != 32
    #error This test needs HISTORY_SIZE to be set at 32
#endif

static struct RLContext test_ctx;

static char* test_getc_ptr;
static int test_getc(void* data)
{
    return *test_getc_ptr++;
}

static bool do_test(char* input_buffer, char* expected_history)
{
    rl_init_ctx(&test_ctx);
    rl_sethook_get(&test_ctx, test_getc, NULL);

    test_getc_ptr = input_buffer;
    while (*test_getc_ptr)
        rl_readline(&test_ctx);

    if (memcmp(test_ctx.real_history, expected_history, HISTORY_SIZE) != 0)
    {
        ASSERT2(0, "history compare failed");
        return false;
    }

    return true;
}

void rl_test(void)
{
    char* test1_in = "a\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk\nl\nm\nn\no\np\nq\nr\ns\nt\nu\nv\nw\nx\ny\nz\n";
    char test1_hist[HISTORY_SIZE] = "\0l\0m\0n\0o\0p\0q\0r\0s\0t\0u\0v\0w\0x\0y\0z";

    if (!do_test(test1_in, test1_hist))
        return;

    kprintf("rl_test successful\n");
}

#endif /* DEBUG_UNIT_TEST */