1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
4 * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
5 * Copyright (c) 2012 - 2014 Steffen "Daode" Nurpmeso <sdaoden@users.sf.net>.
8 * Copyright (c) 1980, 1993
9 * The Regents of the University of California. All rights reserved.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. All advertising materials mentioning features or use of this software
20 * must display the following acknowledgement:
21 * This product includes software developed by the University of
22 * California, Berkeley and its contributors.
23 * 4. Neither the name of the University nor the names of its contributors
24 * may be used to endorse or promote products derived from this software
25 * without specific prior written permission.
27 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
28 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
31 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
33 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
41 * Copyright (c) 2013 - 2014 Steffen "Daode" Nurpmeso <sdaoden@users.sf.net>.
43 * Permission to use, copy, modify, and/or distribute this software for any
44 * purpose with or without fee is hereby granted, provided that the above
45 * copyright notice and this permission notice appear in all copies.
47 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
48 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
49 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
50 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
51 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
52 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
53 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
56 #ifndef HAVE_AMALGAMATION
61 # include <readline/readline.h>
63 # include <readline/history.h>
65 #elif defined HAVE_EDITLINE
66 # include <histedit.h>
69 /* Shared history support macros */
71 # define _CL_HISTFILE(S) \
73 S = ok_vlook(NAIL_HISTFILE);\
75 S = fexpand(S, FEXP_LOCAL);\
78 # define _CL_HISTSIZE(V) \
80 char const *__sv = ok_vlook(NAIL_HISTSIZE);\
82 if (__sv == NULL || *__sv == '\0' || (__rv = strtol(__sv, NULL, 10)) == 0)\
90 # define _CL_CHECK_ADDHIST(S,NOACT) \
101 # define C_HISTORY_SHARED \
107 if (argv[1] != NULL)\
109 if (asccasecmp(*argv, "show") == 0)\
111 if (asccasecmp(*argv, "clear") == 0)\
113 if ((entry = strtol(*argv, argv, 10)) > 0 && **argv == '\0')\
116 fprintf(stderr, "Synopsis: history: %s\n", tr(431,\
117 "<show> (default), <clear> or select <NO> from editor history"));\
120 return (v == NULL ? !STOP : !OKAY); /* xxx 1:bad 0:good -- do some */
121 #endif /* HAVE_HISTORY */
123 /* fexpand() flags for expand-on-tab */
124 #define _CL_TAB_FEXP_FL (FEXP_FULL | FEXP_SILENT | FEXP_MULTIOK)
127 * Because we have multiple identical implementations, change file layout a bit
128 * and place the implementations one after the other below the other externals
132 yorn(char const *msg
)
136 if (!(options
& OPT_INTERACTIVE
))
138 do if ((cp
= readstr_input(msg
, NULL
)) == NULL
)
140 while (*cp
!= 'y' && *cp
!= 'Y' && *cp
!= 'n' && *cp
!= 'N');
141 return (*cp
== 'y' || *cp
== 'Y');
145 getuser(char const *query
)
150 query
= tr(509, "User: ");
152 if (readline_input(query
, FAL0
, &termios_state
.ts_linebuf
,
153 &termios_state
.ts_linesize
, NULL
) >= 0)
154 user
= termios_state
.ts_linebuf
;
155 termios_state_reset();
160 getpassword(char const *query
) /* FIXME encaps ttystate signal safe */
166 query
= tr(510, "Password: ");
167 fputs(query
, stdout
);
171 * FIXME everywhere: tcsetattr() generates SIGTTOU when we're not in
172 * foreground pgrp, and can fail with EINTR!!
174 if (options
& OPT_TTYIN
) {
175 tcgetattr(STDIN_FILENO
, &termios_state
.ts_tios
);
176 memcpy(&tios
, &termios_state
.ts_tios
, sizeof tios
);
177 termios_state
.ts_needs_reset
= TRU1
;
178 tios
.c_iflag
&= ~(ISTRIP
);
179 tios
.c_lflag
&= ~(ECHO
| ECHOE
| ECHOK
| ECHONL
);
180 tcsetattr(STDIN_FILENO
, TCSAFLUSH
, &tios
);
183 if (readline_restart(stdin
, &termios_state
.ts_linebuf
,
184 &termios_state
.ts_linesize
, 0) >= 0)
185 pass
= termios_state
.ts_linebuf
;
186 termios_state_reset();
188 if (options
& OPT_TTYIN
)
194 getcredentials(char **user
, char **pass
)
197 char *u
= *user
, *p
= *pass
;
200 if ((u
= getuser(NULL
)) == NULL
)
208 if ((p
= getpassword(NULL
)) == NULL
)
220 static sighandler_type _rl_shup
;
221 static char * _rl_buf
; /* pre_input() hook: initial line */
222 static int _rl_buflen
; /* content, and its length */
224 static int _rl_pre_input(void);
229 /* Handle leftover data from \ escaped former line */
230 rl_extend_line_buffer(_rl_buflen
+ 10);
231 memcpy(rl_line_buffer
, _rl_buf
, _rl_buflen
+ 1);
232 rl_point
= rl_end
= _rl_buflen
;
233 rl_pre_input_hook
= (rl_hook_func_t
*)NULL
;
246 rl_readline_name
= UNCONST(uagent
);
250 stifle_history((int)hs
);
252 rl_read_init_file(NULL
);
254 /* Because rl_read_init_file() may have introduced yet a different
255 * history size limit, simply load and incorporate the history, leave
256 * it up to readline(3) to do the rest */
288 /* readline(3) doesn't catch it :( */
289 rl_free_line_state();
290 rl_cleanup_after_signal();
291 safe_signal(SIGHUP
, _rl_shup
);
293 sigaddset(&nset
, sig
);
294 sigprocmask(SIG_UNBLOCK
, &nset
, &oset
);
296 /* XXX When we come here we'll continue editing, so reestablish
297 * XXX cannot happen */
298 sigprocmask(SIG_BLOCK
, &oset
, (sigset_t
*)NULL
);
299 _rl_shup
= safe_signal(SIGHUP
, &tty_signal
);
300 rl_reset_after_signal();
308 (tty_readline
)(char const *prompt
, char **linebuf
, size_t *linesize
, size_t n
317 rl_pre_input_hook
= &_rl_pre_input
;
320 _rl_shup
= safe_signal(SIGHUP
, &tty_signal
);
321 line
= readline(prompt
!= NULL
? prompt
: "");
322 safe_signal(SIGHUP
, _rl_shup
);
330 if (n
>= *linesize
) {
331 *linesize
= LINESIZE
+ n
+ 1;
332 *linebuf
= (srealloc
)(*linebuf
, *linesize SMALLOC_DEBUG_ARGSCALL
);
334 memcpy(*linebuf
, line
, n
);
336 (*linebuf
)[n
] = '\0';
343 tty_addhist(char const *s
)
346 _CL_CHECK_ADDHIST(s
, goto jleave
);
347 hold_all_sigs(); /* XXX too heavy */
348 add_history(s
); /* XXX yet we jump away! */
349 rele_all_sigs(); /* XXX remove jumps */
368 if ((fp
= Ftemp(&cp
, "Ra", "w+", 0600, 1)) == NULL
) {
376 hs
= history_get_history_state();
378 for (i
= (ul_it
)hs
->length
, hl
= hs
->entries
+ i
, b
= 0; i
> 0; --i
) {
379 size_t sl
= strlen(cp
= (*--hl
)->line
);
380 fprintf(fp
, "%4lu. %-50.50s (%4lu+%lu bytes)\n", i
, cp
, b
, sl
);
384 page_or_print(fp
, (size_t)hs
->length
);
394 HISTORY_STATE
*hs
= history_get_history_state();
396 if (UICMP(z
, entry
, <=, hs
->length
))
397 v
= temporary_arg_v_store
= hs
->entries
[entry
- 1]->line
;
403 # endif /* HAVE_HISTORY */
404 #endif /* HAVE_READLINE */
411 static EditLine
* _el_el
; /* editline(3) handle */
412 static char const * _el_prompt
; /* Current prompt */
414 static History
* _el_hcom
; /* History handle for commline */
417 static char const * _el_getprompt(void);
436 _el_hcom
= history_init();
437 history(_el_hcom
, &he
, H_SETSIZE
, (int)hs
);
438 /* We unroll our own one history(_el_hcom, &he, H_SETUNIQUE, 1);*/
441 _el_el
= el_init(uagent
, stdin
, stdout
, stderr
);
442 el_set(_el_el
, EL_SIGNAL
, 1);
443 el_set(_el_el
, EL_TERMINAL
, NULL
);
444 /* Need to set HIST before EDITOR, otherwise it won't work automatic */
446 el_set(_el_el
, EL_HIST
, &history
, _el_hcom
);
448 el_set(_el_el
, EL_EDITOR
, "emacs");
449 # ifdef EL_PROMPT_ESC
450 el_set(_el_el
, EL_PROMPT_ESC
, &_el_getprompt
, '\1');
452 el_set(_el_el
, EL_PROMPT
, &_el_getprompt
);
455 el_set(_el_el
, EL_ADDFN
, "tab_complete",
456 "editline(3) internal completion function", &_el_file_cpl
);
457 el_set(_el_el
, EL_BIND
, "^I", "tab_complete", NULL
);
460 el_set(_el_el
, EL_BIND
, "^R", "ed-search-prev-history", NULL
);
462 el_source(_el_el
, NULL
); /* Source ~/.editrc */
464 /* Because el_source() may have introduced yet a different history size
465 * limit, simply load and incorporate the history, leave it up to
466 * editline(3) to do the rest */
470 history(_el_hcom
, &he
, H_LOAD
, v
);
487 history(_el_hcom
, &he
, H_SAVE
, v
);
488 history_end(_el_hcom
);
507 (tty_readline
)(char const *prompt
, char **linebuf
, size_t *linesize
, size_t n
513 _el_prompt
= (prompt
!= NULL
) ? prompt
: "";
515 el_push(_el_el
, *linebuf
);
516 line
= el_gets(_el_el
, &nn
);
524 if (n
> 0 && line
[n
- 1] == '\n')
527 if (n
>= *linesize
) {
528 *linesize
= LINESIZE
+ n
+ 1;
529 *linebuf
= (srealloc
)(*linebuf
, *linesize SMALLOC_DEBUG_ARGSCALL
);
531 memcpy(*linebuf
, line
, n
);
532 (*linebuf
)[n
] = '\0';
538 tty_addhist(char const *s
)
541 /* Enlarge meaning of unique .. to something that rocks;
542 * xxx unfortunately this is expensive to do with editline(3)
543 * xxx maybe it would be better to hook the ptfs instead? */
547 _CL_CHECK_ADDHIST(s
, goto jleave
);
549 hold_all_sigs(); /* XXX too heavy, yet we jump away! */
550 for (i
= history(_el_hcom
, &he
, H_FIRST
); i
>= 0;
551 i
= history(_el_hcom
, &he
, H_NEXT
))
552 if (strcmp(he
.str
, s
) == 0) {
553 history(_el_hcom
, &he
, H_DEL
, he
.num
);
556 history(_el_hcom
, &he
, H_ENTER
, s
);
557 rele_all_sigs(); /* XXX remove jumps */
576 if ((fp
= Ftemp(&cp
, "Ra", "w+", 0600, 1)) == NULL
) {
584 i
= (size_t)((history(_el_hcom
, &he
, H_GETSIZE
) >= 0) ? he
.num
: 0);
586 for (x
= history(_el_hcom
, &he
, H_FIRST
); x
>= 0;
587 x
= history(_el_hcom
, &he
, H_NEXT
)) {
588 size_t sl
= strlen(he
.str
);
589 fprintf(fp
, "%4lu. %-50.50s (%4lu+%lu bytes)\n",
590 (ul_it
)i
, he
.str
, (ul_it
)b
, (ul_it
)sl
);
595 page_or_print(fp
, i
);
602 history(_el_hcom
, &he
, H_CLEAR
);
611 i
= (size_t)((history(_el_hcom
, &he
, H_GETSIZE
) >= 0) ? he
.num
: 0);
612 if (UICMP(z
, entry
, <=, i
)) {
613 entry
= (long)i
- entry
;
614 for (x
= history(_el_hcom
, &he
, H_FIRST
); x
>= 0;
615 x
= history(_el_hcom
, &he
, H_NEXT
))
617 v
= temporary_arg_v_store
= UNCONST(he
.str
);
625 # endif /* HAVE_HISTORY */
626 #endif /* HAVE_EDITLINE */
629 * NCL: our homebrew version (inspired from NetBSD sh(1) / dash(1)s hetio.c).
631 * Only used in interactive mode, simply use STDIN_FILENO as point of interest.
632 * We do not handle character widths because the terminal must deal with that
633 * anyway on the one hand, and also wcwidth(3) doesn't support zero-width
634 * characters by definition on the other. We're addicted.
636 * To avoid memory leaks etc. with the current codebase that simply longjmp(3)s
637 * we're forced to use the very same buffer--the one that is passed through to
638 * us from the outside--to store anything we need, i.e., a `struct cell[]', and
639 * convert that on-the-fly back to the plain char* result once we're done.
640 * To simplify our live, use savestr() buffers for all other needed memory
644 * TODO NCL: don't use that stupid .sint=-1 stuff, but simply block all signals
645 * TODO NCL: during handler de-/installation handling.
650 # define MAX_INPUT 255 /* (_POSIX_MAX_INPUT = 255 as of Issue 7 TC1) */
653 /* Since we simply fputs(3) the prompt, assume each character requires two
654 * visual cells -- and we need to restrict the maximum prompt size because
655 * of MAX_INPUT and our desire to have room for some error message left */
656 # define _PROMPT_VLEN(P) (strlen(P) * 2)
657 # define _PROMPT_MAX ((MAX_INPUT / 2) + (MAX_INPUT / 4))
660 sighandler_type shdl
; /* Try avoid races by setting */
661 sl_it sint
; /* .sint=-1 when inactive */
663 CTA(sizeof(sl_it
) >= sizeof(sighandler_type
));
673 char cbuf
[MB_LEN_MAX
* 2]; /* .. plus reset shift sequence */
677 size_t cursor
; /* Current cursor position */
678 size_t topins
; /* Outermost cursor col set */
680 char * cbuf
; /* *x_buf */
683 struct str defc
; /* Current default content */
684 struct str savec
; /* Saved default content */
686 struct hist
* hist
; /* History cursor */
689 char const * nd
; /* Cursor right */
690 char ** x_buf
; /* Caller pointers */
697 struct hist
* younger
;
699 char dat
[VFIELD_SIZE(sizeof(size_t))];
703 static union xsighdl _ncl_oint
;
704 static union xsighdl _ncl_oquit
;
705 static union xsighdl _ncl_oterm
;
706 static union xsighdl _ncl_ohup
;
707 static union xsighdl _ncl_otstp
;
708 static union xsighdl _ncl_ottin
;
709 static union xsighdl _ncl_ottou
;
710 static struct xtios _ncl_tios
;
712 static struct hist
* _ncl_hist
;
713 static struct hist
* _ncl_hist_tail
;
714 static size_t _ncl_hist_size
;
715 static size_t _ncl_hist_size_max
;
716 static bool_t _ncl_hist_load
;
719 static void _ncl_sigs_up(void);
720 static void _ncl_sigs_down(void);
722 static void _ncl_term_mode(bool_t raw
);
724 static void _ncl_check_grow(struct line
*l
, size_t no SMALLOC_DEBUG_ARGS
);
725 static void _ncl_bs_eof_dvup(struct cell
*cap
, size_t i
);
726 static ssize_t
_ncl_wboundary(struct line
*l
, ssize_t dir
);
727 static ssize_t
_ncl_cell2dat(struct line
*l
);
728 # if defined HAVE_HISTORY || defined HAVE_TABEXPAND
729 static void _ncl_cell2save(struct line
*l
);
732 static void _ncl_khome(struct line
*l
, bool_t dobell
);
733 static void _ncl_kend(struct line
*l
);
734 static void _ncl_kbs(struct line
*l
);
735 static void _ncl_kkill(struct line
*l
, bool_t dobell
);
736 static ssize_t
_ncl_keof(struct line
*l
);
737 static void _ncl_kleft(struct line
*l
);
738 static void _ncl_kright(struct line
*l
);
739 static void _ncl_krefresh(struct line
*l
);
740 static void _ncl_kbwddelw(struct line
*l
);
741 static void _ncl_kgow(struct line
*l
, ssize_t dir
);
742 static void _ncl_kother(struct line
*l
, wchar_t wc
);
744 static size_t __ncl_khist_shared(struct line
*l
, struct hist
*hp
);
745 static size_t _ncl_khist(struct line
*l
, bool_t backwd
);
746 static size_t _ncl_krhist(struct line
*l
);
748 # ifdef HAVE_TABEXPAND
749 static size_t _ncl_kht(struct line
*l
);
751 static ssize_t
_ncl_readline(char const *prompt
, char **buf
, size_t *bufsize
,
752 size_t len SMALLOC_DEBUG_ARGS
);
757 if (_ncl_oint
.sint
== -1)
758 _ncl_oint
.shdl
= safe_signal(SIGINT
, &tty_signal
);
759 if (_ncl_oquit
.sint
== -1)
760 _ncl_oquit
.shdl
= safe_signal(SIGQUIT
, &tty_signal
);
761 if (_ncl_oterm
.sint
== -1)
762 _ncl_oterm
.shdl
= safe_signal(SIGTERM
, &tty_signal
);
763 if (_ncl_ohup
.sint
== -1)
764 _ncl_ohup
.shdl
= safe_signal(SIGHUP
, &tty_signal
);
765 if (_ncl_otstp
.sint
== -1)
766 _ncl_otstp
.shdl
= safe_signal(SIGTSTP
, &tty_signal
);
767 if (_ncl_ottin
.sint
== -1)
768 _ncl_ottin
.shdl
= safe_signal(SIGTTIN
, &tty_signal
);
769 if (_ncl_ottou
.sint
== -1)
770 _ncl_ottou
.shdl
= safe_signal(SIGTTOU
, &tty_signal
);
776 /* aaah.. atomic cas would be nice (but isn't it all redundant?) */
779 if (_ncl_ottou
.sint
!= -1) {
780 st
= _ncl_ottou
.shdl
, _ncl_ottou
.sint
= -1;
781 safe_signal(SIGTTOU
, st
);
783 if (_ncl_ottin
.sint
!= -1) {
784 st
= _ncl_ottin
.shdl
, _ncl_ottin
.sint
= -1;
785 safe_signal(SIGTTIN
, st
);
787 if (_ncl_otstp
.sint
!= -1) {
788 st
= _ncl_otstp
.shdl
, _ncl_otstp
.sint
= -1;
789 safe_signal(SIGTSTP
, st
);
791 if (_ncl_ohup
.sint
!= -1) {
792 st
= _ncl_ohup
.shdl
, _ncl_ohup
.sint
= -1;
793 safe_signal(SIGHUP
, st
);
795 if (_ncl_oterm
.sint
!= -1) {
796 st
= _ncl_oterm
.shdl
, _ncl_oterm
.sint
= -1;
797 safe_signal(SIGTERM
, st
);
799 if (_ncl_oquit
.sint
!= -1) {
800 st
= _ncl_oquit
.shdl
, _ncl_oquit
.sint
= -1;
801 safe_signal(SIGQUIT
, st
);
803 if (_ncl_oint
.sint
!= -1) {
804 st
= _ncl_oint
.shdl
, _ncl_oint
.sint
= -1;
805 safe_signal(SIGINT
, st
);
810 _ncl_term_mode(bool_t raw
)
812 struct termios
*tiosp
= &_ncl_tios
.told
;
817 /* Always requery the attributes, in case we've been moved from background
818 * to foreground or however else in between sessions */
819 tcgetattr(STDIN_FILENO
, tiosp
);
820 memcpy(&_ncl_tios
.tnew
, tiosp
, sizeof *tiosp
);
821 tiosp
= &_ncl_tios
.tnew
;
822 tiosp
->c_cc
[VMIN
] = 1;
823 tiosp
->c_cc
[VTIME
] = 0;
824 tiosp
->c_iflag
&= ~(ISTRIP
);
825 tiosp
->c_lflag
&= ~(ECHO
/*| ECHOE | ECHONL */| ICANON
| IEXTEN
);
827 tcsetattr(STDIN_FILENO
, TCSADRAIN
, tiosp
);
831 _ncl_check_grow(struct line
*l
, size_t no SMALLOC_DEBUG_ARGS
)
833 size_t i
= (l
->topins
+ no
) * sizeof(struct cell
) + 2 * sizeof(struct cell
);
835 if (i
> *l
->x_bufsize
) {
839 *l
->x_buf
= (srealloc
)(*l
->x_buf
, i SMALLOC_DEBUG_ARGSCALL
);
844 _ncl_bs_eof_dvup(struct cell
*cap
, size_t i
)
849 memmove(cap
, cap
+ 1, i
* sizeof(*cap
));
851 /* And.. the (rest of the) visual update */
852 for (j
= 0; j
< i
; ++j
)
853 fwrite(cap
[j
].cbuf
, sizeof *cap
->cbuf
, cap
[j
].count
, stdout
);
854 fputs(" \b", stdout
);
855 for (j
= 0; j
< i
; ++j
)
860 _ncl_wboundary(struct line
*l
, ssize_t dir
)
862 size_t c
= l
->cursor
, t
= l
->topins
, i
;
873 --t
, --c
; /* Unsigned wrapping may occur (twice), then */
875 for (i
= 0, cap
= l
->line
.cells
, anynon
= FAL0
;;) {
876 wchar_t wc
= cap
[c
+ dir
].wc
;
877 if (iswblank(wc
) || iswpunct(wc
)) {
895 _ncl_cell2dat(struct line
*l
)
900 for (i
= 0; i
< l
->topins
; ++i
) {
901 struct cell
*cap
= l
->line
.cells
+ i
;
902 memcpy(l
->line
.cbuf
+ len
, cap
->cbuf
, cap
->count
);
905 l
->line
.cbuf
[len
] = '\0';
909 # if defined HAVE_HISTORY || defined HAVE_TABEXPAND
911 _ncl_cell2save(struct line
*l
)
916 l
->savec
.s
= NULL
, l
->savec
.l
= 0;
920 for (cap
= l
->line
.cells
, len
= i
= 0; i
< l
->topins
; ++cap
, ++i
)
924 l
->savec
.s
= salloc(len
+ 1);
926 for (cap
= l
->line
.cells
, len
= i
= 0; i
< l
->topins
; ++cap
, ++i
) {
927 memcpy(l
->savec
.s
+ len
, cap
->cbuf
, cap
->count
);
930 l
->savec
.s
[len
] = '\0';
937 _ncl_khome(struct line
*l
, bool_t dobell
)
939 size_t c
= l
->cursor
;
950 _ncl_kend(struct line
*l
)
952 ssize_t i
= (ssize_t
)(l
->topins
- l
->cursor
);
955 l
->cursor
= l
->topins
;
957 fputs(l
->nd
, stdout
);
963 _ncl_kbs(struct line
*l
)
965 ssize_t c
= l
->cursor
, t
= l
->topins
;
972 _ncl_bs_eof_dvup(l
->line
.cells
+ c
, t
);
978 _ncl_kkill(struct line
*l
, bool_t dobell
)
980 size_t j
, c
= l
->cursor
, i
= (size_t)(l
->topins
- c
);
984 for (j
= i
; j
!= 0; --j
)
986 for (j
= i
; j
!= 0; --j
)
993 _ncl_keof(struct line
*l
)
995 size_t c
= l
->cursor
, t
= l
->topins
;
996 ssize_t i
= (ssize_t
)(t
- c
);
1000 _ncl_bs_eof_dvup(l
->line
.cells
+ c
, --i
);
1001 } else if (t
== 0 && !ok_blook(ignoreeof
)) {
1002 fputs("^D", stdout
);
1013 _ncl_kleft(struct line
*l
)
1015 if (l
->cursor
> 0) {
1023 _ncl_kright(struct line
*l
)
1025 if (l
->cursor
< l
->topins
) {
1027 fputs(l
->nd
, stdout
);
1033 _ncl_krefresh(struct line
*l
)
1039 if (l
->prompt
!= NULL
&& *l
->prompt
!= '\0')
1040 fputs(l
->prompt
, stdout
);
1041 for (cap
= l
->line
.cells
, i
= l
->topins
; i
> 0; ++cap
, --i
)
1042 fwrite(cap
->cbuf
, sizeof *cap
->cbuf
, cap
->count
, stdout
);
1043 for (i
= l
->topins
- l
->cursor
; i
> 0; --i
)
1048 _ncl_kbwddelw(struct line
*l
)
1051 size_t c
= l
->cursor
, t
, j
;
1054 i
= _ncl_wboundary(l
, -1);
1065 cap
= l
->line
.cells
+ c
;
1067 if (t
!= l
->cursor
) {
1069 memmove(cap
, cap
+ i
, j
* sizeof(*cap
));
1072 for (j
= i
; j
> 0; --j
)
1074 for (j
= l
->topins
- c
; j
> 0; ++cap
, --j
)
1075 fwrite(cap
[0].cbuf
, sizeof *cap
->cbuf
, cap
[0].count
, stdout
);
1076 for (j
= i
; j
> 0; --j
)
1078 for (j
= t
- c
; j
> 0; --j
)
1085 _ncl_kgow(struct line
*l
, ssize_t dir
)
1087 ssize_t i
= _ncl_wboundary(l
, dir
);
1101 fputs(l
->nd
, stdout
);
1108 _ncl_kother(struct line
*l
, wchar_t wc
)
1110 /* Append if at EOL, insert otherwise;
1111 * since we may move around character-wise, always use a fresh ps */
1113 struct cell cell
, *cap
;
1116 /* First init a cell and see wether we'll really handle this wc */
1118 memset(&ps
, 0, sizeof ps
);
1119 i
= wcrtomb(cell
.cbuf
, wc
, &ps
);
1122 cell
.count
= (ui_it
)i
;
1123 if (enc_has_state
) {
1124 i
= wcrtomb(cell
.cbuf
+ i
, L
'\0', &ps
);
1127 else if (--i
< MB_LEN_MAX
)
1128 cell
.count
+= (ui_it
)i
;
1133 /* Yes, we will! Place it in the array */
1135 i
= l
->topins
++ - c
;
1136 cap
= l
->line
.cells
+ c
;
1138 memmove(cap
+ 1, cap
, i
* sizeof(cell
));
1139 memcpy(cap
, &cell
, sizeof cell
);
1141 /* And update visual */
1144 fwrite(cap
->cbuf
, sizeof *cap
->cbuf
, cap
->count
, stdout
);
1145 while ((++cap
, i
-- != 0));
1152 # ifdef HAVE_HISTORY
1154 __ncl_khist_shared(struct line
*l
, struct hist
*hp
)
1158 if ((l
->hist
= hp
) != NULL
) {
1159 l
->defc
.s
= savestrbuf(hp
->dat
, hp
->len
);
1161 l
->defc
.l
= hp
->len
;
1162 if (l
->topins
> 0) {
1163 _ncl_khome(l
, FAL0
);
1164 _ncl_kkill(l
, FAL0
);
1174 _ncl_khist(struct line
*l
, bool_t backwd
)
1178 /* If we're not in history mode yet, save line content;
1179 * also, disallow forward search, then, and, of course, bail unless we
1180 * do have any history at all */
1181 if ((hp
= l
->hist
) == NULL
) {
1184 if ((hp
= _ncl_hist
) == NULL
)
1190 hp
= backwd
? hp
->older
: hp
->younger
;
1192 return __ncl_khist_shared(l
, hp
);
1196 _ncl_krhist(struct line
*l
)
1198 struct str orig_savec
;
1199 struct hist
*hp
= NULL
;
1201 /* We cannot complete an empty line */
1202 if (l
->topins
== 0) {
1203 /* XXX The upcoming hard reset would restore a set savec buffer,
1204 * XXX so forcefully reset that. A cleaner solution would be to
1205 * XXX reset it whenever a restore is no longer desired */
1206 l
->savec
.s
= NULL
, l
->savec
.l
= 0;
1209 if ((hp
= l
->hist
) == NULL
) {
1210 if ((hp
= _ncl_hist
) == NULL
)
1212 orig_savec
.s
= NULL
;
1213 orig_savec
.l
= 0; /* silence CC */
1214 } else if ((hp
= hp
->older
) == NULL
)
1217 orig_savec
= l
->savec
;
1219 if (orig_savec
.s
== NULL
)
1221 for (; hp
!= NULL
; hp
= hp
->older
)
1222 if (is_prefix(l
->savec
.s
, hp
->dat
))
1224 if (orig_savec
.s
!= NULL
)
1225 l
->savec
= orig_savec
;
1227 return __ncl_khist_shared(l
, hp
);
1231 # ifdef HAVE_TABEXPAND
1233 _ncl_kht(struct line
*l
)
1235 struct str orig
, bot
, topp
, sub
, exp
;
1236 struct cell
*cword
, *ctop
, *cx
;
1237 bool_t set_savec
= FAL0
;
1240 /* We cannot expand an empty line */
1244 /* Get plain line data; if this is the first expansion/xy, update the
1245 * very original content so that ^G gets the origin back */
1255 cword
= l
->line
.cells
;
1256 ctop
= cword
+ l
->cursor
;
1258 /* topp: separate data right of cursor */
1259 if ((cx
= cword
+ l
->topins
) != ctop
) {
1260 for (rv
= 0; cx
> ctop
; --cx
)
1263 topp
.s
= orig
.s
+ orig
.l
- rv
;
1265 topp
.s
= NULL
, topp
.l
= 0;
1267 /* bot, sub: we cannot expand the entire data left of cursor, but only
1268 * the last "word", so separate them */
1269 while (cx
> cword
&& !iswspace(cx
[-1].wc
))
1271 for (rv
= 0; cword
< cx
; ++cword
)
1281 sub
.s
= savestrbuf(sub
.s
, sub
.l
);
1282 /* TODO there is a TODO note upon fexpand() with multi-return;
1283 * TODO if that will change, the if() below can be simplified */
1284 /* Super-Heavy-Metal: block all sigs, avoid leaks on jump */
1286 exp
.s
= fexpand(sub
.s
, _CL_TAB_FEXP_FL
);
1289 if (exp
.s
!= NULL
&& (exp
.l
= strlen(exp
.s
)) > 0 &&
1290 (exp
.l
!= sub
.l
|| strcmp(exp
.s
, sub
.s
))) {
1291 /* Cramp expansion length to MAX_INPUT, or 255 if not defined.
1292 * Take care to take *prompt* into account, since we don't know
1293 * anything about it's visual length (fputs(3) is used), simply
1294 * assume each character requires two columns */
1295 /* TODO the problem is that we loose control otherwise; in the best
1296 * TODO case the user can control via ^A and ^K etc., but be safe;
1297 * TODO we cannot simply adjust fexpand() because we don't know how
1298 * TODO that is implemented... The real solution would be to check
1299 * TODO wether we fit on a line, and start a pager if not.
1300 * TODO However, that should be part of a real tab-COMPLETION, then,
1301 * TODO i.e., don't EXPAND, but SHOW COMPLETIONS, page-wise if needed.
1302 * TODO And: MAX_INPUT is dynamic: pathconf(2), _SC_MAX_INPUT */
1303 rv
= (l
->prompt
!= NULL
) ? _PROMPT_VLEN(l
->prompt
) : 0;
1304 if (rv
+ bot
.l
+ exp
.l
+ topp
.l
>= MAX_INPUT
) {
1305 char const e1
[] = "[maximum line size exceeded]";
1306 exp
.s
= UNCONST(e1
);
1307 exp
.l
= sizeof(e1
) - 1;
1309 if (rv
+ bot
.l
+ exp
.l
>= MAX_INPUT
)
1311 if (rv
+ exp
.l
>= MAX_INPUT
) {
1312 char const e2
[] = "[ERR]";
1313 exp
.s
= UNCONST(e2
);
1314 exp
.l
= sizeof(e2
) - 1;
1317 orig
.l
= bot
.l
+ exp
.l
+ topp
.l
;
1318 orig
.s
= salloc(orig
.l
+ 1 + 5);
1319 if ((rv
= bot
.l
) > 0)
1320 memcpy(orig
.s
, bot
.s
, rv
);
1321 memcpy(orig
.s
+ rv
, exp
.s
, exp
.l
);
1324 memcpy(orig
.s
+ rv
, topp
.s
, topp
.l
);
1330 _ncl_khome(l
, FAL0
);
1331 _ncl_kkill(l
, FAL0
);
1336 /* If we've provided a default content, but failed to expand, there is
1337 * nothing we can "revert to": drop that default again */
1339 l
->savec
.s
= NULL
, l
->savec
.l
= 0;
1344 # endif /* HAVE_TABEXPAND */
1347 _ncl_readline(char const *prompt
, char **buf
, size_t *bufsize
, size_t len
1350 /* We want to save code, yet we may have to incorporate a lines'
1351 * default content and / or default input to switch back to after some
1352 * history movement; let "len > 0" mean "have to display some data
1353 * buffer", and only otherwise read(2) it */
1356 char cbuf_base
[MB_LEN_MAX
* 2], *cbuf
, *cbufp
;
1359 ui32_t maybe_cursor
;
1361 memset(&l
, 0, sizeof l
);
1364 l
.defc
.s
= savestrbuf(*buf
, len
);
1367 if ((l
.prompt
= prompt
) != NULL
&& _PROMPT_VLEN(prompt
) > _PROMPT_MAX
)
1368 l
.prompt
= prompt
= "?ERR?";
1369 /* TODO *l.nd=='\0' only because we have no value-cache -> see acmava.c */
1370 if ((l
.nd
= ok_vlook(line_editor_cursor_right
)) == NULL
|| *l
.nd
== '\0')
1371 l
.nd
= "\033[C"; /* XXX no "magic" constant */
1373 l
.x_bufsize
= bufsize
;
1375 if (prompt
!= NULL
&& *prompt
!= '\0') {
1376 fputs(prompt
, stdout
);
1380 memset(ps
, 0, sizeof ps
);
1382 /* TODO: NCL: we should output the reset sequence when we jrestart:
1383 * TODO: NCL: if we are using a stateful encoding? !
1384 * TODO: NCL: in short: this is not yet well understood */
1386 _ncl_check_grow(&l
, len SMALLOC_DEBUG_ARGSCALL
);
1388 /* Normal read(2)? Else buffer-takeover: speed this one up */
1393 assert(l
.defc
.l
> 0 && l
.defc
.s
!= NULL
);
1395 cbuf
= l
.defc
.s
+ (l
.defc
.l
- len
);
1399 /* Read in the next complete multibyte character */
1402 if ((rv
= read(STDIN_FILENO
, cbufp
, 1)) < 1) {
1403 if (errno
== EINTR
) /* xxx #if !SA_RESTART ? */
1410 /* Ach! the ISO C multibyte handling!
1411 * Encodings with locking shift states cannot really be helped, since
1412 * it is impossible to only query the shift state, as opposed to the
1413 * entire shift state + character pair (via ISO C functions) */
1414 rv
= (ssize_t
)mbrtowc(&wc
, cbuf
, (size_t)(cbufp
- cbuf
), ps
+ 0);
1416 /* Any error during take-over can only result in a hard reset;
1417 * Otherwise, if it's a hard error, or if too many redundant shift
1418 * sequences overflow our buffer, also perform a hard reset */
1419 if (len
!= 0 || rv
== -1 ||
1420 sizeof cbuf_base
== (size_t)(cbufp
- cbuf
)) {
1421 l
.savec
.s
= l
.defc
.s
= NULL
,
1422 l
.savec
.l
= l
.defc
.l
= len
= 0;
1427 /* Otherwise, due to the way we deal with the buffer, we need to
1428 * restore the mbstate_t from before this conversion */
1433 if (len
!= 0 && (len
-= (size_t)rv
) == 0)
1434 l
.defc
.s
= NULL
, l
.defc
.l
= 0;
1439 /* Don't interpret control bytes during buffer take-over */
1440 if (cbuf
!= cbuf_base
)
1443 case 'A' ^ 0x40: /* cursor home */
1444 _ncl_khome(&l
, TRU1
);
1447 case 'B' ^ 0x40: /* backward character */
1450 /* 'C': interrupt (CTRL-C) */
1451 case 'D' ^ 0x40: /* delete char forward if any, else EOF */
1452 if ((rv
= _ncl_keof(&l
)) < 0)
1455 case 'E' ^ 0x40: /* end of line */
1459 case 'F' ^ 0x40: /* forward character */
1463 case 'H' ^ 0x40: /* backspace */
1467 case 'I' ^ 0x40: /* horizontal tab */
1468 # ifdef HAVE_TABEXPAND
1469 if ((len
= _ncl_kht(&l
)) > 0)
1473 case 'J' ^ 0x40: /* NL (\n) */
1475 case 'G' ^ 0x40: /* full reset */
1478 case 'U' ^ 0x40: /* ^U: ^A + ^K */
1479 _ncl_khome(&l
, FAL0
);
1481 case 'K' ^ 0x40: /* kill from cursor to end of line */
1482 _ncl_kkill(&l
, (wc
== ('K' ^ 0x40) || l
.topins
== 0));
1483 /* (Handle full reset?) */
1484 if (wc
== ('G' ^ 0x40)) {
1485 # ifdef HAVE_HISTORY
1488 if ((len
= l
.savec
.l
) != 0) {
1490 l
.savec
.s
= NULL
, l
.savec
.l
= 0;
1496 case 'L' ^ 0x40: /* repaint line */
1501 case 'N' ^ 0x40: /* history next */
1502 # ifdef HAVE_HISTORY
1505 if ((len
= _ncl_khist(&l
, FAL0
)) > 0)
1514 case 'P' ^ 0x40: /* history previous */
1515 # ifdef HAVE_HISTORY
1516 if ((len
= _ncl_khist(&l
, TRU1
)) > 0)
1524 case 'R' ^ 0x40: /* reverse history search */
1525 # ifdef HAVE_HISTORY
1526 if ((len
= _ncl_krhist(&l
)) > 0)
1535 /*case 'V' ^ 0x40: TODO*/ /* forward delete "word" */
1536 case 'W' ^ 0x40: /* backward delete "word" */
1539 case 'X' ^ 0x40: /* move cursor forward "word" */
1542 case 'Y' ^ 0x40: /* move cursor backward "word" */
1545 /* 'Z': suspend (CTRL-Z) */
1547 if (maybe_cursor
++ != 0)
1551 /* XXX Handle usual ^[[[ABCD] cursor keys -- UGLY, "MAGIC", INFLEX */
1552 if (maybe_cursor
> 0) {
1553 if (++maybe_cursor
== 2) {
1560 case L
'A': goto j_p
;
1561 case L
'B': goto j_n
;
1562 case L
'C': goto j_f
;
1563 case L
'D': goto j_b
;
1565 _ncl_kother(&l
, L
'[');
1570 _ncl_kother(&l
, wc
);
1571 /* Don't clear the history during takeover..
1572 * ..and also avoid fflush()ing unless we've
1573 * worked the entire buffer */
1576 # ifdef HAVE_HISTORY
1577 if (cbuf
== cbuf_base
)
1589 /* We have a completed input line, convert the struct cell data to its
1590 * plain character equivalent */
1594 len
= _ncl_cell2dat(&l
);
1603 # ifdef HAVE_HISTORY
1607 size_t lsize
, cnt
, llen
;
1610 _ncl_oint
.sint
= _ncl_oquit
.sint
= _ncl_oterm
.sint
=
1611 _ncl_ohup
.sint
= _ncl_otstp
.sint
= _ncl_ottin
.sint
=
1612 _ncl_ottou
.sint
= -1;
1614 # ifdef HAVE_HISTORY
1617 _ncl_hist_size_max
= hs
;
1625 hold_all_sigs(); /* XXX too heavy, yet we may jump even here!? */
1626 f
= fopen(v
, "r"); /* TODO HISTFILE LOAD: use linebuf pool */
1633 while (fgetline(&lbuf
, &lsize
, &cnt
, &llen
, f
, FAL0
) != NULL
) {
1634 if (llen
> 0 && lbuf
[llen
- 1] == '\n')
1635 lbuf
[--llen
] = '\0';
1636 if (llen
== 0 || lbuf
[0] == '#') /* xxx comments? noone! */
1638 _ncl_hist_load
= TRU1
;
1640 _ncl_hist_load
= FAL0
;
1647 rele_all_sigs(); /* XXX remove jumps */
1649 # endif /* HAVE_HISTORY */
1656 # ifdef HAVE_HISTORY
1670 if ((hp
= _ncl_hist
) != NULL
)
1671 while (hp
->older
!= NULL
&& hs
-- != 0)
1674 hold_all_sigs(); /* TODO too heavy, yet we may jump even here!? */
1675 f
= fopen(v
, "w"); /* TODO temporary + rename?! */
1678 if (fchmod(fileno(f
), S_IRUSR
| S_IWUSR
) != 0)
1681 for (; hp
!= NULL
; hp
= hp
->younger
) {
1682 fwrite(hp
->dat
, sizeof *hp
->dat
, hp
->len
, f
);
1688 rele_all_sigs(); /* XXX remove jumps */
1690 # endif /* HAVE_HISTORY */
1697 sigset_t nset
, oset
;
1701 /* We don't deal with SIGWINCH, yet get called from main.c */
1704 _ncl_term_mode(FAL0
);
1707 sigaddset(&nset
, sig
);
1708 sigprocmask(SIG_UNBLOCK
, &nset
, &oset
);
1710 /* When we come here we'll continue editing, so reestablish */
1711 sigprocmask(SIG_BLOCK
, &oset
, (sigset_t
*)NULL
);
1713 _ncl_term_mode(TRU1
);
1719 (tty_readline
)(char const *prompt
, char **linebuf
, size_t *linesize
, size_t n
1724 /* Of course we have races here, but they cannot be avoided on POSIX
1725 * (except by even *more* actions) */
1727 _ncl_term_mode(TRU1
);
1728 nn
= _ncl_readline(prompt
, linebuf
, linesize
, n SMALLOC_DEBUG_ARGSCALL
);
1729 _ncl_term_mode(FAL0
);
1736 tty_addhist(char const *s
)
1738 # ifdef HAVE_HISTORY
1739 /* Super-Heavy-Metal: block all sigs, avoid leaks+ on jump */
1740 size_t l
= strlen(s
);
1741 struct hist
*h
, *o
, *y
;
1743 if (_ncl_hist_size_max
== 0)
1745 _CL_CHECK_ADDHIST(s
, goto j_leave
);
1747 /* Eliminating duplicates is expensive, but simply inacceptable so
1748 * during the load of a potentially large history file! */
1749 if (!_ncl_hist_load
)
1750 for (h
= _ncl_hist
; h
!= NULL
; h
= h
->older
)
1751 if (h
->len
== l
&& !strcmp(h
->dat
, s
)) {
1752 hold_all_sigs(); /* TODO */
1768 if (!_ncl_hist_load
&& _ncl_hist_size
> _ncl_hist_size_max
) {
1770 if ((h
= _ncl_hist_tail
) != NULL
) {
1771 if ((_ncl_hist_tail
= h
->younger
) == NULL
)
1774 _ncl_hist_tail
->older
= NULL
;
1779 h
= smalloc((sizeof(struct hist
) - VFIELD_SIZEOF(struct hist
, dat
)) + l
+1);
1781 memcpy(h
->dat
, s
, l
+1);
1783 if ((h
->older
= _ncl_hist
) != NULL
)
1784 _ncl_hist
->younger
= h
;
1796 # ifdef HAVE_HISTORY
1808 if (_ncl_hist
== NULL
)
1811 if ((fp
= Ftemp(&cp
, "Ra", "w+", 0600, 1)) == NULL
) {
1821 for (h
= _ncl_hist
; h
!= NULL
; --i
, b
+= h
->len
, h
= h
->older
)
1822 fprintf(fp
, "%4lu. %-50.50s (%4lu+%lu bytes)\n",
1823 (ul_it
)i
, h
->dat
, (ul_it
)b
, (ul_it
)h
->len
);
1825 page_or_print(fp
, i
);
1832 while ((h
= _ncl_hist
) != NULL
) {
1833 _ncl_hist
= h
->older
;
1836 _ncl_hist_tail
= NULL
;
1842 struct hist
*h
= _ncl_hist
;
1843 if (UICMP(z
, entry
, <=, _ncl_hist_size
)) {
1844 entry
= (long)_ncl_hist_size
- entry
;
1845 for (h
= _ncl_hist
;; h
= h
->older
)
1848 else if (entry
-- != 0)
1851 v
= temporary_arg_v_store
= h
->dat
;
1859 # endif /* HAVE_HISTORY */
1860 #endif /* HAVE_NCL */
1863 * The really-nothing-at-all implementation
1866 #if !defined HAVE_READLINE && !defined HAVE_EDITLINE && !defined HAVE_NCL
1882 (tty_readline
)(char const *prompt
, char **linebuf
, size_t *linesize
, size_t n
1886 * TODO The nothing-at-all tty layer even forces re-entering all the
1887 * TODO original data when re-editing a field
1889 bool_t doffl
= FAL0
;
1891 if (prompt
!= NULL
&& *prompt
!= '\0') {
1892 fputs(prompt
, stdout
);
1896 fprintf(stdout
, tr(511, "{former content: %.*s} "), (int)n
, *linebuf
);
1902 return (readline_restart
)(stdin
, linebuf
, linesize
,n SMALLOC_DEBUG_ARGSCALL
);
1906 tty_addhist(char const *s
)
1910 #endif /* nothing at all */
1912 /* vim:set fenc=utf-8:s-it-mode */