Contents of /tags/mkinitrd-6_3_2/busybox/libbb/lineedit.c
Parent Directory
|
Revision Log
Revision 1164 -
(show annotations)
(download)
Tue Sep 14 20:33:28 2010 UTC (13 years, 9 months ago) by niro
File MIME type: text/plain
File size: 61145 byte(s)
Tue Sep 14 20:33:28 2010 UTC (13 years, 9 months ago) by niro
File MIME type: text/plain
File size: 61145 byte(s)
tagged 'mkinitrd-6_3_2'
1 | /* vi: set sw=4 ts=4: */ |
2 | /* |
3 | * Termios command line History and 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 | /* |
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. |
24 | * |
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 |
30 | * |
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: |
39 | * |
40 | * PS1='\[\033[01;32m\]\u@\h\[\033[01;34m\] \w \$\[\033[00m\] ' |
41 | */ |
42 | #include "libbb.h" |
43 | #include "unicode.h" |
44 | |
45 | #ifdef TEST |
46 | # define ENABLE_FEATURE_EDITING 0 |
47 | # define ENABLE_FEATURE_TAB_COMPLETION 0 |
48 | # define ENABLE_FEATURE_USERNAME_COMPLETION 0 |
49 | #endif |
50 | |
51 | |
52 | /* Entire file (except TESTing part) sits inside this #if */ |
53 | #if ENABLE_FEATURE_EDITING |
54 | |
55 | |
56 | #define ENABLE_FEATURE_GETUSERNAME_AND_HOMEDIR \ |
57 | (ENABLE_FEATURE_USERNAME_COMPLETION || ENABLE_FEATURE_EDITING_FANCY_PROMPT) |
58 | #define IF_FEATURE_GETUSERNAME_AND_HOMEDIR(...) |
59 | #if ENABLE_FEATURE_GETUSERNAME_AND_HOMEDIR |
60 | #undef IF_FEATURE_GETUSERNAME_AND_HOMEDIR |
61 | #define IF_FEATURE_GETUSERNAME_AND_HOMEDIR(...) __VA_ARGS__ |
62 | #endif |
63 | |
64 | |
65 | #define SEQ_CLEAR_TILL_END_OF_SCREEN "\033[J" |
66 | //#define SEQ_CLEAR_TILL_END_OF_LINE "\033[K" |
67 | |
68 | |
69 | #undef CHAR_T |
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)); } |
76 | # endif |
77 | static bool BB_ispunct(CHAR_T c) { return ((unsigned)c < 256 && ispunct(c)); } |
78 | # undef isspace |
79 | # undef isalnum |
80 | # undef ispunct |
81 | # undef isprint |
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 |
86 | #else |
87 | # define BB_NUL '\0' |
88 | # define CHAR_T char |
89 | # define BB_isspace(c) isspace(c) |
90 | # define BB_isalnum(c) isalnum(c) |
91 | # define BB_ispunct(c) ispunct(c) |
92 | #endif |
93 | |
94 | |
95 | # if ENABLE_UNICODE_PRESERVE_BROKEN |
96 | # define unicode_mark_raw_byte(wc) ((wc) | 0x20000000) |
97 | # define unicode_is_raw_byte(wc) ((wc) & 0x20000000) |
98 | # else |
99 | # define unicode_is_raw_byte(wc) 0 |
100 | # endif |
101 | |
102 | |
103 | enum { |
104 | /* We use int16_t for positions, need to limit line len */ |
105 | MAX_LINELEN = CONFIG_FEATURE_EDITING_MAX_LEN < 0x7ff0 |
106 | ? CONFIG_FEATURE_EDITING_MAX_LEN |
107 | : 0x7ff0 |
108 | }; |
109 | |
110 | #if ENABLE_FEATURE_GETUSERNAME_AND_HOMEDIR |
111 | static const char null_str[] ALIGN1 = ""; |
112 | #endif |
113 | |
114 | /* We try to minimize both static and stack usage. */ |
115 | struct lineedit_statics { |
116 | line_input_t *state; |
117 | |
118 | volatile unsigned cmdedit_termw; /* = 80; */ /* actual terminal width */ |
119 | sighandler_t previous_SIGWINCH_handler; |
120 | |
121 | unsigned cmdedit_x; /* real x (col) terminal position */ |
122 | unsigned cmdedit_y; /* pseudoreal y (row) terminal position */ |
123 | unsigned cmdedit_prmt_len; /* length of prompt (without colors etc) */ |
124 | |
125 | unsigned cursor; |
126 | int command_len; /* must be signed */ |
127 | /* signed maxsize: we want x in "if (x > S.maxsize)" |
128 | * to _not_ be promoted to unsigned */ |
129 | int maxsize; |
130 | CHAR_T *command_ps; |
131 | |
132 | const char *cmdedit_prompt; |
133 | #if ENABLE_FEATURE_EDITING_FANCY_PROMPT |
134 | int num_ok_lines; /* = 1; */ |
135 | #endif |
136 | |
137 | #if ENABLE_FEATURE_GETUSERNAME_AND_HOMEDIR |
138 | char *user_buf; |
139 | char *home_pwd_buf; /* = (char*)null_str; */ |
140 | #endif |
141 | |
142 | #if ENABLE_FEATURE_TAB_COMPLETION |
143 | char **matches; |
144 | unsigned num_matches; |
145 | #endif |
146 | |
147 | #if ENABLE_FEATURE_EDITING_VI |
148 | #define DELBUFSIZ 128 |
149 | CHAR_T *delptr; |
150 | smallint newdelflag; /* whether delbuf should be reused yet */ |
151 | CHAR_T delbuf[DELBUFSIZ]; /* a place to store deleted characters */ |
152 | #endif |
153 | #if ENABLE_FEATURE_EDITING_ASK_TERMINAL |
154 | smallint sent_ESC_br6n; |
155 | #endif |
156 | |
157 | /* Formerly these were big buffers on stack: */ |
158 | #if ENABLE_FEATURE_TAB_COMPLETION |
159 | char exe_n_cwd_tab_completion__dirbuf[MAX_LINELEN]; |
160 | char input_tab__matchBuf[MAX_LINELEN]; |
161 | int16_t find_match__int_buf[MAX_LINELEN + 1]; /* need to have 9 bits at least */ |
162 | int16_t find_match__pos_buf[MAX_LINELEN + 1]; |
163 | #endif |
164 | }; |
165 | |
166 | /* See lineedit_ptr_hack.c */ |
167 | extern struct lineedit_statics *const lineedit_ptr_to_statics; |
168 | |
169 | #define S (*lineedit_ptr_to_statics) |
170 | #define state (S.state ) |
171 | #define cmdedit_termw (S.cmdedit_termw ) |
172 | #define previous_SIGWINCH_handler (S.previous_SIGWINCH_handler) |
173 | #define cmdedit_x (S.cmdedit_x ) |
174 | #define cmdedit_y (S.cmdedit_y ) |
175 | #define cmdedit_prmt_len (S.cmdedit_prmt_len) |
176 | #define cursor (S.cursor ) |
177 | #define command_len (S.command_len ) |
178 | #define command_ps (S.command_ps ) |
179 | #define cmdedit_prompt (S.cmdedit_prompt ) |
180 | #define num_ok_lines (S.num_ok_lines ) |
181 | #define user_buf (S.user_buf ) |
182 | #define home_pwd_buf (S.home_pwd_buf ) |
183 | #define matches (S.matches ) |
184 | #define num_matches (S.num_matches ) |
185 | #define delptr (S.delptr ) |
186 | #define newdelflag (S.newdelflag ) |
187 | #define delbuf (S.delbuf ) |
188 | |
189 | #define INIT_S() do { \ |
190 | (*(struct lineedit_statics**)&lineedit_ptr_to_statics) = xzalloc(sizeof(S)); \ |
191 | barrier(); \ |
192 | cmdedit_termw = 80; \ |
193 | IF_FEATURE_EDITING_FANCY_PROMPT(num_ok_lines = 1;) \ |
194 | IF_FEATURE_GETUSERNAME_AND_HOMEDIR(home_pwd_buf = (char*)null_str;) \ |
195 | } while (0) |
196 | static void deinit_S(void) |
197 | { |
198 | #if ENABLE_FEATURE_EDITING_FANCY_PROMPT |
199 | /* This one is allocated only if FANCY_PROMPT is on |
200 | * (otherwise it points to verbatim prompt (NOT malloced) */ |
201 | free((char*)cmdedit_prompt); |
202 | #endif |
203 | #if ENABLE_FEATURE_GETUSERNAME_AND_HOMEDIR |
204 | free(user_buf); |
205 | if (home_pwd_buf != null_str) |
206 | free(home_pwd_buf); |
207 | #endif |
208 | free(lineedit_ptr_to_statics); |
209 | } |
210 | #define DEINIT_S() deinit_S() |
211 | |
212 | |
213 | #if ENABLE_UNICODE_SUPPORT |
214 | static size_t load_string(const char *src, int maxsize) |
215 | { |
216 | ssize_t len = mbstowcs(command_ps, src, maxsize - 1); |
217 | if (len < 0) |
218 | len = 0; |
219 | command_ps[len] = 0; |
220 | return len; |
221 | } |
222 | static unsigned save_string(char *dst, unsigned maxsize) |
223 | { |
224 | # if !ENABLE_UNICODE_PRESERVE_BROKEN |
225 | ssize_t len = wcstombs(dst, command_ps, maxsize - 1); |
226 | if (len < 0) |
227 | len = 0; |
228 | dst[len] = '\0'; |
229 | return len; |
230 | # else |
231 | unsigned dstpos = 0; |
232 | unsigned srcpos = 0; |
233 | |
234 | maxsize--; |
235 | while (dstpos < maxsize) { |
236 | wchar_t wc; |
237 | int n = srcpos; |
238 | while ((wc = command_ps[srcpos]) != 0 |
239 | && !unicode_is_raw_byte(wc) |
240 | ) { |
241 | srcpos++; |
242 | } |
243 | command_ps[srcpos] = 0; |
244 | n = wcstombs(dst + dstpos, command_ps + n, maxsize - dstpos); |
245 | if (n < 0) /* should not happen */ |
246 | break; |
247 | dstpos += n; |
248 | if (wc == 0) /* usually is */ |
249 | break; |
250 | /* We do have invalid byte here! */ |
251 | command_ps[srcpos] = wc; /* restore it */ |
252 | srcpos++; |
253 | if (dstpos == maxsize) |
254 | break; |
255 | dst[dstpos++] = (char) wc; |
256 | } |
257 | dst[dstpos] = '\0'; |
258 | return dstpos; |
259 | # endif |
260 | } |
261 | /* I thought just fputwc(c, stdout) would work. But no... */ |
262 | static void BB_PUTCHAR(wchar_t c) |
263 | { |
264 | char buf[MB_CUR_MAX + 1]; |
265 | mbstate_t mbst = { 0 }; |
266 | ssize_t len; |
267 | |
268 | len = wcrtomb(buf, c, &mbst); |
269 | if (len > 0) { |
270 | buf[len] = '\0'; |
271 | fputs(buf, stdout); |
272 | } |
273 | } |
274 | # if ENABLE_UNICODE_COMBINING_WCHARS || ENABLE_UNICODE_WIDE_WCHARS |
275 | static wchar_t adjust_width_and_validate_wc(unsigned *width_adj, wchar_t wc) |
276 | # else |
277 | static wchar_t adjust_width_and_validate_wc(wchar_t wc) |
278 | # define adjust_width_and_validate_wc(width_adj, wc) \ |
279 | ((*(width_adj))++, adjust_width_and_validate_wc(wc)) |
280 | # endif |
281 | { |
282 | int w = 1; |
283 | |
284 | if (unicode_status == UNICODE_ON) { |
285 | if (wc > CONFIG_LAST_SUPPORTED_WCHAR) { |
286 | /* note: also true for unicode_is_raw_byte(wc) */ |
287 | goto subst; |
288 | } |
289 | w = wcwidth(wc); |
290 | if ((ENABLE_UNICODE_COMBINING_WCHARS && w < 0) |
291 | || (!ENABLE_UNICODE_COMBINING_WCHARS && w <= 0) |
292 | || (!ENABLE_UNICODE_WIDE_WCHARS && w > 1) |
293 | ) { |
294 | subst: |
295 | w = 1; |
296 | wc = CONFIG_SUBST_WCHAR; |
297 | } |
298 | } |
299 | |
300 | # if ENABLE_UNICODE_COMBINING_WCHARS || ENABLE_UNICODE_WIDE_WCHARS |
301 | *width_adj += w; |
302 | #endif |
303 | return wc; |
304 | } |
305 | #else /* !UNICODE */ |
306 | static size_t load_string(const char *src, int maxsize) |
307 | { |
308 | safe_strncpy(command_ps, src, maxsize); |
309 | return strlen(command_ps); |
310 | } |
311 | # if ENABLE_FEATURE_TAB_COMPLETION |
312 | static void save_string(char *dst, unsigned maxsize) |
313 | { |
314 | safe_strncpy(dst, command_ps, maxsize); |
315 | } |
316 | # endif |
317 | # define BB_PUTCHAR(c) bb_putchar(c) |
318 | /* Should never be called: */ |
319 | int adjust_width_and_validate_wc(unsigned *width_adj, int wc); |
320 | #endif |
321 | |
322 | |
323 | /* Put 'command_ps[cursor]', cursor++. |
324 | * Advance cursor on screen. If we reached right margin, scroll text up |
325 | * and remove terminal margin effect by printing 'next_char' */ |
326 | #define HACK_FOR_WRONG_WIDTH 1 |
327 | static void put_cur_glyph_and_inc_cursor(void) |
328 | { |
329 | CHAR_T c = command_ps[cursor]; |
330 | unsigned width = 0; |
331 | int ofs_to_right; |
332 | |
333 | if (c == BB_NUL) { |
334 | /* erase character after end of input string */ |
335 | c = ' '; |
336 | } else { |
337 | /* advance cursor only if we aren't at the end yet */ |
338 | cursor++; |
339 | if (unicode_status == UNICODE_ON) { |
340 | IF_UNICODE_WIDE_WCHARS(width = cmdedit_x;) |
341 | c = adjust_width_and_validate_wc(&cmdedit_x, c); |
342 | IF_UNICODE_WIDE_WCHARS(width = cmdedit_x - width;) |
343 | } else { |
344 | cmdedit_x++; |
345 | } |
346 | } |
347 | |
348 | ofs_to_right = cmdedit_x - cmdedit_termw; |
349 | if (!ENABLE_UNICODE_WIDE_WCHARS || ofs_to_right <= 0) { |
350 | /* c fits on this line */ |
351 | BB_PUTCHAR(c); |
352 | } |
353 | |
354 | if (ofs_to_right >= 0) { |
355 | /* we go to the next line */ |
356 | #if HACK_FOR_WRONG_WIDTH |
357 | /* This works better if our idea of term width is wrong |
358 | * and it is actually wider (often happens on serial lines). |
359 | * Printing CR,LF *forces* cursor to next line. |
360 | * OTOH if terminal width is correct AND terminal does NOT |
361 | * have automargin (IOW: it is moving cursor to next line |
362 | * by itself (which is wrong for VT-10x terminals)), |
363 | * this will break things: there will be one extra empty line */ |
364 | puts("\r"); /* + implicit '\n' */ |
365 | #else |
366 | /* VT-10x terminals don't wrap cursor to next line when last char |
367 | * on the line is printed - cursor stays "over" this char. |
368 | * Need to print _next_ char too (first one to appear on next line) |
369 | * to make cursor move down to next line. |
370 | */ |
371 | /* Works ok only if cmdedit_termw is correct. */ |
372 | c = command_ps[cursor]; |
373 | if (c == BB_NUL) |
374 | c = ' '; |
375 | BB_PUTCHAR(c); |
376 | bb_putchar('\b'); |
377 | #endif |
378 | cmdedit_y++; |
379 | if (!ENABLE_UNICODE_WIDE_WCHARS || ofs_to_right == 0) { |
380 | width = 0; |
381 | } else { /* ofs_to_right > 0 */ |
382 | /* wide char c didn't fit on prev line */ |
383 | BB_PUTCHAR(c); |
384 | } |
385 | cmdedit_x = width; |
386 | } |
387 | } |
388 | |
389 | /* Move to end of line (by printing all chars till the end) */ |
390 | static void put_till_end_and_adv_cursor(void) |
391 | { |
392 | while (cursor < command_len) |
393 | put_cur_glyph_and_inc_cursor(); |
394 | } |
395 | |
396 | /* Go to the next line */ |
397 | static void goto_new_line(void) |
398 | { |
399 | put_till_end_and_adv_cursor(); |
400 | if (cmdedit_x != 0) |
401 | bb_putchar('\n'); |
402 | } |
403 | |
404 | static void beep(void) |
405 | { |
406 | bb_putchar('\007'); |
407 | } |
408 | |
409 | static void put_prompt(void) |
410 | { |
411 | unsigned w; |
412 | |
413 | fputs(cmdedit_prompt, stdout); |
414 | fflush_all(); |
415 | cursor = 0; |
416 | w = cmdedit_termw; /* read volatile var once */ |
417 | cmdedit_y = cmdedit_prmt_len / w; /* new quasireal y */ |
418 | cmdedit_x = cmdedit_prmt_len % w; |
419 | } |
420 | |
421 | /* Move back one character */ |
422 | /* (optimized for slow terminals) */ |
423 | static void input_backward(unsigned num) |
424 | { |
425 | if (num > cursor) |
426 | num = cursor; |
427 | if (num == 0) |
428 | return; |
429 | cursor -= num; |
430 | |
431 | if ((ENABLE_UNICODE_COMBINING_WCHARS || ENABLE_UNICODE_WIDE_WCHARS) |
432 | && unicode_status == UNICODE_ON |
433 | ) { |
434 | /* correct NUM to be equal to _screen_ width */ |
435 | int n = num; |
436 | num = 0; |
437 | while (--n >= 0) |
438 | adjust_width_and_validate_wc(&num, command_ps[cursor + n]); |
439 | if (num == 0) |
440 | return; |
441 | } |
442 | |
443 | if (cmdedit_x >= num) { |
444 | cmdedit_x -= num; |
445 | if (num <= 4) { |
446 | /* This is longer by 5 bytes on x86. |
447 | * Also gets miscompiled for ARM users |
448 | * (busybox.net/bugs/view.php?id=2274). |
449 | * printf(("\b\b\b\b" + 4) - num); |
450 | * return; |
451 | */ |
452 | do { |
453 | bb_putchar('\b'); |
454 | } while (--num); |
455 | return; |
456 | } |
457 | printf("\033[%uD", num); |
458 | return; |
459 | } |
460 | |
461 | /* Need to go one or more lines up */ |
462 | if (ENABLE_UNICODE_WIDE_WCHARS) { |
463 | /* With wide chars, it is hard to "backtrack" |
464 | * and reliably figure out where to put cursor. |
465 | * Example (<> is a wide char; # is an ordinary char, _ cursor): |
466 | * |prompt: <><> | |
467 | * |<><><><><><> | |
468 | * |_ | |
469 | * and user presses left arrow. num = 1, cmdedit_x = 0, |
470 | * We need to go up one line, and then - how do we know that |
471 | * we need to go *10* positions to the right? Because |
472 | * |prompt: <>#<>| |
473 | * |<><><>#<><><>| |
474 | * |_ | |
475 | * in this situation we need to go *11* positions to the right. |
476 | * |
477 | * A simpler thing to do is to redraw everything from the start |
478 | * up to new cursor position (which is already known): |
479 | */ |
480 | unsigned sv_cursor; |
481 | /* go to 1st column; go up to first line */ |
482 | printf("\r" "\033[%uA", cmdedit_y); |
483 | cmdedit_y = 0; |
484 | sv_cursor = cursor; |
485 | put_prompt(); /* sets cursor to 0 */ |
486 | while (cursor < sv_cursor) |
487 | put_cur_glyph_and_inc_cursor(); |
488 | } else { |
489 | int lines_up; |
490 | unsigned width; |
491 | /* num = chars to go back from the beginning of current line: */ |
492 | num -= cmdedit_x; |
493 | width = cmdedit_termw; /* read volatile var once */ |
494 | /* num=1...w: one line up, w+1...2w: two, etc: */ |
495 | lines_up = 1 + (num - 1) / width; |
496 | cmdedit_x = (width * cmdedit_y - num) % width; |
497 | cmdedit_y -= lines_up; |
498 | /* go to 1st column; go up */ |
499 | printf("\r" "\033[%uA", lines_up); |
500 | /* go to correct column. |
501 | * xterm, konsole, Linux VT interpret 0 as 1 below! wow. |
502 | * need to *make sure* we skip it if cmdedit_x == 0 */ |
503 | if (cmdedit_x) |
504 | printf("\033[%uC", cmdedit_x); |
505 | } |
506 | } |
507 | |
508 | /* draw prompt, editor line, and clear tail */ |
509 | static void redraw(int y, int back_cursor) |
510 | { |
511 | if (y > 0) /* up y lines */ |
512 | printf("\033[%uA", y); |
513 | bb_putchar('\r'); |
514 | put_prompt(); |
515 | put_till_end_and_adv_cursor(); |
516 | printf(SEQ_CLEAR_TILL_END_OF_SCREEN); |
517 | input_backward(back_cursor); |
518 | } |
519 | |
520 | /* Delete the char in front of the cursor, optionally saving it |
521 | * for later putback */ |
522 | #if !ENABLE_FEATURE_EDITING_VI |
523 | static void input_delete(void) |
524 | #define input_delete(save) input_delete() |
525 | #else |
526 | static void input_delete(int save) |
527 | #endif |
528 | { |
529 | int j = cursor; |
530 | |
531 | if (j == (int)command_len) |
532 | return; |
533 | |
534 | #if ENABLE_FEATURE_EDITING_VI |
535 | if (save) { |
536 | if (newdelflag) { |
537 | delptr = delbuf; |
538 | newdelflag = 0; |
539 | } |
540 | if ((delptr - delbuf) < DELBUFSIZ) |
541 | *delptr++ = command_ps[j]; |
542 | } |
543 | #endif |
544 | |
545 | memmove(command_ps + j, command_ps + j + 1, |
546 | /* (command_len + 1 [because of NUL]) - (j + 1) |
547 | * simplified into (command_len - j) */ |
548 | (command_len - j) * sizeof(command_ps[0])); |
549 | command_len--; |
550 | put_till_end_and_adv_cursor(); |
551 | /* Last char is still visible, erase it (and more) */ |
552 | printf(SEQ_CLEAR_TILL_END_OF_SCREEN); |
553 | input_backward(cursor - j); /* back to old pos cursor */ |
554 | } |
555 | |
556 | #if ENABLE_FEATURE_EDITING_VI |
557 | static void put(void) |
558 | { |
559 | int ocursor; |
560 | int j = delptr - delbuf; |
561 | |
562 | if (j == 0) |
563 | return; |
564 | ocursor = cursor; |
565 | /* open hole and then fill it */ |
566 | memmove(command_ps + cursor + j, command_ps + cursor, |
567 | (command_len - cursor + 1) * sizeof(command_ps[0])); |
568 | memcpy(command_ps + cursor, delbuf, j * sizeof(command_ps[0])); |
569 | command_len += j; |
570 | put_till_end_and_adv_cursor(); |
571 | input_backward(cursor - ocursor - j + 1); /* at end of new text */ |
572 | } |
573 | #endif |
574 | |
575 | /* Delete the char in back of the cursor */ |
576 | static void input_backspace(void) |
577 | { |
578 | if (cursor > 0) { |
579 | input_backward(1); |
580 | input_delete(0); |
581 | } |
582 | } |
583 | |
584 | /* Move forward one character */ |
585 | static void input_forward(void) |
586 | { |
587 | if (cursor < command_len) |
588 | put_cur_glyph_and_inc_cursor(); |
589 | } |
590 | |
591 | #if ENABLE_FEATURE_TAB_COMPLETION |
592 | |
593 | static void free_tab_completion_data(void) |
594 | { |
595 | if (matches) { |
596 | while (num_matches) |
597 | free(matches[--num_matches]); |
598 | free(matches); |
599 | matches = NULL; |
600 | } |
601 | } |
602 | |
603 | static void add_match(char *matched) |
604 | { |
605 | matches = xrealloc_vector(matches, 4, num_matches); |
606 | matches[num_matches] = matched; |
607 | num_matches++; |
608 | } |
609 | |
610 | #if ENABLE_FEATURE_USERNAME_COMPLETION |
611 | static void username_tab_completion(char *ud, char *with_shash_flg) |
612 | { |
613 | struct passwd *entry; |
614 | int userlen; |
615 | |
616 | ud++; /* ~user/... to user/... */ |
617 | userlen = strlen(ud); |
618 | |
619 | if (with_shash_flg) { /* "~/..." or "~user/..." */ |
620 | char *sav_ud = ud - 1; |
621 | char *home = NULL; |
622 | |
623 | if (*ud == '/') { /* "~/..." */ |
624 | home = home_pwd_buf; |
625 | } else { |
626 | /* "~user/..." */ |
627 | char *temp; |
628 | temp = strchr(ud, '/'); |
629 | *temp = '\0'; /* ~user\0 */ |
630 | entry = getpwnam(ud); |
631 | *temp = '/'; /* restore ~user/... */ |
632 | ud = temp; |
633 | if (entry) |
634 | home = entry->pw_dir; |
635 | } |
636 | if (home) { |
637 | if ((userlen + strlen(home) + 1) < MAX_LINELEN) { |
638 | /* /home/user/... */ |
639 | sprintf(sav_ud, "%s%s", home, ud); |
640 | } |
641 | } |
642 | } else { |
643 | /* "~[^/]*" */ |
644 | /* Using _r function to avoid pulling in static buffers */ |
645 | char line_buff[256]; |
646 | struct passwd pwd; |
647 | struct passwd *result; |
648 | |
649 | setpwent(); |
650 | while (!getpwent_r(&pwd, line_buff, sizeof(line_buff), &result)) { |
651 | /* Null usernames should result in all users as possible completions. */ |
652 | if (/*!userlen || */ strncmp(ud, pwd.pw_name, userlen) == 0) { |
653 | add_match(xasprintf("~%s/", pwd.pw_name)); |
654 | } |
655 | } |
656 | endpwent(); |
657 | } |
658 | } |
659 | #endif /* FEATURE_COMMAND_USERNAME_COMPLETION */ |
660 | |
661 | enum { |
662 | FIND_EXE_ONLY = 0, |
663 | FIND_DIR_ONLY = 1, |
664 | FIND_FILE_ONLY = 2, |
665 | }; |
666 | |
667 | static int path_parse(char ***p, int flags) |
668 | { |
669 | int npth; |
670 | const char *pth; |
671 | char *tmp; |
672 | char **res; |
673 | |
674 | /* if not setenv PATH variable, to search cur dir "." */ |
675 | if (flags != FIND_EXE_ONLY) |
676 | return 1; |
677 | |
678 | if (state->flags & WITH_PATH_LOOKUP) |
679 | pth = state->path_lookup; |
680 | else |
681 | pth = getenv("PATH"); |
682 | /* PATH=<empty> or PATH=:<empty> */ |
683 | if (!pth || !pth[0] || LONE_CHAR(pth, ':')) |
684 | return 1; |
685 | |
686 | tmp = (char*)pth; |
687 | npth = 1; /* path component count */ |
688 | while (1) { |
689 | tmp = strchr(tmp, ':'); |
690 | if (!tmp) |
691 | break; |
692 | if (*++tmp == '\0') |
693 | break; /* :<empty> */ |
694 | npth++; |
695 | } |
696 | |
697 | res = xmalloc(npth * sizeof(char*)); |
698 | res[0] = tmp = xstrdup(pth); |
699 | npth = 1; |
700 | while (1) { |
701 | tmp = strchr(tmp, ':'); |
702 | if (!tmp) |
703 | break; |
704 | *tmp++ = '\0'; /* ':' -> '\0' */ |
705 | if (*tmp == '\0') |
706 | break; /* :<empty> */ |
707 | res[npth++] = tmp; |
708 | } |
709 | *p = res; |
710 | return npth; |
711 | } |
712 | |
713 | static void exe_n_cwd_tab_completion(char *command, int type) |
714 | { |
715 | DIR *dir; |
716 | struct dirent *next; |
717 | struct stat st; |
718 | char *path1[1]; |
719 | char **paths = path1; |
720 | int npaths; |
721 | int i; |
722 | char *found; |
723 | char *pfind = strrchr(command, '/'); |
724 | /* char dirbuf[MAX_LINELEN]; */ |
725 | #define dirbuf (S.exe_n_cwd_tab_completion__dirbuf) |
726 | |
727 | npaths = 1; |
728 | path1[0] = (char*)"."; |
729 | |
730 | if (pfind == NULL) { |
731 | /* no dir, if flags==EXE_ONLY - get paths, else "." */ |
732 | npaths = path_parse(&paths, type); |
733 | pfind = command; |
734 | } else { |
735 | /* dirbuf = ".../.../.../" */ |
736 | safe_strncpy(dirbuf, command, (pfind - command) + 2); |
737 | #if ENABLE_FEATURE_USERNAME_COMPLETION |
738 | if (dirbuf[0] == '~') /* ~/... or ~user/... */ |
739 | username_tab_completion(dirbuf, dirbuf); |
740 | #endif |
741 | paths[0] = dirbuf; |
742 | /* point to 'l' in "..../last_component" */ |
743 | pfind++; |
744 | } |
745 | |
746 | for (i = 0; i < npaths; i++) { |
747 | dir = opendir(paths[i]); |
748 | if (!dir) |
749 | continue; /* don't print an error */ |
750 | |
751 | while ((next = readdir(dir)) != NULL) { |
752 | int len1; |
753 | const char *str_found = next->d_name; |
754 | |
755 | /* matched? */ |
756 | if (strncmp(str_found, pfind, strlen(pfind))) |
757 | continue; |
758 | /* not see .name without .match */ |
759 | if (*str_found == '.' && *pfind == '\0') { |
760 | if (NOT_LONE_CHAR(paths[i], '/') || str_found[1]) |
761 | continue; |
762 | str_found = ""; /* only "/" */ |
763 | } |
764 | found = concat_path_file(paths[i], str_found); |
765 | /* hmm, remove in progress? */ |
766 | /* NB: stat() first so that we see is it a directory; |
767 | * but if that fails, use lstat() so that |
768 | * we still match dangling links */ |
769 | if (stat(found, &st) && lstat(found, &st)) |
770 | goto cont; |
771 | /* find with dirs? */ |
772 | if (paths[i] != dirbuf) |
773 | strcpy(found, next->d_name); /* only name */ |
774 | |
775 | len1 = strlen(found); |
776 | found = xrealloc(found, len1 + 2); |
777 | found[len1] = '\0'; |
778 | found[len1+1] = '\0'; |
779 | |
780 | if (S_ISDIR(st.st_mode)) { |
781 | /* name is a directory */ |
782 | if (found[len1-1] != '/') { |
783 | found[len1] = '/'; |
784 | } |
785 | } else { |
786 | /* not put found file if search only dirs for cd */ |
787 | if (type == FIND_DIR_ONLY) |
788 | goto cont; |
789 | } |
790 | /* Add it to the list */ |
791 | add_match(found); |
792 | continue; |
793 | cont: |
794 | free(found); |
795 | } |
796 | closedir(dir); |
797 | } |
798 | if (paths != path1) { |
799 | free(paths[0]); /* allocated memory is only in first member */ |
800 | free(paths); |
801 | } |
802 | #undef dirbuf |
803 | } |
804 | |
805 | /* QUOT is used on elements of int_buf[], which are bytes, |
806 | * not Unicode chars. Therefore it works correctly even in Unicode mode. |
807 | */ |
808 | #define QUOT (UCHAR_MAX+1) |
809 | |
810 | #define int_buf (S.find_match__int_buf) |
811 | #define pos_buf (S.find_match__pos_buf) |
812 | /* is must be <= in */ |
813 | static void collapse_pos(int is, int in) |
814 | { |
815 | memmove(int_buf+is, int_buf+in, (MAX_LINELEN+1-in)*sizeof(int_buf[0])); |
816 | memmove(pos_buf+is, pos_buf+in, (MAX_LINELEN+1-in)*sizeof(pos_buf[0])); |
817 | } |
818 | static NOINLINE int find_match(char *matchBuf, int *len_with_quotes) |
819 | { |
820 | int i, j; |
821 | int command_mode; |
822 | int c, c2; |
823 | /* Were local, but it uses too much stack */ |
824 | /* int16_t int_buf[MAX_LINELEN + 1]; */ |
825 | /* int16_t pos_buf[MAX_LINELEN + 1]; */ |
826 | |
827 | /* set to integer dimension characters and own positions */ |
828 | for (i = 0;; i++) { |
829 | int_buf[i] = (unsigned char)matchBuf[i]; |
830 | if (int_buf[i] == 0) { |
831 | pos_buf[i] = -1; /* end-fo-line indicator */ |
832 | break; |
833 | } |
834 | pos_buf[i] = i; |
835 | } |
836 | |
837 | /* mask \+symbol and convert '\t' to ' ' */ |
838 | for (i = j = 0; matchBuf[i]; i++, j++) { |
839 | if (matchBuf[i] == '\\') { |
840 | collapse_pos(j, j + 1); |
841 | int_buf[j] |= QUOT; |
842 | i++; |
843 | } |
844 | } |
845 | /* mask "symbols" or 'symbols' */ |
846 | c2 = 0; |
847 | for (i = 0; int_buf[i]; i++) { |
848 | c = int_buf[i]; |
849 | if (c == '\'' || c == '"') { |
850 | if (c2 == 0) |
851 | c2 = c; |
852 | else { |
853 | if (c == c2) |
854 | c2 = 0; |
855 | else |
856 | int_buf[i] |= QUOT; |
857 | } |
858 | } else if (c2 != 0 && c != '$') |
859 | int_buf[i] |= QUOT; |
860 | } |
861 | |
862 | /* skip commands with arguments if line has commands delimiters */ |
863 | /* ';' ';;' '&' '|' '&&' '||' but `>&' `<&' `>|' */ |
864 | for (i = 0; int_buf[i]; i++) { |
865 | c = int_buf[i]; |
866 | c2 = int_buf[i + 1]; |
867 | j = i ? int_buf[i - 1] : -1; |
868 | command_mode = 0; |
869 | if (c == ';' || c == '&' || c == '|') { |
870 | command_mode = 1 + (c == c2); |
871 | if (c == '&') { |
872 | if (j == '>' || j == '<') |
873 | command_mode = 0; |
874 | } else if (c == '|' && j == '>') |
875 | command_mode = 0; |
876 | } |
877 | if (command_mode) { |
878 | collapse_pos(0, i + command_mode); |
879 | i = -1; /* hack incremet */ |
880 | } |
881 | } |
882 | /* collapse `command...` */ |
883 | for (i = 0; int_buf[i]; i++) { |
884 | if (int_buf[i] == '`') { |
885 | for (j = i + 1; int_buf[j]; j++) |
886 | if (int_buf[j] == '`') { |
887 | collapse_pos(i, j + 1); |
888 | j = 0; |
889 | break; |
890 | } |
891 | if (j) { |
892 | /* not found closing ` - command mode, collapse all previous */ |
893 | collapse_pos(0, i + 1); |
894 | break; |
895 | } else |
896 | i--; /* hack incremet */ |
897 | } |
898 | } |
899 | |
900 | /* collapse (command...(command...)...) or {command...{command...}...} */ |
901 | c = 0; /* "recursive" level */ |
902 | c2 = 0; |
903 | for (i = 0; int_buf[i]; i++) { |
904 | if (int_buf[i] == '(' || int_buf[i] == '{') { |
905 | if (int_buf[i] == '(') |
906 | c++; |
907 | else |
908 | c2++; |
909 | collapse_pos(0, i + 1); |
910 | i = -1; /* hack incremet */ |
911 | } |
912 | } |
913 | for (i = 0; pos_buf[i] >= 0 && (c > 0 || c2 > 0); i++) { |
914 | if ((int_buf[i] == ')' && c > 0) || (int_buf[i] == '}' && c2 > 0)) { |
915 | if (int_buf[i] == ')') |
916 | c--; |
917 | else |
918 | c2--; |
919 | collapse_pos(0, i + 1); |
920 | i = -1; /* hack incremet */ |
921 | } |
922 | } |
923 | |
924 | /* skip first not quote space */ |
925 | for (i = 0; int_buf[i]; i++) |
926 | if (int_buf[i] != ' ') |
927 | break; |
928 | if (i) |
929 | collapse_pos(0, i); |
930 | |
931 | /* set find mode for completion */ |
932 | command_mode = FIND_EXE_ONLY; |
933 | for (i = 0; int_buf[i]; i++) { |
934 | if (int_buf[i] == ' ' || int_buf[i] == '<' || int_buf[i] == '>') { |
935 | if (int_buf[i] == ' ' && command_mode == FIND_EXE_ONLY |
936 | && matchBuf[pos_buf[0]] == 'c' |
937 | && matchBuf[pos_buf[1]] == 'd' |
938 | ) { |
939 | command_mode = FIND_DIR_ONLY; |
940 | } else { |
941 | command_mode = FIND_FILE_ONLY; |
942 | break; |
943 | } |
944 | } |
945 | } |
946 | for (i = 0; int_buf[i]; i++) |
947 | /* "strlen" */; |
948 | /* find last word */ |
949 | for (--i; i >= 0; i--) { |
950 | c = int_buf[i]; |
951 | if (c == ' ' || c == '<' || c == '>' || c == '|' || c == '&') { |
952 | collapse_pos(0, i + 1); |
953 | break; |
954 | } |
955 | } |
956 | /* skip first not quoted '\'' or '"' */ |
957 | for (i = 0; int_buf[i] == '\'' || int_buf[i] == '"'; i++) |
958 | /*skip*/; |
959 | /* collapse quote or unquote // or /~ */ |
960 | while ((int_buf[i] & ~QUOT) == '/' |
961 | && ((int_buf[i+1] & ~QUOT) == '/' || (int_buf[i+1] & ~QUOT) == '~') |
962 | ) { |
963 | i++; |
964 | } |
965 | |
966 | /* set only match and destroy quotes */ |
967 | j = 0; |
968 | for (c = 0; pos_buf[i] >= 0; i++) { |
969 | matchBuf[c++] = matchBuf[pos_buf[i]]; |
970 | j = pos_buf[i] + 1; |
971 | } |
972 | matchBuf[c] = '\0'; |
973 | /* old length matchBuf with quotes symbols */ |
974 | *len_with_quotes = j ? j - pos_buf[0] : 0; |
975 | |
976 | return command_mode; |
977 | } |
978 | #undef int_buf |
979 | #undef pos_buf |
980 | |
981 | /* |
982 | * display by column (original idea from ls applet, |
983 | * very optimized by me :) |
984 | */ |
985 | static void showfiles(void) |
986 | { |
987 | int ncols, row; |
988 | int column_width = 0; |
989 | int nfiles = num_matches; |
990 | int nrows = nfiles; |
991 | int l; |
992 | |
993 | /* find the longest file name - use that as the column width */ |
994 | for (row = 0; row < nrows; row++) { |
995 | l = unicode_strwidth(matches[row]); |
996 | if (column_width < l) |
997 | column_width = l; |
998 | } |
999 | column_width += 2; /* min space for columns */ |
1000 | ncols = cmdedit_termw / column_width; |
1001 | |
1002 | if (ncols > 1) { |
1003 | nrows /= ncols; |
1004 | if (nfiles % ncols) |
1005 | nrows++; /* round up fractionals */ |
1006 | } else { |
1007 | ncols = 1; |
1008 | } |
1009 | for (row = 0; row < nrows; row++) { |
1010 | int n = row; |
1011 | int nc; |
1012 | |
1013 | for (nc = 1; nc < ncols && n+nrows < nfiles; n += nrows, nc++) { |
1014 | printf("%s%-*s", matches[n], |
1015 | (int)(column_width - unicode_strwidth(matches[n])), "" |
1016 | ); |
1017 | } |
1018 | if (ENABLE_UNICODE_SUPPORT) |
1019 | puts(printable_string(NULL, matches[n])); |
1020 | else |
1021 | puts(matches[n]); |
1022 | } |
1023 | } |
1024 | |
1025 | static char *add_quote_for_spec_chars(char *found) |
1026 | { |
1027 | int l = 0; |
1028 | char *s = xzalloc((strlen(found) + 1) * 2); |
1029 | |
1030 | while (*found) { |
1031 | if (strchr(" `\"#$%^&*()=+{}[]:;'|\\<>", *found)) |
1032 | s[l++] = '\\'; |
1033 | s[l++] = *found++; |
1034 | } |
1035 | /* s[l] = '\0'; - already is */ |
1036 | return s; |
1037 | } |
1038 | |
1039 | /* Do TAB completion */ |
1040 | static void input_tab(smallint *lastWasTab) |
1041 | { |
1042 | if (!(state->flags & TAB_COMPLETION)) |
1043 | return; |
1044 | |
1045 | if (!*lastWasTab) { |
1046 | char *tmp, *tmp1; |
1047 | size_t len_found; |
1048 | /* char matchBuf[MAX_LINELEN]; */ |
1049 | #define matchBuf (S.input_tab__matchBuf) |
1050 | int find_type; |
1051 | int recalc_pos; |
1052 | #if ENABLE_UNICODE_SUPPORT |
1053 | /* cursor pos in command converted to multibyte form */ |
1054 | int cursor_mb; |
1055 | #endif |
1056 | |
1057 | *lastWasTab = TRUE; /* flop trigger */ |
1058 | |
1059 | /* Make a local copy of the string -- |
1060 | * up to the position of the cursor */ |
1061 | save_string(matchBuf, cursor + 1); |
1062 | #if ENABLE_UNICODE_SUPPORT |
1063 | cursor_mb = strlen(matchBuf); |
1064 | #endif |
1065 | tmp = matchBuf; |
1066 | |
1067 | find_type = find_match(matchBuf, &recalc_pos); |
1068 | |
1069 | /* Free up any memory already allocated */ |
1070 | free_tab_completion_data(); |
1071 | |
1072 | #if ENABLE_FEATURE_USERNAME_COMPLETION |
1073 | /* If the word starts with `~' and there is no slash in the word, |
1074 | * then try completing this word as a username. */ |
1075 | if (state->flags & USERNAME_COMPLETION) |
1076 | if (matchBuf[0] == '~' && strchr(matchBuf, '/') == NULL) |
1077 | username_tab_completion(matchBuf, NULL); |
1078 | #endif |
1079 | /* Try to match any executable in our path and everything |
1080 | * in the current working directory */ |
1081 | if (!matches) |
1082 | exe_n_cwd_tab_completion(matchBuf, find_type); |
1083 | /* Sort, then remove any duplicates found */ |
1084 | if (matches) { |
1085 | unsigned i; |
1086 | int n = 0; |
1087 | qsort_string_vector(matches, num_matches); |
1088 | for (i = 0; i < num_matches - 1; ++i) { |
1089 | if (matches[i] && matches[i+1]) { /* paranoia */ |
1090 | if (strcmp(matches[i], matches[i+1]) == 0) { |
1091 | free(matches[i]); |
1092 | matches[i] = NULL; /* paranoia */ |
1093 | } else { |
1094 | matches[n++] = matches[i]; |
1095 | } |
1096 | } |
1097 | } |
1098 | matches[n] = matches[i]; |
1099 | num_matches = n + 1; |
1100 | } |
1101 | /* Did we find exactly one match? */ |
1102 | if (!matches || num_matches > 1) { /* no */ |
1103 | beep(); |
1104 | if (!matches) |
1105 | return; /* not found */ |
1106 | /* find minimal match */ |
1107 | tmp1 = xstrdup(matches[0]); |
1108 | for (tmp = tmp1; *tmp; tmp++) { |
1109 | for (len_found = 1; len_found < num_matches; len_found++) { |
1110 | if (matches[len_found][tmp - tmp1] != *tmp) { |
1111 | *tmp = '\0'; |
1112 | break; |
1113 | } |
1114 | } |
1115 | } |
1116 | if (*tmp1 == '\0') { /* have unique */ |
1117 | free(tmp1); |
1118 | return; |
1119 | } |
1120 | tmp = add_quote_for_spec_chars(tmp1); |
1121 | free(tmp1); |
1122 | } else { /* one match */ |
1123 | tmp = add_quote_for_spec_chars(matches[0]); |
1124 | /* for next completion current found */ |
1125 | *lastWasTab = FALSE; |
1126 | |
1127 | len_found = strlen(tmp); |
1128 | if (tmp[len_found-1] != '/') { |
1129 | tmp[len_found] = ' '; |
1130 | tmp[len_found+1] = '\0'; |
1131 | } |
1132 | } |
1133 | |
1134 | len_found = strlen(tmp); |
1135 | #if !ENABLE_UNICODE_SUPPORT |
1136 | /* have space to place the match? */ |
1137 | /* The result consists of three parts with these lengths: */ |
1138 | /* (cursor - recalc_pos) + len_found + (command_len - cursor) */ |
1139 | /* it simplifies into: */ |
1140 | if ((int)(len_found + command_len - recalc_pos) < S.maxsize) { |
1141 | /* save tail */ |
1142 | strcpy(matchBuf, command_ps + cursor); |
1143 | /* add match and tail */ |
1144 | sprintf(&command_ps[cursor - recalc_pos], "%s%s", tmp, matchBuf); |
1145 | command_len = strlen(command_ps); |
1146 | /* new pos */ |
1147 | recalc_pos = cursor - recalc_pos + len_found; |
1148 | /* write out the matched command */ |
1149 | redraw(cmdedit_y, command_len - recalc_pos); |
1150 | } |
1151 | #else |
1152 | { |
1153 | char command[MAX_LINELEN]; |
1154 | int len = save_string(command, sizeof(command)); |
1155 | /* have space to place the match? */ |
1156 | /* (cursor_mb - recalc_pos) + len_found + (len - cursor_mb) */ |
1157 | if ((int)(len_found + len - recalc_pos) < MAX_LINELEN) { |
1158 | /* save tail */ |
1159 | strcpy(matchBuf, command + cursor_mb); |
1160 | /* where do we want to have cursor after all? */ |
1161 | strcpy(&command[cursor_mb - recalc_pos], tmp); |
1162 | len = load_string(command, S.maxsize); |
1163 | /* add match and tail */ |
1164 | sprintf(&command[cursor_mb - recalc_pos], "%s%s", tmp, matchBuf); |
1165 | command_len = load_string(command, S.maxsize); |
1166 | /* write out the matched command */ |
1167 | redraw(cmdedit_y, command_len - len); |
1168 | } |
1169 | } |
1170 | #endif |
1171 | free(tmp); |
1172 | #undef matchBuf |
1173 | } else { |
1174 | /* Ok -- the last char was a TAB. Since they |
1175 | * just hit TAB again, print a list of all the |
1176 | * available choices... */ |
1177 | if (matches && num_matches > 0) { |
1178 | /* changed by goto_new_line() */ |
1179 | int sav_cursor = cursor; |
1180 | |
1181 | /* Go to the next line */ |
1182 | goto_new_line(); |
1183 | showfiles(); |
1184 | redraw(0, command_len - sav_cursor); |
1185 | } |
1186 | } |
1187 | } |
1188 | |
1189 | #endif /* FEATURE_COMMAND_TAB_COMPLETION */ |
1190 | |
1191 | |
1192 | line_input_t* FAST_FUNC new_line_input_t(int flags) |
1193 | { |
1194 | line_input_t *n = xzalloc(sizeof(*n)); |
1195 | n->flags = flags; |
1196 | return n; |
1197 | } |
1198 | |
1199 | |
1200 | #if MAX_HISTORY > 0 |
1201 | |
1202 | static void save_command_ps_at_cur_history(void) |
1203 | { |
1204 | if (command_ps[0] != BB_NUL) { |
1205 | int cur = state->cur_history; |
1206 | free(state->history[cur]); |
1207 | |
1208 | # if ENABLE_UNICODE_SUPPORT |
1209 | { |
1210 | char tbuf[MAX_LINELEN]; |
1211 | save_string(tbuf, sizeof(tbuf)); |
1212 | state->history[cur] = xstrdup(tbuf); |
1213 | } |
1214 | # else |
1215 | state->history[cur] = xstrdup(command_ps); |
1216 | # endif |
1217 | } |
1218 | } |
1219 | |
1220 | /* state->flags is already checked to be nonzero */ |
1221 | static int get_previous_history(void) |
1222 | { |
1223 | if ((state->flags & DO_HISTORY) && state->cur_history) { |
1224 | save_command_ps_at_cur_history(); |
1225 | state->cur_history--; |
1226 | return 1; |
1227 | } |
1228 | beep(); |
1229 | return 0; |
1230 | } |
1231 | |
1232 | static int get_next_history(void) |
1233 | { |
1234 | if (state->flags & DO_HISTORY) { |
1235 | if (state->cur_history < state->cnt_history) { |
1236 | save_command_ps_at_cur_history(); /* save the current history line */ |
1237 | return ++state->cur_history; |
1238 | } |
1239 | } |
1240 | beep(); |
1241 | return 0; |
1242 | } |
1243 | |
1244 | # if ENABLE_FEATURE_EDITING_SAVEHISTORY |
1245 | /* We try to ensure that concurrent additions to the history |
1246 | * do not overwrite each other. |
1247 | * Otherwise shell users get unhappy. |
1248 | * |
1249 | * History file is trimmed lazily, when it grows several times longer |
1250 | * than configured MAX_HISTORY lines. |
1251 | */ |
1252 | |
1253 | static void free_line_input_t(line_input_t *n) |
1254 | { |
1255 | int i = n->cnt_history; |
1256 | while (i > 0) |
1257 | free(n->history[--i]); |
1258 | free(n); |
1259 | } |
1260 | |
1261 | /* state->flags is already checked to be nonzero */ |
1262 | static void load_history(line_input_t *st_parm) |
1263 | { |
1264 | char *temp_h[MAX_HISTORY]; |
1265 | char *line; |
1266 | FILE *fp; |
1267 | unsigned idx, i, line_len; |
1268 | |
1269 | /* NB: do not trash old history if file can't be opened */ |
1270 | |
1271 | fp = fopen_for_read(st_parm->hist_file); |
1272 | if (fp) { |
1273 | /* clean up old history */ |
1274 | for (idx = st_parm->cnt_history; idx > 0;) { |
1275 | idx--; |
1276 | free(st_parm->history[idx]); |
1277 | st_parm->history[idx] = NULL; |
1278 | } |
1279 | |
1280 | /* fill temp_h[], retaining only last MAX_HISTORY lines */ |
1281 | memset(temp_h, 0, sizeof(temp_h)); |
1282 | st_parm->cnt_history_in_file = idx = 0; |
1283 | while ((line = xmalloc_fgetline(fp)) != NULL) { |
1284 | if (line[0] == '\0') { |
1285 | free(line); |
1286 | continue; |
1287 | } |
1288 | free(temp_h[idx]); |
1289 | temp_h[idx] = line; |
1290 | st_parm->cnt_history_in_file++; |
1291 | idx++; |
1292 | if (idx == MAX_HISTORY) |
1293 | idx = 0; |
1294 | } |
1295 | fclose(fp); |
1296 | |
1297 | /* find first non-NULL temp_h[], if any */ |
1298 | if (st_parm->cnt_history_in_file) { |
1299 | while (temp_h[idx] == NULL) { |
1300 | idx++; |
1301 | if (idx == MAX_HISTORY) |
1302 | idx = 0; |
1303 | } |
1304 | } |
1305 | |
1306 | /* copy temp_h[] to st_parm->history[] */ |
1307 | for (i = 0; i < MAX_HISTORY;) { |
1308 | line = temp_h[idx]; |
1309 | if (!line) |
1310 | break; |
1311 | idx++; |
1312 | if (idx == MAX_HISTORY) |
1313 | idx = 0; |
1314 | line_len = strlen(line); |
1315 | if (line_len >= MAX_LINELEN) |
1316 | line[MAX_LINELEN-1] = '\0'; |
1317 | st_parm->history[i++] = line; |
1318 | } |
1319 | st_parm->cnt_history = i; |
1320 | } |
1321 | } |
1322 | |
1323 | /* state->flags is already checked to be nonzero */ |
1324 | static void save_history(char *str) |
1325 | { |
1326 | int fd; |
1327 | int len, len2; |
1328 | |
1329 | fd = open(state->hist_file, O_WRONLY | O_CREAT | O_APPEND, 0666); |
1330 | if (fd < 0) |
1331 | return; |
1332 | xlseek(fd, 0, SEEK_END); /* paranoia */ |
1333 | len = strlen(str); |
1334 | str[len] = '\n'; /* we (try to) do atomic write */ |
1335 | len2 = full_write(fd, str, len + 1); |
1336 | str[len] = '\0'; |
1337 | close(fd); |
1338 | if (len2 != len + 1) |
1339 | return; /* "wtf?" */ |
1340 | |
1341 | /* did we write so much that history file needs trimming? */ |
1342 | state->cnt_history_in_file++; |
1343 | if (state->cnt_history_in_file > MAX_HISTORY * 4) { |
1344 | FILE *fp; |
1345 | char *new_name; |
1346 | line_input_t *st_temp; |
1347 | int i; |
1348 | |
1349 | /* we may have concurrently written entries from others. |
1350 | * load them */ |
1351 | st_temp = new_line_input_t(state->flags); |
1352 | st_temp->hist_file = state->hist_file; |
1353 | load_history(st_temp); |
1354 | |
1355 | /* write out temp file and replace hist_file atomically */ |
1356 | new_name = xasprintf("%s.%u.new", state->hist_file, (int) getpid()); |
1357 | fp = fopen_for_write(new_name); |
1358 | if (fp) { |
1359 | for (i = 0; i < st_temp->cnt_history; i++) |
1360 | fprintf(fp, "%s\n", st_temp->history[i]); |
1361 | fclose(fp); |
1362 | if (rename(new_name, state->hist_file) == 0) |
1363 | state->cnt_history_in_file = st_temp->cnt_history; |
1364 | } |
1365 | free(new_name); |
1366 | free_line_input_t(st_temp); |
1367 | } |
1368 | } |
1369 | # else |
1370 | # define load_history(a) ((void)0) |
1371 | # define save_history(a) ((void)0) |
1372 | # endif /* FEATURE_COMMAND_SAVEHISTORY */ |
1373 | |
1374 | static void remember_in_history(char *str) |
1375 | { |
1376 | int i; |
1377 | |
1378 | if (!(state->flags & DO_HISTORY)) |
1379 | return; |
1380 | if (str[0] == '\0') |
1381 | return; |
1382 | i = state->cnt_history; |
1383 | /* Don't save dupes */ |
1384 | if (i && strcmp(state->history[i-1], str) == 0) |
1385 | return; |
1386 | |
1387 | free(state->history[MAX_HISTORY]); /* redundant, paranoia */ |
1388 | state->history[MAX_HISTORY] = NULL; /* redundant, paranoia */ |
1389 | |
1390 | /* If history[] is full, remove the oldest command */ |
1391 | /* we need to keep history[MAX_HISTORY] empty, hence >=, not > */ |
1392 | if (i >= MAX_HISTORY) { |
1393 | free(state->history[0]); |
1394 | for (i = 0; i < MAX_HISTORY-1; i++) |
1395 | state->history[i] = state->history[i+1]; |
1396 | /* i == MAX_HISTORY-1 */ |
1397 | } |
1398 | /* i <= MAX_HISTORY-1 */ |
1399 | state->history[i++] = xstrdup(str); |
1400 | /* i <= MAX_HISTORY */ |
1401 | state->cur_history = i; |
1402 | state->cnt_history = i; |
1403 | # if MAX_HISTORY > 0 && ENABLE_FEATURE_EDITING_SAVEHISTORY |
1404 | if ((state->flags & SAVE_HISTORY) && state->hist_file) |
1405 | save_history(str); |
1406 | # endif |
1407 | IF_FEATURE_EDITING_FANCY_PROMPT(num_ok_lines++;) |
1408 | } |
1409 | |
1410 | #else /* MAX_HISTORY == 0 */ |
1411 | # define remember_in_history(a) ((void)0) |
1412 | #endif /* MAX_HISTORY */ |
1413 | |
1414 | |
1415 | #if ENABLE_FEATURE_EDITING_VI |
1416 | /* |
1417 | * vi mode implemented 2005 by Paul Fox <pgf@foxharp.boston.ma.us> |
1418 | */ |
1419 | static void |
1420 | vi_Word_motion(int eat) |
1421 | { |
1422 | CHAR_T *command = command_ps; |
1423 | |
1424 | while (cursor < command_len && !BB_isspace(command[cursor])) |
1425 | input_forward(); |
1426 | if (eat) while (cursor < command_len && BB_isspace(command[cursor])) |
1427 | input_forward(); |
1428 | } |
1429 | |
1430 | static void |
1431 | vi_word_motion(int eat) |
1432 | { |
1433 | CHAR_T *command = command_ps; |
1434 | |
1435 | if (BB_isalnum(command[cursor]) || command[cursor] == '_') { |
1436 | while (cursor < command_len |
1437 | && (BB_isalnum(command[cursor+1]) || command[cursor+1] == '_') |
1438 | ) { |
1439 | input_forward(); |
1440 | } |
1441 | } else if (BB_ispunct(command[cursor])) { |
1442 | while (cursor < command_len && BB_ispunct(command[cursor+1])) |
1443 | input_forward(); |
1444 | } |
1445 | |
1446 | if (cursor < command_len) |
1447 | input_forward(); |
1448 | |
1449 | if (eat) { |
1450 | while (cursor < command_len && BB_isspace(command[cursor])) |
1451 | input_forward(); |
1452 | } |
1453 | } |
1454 | |
1455 | static void |
1456 | vi_End_motion(void) |
1457 | { |
1458 | CHAR_T *command = command_ps; |
1459 | |
1460 | input_forward(); |
1461 | while (cursor < command_len && BB_isspace(command[cursor])) |
1462 | input_forward(); |
1463 | while (cursor < command_len-1 && !BB_isspace(command[cursor+1])) |
1464 | input_forward(); |
1465 | } |
1466 | |
1467 | static void |
1468 | vi_end_motion(void) |
1469 | { |
1470 | CHAR_T *command = command_ps; |
1471 | |
1472 | if (cursor >= command_len-1) |
1473 | return; |
1474 | input_forward(); |
1475 | while (cursor < command_len-1 && BB_isspace(command[cursor])) |
1476 | input_forward(); |
1477 | if (cursor >= command_len-1) |
1478 | return; |
1479 | if (BB_isalnum(command[cursor]) || command[cursor] == '_') { |
1480 | while (cursor < command_len-1 |
1481 | && (BB_isalnum(command[cursor+1]) || command[cursor+1] == '_') |
1482 | ) { |
1483 | input_forward(); |
1484 | } |
1485 | } else if (BB_ispunct(command[cursor])) { |
1486 | while (cursor < command_len-1 && BB_ispunct(command[cursor+1])) |
1487 | input_forward(); |
1488 | } |
1489 | } |
1490 | |
1491 | static void |
1492 | vi_Back_motion(void) |
1493 | { |
1494 | CHAR_T *command = command_ps; |
1495 | |
1496 | while (cursor > 0 && BB_isspace(command[cursor-1])) |
1497 | input_backward(1); |
1498 | while (cursor > 0 && !BB_isspace(command[cursor-1])) |
1499 | input_backward(1); |
1500 | } |
1501 | |
1502 | static void |
1503 | vi_back_motion(void) |
1504 | { |
1505 | CHAR_T *command = command_ps; |
1506 | |
1507 | if (cursor <= 0) |
1508 | return; |
1509 | input_backward(1); |
1510 | while (cursor > 0 && BB_isspace(command[cursor])) |
1511 | input_backward(1); |
1512 | if (cursor <= 0) |
1513 | return; |
1514 | if (BB_isalnum(command[cursor]) || command[cursor] == '_') { |
1515 | while (cursor > 0 |
1516 | && (BB_isalnum(command[cursor-1]) || command[cursor-1] == '_') |
1517 | ) { |
1518 | input_backward(1); |
1519 | } |
1520 | } else if (BB_ispunct(command[cursor])) { |
1521 | while (cursor > 0 && BB_ispunct(command[cursor-1])) |
1522 | input_backward(1); |
1523 | } |
1524 | } |
1525 | #endif |
1526 | |
1527 | /* Modelled after bash 4.0 behavior of Ctrl-<arrow> */ |
1528 | static void ctrl_left(void) |
1529 | { |
1530 | CHAR_T *command = command_ps; |
1531 | |
1532 | while (1) { |
1533 | CHAR_T c; |
1534 | |
1535 | input_backward(1); |
1536 | if (cursor == 0) |
1537 | break; |
1538 | c = command[cursor]; |
1539 | if (c != ' ' && !BB_ispunct(c)) { |
1540 | /* we reached a "word" delimited by spaces/punct. |
1541 | * go to its beginning */ |
1542 | while (1) { |
1543 | c = command[cursor - 1]; |
1544 | if (c == ' ' || BB_ispunct(c)) |
1545 | break; |
1546 | input_backward(1); |
1547 | if (cursor == 0) |
1548 | break; |
1549 | } |
1550 | break; |
1551 | } |
1552 | } |
1553 | } |
1554 | static void ctrl_right(void) |
1555 | { |
1556 | CHAR_T *command = command_ps; |
1557 | |
1558 | while (1) { |
1559 | CHAR_T c; |
1560 | |
1561 | c = command[cursor]; |
1562 | if (c == BB_NUL) |
1563 | break; |
1564 | if (c != ' ' && !BB_ispunct(c)) { |
1565 | /* we reached a "word" delimited by spaces/punct. |
1566 | * go to its end + 1 */ |
1567 | while (1) { |
1568 | input_forward(); |
1569 | c = command[cursor]; |
1570 | if (c == BB_NUL || c == ' ' || BB_ispunct(c)) |
1571 | break; |
1572 | } |
1573 | break; |
1574 | } |
1575 | input_forward(); |
1576 | } |
1577 | } |
1578 | |
1579 | |
1580 | /* |
1581 | * read_line_input and its helpers |
1582 | */ |
1583 | |
1584 | #if ENABLE_FEATURE_EDITING_ASK_TERMINAL |
1585 | static void ask_terminal(void) |
1586 | { |
1587 | /* Ask terminal where is the cursor now. |
1588 | * lineedit_read_key handles response and corrects |
1589 | * our idea of current cursor position. |
1590 | * Testcase: run "echo -n long_line_long_line_long_line", |
1591 | * then type in a long, wrapping command and try to |
1592 | * delete it using backspace key. |
1593 | * Note: we print it _after_ prompt, because |
1594 | * prompt may contain CR. Example: PS1='\[\r\n\]\w ' |
1595 | */ |
1596 | /* Problem: if there is buffered input on stdin, |
1597 | * the response will be delivered later, |
1598 | * possibly to an unsuspecting application. |
1599 | * Testcase: "sleep 1; busybox ash" + press and hold [Enter]. |
1600 | * Result: |
1601 | * ~/srcdevel/bbox/fix/busybox.t4 # |
1602 | * ~/srcdevel/bbox/fix/busybox.t4 # |
1603 | * ^[[59;34~/srcdevel/bbox/fix/busybox.t4 # <-- garbage |
1604 | * ~/srcdevel/bbox/fix/busybox.t4 # |
1605 | * |
1606 | * Checking for input with poll only makes the race narrower, |
1607 | * I still can trigger it. Strace: |
1608 | * |
1609 | * write(1, "~/srcdevel/bbox/fix/busybox.t4 # ", 33) = 33 |
1610 | * poll([{fd=0, events=POLLIN}], 1, 0) = 0 (Timeout) <-- no input exists |
1611 | * write(1, "\33[6n", 4) = 4 <-- send the ESC sequence, quick! |
1612 | * poll([{fd=0, events=POLLIN}], 1, 4294967295) = 1 ([{fd=0, revents=POLLIN}]) |
1613 | * read(0, "\n", 1) = 1 <-- oh crap, user's input got in first |
1614 | */ |
1615 | struct pollfd pfd; |
1616 | |
1617 | pfd.fd = STDIN_FILENO; |
1618 | pfd.events = POLLIN; |
1619 | if (safe_poll(&pfd, 1, 0) == 0) { |
1620 | S.sent_ESC_br6n = 1; |
1621 | fputs("\033" "[6n", stdout); |
1622 | fflush_all(); /* make terminal see it ASAP! */ |
1623 | } |
1624 | } |
1625 | #else |
1626 | #define ask_terminal() ((void)0) |
1627 | #endif |
1628 | |
1629 | #if !ENABLE_FEATURE_EDITING_FANCY_PROMPT |
1630 | static void parse_and_put_prompt(const char *prmt_ptr) |
1631 | { |
1632 | cmdedit_prompt = prmt_ptr; |
1633 | cmdedit_prmt_len = strlen(prmt_ptr); |
1634 | put_prompt(); |
1635 | } |
1636 | #else |
1637 | static void parse_and_put_prompt(const char *prmt_ptr) |
1638 | { |
1639 | int prmt_len = 0; |
1640 | size_t cur_prmt_len = 0; |
1641 | char flg_not_length = '['; |
1642 | char *prmt_mem_ptr = xzalloc(1); |
1643 | char *cwd_buf = xrealloc_getcwd_or_warn(NULL); |
1644 | char cbuf[2]; |
1645 | char c; |
1646 | char *pbuf; |
1647 | |
1648 | cmdedit_prmt_len = 0; |
1649 | |
1650 | if (!cwd_buf) { |
1651 | cwd_buf = (char *)bb_msg_unknown; |
1652 | } |
1653 | |
1654 | cbuf[1] = '\0'; /* never changes */ |
1655 | |
1656 | while (*prmt_ptr) { |
1657 | char *free_me = NULL; |
1658 | |
1659 | pbuf = cbuf; |
1660 | c = *prmt_ptr++; |
1661 | if (c == '\\') { |
1662 | const char *cp = prmt_ptr; |
1663 | int l; |
1664 | |
1665 | c = bb_process_escape_sequence(&prmt_ptr); |
1666 | if (prmt_ptr == cp) { |
1667 | if (*cp == '\0') |
1668 | break; |
1669 | c = *prmt_ptr++; |
1670 | |
1671 | switch (c) { |
1672 | # if ENABLE_FEATURE_GETUSERNAME_AND_HOMEDIR |
1673 | case 'u': |
1674 | pbuf = user_buf ? user_buf : (char*)""; |
1675 | break; |
1676 | # endif |
1677 | case 'h': |
1678 | pbuf = free_me = safe_gethostname(); |
1679 | *strchrnul(pbuf, '.') = '\0'; |
1680 | break; |
1681 | case '$': |
1682 | c = (geteuid() == 0 ? '#' : '$'); |
1683 | break; |
1684 | # if ENABLE_FEATURE_GETUSERNAME_AND_HOMEDIR |
1685 | case 'w': |
1686 | /* /home/user[/something] -> ~[/something] */ |
1687 | pbuf = cwd_buf; |
1688 | l = strlen(home_pwd_buf); |
1689 | if (l != 0 |
1690 | && strncmp(home_pwd_buf, cwd_buf, l) == 0 |
1691 | && (cwd_buf[l]=='/' || cwd_buf[l]=='\0') |
1692 | && strlen(cwd_buf + l) < PATH_MAX |
1693 | ) { |
1694 | pbuf = free_me = xasprintf("~%s", cwd_buf + l); |
1695 | } |
1696 | break; |
1697 | # endif |
1698 | case 'W': |
1699 | pbuf = cwd_buf; |
1700 | cp = strrchr(pbuf, '/'); |
1701 | if (cp != NULL && cp != pbuf) |
1702 | pbuf += (cp-pbuf) + 1; |
1703 | break; |
1704 | case '!': |
1705 | pbuf = free_me = xasprintf("%d", num_ok_lines); |
1706 | break; |
1707 | case 'e': case 'E': /* \e \E = \033 */ |
1708 | c = '\033'; |
1709 | break; |
1710 | case 'x': case 'X': { |
1711 | char buf2[4]; |
1712 | for (l = 0; l < 3;) { |
1713 | unsigned h; |
1714 | buf2[l++] = *prmt_ptr; |
1715 | buf2[l] = '\0'; |
1716 | h = strtoul(buf2, &pbuf, 16); |
1717 | if (h > UCHAR_MAX || (pbuf - buf2) < l) { |
1718 | buf2[--l] = '\0'; |
1719 | break; |
1720 | } |
1721 | prmt_ptr++; |
1722 | } |
1723 | c = (char)strtoul(buf2, NULL, 16); |
1724 | if (c == 0) |
1725 | c = '?'; |
1726 | pbuf = cbuf; |
1727 | break; |
1728 | } |
1729 | case '[': case ']': |
1730 | if (c == flg_not_length) { |
1731 | flg_not_length = (flg_not_length == '[' ? ']' : '['); |
1732 | continue; |
1733 | } |
1734 | break; |
1735 | } /* switch */ |
1736 | } /* if */ |
1737 | } /* if */ |
1738 | cbuf[0] = c; |
1739 | cur_prmt_len = strlen(pbuf); |
1740 | prmt_len += cur_prmt_len; |
1741 | if (flg_not_length != ']') |
1742 | cmdedit_prmt_len += cur_prmt_len; |
1743 | prmt_mem_ptr = strcat(xrealloc(prmt_mem_ptr, prmt_len+1), pbuf); |
1744 | free(free_me); |
1745 | } /* while */ |
1746 | |
1747 | if (cwd_buf != (char *)bb_msg_unknown) |
1748 | free(cwd_buf); |
1749 | cmdedit_prompt = prmt_mem_ptr; |
1750 | put_prompt(); |
1751 | } |
1752 | #endif |
1753 | |
1754 | static void cmdedit_setwidth(unsigned w, int redraw_flg) |
1755 | { |
1756 | cmdedit_termw = w; |
1757 | if (redraw_flg) { |
1758 | /* new y for current cursor */ |
1759 | int new_y = (cursor + cmdedit_prmt_len) / w; |
1760 | /* redraw */ |
1761 | redraw((new_y >= cmdedit_y ? new_y : cmdedit_y), command_len - cursor); |
1762 | fflush_all(); |
1763 | } |
1764 | } |
1765 | |
1766 | static void win_changed(int nsig) |
1767 | { |
1768 | int sv_errno = errno; |
1769 | unsigned width; |
1770 | get_terminal_width_height(0, &width, NULL); |
1771 | cmdedit_setwidth(width, nsig /* - just a yes/no flag */); |
1772 | if (nsig == SIGWINCH) |
1773 | signal(SIGWINCH, win_changed); /* rearm ourself */ |
1774 | errno = sv_errno; |
1775 | } |
1776 | |
1777 | static int lineedit_read_key(char *read_key_buffer) |
1778 | { |
1779 | int64_t ic; |
1780 | int timeout = -1; |
1781 | #if ENABLE_UNICODE_SUPPORT |
1782 | char unicode_buf[MB_CUR_MAX + 1]; |
1783 | int unicode_idx = 0; |
1784 | #endif |
1785 | |
1786 | while (1) { |
1787 | /* Wait for input. TIMEOUT = -1 makes read_key wait even |
1788 | * on nonblocking stdin, TIMEOUT = 50 makes sure we won't |
1789 | * insist on full MB_CUR_MAX buffer to declare input like |
1790 | * "\xff\n",pause,"ls\n" invalid and thus won't lose "ls". |
1791 | * |
1792 | * Note: read_key sets errno to 0 on success. |
1793 | */ |
1794 | ic = read_key(STDIN_FILENO, read_key_buffer, timeout); |
1795 | if (errno) { |
1796 | #if ENABLE_UNICODE_SUPPORT |
1797 | if (errno == EAGAIN && unicode_idx != 0) |
1798 | goto pushback; |
1799 | #endif |
1800 | break; |
1801 | } |
1802 | |
1803 | #if ENABLE_FEATURE_EDITING_ASK_TERMINAL |
1804 | if ((int32_t)ic == KEYCODE_CURSOR_POS |
1805 | && S.sent_ESC_br6n |
1806 | ) { |
1807 | S.sent_ESC_br6n = 0; |
1808 | if (cursor == 0) { /* otherwise it may be bogus */ |
1809 | int col = ((ic >> 32) & 0x7fff) - 1; |
1810 | if (col > cmdedit_prmt_len) { |
1811 | cmdedit_x += (col - cmdedit_prmt_len); |
1812 | while (cmdedit_x >= cmdedit_termw) { |
1813 | cmdedit_x -= cmdedit_termw; |
1814 | cmdedit_y++; |
1815 | } |
1816 | } |
1817 | } |
1818 | continue; |
1819 | } |
1820 | #endif |
1821 | |
1822 | #if ENABLE_UNICODE_SUPPORT |
1823 | if (unicode_status == UNICODE_ON) { |
1824 | wchar_t wc; |
1825 | |
1826 | if ((int32_t)ic < 0) /* KEYCODE_xxx */ |
1827 | break; |
1828 | // TODO: imagine sequence like: 0xff,<left-arrow>: we are currently losing 0xff... |
1829 | |
1830 | unicode_buf[unicode_idx++] = ic; |
1831 | unicode_buf[unicode_idx] = '\0'; |
1832 | if (mbstowcs(&wc, unicode_buf, 1) != 1) { |
1833 | /* Not (yet?) a valid unicode char */ |
1834 | if (unicode_idx < MB_CUR_MAX) { |
1835 | timeout = 50; |
1836 | continue; |
1837 | } |
1838 | pushback: |
1839 | /* Invalid sequence. Save all "bad bytes" except first */ |
1840 | read_key_ungets(read_key_buffer, unicode_buf + 1, unicode_idx - 1); |
1841 | # if !ENABLE_UNICODE_PRESERVE_BROKEN |
1842 | ic = CONFIG_SUBST_WCHAR; |
1843 | # else |
1844 | ic = unicode_mark_raw_byte(unicode_buf[0]); |
1845 | # endif |
1846 | } else { |
1847 | /* Valid unicode char, return its code */ |
1848 | ic = wc; |
1849 | } |
1850 | } |
1851 | #endif |
1852 | break; |
1853 | } |
1854 | |
1855 | return ic; |
1856 | } |
1857 | |
1858 | #if ENABLE_UNICODE_BIDI_SUPPORT |
1859 | static int isrtl_str(void) |
1860 | { |
1861 | int idx = cursor; |
1862 | |
1863 | while (idx < command_len && unicode_bidi_is_neutral_wchar(command_ps[idx])) |
1864 | idx++; |
1865 | return unicode_bidi_isrtl(command_ps[idx]); |
1866 | } |
1867 | #else |
1868 | # define isrtl_str() 0 |
1869 | #endif |
1870 | |
1871 | /* leave out the "vi-mode"-only case labels if vi editing isn't |
1872 | * configured. */ |
1873 | #define vi_case(caselabel) IF_FEATURE_EDITING_VI(case caselabel) |
1874 | |
1875 | /* convert uppercase ascii to equivalent control char, for readability */ |
1876 | #undef CTRL |
1877 | #define CTRL(a) ((a) & ~0x40) |
1878 | |
1879 | /* maxsize must be >= 2. |
1880 | * Returns: |
1881 | * -1 on read errors or EOF, or on bare Ctrl-D, |
1882 | * 0 on ctrl-C (the line entered is still returned in 'command'), |
1883 | * >0 length of input string, including terminating '\n' |
1884 | */ |
1885 | int FAST_FUNC read_line_input(const char *prompt, char *command, int maxsize, line_input_t *st) |
1886 | { |
1887 | int len; |
1888 | #if ENABLE_FEATURE_TAB_COMPLETION |
1889 | smallint lastWasTab = FALSE; |
1890 | #endif |
1891 | smallint break_out = 0; |
1892 | #if ENABLE_FEATURE_EDITING_VI |
1893 | smallint vi_cmdmode = 0; |
1894 | #endif |
1895 | struct termios initial_settings; |
1896 | struct termios new_settings; |
1897 | char read_key_buffer[KEYCODE_BUFFER_SIZE]; |
1898 | |
1899 | INIT_S(); |
1900 | |
1901 | if (tcgetattr(STDIN_FILENO, &initial_settings) < 0 |
1902 | || !(initial_settings.c_lflag & ECHO) |
1903 | ) { |
1904 | /* Happens when e.g. stty -echo was run before */ |
1905 | parse_and_put_prompt(prompt); |
1906 | /* fflush_all(); - done by parse_and_put_prompt */ |
1907 | if (fgets(command, maxsize, stdin) == NULL) |
1908 | len = -1; /* EOF or error */ |
1909 | else |
1910 | len = strlen(command); |
1911 | DEINIT_S(); |
1912 | return len; |
1913 | } |
1914 | |
1915 | init_unicode(); |
1916 | |
1917 | // FIXME: audit & improve this |
1918 | if (maxsize > MAX_LINELEN) |
1919 | maxsize = MAX_LINELEN; |
1920 | S.maxsize = maxsize; |
1921 | |
1922 | /* With null flags, no other fields are ever used */ |
1923 | state = st ? st : (line_input_t*) &const_int_0; |
1924 | #if MAX_HISTORY > 0 |
1925 | # if ENABLE_FEATURE_EDITING_SAVEHISTORY |
1926 | if ((state->flags & SAVE_HISTORY) && state->hist_file) |
1927 | if (state->cnt_history == 0) |
1928 | load_history(state); |
1929 | # endif |
1930 | if (state->flags & DO_HISTORY) |
1931 | state->cur_history = state->cnt_history; |
1932 | #endif |
1933 | |
1934 | /* prepare before init handlers */ |
1935 | cmdedit_y = 0; /* quasireal y, not true if line > xt*yt */ |
1936 | command_len = 0; |
1937 | #if ENABLE_UNICODE_SUPPORT |
1938 | command_ps = xzalloc(maxsize * sizeof(command_ps[0])); |
1939 | #else |
1940 | command_ps = command; |
1941 | command[0] = '\0'; |
1942 | #endif |
1943 | #define command command_must_not_be_used |
1944 | |
1945 | new_settings = initial_settings; |
1946 | new_settings.c_lflag &= ~ICANON; /* unbuffered input */ |
1947 | /* Turn off echoing and CTRL-C, so we can trap it */ |
1948 | new_settings.c_lflag &= ~(ECHO | ECHONL | ISIG); |
1949 | /* Hmm, in linux c_cc[] is not parsed if ICANON is off */ |
1950 | new_settings.c_cc[VMIN] = 1; |
1951 | new_settings.c_cc[VTIME] = 0; |
1952 | /* Turn off CTRL-C, so we can trap it */ |
1953 | #ifndef _POSIX_VDISABLE |
1954 | # define _POSIX_VDISABLE '\0' |
1955 | #endif |
1956 | new_settings.c_cc[VINTR] = _POSIX_VDISABLE; |
1957 | tcsetattr_stdin_TCSANOW(&new_settings); |
1958 | |
1959 | /* Now initialize things */ |
1960 | previous_SIGWINCH_handler = signal(SIGWINCH, win_changed); |
1961 | win_changed(0); /* do initial resizing */ |
1962 | #if ENABLE_FEATURE_GETUSERNAME_AND_HOMEDIR |
1963 | { |
1964 | struct passwd *entry; |
1965 | |
1966 | entry = getpwuid(geteuid()); |
1967 | if (entry) { |
1968 | user_buf = xstrdup(entry->pw_name); |
1969 | home_pwd_buf = xstrdup(entry->pw_dir); |
1970 | } |
1971 | } |
1972 | #endif |
1973 | |
1974 | #if 0 |
1975 | for (i = 0; i <= MAX_HISTORY; i++) |
1976 | bb_error_msg("history[%d]:'%s'", i, state->history[i]); |
1977 | bb_error_msg("cur_history:%d cnt_history:%d", state->cur_history, state->cnt_history); |
1978 | #endif |
1979 | |
1980 | /* Print out the command prompt, optionally ask where cursor is */ |
1981 | parse_and_put_prompt(prompt); |
1982 | ask_terminal(); |
1983 | |
1984 | read_key_buffer[0] = 0; |
1985 | while (1) { |
1986 | /* |
1987 | * The emacs and vi modes share much of the code in the big |
1988 | * command loop. Commands entered when in vi's command mode |
1989 | * (aka "escape mode") get an extra bit added to distinguish |
1990 | * them - this keeps them from being self-inserted. This |
1991 | * clutters the big switch a bit, but keeps all the code |
1992 | * in one place. |
1993 | */ |
1994 | enum { |
1995 | VI_CMDMODE_BIT = 0x40000000, |
1996 | /* 0x80000000 bit flags KEYCODE_xxx */ |
1997 | }; |
1998 | int32_t ic, ic_raw; |
1999 | |
2000 | fflush_all(); |
2001 | ic = ic_raw = lineedit_read_key(read_key_buffer); |
2002 | |
2003 | #if ENABLE_FEATURE_EDITING_VI |
2004 | newdelflag = 1; |
2005 | if (vi_cmdmode) { |
2006 | /* btw, since KEYCODE_xxx are all < 0, this doesn't |
2007 | * change ic if it contains one of them: */ |
2008 | ic |= VI_CMDMODE_BIT; |
2009 | } |
2010 | #endif |
2011 | |
2012 | switch (ic) { |
2013 | case '\n': |
2014 | case '\r': |
2015 | vi_case('\n'|VI_CMDMODE_BIT:) |
2016 | vi_case('\r'|VI_CMDMODE_BIT:) |
2017 | /* Enter */ |
2018 | goto_new_line(); |
2019 | break_out = 1; |
2020 | break; |
2021 | case CTRL('A'): |
2022 | vi_case('0'|VI_CMDMODE_BIT:) |
2023 | /* Control-a -- Beginning of line */ |
2024 | input_backward(cursor); |
2025 | break; |
2026 | case CTRL('B'): |
2027 | vi_case('h'|VI_CMDMODE_BIT:) |
2028 | vi_case('\b'|VI_CMDMODE_BIT:) /* ^H */ |
2029 | vi_case('\x7f'|VI_CMDMODE_BIT:) /* DEL */ |
2030 | input_backward(1); /* Move back one character */ |
2031 | break; |
2032 | case CTRL('E'): |
2033 | vi_case('$'|VI_CMDMODE_BIT:) |
2034 | /* Control-e -- End of line */ |
2035 | put_till_end_and_adv_cursor(); |
2036 | break; |
2037 | case CTRL('F'): |
2038 | vi_case('l'|VI_CMDMODE_BIT:) |
2039 | vi_case(' '|VI_CMDMODE_BIT:) |
2040 | input_forward(); /* Move forward one character */ |
2041 | break; |
2042 | case '\b': /* ^H */ |
2043 | case '\x7f': /* DEL */ |
2044 | if (!isrtl_str()) |
2045 | input_backspace(); |
2046 | else |
2047 | input_delete(0); |
2048 | break; |
2049 | case KEYCODE_DELETE: |
2050 | if (!isrtl_str()) |
2051 | input_delete(0); |
2052 | else |
2053 | input_backspace(); |
2054 | break; |
2055 | #if ENABLE_FEATURE_TAB_COMPLETION |
2056 | case '\t': |
2057 | input_tab(&lastWasTab); |
2058 | break; |
2059 | #endif |
2060 | case CTRL('K'): |
2061 | /* Control-k -- clear to end of line */ |
2062 | command_ps[cursor] = BB_NUL; |
2063 | command_len = cursor; |
2064 | printf(SEQ_CLEAR_TILL_END_OF_SCREEN); |
2065 | break; |
2066 | case CTRL('L'): |
2067 | vi_case(CTRL('L')|VI_CMDMODE_BIT:) |
2068 | /* Control-l -- clear screen */ |
2069 | printf("\033[H"); /* cursor to top,left */ |
2070 | redraw(0, command_len - cursor); |
2071 | break; |
2072 | #if MAX_HISTORY > 0 |
2073 | case CTRL('N'): |
2074 | vi_case(CTRL('N')|VI_CMDMODE_BIT:) |
2075 | vi_case('j'|VI_CMDMODE_BIT:) |
2076 | /* Control-n -- Get next command in history */ |
2077 | if (get_next_history()) |
2078 | goto rewrite_line; |
2079 | break; |
2080 | case CTRL('P'): |
2081 | vi_case(CTRL('P')|VI_CMDMODE_BIT:) |
2082 | vi_case('k'|VI_CMDMODE_BIT:) |
2083 | /* Control-p -- Get previous command from history */ |
2084 | if (get_previous_history()) |
2085 | goto rewrite_line; |
2086 | break; |
2087 | #endif |
2088 | case CTRL('U'): |
2089 | vi_case(CTRL('U')|VI_CMDMODE_BIT:) |
2090 | /* Control-U -- Clear line before cursor */ |
2091 | if (cursor) { |
2092 | command_len -= cursor; |
2093 | memmove(command_ps, command_ps + cursor, |
2094 | (command_len + 1) * sizeof(command_ps[0])); |
2095 | redraw(cmdedit_y, command_len); |
2096 | } |
2097 | break; |
2098 | case CTRL('W'): |
2099 | vi_case(CTRL('W')|VI_CMDMODE_BIT:) |
2100 | /* Control-W -- Remove the last word */ |
2101 | while (cursor > 0 && BB_isspace(command_ps[cursor-1])) |
2102 | input_backspace(); |
2103 | while (cursor > 0 && !BB_isspace(command_ps[cursor-1])) |
2104 | input_backspace(); |
2105 | break; |
2106 | |
2107 | #if ENABLE_FEATURE_EDITING_VI |
2108 | case 'i'|VI_CMDMODE_BIT: |
2109 | vi_cmdmode = 0; |
2110 | break; |
2111 | case 'I'|VI_CMDMODE_BIT: |
2112 | input_backward(cursor); |
2113 | vi_cmdmode = 0; |
2114 | break; |
2115 | case 'a'|VI_CMDMODE_BIT: |
2116 | input_forward(); |
2117 | vi_cmdmode = 0; |
2118 | break; |
2119 | case 'A'|VI_CMDMODE_BIT: |
2120 | put_till_end_and_adv_cursor(); |
2121 | vi_cmdmode = 0; |
2122 | break; |
2123 | case 'x'|VI_CMDMODE_BIT: |
2124 | input_delete(1); |
2125 | break; |
2126 | case 'X'|VI_CMDMODE_BIT: |
2127 | if (cursor > 0) { |
2128 | input_backward(1); |
2129 | input_delete(1); |
2130 | } |
2131 | break; |
2132 | case 'W'|VI_CMDMODE_BIT: |
2133 | vi_Word_motion(1); |
2134 | break; |
2135 | case 'w'|VI_CMDMODE_BIT: |
2136 | vi_word_motion(1); |
2137 | break; |
2138 | case 'E'|VI_CMDMODE_BIT: |
2139 | vi_End_motion(); |
2140 | break; |
2141 | case 'e'|VI_CMDMODE_BIT: |
2142 | vi_end_motion(); |
2143 | break; |
2144 | case 'B'|VI_CMDMODE_BIT: |
2145 | vi_Back_motion(); |
2146 | break; |
2147 | case 'b'|VI_CMDMODE_BIT: |
2148 | vi_back_motion(); |
2149 | break; |
2150 | case 'C'|VI_CMDMODE_BIT: |
2151 | vi_cmdmode = 0; |
2152 | /* fall through */ |
2153 | case 'D'|VI_CMDMODE_BIT: |
2154 | goto clear_to_eol; |
2155 | |
2156 | case 'c'|VI_CMDMODE_BIT: |
2157 | vi_cmdmode = 0; |
2158 | /* fall through */ |
2159 | case 'd'|VI_CMDMODE_BIT: { |
2160 | int nc, sc; |
2161 | |
2162 | ic = lineedit_read_key(read_key_buffer); |
2163 | if (errno) /* error */ |
2164 | goto prepare_to_die; |
2165 | if (ic == ic_raw) { /* "cc", "dd" */ |
2166 | input_backward(cursor); |
2167 | goto clear_to_eol; |
2168 | break; |
2169 | } |
2170 | |
2171 | sc = cursor; |
2172 | switch (ic) { |
2173 | case 'w': |
2174 | case 'W': |
2175 | case 'e': |
2176 | case 'E': |
2177 | switch (ic) { |
2178 | case 'w': /* "dw", "cw" */ |
2179 | vi_word_motion(vi_cmdmode); |
2180 | break; |
2181 | case 'W': /* 'dW', 'cW' */ |
2182 | vi_Word_motion(vi_cmdmode); |
2183 | break; |
2184 | case 'e': /* 'de', 'ce' */ |
2185 | vi_end_motion(); |
2186 | input_forward(); |
2187 | break; |
2188 | case 'E': /* 'dE', 'cE' */ |
2189 | vi_End_motion(); |
2190 | input_forward(); |
2191 | break; |
2192 | } |
2193 | nc = cursor; |
2194 | input_backward(cursor - sc); |
2195 | while (nc-- > cursor) |
2196 | input_delete(1); |
2197 | break; |
2198 | case 'b': /* "db", "cb" */ |
2199 | case 'B': /* implemented as B */ |
2200 | if (ic == 'b') |
2201 | vi_back_motion(); |
2202 | else |
2203 | vi_Back_motion(); |
2204 | while (sc-- > cursor) |
2205 | input_delete(1); |
2206 | break; |
2207 | case ' ': /* "d ", "c " */ |
2208 | input_delete(1); |
2209 | break; |
2210 | case '$': /* "d$", "c$" */ |
2211 | clear_to_eol: |
2212 | while (cursor < command_len) |
2213 | input_delete(1); |
2214 | break; |
2215 | } |
2216 | break; |
2217 | } |
2218 | case 'p'|VI_CMDMODE_BIT: |
2219 | input_forward(); |
2220 | /* fallthrough */ |
2221 | case 'P'|VI_CMDMODE_BIT: |
2222 | put(); |
2223 | break; |
2224 | case 'r'|VI_CMDMODE_BIT: |
2225 | //FIXME: unicode case? |
2226 | ic = lineedit_read_key(read_key_buffer); |
2227 | if (errno) /* error */ |
2228 | goto prepare_to_die; |
2229 | if (ic < ' ' || ic > 255) { |
2230 | beep(); |
2231 | } else { |
2232 | command_ps[cursor] = ic; |
2233 | bb_putchar(ic); |
2234 | bb_putchar('\b'); |
2235 | } |
2236 | break; |
2237 | case '\x1b': /* ESC */ |
2238 | if (state->flags & VI_MODE) { |
2239 | /* insert mode --> command mode */ |
2240 | vi_cmdmode = 1; |
2241 | input_backward(1); |
2242 | } |
2243 | break; |
2244 | #endif /* FEATURE_COMMAND_EDITING_VI */ |
2245 | |
2246 | #if MAX_HISTORY > 0 |
2247 | case KEYCODE_UP: |
2248 | if (get_previous_history()) |
2249 | goto rewrite_line; |
2250 | beep(); |
2251 | break; |
2252 | case KEYCODE_DOWN: |
2253 | if (!get_next_history()) |
2254 | break; |
2255 | rewrite_line: |
2256 | /* Rewrite the line with the selected history item */ |
2257 | /* change command */ |
2258 | command_len = load_string(state->history[state->cur_history] ? |
2259 | state->history[state->cur_history] : "", maxsize); |
2260 | /* redraw and go to eol (bol, in vi) */ |
2261 | redraw(cmdedit_y, (state->flags & VI_MODE) ? 9999 : 0); |
2262 | break; |
2263 | #endif |
2264 | case KEYCODE_RIGHT: |
2265 | input_forward(); |
2266 | break; |
2267 | case KEYCODE_LEFT: |
2268 | input_backward(1); |
2269 | break; |
2270 | case KEYCODE_CTRL_LEFT: |
2271 | ctrl_left(); |
2272 | break; |
2273 | case KEYCODE_CTRL_RIGHT: |
2274 | ctrl_right(); |
2275 | break; |
2276 | case KEYCODE_HOME: |
2277 | input_backward(cursor); |
2278 | break; |
2279 | case KEYCODE_END: |
2280 | put_till_end_and_adv_cursor(); |
2281 | break; |
2282 | |
2283 | default: |
2284 | if (initial_settings.c_cc[VINTR] != 0 |
2285 | && ic_raw == initial_settings.c_cc[VINTR] |
2286 | ) { |
2287 | /* Ctrl-C (usually) - stop gathering input */ |
2288 | goto_new_line(); |
2289 | command_len = 0; |
2290 | break_out = -1; /* "do not append '\n'" */ |
2291 | break; |
2292 | } |
2293 | if (initial_settings.c_cc[VEOF] != 0 |
2294 | && ic_raw == initial_settings.c_cc[VEOF] |
2295 | ) { |
2296 | /* Ctrl-D (usually) - delete one character, |
2297 | * or exit if len=0 and no chars to delete */ |
2298 | if (command_len == 0) { |
2299 | errno = 0; |
2300 | #if ENABLE_FEATURE_EDITING_VI |
2301 | prepare_to_die: |
2302 | #endif |
2303 | break_out = command_len = -1; |
2304 | break; |
2305 | } |
2306 | input_delete(0); |
2307 | break; |
2308 | } |
2309 | // /* Control-V -- force insert of next char */ |
2310 | // if (c == CTRL('V')) { |
2311 | // if (safe_read(STDIN_FILENO, &c, 1) < 1) |
2312 | // goto prepare_to_die; |
2313 | // if (c == 0) { |
2314 | // beep(); |
2315 | // break; |
2316 | // } |
2317 | // } |
2318 | if (ic < ' ' |
2319 | || (!ENABLE_UNICODE_SUPPORT && ic >= 256) |
2320 | || (ENABLE_UNICODE_SUPPORT && ic >= VI_CMDMODE_BIT) |
2321 | ) { |
2322 | /* If VI_CMDMODE_BIT is set, ic is >= 256 |
2323 | * and vi mode ignores unexpected chars. |
2324 | * Otherwise, we are here if ic is a |
2325 | * control char or an unhandled ESC sequence, |
2326 | * which is also ignored. |
2327 | */ |
2328 | break; |
2329 | } |
2330 | if ((int)command_len >= (maxsize - 2)) { |
2331 | /* Not enough space for the char and EOL */ |
2332 | break; |
2333 | } |
2334 | |
2335 | command_len++; |
2336 | if (cursor == (command_len - 1)) { |
2337 | /* We are at the end, append */ |
2338 | command_ps[cursor] = ic; |
2339 | command_ps[cursor + 1] = BB_NUL; |
2340 | put_cur_glyph_and_inc_cursor(); |
2341 | if (unicode_bidi_isrtl(ic)) |
2342 | input_backward(1); |
2343 | } else { |
2344 | /* In the middle, insert */ |
2345 | int sc = cursor; |
2346 | |
2347 | memmove(command_ps + sc + 1, command_ps + sc, |
2348 | (command_len - sc) * sizeof(command_ps[0])); |
2349 | command_ps[sc] = ic; |
2350 | /* is right-to-left char, or neutral one (e.g. comma) was just added to rtl text? */ |
2351 | if (!isrtl_str()) |
2352 | sc++; /* no */ |
2353 | put_till_end_and_adv_cursor(); |
2354 | /* to prev x pos + 1 */ |
2355 | input_backward(cursor - sc); |
2356 | } |
2357 | break; |
2358 | } /* switch (ic) */ |
2359 | |
2360 | if (break_out) |
2361 | break; |
2362 | |
2363 | #if ENABLE_FEATURE_TAB_COMPLETION |
2364 | if (ic_raw != '\t') |
2365 | lastWasTab = FALSE; |
2366 | #endif |
2367 | } /* while (1) */ |
2368 | |
2369 | #if ENABLE_FEATURE_EDITING_ASK_TERMINAL |
2370 | if (S.sent_ESC_br6n) { |
2371 | /* "sleep 1; busybox ash" + hold [Enter] to trigger. |
2372 | * We sent "ESC [ 6 n", but got '\n' first, and |
2373 | * KEYCODE_CURSOR_POS response is now buffered from terminal. |
2374 | * It's bad already and not much can be done with it |
2375 | * (it _will_ be visible for the next process to read stdin), |
2376 | * but without this delay it even shows up on the screen |
2377 | * as garbage because we restore echo settings with tcsetattr |
2378 | * before it comes in. UGLY! |
2379 | */ |
2380 | usleep(20*1000); |
2381 | } |
2382 | #endif |
2383 | |
2384 | /* Stop bug catching using "command_must_not_be_used" trick */ |
2385 | #undef command |
2386 | |
2387 | #if ENABLE_UNICODE_SUPPORT |
2388 | command[0] = '\0'; |
2389 | if (command_len > 0) |
2390 | command_len = save_string(command, maxsize - 1); |
2391 | free(command_ps); |
2392 | #endif |
2393 | |
2394 | if (command_len > 0) |
2395 | remember_in_history(command); |
2396 | |
2397 | if (break_out > 0) { |
2398 | command[command_len++] = '\n'; |
2399 | command[command_len] = '\0'; |
2400 | } |
2401 | |
2402 | #if ENABLE_FEATURE_TAB_COMPLETION |
2403 | free_tab_completion_data(); |
2404 | #endif |
2405 | |
2406 | /* restore initial_settings */ |
2407 | tcsetattr_stdin_TCSANOW(&initial_settings); |
2408 | /* restore SIGWINCH handler */ |
2409 | signal(SIGWINCH, previous_SIGWINCH_handler); |
2410 | fflush_all(); |
2411 | |
2412 | len = command_len; |
2413 | DEINIT_S(); |
2414 | |
2415 | return len; /* can't return command_len, DEINIT_S() destroys it */ |
2416 | } |
2417 | |
2418 | #else |
2419 | |
2420 | #undef read_line_input |
2421 | int FAST_FUNC read_line_input(const char* prompt, char* command, int maxsize) |
2422 | { |
2423 | fputs(prompt, stdout); |
2424 | fflush_all(); |
2425 | fgets(command, maxsize, stdin); |
2426 | return strlen(command); |
2427 | } |
2428 | |
2429 | #endif /* FEATURE_EDITING */ |
2430 | |
2431 | |
2432 | /* |
2433 | * Testing |
2434 | */ |
2435 | |
2436 | #ifdef TEST |
2437 | |
2438 | #include <locale.h> |
2439 | |
2440 | const char *applet_name = "debug stuff usage"; |
2441 | |
2442 | int main(int argc, char **argv) |
2443 | { |
2444 | char buff[MAX_LINELEN]; |
2445 | char *prompt = |
2446 | #if ENABLE_FEATURE_EDITING_FANCY_PROMPT |
2447 | "\\[\\033[32;1m\\]\\u@\\[\\x1b[33;1m\\]\\h:" |
2448 | "\\[\\033[34;1m\\]\\w\\[\\033[35;1m\\] " |
2449 | "\\!\\[\\e[36;1m\\]\\$ \\[\\E[0m\\]"; |
2450 | #else |
2451 | "% "; |
2452 | #endif |
2453 | |
2454 | while (1) { |
2455 | int l; |
2456 | l = read_line_input(prompt, buff); |
2457 | if (l <= 0 || buff[l-1] != '\n') |
2458 | break; |
2459 | buff[l-1] = 0; |
2460 | printf("*** read_line_input() returned line =%s=\n", buff); |
2461 | } |
2462 | printf("*** read_line_input() detect ^D\n"); |
2463 | return 0; |
2464 | } |
2465 | |
2466 | #endif /* TEST */ |