linenoise 命令行编辑库 < 不止于 tab 补全 >

linenoise 是一个命令行编辑库（ line editing library ），由 Redis 设计者 Antirez 发布的一个用于替代 readline 的工具库。目前 linenoise 已经使用在 Redis、MongoDB、Android 等 应用上了

我们平时在使用 redis-cli 等工具的时候经常会发现输入命令的时候会有一些提示信息，这就是 linenoise 这个库比较直观的功能。我们这次主要探讨 linenoise 的 使用示例 以及 源码解析

特点

linenoise 有很多比较显著的特点，其中比较吸引我们的是：

• 及其简练，无需配置，直接调用
• 单行/多行 编辑模式都支持，并且实现了常用的快捷键绑定
• history 历史记录
• 兼容性
• 源码可读性好，而且只有 1100+ 行

项目地址：https://github.com/antirez/linenoise

使用示例

示例：example.c，代码比较简单，这里就不展示运行结果了，可以下载一下自行运行尝试

核心 API 主要为（根据使用顺序）

• linenoiseSetMultiLine 设置多行模式
• linenoisePrintKeyCodes 键盘检测模式
• linenoiseSetCompletionCallback 设置信息自动补全回调函数，tab 效果
• linenoiseAddCompletion 添加补全信息
• linenoiseSetHintsCallback 设置命令提示内容以及显示样式
• linenoiseHistoryLoad 历史命令加载
• linenoise 命令动态监控
• linenoiseHistoryAdd 添加命令至历史列表
• linenoiseHistorySave 保存命令至历史文件
• linenoiseHistorySetMaxLen 设置命令最大保存个数

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "linenoise.h"

/* 添加自动补全信息 */
void completion(const char *buf, linenoiseCompletions *lc) {
    if (buf[0] == 'h') {
        linenoiseAddCompletion(lc,"hello");
        linenoiseAddCompletion(lc,"hello there");
    }
}
/* 命令提示内容显示设置 */
char *hints(const char *buf, int *color, int *bold) {
    // 如果命令为 hello
    if (!strcasecmp(buf,"hello")) {
        // 命令字体颜色
        *color = 35;
        // 命令字体样式
        *bold = 0;
        // 提示内容
        return " World";
    }
    return NULL;
}

int main(int argc, char **argv) {
    char *line;
    char *prgname = argv[0];

    /* Parse options, with --multiline we enable multi line editing. */
    // 解析传参
    while(argc > 1) {
        argc--;
        argv++;
        if (!strcmp(*argv,"--multiline")) {
            // 设置多行模式
            linenoiseSetMultiLine(1);
            printf("Multi-line mode enabled.\n");
        } else if (!strcmp(*argv,"--keycodes")) {
            // 进入键盘检测模式
            linenoisePrintKeyCodes();
            exit(0);
        } else {
            fprintf(stderr, "Usage: %s [--multiline] [--keycodes]\n", prgname);
            exit(1);
        }
    }

    /* Set the completion callback. This will be called every time the
     * user uses the <tab> key. */
    // 设置信息自动补全回调函数
    linenoiseSetCompletionCallback(completion);
    // 设置命令提示内容以及显示样式回调函数
    linenoiseSetHintsCallback(hints);

    /* Load history from file. The history file is just a plain text file
     * where entries are separated by newlines. */
    // 历史命令加载
    linenoiseHistoryLoad("history.txt"); /* Load the history at startup */

    /* Now this is the main loop of the typical linenoise-based application.
     * The call to linenoise() will block as long as the user types something
     * and presses enter.
     *
     * The typed string is returned as a malloc() allocated string by
     * linenoise, so the user needs to free() it. */
    // 命令动态监控
    while((line = linenoise("hello> ")) != NULL) {
        /* Do something with the string. */
        if (line[0] != '\0' && line[0] != '/') {
            printf("echo: '%s'\n", line);
            // 添加命令至历史列表
            linenoiseHistoryAdd(line); /* Add to the history. */
            // 保存命令至历史文件
            linenoiseHistorySave("history.txt"); /* Save the history on disk. */
        } else if (!strncmp(line,"/historylen",11)) {
            /* The "/historylen" command will change the history len. */
            int len = atoi(line+11);
            // 设置命令最大保存个数
            linenoiseHistorySetMaxLen(len);
        } else if (line[0] == '/') {
            printf("Unreconized command: %s\n", line);
        }
        free(line);
    }
    return 0;
}

源码解析

由于有些方法里的代码量比较大，我们这里按照 典型的代码片段进行解析，同志们可以根据文章提示的代码位置 和 代码里面的关键词 在源码中搜素，可能数据结构一些元素 看不太懂什么意思，没关系，先混个脸熟，后面看完回头再看过来就明白了

linenoise 源码结构比较简单，主要就是 linenoise.c 文件，由于源码比较简单，我们主要对 char *linenoise(const char *prompt); 这一个 API 进行剖析…

/* linenoise.c: line 1054 */

char *linenoise(const char *prompt) {
    char buf[LINENOISE_MAX_LINE];
    int count;

    if (!isatty(STDIN_FILENO)) {
        /* Not a tty: read from file / pipe. In this mode we don't want any
         * limit to the line size, so we call a function to handle that. */
        // 非 TTY 模式逻辑，一般通过 管道或者执行文件 的方式而来，通过处理尽量返回原数据，一般限制最大4KB
        return linenoiseNoTTY();
    } else if (isUnsupportedTerm()) {
        // 根据 getenv("TERM") 获取判断是否 不支持的 终端（不支持的终端只有 "dumb","cons25","emacs"），简单处理直接返回
        size_t len;
        // 先输出前缀，比如 hello>
        printf("%s",prompt);
        fflush(stdout);
        // 获取输入设备数据
        if (fgets(buf,LINENOISE_MAX_LINE,stdin) == NULL) return NULL;
        len = strlen(buf);
        while(len && (buf[len-1] == '\n' || buf[len-1] == '\r')) {
            len--;
            buf[len] = '\0';
        }
        return strdup(buf);
    } else {
        // 正常终端，根据键入的 字符串或者识别 特殊 快捷键，加工字符串并 输出，而 linenoiseRaw函数的 核心处理逻辑为 linenoiseEdit
        count = linenoiseRaw(buf,LINENOISE_MAX_LINE,prompt);
        if (count == -1) return NULL;
        return strdup(buf);
    }
}

linenoiseRaw函数的 核心处理逻辑为 linenoiseEdit，用来处理用户交互运算

/* linenoise.c: line 770 */

/**
 * 命令提示交互
 * @param int stdin_fd   输入设备描述符
 * @param int stdout_fd  输出设备描述符
 * @param char *buf      返回字符指针
 * @param size_t buflen  返回字符长度
 * @param char *prompt   提示符，比如 hello> 
 */
static int linenoiseEdit(int stdin_fd, int stdout_fd, char *buf, size_t buflen, const char *prompt)
{
    // linenoise 状态变量
    struct linenoiseState l;

    /* Populate the linenoise state that we pass to functions implementing
     * specific editing functionalities. */
    l.ifd = stdin_fd;
    l.ofd = stdout_fd;
    l.buf = buf;
    l.buflen = buflen;
    l.prompt = prompt;
    l.plen = strlen(prompt);
    l.oldpos = l.pos = 0;
    l.len = 0;
    // 获取终端 列数目，是使用 ioctl 的 winsize 函数，主要用来区分 单行/双行 模式
    l.cols = getColumns(stdin_fd, stdout_fd);
    l.maxrows = 0;
    l.history_index = 0;

    /* Buffer starts empty. */
    l.buf[0] = '\0';
    l.buflen--; /* Make sure there is always space for the nulterm */

    /* The latest history entry is always our current buffer, that
     * initially is just an empty string. */
    // 初始化 当前命令在 history 中记录
    linenoiseHistoryAdd("");
    // 先将提示 前缀输出，比如 hello> 
    if (write(l.ofd,prompt,l.plen) == -1) return -1;
    while(1) {
        char c;
        int nread;
        char seq[3];
        
        // 读取输入终端键入数据
        nread = read(l.ifd,&c,1);
        if (nread <= 0) return l.len;

        /* Only autocomplete when the callback is set. It returns < 0 when
         * there was an error reading from fd. Otherwise it will return the
         * character that should be handled next. */
        // 9 代表 tab 键，当前判断是 如果键入的 tab 并且设置过自动补全的回调函数
        if (c == 9 && completionCallback != NULL) {
            // 将自动补全处理后的字符串返回，不过返回结果可能为0 则没有符合条件的补全所以继续走后续逻辑，小于0 则错误
            c = completeLine(&l);
            /* Return on errors */
            if (c < 0) return l.len;
            /* Read next character when 0 */
            if (c == 0) continue;
        }

        switch(c) {
        case ENTER:    /* enter */
            // enter 键，直接返回
            // 去除 空 history
            history_len--;
            free(history[history_len]);
            // 多行模式，移到行尾
            if (mlmode) linenoiseEditMoveEnd(&l);
            // 命令提示回调函数存在
            if (hintsCallback) {
                /* Force a refresh without hints to leave the previous
                 * line as the user typed it after a newline. */
                linenoiseHintsCallback *hc = hintsCallback;
                hintsCallback = NULL;
                // 刷新 linenoise 状态
                refreshLine(&l);
                hintsCallback = hc;
            }
            return (int)l.len;
        case CTRL_C:     /* ctrl-c */
            // 退出
            errno = EAGAIN;
            return -1;
        case BACKSPACE:   /* backspace */
        case 8:     /* ctrl-h */
            // 退格，backspace 和 ctrl+h 一样效果
            linenoiseEditBackspace(&l);
            break;
        case CTRL_D:     /* ctrl-d, remove char at right of cursor, or if the line is empty, act as end-of-file. */
            // 移除当前光标右侧一个字符
            if (l.len > 0) {
                linenoiseEditDelete(&l);
            } else {
                history_len--;
                free(history[history_len]);
                return -1;
            }
            break;
        case CTRL_T:    /* ctrl-t, swaps current character with previous. */
            // 将当前光标的字符跟前面字符调换
            if (l.pos > 0 && l.pos < l.len) {
                int aux = buf[l.pos-1];
                buf[l.pos-1] = buf[l.pos];
                buf[l.pos] = aux;
                if (l.pos != l.len-1) l.pos++;
                refreshLine(&l);
            }
            break;
        case CTRL_B:     /* ctrl-b */
            // 光标往前移动
            linenoiseEditMoveLeft(&l);
            break;
        case CTRL_F:     /* ctrl-f */
            // 光标往后移动
            linenoiseEditMoveRight(&l);
            break;
        case CTRL_P:    /* ctrl-p */
            // 上一条 history 记录
            linenoiseEditHistoryNext(&l, LINENOISE_HISTORY_PREV);
            break;
        case CTRL_N:    /* ctrl-n */
            // 下一条 history 记录
            linenoiseEditHistoryNext(&l, LINENOISE_HISTORY_NEXT);
            break;
        case ESC:    /* escape sequence */
            /* Read the next two bytes representing the escape sequence.
             * Use two calls to handle slow terminals returning the two
             * chars at different times. */
            // ESC 需要配合另外键进行组合执行，单独 ESC 不执行
            if (read(l.ifd,seq,1) == -1) break;
            if (read(l.ifd,seq+1,1) == -1) break;

            /* ESC [ sequences. */
            // 输入 ESC 后，再输入 [
            if (seq[0] == '[') {
                // 再输入 3~ 则相当于删除按钮
                if (seq[1] >= '0' && seq[1] <= '9') {
                    /* Extended escape, read additional byte. */
                    if (read(l.ifd,seq+2,1) == -1) break;
                    if (seq[2] == '~') {
                        switch(seq[1]) {
                        // 输入 ESC[3~ 效果
                        case '3': /* Delete key. */
                            linenoiseEditDelete(&l);
                            break;
                        }
                    }
                } else {
                // 再输入 其他字符如下作用
                    switch(seq[1]) {
                    // 输入 ESC[A 效果
                    case 'A': /* Up */
                        // 上一条 history 记录
                        linenoiseEditHistoryNext(&l, LINENOISE_HISTORY_PREV);
                        break;
                    // 输入 ESC[B 效果
                    case 'B': /* Down */
                        // 下一条 history 记录
                        linenoiseEditHistoryNext(&l, LINENOISE_HISTORY_NEXT);
                        break;
                    // 输入 ESC[C 效果
                    case 'C': /* Right */
                        // 光标往后移动
                        linenoiseEditMoveRight(&l);
                        break;
                    // 输入 ESC[D 效果
                    case 'D': /* Left */
                        // 光标往前移动
                        linenoiseEditMoveLeft(&l);
                        break;
                    // 输入 ESC[H 效果
                    case 'H': /* Home */
                        // 光标移动到行首
                        linenoiseEditMoveHome(&l);
                        break;
                    // 输入 ESC[F 效果
                    case 'F': /* End*/
                        // 光标移动到行尾
                        linenoiseEditMoveEnd(&l);
                        break;
                    }
                }
            }

            /* ESC O sequences. */
            // 开头输入 ESCO
            else if (seq[0] == 'O') {
                switch(seq[1]) {
                // 输入 ESCOH 效果
                case 'H': /* Home */
                    // 光标移动到行首
                    linenoiseEditMoveHome(&l);
                    break;
                // 输入 ESCOF 效果
                case 'F': /* End*/
                    // 光标移动到行尾
                    linenoiseEditMoveEnd(&l);
                    break;
                }
            }
            break;
        default:
            // 非快捷键，正常字符串输入
            if (linenoiseEditInsert(&l,c)) return -1;
            break;
        case CTRL_U: /* Ctrl+u, delete the whole line. */
            // 删除整行
            buf[0] = '\0';
            l.pos = l.len = 0;
            refreshLine(&l);
            break;
        case CTRL_K: /* Ctrl+k, delete from current to end of line. */
            // 删除从当前光标到行尾的所有字符
            buf[l.pos] = '\0';
            l.len = l.pos;
            refreshLine(&l);
            break;
        case CTRL_A: /* Ctrl+a, go to the start of the line */
            // 光标移动到行首
            linenoiseEditMoveHome(&l);
            break;
        case CTRL_E: /* ctrl+e, go to the end of the line */
            // 光标移动到行尾
            linenoiseEditMoveEnd(&l);
            break;
        case CTRL_L: /* ctrl+l, clear screen */
            // 清屏，这个操作比较简单，是向输出设备输出 \x1b[H\x1b[2J 字符
            linenoiseClearScreen();
            refreshLine(&l);
            break;
        case CTRL_W: /* ctrl+w, delete previous word */
            // 删除前一个单词
            linenoiseEditDeletePrevWord(&l);
            break;
        }
    }
    return l.len;
}

TAB 命令信息自动补全处理逻辑 completeLine()

/* linenoise.c: line 350 */

static int completeLine(struct linenoiseState *ls) {
    linenoiseCompletions lc = { 0, NULL };
    int nread, nwritten;
    char c = 0;
    
    // 执行信息补全回调函数，获取补全信息
    completionCallback(ls->buf,&lc);
    if (lc.len == 0) {
        // 补全信息什么也没有，并给出提示音，实现也比较简单：
        // fprintf(stderr, "\x7"); fflush(stderr);
        linenoiseBeep();
    } else {
        size_t stop = 0, i = 0;

        while(!stop) {
            /* Show completion or original buffer */
            if (i < lc.len) {
                // 追加处理补全信息并刷新页面显示，如果还有后续循环存储命令
                struct linenoiseState saved = *ls;

                ls->len = ls->pos = strlen(lc.cvec[i]);
                ls->buf = lc.cvec[i];
                refreshLine(ls);
                ls->len = saved.len;
                ls->pos = saved.pos;
                ls->buf = saved.buf;
            } else {
                refreshLine(ls);
            }
            // 继续读取数据并处理
            nread = read(ls->ifd,&c,1);
            if (nread <= 0) {
                freeCompletions(&lc);
                return -1;
            }

            switch(c) {
                case 9: /* tab */
                    // 字符+1，如果等于补全数据长度则 补全完毕，beep 提示
                    i = (i+1) % (lc.len+1);
                    if (i == lc.len) linenoiseBeep();
                    break;
                case 27: /* escape */
                    // ESC 退出检测循环
                    /* Re-show original buffer */
                    if (i < lc.len) refreshLine(ls);
                    stop = 1;
                    break;
                default:
                    /* Update buffer and return */
                    // 继续读取循环
                    if (i < lc.len) {
                        nwritten = snprintf(ls->buf,ls->buflen,"%s",lc.cvec[i]);
                        ls->len = ls->pos = nwritten;
                    }
                    stop = 1;
                    break;
            }
        }
    }
    // 回收 lc
    freeCompletions(&lc);
    return c; /* Return last read character */
}

---

本文作者： wettper
本文链接： http://www.web-lovers.com/c-linenoise.html
版权声明： 本博客所有文章除特别声明外，均采用 CC BY-NC-SA 3.0 许可协议。转载请注明出处！

赏

谢谢你请我吃糖果

支付宝

微信