summaryrefslogtreecommitdiffstats
path: root/src/readline_curses.cc
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/readline_curses.cc1508
1 files changed, 1508 insertions, 0 deletions
diff --git a/src/readline_curses.cc b/src/readline_curses.cc
new file mode 100644
index 0000000..ed91b3c
--- /dev/null
+++ b/src/readline_curses.cc
@@ -0,0 +1,1508 @@
+/**
+ * Copyright (c) 2007-2012, Timothy Stack
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * * Neither the name of Timothy Stack nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ''AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @file readline_curses.cc
+ */
+
+#include <errno.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include "config.h"
+
+#ifdef HAVE_PTY_H
+# include <pty.h>
+#endif
+
+#ifdef HAVE_UTIL_H
+# include <util.h>
+#endif
+
+#ifdef HAVE_LIBUTIL_H
+# include <libutil.h>
+#endif
+
+#include <string>
+#include <utility>
+
+#include "base/ansi_scrubber.hh"
+#include "base/auto_mem.hh"
+#include "base/lnav_log.hh"
+#include "base/paths.hh"
+#include "base/string_util.hh"
+#include "fmt/format.h"
+#include "fts_fuzzy_match.hh"
+#include "lnav_util.hh"
+#include "readline_curses.hh"
+#include "shlex.hh"
+#include "spookyhash/SpookyV2.h"
+
+static int got_line = 0;
+static int got_abort = 0;
+static bool alt_done = 0;
+static sig_atomic_t got_timeout = 0;
+static sig_atomic_t got_winch = 0;
+static readline_curses* child_this;
+static sig_atomic_t looping = 1;
+static const int HISTORY_SIZE = 256;
+static int completion_start;
+static const int FUZZY_PEER_THRESHOLD = 30;
+
+static const char* RL_INIT[] = {
+ /*
+ * XXX Need to keep the input on a single line since the display screws
+ * up if it wraps around.
+ */
+ "set horizontal-scroll-mode on",
+ "set bell-style none",
+ "set show-all-if-ambiguous on",
+ "set show-all-if-unmodified on",
+ "set menu-complete-display-prefix on",
+ "TAB: menu-complete",
+ "\"\\e[Z\": menu-complete-backward",
+};
+
+readline_context* readline_context::loaded_context;
+std::set<std::string>* readline_context::arg_possibilities;
+static std::string last_match_str;
+static bool last_match_str_valid;
+static bool arg_needs_shlex;
+static nonstd::optional<std::string> rewrite_line_start;
+
+static void
+sigalrm(int sig)
+{
+ got_timeout = 1;
+}
+
+static void
+sigwinch(int sig)
+{
+ got_winch = 1;
+}
+
+static void
+sigterm(int sig)
+{
+ looping = 0;
+}
+
+static void
+line_ready_tramp(char* line)
+{
+ child_this->line_ready(line);
+ got_line = 1;
+ rl_callback_handler_remove();
+}
+
+static int
+sendall(int sock, const char* buf, size_t len)
+{
+ off_t offset = 0;
+
+ while (len > 0) {
+ int rc = send(sock, &buf[offset], len, 0);
+
+ if (rc == -1) {
+ switch (errno) {
+ case EAGAIN:
+ case EINTR:
+ break;
+ default:
+ return -1;
+ }
+ } else {
+ len -= rc;
+ offset += rc;
+ }
+ }
+
+ return 0;
+}
+
+static int
+sendstring(int sock, const char* buf, size_t len)
+{
+ if (sendall(sock, (char*) &len, sizeof(len)) == -1) {
+ return -1;
+ } else if (sendall(sock, buf, len) == -1) {
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+sendcmd(int sock, char cmd, const char* buf, size_t len)
+{
+ size_t total_len = len + 2;
+ char prefix[2] = {cmd, ':'};
+
+ if (sendall(sock, (char*) &total_len, sizeof(total_len)) == -1) {
+ return -1;
+ } else if (sendall(sock, prefix, sizeof(prefix)) == -1
+ || sendall(sock, buf, len) == -1)
+ {
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+recvall(int sock, char* buf, size_t len)
+{
+ off_t offset = 0;
+
+ while (len > 0) {
+ ssize_t rc = recv(sock, &buf[offset], len, 0);
+
+ if (rc == -1) {
+ switch (errno) {
+ case EAGAIN:
+ case EINTR:
+ break;
+ default:
+ return -1;
+ }
+ } else if (rc == 0) {
+ errno = EIO;
+ return -1;
+ } else {
+ len -= rc;
+ offset += rc;
+ }
+ }
+
+ return 0;
+}
+
+static ssize_t
+recvstring(int sock, char* buf, size_t len)
+{
+ ssize_t retval;
+
+ if (recvall(sock, (char*) &retval, sizeof(retval)) == -1) {
+ return -1;
+ } else if (retval > (ssize_t) len) {
+ return -1;
+ } else if (recvall(sock, buf, retval) == -1) {
+ return -1;
+ }
+
+ return retval;
+}
+
+char*
+readline_context::completion_generator(const char* text_in, int state)
+{
+ static std::vector<std::string> matches;
+
+ std::vector<std::string> long_matches;
+ char* retval = nullptr;
+
+ if (state == 0) {
+ auto text_str = std::string(text_in);
+
+ if (arg_needs_shlex) {
+ shlex arg_lexer(text_str);
+ std::map<std::string, std::string> scope;
+ std::string result;
+
+ if (arg_lexer.eval(result, scope)) {
+ text_str = result;
+ }
+ }
+
+ matches.clear();
+ if (arg_possibilities != nullptr) {
+ for (const auto& poss : (*arg_possibilities)) {
+ auto cmpfunc
+ = (loaded_context->is_case_sensitive() ? strncmp
+ : strncasecmp);
+ auto poss_str = poss.c_str();
+
+ // Check for an exact match and for the quoted version.
+ if (cmpfunc(text_str.c_str(), poss_str, text_str.length()) == 0
+ || ((strchr(loaded_context->rc_quote_chars, poss_str[0])
+ != nullptr)
+ && cmpfunc(text_str.c_str(),
+ &poss_str[1],
+ text_str.length())
+ == 0))
+ {
+ auto poss_slash_count
+ = std::count(poss.begin(), poss.end(), '/');
+
+ if (endswith(poss, "/")) {
+ poss_slash_count -= 1;
+ }
+ if (std::count(text_str.begin(), text_str.end(), '/')
+ == poss_slash_count)
+ {
+ matches.emplace_back(poss);
+ } else {
+ long_matches.emplace_back(poss);
+ }
+ }
+ }
+
+ if (matches.empty()) {
+ matches = std::move(long_matches);
+ }
+
+ if (matches.empty()) {
+ std::vector<std::pair<int, std::string>> fuzzy_matches;
+ std::vector<std::pair<int, std::string>> fuzzy_long_matches;
+
+ for (const auto& poss : (*arg_possibilities)) {
+ std::string poss_str = tolower(poss);
+ int score = 0;
+
+ if (fts::fuzzy_match(
+ text_str.c_str(), poss_str.c_str(), score)
+ && score > 0)
+ {
+ if (score <= 0) {
+ continue;
+ }
+
+ auto poss_slash_count
+ = std::count(poss_str.begin(), poss_str.end(), '/');
+ if (endswith(poss, "/")) {
+ poss_slash_count -= 1;
+ }
+ if (std::count(text_str.begin(), text_str.end(), '/')
+ == poss_slash_count)
+ {
+ fuzzy_matches.emplace_back(score, poss);
+ } else {
+ fuzzy_long_matches.emplace_back(score, poss);
+ }
+ }
+ }
+
+ if (fuzzy_matches.empty()) {
+ fuzzy_matches = std::move(fuzzy_long_matches);
+ }
+
+ if (!fuzzy_matches.empty()) {
+ stable_sort(
+ begin(fuzzy_matches),
+ end(fuzzy_matches),
+ [](auto l, auto r) { return r.first < l.first; });
+
+ int highest = fuzzy_matches[0].first;
+
+ for (const auto& pair : fuzzy_matches) {
+ if (highest - pair.first < FUZZY_PEER_THRESHOLD) {
+ matches.push_back(pair.second);
+ } else {
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ if (matches.size() == 1) {
+ if (text_str == matches[0]) {
+ matches.pop_back();
+ }
+
+ last_match_str_valid = false;
+ if (sendstring(
+ child_this->rc_command_pipe[readline_curses::RCF_SLAVE],
+ "m:0:0:0",
+ 7)
+ == -1)
+ {
+ _exit(1);
+ }
+ }
+ }
+
+ if (!matches.empty()) {
+ retval = strdup(matches.back().c_str());
+ matches.pop_back();
+ }
+
+ return retval;
+}
+
+char**
+readline_context::attempted_completion(const char* text, int start, int end)
+{
+ char** retval = nullptr;
+
+ completion_start = start;
+ if (start == 0
+ && loaded_context->rc_possibilities.find("__command")
+ != loaded_context->rc_possibilities.end())
+ {
+ arg_possibilities = &loaded_context->rc_possibilities["__command"];
+ arg_needs_shlex = false;
+ rl_completion_append_character = loaded_context->rc_append_character;
+ } else {
+ char* space;
+ std::string cmd;
+ std::vector<std::string> prefix;
+ int point = rl_point;
+ while (point > 0 && rl_line_buffer[point] != ' ') {
+ point -= 1;
+ }
+ shlex lexer(rl_line_buffer, point);
+ std::map<std::string, std::string> scope;
+
+ arg_possibilities = nullptr;
+ rl_completion_append_character = 0;
+ if (lexer.split(prefix, scope)) {
+ auto prefix2
+ = fmt::format(FMT_STRING("{}"), fmt::join(prefix, "\x1f"));
+ auto prefix_iter = loaded_context->rc_prefixes.find(prefix2);
+
+ if (prefix_iter != loaded_context->rc_prefixes.end()) {
+ arg_possibilities
+ = &(loaded_context->rc_possibilities[prefix_iter->second]);
+ arg_needs_shlex = false;
+ }
+ }
+
+ if (arg_possibilities == nullptr) {
+ space = strchr(rl_line_buffer, ' ');
+ if (space == nullptr) {
+ space = rl_line_buffer + strlen(rl_line_buffer);
+ }
+ cmd = std::string(rl_line_buffer, space - rl_line_buffer);
+
+ auto iter = loaded_context->rc_prototypes.find(cmd);
+
+ if (iter == loaded_context->rc_prototypes.end()) {
+ if (loaded_context->rc_possibilities.find("*")
+ != loaded_context->rc_possibilities.end())
+ {
+ arg_possibilities = &loaded_context->rc_possibilities["*"];
+ arg_needs_shlex = false;
+ rl_completion_append_character
+ = loaded_context->rc_append_character;
+ }
+ } else {
+ std::vector<std::string>& proto
+ = loaded_context->rc_prototypes[cmd];
+
+ if (proto.empty()) {
+ arg_possibilities = nullptr;
+ } else if (proto[0] == "filename") {
+ shlex fn_lexer(rl_line_buffer, rl_point);
+ std::vector<std::string> fn_list;
+ int found = 0;
+
+ fn_lexer.split(fn_list, scope);
+
+ const auto& last_fn = fn_list.size() <= 1 ? ""
+ : fn_list.back();
+
+ if (last_fn.find(':') != std::string::npos) {
+ auto rp_iter = loaded_context->rc_possibilities.find(
+ "remote-path");
+ if (rp_iter != loaded_context->rc_possibilities.end()) {
+ for (const auto& poss : rp_iter->second) {
+ if (startswith(poss, last_fn.c_str())) {
+ found += 1;
+ }
+ }
+ if (found) {
+ arg_possibilities = &rp_iter->second;
+ arg_needs_shlex = false;
+ }
+ }
+ if (!found || (endswith(last_fn, "/") && found == 1)) {
+ char msg[2048];
+
+ snprintf(
+ msg, sizeof(msg), "\t:%s", last_fn.c_str());
+ sendstring(child_this->rc_command_pipe[1],
+ msg,
+ strlen(msg));
+ }
+ }
+ if (!found) {
+ static std::set<std::string> file_name_set;
+
+ file_name_set.clear();
+ auto_mem<char> completed_fn;
+ int fn_state = 0;
+ auto recent_netlocs_iter
+ = loaded_context->rc_possibilities.find(
+ "recent-netlocs");
+
+ if (recent_netlocs_iter
+ != loaded_context->rc_possibilities.end())
+ {
+ file_name_set.insert(
+ recent_netlocs_iter->second.begin(),
+ recent_netlocs_iter->second.end());
+ }
+ while ((completed_fn = rl_filename_completion_function(
+ last_fn.c_str(), fn_state))
+ != nullptr)
+ {
+ file_name_set.insert(completed_fn.in());
+ fn_state += 1;
+ }
+ arg_possibilities = &file_name_set;
+ arg_needs_shlex = true;
+ }
+ } else {
+ arg_possibilities
+ = &(loaded_context->rc_possibilities[proto[0]]);
+ arg_needs_shlex = false;
+ }
+ }
+ }
+ }
+
+ retval = rl_completion_matches(text, completion_generator);
+ if (retval == nullptr) {
+ rl_attempted_completion_over = 1;
+ }
+
+ return retval;
+}
+
+static int
+rubout_char_or_abort(int count, int key)
+{
+ if (rl_line_buffer[0] == '\0') {
+ rl_done = true;
+ got_abort = 1;
+ got_line = 0;
+ return 0;
+ } else {
+ return rl_rubout(count, '\b');
+ }
+}
+
+static int
+alt_done_func(int count, int key)
+{
+ alt_done = true;
+ rl_newline(count, key);
+ return 0;
+}
+
+int
+readline_context::command_complete(int count, int key)
+{
+ if (loaded_context->rc_possibilities.find("__command")
+ != loaded_context->rc_possibilities.end())
+ {
+ char* space = strchr(rl_line_buffer, ' ');
+
+ if (space == nullptr) {
+ return rl_menu_complete(count, key);
+ }
+ }
+ return rl_insert(count, key);
+}
+
+readline_context::readline_context(std::string name,
+ readline_context::command_map_t* commands,
+ bool case_sensitive)
+ : rc_name(std::move(name)), rc_case_sensitive(case_sensitive),
+ rc_quote_chars("\"'"), rc_highlighter(nullptr)
+{
+ if (commands != nullptr) {
+ command_map_t::iterator iter;
+
+ for (iter = commands->begin(); iter != commands->end(); ++iter) {
+ std::string cmd = iter->first;
+
+ this->rc_possibilities["__command"].insert(cmd);
+ iter->second->c_func(
+ INIT_EXEC_CONTEXT, cmd, this->rc_prototypes[cmd]);
+ }
+ }
+
+ memset(&this->rc_history, 0, sizeof(this->rc_history));
+ history_set_history_state(&this->rc_history);
+
+ auto config_dir = lnav::paths::dotlnav();
+ auto hpath = (config_dir / this->rc_name).string() + ".history";
+ read_history(hpath.c_str());
+ this->save();
+
+ this->rc_append_character = ' ';
+}
+
+void
+readline_context::load()
+{
+ char buffer[128];
+
+ rl_completer_word_break_characters = (char*) " \t\n|()"; /* XXX */
+ /*
+ * XXX Need to keep the input on a single line since the display screws
+ * up if it wraps around.
+ */
+ snprintf(buffer,
+ sizeof(buffer),
+ "set completion-ignore-case %s",
+ this->rc_case_sensitive ? "off" : "on");
+ rl_parse_and_bind(buffer); /* NOTE: buffer is modified */
+
+ loaded_context = this;
+ rl_attempted_completion_function = attempted_completion;
+ history_set_history_state(&this->rc_history);
+ for (auto& rc_var : this->rc_vars) {
+ *(rc_var.rv_dst.ch) = (char*) rc_var.rv_val.ch;
+ }
+}
+
+void
+readline_context::save()
+{
+ HISTORY_STATE* hs = history_get_history_state();
+
+ this->rc_history = *hs;
+ free(hs);
+ hs = nullptr;
+}
+
+readline_curses::readline_curses(
+ std::shared_ptr<pollable_supervisor> supervisor)
+ : pollable(supervisor, pollable::category::interactive),
+ rc_focus(noop_func{}), rc_change(noop_func{}), rc_perform(noop_func{}),
+ rc_alt_perform(noop_func{}), rc_timeout(noop_func{}),
+ rc_abort(noop_func{}), rc_display_match(noop_func{}),
+ rc_display_next(noop_func{}), rc_blur(noop_func{}),
+ rc_completion_request(noop_func{})
+{
+}
+
+readline_curses::~readline_curses()
+{
+ this->rc_pty[RCF_MASTER].reset();
+ this->rc_command_pipe[RCF_MASTER].reset();
+ if (this->rc_child == 0) {
+ _exit(0);
+ } else if (this->rc_child > 0) {
+ int status;
+
+ log_debug("terminating readline child %d", this->rc_child);
+ log_perror(kill(this->rc_child, SIGTERM));
+ this->rc_child = -1;
+
+ while (wait(&status) < 0 && (errno == EINTR)) {
+ ;
+ }
+ log_debug(" child %d has exited", this->rc_child);
+ }
+}
+
+void
+readline_curses::store_matches(char** matches, int num_matches, int max_len)
+{
+ static int match_index = 0;
+ char msg[64];
+ int rc;
+
+ max_len = 0;
+ for (int lpc = 0; lpc <= num_matches; lpc++) {
+ max_len = std::max(max_len, (int) strlen(matches[lpc]));
+ }
+
+ if (last_match_str_valid && strcmp(last_match_str.c_str(), matches[0]) == 0)
+ {
+ match_index += 1;
+ rc = snprintf(msg, sizeof(msg), "n:%d", match_index);
+
+ if (sendstring(child_this->rc_command_pipe[RCF_SLAVE], msg, rc) == -1) {
+ _exit(1);
+ }
+ } else {
+ match_index = 0;
+ rc = snprintf(msg,
+ sizeof(msg),
+ "m:%d:%d:%d",
+ completion_start,
+ num_matches,
+ max_len);
+ if (sendstring(child_this->rc_command_pipe[RCF_SLAVE], msg, rc) == -1) {
+ _exit(1);
+ }
+ for (int lpc = 1; lpc <= num_matches; lpc++) {
+ if (sendstring(child_this->rc_command_pipe[RCF_SLAVE],
+ matches[lpc],
+ strlen(matches[lpc]))
+ == -1)
+ {
+ _exit(1);
+ }
+ }
+
+ last_match_str = matches[0];
+ last_match_str_valid = true;
+ }
+}
+
+void
+readline_curses::start()
+{
+ if (this->rc_child > 0) {
+ return;
+ }
+
+ struct winsize ws;
+ int sp[2];
+
+ if (socketpair(PF_UNIX, SOCK_STREAM, 0, sp) < 0) {
+ throw error(errno);
+ }
+
+ this->rc_command_pipe[RCF_MASTER] = sp[RCF_MASTER];
+ this->rc_command_pipe[RCF_SLAVE] = sp[RCF_SLAVE];
+
+ if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == -1) {
+ throw error(errno);
+ }
+
+ if (openpty(this->rc_pty[RCF_MASTER].out(),
+ this->rc_pty[RCF_SLAVE].out(),
+ nullptr,
+ nullptr,
+ &ws)
+ < 0)
+ {
+ perror("error: failed to open terminal(openpty)");
+ throw error(errno);
+ }
+
+ if ((this->rc_child = fork()) == -1) {
+ throw error(errno);
+ }
+
+ if (this->rc_child != 0) {
+ this->rc_command_pipe[RCF_SLAVE].reset();
+ this->rc_pty[RCF_SLAVE].reset();
+ return;
+ }
+
+ {
+ char buffer[1024];
+
+ this->rc_command_pipe[RCF_MASTER].reset();
+ this->rc_pty[RCF_MASTER].reset();
+
+ signal(SIGALRM, sigalrm);
+ signal(SIGWINCH, sigwinch);
+ signal(SIGINT, sigterm);
+ signal(SIGTERM, sigterm);
+
+ dup2(this->rc_pty[RCF_SLAVE], STDIN_FILENO);
+ dup2(this->rc_pty[RCF_SLAVE], STDOUT_FILENO);
+
+ setenv("TERM", "vt52", 1);
+
+ rl_initialize();
+ using_history();
+ stifle_history(HISTORY_SIZE);
+
+ rl_add_defun("rubout-char-or-abort", rubout_char_or_abort, '\b');
+ rl_add_defun("alt-done", alt_done_func, '\x0a');
+ // rl_add_defun("command-complete", readline_context::command_complete,
+ // ' ');
+
+ for (const auto* init_cmd : RL_INIT) {
+ snprintf(buffer, sizeof(buffer), "%s", init_cmd);
+ rl_parse_and_bind(buffer); /* NOTE: buffer is modified */
+ }
+
+ child_this = this;
+ }
+
+ std::map<int, readline_context*>::iterator current_context;
+ int maxfd;
+
+ require(!this->rc_contexts.empty());
+
+ rl_completion_display_matches_hook = store_matches;
+
+ current_context = this->rc_contexts.end();
+
+ maxfd = std::max(STDIN_FILENO, this->rc_command_pipe[RCF_SLAVE].get());
+
+ while (looping) {
+ fd_set ready_rfds;
+ int rc;
+
+ FD_ZERO(&ready_rfds);
+ if (current_context != this->rc_contexts.end()) {
+ FD_SET(STDIN_FILENO, &ready_rfds);
+ }
+ FD_SET(this->rc_command_pipe[RCF_SLAVE], &ready_rfds);
+
+ rc = select(maxfd + 1, &ready_rfds, nullptr, nullptr, nullptr);
+ if (rc < 0) {
+ switch (errno) {
+ case EINTR:
+ break;
+ }
+ } else {
+ if (FD_ISSET(STDIN_FILENO, &ready_rfds)) {
+ static uint64_t last_h1, last_h2;
+
+ struct itimerval itv;
+
+ itv.it_value.tv_sec = 0;
+ itv.it_value.tv_usec = KEY_TIMEOUT;
+ itv.it_interval.tv_sec = 0;
+ itv.it_interval.tv_usec = 0;
+ setitimer(ITIMER_REAL, &itv, nullptr);
+
+ rl_callback_read_char();
+ if (RL_ISSTATE(RL_STATE_DONE) && !got_line) {
+ got_line = 1;
+ this->line_ready("");
+ rl_callback_handler_remove();
+ } else {
+ uint64_t h1 = 1, h2 = 2;
+
+ if (rl_last_func == readline_context::command_complete) {
+ rl_last_func = rl_menu_complete;
+ }
+
+ bool complete_done
+ = (rl_last_func != rl_menu_complete
+ && rl_last_func != rl_backward_menu_complete);
+
+ if (complete_done) {
+ last_match_str_valid = false;
+ } else if (rewrite_line_start
+ && !startswith(rl_line_buffer,
+ rewrite_line_start->c_str()))
+ {
+ // If the line was rewritten, the extra text stays on
+ // the screen, so we need to delete it, make sure the
+ // append character is there, and redisplay. For
+ // example, ':co<TAB>' will complete ':comment' and
+ // append the current comment. Pressing '<TAB>' again
+ // would switch to ':config' and the comment text would
+ // be left on the display.
+ rl_delete_text(rl_point, rl_end);
+ if (rl_completion_append_character
+ && rl_line_buffer[rl_point]
+ != rl_completion_append_character)
+ {
+ char buf[2]
+ = {(char) rl_completion_append_character, '\0'};
+
+ rl_insert_text(buf);
+ }
+ rl_redisplay();
+ }
+ rewrite_line_start = nonstd::nullopt;
+
+ SpookyHash::Hash128(rl_line_buffer, rl_end, &h1, &h2);
+
+ if (h1 == last_h1 && h2 == last_h2) {
+ // do nothing
+ } else if (sendcmd(this->rc_command_pipe[RCF_SLAVE],
+ complete_done ? 'l' : 'c',
+ rl_line_buffer,
+ rl_end)
+ != 0)
+ {
+ perror("line: write failed");
+ _exit(1);
+ }
+ last_h1 = h1;
+ last_h2 = h2;
+ if (sendcmd(this->rc_command_pipe[RCF_SLAVE], 'w', "", 0)
+ != 0)
+ {
+ perror("line: write failed");
+ _exit(1);
+ }
+ }
+ }
+ if (FD_ISSET(this->rc_command_pipe[RCF_SLAVE], &ready_rfds)) {
+ char msg[1024 + 1];
+
+ if ((rc = recvstring(this->rc_command_pipe[RCF_SLAVE],
+ msg,
+ sizeof(msg) - 1))
+ < 0)
+ {
+ looping = false;
+ } else {
+ int context, prompt_start = 0;
+ char type[1024];
+
+ msg[rc] = '\0';
+ if (sscanf(msg, "i:%d:%n", &rl_point, &prompt_start) == 1) {
+ const char* initial = &msg[prompt_start];
+
+ rl_extend_line_buffer(strlen(initial) + 1);
+ strcpy(rl_line_buffer, initial);
+ rl_end = strlen(initial);
+ rewrite_line_start
+ = std::string(rl_line_buffer, rl_point);
+ rl_redisplay();
+ if (sendcmd(this->rc_command_pipe[RCF_SLAVE],
+ 'c',
+ rl_line_buffer,
+ rl_end)
+ != 0)
+ {
+ perror("line: write failed");
+ _exit(1);
+ }
+ } else if (sscanf(msg, "f:%d:%n", &context, &prompt_start)
+ == 1
+ && prompt_start != 0
+ && (current_context
+ = this->rc_contexts.find(context))
+ != this->rc_contexts.end())
+ {
+ got_abort = 0;
+ current_context->second->load();
+ rl_callback_handler_install(&msg[prompt_start],
+ line_ready_tramp);
+ last_match_str_valid = false;
+ if (sendcmd(this->rc_command_pipe[RCF_SLAVE],
+ 'l',
+ rl_line_buffer,
+ rl_end)
+ != 0)
+ {
+ perror("line: write failed");
+ _exit(1);
+ }
+ if (sendcmd(
+ this->rc_command_pipe[RCF_SLAVE], 'w', "", 0)
+ != 0)
+ {
+ perror("line: write failed");
+ _exit(1);
+ }
+ } else if (strcmp(msg, "a") == 0) {
+ char reply[4];
+
+ rl_done = 1;
+ got_timeout = 0;
+ got_line = 1;
+ rl_callback_handler_remove();
+
+ snprintf(reply, sizeof(reply), "a");
+
+ if (sendstring(this->rc_command_pipe[RCF_SLAVE],
+ reply,
+ strlen(reply))
+ == -1)
+ {
+ perror("abort: write failed");
+ _exit(1);
+ }
+ } else if (sscanf(msg,
+ "apre:%d:%1023[^\x1d]\x1d%n",
+ &context,
+ type,
+ &prompt_start)
+ == 2)
+ {
+ require(this->rc_contexts[context] != nullptr);
+
+ this->rc_contexts[context]
+ ->rc_prefixes[std::string(type)]
+ = std::string(&msg[prompt_start]);
+ } else if (sscanf(msg,
+ "ap:%d:%31[^:]:%n",
+ &context,
+ type,
+ &prompt_start)
+ == 2)
+ {
+ require(this->rc_contexts[context] != nullptr);
+
+ this->rc_contexts[context]->add_possibility(
+ std::string(type), std::string(&msg[prompt_start]));
+ if (rl_last_func == rl_complete
+ || rl_last_func == rl_menu_complete)
+ {
+ rl_last_func = NULL;
+ }
+ } else if (sscanf(msg,
+ "rp:%d:%31[^:]:%n",
+ &context,
+ type,
+ &prompt_start)
+ == 2)
+ {
+ require(this->rc_contexts[context] != nullptr);
+
+ this->rc_contexts[context]->rem_possibility(
+ std::string(type), std::string(&msg[prompt_start]));
+ } else if (sscanf(msg, "cpre:%d", &context) == 1) {
+ this->rc_contexts[context]->rc_prefixes.clear();
+ } else if (sscanf(msg, "cp:%d:%s", &context, type)) {
+ this->rc_contexts[context]->clear_possibilities(type);
+ } else {
+ log_error("unhandled message: %s", msg);
+ }
+ }
+ }
+ }
+
+ if (got_timeout) {
+ got_timeout = 0;
+ if (sendcmd(this->rc_command_pipe[RCF_SLAVE],
+ 't',
+ rl_line_buffer,
+ rl_end)
+ == -1)
+ {
+ _exit(1);
+ }
+ }
+ if (got_line) {
+ struct itimerval itv;
+
+ got_line = 0;
+ itv.it_value.tv_sec = 0;
+ itv.it_value.tv_usec = 0;
+ itv.it_interval.tv_sec = 0;
+ itv.it_interval.tv_usec = 0;
+ if (setitimer(ITIMER_REAL, &itv, nullptr) < 0) {
+ log_error("setitimer: %s", strerror(errno));
+ }
+ if (current_context != this->rc_contexts.end()) {
+ current_context->second->save();
+ current_context = this->rc_contexts.end();
+ }
+ }
+ if (got_winch) {
+ struct winsize new_ws;
+
+ if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &new_ws) == -1) {
+ throw error(errno);
+ }
+ got_winch = 0;
+ rl_set_screen_size(new_ws.ws_row, new_ws.ws_col);
+ }
+ }
+
+ if (this->rc_save_history) {
+ auto config_dir = lnav::paths::dotlnav();
+ for (auto& pair : this->rc_contexts) {
+ pair.second->load();
+
+ auto hpath
+ = (config_dir / pair.second->get_name()).string() + ".history";
+ write_history(hpath.c_str());
+ pair.second->save();
+ }
+ }
+
+ _exit(0);
+}
+
+void
+readline_curses::line_ready(const char* line)
+{
+ auto_mem<char> expanded;
+ char msg[1024] = {0};
+ int rc;
+ const char* cmd_ch = alt_done ? "D" : "d";
+
+ alt_done = false;
+ if (got_abort || line == nullptr) {
+ snprintf(msg, sizeof(msg), "a");
+
+ if (sendstring(this->rc_command_pipe[RCF_SLAVE], msg, strlen(msg))
+ == -1)
+ {
+ perror("abort: write failed");
+ _exit(1);
+ }
+ return;
+ }
+
+ if (rl_line_buffer[0] == '^') {
+ rc = -1;
+ } else {
+ rc = history_expand(rl_line_buffer, expanded.out());
+ }
+ switch (rc) {
+#if 0
+ /* TODO: fix clash between history and pcre metacharacters */
+ case -1:
+ /* XXX */
+ snprintf(msg, sizeof(msg),
+ "e:unable to expand history -- %s",
+ expanded.in());
+ break;
+#endif
+
+ case -1:
+ snprintf(msg, sizeof(msg), "%s:%s", cmd_ch, line);
+ break;
+
+ case 0:
+ case 1:
+ case 2: /* XXX */
+ snprintf(msg, sizeof(msg), "%s:%s", cmd_ch, expanded.in());
+ break;
+ }
+
+ if (sendstring(this->rc_command_pipe[RCF_SLAVE], msg, strlen(msg)) == -1) {
+ perror("line_ready: write failed");
+ _exit(1);
+ }
+
+ {
+ HIST_ENTRY* entry;
+
+ if (line[0] != '\0'
+ && (history_length == 0
+ || (entry = history_get(history_base + history_length - 1))
+ == nullptr
+ || strcmp(entry->line, line) != 0))
+ {
+ add_history(line);
+ }
+ }
+}
+
+void
+readline_curses::check_poll_set(const std::vector<struct pollfd>& pollfds)
+{
+ int rc;
+
+ if (pollfd_ready(pollfds, this->rc_pty[RCF_MASTER])) {
+ char buffer[128];
+
+ rc = read(this->rc_pty[RCF_MASTER], buffer, sizeof(buffer));
+ if (rc > 0) {
+ int old_x = this->vc_x;
+
+ this->map_output(buffer, rc);
+ if (this->vc_x != old_x) {
+ this->rc_change(this);
+ }
+ }
+ }
+ if (pollfd_ready(pollfds, this->rc_command_pipe[RCF_MASTER])) {
+ char msg[1024 + 1];
+
+ rc = recvstring(
+ this->rc_command_pipe[RCF_MASTER], msg, sizeof(msg) - 1);
+ if (rc >= 0) {
+ msg[rc] = '\0';
+ if (this->rc_matches_remaining > 0) {
+ this->rc_matches.emplace_back(msg);
+ this->rc_matches_remaining -= 1;
+ if (this->rc_matches_remaining == 0) {
+ this->rc_display_match(this);
+ }
+ } else if (msg[0] == 'm') {
+ if (sscanf(msg,
+ "m:%d:%d:%d",
+ &this->rc_match_start,
+ &this->rc_matches_remaining,
+ &this->rc_max_match_length)
+ != 3)
+ {
+ require(0);
+ }
+ this->rc_matches.clear();
+ if (this->rc_matches_remaining == 0) {
+ this->rc_display_match(this);
+ }
+ this->rc_match_index = 0;
+ } else if (msg[0] == '\t') {
+ char path[2048];
+
+ if (sscanf(msg, "\t:%s", path) != 1) {
+ require(0);
+ }
+ this->rc_remote_complete_path = path;
+ this->rc_completion_request(this);
+ } else if (msg[0] == 'n') {
+ if (sscanf(msg, "n:%d", &this->rc_match_index) != 1) {
+ require(0);
+ }
+ this->rc_display_next(this);
+ } else {
+ switch (msg[0]) {
+ case 't':
+ case 'd':
+ case 'D':
+ this->rc_value = std::string(&msg[2]);
+ break;
+ }
+ switch (msg[0]) {
+ case 'a':
+ curs_set(0);
+ this->vc_line.clear();
+ this->rc_active_context = -1;
+ this->rc_matches.clear();
+ this->rc_abort(this);
+ this->rc_display_match(this);
+ this->rc_blur(this);
+ break;
+
+ case 't':
+ this->rc_timeout(this);
+ break;
+
+ case 'd':
+ case 'D':
+ curs_set(0);
+ this->rc_active_context = -1;
+ this->rc_matches.clear();
+ if (msg[0] == 'D' || this->rc_is_alt_focus) {
+ this->rc_alt_perform(this);
+ } else {
+ this->rc_perform(this);
+ }
+ this->rc_display_match(this);
+ this->rc_blur(this);
+ break;
+
+ case 'l':
+ this->rc_line_buffer = &msg[2];
+ if (this->rc_active_context != -1) {
+ this->rc_change(this);
+ }
+ this->rc_matches.clear();
+ if (this->rc_active_context != -1) {
+ this->rc_display_match(this);
+ }
+ break;
+
+ case 'c':
+ this->rc_line_buffer = &msg[2];
+ this->rc_change(this);
+ this->rc_display_match(this);
+ break;
+ case 'w':
+ this->rc_ready_for_input = true;
+ break;
+ }
+ }
+ }
+ }
+}
+
+void
+readline_curses::handle_key(int ch)
+{
+ const char* bch;
+ int len;
+
+ bch = this->map_input(ch, len);
+ if (write(this->rc_pty[RCF_MASTER], bch, len) == -1) {
+ perror("handle_key: write failed");
+ }
+}
+
+void
+readline_curses::focus(int context,
+ const std::string& prompt,
+ const std::string& initial)
+{
+ char buffer[1024];
+
+ curs_set(1);
+
+ this->rc_active_context = context;
+
+ snprintf(buffer, sizeof(buffer), "f:%d:%s", context, prompt.c_str());
+ if (sendstring(
+ this->rc_command_pipe[RCF_MASTER], buffer, strlen(buffer) + 1)
+ == -1)
+ {
+ perror("focus: write failed");
+ }
+ wmove(this->vc_window, this->get_actual_y(), this->vc_left);
+ wclrtoeol(this->vc_window);
+ if (!initial.empty()) {
+ this->rewrite_line(initial.size(), initial);
+ }
+ this->rc_is_alt_focus = false;
+ this->rc_focus(this);
+}
+
+void
+readline_curses::rewrite_line(int pos, const std::string& value)
+{
+ char buffer[1024];
+
+ snprintf(buffer, sizeof(buffer), "i:%d:%s", pos, value.c_str());
+ if (sendstring(
+ this->rc_command_pipe[RCF_MASTER], buffer, strlen(buffer) + 1)
+ == -1)
+ {
+ perror("rewrite_line: write failed");
+ }
+}
+
+void
+readline_curses::abort()
+{
+ char buffer[1024];
+
+ this->vc_x = 0;
+ snprintf(buffer, sizeof(buffer), "a");
+ if (sendstring(this->rc_command_pipe[RCF_MASTER], buffer, strlen(buffer))
+ == -1)
+ {
+ perror("abort: write failed");
+ }
+}
+
+void
+readline_curses::add_prefix(int context,
+ const std::vector<std::string>& prefix,
+ const std::string& value)
+{
+ char buffer[1024];
+ auto prefix_wire = fmt::format(FMT_STRING("{}"), fmt::join(prefix, "\x1f"));
+
+ snprintf(buffer,
+ sizeof(buffer),
+ "apre:%d:%s\x1d%s",
+ context,
+ prefix_wire.c_str(),
+ value.c_str());
+ if (sendstring(
+ this->rc_command_pipe[RCF_MASTER], buffer, strlen(buffer) + 1)
+ == -1)
+ {
+ perror("add_prefix: write failed");
+ }
+}
+
+void
+readline_curses::clear_prefixes(int context)
+{
+ char buffer[1024];
+
+ snprintf(buffer, sizeof(buffer), "cpre:%d", context);
+ if (sendstring(
+ this->rc_command_pipe[RCF_MASTER], buffer, strlen(buffer) + 1)
+ == -1)
+ {
+ perror("add_possibility: write failed");
+ }
+}
+
+void
+readline_curses::add_possibility(int context,
+ const std::string& type,
+ const std::string& value)
+{
+ char buffer[1024];
+
+ if (value.empty()) {
+ return;
+ }
+
+ snprintf(buffer,
+ sizeof(buffer),
+ "ap:%d:%s:%s",
+ context,
+ type.c_str(),
+ value.c_str());
+ if (sendstring(
+ this->rc_command_pipe[RCF_MASTER], buffer, strlen(buffer) + 1)
+ == -1)
+ {
+ perror("add_possibility: write failed");
+ }
+}
+
+void
+readline_curses::rem_possibility(int context,
+ const std::string& type,
+ const std::string& value)
+{
+ char buffer[1024];
+
+ snprintf(buffer,
+ sizeof(buffer),
+ "rp:%d:%s:%s",
+ context,
+ type.c_str(),
+ value.c_str());
+ if (sendstring(
+ this->rc_command_pipe[RCF_MASTER], buffer, strlen(buffer) + 1)
+ == -1)
+ {
+ perror("rem_possiblity: write failed");
+ }
+}
+
+void
+readline_curses::clear_possibilities(int context, std::string type)
+{
+ char buffer[1024];
+
+ snprintf(buffer, sizeof(buffer), "cp:%d:%s", context, type.c_str());
+ if (sendstring(
+ this->rc_command_pipe[RCF_MASTER], buffer, strlen(buffer) + 1)
+ == -1)
+ {
+ perror("clear_possiblity: write failed");
+ }
+}
+
+void
+readline_curses::do_update()
+{
+ if (!this->vc_visible || this->vc_window == nullptr) {
+ return;
+ }
+
+ if (this->rc_active_context == -1) {
+ int alt_start = -1;
+ struct line_range lr(0, 0);
+ attr_line_t alt_al;
+ view_colors& vc = view_colors::singleton();
+
+ wmove(this->vc_window, this->get_actual_y(), this->vc_left);
+ auto attrs = vc.attrs_for_role(role_t::VCR_TEXT);
+ wattr_set(this->vc_window,
+ attrs.ta_attrs,
+ vc.ensure_color_pair(attrs.ta_fg_color, attrs.ta_bg_color),
+ nullptr);
+ whline(this->vc_window, ' ', this->vc_width);
+
+ if (time(nullptr) > this->rc_value_expiration) {
+ this->rc_value.clear();
+ }
+
+ if (!this->rc_alt_value.empty()) {
+ alt_al.get_string() = this->rc_alt_value;
+ scrub_ansi_string(alt_al.get_string(), &alt_al.get_attrs());
+
+ alt_start = getmaxx(this->vc_window) - alt_al.get_string().size();
+ }
+
+ if (alt_start >= (int) (this->rc_value.length() + 5)) {
+ lr.lr_end = alt_al.get_string().length();
+ view_curses::mvwattrline(
+ this->vc_window, this->get_actual_y(), alt_start, alt_al, lr);
+ }
+
+ lr.lr_end = this->rc_value.length();
+ view_curses::mvwattrline(this->vc_window,
+ this->get_actual_y(),
+ this->vc_left,
+ this->rc_value,
+ lr);
+ this->set_x(0);
+ }
+
+ if (this->rc_active_context != -1) {
+ readline_context* rc = this->rc_contexts[this->rc_active_context];
+ readline_highlighter_t hl = rc->get_highlighter();
+ attr_line_t al = this->vc_line;
+
+ if (hl != nullptr) {
+ hl(al, this->vc_left + this->vc_x);
+ }
+ view_curses::mvwattrline(this->vc_window,
+ this->get_actual_y(),
+ this->vc_left,
+ al,
+ line_range{0, (int) this->vc_width});
+
+ wmove(
+ this->vc_window, this->get_actual_y(), this->vc_left + this->vc_x);
+ }
+}
+
+std::string
+readline_curses::get_match_string() const
+{
+ auto len = std::min((size_t) this->vc_x, this->rc_line_buffer.size())
+ - this->rc_match_start;
+ auto* context = this->get_active_context();
+
+ if (context->get_append_character() != 0) {
+ if (this->rc_line_buffer.length() > (this->rc_match_start + len - 1)
+ && this->rc_line_buffer[this->rc_match_start + len - 1]
+ == context->get_append_character())
+ {
+ len -= 1;
+ } else if (this->rc_line_buffer.length()
+ > (this->rc_match_start + len - 2)
+ && this->rc_line_buffer[this->rc_match_start + len - 2]
+ == context->get_append_character())
+ {
+ len -= 2;
+ }
+ }
+
+ return this->rc_line_buffer.substr(this->rc_match_start, len);
+}
+
+void
+readline_curses::set_value(const std::string& value)
+{
+ this->set_attr_value(attr_line_t::from_ansi_str(value.c_str()));
+}
+
+void
+readline_curses::set_attr_value(const attr_line_t& value)
+{
+ this->rc_value = value;
+ if (this->rc_value.length() > 1024) {
+ this->rc_value = this->rc_value.subline(0, 1024);
+ }
+ this->rc_value_expiration = time(nullptr) + VALUE_EXPIRATION;
+ this->set_needs_update();
+}
+
+void
+readline_curses::update_poll_set(std::vector<struct pollfd>& pollfds)
+{
+ if (this->rc_pty[RCF_MASTER] != -1) {
+ pollfds.push_back((struct pollfd){this->rc_pty[RCF_MASTER], POLLIN, 0});
+ }
+ if (this->rc_command_pipe[RCF_MASTER] != -1) {
+ pollfds.push_back(
+ (struct pollfd){this->rc_command_pipe[RCF_MASTER], POLLIN, 0});
+ }
+}