Patch from vodz:
[people/mcb30/busybox.git] / shell / cmdedit.c
1 /* vi: set sw=4 ts=4: */
2 /*
3  * Termios command line History and Editting.
4  *
5  * Copyright (c) 1986-2001 may safely be consumed by a BSD or GPL license.
6  * Written by:   Vladimir Oleynik <dzo@simtreas.ru>
7  *
8  * Used ideas:
9  *      Adam Rogoyski    <rogoyski@cs.utexas.edu>
10  *      Dave Cinege      <dcinege@psychosis.com>
11  *      Jakub Jelinek (c) 1995
12  *      Erik Andersen    <andersee@debian.org> (Majorly adjusted for busybox)
13  *
14  * This code is 'as is' with no warranty.
15  *
16  *
17  */
18
19 /*
20    Usage and Known bugs:
21    Terminal key codes are not extensive, and more will probably
22    need to be added. This version was created on Debian GNU/Linux 2.x.
23    Delete, Backspace, Home, End, and the arrow keys were tested
24    to work in an Xterm and console. Ctrl-A also works as Home.
25    Ctrl-E also works as End.
26
27    Small bugs (simple effect):
28    - not true viewing if terminal size (x*y symbols) less
29      size (prompt + editor`s line + 2 symbols)
30    - not true viewing if length prompt less terminal width
31  */
32
33
34 #include <stdio.h>
35 #include <errno.h>
36 #include <unistd.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <sys/ioctl.h>
40 #include <ctype.h>
41 #include <signal.h>
42 #include <limits.h>
43
44 #include "busybox.h"
45
46 #ifdef BB_LOCALE_SUPPORT
47 #define Isprint(c) isprint((c))
48 #else
49 #define Isprint(c) ( (c) >= ' ' && (c) != ((unsigned char)'\233') )
50 #endif
51
52 #ifndef TEST
53
54 #define D(x)
55
56 #else
57
58 #define BB_FEATURE_COMMAND_EDITING
59 #define BB_FEATURE_COMMAND_TAB_COMPLETION
60 #define BB_FEATURE_COMMAND_USERNAME_COMPLETION
61 #define BB_FEATURE_NONPRINTABLE_INVERSE_PUT
62 #define BB_FEATURE_CLEAN_UP
63
64 #define D(x)  x
65
66 #endif                                                  /* TEST */
67
68 #ifdef BB_FEATURE_COMMAND_TAB_COMPLETION
69 #include <dirent.h>
70 #include <sys/stat.h>
71 #endif
72
73 #ifdef BB_FEATURE_COMMAND_EDITING
74
75 #ifndef BB_FEATURE_COMMAND_TAB_COMPLETION
76 #undef  BB_FEATURE_COMMAND_USERNAME_COMPLETION
77 #endif
78
79 #if defined(BB_FEATURE_COMMAND_USERNAME_COMPLETION) || defined(BB_FEATURE_SH_FANCY_PROMPT)
80 #define BB_FEATURE_GETUSERNAME_AND_HOMEDIR
81 #endif
82
83 #ifdef BB_FEATURE_GETUSERNAME_AND_HOMEDIR
84 #       ifndef TEST
85 #               include "pwd_grp/pwd.h"
86 #       else
87 #               include <pwd.h>
88 #       endif  /* TEST */
89 #endif                                                  /* advanced FEATURES */
90
91
92
93 struct history {
94         char *s;
95         struct history *p;
96         struct history *n;
97 };
98
99 /* Maximum length of the linked list for the command line history */
100 static const int MAX_HISTORY = 15;
101
102 /* First element in command line list */
103 static struct history *his_front = NULL;
104
105 /* Last element in command line list */
106 static struct history *his_end = NULL;
107
108
109 #include <termios.h>
110 #define setTermSettings(fd,argp) tcsetattr(fd,TCSANOW,argp)
111 #define getTermSettings(fd,argp) tcgetattr(fd, argp);
112
113 /* Current termio and the previous termio before starting sh */
114 static struct termios initial_settings, new_settings;
115
116
117 static
118 volatile int cmdedit_termw = 80;        /* actual terminal width */
119 static int history_counter = 0; /* Number of commands in history list */
120 static
121 volatile int handlers_sets = 0; /* Set next bites: */
122
123 enum {
124         SET_ATEXIT = 1,         /* when atexit() has been called 
125                                    and get euid,uid,gid to fast compare */
126         SET_WCHG_HANDLERS = 2,  /* winchg signal handler */
127         SET_RESET_TERM = 4,     /* if the terminal needs to be reset upon exit */
128 };
129
130
131 static int cmdedit_x;           /* real x terminal position */
132 static int cmdedit_y;           /* pseudoreal y terminal position */
133 static int cmdedit_prmt_len;    /* lenght prompt without colores string */
134
135 static int cursor;              /* required global for signal handler */
136 static int len;                 /* --- "" - - "" - -"- --""-- --""--- */
137 static char *command_ps;        /* --- "" - - "" - -"- --""-- --""--- */
138 static
139 #ifndef BB_FEATURE_SH_FANCY_PROMPT
140         const
141 #endif
142 char *cmdedit_prompt;           /* --- "" - - "" - -"- --""-- --""--- */
143
144 #ifdef BB_FEATURE_GETUSERNAME_AND_HOMEDIR
145 static char *user_buf = "";
146 static char *home_pwd_buf = "";
147 static int my_euid;
148 #endif
149
150 #ifdef BB_FEATURE_SH_FANCY_PROMPT
151 static char *hostname_buf = "";
152 static int num_ok_lines = 1;
153 #endif
154
155
156 #ifdef  BB_FEATURE_COMMAND_TAB_COMPLETION
157
158 #ifndef BB_FEATURE_GETUSERNAME_AND_HOMEDIR
159 static int my_euid;
160 #endif
161
162 static int my_uid;
163 static int my_gid;
164
165 #endif  /* BB_FEATURE_COMMAND_TAB_COMPLETION */
166
167
168 static void cmdedit_setwidth(int w, int redraw_flg);
169
170 static void win_changed(int nsig)
171 {
172         struct winsize win = { 0, 0, 0, 0 };
173         static __sighandler_t previous_SIGWINCH_handler;        /* for reset */
174
175         /*   emulate      || signal call */
176         if (nsig == -SIGWINCH || nsig == SIGWINCH) {
177                 ioctl(0, TIOCGWINSZ, &win);
178                 if (win.ws_col > 0) {
179                         cmdedit_setwidth(win.ws_col, nsig == SIGWINCH);
180                 } 
181         }
182         /* Unix not all standart in recall signal */
183
184         if (nsig == -SIGWINCH)          /* save previous handler   */
185                 previous_SIGWINCH_handler = signal(SIGWINCH, win_changed);
186         else if (nsig == SIGWINCH)      /* signaled called handler */
187                 signal(SIGWINCH, win_changed);  /* set for next call       */
188         else                                            /* nsig == 0 */
189                 /* set previous handler    */
190                 signal(SIGWINCH, previous_SIGWINCH_handler);    /* reset    */
191 }
192
193 static void cmdedit_reset_term(void)
194 {
195         if ((handlers_sets & SET_RESET_TERM) != 0) {
196 /* sparc and other have broken termios support: use old termio handling. */
197                 setTermSettings(fileno(stdin), (void *) &initial_settings);
198                 handlers_sets &= ~SET_RESET_TERM;
199         }
200         if ((handlers_sets & SET_WCHG_HANDLERS) != 0) {
201                 /* reset SIGWINCH handler to previous (default) */
202                 win_changed(0);
203                 handlers_sets &= ~SET_WCHG_HANDLERS;
204         }
205         fflush(stdout);
206 #ifdef BB_FEATURE_CLEAN_UP
207         if (his_front) {
208                 struct history *n;
209
210                 while (his_front != his_end) {
211                         n = his_front->n;
212                         free(his_front->s);
213                         free(his_front);
214                         his_front = n;
215                 }
216         }
217 #endif
218 }
219
220
221 /* special for recount position for scroll and remove terminal margin effect */
222 static void cmdedit_set_out_char(int next_char)
223 {
224
225         int c = (int)((unsigned char) command_ps[cursor]);
226
227         if (c == 0)
228                 c = ' ';        /* destroy end char? */
229 #ifdef BB_FEATURE_NONPRINTABLE_INVERSE_PUT
230         if (!Isprint(c)) {      /* Inverse put non-printable characters */
231                 if (c >= 128)
232                         c -= 128;
233                 if (c < ' ')
234                         c += '@';
235                 if (c == 127)
236                         c = '?';
237                 printf("\033[7m%c\033[0m", c);
238         } else
239 #endif
240                 putchar(c);
241         if (++cmdedit_x >= cmdedit_termw) {
242                 /* terminal is scrolled down */
243                 cmdedit_y++;
244                 cmdedit_x = 0;
245
246                 if (!next_char)
247                         next_char = ' ';
248                 /* destroy "(auto)margin" */
249                 putchar(next_char);
250                 putchar('\b');
251         }
252         cursor++;
253 }
254
255 /* Move to end line. Bonus: rewrite line from cursor */
256 static void input_end(void)
257 {
258         while (cursor < len)
259                 cmdedit_set_out_char(0);
260 }
261
262 /* Go to the next line */
263 static void goto_new_line(void)
264 {
265         input_end();
266         if (cmdedit_x)
267                 putchar('\n');
268 }
269
270
271 static inline void out1str(const char *s)
272 {
273         fputs(s, stdout);
274 }
275 static inline void beep(void)
276 {
277         putchar('\007');
278 }
279
280 /* Move back one charactor */
281 /* special for slow terminal */
282 static void input_backward(int num)
283 {
284         if (num > cursor)
285                 num = cursor;
286         cursor -= num;          /* new cursor (in command, not terminal) */
287
288         if (cmdedit_x >= num) {         /* no to up line */
289                 cmdedit_x -= num;
290                 if (num < 4)
291                         while (num-- > 0)
292                                 putchar('\b');
293
294                 else
295                         printf("\033[%dD", num);
296         } else {
297                 int count_y;
298
299                 if (cmdedit_x) {
300                         putchar('\r');          /* back to first terminal pos.  */
301                         num -= cmdedit_x;       /* set previous backward        */
302                 }
303                 count_y = 1 + num / cmdedit_termw;
304                 printf("\033[%dA", count_y);
305                 cmdedit_y -= count_y;
306                 /*  require  forward  after  uping   */
307                 cmdedit_x = cmdedit_termw * count_y - num;
308                 printf("\033[%dC", cmdedit_x);  /* set term cursor   */
309         }
310 }
311
312 static void put_prompt(void)
313 {
314         out1str(cmdedit_prompt);
315         cmdedit_x = cmdedit_prmt_len;   /* count real x terminal position */
316         cursor = 0;
317         cmdedit_y = 0;                  /* new quasireal y */
318 }
319
320 #ifndef BB_FEATURE_SH_FANCY_PROMPT
321 static void parse_prompt(const char *prmt_ptr)
322 {
323         cmdedit_prompt = prmt_ptr;
324         cmdedit_prmt_len = strlen(prmt_ptr);
325         put_prompt();
326 }
327 #else
328 static void parse_prompt(const char *prmt_ptr)
329 {
330         int prmt_len = 0;
331         int sub_len = 0;
332         char  flg_not_length = '[';
333         char *prmt_mem_ptr = xcalloc(1, 1);
334         char *pwd_buf = xgetcwd(0);
335         char  buf2[PATH_MAX + 1];
336         char  buf[2];
337         char  c;
338         char *pbuf;
339
340         if (!pwd_buf) {
341                 pwd_buf=(char *)unknown;
342         }
343
344         while (*prmt_ptr) {
345                 pbuf    = buf;
346                 pbuf[1] = 0;
347                 c = *prmt_ptr++;
348                 if (c == '\\') {
349                         const char *cp = prmt_ptr;
350                         int l;
351                         
352                         c = process_escape_sequence(&prmt_ptr);
353                         if(prmt_ptr==cp) {
354                           if (*cp == 0)
355                                 break;
356                           c = *prmt_ptr++;
357                           switch (c) {
358 #ifdef BB_FEATURE_GETUSERNAME_AND_HOMEDIR
359                           case 'u':
360                                 pbuf = user_buf;
361                                 break;
362 #endif  
363                           case 'h':
364                                 pbuf = hostname_buf;
365                                 if (*pbuf == 0) {
366                                         pbuf = xcalloc(256, 1);
367                                         if (gethostname(pbuf, 255) < 0) {
368                                                 strcpy(pbuf, "?");
369                                         } else {
370                                                 char *s = strchr(pbuf, '.');
371
372                                                 if (s)
373                                                         *s = 0;
374                                         }
375                                         hostname_buf = pbuf;
376                                 }
377                                 break;
378                           case '$':
379                                 c = my_euid == 0 ? '#' : '$';
380                                 break;
381 #ifdef BB_FEATURE_GETUSERNAME_AND_HOMEDIR
382                           case 'w':
383                                 pbuf = pwd_buf;
384                                 l = strlen(home_pwd_buf);
385                                 if (home_pwd_buf[0] != 0 &&
386                                     strncmp(home_pwd_buf, pbuf, l) == 0 &&
387                                     (pbuf[l]=='/' || pbuf[l]=='\0') &&
388                                     strlen(pwd_buf+l)<PATH_MAX) {
389                                         pbuf = buf2;
390                                         *pbuf = '~';
391                                         strcpy(pbuf+1, pwd_buf+l);
392                                         }
393                                 break;
394 #endif  
395                           case 'W':
396                                 pbuf = pwd_buf;
397                                 cp = strrchr(pbuf,'/');
398                                 if ( (cp != NULL) && (cp != pbuf) )
399                                         pbuf += (cp-pbuf)+1;
400                                 break;
401                           case '!':
402                                 snprintf(pbuf = buf2, sizeof(buf2), "%d", num_ok_lines);
403                                 break;
404                           case 'e': case 'E':     /* \e \E = \033 */
405                                 c = '\033';
406                                 break;
407                           case 'x': case 'X': 
408                                 for (l = 0; l < 3;) {
409                                         int h;
410                                         buf2[l++] = *prmt_ptr;
411                                         buf2[l] = 0;
412                                         h = strtol(buf2, &pbuf, 16);
413                                         if (h > UCHAR_MAX || (pbuf - buf2) < l) {
414                                                 l--;
415                                                 break;
416                                         }
417                                         prmt_ptr++;
418                                 }
419                                 buf2[l] = 0;
420                                 c = (char)strtol(buf2, 0, 16);
421                                 if(c==0)
422                                         c = '?';
423                                 pbuf = buf;
424                                 break;
425                           case '[': case ']':
426                                 if (c == flg_not_length) {
427                                         flg_not_length = flg_not_length == '[' ? ']' : '[';
428                                         continue;
429                                 }
430                                 break;
431                           }
432                         } 
433                 }
434                 if(pbuf == buf)
435                         *pbuf = c;
436                 prmt_len += strlen(pbuf);
437                 prmt_mem_ptr = strcat(xrealloc(prmt_mem_ptr, prmt_len+1), pbuf);
438                 if (flg_not_length == ']')
439                         sub_len++;
440         }
441         if(pwd_buf!=(char *)unknown)
442                 free(pwd_buf);
443         cmdedit_prompt = prmt_mem_ptr;
444         cmdedit_prmt_len = prmt_len - sub_len;
445         put_prompt();
446 }
447 #endif
448
449
450 /* draw promt, editor line, and clear tail */
451 static void redraw(int y, int back_cursor)
452 {
453         if (y > 0)                              /* up to start y */
454                 printf("\033[%dA", y);
455         putchar('\r');
456         put_prompt();
457         input_end();                            /* rewrite */
458         printf("\033[J");                       /* destroy tail after cursor */
459         input_backward(back_cursor);
460 }
461
462 /* Delete the char in front of the cursor */
463 static void input_delete(void)
464 {
465         int j = cursor;
466
467         if (j == len)
468                 return;
469
470         strcpy(command_ps + j, command_ps + j + 1);
471         len--;
472         input_end();                    /* rewtite new line */
473         cmdedit_set_out_char(0);        /* destroy end char */
474         input_backward(cursor - j);     /* back to old pos cursor */
475 }
476
477 /* Delete the char in back of the cursor */
478 static void input_backspace(void)
479 {
480         if (cursor > 0) {
481                 input_backward(1);
482                 input_delete();
483         }
484 }
485
486
487 /* Move forward one charactor */
488 static void input_forward(void)
489 {
490         if (cursor < len)
491                 cmdedit_set_out_char(command_ps[cursor + 1]);
492 }
493
494
495 static void cmdedit_setwidth(int w, int redraw_flg)
496 {
497         cmdedit_termw = cmdedit_prmt_len + 2;
498         if (w <= cmdedit_termw) {
499                 cmdedit_termw = cmdedit_termw % w;
500         }
501         if (w > cmdedit_termw) {
502                 cmdedit_termw = w;
503
504                 if (redraw_flg) {
505                         /* new y for current cursor */
506                         int new_y = (cursor + cmdedit_prmt_len) / w;
507
508                         /* redraw */
509                         redraw((new_y >= cmdedit_y ? new_y : cmdedit_y), len - cursor);
510                         fflush(stdout);
511                 }
512         } 
513 }
514
515 static void cmdedit_init(void)
516 {
517         cmdedit_prmt_len = 0;
518         if ((handlers_sets & SET_WCHG_HANDLERS) == 0) {
519                 /* emulate usage handler to set handler and call yours work */
520                 win_changed(-SIGWINCH);
521                 handlers_sets |= SET_WCHG_HANDLERS;
522         }
523
524         if ((handlers_sets & SET_ATEXIT) == 0) {
525 #ifdef BB_FEATURE_GETUSERNAME_AND_HOMEDIR
526                 struct passwd *entry;
527
528                 my_euid = geteuid();
529                 entry = getpwuid(my_euid);
530                 if (entry) {
531                         user_buf = xstrdup(entry->pw_name);
532                         home_pwd_buf = xstrdup(entry->pw_dir);
533                 }
534 #endif
535
536 #ifdef  BB_FEATURE_COMMAND_TAB_COMPLETION
537
538 #ifndef BB_FEATURE_GETUSERNAME_AND_HOMEDIR
539                 my_euid = geteuid();
540 #endif
541                 my_uid = getuid();
542                 my_gid = getgid();
543 #endif  /* BB_FEATURE_COMMAND_TAB_COMPLETION */
544                 handlers_sets |= SET_ATEXIT;
545                 atexit(cmdedit_reset_term);     /* be sure to do this only once */
546         }
547 }
548
549 #ifdef BB_FEATURE_COMMAND_TAB_COMPLETION
550
551 static int is_execute(const struct stat *st)
552 {
553         if ((!my_euid && (st->st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))) ||
554                 (my_uid == st->st_uid && (st->st_mode & S_IXUSR)) ||
555                 (my_gid == st->st_gid && (st->st_mode & S_IXGRP)) ||
556                 (st->st_mode & S_IXOTH)) return TRUE;
557         return FALSE;
558 }
559
560 #ifdef BB_FEATURE_COMMAND_USERNAME_COMPLETION
561
562 static char **username_tab_completion(char *ud, int *num_matches)
563 {
564         struct passwd *entry;
565         int userlen;
566         char *temp;
567
568
569         ud++;                           /* ~user/... to user/... */
570         userlen = strlen(ud);
571
572         if (num_matches == 0) {         /* "~/..." or "~user/..." */
573                 char *sav_ud = ud - 1;
574                 char *home = 0;
575
576                 if (*ud == '/') {       /* "~/..."     */
577                         home = home_pwd_buf;
578                 } else {
579                         /* "~user/..." */
580                         temp = strchr(ud, '/');
581                         *temp = 0;              /* ~user\0 */
582                         entry = getpwnam(ud);
583                         *temp = '/';            /* restore ~user/... */
584                         ud = temp;
585                         if (entry)
586                                 home = entry->pw_dir;
587                 }
588                 if (home) {
589                         if ((userlen + strlen(home) + 1) < BUFSIZ) {
590                                 char temp2[BUFSIZ];     /* argument size */
591
592                                 /* /home/user/... */
593                                 sprintf(temp2, "%s%s", home, ud);
594                                 strcpy(sav_ud, temp2);
595                         }
596                 }
597                 return 0;       /* void, result save to argument :-) */
598         } else {
599                 /* "~[^/]*" */
600                 char **matches = (char **) NULL;
601                 int nm = 0;
602
603                 setpwent();
604
605                 while ((entry = getpwent()) != NULL) {
606                         /* Null usernames should result in all users as possible completions. */
607                         if ( /*!userlen || */ !strncmp(ud, entry->pw_name, userlen)) {
608
609                                 temp = xmalloc(3 + strlen(entry->pw_name));
610                                 sprintf(temp, "~%s/", entry->pw_name);
611                                 matches = xrealloc(matches, (nm + 1) * sizeof(char *));
612
613                                 matches[nm++] = temp;
614                         }
615                 }
616
617                 endpwent();
618                 (*num_matches) = nm;
619                 return (matches);
620         }
621 }
622 #endif  /* BB_FEATURE_COMMAND_USERNAME_COMPLETION */
623
624 enum {
625         FIND_EXE_ONLY = 0,
626         FIND_DIR_ONLY = 1,
627         FIND_FILE_ONLY = 2,
628 };
629
630 static int path_parse(char ***p, int flags)
631 {
632         int npth;
633         char *tmp;
634         char *pth;
635
636         /* if not setenv PATH variable, to search cur dir "." */
637         if (flags != FIND_EXE_ONLY || (pth = getenv("PATH")) == 0 ||
638                 /* PATH=<empty> or PATH=:<empty> */
639                 *pth == 0 || (*pth == ':' && *(pth + 1) == 0)) {
640                 return 1;
641         }
642
643         tmp = pth;
644         npth = 0;
645
646         for (;;) {
647                 npth++;                 /* count words is + 1 count ':' */
648                 tmp = strchr(tmp, ':');
649                 if (tmp) {
650                         if (*++tmp == 0)
651                                 break;  /* :<empty> */
652                 } else
653                         break;
654         }
655
656         *p = xmalloc(npth * sizeof(char *));
657
658         tmp = pth;
659         (*p)[0] = xstrdup(tmp);
660         npth = 1;                       /* count words is + 1 count ':' */
661
662         for (;;) {
663                 tmp = strchr(tmp, ':');
664                 if (tmp) {
665                         (*p)[0][(tmp - pth)] = 0;       /* ':' -> '\0' */
666                         if (*++tmp == 0)
667                                 break;                  /* :<empty> */
668                 } else
669                         break;
670                 (*p)[npth++] = &(*p)[0][(tmp - pth)];   /* p[next]=p[0][&'\0'+1] */
671         }
672
673         return npth;
674 }
675
676 static char *add_quote_for_spec_chars(char *found)
677 {
678         int l = 0;
679         char *s = xmalloc((strlen(found) + 1) * 2);
680
681         while (*found) {
682                 if (strchr(" `\"#$%^&*()=+{}[]:;\'|\\<>", *found))
683                         s[l++] = '\\';
684                 s[l++] = *found++;
685         }
686         s[l] = 0;
687         return s;
688 }
689
690 static char **exe_n_cwd_tab_completion(char *command, int *num_matches,
691                                         int type)
692 {
693
694         char **matches = 0;
695         DIR *dir;
696         struct dirent *next;
697         char dirbuf[BUFSIZ];
698         int nm = *num_matches;
699         struct stat st;
700         char *path1[1];
701         char **paths = path1;
702         int npaths;
703         int i;
704         char *found;
705         char *pfind = strrchr(command, '/');
706
707         path1[0] = ".";
708
709         if (pfind == NULL) {
710                 /* no dir, if flags==EXE_ONLY - get paths, else "." */
711                 npaths = path_parse(&paths, type);
712                 pfind = command;
713         } else {
714                 /* with dir */
715                 /* save for change */
716                 strcpy(dirbuf, command);
717                 /* set dir only */
718                 dirbuf[(pfind - command) + 1] = 0;
719 #ifdef BB_FEATURE_COMMAND_USERNAME_COMPLETION
720                 if (dirbuf[0] == '~')   /* ~/... or ~user/... */
721                         username_tab_completion(dirbuf, 0);
722 #endif
723                 /* "strip" dirname in command */
724                 pfind++;
725
726                 paths[0] = dirbuf;
727                 npaths = 1;                             /* only 1 dir */
728         }
729
730         for (i = 0; i < npaths; i++) {
731
732                 dir = opendir(paths[i]);
733                 if (!dir)                       /* Don't print an error */
734                         continue;
735
736                 while ((next = readdir(dir)) != NULL) {
737                         char *str_found = next->d_name;
738
739                         /* matched ? */
740                         if (strncmp(str_found, pfind, strlen(pfind)))
741                                 continue;
742                         /* not see .name without .match */
743                         if (*str_found == '.' && *pfind == 0) {
744                                 if (*paths[i] == '/' && paths[i][1] == 0
745                                         && str_found[1] == 0) str_found = "";   /* only "/" */
746                                 else
747                                         continue;
748                         }
749                         found = concat_path_file(paths[i], str_found);
750                         /* hmm, remover in progress? */
751                         if (stat(found, &st) < 0) 
752                                 goto cont;
753                         /* find with dirs ? */
754                         if (paths[i] != dirbuf)
755                                 strcpy(found, next->d_name);    /* only name */
756                         if (S_ISDIR(st.st_mode)) {
757                                 /* name is directory      */
758                                 str_found = found;
759                                 found = concat_path_file(found, "");
760                                 free(str_found);
761                                 str_found = add_quote_for_spec_chars(found);
762                         } else {
763                                 /* not put found file if search only dirs for cd */
764                                 if (type == FIND_DIR_ONLY) 
765                                         goto cont;
766                                 str_found = add_quote_for_spec_chars(found);
767                                 if (type == FIND_FILE_ONLY ||
768                                         (type == FIND_EXE_ONLY && is_execute(&st) == TRUE))
769                                         strcat(str_found, " ");
770                         }
771                         /* Add it to the list */
772                         matches = xrealloc(matches, (nm + 1) * sizeof(char *));
773
774                         matches[nm++] = str_found;
775 cont:
776                         free(found);
777                 }
778                 closedir(dir);
779         }
780         if (paths != path1) {
781                 free(paths[0]);                 /* allocated memory only in first member */
782                 free(paths);
783         }
784         *num_matches = nm;
785         return (matches);
786 }
787
788 static int match_compare(const void *a, const void *b)
789 {
790         return strcmp(*(char **) a, *(char **) b);
791 }
792
793
794
795 #define QUOT    (UCHAR_MAX+1)
796
797 #define collapse_pos(is, in) { \
798         memcpy(int_buf+is, int_buf+in, (BUFSIZ+1-is-in)*sizeof(int)); \
799         memcpy(pos_buf+is, pos_buf+in, (BUFSIZ+1-is-in)*sizeof(int)); }
800
801 static int find_match(char *matchBuf, int *len_with_quotes)
802 {
803         int i, j;
804         int command_mode;
805         int c, c2;
806         int int_buf[BUFSIZ + 1];
807         int pos_buf[BUFSIZ + 1];
808
809         /* set to integer dimension characters and own positions */
810         for (i = 0;; i++) {
811                 int_buf[i] = (int) ((unsigned char) matchBuf[i]);
812                 if (int_buf[i] == 0) {
813                         pos_buf[i] = -1;        /* indicator end line */
814                         break;
815                 } else
816                         pos_buf[i] = i;
817         }
818
819         /* mask \+symbol and convert '\t' to ' ' */
820         for (i = j = 0; matchBuf[i]; i++, j++)
821                 if (matchBuf[i] == '\\') {
822                         collapse_pos(j, j + 1);
823                         int_buf[j] |= QUOT;
824                         i++;
825 #ifdef BB_FEATURE_NONPRINTABLE_INVERSE_PUT
826                         if (matchBuf[i] == '\t')        /* algorithm equivalent */
827                                 int_buf[j] = ' ' | QUOT;
828 #endif
829                 }
830 #ifdef BB_FEATURE_NONPRINTABLE_INVERSE_PUT
831                 else if (matchBuf[i] == '\t')
832                         int_buf[j] = ' ';
833 #endif
834
835         /* mask "symbols" or 'symbols' */
836         c2 = 0;
837         for (i = 0; int_buf[i]; i++) {
838                 c = int_buf[i];
839                 if (c == '\'' || c == '"') {
840                         if (c2 == 0)
841                                 c2 = c;
842                         else {
843                                 if (c == c2)
844                                         c2 = 0;
845                                 else
846                                         int_buf[i] |= QUOT;
847                         }
848                 } else if (c2 != 0 && c != '$')
849                         int_buf[i] |= QUOT;
850         }
851
852         /* skip commands with arguments if line have commands delimiters */
853         /* ';' ';;' '&' '|' '&&' '||' but `>&' `<&' `>|' */
854         for (i = 0; int_buf[i]; i++) {
855                 c = int_buf[i];
856                 c2 = int_buf[i + 1];
857                 j = i ? int_buf[i - 1] : -1;
858                 command_mode = 0;
859                 if (c == ';' || c == '&' || c == '|') {
860                         command_mode = 1 + (c == c2);
861                         if (c == '&') {
862                                 if (j == '>' || j == '<')
863                                         command_mode = 0;
864                         } else if (c == '|' && j == '>')
865                                 command_mode = 0;
866                 }
867                 if (command_mode) {
868                         collapse_pos(0, i + command_mode);
869                         i = -1;                         /* hack incremet */
870                 }
871         }
872         /* collapse `command...` */
873         for (i = 0; int_buf[i]; i++)
874                 if (int_buf[i] == '`') {
875                         for (j = i + 1; int_buf[j]; j++)
876                                 if (int_buf[j] == '`') {
877                                         collapse_pos(i, j + 1);
878                                         j = 0;
879                                         break;
880                                 }
881                         if (j) {
882                                 /* not found close ` - command mode, collapse all previous */
883                                 collapse_pos(0, i + 1);
884                                 break;
885                         } else
886                                 i--;                    /* hack incremet */
887                 }
888
889         /* collapse (command...(command...)...) or {command...{command...}...} */
890         c = 0;                                          /* "recursive" level */
891         c2 = 0;
892         for (i = 0; int_buf[i]; i++)
893                 if (int_buf[i] == '(' || int_buf[i] == '{') {
894                         if (int_buf[i] == '(')
895                                 c++;
896                         else
897                                 c2++;
898                         collapse_pos(0, i + 1);
899                         i = -1;                         /* hack incremet */
900                 }
901         for (i = 0; pos_buf[i] >= 0 && (c > 0 || c2 > 0); i++)
902                 if ((int_buf[i] == ')' && c > 0) || (int_buf[i] == '}' && c2 > 0)) {
903                         if (int_buf[i] == ')')
904                                 c--;
905                         else
906                                 c2--;
907                         collapse_pos(0, i + 1);
908                         i = -1;                         /* hack incremet */
909                 }
910
911         /* skip first not quote space */
912         for (i = 0; int_buf[i]; i++)
913                 if (int_buf[i] != ' ')
914                         break;
915         if (i)
916                 collapse_pos(0, i);
917
918         /* set find mode for completion */
919         command_mode = FIND_EXE_ONLY;
920         for (i = 0; int_buf[i]; i++)
921                 if (int_buf[i] == ' ' || int_buf[i] == '<' || int_buf[i] == '>') {
922                         if (int_buf[i] == ' ' && command_mode == FIND_EXE_ONLY
923                                 && matchBuf[pos_buf[0]]=='c'
924                                 && matchBuf[pos_buf[1]]=='d' )
925                                 command_mode = FIND_DIR_ONLY;
926                         else {
927                                 command_mode = FIND_FILE_ONLY;
928                                 break;
929                         }
930                 }
931         /* "strlen" */
932         for (i = 0; int_buf[i]; i++);
933         /* find last word */
934         for (--i; i >= 0; i--) {
935                 c = int_buf[i];
936                 if (c == ' ' || c == '<' || c == '>' || c == '|' || c == '&') {
937                         collapse_pos(0, i + 1);
938                         break;
939                 }
940         }
941         /* skip first not quoted '\'' or '"' */
942         for (i = 0; int_buf[i] == '\'' || int_buf[i] == '"'; i++);
943         /* collapse quote or unquote // or /~ */
944         while ((int_buf[i] & ~QUOT) == '/' && 
945                         ((int_buf[i + 1] & ~QUOT) == '/'
946                          || (int_buf[i + 1] & ~QUOT) == '~')) {
947                 i++;
948         }
949
950         /* set only match and destroy quotes */
951         j = 0;
952         for (c = 0; pos_buf[i] >= 0; i++) {
953                 matchBuf[c++] = matchBuf[pos_buf[i]];
954                 j = pos_buf[i] + 1;
955         }
956         matchBuf[c] = 0;
957         /* old lenght matchBuf with quotes symbols */
958         *len_with_quotes = j ? j - pos_buf[0] : 0;
959
960         return command_mode;
961 }
962
963
964 static void input_tab(int *lastWasTab)
965 {
966         /* Do TAB completion */
967         static int num_matches;
968         static char **matches;
969
970         if (lastWasTab == 0) {          /* free all memory */
971                 if (matches) {
972                         while (num_matches > 0)
973                                 free(matches[--num_matches]);
974                         free(matches);
975                         matches = (char **) NULL;
976                 }
977                 return;
978         }
979         if (*lastWasTab == FALSE) {
980
981                 char *tmp;
982                 int len_found;
983                 char matchBuf[BUFSIZ];
984                 int find_type;
985                 int recalc_pos;
986
987                 *lastWasTab = TRUE;             /* flop trigger */
988
989                 /* Make a local copy of the string -- up
990                  * to the position of the cursor */
991                 tmp = strncpy(matchBuf, command_ps, cursor);
992                 tmp[cursor] = 0;
993
994                 find_type = find_match(matchBuf, &recalc_pos);
995
996                 /* Free up any memory already allocated */
997                 input_tab(0);
998
999 #ifdef BB_FEATURE_COMMAND_USERNAME_COMPLETION
1000                 /* If the word starts with `~' and there is no slash in the word,
1001                  * then try completing this word as a username. */
1002
1003                 if (matchBuf[0] == '~' && strchr(matchBuf, '/') == 0)
1004                         matches = username_tab_completion(matchBuf, &num_matches);
1005 #endif
1006                 /* Try to match any executable in our path and everything
1007                  * in the current working directory that matches.  */
1008                 if (!matches)
1009                         matches =
1010                                 exe_n_cwd_tab_completion(matchBuf,
1011                                         &num_matches, find_type);
1012                 /* Remove duplicate found */
1013                 if(matches) {
1014                         int i, j;
1015                         /* bubble */
1016                         for(i=0; i<(num_matches-1); i++)
1017                                 for(j=i+1; j<num_matches; j++)
1018                                         if(matches[i]!=0 && matches[j]!=0 &&
1019                                                 strcmp(matches[i], matches[j])==0) {
1020                                                         free(matches[j]);
1021                                                         matches[j]=0;
1022                                         }
1023                         j=num_matches;
1024                         num_matches = 0;
1025                         for(i=0; i<j; i++)
1026                                 if(matches[i]) {
1027                                         if(!strcmp(matches[i], "./"))
1028                                                 matches[i][1]=0;
1029                                         else if(!strcmp(matches[i], "../"))
1030                                                 matches[i][2]=0;
1031                                         matches[num_matches++]=matches[i];
1032                                 }
1033                 }
1034                 /* Did we find exactly one match? */
1035                 if (!matches || num_matches > 1) {
1036                         char *tmp1;
1037
1038                         beep();
1039                         if (!matches)
1040                                 return;         /* not found */
1041                         /* sort */
1042                         qsort(matches, num_matches, sizeof(char *), match_compare);
1043
1044                         /* find minimal match */
1045                         tmp = xstrdup(matches[0]);
1046                         for (tmp1 = tmp; *tmp1; tmp1++)
1047                                 for (len_found = 1; len_found < num_matches; len_found++)
1048                                         if (matches[len_found][(tmp1 - tmp)] != *tmp1) {
1049                                                 *tmp1 = 0;
1050                                                 break;
1051                                         }
1052                         if (*tmp == 0) {        /* have unique */
1053                                 free(tmp);
1054                                 return;
1055                         }
1056                 } else {                        /* one match */
1057                         tmp = matches[0];
1058                         /* for next completion current found */
1059                         *lastWasTab = FALSE;
1060                 }
1061
1062                 len_found = strlen(tmp);
1063                 /* have space to placed match? */
1064                 if ((len_found - strlen(matchBuf) + len) < BUFSIZ) {
1065
1066                         /* before word for match   */
1067                         command_ps[cursor - recalc_pos] = 0;
1068                         /* save   tail line        */
1069                         strcpy(matchBuf, command_ps + cursor);
1070                         /* add    match            */
1071                         strcat(command_ps, tmp);
1072                         /* add    tail             */
1073                         strcat(command_ps, matchBuf);
1074                         /* back to begin word for match    */
1075                         input_backward(recalc_pos);
1076                         /* new pos                         */
1077                         recalc_pos = cursor + len_found;
1078                         /* new len                         */
1079                         len = strlen(command_ps);
1080                         /* write out the matched command   */
1081                         redraw(cmdedit_y, len - recalc_pos);
1082                 }
1083                 if (tmp != matches[0])
1084                         free(tmp);
1085         } else {
1086                 /* Ok -- the last char was a TAB.  Since they
1087                  * just hit TAB again, print a list of all the
1088                  * available choices... */
1089                 if (matches && num_matches > 0) {
1090                         int i, col, l;
1091                         int sav_cursor = cursor;        /* change goto_new_line() */
1092
1093                         /* Go to the next line */
1094                         goto_new_line();
1095                         for (i = 0, col = 0; i < num_matches; i++) {
1096                                 l = strlen(matches[i]);
1097                                 if (l < 14)
1098                                         l = 14;
1099                                 printf("%-14s  ", matches[i]);
1100                                 if ((l += 2) > 16)
1101                                         while (l % 16) {
1102                                                 putchar(' ');
1103                                                 l++;
1104                                         }
1105                                 col += l;
1106                                 col -= (col / cmdedit_termw) * cmdedit_termw;
1107                                 if (col > 60 && matches[i + 1] != NULL) {
1108                                         putchar('\n');
1109                                         col = 0;
1110                                 }
1111                         }
1112                         /* Go to the next line and rewrite */
1113                         putchar('\n');
1114                         redraw(0, len - sav_cursor);
1115                 }
1116         }
1117 }
1118 #endif  /* BB_FEATURE_COMMAND_TAB_COMPLETION */
1119
1120 static void get_previous_history(struct history **hp, struct history *p)
1121 {
1122         if ((*hp)->s)
1123                 free((*hp)->s);
1124         (*hp)->s = xstrdup(command_ps);
1125         *hp = p;
1126 }
1127
1128 static inline void get_next_history(struct history **hp)
1129 {
1130         get_previous_history(hp, (*hp)->n);
1131 }
1132
1133 enum {
1134         ESC = 27,
1135         DEL = 127,
1136 };
1137
1138
1139 /*
1140  * This function is used to grab a character buffer
1141  * from the input file descriptor and allows you to
1142  * a string with full command editing (sortof like
1143  * a mini readline).
1144  *
1145  * The following standard commands are not implemented:
1146  * ESC-b -- Move back one word
1147  * ESC-f -- Move forward one word
1148  * ESC-d -- Delete back one word
1149  * ESC-h -- Delete forward one word
1150  * CTL-t -- Transpose two characters
1151  *
1152  * Furthermore, the "vi" command editing keys are not implemented.
1153  *
1154  */
1155  
1156 extern void cmdedit_read_input(char *prompt, char command[BUFSIZ])
1157 {
1158
1159         int break_out = 0;
1160         int lastWasTab = FALSE;
1161         unsigned char c = 0;
1162         struct history *hp = his_end;
1163
1164         /* prepare before init handlers */
1165         cmdedit_y = 0;  /* quasireal y, not true work if line > xt*yt */
1166         len = 0;
1167         command_ps = command;
1168
1169         if (new_settings.c_cc[VERASE] == 0) {     /* first call */
1170
1171                 getTermSettings(0, (void *) &initial_settings);
1172                 memcpy(&new_settings, &initial_settings, sizeof(struct termios));
1173                 new_settings.c_lflag &= ~ICANON;        /* unbuffered input */
1174                 /* Turn off echoing and CTRL-C, so we can trap it */
1175                 new_settings.c_lflag &= ~(ECHO | ECHONL | ISIG);
1176 #ifndef linux
1177                 /* Hmm, in linux c_cc[] not parsed if set ~ICANON */
1178                 new_settings.c_cc[VMIN] = 1;
1179                 new_settings.c_cc[VTIME] = 0;
1180                 /* Turn off CTRL-C, so we can trap it */
1181 #       ifndef _POSIX_VDISABLE
1182 #               define _POSIX_VDISABLE '\0'
1183 #       endif
1184                 new_settings.c_cc[VINTR] = _POSIX_VDISABLE;     
1185 #endif
1186         }
1187
1188         command[0] = 0;
1189
1190         setTermSettings(0, (void *) &new_settings);
1191         handlers_sets |= SET_RESET_TERM;
1192
1193         /* Now initialize things */
1194         cmdedit_init();
1195         /* Print out the command prompt */
1196         parse_prompt(prompt);
1197
1198         while (1) {
1199
1200                 fflush(stdout);                 /* buffered out to fast */
1201
1202                 if (safe_read(0, &c, 1) < 1)
1203                         /* if we can't read input then exit */
1204                         goto prepare_to_die;
1205
1206                 switch (c) {
1207                 case '\n':
1208                 case '\r':
1209                         /* Enter */
1210                         goto_new_line();
1211                         break_out = 1;
1212                         break;
1213                 case 1:
1214                         /* Control-a -- Beginning of line */
1215                         input_backward(cursor);
1216                         break;
1217                 case 2:
1218                         /* Control-b -- Move back one character */
1219                         input_backward(1);
1220                         break;
1221                 case 3:
1222                         /* Control-c -- stop gathering input */
1223                         goto_new_line();
1224                         command[0] = 0;
1225                         len = 0;
1226                         lastWasTab = FALSE;
1227                         put_prompt();
1228                         break;
1229                 case 4:
1230                         /* Control-d -- Delete one character, or exit
1231                          * if the len=0 and no chars to delete */
1232                         if (len == 0) {
1233 prepare_to_die:
1234                                 printf("exit");
1235                                 goto_new_line();
1236                                 /* cmdedit_reset_term() called in atexit */
1237                                 exit(EXIT_SUCCESS);
1238                         } else {
1239                                 input_delete();
1240                         }
1241                         break;
1242                 case 5:
1243                         /* Control-e -- End of line */
1244                         input_end();
1245                         break;
1246                 case 6:
1247                         /* Control-f -- Move forward one character */
1248                         input_forward();
1249                         break;
1250                 case '\b':
1251                 case DEL:
1252                         /* Control-h and DEL */
1253                         input_backspace();
1254                         break;
1255                 case '\t':
1256 #ifdef BB_FEATURE_COMMAND_TAB_COMPLETION
1257                         input_tab(&lastWasTab);
1258 #endif
1259                         break;
1260                 case 14:
1261                         /* Control-n -- Get next command in history */
1262                         if (hp && hp->n && hp->n->s) {
1263                                 get_next_history(&hp);
1264                                 goto rewrite_line;
1265                         } else {
1266                                 beep();
1267                         }
1268                         break;
1269                 case 16:
1270                         /* Control-p -- Get previous command from history */
1271                         if (hp && hp->p) {
1272                                 get_previous_history(&hp, hp->p);
1273                                 goto rewrite_line;
1274                         } else {
1275                                 beep();
1276                         }
1277                         break;
1278                 case 21:
1279                         /* Control-U -- Clear line before cursor */
1280                         if (cursor) {
1281                                 strcpy(command, command + cursor);
1282                                 redraw(cmdedit_y, len -= cursor);
1283                         }
1284                         break;
1285
1286                 case ESC:{
1287                         /* escape sequence follows */
1288                         if (safe_read(0, &c, 1) < 1)
1289                                 goto prepare_to_die;
1290                         /* different vt100 emulations */
1291                         if (c == '[' || c == 'O') {
1292                                 if (safe_read(0, &c, 1) < 1)
1293                                         goto prepare_to_die;
1294                         }
1295                         switch (c) {
1296 #ifdef BB_FEATURE_COMMAND_TAB_COMPLETION
1297                         case '\t':                      /* Alt-Tab */
1298
1299                                 input_tab(&lastWasTab);
1300                                 break;
1301 #endif
1302                         case 'A':
1303                                 /* Up Arrow -- Get previous command from history */
1304                                 if (hp && hp->p) {
1305                                         get_previous_history(&hp, hp->p);
1306                                         goto rewrite_line;
1307                                 } else {
1308                                         beep();
1309                                 }
1310                                 break;
1311                         case 'B':
1312                                 /* Down Arrow -- Get next command in history */
1313                                 if (hp && hp->n && hp->n->s) {
1314                                         get_next_history(&hp);
1315                                         goto rewrite_line;
1316                                 } else {
1317                                         beep();
1318                                 }
1319                                 break;
1320
1321                                 /* Rewrite the line with the selected history item */
1322                           rewrite_line:
1323                                 /* change command */
1324                                 len = strlen(strcpy(command, hp->s));
1325                                 /* redraw and go to end line */
1326                                 redraw(cmdedit_y, 0);
1327                                 break;
1328                         case 'C':
1329                                 /* Right Arrow -- Move forward one character */
1330                                 input_forward();
1331                                 break;
1332                         case 'D':
1333                                 /* Left Arrow -- Move back one character */
1334                                 input_backward(1);
1335                                 break;
1336                         case '3':
1337                                 /* Delete */
1338                                 input_delete();
1339                                 break;
1340                         case '1':
1341                         case 'H':
1342                                 /* Home (Ctrl-A) */
1343                                 input_backward(cursor);
1344                                 break;
1345                         case '4':
1346                         case 'F':
1347                                 /* End (Ctrl-E) */
1348                                 input_end();
1349                                 break;
1350                         default:
1351                                 if (!(c >= '1' && c <= '9'))
1352                                         c = 0;
1353                                 beep();
1354                         }
1355                         if (c >= '1' && c <= '9')
1356                                 do
1357                                         if (safe_read(0, &c, 1) < 1)
1358                                                 goto prepare_to_die;
1359                                 while (c != '~');
1360                         break;
1361                 }
1362
1363                 default:        /* If it's regular input, do the normal thing */
1364 #ifdef BB_FEATURE_NONPRINTABLE_INVERSE_PUT
1365                         /* Control-V -- Add non-printable symbol */
1366                         if (c == 22) {
1367                                 if (safe_read(0, &c, 1) < 1)
1368                                         goto prepare_to_die;
1369                                 if (c == 0) {
1370                                         beep();
1371                                         break;
1372                                 }
1373                         } else
1374 #endif
1375                         if (!Isprint(c))        /* Skip non-printable characters */
1376                                 break;
1377
1378                         if (len >= (BUFSIZ - 2))        /* Need to leave space for enter */
1379                                 break;
1380
1381                         len++;
1382
1383                         if (cursor == (len - 1)) {      /* Append if at the end of the line */
1384                                 *(command + cursor) = c;
1385                                 *(command + cursor + 1) = 0;
1386                                 cmdedit_set_out_char(0);
1387                         } else {                        /* Insert otherwise */
1388                                 int sc = cursor;
1389
1390                                 memmove(command + sc + 1, command + sc, len - sc);
1391                                 *(command + sc) = c;
1392                                 sc++;
1393                                 /* rewrite from cursor */
1394                                 input_end();
1395                                 /* to prev x pos + 1 */
1396                                 input_backward(cursor - sc);
1397                         }
1398
1399                         break;
1400                 }
1401                 if (break_out)                  /* Enter is the command terminator, no more input. */
1402                         break;
1403
1404                 if (c != '\t')
1405                         lastWasTab = FALSE;
1406         }
1407
1408         setTermSettings(0, (void *) &initial_settings);
1409         handlers_sets &= ~SET_RESET_TERM;
1410
1411         /* Handle command history log */
1412         if (len) {                                      /* no put empty line */
1413
1414                 struct history *h = his_end;
1415                 char *ss;
1416
1417                 ss = xstrdup(command);  /* duplicate */
1418
1419                 if (h == 0) {
1420                         /* No previous history -- this memory is never freed */
1421                         h = his_front = xmalloc(sizeof(struct history));
1422                         h->n = xmalloc(sizeof(struct history));
1423
1424                         h->p = NULL;
1425                         h->s = ss;
1426                         h->n->p = h;
1427                         h->n->n = NULL;
1428                         h->n->s = NULL;
1429                         his_end = h->n;
1430                         history_counter++;
1431                 } else {
1432                         /* Add a new history command -- this memory is never freed */
1433                         h->n = xmalloc(sizeof(struct history));
1434
1435                         h->n->p = h;
1436                         h->n->n = NULL;
1437                         h->n->s = NULL;
1438                         h->s = ss;
1439                         his_end = h->n;
1440
1441                         /* After max history, remove the oldest command */
1442                         if (history_counter >= MAX_HISTORY) {
1443
1444                                 struct history *p = his_front->n;
1445
1446                                 p->p = NULL;
1447                                 free(his_front->s);
1448                                 free(his_front);
1449                                 his_front = p;
1450                         } else {
1451                                 history_counter++;
1452                         }
1453                 }
1454 #if defined(BB_FEATURE_SH_FANCY_PROMPT)
1455                 num_ok_lines++;
1456 #endif
1457         }
1458         command[len++] = '\n';          /* set '\n' */
1459         command[len] = 0;
1460 #if defined(BB_FEATURE_CLEAN_UP) && defined(BB_FEATURE_COMMAND_TAB_COMPLETION)
1461         input_tab(0);                           /* strong free */
1462 #endif
1463 #if defined(BB_FEATURE_SH_FANCY_PROMPT)
1464         free(cmdedit_prompt);
1465 #endif
1466         cmdedit_reset_term();
1467 }
1468
1469
1470
1471 #endif  /* BB_FEATURE_COMMAND_EDITING */
1472
1473
1474 #ifdef TEST
1475
1476 const char *applet_name = "debug stuff usage";
1477 const char *memory_exhausted = "Memory exhausted";
1478
1479 #ifdef BB_FEATURE_NONPRINTABLE_INVERSE_PUT
1480 #include <locale.h>
1481 #endif
1482
1483 int main(int argc, char **argv)
1484 {
1485         char buff[BUFSIZ];
1486         char *prompt =
1487 #if defined(BB_FEATURE_SH_FANCY_PROMPT)
1488                 "\\[\\033[32;1m\\]\\u@\\[\\x1b[33;1m\\]\\h:\
1489 \\[\\033[34;1m\\]\\w\\[\\033[35;1m\\] \
1490 \\!\\[\\e[36;1m\\]\\$ \\[\\E[0m\\]";
1491 #else
1492                 "% ";
1493 #endif
1494
1495 #ifdef BB_FEATURE_NONPRINTABLE_INVERSE_PUT
1496         setlocale(LC_ALL, "");
1497 #endif
1498         while(1) {
1499                 int l;
1500                 cmdedit_read_input(prompt, buff);
1501                 l = strlen(buff);
1502                 if(l==0)
1503                         break;
1504                 if(l > 0 && buff[l-1] == '\n')
1505                         buff[l-1] = 0;
1506                 printf("*** cmdedit_read_input() returned line =%s=\n", buff);
1507         }
1508         printf("*** cmdedit_read_input() detect ^C\n");
1509         return 0;
1510 }
1511
1512 #endif  /* TEST */