+/*-
+ * Copyright (c) <2010>, Intel Corporation
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * - Neither the name of Intel Corporation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
/*
* Copyright (c) 2009, Olivier MATZ <zer0@droids-corp.org>
* All rights reserved.
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)
rdl->status = RDLINE_INIT;
}
+void
+rdline_quit(struct rdline *rdl)
+{
+ rdl->status = RDLINE_EXITED;
+}
+
void
rdline_restart(struct rdline *rdl)
{
}
}
-void rdline_redisplay(struct rdline *rdl)
+void
+rdline_redisplay(struct rdline *rdl)
{
unsigned int i;
char tmp;
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) {
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);
char tmp_buf[BUFSIZ];
int complete_state;
int ret;
- int tmp_size;
+ unsigned int tmp_size;
if (cmd == CMDLINE_KEY_TAB)
complete_state = 0;
&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 &&
i++;
}
display_right_buffer(rdl);
- return 2; /* ?? */
+ return RDLINE_RES_COMPLETE; /* ?? */
}
/* choice */
rdline_redisplay(rdl);
}
- return 2;
+ return RDLINE_RES_COMPLETE;
case CMDLINE_KEY_RETURN:
case CMDLINE_KEY_RETURN2:
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:
break;
}
- return 0;
+ return RDLINE_RES_SUCCESS;
}
- if (! isprint(c))
- return 0;
+ if (!isprint((int)c))
+ 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);
- return 0;
+ return RDLINE_RES_SUCCESS;
}
}
/* 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;