cmdline (merge-intel): support ctrl-w in librte_cmdline

[libcmdline.git] / src / lib / cmdline_rdline.c

diff --git a/src/lib/cmdline_rdline.c b/src/lib/cmdline_rdline.c
index 86d3a9c..91217be 100644 (file)
--- a/src/lib/cmdline_rdline.c
+++ b/src/lib/cmdline_rdline.c
@@ -91,7 +91,8 @@ isblank2(char c)
        return 0;
 }
 
-void rdline_init(struct rdline *rdl,
+void
+rdline_init(struct rdline *rdl,
                 rdline_write_char_t *write_char,
                 rdline_validate_t *validate,
                 rdline_complete_t *complete)
@@ -134,6 +135,12 @@ rdline_stop(struct rdline *rdl)
        rdl->status = RDLINE_INIT;
 }
 
+void
+rdline_quit(struct rdline *rdl)
+{
+       rdl->status = RDLINE_EXITED;
+}
+
 void
 rdline_restart(struct rdline *rdl)
 {
@@ -157,22 +164,25 @@ rdline_get_buffer(struct rdline *rdl)
 }
 
 static void
-display_right_buffer(struct rdline *rdl)
+display_right_buffer(struct rdline *rdl, int force)
 {
        unsigned int i;
        char tmp;
 
+       if (!force && CIRBUF_IS_EMPTY(&rdl->right))
+               return;
+
        rdline_puts(rdl, vt100_clear_right);
-       if (!CIRBUF_IS_EMPTY(&rdl->right)) {
-               CIRBUF_FOREACH(&rdl->right, i, tmp) {
-                       rdl->write_char(rdl, tmp);
-               }
+       CIRBUF_FOREACH(&rdl->right, i, tmp) {
+               rdl->write_char(rdl, tmp);
+       }
+       if (!CIRBUF_IS_EMPTY(&rdl->right))
                rdline_miniprintf(rdl, vt100_multi_left,
                                  CIRBUF_GET_LEN(&rdl->right));
-       }
 }
 
-void rdline_redisplay(struct rdline *rdl)
+void
+rdline_redisplay(struct rdline *rdl)
 {
        unsigned int i;
        char tmp;
@@ -183,7 +193,7 @@ void rdline_redisplay(struct rdline *rdl)
        CIRBUF_FOREACH(&rdl->left, i, tmp) {
                rdl->write_char(rdl, tmp);
        }
-       display_right_buffer(rdl);
+       display_right_buffer(rdl, 1);
 }
 
 int
@@ -196,12 +206,14 @@ rdline_char_in(struct rdline *rdl, char c)
        char *buf;
 #endif
 
+       if (rdl->status == RDLINE_EXITED)
+               return RDLINE_RES_EXITED;
        if (rdl->status != RDLINE_RUNNING)
-               return -1;
+               return RDLINE_RES_NOT_RUNNING;
 
        cmd = vt100_parser(&rdl->vt100, c);
        if (cmd == -2)
-               return 0;
+               return RDLINE_RES_SUCCESS;
 
        if (cmd >= 0) {
                switch (cmd) {
@@ -262,11 +274,12 @@ rdline_char_in(struct rdline *rdl, char c)
                case CMDLINE_KEY_BKSPACE:
                        if(!cirbuf_del_tail_safe(&rdl->left)) {
                                rdline_puts(rdl, vt100_bs);
-                               display_right_buffer(rdl);
+                               display_right_buffer(rdl, 1);
                        }
                        break;
 
                case CMDLINE_KEY_META_BKSPACE:
+               case CMDLINE_KEY_CTRL_W:
                        while (! CIRBUF_IS_EMPTY(&rdl->left) && isblank2(cirbuf_get_tail(&rdl->left))) {
                                rdline_puts(rdl, vt100_bs);
                                cirbuf_del_tail(&rdl->left);
@@ -275,7 +288,7 @@ rdline_char_in(struct rdline *rdl, char c)
                                rdline_puts(rdl, vt100_bs);
                                cirbuf_del_tail(&rdl->left);
                        }
-                       display_right_buffer(rdl);
+                       display_right_buffer(rdl, 1);
                        break;
 
                case CMDLINE_KEY_SUPPR:
@@ -283,10 +296,10 @@ rdline_char_in(struct rdline *rdl, char c)
                        if (cmd == CMDLINE_KEY_CTRL_D &&
                            CIRBUF_IS_EMPTY(&rdl->left) &&
                            CIRBUF_IS_EMPTY(&rdl->right)) {
-                               return -2;
+                               return RDLINE_RES_EOF;
                        }
                        if (!cirbuf_del_head_safe(&rdl->right)) {
-                               display_right_buffer(rdl);
+                               display_right_buffer(rdl, 1);
                        }
                        break;
 
@@ -331,7 +344,7 @@ rdline_char_in(struct rdline *rdl, char c)
                                rdl->write_char(rdl, rdl->kill_buf[i]);
                                i++;
                        }
-                       display_right_buffer(rdl);
+                       display_right_buffer(rdl, 0);
                        break;
 #endif /* !NO_RDLINE_KILL_BUF */
 
@@ -365,12 +378,12 @@ rdline_char_in(struct rdline *rdl, char c)
                                                    &complete_state);
                                /* no completion or error */
                                if (ret <= 0) {
-                                       return 2;
+                                       return RDLINE_RES_COMPLETE;
                                }
 
                                tmp_size = strlen(tmp_buf);
                                /* add chars */
-                               if (ret == 2) {
+                               if (ret == RDLINE_RES_COMPLETE) {
                                        i=0;
                                        while(CIRBUF_GET_LEN(&rdl->right) + CIRBUF_GET_LEN(&rdl->left) <
                                              RDLINE_BUF_SIZE &&
@@ -379,8 +392,8 @@ rdline_char_in(struct rdline *rdl, char c)
                                                rdl->write_char(rdl, tmp_buf[i]);
                                                i++;
                                        }
-                                       display_right_buffer(rdl);
-                                       return 2; /* ?? */
+                                       display_right_buffer(rdl, 1);
+                                       return RDLINE_RES_COMPLETE; /* ?? */
                                }
 
                                /* choice */
@@ -397,7 +410,7 @@ rdline_char_in(struct rdline *rdl, char c)
 
                                rdline_redisplay(rdl);
                        }
-                       return 2;
+                       return RDLINE_RES_COMPLETE;
 
                case CMDLINE_KEY_RETURN:
                case CMDLINE_KEY_RETURN2:
@@ -411,7 +424,10 @@ rdline_char_in(struct rdline *rdl, char c)
 
                        if (rdl->validate)
                                rdl->validate(rdl, rdl->left_buf, CIRBUF_GET_LEN(&rdl->left)+2);
-                       return 1;
+                       /* user may have stopped rdline */
+                       if (rdl->status == RDLINE_EXITED)
+                               return RDLINE_RES_EXITED;
+                       return RDLINE_RES_VALIDATED;
 
 #ifndef NO_RDLINE_HISTORY
                case CMDLINE_KEY_UP_ARR:
@@ -457,23 +473,23 @@ rdline_char_in(struct rdline *rdl, char c)
                        break;
                }
 
-               return 0;
+               return RDLINE_RES_SUCCESS;
        }
 
        if (!isprint((int)c))
-               return 0;
+               return RDLINE_RES_SUCCESS;
 
        /* standard chars */
        if (CIRBUF_GET_LEN(&rdl->left) + CIRBUF_GET_LEN(&rdl->right) >= RDLINE_BUF_SIZE)
-               return 0;
+               return RDLINE_RES_SUCCESS;
 
        if (cirbuf_add_tail_safe(&rdl->left, c))
-               return 0;
+               return RDLINE_RES_SUCCESS;
 
        rdl->write_char(rdl, c);
-       display_right_buffer(rdl);
+       display_right_buffer(rdl, 0);
 
-       return 0;
+       return RDLINE_RES_SUCCESS;
 }
 
 
@@ -621,9 +637,9 @@ rdline_miniprintf(struct rdline *rdl, const char * buf, unsigned int val)
                }
                /* val is never more than 255 */
                while (div) {
-                       c = val / div;
+                       c = (char)(val / div);
                        if (c || started) {
-                               rdl->write_char(rdl, c+'0');
+                               rdl->write_char(rdl, (char)(c+'0'));
                                started = 1;
                        }
                        val %= div;