1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
2 *@ TTY (command line) editing interaction.
3 *@ Because we have (had) multiple line-editor implementations, including our
4 *@ own M(ailx) L(ine) E(ditor), change the file layout a bit and place those
5 *@ one after the other below the other externals.
7 * Copyright (c) 2012 - 2017 Steffen (Daode) Nurpmeso <steffen@sdaoden.eu>.
9 * Permission to use, copy, modify, and/or distribute this software for any
10 * purpose with or without fee is hereby granted, provided that the above
11 * copyright notice and this permission notice appear in all copies.
13 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
14 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
15 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
16 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
17 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
19 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
24 #ifndef HAVE_AMALGAMATION
28 #if defined HAVE_MLE || defined HAVE_TERMCAP
29 # define a_TTY_SIGNALS
33 static sighandler_type a_tty_oint
, a_tty_oquit
, a_tty_oterm
,
35 a_tty_otstp
, a_tty_ottin
, a_tty_ottou
;
39 static void a_tty_sigs_up(void), a_tty_sigs_down(void);
50 sigprocmask(SIG_BLOCK
, &nset
, &oset
);
51 a_tty_oint
= safe_signal(SIGINT
, &n_tty_signal
);
52 a_tty_oquit
= safe_signal(SIGQUIT
, &n_tty_signal
);
53 a_tty_oterm
= safe_signal(SIGTERM
, &n_tty_signal
);
54 a_tty_ohup
= safe_signal(SIGHUP
, &n_tty_signal
);
55 a_tty_otstp
= safe_signal(SIGTSTP
, &n_tty_signal
);
56 a_tty_ottin
= safe_signal(SIGTTIN
, &n_tty_signal
);
57 a_tty_ottou
= safe_signal(SIGTTOU
, &n_tty_signal
);
58 sigprocmask(SIG_SETMASK
, &oset
, NULL
);
63 a_tty_sigs_down(void){
69 sigprocmask(SIG_BLOCK
, &nset
, &oset
);
70 safe_signal(SIGINT
, a_tty_oint
);
71 safe_signal(SIGQUIT
, a_tty_oquit
);
72 safe_signal(SIGTERM
, a_tty_oterm
);
73 safe_signal(SIGHUP
, a_tty_ohup
);
74 safe_signal(SIGTSTP
, a_tty_otstp
);
75 safe_signal(SIGTTIN
, a_tty_ottin
);
76 safe_signal(SIGTTOU
, a_tty_ottou
);
77 sigprocmask(SIG_SETMASK
, &oset
, NULL
);
80 #endif /* a_TTY_SIGNALS */
82 static sigjmp_buf a_tty__actjmp
; /* TODO someday, we won't need it no more */
84 a_tty__acthdl(int s
) /* TODO someday, we won't need it no more */
86 NYD_X
; /* Signal handler */
87 termios_state_reset();
88 siglongjmp(a_tty__actjmp
, s
);
92 getapproval(char const * volatile prompt
, bool_t noninteract_default
)
94 sighandler_type
volatile oint
, ohup
;
99 if(!(n_psonce
& n_PSO_INTERACTIVE
)){
101 rv
= noninteract_default
;
107 char const *quest
= noninteract_default
108 ? _("[yes]/no? ") : _("[no]/yes? ");
111 prompt
= _("Continue");
112 prompt
= savecatsep(prompt
, ' ', quest
);
115 oint
= safe_signal(SIGINT
, SIG_IGN
);
116 ohup
= safe_signal(SIGHUP
, SIG_IGN
);
117 if ((sig
= sigsetjmp(a_tty__actjmp
, 1)) != 0)
119 safe_signal(SIGINT
, &a_tty__acthdl
);
120 safe_signal(SIGHUP
, &a_tty__acthdl
);
122 if (n_lex_input(n_LEXINPUT_CTX_DEFAULT
| n_LEXINPUT_NL_ESC
, prompt
,
123 &termios_state
.ts_linebuf
, &termios_state
.ts_linesize
, NULL
) >= 0)
124 rv
= (boolify(termios_state
.ts_linebuf
, UIZ_MAX
,
125 noninteract_default
) > 0);
127 termios_state_reset();
129 safe_signal(SIGHUP
, ohup
);
130 safe_signal(SIGINT
, oint
);
140 getuser(char const * volatile query
) /* TODO v15-compat obsolete */
142 sighandler_type
volatile oint
, ohup
;
143 char * volatile user
= NULL
;
150 oint
= safe_signal(SIGINT
, SIG_IGN
);
151 ohup
= safe_signal(SIGHUP
, SIG_IGN
);
152 if ((sig
= sigsetjmp(a_tty__actjmp
, 1)) != 0)
154 safe_signal(SIGINT
, &a_tty__acthdl
);
155 safe_signal(SIGHUP
, &a_tty__acthdl
);
157 if (n_lex_input(n_LEXINPUT_CTX_DEFAULT
| n_LEXINPUT_NL_ESC
, query
,
158 &termios_state
.ts_linebuf
, &termios_state
.ts_linesize
, NULL
) >= 0)
159 user
= termios_state
.ts_linebuf
;
161 termios_state_reset();
163 safe_signal(SIGHUP
, ohup
);
164 safe_signal(SIGINT
, oint
);
172 getpassword(char const *query
)/* TODO v15: use _only_ n_tty_fp! */
174 sighandler_type
volatile oint
, ohup
;
176 char * volatile pass
;
181 if(!(n_psonce
& n_PSO_TTYIN
))
185 query
= _("Password: ");
186 fputs(query
, n_tty_fp
);
189 /* FIXME everywhere: tcsetattr() generates SIGTTOU when we're not in
190 * FIXME foreground pgrp, and can fail with EINTR!! also affects
191 * FIXME termios_state_reset() */
192 tcgetattr(STDIN_FILENO
, &termios_state
.ts_tios
);
193 memcpy(&tios
, &termios_state
.ts_tios
, sizeof tios
);
194 termios_state
.ts_needs_reset
= TRU1
;
195 tios
.c_iflag
&= ~(ISTRIP
);
196 tios
.c_lflag
&= ~(ECHO
| ECHOE
| ECHOK
| ECHONL
);
198 oint
= safe_signal(SIGINT
, SIG_IGN
);
199 ohup
= safe_signal(SIGHUP
, SIG_IGN
);
200 if ((sig
= sigsetjmp(a_tty__actjmp
, 1)) != 0)
202 safe_signal(SIGINT
, &a_tty__acthdl
);
203 safe_signal(SIGHUP
, &a_tty__acthdl
);
205 tcsetattr(STDIN_FILENO
, TCSAFLUSH
, &tios
);
206 if (readline_restart(n_stdin
, &termios_state
.ts_linebuf
,
207 &termios_state
.ts_linesize
, 0) >= 0)
208 pass
= termios_state
.ts_linebuf
;
210 termios_state_reset();
211 putc('\n', n_tty_fp
);
213 safe_signal(SIGHUP
, ohup
);
214 safe_signal(SIGINT
, oint
);
221 #endif /* HAVE_SOCKETS */
224 n_tty_create_prompt(struct n_string
*store
, char const *xprompt
,
225 enum n_lexinput_flags lif
){
226 struct n_visual_info_ctx vic
;
232 /* Prompt creation indicates that prompt printing is directly ahead, so take
233 * this opportunity of UI-in-a-known-state and advertise the error ring */
235 if((n_psonce
& (n_PSO_INTERACTIVE
| n_PSO_ERRORS_NOTED
)
236 ) == n_PSO_INTERACTIVE
&& (n_pstate
& n_PS_ERRORS_PROMPT
)){
237 n_psonce
|= n_PSO_ERRORS_NOTED
;
238 fprintf(n_stdout
, _("There are new messages in the error message ring "
240 " The `errors' command manages this message ring\n"),
246 n_string_trunc(store
, 0);
248 if(lif
& n_LEXINPUT_PROMPT_NONE
){
253 if(n_pstate
& n_PS_ERRORS_PROMPT
){
254 n_pstate
&= ~n_PS_ERRORS_PROMPT
;
255 store
= n_string_push_cp(store
, V_(n_error
));
256 store
= n_string_push_c(store
, '#');
257 store
= n_string_push_c(store
, ' ');
261 cp
= (lif
& n_LEXINPUT_PROMPT_EVAL
)
262 ? (lif
& n_LEXINPUT_NL_FOLLOW
? ok_vlook(prompt2
) : ok_vlook(prompt
))
264 if(cp
!= NULL
&& *cp
!= '\0'){
265 enum n_shexp_state shs
;
267 store
= n_string_push_cp(store
, cp
);
268 in
.s
= n_string_cp(store
);
271 store
= n_string_drop_ownership(store
);
273 shs
= n_shexp_parse_token(store
, &in
, n_SHEXP_PARSE_LOG
|
274 n_SHEXP_PARSE_IGNORE_EMPTY
| n_SHEXP_PARSE_QUOTE_AUTO_FIXED
|
275 n_SHEXP_PARSE_QUOTE_AUTO_DSQ
);
276 if((shs
& n_SHEXP_STATE_ERR_MASK
) || !(shs
& n_SHEXP_STATE_STOP
)){
277 store
= n_string_clear(store
);
278 store
= n_string_take_ownership(store
, out
.s
, out
.l
+1, out
.l
);
280 n_err(_("*prompt2?* evaluation failed, actively unsetting it\n"));
281 if(lif
& n_LEXINPUT_NL_FOLLOW
)
292 /* Make all printable TODO not know, we want to pass through ESC/CSI! */
294 in
.s
= n_string_cp(store
);
296 makeprint(&in
, &out
);
297 store
= n_string_assign_buf(store
, out
.s
, out
.l
);
301 /* We need the visual width.. */
302 memset(&vic
, 0, sizeof vic
);
303 vic
.vic_indat
= n_string_cp(store
);
304 vic
.vic_inlen
= store
->s_len
;
305 for(pwidth
= 0; vic
.vic_inlen
> 0;){
306 /* but \[ .. \] is not taken into account */
307 if(vic
.vic_indat
[0] == '\\' && vic
.vic_inlen
> 1 &&
308 vic
.vic_indat
[1] == '['){
311 i
= PTR2SIZE(vic
.vic_indat
- store
->s_dat
);
312 store
= n_string_cut(store
, i
, 2);
313 cp
= &n_string_cp(store
)[i
];
314 i
= store
->s_len
- i
;
317 n_err(_("Open \\[ sequence not closed in *prompt2?*\n"));
320 if(cp
[0] == '\\' && cp
[1] == ']')
323 i
= PTR2SIZE(cp
- store
->s_dat
);
324 store
= n_string_cut(store
, i
, 2);
325 vic
.vic_indat
= &n_string_cp(store
)[i
];
326 vic
.vic_inlen
= store
->s_len
- i
;
327 }else if(!n_visual_info(&vic
, n_VISUAL_INFO_WIDTH_QUERY
|
328 n_VISUAL_INFO_ONE_CHAR
)){
329 n_err(_("Character set error in evaluation of *prompt2?*\n"));
332 pwidth
+= (ui32_t
)vic
.vic_vi_width
;
333 vic
.vic_indat
= vic
.vic_oudat
;
334 vic
.vic_inlen
= vic
.vic_oulen
;
338 /* And there may be colour support, too */
341 struct str
const *psp
, *rsp
;
342 struct n_colour_pen
*ccp
;
344 if((ccp
= n_colour_pen_create(n_COLOUR_ID_MLE_PROMPT
, NULL
)) != NULL
&&
345 (psp
= n_colour_pen_to_str(ccp
)) != NULL
&&
346 (rsp
= n_colour_reset_to_str()) != NULL
){
347 store
= n_string_unshift_buf(store
, psp
->s
, psp
->l
);
348 store
= n_string_push_buf(store
, rsp
->s
, rsp
->l
);
351 #endif /* HAVE_COLOUR */
359 * MLE: the Mailx-Line-Editor, our homebrew editor
360 * (inspired from NetBSDs sh(1) and dash(1)s hetio.c).
362 * Only used in interactive mode.
363 * TODO . This code should be splitted in funs/raw input/bind modules.
364 * TODO . We work with wide characters, but not for buffer takeovers and
365 * TODO cell2save()ings. This should be changed. For the former the buffer
366 * TODO thus needs to be converted to wide first, and then simply be fed in.
367 * TODO . We repaint too much. To overcome this use the same approach that my
368 * TODO terminal library uses, add a true "virtual screen line" that stores
369 * TODO the actually visible content, keep a notion of "first modified slot"
370 * TODO and "last modified slot" (including "unknown" and "any" specials),
371 * TODO update that virtual instead, then synchronize what has truly changed.
372 * TODO I.e., add an indirection layer.
373 * TODO . No BIDI support.
374 * TODO . `bind': we currently use only one lookup tree.
375 * TODO For absolute graceful behaviour in conjunction (with HAVE_TERMCAP) we
376 * TODO need a lower level tree, which possibly combines bytes into "symbolic
377 * TODO wchar_t values", into "keys" that is, as applicable, and an upper
378 * TODO layer which only works on "keys" in order to possibly combine them
379 * TODO into key sequences. We can reuse existent tree code for that.
380 * TODO We need an additional hashmap which maps termcap/terminfo names to
381 * TODO (their byte representations and) a dynamically assigned unique
382 * TODO "symbolic wchar_t value". This implies we may have incompatibilities
383 * TODO when __STDC_ISO_10646__ is not defined. Also we do need takeover-
384 * TODO bytes storage, but it can be a string_creat_auto in the line struct.
385 * TODO Until then we can run into ambiguities; in rare occasions.
388 /* To avoid memory leaks etc. with the current codebase that simply longjmp(3)s
389 * we're forced to use the very same buffer--the one that is passed through to
390 * us from the outside--to store anything we need, i.e., a "struct cell[]", and
391 * convert that on-the-fly back to the plain char* result once we're done.
392 * To simplify our live, use savestr() buffers for all other needed memory */
394 # ifdef HAVE_KEY_BINDINGS
395 /* Default *bind-timeout* key-sequence continuation timeout, in tenths of
396 * a second. Must fit in 8-bit! Update the manual upon change! */
397 # define a_TTY_BIND_TIMEOUT 2
398 # define a_TTY_BIND_TIMEOUT_MAX SI8_MAX
400 n_CTAV(a_TTY_BIND_TIMEOUT_MAX
<= UI8_MAX
);
402 /* We have a chicken-and-egg problem with `bind' and our termcap layer,
403 * because we may not initialize the latter automatically to allow users to
404 * specify *termcap-disable* and let it mean exactly that.
405 * On the other hand users can be expected to use `bind' in resource file(s).
406 * Therefore bindings which involve termcap/terminfo sequences, and which are
407 * defined before n_PSO_STARTED signals usability of termcap/terminfo, will be
408 * (partially) delayed until tty_init() is called.
409 * And we preallocate space for the expansion of the resolved capability */
410 # define a_TTY_BIND_CAPNAME_MAX 15
411 # define a_TTY_BIND_CAPEXP_ROUNDUP 16
413 n_CTAV(n_ISPOW2(a_TTY_BIND_CAPEXP_ROUNDUP
));
414 n_CTA(a_TTY_BIND_CAPEXP_ROUNDUP
<= SI8_MAX
/ 2, "Variable must fit in 6-bit");
415 n_CTA(a_TTY_BIND_CAPEXP_ROUNDUP
>= 8, "Variable too small");
416 # endif /* HAVE_KEY_BINDINGS */
418 /* The maximum size (of a_tty_cell's) in a line */
419 # define a_TTY_LINE_MAX SI32_MAX
421 /* (Some more CTAs around) */
422 n_CTA(a_TTY_LINE_MAX
<= SI32_MAX
,
423 "a_TTY_LINE_MAX larger than SI32_MAX, but the MLE uses 32-bit arithmetic");
425 /* When shall the visual screen be scrolled, in % of usable screen width */
426 # define a_TTY_SCROLL_MARGIN_LEFT 15
427 # define a_TTY_SCROLL_MARGIN_RIGHT 10
429 /* fexpand() flags for expand-on-tab */
430 # define a_TTY_TAB_FEXP_FL (FEXP_FULL | FEXP_SILENT | FEXP_MULTIOK)
432 /* Columns to ripoff: outermost may not be touched, plus position indicator.
433 * Must thus be at least 1, but should be >= 1+4 to dig the position indicator
434 * that we place (if there is sufficient space) */
435 # define a_TTY_WIDTH_RIPOFF 5
437 /* The implementation of the MLE functions always exists, and is based upon
438 * the a_TTY_BIND_FUN_* constants, so most of this enum is always necessary */
439 enum a_tty_bind_flags
{
440 # ifdef HAVE_KEY_BINDINGS
441 a_TTY_BIND_RESOLVE
= 1u<<8, /* Term cap. yet needs to be resolved */
442 a_TTY_BIND_DEFUNCT
= 1u<<9, /* Unicode/term cap. used but not avail. */
443 a_TTY__BIND_MASK
= a_TTY_BIND_RESOLVE
| a_TTY_BIND_DEFUNCT
,
444 /* MLE fun assigned to a one-byte-sequence: this may be used for special
445 * key-sequence bypass processing */
446 a_TTY_BIND_MLE1CNTRL
= 1u<<10,
447 a_TTY_BIND_NOCOMMIT
= 1u<<11, /* Expansion shall be editable */
450 /* MLE internal commands */
451 a_TTY_BIND_FUN_INTERNAL
= 1u<<15,
452 a_TTY__BIND_FUN_SHIFT
= 16u,
453 a_TTY__BIND_FUN_SHIFTMAX
= 24u,
454 a_TTY__BIND_FUN_MASK
= ((1u << a_TTY__BIND_FUN_SHIFTMAX
) - 1) &
455 ~((1u << a_TTY__BIND_FUN_SHIFT
) - 1),
456 # define a_TTY_BIND_FUN_REDUCE(X) \
457 (((ui32_t)(X) & a_TTY__BIND_FUN_MASK) >> a_TTY__BIND_FUN_SHIFT)
458 # define a_TTY_BIND_FUN_EXPAND(X) \
459 (((ui32_t)(X) & (a_TTY__BIND_FUN_MASK >> a_TTY__BIND_FUN_SHIFT)) << \
460 a_TTY__BIND_FUN_SHIFT)
463 a_TTY_BIND_FUN_ ## N = a_TTY_BIND_FUN_EXPAND(I),
466 a_X(GO_BWD
, 1) a_X(GO_FWD
, 2)
467 a_X(GO_WORD_BWD
, 3) a_X(GO_WORD_FWD
, 4)
468 a_X(GO_HOME
, 5) a_X(GO_END
, 6)
469 a_X(DEL_BWD
, 7) a_X(DEL_FWD
, 8)
470 a_X(SNARF_WORD_BWD
, 9) a_X(SNARF_WORD_FWD
, 10)
471 a_X(SNARF_END
, 11) a_X(SNARF_LINE
, 12)
472 a_X(HIST_BWD
, 13) a_X(HIST_FWD
, 14)
473 a_X(HIST_SRCH_BWD
, 15) a_X(HIST_SRCH_FWD
, 16)
475 a_X(QUOTE_RNDTRIP
, 18)
483 a_X(COMMIT
, 25) /* Must be last one! */
486 a_TTY__BIND_LAST
= 1<<25
488 # ifdef HAVE_KEY_BINDINGS
489 n_CTA((ui32_t
)a_TTY_BIND_RESOLVE
>= (ui32_t
)n__LEXINPUT_CTX_MAX1
,
490 "Bit carrier lower boundary must be raised to avoid value sharing");
492 n_CTA(a_TTY_BIND_FUN_EXPAND(a_TTY_BIND_FUN_COMMIT
) <
493 (1 << a_TTY__BIND_FUN_SHIFTMAX
),
494 "Bit carrier range must be expanded to represent necessary bits");
495 n_CTA(a_TTY__BIND_LAST
>= (1u << a_TTY__BIND_FUN_SHIFTMAX
),
496 "Bit carrier upper boundary must be raised to avoid value sharing");
497 n_CTA(UICMP(64, a_TTY__BIND_LAST
, <=, SI32_MAX
),
498 "Flag bits excess storage datatype" /* And we need one bit free */);
500 enum a_tty_fun_status
{
501 a_TTY_FUN_STATUS_OK
, /* Worked, next character */
502 a_TTY_FUN_STATUS_COMMIT
, /* Line done */
503 a_TTY_FUN_STATUS_RESTART
, /* Complete restart, reset multibyte etc. */
504 a_TTY_FUN_STATUS_END
/* End, return EOF */
507 enum a_tty_visual_flags
{
509 a_TTY_VF_MOD_CURSOR
= 1u<<0, /* Cursor moved */
510 a_TTY_VF_MOD_CONTENT
= 1u<<1, /* Content modified */
511 a_TTY_VF_MOD_DIRTY
= 1u<<2, /* Needs complete repaint */
512 a_TTY_VF_MOD_SINGLE
= 1u<<3, /* TODO Drop when indirection as above comes */
513 a_TTY_VF_REFRESH
= a_TTY_VF_MOD_DIRTY
| a_TTY_VF_MOD_CURSOR
|
514 a_TTY_VF_MOD_CONTENT
| a_TTY_VF_MOD_SINGLE
,
515 a_TTY_VF_BELL
= 1u<<8, /* Ring the bell */
516 a_TTY_VF_SYNC
= 1u<<9, /* Flush/Sync I/O channel */
518 a_TTY_VF_ALL_MASK
= a_TTY_VF_REFRESH
| a_TTY_VF_BELL
| a_TTY_VF_SYNC
,
519 a_TTY__VF_LAST
= a_TTY_VF_SYNC
522 # ifdef HAVE_KEY_BINDINGS
523 struct a_tty_bind_ctx
{
524 struct a_tty_bind_ctx
*tbc_next
;
525 char *tbc_seq
; /* quence as given (poss. re-quoted), in .tb__buf */
526 char *tbc_exp
; /* ansion, in .tb__buf */
527 /* The .tbc_seq'uence with any terminal capabilities resolved; in fact an
528 * array of structures, the first entry of which is {si32_t buf_len_iscap;}
529 * where the signed bit indicates whether the buffer is a resolved terminal
530 * capability instead of a (possibly multibyte) character. In .tbc__buf */
536 char tbc__buf
[n_VFIELD_SIZE(0)];
539 struct a_tty_bind_ctx_map
{
540 enum n_lexinput_flags tbcm_ctx
;
541 char const tbcm_name
[12]; /* Name of `bind' context */
543 # endif /* HAVE_KEY_BINDINGS */
545 struct a_tty_bind_builtin_tuple
{
546 bool_t tbbt_iskey
; /* Whether this is a control key; else termcap query */
547 char tbbt_ckey
; /* Control code */
548 ui16_t tbbt_query
; /* enum n_termcap_query (instead) */
549 char tbbt_exp
[12]; /* String or [0]=NUL/[1]=BIND_FUN_REDUCE() */
551 n_CTA(n__TERMCAP_QUERY_MAX1
<= UI16_MAX
,
552 "Enumeration cannot be stored in datatype");
554 # ifdef HAVE_KEY_BINDINGS
555 struct a_tty_bind_parse_ctx
{
556 char const *tbpc_cmd
; /* Command which parses */
557 char const *tbpc_in_seq
; /* In: key sequence */
558 struct str tbpc_exp
; /* In/Out: expansion (or NULL) */
559 struct a_tty_bind_ctx
*tbpc_tbcp
; /* Out: if yet existent */
560 struct a_tty_bind_ctx
*tbpc_ltbcp
; /* Out: the one before .tbpc_tbcp */
561 char *tbpc_seq
; /* Out: normalized sequence */
562 char *tbpc_cnv
; /* Out: sequence when read(2)ing it */
565 ui32_t tbpc_cnv_align_mask
; /* For creating a_tty_bind_ctx.tbc_cnv */
566 ui32_t tbpc_flags
; /* n_lexinput_flags | a_tty_bind_flags */
569 /* Input character tree */
570 struct a_tty_bind_tree
{
571 struct a_tty_bind_tree
*tbt_sibling
; /* s at same level */
572 struct a_tty_bind_tree
*tbt_childs
; /* Sequence continues.. here */
573 struct a_tty_bind_tree
*tbt_parent
;
574 struct a_tty_bind_ctx
*tbt_bind
; /* NULL for intermediates */
575 wchar_t tbt_char
; /* acter this level represents */
576 bool_t tbt_isseq
; /* Belongs to multibyte sequence */
577 bool_t tbt_isseq_trail
; /* ..is trailing byte of it */
580 # endif /* HAVE_KEY_BINDINGS */
584 ui16_t tc_count
; /* ..of bytes */
585 ui8_t tc_width
; /* Visual width; TAB==UI8_MAX! */
586 bool_t tc_novis
; /* Don't display visually as such (control character) */
587 char tc_cbuf
[MB_LEN_MAX
* 2]; /* .. plus reset shift sequence */
591 struct a_tty_line
*tg_line
; /* To be able to access it from signal hdl */
593 struct a_tty_hist
*tg_hist
;
594 struct a_tty_hist
*tg_hist_tail
;
596 size_t tg_hist_size_max
;
598 # ifdef HAVE_KEY_BINDINGS
599 ui32_t tg_bind_cnt
; /* Overall number of bindings */
600 bool_t tg_bind_isdirty
;
601 bool_t tg_bind_isbuild
;
602 # define a_TTY_SHCUT_MAX (3 +1) /* Note: update manual on change! */
603 ui8_t tg_bind__dummy
[2];
604 char tg_bind_shcut_cancel
[n__LEXINPUT_CTX_MAX1
][a_TTY_SHCUT_MAX
];
605 char tg_bind_shcut_prompt_char
[n__LEXINPUT_CTX_MAX1
][a_TTY_SHCUT_MAX
];
606 struct a_tty_bind_ctx
*tg_bind
[n__LEXINPUT_CTX_MAX1
];
607 struct a_tty_bind_tree
*tg_bind_tree
[n__LEXINPUT_CTX_MAX1
][HSHSIZE
];
609 struct termios tg_tios_old
;
610 struct termios tg_tios_new
;
612 # ifdef HAVE_KEY_BINDINGS
613 n_CTA(n__LEXINPUT_CTX_MAX1
== 3 && a_TTY_SHCUT_MAX
== 4 &&
614 n_SIZEOF_FIELD(struct a_tty_global
, tg_bind__dummy
) == 2,
615 "Value results in array sizes that results in bad structure layout");
616 n_CTA(a_TTY_SHCUT_MAX
> 1,
617 "Users need at least one shortcut, plus NUL terminator");
622 struct a_tty_hist
*th_older
;
623 struct a_tty_hist
*th_younger
;
624 ui32_t th_isgabby
: 1;
626 char th_dat
[n_VFIELD_SIZE(sizeof(ui32_t
))];
631 /* Caller pointers */
633 size_t *tl_x_bufsize
;
634 /* Input processing */
635 # ifdef HAVE_KEY_BINDINGS
636 wchar_t tl_bind_takeover
; /* Leftover byte to consume next */
637 ui8_t tl_bind_timeout
; /* In-seq. inter-byte-timer, in 1/10th secs */
638 ui8_t tl__bind_dummy
[3];
639 char (*tl_bind_shcut_cancel
)[a_TTY_SHCUT_MAX
]; /* Special _CANCEL control */
640 char (*tl_bind_shcut_prompt_char
)[a_TTY_SHCUT_MAX
]; /* ..for _PROMPT_CHAR */
641 struct a_tty_bind_tree
*(*tl_bind_tree_hmap
)[HSHSIZE
]; /* Bind lookup tree */
642 struct a_tty_bind_tree
*tl_bind_tree
;
644 /* Line data / content handling */
645 ui32_t tl_count
; /* ..of a_tty_cell's (<= a_TTY_LINE_MAX) */
646 ui32_t tl_cursor
; /* Current a_tty_cell insertion point */
648 char *cbuf
; /* *.tl_x_buf */
649 struct a_tty_cell
*cells
;
651 struct str tl_defc
; /* Current default content */
652 size_t tl_defc_cursor_byte
; /* Desired position of cursor after takeover */
653 struct str tl_savec
; /* Saved default content */
654 struct str tl_pastebuf
; /* Last snarfed data */
656 struct a_tty_hist
*tl_hist
; /* History cursor */
658 ui32_t tl_count_max
; /* ..before buffer needs to grow */
659 /* Visual data representation handling */
660 ui32_t tl_vi_flags
; /* enum a_tty_visual_flags */
661 ui32_t tl_lst_count
; /* .tl_count after last sync */
662 ui32_t tl_lst_cursor
; /* .tl_cursor after last sync */
663 /* TODO Add another indirection layer by adding a tl_phy_line of
664 * TODO a_tty_cell objects, incorporate changes in visual layer,
665 * TODO then check what _really_ has changed, sync those changes only */
666 struct a_tty_cell
const *tl_phy_start
; /* First visible cell, left border */
667 ui32_t tl_phy_cursor
; /* Physical cursor position */
668 bool_t tl_quote_rndtrip
; /* For _kht() expansion */
670 ui32_t tl_prompt_length
; /* Preclassified (TODO needed as a_tty_cell) */
671 ui32_t tl_prompt_width
;
672 char const *tl_prompt
; /* Preformatted prompt (including colours) */
673 /* .tl_pos_buf is a hack */
675 char *tl_pos_buf
; /* mle-position colour-on, [4], reset seq. */
676 char *tl_pos
; /* Address of the [4] */
680 # ifdef HAVE_KEY_BINDINGS
681 /* C99: use [INDEX]={} */
682 n_CTAV(n_LEXINPUT_CTX_BASE
== 0);
683 n_CTAV(n_LEXINPUT_CTX_DEFAULT
== 1);
684 n_CTAV(n_LEXINPUT_CTX_COMPOSE
== 2);
685 static struct a_tty_bind_ctx_map
const
686 a_tty_bind_ctx_maps
[n__LEXINPUT_CTX_MAX1
] = {
687 {n_LEXINPUT_CTX_BASE
, "base"},
688 {n_LEXINPUT_CTX_DEFAULT
, "default"},
689 {n_LEXINPUT_CTX_COMPOSE
, "compose"}
692 /* Special functions which our MLE provides internally.
693 * Update the manual upon change! */
694 static char const a_tty_bind_fun_names
[][24] = {
697 n_FIELD_INITI(a_TTY_BIND_FUN_REDUCE(a_TTY_BIND_FUN_ ## I)) "mle-" N "\0",
700 a_X(GO_BWD
, "go-bwd") a_X(GO_FWD
, "go-fwd")
701 a_X(GO_WORD_BWD
, "go-word-bwd") a_X(GO_WORD_FWD
, "go-word-fwd")
702 a_X(GO_HOME
, "go-home") a_X(GO_END
, "go-end")
703 a_X(DEL_BWD
, "del-bwd") a_X(DEL_FWD
, "del-fwd")
704 a_X(SNARF_WORD_BWD
, "snarf-word-bwd") a_X(SNARF_WORD_FWD
, "snarf-word-fwd")
705 a_X(SNARF_END
, "snarf-end") a_X(SNARF_LINE
, "snarf-line")
706 a_X(HIST_BWD
, "hist-bwd") a_X(HIST_FWD
, "hist-fwd")
707 a_X(HIST_SRCH_BWD
, "hist-srch-bwd") a_X(HIST_SRCH_FWD
, "hist-srch-fwd")
708 a_X(REPAINT
, "repaint")
709 a_X(QUOTE_RNDTRIP
, "quote-rndtrip")
710 a_X(PROMPT_CHAR
, "prompt-char")
711 a_X(COMPLETE
, "complete")
714 a_X(CANCEL
, "cancel")
716 a_X(FULLRESET
, "fullreset")
717 a_X(COMMIT
, "commit")
721 # endif /* HAVE_KEY_BINDINGS */
723 /* The default key bindings (unless disallowed). Update manual upon change!
724 * A logical subset of this table is also used if !HAVE_KEY_BINDINGS (more
725 * expensive than a switch() on control codes directly, but less redundant).
726 * The table for the "base" context */
727 static struct a_tty_bind_builtin_tuple
const a_tty_bind_base_tuples
[] = {
730 {TRU1, K, 0, {'\0', (char)a_TTY_BIND_FUN_REDUCE(a_TTY_BIND_FUN_ ## S),}},
748 a_X('Q', QUOTE_RNDTRIP
)
749 a_X('R', HIST_SRCH_BWD
)
750 a_X('S', HIST_SRCH_FWD
)
753 a_X('V', PROMPT_CHAR
)
754 a_X('W', SNARF_WORD_BWD
)
755 a_X('X', GO_WORD_FWD
)
756 a_X('Y', GO_WORD_BWD
)
763 a_X('_', SNARF_WORD_FWD
)
768 # define a_X(K,S) {TRU1, K, 0, {S}},
770 /* The remains only if we have `bind' functionality available */
771 # ifdef HAVE_KEY_BINDINGS
774 {FAL0, '\0', n_TERMCAP_QUERY_ ## Q,\
775 {'\0', (char)a_TTY_BIND_FUN_REDUCE(a_TTY_BIND_FUN_ ## S),}},
777 a_X(key_backspace
, DEL_BWD
) a_X(key_dc
, DEL_FWD
)
778 a_X(key_eol
, SNARF_END
)
779 a_X(key_home
, GO_HOME
) a_X(key_end
, GO_END
)
780 a_X(key_left
, GO_BWD
) a_X(key_right
, GO_FWD
)
781 a_X(key_sleft
, GO_HOME
) a_X(key_sright
, GO_END
)
782 a_X(key_up
, HIST_BWD
) a_X(key_down
, HIST_FWD
)
783 # endif /* HAVE_KEY_BINDINGS */
786 /* The table for the "default" context.
787 * We don't want commands to end up in history, so place an initial space */
788 static struct a_tty_bind_builtin_tuple
const a_tty_bind_default_tuples
[] = {
791 {TRU1, K, 0, {'\0', (char)a_TTY_BIND_FUN_REDUCE(a_TTY_BIND_FUN_ ## S),}},
794 # define a_X(K,S) {TRU1, K, 0, {" " S}},
802 /* The remains only if we have `bind' functionality available */
803 # ifdef HAVE_KEY_BINDINGS
805 # define a_X(Q,S) {FAL0, '\0', n_TERMCAP_QUERY_ ## Q, {" " S}},
807 a_X(key_shome
, "z0") a_X(key_send
, "z$")
808 a_X(xkey_sup
, "z0") a_X(xkey_sdown
, "z$")
809 a_X(key_ppage
, "z-") a_X(key_npage
, "z+")
810 a_X(xkey_cup
, "dotmove-") a_X(xkey_cdown
, "dotmove+")
811 # endif /* HAVE_KEY_BINDINGS */
815 static struct a_tty_global a_tty
;
817 /* Change from canonical to raw, non-canonical mode, and way back */
818 static void a_tty_term_mode(bool_t raw
);
820 /* Initialize .tg_hist_size_max and return desired history file, or NULL */
822 static char const *a_tty_hist_query_config(void);
825 /* Adjust an active raw mode to use / not use a timeout */
826 # ifdef HAVE_KEY_BINDINGS
827 static void a_tty_term_rawmode_timeout(struct a_tty_line
*tlp
, bool_t enable
);
830 /* 0-X (2), UI8_MAX == \t / TAB */
831 static ui8_t
a_tty_wcwidth(wchar_t wc
);
833 /* Memory / cell / word generics */
834 static void a_tty_check_grow(struct a_tty_line
*tlp
, ui32_t no
835 n_MEMORY_DEBUG_ARGS
);
836 static ssize_t
a_tty_cell2dat(struct a_tty_line
*tlp
);
837 static void a_tty_cell2save(struct a_tty_line
*tlp
);
839 /* Save away data bytes of given range (max = non-inclusive) */
840 static void a_tty_copy2paste(struct a_tty_line
*tlp
, struct a_tty_cell
*tcpmin
,
841 struct a_tty_cell
*tcpmax
);
843 /* Ask user for hexadecimal number, interpret as UTF-32 */
844 static wchar_t a_tty_vinuni(struct a_tty_line
*tlp
);
846 /* Visual screen synchronization */
847 static bool_t
a_tty_vi_refresh(struct a_tty_line
*tlp
);
849 static bool_t
a_tty_vi__paint(struct a_tty_line
*tlp
);
851 /* Search for word boundary, starting at tl_cursor, in "dir"ection (<> 0).
852 * Return <0 when moving is impossible (backward direction but in position 0,
853 * forward direction but in outermost column), and relative distance to
854 * tl_cursor otherwise */
855 static si32_t
a_tty_wboundary(struct a_tty_line
*tlp
, si32_t dir
);
857 /* Most function implementations */
858 static void a_tty_khome(struct a_tty_line
*tlp
, bool_t dobell
);
859 static void a_tty_kend(struct a_tty_line
*tlp
);
860 static void a_tty_kbs(struct a_tty_line
*tlp
);
861 static void a_tty_ksnarf(struct a_tty_line
*tlp
, bool_t cplline
, bool_t dobell
);
862 static si32_t
a_tty_kdel(struct a_tty_line
*tlp
);
863 static void a_tty_kleft(struct a_tty_line
*tlp
);
864 static void a_tty_kright(struct a_tty_line
*tlp
);
865 static void a_tty_ksnarfw(struct a_tty_line
*tlp
, bool_t fwd
);
866 static void a_tty_kgow(struct a_tty_line
*tlp
, si32_t dir
);
867 static bool_t
a_tty_kother(struct a_tty_line
*tlp
, wchar_t wc
);
868 static ui32_t
a_tty_kht(struct a_tty_line
*tlp
);
871 /* Return UI32_MAX on "exhaustion" */
872 static ui32_t
a_tty_khist(struct a_tty_line
*tlp
, bool_t fwd
);
873 static ui32_t
a_tty_khist_search(struct a_tty_line
*tlp
, bool_t fwd
);
875 static ui32_t
a_tty__khist_shared(struct a_tty_line
*tlp
,
876 struct a_tty_hist
*thp
);
879 /* Handle a function */
880 static enum a_tty_fun_status
a_tty_fun(struct a_tty_line
*tlp
,
881 enum a_tty_bind_flags tbf
, size_t *len
);
884 static ssize_t
a_tty_readline(struct a_tty_line
*tlp
, size_t len
885 n_MEMORY_DEBUG_ARGS
);
887 # ifdef HAVE_KEY_BINDINGS
888 /* Find context or -1 */
889 static enum n_lexinput_flags
a_tty_bind_ctx_find(char const *name
);
891 /* Create (or replace, if allowed) a binding */
892 static bool_t
a_tty_bind_create(struct a_tty_bind_parse_ctx
*tbpcp
,
895 /* Shared implementation to parse `bind' and `unbind' "key-sequence" and
896 * "expansion" command line arguments into something that we can work with */
897 static bool_t
a_tty_bind_parse(bool_t isbindcmd
,
898 struct a_tty_bind_parse_ctx
*tbpcp
);
900 /* Lazy resolve a termcap(5)/terminfo(5) (or *termcap*!) capability */
901 static void a_tty_bind_resolve(struct a_tty_bind_ctx
*tbcp
);
903 /* Delete an existing binding */
904 static void a_tty_bind_del(struct a_tty_bind_parse_ctx
*tbpcp
);
906 /* Life cycle of all input node trees */
907 static void a_tty_bind_tree_build(void);
908 static void a_tty_bind_tree_teardown(void);
910 static void a_tty__bind_tree_add(ui32_t hmap_idx
,
911 struct a_tty_bind_tree
*store
[HSHSIZE
],
912 struct a_tty_bind_ctx
*tbcp
);
913 static struct a_tty_bind_tree
*a_tty__bind_tree_add_wc(
914 struct a_tty_bind_tree
**treep
, struct a_tty_bind_tree
*parentp
,
915 wchar_t wc
, bool_t isseq
);
916 static void a_tty__bind_tree_free(struct a_tty_bind_tree
*tbtp
);
917 # endif /* HAVE_KEY_BINDINGS */
920 a_tty_term_mode(bool_t raw
){
921 struct termios
*tiosp
;
924 tiosp
= &a_tty
.tg_tios_old
;
928 /* Always requery the attributes, in case we've been moved from background
929 * to foreground or however else in between sessions */
930 /* XXX Always enforce ECHO and ICANON in the OLD attributes - do so as long
931 * XXX as we don't properly deal with TTIN and TTOU etc. */
932 tcgetattr(STDIN_FILENO
, tiosp
); /* TODO v15: use _only_ n_tty_fp! */
933 tiosp
->c_lflag
|= ECHO
| ICANON
;
935 memcpy(&a_tty
.tg_tios_new
, tiosp
, sizeof *tiosp
);
936 tiosp
= &a_tty
.tg_tios_new
;
937 tiosp
->c_cc
[VMIN
] = 1;
938 tiosp
->c_cc
[VTIME
] = 0;
939 /* Enable ^\, ^Q and ^S to be used for key bindings */
940 tiosp
->c_cc
[VQUIT
] = tiosp
->c_cc
[VSTART
] = tiosp
->c_cc
[VSTOP
] = '\0';
941 tiosp
->c_iflag
&= ~(ISTRIP
| IGNCR
);
942 tiosp
->c_lflag
&= ~(ECHO
/*| ECHOE | ECHONL */| ICANON
| IEXTEN
);
944 tcsetattr(STDIN_FILENO
, TCSADRAIN
, tiosp
);
950 a_tty_hist_query_config(void){
954 if((cp
= ok_vlook(NAIL_HISTSIZE
)) != NULL
)
955 n_OBSOLETE(_("please use *history-size* instead of *NAIL_HISTSIZE*"));
956 if((rv
= ok_vlook(history_size
)) == NULL
)
959 a_tty
.tg_hist_size_max
= UIZ_MAX
;
961 (void)n_idec_uiz_cp(&a_tty
.tg_hist_size_max
, rv
, 10, NULL
);
963 if((cp
= ok_vlook(NAIL_HISTFILE
)) != NULL
)
964 n_OBSOLETE(_("please use *history-file* instead of *NAIL_HISTFILE*"));
965 if((rv
= ok_vlook(history_file
)) == NULL
)
968 rv
= fexpand(rv
, FEXP_LOCAL
| FEXP_NSHELL
);
972 # endif /* HAVE_HISTORY */
974 # ifdef HAVE_KEY_BINDINGS
976 a_tty_term_rawmode_timeout(struct a_tty_line
*tlp
, bool_t enable
){
981 a_tty
.tg_tios_new
.c_cc
[VMIN
] = 0;
982 if((bt
= tlp
->tl_bind_timeout
) == 0)
983 bt
= a_TTY_BIND_TIMEOUT
;
984 a_tty
.tg_tios_new
.c_cc
[VTIME
] = bt
;
986 a_tty
.tg_tios_new
.c_cc
[VMIN
] = 1;
987 a_tty
.tg_tios_new
.c_cc
[VTIME
] = 0;
989 tcsetattr(STDIN_FILENO
, TCSANOW
, &a_tty
.tg_tios_new
);
992 # endif /* HAVE_KEY_BINDINGS */
995 a_tty_wcwidth(wchar_t wc
){
999 /* Special case the backslash at first */
1005 # ifdef HAVE_WCWIDTH
1006 rv
= ((i
= wcwidth(wc
)) > 0) ? (ui8_t
)i
: 0;
1008 rv
= iswprint(wc
) ? 1 + (wc
>= 0x1100u
) : 0; /* TODO use S-CText */
1016 a_tty_check_grow(struct a_tty_line
*tlp
, ui32_t no n_MEMORY_DEBUG_ARGS
){
1020 if(n_UNLIKELY((cmax
= tlp
->tl_count
+ no
) > tlp
->tl_count_max
)){
1023 i
= cmax
* sizeof(struct a_tty_cell
) + 2 * sizeof(struct a_tty_cell
);
1024 if(n_LIKELY(i
>= *tlp
->tl_x_bufsize
)){
1025 hold_all_sigs(); /* XXX v15 drop */
1028 *tlp
->tl_x_buf
= (n_realloc
)(*tlp
->tl_x_buf
, i
1029 n_MEMORY_DEBUG_ARGSCALL
);
1030 rele_all_sigs(); /* XXX v15 drop */
1032 tlp
->tl_count_max
= cmax
;
1033 *tlp
->tl_x_bufsize
= i
;
1039 a_tty_cell2dat(struct a_tty_line
*tlp
){
1045 if(n_LIKELY((i
= tlp
->tl_count
) > 0)){
1046 struct a_tty_cell
const *tcap
;
1048 tcap
= tlp
->tl_line
.cells
;
1050 memcpy(tlp
->tl_line
.cbuf
+ len
, tcap
->tc_cbuf
, tcap
->tc_count
);
1051 len
+= tcap
->tc_count
;
1052 }while(++tcap
, --i
> 0);
1055 tlp
->tl_line
.cbuf
[len
] = '\0';
1057 return (ssize_t
)len
;
1061 a_tty_cell2save(struct a_tty_line
*tlp
){
1063 struct a_tty_cell
*tcap
;
1066 tlp
->tl_savec
.s
= NULL
;
1067 tlp
->tl_savec
.l
= 0;
1069 if(n_UNLIKELY(tlp
->tl_count
== 0))
1072 for(tcap
= tlp
->tl_line
.cells
, len
= 0, i
= tlp
->tl_count
; i
> 0;
1074 len
+= tcap
->tc_count
;
1076 tlp
->tl_savec
.s
= salloc((tlp
->tl_savec
.l
= len
) +1);
1078 for(tcap
= tlp
->tl_line
.cells
, len
= 0, i
= tlp
->tl_count
; i
> 0;
1080 memcpy(tlp
->tl_savec
.s
+ len
, tcap
->tc_cbuf
, tcap
->tc_count
);
1081 len
+= tcap
->tc_count
;
1083 tlp
->tl_savec
.s
[len
] = '\0';
1089 a_tty_copy2paste(struct a_tty_line
*tlp
, struct a_tty_cell
*tcpmin
,
1090 struct a_tty_cell
*tcpmax
){
1092 struct a_tty_cell
*tcp
;
1097 for(tcp
= tcpmin
; tcp
< tcpmax
; ++tcp
)
1100 tlp
->tl_pastebuf
.s
= cp
= salloc((tlp
->tl_pastebuf
.l
= l
) +1);
1103 for(tcp
= tcpmin
; tcp
< tcpmax
; cp
+= l
, ++tcp
)
1104 memcpy(cp
, tcp
->tc_cbuf
, l
= tcp
->tc_count
);
1110 a_tty_vinuni(struct a_tty_line
*tlp
){
1118 if(!n_termcap_cmdx(n_TERMCAP_CMD_cr
) ||
1119 !n_termcap_cmd(n_TERMCAP_CMD_ce
, 0, -1))
1123 struct str
const *cpre
, *csuf
;
1125 struct n_colour_pen
*cpen
;
1127 cpen
= n_colour_pen_create(n_COLOUR_ID_MLE_PROMPT
, NULL
);
1128 if((cpre
= n_colour_pen_to_str(cpen
)) != NULL
)
1129 csuf
= n_colour_reset_to_str();
1135 fprintf(n_tty_fp
, _("%sPlease enter Unicode code point:%s "),
1136 (cpre
!= NULL
? cpre
->s
: n_empty
),
1137 (csuf
!= NULL
? csuf
->s
: n_empty
));
1141 buf
[sizeof(buf
) -1] = '\0';
1143 if(read(STDIN_FILENO
, &buf
[i
], 1) != 1){
1144 if(errno
== EINTR
) /* xxx #if !SA_RESTART ? */
1150 if(!hexchar(buf
[i
])){
1151 char const emsg
[] = "[0-9a-fA-F]";
1153 n_LCTA(sizeof emsg
<= sizeof(buf
), "Preallocated buffer too small");
1154 memcpy(buf
, emsg
, sizeof emsg
);
1158 putc(buf
[i
], n_tty_fp
);
1160 if(++i
== sizeof buf
)
1165 if((n_idec_uiz_cp(&i
, buf
, 16, NULL
1166 ) & (n_IDEC_STATE_EMASK
| n_IDEC_STATE_CONSUMED
)
1167 ) != n_IDEC_STATE_CONSUMED
|| i
> 0x10FFFF/* XXX magic; CText */){
1169 n_err(_("\nInvalid input: %s\n"), buf
);
1175 tlp
->tl_vi_flags
|= a_TTY_VF_MOD_DIRTY
| (wc
== '\0' ? a_TTY_VF_BELL
: 0);
1181 a_tty_vi_refresh(struct a_tty_line
*tlp
){
1185 if(tlp
->tl_vi_flags
& a_TTY_VF_BELL
){
1186 tlp
->tl_vi_flags
|= a_TTY_VF_SYNC
;
1187 if(putc('\a', n_tty_fp
) == EOF
)
1191 if(tlp
->tl_vi_flags
& a_TTY_VF_REFRESH
){
1192 /* kht may want to restore a cursor position after inserting some
1194 if(tlp
->tl_defc_cursor_byte
> 0){
1198 a_tty_khome(tlp
, FAL0
);
1200 i
= tlp
->tl_defc_cursor_byte
;
1201 tlp
->tl_defc_cursor_byte
= 0;
1202 for(j
= 0; tlp
->tl_cursor
< tlp
->tl_count
; ++j
){
1204 if((k
= tlp
->tl_line
.cells
[j
].tc_count
) > i
)
1210 if(!a_tty_vi__paint(tlp
))
1214 if(tlp
->tl_vi_flags
& a_TTY_VF_SYNC
){
1215 tlp
->tl_vi_flags
&= ~a_TTY_VF_SYNC
;
1216 if(fflush(n_tty_fp
))
1222 tlp
->tl_vi_flags
&= ~a_TTY_VF_ALL_MASK
;
1227 clearerr(n_tty_fp
); /* xxx I/O layer rewrite */
1228 n_err(_("Visual refresh failed! Is $TERM set correctly?\n"
1229 " Setting *line-editor-disable* to get us through!\n"));
1230 ok_bset(line_editor_disable
);
1236 a_tty_vi__paint(struct a_tty_line
*tlp
){
1238 a_TRUE_RV
= a_TTY__VF_LAST
<<1, /* Return value bit */
1239 a_HAVE_PROMPT
= a_TTY__VF_LAST
<<2, /* Have a prompt */
1240 a_SHOW_PROMPT
= a_TTY__VF_LAST
<<3, /* Shall print the prompt */
1241 a_MOVE_CURSOR
= a_TTY__VF_LAST
<<4, /* Move visual cursor for user! */
1242 a_LEFT_MIN
= a_TTY__VF_LAST
<<5, /* On left boundary */
1243 a_RIGHT_MAX
= a_TTY__VF_LAST
<<6,
1244 a_HAVE_POSITION
= a_TTY__VF_LAST
<<7, /* Print the position indicator */
1246 /* We carry some flags over invocations (not worth a specific field) */
1247 a_VISIBLE_PROMPT
= a_TTY__VF_LAST
<<8, /* The prompt is on the screen */
1248 a_PERSIST_MASK
= a_VISIBLE_PROMPT
,
1249 a__LAST
= a_PERSIST_MASK
1252 ui32_t f
, w
, phy_wid_base
, phy_wid
, phy_base
, phy_cur
, cnt
,
1253 DBG(lstcur COMMA
) cur
,
1254 vi_left
, /*vi_right,*/ phy_nxtcur
;
1255 struct a_tty_cell
const *tccp
, *tcp_left
, *tcp_right
, *tcxp
;
1257 n_LCTA(UICMP(64, a__LAST
, <, UI32_MAX
), "Flag bits excess storage datatype");
1259 f
= tlp
->tl_vi_flags
;
1260 tlp
->tl_vi_flags
= (f
& ~(a_TTY_VF_REFRESH
| a_PERSIST_MASK
)) |
1263 if((w
= tlp
->tl_prompt_width
) > 0)
1265 f
|= a_HAVE_POSITION
;
1267 /* XXX We don't have a OnTerminalResize event (see main.c) yet, so we need
1268 * XXX to reevaluate our circumstances over and over again */
1269 /* Don't display prompt or position indicator on very small screens */
1270 if((phy_wid_base
= (ui32_t
)n_scrnwidth
) <= a_TTY_WIDTH_RIPOFF
)
1271 f
&= ~(a_HAVE_PROMPT
| a_HAVE_POSITION
);
1273 phy_wid_base
-= a_TTY_WIDTH_RIPOFF
;
1275 /* Disable the prompt if the screen is too small; due to lack of some
1276 * indicator simply add a second ripoff */
1277 if((f
& a_HAVE_PROMPT
) && w
+ a_TTY_WIDTH_RIPOFF
>= phy_wid_base
)
1278 f
&= ~a_HAVE_PROMPT
;
1281 phy_wid
= phy_wid_base
;
1283 phy_cur
= tlp
->tl_phy_cursor
;
1284 cnt
= tlp
->tl_count
;
1285 DBG( lstcur
= tlp
->tl_lst_cursor
; )
1287 /* XXX Assume dirty screen if shrunk */
1288 if(cnt
< tlp
->tl_lst_count
)
1289 f
|= a_TTY_VF_MOD_DIRTY
;
1291 /* TODO Without HAVE_TERMCAP, it would likely be much cheaper to simply
1292 * TODO always "cr + paint + ce + ch", since ce is simulated via spaces.. */
1294 /* Quickshot: if the line is empty, possibly print prompt and out */
1296 /* In that special case dirty anything if it seems better */
1297 if((f
& a_TTY_VF_MOD_CONTENT
) || tlp
->tl_lst_count
> 0)
1298 f
|= a_TTY_VF_MOD_DIRTY
;
1300 if((f
& a_TTY_VF_MOD_DIRTY
) && phy_cur
!= 0){
1301 if(!n_termcap_cmdx(n_TERMCAP_CMD_cr
))
1306 if((f
& (a_TTY_VF_MOD_DIRTY
| a_HAVE_PROMPT
)) ==
1307 (a_TTY_VF_MOD_DIRTY
| a_HAVE_PROMPT
)){
1308 if(fputs(tlp
->tl_prompt
, n_tty_fp
) == EOF
)
1310 phy_cur
= tlp
->tl_prompt_width
+ 1;
1313 /* May need to clear former line content */
1314 if((f
& a_TTY_VF_MOD_DIRTY
) &&
1315 !n_termcap_cmd(n_TERMCAP_CMD_ce
, phy_cur
, -1))
1318 tlp
->tl_phy_start
= tlp
->tl_line
.cells
;
1322 /* Try to get an idea of the visual window */
1324 /* Find the left visual boundary */
1325 phy_wid
= (phy_wid
>> 1) + (phy_wid
>> 2);
1326 if((cur
= tlp
->tl_cursor
) == cnt
)
1329 w
= (tcp_left
= tccp
= tlp
->tl_line
.cells
+ cur
)->tc_width
;
1330 if(w
== UI8_MAX
) /* TODO yet TAB == SPC */
1332 while(tcp_left
> tlp
->tl_line
.cells
){
1333 ui16_t cw
= tcp_left
[-1].tc_width
;
1335 if(cw
== UI8_MAX
) /* TODO yet TAB == SPC */
1337 if(w
+ cw
>= phy_wid
)
1344 /* If the left hand side of our visual viewpoint consumes less than half
1345 * of the screen width, show the prompt */
1346 if(tcp_left
== tlp
->tl_line
.cells
)
1349 if((f
& (a_LEFT_MIN
| a_HAVE_PROMPT
)) == (a_LEFT_MIN
| a_HAVE_PROMPT
) &&
1350 w
+ tlp
->tl_prompt_width
< phy_wid
){
1351 phy_base
= tlp
->tl_prompt_width
;
1355 /* Then search for right boundary. We always leave the rightmost column
1356 * empty because some terminals [cw]ould wrap the line if we write into
1357 * that. XXX terminfo(5)/termcap(5) have the semi_auto_right_margin/sam/YE
1358 * XXX capability to indicate this, but we don't look at that */
1359 phy_wid
= phy_wid_base
- phy_base
;
1360 tcp_right
= tlp
->tl_line
.cells
+ cnt
;
1362 while(&tccp
[1] < tcp_right
){
1363 ui16_t cw
= tccp
[1].tc_width
;
1366 if(cw
== UI8_MAX
) /* TODO yet TAB == SPC */
1374 /*vi_right = w - vi_left;*/
1376 /* If the complete line including prompt fits on the screen, show prompt */
1377 if(--tcp_right
== tccp
){
1380 /* Since we did brute-force walk also for the left boundary we may end up
1381 * in a situation were anything effectively fits on the screen, including
1382 * the prompt that is, but were we don't recognize this since we
1383 * restricted the search to fit in some visual viewpoint. Therefore try
1384 * again to extend the left boundary to overcome that */
1385 if(!(f
& a_LEFT_MIN
)){
1386 struct a_tty_cell
const *tc1p
= tlp
->tl_line
.cells
;
1387 ui32_t vil1
= vi_left
;
1389 assert(!(f
& a_SHOW_PROMPT
));
1390 w
+= tlp
->tl_prompt_width
;
1391 for(tcxp
= tcp_left
;;){
1392 ui32_t i
= tcxp
[-1].tc_width
;
1394 if(i
== UI8_MAX
) /* TODO yet TAB == SPC */
1408 /*w -= tlp->tl_prompt_width;*/
1412 tccp
= tlp
->tl_line
.cells
+ cur
;
1414 if((f
& (a_LEFT_MIN
| a_RIGHT_MAX
| a_HAVE_PROMPT
| a_SHOW_PROMPT
)) ==
1415 (a_LEFT_MIN
| a_RIGHT_MAX
| a_HAVE_PROMPT
) &&
1416 w
+ tlp
->tl_prompt_width
<= phy_wid
){
1417 phy_wid
-= (phy_base
= tlp
->tl_prompt_width
);
1421 /* Try to avoid repainting the complete line - this is possible if the
1422 * cursor "did not leave the screen" and the prompt status hasn't changed.
1423 * I.e., after clamping virtual viewpoint, compare relation to physical */
1424 if((f
& (a_TTY_VF_MOD_SINGLE
/*FIXME*/ |
1425 a_TTY_VF_MOD_CONTENT
/* xxx */ | a_TTY_VF_MOD_DIRTY
)) ||
1426 (tcxp
= tlp
->tl_phy_start
) == NULL
||
1427 tcxp
> tccp
|| tcxp
<= tcp_right
)
1428 f
|= a_TTY_VF_MOD_DIRTY
;
1430 f
|= a_TTY_VF_MOD_DIRTY
;
1432 struct a_tty_cell
const *tcyp
;
1433 si32_t cur_displace
;
1434 ui32_t phy_lmargin
, phy_rmargin
, fx
, phy_displace
;
1436 phy_lmargin
= (fx
= phy_wid
) / 100;
1437 phy_rmargin
= fx
- (phy_lmargin
* a_TTY_SCROLL_MARGIN_RIGHT
);
1438 phy_lmargin
*= a_TTY_SCROLL_MARGIN_LEFT
;
1439 fx
= (f
& (a_SHOW_PROMPT
| a_VISIBLE_PROMPT
));
1441 if(fx
== 0 || fx
== (a_SHOW_PROMPT
| a_VISIBLE_PROMPT
)){
1447 /* We know what we have to paint, start synchronizing */
1449 assert(phy_cur
== tlp
->tl_phy_cursor
);
1450 assert(phy_wid
== phy_wid_base
- phy_base
);
1451 assert(cnt
== tlp
->tl_count
);
1453 assert(lstcur
== tlp
->tl_lst_cursor
);
1454 assert(tccp
== tlp
->tl_line
.cells
+ cur
);
1456 phy_nxtcur
= phy_base
; /* FIXME only if repaint cpl. */
1458 /* Quickshot: is it only cursor movement within the visible screen? */
1459 if((f
& a_TTY_VF_REFRESH
) == a_TTY_VF_MOD_CURSOR
){
1464 /* To be able to apply some quick jump offs, clear line if possible */
1465 if(f
& a_TTY_VF_MOD_DIRTY
){
1466 /* Force complete clearance and cursor reinitialization */
1467 if(!n_termcap_cmdx(n_TERMCAP_CMD_cr
) ||
1468 !n_termcap_cmd(n_TERMCAP_CMD_ce
, 0, -1))
1470 tlp
->tl_phy_start
= tcp_left
;
1474 if((f
& (a_TTY_VF_MOD_DIRTY
| a_SHOW_PROMPT
)) && phy_cur
!= 0){
1475 if(!n_termcap_cmdx(n_TERMCAP_CMD_cr
))
1480 if(f
& a_SHOW_PROMPT
){
1481 assert(phy_base
== tlp
->tl_prompt_width
);
1482 if(fputs(tlp
->tl_prompt
, n_tty_fp
) == EOF
)
1484 phy_cur
= phy_nxtcur
;
1485 f
|= a_VISIBLE_PROMPT
;
1487 f
&= ~a_VISIBLE_PROMPT
;
1489 /* FIXME reposition cursor for paint */
1490 for(w
= phy_nxtcur
; tcp_left
<= tcp_right
; ++tcp_left
){
1493 cw
= tcp_left
->tc_width
;
1495 if(n_LIKELY(!tcp_left
->tc_novis
)){
1496 if(fwrite(tcp_left
->tc_cbuf
, sizeof *tcp_left
->tc_cbuf
,
1497 tcp_left
->tc_count
, n_tty_fp
) != tcp_left
->tc_count
)
1499 }else{ /* XXX Shouldn't be here <-> CText, ui_str.c */
1500 char wbuf
[8]; /* XXX magic */
1502 if(n_psonce
& n_PSO_UNICODE
){
1505 wc
= (ui32_t
)tcp_left
->tc_wc
;
1506 if((wc
& ~0x1Fu
) == 0)
1512 n_utf32_to_utf8(wc
, wbuf
);
1514 wbuf
[0] = '?', wbuf
[1] = '\0';
1516 if(fputs(wbuf
, n_tty_fp
) == EOF
)
1521 if(cw
== UI8_MAX
) /* TODO yet TAB == SPC */
1524 if(tcp_left
== tccp
)
1529 /* Write something position marker alike if it doesn't fit on screen */
1530 if((f
& a_HAVE_POSITION
) &&
1531 ((f
& (a_LEFT_MIN
| a_RIGHT_MAX
)) != (a_LEFT_MIN
| a_RIGHT_MAX
) ||
1532 ((f
& a_HAVE_PROMPT
) && !(f
& a_SHOW_PROMPT
)))){
1534 char *posbuf
= tlp
->tl_pos_buf
, *pos
= tlp
->tl_pos
;
1536 char posbuf
[5], *pos
= posbuf
;
1541 if(phy_cur
!= (w
= phy_wid_base
) &&
1542 !n_termcap_cmd(n_TERMCAP_CMD_ch
, phy_cur
= w
, 0))
1546 if((f
& a_LEFT_MIN
) && (!(f
& a_HAVE_PROMPT
) || (f
& a_SHOW_PROMPT
)))
1547 memcpy(pos
, "^.+", 3);
1548 else if(f
& a_RIGHT_MAX
)
1549 memcpy(pos
, ".+$", 3);
1551 /* Theoretical line length limit a_TTY_LINE_MAX, choose next power of
1552 * ten (10 ** 10) to represent 100 percent, since we don't have a macro
1553 * that generates a constant, and i don't trust the standard "u type
1554 * suffix automatically scales" calculate the large number */
1555 static char const itoa
[] = "0123456789";
1557 ui64_t
const fact100
= (ui64_t
)0x3B9ACA00u
* 10u, fact
= fact100
/ 100;
1558 ui32_t i
= (ui32_t
)(((fact100
/ cnt
) * tlp
->tl_cursor
) / fact
);
1559 n_LCTA(a_TTY_LINE_MAX
<= SI32_MAX
, "a_TTY_LINE_MAX too large");
1562 pos
[0] = ' ', pos
[1] = itoa
[i
];
1564 pos
[1] = itoa
[i
% 10], pos
[0] = itoa
[i
/ 10];
1568 if(fputs(posbuf
, n_tty_fp
) == EOF
)
1573 /* Users are used to see the cursor right of the point of interest, so we
1574 * need some further adjustments unless in special conditions. Be aware
1575 * that we may have adjusted cur at the beginning, too */
1576 if((cur
= tlp
->tl_cursor
) == 0)
1577 phy_nxtcur
= phy_base
;
1578 else if(cur
!= cnt
){
1579 ui16_t cw
= tccp
->tc_width
;
1581 if(cw
== UI8_MAX
) /* TODO yet TAB == SPC */
1587 if(((f
& a_MOVE_CURSOR
) || phy_nxtcur
!= phy_cur
) &&
1588 !n_termcap_cmd(n_TERMCAP_CMD_ch
, phy_cur
= phy_nxtcur
, 0))
1592 tlp
->tl_vi_flags
|= (f
& a_PERSIST_MASK
);
1593 tlp
->tl_lst_count
= tlp
->tl_count
;
1594 tlp
->tl_lst_cursor
= tlp
->tl_cursor
;
1595 tlp
->tl_phy_cursor
= phy_cur
;
1598 return ((f
& a_TRUE_RV
) != 0);
1605 a_tty_wboundary(struct a_tty_line
*tlp
, si32_t dir
){/* TODO shell token-wise */
1607 struct a_tty_cell
*tcap
;
1612 assert(dir
== 1 || dir
== -1);
1615 cnt
= tlp
->tl_count
;
1616 cur
= tlp
->tl_cursor
;
1621 }else if(cur
+ 1 >= cnt
)
1624 --cnt
, --cur
; /* xxx Unsigned wrapping may occur (twice), then */
1626 for(rv
= 0, tcap
= tlp
->tl_line
.cells
, anynon
= FAL0
;;){
1629 wc
= tcap
[cur
+= (ui32_t
)dir
].tc_wc
;
1630 if(iswblank(wc
) || iswpunct(wc
)){
1641 }else if(cur
+ 1 >= cnt
){
1652 a_tty_khome(struct a_tty_line
*tlp
, bool_t dobell
){
1656 if(n_LIKELY(tlp
->tl_cursor
> 0)){
1658 f
= a_TTY_VF_MOD_CURSOR
;
1664 tlp
->tl_vi_flags
|= f
;
1669 a_tty_kend(struct a_tty_line
*tlp
){
1673 if(n_LIKELY(tlp
->tl_cursor
< tlp
->tl_count
)){
1674 tlp
->tl_cursor
= tlp
->tl_count
;
1675 f
= a_TTY_VF_MOD_CURSOR
;
1679 tlp
->tl_vi_flags
|= f
;
1684 a_tty_kbs(struct a_tty_line
*tlp
){
1688 cur
= tlp
->tl_cursor
;
1689 cnt
= tlp
->tl_count
;
1691 if(n_LIKELY(cur
> 0)){
1692 tlp
->tl_cursor
= --cur
;
1693 tlp
->tl_count
= --cnt
;
1695 if((cnt
-= cur
) > 0){
1696 struct a_tty_cell
*tcap
;
1698 tcap
= tlp
->tl_line
.cells
+ cur
;
1699 memmove(tcap
, &tcap
[1], cnt
*= sizeof(*tcap
));
1701 f
= a_TTY_VF_MOD_CURSOR
| a_TTY_VF_MOD_CONTENT
;
1705 tlp
->tl_vi_flags
|= f
;
1710 a_tty_ksnarf(struct a_tty_line
*tlp
, bool_t cplline
, bool_t dobell
){
1717 if(cplline
&& i
> 0){
1718 tlp
->tl_cursor
= i
= 0;
1719 f
= a_TTY_VF_MOD_CURSOR
;
1722 if(n_LIKELY(i
< tlp
->tl_count
)){
1723 struct a_tty_cell
*tcap
;
1725 tcap
= &tlp
->tl_line
.cells
[0];
1726 a_tty_copy2paste(tlp
, &tcap
[i
], &tcap
[tlp
->tl_count
]);
1728 f
= a_TTY_VF_MOD_CONTENT
;
1732 tlp
->tl_vi_flags
|= f
;
1737 a_tty_kdel(struct a_tty_line
*tlp
){
1742 cur
= tlp
->tl_cursor
;
1743 cnt
= tlp
->tl_count
;
1744 i
= (si32_t
)(cnt
- cur
);
1746 if(n_LIKELY(i
> 0)){
1747 tlp
->tl_count
= --cnt
;
1749 if(n_LIKELY(--i
> 0)){
1750 struct a_tty_cell
*tcap
;
1752 tcap
= &tlp
->tl_line
.cells
[cur
];
1753 memmove(tcap
, &tcap
[1], (ui32_t
)i
* sizeof(*tcap
));
1755 f
= a_TTY_VF_MOD_CONTENT
;
1756 }else if(cnt
== 0 && !ok_blook(ignoreeof
)){
1757 putc('^', n_tty_fp
);
1758 putc('D', n_tty_fp
);
1766 tlp
->tl_vi_flags
|= f
;
1772 a_tty_kleft(struct a_tty_line
*tlp
){
1776 if(n_LIKELY(tlp
->tl_cursor
> 0)){
1778 f
= a_TTY_VF_MOD_CURSOR
;
1782 tlp
->tl_vi_flags
|= f
;
1787 a_tty_kright(struct a_tty_line
*tlp
){
1791 if(n_LIKELY((i
= tlp
->tl_cursor
+ 1) <= tlp
->tl_count
)){
1793 i
= a_TTY_VF_MOD_CURSOR
;
1797 tlp
->tl_vi_flags
|= i
;
1802 a_tty_ksnarfw(struct a_tty_line
*tlp
, bool_t fwd
){
1803 struct a_tty_cell
*tcap
;
1808 if(n_UNLIKELY((i
= a_tty_wboundary(tlp
, (fwd
? +1 : -1))) <= 0)){
1809 f
= (i
< 0) ? a_TTY_VF_BELL
: a_TTY_VF_NONE
;
1813 cnt
= tlp
->tl_count
- (ui32_t
)i
;
1814 cur
= tlp
->tl_cursor
;
1817 tcap
= &tlp
->tl_line
.cells
[cur
];
1819 a_tty_copy2paste(tlp
, &tcap
[0], &tcap
[i
]);
1821 if((tlp
->tl_count
= cnt
) != (tlp
->tl_cursor
= cur
)){
1823 memmove(&tcap
[0], &tcap
[i
], cnt
* sizeof(*tcap
)); /* FIXME*/
1826 f
= a_TTY_VF_MOD_CURSOR
| a_TTY_VF_MOD_CONTENT
;
1828 tlp
->tl_vi_flags
|= f
;
1833 a_tty_kgow(struct a_tty_line
*tlp
, si32_t dir
){
1838 if(n_UNLIKELY((i
= a_tty_wboundary(tlp
, dir
)) <= 0))
1839 f
= (i
< 0) ? a_TTY_VF_BELL
: a_TTY_VF_NONE
;
1843 tlp
->tl_cursor
+= (ui32_t
)i
;
1844 f
= a_TTY_VF_MOD_CURSOR
;
1847 tlp
->tl_vi_flags
|= f
;
1852 a_tty_kother(struct a_tty_line
*tlp
, wchar_t wc
){
1853 /* Append if at EOL, insert otherwise;
1854 * since we may move around character-wise, always use a fresh ps */
1856 struct a_tty_cell tc
, *tcap
;
1864 n_LCTA(a_TTY_LINE_MAX
<= SI32_MAX
, "a_TTY_LINE_MAX too large");
1865 if(tlp
->tl_count
+ 1 >= a_TTY_LINE_MAX
){
1866 n_err(_("Stop here, we can't extend line beyond size limit\n"));
1870 /* First init a cell and see whether we'll really handle this wc */
1871 memset(&ps
, 0, sizeof ps
);
1875 l
= wcrtomb(tc
.tc_cbuf
, tc
.tc_wc
= wc
, &ps
);
1876 if(n_UNLIKELY(l
> MB_LEN_MAX
)){
1878 n_err(_("wcrtomb(3) error: too many multibyte character bytes\n"));
1881 tc
.tc_count
= (ui16_t
)l
;
1883 if(n_UNLIKELY((n_psonce
& n_PSO_ENC_MBSTATE
) != 0)){
1884 l
= wcrtomb(&tc
.tc_cbuf
[l
], L
'\0', &ps
);
1885 if(n_LIKELY(l
== 1))
1886 /* Only NUL terminator */;
1887 else if(n_LIKELY(--l
< MB_LEN_MAX
))
1888 tc
.tc_count
+= (ui16_t
)l
;
1894 /* Yes, we will! Place it in the array */
1895 tc
.tc_novis
= (iswprint(wc
) == 0);
1896 tc
.tc_width
= a_tty_wcwidth(wc
);
1897 /* TODO if(tc.tc_novis && tc.tc_width > 0) */
1899 cur
= tlp
->tl_cursor
++;
1900 cnt
= tlp
->tl_count
++ - cur
;
1901 tcap
= &tlp
->tl_line
.cells
[cur
];
1903 memmove(&tcap
[1], tcap
, cnt
* sizeof(*tcap
));
1904 f
= a_TTY_VF_MOD_CONTENT
;
1906 f
= a_TTY_VF_MOD_SINGLE
;
1907 memcpy(tcap
, &tc
, sizeof *tcap
);
1909 f
|= a_TTY_VF_MOD_CURSOR
;
1914 tlp
->tl_vi_flags
|= f
;
1920 a_tty_kht(struct a_tty_line
*tlp
){
1921 ui8_t (*autorecmem
)[n_MEMORY_AUTOREC_TYPE_SIZEOF
], *autorec_persist
;
1923 struct str orig
, bot
, topp
, sub
, exp
, preexp
;
1924 struct n_string shou
, *shoup
;
1925 struct a_tty_cell
*cword
, *ctop
, *cx
;
1926 bool_t wedid
, set_savec
;
1930 /* Get plain line data; if this is the first expansion/xy, update the
1931 * very original content so that ^G gets the origin back */
1932 orig
= tlp
->tl_savec
;
1933 a_tty_cell2save(tlp
);
1934 exp
= tlp
->tl_savec
;
1936 /*tlp->tl_savec = orig;*/
1942 autorec_persist
= n_memory_autorec_current();
1943 n_memory_autorec_push(autorecmem
= n_lofi_alloc(sizeof *autorecmem
));
1945 shoup
= n_string_creat_auto(&shou
);
1948 /* Find the word to be expanded */
1950 cword
= tlp
->tl_line
.cells
;
1951 ctop
= cword
+ tlp
->tl_cursor
;
1952 cx
= cword
+ tlp
->tl_count
;
1954 /* topp: separate data right of cursor */
1956 for(rv
= 0; ctop
< cx
; ++ctop
)
1957 rv
+= ctop
->tc_count
;
1959 topp
.s
= orig
.s
+ orig
.l
- rv
;
1960 ctop
= cword
+ tlp
->tl_cursor
;
1962 topp
.s
= NULL
, topp
.l
= 0;
1964 /* Find the shell token that corresponds to the cursor position */
1970 for(; cword
< ctop
; ++cword
)
1971 max
+= cword
->tc_count
;
1972 cword
= tlp
->tl_line
.cells
;
1980 enum n_shexp_state shs
;
1983 shs
= n_shexp_parse_token(NULL
, &sub
, n_SHEXP_PARSE_DRYRUN
|
1984 n_SHEXP_PARSE_TRIMSPACE
| n_SHEXP_PARSE_IGNORE_EMPTY
|
1985 n_SHEXP_PARSE_QUOTE_AUTO_CLOSE
);
1989 assert(max
>= sub
.l
);
1995 if(shs
& n_SHEXP_STATE_ERR_MASK
){
1996 n_err(_("Invalid completion pattern: %.*s\n"),
2000 n_shexp_parse_token(shoup
, &exp
,
2001 n_SHEXP_PARSE_TRIMSPACE
| n_SHEXP_PARSE_IGNORE_EMPTY
|
2002 n_SHEXP_PARSE_QUOTE_AUTO_CLOSE
);
2006 sub
.s
= n_string_cp(shoup
);
2007 sub
.l
= shoup
->s_len
;
2011 /* Leave room for "implicit asterisk" expansion, as below */
2014 sub
.s
= n_UNCONST("*");
2018 preexp
.s
= n_UNCONST(n_empty
);
2022 /* TODO Super-Heavy-Metal: block all sigs, avoid leaks on jump */
2024 exp
.s
= fexpand(sub
.s
, a_TTY_TAB_FEXP_FL
);
2027 if(exp
.s
== NULL
|| (exp
.l
= strlen(exp
.s
)) == 0){
2028 /* No. But maybe the users' desire was to complete only a part of the
2029 * shell token of interest! TODO This can be improved, we would need to
2030 * TODO have shexp_parse to create a DOM structure of parsed snippets, so
2031 * TODO that we can tell for each snippet which quote is active and
2032 * TODO whether we may cross its boundary and/or apply expansion for it */
2037 for(li
= UIZ_MAX
, i
= sub
.l
; i
-- > 0;){
2040 if((c
= sub
.s
[i
]) == '/' || c
== '+' /* *folder*! */)
2042 /* Do stop once some "magic" characters are seen XXX magic set */
2043 else if(c
== '<' || c
== '>' || c
== '=' || c
== ':')
2057 if(wedid
== TRUM1
&& preexp
.l
> 0)
2058 preexp
.s
= savestrbuf(preexp
.s
, preexp
.l
);
2060 /* May be multi-return! */
2061 if(n_pstate
& n_PS_EXPAND_MULTIRESULT
)
2064 /* xxx That is not really true since the limit counts characters not bytes */
2065 n_LCTA(a_TTY_LINE_MAX
<= SI32_MAX
, "a_TTY_LINE_MAX too large");
2066 if(exp
.l
>= a_TTY_LINE_MAX
- 1 || a_TTY_LINE_MAX
- 1 - exp
.l
< preexp
.l
){
2067 n_err(_("Tabulator expansion would extend beyond line size limit\n"));
2071 /* If the expansion equals the original string, assume the user wants what
2072 * is usually known as tab completion, append `*' and restart */
2073 if(!wedid
&& exp
.l
== sub
.l
&& !memcmp(exp
.s
, sub
.s
, exp
.l
)){
2074 if(sub
.s
[sub
.l
- 1] == '*')
2078 shoup
= n_string_push_c(shoup
, '*');
2079 sub
.s
= n_string_cp(shoup
);
2080 sub
.l
= shoup
->s_len
;
2084 /* If it is a directory, and there is not yet a / appended, then we want the
2085 * user to confirm that he wants to dive in -- with only a HT */
2086 if(wedid
&& exp
.l
== --sub
.l
&& !memcmp(exp
.s
, sub
.s
, exp
.l
) &&
2087 exp
.s
[exp
.l
- 1] != '/'){
2088 if(stat(exp
.s
, &sb
) || !S_ISDIR(sb
.st_mode
))
2090 sub
.s
= salloc(exp
.l
+ 1 +1);
2091 memcpy(sub
.s
, exp
.s
, exp
.l
);
2092 sub
.s
[exp
.l
++] = '/';
2093 sub
.s
[exp
.l
] = '\0';
2098 if(wedid
&& (wedid
= (exp
.s
[exp
.l
- 1] == '*')))
2100 exp
.s
[exp
.l
] = '\0';
2102 exp
.l
= strlen(exp
.s
= n_shexp_quote_cp(exp
.s
, tlp
->tl_quote_rndtrip
));
2103 tlp
->tl_defc_cursor_byte
= bot
.l
+ preexp
.l
+ exp
.l
-1;
2108 orig
.l
= bot
.l
+ preexp
.l
+ exp
.l
+ topp
.l
;
2109 orig
.s
= n_autorec_alloc(autorec_persist
, orig
.l
+ 5 +1);
2110 if((rv
= (ui32_t
)bot
.l
) > 0)
2111 memcpy(orig
.s
, bot
.s
, rv
);
2113 memcpy(&orig
.s
[rv
], preexp
.s
, preexp
.l
);
2116 memcpy(&orig
.s
[rv
], exp
.s
, exp
.l
);
2119 memcpy(&orig
.s
[rv
], topp
.s
, topp
.l
);
2124 tlp
->tl_defc
= orig
;
2125 tlp
->tl_count
= tlp
->tl_cursor
= 0;
2126 f
|= a_TTY_VF_MOD_DIRTY
;
2128 n_memory_autorec_pop(autorecmem
);
2129 n_lofi_free(autorecmem
);
2130 tlp
->tl_vi_flags
|= f
;
2135 struct n_visual_info_ctx vic
;
2140 size_t locolen
, scrwid
, lnlen
, lncnt
, prefixlen
;
2143 if((fp
= Ftmp(NULL
, "tabex", OF_RDWR
| OF_UNLINK
| OF_REGISTER
)) == NULL
){
2144 n_perr(_("tmpfile"), 0);
2148 /* How long is the result string for real? Search the NUL NUL
2149 * terminator. While here, detect the longest entry to perform an
2150 * initial allocation of our accumulator string */
2155 i
= strlen(&exp
.s
[++exp
.l
]);
2156 locolen
= n_MAX(locolen
, i
);
2158 }while(exp
.s
[exp
.l
+ 1] != '\0');
2160 shoup
= n_string_reserve(n_string_trunc(shoup
, 0),
2161 locolen
+ (locolen
>> 1));
2163 /* Iterate (once again) over all results */
2164 scrwid
= (size_t)n_scrnwidth
- ((size_t)n_scrnwidth
>> 3);
2166 n_UNINIT(prefixlen
, 0);
2167 n_UNINIT(lococp
, NULL
);
2169 for(isfirst
= TRU1
; exp
.l
> 0; isfirst
= FAL0
, c1
= c2
){
2171 char const *fullpath
;
2175 sub
.l
= i
= strlen(sub
.s
);
2177 if((exp
.l
-= i
) > 0)
2181 /* Separate dirname and basename */
2186 if((cp
= strrchr(fullpath
, '/')) != NULL
)
2187 prefixlen
= PTR2SIZE(++cp
- fullpath
);
2191 if(prefixlen
> 0 && prefixlen
< sub
.l
){
2196 /* We want case-insensitive sort-order */
2197 memset(&vic
, 0, sizeof vic
);
2198 vic
.vic_indat
= sub
.s
;
2199 vic
.vic_inlen
= sub
.l
;
2200 c2
= n_visual_info(&vic
, n_VISUAL_INFO_ONE_CHAR
) ? vic
.vic_waccu
2202 #ifdef HAVE_C90AMEND1
2208 /* Query longest common prefix along the way */
2213 }else if(locolen
> 0){
2214 for(i
= 0; i
< locolen
; ++i
)
2215 if(lococp
[i
] != sub
.s
[i
]){
2216 i
= field_detect_clip(i
, lococp
, i
);
2222 /* Prepare display */
2224 shoup
= n_shexp_quote(n_string_trunc(shoup
, 0), &input
,
2225 tlp
->tl_quote_rndtrip
);
2226 memset(&vic
, 0, sizeof vic
);
2227 vic
.vic_indat
= shoup
->s_dat
;
2228 vic
.vic_inlen
= shoup
->s_len
;
2229 if(!n_visual_info(&vic
,
2230 n_VISUAL_INFO_SKIP_ERRORS
| n_VISUAL_INFO_WIDTH_QUERY
))
2231 vic
.vic_vi_width
= shoup
->s_len
;
2233 /* Put on screen. Indent follow lines of same sort slot */
2236 scrwid
< lnlen
|| scrwid
- lnlen
<= vic
.vic_vi_width
+ 2){
2243 }else if(lnlen
> 0){
2248 fputs(n_string_cp(shoup
), fp
);
2249 lnlen
+= vic
.vic_vi_width
;
2251 /* Support the known file name tagging
2252 * XXX *line-editor-completion-filetype* or so */
2253 if(!lstat(fullpath
, &sb
)){
2256 if(S_ISDIR(sb
.st_mode
))
2258 else if(S_ISLNK(sb
.st_mode
))
2261 else if(S_ISFIFO(sb
.st_mode
))
2265 else if(S_ISSOCK(sb
.st_mode
))
2269 else if(S_ISCHR(sb
.st_mode
))
2273 else if(S_ISBLK(sb
.st_mode
))
2286 page_or_print(fp
, lncnt
);
2290 n_string_gut(shoup
);
2292 /* A common prefix of 0 means we cannot provide the user any auto
2293 * completed characters */
2297 /* Otherwise we can, so extend the visual line content by the common
2298 * prefix (in a reversible way) */
2299 (exp
.s
= n_UNCONST(lococp
))[locolen
] = '\0';
2301 exp
.l
= (locolen
+= prefixlen
);
2303 /* XXX Indicate that there is multiple choice */
2304 /* XXX f |= a_TTY_VF_BELL; -> *line-editor-completion-bell*? or so */
2310 /* If we've provided a default content, but failed to expand, there is
2311 * nothing we can "revert to": drop that default again */
2313 tlp
->tl_savec
.s
= NULL
;
2314 tlp
->tl_savec
.l
= 0;
2321 # ifdef HAVE_HISTORY
2323 a_tty__khist_shared(struct a_tty_line
*tlp
, struct a_tty_hist
*thp
){
2327 if(n_LIKELY((tlp
->tl_hist
= thp
) != NULL
)){
2328 tlp
->tl_defc
.s
= savestrbuf(thp
->th_dat
, thp
->th_len
);
2329 rv
= tlp
->tl_defc
.l
= thp
->th_len
;
2330 f
= (tlp
->tl_count
> 0) ? a_TTY_VF_MOD_DIRTY
: a_TTY_VF_NONE
;
2331 tlp
->tl_count
= tlp
->tl_cursor
= 0;
2337 tlp
->tl_vi_flags
|= f
;
2343 a_tty_khist(struct a_tty_line
*tlp
, bool_t fwd
){
2344 struct a_tty_hist
*thp
;
2348 /* If we're not in history mode yet, save line content;
2349 * also, disallow forward search, then, and, of course, bail unless we
2350 * do have any history at all */
2351 if((thp
= tlp
->tl_hist
) == NULL
){
2354 if((thp
= a_tty
.tg_hist
) == NULL
)
2356 a_tty_cell2save(tlp
);
2360 thp
= fwd
? thp
->th_younger
: thp
->th_older
;
2362 rv
= a_tty__khist_shared(tlp
, thp
);
2368 a_tty_khist_search(struct a_tty_line
*tlp
, bool_t fwd
){
2369 struct str orig_savec
;
2370 struct a_tty_hist
*thp
;
2376 /* We cannot complete an empty line */
2377 if(n_UNLIKELY(tlp
->tl_count
== 0)){
2378 /* XXX The upcoming hard reset would restore a set savec buffer,
2379 * XXX so forcefully reset that. A cleaner solution would be to
2380 * XXX reset it whenever a restore is no longer desired */
2381 tlp
->tl_savec
.s
= NULL
;
2382 tlp
->tl_savec
.l
= 0;
2386 if((thp
= tlp
->tl_hist
) == NULL
){
2387 if((thp
= a_tty
.tg_hist
) == NULL
)
2389 /* We don't support wraparound, searching forward must always step */
2391 thp
= thp
->th_younger
;
2392 orig_savec
.s
= NULL
;
2393 orig_savec
.l
= 0; /* silence CC */
2394 }else if((thp
= (fwd
? thp
->th_younger
: thp
->th_older
)) == NULL
)
2397 orig_savec
= tlp
->tl_savec
;
2399 if(orig_savec
.s
== NULL
)
2400 a_tty_cell2save(tlp
);
2402 for(; thp
!= NULL
; thp
= (fwd
? thp
->th_younger
: thp
->th_older
))
2403 if(is_prefix(tlp
->tl_savec
.s
, thp
->th_dat
))
2406 if(orig_savec
.s
!= NULL
)
2407 tlp
->tl_savec
= orig_savec
;
2409 rv
= a_tty__khist_shared(tlp
, thp
);
2413 # endif /* HAVE_HISTORY */
2415 static enum a_tty_fun_status
2416 a_tty_fun(struct a_tty_line
*tlp
, enum a_tty_bind_flags tbf
, size_t *len
){
2417 enum a_tty_fun_status rv
;
2420 rv
= a_TTY_FUN_STATUS_OK
;
2422 # define a_X(N) a_TTY_BIND_FUN_REDUCE(a_TTY_BIND_FUN_ ## N)
2423 switch(a_TTY_BIND_FUN_REDUCE(tbf
)){
2425 tlp
->tl_vi_flags
|= a_TTY_VF_BELL
;
2433 case a_X(GO_WORD_BWD
):
2434 a_tty_kgow(tlp
, -1);
2436 case a_X(GO_WORD_FWD
):
2437 a_tty_kgow(tlp
, +1);
2440 a_tty_khome(tlp
, TRU1
);
2449 if(a_tty_kdel(tlp
) < 0)
2450 rv
= a_TTY_FUN_STATUS_END
;
2452 case a_X(SNARF_WORD_BWD
):
2453 a_tty_ksnarfw(tlp
, FAL0
);
2455 case a_X(SNARF_WORD_FWD
):
2456 a_tty_ksnarfw(tlp
, TRU1
);
2458 case a_X(SNARF_END
):
2459 a_tty_ksnarf(tlp
, FAL0
, TRU1
);
2461 case a_X(SNARF_LINE
):
2462 a_tty_ksnarf(tlp
, TRU1
, (tlp
->tl_count
== 0));
2466 # ifdef HAVE_HISTORY
2467 if(tlp
->tl_hist
!= NULL
){
2468 bool_t isfwd
= TRU1
;
2474 # ifdef HAVE_HISTORY
2477 if((*len
= a_tty_khist(tlp
, isfwd
)) != UI32_MAX
){
2478 rv
= a_TTY_FUN_STATUS_RESTART
;
2484 tlp
->tl_vi_flags
|= a_TTY_VF_BELL
;
2487 case a_X(HIST_SRCH_FWD
):{
2488 # ifdef HAVE_HISTORY
2489 bool_t isfwd
= TRU1
;
2494 case a_X(HIST_SRCH_BWD
):
2495 # ifdef HAVE_HISTORY
2498 if((*len
= a_tty_khist_search(tlp
, isfwd
)) != UI32_MAX
){
2499 rv
= a_TTY_FUN_STATUS_RESTART
;
2504 tlp
->tl_vi_flags
|= a_TTY_VF_BELL
;
2509 tlp
->tl_vi_flags
|= a_TTY_VF_MOD_DIRTY
;
2511 case a_X(QUOTE_RNDTRIP
):
2512 tlp
->tl_quote_rndtrip
= !tlp
->tl_quote_rndtrip
;
2514 case a_X(PROMPT_CHAR
):{
2517 if((wc
= a_tty_vinuni(tlp
)) > 0)
2518 a_tty_kother(tlp
, wc
);
2521 if((*len
= a_tty_kht(tlp
)) > 0)
2522 rv
= a_TTY_FUN_STATUS_RESTART
;
2526 if(tlp
->tl_pastebuf
.l
> 0)
2527 *len
= (tlp
->tl_defc
= tlp
->tl_pastebuf
).l
;
2529 tlp
->tl_vi_flags
|= a_TTY_VF_BELL
;
2534 /* Normally this just causes a restart and thus resets the state
2536 if(tlp
->tl_savec
.l
== 0 && tlp
->tl_defc
.l
== 0){
2538 # ifdef HAVE_KEY_BINDINGS
2539 tlp
->tl_bind_takeover
= '\0';
2541 tlp
->tl_vi_flags
|= a_TTY_VF_BELL
;
2542 rv
= a_TTY_FUN_STATUS_RESTART
;
2546 if(tlp
->tl_count
== 0 && tlp
->tl_savec
.l
== 0 && tlp
->tl_defc
.l
== 0){
2547 # ifdef HAVE_KEY_BINDINGS
2548 tlp
->tl_bind_takeover
= '\0';
2550 tlp
->tl_vi_flags
|= a_TTY_VF_MOD_DIRTY
| a_TTY_VF_BELL
;
2553 case a_X(FULLRESET
):
2554 tlp
->tl_savec
.s
= tlp
->tl_defc
.s
= NULL
;
2555 tlp
->tl_savec
.l
= tlp
->tl_defc
.l
= 0;
2556 tlp
->tl_defc_cursor_byte
= 0;
2557 tlp
->tl_vi_flags
|= a_TTY_VF_BELL
;
2560 # ifdef HAVE_KEY_BINDINGS
2561 tlp
->tl_bind_takeover
= '\0';
2563 tlp
->tl_vi_flags
|= a_TTY_VF_MOD_DIRTY
;
2564 tlp
->tl_cursor
= tlp
->tl_count
= 0;
2565 # ifdef HAVE_HISTORY
2566 tlp
->tl_hist
= NULL
;
2568 if((*len
= tlp
->tl_savec
.l
) != 0){
2569 tlp
->tl_defc
= tlp
->tl_savec
;
2570 tlp
->tl_savec
.s
= NULL
;
2571 tlp
->tl_savec
.l
= 0;
2573 *len
= tlp
->tl_defc
.l
;
2574 rv
= a_TTY_FUN_STATUS_RESTART
;
2579 rv
= a_TTY_FUN_STATUS_COMMIT
;
2589 a_tty_readline(struct a_tty_line
*tlp
, size_t len n_MEMORY_DEBUG_ARGS
){
2590 /* We want to save code, yet we may have to incorporate a lines'
2591 * default content and / or default input to switch back to after some
2592 * history movement; let "len > 0" mean "have to display some data
2593 * buffer" -> a_BUFMODE, and only otherwise read(2) it */
2595 char cbuf_base
[MB_LEN_MAX
* 2], *cbuf
, *cbufp
;
2597 struct a_tty_bind_tree
*tbtp
;
2599 enum a_tty_bind_flags tbf
;
2600 enum {a_NONE
, a_WAS_HERE
= 1<<0, a_BUFMODE
= 1<<1, a_MAYBEFUN
= 1<<2,
2601 a_TIMEOUT
= 1<<3, a_TIMEOUT_EXPIRED
= 1<<4,
2602 a_TIMEOUT_MASK
= a_TIMEOUT
| a_TIMEOUT_EXPIRED
,
2603 a_READ_LOOP_MASK
= ~(a_WAS_HERE
| a_MAYBEFUN
| a_TIMEOUT_MASK
)
2608 # ifdef HAVE_KEY_BINDINGS
2609 assert(tlp
->tl_bind_takeover
== '\0');
2612 memset(ps
, 0, sizeof ps
);
2615 tlp
->tl_vi_flags
|= a_TTY_VF_REFRESH
| a_TTY_VF_SYNC
;
2622 /* Ensure we have valid pointers, and room for grow */
2623 a_tty_check_grow(tlp
, ((flags
& a_BUFMODE
) ? (ui32_t
)len
: 1)
2624 n_MEMORY_DEBUG_ARGSCALL
);
2626 /* Handle visual state flags, except in buffer mode */
2627 if(!(flags
& a_BUFMODE
) && (tlp
->tl_vi_flags
& a_TTY_VF_ALL_MASK
))
2628 if(!a_tty_vi_refresh(tlp
)){
2633 /* Ready for messing around.
2634 * Normal read(2)? Else buffer mode: speed this one up */
2635 if(!(flags
& a_BUFMODE
)){
2639 assert(tlp
->tl_defc
.l
> 0 && tlp
->tl_defc
.s
!= NULL
);
2640 assert(tlp
->tl_defc
.l
>= len
);
2642 cbuf
= tlp
->tl_defc
.s
+ (tlp
->tl_defc
.l
- len
);
2646 /* Read in the next complete multibyte character */
2648 # ifdef HAVE_KEY_BINDINGS
2649 struct a_tty_bind_tree
*xtbtp
;
2653 struct a_tty_bind_tree
*tbtp
;
2656 isp_head
= isp
= NULL
;
2659 for(flags
&= a_READ_LOOP_MASK
;;){
2660 # ifdef HAVE_KEY_BINDINGS
2661 if(!(flags
& a_BUFMODE
) && tlp
->tl_bind_takeover
!= '\0'){
2662 wc
= tlp
->tl_bind_takeover
;
2663 tlp
->tl_bind_takeover
= '\0';
2667 if(!(flags
& a_BUFMODE
)){
2668 /* Let me at least once dream of iomon(itor), timer with
2669 * one-shot, enwrapped with key_event and key_sequence_event,
2670 * all driven by an event_loop */
2671 /* TODO v15 Until we have SysV signal handling all through we
2672 * TODO need to temporarily adjust our BSD signal handler with
2673 * TODO a SysV one, here */
2674 n_sighdl_t otstp
, ottin
, ottou
;
2676 otstp
= n_signal(SIGTSTP
, &n_tty_signal
);
2677 ottin
= n_signal(SIGTTIN
, &n_tty_signal
);
2678 ottou
= n_signal(SIGTTOU
, &n_tty_signal
);
2679 # ifdef HAVE_KEY_BINDINGS
2680 flags
&= ~a_TIMEOUT_MASK
;
2681 if(isp
!= NULL
&& (tbtp
= isp
->tbtp
)->tbt_isseq
&&
2682 !tbtp
->tbt_isseq_trail
){
2683 a_tty_term_rawmode_timeout(tlp
, TRU1
);
2688 while((rv
= read(STDIN_FILENO
, cbufp
, 1)) < 1){
2691 if((tlp
->tl_vi_flags
& a_TTY_VF_MOD_DIRTY
) &&
2692 !a_tty_vi_refresh(tlp
))
2699 # ifdef HAVE_KEY_BINDINGS
2700 /* Timeout expiration */
2702 assert(flags
& a_TIMEOUT
);
2703 assert(isp
!= NULL
);
2704 a_tty_term_rawmode_timeout(tlp
, FAL0
);
2706 /* Something "atomic" broke. Maybe the current one can
2707 * also be terminated already, by itself? xxx really? */
2708 if((tbtp
= isp
->tbtp
)->tbt_bind
!= NULL
){
2709 tlp
->tl_bind_takeover
= wc
;
2713 /* Or, maybe there is a second path without a timeout;
2714 * this should be covered by .tbt_isseq_trail, but then
2715 * again a single-layer implementation cannot "know" */
2716 for(xtbtp
= tbtp
; (xtbtp
= xtbtp
->tbt_sibling
) != NULL
;)
2717 if(xtbtp
->tbt_char
== tbtp
->tbt_char
){
2718 assert(!xtbtp
->tbt_isseq
);
2721 /* Lay down on read(2)? */
2726 # endif /* HAVE_KEY_BINDINGS */
2729 # ifdef HAVE_KEY_BINDINGS
2730 if(flags
& a_TIMEOUT
)
2731 a_tty_term_rawmode_timeout(tlp
, FAL0
);
2733 safe_signal(SIGTSTP
, otstp
);
2734 safe_signal(SIGTTIN
, ottin
);
2735 safe_signal(SIGTTOU
, ottou
);
2742 rv
= (ssize_t
)mbrtowc(&wc
, cbuf
, PTR2SIZE(cbufp
- cbuf
), &ps
[0]);
2744 /* Any error during buffer mode can only result in a hard
2745 * reset; Otherwise, if it's a hard error, or if too many
2746 * redundant shift sequences overflow our buffer: perform
2748 if((flags
& a_BUFMODE
) || rv
== -1 ||
2749 sizeof cbuf_base
== PTR2SIZE(cbufp
- cbuf
)){
2750 a_tty_fun(tlp
, a_TTY_BIND_FUN_FULLRESET
, &len
);
2753 /* Otherwise, due to the way we deal with the buffer, we need
2754 * to restore the mbstate_t from before this conversion */
2762 /* Normal read(2)ing is subject to detection of key-bindings */
2763 # ifdef HAVE_KEY_BINDINGS
2764 if(!(flags
& a_BUFMODE
)){
2765 /* Check for special bypass functions before we try to embed
2766 * this character into the tree */
2767 if(n_uasciichar(wc
)){
2771 for(c
= (char)wc
, cp
= &(*tlp
->tl_bind_shcut_prompt_char
)[0];
2774 wc
= a_tty_vinuni(tlp
);
2779 tlp
->tl_vi_flags
|= a_TTY_VF_BELL
;
2783 if(n_uasciichar(wc
))
2784 flags
|= a_MAYBEFUN
;
2786 flags
&= ~a_MAYBEFUN
;
2788 /* Search for this character in the bind tree */
2789 tbtp
= (isp
!= NULL
) ? isp
->tbtp
->tbt_childs
2790 : (*tlp
->tl_bind_tree_hmap
)[wc
% HSHSIZE
];
2791 for(; tbtp
!= NULL
; tbtp
= tbtp
->tbt_sibling
){
2792 if(tbtp
->tbt_char
== wc
){
2795 /* If this one cannot continue we're likely finished! */
2796 if(tbtp
->tbt_childs
== NULL
){
2797 assert(tbtp
->tbt_bind
!= NULL
);
2798 tbf
= tbtp
->tbt_bind
->tbc_flags
;
2802 /* This needs to read more characters */
2803 nisp
= salloc(sizeof *nisp
);
2804 if((nisp
->last
= isp
) == NULL
)
2811 flags
&= ~a_WAS_HERE
;
2818 /* Was there a binding active, but couldn't be continued? */
2820 /* A binding had a timeout, it didn't expire, but we saw
2821 * something non-expected. Something "atomic" broke.
2822 * Maybe there is a second path without a timeout, that
2823 * continues like we've seen it. I.e., it may just have been
2824 * the user, typing too fast. We definitely want to allow
2825 * bindings like \e,d etc. to succeed: users are so used to
2826 * them that a timeout cannot be the mechanism to catch up!
2827 * A single-layer implementation cannot "know" */
2828 if((tbtp
= isp
->tbtp
)->tbt_isseq
&& (isp
->last
== NULL
||
2829 !(xtbtp
= isp
->last
->tbtp
)->tbt_isseq
||
2830 xtbtp
->tbt_isseq_trail
)){
2831 for(xtbtp
= (tbtp
= isp
->tbtp
);
2832 (xtbtp
= xtbtp
->tbt_sibling
) != NULL
;)
2833 if(xtbtp
->tbt_char
== tbtp
->tbt_char
){
2834 assert(!xtbtp
->tbt_isseq
);
2839 tlp
->tl_bind_takeover
= wc
;
2844 /* Check for CANCEL shortcut now */
2845 if(flags
& a_MAYBEFUN
){
2849 for(c
= (char)wc
, cp
= &(*tlp
->tl_bind_shcut_cancel
)[0];
2852 tbf
= a_TTY_BIND_FUN_INTERNAL
|a_TTY_BIND_FUN_CANCEL
;
2857 /* So: maybe the current sequence can be terminated here? */
2858 if((tbtp
= isp
->tbtp
)->tbt_bind
!= NULL
){
2860 tbf
= tbtp
->tbt_bind
->tbc_flags
;
2862 if(tbf
& a_TTY_BIND_FUN_INTERNAL
){
2863 switch(a_tty_fun(tlp
, tbf
, &len
)){
2864 case a_TTY_FUN_STATUS_OK
:
2866 case a_TTY_FUN_STATUS_COMMIT
:
2868 case a_TTY_FUN_STATUS_RESTART
:
2870 case a_TTY_FUN_STATUS_END
:
2874 }else if(tbtp
->tbt_bind
->tbc_flags
& a_TTY_BIND_NOCOMMIT
){
2875 struct a_tty_bind_ctx
*tbcp
;
2877 tbcp
= tbtp
->tbt_bind
;
2878 memcpy(tlp
->tl_defc
.s
= salloc(
2879 (tlp
->tl_defc
.l
= len
= tbcp
->tbc_exp_len
) +1),
2880 tbcp
->tbc_exp
, tbcp
->tbc_exp_len
+1);
2883 cbufp
= tbtp
->tbt_bind
->tbc_exp
;
2889 /* Otherwise take over all chars "as is" */
2891 for(; isp_head
!= NULL
; isp_head
= isp_head
->next
)
2892 if(a_tty_kother(tlp
, isp_head
->tbtp
->tbt_char
)){
2895 /* And the current one too */
2898 # endif /* HAVE_KEY_BINDINGS */
2900 if((flags
& a_BUFMODE
) && (len
-= (size_t)rv
) == 0){
2901 /* Buffer mode completed */
2902 tlp
->tl_defc
.s
= NULL
;
2904 flags
&= ~a_BUFMODE
;
2909 # ifndef HAVE_KEY_BINDINGS
2910 /* Don't interpret control bytes during buffer mode.
2911 * Otherwise, if it's a control byte check whether it is a MLE
2912 * function. Remarks: initially a complete duplicate to be able to
2913 * switch(), later converted to simply iterate over (an #ifdef'd
2914 * subset of) the MLE base_tuple table in order to have "a SPOF" */
2915 if(cbuf
== cbuf_base
&& n_uasciichar(wc
) && cntrlchar((char)wc
)){
2916 struct a_tty_bind_builtin_tuple
const *tbbtp
, *tbbtp_max
;
2919 c
= (char)wc
^ 0x40;
2920 tbbtp
= a_tty_bind_base_tuples
;
2921 tbbtp_max
= &tbbtp
[n_NELEM(a_tty_bind_base_tuples
)];
2923 for(; tbbtp
< tbbtp_max
; ++tbbtp
){
2924 /* Assert default_tuple table is properly subset'ed */
2925 assert(tbbtp
->tbdt_iskey
);
2926 if(tbbtp
->tbbt_ckey
== c
){
2927 if(tbbtp
->tbbt_exp
[0] == '\0'){
2928 enum a_tty_bind_flags tbf
;
2930 tbf
= a_TTY_BIND_FUN_EXPAND((ui8_t
)tbbtp
->tbbt_exp
[1]);
2931 switch(a_tty_fun(tlp
, tbf
, &len
)){
2932 case a_TTY_FUN_STATUS_OK
:
2934 case a_TTY_FUN_STATUS_COMMIT
:
2936 case a_TTY_FUN_STATUS_RESTART
:
2938 case a_TTY_FUN_STATUS_END
:
2943 cbufp
= tbbtp
->tbbt_exp
;
2949 &a_tty_bind_base_tuples
[n_NELEM(a_tty_bind_base_tuples
)]){
2950 tbbtp
= a_tty_bind_default_tuples
;
2951 tbbtp_max
= &tbbtp
[n_NELEM(a_tty_bind_default_tuples
)];
2955 # endif /* !HAVE_KEY_BINDINGS */
2957 # ifdef HAVE_KEY_BINDINGS
2960 if(a_tty_kother(tlp
, wc
)){
2961 /* Don't clear the history during buffer mode.. */
2962 # ifdef HAVE_HISTORY
2963 if(!(flags
& a_BUFMODE
) && cbuf
== cbuf_base
)
2964 tlp
->tl_hist
= NULL
;
2970 /* We have a completed input line, convert the struct cell data to its
2971 * plain character equivalent */
2973 rv
= a_tty_cell2dat(tlp
);
2975 putc('\n', n_tty_fp
);
2983 hold_all_sigs(); /* XXX v15 drop */
2984 i
= a_tty_cell2dat(tlp
);
2985 n_source_inject_input(tlp
->tl_line
.cbuf
, i
, FAL0
);
2986 i
= strlen(cbufp
) +1;
2987 if(i
>= *tlp
->tl_x_bufsize
){
2988 *tlp
->tl_x_buf
= (n_realloc
)(*tlp
->tl_x_buf
, i n_MEMORY_DEBUG_ARGSCALL
);
2989 *tlp
->tl_x_bufsize
= i
;
2991 memcpy(*tlp
->tl_x_buf
, cbufp
, i
);
2992 rele_all_sigs(); /* XXX v15 drop */
2998 # ifdef HAVE_KEY_BINDINGS
2999 static enum n_lexinput_flags
3000 a_tty_bind_ctx_find(char const *name
){
3001 enum n_lexinput_flags rv
;
3002 struct a_tty_bind_ctx_map
const *tbcmp
;
3005 tbcmp
= a_tty_bind_ctx_maps
;
3006 do if(!asccasecmp(tbcmp
->tbcm_name
, name
)){
3007 rv
= tbcmp
->tbcm_ctx
;
3009 }while(PTRCMP(++tbcmp
, <,
3010 &a_tty_bind_ctx_maps
[n_NELEM(a_tty_bind_ctx_maps
)]));
3012 rv
= (enum n_lexinput_flags
)-1;
3019 a_tty_bind_create(struct a_tty_bind_parse_ctx
*tbpcp
, bool_t replace
){
3020 struct a_tty_bind_ctx
*tbcp
;
3026 if(!a_tty_bind_parse(TRU1
, tbpcp
))
3029 /* Since we use a single buffer for it all, need to replace as such */
3030 if(tbpcp
->tbpc_tbcp
!= NULL
){
3033 a_tty_bind_del(tbpcp
);
3034 }else if(a_tty
.tg_bind_cnt
== UI32_MAX
){
3035 n_err(_("`bind': maximum number of bindings already established\n"));
3042 tbcp
= smalloc(n_VSTRUCT_SIZEOF(struct a_tty_bind_ctx
, tbc__buf
) +
3043 tbpcp
->tbpc_seq_len
+ tbpcp
->tbpc_exp
.l
+
3044 n_MAX(sizeof(si32_t
), sizeof(wc_t
)) + tbpcp
->tbpc_cnv_len
+3);
3045 if(tbpcp
->tbpc_ltbcp
!= NULL
){
3046 tbcp
->tbc_next
= tbpcp
->tbpc_ltbcp
->tbc_next
;
3047 tbpcp
->tbpc_ltbcp
->tbc_next
= tbcp
;
3049 enum n_lexinput_flags lif
= tbpcp
->tbpc_flags
& n__LEXINPUT_CTX_MASK
;
3051 tbcp
->tbc_next
= a_tty
.tg_bind
[lif
];
3052 a_tty
.tg_bind
[lif
] = tbcp
;
3054 memcpy(tbcp
->tbc_seq
= &tbcp
->tbc__buf
[0],
3055 tbpcp
->tbpc_seq
, i
= (tbcp
->tbc_seq_len
= tbpcp
->tbpc_seq_len
) +1);
3056 memcpy(tbcp
->tbc_exp
= &tbcp
->tbc__buf
[i
],
3057 tbpcp
->tbpc_exp
.s
, j
= (tbcp
->tbc_exp_len
= tbpcp
->tbpc_exp
.l
) +1);
3059 i
= (i
+ tbpcp
->tbpc_cnv_align_mask
) & ~tbpcp
->tbpc_cnv_align_mask
;
3060 memcpy(tbcp
->tbc_cnv
= &tbcp
->tbc__buf
[i
],
3061 tbpcp
->tbpc_cnv
, (tbcp
->tbc_cnv_len
= tbpcp
->tbpc_cnv_len
) +1);
3062 tbcp
->tbc_flags
= tbpcp
->tbpc_flags
;
3065 /* Directly resolve any termcap(5) symbol if we are already setup */
3066 if((n_psonce
& n_PSO_STARTED
) &&
3067 (tbcp
->tbc_flags
& (a_TTY_BIND_RESOLVE
| a_TTY_BIND_DEFUNCT
)) ==
3069 a_tty_bind_resolve(tbcp
);
3071 ++a_tty
.tg_bind_cnt
;
3072 /* If this binding is usable invalidate the key input lookup trees */
3073 if(!(tbcp
->tbc_flags
& a_TTY_BIND_DEFUNCT
))
3074 a_tty
.tg_bind_isdirty
= TRU1
;
3082 a_tty_bind_parse(bool_t isbindcmd
, struct a_tty_bind_parse_ctx
*tbpcp
){
3083 enum{a_TRUE_RV
= a_TTY__BIND_LAST
<<1};
3085 struct n_visual_info_ctx vic
;
3086 struct str shin_save
, shin
;
3087 struct n_string shou
, *shoup
;
3094 ui32_t cnv_len
; /* High bit set if a termap to be resolved */
3095 ui32_t calc_cnv_len
; /* Ditto, but aligned etc. */
3096 ui8_t kse__dummy
[4];
3100 n_LCTA(UICMP(64, a_TRUE_RV
, <, UI32_MAX
),
3101 "Flag bits excess storage datatype");
3103 f
= n_LEXINPUT_NONE
;
3104 shoup
= n_string_creat_auto(&shou
);
3107 /* Parse the key-sequence */
3108 for(shin
.s
= n_UNCONST(tbpcp
->tbpc_in_seq
), shin
.l
= UIZ_MAX
;;){
3110 enum n_shexp_state shs
;
3113 shs
= n_shexp_parse_token(shoup
, &shin
,
3114 n_SHEXP_PARSE_TRUNC
| n_SHEXP_PARSE_TRIMSPACE
|
3115 n_SHEXP_PARSE_IGNORE_EMPTY
| n_SHEXP_PARSE_IFS_IS_COMMA
);
3116 if(shs
& n_SHEXP_STATE_ERR_UNICODE
){
3117 f
|= a_TTY_BIND_DEFUNCT
;
3118 if(isbindcmd
&& (n_poption
& n_PO_D_V
))
3119 n_err(_("`%s': \\uNICODE not available in locale: %s\n"),
3120 tbpcp
->tbpc_cmd
, tbpcp
->tbpc_in_seq
);
3122 if((shs
& n_SHEXP_STATE_ERR_MASK
) & ~n_SHEXP_STATE_ERR_UNICODE
){
3123 n_err(_("`%s': failed to parse key-sequence: %s\n"),
3124 tbpcp
->tbpc_cmd
, tbpcp
->tbpc_in_seq
);
3127 if((shs
& (n_SHEXP_STATE_OUTPUT
| n_SHEXP_STATE_STOP
)) ==
3131 ep
= salloc(sizeof *ep
);
3138 if(!(shs
& n_SHEXP_STATE_ERR_UNICODE
)){
3139 i
= strlen(ep
->seq_dat
= n_shexp_quote_cp(n_string_cp(shoup
), TRU1
));
3140 if(i
>= SI32_MAX
- 1)
3142 ep
->seq_len
= (ui32_t
)i
;
3144 /* Otherwise use the original buffer, _we_ can only quote it the wrong
3145 * way (e.g., an initial $'\u3a' becomes '\u3a'), _then_ */
3146 if((i
= shin_save
.l
- shin
.l
) >= SI32_MAX
- 1)
3148 ep
->seq_len
= (ui32_t
)i
;
3149 ep
->seq_dat
= savestrbuf(shin_save
.s
, i
);
3152 memset(&vic
, 0, sizeof vic
);
3153 vic
.vic_inlen
= shoup
->s_len
;
3154 vic
.vic_indat
= shoup
->s_dat
;
3155 if(!n_visual_info(&vic
,
3156 n_VISUAL_INFO_WOUT_CREATE
| n_VISUAL_INFO_WOUT_SALLOC
)){
3157 n_err(_("`%s': key-sequence seems to contain invalid "
3158 "characters: %s: %s\n"),
3159 tbpcp
->tbpc_cmd
, n_string_cp(shoup
), tbpcp
->tbpc_in_seq
);
3160 f
|= a_TTY_BIND_DEFUNCT
;
3162 }else if(vic
.vic_woulen
== 0 ||
3163 vic
.vic_woulen
>= (SI32_MAX
- 2) / sizeof(wc_t
)){
3165 n_err(_("`%s': length of key-sequence unsupported: %s: %s\n"),
3166 tbpcp
->tbpc_cmd
, n_string_cp(shoup
), tbpcp
->tbpc_in_seq
);
3167 f
|= a_TTY_BIND_DEFUNCT
;
3170 ep
->cnv_dat
= vic
.vic_woudat
;
3171 ep
->cnv_len
= (ui32_t
)vic
.vic_woulen
;
3173 /* A termcap(5)/terminfo(5) identifier? */
3174 if(ep
->cnv_len
> 1 && ep
->cnv_dat
[0] == ':'){
3175 i
= --ep
->cnv_len
, ++ep
->cnv_dat
;
3176 # ifndef HAVE_TERMCAP
3177 if(n_poption
& n_PO_D_V
)
3178 n_err(_("`%s': no termcap(5)/terminfo(5) support: %s: %s\n"),
3179 tbpcp
->tbpc_cmd
, ep
->seq_dat
, tbpcp
->tbpc_in_seq
);
3180 f
|= a_TTY_BIND_DEFUNCT
;
3182 if(i
> a_TTY_BIND_CAPNAME_MAX
){
3183 n_err(_("`%s': termcap(5)/terminfo(5) name too long: %s: %s\n"),
3184 tbpcp
->tbpc_cmd
, ep
->seq_dat
, tbpcp
->tbpc_in_seq
);
3185 f
|= a_TTY_BIND_DEFUNCT
;
3188 /* (We store it as char[]) */
3189 if((ui32_t
)ep
->cnv_dat
[--i
] & ~0x7Fu
){
3190 n_err(_("`%s': invalid termcap(5)/terminfo(5) name content: "
3192 tbpcp
->tbpc_cmd
, ep
->seq_dat
, tbpcp
->tbpc_in_seq
);
3193 f
|= a_TTY_BIND_DEFUNCT
;
3196 ep
->cnv_len
|= SI32_MIN
; /* Needs resolve */
3197 f
|= a_TTY_BIND_RESOLVE
;
3200 if(shs
& n_SHEXP_STATE_STOP
)
3206 n_err(_("`%s': effectively empty key-sequence: %s\n"),
3207 tbpcp
->tbpc_cmd
, tbpcp
->tbpc_in_seq
);
3211 if(isbindcmd
) /* (Or always, just "1st time init") */
3212 tbpcp
->tbpc_cnv_align_mask
= n_MAX(sizeof(si32_t
), sizeof(wc_t
)) - 1;
3215 struct a_tty_bind_ctx
*ltbcp
, *tbcp
;
3216 char *cpbase
, *cp
, *cnv
;
3219 /* Unite the parsed sequence(s) into single string representations */
3220 for(sl
= cl
= 0, tail
= head
; tail
!= NULL
; tail
= tail
->next
){
3221 sl
+= tail
->seq_len
+ 1;
3226 /* Preserve room for terminal capabilities to be resolved.
3227 * Above we have ensured the buffer will fit in these calculations */
3228 if((i
= tail
->cnv_len
) & SI32_MIN
){
3230 * struct{si32_t buf_len_iscap; si32_t cap_len; wc_t name[]+NUL;}
3232 * struct{si32_t buf_len_iscap; si32_t cap_len; char buf[]+NUL;} */
3233 n_LCTAV(n_ISPOW2(a_TTY_BIND_CAPEXP_ROUNDUP
));
3234 n_LCTA(a_TTY_BIND_CAPEXP_ROUNDUP
>= sizeof(wc_t
),
3235 "Aligning on this constant doesn't properly align wc_t");
3238 i
+= sizeof(si32_t
);
3239 if(i
< a_TTY_BIND_CAPEXP_ROUNDUP
)
3240 i
= (i
+ (a_TTY_BIND_CAPEXP_ROUNDUP
- 1)) &
3241 ~(a_TTY_BIND_CAPEXP_ROUNDUP
- 1);
3243 /* struct{si32_t buf_len_iscap; wc_t buf[]+NUL;} */
3245 i
+= sizeof(si32_t
) + sizeof(wc_t
); /* (buf_len_iscap, NUL) */
3247 if(tail
->cnv_len
& SI32_MIN
){
3248 tail
->cnv_len
&= SI32_MAX
;
3251 tail
->calc_cnv_len
= (ui32_t
)i
;
3255 tbpcp
->tbpc_seq_len
= sl
;
3256 tbpcp
->tbpc_cnv_len
= cl
;
3260 j
= i
= sl
+ 1; /* Room for comma separator */
3262 i
= (i
+ tbpcp
->tbpc_cnv_align_mask
) & ~tbpcp
->tbpc_cnv_align_mask
;
3266 tbpcp
->tbpc_seq
= cp
= cpbase
= salloc(i
);
3267 tbpcp
->tbpc_cnv
= cnv
= &cpbase
[j
];
3270 for(tail
= head
; tail
!= NULL
; tail
= tail
->next
){
3271 memcpy(cp
, tail
->seq_dat
, tail
->seq_len
);
3272 cp
+= tail
->seq_len
;
3276 char * const save_cnv
= cnv
;
3278 n_UNALIGN(si32_t
*,cnv
)[0] = (si32_t
)(i
= tail
->calc_cnv_len
);
3279 cnv
+= sizeof(si32_t
);
3282 * struct{si32_t buf_len_iscap; si32_t cap_len; wc_t name[];}
3284 * struct{si32_t buf_len_iscap; si32_t cap_len; char buf[];} */
3285 n_UNALIGN(si32_t
*,cnv
)[0] = tail
->cnv_len
;
3286 cnv
+= sizeof(si32_t
);
3288 i
= tail
->cnv_len
* sizeof(wc_t
);
3289 memcpy(cnv
, tail
->cnv_dat
, i
);
3291 *n_UNALIGN(wc_t
*,cnv
) = '\0';
3293 cnv
= save_cnv
+ (tail
->calc_cnv_len
& SI32_MAX
);
3298 /* Search for a yet existing identical mapping */
3299 for(ltbcp
= NULL
, tbcp
= a_tty
.tg_bind
[tbpcp
->tbpc_flags
]; tbcp
!= NULL
;
3300 ltbcp
= tbcp
, tbcp
= tbcp
->tbc_next
)
3301 if(tbcp
->tbc_seq_len
== sl
&& !memcmp(tbcp
->tbc_seq
, cpbase
, sl
)){
3302 tbpcp
->tbpc_tbcp
= tbcp
;
3305 tbpcp
->tbpc_ltbcp
= ltbcp
;
3306 tbpcp
->tbpc_flags
|= (f
& a_TTY__BIND_MASK
);
3309 /* Create single string expansion if so desired */
3313 exp
= tbpcp
->tbpc_exp
.s
;
3315 i
= tbpcp
->tbpc_exp
.l
;
3316 if(i
> 0 && exp
[i
- 1] == '@'){
3318 if(!blankspacechar(exp
[i
- 1]))
3324 exp
[tbpcp
->tbpc_exp
.l
= i
] = '\0';
3325 tbpcp
->tbpc_flags
|= a_TTY_BIND_NOCOMMIT
;
3328 /* Reverse solidus cannot be placed last in expansion to avoid (at the
3329 * time of this writing) possible problems with newline escaping.
3330 * Don't care about (un)even number thereof */
3331 if(i
> 0 && exp
[i
- 1] == '\\'){
3332 n_err(_("`%s': reverse solidus cannot be last in expansion: %s\n"),
3333 tbpcp
->tbpc_cmd
, tbpcp
->tbpc_in_seq
);
3337 /* It may map to an internal MLE command! */
3338 for(i
= 0; i
< n_NELEM(a_tty_bind_fun_names
); ++i
)
3339 if(!asccasecmp(exp
, a_tty_bind_fun_names
[i
])){
3340 tbpcp
->tbpc_flags
|= a_TTY_BIND_FUN_EXPAND(i
) |
3341 a_TTY_BIND_FUN_INTERNAL
|
3342 (head
->next
== NULL
? a_TTY_BIND_MLE1CNTRL
: 0);
3343 if((n_poption
& n_PO_D_V
) &&
3344 (tbpcp
->tbpc_flags
& a_TTY_BIND_NOCOMMIT
))
3345 n_err(_("`%s': MLE commands can't be made editable via @: %s\n"),
3346 tbpcp
->tbpc_cmd
, exp
);
3347 tbpcp
->tbpc_flags
&= ~a_TTY_BIND_NOCOMMIT
;
3352 f
|= a_TRUE_RV
; /* TODO because we only now true and false; DEFUNCT.. */
3354 n_string_gut(shoup
);
3356 return (f
& a_TRUE_RV
) != 0;
3360 a_tty_bind_resolve(struct a_tty_bind_ctx
*tbcp
){
3361 char capname
[a_TTY_BIND_CAPNAME_MAX
+1];
3362 struct n_termcap_value tv
;
3364 bool_t isfirst
; /* TODO For now: first char must be control! */
3368 n_UNINIT(next
, NULL
);
3369 for(cp
= tbcp
->tbc_cnv
, isfirst
= TRU1
, len
= tbcp
->tbc_cnv_len
;
3370 len
> 0; isfirst
= FAL0
, cp
= next
){
3374 i
= n_UNALIGN(si32_t
*,cp
)[0];
3381 /* struct{si32_t buf_len_iscap; si32_t cap_len; wc_t name[];} */
3382 cp
+= sizeof(si32_t
);
3383 i
= n_UNALIGN(si32_t
*,cp
)[0];
3384 cp
+= sizeof(si32_t
);
3385 for(j
= 0; j
< i
; ++j
)
3386 capname
[j
] = n_UNALIGN(wc_t
*,cp
)[j
];
3390 /* Use generic lookup mechanism if not a known query */
3394 tq
= n_termcap_query_for_name(capname
, n_TERMCAP_CAPTYPE_STRING
);
3396 tv
.tv_data
.tvd_string
= capname
;
3397 tq
= n__TERMCAP_QUERY_MAX1
;
3400 if(tq
< 0 || !n_termcap_query(tq
, &tv
)){
3401 if(n_poption
& n_PO_D_V
)
3402 n_err(_("`bind': unknown or unsupported capability: %s: %s\n"),
3403 capname
, tbcp
->tbc_seq
);
3404 tbcp
->tbc_flags
|= a_TTY_BIND_DEFUNCT
;
3409 /* struct{si32_t buf_len_iscap; si32_t cap_len; char buf[]+NUL;} */
3413 i
= strlen(tv
.tv_data
.tvd_string
);
3414 if(/*i > SI32_MAX ||*/ i
>= PTR2SIZE(next
- cp
)){
3415 if(n_poption
& n_PO_D_V
)
3416 n_err(_("`bind': capability expansion too long: %s: %s\n"),
3417 capname
, tbcp
->tbc_seq
);
3418 tbcp
->tbc_flags
|= a_TTY_BIND_DEFUNCT
;
3421 if(n_poption
& n_PO_D_V
)
3422 n_err(_("`bind': empty capability expansion: %s: %s\n"),
3423 capname
, tbcp
->tbc_seq
);
3424 tbcp
->tbc_flags
|= a_TTY_BIND_DEFUNCT
;
3426 }else if(isfirst
&& !cntrlchar(*tv
.tv_data
.tvd_string
)){
3427 if(n_poption
& n_PO_D_V
)
3428 n_err(_("`bind': capability expansion doesn't start with "
3429 "control: %s: %s\n"), capname
, tbcp
->tbc_seq
);
3430 tbcp
->tbc_flags
|= a_TTY_BIND_DEFUNCT
;
3433 n_UNALIGN(si32_t
*,cp
)[-1] = (si32_t
)i
;
3434 memcpy(cp
, tv
.tv_data
.tvd_string
, i
);
3442 a_tty_bind_del(struct a_tty_bind_parse_ctx
*tbpcp
){
3443 struct a_tty_bind_ctx
*ltbcp
, *tbcp
;
3446 tbcp
= tbpcp
->tbpc_tbcp
;
3448 if((ltbcp
= tbpcp
->tbpc_ltbcp
) != NULL
)
3449 ltbcp
->tbc_next
= tbcp
->tbc_next
;
3451 a_tty
.tg_bind
[tbpcp
->tbpc_flags
] = tbcp
->tbc_next
;
3454 --a_tty
.tg_bind_cnt
;
3455 a_tty
.tg_bind_isdirty
= TRU1
;
3460 a_tty_bind_tree_build(void){
3464 for(i
= 0; i
< n__LEXINPUT_CTX_MAX1
; ++i
){
3465 struct a_tty_bind_ctx
*tbcp
;
3466 n_LCTAV(n_LEXINPUT_CTX_BASE
== 0);
3468 /* Somewhat wasteful, but easier to handle: simply clone the entire
3469 * primary key onto the secondary one, then only modify it */
3470 for(tbcp
= a_tty
.tg_bind
[n_LEXINPUT_CTX_BASE
]; tbcp
!= NULL
;
3471 tbcp
= tbcp
->tbc_next
)
3472 if(!(tbcp
->tbc_flags
& a_TTY_BIND_DEFUNCT
))
3473 a_tty__bind_tree_add(n_LEXINPUT_CTX_BASE
, &a_tty
.tg_bind_tree
[i
][0],
3476 if(i
!= n_LEXINPUT_CTX_BASE
)
3477 for(tbcp
= a_tty
.tg_bind
[i
]; tbcp
!= NULL
; tbcp
= tbcp
->tbc_next
)
3478 if(!(tbcp
->tbc_flags
& a_TTY_BIND_DEFUNCT
))
3479 a_tty__bind_tree_add(i
, &a_tty
.tg_bind_tree
[i
][0], tbcp
);
3482 a_tty
.tg_bind_isbuild
= TRU1
;
3487 a_tty_bind_tree_teardown(void){
3491 memset(&a_tty
.tg_bind_shcut_cancel
[0], 0,
3492 sizeof(a_tty
.tg_bind_shcut_cancel
));
3493 memset(&a_tty
.tg_bind_shcut_prompt_char
[0], 0,
3494 sizeof(a_tty
.tg_bind_shcut_prompt_char
));
3496 for(i
= 0; i
< n__LEXINPUT_CTX_MAX1
; ++i
)
3497 for(j
= 0; j
< HSHSIZE
; ++j
)
3498 a_tty__bind_tree_free(a_tty
.tg_bind_tree
[i
][j
]);
3499 memset(&a_tty
.tg_bind_tree
[0], 0, sizeof(a_tty
.tg_bind_tree
));
3501 a_tty
.tg_bind_isdirty
= a_tty
.tg_bind_isbuild
= FAL0
;
3506 a_tty__bind_tree_add(ui32_t hmap_idx
, struct a_tty_bind_tree
*store
[HSHSIZE
],
3507 struct a_tty_bind_ctx
*tbcp
){
3510 struct a_tty_bind_tree
*ntbtp
;
3516 for(cnvdat
= tbcp
->tbc_cnv
, cnvlen
= tbcp
->tbc_cnv_len
; cnvlen
> 0;){
3517 union {wchar_t const *wp
; char const *cp
;} u
;
3520 /* {si32_t buf_len_iscap;} */
3521 entlen
= *n_UNALIGN(si32_t
const*,cnvdat
);
3523 if(entlen
& SI32_MIN
){
3524 /* struct{si32_t buf_len_iscap; si32_t cap_len; char buf[]+NUL;}
3525 * Note that empty capabilities result in DEFUNCT */
3526 for(u
.cp
= (char const*)&n_UNALIGN(si32_t
const*,cnvdat
)[2];
3527 *u
.cp
!= '\0'; ++u
.cp
)
3528 ntbtp
= a_tty__bind_tree_add_wc(store
, ntbtp
, *u
.cp
, TRU1
);
3529 assert(ntbtp
!= NULL
);
3530 ntbtp
->tbt_isseq_trail
= TRU1
;
3533 /* struct{si32_t buf_len_iscap; wc_t buf[]+NUL;} */
3536 u
.wp
= (wchar_t const*)&n_UNALIGN(si32_t
const*,cnvdat
)[1];
3538 /* May be a special shortcut function? */
3539 if(ntbtp
== NULL
&& (tbcp
->tbc_flags
& a_TTY_BIND_MLE1CNTRL
)){
3543 ctx
= tbcp
->tbc_flags
& n__LEXINPUT_CTX_MASK
;
3544 fun
= tbcp
->tbc_flags
& a_TTY__BIND_FUN_MASK
;
3546 if(fun
== a_TTY_BIND_FUN_CANCEL
){
3547 for(cp
= &a_tty
.tg_bind_shcut_cancel
[ctx
][0];
3548 PTRCMP(cp
, <, &a_tty
.tg_bind_shcut_cancel
[ctx
]
3549 [n_NELEM(a_tty
.tg_bind_shcut_cancel
[ctx
]) - 1]); ++cp
)
3554 }else if(fun
== a_TTY_BIND_FUN_PROMPT_CHAR
){
3555 for(cp
= &a_tty
.tg_bind_shcut_prompt_char
[ctx
][0];
3556 PTRCMP(cp
, <, &a_tty
.tg_bind_shcut_prompt_char
[ctx
]
3557 [n_NELEM(a_tty
.tg_bind_shcut_prompt_char
[ctx
]) - 1]);
3566 isseq
= (u
.wp
[1] != '\0');
3567 for(; *u
.wp
!= '\0'; ++u
.wp
)
3568 ntbtp
= a_tty__bind_tree_add_wc(store
, ntbtp
, *u
.wp
, isseq
);
3570 ntbtp
->tbt_isseq_trail
= TRU1
;
3577 /* Should have been rendered defunctional at first instead */
3578 assert(ntbtp
!= NULL
);
3579 ntbtp
->tbt_bind
= tbcp
;
3583 static struct a_tty_bind_tree
*
3584 a_tty__bind_tree_add_wc(struct a_tty_bind_tree
**treep
,
3585 struct a_tty_bind_tree
*parentp
, wchar_t wc
, bool_t isseq
){
3586 struct a_tty_bind_tree
*tbtp
, *xtbtp
;
3589 if(parentp
== NULL
){
3590 treep
+= wc
% HSHSIZE
;
3592 /* Having no parent also means that the tree slot is possibly empty */
3593 for(tbtp
= *treep
; tbtp
!= NULL
;
3594 parentp
= tbtp
, tbtp
= tbtp
->tbt_sibling
){
3595 if(tbtp
->tbt_char
!= wc
)
3597 if(tbtp
->tbt_isseq
== isseq
)
3599 /* isseq MUST be linked before !isseq, so record this "parent"
3600 * sibling, but continue searching for now */
3603 /* Otherwise it is impossible that we'll find what we look for */
3606 while((tbtp
= tbtp
->tbt_sibling
) != NULL
)
3607 assert(tbtp
->tbt_char
!= wc
);
3613 tbtp
= smalloc(sizeof *tbtp
);
3614 memset(tbtp
, 0, sizeof *tbtp
);
3615 tbtp
->tbt_char
= wc
;
3616 tbtp
->tbt_isseq
= isseq
;
3618 if(parentp
== NULL
){
3619 tbtp
->tbt_sibling
= *treep
;
3622 tbtp
->tbt_sibling
= parentp
->tbt_sibling
;
3623 parentp
->tbt_sibling
= tbtp
;
3626 if((tbtp
= *(treep
= &parentp
->tbt_childs
)) != NULL
){
3627 for(;; tbtp
= xtbtp
){
3628 if(tbtp
->tbt_char
== wc
){
3629 if(tbtp
->tbt_isseq
== isseq
)
3631 /* isseq MUST be linked before, so it is impossible that we'll
3632 * find what we look for */
3635 while((tbtp
= tbtp
->tbt_sibling
) != NULL
)
3636 assert(tbtp
->tbt_char
!= wc
);
3643 if((xtbtp
= tbtp
->tbt_sibling
) == NULL
){
3644 treep
= &tbtp
->tbt_sibling
;
3650 xtbtp
= smalloc(sizeof *xtbtp
);
3651 memset(xtbtp
, 0, sizeof *xtbtp
);
3652 xtbtp
->tbt_parent
= parentp
;
3653 xtbtp
->tbt_char
= wc
;
3654 xtbtp
->tbt_isseq
= isseq
;
3664 a_tty__bind_tree_free(struct a_tty_bind_tree
*tbtp
){
3666 while(tbtp
!= NULL
){
3667 struct a_tty_bind_tree
*tmp
;
3669 if((tmp
= tbtp
->tbt_childs
) != NULL
)
3670 a_tty__bind_tree_free(tmp
);
3672 tmp
= tbtp
->tbt_sibling
;
3678 # endif /* HAVE_KEY_BINDINGS */
3684 if(ok_blook(line_editor_disable
))
3687 /* Load the history file */
3688 # ifdef HAVE_HISTORY
3693 size_t lsize
, cnt
, llen
;
3695 if((v
= a_tty_hist_query_config()) == NULL
||
3696 a_tty
.tg_hist_size_max
== 0)
3699 hold_all_sigs(); /* TODO too heavy, yet we may jump even here!? */
3700 f
= fopen(v
, "r"); /* TODO HISTFILE LOAD: use linebuf pool */
3703 (void)n_file_lock(fileno(f
), FLT_READ
, 0,0, UIZ_MAX
);
3705 assert(!(n_pstate
& n_PS_ROOT
));
3706 n_pstate
|= n_PS_ROOT
; /* Allow calling addhist() */
3709 cnt
= (size_t)fsize(f
);
3710 while(fgetline(&lbuf
, &lsize
, &cnt
, &llen
, f
, FAL0
) != NULL
){
3711 if(llen
> 0 && lbuf
[llen
- 1] == '\n')
3712 lbuf
[--llen
] = '\0';
3713 if(llen
== 0 || lbuf
[0] == '#') /* xxx comments? noone! */
3718 isgabby
= (lbuf
[0] == '*');
3719 n_tty_addhist(lbuf
+ isgabby
, isgabby
);
3724 n_pstate
&= ~n_PS_ROOT
;
3728 rele_all_sigs(); /* XXX remove jumps */
3730 # endif /* HAVE_HISTORY */
3732 /* Force immediate resolve for anything which follows */
3733 n_psonce
|= n_PSO_LINE_EDITOR_INIT
;
3735 # ifdef HAVE_KEY_BINDINGS
3736 /* `bind's (and `unbind's) done from within resource files couldn't be
3737 * performed for real since our termcap driver wasn't yet loaded, and we
3738 * can't perform automatic init since the user may have disallowed so */
3740 struct a_tty_bind_ctx
*tbcp
;
3741 enum n_lexinput_flags lif
;
3743 for(lif
= 0; lif
< n__LEXINPUT_CTX_MAX1
; ++lif
)
3744 for(tbcp
= a_tty
.tg_bind
[lif
]; tbcp
!= NULL
; tbcp
= tbcp
->tbc_next
)
3745 if((tbcp
->tbc_flags
& (a_TTY_BIND_RESOLVE
| a_TTY_BIND_DEFUNCT
)) ==
3747 a_tty_bind_resolve(tbcp
);
3750 /* And we want to (try to) install some default key bindings */
3751 if(!ok_blook(line_editor_no_defaults
)){
3753 struct a_tty_bind_parse_ctx tbpc
;
3754 struct a_tty_bind_builtin_tuple
const *tbbtp
, *tbbtp_max
;
3757 buf
[0] = '$', buf
[1] = '\'', buf
[2] = '\\', buf
[3] = 'c',
3758 buf
[5] = '\'', buf
[6] = '\0';
3760 tbbtp
= a_tty_bind_base_tuples
;
3761 tbbtp_max
= &tbbtp
[n_NELEM(a_tty_bind_base_tuples
)];
3762 flags
= n_LEXINPUT_CTX_BASE
;
3764 for(; tbbtp
< tbbtp_max
; ++tbbtp
){
3765 memset(&tbpc
, 0, sizeof tbpc
);
3766 tbpc
.tbpc_cmd
= "bind";
3767 if(tbbtp
->tbbt_iskey
){
3768 buf
[4] = tbbtp
->tbbt_ckey
;
3769 tbpc
.tbpc_in_seq
= buf
;
3771 tbpc
.tbpc_in_seq
= savecatsep(":", '\0',
3772 n_termcap_name_of_query(tbbtp
->tbbt_query
));
3773 tbpc
.tbpc_exp
.s
= n_UNCONST(tbbtp
->tbbt_exp
[0] == '\0'
3774 ? a_tty_bind_fun_names
[(ui8_t
)tbbtp
->tbbt_exp
[1]]
3776 tbpc
.tbpc_exp
.l
= strlen(tbpc
.tbpc_exp
.s
);
3777 tbpc
.tbpc_flags
= flags
;
3778 /* ..but don't want to overwrite any user settings */
3779 a_tty_bind_create(&tbpc
, FAL0
);
3781 if(flags
== n_LEXINPUT_CTX_BASE
){
3782 tbbtp
= a_tty_bind_default_tuples
;
3783 tbbtp_max
= &tbbtp
[n_NELEM(a_tty_bind_default_tuples
)];
3784 flags
= n_LEXINPUT_CTX_DEFAULT
;
3788 # endif /* HAVE_KEY_BINDINGS */
3795 n_tty_destroy(void){
3798 if(!(n_psonce
& n_PSO_LINE_EDITOR_INIT
))
3801 # ifdef HAVE_HISTORY
3805 struct a_tty_hist
*thp
;
3809 if((v
= a_tty_hist_query_config()) == NULL
||
3810 a_tty
.tg_hist_size_max
== 0)
3813 dogabby
= ok_blook(history_gabby_persist
);
3815 if((thp
= a_tty
.tg_hist
) != NULL
)
3816 for(i
= a_tty
.tg_hist_size_max
; thp
->th_older
!= NULL
;
3817 thp
= thp
->th_older
)
3818 if((dogabby
|| !thp
->th_isgabby
) && --i
== 0)
3821 hold_all_sigs(); /* TODO too heavy, yet we may jump even here!? */
3822 f
= fopen(v
, "w"); /* TODO temporary + rename?! */
3825 (void)n_file_lock(fileno(f
), FLT_WRITE
, 0,0, UIZ_MAX
);
3827 for(; thp
!= NULL
; thp
= thp
->th_younger
){
3828 if(dogabby
|| !thp
->th_isgabby
){
3831 fwrite(thp
->th_dat
, sizeof *thp
->th_dat
, thp
->th_len
, f
);
3837 rele_all_sigs(); /* XXX remove jumps */
3839 # endif /* HAVE_HISTORY */
3841 # if defined HAVE_KEY_BINDINGS && defined HAVE_DEBUG
3842 c_unbind(n_UNCONST("* *"));
3846 memset(&a_tty
, 0, sizeof a_tty
);
3848 DBG( n_psonce
&= ~n_PSO_LINE_EDITOR_INIT
; )
3854 n_tty_signal(int sig
){
3855 sigset_t nset
, oset
;
3856 NYD_X
; /* Signal handler */
3861 /* We don't deal with SIGWINCH, yet get called from main.c.
3862 * Note this case might get called even if !n_PO_LINE_EDITOR_INIT */
3866 a_tty_term_mode(FAL0
);
3867 n_TERMCAP_SUSPEND(TRU1
);
3871 sigaddset(&nset
, sig
);
3872 sigprocmask(SIG_UNBLOCK
, &nset
, &oset
);
3874 /* When we come here we'll continue editing, so reestablish */
3875 sigprocmask(SIG_BLOCK
, &oset
, (sigset_t
*)NULL
);
3878 n_TERMCAP_RESUME(TRU1
);
3879 a_tty_term_mode(TRU1
);
3880 a_tty
.tg_line
->tl_vi_flags
|= a_TTY_VF_MOD_DIRTY
;
3886 (n_tty_readline
)(enum n_lexinput_flags lif
, char const *prompt
,
3887 char **linebuf
, size_t *linesize
, size_t n n_MEMORY_DEBUG_ARGS
){
3888 struct a_tty_line tl
;
3889 struct n_string xprompt
;
3897 assert(!ok_blook(line_editor_disable
));
3898 if(!(n_psonce
& n_PSO_LINE_EDITOR_INIT
))
3900 assert(n_psonce
& n_PSO_LINE_EDITOR_INIT
);
3903 n_colour_env_create(n_COLOUR_CTX_MLE
, FAL0
);
3906 struct n_colour_pen
*ccp
;
3907 struct str
const *sp
;
3909 /* .tl_pos_buf is a hack */
3910 posbuf
= pos
= NULL
;
3911 if((ccp
= n_colour_pen_create(n_COLOUR_ID_MLE_POSITION
, NULL
)) != NULL
&&
3912 (sp
= n_colour_pen_to_str(ccp
)) != NULL
){
3914 if((sp
= n_colour_reset_to_str()) != NULL
){
3919 posbuf
= salloc(l1
+ 4 + l2
+1);
3920 memcpy(posbuf
, ccol
, l1
);
3922 memcpy(&pos
[4], sp
->s
, ++l2
);
3926 posbuf
= pos
= salloc(4 +1);
3930 # endif /* HAVE_COLOUR */
3932 memset(&tl
, 0, sizeof tl
);
3934 # ifdef HAVE_KEY_BINDINGS
3938 if((cp
= ok_vlook(bind_timeout
)) != NULL
){
3941 n_idec_ui64_cp(&uib
, cp
, 0, NULL
);
3944 /* Convert to tenths of a second, unfortunately */
3945 (uib
= (uib
+ 99) / 100) <= a_TTY_BIND_TIMEOUT_MAX
)
3946 tl
.tl_bind_timeout
= (ui8_t
)uib
;
3947 else if(n_poption
& n_PO_D_V
)
3948 n_err(_("Ignoring invalid *bind-timeout*: %s\n"), cp
);
3952 if(a_tty
.tg_bind_isdirty
)
3953 a_tty_bind_tree_teardown();
3954 if(a_tty
.tg_bind_cnt
> 0 && !a_tty
.tg_bind_isbuild
)
3955 a_tty_bind_tree_build();
3956 tl
.tl_bind_tree_hmap
= &a_tty
.tg_bind_tree
[lif
& n__LEXINPUT_CTX_MASK
];
3957 tl
.tl_bind_shcut_cancel
=
3958 &a_tty
.tg_bind_shcut_cancel
[lif
& n__LEXINPUT_CTX_MASK
];
3959 tl
.tl_bind_shcut_prompt_char
=
3960 &a_tty
.tg_bind_shcut_prompt_char
[lif
& n__LEXINPUT_CTX_MASK
];
3961 # endif /* HAVE_KEY_BINDINGS */
3964 tl
.tl_pos_buf
= posbuf
;
3968 if(!(lif
& n_LEXINPUT_PROMPT_NONE
)){
3969 n_string_creat_auto(&xprompt
);
3971 if((tl
.tl_prompt_width
= n_tty_create_prompt(&xprompt
, prompt
, lif
)
3973 tl
.tl_prompt
= n_string_cp_const(&xprompt
);
3974 tl
.tl_prompt_length
= (ui32_t
)xprompt
.s_len
;
3978 tl
.tl_line
.cbuf
= *linebuf
;
3980 tl
.tl_defc
.s
= savestrbuf(*linebuf
, n
);
3983 tl
.tl_x_buf
= linebuf
;
3984 tl
.tl_x_bufsize
= linesize
;
3986 a_tty
.tg_line
= &tl
;
3988 n_TERMCAP_RESUME(FAL0
);
3989 a_tty_term_mode(TRU1
);
3990 nn
= a_tty_readline(&tl
, n n_MEMORY_DEBUG_ARGSCALL
);
3991 a_tty_term_mode(FAL0
);
3992 n_TERMCAP_SUSPEND(FAL0
);
3994 a_tty
.tg_line
= NULL
;
3997 n_colour_env_gut(n_tty_fp
);
4004 n_tty_addhist(char const *s
, bool_t isgabby
){
4005 # ifdef HAVE_HISTORY
4006 /* Super-Heavy-Metal: block all sigs, avoid leaks+ on jump */
4008 struct a_tty_hist
*thp
, *othp
, *ythp
;
4014 # ifdef HAVE_HISTORY
4015 if(spacechar(*s
) || *s
== '\0' ||
4016 (!(n_psonce
& n_PSO_LINE_EDITOR_INIT
) && !(n_pstate
& n_PS_ROOT
)) ||
4017 a_tty
.tg_hist_size_max
== 0 ||
4018 ok_blook(line_editor_disable
) ||
4019 (isgabby
&& !ok_blook(history_gabby
)))
4022 l
= (ui32_t
)strlen(s
);
4024 /* Eliminating duplicates is expensive, but simply inacceptable so
4025 * during the load of a potentially large history file! */
4026 if(n_psonce
& n_PSO_LINE_EDITOR_INIT
)
4027 for(thp
= a_tty
.tg_hist
; thp
!= NULL
; thp
= thp
->th_older
)
4028 if(thp
->th_len
== l
&& !strcmp(thp
->th_dat
, s
)){
4029 hold_all_sigs(); /* TODO */
4031 thp
->th_isgabby
= !!isgabby
;
4032 othp
= thp
->th_older
;
4033 ythp
= thp
->th_younger
;
4035 othp
->th_younger
= ythp
;
4037 a_tty
.tg_hist_tail
= ythp
;
4039 ythp
->th_older
= othp
;
4041 a_tty
.tg_hist
= othp
;
4046 ++a_tty
.tg_hist_size
;
4047 if((n_psonce
& n_PSO_LINE_EDITOR_INIT
) &&
4048 a_tty
.tg_hist_size
> a_tty
.tg_hist_size_max
){
4049 --a_tty
.tg_hist_size
;
4050 if((thp
= a_tty
.tg_hist_tail
) != NULL
){
4051 if((a_tty
.tg_hist_tail
= thp
->th_younger
) == NULL
)
4052 a_tty
.tg_hist
= NULL
;
4054 a_tty
.tg_hist_tail
->th_older
= NULL
;
4059 thp
= smalloc(n_VSTRUCT_SIZEOF(struct a_tty_hist
, th_dat
) + l
+1);
4060 thp
->th_isgabby
= !!isgabby
;
4062 memcpy(thp
->th_dat
, s
, l
+1);
4064 if((thp
->th_older
= a_tty
.tg_hist
) != NULL
)
4065 a_tty
.tg_hist
->th_younger
= thp
;
4067 a_tty
.tg_hist_tail
= thp
;
4068 thp
->th_younger
= NULL
;
4069 a_tty
.tg_hist
= thp
;
4073 # endif /* HAVE_HISTORY */
4077 # ifdef HAVE_HISTORY
4081 struct a_tty_hist
*thp
;
4085 if(ok_blook(line_editor_disable
)){
4086 n_err(_("history: *line-editor-disable* is set\n"));
4090 if(!(n_psonce
& n_PSO_LINE_EDITOR_INIT
)){
4092 assert(n_psonce
& n_PSO_LINE_EDITOR_INIT
);
4095 if(*(argv
= v
) == NULL
)
4099 if(!asccasecmp(*argv
, "show"))
4101 if(!asccasecmp(*argv
, "clear"))
4103 if((n_idec_uiz_cp(&entry
, *argv
, 10, NULL
4104 ) & (n_IDEC_STATE_EMASK
| n_IDEC_STATE_CONSUMED
)
4105 ) == n_IDEC_STATE_CONSUMED
)
4108 n_err(_("Synopsis: history: %s\n"),
4109 /* Same string as in cmd_tab.h, still hoping...) */
4110 _("<show> (default), <clear> or select <NO> from editor history"));
4114 return (v
== NULL
? !STOP
: !OKAY
); /* xxx 1:bad 0:good -- do some */
4120 if(a_tty
.tg_hist
== NULL
)
4123 if((fp
= Ftmp(NULL
, "hist", OF_RDWR
| OF_UNLINK
| OF_REGISTER
)) == NULL
){
4124 n_perr(_("tmpfile"), 0);
4129 i
= a_tty
.tg_hist_size
;
4131 for(thp
= a_tty
.tg_hist
; thp
!= NULL
;
4132 --i
, b
+= thp
->th_len
, thp
= thp
->th_older
)
4134 "%c%4" PRIuZ
". %-50.50s (%4" PRIuZ
"+%2" PRIu32
" B)\n",
4135 (thp
->th_isgabby
? '*' : ' '), i
, thp
->th_dat
, b
, thp
->th_len
);
4137 page_or_print(fp
, i
);
4143 while((thp
= a_tty
.tg_hist
) != NULL
){
4144 a_tty
.tg_hist
= thp
->th_older
;
4147 a_tty
.tg_hist_tail
= NULL
;
4148 a_tty
.tg_hist_size
= 0;
4152 if(UICMP(z
, entry
, <=, a_tty
.tg_hist_size
)){
4153 entry
= a_tty
.tg_hist_size
- entry
;
4154 for(thp
= a_tty
.tg_hist
;; thp
= thp
->th_older
){
4155 assert(thp
!= NULL
);
4157 n_source_inject_input(v
= thp
->th_dat
, thp
->th_len
, TRU1
);
4162 n_err(_("`history': no such entry: %" PRIuZ
"\n"), entry
);
4167 # endif /* HAVE_HISTORY */
4169 # ifdef HAVE_KEY_BINDINGS
4172 n_CMD_ARG_DESC_SUBCLASS_DEF(bind
, 3, a_tty_bind_cad
) { /* TODO cmd_tab.h */
4173 {n_CMD_ARG_DESC_STRING
, 0},
4174 {n_CMD_ARG_DESC_WYSH
| n_CMD_ARG_DESC_OPTION
|
4175 n_CMD_ARG_DESC_HONOUR_STOP
,
4176 n_SHEXP_PARSE_DRYRUN
| n_SHEXP_PARSE_LOG
},
4177 {n_CMD_ARG_DESC_WYSH
| n_CMD_ARG_DESC_OPTION
| n_CMD_ARG_DESC_GREEDY
|
4178 n_CMD_ARG_DESC_HONOUR_STOP
,
4179 n_SHEXP_PARSE_IGNORE_EMPTY
}
4180 } n_CMD_ARG_DESC_SUBCLASS_DEF_END
;
4181 struct n_cmd_arg_ctx cac
;
4182 struct a_tty_bind_ctx
*tbcp
;
4183 enum n_lexinput_flags lif
;
4185 union {char const *cp
; char *p
; char c
;} c
;
4188 cac
.cac_desc
= n_CMD_ARG_DESC_SUBCLASS_CAST(&a_tty_bind_cad
);
4190 cac
.cac_inlen
= UIZ_MAX
;
4191 if(!n_cmd_arg_parse(&cac
)){
4196 c
.cp
= cac
.cac_arg
->ca_arg
.ca_str
.s
;
4200 show
= !asccasecmp(cac
.cac_arg
->ca_next
->ca_arg
.ca_str
.s
, "show");
4203 if((lif
= a_tty_bind_ctx_find(c
.cp
)) == (enum n_lexinput_flags
)-1){
4204 if(!(aster
= n_is_all_or_aster(c
.cp
)) || !show
){
4205 n_err(_("`bind': invalid context: %s\n"), c
.cp
);
4216 if((fp
= Ftmp(NULL
, "bind", OF_RDWR
| OF_UNLINK
| OF_REGISTER
)) == NULL
){
4217 n_perr(_("tmpfile"), 0);
4224 for(tbcp
= a_tty
.tg_bind
[lif
]; tbcp
!= NULL
;
4225 ++lns
, tbcp
= tbcp
->tbc_next
){
4226 /* Print the bytes of resolved terminal capabilities, then */
4227 if((n_poption
& n_PO_D_V
) &&
4228 (tbcp
->tbc_flags
& (a_TTY_BIND_RESOLVE
| a_TTY_BIND_DEFUNCT
)
4229 ) == a_TTY_BIND_RESOLVE
){
4231 union {wchar_t const *wp
; char const *cp
;} u
;
4234 char const *cnvdat
, *bsep
, *cbufp
;
4239 cbuf
[0] = '=', cbuf
[2] = '\0';
4240 for(cnvdat
= tbcp
->tbc_cnv
, cnvlen
= tbcp
->tbc_cnv_len
;
4242 if(cnvdat
!= tbcp
->tbc_cnv
)
4245 /* {si32_t buf_len_iscap;} */
4246 entlen
= *n_UNALIGN(si32_t
const*,cnvdat
);
4247 if(entlen
& SI32_MIN
){
4248 /* struct{si32_t buf_len_iscap; si32_t cap_len;
4249 * char buf[]+NUL;} */
4251 u
.cp
= (char const*)
4252 &n_UNALIGN(si32_t
const*,cnvdat
)[2];
4253 (c
.c
= *u
.cp
) != '\0'; ++u
.cp
){
4254 if(asciichar(c
.c
) && !cntrlchar(c
.c
))
4255 cbuf
[1] = c
.c
, cbufp
= cbuf
;
4258 fprintf(fp
, "%s%02X%s",
4259 bsep
, (ui32_t
)(ui8_t
)c
.c
, cbufp
);
4274 fprintf(fp
, "%sbind %s %s %s%s%s\n",
4275 ((tbcp
->tbc_flags
& a_TTY_BIND_DEFUNCT
)
4276 /* I18N: `bind' sequence not working, either because it is
4277 * I18N: using Unicode and that is not available in the locale,
4278 * I18N: or a termcap(5)/terminfo(5) sequence won't work out */
4279 ? _("# <Defunctional> ") : n_empty
),
4280 a_tty_bind_ctx_maps
[lif
].tbcm_name
, tbcp
->tbc_seq
,
4281 n_shexp_quote_cp(tbcp
->tbc_exp
, TRU1
),
4282 (tbcp
->tbc_flags
& a_TTY_BIND_NOCOMMIT
? "@" : n_empty
),
4283 (!(n_poption
& n_PO_D_VV
) ? n_empty
4284 : (tbcp
->tbc_flags
& a_TTY_BIND_FUN_INTERNAL
4285 ? _(" # MLE internal") : n_empty
))
4288 if(!aster
|| ++lif
>= n__LEXINPUT_CTX_MAX1
)
4291 page_or_print(fp
, lns
);
4295 struct a_tty_bind_parse_ctx tbpc
;
4296 struct n_string store
;
4298 memset(&tbpc
, 0, sizeof tbpc
);
4299 tbpc
.tbpc_cmd
= a_tty_bind_cad
.cad_name
;
4300 tbpc
.tbpc_in_seq
= cac
.cac_arg
->ca_next
->ca_arg
.ca_str
.s
;
4301 tbpc
.tbpc_exp
.s
= n_string_cp(n_cmd_arg_join_greedy(&cac
,
4302 n_string_creat_auto(&store
)));
4303 tbpc
.tbpc_exp
.l
= store
.s_len
;
4304 tbpc
.tbpc_flags
= lif
;
4305 if(!a_tty_bind_create(&tbpc
, TRU1
))
4307 n_string_gut(&store
);
4311 return (v
!= NULL
) ? n_EXIT_OK
: n_EXIT_ERR
;
4316 n_CMD_ARG_DESC_SUBCLASS_DEF(unbind
, 2, a_tty_unbind_cad
) {/* TODO cmd_tab.h*/
4317 {n_CMD_ARG_DESC_STRING
, 0},
4318 {n_CMD_ARG_DESC_WYSH
| n_CMD_ARG_DESC_HONOUR_STOP
,
4319 n_SHEXP_PARSE_DRYRUN
| n_SHEXP_PARSE_LOG
}
4320 } n_CMD_ARG_DESC_SUBCLASS_DEF_END
;
4321 struct a_tty_bind_parse_ctx tbpc
;
4322 struct n_cmd_arg_ctx cac
;
4323 struct a_tty_bind_ctx
*tbcp
;
4324 enum n_lexinput_flags lif
;
4326 union {char const *cp
; char *p
;} c
;
4329 cac
.cac_desc
= n_CMD_ARG_DESC_SUBCLASS_CAST(&a_tty_unbind_cad
);
4331 cac
.cac_inlen
= UIZ_MAX
;
4332 if(!n_cmd_arg_parse(&cac
)){
4337 c
.cp
= cac
.cac_arg
->ca_arg
.ca_str
.s
;
4340 if((lif
= a_tty_bind_ctx_find(c
.cp
)) == (enum n_lexinput_flags
)-1){
4341 if(!(aster
= n_is_all_or_aster(c
.cp
))){
4342 n_err(_("`unbind': invalid context: %s\n"), c
.cp
);
4349 c
.cp
= cac
.cac_arg
->ca_next
->ca_arg
.ca_str
.s
;
4351 if(n_is_all_or_aster(c
.cp
)){
4352 while((tbcp
= a_tty
.tg_bind
[lif
]) != NULL
){
4353 memset(&tbpc
, 0, sizeof tbpc
);
4354 tbpc
.tbpc_tbcp
= tbcp
;
4355 tbpc
.tbpc_flags
= lif
;
4356 a_tty_bind_del(&tbpc
);
4359 memset(&tbpc
, 0, sizeof tbpc
);
4360 tbpc
.tbpc_cmd
= a_tty_unbind_cad
.cad_name
;
4361 tbpc
.tbpc_in_seq
= c
.cp
;
4362 tbpc
.tbpc_flags
= lif
;
4364 if(n_UNLIKELY(!a_tty_bind_parse(FAL0
, &tbpc
)))
4366 else if(n_UNLIKELY((tbcp
= tbpc
.tbpc_tbcp
) == NULL
)){
4367 n_err(_("`unbind': no such `bind'ing: %s %s\n"),
4368 a_tty_bind_ctx_maps
[lif
].tbcm_name
, c
.cp
);
4371 a_tty_bind_del(&tbpc
);
4374 if(aster
&& ++lif
< n__LEXINPUT_CTX_MAX1
)
4378 return (v
!= NULL
) ? n_EXIT_OK
: n_EXIT_ERR
;
4380 # endif /* HAVE_KEY_BINDINGS */
4382 #else /* HAVE_MLE */
4384 * The really-nothing-at-all implementation
4394 n_tty_destroy(void){
4400 n_tty_signal(int sig
){
4401 NYD_X
; /* Signal handler */
4404 # ifdef HAVE_TERMCAP
4407 sigset_t nset
, oset
;
4409 n_TERMCAP_SUSPEND(TRU1
);
4413 sigaddset(&nset
, sig
);
4414 sigprocmask(SIG_UNBLOCK
, &nset
, &oset
);
4416 /* When we come here we'll continue editing, so reestablish */
4417 sigprocmask(SIG_BLOCK
, &oset
, (sigset_t
*)NULL
);
4420 n_TERMCAP_RESUME(TRU1
);
4424 # endif /* HAVE_TERMCAP */
4428 (n_tty_readline
)(enum n_lexinput_flags lif
, char const *prompt
,
4429 char **linebuf
, size_t *linesize
, size_t n n_MEMORY_DEBUG_ARGS
){
4430 struct n_string xprompt
;
4434 if(!(lif
& n_LEXINPUT_PROMPT_NONE
)){
4435 if(n_tty_create_prompt(n_string_creat_auto(&xprompt
), prompt
, lif
) > 0){
4436 fwrite(xprompt
.s_dat
, 1, xprompt
.s_len
, n_tty_fp
);
4441 # ifdef HAVE_TERMCAP
4443 n_TERMCAP_RESUME(FAL0
);
4445 rv
= (readline_restart
)(n_stdin
, linebuf
, linesize
,n n_MEMORY_DEBUG_ARGSCALL
);
4446 # ifdef HAVE_TERMCAP
4447 n_TERMCAP_SUSPEND(FAL0
);
4455 n_tty_addhist(char const *s
, bool_t isgabby
){
4461 #endif /* nothing at all */
4463 #undef a_TTY_SIGNALS