]>
Commit | Line | Data |
---|---|---|
7e2515e8 FB |
1 | /* |
2 | * QEMU readline utility | |
5fafdf24 | 3 | * |
7e2515e8 | 4 | * Copyright (c) 2003-2004 Fabrice Bellard |
5fafdf24 | 5 | * |
7e2515e8 FB |
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | * of this software and associated documentation files (the "Software"), to deal | |
8 | * in the Software without restriction, including without limitation the rights | |
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
10 | * copies of the Software, and to permit persons to whom the Software is | |
11 | * furnished to do so, subject to the following conditions: | |
12 | * | |
13 | * The above copyright notice and this permission notice shall be included in | |
14 | * all copies or substantial portions of the Software. | |
15 | * | |
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
22 | * THE SOFTWARE. | |
23 | */ | |
c60bf339 SH |
24 | |
25 | #include "qemu-common.h" | |
0150cd81 | 26 | #include "qemu/readline.h" |
7e2515e8 | 27 | |
7e2515e8 FB |
28 | #define IS_NORM 0 |
29 | #define IS_ESC 1 | |
30 | #define IS_CSI 2 | |
d34dc45d | 31 | #define IS_SS3 3 |
7e2515e8 | 32 | |
4c36ba32 | 33 | void readline_show_prompt(ReadLineState *rs) |
7e2515e8 | 34 | { |
c60bf339 SH |
35 | rs->printf_func(rs->opaque, "%s", rs->prompt); |
36 | rs->flush_func(rs->opaque); | |
4c36ba32 AL |
37 | rs->last_cmd_buf_index = 0; |
38 | rs->last_cmd_buf_size = 0; | |
39 | rs->esc_state = IS_NORM; | |
7e2515e8 FB |
40 | } |
41 | ||
7e2515e8 | 42 | /* update the displayed command line */ |
4c36ba32 | 43 | static void readline_update(ReadLineState *rs) |
7e2515e8 FB |
44 | { |
45 | int i, delta, len; | |
46 | ||
4c36ba32 AL |
47 | if (rs->cmd_buf_size != rs->last_cmd_buf_size || |
48 | memcmp(rs->cmd_buf, rs->last_cmd_buf, rs->cmd_buf_size) != 0) { | |
49 | for(i = 0; i < rs->last_cmd_buf_index; i++) { | |
c60bf339 | 50 | rs->printf_func(rs->opaque, "\033[D"); |
7e2515e8 | 51 | } |
4c36ba32 AL |
52 | rs->cmd_buf[rs->cmd_buf_size] = '\0'; |
53 | if (rs->read_password) { | |
54 | len = strlen(rs->cmd_buf); | |
7e2515e8 | 55 | for(i = 0; i < len; i++) |
c60bf339 | 56 | rs->printf_func(rs->opaque, "*"); |
7e2515e8 | 57 | } else { |
c60bf339 | 58 | rs->printf_func(rs->opaque, "%s", rs->cmd_buf); |
7e2515e8 | 59 | } |
c60bf339 | 60 | rs->printf_func(rs->opaque, "\033[K"); |
4c36ba32 AL |
61 | memcpy(rs->last_cmd_buf, rs->cmd_buf, rs->cmd_buf_size); |
62 | rs->last_cmd_buf_size = rs->cmd_buf_size; | |
63 | rs->last_cmd_buf_index = rs->cmd_buf_size; | |
7e2515e8 | 64 | } |
4c36ba32 AL |
65 | if (rs->cmd_buf_index != rs->last_cmd_buf_index) { |
66 | delta = rs->cmd_buf_index - rs->last_cmd_buf_index; | |
7e2515e8 FB |
67 | if (delta > 0) { |
68 | for(i = 0;i < delta; i++) { | |
c60bf339 | 69 | rs->printf_func(rs->opaque, "\033[C"); |
7e2515e8 FB |
70 | } |
71 | } else { | |
72 | delta = -delta; | |
73 | for(i = 0;i < delta; i++) { | |
c60bf339 | 74 | rs->printf_func(rs->opaque, "\033[D"); |
7e2515e8 FB |
75 | } |
76 | } | |
4c36ba32 | 77 | rs->last_cmd_buf_index = rs->cmd_buf_index; |
7e2515e8 | 78 | } |
c60bf339 | 79 | rs->flush_func(rs->opaque); |
7e2515e8 FB |
80 | } |
81 | ||
4c36ba32 | 82 | static void readline_insert_char(ReadLineState *rs, int ch) |
7e2515e8 | 83 | { |
4c36ba32 AL |
84 | if (rs->cmd_buf_index < READLINE_CMD_BUF_SIZE) { |
85 | memmove(rs->cmd_buf + rs->cmd_buf_index + 1, | |
86 | rs->cmd_buf + rs->cmd_buf_index, | |
87 | rs->cmd_buf_size - rs->cmd_buf_index); | |
88 | rs->cmd_buf[rs->cmd_buf_index] = ch; | |
89 | rs->cmd_buf_size++; | |
90 | rs->cmd_buf_index++; | |
7e2515e8 FB |
91 | } |
92 | } | |
93 | ||
4c36ba32 | 94 | static void readline_backward_char(ReadLineState *rs) |
7e2515e8 | 95 | { |
4c36ba32 AL |
96 | if (rs->cmd_buf_index > 0) { |
97 | rs->cmd_buf_index--; | |
7e2515e8 FB |
98 | } |
99 | } | |
100 | ||
4c36ba32 | 101 | static void readline_forward_char(ReadLineState *rs) |
7e2515e8 | 102 | { |
4c36ba32 AL |
103 | if (rs->cmd_buf_index < rs->cmd_buf_size) { |
104 | rs->cmd_buf_index++; | |
7e2515e8 FB |
105 | } |
106 | } | |
107 | ||
4c36ba32 | 108 | static void readline_delete_char(ReadLineState *rs) |
7e2515e8 | 109 | { |
4c36ba32 AL |
110 | if (rs->cmd_buf_index < rs->cmd_buf_size) { |
111 | memmove(rs->cmd_buf + rs->cmd_buf_index, | |
112 | rs->cmd_buf + rs->cmd_buf_index + 1, | |
113 | rs->cmd_buf_size - rs->cmd_buf_index - 1); | |
114 | rs->cmd_buf_size--; | |
7e2515e8 FB |
115 | } |
116 | } | |
117 | ||
4c36ba32 | 118 | static void readline_backspace(ReadLineState *rs) |
7e2515e8 | 119 | { |
4c36ba32 AL |
120 | if (rs->cmd_buf_index > 0) { |
121 | readline_backward_char(rs); | |
122 | readline_delete_char(rs); | |
7e2515e8 FB |
123 | } |
124 | } | |
125 | ||
4c36ba32 | 126 | static void readline_backword(ReadLineState *rs) |
33fa11d4 TS |
127 | { |
128 | int start; | |
129 | ||
4c36ba32 | 130 | if (rs->cmd_buf_index == 0 || rs->cmd_buf_index > rs->cmd_buf_size) { |
33fa11d4 TS |
131 | return; |
132 | } | |
133 | ||
4c36ba32 | 134 | start = rs->cmd_buf_index - 1; |
33fa11d4 TS |
135 | |
136 | /* find first word (backwards) */ | |
137 | while (start > 0) { | |
4c36ba32 | 138 | if (!qemu_isspace(rs->cmd_buf[start])) { |
33fa11d4 TS |
139 | break; |
140 | } | |
141 | ||
142 | --start; | |
143 | } | |
144 | ||
145 | /* find first space (backwards) */ | |
146 | while (start > 0) { | |
4c36ba32 | 147 | if (qemu_isspace(rs->cmd_buf[start])) { |
33fa11d4 TS |
148 | ++start; |
149 | break; | |
150 | } | |
151 | ||
152 | --start; | |
153 | } | |
154 | ||
155 | /* remove word */ | |
4c36ba32 AL |
156 | if (start < rs->cmd_buf_index) { |
157 | memmove(rs->cmd_buf + start, | |
158 | rs->cmd_buf + rs->cmd_buf_index, | |
159 | rs->cmd_buf_size - rs->cmd_buf_index); | |
160 | rs->cmd_buf_size -= rs->cmd_buf_index - start; | |
161 | rs->cmd_buf_index = start; | |
33fa11d4 TS |
162 | } |
163 | } | |
164 | ||
4c36ba32 | 165 | static void readline_bol(ReadLineState *rs) |
7e2515e8 | 166 | { |
4c36ba32 | 167 | rs->cmd_buf_index = 0; |
7e2515e8 FB |
168 | } |
169 | ||
4c36ba32 | 170 | static void readline_eol(ReadLineState *rs) |
7e2515e8 | 171 | { |
4c36ba32 | 172 | rs->cmd_buf_index = rs->cmd_buf_size; |
7e2515e8 FB |
173 | } |
174 | ||
4c36ba32 | 175 | static void readline_up_char(ReadLineState *rs) |
7e2515e8 FB |
176 | { |
177 | int idx; | |
178 | ||
4c36ba32 | 179 | if (rs->hist_entry == 0) |
7e2515e8 | 180 | return; |
4c36ba32 | 181 | if (rs->hist_entry == -1) { |
7e2515e8 | 182 | /* Find latest entry */ |
4c36ba32 AL |
183 | for (idx = 0; idx < READLINE_MAX_CMDS; idx++) { |
184 | if (rs->history[idx] == NULL) | |
7e2515e8 FB |
185 | break; |
186 | } | |
4c36ba32 | 187 | rs->hist_entry = idx; |
7e2515e8 | 188 | } |
4c36ba32 AL |
189 | rs->hist_entry--; |
190 | if (rs->hist_entry >= 0) { | |
191 | pstrcpy(rs->cmd_buf, sizeof(rs->cmd_buf), | |
192 | rs->history[rs->hist_entry]); | |
193 | rs->cmd_buf_index = rs->cmd_buf_size = strlen(rs->cmd_buf); | |
7e2515e8 FB |
194 | } |
195 | } | |
196 | ||
4c36ba32 | 197 | static void readline_down_char(ReadLineState *rs) |
7e2515e8 | 198 | { |
5b0d2727 AL |
199 | if (rs->hist_entry == -1) |
200 | return; | |
201 | if (rs->hist_entry < READLINE_MAX_CMDS - 1 && | |
202 | rs->history[++rs->hist_entry] != NULL) { | |
4c36ba32 AL |
203 | pstrcpy(rs->cmd_buf, sizeof(rs->cmd_buf), |
204 | rs->history[rs->hist_entry]); | |
7e2515e8 | 205 | } else { |
5b0d2727 | 206 | rs->cmd_buf[0] = 0; |
4c36ba32 | 207 | rs->hist_entry = -1; |
7e2515e8 | 208 | } |
4c36ba32 | 209 | rs->cmd_buf_index = rs->cmd_buf_size = strlen(rs->cmd_buf); |
7e2515e8 FB |
210 | } |
211 | ||
4c36ba32 | 212 | static void readline_hist_add(ReadLineState *rs, const char *cmdline) |
7e2515e8 FB |
213 | { |
214 | char *hist_entry, *new_entry; | |
215 | int idx; | |
216 | ||
217 | if (cmdline[0] == '\0') | |
218 | return; | |
219 | new_entry = NULL; | |
4c36ba32 | 220 | if (rs->hist_entry != -1) { |
7e2515e8 | 221 | /* We were editing an existing history entry: replace it */ |
4c36ba32 AL |
222 | hist_entry = rs->history[rs->hist_entry]; |
223 | idx = rs->hist_entry; | |
7e2515e8 FB |
224 | if (strcmp(hist_entry, cmdline) == 0) { |
225 | goto same_entry; | |
226 | } | |
227 | } | |
228 | /* Search cmdline in history buffers */ | |
4c36ba32 AL |
229 | for (idx = 0; idx < READLINE_MAX_CMDS; idx++) { |
230 | hist_entry = rs->history[idx]; | |
7e2515e8 FB |
231 | if (hist_entry == NULL) |
232 | break; | |
233 | if (strcmp(hist_entry, cmdline) == 0) { | |
234 | same_entry: | |
235 | new_entry = hist_entry; | |
236 | /* Put this entry at the end of history */ | |
4c36ba32 | 237 | memmove(&rs->history[idx], &rs->history[idx + 1], |
8af42882 | 238 | (READLINE_MAX_CMDS - (idx + 1)) * sizeof(char *)); |
4c36ba32 AL |
239 | rs->history[READLINE_MAX_CMDS - 1] = NULL; |
240 | for (; idx < READLINE_MAX_CMDS; idx++) { | |
241 | if (rs->history[idx] == NULL) | |
7e2515e8 FB |
242 | break; |
243 | } | |
244 | break; | |
245 | } | |
246 | } | |
4c36ba32 | 247 | if (idx == READLINE_MAX_CMDS) { |
7e2515e8 | 248 | /* Need to get one free slot */ |
c3baa5f9 | 249 | g_free(rs->history[0]); |
7682e858 NZ |
250 | memmove(rs->history, &rs->history[1], |
251 | (READLINE_MAX_CMDS - 1) * sizeof(char *)); | |
4c36ba32 AL |
252 | rs->history[READLINE_MAX_CMDS - 1] = NULL; |
253 | idx = READLINE_MAX_CMDS - 1; | |
7e2515e8 FB |
254 | } |
255 | if (new_entry == NULL) | |
c3baa5f9 | 256 | new_entry = g_strdup(cmdline); |
4c36ba32 AL |
257 | rs->history[idx] = new_entry; |
258 | rs->hist_entry = -1; | |
7e2515e8 FB |
259 | } |
260 | ||
261 | /* completion support */ | |
262 | ||
4c36ba32 | 263 | void readline_add_completion(ReadLineState *rs, const char *str) |
7e2515e8 | 264 | { |
4c36ba32 | 265 | if (rs->nb_completions < READLINE_MAX_COMPLETIONS) { |
7267c094 | 266 | rs->completions[rs->nb_completions++] = g_strdup(str); |
7e2515e8 FB |
267 | } |
268 | } | |
269 | ||
4c36ba32 | 270 | void readline_set_completion_index(ReadLineState *rs, int index) |
376253ec | 271 | { |
4c36ba32 | 272 | rs->completion_index = index; |
376253ec AL |
273 | } |
274 | ||
307b2f01 HB |
275 | static int completion_comp(const void *a, const void *b) |
276 | { | |
277 | return strcmp(*(const char **) a, *(const char **) b); | |
278 | } | |
279 | ||
4c36ba32 | 280 | static void readline_completion(ReadLineState *rs) |
7e2515e8 | 281 | { |
b427c726 | 282 | int len, i, j, max_width, nb_cols, max_prefix; |
7e2515e8 FB |
283 | char *cmdline; |
284 | ||
4c36ba32 | 285 | rs->nb_completions = 0; |
3b46e624 | 286 | |
6ad7c326 | 287 | cmdline = g_strndup(rs->cmd_buf, rs->cmd_buf_index); |
c60bf339 | 288 | rs->completion_finder(rs->opaque, cmdline); |
7267c094 | 289 | g_free(cmdline); |
7e2515e8 FB |
290 | |
291 | /* no completion found */ | |
4c36ba32 | 292 | if (rs->nb_completions <= 0) |
7e2515e8 | 293 | return; |
4c36ba32 AL |
294 | if (rs->nb_completions == 1) { |
295 | len = strlen(rs->completions[0]); | |
296 | for(i = rs->completion_index; i < len; i++) { | |
297 | readline_insert_char(rs, rs->completions[0][i]); | |
7e2515e8 FB |
298 | } |
299 | /* extra space for next argument. XXX: make it more generic */ | |
4c36ba32 AL |
300 | if (len > 0 && rs->completions[0][len - 1] != '/') |
301 | readline_insert_char(rs, ' '); | |
7e2515e8 | 302 | } else { |
307b2f01 HB |
303 | qsort(rs->completions, rs->nb_completions, sizeof(char *), |
304 | completion_comp); | |
c60bf339 | 305 | rs->printf_func(rs->opaque, "\n"); |
7e2515e8 | 306 | max_width = 0; |
b427c726 | 307 | max_prefix = 0; |
4c36ba32 AL |
308 | for(i = 0; i < rs->nb_completions; i++) { |
309 | len = strlen(rs->completions[i]); | |
b427c726 TS |
310 | if (i==0) { |
311 | max_prefix = len; | |
312 | } else { | |
313 | if (len < max_prefix) | |
314 | max_prefix = len; | |
315 | for(j=0; j<max_prefix; j++) { | |
4c36ba32 | 316 | if (rs->completions[i][j] != rs->completions[0][j]) |
b427c726 TS |
317 | max_prefix = j; |
318 | } | |
319 | } | |
7e2515e8 FB |
320 | if (len > max_width) |
321 | max_width = len; | |
322 | } | |
b427c726 | 323 | if (max_prefix > 0) |
4c36ba32 AL |
324 | for(i = rs->completion_index; i < max_prefix; i++) { |
325 | readline_insert_char(rs, rs->completions[0][i]); | |
b427c726 | 326 | } |
7e2515e8 FB |
327 | max_width += 2; |
328 | if (max_width < 10) | |
329 | max_width = 10; | |
330 | else if (max_width > 80) | |
331 | max_width = 80; | |
332 | nb_cols = 80 / max_width; | |
333 | j = 0; | |
4c36ba32 | 334 | for(i = 0; i < rs->nb_completions; i++) { |
c60bf339 | 335 | rs->printf_func(rs->opaque, "%-*s", max_width, rs->completions[i]); |
4c36ba32 | 336 | if (++j == nb_cols || i == (rs->nb_completions - 1)) { |
c60bf339 | 337 | rs->printf_func(rs->opaque, "\n"); |
7e2515e8 FB |
338 | j = 0; |
339 | } | |
340 | } | |
4c36ba32 | 341 | readline_show_prompt(rs); |
7e2515e8 | 342 | } |
fc9fa4bd SW |
343 | for (i = 0; i < rs->nb_completions; i++) { |
344 | g_free(rs->completions[i]); | |
345 | } | |
7e2515e8 FB |
346 | } |
347 | ||
348 | /* return true if command handled */ | |
4c36ba32 | 349 | void readline_handle_byte(ReadLineState *rs, int ch) |
7e2515e8 | 350 | { |
4c36ba32 | 351 | switch(rs->esc_state) { |
7e2515e8 FB |
352 | case IS_NORM: |
353 | switch(ch) { | |
354 | case 1: | |
4c36ba32 | 355 | readline_bol(rs); |
7e2515e8 FB |
356 | break; |
357 | case 4: | |
4c36ba32 | 358 | readline_delete_char(rs); |
7e2515e8 FB |
359 | break; |
360 | case 5: | |
4c36ba32 | 361 | readline_eol(rs); |
7e2515e8 FB |
362 | break; |
363 | case 9: | |
4c36ba32 | 364 | readline_completion(rs); |
7e2515e8 FB |
365 | break; |
366 | case 10: | |
367 | case 13: | |
4c36ba32 AL |
368 | rs->cmd_buf[rs->cmd_buf_size] = '\0'; |
369 | if (!rs->read_password) | |
370 | readline_hist_add(rs, rs->cmd_buf); | |
c60bf339 | 371 | rs->printf_func(rs->opaque, "\n"); |
4c36ba32 AL |
372 | rs->cmd_buf_index = 0; |
373 | rs->cmd_buf_size = 0; | |
374 | rs->last_cmd_buf_index = 0; | |
375 | rs->last_cmd_buf_size = 0; | |
c60bf339 | 376 | rs->readline_func(rs->opaque, rs->cmd_buf, rs->readline_opaque); |
7e2515e8 | 377 | break; |
33fa11d4 TS |
378 | case 23: |
379 | /* ^W */ | |
4c36ba32 | 380 | readline_backword(rs); |
33fa11d4 | 381 | break; |
7e2515e8 | 382 | case 27: |
4c36ba32 | 383 | rs->esc_state = IS_ESC; |
7e2515e8 FB |
384 | break; |
385 | case 127: | |
386 | case 8: | |
4c36ba32 | 387 | readline_backspace(rs); |
7e2515e8 FB |
388 | break; |
389 | case 155: | |
4c36ba32 | 390 | rs->esc_state = IS_CSI; |
7e2515e8 FB |
391 | break; |
392 | default: | |
393 | if (ch >= 32) { | |
4c36ba32 | 394 | readline_insert_char(rs, ch); |
7e2515e8 FB |
395 | } |
396 | break; | |
397 | } | |
398 | break; | |
399 | case IS_ESC: | |
400 | if (ch == '[') { | |
4c36ba32 AL |
401 | rs->esc_state = IS_CSI; |
402 | rs->esc_param = 0; | |
d34dc45d KW |
403 | } else if (ch == 'O') { |
404 | rs->esc_state = IS_SS3; | |
405 | rs->esc_param = 0; | |
7e2515e8 | 406 | } else { |
4c36ba32 | 407 | rs->esc_state = IS_NORM; |
7e2515e8 FB |
408 | } |
409 | break; | |
410 | case IS_CSI: | |
411 | switch(ch) { | |
412 | case 'A': | |
413 | case 'F': | |
4c36ba32 | 414 | readline_up_char(rs); |
7e2515e8 FB |
415 | break; |
416 | case 'B': | |
417 | case 'E': | |
4c36ba32 | 418 | readline_down_char(rs); |
7e2515e8 FB |
419 | break; |
420 | case 'D': | |
4c36ba32 | 421 | readline_backward_char(rs); |
7e2515e8 FB |
422 | break; |
423 | case 'C': | |
4c36ba32 | 424 | readline_forward_char(rs); |
7e2515e8 FB |
425 | break; |
426 | case '0' ... '9': | |
4c36ba32 | 427 | rs->esc_param = rs->esc_param * 10 + (ch - '0'); |
7e2515e8 FB |
428 | goto the_end; |
429 | case '~': | |
4c36ba32 | 430 | switch(rs->esc_param) { |
7e2515e8 | 431 | case 1: |
4c36ba32 | 432 | readline_bol(rs); |
7e2515e8 FB |
433 | break; |
434 | case 3: | |
4c36ba32 | 435 | readline_delete_char(rs); |
7e2515e8 FB |
436 | break; |
437 | case 4: | |
4c36ba32 | 438 | readline_eol(rs); |
7e2515e8 FB |
439 | break; |
440 | } | |
441 | break; | |
442 | default: | |
443 | break; | |
444 | } | |
4c36ba32 | 445 | rs->esc_state = IS_NORM; |
7e2515e8 FB |
446 | the_end: |
447 | break; | |
d34dc45d KW |
448 | case IS_SS3: |
449 | switch(ch) { | |
450 | case 'F': | |
451 | readline_eol(rs); | |
452 | break; | |
453 | case 'H': | |
454 | readline_bol(rs); | |
455 | break; | |
456 | } | |
457 | rs->esc_state = IS_NORM; | |
458 | break; | |
7e2515e8 | 459 | } |
4c36ba32 | 460 | readline_update(rs); |
7e2515e8 FB |
461 | } |
462 | ||
4c36ba32 | 463 | void readline_start(ReadLineState *rs, const char *prompt, int read_password, |
7e2515e8 FB |
464 | ReadLineFunc *readline_func, void *opaque) |
465 | { | |
4c36ba32 AL |
466 | pstrcpy(rs->prompt, sizeof(rs->prompt), prompt); |
467 | rs->readline_func = readline_func; | |
468 | rs->readline_opaque = opaque; | |
469 | rs->read_password = read_password; | |
2724b180 AL |
470 | readline_restart(rs); |
471 | } | |
472 | ||
473 | void readline_restart(ReadLineState *rs) | |
474 | { | |
4c36ba32 AL |
475 | rs->cmd_buf_index = 0; |
476 | rs->cmd_buf_size = 0; | |
7e2515e8 FB |
477 | } |
478 | ||
4c36ba32 | 479 | const char *readline_get_history(ReadLineState *rs, unsigned int index) |
7e2515e8 | 480 | { |
4c36ba32 | 481 | if (index >= READLINE_MAX_CMDS) |
7e2515e8 | 482 | return NULL; |
4c36ba32 AL |
483 | return rs->history[index]; |
484 | } | |
485 | ||
c60bf339 SH |
486 | ReadLineState *readline_init(ReadLinePrintfFunc *printf_func, |
487 | ReadLineFlushFunc *flush_func, | |
488 | void *opaque, | |
4c36ba32 AL |
489 | ReadLineCompletionFunc *completion_finder) |
490 | { | |
7267c094 | 491 | ReadLineState *rs = g_malloc0(sizeof(*rs)); |
4c36ba32 | 492 | |
4c36ba32 | 493 | rs->hist_entry = -1; |
c60bf339 SH |
494 | rs->opaque = opaque; |
495 | rs->printf_func = printf_func; | |
496 | rs->flush_func = flush_func; | |
4c36ba32 AL |
497 | rs->completion_finder = completion_finder; |
498 | ||
499 | return rs; | |
7e2515e8 | 500 | } |