readline.c 8.18 KB
Newer Older
1
#include <stdio.h>
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <string.h>

#include <stm32f4xx_hal.h>

#include "misc.h"
#include "mpconfig.h"
#include "qstr.h"
#include "misc.h"
#include "obj.h"
#include "pybstdio.h"
#include "readline.h"
#include "usb.h"

15
16
17
18
19
20
21
#if 0 // print debugging info
#define DEBUG_PRINT (1)
#define DEBUG_printf printf
#else // don't print debugging info
#define DEBUG_printf(...) (void)0
#endif

22
23
24
25
#define READLINE_HIST_SIZE (8)

static const char *readline_hist[READLINE_HIST_SIZE] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};

26
enum { ESEQ_NONE, ESEQ_ESC, ESEQ_ESC_BRACKET, ESEQ_ESC_BRACKET_DIGIT, ESEQ_ESC_O };
27

28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
void readline_init(void) {
    memset(readline_hist, 0, READLINE_HIST_SIZE * sizeof(const char*));
}

STATIC char *str_dup(const char *str) {
    uint32_t len = strlen(str);
    char *s2 = m_new(char, len + 1);
    memcpy(s2, str, len);
    s2[len] = 0;
    return s2;
}

int readline(vstr_t *line, const char *prompt) {
    stdout_tx_str(prompt);
    int orig_line_len = line->len;
43
    int escape_seq = ESEQ_NONE;
44
    char escape_seq_buf[1] = {0};
45
46
47
48
49
50
51
52
    int hist_cur = -1;
    int cursor_pos = orig_line_len;
    for (;;) {
        int c = stdin_rx_chr();
        int last_line_len = line->len;
        int redraw_step_back = 0;
        bool redraw_from_cursor = false;
        int redraw_step_forward = 0;
53
        if (escape_seq == ESEQ_NONE) {
54
55
56
            if (VCP_CHAR_CTRL_A <= c && c <= VCP_CHAR_CTRL_D && vstr_len(line) == orig_line_len) {
                // control character with empty line
                return c;
57
58
            } else if (c == VCP_CHAR_CTRL_A) {
                // CTRL-A with non-empty line is go-to-start-of-line
59
                goto home_key;
60
61
            } else if (c == VCP_CHAR_CTRL_E) {
                // CTRL-E is go-to-end-of-line
62
                goto end_key;
63
64
65
66
67
68
69
70
71
72
73
74
75
76
            } else if (c == '\r') {
                // newline
                stdout_tx_str("\r\n");
                if (line->len > orig_line_len && (readline_hist[0] == NULL || strcmp(readline_hist[0], line->buf + orig_line_len) != 0)) {
                    // a line which is not empty and different from the last one
                    // so update the history
                    for (int i = READLINE_HIST_SIZE - 1; i > 0; i--) {
                        readline_hist[i] = readline_hist[i - 1];
                    }
                    readline_hist[0] = str_dup(line->buf + orig_line_len);
                }
                return 0;
            } else if (c == 27) {
                // escape sequence
77
                escape_seq = ESEQ_ESC;
78
79
            } else if (c == 8 || c == 127) {
                // backspace/delete
80
81
82
83
84
85
86
87
88
89
90
91
92
                if (cursor_pos > orig_line_len) {
                    vstr_cut_out_bytes(line, cursor_pos - 1, 1);
                    // set redraw parameters
                    redraw_step_back = 1;
                    redraw_from_cursor = true;
                }
            } else if (32 <= c && c <= 126) {
                // printable character
                vstr_ins_char(line, cursor_pos, c);
                // set redraw parameters
                redraw_from_cursor = true;
                redraw_step_forward = 1;
            }
93
        } else if (escape_seq == ESEQ_ESC) {
94
95
            switch (c) {
                case '[':
96
                    escape_seq = ESEQ_ESC_BRACKET;
97
98
                    break;
                case 'O':
99
                    escape_seq = ESEQ_ESC_O;
100
101
                    break;
                default:
102
103
                    DEBUG_printf("(ESC %d)", c);
                    escape_seq = ESEQ_NONE;
104
            }
105
        } else if (escape_seq == ESEQ_ESC_BRACKET) {
106
            if ('0' <= c && c <= '9') {
107
                escape_seq = ESEQ_ESC_BRACKET_DIGIT;
108
109
                escape_seq_buf[0] = c;
            } else {
110
                escape_seq = ESEQ_NONE;
111
112
113
114
115
116
117
                if (c == 'A') {
                    // up arrow
                    if (hist_cur + 1 < READLINE_HIST_SIZE && readline_hist[hist_cur + 1] != NULL) {
                        // increase hist num
                        hist_cur += 1;
                        // set line to history
                        line->len = orig_line_len;
118
                        vstr_add_str(line, readline_hist[hist_cur]);
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
                        // set redraw parameters
                        redraw_step_back = cursor_pos - orig_line_len;
                        redraw_from_cursor = true;
                        redraw_step_forward = line->len - orig_line_len;
                    }
                } else if (c == 'B') {
                    // down arrow
                    if (hist_cur >= 0) {
                        // decrease hist num
                        hist_cur -= 1;
                        // set line to history
                        vstr_cut_tail_bytes(line, line->len - orig_line_len);
                        if (hist_cur >= 0) {
                            vstr_add_str(line, readline_hist[hist_cur]);
                        }
                        // set redraw parameters
                        redraw_step_back = cursor_pos - orig_line_len;
                        redraw_from_cursor = true;
                        redraw_step_forward = line->len - orig_line_len;
                    }
                } else if (c == 'C') {
                    // right arrow
                    if (cursor_pos < line->len) {
                        redraw_step_forward = 1;
                    }
                } else if (c == 'D') {
                    // left arrow
                    if (cursor_pos > orig_line_len) {
                        redraw_step_back = 1;
148
                    }
149
150
151
152
153
154
155
156
                } else if (c == 'H') {
                    // home
                    goto home_key;
                } else if (c == 'F') {
                    // end
                    goto end_key;
                } else {
                    DEBUG_printf("(ESC [ %d)", c);
157
                }
158
            }
159
        } else if (escape_seq == ESEQ_ESC_BRACKET_DIGIT) {
160
161
            if (c == '~') {
                if (escape_seq_buf[0] == '1' || escape_seq_buf[0] == '7') {
162
home_key:
163
164
                    redraw_step_back = cursor_pos - orig_line_len;
                } else if (escape_seq_buf[0] == '4' || escape_seq_buf[0] == '8') {
165
end_key:
166
                    redraw_step_forward = line->len - cursor_pos;
167
168
                } else {
                    DEBUG_printf("(ESC [ %c %d)", escape_seq_buf[0], c);
169
                }
170
171
            } else {
                DEBUG_printf("(ESC [ %c %d)", escape_seq_buf[0], c);
172
            }
173
174
            escape_seq = ESEQ_NONE;
        } else if (escape_seq == ESEQ_ESC_O) {
175
176
177
178
179
180
            switch (c) {
                case 'H':
                    goto home_key;
                case 'F':
                    goto end_key;
                default:
181
182
                    DEBUG_printf("(ESC O %d)", c);
                    escape_seq = ESEQ_NONE;
183
            }
184
        } else {
185
            escape_seq = ESEQ_NONE;
186
187
188
        }

        // redraw command prompt, efficiently
189
        // TODO we can probably use some more sophisticated VT100 commands here
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
        if (redraw_step_back > 0) {
            for (int i = 0; i < redraw_step_back; i++) {
                stdout_tx_str("\b");
            }
            cursor_pos -= redraw_step_back;
        }
        if (redraw_from_cursor) {
            if (line->len < last_line_len) {
                // erase old chars
                for (int i = cursor_pos; i < last_line_len; i++) {
                    stdout_tx_str(" ");
                }
                // step back
                for (int i = cursor_pos; i < last_line_len; i++) {
                    stdout_tx_str("\b");
                }
            }
            // draw new chars
            stdout_tx_strn(line->buf + cursor_pos, line->len - cursor_pos);
            // move cursor forward if needed (already moved forward by length of line, so move it back)
            for (int i = cursor_pos + redraw_step_forward; i < line->len; i++) {
                stdout_tx_str("\b");
            }
            cursor_pos += redraw_step_forward;
        } else if (redraw_step_forward > 0) {
            // draw over old chars to move cursor forwards
            stdout_tx_strn(line->buf + cursor_pos, redraw_step_forward);
            cursor_pos += redraw_step_forward;
        }

        HAL_Delay(1);
    }
}