4 * Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * * Neither the name of Intel Corporation nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 * Copyright (c) 2009, Olivier MATZ <zer0@droids-corp.org>
36 * All rights reserved.
37 * Redistribution and use in source and binary forms, with or without
38 * modification, are permitted provided that the following conditions are met:
40 * * Redistributions of source code must retain the above copyright
41 * notice, this list of conditions and the following disclaimer.
42 * * Redistributions in binary form must reproduce the above copyright
43 * notice, this list of conditions and the following disclaimer in the
44 * documentation and/or other materials provided with the distribution.
45 * * Neither the name of the University of California, Berkeley nor the
46 * names of its contributors may be used to endorse or promote products
47 * derived from this software without specific prior written permission.
49 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
50 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
51 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
52 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
53 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
54 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
55 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
56 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
57 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
58 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
69 #include "cmdline_cirbuf.h"
70 #include "cmdline_rdline.h"
72 static void rdline_puts(struct rdline *rdl, const char *buf);
73 static void rdline_miniprintf(struct rdline *rdl,
74 const char *buf, unsigned int val);
76 static void rdline_remove_old_history_item(struct rdline *rdl);
77 static void rdline_remove_first_history_item(struct rdline *rdl);
78 static unsigned int rdline_get_history_size(struct rdline *rdl);
81 /* isblank() needs _XOPEN_SOURCE >= 600 || _ISOC99_SOURCE, so use our
93 rdline_init(struct rdline *rdl,
94 rdline_write_char_t *write_char,
95 rdline_validate_t *validate,
96 rdline_complete_t *complete)
98 if (!rdl || !write_char || !validate || !complete)
100 memset(rdl, 0, sizeof(*rdl));
101 rdl->validate = validate;
102 rdl->complete = complete;
103 rdl->write_char = write_char;
104 rdl->status = RDLINE_INIT;
105 return cirbuf_init(&rdl->history, rdl->history_buf, 0, RDLINE_HISTORY_BUF_SIZE);
109 rdline_newline(struct rdline *rdl, const char *prompt)
116 vt100_init(&rdl->vt100);
117 cirbuf_init(&rdl->left, rdl->left_buf, 0, RDLINE_BUF_SIZE);
118 cirbuf_init(&rdl->right, rdl->right_buf, 0, RDLINE_BUF_SIZE);
120 rdl->prompt_size = strnlen(prompt, RDLINE_PROMPT_SIZE-1);
121 if (prompt != rdl->prompt)
122 memcpy(rdl->prompt, prompt, rdl->prompt_size);
123 rdl->prompt[RDLINE_PROMPT_SIZE-1] = '\0';
125 for (i=0 ; i<rdl->prompt_size ; i++)
126 rdl->write_char(rdl, rdl->prompt[i]);
127 rdl->status = RDLINE_RUNNING;
129 rdl->history_cur_line = -1;
133 rdline_stop(struct rdline *rdl)
137 rdl->status = RDLINE_INIT;
141 rdline_quit(struct rdline *rdl)
145 rdl->status = RDLINE_EXITED;
149 rdline_restart(struct rdline *rdl)
153 rdl->status = RDLINE_RUNNING;
157 rdline_reset(struct rdline *rdl)
161 vt100_init(&rdl->vt100);
162 cirbuf_init(&rdl->left, rdl->left_buf, 0, RDLINE_BUF_SIZE);
163 cirbuf_init(&rdl->right, rdl->right_buf, 0, RDLINE_BUF_SIZE);
165 rdl->status = RDLINE_RUNNING;
167 rdl->history_cur_line = -1;
171 rdline_get_buffer(struct rdline *rdl)
175 unsigned int len_l, len_r;
176 cirbuf_align_left(&rdl->left);
177 cirbuf_align_left(&rdl->right);
179 len_l = CIRBUF_GET_LEN(&rdl->left);
180 len_r = CIRBUF_GET_LEN(&rdl->right);
181 memcpy(rdl->left_buf+len_l, rdl->right_buf, len_r);
183 rdl->left_buf[len_l + len_r] = '\n';
184 rdl->left_buf[len_l + len_r + 1] = '\0';
185 return rdl->left_buf;
189 display_right_buffer(struct rdline *rdl, int force)
194 if (!force && CIRBUF_IS_EMPTY(&rdl->right))
197 rdline_puts(rdl, vt100_clear_right);
198 CIRBUF_FOREACH(&rdl->right, i, tmp) {
199 rdl->write_char(rdl, tmp);
201 if (!CIRBUF_IS_EMPTY(&rdl->right))
202 rdline_miniprintf(rdl, vt100_multi_left,
203 CIRBUF_GET_LEN(&rdl->right));
207 rdline_redisplay(struct rdline *rdl)
215 rdline_puts(rdl, vt100_home);
216 for (i=0 ; i<rdl->prompt_size ; i++)
217 rdl->write_char(rdl, rdl->prompt[i]);
218 CIRBUF_FOREACH(&rdl->left, i, tmp) {
219 rdl->write_char(rdl, tmp);
221 display_right_buffer(rdl, 1);
225 rdline_char_in(struct rdline *rdl, char c)
235 if (rdl->status == RDLINE_EXITED)
236 return RDLINE_RES_EXITED;
237 if (rdl->status != RDLINE_RUNNING)
238 return RDLINE_RES_NOT_RUNNING;
240 cmd = vt100_parser(&rdl->vt100, c);
242 return RDLINE_RES_SUCCESS;
246 /* move caret 1 char to the left */
247 case CMDLINE_KEY_CTRL_B:
248 case CMDLINE_KEY_LEFT_ARR:
249 if (CIRBUF_IS_EMPTY(&rdl->left))
251 tmp = cirbuf_get_tail(&rdl->left);
252 cirbuf_del_tail(&rdl->left);
253 cirbuf_add_head(&rdl->right, tmp);
254 rdline_puts(rdl, vt100_left_arr);
257 /* move caret 1 char to the right */
258 case CMDLINE_KEY_CTRL_F:
259 case CMDLINE_KEY_RIGHT_ARR:
260 if (CIRBUF_IS_EMPTY(&rdl->right))
262 tmp = cirbuf_get_head(&rdl->right);
263 cirbuf_del_head(&rdl->right);
264 cirbuf_add_tail(&rdl->left, tmp);
265 rdline_puts(rdl, vt100_right_arr);
268 /* move caret 1 word to the left */
269 /* keyboard equivalent: Alt+B */
270 case CMDLINE_KEY_WLEFT:
271 while (! CIRBUF_IS_EMPTY(&rdl->left) &&
272 (tmp = cirbuf_get_tail(&rdl->left)) &&
274 rdline_puts(rdl, vt100_left_arr);
275 cirbuf_del_tail(&rdl->left);
276 cirbuf_add_head(&rdl->right, tmp);
278 while (! CIRBUF_IS_EMPTY(&rdl->left) &&
279 (tmp = cirbuf_get_tail(&rdl->left)) &&
281 rdline_puts(rdl, vt100_left_arr);
282 cirbuf_del_tail(&rdl->left);
283 cirbuf_add_head(&rdl->right, tmp);
287 /* move caret 1 word to the right */
288 /* keyboard equivalent: Alt+F */
289 case CMDLINE_KEY_WRIGHT:
290 while (! CIRBUF_IS_EMPTY(&rdl->right) &&
291 (tmp = cirbuf_get_head(&rdl->right)) &&
293 rdline_puts(rdl, vt100_right_arr);
294 cirbuf_del_head(&rdl->right);
295 cirbuf_add_tail(&rdl->left, tmp);
297 while (! CIRBUF_IS_EMPTY(&rdl->right) &&
298 (tmp = cirbuf_get_head(&rdl->right)) &&
300 rdline_puts(rdl, vt100_right_arr);
301 cirbuf_del_head(&rdl->right);
302 cirbuf_add_tail(&rdl->left, tmp);
306 /* move caret to the left */
307 case CMDLINE_KEY_CTRL_A:
308 if (CIRBUF_IS_EMPTY(&rdl->left))
310 rdline_miniprintf(rdl, vt100_multi_left,
311 CIRBUF_GET_LEN(&rdl->left));
312 while (! CIRBUF_IS_EMPTY(&rdl->left)) {
313 tmp = cirbuf_get_tail(&rdl->left);
314 cirbuf_del_tail(&rdl->left);
315 cirbuf_add_head(&rdl->right, tmp);
319 /* move caret to the right */
320 case CMDLINE_KEY_CTRL_E:
321 if (CIRBUF_IS_EMPTY(&rdl->right))
323 rdline_miniprintf(rdl, vt100_multi_right,
324 CIRBUF_GET_LEN(&rdl->right));
325 while (! CIRBUF_IS_EMPTY(&rdl->right)) {
326 tmp = cirbuf_get_head(&rdl->right);
327 cirbuf_del_head(&rdl->right);
328 cirbuf_add_tail(&rdl->left, tmp);
332 /* delete 1 char from the left */
333 case CMDLINE_KEY_BKSPACE:
334 case CMDLINE_KEY_BKSPACE2:
335 if(!cirbuf_del_tail_safe(&rdl->left)) {
336 rdline_puts(rdl, vt100_bs);
337 display_right_buffer(rdl, 1);
341 /* delete 1 char from the right */
342 case CMDLINE_KEY_SUPPR:
343 case CMDLINE_KEY_CTRL_D:
344 if (cmd == CMDLINE_KEY_CTRL_D &&
345 CIRBUF_IS_EMPTY(&rdl->left) &&
346 CIRBUF_IS_EMPTY(&rdl->right)) {
347 return RDLINE_RES_EOF;
349 if (!cirbuf_del_head_safe(&rdl->right)) {
350 display_right_buffer(rdl, 1);
354 /* delete 1 word from the left */
355 case CMDLINE_KEY_META_BKSPACE:
356 case CMDLINE_KEY_CTRL_W:
357 while (! CIRBUF_IS_EMPTY(&rdl->left) && isblank2(cirbuf_get_tail(&rdl->left))) {
358 rdline_puts(rdl, vt100_bs);
359 cirbuf_del_tail(&rdl->left);
361 while (! CIRBUF_IS_EMPTY(&rdl->left) && !isblank2(cirbuf_get_tail(&rdl->left))) {
362 rdline_puts(rdl, vt100_bs);
363 cirbuf_del_tail(&rdl->left);
365 display_right_buffer(rdl, 1);
368 /* delete 1 word from the right */
369 case CMDLINE_KEY_META_D:
370 while (! CIRBUF_IS_EMPTY(&rdl->right) && isblank2(cirbuf_get_head(&rdl->right)))
371 cirbuf_del_head(&rdl->right);
372 while (! CIRBUF_IS_EMPTY(&rdl->right) && !isblank2(cirbuf_get_head(&rdl->right)))
373 cirbuf_del_head(&rdl->right);
374 display_right_buffer(rdl, 1);
377 /* set kill buffer to contents on the right side of caret */
378 case CMDLINE_KEY_CTRL_K:
379 cirbuf_get_buf_head(&rdl->right, rdl->kill_buf, RDLINE_BUF_SIZE);
380 rdl->kill_size = CIRBUF_GET_LEN(&rdl->right);
381 cirbuf_del_buf_head(&rdl->right, rdl->kill_size);
382 rdline_puts(rdl, vt100_clear_right);
385 /* paste contents of kill buffer to the left side of caret */
386 case CMDLINE_KEY_CTRL_Y:
388 while(CIRBUF_GET_LEN(&rdl->right) + CIRBUF_GET_LEN(&rdl->left) <
390 i < rdl->kill_size) {
391 cirbuf_add_tail(&rdl->left, rdl->kill_buf[i]);
392 rdl->write_char(rdl, rdl->kill_buf[i]);
395 display_right_buffer(rdl, 0);
398 /* clear and newline */
399 case CMDLINE_KEY_CTRL_C:
400 rdline_puts(rdl, "\r\n");
401 rdline_newline(rdl, rdl->prompt);
404 /* redisplay (helps when prompt is lost in other output) */
405 case CMDLINE_KEY_CTRL_L:
406 rdline_redisplay(rdl);
410 case CMDLINE_KEY_TAB:
411 case CMDLINE_KEY_HELP:
412 cirbuf_align_left(&rdl->left);
413 rdl->left_buf[CIRBUF_GET_LEN(&rdl->left)] = '\0';
415 char tmp_buf[BUFSIZ];
418 unsigned int tmp_size;
420 if (cmd == CMDLINE_KEY_TAB)
425 /* see in parse.h for help on complete() */
426 ret = rdl->complete(rdl, rdl->left_buf,
427 tmp_buf, sizeof(tmp_buf),
429 /* no completion or error */
431 return RDLINE_RES_COMPLETE;
434 tmp_size = strnlen(tmp_buf, sizeof(tmp_buf));
436 if (ret == RDLINE_RES_COMPLETE) {
438 while(CIRBUF_GET_LEN(&rdl->right) + CIRBUF_GET_LEN(&rdl->left) <
441 cirbuf_add_tail(&rdl->left, tmp_buf[i]);
442 rdl->write_char(rdl, tmp_buf[i]);
445 display_right_buffer(rdl, 1);
446 return RDLINE_RES_COMPLETE; /* ?? */
450 rdline_puts(rdl, "\r\n");
452 rdl->write_char(rdl, ' ');
453 for (i=0 ; tmp_buf[i] ; i++)
454 rdl->write_char(rdl, tmp_buf[i]);
455 rdline_puts(rdl, "\r\n");
456 ret = rdl->complete(rdl, rdl->left_buf,
457 tmp_buf, sizeof(tmp_buf),
461 rdline_redisplay(rdl);
463 return RDLINE_RES_COMPLETE;
465 /* complete buffer */
466 case CMDLINE_KEY_RETURN:
467 case CMDLINE_KEY_RETURN2:
468 rdline_get_buffer(rdl);
469 rdl->status = RDLINE_INIT;
470 rdline_puts(rdl, "\r\n");
471 if (rdl->history_cur_line != -1)
472 rdline_remove_first_history_item(rdl);
475 rdl->validate(rdl, rdl->left_buf, CIRBUF_GET_LEN(&rdl->left)+2);
476 /* user may have stopped rdline */
477 if (rdl->status == RDLINE_EXITED)
478 return RDLINE_RES_EXITED;
479 return RDLINE_RES_VALIDATED;
481 /* previous element in history */
482 case CMDLINE_KEY_UP_ARR:
483 case CMDLINE_KEY_CTRL_P:
484 if (rdl->history_cur_line == 0) {
485 rdline_remove_first_history_item(rdl);
487 if (rdl->history_cur_line <= 0) {
488 rdline_add_history(rdl, rdline_get_buffer(rdl));
489 rdl->history_cur_line = 0;
492 buf = rdline_get_history_item(rdl, rdl->history_cur_line + 1);
496 rdl->history_cur_line ++;
497 vt100_init(&rdl->vt100);
498 cirbuf_init(&rdl->left, rdl->left_buf, 0, RDLINE_BUF_SIZE);
499 cirbuf_init(&rdl->right, rdl->right_buf, 0, RDLINE_BUF_SIZE);
500 cirbuf_add_buf_tail(&rdl->left, buf, strnlen(buf, RDLINE_BUF_SIZE));
501 rdline_redisplay(rdl);
504 /* next element in history */
505 case CMDLINE_KEY_DOWN_ARR:
506 case CMDLINE_KEY_CTRL_N:
507 if (rdl->history_cur_line - 1 < 0)
510 rdl->history_cur_line --;
511 buf = rdline_get_history_item(rdl, rdl->history_cur_line);
514 vt100_init(&rdl->vt100);
515 cirbuf_init(&rdl->left, rdl->left_buf, 0, RDLINE_BUF_SIZE);
516 cirbuf_init(&rdl->right, rdl->right_buf, 0, RDLINE_BUF_SIZE);
517 cirbuf_add_buf_tail(&rdl->left, buf, strnlen(buf, RDLINE_BUF_SIZE));
518 rdline_redisplay(rdl);
527 return RDLINE_RES_SUCCESS;
530 if (!isprint((int)c))
531 return RDLINE_RES_SUCCESS;
534 if (CIRBUF_GET_LEN(&rdl->left) + CIRBUF_GET_LEN(&rdl->right) >= RDLINE_BUF_SIZE)
535 return RDLINE_RES_SUCCESS;
537 if (cirbuf_add_tail_safe(&rdl->left, c))
538 return RDLINE_RES_SUCCESS;
540 rdl->write_char(rdl, c);
541 display_right_buffer(rdl, 0);
543 return RDLINE_RES_SUCCESS;
550 rdline_remove_old_history_item(struct rdline * rdl)
554 while (! CIRBUF_IS_EMPTY(&rdl->history) ) {
555 tmp = cirbuf_get_head(&rdl->history);
556 cirbuf_del_head(&rdl->history);
563 rdline_remove_first_history_item(struct rdline * rdl)
567 if ( CIRBUF_IS_EMPTY(&rdl->history) ) {
571 cirbuf_del_tail(&rdl->history);
574 while (! CIRBUF_IS_EMPTY(&rdl->history) ) {
575 tmp = cirbuf_get_tail(&rdl->history);
578 cirbuf_del_tail(&rdl->history);
583 rdline_get_history_size(struct rdline * rdl)
585 unsigned int i, tmp, ret=0;
587 CIRBUF_FOREACH(&rdl->history, i, tmp) {
596 rdline_get_history_item(struct rdline * rdl, unsigned int idx)
598 unsigned int len, i, tmp;
603 len = rdline_get_history_size(rdl);
608 cirbuf_align_left(&rdl->history);
610 CIRBUF_FOREACH(&rdl->history, i, tmp) {
611 if ( idx == len - 1) {
612 return rdl->history_buf + i;
622 rdline_add_history(struct rdline * rdl, const char * buf)
629 len = strnlen(buf, RDLINE_BUF_SIZE);
630 for (i=0; i<len ; i++) {
631 if (buf[i] == '\n') {
637 if ( len >= RDLINE_HISTORY_BUF_SIZE )
640 while ( len >= CIRBUF_GET_FREELEN(&rdl->history) ) {
641 rdline_remove_old_history_item(rdl);
644 cirbuf_add_buf_tail(&rdl->history, buf, len);
645 cirbuf_add_tail(&rdl->history, 0);
651 rdline_clear_history(struct rdline * rdl)
655 cirbuf_init(&rdl->history, rdl->history_buf, 0, RDLINE_HISTORY_BUF_SIZE);
659 /* STATIC USEFUL FUNCS */
662 rdline_puts(struct rdline * rdl, const char * buf)
665 while ( (c = *(buf++)) != '\0' ) {
666 rdl->write_char(rdl, c);
670 /* a very very basic printf with one arg and one format 'u' */
672 rdline_miniprintf(struct rdline *rdl, const char * buf, unsigned int val)
674 char c, started=0, div=100;
676 while ( (c=*(buf++)) ) {
678 rdl->write_char(rdl, c);
683 rdl->write_char(rdl, '%');
684 rdl->write_char(rdl, c);
687 /* val is never more than 255 */
689 c = (char)(val / div);
691 rdl->write_char(rdl, (char)(c+'0'));