1 /* vi: set sw=4 ts=4: */
3 * Command line editing.
5 * Copyright (c) 1986-2003 may safely be consumed by a BSD or GPL license.
6 * Written by: Vladimir Oleynik <dzo@simtreas.ru>
9 * Adam Rogoyski <rogoyski@cs.utexas.edu>
10 * Dave Cinege <dcinege@psychosis.com>
11 * Jakub Jelinek (c) 1995
12 * Erik Andersen <andersen@codepoet.org> (Majorly adjusted for busybox)
14 * This code is 'as is' with no warranty.
18 * Usage and known bugs:
19 * Terminal key codes are not extensive, more needs to be added.
20 * This version was created on Debian GNU/Linux 2.x.
21 * Delete, Backspace, Home, End, and the arrow keys were tested
22 * to work in an Xterm and console. Ctrl-A also works as Home.
23 * Ctrl-E also works as End.
25 * The following readline-like commands are not implemented:
26 * ESC-b -- Move back one word
27 * ESC-f -- Move forward one word
28 * ESC-d -- Delete forward one word
29 * CTL-t -- Transpose two characters
31 * lineedit does not know that the terminal escape sequences do not
32 * take up space on the screen. The redisplay code assumes, unless
33 * told otherwise, that each character in the prompt is a printable
34 * character that takes up one character position on the screen.
35 * You need to tell lineedit that some sequences of characters
36 * in the prompt take up no screen space. Compatibly with readline,
37 * use the \[ escape to begin a sequence of non-printing characters,
38 * and the \] escape to signal the end of such a sequence. Example:
40 * PS1='\[\033[01;32m\]\u@\h\[\033[01;34m\] \w \$\[\033[00m\] '
44 #ifndef _POSIX_VDISABLE
45 # define _POSIX_VDISABLE '\0'
50 # define ENABLE_FEATURE_EDITING 0
51 # define ENABLE_FEATURE_TAB_COMPLETION 0
52 # define ENABLE_FEATURE_USERNAME_COMPLETION 0
56 /* Entire file (except TESTing part) sits inside this #if */
57 #if ENABLE_FEATURE_EDITING
60 #define ENABLE_USERNAME_OR_HOMEDIR \
61 (ENABLE_FEATURE_USERNAME_COMPLETION || ENABLE_FEATURE_EDITING_FANCY_PROMPT)
62 #define IF_USERNAME_OR_HOMEDIR(...)
63 #if ENABLE_USERNAME_OR_HOMEDIR
64 # undef IF_USERNAME_OR_HOMEDIR
65 # define IF_USERNAME_OR_HOMEDIR(...) __VA_ARGS__
70 #if ENABLE_UNICODE_SUPPORT
71 # define BB_NUL ((wchar_t)0)
72 # define CHAR_T wchar_t
73 static bool BB_isspace(CHAR_T c
) { return ((unsigned)c
< 256 && isspace(c
)); }
74 # if ENABLE_FEATURE_EDITING_VI
75 static bool BB_isalnum(CHAR_T c
) { return ((unsigned)c
< 256 && isalnum(c
)); }
77 static bool BB_ispunct(CHAR_T c
) { return ((unsigned)c
< 256 && ispunct(c
)); }
82 # define isspace isspace_must_not_be_used
83 # define isalnum isalnum_must_not_be_used
84 # define ispunct ispunct_must_not_be_used
85 # define isprint isprint_must_not_be_used
89 # define BB_isspace(c) isspace(c)
90 # define BB_isalnum(c) isalnum(c)
91 # define BB_ispunct(c) ispunct(c)
93 #if ENABLE_UNICODE_PRESERVE_BROKEN
94 # define unicode_mark_raw_byte(wc) ((wc) | 0x20000000)
95 # define unicode_is_raw_byte(wc) ((wc) & 0x20000000)
97 # define unicode_is_raw_byte(wc) 0
103 #define SEQ_CLEAR_TILL_END_OF_SCREEN ESC"[J"
104 //#define SEQ_CLEAR_TILL_END_OF_LINE ESC"[K"
108 MAX_LINELEN
= CONFIG_FEATURE_EDITING_MAX_LEN
< 0x7ff0
109 ? CONFIG_FEATURE_EDITING_MAX_LEN
113 #if ENABLE_USERNAME_OR_HOMEDIR
114 static const char null_str
[] ALIGN1
= "";
117 /* We try to minimize both static and stack usage. */
118 struct lineedit_statics
{
121 volatile unsigned cmdedit_termw
; /* = 80; */ /* actual terminal width */
122 sighandler_t previous_SIGWINCH_handler
;
124 unsigned cmdedit_x
; /* real x (col) terminal position */
125 unsigned cmdedit_y
; /* pseudoreal y (row) terminal position */
126 unsigned cmdedit_prmt_len
; /* length of prompt (without colors etc) */
129 int command_len
; /* must be signed */
130 /* signed maxsize: we want x in "if (x > S.maxsize)"
131 * to _not_ be promoted to unsigned */
135 const char *cmdedit_prompt
;
136 #if ENABLE_FEATURE_EDITING_FANCY_PROMPT
137 int num_ok_lines
; /* = 1; */
140 #if ENABLE_USERNAME_OR_HOMEDIR
142 char *home_pwd_buf
; /* = (char*)null_str; */
145 #if ENABLE_FEATURE_TAB_COMPLETION
147 unsigned num_matches
;
150 #if ENABLE_FEATURE_EDITING_VI
151 # define DELBUFSIZ 128
153 smallint newdelflag
; /* whether delbuf should be reused yet */
154 CHAR_T delbuf
[DELBUFSIZ
]; /* a place to store deleted characters */
156 #if ENABLE_FEATURE_EDITING_ASK_TERMINAL
157 smallint sent_ESC_br6n
;
161 /* See lineedit_ptr_hack.c */
162 extern struct lineedit_statics
*const lineedit_ptr_to_statics
;
164 #define S (*lineedit_ptr_to_statics)
165 #define state (S.state )
166 #define cmdedit_termw (S.cmdedit_termw )
167 #define previous_SIGWINCH_handler (S.previous_SIGWINCH_handler)
168 #define cmdedit_x (S.cmdedit_x )
169 #define cmdedit_y (S.cmdedit_y )
170 #define cmdedit_prmt_len (S.cmdedit_prmt_len)
171 #define cursor (S.cursor )
172 #define command_len (S.command_len )
173 #define command_ps (S.command_ps )
174 #define cmdedit_prompt (S.cmdedit_prompt )
175 #define num_ok_lines (S.num_ok_lines )
176 #define user_buf (S.user_buf )
177 #define home_pwd_buf (S.home_pwd_buf )
178 #define matches (S.matches )
179 #define num_matches (S.num_matches )
180 #define delptr (S.delptr )
181 #define newdelflag (S.newdelflag )
182 #define delbuf (S.delbuf )
184 #define INIT_S() do { \
185 (*(struct lineedit_statics**)&lineedit_ptr_to_statics) = xzalloc(sizeof(S)); \
187 cmdedit_termw = 80; \
188 IF_FEATURE_EDITING_FANCY_PROMPT(num_ok_lines = 1;) \
189 IF_USERNAME_OR_HOMEDIR(home_pwd_buf = (char*)null_str;) \
192 static void deinit_S(void)
194 #if ENABLE_FEATURE_EDITING_FANCY_PROMPT
195 /* This one is allocated only if FANCY_PROMPT is on
196 * (otherwise it points to verbatim prompt (NOT malloced)) */
197 free((char*)cmdedit_prompt
);
199 #if ENABLE_USERNAME_OR_HOMEDIR
201 if (home_pwd_buf
!= null_str
)
204 free(lineedit_ptr_to_statics
);
206 #define DEINIT_S() deinit_S()
209 #if ENABLE_UNICODE_SUPPORT
210 static size_t load_string(const char *src
)
212 if (unicode_status
== UNICODE_ON
) {
213 ssize_t len
= mbstowcs(command_ps
, src
, S
.maxsize
- 1);
216 command_ps
[len
] = BB_NUL
;
220 while (src
[i
] && i
< S
.maxsize
- 1) {
221 command_ps
[i
] = src
[i
];
224 command_ps
[i
] = BB_NUL
;
228 static unsigned save_string(char *dst
, unsigned maxsize
)
230 if (unicode_status
== UNICODE_ON
) {
231 # if !ENABLE_UNICODE_PRESERVE_BROKEN
232 ssize_t len
= wcstombs(dst
, command_ps
, maxsize
- 1);
242 while (dstpos
< maxsize
) {
246 /* Convert up to 1st invalid byte (or up to end) */
247 while ((wc
= command_ps
[srcpos
]) != BB_NUL
248 && !unicode_is_raw_byte(wc
)
252 command_ps
[srcpos
] = BB_NUL
;
253 n
= wcstombs(dst
+ dstpos
, command_ps
+ n
, maxsize
- dstpos
);
254 if (n
< 0) /* should not happen */
257 if (wc
== BB_NUL
) /* usually is */
260 /* We do have invalid byte here! */
261 command_ps
[srcpos
] = wc
; /* restore it */
263 if (dstpos
== maxsize
)
265 dst
[dstpos
++] = (char) wc
;
272 while ((dst
[i
] = command_ps
[i
]) != 0)
277 /* I thought just fputwc(c, stdout) would work. But no... */
278 static void BB_PUTCHAR(wchar_t c
)
280 if (unicode_status
== UNICODE_ON
) {
281 char buf
[MB_CUR_MAX
+ 1];
282 mbstate_t mbst
= { 0 };
283 ssize_t len
= wcrtomb(buf
, c
, &mbst
);
289 /* In this case, c is always one byte */
293 # if ENABLE_UNICODE_COMBINING_WCHARS || ENABLE_UNICODE_WIDE_WCHARS
294 static wchar_t adjust_width_and_validate_wc(unsigned *width_adj
, wchar_t wc
)
296 static wchar_t adjust_width_and_validate_wc(wchar_t wc
)
297 # define adjust_width_and_validate_wc(width_adj, wc) \
298 ((*(width_adj))++, adjust_width_and_validate_wc(wc))
303 if (unicode_status
== UNICODE_ON
) {
304 if (wc
> CONFIG_LAST_SUPPORTED_WCHAR
) {
305 /* note: also true for unicode_is_raw_byte(wc) */
309 if ((ENABLE_UNICODE_COMBINING_WCHARS
&& w
< 0)
310 || (!ENABLE_UNICODE_COMBINING_WCHARS
&& w
<= 0)
311 || (!ENABLE_UNICODE_WIDE_WCHARS
&& w
> 1)
315 wc
= CONFIG_SUBST_WCHAR
;
319 # if ENABLE_UNICODE_COMBINING_WCHARS || ENABLE_UNICODE_WIDE_WCHARS
325 static size_t load_string(const char *src
)
327 safe_strncpy(command_ps
, src
, S
.maxsize
);
328 return strlen(command_ps
);
330 # if ENABLE_FEATURE_TAB_COMPLETION
331 static void save_string(char *dst
, unsigned maxsize
)
333 safe_strncpy(dst
, command_ps
, maxsize
);
336 # define BB_PUTCHAR(c) bb_putchar(c)
337 /* Should never be called: */
338 int adjust_width_and_validate_wc(unsigned *width_adj
, int wc
);
342 /* Put 'command_ps[cursor]', cursor++.
343 * Advance cursor on screen. If we reached right margin, scroll text up
344 * and remove terminal margin effect by printing 'next_char' */
345 #define HACK_FOR_WRONG_WIDTH 1
346 static void put_cur_glyph_and_inc_cursor(void)
348 CHAR_T c
= command_ps
[cursor
];
353 /* erase character after end of input string */
356 /* advance cursor only if we aren't at the end yet */
358 if (unicode_status
== UNICODE_ON
) {
359 IF_UNICODE_WIDE_WCHARS(width
= cmdedit_x
;)
360 c
= adjust_width_and_validate_wc(&cmdedit_x
, c
);
361 IF_UNICODE_WIDE_WCHARS(width
= cmdedit_x
- width
;)
367 ofs_to_right
= cmdedit_x
- cmdedit_termw
;
368 if (!ENABLE_UNICODE_WIDE_WCHARS
|| ofs_to_right
<= 0) {
369 /* c fits on this line */
373 if (ofs_to_right
>= 0) {
374 /* we go to the next line */
375 #if HACK_FOR_WRONG_WIDTH
376 /* This works better if our idea of term width is wrong
377 * and it is actually wider (often happens on serial lines).
378 * Printing CR,LF *forces* cursor to next line.
379 * OTOH if terminal width is correct AND terminal does NOT
380 * have automargin (IOW: it is moving cursor to next line
381 * by itself (which is wrong for VT-10x terminals)),
382 * this will break things: there will be one extra empty line */
383 puts("\r"); /* + implicit '\n' */
385 /* VT-10x terminals don't wrap cursor to next line when last char
386 * on the line is printed - cursor stays "over" this char.
387 * Need to print _next_ char too (first one to appear on next line)
388 * to make cursor move down to next line.
390 /* Works ok only if cmdedit_termw is correct. */
391 c
= command_ps
[cursor
];
398 if (!ENABLE_UNICODE_WIDE_WCHARS
|| ofs_to_right
== 0) {
400 } else { /* ofs_to_right > 0 */
401 /* wide char c didn't fit on prev line */
408 /* Move to end of line (by printing all chars till the end) */
409 static void put_till_end_and_adv_cursor(void)
411 while (cursor
< command_len
)
412 put_cur_glyph_and_inc_cursor();
415 /* Go to the next line */
416 static void goto_new_line(void)
418 put_till_end_and_adv_cursor();
423 static void beep(void)
428 static void put_prompt(void)
432 fputs(cmdedit_prompt
, stdout
);
435 w
= cmdedit_termw
; /* read volatile var once */
436 cmdedit_y
= cmdedit_prmt_len
/ w
; /* new quasireal y */
437 cmdedit_x
= cmdedit_prmt_len
% w
;
440 /* Move back one character */
441 /* (optimized for slow terminals) */
442 static void input_backward(unsigned num
)
450 if ((ENABLE_UNICODE_COMBINING_WCHARS
|| ENABLE_UNICODE_WIDE_WCHARS
)
451 && unicode_status
== UNICODE_ON
453 /* correct NUM to be equal to _screen_ width */
457 adjust_width_and_validate_wc(&num
, command_ps
[cursor
+ n
]);
462 if (cmdedit_x
>= num
) {
465 /* This is longer by 5 bytes on x86.
466 * Also gets miscompiled for ARM users
467 * (busybox.net/bugs/view.php?id=2274).
468 * printf(("\b\b\b\b" + 4) - num);
476 printf(ESC
"[%uD", num
);
480 /* Need to go one or more lines up */
481 if (ENABLE_UNICODE_WIDE_WCHARS
) {
482 /* With wide chars, it is hard to "backtrack"
483 * and reliably figure out where to put cursor.
484 * Example (<> is a wide char; # is an ordinary char, _ cursor):
488 * and user presses left arrow. num = 1, cmdedit_x = 0,
489 * We need to go up one line, and then - how do we know that
490 * we need to go *10* positions to the right? Because
494 * in this situation we need to go *11* positions to the right.
496 * A simpler thing to do is to redraw everything from the start
497 * up to new cursor position (which is already known):
500 /* go to 1st column; go up to first line */
501 printf("\r" ESC
"[%uA", cmdedit_y
);
504 put_prompt(); /* sets cursor to 0 */
505 while (cursor
< sv_cursor
)
506 put_cur_glyph_and_inc_cursor();
510 /* num = chars to go back from the beginning of current line: */
512 width
= cmdedit_termw
; /* read volatile var once */
513 /* num=1...w: one line up, w+1...2w: two, etc: */
514 lines_up
= 1 + (num
- 1) / width
;
515 cmdedit_x
= (width
* cmdedit_y
- num
) % width
;
516 cmdedit_y
-= lines_up
;
517 /* go to 1st column; go up */
518 printf("\r" ESC
"[%uA", lines_up
);
519 /* go to correct column.
520 * xterm, konsole, Linux VT interpret 0 as 1 below! wow.
521 * need to *make sure* we skip it if cmdedit_x == 0 */
523 printf(ESC
"[%uC", cmdedit_x
);
527 /* draw prompt, editor line, and clear tail */
528 static void redraw(int y
, int back_cursor
)
530 if (y
> 0) /* up y lines */
531 printf(ESC
"[%uA", y
);
534 put_till_end_and_adv_cursor();
535 printf(SEQ_CLEAR_TILL_END_OF_SCREEN
);
536 input_backward(back_cursor
);
539 /* Delete the char in front of the cursor, optionally saving it
540 * for later putback */
541 #if !ENABLE_FEATURE_EDITING_VI
542 static void input_delete(void)
543 #define input_delete(save) input_delete()
545 static void input_delete(int save
)
550 if (j
== (int)command_len
)
553 #if ENABLE_FEATURE_EDITING_VI
559 if ((delptr
- delbuf
) < DELBUFSIZ
)
560 *delptr
++ = command_ps
[j
];
564 memmove(command_ps
+ j
, command_ps
+ j
+ 1,
565 /* (command_len + 1 [because of NUL]) - (j + 1)
566 * simplified into (command_len - j) */
567 (command_len
- j
) * sizeof(command_ps
[0]));
569 put_till_end_and_adv_cursor();
570 /* Last char is still visible, erase it (and more) */
571 printf(SEQ_CLEAR_TILL_END_OF_SCREEN
);
572 input_backward(cursor
- j
); /* back to old pos cursor */
575 #if ENABLE_FEATURE_EDITING_VI
576 static void put(void)
579 int j
= delptr
- delbuf
;
584 /* open hole and then fill it */
585 memmove(command_ps
+ cursor
+ j
, command_ps
+ cursor
,
586 (command_len
- cursor
+ 1) * sizeof(command_ps
[0]));
587 memcpy(command_ps
+ cursor
, delbuf
, j
* sizeof(command_ps
[0]));
589 put_till_end_and_adv_cursor();
590 input_backward(cursor
- ocursor
- j
+ 1); /* at end of new text */
594 /* Delete the char in back of the cursor */
595 static void input_backspace(void)
603 /* Move forward one character */
604 static void input_forward(void)
606 if (cursor
< command_len
)
607 put_cur_glyph_and_inc_cursor();
610 #if ENABLE_FEATURE_TAB_COMPLETION
613 //needs to be more clever: currently it thinks that "foo\ b<TAB>
614 //matches the file named "foo bar", which is untrue.
615 //Also, perhaps "foo b<TAB> needs to complete to "foo bar" <cursor>,
616 //not "foo bar <cursor>...
618 static void free_tab_completion_data(void)
622 free(matches
[--num_matches
]);
628 static void add_match(char *matched
)
630 matches
= xrealloc_vector(matches
, 4, num_matches
);
631 matches
[num_matches
] = matched
;
635 # if ENABLE_FEATURE_USERNAME_COMPLETION
636 /* Replace "~user/..." with "/homedir/...".
637 * The parameter is malloced, free it or return it
638 * unchanged if no user is matched.
640 static char *username_path_completion(char *ud
)
642 struct passwd
*entry
;
643 char *tilde_name
= ud
;
647 if (*ud
== '/') { /* "~/..." */
651 ud
= strchr(ud
, '/');
652 *ud
= '\0'; /* "~user" */
653 entry
= getpwnam(tilde_name
+ 1);
654 *ud
= '/'; /* restore "~user/..." */
656 home
= entry
->pw_dir
;
659 ud
= concat_path_file(home
, ud
);
666 /* ~use<tab> - find all users with this prefix.
667 * Return the length of the prefix used for matching.
669 static NOINLINE
unsigned complete_username(const char *ud
)
671 /* Using _r function to avoid pulling in static buffers */
674 struct passwd
*result
;
678 userlen
= strlen(ud
);
681 while (!getpwent_r(&pwd
, line_buff
, sizeof(line_buff
), &result
)) {
682 /* Null usernames should result in all users as possible completions. */
683 if (/*!userlen || */ strncmp(ud
, pwd
.pw_name
, userlen
) == 0) {
684 add_match(xasprintf("~%s/", pwd
.pw_name
));
691 # endif /* FEATURE_USERNAME_COMPLETION */
699 static int path_parse(char ***p
)
706 if (state
->flags
& WITH_PATH_LOOKUP
)
707 pth
= state
->path_lookup
;
709 pth
= getenv("PATH");
711 /* PATH="" or PATH=":"? */
712 if (!pth
|| !pth
[0] || LONE_CHAR(pth
, ':'))
716 npth
= 1; /* path component count */
718 tmp
= strchr(tmp
, ':');
723 break; /* :<empty> */
727 *p
= res
= xmalloc(npth
* sizeof(res
[0]));
728 res
[0] = tmp
= xstrdup(pth
);
731 tmp
= strchr(tmp
, ':');
734 *tmp
++ = '\0'; /* ':' -> '\0' */
736 break; /* :<empty> */
742 /* Complete command, directory or file name.
743 * Return the length of the prefix used for matching.
745 static NOINLINE
unsigned complete_cmd_dir_file(const char *command
, int type
)
748 char **paths
= path1
;
756 path1
[0] = (char*)".";
758 pfind
= strrchr(command
, '/');
760 if (type
== FIND_EXE_ONLY
)
761 npaths
= path_parse(&paths
);
764 /* point to 'l' in "..../last_component" */
766 /* dirbuf = ".../.../.../" */
767 dirbuf
= xstrndup(command
, pfind
- command
);
768 # if ENABLE_FEATURE_USERNAME_COMPLETION
769 if (dirbuf
[0] == '~') /* ~/... or ~user/... */
770 dirbuf
= username_path_completion(dirbuf
);
774 pf_len
= strlen(pfind
);
776 for (i
= 0; i
< npaths
; i
++) {
782 dir
= opendir(paths
[i
]);
784 continue; /* don't print an error */
786 while ((next
= readdir(dir
)) != NULL
) {
788 const char *name_found
= next
->d_name
;
790 /* .../<tab>: bash 3.2.0 shows dotfiles, but not . and .. */
791 if (!pfind
[0] && DOT_OR_DOTDOT(name_found
))
794 if (strncmp(name_found
, pfind
, pf_len
) != 0)
797 found
= concat_path_file(paths
[i
], name_found
);
798 /* NB: stat() first so that we see is it a directory;
799 * but if that fails, use lstat() so that
800 * we still match dangling links */
801 if (stat(found
, &st
) && lstat(found
, &st
))
802 goto cont
; /* hmm, remove in progress? */
805 len
= strlen(name_found
);
806 found
= xrealloc(found
, len
+ 2); /* +2: for slash and NUL */
807 strcpy(found
, name_found
);
809 if (S_ISDIR(st
.st_mode
)) {
810 /* name is a directory, add slash */
812 found
[len
+ 1] = '\0';
814 /* skip files if looking for dirs only (example: cd) */
815 if (type
== FIND_DIR_ONLY
)
818 /* add it to the list */
825 } /* for every path */
827 if (paths
!= path1
) {
828 free(paths
[0]); /* allocated memory is only in first member */
836 /* build_match_prefix:
837 * On entry, match_buf contains everything up to cursor at the moment <tab>
838 * was pressed. This function looks at it, figures out what part of it
839 * constitutes the command/file/directory prefix to use for completion,
840 * and rewrites match_buf to contain only that part.
844 /* QUOT is used on elements of int_buf[], which are bytes,
845 * not Unicode chars. Therefore it works correctly even in Unicode mode.
847 #define QUOT (UCHAR_MAX+1)
848 static void remove_chunk(int16_t *int_buf
, int beg
, int end
)
850 /* beg must be <= end */
854 while ((int_buf
[beg
] = int_buf
[end
]) != 0)
859 for (i
= 0; int_buf
[i
]; i
++)
860 bb_putchar((unsigned char)int_buf
[i
]);
864 /* Caller ensures that match_buf points to a malloced buffer
865 * big enough to hold strlen(match_buf)*2 + 2
867 static NOINLINE
int build_match_prefix(char *match_buf
)
871 int16_t *int_buf
= (int16_t*)match_buf
;
873 if (dbg_bmp
) printf("\n%s\n", match_buf
);
875 /* Copy in reverse order, since they overlap */
876 i
= strlen(match_buf
);
878 int_buf
[i
] = (unsigned char)match_buf
[i
];
882 /* Mark every \c as "quoted c" */
883 for (i
= 0; int_buf
[i
]; i
++) {
884 if (int_buf
[i
] == '\\') {
885 remove_chunk(int_buf
, i
, i
+ 1);
889 /* Quote-mark "chars" and 'chars', drop delimiters */
894 int cur
= int_buf
[i
];
897 if (cur
== '\'' || cur
== '"') {
898 if (!in_quote
|| (cur
== in_quote
)) {
900 remove_chunk(int_buf
, i
, i
+ 1);
905 int_buf
[i
] = cur
| QUOT
;
910 /* Remove everything up to command delimiters:
911 * ';' ';;' '&' '|' '&&' '||',
912 * but careful with '>&' '<&' '>|'
914 for (i
= 0; int_buf
[i
]; i
++) {
915 int cur
= int_buf
[i
];
916 if (cur
== ';' || cur
== '&' || cur
== '|') {
917 int prev
= i
? int_buf
[i
- 1] : 0;
918 if (cur
== '&' && (prev
== '>' || prev
== '<')) {
920 } else if (cur
== '|' && prev
== '>') {
923 remove_chunk(int_buf
, 0, i
+ 1 + (cur
== int_buf
[i
+ 1]));
924 i
= -1; /* back to square 1 */
927 /* Remove all `cmd` */
928 for (i
= 0; int_buf
[i
]; i
++) {
929 if (int_buf
[i
] == '`') {
930 for (j
= i
+ 1; int_buf
[j
]; j
++) {
931 if (int_buf
[j
] == '`') {
932 /* `cmd` should count as a word:
933 * `cmd` c<tab> should search for files c*,
934 * not commands c*. Therefore we don't drop
935 * `cmd` entirely, we replace it with single `.
937 remove_chunk(int_buf
, i
, j
);
941 /* No closing ` - command mode, remove all up to ` */
942 remove_chunk(int_buf
, 0, i
+ 1);
948 /* Remove "cmd (" and "cmd {"
949 * Example: "if { c<tab>"
950 * In this example, c should be matched as command pfx.
952 for (i
= 0; int_buf
[i
]; i
++) {
953 if (int_buf
[i
] == '(' || int_buf
[i
] == '{') {
954 remove_chunk(int_buf
, 0, i
+ 1);
955 i
= -1; /* back to square 1 */
959 /* Remove leading unquoted spaces */
960 for (i
= 0; int_buf
[i
]; i
++)
961 if (int_buf
[i
] != ' ')
963 remove_chunk(int_buf
, 0, i
);
965 /* Determine completion mode */
966 command_mode
= FIND_EXE_ONLY
;
967 for (i
= 0; int_buf
[i
]; i
++) {
968 if (int_buf
[i
] == ' ' || int_buf
[i
] == '<' || int_buf
[i
] == '>') {
969 if (int_buf
[i
] == ' '
970 && command_mode
== FIND_EXE_ONLY
971 && (char)int_buf
[0] == 'c'
972 && (char)int_buf
[1] == 'd'
973 && i
== 2 /* -> int_buf[2] == ' ' */
975 command_mode
= FIND_DIR_ONLY
;
977 command_mode
= FIND_FILE_ONLY
;
982 if (dbg_bmp
) printf("command_mode(0:exe/1:dir/2:file):%d\n", command_mode
);
984 /* Remove everything except last word */
985 for (i
= 0; int_buf
[i
]; i
++) /* quasi-strlen(int_buf) */
987 for (--i
; i
>= 0; i
--) {
988 int cur
= int_buf
[i
];
989 if (cur
== ' ' || cur
== '<' || cur
== '>' || cur
== '|' || cur
== '&') {
990 remove_chunk(int_buf
, 0, i
+ 1);
995 /* Convert back to string of _chars_ */
997 while ((match_buf
[i
] = int_buf
[i
]) != '\0')
1000 if (dbg_bmp
) printf("final match_buf:'%s'\n", match_buf
);
1002 return command_mode
;
1006 * Display by column (original idea from ls applet,
1007 * very optimized by me [Vladimir] :)
1009 static void showfiles(void)
1012 int column_width
= 0;
1013 int nfiles
= num_matches
;
1017 /* find the longest file name - use that as the column width */
1018 for (row
= 0; row
< nrows
; row
++) {
1019 l
= unicode_strwidth(matches
[row
]);
1020 if (column_width
< l
)
1023 column_width
+= 2; /* min space for columns */
1024 ncols
= cmdedit_termw
/ column_width
;
1029 nrows
++; /* round up fractionals */
1033 for (row
= 0; row
< nrows
; row
++) {
1037 for (nc
= 1; nc
< ncols
&& n
+nrows
< nfiles
; n
+= nrows
, nc
++) {
1038 printf("%s%-*s", matches
[n
],
1039 (int)(column_width
- unicode_strwidth(matches
[n
])), ""
1042 if (ENABLE_UNICODE_SUPPORT
)
1043 puts(printable_string(NULL
, matches
[n
]));
1049 static const char *is_special_char(char c
)
1051 return strchr(" `\"#$%^&*()=+{}[]:;'|\\<>", c
);
1054 static char *quote_special_chars(char *found
)
1057 char *s
= xzalloc((strlen(found
) + 1) * 2);
1060 if (is_special_char(*found
))
1064 /* s[l] = '\0'; - already is */
1068 /* Do TAB completion */
1069 static NOINLINE
void input_tab(smallint
*lastWasTab
)
1074 /* Length of string used for matching */
1075 unsigned match_pfx_len
= match_pfx_len
;
1077 # if ENABLE_UNICODE_SUPPORT
1078 /* cursor pos in command converted to multibyte form */
1081 if (!(state
->flags
& TAB_COMPLETION
))
1085 /* The last char was a TAB too.
1086 * Print a list of all the available choices.
1088 if (num_matches
> 0) {
1089 /* cursor will be changed by goto_new_line() */
1090 int sav_cursor
= cursor
;
1093 redraw(0, command_len
- sav_cursor
);
1099 chosen_match
= NULL
;
1101 /* Make a local copy of the string up to the position of the cursor.
1102 * build_match_prefix will expand it into int16_t's, need to allocate
1103 * twice as much as the string_len+1.
1104 * (we then also (ab)use this extra space later - see (**))
1106 match_buf
= xmalloc(MAX_LINELEN
* sizeof(int16_t));
1107 # if !ENABLE_UNICODE_SUPPORT
1108 save_string(match_buf
, cursor
+ 1); /* +1 for NUL */
1111 CHAR_T wc
= command_ps
[cursor
];
1112 command_ps
[cursor
] = BB_NUL
;
1113 save_string(match_buf
, MAX_LINELEN
);
1114 command_ps
[cursor
] = wc
;
1115 cursor_mb
= strlen(match_buf
);
1118 find_type
= build_match_prefix(match_buf
);
1120 /* Free up any memory already allocated */
1121 free_tab_completion_data();
1123 # if ENABLE_FEATURE_USERNAME_COMPLETION
1124 /* If the word starts with ~ and there is no slash in the word,
1125 * then try completing this word as a username. */
1126 if (state
->flags
& USERNAME_COMPLETION
)
1127 if (match_buf
[0] == '~' && strchr(match_buf
, '/') == NULL
)
1128 match_pfx_len
= complete_username(match_buf
);
1130 /* If complete_username() did not match,
1131 * try to match a command in $PATH, or a directory, or a file */
1133 match_pfx_len
= complete_cmd_dir_file(match_buf
, find_type
);
1135 /* Account for backslashes which will be inserted
1136 * by quote_special_chars() later */
1138 const char *e
= match_buf
+ strlen(match_buf
);
1139 const char *s
= e
- match_pfx_len
;
1141 if (is_special_char(*s
++))
1145 /* Remove duplicates */
1148 qsort_string_vector(matches
, num_matches
);
1149 for (i
= 0; i
< num_matches
- 1; ++i
) {
1150 //if (matches[i] && matches[i+1]) { /* paranoia */
1151 if (strcmp(matches
[i
], matches
[i
+1]) == 0) {
1153 //matches[i] = NULL; /* paranoia */
1155 matches
[n
++] = matches
[i
];
1159 matches
[n
++] = matches
[i
];
1163 /* Did we find exactly one match? */
1164 if (num_matches
!= 1) { /* no */
1168 goto ret
; /* no matches at all */
1169 /* Find common prefix */
1170 chosen_match
= xstrdup(matches
[0]);
1171 for (cp
= chosen_match
; *cp
; cp
++) {
1173 for (n
= 1; n
< num_matches
; n
++) {
1174 if (matches
[n
][cp
- chosen_match
] != *cp
) {
1180 if (cp
== chosen_match
) { /* have unique prefix? */
1184 cp
= quote_special_chars(chosen_match
);
1187 len_found
= strlen(chosen_match
);
1188 } else { /* exactly one match */
1189 /* Next <tab> is not a double-tab */
1192 chosen_match
= quote_special_chars(matches
[0]);
1193 len_found
= strlen(chosen_match
);
1194 if (chosen_match
[len_found
-1] != '/') {
1195 chosen_match
[len_found
] = ' ';
1196 chosen_match
[++len_found
] = '\0';
1200 # if !ENABLE_UNICODE_SUPPORT
1201 /* Have space to place the match? */
1202 /* The result consists of three parts with these lengths: */
1203 /* cursor + (len_found - match_pfx_len) + (command_len - cursor) */
1204 /* it simplifies into: */
1205 if ((int)(len_found
- match_pfx_len
+ command_len
) < S
.maxsize
) {
1208 strcpy(match_buf
, &command_ps
[cursor
]);
1209 /* add match and tail */
1210 sprintf(&command_ps
[cursor
], "%s%s", chosen_match
+ match_pfx_len
, match_buf
);
1211 command_len
= strlen(command_ps
);
1213 pos
= cursor
+ len_found
- match_pfx_len
;
1214 /* write out the matched command */
1215 redraw(cmdedit_y
, command_len
- pos
);
1219 /* Use 2nd half of match_buf as scratch space - see (**) */
1220 char *command
= match_buf
+ MAX_LINELEN
;
1221 int len
= save_string(command
, MAX_LINELEN
);
1222 /* Have space to place the match? */
1223 /* cursor_mb + (len_found - match_pfx_len) + (len - cursor_mb) */
1224 if ((int)(len_found
- match_pfx_len
+ len
) < MAX_LINELEN
) {
1227 strcpy(match_buf
, &command
[cursor_mb
]);
1228 /* where do we want to have cursor after all? */
1229 strcpy(&command
[cursor_mb
], chosen_match
+ match_pfx_len
);
1230 len
= load_string(command
);
1231 /* add match and tail */
1232 sprintf(&command
[cursor_mb
], "%s%s", chosen_match
+ match_pfx_len
, match_buf
);
1233 command_len
= load_string(command
);
1234 /* write out the matched command */
1235 /* paranoia: load_string can return 0 on conv error,
1236 * prevent passing pos = (0 - 12) to redraw */
1237 pos
= command_len
- len
;
1238 redraw(cmdedit_y
, pos
>= 0 ? pos
: 0);
1247 #endif /* FEATURE_TAB_COMPLETION */
1250 line_input_t
* FAST_FUNC
new_line_input_t(int flags
)
1252 line_input_t
*n
= xzalloc(sizeof(*n
));
1254 n
->max_history
= MAX_HISTORY
;
1261 unsigned size_from_HISTFILESIZE(const char *hp
)
1263 int size
= MAX_HISTORY
;
1268 if (size
> MAX_HISTORY
)
1274 static void save_command_ps_at_cur_history(void)
1276 if (command_ps
[0] != BB_NUL
) {
1277 int cur
= state
->cur_history
;
1278 free(state
->history
[cur
]);
1280 # if ENABLE_UNICODE_SUPPORT
1282 char tbuf
[MAX_LINELEN
];
1283 save_string(tbuf
, sizeof(tbuf
));
1284 state
->history
[cur
] = xstrdup(tbuf
);
1287 state
->history
[cur
] = xstrdup(command_ps
);
1292 /* state->flags is already checked to be nonzero */
1293 static int get_previous_history(void)
1295 if ((state
->flags
& DO_HISTORY
) && state
->cur_history
) {
1296 save_command_ps_at_cur_history();
1297 state
->cur_history
--;
1304 static int get_next_history(void)
1306 if (state
->flags
& DO_HISTORY
) {
1307 if (state
->cur_history
< state
->cnt_history
) {
1308 save_command_ps_at_cur_history(); /* save the current history line */
1309 return ++state
->cur_history
;
1316 # if ENABLE_FEATURE_EDITING_SAVEHISTORY
1317 /* We try to ensure that concurrent additions to the history
1318 * do not overwrite each other.
1319 * Otherwise shell users get unhappy.
1321 * History file is trimmed lazily, when it grows several times longer
1322 * than configured MAX_HISTORY lines.
1325 static void free_line_input_t(line_input_t
*n
)
1327 int i
= n
->cnt_history
;
1329 free(n
->history
[--i
]);
1333 /* state->flags is already checked to be nonzero */
1334 static void load_history(line_input_t
*st_parm
)
1336 char *temp_h
[MAX_HISTORY
];
1339 unsigned idx
, i
, line_len
;
1341 /* NB: do not trash old history if file can't be opened */
1343 fp
= fopen_for_read(st_parm
->hist_file
);
1345 /* clean up old history */
1346 for (idx
= st_parm
->cnt_history
; idx
> 0;) {
1348 free(st_parm
->history
[idx
]);
1349 st_parm
->history
[idx
] = NULL
;
1352 /* fill temp_h[], retaining only last MAX_HISTORY lines */
1353 memset(temp_h
, 0, sizeof(temp_h
));
1355 st_parm
->cnt_history_in_file
= 0;
1356 while ((line
= xmalloc_fgetline(fp
)) != NULL
) {
1357 if (line
[0] == '\0') {
1363 st_parm
->cnt_history_in_file
++;
1365 if (idx
== st_parm
->max_history
)
1370 /* find first non-NULL temp_h[], if any */
1371 if (st_parm
->cnt_history_in_file
) {
1372 while (temp_h
[idx
] == NULL
) {
1374 if (idx
== st_parm
->max_history
)
1379 /* copy temp_h[] to st_parm->history[] */
1380 for (i
= 0; i
< st_parm
->max_history
;) {
1385 if (idx
== st_parm
->max_history
)
1387 line_len
= strlen(line
);
1388 if (line_len
>= MAX_LINELEN
)
1389 line
[MAX_LINELEN
-1] = '\0';
1390 st_parm
->history
[i
++] = line
;
1392 st_parm
->cnt_history
= i
;
1393 if (ENABLE_FEATURE_EDITING_SAVE_ON_EXIT
)
1394 st_parm
->cnt_history_in_file
= i
;
1398 # if ENABLE_FEATURE_EDITING_SAVE_ON_EXIT
1399 void save_history(line_input_t
*st
)
1405 if (st
->cnt_history
<= st
->cnt_history_in_file
)
1408 fp
= fopen(st
->hist_file
, "a");
1412 line_input_t
*st_temp
;
1414 for (i
= st
->cnt_history_in_file
; i
< st
->cnt_history
; i
++)
1415 fprintf(fp
, "%s\n", st
->history
[i
]);
1418 /* we may have concurrently written entries from others.
1420 st_temp
= new_line_input_t(st
->flags
);
1421 st_temp
->hist_file
= st
->hist_file
;
1422 st_temp
->max_history
= st
->max_history
;
1423 load_history(st_temp
);
1425 /* write out temp file and replace hist_file atomically */
1426 new_name
= xasprintf("%s.%u.new", st
->hist_file
, (int) getpid());
1427 fd
= open(new_name
, O_WRONLY
| O_CREAT
| O_TRUNC
, 0600);
1429 fp
= xfdopen_for_write(fd
);
1430 for (i
= 0; i
< st_temp
->cnt_history
; i
++)
1431 fprintf(fp
, "%s\n", st_temp
->history
[i
]);
1433 if (rename(new_name
, st
->hist_file
) == 0)
1434 st
->cnt_history_in_file
= st_temp
->cnt_history
;
1437 free_line_input_t(st_temp
);
1441 static void save_history(char *str
)
1446 if (!state
->hist_file
)
1449 fd
= open(state
->hist_file
, O_WRONLY
| O_CREAT
| O_APPEND
, 0600);
1452 xlseek(fd
, 0, SEEK_END
); /* paranoia */
1454 str
[len
] = '\n'; /* we (try to) do atomic write */
1455 len2
= full_write(fd
, str
, len
+ 1);
1458 if (len2
!= len
+ 1)
1459 return; /* "wtf?" */
1461 /* did we write so much that history file needs trimming? */
1462 state
->cnt_history_in_file
++;
1463 if (state
->cnt_history_in_file
> state
->max_history
* 4) {
1465 line_input_t
*st_temp
;
1467 /* we may have concurrently written entries from others.
1469 st_temp
= new_line_input_t(state
->flags
);
1470 st_temp
->hist_file
= state
->hist_file
;
1471 st_temp
->max_history
= state
->max_history
;
1472 load_history(st_temp
);
1474 /* write out temp file and replace hist_file atomically */
1475 new_name
= xasprintf("%s.%u.new", state
->hist_file
, (int) getpid());
1476 fd
= open(new_name
, O_WRONLY
| O_CREAT
| O_TRUNC
, 0600);
1481 fp
= xfdopen_for_write(fd
);
1482 for (i
= 0; i
< st_temp
->cnt_history
; i
++)
1483 fprintf(fp
, "%s\n", st_temp
->history
[i
]);
1485 if (rename(new_name
, state
->hist_file
) == 0)
1486 state
->cnt_history_in_file
= st_temp
->cnt_history
;
1489 free_line_input_t(st_temp
);
1494 # define load_history(a) ((void)0)
1495 # define save_history(a) ((void)0)
1496 # endif /* FEATURE_COMMAND_SAVEHISTORY */
1498 static void remember_in_history(char *str
)
1502 if (!(state
->flags
& DO_HISTORY
))
1506 i
= state
->cnt_history
;
1507 /* Don't save dupes */
1508 if (i
&& strcmp(state
->history
[i
-1], str
) == 0)
1511 free(state
->history
[state
->max_history
]); /* redundant, paranoia */
1512 state
->history
[state
->max_history
] = NULL
; /* redundant, paranoia */
1514 /* If history[] is full, remove the oldest command */
1515 /* we need to keep history[state->max_history] empty, hence >=, not > */
1516 if (i
>= state
->max_history
) {
1517 free(state
->history
[0]);
1518 for (i
= 0; i
< state
->max_history
-1; i
++)
1519 state
->history
[i
] = state
->history
[i
+1];
1520 /* i == state->max_history-1 */
1521 # if ENABLE_FEATURE_EDITING_SAVE_ON_EXIT
1522 if (state
->cnt_history_in_file
)
1523 state
->cnt_history_in_file
--;
1526 /* i <= state->max_history-1 */
1527 state
->history
[i
++] = xstrdup(str
);
1528 /* i <= state->max_history */
1529 state
->cur_history
= i
;
1530 state
->cnt_history
= i
;
1531 # if ENABLE_FEATURE_EDITING_SAVEHISTORY && !ENABLE_FEATURE_EDITING_SAVE_ON_EXIT
1534 IF_FEATURE_EDITING_FANCY_PROMPT(num_ok_lines
++;)
1537 #else /* MAX_HISTORY == 0 */
1538 # define remember_in_history(a) ((void)0)
1539 #endif /* MAX_HISTORY */
1542 #if ENABLE_FEATURE_EDITING_VI
1544 * vi mode implemented 2005 by Paul Fox <pgf@foxharp.boston.ma.us>
1547 vi_Word_motion(int eat
)
1549 CHAR_T
*command
= command_ps
;
1551 while (cursor
< command_len
&& !BB_isspace(command
[cursor
]))
1553 if (eat
) while (cursor
< command_len
&& BB_isspace(command
[cursor
]))
1558 vi_word_motion(int eat
)
1560 CHAR_T
*command
= command_ps
;
1562 if (BB_isalnum(command
[cursor
]) || command
[cursor
] == '_') {
1563 while (cursor
< command_len
1564 && (BB_isalnum(command
[cursor
+1]) || command
[cursor
+1] == '_')
1568 } else if (BB_ispunct(command
[cursor
])) {
1569 while (cursor
< command_len
&& BB_ispunct(command
[cursor
+1]))
1573 if (cursor
< command_len
)
1577 while (cursor
< command_len
&& BB_isspace(command
[cursor
]))
1585 CHAR_T
*command
= command_ps
;
1588 while (cursor
< command_len
&& BB_isspace(command
[cursor
]))
1590 while (cursor
< command_len
-1 && !BB_isspace(command
[cursor
+1]))
1597 CHAR_T
*command
= command_ps
;
1599 if (cursor
>= command_len
-1)
1602 while (cursor
< command_len
-1 && BB_isspace(command
[cursor
]))
1604 if (cursor
>= command_len
-1)
1606 if (BB_isalnum(command
[cursor
]) || command
[cursor
] == '_') {
1607 while (cursor
< command_len
-1
1608 && (BB_isalnum(command
[cursor
+1]) || command
[cursor
+1] == '_')
1612 } else if (BB_ispunct(command
[cursor
])) {
1613 while (cursor
< command_len
-1 && BB_ispunct(command
[cursor
+1]))
1619 vi_Back_motion(void)
1621 CHAR_T
*command
= command_ps
;
1623 while (cursor
> 0 && BB_isspace(command
[cursor
-1]))
1625 while (cursor
> 0 && !BB_isspace(command
[cursor
-1]))
1630 vi_back_motion(void)
1632 CHAR_T
*command
= command_ps
;
1637 while (cursor
> 0 && BB_isspace(command
[cursor
]))
1641 if (BB_isalnum(command
[cursor
]) || command
[cursor
] == '_') {
1643 && (BB_isalnum(command
[cursor
-1]) || command
[cursor
-1] == '_')
1647 } else if (BB_ispunct(command
[cursor
])) {
1648 while (cursor
> 0 && BB_ispunct(command
[cursor
-1]))
1654 /* Modelled after bash 4.0 behavior of Ctrl-<arrow> */
1655 static void ctrl_left(void)
1657 CHAR_T
*command
= command_ps
;
1665 c
= command
[cursor
];
1666 if (c
!= ' ' && !BB_ispunct(c
)) {
1667 /* we reached a "word" delimited by spaces/punct.
1668 * go to its beginning */
1670 c
= command
[cursor
- 1];
1671 if (c
== ' ' || BB_ispunct(c
))
1681 static void ctrl_right(void)
1683 CHAR_T
*command
= command_ps
;
1688 c
= command
[cursor
];
1691 if (c
!= ' ' && !BB_ispunct(c
)) {
1692 /* we reached a "word" delimited by spaces/punct.
1693 * go to its end + 1 */
1696 c
= command
[cursor
];
1697 if (c
== BB_NUL
|| c
== ' ' || BB_ispunct(c
))
1708 * read_line_input and its helpers
1711 #if ENABLE_FEATURE_EDITING_ASK_TERMINAL
1712 static void ask_terminal(void)
1714 /* Ask terminal where is the cursor now.
1715 * lineedit_read_key handles response and corrects
1716 * our idea of current cursor position.
1717 * Testcase: run "echo -n long_line_long_line_long_line",
1718 * then type in a long, wrapping command and try to
1719 * delete it using backspace key.
1720 * Note: we print it _after_ prompt, because
1721 * prompt may contain CR. Example: PS1='\[\r\n\]\w '
1723 /* Problem: if there is buffered input on stdin,
1724 * the response will be delivered later,
1725 * possibly to an unsuspecting application.
1726 * Testcase: "sleep 1; busybox ash" + press and hold [Enter].
1728 * ~/srcdevel/bbox/fix/busybox.t4 #
1729 * ~/srcdevel/bbox/fix/busybox.t4 #
1730 * ^[[59;34~/srcdevel/bbox/fix/busybox.t4 # <-- garbage
1731 * ~/srcdevel/bbox/fix/busybox.t4 #
1733 * Checking for input with poll only makes the race narrower,
1734 * I still can trigger it. Strace:
1736 * write(1, "~/srcdevel/bbox/fix/busybox.t4 # ", 33) = 33
1737 * poll([{fd=0, events=POLLIN}], 1, 0) = 0 (Timeout) <-- no input exists
1738 * write(1, "\33[6n", 4) = 4 <-- send the ESC sequence, quick!
1739 * poll([{fd=0, events=POLLIN}], 1, -1) = 1 ([{fd=0, revents=POLLIN}])
1740 * read(0, "\n", 1) = 1 <-- oh crap, user's input got in first
1744 pfd
.fd
= STDIN_FILENO
;
1745 pfd
.events
= POLLIN
;
1746 if (safe_poll(&pfd
, 1, 0) == 0) {
1747 S
.sent_ESC_br6n
= 1;
1748 fputs(ESC
"[6n", stdout
);
1749 fflush_all(); /* make terminal see it ASAP! */
1753 #define ask_terminal() ((void)0)
1756 #if !ENABLE_FEATURE_EDITING_FANCY_PROMPT
1757 static void parse_and_put_prompt(const char *prmt_ptr
)
1759 cmdedit_prompt
= prmt_ptr
;
1760 cmdedit_prmt_len
= strlen(prmt_ptr
);
1764 static void parse_and_put_prompt(const char *prmt_ptr
)
1767 size_t cur_prmt_len
= 0;
1768 char flg_not_length
= '[';
1769 char *prmt_mem_ptr
= xzalloc(1);
1770 char *cwd_buf
= xrealloc_getcwd_or_warn(NULL
);
1775 cmdedit_prmt_len
= 0;
1778 cwd_buf
= (char *)bb_msg_unknown
;
1781 cbuf
[1] = '\0'; /* never changes */
1784 char *free_me
= NULL
;
1789 const char *cp
= prmt_ptr
;
1792 c
= bb_process_escape_sequence(&prmt_ptr
);
1793 if (prmt_ptr
== cp
) {
1799 # if ENABLE_USERNAME_OR_HOMEDIR
1801 pbuf
= user_buf
? user_buf
: (char*)"";
1805 pbuf
= free_me
= safe_gethostname();
1806 *strchrnul(pbuf
, '.') = '\0';
1809 c
= (geteuid() == 0 ? '#' : '$');
1811 # if ENABLE_USERNAME_OR_HOMEDIR
1813 /* /home/user[/something] -> ~[/something] */
1815 l
= strlen(home_pwd_buf
);
1817 && strncmp(home_pwd_buf
, cwd_buf
, l
) == 0
1818 && (cwd_buf
[l
]=='/' || cwd_buf
[l
]=='\0')
1819 && strlen(cwd_buf
+ l
) < PATH_MAX
1821 pbuf
= free_me
= xasprintf("~%s", cwd_buf
+ l
);
1827 cp
= strrchr(pbuf
, '/');
1828 if (cp
!= NULL
&& cp
!= pbuf
)
1829 pbuf
+= (cp
-pbuf
) + 1;
1832 pbuf
= free_me
= xasprintf("%d", num_ok_lines
);
1834 case 'e': case 'E': /* \e \E = \033 */
1837 case 'x': case 'X': {
1839 for (l
= 0; l
< 3;) {
1841 buf2
[l
++] = *prmt_ptr
;
1843 h
= strtoul(buf2
, &pbuf
, 16);
1844 if (h
> UCHAR_MAX
|| (pbuf
- buf2
) < l
) {
1850 c
= (char)strtoul(buf2
, NULL
, 16);
1857 if (c
== flg_not_length
) {
1858 flg_not_length
= (flg_not_length
== '[' ? ']' : '[');
1866 cur_prmt_len
= strlen(pbuf
);
1867 prmt_len
+= cur_prmt_len
;
1868 if (flg_not_length
!= ']')
1869 cmdedit_prmt_len
+= cur_prmt_len
;
1870 prmt_mem_ptr
= strcat(xrealloc(prmt_mem_ptr
, prmt_len
+1), pbuf
);
1874 if (cwd_buf
!= (char *)bb_msg_unknown
)
1876 cmdedit_prompt
= prmt_mem_ptr
;
1881 static void cmdedit_setwidth(unsigned w
, int redraw_flg
)
1885 /* new y for current cursor */
1886 int new_y
= (cursor
+ cmdedit_prmt_len
) / w
;
1888 redraw((new_y
>= cmdedit_y
? new_y
: cmdedit_y
), command_len
- cursor
);
1893 static void win_changed(int nsig
)
1895 int sv_errno
= errno
;
1898 get_terminal_width_height(0, &width
, NULL
);
1899 //FIXME: cmdedit_setwidth() -> redraw() -> printf() -> KABOOM! (we are in signal handler!)
1900 cmdedit_setwidth(width
, /*redraw_flg:*/ nsig
);
1905 static int lineedit_read_key(char *read_key_buffer
, int timeout
)
1908 #if ENABLE_UNICODE_SUPPORT
1909 char unicode_buf
[MB_CUR_MAX
+ 1];
1910 int unicode_idx
= 0;
1914 /* Wait for input. TIMEOUT = -1 makes read_key wait even
1915 * on nonblocking stdin, TIMEOUT = 50 makes sure we won't
1916 * insist on full MB_CUR_MAX buffer to declare input like
1917 * "\xff\n",pause,"ls\n" invalid and thus won't lose "ls".
1919 * Note: read_key sets errno to 0 on success.
1921 ic
= read_key(STDIN_FILENO
, read_key_buffer
, timeout
);
1923 #if ENABLE_UNICODE_SUPPORT
1924 if (errno
== EAGAIN
&& unicode_idx
!= 0)
1930 #if ENABLE_FEATURE_EDITING_ASK_TERMINAL
1931 if ((int32_t)ic
== KEYCODE_CURSOR_POS
1934 S
.sent_ESC_br6n
= 0;
1935 if (cursor
== 0) { /* otherwise it may be bogus */
1936 int col
= ((ic
>> 32) & 0x7fff) - 1;
1937 if (col
> cmdedit_prmt_len
) {
1938 cmdedit_x
+= (col
- cmdedit_prmt_len
);
1939 while (cmdedit_x
>= cmdedit_termw
) {
1940 cmdedit_x
-= cmdedit_termw
;
1949 #if ENABLE_UNICODE_SUPPORT
1950 if (unicode_status
== UNICODE_ON
) {
1953 if ((int32_t)ic
< 0) /* KEYCODE_xxx */
1955 // TODO: imagine sequence like: 0xff,<left-arrow>: we are currently losing 0xff...
1957 unicode_buf
[unicode_idx
++] = ic
;
1958 unicode_buf
[unicode_idx
] = '\0';
1959 if (mbstowcs(&wc
, unicode_buf
, 1) != 1) {
1960 /* Not (yet?) a valid unicode char */
1961 if (unicode_idx
< MB_CUR_MAX
) {
1966 /* Invalid sequence. Save all "bad bytes" except first */
1967 read_key_ungets(read_key_buffer
, unicode_buf
+ 1, unicode_idx
- 1);
1968 # if !ENABLE_UNICODE_PRESERVE_BROKEN
1969 ic
= CONFIG_SUBST_WCHAR
;
1971 ic
= unicode_mark_raw_byte(unicode_buf
[0]);
1974 /* Valid unicode char, return its code */
1985 #if ENABLE_UNICODE_BIDI_SUPPORT
1986 static int isrtl_str(void)
1990 while (idx
< command_len
&& unicode_bidi_is_neutral_wchar(command_ps
[idx
]))
1992 return unicode_bidi_isrtl(command_ps
[idx
]);
1995 # define isrtl_str() 0
1998 /* leave out the "vi-mode"-only case labels if vi editing isn't
2000 #define vi_case(caselabel) IF_FEATURE_EDITING_VI(case caselabel)
2002 /* convert uppercase ascii to equivalent control char, for readability */
2004 #define CTRL(a) ((a) & ~0x40)
2007 VI_CMDMODE_BIT
= 0x40000000,
2008 /* 0x80000000 bit flags KEYCODE_xxx */
2011 #if ENABLE_FEATURE_REVERSE_SEARCH
2012 /* Mimic readline Ctrl-R reverse history search.
2013 * When invoked, it shows the following prompt:
2014 * (reverse-i-search)'': user_input [cursor pos unchanged by Ctrl-R]
2015 * and typing results in search being performed:
2016 * (reverse-i-search)'tmp': cd /tmp [cursor under t in /tmp]
2017 * Search is performed by looking at progressively older lines in history.
2018 * Ctrl-R again searches for the next match in history.
2019 * Backspace deletes last matched char.
2020 * Control keys exit search and return to normal editing (at current history line).
2022 static int32_t reverse_i_search(void)
2024 char match_buf
[128]; /* for user input */
2025 char read_key_buffer
[KEYCODE_BUFFER_SIZE
];
2026 const char *matched_history_line
;
2027 const char *saved_prompt
;
2030 matched_history_line
= NULL
;
2031 read_key_buffer
[0] = 0;
2032 match_buf
[0] = '\0';
2034 /* Save and replace the prompt */
2035 saved_prompt
= cmdedit_prompt
;
2040 unsigned match_buf_len
= strlen(match_buf
);
2043 //FIXME: correct timeout?
2044 ic
= lineedit_read_key(read_key_buffer
, -1);
2047 case CTRL('R'): /* searching for the next match */
2053 if (unicode_status
== UNICODE_ON
) {
2054 while (match_buf_len
!= 0) {
2055 uint8_t c
= match_buf
[--match_buf_len
];
2056 if ((c
& 0xc0) != 0x80) /* start of UTF-8 char? */
2060 if (match_buf_len
!= 0)
2063 match_buf
[match_buf_len
] = '\0';
2068 || (!ENABLE_UNICODE_SUPPORT
&& ic
>= 256)
2069 || (ENABLE_UNICODE_SUPPORT
&& ic
>= VI_CMDMODE_BIT
)
2074 /* Append this char */
2075 #if ENABLE_UNICODE_SUPPORT
2076 if (unicode_status
== UNICODE_ON
) {
2077 mbstate_t mbstate
= { 0 };
2078 char buf
[MB_CUR_MAX
+ 1];
2079 int len
= wcrtomb(buf
, ic
, &mbstate
);
2082 if (match_buf_len
+ len
< sizeof(match_buf
))
2083 strcpy(match_buf
+ match_buf_len
, buf
);
2087 if (match_buf_len
< sizeof(match_buf
) - 1) {
2088 match_buf
[match_buf_len
] = ic
;
2089 match_buf
[match_buf_len
+ 1] = '\0';
2094 /* Search in history for match_buf */
2095 h
= state
->cur_history
;
2096 if (ic
== CTRL('R'))
2099 if (state
->history
[h
]) {
2100 char *match
= strstr(state
->history
[h
], match_buf
);
2102 state
->cur_history
= h
;
2103 matched_history_line
= state
->history
[h
];
2104 command_len
= load_string(matched_history_line
);
2105 cursor
= match
- matched_history_line
;
2106 //FIXME: cursor position for Unicode case
2108 free((char*)cmdedit_prompt
);
2110 cmdedit_prompt
= xasprintf("(reverse-i-search)'%s': ", match_buf
);
2111 cmdedit_prmt_len
= strlen(cmdedit_prompt
);
2119 match_buf
[match_buf_len
] = '\0';
2124 redraw(cmdedit_y
, command_len
- cursor
);
2128 if (matched_history_line
)
2129 command_len
= load_string(matched_history_line
);
2131 free((char*)cmdedit_prompt
);
2132 cmdedit_prompt
= saved_prompt
;
2133 cmdedit_prmt_len
= strlen(cmdedit_prompt
);
2134 redraw(cmdedit_y
, command_len
- cursor
);
2140 /* maxsize must be >= 2.
2142 * -1 on read errors or EOF, or on bare Ctrl-D,
2143 * 0 on ctrl-C (the line entered is still returned in 'command'),
2144 * >0 length of input string, including terminating '\n'
2146 int FAST_FUNC
read_line_input(line_input_t
*st
, const char *prompt
, char *command
, int maxsize
, int timeout
)
2149 #if ENABLE_FEATURE_TAB_COMPLETION
2150 smallint lastWasTab
= 0;
2152 smallint break_out
= 0;
2153 #if ENABLE_FEATURE_EDITING_VI
2154 smallint vi_cmdmode
= 0;
2156 struct termios initial_settings
;
2157 struct termios new_settings
;
2158 char read_key_buffer
[KEYCODE_BUFFER_SIZE
];
2162 if (tcgetattr(STDIN_FILENO
, &initial_settings
) < 0
2163 || !(initial_settings
.c_lflag
& ECHO
)
2165 /* Happens when e.g. stty -echo was run before */
2166 parse_and_put_prompt(prompt
);
2167 /* fflush_all(); - done by parse_and_put_prompt */
2168 if (fgets(command
, maxsize
, stdin
) == NULL
)
2169 len
= -1; /* EOF or error */
2171 len
= strlen(command
);
2178 // FIXME: audit & improve this
2179 if (maxsize
> MAX_LINELEN
)
2180 maxsize
= MAX_LINELEN
;
2181 S
.maxsize
= maxsize
;
2183 /* With zero flags, no other fields are ever used */
2184 state
= st
? st
: (line_input_t
*) &const_int_0
;
2186 # if ENABLE_FEATURE_EDITING_SAVEHISTORY
2187 if (state
->hist_file
)
2188 if (state
->cnt_history
== 0)
2189 load_history(state
);
2191 if (state
->flags
& DO_HISTORY
)
2192 state
->cur_history
= state
->cnt_history
;
2195 /* prepare before init handlers */
2196 cmdedit_y
= 0; /* quasireal y, not true if line > xt*yt */
2198 #if ENABLE_UNICODE_SUPPORT
2199 command_ps
= xzalloc(maxsize
* sizeof(command_ps
[0]));
2201 command_ps
= command
;
2204 #define command command_must_not_be_used
2206 new_settings
= initial_settings
;
2207 /* ~ICANON: unbuffered input (most c_cc[] are disabled, VMIN/VTIME are enabled) */
2208 /* ~ECHO, ~ECHONL: turn off echoing, including newline echoing */
2209 /* ~ISIG: turn off INTR (ctrl-C), QUIT, SUSP */
2210 new_settings
.c_lflag
&= ~(ICANON
| ECHO
| ECHONL
| ISIG
);
2211 /* reads would block only if < 1 char is available */
2212 new_settings
.c_cc
[VMIN
] = 1;
2213 /* no timeout (reads block forever) */
2214 new_settings
.c_cc
[VTIME
] = 0;
2215 /* Should be not needed if ISIG is off: */
2216 /* Turn off CTRL-C */
2217 /* new_settings.c_cc[VINTR] = _POSIX_VDISABLE; */
2218 tcsetattr_stdin_TCSANOW(&new_settings
);
2220 #if ENABLE_USERNAME_OR_HOMEDIR
2222 struct passwd
*entry
;
2224 entry
= getpwuid(geteuid());
2226 user_buf
= xstrdup(entry
->pw_name
);
2227 home_pwd_buf
= xstrdup(entry
->pw_dir
);
2233 for (i
= 0; i
<= state
->max_history
; i
++)
2234 bb_error_msg("history[%d]:'%s'", i
, state
->history
[i
]);
2235 bb_error_msg("cur_history:%d cnt_history:%d", state
->cur_history
, state
->cnt_history
);
2238 /* Print out the command prompt, optionally ask where cursor is */
2239 parse_and_put_prompt(prompt
);
2242 /* Install window resize handler (NB: after *all* init is complete) */
2243 //FIXME: save entire sigaction!
2244 previous_SIGWINCH_handler
= signal(SIGWINCH
, win_changed
);
2245 win_changed(0); /* get initial window size */
2247 read_key_buffer
[0] = 0;
2250 * The emacs and vi modes share much of the code in the big
2251 * command loop. Commands entered when in vi's command mode
2252 * (aka "escape mode") get an extra bit added to distinguish
2253 * them - this keeps them from being self-inserted. This
2254 * clutters the big switch a bit, but keeps all the code
2260 ic
= ic_raw
= lineedit_read_key(read_key_buffer
, timeout
);
2262 #if ENABLE_FEATURE_REVERSE_SEARCH
2265 #if ENABLE_FEATURE_EDITING_VI
2268 /* btw, since KEYCODE_xxx are all < 0, this doesn't
2269 * change ic if it contains one of them: */
2270 ic
|= VI_CMDMODE_BIT
;
2277 vi_case('\n'|VI_CMDMODE_BIT
:)
2278 vi_case('\r'|VI_CMDMODE_BIT
:)
2284 vi_case('0'|VI_CMDMODE_BIT
:)
2285 /* Control-a -- Beginning of line */
2286 input_backward(cursor
);
2289 vi_case('h'|VI_CMDMODE_BIT
:)
2290 vi_case('\b'|VI_CMDMODE_BIT
:) /* ^H */
2291 vi_case('\x7f'|VI_CMDMODE_BIT
:) /* DEL */
2292 input_backward(1); /* Move back one character */
2295 vi_case('$'|VI_CMDMODE_BIT
:)
2296 /* Control-e -- End of line */
2297 put_till_end_and_adv_cursor();
2300 vi_case('l'|VI_CMDMODE_BIT
:)
2301 vi_case(' '|VI_CMDMODE_BIT
:)
2302 input_forward(); /* Move forward one character */
2305 case '\x7f': /* DEL */
2311 case KEYCODE_DELETE
:
2317 #if ENABLE_FEATURE_TAB_COMPLETION
2319 input_tab(&lastWasTab
);
2323 /* Control-k -- clear to end of line */
2324 command_ps
[cursor
] = BB_NUL
;
2325 command_len
= cursor
;
2326 printf(SEQ_CLEAR_TILL_END_OF_SCREEN
);
2329 vi_case(CTRL('L')|VI_CMDMODE_BIT
:)
2330 /* Control-l -- clear screen */
2331 printf(ESC
"[H"); /* cursor to top,left */
2332 redraw(0, command_len
- cursor
);
2336 vi_case(CTRL('N')|VI_CMDMODE_BIT
:)
2337 vi_case('j'|VI_CMDMODE_BIT
:)
2338 /* Control-n -- Get next command in history */
2339 if (get_next_history())
2343 vi_case(CTRL('P')|VI_CMDMODE_BIT
:)
2344 vi_case('k'|VI_CMDMODE_BIT
:)
2345 /* Control-p -- Get previous command from history */
2346 if (get_previous_history())
2351 vi_case(CTRL('U')|VI_CMDMODE_BIT
:)
2352 /* Control-U -- Clear line before cursor */
2354 command_len
-= cursor
;
2355 memmove(command_ps
, command_ps
+ cursor
,
2356 (command_len
+ 1) * sizeof(command_ps
[0]));
2357 redraw(cmdedit_y
, command_len
);
2361 vi_case(CTRL('W')|VI_CMDMODE_BIT
:)
2362 /* Control-W -- Remove the last word */
2363 while (cursor
> 0 && BB_isspace(command_ps
[cursor
-1]))
2365 while (cursor
> 0 && !BB_isspace(command_ps
[cursor
-1]))
2368 #if ENABLE_FEATURE_REVERSE_SEARCH
2370 ic
= ic_raw
= reverse_i_search();
2374 #if ENABLE_FEATURE_EDITING_VI
2375 case 'i'|VI_CMDMODE_BIT
:
2378 case 'I'|VI_CMDMODE_BIT
:
2379 input_backward(cursor
);
2382 case 'a'|VI_CMDMODE_BIT
:
2386 case 'A'|VI_CMDMODE_BIT
:
2387 put_till_end_and_adv_cursor();
2390 case 'x'|VI_CMDMODE_BIT
:
2393 case 'X'|VI_CMDMODE_BIT
:
2399 case 'W'|VI_CMDMODE_BIT
:
2402 case 'w'|VI_CMDMODE_BIT
:
2405 case 'E'|VI_CMDMODE_BIT
:
2408 case 'e'|VI_CMDMODE_BIT
:
2411 case 'B'|VI_CMDMODE_BIT
:
2414 case 'b'|VI_CMDMODE_BIT
:
2417 case 'C'|VI_CMDMODE_BIT
:
2420 case 'D'|VI_CMDMODE_BIT
:
2423 case 'c'|VI_CMDMODE_BIT
:
2426 case 'd'|VI_CMDMODE_BIT
: {
2429 ic
= lineedit_read_key(read_key_buffer
, timeout
);
2430 if (errno
) /* error */
2431 goto return_error_indicator
;
2432 if (ic
== ic_raw
) { /* "cc", "dd" */
2433 input_backward(cursor
);
2445 case 'w': /* "dw", "cw" */
2446 vi_word_motion(vi_cmdmode
);
2448 case 'W': /* 'dW', 'cW' */
2449 vi_Word_motion(vi_cmdmode
);
2451 case 'e': /* 'de', 'ce' */
2455 case 'E': /* 'dE', 'cE' */
2461 input_backward(cursor
- sc
);
2462 while (nc
-- > cursor
)
2465 case 'b': /* "db", "cb" */
2466 case 'B': /* implemented as B */
2471 while (sc
-- > cursor
)
2474 case ' ': /* "d ", "c " */
2477 case '$': /* "d$", "c$" */
2479 while (cursor
< command_len
)
2485 case 'p'|VI_CMDMODE_BIT
:
2488 case 'P'|VI_CMDMODE_BIT
:
2491 case 'r'|VI_CMDMODE_BIT
:
2492 //FIXME: unicode case?
2493 ic
= lineedit_read_key(read_key_buffer
, timeout
);
2494 if (errno
) /* error */
2495 goto return_error_indicator
;
2496 if (ic
< ' ' || ic
> 255) {
2499 command_ps
[cursor
] = ic
;
2504 case '\x1b': /* ESC */
2505 if (state
->flags
& VI_MODE
) {
2506 /* insert mode --> command mode */
2510 /* Handle a few ESC-<key> combinations the same way
2511 * standard readline bindings (IOW: bash) do.
2512 * Often, Alt-<key> generates ESC-<key>.
2514 ic
= lineedit_read_key(read_key_buffer
, timeout
);
2516 //case KEYCODE_LEFT: - bash doesn't do this
2520 //case KEYCODE_RIGHT: - bash doesn't do this
2524 //case KEYCODE_DELETE: - bash doesn't do this
2525 case 'd': /* Alt-D */
2527 /* Delete word forward */
2528 int nc
, sc
= cursor
;
2536 case '\b': /* Alt-Backspace(?) */
2537 case '\x7f': /* Alt-Backspace(?) */
2538 //case 'w': - bash doesn't do this
2540 /* Delete word backward */
2543 while (sc
-- > cursor
)
2549 #endif /* FEATURE_COMMAND_EDITING_VI */
2553 if (get_previous_history())
2558 if (!get_next_history())
2561 /* Rewrite the line with the selected history item */
2562 /* change command */
2563 command_len
= load_string(state
->history
[state
->cur_history
] ?
2564 state
->history
[state
->cur_history
] : "");
2565 /* redraw and go to eol (bol, in vi) */
2566 redraw(cmdedit_y
, (state
->flags
& VI_MODE
) ? 9999 : 0);
2575 case KEYCODE_CTRL_LEFT
:
2576 case KEYCODE_ALT_LEFT
: /* bash doesn't do it */
2579 case KEYCODE_CTRL_RIGHT
:
2580 case KEYCODE_ALT_RIGHT
: /* bash doesn't do it */
2584 input_backward(cursor
);
2587 put_till_end_and_adv_cursor();
2591 if (initial_settings
.c_cc
[VINTR
] != 0
2592 && ic_raw
== initial_settings
.c_cc
[VINTR
]
2594 /* Ctrl-C (usually) - stop gathering input */
2597 break_out
= -1; /* "do not append '\n'" */
2600 if (initial_settings
.c_cc
[VEOF
] != 0
2601 && ic_raw
== initial_settings
.c_cc
[VEOF
]
2603 /* Ctrl-D (usually) - delete one character,
2604 * or exit if len=0 and no chars to delete */
2605 if (command_len
== 0) {
2608 case -1: /* error (e.g. EIO when tty is destroyed) */
2609 IF_FEATURE_EDITING_VI(return_error_indicator
:)
2610 break_out
= command_len
= -1;
2616 // /* Control-V -- force insert of next char */
2617 // if (c == CTRL('V')) {
2618 // if (safe_read(STDIN_FILENO, &c, 1) < 1)
2619 // goto return_error_indicator;
2626 || (!ENABLE_UNICODE_SUPPORT
&& ic
>= 256)
2627 || (ENABLE_UNICODE_SUPPORT
&& ic
>= VI_CMDMODE_BIT
)
2629 /* If VI_CMDMODE_BIT is set, ic is >= 256
2630 * and vi mode ignores unexpected chars.
2631 * Otherwise, we are here if ic is a
2632 * control char or an unhandled ESC sequence,
2633 * which is also ignored.
2637 if ((int)command_len
>= (maxsize
- 2)) {
2638 /* Not enough space for the char and EOL */
2643 if (cursor
== (command_len
- 1)) {
2644 /* We are at the end, append */
2645 command_ps
[cursor
] = ic
;
2646 command_ps
[cursor
+ 1] = BB_NUL
;
2647 put_cur_glyph_and_inc_cursor();
2648 if (unicode_bidi_isrtl(ic
))
2651 /* In the middle, insert */
2654 memmove(command_ps
+ sc
+ 1, command_ps
+ sc
,
2655 (command_len
- sc
) * sizeof(command_ps
[0]));
2656 command_ps
[sc
] = ic
;
2657 /* is right-to-left char, or neutral one (e.g. comma) was just added to rtl text? */
2660 put_till_end_and_adv_cursor();
2661 /* to prev x pos + 1 */
2662 input_backward(cursor
- sc
);
2670 #if ENABLE_FEATURE_TAB_COMPLETION
2676 #if ENABLE_FEATURE_EDITING_ASK_TERMINAL
2677 if (S
.sent_ESC_br6n
) {
2678 /* "sleep 1; busybox ash" + hold [Enter] to trigger.
2679 * We sent "ESC [ 6 n", but got '\n' first, and
2680 * KEYCODE_CURSOR_POS response is now buffered from terminal.
2681 * It's bad already and not much can be done with it
2682 * (it _will_ be visible for the next process to read stdin),
2683 * but without this delay it even shows up on the screen
2684 * as garbage because we restore echo settings with tcsetattr
2685 * before it comes in. UGLY!
2691 /* End of bug-catching "command_must_not_be_used" trick */
2694 #if ENABLE_UNICODE_SUPPORT
2696 if (command_len
> 0)
2697 command_len
= save_string(command
, maxsize
- 1);
2701 if (command_len
> 0)
2702 remember_in_history(command
);
2704 if (break_out
> 0) {
2705 command
[command_len
++] = '\n';
2706 command
[command_len
] = '\0';
2709 #if ENABLE_FEATURE_TAB_COMPLETION
2710 free_tab_completion_data();
2713 /* restore initial_settings */
2714 tcsetattr_stdin_TCSANOW(&initial_settings
);
2715 /* restore SIGWINCH handler */
2716 signal(SIGWINCH
, previous_SIGWINCH_handler
);
2722 return len
; /* can't return command_len, DEINIT_S() destroys it */
2725 #else /* !FEATURE_EDITING */
2727 #undef read_line_input
2728 int FAST_FUNC
read_line_input(const char* prompt
, char* command
, int maxsize
)
2730 fputs(prompt
, stdout
);
2732 if (!fgets(command
, maxsize
, stdin
))
2734 return strlen(command
);
2737 #endif /* !FEATURE_EDITING */
2748 const char *applet_name
= "debug stuff usage";
2750 int main(int argc
, char **argv
)
2752 char buff
[MAX_LINELEN
];
2754 #if ENABLE_FEATURE_EDITING_FANCY_PROMPT
2755 "\\[\\033[32;1m\\]\\u@\\[\\x1b[33;1m\\]\\h:"
2756 "\\[\\033[34;1m\\]\\w\\[\\033[35;1m\\] "
2757 "\\!\\[\\e[36;1m\\]\\$ \\[\\E[0m\\]";
2764 l
= read_line_input(prompt
, buff
);
2765 if (l
<= 0 || buff
[l
-1] != '\n')
2768 printf("*** read_line_input() returned line =%s=\n", buff
);
2770 printf("*** read_line_input() detect ^D\n");