1 /** Support for keyboard interface
4 * @todo TODO: move stuff from here to itrm.{c,h} and mouse.{c,h}
21 #define HPUX_PIPE (len > PIPE_BUF || errno != EAGAIN)
28 #include "config/options.h"
29 #include "intl/gettext/libintl.h"
30 #include "main/select.h"
31 #include "main/timer.h"
32 #include "osdep/ascii.h"
33 #include "osdep/osdep.h"
34 #include "terminal/hardio.h"
35 #include "terminal/itrm.h"
36 #include "terminal/kbd.h"
37 #include "terminal/mouse.h"
38 #include "terminal/terminal.h"
39 #include "util/error.h"
40 #include "util/memory.h"
41 #include "util/string.h"
42 #include "util/time.h"
44 struct itrm
*ditrm
= NULL
;
46 static void free_itrm(struct itrm
*);
47 static void in_kbd(struct itrm
*);
48 static void in_sock(struct itrm
*);
49 static int process_queue(struct itrm
*);
50 static void handle_itrm_stdin(struct itrm
*);
51 static void unhandle_itrm_stdin(struct itrm
*);
54 /** This hack makes GCC put enum term_event_special_key in the debug
55 * information even though it is not otherwise used. The const
56 * prevents an unused-variable warning. */
57 static const enum term_event_special_key dummy_term_event_special_key
;
64 return ditrm
&& ditrm
->blocked
;
71 if (ditrm
) free_itrm(ditrm
);
75 /** A select_handler_T write_func for itrm_out.sock. This is called
76 * when there is data in @c itrm->out.queue and it is possible to write
77 * it to @c itrm->out.sock. When @c itrm->out.queue becomes empty, this
78 * handler is temporarily removed. */
80 itrm_queue_write(struct itrm
*itrm
)
83 int qlen
= int_min(itrm
->out
.queue
.len
, 128);
85 assertm(qlen
, "event queue empty");
86 if_assert_failed
return;
88 written
= safe_write(itrm
->out
.sock
, itrm
->out
.queue
.data
, qlen
);
90 if (written
< 0) free_itrm(itrm
); /* write error */
94 itrm
->out
.queue
.len
-= written
;
96 if (itrm
->out
.queue
.len
== 0) {
97 set_handlers(itrm
->out
.sock
,
98 get_handler(itrm
->out
.sock
, SELECT_HANDLER_READ
),
100 get_handler(itrm
->out
.sock
, SELECT_HANDLER_ERROR
),
101 get_handler(itrm
->out
.sock
, SELECT_HANDLER_DATA
));
103 assert(itrm
->out
.queue
.len
> 0);
104 memmove(itrm
->out
.queue
.data
, itrm
->out
.queue
.data
+ written
, itrm
->out
.queue
.len
);
110 itrm_queue_event(struct itrm
*itrm
, unsigned char *data
, int len
)
116 if (!itrm
->out
.queue
.len
&& can_write(itrm
->out
.sock
)) {
117 w
= safe_write(itrm
->out
.sock
, data
, len
);
118 if (w
<= 0 && HPUX_PIPE
) {
119 register_bottom_half(free_itrm
, itrm
);
126 unsigned char *c
= mem_realloc(itrm
->out
.queue
.data
,
127 itrm
->out
.queue
.len
+ left
);
134 itrm
->out
.queue
.data
= c
;
135 memcpy(itrm
->out
.queue
.data
+ itrm
->out
.queue
.len
, data
+ w
, left
);
136 itrm
->out
.queue
.len
+= left
;
137 set_handlers(itrm
->out
.sock
,
138 get_handler(itrm
->out
.sock
, SELECT_HANDLER_READ
),
139 (select_handler_T
) itrm_queue_write
,
140 (select_handler_T
) free_itrm
, itrm
);
148 struct interlink_event ev
;
151 /* This is called because of a signal, and there may be input
152 * pending from the terminal, so do not reset
153 * ditrm->bracketed_pasting. */
154 set_kbd_interlink_event(&ev
, KBD_CTRL_C
, KBD_MOD_NONE
);
155 itrm_queue_event(ditrm
, (unsigned char *) &ev
, sizeof(ev
));
158 #define write_sequence(fd, seq) \
159 hard_write(fd, seq, sizeof(seq) - 1)
162 #define INIT_TERMINAL_SEQ "\033)0\0337" /**< Special Character and Line Drawing Set, Save Cursor */
163 #define INIT_ALT_SCREEN_SEQ "\033[?47h" /**< Use Alternate Screen Buffer */
164 #define INIT_BRACKETED_PASTE_SEQ "\033[?2004h" /**< Enable XTerm bracketed paste mode */
167 send_init_sequence(int h
, int altscreen
)
169 write_sequence(h
, INIT_TERMINAL_SEQ
);
171 /* If alternate screen is supported switch to it. */
173 write_sequence(h
, INIT_ALT_SCREEN_SEQ
);
176 send_mouse_init_sequence(h
);
178 write_sequence(h
, INIT_BRACKETED_PASTE_SEQ
);
181 #define DONE_CLS_SEQ "\033[2J" /**< Erase in Display, Clear All */
182 #define DONE_TERMINAL_SEQ "\0338\r \b" /**< Restore Cursor (DECRC) + ??? */
183 #define DONE_ALT_SCREEN_SEQ "\033[?47l" /**< Use Normal Screen Buffer */
184 #define DONE_BRACKETED_PASTE_SEQ "\033[?2004l" /**< Disable XTerm bracketed paste mode */
187 send_done_sequence(int h
, int altscreen
)
189 write_sequence(h
, DONE_BRACKETED_PASTE_SEQ
);
190 write_sequence(h
, DONE_CLS_SEQ
);
193 send_mouse_done_sequence(h
);
196 /* Switch from alternate screen. */
198 write_sequence(h
, DONE_ALT_SCREEN_SEQ
);
201 write_sequence(h
, DONE_TERMINAL_SEQ
);
205 #undef write_sequence
208 resize_terminal(void)
210 struct interlink_event ev
;
213 get_terminal_size(ditrm
->out
.std
, &width
, &height
);
214 set_resize_interlink_event(&ev
, width
, height
);
215 itrm_queue_event(ditrm
, (char *) &ev
, sizeof(ev
));
219 get_terminal_name(unsigned char name
[MAX_TERM_LEN
])
221 unsigned char *term
= getenv("TERM");
224 memset(name
, 0, MAX_TERM_LEN
);
228 for (i
= 0; term
[i
] != 0 && i
< MAX_TERM_LEN
- 1; i
++)
229 name
[i
] = isident(term
[i
]) ? term
[i
] : '-';
234 setraw(struct itrm
*itrm
, int save_orig
)
239 memset(&t
, 0, sizeof(t
));
240 if (tcgetattr(itrm
->in
.ctl
, &t
)) return -1;
242 if (save_orig
) copy_struct(&itrm
->t
, &t
);
244 #ifdef _POSIX_VDISABLE
245 vdisable
= _POSIX_VDISABLE
;
246 #elif defined(HAVE_FPATHCONF)
247 vdisable
= fpathconf(itrm
->in
.ctl
, _PC_VDISABLE
);
251 /* Is VERASE defined on Windows? */
252 if (vdisable
!= -1 && t
.c_cc
[VERASE
] == vdisable
)
255 itrm
->verase
= (unsigned char) t
.c_cc
[VERASE
];
260 elinks_cfmakeraw(&t
);
266 if (tcsetattr(itrm
->in
.ctl
, TCSANOW
, &t
)) return -1;
271 /** Construct the struct itrm of this process, make ::ditrm point to it,
272 * set up select() handlers, and send the initial interlink packet.
274 * The first five parameters are file descriptors that this function
275 * saves in submembers of struct itrm, and for which this function may
276 * set select() handlers. Please see the definitions of struct
277 * itrm_in and struct itrm_out for further explanations.
279 * @param std_in itrm_in.std: read tty device (or pipe)
280 * @param std_out itrm_out.std: write tty device (or pipe)
281 * @param sock_in itrm_in.sock
282 * - If master: == @a std_out (masterhood flag)
283 * - If slave: read socket from master
284 * @param sock_out itrm_out.sock
285 * - If master: write pipe to same process
286 * - If slave: write socket to master
287 * @param ctl_in itrm_in.ctl: control tty device
289 * The remaining three parameters control the initial interlink packet.
291 * @param init_string A string to be passed to the master process. Need
292 * not be null-terminated. If @a remote == 0, this is
293 * a URI. Otherwise, this is a remote command.
294 * @param init_len The length of init_string, in bytes.
295 * @param remote = 0 if asking the master to start a new session
296 * and display it via this process. Otherwise,
297 * enum ::remote_session_flags. */
299 handle_trm(int std_in
, int std_out
, int sock_in
, int sock_out
, int ctl_in
,
300 void *init_string
, int init_len
, int remote
)
303 struct terminal_info info
;
304 struct interlink_event_size
*size
= &info
.event
.info
.size
;
307 memset(&info
, 0, sizeof(info
));
309 get_terminal_size(ctl_in
, &size
->width
, &size
->height
);
310 info
.event
.ev
= EVENT_INIT
;
311 info
.system_env
= get_system_env();
312 info
.length
= init_len
;
315 info
.session_info
= remote
;
316 info
.magic
= INTERLINK_REMOTE_MAGIC
;
318 info
.session_info
= get_cmd_opt_int("base-session");
319 info
.magic
= INTERLINK_NORMAL_MAGIC
;
322 itrm
= mem_calloc(1, sizeof(*itrm
));
325 itrm
->in
.queue
.data
= mem_calloc(1, ITRM_IN_QUEUE_SIZE
);
326 if (!itrm
->in
.queue
.data
) {
332 itrm
->in
.std
= std_in
;
333 itrm
->out
.std
= std_out
;
334 itrm
->in
.sock
= sock_in
;
335 itrm
->out
.sock
= sock_out
;
336 itrm
->in
.ctl
= ctl_in
;
337 itrm
->timer
= TIMER_ID_UNDEF
;
338 itrm
->remote
= !!remote
;
340 /* If the master does not tell which charset it's using in
341 * this terminal, assume it's some ISO 8859. Because that's
342 * what older versions of ELinks did. */
343 itrm
->title_codepage
= get_cp_index("ISO-8859-1");
345 /* FIXME: Combination altscreen + xwin does not work as it should,
346 * mouse clicks are reportedly partially ignored. */
347 if (info
.system_env
& (ENV_SCREEN
| ENV_XWIN
))
351 if (ctl_in
>= 0) setraw(itrm
, 1);
352 send_init_sequence(std_out
, itrm
->altscreen
);
353 handle_terminal_resize(ctl_in
, resize_terminal
);
357 handle_itrm_stdin(itrm
);
359 /* elinks -remote may not have a valid stdin if not run from a tty (bug 938) */
360 if (std_in
>= 0) handle_itrm_stdin(itrm
);
363 if (sock_in
!= std_out
)
364 set_handlers(sock_in
, (select_handler_T
) in_sock
,
365 NULL
, (select_handler_T
) free_itrm
, itrm
);
367 get_terminal_name(info
.name
);
371 memcpy(info
.cwd
, ts
, int_min(strlen(ts
), MAX_CWD_LEN
));
375 itrm_queue_event(itrm
, (char *) &info
, TERMINAL_INFO_SIZE
);
376 itrm_queue_event(itrm
, (char *) init_string
, init_len
);
380 /** A select_handler_T read_func and error_func for the pipe (long) @a h.
381 * This is called when the subprocess started on the terminal of this
382 * ELinks process exits. ELinks then resumes using the terminal. */
384 unblock_itrm_x(void *h
)
390 /* Note: External editor support depends on this resize event. */
398 if (!ditrm
) return -1;
400 if (ditrm
->in
.ctl
>= 0 && setraw(ditrm
, 0)) return -1;
402 send_init_sequence(ditrm
->out
.std
, ditrm
->altscreen
);
404 handle_itrm_stdin(ditrm
);
405 resume_mouse(ditrm
->mouse_h
);
407 handle_terminal_resize(ditrm
->in
.ctl
, resize_terminal
);
421 kill_timer(&ditrm
->timer
);
422 ditrm
->in
.queue
.len
= 0;
423 unhandle_terminal_resize(ditrm
->in
.ctl
);
424 send_done_sequence(ditrm
->out
.std
, ditrm
->altscreen
);
425 tcsetattr(ditrm
->in
.ctl
, TCSANOW
, &ditrm
->t
);
426 unhandle_itrm_stdin(ditrm
);
427 suspend_mouse(ditrm
->mouse_h
);
432 free_itrm(struct itrm
*itrm
)
437 if (itrm
->orig_title
&& *itrm
->orig_title
) {
438 set_window_title(itrm
->orig_title
, itrm
->title_codepage
);
440 } else if (itrm
->touched_title
) {
441 /* Set the window title to the value of $TERM if X11
442 * wasn't compiled in. Should hopefully make at least
443 * half the users happy. (debian bug #312955) */
444 unsigned char title
[MAX_TERM_LEN
];
446 get_terminal_name(title
);
448 set_window_title(title
,
449 get_cp_index("US-ASCII"));
453 unhandle_terminal_resize(itrm
->in
.ctl
);
457 send_done_sequence(itrm
->out
.std
, itrm
->altscreen
);
458 tcsetattr(itrm
->in
.ctl
, TCSANOW
, &itrm
->t
);
461 mem_free_set(&itrm
->orig_title
, NULL
);
463 /* elinks -remote may not have a valid stdin if not run from a tty (bug 938) */
464 if (!itrm
->remote
|| itrm
->in
.std
>= 0) clear_handlers(itrm
->in
.std
);
465 clear_handlers(itrm
->in
.sock
);
466 clear_handlers(itrm
->out
.std
);
467 clear_handlers(itrm
->out
.sock
);
469 kill_timer(&itrm
->timer
);
471 if (itrm
== ditrm
) ditrm
= NULL
;
472 mem_free_if(itrm
->out
.queue
.data
);
473 mem_free_if(itrm
->in
.queue
.data
);
477 /** Resize terminal to dimensions specified by @a text string.
478 * @a text should look like "width,height,old-width,old-height"
479 * where width and height are integers. */
481 resize_terminal_from_str(unsigned char *text
)
483 enum { NEW_WIDTH
= 0, NEW_HEIGHT
, OLD_WIDTH
, OLD_HEIGHT
, NUMBERS
} i
;
484 int numbers
[NUMBERS
];
486 assert(text
&& *text
);
487 if_assert_failed
return;
489 for (i
= 0; i
< NUMBERS
; i
++) {
490 unsigned char *p
= strchr(text
, ',');
495 } else if (i
< OLD_HEIGHT
) {
499 numbers
[i
] = atoi(text
);
504 resize_window(numbers
[NEW_WIDTH
], numbers
[NEW_HEIGHT
],
505 numbers
[OLD_WIDTH
], numbers
[OLD_HEIGHT
]);
510 dispatch_special(unsigned char *text
)
518 if (!ditrm
->orig_title
)
519 ditrm
->orig_title
= get_window_title(
520 ditrm
->title_codepage
);
521 ditrm
->touched_title
= 1;
523 /* TODO: Is it really possible to get here with
524 * ditrm == NULL, and which charset would then
525 * be most appropriate? */
526 set_window_title(text
+ 1,
527 ditrm
? ditrm
->title_codepage
528 : get_cp_index("US-ASCII"));
531 if (ditrm
&& ditrm
->remote
)
534 resize_terminal_from_str(text
+ 1);
536 case TERM_FN_TITLE_CODEPAGE
:
538 int cp
= get_cp_index(text
+ 1);
540 /* If the master sends the name of an
541 * unrecognized charset, assume only
542 * that it's ASCII compatible. */
544 cp
= get_cp_index("US-ASCII");
545 ditrm
->title_codepage
= cp
;
552 safe_hard_write(int fd
, unsigned char *buf
, int len
)
554 if (is_blocked()) return;
557 hard_write(fd
, buf
, len
);
561 /** A select_handler_T read_func for itrm_in.sock. A slave process
562 * calls this when the master sends it data to be displayed. The
563 * master process never calls this. */
565 in_sock(struct itrm
*itrm
)
568 struct string
delete;
570 int fg
; /* enum term_exec */
571 ssize_t bytes_read
, i
, p
;
572 unsigned char buf
[ITRM_OUT_QUEUE_SIZE
];
574 bytes_read
= safe_read(itrm
->in
.sock
, buf
, ITRM_OUT_QUEUE_SIZE
);
575 if (bytes_read
<= 0) goto free_and_return
;
578 for (i
= 0; i
< bytes_read
; i
++)
582 safe_hard_write(itrm
->out
.std
, buf
, bytes_read
);
586 if (i
) safe_hard_write(itrm
->out
.std
, buf
, i
);
589 assert(ITRM_OUT_QUEUE_SIZE
- i
> 0);
590 memmove(buf
, buf
+ i
, ITRM_OUT_QUEUE_SIZE
- i
);
597 if (p < bytes_read) \
599 else if ((hard_read(itrm->in.sock, &cc, 1)) <= 0) \
600 goto free_and_return; \
606 if (!init_string(&path
)) goto free_and_return
;
611 add_char_to_string(&path
, ch
);
614 if (!init_string(&delete)) {
616 goto free_and_return
;
622 add_char_to_string(&delete, ch
);
628 dispatch_special(delete.source
);
632 unsigned char *param
;
633 int path_len
, del_len
, param_len
;
635 /* TODO: Should this be changed to allow TERM_EXEC_NEWWIN
636 * in a blocked terminal? There is similar code in
637 * exec_on_terminal(). --KON, 2007 */
638 if (is_blocked() && fg
!= TERM_EXEC_BG
) {
639 if (*delete.source
) unlink(delete.source
);
643 path_len
= path
.length
;
644 del_len
= delete.length
;
645 param_len
= path_len
+ del_len
+ 3;
647 param
= mem_alloc(param_len
);
648 if (!param
) goto nasty_thing
;
651 memcpy(param
+ 1, path
.source
, path_len
+ 1);
652 memcpy(param
+ 1 + path_len
+ 1, delete.source
, del_len
+ 1);
654 if (fg
== TERM_EXEC_FG
) block_itrm();
656 blockh
= start_thread((void (*)(void *, int)) exec_thread
,
661 if (fg
== TERM_EXEC_FG
)
667 if (fg
== TERM_EXEC_FG
) {
668 set_handlers(blockh
, (select_handler_T
) unblock_itrm_x
,
669 NULL
, (select_handler_T
) unblock_itrm_x
,
670 (void *) (long) blockh
);
673 set_handlers(blockh
, close_handle
, NULL
, close_handle
,
674 (void *) (long) blockh
);
680 done_string(&delete);
681 assert(ITRM_OUT_QUEUE_SIZE
- p
> 0);
682 memmove(buf
, buf
+ p
, ITRM_OUT_QUEUE_SIZE
- p
);
692 /** Parse an ECMA-48 control sequence that was received from a
693 * terminal. Extract the Final Byte (if there are no Intermediate
694 * Bytes) and the value of the first parameter (if it is an integer).
696 * This function assumes the control sequence begins with a CSI -
697 * CONTROL SEQUENCE INTRODUCER encoded as ESC [. (ECMA-48 also allows
698 * 0x9B as a single-byte CSI, but we don't support that here.)
701 * - -1 if the control sequence is not yet complete; the caller sets a timer.
702 * - 0 if the control sequence does not comply with ECMA-48.
703 * - The length of the control sequence otherwise. */
705 get_esc_code(unsigned char *str
, int len
, unsigned char *final_byte
,
706 int *first_param_value
)
708 const int parameter_pos
= 2;
709 int intermediate_pos
;
714 *first_param_value
= 0;
716 /* Parameter Bytes */
718 while (pos
< len
&& str
[pos
] >= 0x30 && str
[pos
] <= 0x3F)
721 /* Intermediate Bytes */
722 intermediate_pos
= pos
;
723 while (pos
< len
&& str
[pos
] >= 0x20 && str
[pos
] <= 0x2F)
730 if (!(str
[pos
] >= 0x40 && str
[pos
] <= 0x7E))
733 /* The control sequence seems OK. If the first Parameter
734 * Byte indicates that the parameter string is formatted
735 * as specified in clause 5.4.2 of ECMA-48, and the first
736 * parameter is an integer, then compute its value.
737 * (We need not check @len here because the loop cannot get
738 * past the Final Byte.) */
739 for (pos
= parameter_pos
; str
[pos
] >= 0x30 && str
[pos
] <= 0x39; ++pos
)
740 *first_param_value
= *first_param_value
* 10 + str
[pos
] - 0x30;
741 /* If the first parameter contains an embedded separator, then
742 * the value is not an integer, so discard what we computed. */
743 if (str
[pos
] == 0x3A)
744 *first_param_value
= 0;
746 /* The meaning of the Final Byte depends on the Intermediate
747 * Bytes. Because we don't currently need to recognize any
748 * control sequences that use Intermediate Bytes, we just
749 * discard the Final Byte if there are any Intermediate
751 if (intermediate_pos
== final_pos
)
752 *final_byte
= str
[final_pos
];
754 return final_pos
+ 1;
757 /* Define it to dump queue content in a readable form,
758 * it may help to determine terminal sequences, and see what goes on. --Zas */
759 /* #define DEBUG_ITRM_QUEUE */
761 #ifdef DEBUG_ITRM_QUEUE
763 #include <ctype.h> /* isprint() isspace() */
766 /** Decode a control sequence that begins with CSI (CONTROL SEQUENCE
767 * INTRODUCER) encoded as ESC [, and set @a *ev accordingly.
768 * (ECMA-48 also allows 0x9B as a single-byte CSI, but we don't
769 * support that here.)
772 * - -1 if the control sequence is not yet complete; the caller sets a timer.
773 * - 0 if the control sequence should be parsed by some other function.
774 * - The length of the control sequence otherwise.
775 * Returning >0 does not imply this function has altered @a *ev. */
777 decode_terminal_escape_sequence(struct itrm
*itrm
, struct interlink_event
*ev
)
779 struct term_event_keyboard kbd
= { KBD_UNDEF
, KBD_MOD_NONE
};
784 if (itrm
->in
.queue
.len
< 3) return -1;
786 if (itrm
->in
.queue
.data
[2] == '[') {
787 /* The terminfo entry for linux has "kf1=\E[[A", etc.
788 * These are not control sequences compliant with
789 * clause 5.4 of ECMA-48. (According to ECMA-48,
790 * "\E[[" is SRS - START REVERSED STRING.) */
791 if (itrm
->in
.queue
.len
>= 4
792 && itrm
->in
.queue
.data
[3] >= 'A'
793 && itrm
->in
.queue
.data
[3] <= 'L') {
794 kbd
.key
= number_to_kbd_fkey(itrm
->in
.queue
.data
[3] - 'A' + 1);
795 set_kbd_interlink_event(ev
, kbd
.key
, kbd
.modifier
);
802 el
= get_esc_code(itrm
->in
.queue
.data
, itrm
->in
.queue
.len
, &c
, &v
);
804 /* If the control sequence is incomplete but itrm->in.queue
805 * is already full, then we must not wait for more input:
806 * kbd_timeout might call in_kbd and thus process_input
807 * and come right back here. Better just reject the whole
808 * thing and let the initial CSI be handled as Alt-[. */
809 if (itrm
->in
.queue
.len
== ITRM_IN_QUEUE_SIZE
)
814 #ifdef DEBUG_ITRM_QUEUE
815 fprintf(stderr
, "esc code: %c v=%d c=%c el=%d\n", itrm
->in
.queue
.data
[1], v
, c
, el
);
819 /* The following information should be listed for each escape
820 * sequence recognized here:
822 * 1. Which control function ECMA-48 assigns to the sequence.
823 * Put parentheses around this if the control function
824 * seems unrelated to how ELinks actually treats the
825 * sequence. Write "private" if it is a control sequence
826 * reserved for private or experimental use in ECMA-48.
827 * (Those have a Final Byte in the range 0x70 to 0x7F,
828 * optionally preceded by a single Intermediate Byte 0x20.)
830 * 2. The capname used by Terminfo, if any. These should help
831 * when ELinks is eventually changed to read escape
832 * sequences from Terminfo (bug 96).
834 * 3. The $TERM identifier of some terminal that generates
835 * this escape sequence with the meaning expected by
836 * ELinks. Escape sequences with no known terminal may end
837 * up being removed from ELinks when bug 96 is fixed.
838 */ /* ECMA-48 Terminfo $TERM */
839 switch (c
) { /* ------- -------- ----- */
840 case 'A': kbd
.key
= KBD_UP
; break; /* CUU kcuu1 vt200 */
841 case 'B': kbd
.key
= KBD_DOWN
; break; /* CUD kcud1 vt200 */
842 case 'C': kbd
.key
= KBD_RIGHT
; break; /* CUF kcuf1 vt200 */
843 case 'D': kbd
.key
= KBD_LEFT
; break; /* CUB kcub1 vt200 */
844 case 'F': /* (CPL) kend cons25 */
845 case 'e': kbd
.key
= KBD_END
; break; /* (VPR) kend */
846 case 'H': kbd
.key
= KBD_HOME
; break; /* CUP khome cons25 */
847 case 'I': kbd
.key
= KBD_PAGE_UP
; break; /* (CHT) kpp cons25 */
848 case 'G': kbd
.key
= KBD_PAGE_DOWN
; break; /* (CHA) knp cons25 */
849 case 'L': kbd
.key
= KBD_INS
; break; /* (IL) kich1 cons25 */
850 /* Free BSD (TERM=cons25 etc.) */
851 /* case 'M': kbd.key = KBD_F1; break;*/ /* (DL) kf1 cons25 */
852 case 'N': kbd
.key
= KBD_F2
; break; /* (EF) kf2 cons25 */
853 case 'O': kbd
.key
= KBD_F3
; break; /* (EA) kf3 cons25 */
854 case 'P': kbd
.key
= KBD_F4
; break; /* (DCH) kf4 cons25 */
855 case 'Q': kbd
.key
= KBD_F5
; break; /* (SEE) kf5 cons25 */
856 /* case 'R': kbd.key = KBD_F6; break;*/ /* (CPR) kf6 cons25 */
857 case 'S': kbd
.key
= KBD_F7
; break; /* (SU) kf7 cons25 */
858 case 'T': kbd
.key
= KBD_F8
; break; /* (SD) kf8 cons25 */
859 case 'U': kbd
.key
= KBD_F9
; break; /* (NP) kf9 cons25 */
860 case 'V': kbd
.key
= KBD_F10
; break; /* (PP) kf10 cons25 */
861 case 'W': kbd
.key
= KBD_F11
; break; /* (CTC) kf11 cons25 */
862 case 'X': kbd
.key
= KBD_F12
; break; /* (ECH) kf12 cons25 */
864 case 'Z': /* CBT kcbt cons25 */
865 kbd
.key
= KBD_TAB
; kbd
.modifier
= KBD_MOD_SHIFT
; break;
867 case 'z': switch (v
) { /* private */
868 case 247: kbd
.key
= KBD_INS
; break; /* kich1 */
869 case 214: kbd
.key
= KBD_HOME
; break; /* khome sun */
870 case 220: kbd
.key
= KBD_END
; break; /* kend sun */
871 case 216: kbd
.key
= KBD_PAGE_UP
; break; /* kpp sun */
872 case 222: kbd
.key
= KBD_PAGE_DOWN
; break; /* knp sun */
873 case 249: kbd
.key
= KBD_DEL
; break; /* kdch1 */
876 case '~': switch (v
) { /* private */
877 case 1: kbd
.key
= KBD_HOME
; break; /* khome linux */
878 case 2: kbd
.key
= KBD_INS
; break; /* kich1 linux */
879 case 3: kbd
.key
= KBD_DEL
; break; /* kdch1 linux */
880 case 4: kbd
.key
= KBD_END
; break; /* kend linux */
881 case 5: kbd
.key
= KBD_PAGE_UP
; break; /* kpp linux */
882 case 6: kbd
.key
= KBD_PAGE_DOWN
; break; /* knp linux */
883 case 7: kbd
.key
= KBD_HOME
; break; /* khome rxvt */
884 case 8: kbd
.key
= KBD_END
; break; /* kend rxvt */
886 case 11: kbd
.key
= KBD_F1
; break; /* kf1 rxvt */
887 case 12: kbd
.key
= KBD_F2
; break; /* kf2 rxvt */
888 case 13: kbd
.key
= KBD_F3
; break; /* kf3 rxvt */
889 case 14: kbd
.key
= KBD_F4
; break; /* kf4 rxvt */
890 case 15: kbd
.key
= KBD_F5
; break; /* kf5 rxvt */
892 case 17: kbd
.key
= KBD_F6
; break; /* kf6 vt200 */
893 case 18: kbd
.key
= KBD_F7
; break; /* kf7 vt200 */
894 case 19: kbd
.key
= KBD_F8
; break; /* kf8 vt200 */
895 case 20: kbd
.key
= KBD_F9
; break; /* kf9 vt200 */
896 case 21: kbd
.key
= KBD_F10
; break; /* kf10 vt200 */
898 case 23: kbd
.key
= KBD_F11
; break; /* kf11 vt200 */
899 case 24: kbd
.key
= KBD_F12
; break; /* kf12 vt200 */
901 /* Give preference to F11 and F12 over shifted F1 and F2. */
903 case 23: kbd.key = KBD_F1; kbd.modifier = KBD_MOD_SHIFT; break;
904 case 24: kbd.key = KBD_F2; kbd.modifier = KBD_MOD_SHIFT; break;
907 case 25: kbd
.key
= KBD_F3
; kbd
.modifier
= KBD_MOD_SHIFT
; break;
908 case 26: kbd
.key
= KBD_F4
; kbd
.modifier
= KBD_MOD_SHIFT
; break;
910 case 28: kbd
.key
= KBD_F5
; kbd
.modifier
= KBD_MOD_SHIFT
; break;
911 case 29: kbd
.key
= KBD_F6
; kbd
.modifier
= KBD_MOD_SHIFT
; break;
913 case 31: kbd
.key
= KBD_F7
; kbd
.modifier
= KBD_MOD_SHIFT
; break;
914 case 32: kbd
.key
= KBD_F8
; kbd
.modifier
= KBD_MOD_SHIFT
; break;
915 case 33: kbd
.key
= KBD_F9
; kbd
.modifier
= KBD_MOD_SHIFT
; break;
916 case 34: kbd
.key
= KBD_F10
; kbd
.modifier
= KBD_MOD_SHIFT
; break;
918 case 200: itrm
->bracketed_pasting
= 1; break; /* xterm */
919 case 201: itrm
->bracketed_pasting
= 0; break; /* xterm */
923 case 'R': resize_terminal(); break; /* CPR u6 */
924 case 'M': /* (DL) kmous xterm */
926 el
= decode_terminal_mouse_escape_sequence(itrm
, ev
, el
, v
);
927 #endif /* CONFIG_MOUSE */
931 /* KBD_UNDEF here means it was unrecognized or a mouse event. */
932 if (kbd
.key
!= KBD_UNDEF
)
933 set_kbd_interlink_event(ev
, kbd
.key
, kbd
.modifier
);
938 /** Decode an escape sequence that begins with SS3 (SINGLE SHIFT 3).
939 * These are used for application cursor keys and the application keypad.
941 * - -1 if the escape sequence is not yet complete; the caller sets a timer.
942 * - 0 if the escape sequence should be parsed by some other function.
943 * - The length of the escape sequence otherwise.
944 * Returning >0 does not imply this function has altered @a *ev. */
946 decode_terminal_application_key(struct itrm
*itrm
, struct interlink_event
*ev
)
949 struct interlink_event_keyboard kbd
= { KBD_UNDEF
, KBD_MOD_NONE
};
951 assert(itrm
->in
.queue
.len
>= 2);
952 assert(itrm
->in
.queue
.data
[0] == ASCII_ESC
);
953 assert(itrm
->in
.queue
.data
[1] == 0x4F); /* == 'O', incidentally */
954 if_assert_failed
return 0;
956 if (itrm
->in
.queue
.len
< 3) return -1;
957 /* According to ECMA-35 section 8.4, a single (possibly multibyte)
958 * character follows the SS3. We now assume the code identifies
959 * GL as the single-shift area and the designated set has 94
961 c
= itrm
->in
.queue
.data
[2];
962 if (c
< 0x21 || c
> 0x7E) return 0;
964 switch (c
) { /* Terminfo $TERM */
965 case ' ': kbd
.key
= ' '; break; /* xterm */
966 case 'A': kbd
.key
= KBD_UP
; break; /* kcuu1 vt100 */
967 case 'B': kbd
.key
= KBD_DOWN
; break; /* kcud1 vt100 */
968 case 'C': kbd
.key
= KBD_RIGHT
; break; /* kcuf1 vt100 */
969 case 'D': kbd
.key
= KBD_LEFT
; break; /* kcub1 vt100 */
970 case 'F': kbd
.key
= KBD_END
; break; /* kend xterm */
971 case 'H': kbd
.key
= KBD_HOME
; break; /* khome xterm */
972 case 'I': kbd
.key
= KBD_TAB
; break; /* xterm */
973 case 'M': kbd
.key
= KBD_ENTER
; break; /* kent vt100 */
974 /* FIXME: xterm generates ESC O 2 P for Shift-PF1 */
975 case 'P': kbd
.key
= KBD_F1
; break; /* kf1 vt100 */
976 case 'Q': kbd
.key
= KBD_F2
; break; /* kf2 vt100 */
977 case 'R': kbd
.key
= KBD_F3
; break; /* kf3 vt100 */
978 case 'S': kbd
.key
= KBD_F4
; break; /* kf4 vt100 */
979 case 'X': kbd
.key
= '='; break; /* xterm */
981 case 'j': case 'k': case 'l': case 'm': /* *+,- xterm */
982 case 'n': case 'o': case 'p': case 'q': /* ./01 xterm */
983 case 'r': case 's': case 't': case 'u': /* 2345 xterm */
984 case 'v': case 'w': case 'x': case 'y': /* 6789 xterm */
985 kbd
.key
= c
- 'p' + '0'; break;
987 if (kbd
.key
!= KBD_UNDEF
)
988 copy_struct(&ev
->info
.keyboard
, &kbd
);
990 return 3; /* even if we didn't recognize it */
994 /** Initialize @a *ev to match the byte @a key received from the terminal.
995 * @a key must not be a value from enum term_event_special_key. */
997 set_kbd_event(const struct itrm
*itrm
, struct interlink_event
*ev
,
998 int key
, term_event_modifier_T modifier
)
1000 if (key
== itrm
->verase
)
1006 case ASCII_DEL
: /* often overridden by itrm->verase above */
1018 case ASCII_BS
: /* often overridden by itrm->verase above */
1022 modifier
|= KBD_MOD_CTRL
;
1026 set_kbd_interlink_event(ev
, key
, modifier
);
1029 /** Timer callback for itrm.timer. As explained in install_timer(),
1030 * this function must erase the expired timer ID from all variables. */
1032 kbd_timeout(struct itrm
*itrm
)
1034 struct interlink_event ev
;
1037 itrm
->timer
= TIMER_ID_UNDEF
;
1038 /* The expired timer ID has now been erased. */
1040 assertm(itrm
->in
.queue
.len
, "timeout on empty queue");
1041 assert(!itrm
->blocked
); /* block_itrm should have killed itrm->timer */
1042 if_assert_failed
return;
1044 if (can_read(itrm
->in
.std
)) {
1049 if (itrm
->in
.queue
.len
>= 2 && itrm
->in
.queue
.data
[0] == ASCII_ESC
) {
1050 /* This is used for ESC [ and ESC O. */
1051 set_kbd_event(itrm
, &ev
, itrm
->in
.queue
.data
[1], KBD_MOD_ALT
);
1054 set_kbd_event(itrm
, &ev
, itrm
->in
.queue
.data
[0], KBD_MOD_NONE
);
1057 itrm
->bracketed_pasting
= 0;
1058 itrm_queue_event(itrm
, (char *) &ev
, sizeof(ev
));
1060 itrm
->in
.queue
.len
-= el
;
1061 if (itrm
->in
.queue
.len
)
1062 memmove(itrm
->in
.queue
.data
, itrm
->in
.queue
.data
+ el
, itrm
->in
.queue
.len
);
1064 while (process_queue(itrm
));
1067 /** Parse one event from itrm_in.queue and append to itrm_out.queue.
1068 * @pre On entry, @a *itrm must not be blocked.
1069 * @returns the number of bytes removed from itrm->in.queue; at least 0.
1070 * @post If this function leaves the queue not full, it also reenables
1071 * reading from itrm->in.std. (Because it does not add to the queue,
1072 * it never need disable reading.) */
1074 process_queue(struct itrm
*itrm
)
1076 struct interlink_event ev
;
1079 if (!itrm
->in
.queue
.len
) goto return_without_event
;
1080 assert(!itrm
->blocked
);
1081 if_assert_failed
return 0; /* unlike goto, don't enable reading */
1083 set_kbd_interlink_event(&ev
, KBD_UNDEF
, KBD_MOD_NONE
);
1085 #ifdef DEBUG_ITRM_QUEUE
1089 /* Dump current queue in a readable form to stderr. */
1090 for (i
= 0; i
< itrm
->in
.queue
.len
; i
++)
1091 if (itrm
->in
.queue
.data
[i
] == ASCII_ESC
)
1092 fprintf(stderr
, "ESC ");
1093 else if (isprint(itrm
->in
.queue
.data
[i
]) && !isspace(itrm
->in
.queue
.data
[i
]))
1094 fprintf(stderr
, "%c ", itrm
->in
.queue
.data
[i
]);
1096 fprintf(stderr
, "0x%02x ", itrm
->in
.queue
.data
[i
]);
1098 fprintf(stderr
, "\n");
1101 #endif /* DEBUG_ITRM_QUEUE */
1103 /* el == -1 means itrm->in.queue appears to be the beginning of an
1104 * escape sequence but it is not yet complete. Set a timer;
1105 * if it times out, then assume it wasn't an escape sequence
1107 * el == 0 means this function has not yet figured out what the data
1108 * in itrm->in.queue is, but some possibilities remain.
1109 * One of them will be chosen before returning.
1110 * el > 0 means some bytes were successfully parsed from the beginning
1111 * of itrm->in.queue and should now be removed from there.
1112 * However, this does not always imply an event will be queued.
1115 /* ELinks should also recognize U+009B CONTROL SEQUENCE INTRODUCER
1116 * as meaning the same as ESC 0x5B, and U+008F SINGLE SHIFT THREE as
1117 * meaning the same as ESC 0x4F, but those cannot yet be implemented
1118 * because of bug 777: the UTF-8 decoder is run too late. */
1119 if (itrm
->in
.queue
.data
[0] == ASCII_ESC
) {
1120 if (itrm
->in
.queue
.len
< 2) {
1122 } else if (itrm
->in
.queue
.data
[1] == 0x5B /* CSI */) {
1123 el
= decode_terminal_escape_sequence(itrm
, &ev
);
1124 } else if (itrm
->in
.queue
.data
[1] == 0x4F /* SS3 */) {
1125 el
= decode_terminal_application_key(itrm
, &ev
);
1126 } else if (itrm
->in
.queue
.data
[1] == ASCII_ESC
) {
1127 /* ESC ESC can be either Alt-Esc or the
1128 * beginning of e.g. ESC ESC 0x5B 0x41,
1129 * which we should parse as Esc Up. */
1130 if (itrm
->in
.queue
.len
< 3) {
1131 /* Need more data to figure it out. */
1133 } else if (itrm
->in
.queue
.data
[2] == 0x5B
1134 || itrm
->in
.queue
.data
[2] == 0x4F) {
1135 /* The first ESC appears to be followed
1136 * by an escape sequence. Treat it as
1137 * a standalone Esc. */
1139 set_kbd_event(itrm
, &ev
,
1140 itrm
->in
.queue
.data
[0],
1143 /* The second ESC of ESC ESC is not the
1144 * beginning of any known escape sequence.
1145 * This must be Alt-Esc, then. */
1147 set_kbd_event(itrm
, &ev
,
1148 itrm
->in
.queue
.data
[1],
1152 if (el
== 0) { /* Begins with ESC, but none of the above */
1154 set_kbd_event(itrm
, &ev
, itrm
->in
.queue
.data
[1],
1158 } else if (itrm
->in
.queue
.data
[0] == 0) {
1159 static const struct term_event_keyboard os2xtd
[256] = {
1160 #include "terminal/key.inc"
1163 if (itrm
->in
.queue
.len
< 2)
1167 set_kbd_interlink_event(&ev
,
1168 os2xtd
[itrm
->in
.queue
.data
[1]].key
,
1169 os2xtd
[itrm
->in
.queue
.data
[1]].modifier
);
1175 set_kbd_event(itrm
, &ev
, itrm
->in
.queue
.data
[0],
1176 itrm
->bracketed_pasting
? KBD_MOD_PASTE
: KBD_MOD_NONE
);
1179 /* The call to decode_terminal_escape_sequence() might have changed the
1180 * keyboard event to a mouse event. */
1181 if (ev
.ev
== EVENT_MOUSE
|| ev
.info
.keyboard
.key
!= KBD_UNDEF
) {
1182 itrm_queue_event(itrm
, (char *) &ev
, sizeof(ev
));
1183 itrm
->bracketed_pasting
=
1185 && (ev
.info
.keyboard
.modifier
& KBD_MOD_PASTE
));
1188 return_without_event
:
1190 install_timer(&itrm
->timer
, ESC_TIMEOUT
, (void (*)(void *)) kbd_timeout
,
1194 assertm(itrm
->in
.queue
.len
>= el
, "event queue underflow");
1195 if_assert_failed
{ itrm
->in
.queue
.len
= el
; }
1197 itrm
->in
.queue
.len
-= el
;
1198 if (itrm
->in
.queue
.len
)
1199 memmove(itrm
->in
.queue
.data
, itrm
->in
.queue
.data
+ el
, itrm
->in
.queue
.len
);
1201 if (itrm
->in
.queue
.len
< ITRM_IN_QUEUE_SIZE
)
1202 handle_itrm_stdin(itrm
);
1209 /** A select_handler_T read_func for itrm_in.std. This is called when
1210 * characters typed by the user arrive from the terminal. */
1212 in_kbd(struct itrm
*itrm
)
1216 if (!can_read(itrm
->in
.std
)) return;
1218 kill_timer(&itrm
->timer
);
1220 if (itrm
->in
.queue
.len
>= ITRM_IN_QUEUE_SIZE
) {
1221 unhandle_itrm_stdin(itrm
);
1222 while (process_queue(itrm
));
1226 r
= safe_read(itrm
->in
.std
, itrm
->in
.queue
.data
+ itrm
->in
.queue
.len
,
1227 ITRM_IN_QUEUE_SIZE
- itrm
->in
.queue
.len
);
1233 itrm
->in
.queue
.len
+= r
;
1234 if (itrm
->in
.queue
.len
> ITRM_IN_QUEUE_SIZE
) {
1235 ERROR(gettext("Too many bytes read from the itrm!"));
1236 itrm
->in
.queue
.len
= ITRM_IN_QUEUE_SIZE
;
1239 while (process_queue(itrm
));
1242 /** Enable reading from itrm_in.std. ELinks will read any available
1243 * bytes from the tty into itrm->in.queue and then parse them.
1244 * Reading should be enabled whenever itrm->in.queue is not full and
1245 * itrm->blocked is 0. */
1247 handle_itrm_stdin(struct itrm
*itrm
)
1249 assert(itrm
->in
.std
>= 0);
1250 if_assert_failed
return;
1252 set_handlers(itrm
->in
.std
, (select_handler_T
) in_kbd
, NULL
,
1253 (select_handler_T
) free_itrm
, itrm
);
1256 /** Disable reading from itrm_in.std. Reading should be disabled
1257 * whenever itrm->in.queue is full (there is no room for the data)
1258 * or itrm->blocked is 1 (other processes may read the data). */
1260 unhandle_itrm_stdin(struct itrm
*itrm
)
1262 assert(itrm
->in
.std
>= 0);
1263 if_assert_failed
return;
1265 set_handlers(itrm
->in
.std
, (select_handler_T
) NULL
, NULL
,
1266 (select_handler_T
) free_itrm
, itrm
);