diff options
| -rw-r--r-- | degesch.c | 1098 |
1 files changed, 652 insertions, 446 deletions
@@ -70,160 +70,256 @@ enum #include <ffi.h> -#ifdef HAVE_READLINE -#include <readline/readline.h> -#include <readline/history.h> -#endif // HAVE_READLINE - -#ifdef HAVE_EDITLINE -#include <histedit.h> -#endif // HAVE_EDITLINE - #ifdef HAVE_LUA #include <lua.h> #include <lualib.h> #include <lauxlib.h> #endif // HAVE_LUA -/// Some arbitrary limit for the history file -#define HISTORY_LIMIT 10000 +// --- Terminal information ---------------------------------------------------- -/// Characters that separate words -#define WORD_BREAKING_CHARS " \f\n\r\t\v" +static struct +{ + bool initialized; ///< Terminal is available + bool stdout_is_tty; ///< `stdout' is a terminal + bool stderr_is_tty; ///< `stderr' is a terminal -// --- User interface ---------------------------------------------------------- + struct termios termios; ///< Terminal attributes + char *color_set_fg[256]; ///< Codes to set the foreground colour + char *color_set_bg[256]; ///< Codes to set the background colour -// I'm not sure which one of these backends is worse: whether it's GNU Readline -// or BSD Editline. They both have their own annoying problems. + int lines; ///< Number of lines + int columns; ///< Number of columns +} +g_terminal; -struct input_buffer +static void +update_screen_size (void) { -#ifdef HAVE_READLINE - HISTORY_STATE *history; ///< Saved history state - char *saved_line; ///< Saved line content - int saved_mark; ///< Saved mark -#elif defined HAVE_EDITLINE - HistoryW *history; ///< The history object - wchar_t *saved_line; ///< Saved line content - int saved_len; ///< Length of the saved line -#endif // HAVE_EDITLINE - int saved_point; ///< Saved cursor position -}; +#ifdef TIOCGWINSZ + if (!g_terminal.stdout_is_tty) + return; -static struct input_buffer * -input_buffer_new (void) + struct winsize size; + if (!ioctl (STDOUT_FILENO, TIOCGWINSZ, (char *) &size)) + { + char *row = getenv ("LINES"); + char *col = getenv ("COLUMNS"); + unsigned long tmp; + g_terminal.lines = + (row && xstrtoul (&tmp, row, 10)) ? tmp : size.ws_row; + g_terminal.columns = + (col && xstrtoul (&tmp, col, 10)) ? tmp : size.ws_col; + } +#endif // TIOCGWINSZ +} + +static bool +init_terminal (void) { - struct input_buffer *self = xcalloc (1, sizeof *self); -#ifdef HAVE_EDITLINE - self->history = history_winit (); + int tty_fd = -1; + if ((g_terminal.stderr_is_tty = isatty (STDERR_FILENO))) + tty_fd = STDERR_FILENO; + if ((g_terminal.stdout_is_tty = isatty (STDOUT_FILENO))) + tty_fd = STDOUT_FILENO; - HistEventW ev; - history_w (self->history, &ev, H_SETSIZE, HISTORY_LIMIT); -#endif // HAVE_EDITLINE - return self; + int err; + if (tty_fd == -1 || setupterm (NULL, tty_fd, &err) == ERR) + return false; + + // Make sure all terminal features used by us are supported + if (!set_a_foreground || !set_a_background + || !enter_bold_mode || !exit_attribute_mode + || tcgetattr (tty_fd, &g_terminal.termios)) + { + del_curterm (cur_term); + return false; + } + + // Make sure newlines are output correctly + g_terminal.termios.c_oflag |= ONLCR; + (void) tcsetattr (tty_fd, TCSADRAIN, &g_terminal.termios); + + g_terminal.lines = tigetnum ("lines"); + g_terminal.columns = tigetnum ("cols"); + update_screen_size (); + + int max = MIN (256, max_colors); + for (int i = 0; i < max; i++) + { + g_terminal.color_set_fg[i] = xstrdup (tparm (set_a_foreground, + i, 0, 0, 0, 0, 0, 0, 0, 0)); + g_terminal.color_set_bg[i] = xstrdup (tparm (set_a_background, + i, 0, 0, 0, 0, 0, 0, 0, 0)); + } + return g_terminal.initialized = true; } static void -input_buffer_destroy (struct input_buffer *self) +free_terminal (void) { -#ifdef HAVE_READLINE - // Can't really free "history" contents from here - free (self->history); -#elif defined HAVE_EDITLINE - history_wend (self->history); -#endif // HAVE_EDITLINE - free (self->saved_line); - free (self); + if (!g_terminal.initialized) + return; + + for (int i = 0; i < 256; i++) + { + free (g_terminal.color_set_fg[i]); + free (g_terminal.color_set_bg[i]); + } + del_curterm (cur_term); } -typedef bool (*input_fn) (int count, int key, void *user_data); +// --- User interface ---------------------------------------------------------- -struct input_fn_data -{ - ffi_closure closure; ///< Closure +// I'm not sure which one of these backends is worse: whether it's GNU Readline +// or BSD Editline. They both have their own annoying problems. We use lots +// of hacks to get the results we want and need. +// +// The abstraction is a necessary evil. It's still not 100%, though. - LIST_HEADER (struct input_fn_data) - input_fn callback; ///< Real callback - void *user_data; ///< Real callback user data +/// Some arbitrary limit for the history +#define HISTORY_LIMIT 10000 -#ifdef HAVE_EDITLINE - wchar_t *name; ///< Function name - wchar_t *help; ///< Function help -#endif // HAVE_EDITLINE -}; +/// Characters that separate words +#define WORD_BREAKING_CHARS " \f\n\r\t\v" struct input { - bool active; ///< Are we a thing? + struct input_vtable *vtable; ///< Virtual methods + void *user_data; ///< User data for callbacks +}; -#if defined HAVE_READLINE - char *saved_line; ///< Saved line content - int saved_point; ///< Saved cursor position - int saved_mark; ///< Saved mark -#elif defined HAVE_EDITLINE - EditLine *editline; ///< The EditLine object -#endif // HAVE_EDITLINE - struct input_fn_data *fns; ///< Functions +typedef void *input_buffer_t; ///< Pointer alias for input buffers - char *prompt; ///< The prompt we use - int prompt_shown; ///< Whether the prompt is shown now +/// Named function that can be bound to a sequence of characters +typedef bool (*input_fn) (int count, int key, void *user_data); - struct input_buffer *current; ///< Current input buffer +// A little bit better than tons of forwarder functions in our case +#define CALL(self, name) ((self)->vtable->name ((self))) +#define CALL_(self, name, ...) ((self)->vtable->name ((self), __VA_ARGS__)) + +struct input_vtable +{ + /// Start the interface under the given program name + void (*start) (void *input, const char *program_name); + /// Stop the interface + void (*stop) (void *input); + /// Prepare or unprepare terminal for our needs + void (*prepare) (void *input, bool enabled); + /// Destroy the object + void (*destroy) (void *input); + + /// Hide the prompt if shown + void (*hide) (void *input); + /// Show the prompt if hidden + void (*show) (void *input); + /// Change the prompt string; takes ownership + const char *(*get_prompt) (void *input); + /// Change the prompt string; takes ownership + void (*set_prompt) (void *input, char *prompt); + /// Ring the terminal bell + void (*ding) (void *input); + + /// Create a new input buffer + input_buffer_t (*buffer_new) (void *input); + // XXX: there's also destroy_buffer + /// Destroy an input buffer + void (*buffer_destroy) (void *input, input_buffer_t buffer); + /// Switch to a different input buffer + void (*buffer_switch) (void *input, input_buffer_t buffer); + + /// Register a function that can be bound to character sequences + void (*register_fn) (void *input, + const char *name, const char *help, input_fn fn, void *user_data); + /// Bind an arbitrary sequence of characters to the given named function + void (*bind) (void *input, const char *seq, const char *fn); + /// Bind Ctrl+key to the given named function + void (*bind_control) (void *input, char key, const char *fn); + /// Bind Alt+key to the given named function + void (*bind_meta) (void *input, char key, const char *fn); + + /// Get the current line input + char *(*get_line) (void *input); + /// Clear the current line input + void (*clear_line) (void *input); + /// Insert text at current position + bool (*insert) (void *input, const char *text); + + /// Handle terminal resize + void (*on_tty_resized) (void *input); + /// Handle terminal input + void (*on_tty_readable) (void *input); }; -static void -input_init (struct input *self) -{ - memset (self, 0, sizeof *self); -} - -static void -input_free (struct input *self) -{ -#ifdef HAVE_READLINE - free (self->saved_line); -#endif // HAVE_READLINE - LIST_FOR_EACH (struct input_fn_data, iter, self->fns) - { -#ifdef HAVE_EDITLINE - free (iter->name); - free (iter->help); -#endif // HAVE_EDITLINE - ffi_closure_free (iter); - } - free (self->prompt); -} +#define INPUT_VTABLE(XX) \ + XX (start) XX (stop) XX (prepare) XX (destroy) \ + XX (hide) XX (show) XX (get_prompt) XX (set_prompt) XX (ding) \ + XX (buffer_new) XX (buffer_destroy) XX (buffer_switch) \ + XX (register_fn) XX (bind) XX (bind_control) XX (bind_meta) \ + XX (get_line) XX (clear_line) XX (insert) \ + XX (on_tty_resized) XX (on_tty_readable) // --- GNU Readline ------------------------------------------------------------ #ifdef HAVE_READLINE +#include <readline/readline.h> +#include <readline/history.h> + #define INPUT_START_IGNORE RL_PROMPT_START_IGNORE #define INPUT_END_IGNORE RL_PROMPT_END_IGNORE -#define input_ding(self) rl_ding () +struct input_rl_fn +{ + ffi_closure closure; ///< Closure + + LIST_HEADER (struct input_rl_fn) + input_fn callback; ///< Real callback + void *user_data; ///< Real callback user data +}; -static void -input_on_terminal_resized (struct input *self) +struct input_rl_buffer { - (void) self; + HISTORY_STATE *history; ///< Saved history state + char *saved_line; ///< Saved line content + int saved_point; ///< Saved cursor position + int saved_mark; ///< Saved mark +}; - // This fucks up big time on terminals with automatic wrapping such as - // rxvt-unicode or newer VTE when the current line overflows, however we - // can't do much about that - rl_resize_terminal (); -} +struct input_rl +{ + struct input super; ///< Parent class + + bool active; ///< Interface has been started + char *prompt; ///< The prompt we use + int prompt_shown; ///< Whether the prompt is shown now + + char *saved_line; ///< Saved line content + int saved_point; ///< Saved cursor position + int saved_mark; ///< Saved mark + + struct input_rl_fn *fns; ///< Named functions + struct input_rl_buffer *current; ///< Current input buffer +}; static void -input_on_readable (struct input *self) +input_rl_ding (void *input) { - (void) self; - rl_callback_read_char (); + (void) input; + rl_ding (); +} + +static const char * +input_rl_get_prompt (void *input) +{ + struct input_rl *self = input; + return self->prompt; } static void -input_set_prompt (struct input *self, char *prompt) +input_rl_set_prompt (void *input, char *prompt) { + struct input_rl *self = input; free (self->prompt); self->prompt = prompt; @@ -241,36 +337,54 @@ input_set_prompt (struct input *self, char *prompt) } static void -input_erase_content (struct input *self) +input_rl_clear_line (void *input) { - (void) self; - + (void) input; rl_replace_line ("", false); rl_redisplay (); } static void -input_erase (struct input *self) +input_rl__erase (struct input_rl *self) { - (void) self; - rl_set_prompt (""); - input_erase_content (self); + input_rl_clear_line (self); +} + +static bool +input_rl_insert (void *input, const char *s) +{ + struct input_rl *self = input; + rl_insert_text (s); + if (self->prompt_shown > 0) + rl_redisplay (); + + // GNU Readline, contrary to Editline, doesn't care about validity + return true; } +static char * +input_rl_get_line (void *input) +{ + (void) input; + return rl_copy_text (0, rl_end); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + static void -input_bind (struct input *self, const char *seq, const char *function_name) +input_rl_bind (void *input, const char *seq, const char *function_name) { - (void) self; + (void) input; rl_bind_keyseq (seq, rl_named_function (function_name)); } static void -input_bind_meta (struct input *self, char key, const char *function_name) +input_rl_bind_meta (void *input, char key, const char *function_name) { // This one seems to actually work char keyseq[] = { '\\', 'e', key, 0 }; - input_bind (self, keyseq, function_name); + input_rl_bind (input, keyseq, function_name); #if 0 // While this one only fucks up UTF-8 // Tested with urxvt and xterm, on Debian Jessie/Arch, default settings @@ -280,38 +394,18 @@ input_bind_meta (struct input *self, char key, const char *function_name) } static void -input_bind_control (struct input *self, char key, const char *function_name) +input_rl_bind_control (void *input, char key, const char *function_name) { char keyseq[] = { '\\', 'C', '-', key, 0 }; - input_bind (self, keyseq, function_name); + input_rl_bind (input, keyseq, function_name); } -static bool -input_insert (struct input *self, const char *s) -{ - rl_insert_text (s); - if (self->prompt_shown > 0) - rl_redisplay (); - - // GNU Readline, contrary to Editline, doesn't care about validity - return true; -} - -static char * -input_get_content (struct input *self) -{ - (void) self; - return rl_copy_text (0, rl_end); -} - -// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void -input_closure_forwarder (ffi_cif *cif, void *ret, void **args, void *user_data) +input_rl__forward (ffi_cif *cif, void *ret, void **args, void *user_data) { (void) cif; - struct input_fn_data *data = user_data; + struct input_rl_fn *data = user_data; if (!data->callback (*(int *) args[0], UNMETA (*(int *) args[1]), data->user_data)) rl_ding (); @@ -319,13 +413,14 @@ input_closure_forwarder (ffi_cif *cif, void *ret, void **args, void *user_data) } static void -input_add_fn (struct input *self, +input_rl_register_fn (void *input, const char *name, const char *help, input_fn callback, void *user_data) { + struct input_rl *self = input; (void) help; void *bound_fn = NULL; - struct input_fn_data *data = ffi_closure_alloc (sizeof *data, &bound_fn); + struct input_rl_fn *data = ffi_closure_alloc (sizeof *data, &bound_fn); hard_assert (data); static ffi_cif cif; @@ -337,7 +432,7 @@ input_add_fn (struct input *self, data->callback = callback; data->user_data = user_data; hard_assert (ffi_prep_closure_loc (&data->closure, - &cif, input_closure_forwarder, data, bound_fn) == FFI_OK); + &cif, input_rl__forward, data, bound_fn) == FFI_OK); rl_add_defun (name, (rl_command_func_t *) bound_fn, -1); LIST_PREPEND (self->fns, data); @@ -350,8 +445,9 @@ static void on_readline_input (char *line); static char **app_readline_completion (const char *text, int start, int end); static void -input_start (struct input *self, const char *program_name) +input_rl_start (void *input, const char *program_name) { + struct input_rl *self = input; using_history (); // This can cause memory leaks, or maybe even a segfault. Funny, eh? stifle_history (HISTORY_LIMIT); @@ -373,10 +469,11 @@ input_start (struct input *self, const char *program_name) } static void -input_stop (struct input *self) +input_rl_stop (void *input) { + struct input_rl *self = input; if (self->prompt_shown > 0) - input_erase (self); + input_rl__erase (self); // This is okay as long as we're not called from within readline rl_callback_handler_remove (); @@ -384,13 +481,23 @@ input_stop (struct input *self) self->prompt_shown = false; } +static void +input_rl_prepare (void *input, bool enabled) +{ + (void) input; + if (enabled) + rl_prep_terminal (true); + else + rl_deprep_terminal (); +} + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // The following part shows you why it's not a good idea to use // GNU Readline for this kind of software. Or for anything else, really. static void -input_save_buffer (struct input *self, struct input_buffer *buffer) +input_rl__save_buffer (struct input_rl *self, struct input_rl_buffer *buffer) { (void) self; @@ -405,7 +512,7 @@ input_save_buffer (struct input *self, struct input_buffer *buffer) } static void -input_restore_buffer (struct input *self, struct input_buffer *buffer) +input_rl__restore_buffer (struct input_rl *self, struct input_rl_buffer *buffer) { if (buffer->history) { @@ -442,8 +549,10 @@ input_restore_buffer (struct input *self, struct input_buffer *buffer) } static void -input_switch_buffer (struct input *self, struct input_buffer *buffer) +input_rl_buffer_switch (void *input, input_buffer_t input_buffer) { + struct input_rl *self = input; + struct input_rl_buffer *buffer = input_buffer; // There could possibly be occurences of the current undo list in some // history entry. We either need to free the undo list, or move it // somewhere else to load back later, as the buffer we're switching to @@ -452,7 +561,7 @@ input_switch_buffer (struct input *self, struct input_buffer *buffer) // Save this buffer's history so that it's independent for each buffer if (self->current) - input_save_buffer (self, self->current); + input_rl__save_buffer (self, self->current); else // Just throw it away; there should always be an active buffer however #if RL_READLINE_VERSION >= 0x0603 @@ -462,21 +571,30 @@ input_switch_buffer (struct input *self, struct input_buffer *buffer) clear_history (); #endif // RL_READLINE_VERSION < 0x0603 - input_restore_buffer (self, buffer); + input_rl__restore_buffer (self, buffer); self->current = buffer; } static void -input_destroy_buffer (struct input *self, struct input_buffer *buffer) +input_rl__buffer_destroy_wo_history (struct input_rl_buffer *self) { - (void) self; + free (self->history); + free (self->saved_line); + free (self); +} + +static void +input_rl_buffer_destroy (void *input, input_buffer_t input_buffer) +{ + (void) input; + struct input_rl_buffer *buffer = input_buffer; // rl_clear_history, being the only way I know of to get rid of the complete // history including attached data, is a pretty recent addition. *sigh* #if RL_READLINE_VERSION >= 0x0603 if (buffer->history) { - // See input_switch_buffer() for why we need to do this BS + // See input_rl_buffer_switch() for why we need to do this BS rl_free_undo_list (); // This is probably the only way we can free the history fully @@ -495,13 +613,25 @@ input_destroy_buffer (struct input *self, struct input_buffer *buffer) } #endif // RL_READLINE_VERSION - input_buffer_destroy (buffer); + input_rl__buffer_destroy_wo_history (buffer); +} + +static input_buffer_t +input_rl_buffer_new (void *input) +{ + (void) input; + struct input_rl_buffer *self = xcalloc (1, sizeof *self); + return self; } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +// Since {save,restore}_buffer() store history, we can't use them here like we +// do with libedit, because then buffer_destroy() can free memory that's still +// being used by readline. This situation is bound to happen on quit. + static void -input_save (struct input *self) +input_rl__save (struct input_rl *self) { hard_assert (!self->saved_line); @@ -511,7 +641,7 @@ input_save (struct input *self) } static void -input_restore (struct input *self) +input_rl__restore (struct input_rl *self) { hard_assert (self->saved_line); @@ -526,100 +656,146 @@ input_restore (struct input *self) // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void -input_hide (struct input *self) +input_rl_hide (void *input) { + struct input_rl *self = input; if (!self->active || self->prompt_shown-- < 1) return; - input_save (self); - input_erase (self); + input_rl__save (self); + input_rl__erase (self); } static void -input_show (struct input *self) +input_rl_show (void *input) { + struct input_rl *self = input; if (!self->active || ++self->prompt_shown < 1) return; - input_restore (self); + input_rl__restore (self); rl_redisplay (); } +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static void +input_rl_on_tty_resized (void *input) +{ + (void) input; + // This fucks up big time on terminals with automatic wrapping such as + // rxvt-unicode or newer VTE when the current line overflows, however we + // can't do much about that + rl_resize_terminal (); +} + +static void +input_rl_on_tty_readable (void *input) +{ + (void) input; + rl_callback_read_char (); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static void +input_rl_destroy (void *input) +{ + struct input_rl *self = input; + free (self->saved_line); + LIST_FOR_EACH (struct input_rl_fn, iter, self->fns) + ffi_closure_free (iter); + free (self->prompt); + free (self); +} + +#define XX(a) .a = input_rl_ ## a, +static struct input_vtable input_rl_vtable = { INPUT_VTABLE (XX) }; +#undef XX + +static struct input * +input_rl_new (void) +{ + struct input_rl *self = xcalloc (1, sizeof *self); + self->super.vtable = &input_rl_vtable; + return &self->super; +} + +#define input_new input_rl_new #endif // HAVE_READLINE // --- BSD Editline ------------------------------------------------------------ #ifdef HAVE_EDITLINE +#include <histedit.h> + #define INPUT_START_IGNORE '\x01' #define INPUT_END_IGNORE '\x01' -static void app_editline_init (struct input *self); - -static void -input_ding (struct input *self) +struct input_el_fn { - (void) self; + ffi_closure closure; ///< Closure - // XXX: this isn't probably very portable; - // we could use "bell" from terminfo but that creates a dependency - write (STDOUT_FILENO, "\a", 1); -} + LIST_HEADER (struct input_el_fn) + input_fn callback; ///< Real callback + void *user_data; ///< Real callback user data -static void -input_on_terminal_resized (struct input *self) -{ - el_resize (self->editline); -} + wchar_t *name; ///< Function name + wchar_t *help; ///< Function help +}; -static void -input_bind (struct input *self, const char *seq, const char *function_name) +struct input_el_buffer { - el_set (self->editline, EL_BIND, seq, function_name, NULL); -} + HistoryW *history; ///< The history object + wchar_t *saved_line; ///< Saved line content + int saved_len; ///< Length of the saved line + int saved_point; ///< Saved cursor position +}; -static void -input_bind_meta (struct input *self, char key, const char *function_name) +struct input_el { - char keyseq[] = { 'M', '-', key, 0 }; - input_bind (self, keyseq, function_name); -} + struct input super; ///< Parent class + EditLine *editline; ///< The EditLine object -static void -input_bind_control (struct input *self, char key, const char *function_name) + bool active; ///< Are we a thing? + char *prompt; ///< The prompt we use + int prompt_shown; ///< Whether the prompt is shown now + + struct input_el_fn *fns; ///< Named functions + struct input_el_buffer *current; ///< Current input buffer +}; + +static void app_editline_init (struct input_el *self); + +static int +input_el__get_termios (int character, int fallback) { - char keyseq[] = { '^', key, 0 }; - input_bind (self, keyseq, function_name); + if (!g_terminal.initialized) + return fallback; + + cc_t value = g_terminal.termios.c_cc[character]; + if (value == _POSIX_VDISABLE) + return fallback; + return value; } static void -input_redisplay (struct input *self) +input_el__redisplay (void *input) { // See rl_redisplay() - // The character is VREPRINT (usually C-r) - // TODO: read it from terminal info - // XXX: could we potentially break UTF-8 with this? - char x[] = { ('R' - 'A' + 1), 0 }; + struct input_el *self = input; + char x[] = { input_el__get_termios (VREPRINT, 'R' - 0x40), 0 }; el_push (self->editline, x); // We have to do this or it gets stuck and nothing is done (void) el_gets (self->editline, NULL); } -static void -input_set_prompt (struct input *self, char *prompt) -{ - free (self->prompt); - self->prompt = prompt; - - if (self->prompt_shown > 0) - input_redisplay (self); -} - static char * -input_make_prompt (EditLine *editline) +input_el__make_prompt (EditLine *editline) { - struct input *self; + struct input_el *self; el_get (editline, EL_CLIENTDATA, &self); if (!self->prompt) return ""; @@ -627,42 +803,74 @@ input_make_prompt (EditLine *editline) } static char * -input_make_empty_prompt (EditLine *editline) +input_el__make_empty_prompt (EditLine *editline) { (void) editline; return ""; } +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + static void -input_erase_content (struct input *self) +input_el_ding (void *input) +{ + // XXX: this isn't probably very portable; + // we could use "bell" from terminfo but that creates a dependency + (void) input; + write (STDOUT_FILENO, "\a", 1); +} + +static const char * +input_el_get_prompt (void *input) { + struct input_el *self = input; + return self->prompt; +} + +static void +input_el_set_prompt (void *input, char *prompt) +{ + struct input_el *self = input; + free (self->prompt); + self->prompt = prompt; + + if (self->prompt_shown > 0) + input_el__redisplay (self); +} + +static void +input_el_clear_line (void *input) +{ + struct input_el *self = input; const LineInfoW *info = el_wline (self->editline); int len = info->lastchar - info->buffer; int point = info->cursor - info->buffer; el_cursor (self->editline, len - point); el_wdeletestr (self->editline, len); - input_redisplay (self); + input_el__redisplay (self); } static void -input_erase (struct input *self) +input_el__erase (struct input_el *self) { - el_set (self->editline, EL_PROMPT, input_make_empty_prompt); - input_erase_content (self); + el_set (self->editline, EL_PROMPT, input_el__make_empty_prompt); + input_el_clear_line (self); } static bool -input_insert (struct input *self, const char *s) +input_el_insert (void *input, const char *s) { + struct input_el *self = input; bool success = !*s || !el_insertstr (self->editline, s); if (self->prompt_shown > 0) - input_redisplay (self); + input_el__redisplay (self); return success; } static char * -input_get_content (struct input *self) +input_el_get_line (void *input) { + struct input_el *self = input; const LineInfo *info = el_line (self->editline); return xstrndup (info->buffer, info->lastchar - info->buffer); } @@ -670,11 +878,32 @@ input_get_content (struct input *self) // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void -input_closure_forwarder (ffi_cif *cif, void *ret, void **args, void *user_data) +input_el_bind (void *input, const char *seq, const char *function_name) +{ + struct input_el *self = input; + el_set (self->editline, EL_BIND, seq, function_name, NULL); +} + +static void +input_el_bind_meta (void *input, char key, const char *function_name) +{ + char keyseq[] = { 'M', '-', key, 0 }; + input_el_bind (input, keyseq, function_name); +} + +static void +input_el_bind_control (void *input, char key, const char *function_name) +{ + char keyseq[] = { '^', key, 0 }; + input_el_bind (input, keyseq, function_name); +} + +static void +input_el__forward (ffi_cif *cif, void *ret, void **args, void *user_data) { (void) cif; - struct input_fn_data *data = user_data; + struct input_el_fn *data = user_data; *(unsigned char *) ret = data->callback (1, *(int *) args[1], data->user_data) ? CC_NORM : CC_ERROR; } @@ -690,11 +919,11 @@ ascii_to_wide (const char *ascii) } static void -input_add_fn (struct input *self, +input_el_register_fn (void *input, const char *name, const char *help, input_fn callback, void *user_data) { void *bound_fn = NULL; - struct input_fn_data *data = ffi_closure_alloc (sizeof *data, &bound_fn); + struct input_el_fn *data = ffi_closure_alloc (sizeof *data, &bound_fn); hard_assert (data); static ffi_cif cif; @@ -707,8 +936,9 @@ input_add_fn (struct input *self, data->name = ascii_to_wide (name); data->help = ascii_to_wide (help); hard_assert (ffi_prep_closure_loc (&data->closure, - &cif, input_closure_forwarder, data, bound_fn) == FFI_OK); + &cif, input_el__forward, data, bound_fn) == FFI_OK); + struct input_el *self = input; el_wset (self->editline, EL_ADDFN, data->name, data->help, bound_fn); LIST_PREPEND (self->fns, data); } @@ -716,12 +946,13 @@ input_add_fn (struct input *self, // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void -input_start (struct input *self, const char *program_name) +input_el_start (void *input, const char *program_name) { + struct input_el *self = input; self->editline = el_init (program_name, stdin, stdout, stderr); el_set (self->editline, EL_CLIENTDATA, self); el_set (self->editline, EL_PROMPT_ESC, - input_make_prompt, INPUT_START_IGNORE); + input_el__make_prompt, INPUT_START_IGNORE); el_set (self->editline, EL_SIGNAL, false); el_set (self->editline, EL_UNBUFFERED, true); el_set (self->editline, EL_EDITOR, "emacs"); @@ -733,10 +964,11 @@ input_start (struct input *self, const char *program_name) } static void -input_stop (struct input *self) +input_el_stop (void *input) { + struct input_el *self = input; if (self->prompt_shown > 0) - input_erase (self); + input_el__erase (self); el_end (self->editline); self->editline = NULL; @@ -744,10 +976,17 @@ input_stop (struct input *self) self->prompt_shown = false; } +static void +input_el_prepare (void *input, bool enabled) +{ + struct input_el *self = input; + el_set (self->editline, EL_PREP_TERM, enabled); +} + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void -input_save_buffer (struct input *self, struct input_buffer *buffer) +input_el__save_buffer (struct input_el *self, struct input_el_buffer *buffer) { const LineInfoW *info = el_wline (self->editline); int len = info->lastchar - info->buffer; @@ -764,7 +1003,14 @@ input_save_buffer (struct input *self, struct input_buffer *buffer) } static void -input_restore_buffer (struct input *self, struct input_buffer *buffer) +input_el__save (struct input_el *self) +{ + if (self->current) + input_el__save_buffer (self, self->current); +} + +static void +input_el__restore_buffer (struct input_el *self, struct input_el_buffer *buffer) { if (buffer->saved_line) { @@ -777,70 +1023,92 @@ input_restore_buffer (struct input *self, struct input_buffer *buffer) } static void -input_switch_buffer (struct input *self, struct input_buffer *buffer) +input_el__restore (struct input_el *self) { if (self->current) - input_save_buffer (self, self->current); - - input_restore_buffer (self, buffer); - el_wset (self->editline, EL_HIST, history, buffer->history); - self->current = buffer; -} - -static void -input_destroy_buffer (struct input *self, struct input_buffer *buffer) -{ - (void) self; - input_buffer_destroy (buffer); + input_el__restore_buffer (self, self->current); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void -input_save (struct input *self) +input_el_buffer_switch (void *input, input_buffer_t input_buffer) { + struct input_el *self = input; + struct input_el_buffer *buffer = input_buffer; + if (self->current) - input_save_buffer (self, self->current); + input_el__save_buffer (self, self->current); + + input_el__restore_buffer (self, buffer); + el_wset (self->editline, EL_HIST, history, buffer->history); + self->current = buffer; } static void -input_restore (struct input *self) +input_el_buffer_destroy (void *input, input_buffer_t input_buffer) { - if (self->current) - input_restore_buffer (self, self->current); + (void) input; + struct input_el_buffer *buffer = input_buffer; + + history_wend (buffer->history); + free (buffer->saved_line); + free (buffer); +} + +static input_buffer_t +input_el_buffer_new (void *input) +{ + (void) input; + struct input_el_buffer *self = xcalloc (1, sizeof *self); + self->history = history_winit (); + + HistEventW ev; + history_w (self->history, &ev, H_SETSIZE, HISTORY_LIMIT); + return self; } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void -input_hide (struct input *self) +input_el_hide (void *input) { + struct input_el *self = input; if (!self->active || self->prompt_shown-- < 1) return; - input_save (self); - input_erase (self); + input_el__save (self); + input_el__erase (self); } static void -input_show (struct input *self) +input_el_show (void *input) { + struct input_el *self = input; if (!self->active || ++self->prompt_shown < 1) return; - input_restore (self); + input_el__restore (self); // XXX: the ignore doesn't quite work, see https://gnats.netbsd.org/47539 el_set (self->editline, - EL_PROMPT_ESC, input_make_prompt, INPUT_START_IGNORE); - input_redisplay (self); + EL_PROMPT_ESC, input_el__make_prompt, INPUT_START_IGNORE); + input_el__redisplay (self); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void -input_on_readable (struct input *self) +input_el_on_tty_resized (void *input) +{ + struct input_el *self = input; + el_resize (self->editline); +} + +static void +input_el_on_tty_readable (void *input) { // We bind the return key to process it how we need to + struct input_el *self = input; // el_gets() with EL_UNBUFFERED doesn't work with UTF-8, // we must use the wide-character interface @@ -849,16 +1117,43 @@ input_on_readable (struct input *self) if (!buf || count-- <= 0) return; - // The character is VEOF (usually C-d) - // TODO: read it from terminal info - if (count == 0 && buf[0] == ('D' - 'A' + 1)) + if (count == 0 && buf[0] == ('D' - 0x40) /* hardcoded VEOF in editline */) { el_deletestr (self->editline, 1); - input_redisplay (self); - input_ding (self); + input_el__redisplay (self); + input_el_ding (self); } } +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static void +input_el_destroy (void *input) +{ + struct input_el *self = input; + LIST_FOR_EACH (struct input_el_fn, iter, self->fns) + { + free (iter->name); + free (iter->help); + ffi_closure_free (iter); + } + free (self->prompt); + free (self); +} + +#define XX(a) .a = input_el_ ## a, +static struct input_vtable input_el_vtable = { INPUT_VTABLE (XX) }; +#undef XX + +static struct input * +input_el_new (void) +{ + struct input_el *self = xcalloc (1, sizeof *self); + self->super.vtable = &input_el_vtable; + return &self->super; +} + +#define input_new input_el_new #endif // HAVE_EDITLINE // --- Application data -------------------------------------------------------- @@ -1198,7 +1493,8 @@ struct buffer enum buffer_type type; ///< Type of the buffer char *name; ///< The name of the buffer - struct input_buffer *input_data; ///< User interface data + struct input *input; ///< API for "input_data" + input_buffer_t input_data; ///< User interface data // Buffer contents: @@ -1220,11 +1516,12 @@ struct buffer }; static struct buffer * -buffer_new (void) +buffer_new (struct input *input) { struct buffer *self = xcalloc (1, sizeof *self); self->ref_count = 1; - self->input_data = input_buffer_new (); + self->input = input; + self->input_data = CALL (input, buffer_new); return self; } @@ -1233,7 +1530,15 @@ buffer_destroy (struct buffer *self) { free (self->name); if (self->input_data) - input_buffer_destroy (self->input_data); + { +#ifdef HAVE_READLINE + // FIXME: can't really free "history" contents from here, as we cannot + // be sure that the user interface pointer is valid and usable + input_rl__buffer_destroy_wo_history (self->input_data); +#else // ! HAVE_READLINE + CALL_ (self->input, buffer_destroy, self->input_data); +#endif // ! HAVE_READLINE + } LIST_FOR_EACH (struct buffer_line, iter, self->lines) buffer_line_destroy (iter); if (self->log_file) @@ -1667,7 +1972,7 @@ struct app_context iconv_t term_from_utf8; ///< UTF-8 to terminal encoding iconv_t latin1_to_utf8; ///< ISO Latin 1 to UTF-8 - struct input input; ///< User interface + struct input *input; ///< User interface struct poller_idle input_event; ///< Pending input event struct str_vector pending_input; ///< Pending input lines @@ -1751,7 +2056,7 @@ app_context_init (struct app_context *self) free (encoding); - input_init (&self->input); + self->input = input_new (); str_vector_init (&self->pending_input); str_init (&self->input_buffer); @@ -1776,7 +2081,8 @@ app_context_free (struct app_context *self) LIST_FOR_EACH (struct buffer, iter, self->buffers) { #ifdef HAVE_READLINE - input_destroy_buffer (&self->input, iter->input_data); + // We can use the user interface here; see buffer_destroy() + CALL_ (self->input, buffer_destroy, iter->input_data); iter->input_data = NULL; #endif // HAVE_READLINE buffer_unref (iter); @@ -1790,7 +2096,7 @@ app_context_free (struct app_context *self) iconv_close (self->term_from_utf8); iconv_close (self->term_to_utf8); - input_free (&self->input); + CALL (self->input, destroy); str_vector_free (&self->pending_input); str_free (&self->input_buffer); @@ -2198,102 +2504,6 @@ serialize_configuration (struct config_item *root, struct str *output) #define COLOR_256(name, c256) \ (((COLOR_ ## name) & 0xFFFF) | (((c256) & 0xFFFF) << 16)) -static struct -{ - bool initialized; ///< Terminal is available - bool stdout_is_tty; ///< `stdout' is a terminal - bool stderr_is_tty; ///< `stderr' is a terminal - - char *color_set_fg[256]; ///< Codes to set the foreground colour - char *color_set_bg[256]; ///< Codes to set the background colour - - int lines; ///< Number of lines - int columns; ///< Number of columns -} -g_terminal; - -static void -update_screen_size (void) -{ -#ifdef TIOCGWINSZ - if (!g_terminal.stdout_is_tty) - return; - - struct winsize size; - if (!ioctl (STDOUT_FILENO, TIOCGWINSZ, (char *) &size)) - { - char *row = getenv ("LINES"); - char *col = getenv ("COLUMNS"); - unsigned long tmp; - g_terminal.lines = - (row && xstrtoul (&tmp, row, 10)) ? tmp : size.ws_row; - g_terminal.columns = - (col && xstrtoul (&tmp, col, 10)) ? tmp : size.ws_col; - } -#endif // TIOCGWINSZ -} - -static bool -init_terminal (void) -{ - int tty_fd = -1; - if ((g_terminal.stderr_is_tty = isatty (STDERR_FILENO))) - tty_fd = STDERR_FILENO; - if ((g_terminal.stdout_is_tty = isatty (STDOUT_FILENO))) - tty_fd = STDOUT_FILENO; - - int err; - if (tty_fd == -1 || setupterm (NULL, tty_fd, &err) == ERR) - return false; - - // Make sure all terminal features used by us are supported - if (!set_a_foreground || !set_a_background - || !enter_bold_mode || !exit_attribute_mode) - { - del_curterm (cur_term); - return false; - } - - // Make sure newlines are output correctly - struct termios termios; - if (!tcgetattr (tty_fd, &termios)) - { - termios.c_oflag |= ONLCR; - (void) tcsetattr (tty_fd, TCSADRAIN, &termios); - } - - g_terminal.lines = tigetnum ("lines"); - g_terminal.columns = tigetnum ("cols"); - update_screen_size (); - - int max = MIN (256, max_colors); - for (int i = 0; i < max; i++) - { - g_terminal.color_set_fg[i] = xstrdup (tparm (set_a_foreground, - i, 0, 0, 0, 0, 0, 0, 0, 0)); - g_terminal.color_set_bg[i] = xstrdup (tparm (set_a_background, - i, 0, 0, 0, 0, 0, 0, 0, 0)); - } - - return g_terminal.initialized = true; -} - -static void -free_terminal (void) -{ - if (!g_terminal.initialized) - return; - - for (int i = 0; i < 256; i++) - { - free (g_terminal.color_set_fg[i]); - free (g_terminal.color_set_bg[i]); - } - del_curterm (cur_term); -} - -// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - typedef int (*terminal_printer_fn) (int); static int @@ -2346,13 +2556,13 @@ log_message_attributed (void *user_data, const char *quote, const char *fmt, FILE *stream = stderr; struct app_context *ctx = g_ctx; - input_hide (&ctx->input); + CALL (ctx->input, hide); print_attributed (ctx, stream, (intptr_t) user_data, "%s", quote); vprint_attributed (ctx, stream, (intptr_t) user_data, fmt, ap); fputs ("\n", stream); - input_show (&ctx->input); + CALL (ctx->input, show); } static ssize_t @@ -3216,11 +3426,11 @@ buffer_line_display (struct app_context *ctx, FORMATTER_ADD_ITEM (&f, IGNORE_ATTR, .attribute = 1); } - input_hide (&ctx->input); + CALL (ctx->input, hide); buffer_line_flush (line, &f, stdout, false); // Flush the trailing formatting reset item fflush (stdout); - input_show (&ctx->input); + CALL (ctx->input, show); } static void @@ -3289,7 +3499,7 @@ log_formatter (struct app_context *ctx, && !(flags & BUFFER_LINE_UNIMPORTANT); bool important = (flags & BUFFER_LINE_HIGHLIGHT) || unseen_pm; if (ctx->beep_on_highlight && important) - input_ding (&ctx->input); + CALL (ctx->input, ding); bool can_leak = false; if ((buffer == ctx->global_buffer) @@ -3487,7 +3697,7 @@ buffer_remove (struct app_context *ctx, struct buffer *buffer) hard_assert (buffer != ctx->current_buffer); hard_assert (buffer != ctx->global_buffer); - input_destroy_buffer (&ctx->input, buffer->input_data); + CALL_ (ctx->input, buffer_destroy, buffer->input_data); buffer->input_data = NULL; // And make sure to unlink the buffer from "irc_buffer_map" @@ -3525,7 +3735,7 @@ static void buffer_print_backlog (struct app_context *ctx, struct buffer *buffer) { // The prompt can take considerable time to redraw - input_hide (&ctx->input); + CALL (ctx->input, hide); // That is, minus the readline prompt int display_limit = MAX (10, g_terminal.lines - 1); @@ -3575,7 +3785,7 @@ buffer_print_backlog (struct app_context *ctx, struct buffer *buffer) buffer_update_time (ctx, time (NULL)); refresh_prompt (ctx); - input_show (&ctx->input); + CALL (ctx->input, show); } static void @@ -3585,7 +3795,7 @@ buffer_activate (struct app_context *ctx, struct buffer *buffer) return; buffer_print_backlog (ctx, buffer); - input_switch_buffer (&ctx->input, buffer->input_data); + CALL_ (ctx->input, buffer_switch, buffer->input_data); // Now at last we can switch the pointers ctx->last_buffer = ctx->current_buffer; @@ -3736,7 +3946,7 @@ buffer_remove_safe (struct app_context *ctx, struct buffer *buffer) static void init_global_buffer (struct app_context *ctx) { - struct buffer *global = ctx->global_buffer = buffer_new (); + struct buffer *global = ctx->global_buffer = buffer_new (ctx->input); global->type = BUFFER_GLOBAL; global->name = xstrdup (PROGRAM_NAME); @@ -3786,7 +3996,7 @@ irc_get_or_make_user_buffer (struct server *s, const char *nickname) struct user *user = irc_get_or_make_user (s, nickname); // Open a new buffer for the user - buffer = buffer_new (); + buffer = buffer_new (s->ctx->input); buffer->type = BUFFER_PM; buffer->name = xstrdup_printf ("%s.%s", s->name, nickname); buffer->server = s; @@ -4202,7 +4412,7 @@ initiate_quit (struct app_context *ctx) log_global_status (ctx, "Shutting down"); // Hide the user interface - input_hide (&ctx->input); + CALL (ctx->input, hide); // Initiate a connection close struct str_map_iter iter; @@ -5281,10 +5491,11 @@ static void input_maybe_set_prompt (struct input *self, char *new_prompt) { // Redisplay can be an expensive operation - if (self->prompt && !strcmp (new_prompt, self->prompt)) + const char *prompt = CALL (self, get_prompt); + if (prompt && !strcmp (new_prompt, prompt)) free (new_prompt); else - input_set_prompt (self, new_prompt); + CALL_ (self, set_prompt, new_prompt); } static void @@ -5302,7 +5513,7 @@ refresh_prompt (struct app_context *ctx) if (have_attributes) { // XXX: to be completely correct, we should use tputs, but we cannot - input_maybe_set_prompt (&ctx->input, xstrdup_printf ("%c%s%c%s%c%s%c", + input_maybe_set_prompt (ctx->input, xstrdup_printf ("%c%s%c%s%c%s%c", INPUT_START_IGNORE, ctx->attrs[ATTR_PROMPT], INPUT_END_IGNORE, localized, @@ -5311,7 +5522,7 @@ refresh_prompt (struct app_context *ctx) free (localized); } else - input_maybe_set_prompt (&ctx->input, localized); + input_maybe_set_prompt (ctx->input, localized); } // --- Helpers ----------------------------------------------------------------- @@ -5829,7 +6040,7 @@ irc_handle_join (struct server *s, const struct irc_message *msg) // We've joined a new channel if (!channel && irc_is_this_us (s, msg->prefix)) { - buffer = buffer_new (); + buffer = buffer_new (s->ctx->input); buffer->type = BUFFER_CHANNEL; buffer->name = xstrdup_printf ("%s.%s", s->name, channel_name); buffer->server = s; @@ -7462,7 +7673,7 @@ server_add (struct app_context *ctx, s->config = subtree; // Add a buffer and activate it - struct buffer *buffer = s->buffer = buffer_new (); + struct buffer *buffer = s->buffer = buffer_new (ctx->input); buffer->type = BUFFER_SERVER; buffer->name = xstrdup (s->name); buffer->server = s; @@ -11241,15 +11452,11 @@ suspend_terminal (struct app_context *ctx) if (ctx->terminal_suspended++ > 0) return; -#ifdef HAVE_READLINE - rl_deprep_terminal (); -#elif defined (HAVE_EDITLINE) - el_set (ctx->input.editline, EL_PREP_TERM, 0); -#endif - toggle_bracketed_paste (false); - input_hide (&ctx->input); + CALL (ctx->input, hide); poller_fd_reset (&ctx->tty_event); + + CALL_ (ctx->input, prepare, false); } static void @@ -11259,18 +11466,14 @@ resume_terminal (struct app_context *ctx) return; update_screen_size (); -#ifdef HAVE_READLINE - rl_prep_terminal (true); -#elif defined (HAVE_EDITLINE) - el_set (ctx->input.editline, EL_PREP_TERM, 1); -#endif + CALL_ (ctx->input, prepare, true); toggle_bracketed_paste (true); // In theory we could just print all unseen messages but this is safer buffer_print_backlog (ctx, ctx->current_buffer); // Now it's safe to process any user input poller_fd_set (&ctx->tty_event, POLLIN); - input_show (&ctx->input); + CALL (ctx->input, show); } static pid_t @@ -11302,15 +11505,13 @@ spawn_helper_child (struct app_context *ctx) static void redraw_screen (struct app_context *ctx) { - input_hide (&ctx->input); - // If by some circumstance we had the wrong idea - input_on_terminal_resized (&ctx->input); + CALL (ctx->input, on_tty_resized); update_screen_size (); + CALL (ctx->input, hide); buffer_print_backlog (ctx, ctx->current_buffer); - - input_show (&ctx->input); + CALL (ctx->input, show); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -11325,7 +11526,7 @@ dump_input_to_file (struct app_context *ctx, char *template, struct error **e) if (fd < 0) FAIL ("%s", strerror (errno)); - char *input = input_get_content (&ctx->input); + char *input = CALL (ctx->input, get_line); bool success = xwrite (fd, input, strlen (input), e); free (input); @@ -11402,9 +11603,9 @@ input_editor_process (struct app_context *ctx) error_free (e); } else - input_erase_content (&ctx->input); + CALL (ctx->input, clear_line); - if (!input_insert (&ctx->input, input.str)) + if (!CALL_ (ctx->input, insert, input.str)) log_global_error (ctx, "#s: #s", "Input editing failed", "could not re-insert the modified text"); @@ -11589,8 +11790,8 @@ on_start_paste_mode (int count, int key, void *user_data) static void bind_common_keys (struct app_context *ctx) { - struct input *self = &ctx->input; -#define XX(...) input_add_fn (self, __VA_ARGS__, ctx); + struct input *self = ctx->input; +#define XX(...) CALL_ (self, register_fn, __VA_ARGS__, ctx); XX ("previous-buffer", "Previous buffer", on_previous_buffer) XX ("next-buffer", "Next buffer", on_next_buffer) XX ("goto-buffer", "Go to buffer", on_goto_buffer) @@ -11603,26 +11804,26 @@ bind_common_keys (struct app_context *ctx) XX ("start-paste-mode", "Bracketed paste", on_start_paste_mode) #undef XX - input_bind_control (self, 'p', "previous-buffer"); - input_bind_control (self, 'n', "next-buffer"); + CALL_ (self, bind_control, 'p', "previous-buffer"); + CALL_ (self, bind_control, 'n', "next-buffer"); // Redefine M-0 through M-9 to switch buffers for (int i = 0; i <= 9; i++) - input_bind_meta (self, '0' + i, "goto-buffer"); + CALL_ (self, bind_meta, '0' + i, "goto-buffer"); - input_bind_meta (self, '\t', "switch-buffer"); - input_bind_meta (self, 'm', "insert-attribute"); - input_bind_meta (self, 'h', "display-full-log"); - input_bind_meta (self, 'e', "edit-input"); + CALL_ (self, bind_meta, '\t', "switch-buffer"); + CALL_ (self, bind_meta, 'm', "insert-attribute"); + CALL_ (self, bind_meta, 'h', "display-full-log"); + CALL_ (self, bind_meta, 'e', "edit-input"); - if (key_f5) input_bind (self, key_f5, "previous-buffer"); - if (key_f6) input_bind (self, key_f6, "next-buffer"); - if (key_ppage) input_bind (self, key_ppage, "display-backlog"); + if (key_f5) CALL_ (self, bind, key_f5, "previous-buffer"); + if (key_f6) CALL_ (self, bind, key_f6, "next-buffer"); + if (key_ppage) CALL_ (self, bind, key_ppage, "display-backlog"); if (clear_screen) - input_bind_control (self, 'l', "redraw-screen"); + CALL_ (self, bind_control, 'l', "redraw-screen"); - input_bind (self, "\x1b[200~", "start-paste-mode"); + CALL_ (self, bind, "\x1b[200~", "start-paste-mode"); } // --- GNU Readline user actions ----------------------------------------------- @@ -11638,10 +11839,12 @@ on_readline_return (int count, int key) // Let readline pass the line to our input handler rl_done = 1; - // Hide the line, don't redisplay it struct app_context *ctx = g_ctx; - input_hide (&ctx->input); - input_restore (&ctx->input); + struct input_rl *self = (struct input_rl *) ctx->input; + + // Hide the line, don't redisplay it + CALL (ctx->input, hide); + input_rl__restore (self); return 0; } @@ -11649,6 +11852,7 @@ static void on_readline_input (char *line) { struct app_context *ctx = g_ctx; + struct input_rl *self = (struct input_rl *) ctx->input; if (line) { @@ -11663,15 +11867,15 @@ on_readline_input (char *line) else { // Prevent readline from showing the prompt twice for w/e reason - input_hide (&ctx->input); - input_restore (&ctx->input); + CALL (ctx->input, hide); + input_rl__restore (self); - input_ding (&ctx->input); + CALL (ctx->input, ding); } - if (ctx->input.active) + if (self->active) // Readline automatically redisplays it - ctx->input.prompt_shown = 1; + self->prompt_shown = 1; } static char ** @@ -11690,7 +11894,7 @@ static int app_readline_init (void) { struct app_context *ctx = g_ctx; - struct input *self = &ctx->input; + struct input *self = ctx->input; // XXX: maybe use rl_make_bare_keymap() and start from there; // our dear user could potentionally rig things up in a way that might @@ -11700,8 +11904,8 @@ app_readline_init (void) bind_common_keys (ctx); // Move native history commands - input_bind_meta (self, 'p', "previous-history"); - input_bind_meta (self, 'n', "next-history"); + CALL_ (self, bind_meta, 'p', "previous-history"); + CALL_ (self, bind_meta, 'n', "next-history"); // We need to hide the prompt and input first rl_bind_key (RETURN, rl_named_function ("send-line")); @@ -11709,7 +11913,7 @@ app_readline_init (void) rl_variable_bind ("completion-ignore-case", "on"); rl_bind_key (TAB, rl_named_function ("menu-complete")); if (key_btab) - input_bind (self, key_btab, "menu-complete-backward"); + CALL_ (self, bind, key_btab, "menu-complete-backward"); return 0; } @@ -11775,6 +11979,7 @@ on_editline_return (EditLine *editline, int key) { (void) key; struct app_context *ctx = g_ctx; + struct input_el *self = (struct input_el *) ctx->input; const LineInfoW *info = el_wline (editline); int len = info->lastchar - info->buffer; @@ -11788,7 +11993,7 @@ on_editline_return (EditLine *editline, int key) if (*line) { HistEventW ev; - history_w (ctx->input.current->history, &ev, H_ENTER, line); + history_w (self->current->history, &ev, H_ENTER, line); print_debug ("history: %d %ls", ev.num, ev.str); } free (line); @@ -11805,7 +12010,7 @@ on_editline_return (EditLine *editline, int key) } static void -app_editline_init (struct input *self) +app_editline_init (struct input_el *self) { // el_set() leaks memory in 20150325 and other versions, we need wchar_t el_wset (self->editline, EL_ADDFN, @@ -11814,20 +12019,21 @@ app_editline_init (struct input *self) L"complete", L"Complete word", on_editline_complete); bind_common_keys (g_ctx); + struct input *input = &self->super; // Move native history commands - input_bind_meta (self, 'p', "ed-prev-history"); - input_bind_meta (self, 'n', "ed-next-history"); + CALL_ (input, bind_meta, 'p', "ed-prev-history"); + CALL_ (input, bind_meta, 'n', "ed-next-history"); // No, editline, it's not supposed to kill the entire line - input_bind_control (self, 'w', "ed-delete-prev-word"); + CALL_ (input, bind_control, 'w', "ed-delete-prev-word"); // Just what are you doing? - input_bind_control (self, 'u', "vi-kill-line-prev"); + CALL_ (input, bind_control, 'u', "vi-kill-line-prev"); // We need to hide the prompt and input first - input_bind (self, "\n", "send-line"); + CALL_ (input, bind, "\n", "send-line"); - input_bind_control (self, 'i', "complete"); + CALL_ (input, bind_control, 'i', "complete"); // Source the user's defaults file el_source (self->editline, NULL); @@ -12157,14 +12363,14 @@ process_mirc_escape (const struct pollfd *fd, struct app_context *ctx) goto error; switch (buf->str[0]) { - case 'b': input_insert (&ctx->input, "\x02"); break; - case 'c': input_insert (&ctx->input, "\x03"); break; + case 'b': CALL_ (ctx->input, insert, "\x02"); break; + case 'c': CALL_ (ctx->input, insert, "\x03"); break; case 'i': - case ']': input_insert (&ctx->input, "\x1d"); break; + case ']': CALL_ (ctx->input, insert, "\x1d"); break; case 'u': - case '_': input_insert (&ctx->input, "\x1f"); break; - case 'v': input_insert (&ctx->input, "\x16"); break; - case 'o': input_insert (&ctx->input, "\x0f"); break; + case '_': CALL_ (ctx->input, insert, "\x1f"); break; + case 'v': CALL_ (ctx->input, insert, "\x16"); break; + case 'o': CALL_ (ctx->input, insert, "\x0f"); break; default: goto error; @@ -12172,7 +12378,7 @@ process_mirc_escape (const struct pollfd *fd, struct app_context *ctx) goto done; error: - input_ding (&ctx->input); + CALL (ctx->input, ding); done: str_reset (buf); ctx->awaiting_mirc_escape = false; @@ -12204,11 +12410,11 @@ process_bracketed_paste (const struct pollfd *fd, struct app_context *ctx) (text_len = BRACKETED_PASTE_LIMIT)); buf->str[text_len] = '\0'; - if (input_insert (&ctx->input, buf->str)) + if (CALL_ (ctx->input, insert, buf->str)) goto done; error: - input_ding (&ctx->input); + CALL (ctx->input, ding); log_global_error (ctx, "Paste failed"); done: str_reset (buf); @@ -12278,7 +12484,7 @@ on_tty_readable (const struct pollfd *fd, struct app_context *ctx) else if (ctx->in_bracketed_paste) process_bracketed_paste (fd, ctx); else if (!ctx->quitting) - input_on_readable (&ctx->input); + CALL (ctx->input, on_tty_readable); // User activity detected, stop current auto-away and start anew; // since they might have just changed the settings, do this last @@ -12573,7 +12779,7 @@ main (int argc, char *argv[]) // Initialize input so that we can switch to new buffers refresh_prompt (&ctx); - input_start (&ctx.input, argv[0]); + CALL_ (ctx.input, start, argv[0]); toggle_bracketed_paste (true); reset_autoaway (&ctx); @@ -12585,7 +12791,7 @@ main (int argc, char *argv[]) while (ctx.polling) poller_run (&ctx.poller); - input_stop (&ctx.input); + CALL (ctx.input, stop); if (get_config_boolean (ctx.config.root, "behaviour.save_on_quit")) save_configuration (&ctx); |