Index: uspace/app/bdsh/Makefile =================================================================== --- uspace/app/bdsh/Makefile (revision 026793d93499d089b36163093b5ef05e10ac1f12) +++ uspace/app/bdsh/Makefile (revision 9be9c4dfa6546c6f2da92b12273ac723bee9af42) @@ -54,4 +54,5 @@ cmds/mod_cmds.c \ cmds/builtin_cmds.c \ + compl.c \ errors.c \ input.c \ Index: uspace/app/bdsh/compl.c =================================================================== --- uspace/app/bdsh/compl.c (revision 9be9c4dfa6546c6f2da92b12273ac723bee9af42) +++ uspace/app/bdsh/compl.c (revision 9be9c4dfa6546c6f2da92b12273ac723bee9af42) @@ -0,0 +1,331 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +#include +#include +#include +#include +#include +#include + +#include "cmds/cmds.h" +#include "compl.h" +#include "exec.h" + +static int compl_init(wchar_t *text, size_t pos, size_t *cstart, void **state); +static int compl_get_next(void *state, char **compl); +static void compl_fini(void *state); + +/** Bdsh implementation of completion ops. */ +tinput_compl_ops_t compl_ops = { + .init = compl_init, + .get_next = compl_get_next, + .fini = compl_fini +}; + +/** Completion state object. + * + * The state object contains 'iterators' for modules, builtins and + * executables in directories. + */ +typedef struct { + /** String prefix which we are trying to complete. */ + char *prefix; + /** Length of string prefix (number of characters) */ + size_t prefix_len; + + /** Pointer inside list of modules */ + module_t *module; + /** Pointer inside list of builtins */ + builtin_t *builtin; + + /** Pointer inside list of directories */ + const char **path; + /** Current open directory */ + DIR *dir; + + char *last_compl; + + /** + * @c true if we are completing a command, @c false if we are + * completing an argument + */ + bool is_command; +} compl_t; + +/** Init completion. + * + * Set up iterators in completion object, based on current token. + */ +static int compl_init(wchar_t *text, size_t pos, size_t *cstart, void **state) +{ + compl_t *cs = NULL; + size_t p; + size_t pref_size; + char *stext = NULL; + char *prefix = NULL; + char *dirname = NULL; + char *rpath_sep; + static const char *dirlist_arg[] = { ".", NULL }; + int retval; + + cs = calloc(1, sizeof(compl_t)); + if (!cs) { + retval = ENOMEM; + goto error; + } + + /* + * Copy token pointed to by caret from start up to the caret. + * XXX Ideally we would use the standard tokenizer. + */ + p = pos; + while (p > 0 && text[p - 1] != (wchar_t) ' ') + --p; + *cstart = p; + + /* Convert text buffer to string */ + stext = wstr_to_astr(text + *cstart); + if (stext == NULL) { + retval = ENOMEM; + goto error; + } + + /* Extract the prefix being completed */ + pref_size = str_lsize(stext, pos - *cstart); + prefix = malloc(pref_size + 1); + if (prefix == NULL) { + retval = ENOMEM; + goto error; + } + + str_ncpy(prefix, pref_size + 1, stext, pref_size); + + /* + * Determine if the token being completed is a command or argument. + * We look at the previous token. If there is none or it is a pipe + * ('|'), it is a command, otherwise it is an argument. + * XXX Again we should use the standard tokenizer/parser. + */ + + /* Skip any whitespace before current token */ + while (p > 0 && text[p - 1] == (wchar_t) ' ') + --p; + + /* + * It is a command if it is the first token or if it immediately + * follows a pipe token. + */ + if (p == 0 || text[p - 1] == '|') + cs->is_command = true; + else + cs->is_command = false; + + rpath_sep = str_rchr(prefix, '/'); + if (rpath_sep != NULL) { + /* Extract path. For path beginning with '/' keep the '/'. */ + dirname = str_ndup(prefix, max(1, rpath_sep - prefix)); + if (dirname == NULL) { + retval = ENOMEM; + goto error; + } + + /* Extract name prefix */ + cs->prefix = str_dup(rpath_sep + 1); + if (cs->prefix == NULL) { + retval = ENOMEM; + goto error; + } + *cstart += rpath_sep + 1 - prefix; +// printf("cstart=%zu\n", *cstart); + free(prefix); + +// printf("\ncs->prefix='%s', dirname='%s'\n", cs->prefix, dirname); + + static const char *dlist2[2]; + dlist2[0] = dirname; + dlist2[1] = NULL; + cs->path = dlist2; + /* XXX dirname won't be freed */ + } else if (cs->is_command) { + /* Command without path */ + cs->module = modules; + cs->builtin = builtins; + cs->prefix = prefix; + cs->path = &search_dir[0]; + } else { + /* Argument without path */ + cs->prefix = prefix; + cs->path = &dirlist_arg[0]; + } + + cs->prefix_len = str_length(cs->prefix); + + *state = cs; + return EOK; + +error: + /* Error cleanup */ + + if (cs != NULL && cs->prefix != NULL) + free(cs->prefix); + if (dirname != NULL) + free(dirname); + if (prefix != NULL) + free(prefix); + if (stext != NULL) + free(stext); + if (cs != NULL) + free(cs); + + return retval; +} + +/** Determine if completion matches the required prefix. + * + * Required prefix is stored in @a cs->prefix. + * + * @param cs Completion state object + * @param compl Completion string + * @return @c true when @a compl matches, @c false otherwise + */ +static bool compl_match_prefix(compl_t *cs, const char *compl) +{ + return str_lcmp(compl, cs->prefix, cs->prefix_len) == 0; +} + +/** Get next match. */ +static int compl_get_next(void *state, char **compl) +{ + compl_t *cs = (compl_t *) state; + struct dirent *dent; + + *compl = NULL; + + if (cs->last_compl != NULL) { + free(cs->last_compl); + cs->last_compl = NULL; + } + + /* Modules */ + if (cs->module != NULL) { + while (*compl == NULL && cs->module->name != NULL) { + if (compl_match_prefix(cs, cs->module->name)) { + asprintf(compl, "%s ", cs->module->name); + cs->last_compl = *compl; + if (*compl == NULL) + return ENOMEM; + } + cs->module++; + } + } + + /* Builtins */ + if (cs->builtin != NULL) { + while (*compl == NULL && cs->builtin->name != NULL) { + if (compl_match_prefix(cs, cs->builtin->name)) { + asprintf(compl, "%s ", cs->builtin->name); + cs->last_compl = *compl; + if (*compl == NULL) + return ENOMEM; + } + cs->builtin++; + } + } + + /* Files and directories. We scan entries from a set of directories. */ + if (cs->path != NULL) { + while (*compl == NULL) { + /* Open next directory */ + while (cs->dir == NULL) { + if (*cs->path == NULL) + break; + + cs->dir = opendir(*cs->path); + } + + /* If it was the last one, we are done */ + if (cs->dir == NULL) { + cs->path = NULL; + break; + } + + /* Read next directory entry */ + dent = readdir(cs->dir); + if (dent == NULL) { + /* Error. Close directory, go to next one */ + closedir(cs->dir); + cs->dir = NULL; + cs->path++; + continue; + } + + if (compl_match_prefix(cs, dent->d_name)) { + /* Construct pathname */ + char *ent_path; + asprintf(&ent_path, "%s/%s", *cs->path, dent->d_name); + struct stat ent_stat; + if (stat(ent_path, &ent_stat) != EOK) { + /* Error */ + free(ent_path); + continue; + } + + free(ent_path); + + /* If completing command, do not match directories. */ + if (!ent_stat.is_directory || !cs->is_command) { + asprintf(compl, "%s%c", dent->d_name, + ent_stat.is_directory ? '/' : ' '); + cs->last_compl = *compl; + if (*compl == NULL) + return ENOMEM; + } + } + } + } + + if (*compl == NULL) + return ENOENT; + + return EOK; +} + +/** Finish completion operation. */ +static void compl_fini(void *state) +{ + compl_t *cs = (compl_t *) state; + + if (cs->last_compl != NULL) + free(cs->last_compl); + if (cs->dir != NULL) + closedir(cs->dir); + + free(cs->prefix); + free(cs); +} Index: uspace/app/bdsh/compl.h =================================================================== --- uspace/app/bdsh/compl.h (revision 9be9c4dfa6546c6f2da92b12273ac723bee9af42) +++ uspace/app/bdsh/compl.h (revision 9be9c4dfa6546c6f2da92b12273ac723bee9af42) @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2008 Tim Post + * 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +#ifndef COMPL_H +#define COMPL_H + +#include + +extern tinput_compl_ops_t compl_ops; + +#endif Index: uspace/app/bdsh/config.h =================================================================== --- uspace/app/bdsh/config.h (revision 026793d93499d089b36163093b5ef05e10ac1f12) +++ uspace/app/bdsh/config.h (revision 9be9c4dfa6546c6f2da92b12273ac723bee9af42) @@ -40,8 +40,4 @@ #endif -/* Work around for getenv() */ -#define PATH "/srv:/app" -#define PATH_DELIM ":" - /* Used in many places */ #define SMALL_BUFLEN 256 Index: uspace/app/bdsh/exec.c =================================================================== --- uspace/app/bdsh/exec.c (revision 026793d93499d089b36163093b5ef05e10ac1f12) +++ uspace/app/bdsh/exec.c (revision 9be9c4dfa6546c6f2da92b12273ac723bee9af42) @@ -52,4 +52,6 @@ static int try_access(const char *); +const char *search_dir[] = { "app", "srv", NULL }; + /* work-around for access() */ static int try_access(const char *f) @@ -69,8 +71,5 @@ static char *find_command(char *cmd) { - char *path_tok; - char *path[PATH_MAX]; - int n = 0, i = 0; - size_t x = str_size(cmd) + 2; + size_t i; found = (char *)malloc(PATH_MAX); @@ -81,24 +80,9 @@ } - path_tok = str_dup(PATH); - - /* Extract the PATH env to a path[] array */ - path[n] = strtok(path_tok, PATH_DELIM); - while (NULL != path[n]) { - if ((str_size(path[n]) + x ) > PATH_MAX) { - cli_error(CL_ENOTSUP, - "Segment %d of path is too large, search ends at segment %d", - n, n-1); - break; - } - path[++n] = strtok(NULL, PATH_DELIM); - } - /* We now have n places to look for the command */ - for (i=0; path[i]; i++) { + for (i = 0; search_dir[i] != NULL; i++) { memset(found, 0, sizeof(found)); - snprintf(found, PATH_MAX, "%s/%s", path[i], cmd); + snprintf(found, PATH_MAX, "%s/%s", search_dir[i], cmd); if (-1 != try_access(found)) { - free(path_tok); return (char *) found; } @@ -106,5 +90,4 @@ /* We didn't find it, just give it back as-is. */ - free(path_tok); return (char *) cmd; } Index: uspace/app/bdsh/exec.h =================================================================== --- uspace/app/bdsh/exec.h (revision 026793d93499d089b36163093b5ef05e10ac1f12) +++ uspace/app/bdsh/exec.h (revision 9be9c4dfa6546c6f2da92b12273ac723bee9af42) @@ -33,4 +33,6 @@ #include "scli.h" +extern const char *search_dir[]; + extern unsigned int try_exec(char *, char **, iostate_t *); Index: uspace/app/bdsh/input.c =================================================================== --- uspace/app/bdsh/input.c (revision 026793d93499d089b36163093b5ef05e10ac1f12) +++ uspace/app/bdsh/input.c (revision 9be9c4dfa6546c6f2da92b12273ac723bee9af42) @@ -1,4 +1,5 @@ /* * Copyright (c) 2008 Tim Post + * Copyright (c) 2011 Jiri Svoboda * All rights reserved. * @@ -43,4 +44,5 @@ #include "config.h" +#include "compl.h" #include "util.h" #include "scli.h" @@ -226,9 +228,5 @@ int rc; - console_flush(tinput->console); - console_set_style(tinput->console, STYLE_EMPHASIS); - printf("%s", usr->prompt); - console_flush(tinput->console); - console_set_style(tinput->console, STYLE_NORMAL); + tinput_set_prompt(tinput, usr->prompt); rc = tinput_read(tinput, &str); @@ -263,4 +261,6 @@ } + tinput_set_compl_ops(tinput, &compl_ops); + return 0; } Index: uspace/app/bdsh/scli.h =================================================================== --- uspace/app/bdsh/scli.h (revision 026793d93499d089b36163093b5ef05e10ac1f12) +++ uspace/app/bdsh/scli.h (revision 9be9c4dfa6546c6f2da92b12273ac723bee9af42) @@ -32,4 +32,5 @@ #include "config.h" #include +#include typedef struct { Index: uspace/app/sbi/src/input.c =================================================================== --- uspace/app/sbi/src/input.c (revision 026793d93499d089b36163093b5ef05e10ac1f12) +++ uspace/app/sbi/src/input.c (revision 9be9c4dfa6546c6f2da92b12273ac723bee9af42) @@ -176,4 +176,5 @@ int input_get_line(input_t *input, char **line) { + const char *prompt; const char *sp; char *dp; @@ -212,10 +213,10 @@ /* Interactive mode */ if (input->line_no == 0) - printf("sbi> "); + prompt = "sbi> "; else - printf("... "); + prompt = "... "; fflush(stdout); - if (os_input_line(&line_p) != EOK) + if (os_input_line(prompt, &line_p) != EOK) return EIO; Index: uspace/app/sbi/src/os/helenos.c =================================================================== --- uspace/app/sbi/src/os/helenos.c (revision 026793d93499d089b36163093b5ef05e10ac1f12) +++ uspace/app/sbi/src/os/helenos.c (revision 9be9c4dfa6546c6f2da92b12273ac723bee9af42) @@ -210,5 +210,5 @@ * @param ptr Place to store pointer to new string. */ -int os_input_line(char **ptr) +int os_input_line(const char *prompt, char **ptr) { char *line; @@ -219,4 +219,6 @@ if (tinput == NULL) return EIO; + + tinput_set_prompt(tinput, prompt); } Index: uspace/app/sbi/src/os/os.h =================================================================== --- uspace/app/sbi/src/os/os.h (revision 026793d93499d089b36163093b5ef05e10ac1f12) +++ uspace/app/sbi/src/os/os.h (revision 9be9c4dfa6546c6f2da92b12273ac723bee9af42) @@ -38,5 +38,5 @@ char *os_chr_to_astr(wchar_t chr); void os_input_disp_help(void); -int os_input_line(char **ptr); +int os_input_line(const char *prompt, char **ptr); int os_exec(char * const cmd[]); Index: uspace/app/sbi/src/os/posix.c =================================================================== --- uspace/app/sbi/src/os/posix.c (revision 026793d93499d089b36163093b5ef05e10ac1f12) +++ uspace/app/sbi/src/os/posix.c (revision 9be9c4dfa6546c6f2da92b12273ac723bee9af42) @@ -193,6 +193,8 @@ * @param ptr Place to store pointer to new string. */ -int os_input_line(char **ptr) -{ +int os_input_line(const char *prompt, char **ptr) +{ + printf("%s", prompt); + if (fgets(os_input_buffer, OS_INPUT_BUFFER_SIZE, stdin) == NULL) os_input_buffer[0] = '\0'; Index: uspace/lib/clui/tinput.c =================================================================== --- uspace/lib/clui/tinput.c (revision 026793d93499d089b36163093b5ef05e10ac1f12) +++ uspace/lib/clui/tinput.c (revision 9be9c4dfa6546c6f2da92b12273ac723bee9af42) @@ -1,4 +1,4 @@ /* - * Copyright (c) 2010 Jiri Svoboda + * Copyright (c) 2011 Jiri Svoboda * All rights reserved. * @@ -27,4 +27,5 @@ */ +#include #include #include @@ -42,4 +43,7 @@ #include +#define LIN_TO_COL(ti, lpos) ((lpos) % ((ti)->con_cols)) +#define LIN_TO_ROW(ti, lpos) ((lpos) / ((ti)->con_cols)) + /** Seek direction */ typedef enum { @@ -61,4 +65,10 @@ static void tinput_post_seek(tinput_t *, bool); +static void tinput_console_set_lpos(tinput_t *ti, unsigned lpos) +{ + console_set_pos(ti->console, LIN_TO_COL(ti, lpos), + LIN_TO_ROW(ti, lpos)); +} + /** Create a new text input field. */ tinput_t *tinput_new(void) @@ -66,5 +76,5 @@ tinput_t *ti; - ti = malloc(sizeof(tinput_t)); + ti = calloc(1, sizeof(tinput_t)); if (ti == NULL) return NULL; @@ -77,5 +87,17 @@ void tinput_destroy(tinput_t *ti) { + if (ti->prompt != NULL) + free(ti->prompt); free(ti); +} + +static void tinput_display_prompt(tinput_t *ti) +{ + tinput_console_set_lpos(ti, ti->prompt_coord); + + console_set_style(ti->console, STYLE_EMPHASIS); + printf("%s", ti->prompt); + console_flush(ti->console); + console_set_style(ti->console, STYLE_NORMAL); } @@ -88,6 +110,5 @@ tinput_sel_get_bounds(ti, &sa, &sb); - console_set_pos(ti->console, (ti->col0 + start) % ti->con_cols, - ti->row0 + (ti->col0 + start) / ti->con_cols); + tinput_console_set_lpos(ti, ti->text_coord + start); console_set_style(ti->console, STYLE_NORMAL); @@ -134,17 +155,45 @@ static void tinput_position_caret(tinput_t *ti) { - console_set_pos(ti->console, (ti->col0 + ti->pos) % ti->con_cols, - ti->row0 + (ti->col0 + ti->pos) / ti->con_cols); -} - -/** Update row0 in case the screen could have scrolled. */ + tinput_console_set_lpos(ti, ti->text_coord + ti->pos); +} + +/** Update text_coord, prompt_coord in case the screen could have scrolled. */ static void tinput_update_origin(tinput_t *ti) { - sysarg_t width = ti->col0 + ti->nc; - sysarg_t rows = (width / ti->con_cols) + 1; - - /* Update row0 if the screen scrolled. */ - if (ti->row0 + rows > ti->con_rows) - ti->row0 = ti->con_rows - rows; + unsigned end_coord = ti->text_coord + ti->nc; + unsigned end_row = LIN_TO_ROW(ti, end_coord); + + unsigned scroll_rows; + + /* Update coords if the screen scrolled. */ + if (end_row >= ti->con_rows) { + scroll_rows = end_row - ti->con_rows + 1; + ti->text_coord -= ti->con_cols * scroll_rows; + ti->prompt_coord -= ti->con_cols * scroll_rows; + } +} + +static void tinput_jump_after(tinput_t *ti) +{ + tinput_console_set_lpos(ti, ti->text_coord + ti->nc); + console_flush(ti->console); + putchar('\n'); +} + +static int tinput_display(tinput_t *ti) +{ + sysarg_t col0, row0; + + if (console_get_pos(ti->console, &col0, &row0) != EOK) + return EIO; + + ti->prompt_coord = row0 * ti->con_cols + col0; + ti->text_coord = ti->prompt_coord + str_length(ti->prompt); + + tinput_display_prompt(ti); + tinput_display_tail(ti, 0, 0); + tinput_position_caret(ti); + + return EOK; } @@ -154,5 +203,5 @@ return; - sysarg_t new_width = ti->col0 + ti->nc + 1; + unsigned new_width = LIN_TO_COL(ti, ti->text_coord) + ti->nc + 1; if (new_width % ti->con_cols == 0) { /* Advancing to new line. */ @@ -185,6 +234,6 @@ return; - sysarg_t new_width = ti->col0 + ti->nc + ilen; - sysarg_t new_height = (new_width / ti->con_cols) + 1; + unsigned new_width = LIN_TO_COL(ti, ti->text_coord) + ti->nc + ilen; + unsigned new_height = (new_width / ti->con_cols) + 1; if (new_height >= ti->con_rows) { /* Disallow text longer than 1 page for now. */ @@ -511,4 +560,141 @@ } +/** Compare two entries in array of completions. */ +static int compl_cmp(void *va, void *vb, void *arg) +{ + const char *a = *(const char **) va; + const char *b = *(const char **) vb; + + return str_cmp(a, b); +} + +static size_t common_pref_len(const char *a, const char *b) +{ + size_t i; + size_t a_off, b_off; + wchar_t ca, cb; + + i = 0; + a_off = 0; + b_off = 0; + + while (true) { + ca = str_decode(a, &a_off, STR_NO_LIMIT); + cb = str_decode(b, &b_off, STR_NO_LIMIT); + + if (ca == '\0' || cb == '\0' || ca != cb) + break; + ++i; + } + + return i; +} + +static void tinput_text_complete(tinput_t *ti) +{ + void *state; + size_t cstart; + char *ctmp; + char **compl; /* Array of completions */ + size_t compl_len; /* Current length of @c compl array */ + size_t cnum; + size_t i; + int rc; + + if (ti->compl_ops == NULL) + return; + + /* + * Obtain list of all possible completions (growing array). + */ + + rc = (*ti->compl_ops->init)(ti->buffer, ti->pos, &cstart, &state); + if (rc != EOK) + return; + + cnum = 0; + + compl_len = 1; + compl = malloc(compl_len * sizeof(char *)); + if (compl == NULL) { + printf("Error: Out of memory.\n"); + return; + } + + while (true) { + rc = (*ti->compl_ops->get_next)(state, &ctmp); + if (rc != EOK) + break; + + if (cnum >= compl_len) { + /* Extend array */ + compl_len = 2 * compl_len; + compl = realloc(compl, compl_len * sizeof(char *)); + if (compl == NULL) { + printf("Error: Out of memory.\n"); + break; + } + } + + compl[cnum] = str_dup(ctmp); + if (compl[cnum] == NULL) { + printf("Error: Out of memory.\n"); + break; + } + cnum++; + } + + (*ti->compl_ops->fini)(state); + + if (cnum > 1) { + /* + * More than one match. Determine maximum common prefix. + */ + size_t cplen; + + cplen = str_length(compl[0]); + for (i = 1; i < cnum; i++) + cplen = min(cplen, common_pref_len(compl[0], compl[i])); + + /* Compute how many bytes we should skip. */ + size_t istart = str_lsize(compl[0], ti->pos - cstart); + + if (cplen > istart) { + /* Insert common prefix. */ + + /* Copy remainder of common prefix. */ + char *cpref = str_ndup(compl[0] + istart, + str_lsize(compl[0], cplen - istart)); + + /* Insert it. */ + tinput_insert_string(ti, cpref); + free(cpref); + } else { + /* No common prefix. Sort and display all entries. */ + + qsort(compl, cnum, sizeof(char *), compl_cmp, NULL); + + tinput_jump_after(ti); + for (i = 0; i < cnum; i++) + printf("%s\n", compl[i]); + tinput_display(ti); + } + } else if (cnum == 1) { + /* + * We have exactly one match. Insert it. + */ + + /* Compute how many bytes of completion string we should skip. */ + size_t istart = str_lsize(compl[0], ti->pos - cstart); + + /* Insert remainder of completion string at current position. */ + tinput_insert_string(ti, compl[0] + istart); + } + + for (i = 0; i < cnum; i++) + free(compl[i]); + free(compl); +} + /** Initialize text input field. * @@ -521,4 +707,33 @@ ti->hpos = 0; ti->history[0] = NULL; +} + +/** Set prompt string. + * + * @param ti Text input + * @param prompt Prompt string + * + * @return EOK on success, ENOMEM if out of memory. + */ +int tinput_set_prompt(tinput_t *ti, const char *prompt) +{ + if (ti->prompt != NULL) + free(ti->prompt); + + ti->prompt = str_dup(prompt); + if (ti->prompt == NULL) + return ENOMEM; + + return EOK; +} + +/** Set completion ops. + * + * Set pointer to completion ops structure that will be used for text + * completion. + */ +void tinput_set_compl_ops(tinput_t *ti, tinput_compl_ops_t *compl_ops) +{ + ti->compl_ops = compl_ops; } @@ -539,7 +754,4 @@ return EIO; - if (console_get_pos(ti->console, &ti->col0, &ti->row0) != EOK) - return EIO; - ti->pos = 0; ti->sel_start = 0; @@ -549,4 +761,7 @@ ti->exit_clui = false; + if (tinput_display(ti) != EOK) + return EIO; + while (!ti->done) { console_flush(ti->console); @@ -714,4 +929,7 @@ tinput_history_seek(ti, -1); break; + case KC_TAB: + tinput_text_complete(ti); + break; default: break; Index: uspace/lib/clui/tinput.h =================================================================== --- uspace/lib/clui/tinput.h (revision 026793d93499d089b36163093b5ef05e10ac1f12) +++ uspace/lib/clui/tinput.h (revision 9be9c4dfa6546c6f2da92b12273ac723bee9af42) @@ -1,4 +1,4 @@ /* - * Copyright (c) 2010 Jiri Svoboda + * Copyright (c) 2011 Jiri Svoboda * All rights reserved. * @@ -37,11 +37,65 @@ #define LIBCLUI_TINPUT_H_ -#include +#include #include #include #include +#include #define HISTORY_LEN 10 #define INPUT_MAX_SIZE 1024 + +/** Begin enumeration of text completions. + * + * When user requests text completion, tinput will call this function to start + * text completion operation. @a *cstart should be set to the position + * (character index) of the first character of the 'word' that is being + * completed. The resulting text is obtained by replacing the range of text + * starting at @a *cstart and ending at @a pos with the completion text. + * + * The function can pass information to the get_next and fini functions + * via @a state. The init function allocates the state object and stores + * a pointer to it to @a *state. The fini function destroys the state object. + * + * @param text Current contents of edit buffer (null-terminated). + * @param pos Current caret position. + * @param cstart Output, position in text where completion begins from. + * @param state Output, pointer to a client state object. + * + * @return EOK on success, negative error code on failure. + */ +typedef int (*tinput_compl_init_fn)(wchar_t *text, size_t pos, size_t *cstart, + void **state); + +/** Obtain one text completion alternative. + * + * Upon success the function sets @a *compl to point to a string, the + * completion text. The caller (Tinput) should not modify or free the text. + * The pointer is only valid until the next invocation of any completion + * function. + * + * @param state Pointer to state object created by the init funtion. + * @param compl Output, the completion text, ownership retained. + * + * @return EOK on success, negative error code on failure. + */ +typedef int (*tinput_compl_get_next_fn)(void *state, char **compl); + + +/** Finish enumeration of text completions. + * + * The function must deallocate any state information allocated by the init + * function or temporary data allocated by the get_next function. + * + * @param state Pointer to state object created by the init funtion. + */ +typedef void (*tinput_compl_fini_fn)(void *state); + +/** Text completion ops. */ +typedef struct { + tinput_compl_init_fn init; + tinput_compl_get_next_fn get_next; + tinput_compl_fini_fn fini; +} tinput_compl_ops_t; /** Text input field (command line). @@ -53,10 +107,17 @@ console_ctrl_t *console; + /** Prompt string */ + char *prompt; + + /** Completion ops. */ + tinput_compl_ops_t *compl_ops; + /** Buffer holding text currently being edited */ wchar_t buffer[INPUT_MAX_SIZE + 1]; - /** Screen coordinates of the top-left corner of the text field */ - sysarg_t col0; - sysarg_t row0; + /** Linear position on screen where the prompt starts */ + unsigned prompt_coord; + /** Linear position on screen where the text field starts */ + unsigned text_coord; /** Screen dimensions */ @@ -90,4 +151,6 @@ extern tinput_t *tinput_new(void); +extern int tinput_set_prompt(tinput_t *, const char *); +extern void tinput_set_compl_ops(tinput_t *, tinput_compl_ops_t *); extern void tinput_destroy(tinput_t *); extern int tinput_read(tinput_t *, char **);