blob: 990865897bac7564c706a3ac4a5072910f0da707
1 | /* vi: set sw=4 ts=4: */ |
2 | /* |
3 | * Command line editing. |
4 | * |
5 | * Copyright (c) 1986-2003 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 <andersen@codepoet.org> (Majorly adjusted for busybox) |
13 | * |
14 | * This code is 'as is' with no warranty. |
15 | */ |
16 | /* |
17 | * Usage and known bugs: |
18 | * Terminal key codes are not extensive, more needs to be added. |
19 | * This version was created on Debian GNU/Linux 2.x. |
20 | * Delete, Backspace, Home, End, and the arrow keys were tested |
21 | * to work in an Xterm and console. Ctrl-A also works as Home. |
22 | * Ctrl-E also works as End. |
23 | * |
24 | * The following readline-like commands are not implemented: |
25 | * CTL-t -- Transpose two characters |
26 | * |
27 | * lineedit does not know that the terminal escape sequences do not |
28 | * take up space on the screen. The redisplay code assumes, unless |
29 | * told otherwise, that each character in the prompt is a printable |
30 | * character that takes up one character position on the screen. |
31 | * You need to tell lineedit that some sequences of characters |
32 | * in the prompt take up no screen space. Compatibly with readline, |
33 | * use the \[ escape to begin a sequence of non-printing characters, |
34 | * and the \] escape to signal the end of such a sequence. Example: |
35 | * |
36 | * PS1='\[\033[01;32m\]\u@\h\[\033[01;34m\] \w \$\[\033[00m\] ' |
37 | * |
38 | * Unicode in PS1 is not fully supported: prompt length calulation is wrong, |
39 | * resulting in line wrap problems with long (multi-line) input. |
40 | * |
41 | * Multi-line PS1 (e.g. PS1="\n[\w]\n$ ") has problems with history |
42 | * browsing: up/down arrows result in scrolling. |
43 | * It stems from simplistic "cmdedit_y = cmdedit_prmt_len / cmdedit_termw" |
44 | * calculation of how many lines the prompt takes. |
45 | */ |
46 | #include "busybox.h" |
47 | #include "NUM_APPLETS.h" |
48 | #include "unicode.h" |
49 | #include "pwd_.h" |
50 | #ifndef _POSIX_VDISABLE |
51 | # define _POSIX_VDISABLE '\0' |
52 | #endif |
53 | |
54 | |
55 | |
56 | //# define ENABLE_FEATURE_EDITING 0 |
57 | //# define ENABLE_FEATURE_TAB_COMPLETION 0 |
58 | # define ENABLE_FEATURE_USERNAME_COMPLETION 0 |
59 | |
60 | |
61 | |
62 | /* Entire file (except TESTing part) sits inside this #if */ |
63 | #if ENABLE_FEATURE_EDITING |
64 | |
65 | |
66 | #define ENABLE_USERNAME_OR_HOMEDIR \ |
67 | (ENABLE_FEATURE_USERNAME_COMPLETION || ENABLE_FEATURE_EDITING_FANCY_PROMPT) |
68 | #define IF_USERNAME_OR_HOMEDIR(...) |
69 | #if ENABLE_USERNAME_OR_HOMEDIR |
70 | # undef IF_USERNAME_OR_HOMEDIR |
71 | # define IF_USERNAME_OR_HOMEDIR(...) __VA_ARGS__ |
72 | #endif |
73 | |
74 | |
75 | #undef CHAR_T |
76 | #if ENABLE_UNICODE_SUPPORT |
77 | # define BB_NUL ((wchar_t)0) |
78 | # define CHAR_T wchar_t |
79 | static bool BB_isspace(CHAR_T c) { return ((unsigned)c < 256 && isspace(c)); } |
80 | # if ENABLE_FEATURE_EDITING_VI |
81 | static bool BB_isalnum_or_underscore(CHAR_T c) { |
82 | return ((unsigned)c < 256 && isalnum(c)) || c == '_'; |
83 | } |
84 | # endif |
85 | static bool BB_ispunct(CHAR_T c) { return ((unsigned)c < 256 && ispunct(c)); } |
86 | # undef isspace |
87 | # undef isalnum |
88 | # undef ispunct |
89 | # undef isprint |
90 | # define isspace isspace_must_not_be_used |
91 | # define isalnum isalnum_must_not_be_used |
92 | # define ispunct ispunct_must_not_be_used |
93 | # define isprint isprint_must_not_be_used |
94 | #else |
95 | # define BB_NUL '\0' |
96 | # define CHAR_T char |
97 | # define BB_isspace(c) isspace(c) |
98 | # if ENABLE_FEATURE_EDITING_VI |
99 | static bool BB_isalnum_or_underscore(CHAR_T c) { |
100 | return ((unsigned)c < 256 && isalnum(c)) || c == '_'; |
101 | } |
102 | # endif |
103 | # define BB_ispunct(c) ispunct(c) |
104 | #endif |
105 | #if ENABLE_UNICODE_PRESERVE_BROKEN |
106 | # define unicode_mark_raw_byte(wc) ((wc) | 0x20000000) |
107 | # define unicode_is_raw_byte(wc) ((wc) & 0x20000000) |
108 | #else |
109 | # define unicode_is_raw_byte(wc) 0 |
110 | #endif |
111 | |
112 | |
113 | #define ESC "\033" |
114 | |
115 | #define SEQ_CLEAR_TILL_END_OF_SCREEN ESC"[J" |
116 | //#define SEQ_CLEAR_TILL_END_OF_LINE ESC"[K" |
117 | |
118 | |
119 | enum { |
120 | MAX_LINELEN = CONFIG_FEATURE_EDITING_MAX_LEN < 0x7ff0 |
121 | ? CONFIG_FEATURE_EDITING_MAX_LEN |
122 | : 0x7ff0 |
123 | }; |
124 | |
125 | #if ENABLE_USERNAME_OR_HOMEDIR |
126 | static const char null_str[] ALIGN1 = ""; |
127 | #endif |
128 | |
129 | /* We try to minimize both static and stack usage. */ |
130 | struct lineedit_statics { |
131 | line_input_t *state; |
132 | |
133 | unsigned cmdedit_termw; /* = 80; */ /* actual terminal width */ |
134 | |
135 | unsigned cmdedit_x; /* real x (col) terminal position */ |
136 | unsigned cmdedit_y; /* pseudoreal y (row) terminal position */ |
137 | unsigned cmdedit_prmt_len; /* length of prompt (without colors etc) */ |
138 | |
139 | unsigned cursor; |
140 | int command_len; /* must be signed */ |
141 | /* signed maxsize: we want x in "if (x > S.maxsize)" |
142 | * to _not_ be promoted to unsigned */ |
143 | int maxsize; |
144 | CHAR_T *command_ps; |
145 | |
146 | const char *cmdedit_prompt; |
147 | |
148 | #if ENABLE_USERNAME_OR_HOMEDIR |
149 | char *user_buf; |
150 | char *home_pwd_buf; /* = (char*)null_str; */ |
151 | #endif |
152 | |
153 | #if ENABLE_FEATURE_TAB_COMPLETION |
154 | char **matches; |
155 | unsigned num_matches; |
156 | #endif |
157 | |
158 | unsigned SIGWINCH_saved; |
159 | volatile unsigned SIGWINCH_count; |
160 | volatile smallint ok_to_redraw; |
161 | |
162 | #if ENABLE_FEATURE_EDITING_VI |
163 | # define DELBUFSIZ 128 |
164 | smallint newdelflag; /* whether delbuf should be reused yet */ |
165 | CHAR_T *delptr; |
166 | CHAR_T delbuf[DELBUFSIZ]; /* a place to store deleted characters */ |
167 | #endif |
168 | #if ENABLE_FEATURE_EDITING_ASK_TERMINAL |
169 | smallint sent_ESC_br6n; |
170 | #endif |
171 | |
172 | /* Largish struct, keeping it last results in smaller code */ |
173 | struct sigaction SIGWINCH_handler; |
174 | }; |
175 | |
176 | /* See lineedit_ptr_hack.c */ |
177 | extern struct lineedit_statics *const lineedit_ptr_to_statics; |
178 | |
179 | #define S (*lineedit_ptr_to_statics) |
180 | #define state (S.state ) |
181 | #define cmdedit_termw (S.cmdedit_termw ) |
182 | #define cmdedit_x (S.cmdedit_x ) |
183 | #define cmdedit_y (S.cmdedit_y ) |
184 | #define cmdedit_prmt_len (S.cmdedit_prmt_len) |
185 | #define cursor (S.cursor ) |
186 | #define command_len (S.command_len ) |
187 | #define command_ps (S.command_ps ) |
188 | #define cmdedit_prompt (S.cmdedit_prompt ) |
189 | #define user_buf (S.user_buf ) |
190 | #define home_pwd_buf (S.home_pwd_buf ) |
191 | #define matches (S.matches ) |
192 | #define num_matches (S.num_matches ) |
193 | #define delptr (S.delptr ) |
194 | #define newdelflag (S.newdelflag ) |
195 | #define delbuf (S.delbuf ) |
196 | |
197 | #define INIT_S() do { \ |
198 | (*(struct lineedit_statics**)&lineedit_ptr_to_statics) = xzalloc(sizeof(S)); \ |
199 | barrier(); \ |
200 | cmdedit_termw = 80; \ |
201 | IF_USERNAME_OR_HOMEDIR(home_pwd_buf = (char*)null_str;) \ |
202 | IF_FEATURE_EDITING_VI(delptr = delbuf;) \ |
203 | } while (0) |
204 | |
205 | static void deinit_S(void) |
206 | { |
207 | #if ENABLE_FEATURE_EDITING_FANCY_PROMPT |
208 | /* This one is allocated only if FANCY_PROMPT is on |
209 | * (otherwise it points to verbatim prompt (NOT malloced)) */ |
210 | free((char*)cmdedit_prompt); |
211 | #endif |
212 | #if ENABLE_USERNAME_OR_HOMEDIR |
213 | free(user_buf); |
214 | if (home_pwd_buf != null_str) |
215 | free(home_pwd_buf); |
216 | #endif |
217 | free(lineedit_ptr_to_statics); |
218 | } |
219 | #define DEINIT_S() deinit_S() |
220 | |
221 | |
222 | #if ENABLE_UNICODE_SUPPORT |
223 | static size_t load_string(const char *src) |
224 | { |
225 | if (unicode_status == UNICODE_ON) { |
226 | ssize_t len = mbstowcs(command_ps, src, S.maxsize - 1); |
227 | if (len < 0) |
228 | len = 0; |
229 | command_ps[len] = BB_NUL; |
230 | return len; |
231 | } else { |
232 | unsigned i = 0; |
233 | while (src[i] && i < S.maxsize - 1) { |
234 | command_ps[i] = src[i]; |
235 | i++; |
236 | } |
237 | command_ps[i] = BB_NUL; |
238 | return i; |
239 | } |
240 | } |
241 | static unsigned save_string(char *dst, unsigned maxsize) |
242 | { |
243 | if (unicode_status == UNICODE_ON) { |
244 | # if !ENABLE_UNICODE_PRESERVE_BROKEN |
245 | ssize_t len = wcstombs(dst, command_ps, maxsize - 1); |
246 | if (len < 0) |
247 | len = 0; |
248 | dst[len] = '\0'; |
249 | return len; |
250 | # else |
251 | unsigned dstpos = 0; |
252 | unsigned srcpos = 0; |
253 | |
254 | maxsize--; |
255 | while (dstpos < maxsize) { |
256 | wchar_t wc; |
257 | int n = srcpos; |
258 | |
259 | /* Convert up to 1st invalid byte (or up to end) */ |
260 | while ((wc = command_ps[srcpos]) != BB_NUL |
261 | && !unicode_is_raw_byte(wc) |
262 | ) { |
263 | srcpos++; |
264 | } |
265 | command_ps[srcpos] = BB_NUL; |
266 | n = wcstombs(dst + dstpos, command_ps + n, maxsize - dstpos); |
267 | if (n < 0) /* should not happen */ |
268 | break; |
269 | dstpos += n; |
270 | if (wc == BB_NUL) /* usually is */ |
271 | break; |
272 | |
273 | /* We do have invalid byte here! */ |
274 | command_ps[srcpos] = wc; /* restore it */ |
275 | srcpos++; |
276 | if (dstpos == maxsize) |
277 | break; |
278 | dst[dstpos++] = (char) wc; |
279 | } |
280 | dst[dstpos] = '\0'; |
281 | return dstpos; |
282 | # endif |
283 | } else { |
284 | unsigned i = 0; |
285 | while ((dst[i] = command_ps[i]) != 0) |
286 | i++; |
287 | return i; |
288 | } |
289 | } |
290 | /* I thought just fputwc(c, stdout) would work. But no... */ |
291 | static void BB_PUTCHAR(wchar_t c) |
292 | { |
293 | if (unicode_status == UNICODE_ON) { |
294 | char buf[MB_CUR_MAX + 1]; |
295 | mbstate_t mbst = { 0 }; |
296 | ssize_t len = wcrtomb(buf, c, &mbst); |
297 | if (len > 0) { |
298 | buf[len] = '\0'; |
299 | fputs(buf, stdout); |
300 | } |
301 | } else { |
302 | /* In this case, c is always one byte */ |
303 | putchar(c); |
304 | } |
305 | } |
306 | # if ENABLE_UNICODE_COMBINING_WCHARS || ENABLE_UNICODE_WIDE_WCHARS |
307 | static wchar_t adjust_width_and_validate_wc(unsigned *width_adj, wchar_t wc) |
308 | # else |
309 | static wchar_t adjust_width_and_validate_wc(wchar_t wc) |
310 | # define adjust_width_and_validate_wc(width_adj, wc) \ |
311 | ((*(width_adj))++, adjust_width_and_validate_wc(wc)) |
312 | # endif |
313 | { |
314 | int w = 1; |
315 | |
316 | if (unicode_status == UNICODE_ON) { |
317 | if (wc > CONFIG_LAST_SUPPORTED_WCHAR) { |
318 | /* note: also true for unicode_is_raw_byte(wc) */ |
319 | goto subst; |
320 | } |
321 | w = wcwidth(wc); |
322 | if ((ENABLE_UNICODE_COMBINING_WCHARS && w < 0) |
323 | || (!ENABLE_UNICODE_COMBINING_WCHARS && w <= 0) |
324 | || (!ENABLE_UNICODE_WIDE_WCHARS && w > 1) |
325 | ) { |
326 | subst: |
327 | w = 1; |
328 | wc = CONFIG_SUBST_WCHAR; |
329 | } |
330 | } |
331 | |
332 | # if ENABLE_UNICODE_COMBINING_WCHARS || ENABLE_UNICODE_WIDE_WCHARS |
333 | *width_adj += w; |
334 | #endif |
335 | return wc; |
336 | } |
337 | #else /* !UNICODE */ |
338 | static size_t load_string(const char *src) |
339 | { |
340 | safe_strncpy(command_ps, src, S.maxsize); |
341 | return strlen(command_ps); |
342 | } |
343 | # if ENABLE_FEATURE_TAB_COMPLETION |
344 | static void save_string(char *dst, unsigned maxsize) |
345 | { |
346 | safe_strncpy(dst, command_ps, maxsize); |
347 | } |
348 | # endif |
349 | # define BB_PUTCHAR(c) bb_putchar(c) |
350 | /* Should never be called: */ |
351 | int adjust_width_and_validate_wc(unsigned *width_adj, int wc); |
352 | #endif |
353 | |
354 | |
355 | /* Put 'command_ps[cursor]', cursor++. |
356 | * Advance cursor on screen. If we reached right margin, scroll text up |
357 | * and remove terminal margin effect by printing 'next_char' */ |
358 | #define HACK_FOR_WRONG_WIDTH 1 |
359 | static void put_cur_glyph_and_inc_cursor(void) |
360 | { |
361 | CHAR_T c = command_ps[cursor]; |
362 | unsigned width = 0; |
363 | int ofs_to_right; |
364 | |
365 | if (c == BB_NUL) { |
366 | /* erase character after end of input string */ |
367 | c = ' '; |
368 | } else { |
369 | /* advance cursor only if we aren't at the end yet */ |
370 | cursor++; |
371 | if (unicode_status == UNICODE_ON) { |
372 | IF_UNICODE_WIDE_WCHARS(width = cmdedit_x;) |
373 | c = adjust_width_and_validate_wc(&cmdedit_x, c); |
374 | IF_UNICODE_WIDE_WCHARS(width = cmdedit_x - width;) |
375 | } else { |
376 | cmdedit_x++; |
377 | } |
378 | } |
379 | |
380 | ofs_to_right = cmdedit_x - cmdedit_termw; |
381 | if (!ENABLE_UNICODE_WIDE_WCHARS || ofs_to_right <= 0) { |
382 | /* c fits on this line */ |
383 | BB_PUTCHAR(c); |
384 | } |
385 | |
386 | if (ofs_to_right >= 0) { |
387 | /* we go to the next line */ |
388 | #if HACK_FOR_WRONG_WIDTH |
389 | /* This works better if our idea of term width is wrong |
390 | * and it is actually wider (often happens on serial lines). |
391 | * Printing CR,LF *forces* cursor to next line. |
392 | * OTOH if terminal width is correct AND terminal does NOT |
393 | * have automargin (IOW: it is moving cursor to next line |
394 | * by itself (which is wrong for VT-10x terminals)), |
395 | * this will break things: there will be one extra empty line */ |
396 | puts("\r"); /* + implicit '\n' */ |
397 | #else |
398 | /* VT-10x terminals don't wrap cursor to next line when last char |
399 | * on the line is printed - cursor stays "over" this char. |
400 | * Need to print _next_ char too (first one to appear on next line) |
401 | * to make cursor move down to next line. |
402 | */ |
403 | /* Works ok only if cmdedit_termw is correct. */ |
404 | c = command_ps[cursor]; |
405 | if (c == BB_NUL) |
406 | c = ' '; |
407 | BB_PUTCHAR(c); |
408 | bb_putchar('\b'); |
409 | #endif |
410 | cmdedit_y++; |
411 | if (!ENABLE_UNICODE_WIDE_WCHARS || ofs_to_right == 0) { |
412 | width = 0; |
413 | } else { /* ofs_to_right > 0 */ |
414 | /* wide char c didn't fit on prev line */ |
415 | BB_PUTCHAR(c); |
416 | } |
417 | cmdedit_x = width; |
418 | } |
419 | } |
420 | |
421 | /* Move to end of line (by printing all chars till the end) */ |
422 | static void put_till_end_and_adv_cursor(void) |
423 | { |
424 | while (cursor < command_len) |
425 | put_cur_glyph_and_inc_cursor(); |
426 | } |
427 | |
428 | /* Go to the next line */ |
429 | static void goto_new_line(void) |
430 | { |
431 | put_till_end_and_adv_cursor(); |
432 | if (cmdedit_x != 0) |
433 | bb_putchar('\n'); |
434 | } |
435 | |
436 | static void beep(void) |
437 | { |
438 | bb_putchar('\007'); |
439 | } |
440 | |
441 | static void put_prompt(void) |
442 | { |
443 | fputs(cmdedit_prompt, stdout); |
444 | cursor = 0; |
445 | cmdedit_y = cmdedit_prmt_len / cmdedit_termw; /* new quasireal y */ |
446 | cmdedit_x = cmdedit_prmt_len % cmdedit_termw; |
447 | } |
448 | |
449 | /* Move back one character */ |
450 | /* (optimized for slow terminals) */ |
451 | static void input_backward(unsigned num) |
452 | { |
453 | if (num > cursor) |
454 | num = cursor; |
455 | if (num == 0) |
456 | return; |
457 | cursor -= num; |
458 | |
459 | if ((ENABLE_UNICODE_COMBINING_WCHARS || ENABLE_UNICODE_WIDE_WCHARS) |
460 | && unicode_status == UNICODE_ON |
461 | ) { |
462 | /* correct NUM to be equal to _screen_ width */ |
463 | int n = num; |
464 | num = 0; |
465 | while (--n >= 0) |
466 | adjust_width_and_validate_wc(&num, command_ps[cursor + n]); |
467 | if (num == 0) |
468 | return; |
469 | } |
470 | |
471 | if (cmdedit_x >= num) { |
472 | cmdedit_x -= num; |
473 | if (num <= 4) { |
474 | /* This is longer by 5 bytes on x86. |
475 | * Also gets miscompiled for ARM users |
476 | * (busybox.net/bugs/view.php?id=2274). |
477 | * printf(("\b\b\b\b" + 4) - num); |
478 | * return; |
479 | */ |
480 | do { |
481 | bb_putchar('\b'); |
482 | } while (--num); |
483 | return; |
484 | } |
485 | printf(ESC"[%uD", num); |
486 | return; |
487 | } |
488 | |
489 | /* Need to go one or more lines up */ |
490 | if (ENABLE_UNICODE_WIDE_WCHARS) { |
491 | /* With wide chars, it is hard to "backtrack" |
492 | * and reliably figure out where to put cursor. |
493 | * Example (<> is a wide char; # is an ordinary char, _ cursor): |
494 | * |prompt: <><> | |
495 | * |<><><><><><> | |
496 | * |_ | |
497 | * and user presses left arrow. num = 1, cmdedit_x = 0, |
498 | * We need to go up one line, and then - how do we know that |
499 | * we need to go *10* positions to the right? Because |
500 | * |prompt: <>#<>| |
501 | * |<><><>#<><><>| |
502 | * |_ | |
503 | * in this situation we need to go *11* positions to the right. |
504 | * |
505 | * A simpler thing to do is to redraw everything from the start |
506 | * up to new cursor position (which is already known): |
507 | */ |
508 | unsigned sv_cursor; |
509 | /* go to 1st column; go up to first line */ |
510 | printf("\r" ESC"[%uA", cmdedit_y); |
511 | cmdedit_y = 0; |
512 | sv_cursor = cursor; |
513 | put_prompt(); /* sets cursor to 0 */ |
514 | while (cursor < sv_cursor) |
515 | put_cur_glyph_and_inc_cursor(); |
516 | } else { |
517 | int lines_up; |
518 | /* num = chars to go back from the beginning of current line: */ |
519 | num -= cmdedit_x; |
520 | /* num=1...w: one line up, w+1...2w: two, etc: */ |
521 | lines_up = 1 + (num - 1) / cmdedit_termw; |
522 | cmdedit_x = (cmdedit_termw * cmdedit_y - num) % cmdedit_termw; |
523 | cmdedit_y -= lines_up; |
524 | /* go to 1st column; go up */ |
525 | printf("\r" ESC"[%uA", lines_up); |
526 | /* go to correct column. |
527 | * xterm, konsole, Linux VT interpret 0 as 1 below! wow. |
528 | * need to *make sure* we skip it if cmdedit_x == 0 */ |
529 | if (cmdedit_x) |
530 | printf(ESC"[%uC", cmdedit_x); |
531 | } |
532 | } |
533 | |
534 | /* draw prompt, editor line, and clear tail */ |
535 | static void redraw(int y, int back_cursor) |
536 | { |
537 | if (y > 0) /* up y lines */ |
538 | printf(ESC"[%uA", y); |
539 | bb_putchar('\r'); |
540 | put_prompt(); |
541 | put_till_end_and_adv_cursor(); |
542 | printf(SEQ_CLEAR_TILL_END_OF_SCREEN); |
543 | input_backward(back_cursor); |
544 | } |
545 | |
546 | /* Delete the char in front of the cursor, optionally saving it |
547 | * for later putback */ |
548 | #if !ENABLE_FEATURE_EDITING_VI |
549 | static void input_delete(void) |
550 | #define input_delete(save) input_delete() |
551 | #else |
552 | static void input_delete(int save) |
553 | #endif |
554 | { |
555 | int j = cursor; |
556 | |
557 | if (j == (int)command_len) |
558 | return; |
559 | |
560 | #if ENABLE_FEATURE_EDITING_VI |
561 | if (save) { |
562 | if (newdelflag) { |
563 | delptr = delbuf; |
564 | newdelflag = 0; |
565 | } |
566 | if ((delptr - delbuf) < DELBUFSIZ) |
567 | *delptr++ = command_ps[j]; |
568 | } |
569 | #endif |
570 | |
571 | memmove(command_ps + j, command_ps + j + 1, |
572 | /* (command_len + 1 [because of NUL]) - (j + 1) |
573 | * simplified into (command_len - j) */ |
574 | (command_len - j) * sizeof(command_ps[0])); |
575 | command_len--; |
576 | put_till_end_and_adv_cursor(); |
577 | /* Last char is still visible, erase it (and more) */ |
578 | printf(SEQ_CLEAR_TILL_END_OF_SCREEN); |
579 | input_backward(cursor - j); /* back to old pos cursor */ |
580 | } |
581 | |
582 | #if ENABLE_FEATURE_EDITING_VI |
583 | static void put(void) |
584 | { |
585 | int ocursor; |
586 | int j = delptr - delbuf; |
587 | |
588 | if (j == 0) |
589 | return; |
590 | ocursor = cursor; |
591 | /* open hole and then fill it */ |
592 | memmove(command_ps + cursor + j, command_ps + cursor, |
593 | (command_len - cursor + 1) * sizeof(command_ps[0])); |
594 | memcpy(command_ps + cursor, delbuf, j * sizeof(command_ps[0])); |
595 | command_len += j; |
596 | put_till_end_and_adv_cursor(); |
597 | input_backward(cursor - ocursor - j + 1); /* at end of new text */ |
598 | } |
599 | #endif |
600 | |
601 | /* Delete the char in back of the cursor */ |
602 | static void input_backspace(void) |
603 | { |
604 | if (cursor > 0) { |
605 | input_backward(1); |
606 | input_delete(0); |
607 | } |
608 | } |
609 | |
610 | /* Move forward one character */ |
611 | static void input_forward(void) |
612 | { |
613 | if (cursor < command_len) |
614 | put_cur_glyph_and_inc_cursor(); |
615 | } |
616 | |
617 | #if ENABLE_FEATURE_TAB_COMPLETION |
618 | |
619 | //FIXME: |
620 | //needs to be more clever: currently it thinks that "foo\ b<TAB> |
621 | //matches the file named "foo bar", which is untrue. |
622 | //Also, perhaps "foo b<TAB> needs to complete to "foo bar" <cursor>, |
623 | //not "foo bar <cursor>... |
624 | |
625 | static void free_tab_completion_data(void) |
626 | { |
627 | if (matches) { |
628 | while (num_matches) |
629 | free(matches[--num_matches]); |
630 | free(matches); |
631 | matches = NULL; |
632 | } |
633 | } |
634 | |
635 | static void add_match(char *matched) |
636 | { |
637 | matches = xrealloc_vector(matches, 4, num_matches); |
638 | matches[num_matches] = matched; |
639 | num_matches++; |
640 | } |
641 | |
642 | # if ENABLE_FEATURE_USERNAME_COMPLETION |
643 | /* Replace "~user/..." with "/homedir/...". |
644 | * The parameter is malloced, free it or return it |
645 | * unchanged if no user is matched. |
646 | */ |
647 | static char *username_path_completion(char *ud) |
648 | { |
649 | struct passwd *entry; |
650 | char *tilde_name = ud; |
651 | char *home = NULL; |
652 | |
653 | ud++; /* skip ~ */ |
654 | if (*ud == '/') { /* "~/..." */ |
655 | home = home_pwd_buf; |
656 | } else { |
657 | /* "~user/..." */ |
658 | ud = strchr(ud, '/'); |
659 | *ud = '\0'; /* "~user" */ |
660 | entry = getpwnam(tilde_name + 1); |
661 | *ud = '/'; /* restore "~user/..." */ |
662 | if (entry) |
663 | home = entry->pw_dir; |
664 | } |
665 | if (home) { |
666 | ud = concat_path_file(home, ud); |
667 | free(tilde_name); |
668 | tilde_name = ud; |
669 | } |
670 | return tilde_name; |
671 | } |
672 | |
673 | /* ~use<tab> - find all users with this prefix. |
674 | * Return the length of the prefix used for matching. |
675 | */ |
676 | static NOINLINE unsigned complete_username(const char *ud) |
677 | { |
678 | struct passwd *pw; |
679 | unsigned userlen; |
680 | |
681 | ud++; /* skip ~ */ |
682 | userlen = strlen(ud); |
683 | |
684 | setpwent(); |
685 | while ((pw = getpwent()) != NULL) { |
686 | /* Null usernames should result in all users as possible completions. */ |
687 | if (/* !ud[0] || */ is_prefixed_with(pw->pw_name, ud)) { |
688 | add_match(xasprintf("~%s/", pw->pw_name)); |
689 | } |
690 | } |
691 | endpwent(); /* don't keep password file open */ |
692 | |
693 | return 1 + userlen; |
694 | } |
695 | # endif /* FEATURE_USERNAME_COMPLETION */ |
696 | |
697 | enum { |
698 | FIND_EXE_ONLY = 0, |
699 | FIND_DIR_ONLY = 1, |
700 | FIND_FILE_ONLY = 2, |
701 | }; |
702 | |
703 | static int path_parse(char ***p) |
704 | { |
705 | int npth; |
706 | const char *pth; |
707 | char *tmp; |
708 | char **res; |
709 | |
710 | if (state->flags & WITH_PATH_LOOKUP) |
711 | pth = state->path_lookup; |
712 | else |
713 | pth = getenv("PATH"); |
714 | |
715 | /* PATH="" or PATH=":"? */ |
716 | if (!pth || !pth[0] || LONE_CHAR(pth, ':')) |
717 | return 1; |
718 | |
719 | tmp = (char*)pth; |
720 | npth = 1; /* path component count */ |
721 | while (1) { |
722 | tmp = strchr(tmp, ':'); |
723 | if (!tmp) |
724 | break; |
725 | tmp++; |
726 | if (*tmp == '\0') |
727 | break; /* :<empty> */ |
728 | npth++; |
729 | } |
730 | |
731 | *p = res = xmalloc(npth * sizeof(res[0])); |
732 | res[0] = tmp = xstrdup(pth); |
733 | npth = 1; |
734 | while (1) { |
735 | tmp = strchr(tmp, ':'); |
736 | if (!tmp) |
737 | break; |
738 | *tmp++ = '\0'; /* ':' -> '\0' */ |
739 | if (*tmp == '\0') |
740 | break; /* :<empty> */ |
741 | res[npth++] = tmp; |
742 | } |
743 | return npth; |
744 | } |
745 | |
746 | /* Complete command, directory or file name. |
747 | * Return the length of the prefix used for matching. |
748 | */ |
749 | static NOINLINE unsigned complete_cmd_dir_file(const char *command, int type) |
750 | { |
751 | char *path1[1]; |
752 | char **paths = path1; |
753 | int npaths; |
754 | int i; |
755 | unsigned pf_len; |
756 | const char *pfind; |
757 | char *dirbuf = NULL; |
758 | |
759 | npaths = 1; |
760 | path1[0] = (char*)"."; |
761 | |
762 | pfind = strrchr(command, '/'); |
763 | if (!pfind) { |
764 | if (type == FIND_EXE_ONLY) |
765 | npaths = path_parse(&paths); |
766 | pfind = command; |
767 | } else { |
768 | /* point to 'l' in "..../last_component" */ |
769 | pfind++; |
770 | /* dirbuf = ".../.../.../" */ |
771 | dirbuf = xstrndup(command, pfind - command); |
772 | # if ENABLE_FEATURE_USERNAME_COMPLETION |
773 | if (dirbuf[0] == '~') /* ~/... or ~user/... */ |
774 | dirbuf = username_path_completion(dirbuf); |
775 | # endif |
776 | path1[0] = dirbuf; |
777 | } |
778 | pf_len = strlen(pfind); |
779 | |
780 | #if ENABLE_FEATURE_SH_STANDALONE && NUM_APPLETS != 1 |
781 | if (type == FIND_EXE_ONLY && !dirbuf) { |
782 | const char *p = applet_names; |
783 | |
784 | while (*p) { |
785 | if (strncmp(pfind, p, pf_len) == 0) |
786 | add_match(xstrdup(p)); |
787 | while (*p++ != '\0') |
788 | continue; |
789 | } |
790 | } |
791 | #endif |
792 | |
793 | for (i = 0; i < npaths; i++) { |
794 | DIR *dir; |
795 | struct dirent *next; |
796 | struct stat st; |
797 | char *found; |
798 | |
799 | dir = opendir(paths[i]); |
800 | if (!dir) |
801 | continue; /* don't print an error */ |
802 | |
803 | while ((next = readdir(dir)) != NULL) { |
804 | unsigned len; |
805 | const char *name_found = next->d_name; |
806 | |
807 | /* .../<tab>: bash 3.2.0 shows dotfiles, but not . and .. */ |
808 | if (!pfind[0] && DOT_OR_DOTDOT(name_found)) |
809 | continue; |
810 | /* match? */ |
811 | if (!is_prefixed_with(name_found, pfind)) |
812 | continue; /* no */ |
813 | |
814 | found = concat_path_file(paths[i], name_found); |
815 | /* NB: stat() first so that we see is it a directory; |
816 | * but if that fails, use lstat() so that |
817 | * we still match dangling links */ |
818 | if (stat(found, &st) && lstat(found, &st)) |
819 | goto cont; /* hmm, remove in progress? */ |
820 | |
821 | /* Save only name */ |
822 | len = strlen(name_found); |
823 | found = xrealloc(found, len + 2); /* +2: for slash and NUL */ |
824 | strcpy(found, name_found); |
825 | |
826 | if (S_ISDIR(st.st_mode)) { |
827 | /* name is a directory, add slash */ |
828 | found[len] = '/'; |
829 | found[len + 1] = '\0'; |
830 | } else { |
831 | /* skip files if looking for dirs only (example: cd) */ |
832 | if (type == FIND_DIR_ONLY) |
833 | goto cont; |
834 | } |
835 | /* add it to the list */ |
836 | add_match(found); |
837 | continue; |
838 | cont: |
839 | free(found); |
840 | } |
841 | closedir(dir); |
842 | } /* for every path */ |
843 | |
844 | if (paths != path1) { |
845 | free(paths[0]); /* allocated memory is only in first member */ |
846 | free(paths); |
847 | } |
848 | free(dirbuf); |
849 | |
850 | return pf_len; |
851 | } |
852 | |
853 | /* build_match_prefix: |
854 | * On entry, match_buf contains everything up to cursor at the moment <tab> |
855 | * was pressed. This function looks at it, figures out what part of it |
856 | * constitutes the command/file/directory prefix to use for completion, |
857 | * and rewrites match_buf to contain only that part. |
858 | */ |
859 | #define dbg_bmp 0 |
860 | /* Helpers: */ |
861 | /* QUOT is used on elements of int_buf[], which are bytes, |
862 | * not Unicode chars. Therefore it works correctly even in Unicode mode. |
863 | */ |
864 | #define QUOT (UCHAR_MAX+1) |
865 | static void remove_chunk(int16_t *int_buf, int beg, int end) |
866 | { |
867 | /* beg must be <= end */ |
868 | if (beg == end) |
869 | return; |
870 | |
871 | while ((int_buf[beg] = int_buf[end]) != 0) |
872 | beg++, end++; |
873 | |
874 | if (dbg_bmp) { |
875 | int i; |
876 | for (i = 0; int_buf[i]; i++) |
877 | bb_putchar((unsigned char)int_buf[i]); |
878 | bb_putchar('\n'); |
879 | } |
880 | } |
881 | /* Caller ensures that match_buf points to a malloced buffer |
882 | * big enough to hold strlen(match_buf)*2 + 2 |
883 | */ |
884 | static NOINLINE int build_match_prefix(char *match_buf) |
885 | { |
886 | int i, j; |
887 | int command_mode; |
888 | int16_t *int_buf = (int16_t*)match_buf; |
889 | |
890 | if (dbg_bmp) printf("\n%s\n", match_buf); |
891 | |
892 | /* Copy in reverse order, since they overlap */ |
893 | i = strlen(match_buf); |
894 | do { |
895 | int_buf[i] = (unsigned char)match_buf[i]; |
896 | i--; |
897 | } while (i >= 0); |
898 | |
899 | /* Mark every \c as "quoted c" */ |
900 | for (i = 0; int_buf[i]; i++) { |
901 | if (int_buf[i] == '\\') { |
902 | remove_chunk(int_buf, i, i + 1); |
903 | int_buf[i] |= QUOT; |
904 | } |
905 | } |
906 | /* Quote-mark "chars" and 'chars', drop delimiters */ |
907 | { |
908 | int in_quote = 0; |
909 | i = 0; |
910 | while (int_buf[i]) { |
911 | int cur = int_buf[i]; |
912 | if (!cur) |
913 | break; |
914 | if (cur == '\'' || cur == '"') { |
915 | if (!in_quote || (cur == in_quote)) { |
916 | in_quote ^= cur; |
917 | remove_chunk(int_buf, i, i + 1); |
918 | continue; |
919 | } |
920 | } |
921 | if (in_quote) |
922 | int_buf[i] = cur | QUOT; |
923 | i++; |
924 | } |
925 | } |
926 | |
927 | /* Remove everything up to command delimiters: |
928 | * ';' ';;' '&' '|' '&&' '||', |
929 | * but careful with '>&' '<&' '>|' |
930 | */ |
931 | for (i = 0; int_buf[i]; i++) { |
932 | int cur = int_buf[i]; |
933 | if (cur == ';' || cur == '&' || cur == '|') { |
934 | int prev = i ? int_buf[i - 1] : 0; |
935 | if (cur == '&' && (prev == '>' || prev == '<')) { |
936 | continue; |
937 | } else if (cur == '|' && prev == '>') { |
938 | continue; |
939 | } |
940 | remove_chunk(int_buf, 0, i + 1 + (cur == int_buf[i + 1])); |
941 | i = -1; /* back to square 1 */ |
942 | } |
943 | } |
944 | /* Remove all `cmd` */ |
945 | for (i = 0; int_buf[i]; i++) { |
946 | if (int_buf[i] == '`') { |
947 | for (j = i + 1; int_buf[j]; j++) { |
948 | if (int_buf[j] == '`') { |
949 | /* `cmd` should count as a word: |
950 | * `cmd` c<tab> should search for files c*, |
951 | * not commands c*. Therefore we don't drop |
952 | * `cmd` entirely, we replace it with single `. |
953 | */ |
954 | remove_chunk(int_buf, i, j); |
955 | goto next; |
956 | } |
957 | } |
958 | /* No closing ` - command mode, remove all up to ` */ |
959 | remove_chunk(int_buf, 0, i + 1); |
960 | break; |
961 | next: ; |
962 | } |
963 | } |
964 | |
965 | /* Remove "cmd (" and "cmd {" |
966 | * Example: "if { c<tab>" |
967 | * In this example, c should be matched as command pfx. |
968 | */ |
969 | for (i = 0; int_buf[i]; i++) { |
970 | if (int_buf[i] == '(' || int_buf[i] == '{') { |
971 | remove_chunk(int_buf, 0, i + 1); |
972 | i = -1; /* back to square 1 */ |
973 | } |
974 | } |
975 | |
976 | /* Remove leading unquoted spaces */ |
977 | for (i = 0; int_buf[i]; i++) |
978 | if (int_buf[i] != ' ') |
979 | break; |
980 | remove_chunk(int_buf, 0, i); |
981 | |
982 | /* Determine completion mode */ |
983 | command_mode = FIND_EXE_ONLY; |
984 | for (i = 0; int_buf[i]; i++) { |
985 | if (int_buf[i] == ' ' || int_buf[i] == '<' || int_buf[i] == '>') { |
986 | if (int_buf[i] == ' ' |
987 | && command_mode == FIND_EXE_ONLY |
988 | && (char)int_buf[0] == 'c' |
989 | && (char)int_buf[1] == 'd' |
990 | && i == 2 /* -> int_buf[2] == ' ' */ |
991 | ) { |
992 | command_mode = FIND_DIR_ONLY; |
993 | } else { |
994 | command_mode = FIND_FILE_ONLY; |
995 | break; |
996 | } |
997 | } |
998 | } |
999 | if (dbg_bmp) printf("command_mode(0:exe/1:dir/2:file):%d\n", command_mode); |
1000 | |
1001 | /* Remove everything except last word */ |
1002 | for (i = 0; int_buf[i]; i++) /* quasi-strlen(int_buf) */ |
1003 | continue; |
1004 | for (--i; i >= 0; i--) { |
1005 | int cur = int_buf[i]; |
1006 | if (cur == ' ' || cur == '<' || cur == '>' || cur == '|' || cur == '&') { |
1007 | remove_chunk(int_buf, 0, i + 1); |
1008 | break; |
1009 | } |
1010 | } |
1011 | |
1012 | /* Convert back to string of _chars_ */ |
1013 | i = 0; |
1014 | while ((match_buf[i] = int_buf[i]) != '\0') |
1015 | i++; |
1016 | |
1017 | if (dbg_bmp) printf("final match_buf:'%s'\n", match_buf); |
1018 | |
1019 | return command_mode; |
1020 | } |
1021 | |
1022 | /* |
1023 | * Display by column (original idea from ls applet, |
1024 | * very optimized by me [Vladimir] :) |
1025 | */ |
1026 | static void showfiles(void) |
1027 | { |
1028 | int ncols, row; |
1029 | int column_width = 0; |
1030 | int nfiles = num_matches; |
1031 | int nrows = nfiles; |
1032 | int l; |
1033 | |
1034 | /* find the longest file name - use that as the column width */ |
1035 | for (row = 0; row < nrows; row++) { |
1036 | l = unicode_strwidth(matches[row]); |
1037 | if (column_width < l) |
1038 | column_width = l; |
1039 | } |
1040 | column_width += 2; /* min space for columns */ |
1041 | ncols = cmdedit_termw / column_width; |
1042 | |
1043 | if (ncols > 1) { |
1044 | nrows /= ncols; |
1045 | if (nfiles % ncols) |
1046 | nrows++; /* round up fractionals */ |
1047 | } else { |
1048 | ncols = 1; |
1049 | } |
1050 | for (row = 0; row < nrows; row++) { |
1051 | int n = row; |
1052 | int nc; |
1053 | |
1054 | for (nc = 1; nc < ncols && n+nrows < nfiles; n += nrows, nc++) { |
1055 | printf("%s%-*s", matches[n], |
1056 | (int)(column_width - unicode_strwidth(matches[n])), "" |
1057 | ); |
1058 | } |
1059 | if (ENABLE_UNICODE_SUPPORT) |
1060 | puts(printable_string(NULL, matches[n])); |
1061 | else |
1062 | puts(matches[n]); |
1063 | } |
1064 | } |
1065 | |
1066 | static const char *is_special_char(char c) |
1067 | { |
1068 | return strchr(" `\"#$%^&*()=+{}[]:;'|\\<>", c); |
1069 | } |
1070 | |
1071 | static char *quote_special_chars(char *found) |
1072 | { |
1073 | int l = 0; |
1074 | char *s = xzalloc((strlen(found) + 1) * 2); |
1075 | |
1076 | while (*found) { |
1077 | if (is_special_char(*found)) |
1078 | s[l++] = '\\'; |
1079 | s[l++] = *found++; |
1080 | } |
1081 | /* s[l] = '\0'; - already is */ |
1082 | return s; |
1083 | } |
1084 | |
1085 | /* Do TAB completion */ |
1086 | static NOINLINE void input_tab(smallint *lastWasTab) |
1087 | { |
1088 | char *chosen_match; |
1089 | char *match_buf; |
1090 | size_t len_found; |
1091 | /* Length of string used for matching */ |
1092 | unsigned match_pfx_len = match_pfx_len; |
1093 | int find_type; |
1094 | # if ENABLE_UNICODE_SUPPORT |
1095 | /* cursor pos in command converted to multibyte form */ |
1096 | int cursor_mb; |
1097 | # endif |
1098 | if (!(state->flags & TAB_COMPLETION)) |
1099 | return; |
1100 | |
1101 | if (*lastWasTab) { |
1102 | /* The last char was a TAB too. |
1103 | * Print a list of all the available choices. |
1104 | */ |
1105 | if (num_matches > 0) { |
1106 | /* cursor will be changed by goto_new_line() */ |
1107 | int sav_cursor = cursor; |
1108 | goto_new_line(); |
1109 | showfiles(); |
1110 | redraw(0, command_len - sav_cursor); |
1111 | } |
1112 | return; |
1113 | } |
1114 | |
1115 | *lastWasTab = 1; |
1116 | chosen_match = NULL; |
1117 | |
1118 | /* Make a local copy of the string up to the position of the cursor. |
1119 | * build_match_prefix will expand it into int16_t's, need to allocate |
1120 | * twice as much as the string_len+1. |
1121 | * (we then also (ab)use this extra space later - see (**)) |
1122 | */ |
1123 | match_buf = xmalloc(MAX_LINELEN * sizeof(int16_t)); |
1124 | # if !ENABLE_UNICODE_SUPPORT |
1125 | save_string(match_buf, cursor + 1); /* +1 for NUL */ |
1126 | # else |
1127 | { |
1128 | CHAR_T wc = command_ps[cursor]; |
1129 | command_ps[cursor] = BB_NUL; |
1130 | save_string(match_buf, MAX_LINELEN); |
1131 | command_ps[cursor] = wc; |
1132 | cursor_mb = strlen(match_buf); |
1133 | } |
1134 | # endif |
1135 | find_type = build_match_prefix(match_buf); |
1136 | |
1137 | /* Free up any memory already allocated */ |
1138 | free_tab_completion_data(); |
1139 | |
1140 | # if ENABLE_FEATURE_USERNAME_COMPLETION |
1141 | /* If the word starts with ~ and there is no slash in the word, |
1142 | * then try completing this word as a username. */ |
1143 | if (state->flags & USERNAME_COMPLETION) |
1144 | if (match_buf[0] == '~' && strchr(match_buf, '/') == NULL) |
1145 | match_pfx_len = complete_username(match_buf); |
1146 | # endif |
1147 | /* If complete_username() did not match, |
1148 | * try to match a command in $PATH, or a directory, or a file */ |
1149 | if (!matches) |
1150 | match_pfx_len = complete_cmd_dir_file(match_buf, find_type); |
1151 | |
1152 | /* Account for backslashes which will be inserted |
1153 | * by quote_special_chars() later */ |
1154 | { |
1155 | const char *e = match_buf + strlen(match_buf); |
1156 | const char *s = e - match_pfx_len; |
1157 | while (s < e) |
1158 | if (is_special_char(*s++)) |
1159 | match_pfx_len++; |
1160 | } |
1161 | |
1162 | /* Remove duplicates */ |
1163 | if (matches) { |
1164 | unsigned i, n = 0; |
1165 | qsort_string_vector(matches, num_matches); |
1166 | for (i = 0; i < num_matches - 1; ++i) { |
1167 | //if (matches[i] && matches[i+1]) { /* paranoia */ |
1168 | if (strcmp(matches[i], matches[i+1]) == 0) { |
1169 | free(matches[i]); |
1170 | //matches[i] = NULL; /* paranoia */ |
1171 | } else { |
1172 | matches[n++] = matches[i]; |
1173 | } |
1174 | //} |
1175 | } |
1176 | matches[n++] = matches[i]; |
1177 | num_matches = n; |
1178 | } |
1179 | |
1180 | /* Did we find exactly one match? */ |
1181 | if (num_matches != 1) { /* no */ |
1182 | char *cp; |
1183 | beep(); |
1184 | if (!matches) |
1185 | goto ret; /* no matches at all */ |
1186 | /* Find common prefix */ |
1187 | chosen_match = xstrdup(matches[0]); |
1188 | for (cp = chosen_match; *cp; cp++) { |
1189 | unsigned n; |
1190 | for (n = 1; n < num_matches; n++) { |
1191 | if (matches[n][cp - chosen_match] != *cp) { |
1192 | goto stop; |
1193 | } |
1194 | } |
1195 | } |
1196 | stop: |
1197 | if (cp == chosen_match) { /* have unique prefix? */ |
1198 | goto ret; /* no */ |
1199 | } |
1200 | *cp = '\0'; |
1201 | cp = quote_special_chars(chosen_match); |
1202 | free(chosen_match); |
1203 | chosen_match = cp; |
1204 | len_found = strlen(chosen_match); |
1205 | } else { /* exactly one match */ |
1206 | /* Next <tab> is not a double-tab */ |
1207 | *lastWasTab = 0; |
1208 | |
1209 | chosen_match = quote_special_chars(matches[0]); |
1210 | len_found = strlen(chosen_match); |
1211 | if (chosen_match[len_found-1] != '/') { |
1212 | chosen_match[len_found] = ' '; |
1213 | chosen_match[++len_found] = '\0'; |
1214 | } |
1215 | } |
1216 | |
1217 | # if !ENABLE_UNICODE_SUPPORT |
1218 | /* Have space to place the match? */ |
1219 | /* The result consists of three parts with these lengths: */ |
1220 | /* cursor + (len_found - match_pfx_len) + (command_len - cursor) */ |
1221 | /* it simplifies into: */ |
1222 | if ((int)(len_found - match_pfx_len + command_len) < S.maxsize) { |
1223 | int pos; |
1224 | /* save tail */ |
1225 | strcpy(match_buf, &command_ps[cursor]); |
1226 | /* add match and tail */ |
1227 | sprintf(&command_ps[cursor], "%s%s", chosen_match + match_pfx_len, match_buf); |
1228 | command_len = strlen(command_ps); |
1229 | /* new pos */ |
1230 | pos = cursor + len_found - match_pfx_len; |
1231 | /* write out the matched command */ |
1232 | redraw(cmdedit_y, command_len - pos); |
1233 | } |
1234 | # else |
1235 | { |
1236 | /* Use 2nd half of match_buf as scratch space - see (**) */ |
1237 | char *command = match_buf + MAX_LINELEN; |
1238 | int len = save_string(command, MAX_LINELEN); |
1239 | /* Have space to place the match? */ |
1240 | /* cursor_mb + (len_found - match_pfx_len) + (len - cursor_mb) */ |
1241 | if ((int)(len_found - match_pfx_len + len) < MAX_LINELEN) { |
1242 | int pos; |
1243 | /* save tail */ |
1244 | strcpy(match_buf, &command[cursor_mb]); |
1245 | /* where do we want to have cursor after all? */ |
1246 | strcpy(&command[cursor_mb], chosen_match + match_pfx_len); |
1247 | len = load_string(command); |
1248 | /* add match and tail */ |
1249 | sprintf(&command[cursor_mb], "%s%s", chosen_match + match_pfx_len, match_buf); |
1250 | command_len = load_string(command); |
1251 | /* write out the matched command */ |
1252 | /* paranoia: load_string can return 0 on conv error, |
1253 | * prevent passing pos = (0 - 12) to redraw */ |
1254 | pos = command_len - len; |
1255 | redraw(cmdedit_y, pos >= 0 ? pos : 0); |
1256 | } |
1257 | } |
1258 | # endif |
1259 | ret: |
1260 | free(chosen_match); |
1261 | free(match_buf); |
1262 | } |
1263 | |
1264 | #endif /* FEATURE_TAB_COMPLETION */ |
1265 | |
1266 | |
1267 | line_input_t* FAST_FUNC new_line_input_t(int flags) |
1268 | { |
1269 | line_input_t *n = xzalloc(sizeof(*n)); |
1270 | n->flags = flags; |
1271 | #if MAX_HISTORY > 0 |
1272 | n->max_history = MAX_HISTORY; |
1273 | #endif |
1274 | return n; |
1275 | } |
1276 | |
1277 | |
1278 | #if MAX_HISTORY > 0 |
1279 | |
1280 | unsigned FAST_FUNC size_from_HISTFILESIZE(const char *hp) |
1281 | { |
1282 | int size = MAX_HISTORY; |
1283 | if (hp) { |
1284 | size = atoi(hp); |
1285 | if (size <= 0) |
1286 | return 1; |
1287 | if (size > MAX_HISTORY) |
1288 | return MAX_HISTORY; |
1289 | } |
1290 | return size; |
1291 | } |
1292 | |
1293 | static void save_command_ps_at_cur_history(void) |
1294 | { |
1295 | if (command_ps[0] != BB_NUL) { |
1296 | int cur = state->cur_history; |
1297 | free(state->history[cur]); |
1298 | |
1299 | # if ENABLE_UNICODE_SUPPORT |
1300 | { |
1301 | char tbuf[MAX_LINELEN]; |
1302 | save_string(tbuf, sizeof(tbuf)); |
1303 | state->history[cur] = xstrdup(tbuf); |
1304 | } |
1305 | # else |
1306 | state->history[cur] = xstrdup(command_ps); |
1307 | # endif |
1308 | } |
1309 | } |
1310 | |
1311 | /* state->flags is already checked to be nonzero */ |
1312 | static int get_previous_history(void) |
1313 | { |
1314 | if ((state->flags & DO_HISTORY) && state->cur_history) { |
1315 | save_command_ps_at_cur_history(); |
1316 | state->cur_history--; |
1317 | return 1; |
1318 | } |
1319 | beep(); |
1320 | return 0; |
1321 | } |
1322 | |
1323 | static int get_next_history(void) |
1324 | { |
1325 | if (state->flags & DO_HISTORY) { |
1326 | if (state->cur_history < state->cnt_history) { |
1327 | save_command_ps_at_cur_history(); /* save the current history line */ |
1328 | return ++state->cur_history; |
1329 | } |
1330 | } |
1331 | beep(); |
1332 | return 0; |
1333 | } |
1334 | |
1335 | /* Lists command history. Used by shell 'history' builtins */ |
1336 | void FAST_FUNC show_history(const line_input_t *st) |
1337 | { |
1338 | int i; |
1339 | |
1340 | if (!st) |
1341 | return; |
1342 | for (i = 0; i < st->cnt_history; i++) |
1343 | printf("%4d %s\n", i, st->history[i]); |
1344 | } |
1345 | |
1346 | # if ENABLE_FEATURE_EDITING_SAVEHISTORY |
1347 | /* We try to ensure that concurrent additions to the history |
1348 | * do not overwrite each other. |
1349 | * Otherwise shell users get unhappy. |
1350 | * |
1351 | * History file is trimmed lazily, when it grows several times longer |
1352 | * than configured MAX_HISTORY lines. |
1353 | */ |
1354 | |
1355 | static void free_line_input_t(line_input_t *n) |
1356 | { |
1357 | int i = n->cnt_history; |
1358 | while (i > 0) |
1359 | free(n->history[--i]); |
1360 | free(n); |
1361 | } |
1362 | |
1363 | /* state->flags is already checked to be nonzero */ |
1364 | static void load_history(line_input_t *st_parm) |
1365 | { |
1366 | char *temp_h[MAX_HISTORY]; |
1367 | char *line; |
1368 | FILE *fp; |
1369 | unsigned idx, i, line_len; |
1370 | |
1371 | /* NB: do not trash old history if file can't be opened */ |
1372 | |
1373 | fp = fopen_for_read(st_parm->hist_file); |
1374 | if (fp) { |
1375 | /* clean up old history */ |
1376 | for (idx = st_parm->cnt_history; idx > 0;) { |
1377 | idx--; |
1378 | free(st_parm->history[idx]); |
1379 | st_parm->history[idx] = NULL; |
1380 | } |
1381 | |
1382 | /* fill temp_h[], retaining only last MAX_HISTORY lines */ |
1383 | memset(temp_h, 0, sizeof(temp_h)); |
1384 | idx = 0; |
1385 | st_parm->cnt_history_in_file = 0; |
1386 | while ((line = xmalloc_fgetline(fp)) != NULL) { |
1387 | if (line[0] == '\0') { |
1388 | free(line); |
1389 | continue; |
1390 | } |
1391 | free(temp_h[idx]); |
1392 | temp_h[idx] = line; |
1393 | st_parm->cnt_history_in_file++; |
1394 | idx++; |
1395 | if (idx == st_parm->max_history) |
1396 | idx = 0; |
1397 | } |
1398 | fclose(fp); |
1399 | |
1400 | /* find first non-NULL temp_h[], if any */ |
1401 | if (st_parm->cnt_history_in_file) { |
1402 | while (temp_h[idx] == NULL) { |
1403 | idx++; |
1404 | if (idx == st_parm->max_history) |
1405 | idx = 0; |
1406 | } |
1407 | } |
1408 | |
1409 | /* copy temp_h[] to st_parm->history[] */ |
1410 | for (i = 0; i < st_parm->max_history;) { |
1411 | line = temp_h[idx]; |
1412 | if (!line) |
1413 | break; |
1414 | idx++; |
1415 | if (idx == st_parm->max_history) |
1416 | idx = 0; |
1417 | line_len = strlen(line); |
1418 | if (line_len >= MAX_LINELEN) |
1419 | line[MAX_LINELEN-1] = '\0'; |
1420 | st_parm->history[i++] = line; |
1421 | } |
1422 | st_parm->cnt_history = i; |
1423 | if (ENABLE_FEATURE_EDITING_SAVE_ON_EXIT) |
1424 | st_parm->cnt_history_in_file = i; |
1425 | } |
1426 | } |
1427 | |
1428 | # if ENABLE_FEATURE_EDITING_SAVE_ON_EXIT |
1429 | void save_history(line_input_t *st) |
1430 | { |
1431 | FILE *fp; |
1432 | |
1433 | if (!st->hist_file) |
1434 | return; |
1435 | if (st->cnt_history <= st->cnt_history_in_file) |
1436 | return; |
1437 | |
1438 | fp = fopen(st->hist_file, "a"); |
1439 | if (fp) { |
1440 | int i, fd; |
1441 | char *new_name; |
1442 | line_input_t *st_temp; |
1443 | |
1444 | for (i = st->cnt_history_in_file; i < st->cnt_history; i++) |
1445 | fprintf(fp, "%s\n", st->history[i]); |
1446 | fclose(fp); |
1447 | |
1448 | /* we may have concurrently written entries from others. |
1449 | * load them */ |
1450 | st_temp = new_line_input_t(st->flags); |
1451 | st_temp->hist_file = st->hist_file; |
1452 | st_temp->max_history = st->max_history; |
1453 | load_history(st_temp); |
1454 | |
1455 | /* write out temp file and replace hist_file atomically */ |
1456 | new_name = xasprintf("%s.%u.new", st->hist_file, (int) getpid()); |
1457 | fd = open(new_name, O_WRONLY | O_CREAT | O_TRUNC, 0600); |
1458 | if (fd >= 0) { |
1459 | fp = xfdopen_for_write(fd); |
1460 | for (i = 0; i < st_temp->cnt_history; i++) |
1461 | fprintf(fp, "%s\n", st_temp->history[i]); |
1462 | fclose(fp); |
1463 | if (rename(new_name, st->hist_file) == 0) |
1464 | st->cnt_history_in_file = st_temp->cnt_history; |
1465 | } |
1466 | free(new_name); |
1467 | free_line_input_t(st_temp); |
1468 | } |
1469 | } |
1470 | # else |
1471 | static void save_history(char *str) |
1472 | { |
1473 | int fd; |
1474 | int len, len2; |
1475 | |
1476 | if (!state->hist_file) |
1477 | return; |
1478 | |
1479 | fd = open(state->hist_file, O_WRONLY | O_CREAT | O_APPEND, 0600); |
1480 | if (fd < 0) |
1481 | return; |
1482 | xlseek(fd, 0, SEEK_END); /* paranoia */ |
1483 | len = strlen(str); |
1484 | str[len] = '\n'; /* we (try to) do atomic write */ |
1485 | len2 = full_write(fd, str, len + 1); |
1486 | str[len] = '\0'; |
1487 | close(fd); |
1488 | if (len2 != len + 1) |
1489 | return; /* "wtf?" */ |
1490 | |
1491 | /* did we write so much that history file needs trimming? */ |
1492 | state->cnt_history_in_file++; |
1493 | if (state->cnt_history_in_file > state->max_history * 4) { |
1494 | char *new_name; |
1495 | line_input_t *st_temp; |
1496 | |
1497 | /* we may have concurrently written entries from others. |
1498 | * load them */ |
1499 | st_temp = new_line_input_t(state->flags); |
1500 | st_temp->hist_file = state->hist_file; |
1501 | st_temp->max_history = state->max_history; |
1502 | load_history(st_temp); |
1503 | |
1504 | /* write out temp file and replace hist_file atomically */ |
1505 | new_name = xasprintf("%s.%u.new", state->hist_file, (int) getpid()); |
1506 | fd = open(new_name, O_WRONLY | O_CREAT | O_TRUNC, 0600); |
1507 | if (fd >= 0) { |
1508 | FILE *fp; |
1509 | int i; |
1510 | |
1511 | fp = xfdopen_for_write(fd); |
1512 | for (i = 0; i < st_temp->cnt_history; i++) |
1513 | fprintf(fp, "%s\n", st_temp->history[i]); |
1514 | fclose(fp); |
1515 | if (rename(new_name, state->hist_file) == 0) |
1516 | state->cnt_history_in_file = st_temp->cnt_history; |
1517 | } |
1518 | free(new_name); |
1519 | free_line_input_t(st_temp); |
1520 | } |
1521 | } |
1522 | # endif |
1523 | # else |
1524 | # define load_history(a) ((void)0) |
1525 | # define save_history(a) ((void)0) |
1526 | # endif /* FEATURE_COMMAND_SAVEHISTORY */ |
1527 | |
1528 | static void remember_in_history(char *str) |
1529 | { |
1530 | int i; |
1531 | |
1532 | if (!(state->flags & DO_HISTORY)) |
1533 | return; |
1534 | if (str[0] == '\0') |
1535 | return; |
1536 | i = state->cnt_history; |
1537 | /* Don't save dupes */ |
1538 | if (i && strcmp(state->history[i-1], str) == 0) |
1539 | return; |
1540 | |
1541 | free(state->history[state->max_history]); /* redundant, paranoia */ |
1542 | state->history[state->max_history] = NULL; /* redundant, paranoia */ |
1543 | |
1544 | /* If history[] is full, remove the oldest command */ |
1545 | /* we need to keep history[state->max_history] empty, hence >=, not > */ |
1546 | if (i >= state->max_history) { |
1547 | free(state->history[0]); |
1548 | for (i = 0; i < state->max_history-1; i++) |
1549 | state->history[i] = state->history[i+1]; |
1550 | /* i == state->max_history-1 */ |
1551 | # if ENABLE_FEATURE_EDITING_SAVE_ON_EXIT |
1552 | if (state->cnt_history_in_file) |
1553 | state->cnt_history_in_file--; |
1554 | # endif |
1555 | } |
1556 | /* i <= state->max_history-1 */ |
1557 | state->history[i++] = xstrdup(str); |
1558 | /* i <= state->max_history */ |
1559 | state->cur_history = i; |
1560 | state->cnt_history = i; |
1561 | # if ENABLE_FEATURE_EDITING_SAVEHISTORY && !ENABLE_FEATURE_EDITING_SAVE_ON_EXIT |
1562 | save_history(str); |
1563 | # endif |
1564 | } |
1565 | |
1566 | #else /* MAX_HISTORY == 0 */ |
1567 | # define remember_in_history(a) ((void)0) |
1568 | #endif /* MAX_HISTORY */ |
1569 | |
1570 | |
1571 | #if ENABLE_FEATURE_EDITING_VI |
1572 | /* |
1573 | * vi mode implemented 2005 by Paul Fox <pgf@foxharp.boston.ma.us> |
1574 | */ |
1575 | static void |
1576 | vi_Word_motion(int eat) |
1577 | { |
1578 | CHAR_T *command = command_ps; |
1579 | |
1580 | while (cursor < command_len && !BB_isspace(command[cursor])) |
1581 | input_forward(); |
1582 | if (eat) while (cursor < command_len && BB_isspace(command[cursor])) |
1583 | input_forward(); |
1584 | } |
1585 | |
1586 | static void |
1587 | vi_word_motion(int eat) |
1588 | { |
1589 | CHAR_T *command = command_ps; |
1590 | |
1591 | if (BB_isalnum_or_underscore(command[cursor])) { |
1592 | while (cursor < command_len |
1593 | && (BB_isalnum_or_underscore(command[cursor+1])) |
1594 | ) { |
1595 | input_forward(); |
1596 | } |
1597 | } else if (BB_ispunct(command[cursor])) { |
1598 | while (cursor < command_len && BB_ispunct(command[cursor+1])) |
1599 | input_forward(); |
1600 | } |
1601 | |
1602 | if (cursor < command_len) |
1603 | input_forward(); |
1604 | |
1605 | if (eat) { |
1606 | while (cursor < command_len && BB_isspace(command[cursor])) |
1607 | input_forward(); |
1608 | } |
1609 | } |
1610 | |
1611 | static void |
1612 | vi_End_motion(void) |
1613 | { |
1614 | CHAR_T *command = command_ps; |
1615 | |
1616 | input_forward(); |
1617 | while (cursor < command_len && BB_isspace(command[cursor])) |
1618 | input_forward(); |
1619 | while (cursor < command_len-1 && !BB_isspace(command[cursor+1])) |
1620 | input_forward(); |
1621 | } |
1622 | |
1623 | static void |
1624 | vi_end_motion(void) |
1625 | { |
1626 | CHAR_T *command = command_ps; |
1627 | |
1628 | if (cursor >= command_len-1) |
1629 | return; |
1630 | input_forward(); |
1631 | while (cursor < command_len-1 && BB_isspace(command[cursor])) |
1632 | input_forward(); |
1633 | if (cursor >= command_len-1) |
1634 | return; |
1635 | if (BB_isalnum_or_underscore(command[cursor])) { |
1636 | while (cursor < command_len-1 |
1637 | && (BB_isalnum_or_underscore(command[cursor+1])) |
1638 | ) { |
1639 | input_forward(); |
1640 | } |
1641 | } else if (BB_ispunct(command[cursor])) { |
1642 | while (cursor < command_len-1 && BB_ispunct(command[cursor+1])) |
1643 | input_forward(); |
1644 | } |
1645 | } |
1646 | |
1647 | static void |
1648 | vi_Back_motion(void) |
1649 | { |
1650 | CHAR_T *command = command_ps; |
1651 | |
1652 | while (cursor > 0 && BB_isspace(command[cursor-1])) |
1653 | input_backward(1); |
1654 | while (cursor > 0 && !BB_isspace(command[cursor-1])) |
1655 | input_backward(1); |
1656 | } |
1657 | |
1658 | static void |
1659 | vi_back_motion(void) |
1660 | { |
1661 | CHAR_T *command = command_ps; |
1662 | |
1663 | if (cursor <= 0) |
1664 | return; |
1665 | input_backward(1); |
1666 | while (cursor > 0 && BB_isspace(command[cursor])) |
1667 | input_backward(1); |
1668 | if (cursor <= 0) |
1669 | return; |
1670 | if (BB_isalnum_or_underscore(command[cursor])) { |
1671 | while (cursor > 0 |
1672 | && (BB_isalnum_or_underscore(command[cursor-1])) |
1673 | ) { |
1674 | input_backward(1); |
1675 | } |
1676 | } else if (BB_ispunct(command[cursor])) { |
1677 | while (cursor > 0 && BB_ispunct(command[cursor-1])) |
1678 | input_backward(1); |
1679 | } |
1680 | } |
1681 | #endif |
1682 | |
1683 | /* Modelled after bash 4.0 behavior of Ctrl-<arrow> */ |
1684 | static void ctrl_left(void) |
1685 | { |
1686 | CHAR_T *command = command_ps; |
1687 | |
1688 | while (1) { |
1689 | CHAR_T c; |
1690 | |
1691 | input_backward(1); |
1692 | if (cursor == 0) |
1693 | break; |
1694 | c = command[cursor]; |
1695 | if (c != ' ' && !BB_ispunct(c)) { |
1696 | /* we reached a "word" delimited by spaces/punct. |
1697 | * go to its beginning */ |
1698 | while (1) { |
1699 | c = command[cursor - 1]; |
1700 | if (c == ' ' || BB_ispunct(c)) |
1701 | break; |
1702 | input_backward(1); |
1703 | if (cursor == 0) |
1704 | break; |
1705 | } |
1706 | break; |
1707 | } |
1708 | } |
1709 | } |
1710 | static void ctrl_right(void) |
1711 | { |
1712 | CHAR_T *command = command_ps; |
1713 | |
1714 | while (1) { |
1715 | CHAR_T c; |
1716 | |
1717 | c = command[cursor]; |
1718 | if (c == BB_NUL) |
1719 | break; |
1720 | if (c != ' ' && !BB_ispunct(c)) { |
1721 | /* we reached a "word" delimited by spaces/punct. |
1722 | * go to its end + 1 */ |
1723 | while (1) { |
1724 | input_forward(); |
1725 | c = command[cursor]; |
1726 | if (c == BB_NUL || c == ' ' || BB_ispunct(c)) |
1727 | break; |
1728 | } |
1729 | break; |
1730 | } |
1731 | input_forward(); |
1732 | } |
1733 | } |
1734 | |
1735 | |
1736 | /* |
1737 | * read_line_input and its helpers |
1738 | */ |
1739 | |
1740 | #if ENABLE_FEATURE_EDITING_ASK_TERMINAL |
1741 | static void ask_terminal(void) |
1742 | { |
1743 | /* Ask terminal where is the cursor now. |
1744 | * lineedit_read_key handles response and corrects |
1745 | * our idea of current cursor position. |
1746 | * Testcase: run "echo -n long_line_long_line_long_line", |
1747 | * then type in a long, wrapping command and try to |
1748 | * delete it using backspace key. |
1749 | * Note: we print it _after_ prompt, because |
1750 | * prompt may contain CR. Example: PS1='\[\r\n\]\w ' |
1751 | */ |
1752 | /* Problem: if there is buffered input on stdin, |
1753 | * the response will be delivered later, |
1754 | * possibly to an unsuspecting application. |
1755 | * Testcase: "sleep 1; busybox ash" + press and hold [Enter]. |
1756 | * Result: |
1757 | * ~/srcdevel/bbox/fix/busybox.t4 # |
1758 | * ~/srcdevel/bbox/fix/busybox.t4 # |
1759 | * ^[[59;34~/srcdevel/bbox/fix/busybox.t4 # <-- garbage |
1760 | * ~/srcdevel/bbox/fix/busybox.t4 # |
1761 | * |
1762 | * Checking for input with poll only makes the race narrower, |
1763 | * I still can trigger it. Strace: |
1764 | * |
1765 | * write(1, "~/srcdevel/bbox/fix/busybox.t4 # ", 33) = 33 |
1766 | * poll([{fd=0, events=POLLIN}], 1, 0) = 0 (Timeout) <-- no input exists |
1767 | * write(1, "\33[6n", 4) = 4 <-- send the ESC sequence, quick! |
1768 | * poll([{fd=0, events=POLLIN}], 1, -1) = 1 ([{fd=0, revents=POLLIN}]) |
1769 | * read(0, "\n", 1) = 1 <-- oh crap, user's input got in first |
1770 | */ |
1771 | struct pollfd pfd; |
1772 | |
1773 | pfd.fd = STDIN_FILENO; |
1774 | pfd.events = POLLIN; |
1775 | if (safe_poll(&pfd, 1, 0) == 0) { |
1776 | S.sent_ESC_br6n = 1; |
1777 | fputs(ESC"[6n", stdout); |
1778 | fflush_all(); /* make terminal see it ASAP! */ |
1779 | } |
1780 | } |
1781 | #else |
1782 | #define ask_terminal() ((void)0) |
1783 | #endif |
1784 | |
1785 | /* Called just once at read_line_input() init time */ |
1786 | #if !ENABLE_FEATURE_EDITING_FANCY_PROMPT |
1787 | static void parse_and_put_prompt(const char *prmt_ptr) |
1788 | { |
1789 | const char *p; |
1790 | cmdedit_prompt = prmt_ptr; |
1791 | p = strrchr(prmt_ptr, '\n'); |
1792 | cmdedit_prmt_len = unicode_strwidth(p ? p+1 : prmt_ptr); |
1793 | put_prompt(); |
1794 | } |
1795 | #else |
1796 | static void parse_and_put_prompt(const char *prmt_ptr) |
1797 | { |
1798 | int prmt_size = 0; |
1799 | char *prmt_mem_ptr = xzalloc(1); |
1800 | # if ENABLE_USERNAME_OR_HOMEDIR |
1801 | char *cwd_buf = NULL; |
1802 | # endif |
1803 | char flg_not_length = '['; |
1804 | char cbuf[2]; |
1805 | |
1806 | /*cmdedit_prmt_len = 0; - already is */ |
1807 | |
1808 | cbuf[1] = '\0'; /* never changes */ |
1809 | |
1810 | while (*prmt_ptr) { |
1811 | char timebuf[sizeof("HH:MM:SS")]; |
1812 | char *free_me = NULL; |
1813 | char *pbuf; |
1814 | char c; |
1815 | |
1816 | pbuf = cbuf; |
1817 | c = *prmt_ptr++; |
1818 | if (c == '\\') { |
1819 | const char *cp; |
1820 | int l; |
1821 | /* |
1822 | * Supported via bb_process_escape_sequence: |
1823 | * \a ASCII bell character (07) |
1824 | * \e ASCII escape character (033) |
1825 | * \n newline |
1826 | * \r carriage return |
1827 | * \\ backslash |
1828 | * \nnn char with octal code nnn |
1829 | * Supported: |
1830 | * \$ if the effective UID is 0, a #, otherwise a $ |
1831 | * \w current working directory, with $HOME abbreviated with a tilde |
1832 | * Note: we do not support $PROMPT_DIRTRIM=n feature |
1833 | * \W basename of the current working directory, with $HOME abbreviated with a tilde |
1834 | * \h hostname up to the first '.' |
1835 | * \H hostname |
1836 | * \u username |
1837 | * \[ begin a sequence of non-printing characters |
1838 | * \] end a sequence of non-printing characters |
1839 | * \T current time in 12-hour HH:MM:SS format |
1840 | * \@ current time in 12-hour am/pm format |
1841 | * \A current time in 24-hour HH:MM format |
1842 | * \t current time in 24-hour HH:MM:SS format |
1843 | * (all of the above work as \A) |
1844 | * Not supported: |
1845 | * \! history number of this command |
1846 | * \# command number of this command |
1847 | * \j number of jobs currently managed by the shell |
1848 | * \l basename of the shell's terminal device name |
1849 | * \s name of the shell, the basename of $0 (the portion following the final slash) |
1850 | * \V release of bash, version + patch level (e.g., 2.00.0) |
1851 | * \d date in "Weekday Month Date" format (e.g., "Tue May 26") |
1852 | * \D{format} |
1853 | * format is passed to strftime(3). |
1854 | * An empty format results in a locale-specific time representation. |
1855 | * The braces are required. |
1856 | * Mishandled by bb_process_escape_sequence: |
1857 | * \v version of bash (e.g., 2.00) |
1858 | */ |
1859 | cp = prmt_ptr; |
1860 | c = *cp; |
1861 | if (c != 't') /* don't treat \t as tab */ |
1862 | c = bb_process_escape_sequence(&prmt_ptr); |
1863 | if (prmt_ptr == cp) { |
1864 | if (*cp == '\0') |
1865 | break; |
1866 | c = *prmt_ptr++; |
1867 | |
1868 | switch (c) { |
1869 | # if ENABLE_USERNAME_OR_HOMEDIR |
1870 | case 'u': |
1871 | pbuf = user_buf ? user_buf : (char*)""; |
1872 | break; |
1873 | # endif |
1874 | case 'H': |
1875 | case 'h': |
1876 | pbuf = free_me = safe_gethostname(); |
1877 | if (c == 'h') |
1878 | strchrnul(pbuf, '.')[0] = '\0'; |
1879 | break; |
1880 | case '$': |
1881 | c = (geteuid() == 0 ? '#' : '$'); |
1882 | break; |
1883 | case 'T': /* 12-hour HH:MM:SS format */ |
1884 | case '@': /* 12-hour am/pm format */ |
1885 | case 'A': /* 24-hour HH:MM format */ |
1886 | case 't': /* 24-hour HH:MM:SS format */ |
1887 | /* We show all of them as 24-hour HH:MM */ |
1888 | strftime_HHMMSS(timebuf, sizeof(timebuf), NULL)[-3] = '\0'; |
1889 | pbuf = timebuf; |
1890 | break; |
1891 | # if ENABLE_USERNAME_OR_HOMEDIR |
1892 | case 'w': /* current dir */ |
1893 | case 'W': /* basename of cur dir */ |
1894 | if (!cwd_buf) { |
1895 | cwd_buf = xrealloc_getcwd_or_warn(NULL); |
1896 | if (!cwd_buf) |
1897 | cwd_buf = (char *)bb_msg_unknown; |
1898 | else if (home_pwd_buf[0]) { |
1899 | char *after_home_user; |
1900 | |
1901 | /* /home/user[/something] -> ~[/something] */ |
1902 | after_home_user = is_prefixed_with(cwd_buf, home_pwd_buf); |
1903 | if (after_home_user |
1904 | && (*after_home_user == '/' || *after_home_user == '\0') |
1905 | ) { |
1906 | cwd_buf[0] = '~'; |
1907 | overlapping_strcpy(cwd_buf + 1, after_home_user); |
1908 | } |
1909 | } |
1910 | } |
1911 | pbuf = cwd_buf; |
1912 | if (c == 'w') |
1913 | break; |
1914 | cp = strrchr(pbuf, '/'); |
1915 | if (cp) |
1916 | pbuf = (char*)cp + 1; |
1917 | break; |
1918 | # endif |
1919 | // bb_process_escape_sequence does this now: |
1920 | // case 'e': case 'E': /* \e \E = \033 */ |
1921 | // c = '\033'; |
1922 | // break; |
1923 | case 'x': case 'X': { |
1924 | char buf2[4]; |
1925 | for (l = 0; l < 3;) { |
1926 | unsigned h; |
1927 | buf2[l++] = *prmt_ptr; |
1928 | buf2[l] = '\0'; |
1929 | h = strtoul(buf2, &pbuf, 16); |
1930 | if (h > UCHAR_MAX || (pbuf - buf2) < l) { |
1931 | buf2[--l] = '\0'; |
1932 | break; |
1933 | } |
1934 | prmt_ptr++; |
1935 | } |
1936 | c = (char)strtoul(buf2, NULL, 16); |
1937 | if (c == 0) |
1938 | c = '?'; |
1939 | pbuf = cbuf; |
1940 | break; |
1941 | } |
1942 | case '[': case ']': |
1943 | if (c == flg_not_length) { |
1944 | /* Toggle '['/']' hex 5b/5d */ |
1945 | flg_not_length ^= 6; |
1946 | continue; |
1947 | } |
1948 | break; |
1949 | } /* switch */ |
1950 | } /* if */ |
1951 | } /* if */ |
1952 | cbuf[0] = c; |
1953 | { |
1954 | int n = strlen(pbuf); |
1955 | prmt_size += n; |
1956 | if (c == '\n') |
1957 | cmdedit_prmt_len = 0; |
1958 | else if (flg_not_length != ']') { |
1959 | #if 0 /*ENABLE_UNICODE_SUPPORT*/ |
1960 | /* Won't work, pbuf is one BYTE string here instead of an one Unicode char string. */ |
1961 | /* FIXME */ |
1962 | cmdedit_prmt_len += unicode_strwidth(pbuf); |
1963 | #else |
1964 | cmdedit_prmt_len += n; |
1965 | #endif |
1966 | } |
1967 | } |
1968 | prmt_mem_ptr = strcat(xrealloc(prmt_mem_ptr, prmt_size+1), pbuf); |
1969 | free(free_me); |
1970 | } /* while */ |
1971 | |
1972 | # if ENABLE_USERNAME_OR_HOMEDIR |
1973 | if (cwd_buf != (char *)bb_msg_unknown) |
1974 | free(cwd_buf); |
1975 | # endif |
1976 | cmdedit_prompt = prmt_mem_ptr; |
1977 | put_prompt(); |
1978 | } |
1979 | #endif |
1980 | |
1981 | static void cmdedit_setwidth(void) |
1982 | { |
1983 | int new_y; |
1984 | |
1985 | cmdedit_termw = get_terminal_width(STDIN_FILENO); |
1986 | /* new y for current cursor */ |
1987 | new_y = (cursor + cmdedit_prmt_len) / cmdedit_termw; |
1988 | /* redraw */ |
1989 | redraw((new_y >= cmdedit_y ? new_y : cmdedit_y), command_len - cursor); |
1990 | } |
1991 | |
1992 | static void win_changed(int nsig UNUSED_PARAM) |
1993 | { |
1994 | if (S.ok_to_redraw) { |
1995 | /* We are in read_key(), safe to redraw immediately */ |
1996 | int sv_errno = errno; |
1997 | cmdedit_setwidth(); |
1998 | fflush_all(); |
1999 | errno = sv_errno; |
2000 | } else { |
2001 | /* Signal main loop that redraw is necessary */ |
2002 | S.SIGWINCH_count++; |
2003 | } |
2004 | } |
2005 | |
2006 | static int lineedit_read_key(char *read_key_buffer, int timeout) |
2007 | { |
2008 | int64_t ic; |
2009 | #if ENABLE_UNICODE_SUPPORT |
2010 | char unicode_buf[MB_CUR_MAX + 1]; |
2011 | int unicode_idx = 0; |
2012 | #endif |
2013 | |
2014 | fflush_all(); |
2015 | while (1) { |
2016 | /* Wait for input. TIMEOUT = -1 makes read_key wait even |
2017 | * on nonblocking stdin, TIMEOUT = 50 makes sure we won't |
2018 | * insist on full MB_CUR_MAX buffer to declare input like |
2019 | * "\xff\n",pause,"ls\n" invalid and thus won't lose "ls". |
2020 | * |
2021 | * Note: read_key sets errno to 0 on success. |
2022 | */ |
2023 | S.ok_to_redraw = 1; |
2024 | ic = read_key(STDIN_FILENO, read_key_buffer, timeout); |
2025 | S.ok_to_redraw = 0; |
2026 | if (errno) { |
2027 | #if ENABLE_UNICODE_SUPPORT |
2028 | if (errno == EAGAIN && unicode_idx != 0) |
2029 | goto pushback; |
2030 | #endif |
2031 | break; |
2032 | } |
2033 | |
2034 | #if ENABLE_FEATURE_EDITING_ASK_TERMINAL |
2035 | if ((int32_t)ic == KEYCODE_CURSOR_POS |
2036 | && S.sent_ESC_br6n |
2037 | ) { |
2038 | S.sent_ESC_br6n = 0; |
2039 | if (cursor == 0) { /* otherwise it may be bogus */ |
2040 | int col = ((ic >> 32) & 0x7fff) - 1; |
2041 | /* |
2042 | * Is col > cmdedit_prmt_len? |
2043 | * If yes (terminal says cursor is farther to the right |
2044 | * of where we think it should be), |
2045 | * the prompt wasn't printed starting at col 1, |
2046 | * there was additional text before it. |
2047 | */ |
2048 | if ((int)(col - cmdedit_prmt_len) > 0) { |
2049 | /* Fix our understanding of current x position */ |
2050 | cmdedit_x += (col - cmdedit_prmt_len); |
2051 | while (cmdedit_x >= cmdedit_termw) { |
2052 | cmdedit_x -= cmdedit_termw; |
2053 | cmdedit_y++; |
2054 | } |
2055 | } |
2056 | } |
2057 | continue; |
2058 | } |
2059 | #endif |
2060 | |
2061 | #if ENABLE_UNICODE_SUPPORT |
2062 | if (unicode_status == UNICODE_ON) { |
2063 | wchar_t wc; |
2064 | |
2065 | if ((int32_t)ic < 0) /* KEYCODE_xxx */ |
2066 | break; |
2067 | // TODO: imagine sequence like: 0xff,<left-arrow>: we are currently losing 0xff... |
2068 | |
2069 | unicode_buf[unicode_idx++] = ic; |
2070 | unicode_buf[unicode_idx] = '\0'; |
2071 | if (mbstowcs(&wc, unicode_buf, 1) != 1) { |
2072 | /* Not (yet?) a valid unicode char */ |
2073 | if (unicode_idx < MB_CUR_MAX) { |
2074 | timeout = 50; |
2075 | continue; |
2076 | } |
2077 | pushback: |
2078 | /* Invalid sequence. Save all "bad bytes" except first */ |
2079 | read_key_ungets(read_key_buffer, unicode_buf + 1, unicode_idx - 1); |
2080 | # if !ENABLE_UNICODE_PRESERVE_BROKEN |
2081 | ic = CONFIG_SUBST_WCHAR; |
2082 | # else |
2083 | ic = unicode_mark_raw_byte(unicode_buf[0]); |
2084 | # endif |
2085 | } else { |
2086 | /* Valid unicode char, return its code */ |
2087 | ic = wc; |
2088 | } |
2089 | } |
2090 | #endif |
2091 | break; |
2092 | } |
2093 | |
2094 | return ic; |
2095 | } |
2096 | |
2097 | #if ENABLE_UNICODE_BIDI_SUPPORT |
2098 | static int isrtl_str(void) |
2099 | { |
2100 | int idx = cursor; |
2101 | |
2102 | while (idx < command_len && unicode_bidi_is_neutral_wchar(command_ps[idx])) |
2103 | idx++; |
2104 | return unicode_bidi_isrtl(command_ps[idx]); |
2105 | } |
2106 | #else |
2107 | # define isrtl_str() 0 |
2108 | #endif |
2109 | |
2110 | /* leave out the "vi-mode"-only case labels if vi editing isn't |
2111 | * configured. */ |
2112 | #define vi_case(caselabel) IF_FEATURE_EDITING_VI(case caselabel) |
2113 | |
2114 | /* convert uppercase ascii to equivalent control char, for readability */ |
2115 | #undef CTRL |
2116 | #define CTRL(a) ((a) & ~0x40) |
2117 | |
2118 | enum { |
2119 | VI_CMDMODE_BIT = 0x40000000, |
2120 | /* 0x80000000 bit flags KEYCODE_xxx */ |
2121 | }; |
2122 | |
2123 | #if ENABLE_FEATURE_REVERSE_SEARCH |
2124 | /* Mimic readline Ctrl-R reverse history search. |
2125 | * When invoked, it shows the following prompt: |
2126 | * (reverse-i-search)'': user_input [cursor pos unchanged by Ctrl-R] |
2127 | * and typing results in search being performed: |
2128 | * (reverse-i-search)'tmp': cd /tmp [cursor under t in /tmp] |
2129 | * Search is performed by looking at progressively older lines in history. |
2130 | * Ctrl-R again searches for the next match in history. |
2131 | * Backspace deletes last matched char. |
2132 | * Control keys exit search and return to normal editing (at current history line). |
2133 | */ |
2134 | static int32_t reverse_i_search(void) |
2135 | { |
2136 | char match_buf[128]; /* for user input */ |
2137 | char read_key_buffer[KEYCODE_BUFFER_SIZE]; |
2138 | const char *matched_history_line; |
2139 | const char *saved_prompt; |
2140 | unsigned saved_prmt_len; |
2141 | int32_t ic; |
2142 | |
2143 | matched_history_line = NULL; |
2144 | read_key_buffer[0] = 0; |
2145 | match_buf[0] = '\0'; |
2146 | |
2147 | /* Save and replace the prompt */ |
2148 | saved_prompt = cmdedit_prompt; |
2149 | saved_prmt_len = cmdedit_prmt_len; |
2150 | goto set_prompt; |
2151 | |
2152 | while (1) { |
2153 | int h; |
2154 | unsigned match_buf_len = strlen(match_buf); |
2155 | |
2156 | //FIXME: correct timeout? |
2157 | ic = lineedit_read_key(read_key_buffer, -1); |
2158 | |
2159 | switch (ic) { |
2160 | case CTRL('R'): /* searching for the next match */ |
2161 | break; |
2162 | |
2163 | case '\b': |
2164 | case '\x7f': |
2165 | /* Backspace */ |
2166 | if (unicode_status == UNICODE_ON) { |
2167 | while (match_buf_len != 0) { |
2168 | uint8_t c = match_buf[--match_buf_len]; |
2169 | if ((c & 0xc0) != 0x80) /* start of UTF-8 char? */ |
2170 | break; /* yes */ |
2171 | } |
2172 | } else { |
2173 | if (match_buf_len != 0) |
2174 | match_buf_len--; |
2175 | } |
2176 | match_buf[match_buf_len] = '\0'; |
2177 | break; |
2178 | |
2179 | default: |
2180 | if (ic < ' ' |
2181 | || (!ENABLE_UNICODE_SUPPORT && ic >= 256) |
2182 | || (ENABLE_UNICODE_SUPPORT && ic >= VI_CMDMODE_BIT) |
2183 | ) { |
2184 | goto ret; |
2185 | } |
2186 | |
2187 | /* Append this char */ |
2188 | #if ENABLE_UNICODE_SUPPORT |
2189 | if (unicode_status == UNICODE_ON) { |
2190 | mbstate_t mbstate = { 0 }; |
2191 | char buf[MB_CUR_MAX + 1]; |
2192 | int len = wcrtomb(buf, ic, &mbstate); |
2193 | if (len > 0) { |
2194 | buf[len] = '\0'; |
2195 | if (match_buf_len + len < sizeof(match_buf)) |
2196 | strcpy(match_buf + match_buf_len, buf); |
2197 | } |
2198 | } else |
2199 | #endif |
2200 | if (match_buf_len < sizeof(match_buf) - 1) { |
2201 | match_buf[match_buf_len] = ic; |
2202 | match_buf[match_buf_len + 1] = '\0'; |
2203 | } |
2204 | break; |
2205 | } /* switch (ic) */ |
2206 | |
2207 | /* Search in history for match_buf */ |
2208 | h = state->cur_history; |
2209 | if (ic == CTRL('R')) |
2210 | h--; |
2211 | while (h >= 0) { |
2212 | if (state->history[h]) { |
2213 | char *match = strstr(state->history[h], match_buf); |
2214 | if (match) { |
2215 | state->cur_history = h; |
2216 | matched_history_line = state->history[h]; |
2217 | command_len = load_string(matched_history_line); |
2218 | cursor = match - matched_history_line; |
2219 | //FIXME: cursor position for Unicode case |
2220 | |
2221 | free((char*)cmdedit_prompt); |
2222 | set_prompt: |
2223 | cmdedit_prompt = xasprintf("(reverse-i-search)'%s': ", match_buf); |
2224 | cmdedit_prmt_len = unicode_strwidth(cmdedit_prompt); |
2225 | goto do_redraw; |
2226 | } |
2227 | } |
2228 | h--; |
2229 | } |
2230 | |
2231 | /* Not found */ |
2232 | match_buf[match_buf_len] = '\0'; |
2233 | beep(); |
2234 | continue; |
2235 | |
2236 | do_redraw: |
2237 | redraw(cmdedit_y, command_len - cursor); |
2238 | } /* while (1) */ |
2239 | |
2240 | ret: |
2241 | if (matched_history_line) |
2242 | command_len = load_string(matched_history_line); |
2243 | |
2244 | free((char*)cmdedit_prompt); |
2245 | cmdedit_prompt = saved_prompt; |
2246 | cmdedit_prmt_len = saved_prmt_len; |
2247 | redraw(cmdedit_y, command_len - cursor); |
2248 | |
2249 | return ic; |
2250 | } |
2251 | #endif |
2252 | |
2253 | /* maxsize must be >= 2. |
2254 | * Returns: |
2255 | * -1 on read errors or EOF, or on bare Ctrl-D, |
2256 | * 0 on ctrl-C (the line entered is still returned in 'command'), |
2257 | * (in both cases the cursor remains on the input line, '\n' is not printed) |
2258 | * >0 length of input string, including terminating '\n' |
2259 | */ |
2260 | int FAST_FUNC read_line_input(line_input_t *st, const char *prompt, char *command, int maxsize, int timeout) |
2261 | { |
2262 | int len; |
2263 | #if ENABLE_FEATURE_TAB_COMPLETION |
2264 | smallint lastWasTab = 0; |
2265 | #endif |
2266 | smallint break_out = 0; |
2267 | #if ENABLE_FEATURE_EDITING_VI |
2268 | smallint vi_cmdmode = 0; |
2269 | #endif |
2270 | struct termios initial_settings; |
2271 | struct termios new_settings; |
2272 | char read_key_buffer[KEYCODE_BUFFER_SIZE]; |
2273 | |
2274 | INIT_S(); |
2275 | |
2276 | if (tcgetattr(STDIN_FILENO, &initial_settings) < 0 |
2277 | || (initial_settings.c_lflag & (ECHO|ICANON)) == ICANON |
2278 | ) { |
2279 | /* Happens when e.g. stty -echo was run before. |
2280 | * But if ICANON is not set, we don't come here. |
2281 | * (example: interactive python ^Z-backgrounded, |
2282 | * tty is still in "raw mode"). |
2283 | */ |
2284 | parse_and_put_prompt(prompt); |
2285 | fflush_all(); |
2286 | if (fgets(command, maxsize, stdin) == NULL) |
2287 | len = -1; /* EOF or error */ |
2288 | else |
2289 | len = strlen(command); |
2290 | DEINIT_S(); |
2291 | return len; |
2292 | } |
2293 | |
2294 | init_unicode(); |
2295 | |
2296 | // FIXME: audit & improve this |
2297 | if (maxsize > MAX_LINELEN) |
2298 | maxsize = MAX_LINELEN; |
2299 | S.maxsize = maxsize; |
2300 | |
2301 | /* With zero flags, no other fields are ever used */ |
2302 | state = st ? st : (line_input_t*) &const_int_0; |
2303 | #if MAX_HISTORY > 0 |
2304 | # if ENABLE_FEATURE_EDITING_SAVEHISTORY |
2305 | if (state->hist_file) |
2306 | if (state->cnt_history == 0) |
2307 | load_history(state); |
2308 | # endif |
2309 | if (state->flags & DO_HISTORY) |
2310 | state->cur_history = state->cnt_history; |
2311 | #endif |
2312 | |
2313 | /* prepare before init handlers */ |
2314 | cmdedit_y = 0; /* quasireal y, not true if line > xt*yt */ |
2315 | command_len = 0; |
2316 | #if ENABLE_UNICODE_SUPPORT |
2317 | command_ps = xzalloc(maxsize * sizeof(command_ps[0])); |
2318 | #else |
2319 | command_ps = command; |
2320 | command[0] = '\0'; |
2321 | #endif |
2322 | #define command command_must_not_be_used |
2323 | |
2324 | new_settings = initial_settings; |
2325 | /* ~ICANON: unbuffered input (most c_cc[] are disabled, VMIN/VTIME are enabled) */ |
2326 | /* ~ECHO, ~ECHONL: turn off echoing, including newline echoing */ |
2327 | /* ~ISIG: turn off INTR (ctrl-C), QUIT, SUSP */ |
2328 | new_settings.c_lflag &= ~(ICANON | ECHO | ECHONL | ISIG); |
2329 | /* reads would block only if < 1 char is available */ |
2330 | new_settings.c_cc[VMIN] = 1; |
2331 | /* no timeout (reads block forever) */ |
2332 | new_settings.c_cc[VTIME] = 0; |
2333 | /* Should be not needed if ISIG is off: */ |
2334 | /* Turn off CTRL-C */ |
2335 | /* new_settings.c_cc[VINTR] = _POSIX_VDISABLE; */ |
2336 | tcsetattr_stdin_TCSANOW(&new_settings); |
2337 | |
2338 | /*#if ENABLE_USERNAME_OR_HOMEDIR |
2339 | { |
2340 | struct passwd *entry; |
2341 | |
2342 | entry = getpwuid(geteuid()); |
2343 | if (entry) { |
2344 | user_buf = xstrdup(entry->pw_name); |
2345 | home_pwd_buf = xstrdup(entry->pw_dir); |
2346 | } |
2347 | } |
2348 | #endif*/ |
2349 | |
2350 | #if 0 |
2351 | for (i = 0; i <= state->max_history; i++) |
2352 | bb_error_msg("history[%d]:'%s'", i, state->history[i]); |
2353 | bb_error_msg("cur_history:%d cnt_history:%d", state->cur_history, state->cnt_history); |
2354 | #endif |
2355 | |
2356 | /* Print out the command prompt, optionally ask where cursor is */ |
2357 | parse_and_put_prompt(prompt); |
2358 | ask_terminal(); |
2359 | |
2360 | /* Install window resize handler (NB: after *all* init is complete) */ |
2361 | S.SIGWINCH_handler.sa_handler = win_changed; |
2362 | S.SIGWINCH_handler.sa_flags = SA_RESTART; |
2363 | sigaction(SIGWINCH, &S.SIGWINCH_handler, &S.SIGWINCH_handler); |
2364 | |
2365 | cmdedit_termw = get_terminal_width(STDIN_FILENO); |
2366 | |
2367 | read_key_buffer[0] = 0; |
2368 | while (1) { |
2369 | /* |
2370 | * The emacs and vi modes share much of the code in the big |
2371 | * command loop. Commands entered when in vi's command mode |
2372 | * (aka "escape mode") get an extra bit added to distinguish |
2373 | * them - this keeps them from being self-inserted. This |
2374 | * clutters the big switch a bit, but keeps all the code |
2375 | * in one place. |
2376 | */ |
2377 | int32_t ic, ic_raw; |
2378 | unsigned count; |
2379 | |
2380 | count = S.SIGWINCH_count; |
2381 | if (S.SIGWINCH_saved != count) { |
2382 | S.SIGWINCH_saved = count; |
2383 | cmdedit_setwidth(); |
2384 | } |
2385 | |
2386 | ic = ic_raw = lineedit_read_key(read_key_buffer, timeout); |
2387 | |
2388 | #if ENABLE_FEATURE_REVERSE_SEARCH |
2389 | again: |
2390 | #endif |
2391 | #if ENABLE_FEATURE_EDITING_VI |
2392 | newdelflag = 1; |
2393 | if (vi_cmdmode) { |
2394 | /* btw, since KEYCODE_xxx are all < 0, this doesn't |
2395 | * change ic if it contains one of them: */ |
2396 | ic |= VI_CMDMODE_BIT; |
2397 | } |
2398 | #endif |
2399 | |
2400 | switch (ic) { |
2401 | case '\n': |
2402 | case '\r': |
2403 | vi_case('\n'|VI_CMDMODE_BIT:) |
2404 | vi_case('\r'|VI_CMDMODE_BIT:) |
2405 | /* Enter */ |
2406 | goto_new_line(); |
2407 | break_out = 1; |
2408 | break; |
2409 | case CTRL('A'): |
2410 | vi_case('0'|VI_CMDMODE_BIT:) |
2411 | /* Control-a -- Beginning of line */ |
2412 | input_backward(cursor); |
2413 | break; |
2414 | case CTRL('B'): |
2415 | vi_case('h'|VI_CMDMODE_BIT:) |
2416 | vi_case('\b'|VI_CMDMODE_BIT:) /* ^H */ |
2417 | vi_case('\x7f'|VI_CMDMODE_BIT:) /* DEL */ |
2418 | input_backward(1); /* Move back one character */ |
2419 | break; |
2420 | case CTRL('E'): |
2421 | vi_case('$'|VI_CMDMODE_BIT:) |
2422 | /* Control-e -- End of line */ |
2423 | put_till_end_and_adv_cursor(); |
2424 | break; |
2425 | case CTRL('F'): |
2426 | vi_case('l'|VI_CMDMODE_BIT:) |
2427 | vi_case(' '|VI_CMDMODE_BIT:) |
2428 | input_forward(); /* Move forward one character */ |
2429 | break; |
2430 | case '\b': /* ^H */ |
2431 | case '\x7f': /* DEL */ |
2432 | if (!isrtl_str()) |
2433 | input_backspace(); |
2434 | else |
2435 | input_delete(0); |
2436 | break; |
2437 | case KEYCODE_DELETE: |
2438 | if (!isrtl_str()) |
2439 | input_delete(0); |
2440 | else |
2441 | input_backspace(); |
2442 | break; |
2443 | #if ENABLE_FEATURE_TAB_COMPLETION |
2444 | case '\t': |
2445 | input_tab(&lastWasTab); |
2446 | break; |
2447 | #endif |
2448 | case CTRL('K'): |
2449 | /* Control-k -- clear to end of line */ |
2450 | command_ps[cursor] = BB_NUL; |
2451 | command_len = cursor; |
2452 | printf(SEQ_CLEAR_TILL_END_OF_SCREEN); |
2453 | break; |
2454 | case CTRL('L'): |
2455 | vi_case(CTRL('L')|VI_CMDMODE_BIT:) |
2456 | /* Control-l -- clear screen */ |
2457 | printf(ESC"[H"); /* cursor to top,left */ |
2458 | redraw(0, command_len - cursor); |
2459 | break; |
2460 | #if MAX_HISTORY > 0 |
2461 | case CTRL('N'): |
2462 | vi_case(CTRL('N')|VI_CMDMODE_BIT:) |
2463 | vi_case('j'|VI_CMDMODE_BIT:) |
2464 | /* Control-n -- Get next command in history */ |
2465 | if (get_next_history()) |
2466 | goto rewrite_line; |
2467 | break; |
2468 | case CTRL('P'): |
2469 | vi_case(CTRL('P')|VI_CMDMODE_BIT:) |
2470 | vi_case('k'|VI_CMDMODE_BIT:) |
2471 | /* Control-p -- Get previous command from history */ |
2472 | if (get_previous_history()) |
2473 | goto rewrite_line; |
2474 | break; |
2475 | #endif |
2476 | case CTRL('U'): |
2477 | vi_case(CTRL('U')|VI_CMDMODE_BIT:) |
2478 | /* Control-U -- Clear line before cursor */ |
2479 | if (cursor) { |
2480 | command_len -= cursor; |
2481 | memmove(command_ps, command_ps + cursor, |
2482 | (command_len + 1) * sizeof(command_ps[0])); |
2483 | redraw(cmdedit_y, command_len); |
2484 | } |
2485 | break; |
2486 | case CTRL('W'): |
2487 | vi_case(CTRL('W')|VI_CMDMODE_BIT:) |
2488 | /* Control-W -- Remove the last word */ |
2489 | while (cursor > 0 && BB_isspace(command_ps[cursor-1])) |
2490 | input_backspace(); |
2491 | while (cursor > 0 && !BB_isspace(command_ps[cursor-1])) |
2492 | input_backspace(); |
2493 | break; |
2494 | case KEYCODE_ALT_D: { |
2495 | /* Delete word forward */ |
2496 | int nc, sc = cursor; |
2497 | ctrl_right(); |
2498 | nc = cursor - sc; |
2499 | input_backward(nc); |
2500 | while (--nc >= 0) |
2501 | input_delete(1); |
2502 | break; |
2503 | } |
2504 | case KEYCODE_ALT_BACKSPACE: { |
2505 | /* Delete word backward */ |
2506 | int sc = cursor; |
2507 | ctrl_left(); |
2508 | while (sc-- > cursor) |
2509 | input_delete(1); |
2510 | break; |
2511 | } |
2512 | #if ENABLE_FEATURE_REVERSE_SEARCH |
2513 | case CTRL('R'): |
2514 | ic = ic_raw = reverse_i_search(); |
2515 | goto again; |
2516 | #endif |
2517 | |
2518 | #if ENABLE_FEATURE_EDITING_VI |
2519 | case 'i'|VI_CMDMODE_BIT: |
2520 | vi_cmdmode = 0; |
2521 | break; |
2522 | case 'I'|VI_CMDMODE_BIT: |
2523 | input_backward(cursor); |
2524 | vi_cmdmode = 0; |
2525 | break; |
2526 | case 'a'|VI_CMDMODE_BIT: |
2527 | input_forward(); |
2528 | vi_cmdmode = 0; |
2529 | break; |
2530 | case 'A'|VI_CMDMODE_BIT: |
2531 | put_till_end_and_adv_cursor(); |
2532 | vi_cmdmode = 0; |
2533 | break; |
2534 | case 'x'|VI_CMDMODE_BIT: |
2535 | input_delete(1); |
2536 | break; |
2537 | case 'X'|VI_CMDMODE_BIT: |
2538 | if (cursor > 0) { |
2539 | input_backward(1); |
2540 | input_delete(1); |
2541 | } |
2542 | break; |
2543 | case 'W'|VI_CMDMODE_BIT: |
2544 | vi_Word_motion(1); |
2545 | break; |
2546 | case 'w'|VI_CMDMODE_BIT: |
2547 | vi_word_motion(1); |
2548 | break; |
2549 | case 'E'|VI_CMDMODE_BIT: |
2550 | vi_End_motion(); |
2551 | break; |
2552 | case 'e'|VI_CMDMODE_BIT: |
2553 | vi_end_motion(); |
2554 | break; |
2555 | case 'B'|VI_CMDMODE_BIT: |
2556 | vi_Back_motion(); |
2557 | break; |
2558 | case 'b'|VI_CMDMODE_BIT: |
2559 | vi_back_motion(); |
2560 | break; |
2561 | case 'C'|VI_CMDMODE_BIT: |
2562 | vi_cmdmode = 0; |
2563 | /* fall through */ |
2564 | case 'D'|VI_CMDMODE_BIT: |
2565 | goto clear_to_eol; |
2566 | |
2567 | case 'c'|VI_CMDMODE_BIT: |
2568 | vi_cmdmode = 0; |
2569 | /* fall through */ |
2570 | case 'd'|VI_CMDMODE_BIT: { |
2571 | int nc, sc; |
2572 | |
2573 | ic = lineedit_read_key(read_key_buffer, timeout); |
2574 | if (errno) /* error */ |
2575 | goto return_error_indicator; |
2576 | if (ic == ic_raw) { /* "cc", "dd" */ |
2577 | input_backward(cursor); |
2578 | goto clear_to_eol; |
2579 | break; |
2580 | } |
2581 | |
2582 | sc = cursor; |
2583 | switch (ic) { |
2584 | case 'w': |
2585 | case 'W': |
2586 | case 'e': |
2587 | case 'E': |
2588 | switch (ic) { |
2589 | case 'w': /* "dw", "cw" */ |
2590 | vi_word_motion(vi_cmdmode); |
2591 | break; |
2592 | case 'W': /* 'dW', 'cW' */ |
2593 | vi_Word_motion(vi_cmdmode); |
2594 | break; |
2595 | case 'e': /* 'de', 'ce' */ |
2596 | vi_end_motion(); |
2597 | input_forward(); |
2598 | break; |
2599 | case 'E': /* 'dE', 'cE' */ |
2600 | vi_End_motion(); |
2601 | input_forward(); |
2602 | break; |
2603 | } |
2604 | nc = cursor; |
2605 | input_backward(cursor - sc); |
2606 | while (nc-- > cursor) |
2607 | input_delete(1); |
2608 | break; |
2609 | case 'b': /* "db", "cb" */ |
2610 | case 'B': /* implemented as B */ |
2611 | if (ic == 'b') |
2612 | vi_back_motion(); |
2613 | else |
2614 | vi_Back_motion(); |
2615 | while (sc-- > cursor) |
2616 | input_delete(1); |
2617 | break; |
2618 | case ' ': /* "d ", "c " */ |
2619 | input_delete(1); |
2620 | break; |
2621 | case '$': /* "d$", "c$" */ |
2622 | clear_to_eol: |
2623 | while (cursor < command_len) |
2624 | input_delete(1); |
2625 | break; |
2626 | } |
2627 | break; |
2628 | } |
2629 | case 'p'|VI_CMDMODE_BIT: |
2630 | input_forward(); |
2631 | /* fallthrough */ |
2632 | case 'P'|VI_CMDMODE_BIT: |
2633 | put(); |
2634 | break; |
2635 | case 'r'|VI_CMDMODE_BIT: |
2636 | //FIXME: unicode case? |
2637 | ic = lineedit_read_key(read_key_buffer, timeout); |
2638 | if (errno) /* error */ |
2639 | goto return_error_indicator; |
2640 | if (ic < ' ' || ic > 255) { |
2641 | beep(); |
2642 | } else { |
2643 | command_ps[cursor] = ic; |
2644 | bb_putchar(ic); |
2645 | bb_putchar('\b'); |
2646 | } |
2647 | break; |
2648 | case '\x1b': /* ESC */ |
2649 | if (state->flags & VI_MODE) { |
2650 | /* insert mode --> command mode */ |
2651 | vi_cmdmode = 1; |
2652 | input_backward(1); |
2653 | } |
2654 | break; |
2655 | #endif /* FEATURE_COMMAND_EDITING_VI */ |
2656 | |
2657 | #if MAX_HISTORY > 0 |
2658 | case KEYCODE_UP: |
2659 | if (get_previous_history()) |
2660 | goto rewrite_line; |
2661 | beep(); |
2662 | break; |
2663 | case KEYCODE_DOWN: |
2664 | if (!get_next_history()) |
2665 | break; |
2666 | rewrite_line: |
2667 | /* Rewrite the line with the selected history item */ |
2668 | /* change command */ |
2669 | command_len = load_string(state->history[state->cur_history] ? |
2670 | state->history[state->cur_history] : ""); |
2671 | /* redraw and go to eol (bol, in vi) */ |
2672 | redraw(cmdedit_y, (state->flags & VI_MODE) ? 9999 : 0); |
2673 | break; |
2674 | #endif |
2675 | case KEYCODE_RIGHT: |
2676 | input_forward(); |
2677 | break; |
2678 | case KEYCODE_LEFT: |
2679 | input_backward(1); |
2680 | break; |
2681 | case KEYCODE_CTRL_LEFT: |
2682 | case KEYCODE_ALT_LEFT: /* bash doesn't do it */ |
2683 | ctrl_left(); |
2684 | break; |
2685 | case KEYCODE_CTRL_RIGHT: |
2686 | case KEYCODE_ALT_RIGHT: /* bash doesn't do it */ |
2687 | ctrl_right(); |
2688 | break; |
2689 | case KEYCODE_HOME: |
2690 | input_backward(cursor); |
2691 | break; |
2692 | case KEYCODE_END: |
2693 | put_till_end_and_adv_cursor(); |
2694 | break; |
2695 | |
2696 | default: |
2697 | if (initial_settings.c_cc[VINTR] != 0 |
2698 | && ic_raw == initial_settings.c_cc[VINTR] |
2699 | ) { |
2700 | /* Ctrl-C (usually) - stop gathering input */ |
2701 | command_len = 0; |
2702 | break_out = -1; /* "do not append '\n'" */ |
2703 | break; |
2704 | } |
2705 | if (initial_settings.c_cc[VEOF] != 0 |
2706 | && ic_raw == initial_settings.c_cc[VEOF] |
2707 | ) { |
2708 | /* Ctrl-D (usually) - delete one character, |
2709 | * or exit if len=0 and no chars to delete */ |
2710 | if (command_len == 0) { |
2711 | errno = 0; |
2712 | |
2713 | case -1: /* error (e.g. EIO when tty is destroyed) */ |
2714 | IF_FEATURE_EDITING_VI(return_error_indicator:) |
2715 | break_out = command_len = -1; |
2716 | break; |
2717 | } |
2718 | input_delete(0); |
2719 | break; |
2720 | } |
2721 | // /* Control-V -- force insert of next char */ |
2722 | // if (c == CTRL('V')) { |
2723 | // if (safe_read(STDIN_FILENO, &c, 1) < 1) |
2724 | // goto return_error_indicator; |
2725 | // if (c == 0) { |
2726 | // beep(); |
2727 | // break; |
2728 | // } |
2729 | // } |
2730 | if (ic < ' ' |
2731 | || (!ENABLE_UNICODE_SUPPORT && ic >= 256) |
2732 | || (ENABLE_UNICODE_SUPPORT && ic >= VI_CMDMODE_BIT) |
2733 | ) { |
2734 | /* If VI_CMDMODE_BIT is set, ic is >= 256 |
2735 | * and vi mode ignores unexpected chars. |
2736 | * Otherwise, we are here if ic is a |
2737 | * control char or an unhandled ESC sequence, |
2738 | * which is also ignored. |
2739 | */ |
2740 | break; |
2741 | } |
2742 | if ((int)command_len >= (maxsize - 2)) { |
2743 | /* Not enough space for the char and EOL */ |
2744 | break; |
2745 | } |
2746 | |
2747 | command_len++; |
2748 | if (cursor == (command_len - 1)) { |
2749 | /* We are at the end, append */ |
2750 | command_ps[cursor] = ic; |
2751 | command_ps[cursor + 1] = BB_NUL; |
2752 | put_cur_glyph_and_inc_cursor(); |
2753 | if (unicode_bidi_isrtl(ic)) |
2754 | input_backward(1); |
2755 | } else { |
2756 | /* In the middle, insert */ |
2757 | int sc = cursor; |
2758 | |
2759 | memmove(command_ps + sc + 1, command_ps + sc, |
2760 | (command_len - sc) * sizeof(command_ps[0])); |
2761 | command_ps[sc] = ic; |
2762 | /* is right-to-left char, or neutral one (e.g. comma) was just added to rtl text? */ |
2763 | if (!isrtl_str()) |
2764 | sc++; /* no */ |
2765 | put_till_end_and_adv_cursor(); |
2766 | /* to prev x pos + 1 */ |
2767 | input_backward(cursor - sc); |
2768 | } |
2769 | break; |
2770 | } /* switch (ic) */ |
2771 | |
2772 | if (break_out) |
2773 | break; |
2774 | |
2775 | #if ENABLE_FEATURE_TAB_COMPLETION |
2776 | if (ic_raw != '\t') |
2777 | lastWasTab = 0; |
2778 | #endif |
2779 | } /* while (1) */ |
2780 | |
2781 | #if ENABLE_FEATURE_EDITING_ASK_TERMINAL |
2782 | if (S.sent_ESC_br6n) { |
2783 | /* "sleep 1; busybox ash" + hold [Enter] to trigger. |
2784 | * We sent "ESC [ 6 n", but got '\n' first, and |
2785 | * KEYCODE_CURSOR_POS response is now buffered from terminal. |
2786 | * It's bad already and not much can be done with it |
2787 | * (it _will_ be visible for the next process to read stdin), |
2788 | * but without this delay it even shows up on the screen |
2789 | * as garbage because we restore echo settings with tcsetattr |
2790 | * before it comes in. UGLY! |
2791 | */ |
2792 | usleep(20*1000); |
2793 | } |
2794 | #endif |
2795 | |
2796 | /* End of bug-catching "command_must_not_be_used" trick */ |
2797 | #undef command |
2798 | |
2799 | #if ENABLE_UNICODE_SUPPORT |
2800 | command[0] = '\0'; |
2801 | if (command_len > 0) |
2802 | command_len = save_string(command, maxsize - 1); |
2803 | free(command_ps); |
2804 | #endif |
2805 | |
2806 | if (command_len > 0) { |
2807 | remember_in_history(command); |
2808 | } |
2809 | |
2810 | if (break_out > 0) { |
2811 | command[command_len++] = '\n'; |
2812 | command[command_len] = '\0'; |
2813 | } |
2814 | |
2815 | #if ENABLE_FEATURE_TAB_COMPLETION |
2816 | free_tab_completion_data(); |
2817 | #endif |
2818 | |
2819 | /* restore initial_settings */ |
2820 | tcsetattr_stdin_TCSANOW(&initial_settings); |
2821 | /* restore SIGWINCH handler */ |
2822 | sigaction_set(SIGWINCH, &S.SIGWINCH_handler); |
2823 | fflush_all(); |
2824 | |
2825 | len = command_len; |
2826 | DEINIT_S(); |
2827 | |
2828 | return len; /* can't return command_len, DEINIT_S() destroys it */ |
2829 | } |
2830 | |
2831 | #else /* !FEATURE_EDITING */ |
2832 | |
2833 | #undef read_line_input |
2834 | int FAST_FUNC read_line_input(const char* prompt, char* command, int maxsize) |
2835 | { |
2836 | fputs(prompt, stdout); |
2837 | fflush_all(); |
2838 | if (!fgets(command, maxsize, stdin)) |
2839 | return -1; |
2840 | return strlen(command); |
2841 | } |
2842 | |
2843 | #endif /* !FEATURE_EDITING */ |
2844 | |
2845 | |
2846 | /* |
2847 | * Testing |
2848 | */ |
2849 | |
2850 | #ifdef TEST |
2851 | |
2852 | #include <locale.h> |
2853 | |
2854 | const char *applet_name = "debug stuff usage"; |
2855 | |
2856 | int main(int argc, char **argv) |
2857 | { |
2858 | char buff[MAX_LINELEN]; |
2859 | char *prompt = |
2860 | #if ENABLE_FEATURE_EDITING_FANCY_PROMPT |
2861 | "\\[\\033[32;1m\\]\\u@\\[\\x1b[33;1m\\]\\h:" |
2862 | "\\[\\033[34;1m\\]\\w\\[\\033[35;1m\\] " |
2863 | "\\!\\[\\e[36;1m\\]\\$ \\[\\E[0m\\]"; |
2864 | #else |
2865 | "% "; |
2866 | #endif |
2867 | |
2868 | while (1) { |
2869 | int l; |
2870 | l = read_line_input(prompt, buff); |
2871 | if (l <= 0 || buff[l-1] != '\n') |
2872 | break; |
2873 | buff[l-1] = '\0'; |
2874 | printf("*** read_line_input() returned line =%s=\n", buff); |
2875 | } |
2876 | printf("*** read_line_input() detect ^D\n"); |
2877 | return 0; |
2878 | } |
2879 | |
2880 | #endif /* TEST */ |
2881 |