Browse Source

Rewrite the input layer

Now we also support libedit for the backend.
tags/v1.0.0
Přemysl Eric Janouch 5 years ago
parent
commit
63df918482
4 changed files with 749 additions and 103 deletions
  1. +18
    -1
      CMakeLists.txt
  2. +2
    -1
      README.adoc
  3. +3
    -0
      config.h.in
  4. +726
    -101
      json-rpc-shell.c

+ 18
- 1
CMakeLists.txt View File

@@ -1,6 +1,10 @@
project (json-rpc-shell C)
cmake_minimum_required (VERSION 2.8.5)

# Options
option (WANT_READLINE "Use GNU Readline for the UI (better)" ON)
option (WANT_LIBEDIT "Use BSD libedit for the UI" OFF)

# Moar warnings
if ("${CMAKE_C_COMPILER_ID}" MATCHES "GNU" OR CMAKE_COMPILER_IS_GNUC)
# -Wunused-function is pretty annoying here, as everything is static
@@ -28,7 +32,7 @@ find_package (LibEV REQUIRED)
pkg_check_modules (ncursesw ncursesw)

set (project_libraries ${dependencies_LIBRARIES}
${libssl_LIBRARIES} ${LIBEV_LIBRARIES} readline)
${libssl_LIBRARIES} ${LIBEV_LIBRARIES})
include_directories (${dependencies_INCLUDE_DIRS}
${libssl_INCLUDE_DIRS} ${LIBEV_INCLUDE_DIRS})

@@ -42,7 +46,20 @@ else (CURSES_FOUND)
message (SEND_ERROR "Curses not found")
endif (ncursesw_FOUND)

if ((WANT_READLINE AND WANT_LIBEDIT) OR (NOT WANT_READLINE AND NOT WANT_LIBEDIT))
message (SEND_ERROR "You have to choose either GNU Readline or libedit")
elseif (WANT_READLINE)
list (APPEND project_libraries readline)
elseif (WANT_LIBEDIT)
pkg_check_modules (libedit REQUIRED libedit)
list (APPEND project_libraries ${libedit_LIBRARIES})
include_directories (${libedit_INCLUDE_DIRS})
endif ((WANT_READLINE AND WANT_LIBEDIT) OR (NOT WANT_READLINE AND NOT WANT_LIBEDIT))

# Generate a configuration file
set (HAVE_READLINE "${WANT_READLINE}")
set (HAVE_EDITLINE "${WANT_LIBEDIT}")

configure_file (${PROJECT_SOURCE_DIR}/config.h.in ${PROJECT_BINARY_DIR}/config.h)
include_directories (${PROJECT_BINARY_DIR})



+ 2
- 1
README.adoc View File

@@ -29,7 +29,8 @@ Building and Running
--------------------
Build dependencies: CMake, pkg-config, help2man,
liberty (included), http-parser (included) +
Runtime dependencies: libev, Jansson, cURL, readline, openssl
Runtime dependencies: libev, Jansson, cURL, openssl,
readline or libedit >= 2013-07-12,

$ git clone --recursive https://github.com/pjanouch/json-rpc-shell.git
$ mkdir json-rpc-shell/build


+ 3
- 0
config.h.in View File

@@ -4,5 +4,8 @@
#define PROGRAM_NAME "${PROJECT_NAME}"
#define PROGRAM_VERSION "${project_VERSION}"

#cmakedefine HAVE_READLINE
#cmakedefine HAVE_EDITLINE

#endif // ! CONFIG_H


+ 726
- 101
json-rpc-shell.c View File

@@ -56,8 +56,6 @@ enum
#include <arpa/inet.h>

#include <ev.h>
#include <readline/readline.h>
#include <readline/history.h>
#include <curl/curl.h>
#include <jansson.h>
#include <openssl/rand.h>
@@ -80,6 +78,7 @@ static struct
bool stdout_is_tty; ///< `stdout' is a terminal
bool stderr_is_tty; ///< `stderr' is a terminal

struct termios termios; ///< Terminal attributes
char *color_set[8]; ///< Codes to set the foreground colour
}
g_terminal;
@@ -97,6 +96,9 @@ init_terminal (void)
if (tty_fd == -1 || setupterm (NULL, tty_fd, &err) == ERR)
return false;

if (tcgetattr (tty_fd, &g_terminal.termios))
return false;

// Make sure all terminal features used by us are supported
if (!set_a_foreground || !enter_bold_mode || !exit_attribute_mode)
{
@@ -122,6 +124,672 @@ free_terminal (void)
del_curterm (cur_term);
}

// --- User interface ----------------------------------------------------------

// Not trying to do anything crazy here like switchable buffers.
// Not trying to be too universal here either, it's not going to be reusable.

struct input
{
struct input_vtable *vtable; ///< Virtual methods
void *user_data; ///< User data for callbacks

/// Process a single line input by the user
void (*on_input) (char *line, void *user_data);
};

struct input_vtable
{
/// Start the interface under the given program name
void (*start) (struct input *input, const char *program_name);
/// Stop the interface
void (*stop) (struct input *input);
/// Destroy the object
void (*destroy) (struct input *input);

/// Hide the prompt if shown
void (*hide) (struct input *input);
/// Show the prompt if hidden
void (*show) (struct input *input);
/// Change the prompt string; takes ownership
void (*set_prompt) (struct input *input, char *prompt);
/// Ring the terminal bell
void (*ding) (struct input *input);

/// Load history from file
bool (*load_history) (struct input *input, const char *filename,
struct error **e);
/// Save history to file
bool (*save_history) (struct input *input, const char *filename,
struct error **e);

/// Handle terminal resize
void (*on_terminal_resized) (struct input *input);
/// Handle terminal input
void (*on_tty_readable) (struct input *input);
};

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

#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

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
};

/// Unfortunately Readline cannot pass us any pointer value in its callbacks
/// that would eliminate the need to use global variables ourselves
static struct input_rl *g_input_rl;

static void
input_rl_erase (void)
{
rl_set_prompt ("");
rl_replace_line ("", false);
rl_redisplay ();
}

static void
input_rl_on_input (char *line)
{
struct input_rl *self = g_input_rl;

// The prompt should always be visible at the moment we process input keys;
// confirming it de facto hides it because we move onto a new line
if (line)
self->prompt_shown = 0;
if (line && *line)
add_history (line);

self->super.on_input (line, self->super.user_data);
free (line);

// Readline automatically redisplays the prompt after we're done here;
// we could have actually hidden it by now in preparation of a quit though
if (line)
self->prompt_shown++;
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static void
input_rl_start (struct input *input, const char *program_name)
{
struct input_rl *self = (struct input_rl *) input;
using_history ();
// This can cause memory leaks, or maybe even a segfault. Funny, eh?
stifle_history (HISTORY_LIMIT);

const char *slash = strrchr (program_name, '/');
rl_readline_name = slash ? ++slash : program_name;
rl_catch_sigwinch = false;

hard_assert (self->prompt != NULL);
rl_callback_handler_install (self->prompt, input_rl_on_input);

self->active = true;
self->prompt_shown = 1;
g_input_rl = self;
}

static void
input_rl_stop (struct input *input)
{
struct input_rl *self = (struct input_rl *) input;
if (self->prompt_shown > 0)
input_rl_erase ();

// This is okay so long as we're not called from within readline
rl_callback_handler_remove ();

self->active = false;
self->prompt_shown = 0;
g_input_rl = NULL;
}

static void
input_rl_destroy (struct input *input)
{
struct input_rl *self = (struct input_rl *) input;

if (self->active)
input_rl_stop (input);

free (self->saved_line);
free (self->prompt);
free (self);
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static void
input_rl_hide (struct input *input)
{
struct input_rl *self = (struct input_rl *) input;
if (!self->active || self->prompt_shown-- < 1)
return;

hard_assert (!self->saved_line);

self->saved_point = rl_point;
self->saved_mark = rl_mark;
self->saved_line = rl_copy_text (0, rl_end);

input_rl_erase ();
}

static void
input_rl_show (struct input *input)
{
struct input_rl *self = (struct input_rl *) input;
if (!self->active || ++self->prompt_shown < 1)
return;

hard_assert (self->saved_line);

rl_set_prompt (self->prompt);
rl_replace_line (self->saved_line, false);
rl_point = self->saved_point;
rl_mark = self->saved_mark;
free (self->saved_line);
self->saved_line = NULL;

rl_redisplay ();
}

static void
input_rl_set_prompt (struct input *input, char *prompt)
{
struct input_rl *self = (struct input_rl *) input;
free (self->prompt);
self->prompt = prompt;

if (!self->active)
return;

// First reset the prompt to work around a bug in readline
rl_set_prompt ("");
if (self->prompt_shown > 0)
rl_redisplay ();

rl_set_prompt (self->prompt);
if (self->prompt_shown > 0)
rl_redisplay ();
}

static void
input_rl_ding (struct input *input)
{
(void) input;
rl_ding ();
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static bool
input_rl_load_history (struct input *input, const char *filename,
struct error **e)
{
(void) input;

if (!(errno = read_history (filename)))
return true;

error_set (e, "%s", strerror (errno));
return false;
}

static bool
input_rl_save_history (struct input *input, const char *filename,
struct error **e)
{
(void) input;

if (!(errno = write_history (filename)))
return true;

error_set (e, "%s", strerror (errno));
return false;
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static void
input_rl_on_terminal_resized (struct input *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
(void) input;
rl_resize_terminal ();
}

static void
input_rl_on_tty_readable (struct input *input)
{
(void) input;
rl_callback_read_char ();
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static struct input_vtable input_rl_vtable =
{
.start = input_rl_start,
.stop = input_rl_stop,
.destroy = input_rl_destroy,

.hide = input_rl_hide,
.show = input_rl_show,
.set_prompt = input_rl_set_prompt,
.ding = input_rl_ding,

.load_history = input_rl_load_history,
.save_history = input_rl_save_history,

.on_terminal_resized = input_rl_on_terminal_resized,
.on_tty_readable = input_rl_on_tty_readable,
};

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

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

#ifdef HAVE_EDITLINE

#include <histedit.h>

#define INPUT_START_IGNORE '\x01'
#define INPUT_END_IGNORE '\x01'

struct input_el
{
struct input super; ///< Parent class

EditLine *editline; ///< The EditLine object
HistoryW *history; ///< The history object
char *entered_line; ///< Buffers the entered line

bool active; ///< Interface has been started
char *prompt; ///< The prompt we use
int prompt_shown; ///< Whether the prompt is shown now

wchar_t *saved_line; ///< Saved line content
int saved_point; ///< Saved cursor position
int saved_len; ///< Saved line length
};

static char *
input_el_wcstombs (const wchar_t *s)
{
size_t len = wcstombs (NULL, s, 0);
if (len++ == (size_t) -1)
return NULL;

char *mb = xmalloc (len);
mb[wcstombs (mb, s, len)] = 0;
return mb;
}

static int
input_el_get_termios (int character, int fallback)
{
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_el_redisplay (struct input_el *self)
{
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 char *
input_el_make_prompt (EditLine *editline)
{
struct input_el *self;
el_get (editline, EL_CLIENTDATA, &self);
return self->prompt ? self->prompt : "";
}

static char *
input_el_make_empty_prompt (EditLine *editline)
{
(void) editline;
return "";
}

static void
input_el_erase (struct input_el *self)
{
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);

el_set (self->editline, EL_PROMPT, input_el_make_empty_prompt);
input_el_redisplay (self);
}

static unsigned char
input_el_on_return (EditLine *editline, int key)
{
(void) key;

struct input_el *self;
el_get (editline, EL_CLIENTDATA, &self);

const LineInfoW *info = el_wline (editline);
int len = info->lastchar - info->buffer;
int point = info->cursor - info->buffer;

wchar_t *line = calloc (sizeof *info->buffer, len + 1);
memcpy (line, info->buffer, sizeof *info->buffer * len);

if (*line)
{
HistEventW ev;
history_w (self->history, &ev, H_ENTER, line);
}
free (line);

// Convert to a multibyte string and store it for later
const LineInfo *info_mb = el_line (editline);
self->entered_line = xstrndup
(info_mb->buffer, info_mb->lastchar - info_mb->buffer);

// Now we need to force editline to actually print the newline
el_cursor (editline, len++ - point);
el_insertstr (editline, "\n");
input_el_redisplay (self);

// Finally we need to discard the old line's contents
el_wdeletestr (editline, len);
return CC_NEWLINE;
}

static void
input_el_install_prompt (struct input_el *self)
{
// XXX: the ignore doesn't quite work, see https://gnats.netbsd.org/47539
el_set (self->editline, EL_PROMPT_ESC,
input_el_make_prompt, INPUT_START_IGNORE);
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static void
input_el_start (struct input *input, const char *program_name)
{
struct input_el *self = (struct input_el *) input;
self->editline = el_init (program_name, stdin, stdout, stderr);
el_set (self->editline, EL_CLIENTDATA, self);
input_el_install_prompt (self);
el_set (self->editline, EL_SIGNAL, false);
el_set (self->editline, EL_UNBUFFERED, true);
el_set (self->editline, EL_EDITOR, "emacs");
el_wset (self->editline, EL_HIST, history_w, self->history);

// No, editline, it's not supposed to kill the entire line
el_set (self->editline, EL_BIND, "^w", "ed-delete-prev-word", NULL);
// Just what are you doing?
el_set (self->editline, EL_BIND, "^u", "vi-kill-line-prev", NULL);

// It's probably better to handle this ourselves
el_set (self->editline, EL_ADDFN,
"send-line", "Send line", input_el_on_return);
el_set (self->editline, EL_BIND, "\n", "send-line", NULL);

// Source the user's defaults file
el_source (self->editline, NULL);

self->active = true;
self->prompt_shown = 1;
}

static void
input_el_stop (struct input *input)
{
struct input_el *self = (struct input_el *) input;
if (self->prompt_shown > 0)
input_el_erase (self);

el_end (self->editline);
self->editline = NULL;

self->active = false;
self->prompt_shown = 0;
}

static void
input_el_destroy (struct input *input)
{
struct input_el *self = (struct input_el *) input;

if (self->active)
input_el_stop (input);

history_wend (self->history);

free (self->saved_line);
free (self->prompt);
free (self);
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static void
input_el_hide (struct input *input)
{
struct input_el *self = (struct input_el *) input;
if (!self->active || self->prompt_shown-- < 1)
return;

hard_assert (!self->saved_line);

const LineInfoW *info = el_wline (self->editline);
int len = info->lastchar - info->buffer;
int point = info->cursor - info->buffer;

wchar_t *line = calloc (sizeof *info->buffer, len + 1);
memcpy (line, info->buffer, sizeof *info->buffer * len);
el_cursor (self->editline, len - point);
el_wdeletestr (self->editline, len);

self->saved_line = line;
self->saved_point = point;
self->saved_len = len;

input_el_erase (self);
}

static void
input_el_show (struct input *input)
{
struct input_el *self = (struct input_el *) input;
if (!self->active || ++self->prompt_shown < 1)
return;

hard_assert (self->saved_line);

el_winsertstr (self->editline, self->saved_line);
el_cursor (self->editline,
-(self->saved_len - self->saved_point));
free (self->saved_line);
self->saved_line = NULL;

input_el_install_prompt (self);
input_el_redisplay (self);
}

static void
input_el_set_prompt (struct input *input, char *prompt)
{
struct input_el *self = (struct input_el *) input;
free (self->prompt);
self->prompt = prompt;

if (self->prompt_shown > 0)
input_el_redisplay (self);
}

static void
input_el_ding (struct input *input)
{
(void) input;

const char *ding = bell ? bell : "\a";
write (STDOUT_FILENO, ding, strlen (ding));
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static bool
input_el_load_history (struct input *input, const char *filename,
struct error **e)
{
struct input_el *self = (struct input_el *) input;

HistEventW ev;
if (history_w (self->history, &ev, H_LOAD, filename) != -1)
return true;

char *error = input_el_wcstombs (ev.str);
error_set (e, "%s", error);
free (error);
return false;
}

static bool
input_el_save_history (struct input *input, const char *filename,
struct error **e)
{
struct input_el *self = (struct input_el *) input;

HistEventW ev;
if (history_w (self->history, &ev, H_SAVE, filename) != -1)
return true;

char *error = input_el_wcstombs (ev.str);
error_set (e, "%s", error);
free (error);
return false;
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static void
input_el_on_terminal_resized (struct input *input)
{
struct input_el *self = (struct input_el *) input;
el_resize (self->editline);
}

static void
input_el_on_tty_readable (struct input *input)
{
// We bind the return key to process it how we need to
struct input_el *self = (struct input_el *) input;

// el_gets() with EL_UNBUFFERED doesn't work with UTF-8,
// we must use the wide-character interface
int count = 0;
const wchar_t *buf = el_wgets (self->editline, &count);

// Process data from our newline handler (async-friendly handling)
if (self->entered_line)
{
// We can't have anything try to hide the old prompt with the appended
// newline, it needs to stay where it is and as it is
self->prompt_shown = 0;

self->super.on_input (self->entered_line, self->super.user_data);
free (self->entered_line);
self->entered_line = NULL;

// Forbid editline from trying to erase the old prompt (or worse)
// and let it redisplay the prompt in its clean state
el_set (self->editline, EL_REFRESH);
self->prompt_shown = 1;
}

if (count == 1 && buf[0] == ('D' - 0x40) /* hardcoded VEOF in editline */)
{
el_deletestr (self->editline, 1);
input_el_redisplay (self);
self->super.on_input (NULL, self->super.user_data);
}
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static struct input_vtable input_el_vtable =
{
.start = input_el_start,
.stop = input_el_stop,
.destroy = input_el_destroy,

.hide = input_el_hide,
.show = input_el_show,
.set_prompt = input_el_set_prompt,
.ding = input_el_ding,

.load_history = input_el_load_history,
.save_history = input_el_save_history,

.on_terminal_resized = input_el_on_terminal_resized,
.on_tty_readable = input_el_on_tty_readable,
};

static struct input *
input_el_new (void)
{
struct input_el *self = xcalloc (1, sizeof *self);
self->super.vtable = &input_el_vtable;

HistEventW ev;
self->history = history_winit ();
history_w (self->history, &ev, H_SETSIZE, HISTORY_LIMIT);
return &self->super;
}

#define input_new input_el_new
#endif // HAVE_EDITLINE

// --- Main program ------------------------------------------------------------

// HTTP/S and WS/S require significantly different handling. While for HTTP we
@@ -251,14 +919,15 @@ enum color_mode

static struct app_context
{
struct input *input; ///< Input interface
char *attrs_defaults[ATTR_COUNT]; ///< Default terminal attributes
char *attrs[ATTR_COUNT]; ///< Terminal attributes

struct backend_iface *backend; ///< Our current backend

struct ws_context ws; ///< WebSockets backend data
struct curl_context curl; ///< cURL backend data

char *attrs_defaults[ATTR_COUNT]; ///< Default terminal attributes
char *attrs[ATTR_COUNT]; ///< Terminal attributes

struct config config; ///< Program configuration
enum color_mode color_mode; ///< Colour output mode
bool pretty_print; ///< Whether to pretty print
@@ -270,9 +939,6 @@ static struct app_context

iconv_t term_to_utf8; ///< Terminal encoding to UTF-8
iconv_t term_from_utf8; ///< UTF-8 to terminal encoding

char *readline_prompt; ///< The prompt we use for readline
bool readline_prompt_shown; ///< Whether the prompt is shown now
}
g_ctx;

@@ -468,34 +1134,13 @@ log_message_attributed (void *user_data, const char *quote, const char *fmt,
va_list ap)
{
FILE *stream = stderr;

// GNU readline is a huge piece of total crap; it seems that we must do
// these incredible shenanigans in order to intersperse readline output
// with asynchronous status messages
char *saved_line;
int saved_point;

if (g_ctx.readline_prompt_shown)
{
saved_point = rl_point;
saved_line = rl_copy_text (0, rl_end);
rl_set_prompt ("");
rl_replace_line ("", 0);
rl_redisplay ();
}
g_ctx.input->vtable->hide (g_ctx.input);

print_attributed (&g_ctx, stream, (intptr_t) user_data, "%s", quote);
vprint_attributed (&g_ctx, stream, (intptr_t) user_data, fmt, ap);
fputs ("\n", stream);

if (g_ctx.readline_prompt_shown)
{
rl_set_prompt (g_ctx.readline_prompt);
rl_replace_line (saved_line, 0);
rl_point = saved_point;
rl_redisplay ();
free (saved_line);
}
g_ctx.input->vtable->show (g_ctx.input);
}

static void
@@ -1659,6 +2304,18 @@ static struct backend_iface g_backend_curl =

// --- Main program ------------------------------------------------------------

static void
quit (struct app_context *ctx)
{
if (ctx->backend->on_quit)
ctx->backend->on_quit (ctx);

ev_break (EV_DEFAULT_ EVBREAK_ALL);
ctx->input->vtable->hide (ctx->input);
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

#define PARSE_FAIL(...) \
BLOCK_START \
print_error (__VA_ARGS__); \
@@ -1842,8 +2499,15 @@ fail:
}

static void
process_input (struct app_context *ctx, char *user_input)
process_input (char *user_input, void *user_data)
{
struct app_context *ctx = user_data;
if (!user_input)
{
quit (ctx);
return;
}

char *input;
size_t len;

@@ -1940,68 +2604,28 @@ on_winch (EV_P_ ev_signal *handle, int revents)
(void) handle;
(void) revents;

// 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
quit (struct app_context *ctx)
{
if (ctx->backend->on_quit)
ctx->backend->on_quit (ctx);

ev_break (EV_DEFAULT_ EVBREAK_ALL);
struct app_context *ctx = ev_userdata (loop);
ctx->input->vtable->on_terminal_resized (ctx->input);
}

static void
on_terminated (EV_P_ ev_signal *handle, int revents)
{
(void) loop;
(void) handle;
(void) revents;

quit (&g_ctx);
}

static void
on_readline_input (char *line)
{
// Otherwise the prompt is shown at all times
// Stupid readline forces us to use a global variable
g_ctx.readline_prompt_shown = false;

if (!line)
{
quit (&g_ctx);

// We must do this here, or the prompt gets printed twice. *shrug*
rl_callback_handler_remove ();

// Note that we don't set "readline_prompt_shown" back to true.
// This is so that we can safely do rl_callback_handler_remove when
// the program is terminated in an unusual manner (other than ^D).
return;
}

if (*line)
add_history (line);

process_input (&g_ctx, line);
free (line);

g_ctx.readline_prompt_shown = true;
struct app_context *ctx = ev_userdata (loop);
quit (ctx);
}

static void
on_tty_readable (EV_P_ ev_io *handle, int revents)
{
(void) loop;
(void) handle;

struct app_context *ctx = ev_userdata (loop);
if (revents & EV_READ)
rl_callback_read_char ();
ctx->input->vtable->on_tty_readable (ctx->input);
}

static void
@@ -2158,23 +2782,26 @@ main (int argc, char *argv[])
data_home = xstrdup_printf ("%s/.local/share", home);
}

using_history ();
stifle_history (HISTORY_LIMIT);
g_ctx.input = input_new ();
g_ctx.input->user_data = &g_ctx;
g_ctx.input->on_input = process_input;

char *history_path =
xstrdup_printf ("%s/" PROGRAM_NAME "/history", data_home);
(void) read_history (history_path);
(void) g_ctx.input->vtable->load_history (g_ctx.input, history_path, NULL);

if (!get_attribute_printer (stdout))
g_ctx.readline_prompt = xstrdup_printf ("json-rpc> ");
g_ctx.input->vtable->set_prompt (g_ctx.input,
xstrdup_printf ("json-rpc> "));
else
{
// XXX: to be completely correct, we should use tputs, but we cannot
g_ctx.readline_prompt = xstrdup_printf ("%c%s%cjson-rpc> %c%s%c",
RL_PROMPT_START_IGNORE, g_ctx.attrs[ATTR_PROMPT],
RL_PROMPT_END_IGNORE,
RL_PROMPT_START_IGNORE, g_ctx.attrs[ATTR_RESET],
RL_PROMPT_END_IGNORE);
g_ctx.input->vtable->set_prompt (g_ctx.input,
xstrdup_printf ("%c%s%cjson-rpc> %c%s%c",
INPUT_START_IGNORE, g_ctx.attrs[ATTR_PROMPT],
INPUT_END_IGNORE,
INPUT_START_IGNORE, g_ctx.attrs[ATTR_RESET],
INPUT_END_IGNORE));
}

// So that if the remote end closes the connection, attempts to write to
@@ -2202,35 +2829,33 @@ main (int argc, char *argv[])
ev_io_init (&tty_watcher, on_tty_readable, STDIN_FILENO, EV_READ);
ev_io_start (EV_DEFAULT_ &tty_watcher);

// readline 6.3 doesn't immediately redraw the terminal upon reception
// of SIGWINCH, so we must run it in an event loop to remediate that
rl_catch_sigwinch = false;
g_ctx.readline_prompt_shown = true;
rl_callback_handler_install (g_ctx.readline_prompt, on_readline_input);
g_ctx.input->vtable->start (g_ctx.input, PROGRAM_NAME);

ev_set_userdata (loop, &g_ctx);
ev_run (loop, 0);

if (g_ctx.readline_prompt_shown)
rl_callback_handler_remove ();
putchar ('\n');

// User has terminated the program, let's save the history and clean up
struct error *e = NULL;
char *dir = xstrdup (history_path);
(void) mkdir_with_parents (dirname (dir), NULL);
free (dir);

if (write_history (history_path))
if (!mkdir_with_parents (dirname (dir), &e)
|| !g_ctx.input->vtable->save_history (g_ctx.input, history_path, &e))
{
print_error ("writing the history file `%s' failed: %s",
history_path, strerror (errno));
history_path, e->message);
error_free (e);
}

free (dir);
free (history_path);

iconv_close (g_ctx.term_from_utf8);
iconv_close (g_ctx.term_to_utf8);
g_ctx.backend->destroy (&g_ctx);
free (origin);
free (g_ctx.readline_prompt);
config_free (&g_ctx.config);
free_terminal ();
g_ctx.input->vtable->destroy (g_ctx.input);
ev_loop_destroy (loop);
return EXIT_SUCCESS;
}

Loading…
Cancel
Save