X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=cmdedit.c;h=2e57b9a349e1be06446848f9af10bb5257b048c6;hb=af4ac77d9d13f879922ccad8a8535c24aeea0380;hp=d15c694977ff28f746cf6723b6aae36b9ac04e1f;hpb=a2685735b1ace4323f0c6fae6c31e0888ed62c34;p=oweals%2Fbusybox.git diff --git a/cmdedit.c b/cmdedit.c index d15c69497..2e57b9a34 100644 --- a/cmdedit.c +++ b/cmdedit.c @@ -1,10 +1,12 @@ /* vi: set sw=4 ts=4: */ /* - * Termios command line History and Editting for NetBSD sh (ash) + * Termios command line History and Editting, originally + * intended for NetBSD sh (ash) * Copyright (c) 1999 * Main code: Adam Rogoyski * Etc: Dave Cinege - * Adjusted for busybox: Erik Andersen + * Majorly adjusted/re-written for busybox: + * Erik Andersen * * You may use this code as you wish, so long as the original author(s) * are attributed in any redistributions of the source code. @@ -23,13 +25,20 @@ need to be added. This version was created on Debian GNU/Linux 2.x. Delete, Backspace, Home, End, and the arrow keys were tested to work in an Xterm and console. Ctrl-A also works as Home. - Ctrl-E also works as End. The binary size increase is <3K. + Ctrl-E also works as End. - Editting will not display correctly for lines greater then the - terminal width. (more then one line.) However, history will. + + Editor with vertical scrolling and completion by + Vladimir Oleynik. vodz@usa.net (c) 2001 + + Small bug: not true work if terminal size (x*y symbols) less + size (prompt + editor`s line + 2 symbols) */ -#include "internal.h" + + +#include "busybox.h" + #ifdef BB_FEATURE_SH_COMMAND_EDITING #include @@ -37,25 +46,85 @@ #include #include #include -#include +#include #include #include +#ifdef BB_FEATURE_SH_TAB_COMPLETION +#include +#endif + +#include "pwd_grp/pwd.h" -#define MAX_HISTORY 15 /* Maximum length of the linked list for the command line history */ -#define ESC 27 -#define DEL 127 +static const int MAX_HISTORY = 15; /* Maximum length of the linked list for the command line history */ + +enum { + ESC = 27, + DEL = 127, +}; + #define member(c, s) ((c) ? ((char *)strchr ((s), (c)) != (char *)NULL) : 0) #define whitespace(c) (((c) == ' ') || ((c) == '\t')) static struct history *his_front = NULL; /* First element in command line list */ static struct history *his_end = NULL; /* Last element in command line list */ -static struct termio old_term, new_term; /* Current termio and the previous termio before starting ash */ -static int history_counter = 0; /* Number of commands in history list */ -static int reset_term = 0; /* Set to true if the terminal needs to be reset upon exit */ -char *parsenextc; /* copy of parsefile->nextc */ +/* ED: sparc termios is broken: revert back to old termio handling. */ + +#if #cpu(sparc) +# include +# define termios termio +# define setTermSettings(fd,argp) ioctl(fd,TCSETAF,argp) +# define getTermSettings(fd,argp) ioctl(fd,TCGETA,argp) +#else +# include +# define setTermSettings(fd,argp) tcsetattr(fd,TCSANOW,argp) +# define getTermSettings(fd,argp) tcgetattr(fd, argp); +#endif + +/* Current termio and the previous termio before starting sh */ +static struct termios initial_settings, new_settings; + + +#ifndef _POSIX_VDISABLE +#define _POSIX_VDISABLE '\0' +#endif + + +static +volatile int cmdedit_termw; /* actual terminal width */ +static int history_counter = 0; /* Number of commands in history list */ + +static +volatile int handlers_sets = 0; /* Set next bites + when atexit() has been called + and set many "terminates" signal handlers + and winchg signal handler + and if the terminal needs to be reset upon exit + */ +enum { + SET_ATEXIT = 1, + SET_TERM_HANDLERS = 2, + SET_WCHG_HANDLERS = 4, + SET_RESET_TERM = 8, +}; + + +static int cmdedit_x; /* real x terminal position, + require put prompt in start x position */ +static int cmdedit_y; /* pseudoreal y terminal position */ +static int cmdedit_prmt_len; /* for fast running, without duplicate calculate */ + +static int cursor; /* required global for signal handler */ +static int len; /* --- "" - - "" - -"- --""-- --""--- */ +static char *command_ps; /* --- "" - - "" - -"- --""-- --""--- */ +static const char *cmdedit_prompt;/* --- "" - - "" - -"- --""-- --""--- */ + +/* Link into lash to reset context to 0 + * on ^C and such */ +extern unsigned int shell_context; + struct history { char *s; @@ -63,171 +132,536 @@ struct history { struct history *n; }; +static void cmdedit_setwidth(int w, int redraw_flg); -/* Version of write which resumes after a signal is caught. */ -int xwrite(int fd, char *buf, int nbytes) +static void win_changed(int nsig) { - int ntry; - int i; - int n; - - n = nbytes; - ntry = 0; - for (;;) { - i = write(fd, buf, n); - if (i > 0) { - if ((n -= i) <= 0) - return nbytes; - buf += i; - ntry = 0; - } else if (i == 0) { - if (++ntry > 10) - return nbytes - n; - } else if (errno != EINTR) { - return -1; + struct winsize win = { 0, 0, 0, 0 }; + static __sighandler_t previous_SIGWINCH_handler; /* for reset */ + + /* emulate signal call if not called as a sig handler */ + if(nsig == -SIGWINCH || nsig == SIGWINCH) { + ioctl(0, TIOCGWINSZ, &win); + if (win.ws_col > 0) { + cmdedit_setwidth( win.ws_col, nsig == SIGWINCH ); + } else { + /* Default to 79 if their console doesn't want to share */ + cmdedit_setwidth( 79, nsig == SIGWINCH ); } } + + /* Unix not all standart in recall signal */ + + if(nsig == -SIGWINCH) /* save previous handler */ + previous_SIGWINCH_handler = signal(SIGWINCH, win_changed); + else if(nsig == SIGWINCH) /* signaled called handler */ + signal(SIGWINCH, win_changed); /* set for next call */ + else /* set previous handler */ + signal(SIGWINCH, previous_SIGWINCH_handler); /* reset */ } - -/* Version of ioctl that retries after a signal is caught. */ -int xioctl(int fd, unsigned long request, char *arg) +static void cmdedit_reset_term(void) { - int i; + if((handlers_sets & SET_RESET_TERM)!=0) { + /* sparc and other have broken termios support: use old termio handling. */ + setTermSettings(fileno(stdin), (void*) &initial_settings); + handlers_sets &= ~SET_RESET_TERM; + } + if((handlers_sets & SET_WCHG_HANDLERS)!=0) { + /* reset SIGWINCH handler to previous (default) */ + win_changed(0); + handlers_sets &= ~SET_WCHG_HANDLERS; + } + fflush(stdout); +#ifdef BB_FEATURE_CLEAN_UP + if (his_front) { + struct history *n; + //while(his_front!=his_end) { + while(his_front!=his_end) { + n = his_front->n; + free(his_front->s); + free(his_front); + his_front=n; + } + } +#endif +} - while ((i = ioctl(fd, request, arg)) == -1 && errno == EINTR); - return i; + + +/* special for recount position for scroll and remove terminal margin effect */ +static void cmdedit_set_out_char(int c, int next_char) { + putchar(c); + if(++cmdedit_x>=cmdedit_termw) { + /* terminal is scrolled down */ + cmdedit_y++; + cmdedit_x=0; + + if(!next_char) + next_char = ' '; + /* destroy "(auto)margin" */ + putchar(next_char); + putchar('\b'); + } + cursor++; } +/* Move to end line. Bonus: rewrite line from cursor without use + special control terminal strings, also saved size and speed! */ +static void input_end (void) { + while(cursor < len) + cmdedit_set_out_char(command_ps[cursor], 0); +} -void cmdedit_reset_term(void) -{ - if (reset_term) - xioctl(fileno(stdin), TCSETA, (void *) &old_term); +/* Go to the next line */ +static void goto_new_line(void) { + input_end(); + cmdedit_set_out_char('\n', 0); } -void prepareToDie(int sig) + +static inline void out1str(const char *s) { fputs (s, stdout); } +static inline void beep (void) { putchar('\007'); } + +/* Go to HOME position */ +static void input_home(void) { - cmdedit_reset_term(); - fprintf(stdout, "\n"); - exit(TRUE); + while(cmdedit_y>0) { /* up to start y */ + out1str("\033[A"); + cmdedit_y--; + } + putchar('\r'); + cursor = 0; + out1str(cmdedit_prompt); + cmdedit_x = cmdedit_prmt_len; + } -void input_home(int outputFd, int *cursor) -{ /* Command line input routines */ - while (*cursor > 0) { - xwrite(outputFd, "\b", 1); - --*cursor; +/* Move back one charactor */ +static void input_backward(void) { + if (cursor > 0) { + cursor--; + if(cmdedit_x!=0) { /* no first position in terminal line */ + putchar('\b'); + cmdedit_x--; + } + else { + out1str("\033[A"); /* up */ + cmdedit_y--; + + /* to end in current terminal line */ + while(cmdedit_x<(cmdedit_termw-1)) { + out1str("\033[C"); + cmdedit_x++; + } + } } } - -void input_delete(int outputFd, int cursor) +/* Delete the char in front of the cursor */ +static void input_delete(void) { - int j = 0; + int j = cursor; + + if (j == len) + return; + + memmove (command_ps + j, command_ps + j + 1, BUFSIZ - j - 1); + len--; + input_end(); /* rewtite new line */ + cmdedit_set_out_char(' ', 0); /* destroy end char */ + while (j < cursor) + input_backward(); /* back to old pos cursor */ +} - memmove(parsenextc + cursor, parsenextc + cursor + 1, - BUFSIZ - cursor - 1); - for (j = cursor; j < (BUFSIZ - 1); j++) { - if (!*(parsenextc + j)) - break; - else - xwrite(outputFd, (parsenextc + j), 1); +/* Delete the char in back of the cursor */ +static void input_backspace(void) +{ + if (cursor > 0) { + input_backward(); + input_delete (); } +} - xwrite(outputFd, " \b", 2); - while (j-- > cursor) - xwrite(outputFd, "\b", 1); +/* Move forward one charactor */ +static void input_forward(void) +{ + if (cursor < len) + cmdedit_set_out_char(command_ps[cursor], command_ps[cursor + 1]); } -void input_end(int outputFd, int *cursor, int len) +static void clean_up_and_die(int sig) { - while (*cursor < len) { - xwrite(outputFd, "\033[C", 3); - ++*cursor; - } + goto_new_line(); + if (sig!=SIGINT) + exit(EXIT_SUCCESS); /* cmdedit_reset_term() called in atexit */ + cmdedit_reset_term(); } - -void input_backspace(int outputFd, int *cursor, int *len) +static void cmdedit_setwidth(int w, int redraw_flg) { - int j = 0; + cmdedit_termw = cmdedit_prmt_len+2; + if (w > cmdedit_termw) { - if (*cursor > 0) { - xwrite(outputFd, "\b \b", 3); - --*cursor; - memmove(parsenextc + *cursor, parsenextc + *cursor + 1, - BUFSIZ - *cursor + 1); + cmdedit_termw = w; - for (j = *cursor; j < (BUFSIZ - 1); j++) { - if (!*(parsenextc + j)) - break; - else - xwrite(outputFd, (parsenextc + j), 1); - } + if(redraw_flg) { + int sav_cursor = cursor; - xwrite(outputFd, " \b", 2); + /* set variables for new terminal size */ + cmdedit_y = sav_cursor/w; + cmdedit_x = sav_cursor-cmdedit_y*w; - while (j-- > *cursor) - xwrite(outputFd, "\b", 1); + /* redraw */ + input_home(); + input_end(); + while(sav_cursorpw_name, userlen)) { + + temp = xmalloc (3 + strlen (entry->pw_name)); + sprintf(temp, "~%s/", entry->pw_name); + + matches = xrealloc(matches, (nm+1)*sizeof(char *)); + matches[nm++] = temp; + } + } + + endpwent (); + (*num_matches) = nm; return (matches); } +#endif + +enum { + FIND_EXE_ONLY = 0, + FIND_DIR_ONLY = 1, + FIND_FILE_ONLY = 2, +}; #include -char** find_path_executable_n_cwd_matches(char* command, int *num_matches) + +static int path_parse(char ***p, int flags) +{ + int npth; + char *tmp; + char *pth; + + if(flags!=FIND_EXE_ONLY || (pth=getenv("PATH"))==0) { + /* if not setenv PATH variable, to search cur dir "." */ + (*p) = xmalloc(sizeof(char *)); + (*p)[0] = xstrdup("."); + return 1; + } + + tmp = pth; + npth=0; + + for(;;) { + npth++; /* count words is + 1 count ':' */ + tmp = strchr(tmp, ':'); + if(tmp) + tmp++; + else + break; + } + + *p = xmalloc(npth*sizeof(char *)); + + tmp = pth; + (*p)[0] = xstrdup(tmp); + npth=1; /* count words is + 1 count ':' */ + + for(;;) { + tmp = strchr(tmp, ':'); + if(tmp) { + (*p)[0][(tmp-pth)]=0; /* ':' -> '\0'*/ + tmp++; + } else + break; + (*p)[npth++] = &(*p)[0][(tmp-pth)]; /* p[next]=p[0][&'\0'+1] */ + } + + return npth; +} + +static char** exe_n_cwd_tab_completion(char* command, int *num_matches, int type) { char *dirName; - char **matches = (char **) NULL; + char **matches = 0; DIR *dir; struct dirent *next; + char cmd [BUFSIZ+4]; + char *dirbuf; + char found [BUFSIZ+4]; + int nm = *num_matches; + struct stat st; + char **paths; + int npaths; + int i; + char full_pth[BUFSIZ+4+PATH_MAX]; + + + strcpy(cmd, command); /* save for change (last '/' to '\0') */ + + dirName = strrchr(cmd, '/'); + if(dirName==NULL) { + /* no dir, if flags==EXE_ONLY - get paths, else "." */ + npaths = path_parse(&paths, type); + if(npaths==0) + return 0; + } else { + /* with dir */ + + /* save dir */ + dirbuf = xstrdup(cmd); + /* set only dirname */ + dirbuf[(dirName-cmd)+1]=0; + + /* strip dirname in cmd */ + strcpy(cmd, dirName+1); - matches = malloc( sizeof(char*)*50); + paths = xmalloc(sizeof(char*)); + paths[0] = dirbuf; + npaths = 1; /* only 1 dir */ + } - /* Stick a wildcard onto the command, for later use */ - strcat( command, "*"); + for(i=0; i < npaths; i++) { - /* Now wall the current directory */ - dirName = get_current_dir_name(); - dir = opendir(dirName); + dir = opendir(paths[i]); if (!dir) { /* Don't print an error, just shut up and return */ - *num_matches=0; return (matches); } while ((next = readdir(dir)) != NULL) { - - /* Some quick sanity checks */ - if ((strcmp(next->d_name, "..") == 0) - || (strcmp(next->d_name, ".") == 0)) { + /* matched ? */ + if(strncmp(next->d_name, cmd, strlen(cmd))) + continue; + /* not see .name without .match */ + if(*next->d_name == '.' && *cmd != '.') + continue; + sprintf(full_pth, "%s/%s", paths[i], next->d_name); + /* hmm, remover in progress? */ + if(stat(full_pth, &st)<0) + continue; + /* Cool, found a match. */ + if (S_ISDIR(st.st_mode)) { + /* name is directory */ + strcpy(found, next->d_name); + strcat(found, "/"); + if(type==FIND_DIR_ONLY) + strcat(found, " "); + } else { + /* not put found file if search only dirs for cd */ + if(type==FIND_DIR_ONLY) continue; + strcpy(found, next->d_name); + strcat(found, " "); } - /* See if this matches */ - if (check_wildcard_match(next->d_name, command) == TRUE) { - /* Cool, found a match. Add it to the list */ - matches[*num_matches] = malloc(strlen(next->d_name)+1); - strcpy( matches[*num_matches], next->d_name); - ++*num_matches; - //matches = realloc( matches, sizeof(char*)*(*num_matches)); + /* Add it to the list */ + matches = xrealloc(matches, (nm+1)*sizeof(char *)); + matches[nm++] = xstrdup(found); } } - + free(paths[0]); /* allocate memory only in first member */ + free(paths); + *num_matches = nm; return (matches); } + +static void input_tab(int lastWasTab) +{ + /* Do TAB completion */ + static int num_matches; + static char **matches; + + char matchBuf[BUFSIZ]; + + int pos = cursor; + int find_type=FIND_FILE_ONLY; + + + if (lastWasTab == FALSE) { + char *tmp, *tmp1; + int len_found; + + /* For now, we will not bother with trying to distinguish + * whether the cursor is in/at a command extression -- we + * will always try all possible matches. If you don't like + * that then feel free to fix it. + */ + + /* Make a local copy of the string -- up + * to the position of the cursor */ + memset(matchBuf, 0, BUFSIZ); + tmp = strncpy(matchBuf, command_ps, cursor); + + /* skip past any command seperator tokens */ + while ( (tmp1=strpbrk(tmp, ";|&{(`")) != NULL) { + tmp = ++tmp1; + } + + /* skip any leading white space */ + while (*tmp == ' ') + tmp++; + + if(strncmp(tmp, "cd ", 3)==0) + find_type = FIND_DIR_ONLY; + else if(strchr(tmp, ' ')==NULL) + find_type = FIND_EXE_ONLY; + + /* find begin curent word */ + if( (tmp1=strrchr(tmp, ' ')) != NULL) { + tmp = ++tmp1; + } + strcpy(matchBuf, tmp); + + /* Free up any memory already allocated */ + if (matches) { + while(num_matches>0) + free(matches[--num_matches]); + free(matches); + matches = (char **) NULL; + } + +#ifdef BB_FEATURE_USERNAME_COMPLETION + /* If the word starts with `~' and there is no slash in the word, + * then try completing this word as a username. */ + + if (matchBuf[0]=='~' && strchr(matchBuf, '/')==0) { + matches = username_tab_completion(matchBuf, &num_matches); + } #endif + /* Try to match any executable in our path and everything + * in the current working directory that matches. */ + if (!matches) + matches = exe_n_cwd_tab_completion(matchBuf, &num_matches, find_type); + + /* Did we find exactly one match? */ + if(!matches || num_matches>1) { + beep(); + return; + } + + len_found = strlen(matches[0]); + + /* have space to placed match? */ + if ( (len_found-strlen(matchBuf)+len) < BUFSIZ ) { + + int recalc_pos = len; + + /* before word for match */ + command_ps[pos-strlen(matchBuf)]=0; + + /* tail line */ + strcpy(matchBuf, command_ps+pos); + + /* add match */ + strcat(command_ps, matches[0]); + /* add tail */ + strcat(command_ps, matchBuf); + + /* write out the matched command */ + len=strlen(command_ps); + recalc_pos = len-recalc_pos+pos; + input_end(); /* write */ + while(recalc_pos0 ) { + int i, col; + int sav_cursor = cursor; + + /* Go to the next line */ + goto_new_line(); + for (i=0,col=0; i 60 && matches[i+1] != NULL) { + putchar('\n'); + col = 0; + } + } + /* Go to the next line and rewrite the prompt */ + printf("\n%s", cmdedit_prompt); + cmdedit_x = cmdedit_prmt_len; + cmdedit_y = 0; + cursor = 0; + input_end(); /* Rewrite the command */ + /* Put the cursor back to where it used to be */ + while (sav_cursor < cursor) + input_backward(); + } + } +} +#endif + +static void get_previous_history(struct history **hp, char* command) +{ + if ((*hp)->s) + free((*hp)->s); + (*hp)->s = strdup(command); + *hp = (*hp)->p; +} + +static void get_next_history(struct history **hp, char* command) +{ + if ((*hp)->s) + free((*hp)->s); + (*hp)->s = strdup(command); + *hp = (*hp)->n; +} /* * This function is used to grab a character buffer @@ -245,323 +679,229 @@ char** find_path_executable_n_cwd_matches(char* command, int *num_matches) * Furthermore, the "vi" command editing keys are not implemented. * * TODO: implement TAB command completion. :) - * */ -extern int cmdedit_read_input(char* prompt, int inputFd, int outputFd, - char command[BUFSIZ]) +extern void cmdedit_read_input(char* prompt, char command[BUFSIZ]) { - int nr = 0; - int len = 0; + int inputFd=fileno(stdin); + int j = 0; - int cursor = 0; int break_out = 0; int ret = 0; int lastWasTab = FALSE; char c = 0; struct history *hp = his_end; - memset(command, 0, sizeof(command)); - parsenextc = command; - if (!reset_term) { - xioctl(inputFd, TCGETA, (void *) &old_term); - memcpy(&new_term, &old_term, sizeof(struct termio)); - - new_term.c_cc[VMIN] = 1; - new_term.c_cc[VTIME] = 0; - new_term.c_lflag &= ~ICANON; /* unbuffered input */ - new_term.c_lflag &= ~ECHO; - xioctl(inputFd, TCSETA, (void *) &new_term); - reset_term = 1; - } else { - xioctl(inputFd, TCSETA, (void *) &new_term); + len = 0; + cursor = 0; + command_ps = command; + + if (new_settings.c_cc[VMIN]==0) { + + getTermSettings(inputFd, (void*) &initial_settings); + memcpy(&new_settings, &initial_settings, sizeof(struct termios)); + new_settings.c_cc[VMIN] = 1; + new_settings.c_cc[VTIME] = 0; + new_settings.c_cc[VINTR] = _POSIX_VDISABLE; /* Turn off CTRL-C, so we can trap it */ + new_settings.c_lflag &= ~ICANON; /* unbuffered input */ + new_settings.c_lflag &= ~(ECHO|ECHOCTL|ECHONL); /* Turn off echoing */ } + setTermSettings(inputFd, (void*) &new_settings); + handlers_sets |= SET_RESET_TERM; + + memset(command, 0, BUFSIZ); + + cmdedit_init(); + + /* Print out the command prompt */ + cmdedit_prompt = prompt; + cmdedit_prmt_len = strlen(prompt); + printf("%s", prompt); + cmdedit_x = cmdedit_prmt_len; /* count real x terminal position */ + cmdedit_y = 0; /* quasireal y, not true work if line > xt*yt */ - memset(parsenextc, 0, BUFSIZ); while (1) { - if ((ret = read(inputFd, &c, 1)) < 1) - return ret; + fflush(stdout); /* buffered out to fast */ - fprintf(stderr, "\n\nkey=%d (%c)\n\n", c, c); - /* Go to the next line */ - xwrite(outputFd, "\n", 1); - /* Rewrite the prompt */ - xwrite(outputFd, prompt, strlen(prompt)); - /* Rewrite the command */ - xwrite(outputFd, parsenextc, len); + if ((ret = read(inputFd, &c, 1)) < 1) + return; + //fprintf(stderr, "got a '%c' (%d)\n", c, c); switch (c) { + case '\n': + case '\r': + /* Enter */ + *(command + len) = c; + len++; + input_end (); + break_out = 1; + break; case 1: /* Control-a -- Beginning of line */ - input_home(outputFd, &cursor); - case 5: - /* Control-e -- End of line */ - input_end(outputFd, &cursor, len); + input_home(); break; case 2: /* Control-b -- Move back one character */ - if (cursor > 0) { - xwrite(outputFd, "\033[D", 3); - cursor--; + input_backward(); + break; + case 3: + /* Control-c -- stop gathering input */ + + /* Link into lash to reset context to 0 on ^C and such */ + shell_context = 0; + + /* Go to the next line */ + goto_new_line(); + +#if 0 + /* Rewrite the prompt */ + printf("%s", prompt); + + /* Reset the command string */ + memset(command, 0, BUFSIZ); + len = cursor = 0; +#endif + return; + + case 4: + /* Control-d -- Delete one character, or exit + * if the len=0 and no chars to delete */ + if (len == 0) { + printf("exit"); + clean_up_and_die(0); + } else { + input_delete(); } break; + case 5: + /* Control-e -- End of line */ + input_end(); + break; case 6: /* Control-f -- Move forward one character */ - if (cursor < len) { - xwrite(outputFd, "\033[C", 3); - cursor++; - } + input_forward(); break; - case 4: - /* Control-d -- Delete one character */ - if (cursor != len) { - input_delete(outputFd, cursor); - len--; - } else if (len == 0) { - prepareToDie(0); - exit(0); - } + case '\b': + case DEL: + /* Control-h and DEL */ + input_backspace(); + break; + case '\t': +#ifdef BB_FEATURE_SH_TAB_COMPLETION + input_tab(lastWasTab); +#endif break; case 14: - /* Control-n -- Get next command */ + /* Control-n -- Get next command in history */ if (hp && hp->n && hp->n->s) { - free(hp->s); - hp->s = strdup(parsenextc); - hp = hp->n; - goto hop; + get_next_history(&hp, command); + goto rewrite_line; + } else { + beep(); } break; case 16: - /* Control-p -- Get previous command */ + /* Control-p -- Get previous command from history */ if (hp && hp->p) { - free(hp->s); - hp->s = strdup(parsenextc); - hp = hp->p; - goto hop; - } - break; - case '\t': -#ifdef BB_FEATURE_SH_TAB_COMPLETION - { - /* Do TAB completion */ - static int num_matches=0; - static char **matches = (char **) NULL; - int pos = cursor; - - - if (lastWasTab == FALSE) { - char *tmp, *tmp1, *matchBuf; - - /* For now, we will not bother with trying to distinguish - * whether the cursor is in/at a command extression -- we - * will always try all possable matches. If you don't like - * that then feel free to fix it. - */ - - /* Make a local copy of the string -- up - * to the position of the cursor */ - matchBuf = (char *) calloc(BUFSIZ, sizeof(char)); - strncpy(matchBuf, parsenextc, cursor); - tmp=matchBuf; - - /* skip past any command seperator tokens */ - while (*tmp && (tmp1=strpbrk(tmp, ";|&{(`")) != NULL) { - tmp=++tmp1; - /* skip any leading white space */ - while (*tmp && isspace(*tmp)) - ++tmp; - } - - /* skip any leading white space */ - while (*tmp && isspace(*tmp)) - ++tmp; - - /* Free up any memory already allocated */ - if (matches) { - free(matches); - matches = (char **) NULL; - } - - /* If the word starts with `~' and there is no slash in the word, - * then try completing this word as a username. */ - - /* FIXME -- this check is broken! */ - if (*tmp == '~' && !strchr(tmp, '/')) - matches = username_completion_matches(tmp, &num_matches); - - /* Try to match any executable in our path and everything - * in the current working directory that matches. */ - if (!matches) - matches = find_path_executable_n_cwd_matches(tmp, &num_matches); - - /* Don't leak memory */ - free( matchBuf); - - /* Did we find exactly one match? */ - if (matches && num_matches==1) { - /* write out the matched command */ - strncpy(parsenextc+pos, matches[0]+pos, strlen(matches[0])-pos); - len=strlen(parsenextc); - cursor=len; - xwrite(outputFd, matches[0]+pos, strlen(matches[0])-pos); - break; - } - } else { - /* Ok -- the last char was a TAB. Since they - * just hit TAB again, print a list of all the - * available choices... */ - if ( matches && num_matches>0 ) { - int i, col; - - /* Go to the next line */ - xwrite(outputFd, "\n", 1); - /* Print the list of matches */ - for (i=0,col=0; i 60 && matches[i+1] != NULL) { - xwrite(outputFd, "\n", 1); - col = 0; - } - } - /* Go to the next line */ - xwrite(outputFd, "\n", 1); - /* Rewrite the prompt */ - xwrite(outputFd, prompt, strlen(prompt)); - /* Rewrite the command */ - xwrite(outputFd, parsenextc, len); - /* Put the cursor back to where it used to be */ - for (cursor=len; cursor > pos; cursor--) - xwrite(outputFd, "\b", 1); - } - } - break; + get_previous_history(&hp, command); + goto rewrite_line; + } else { + beep(); } -#else - break; -#endif - case '\b': - case DEL: - /* Backspace */ - input_backspace(outputFd, &cursor, &len); - break; - case '\n': - /* Enter */ - *(parsenextc + len++ + 1) = c; - xwrite(outputFd, &c, 1); - break_out = 1; break; case ESC:{ /* escape sequence follows */ if ((ret = read(inputFd, &c, 1)) < 1) - return ret; + return; if (c == '[') { /* 91 */ if ((ret = read(inputFd, &c, 1)) < 1) - return ret; + return; switch (c) { case 'A': - /* Up Arrow -- Get previous command */ + /* Up Arrow -- Get previous command from history */ if (hp && hp->p) { - free(hp->s); - hp->s = strdup(parsenextc); - hp = hp->p; - goto hop; + get_previous_history(&hp, command); + goto rewrite_line; + } else { + beep(); } break; case 'B': - /* Down Arrow -- Get next command */ + /* Down Arrow -- Get next command in history */ if (hp && hp->n && hp->n->s) { - free(hp->s); - hp->s = strdup(parsenextc); - hp = hp->n; - goto hop; + get_next_history(&hp, command); + goto rewrite_line; + } else { + beep(); } break; - /* This is where we rewrite the line - * using the selected history item */ - hop: - len = strlen(parsenextc); - - /* return to begining of line */ - for (; cursor > 0; cursor--) - xwrite(outputFd, "\b", 1); - - /* erase old command */ - for (j = 0; j < len; j++) - xwrite(outputFd, " ", 1); - - /* return to begining of line */ - for (j = len; j > 0; j--) - xwrite(outputFd, "\b", 1); - - memset(parsenextc, 0, BUFSIZ); - len = strlen(parsenextc); + /* Rewrite the line with the selected history item */ + rewrite_line: + /* return to begin of line */ + input_home (); + /* for next memmoves without set '\0' */ + memset (command, 0, BUFSIZ); + /* change command */ + strcpy (command, hp->s); /* write new command */ - strcpy(parsenextc, hp->s); - len = strlen(hp->s); - xwrite(outputFd, parsenextc, len); - cursor = len; + for (j=0; command[j]; j++) + cmdedit_set_out_char(command[j], 0); + ret = cursor; + /* erase tail if required */ + for (j = ret; j < len; j++) + cmdedit_set_out_char(' ', 0); + /* and backward cursor */ + for (j = ret; j < len; j++) + input_backward(); + len = cursor; /* set new len */ break; case 'C': /* Right Arrow -- Move forward one character */ - if (cursor < len) { - xwrite(outputFd, "\033[C", 3); - cursor++; - } + input_forward(); break; case 'D': /* Left Arrow -- Move back one character */ - if (cursor > 0) { - xwrite(outputFd, "\033[D", 3); - cursor--; - } + input_backward(); break; case '3': /* Delete */ - if (cursor != len) { - input_delete(outputFd, cursor); - len--; - } + input_delete(); break; - - //case '5': case '6': /* pgup/pgdown */ - - case '7': - /* rxvt home */ case '1': /* Home (Ctrl-A) */ - input_home(outputFd, &cursor); + input_home(); break; - case '8': - /* rxvt END */ case '4': /* End (Ctrl-E) */ - input_end(outputFd, &cursor, len); + input_end(); break; + default: + beep(); } if (c == '1' || c == '3' || c == '4') if ((ret = read(inputFd, &c, 1)) < 1) - return ret; /* read 126 (~) */ + return; /* read 126 (~) */ } if (c == 'O') { /* 79 */ if ((ret = read(inputFd, &c, 1)) < 1) - return ret; + return; switch (c) { case 'H': /* Home (xterm) */ - input_home(outputFd, &cursor); + input_home(); break; case 'F': /* End (xterm) */ - input_end(outputFd, &cursor, len); + input_end(); break; + default: + beep(); } } c = 0; @@ -570,8 +910,9 @@ extern int cmdedit_read_input(char* prompt, int inputFd, int outputFd, default: /* If it's regular input, do the normal thing */ - if (!isprint(c)) /* Skip non-printable characters */ + if (!isprint(c)) { /* Skip non-printable characters */ break; + } if (len >= (BUFSIZ - 2)) /* Need to leave space for enter */ break; @@ -579,21 +920,21 @@ extern int cmdedit_read_input(char* prompt, int inputFd, int outputFd, len++; if (cursor == (len - 1)) { /* Append if at the end of the line */ - *(parsenextc + cursor) = c; + *(command + cursor) = c; + cmdedit_set_out_char(c, command[cursor+1]); } else { /* Insert otherwise */ - memmove(parsenextc + cursor + 1, parsenextc + cursor, + memmove(command + cursor + 1, command + cursor, len - cursor - 1); - *(parsenextc + cursor) = c; - - for (j = cursor; j < len; j++) - xwrite(outputFd, parsenextc + j, 1); - for (; j > cursor; j--) - xwrite(outputFd, "\033[D", 3); + *(command + cursor) = c; + j = cursor+1; + /* rewrite from cursor */ + input_end (); + /* to prev x pos + 1 */ + while(cursor > j) + input_backward(); } - cursor++; - xwrite(outputFd, &c, 1); break; } if (c == '\t') @@ -605,36 +946,39 @@ extern int cmdedit_read_input(char* prompt, int inputFd, int outputFd, break; } - nr = len + 1; - xioctl(inputFd, TCSETA, (void *) &old_term); - reset_term = 0; - + setTermSettings (inputFd, (void *) &initial_settings); + handlers_sets &= ~SET_RESET_TERM; /* Handle command history log */ - if (*(parsenextc)) { + if (len>1) { /* no put empty line (only '\n') */ struct history *h = his_end; + char *ss; + + command[len-1] = 0; /* destroy end '\n' */ + ss = strdup(command); /* duplicate without '\n' */ + command[len-1] = '\n'; /* restore '\n' */ if (!h) { - /* No previous history */ - h = his_front = malloc(sizeof(struct history)); - h->n = malloc(sizeof(struct history)); + /* No previous history -- this memory is never freed */ + h = his_front = xmalloc(sizeof(struct history)); + h->n = xmalloc(sizeof(struct history)); h->p = NULL; - h->s = strdup(parsenextc); + h->s = ss; h->n->p = h; h->n->n = NULL; h->n->s = NULL; his_end = h->n; history_counter++; } else { - /* Add a new history command */ - h->n = malloc(sizeof(struct history)); + /* Add a new history command -- this memory is never freed */ + h->n = xmalloc(sizeof(struct history)); h->n->p = h; h->n->n = NULL; h->n->s = NULL; - h->s = strdup(parsenextc); + h->s = ss; his_end = h->n; /* After max history, remove the oldest command */ @@ -652,14 +996,24 @@ extern int cmdedit_read_input(char* prompt, int inputFd, int outputFd, } } - return nr; + return; } -extern void cmdedit_init(void) + +/* Undo the effects of cmdedit_init(). */ +extern void cmdedit_terminate(void) { - atexit(cmdedit_reset_term); - signal(SIGINT, prepareToDie); - signal(SIGQUIT, prepareToDie); - signal(SIGTERM, prepareToDie); + cmdedit_reset_term(); + if((handlers_sets & SET_TERM_HANDLERS)!=0) { + signal(SIGKILL, SIG_DFL); + signal(SIGINT, SIG_DFL); + signal(SIGQUIT, SIG_DFL); + signal(SIGTERM, SIG_DFL); + signal(SIGWINCH, SIG_DFL); + handlers_sets &= ~SET_TERM_HANDLERS; + } } -#endif /* BB_FEATURE_SH_COMMAND_EDITING */ + + + +#endif /* BB_FEATURE_SH_COMMAND_EDITING */