2017-05-29 22:39:49 +00:00
|
|
|
#include "readline_buffer.h"
|
|
|
|
#include <readline/readline.h>
|
|
|
|
#include <readline/history.h>
|
|
|
|
#include <sys/select.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <mutex>
|
|
|
|
#include <condition_variable>
|
2017-06-27 15:10:26 +00:00
|
|
|
#include <boost/thread.hpp>
|
2017-07-07 19:40:32 +00:00
|
|
|
#include <boost/algorithm/string.hpp>
|
2017-05-29 22:39:49 +00:00
|
|
|
|
|
|
|
static int process_input();
|
|
|
|
static void install_line_handler();
|
|
|
|
static void remove_line_handler();
|
|
|
|
|
|
|
|
static std::string last_line;
|
|
|
|
static std::string last_prompt;
|
2017-06-22 12:15:18 +00:00
|
|
|
std::mutex line_mutex, sync_mutex, process_mutex;
|
2017-05-29 22:39:49 +00:00
|
|
|
std::condition_variable have_line;
|
|
|
|
|
2017-07-07 19:40:32 +00:00
|
|
|
std::vector<std::string> rdln::readline_buffer::completion_commands = {"exit"};
|
|
|
|
|
2017-05-29 22:39:49 +00:00
|
|
|
namespace
|
|
|
|
{
|
|
|
|
rdln::readline_buffer* current = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
rdln::suspend_readline::suspend_readline()
|
2017-06-22 12:15:18 +00:00
|
|
|
: m_buffer(NULL), m_restart(false)
|
2017-05-29 22:39:49 +00:00
|
|
|
{
|
|
|
|
m_buffer = current;
|
|
|
|
if(!m_buffer)
|
|
|
|
return;
|
|
|
|
m_restart = m_buffer->is_running();
|
|
|
|
if(m_restart)
|
|
|
|
m_buffer->stop();
|
|
|
|
}
|
|
|
|
|
|
|
|
rdln::suspend_readline::~suspend_readline()
|
|
|
|
{
|
|
|
|
if(!m_buffer)
|
|
|
|
return;
|
|
|
|
if(m_restart)
|
|
|
|
m_buffer->start();
|
|
|
|
}
|
|
|
|
|
|
|
|
rdln::readline_buffer::readline_buffer()
|
2017-06-21 16:33:47 +00:00
|
|
|
: std::stringbuf(), m_cout_buf(NULL)
|
2017-05-29 22:39:49 +00:00
|
|
|
{
|
|
|
|
current = this;
|
|
|
|
}
|
|
|
|
|
|
|
|
void rdln::readline_buffer::start()
|
|
|
|
{
|
2017-06-22 12:15:18 +00:00
|
|
|
std::unique_lock<std::mutex> lock(process_mutex);
|
2017-05-29 22:39:49 +00:00
|
|
|
if(m_cout_buf != NULL)
|
|
|
|
return;
|
|
|
|
m_cout_buf = std::cout.rdbuf();
|
|
|
|
std::cout.rdbuf(this);
|
|
|
|
install_line_handler();
|
|
|
|
}
|
|
|
|
|
|
|
|
void rdln::readline_buffer::stop()
|
|
|
|
{
|
2017-06-22 12:15:18 +00:00
|
|
|
std::unique_lock<std::mutex> lock(process_mutex);
|
2017-07-07 11:59:07 +00:00
|
|
|
have_line.notify_all();
|
2017-05-29 22:39:49 +00:00
|
|
|
if(m_cout_buf == NULL)
|
|
|
|
return;
|
|
|
|
std::cout.rdbuf(m_cout_buf);
|
|
|
|
m_cout_buf = NULL;
|
|
|
|
remove_line_handler();
|
|
|
|
}
|
|
|
|
|
2017-06-21 16:33:30 +00:00
|
|
|
void rdln::readline_buffer::get_line(std::string& line) const
|
2017-05-29 22:39:49 +00:00
|
|
|
{
|
|
|
|
std::unique_lock<std::mutex> lock(line_mutex);
|
|
|
|
have_line.wait(lock);
|
|
|
|
line = last_line;
|
|
|
|
}
|
|
|
|
|
|
|
|
void rdln::readline_buffer::set_prompt(const std::string& prompt)
|
|
|
|
{
|
|
|
|
last_prompt = prompt;
|
|
|
|
if(m_cout_buf == NULL)
|
|
|
|
return;
|
2017-07-07 19:40:32 +00:00
|
|
|
std::lock_guard<std::mutex> lock(sync_mutex);
|
2017-05-29 22:39:49 +00:00
|
|
|
rl_set_prompt(last_prompt.c_str());
|
|
|
|
rl_redisplay();
|
|
|
|
}
|
|
|
|
|
|
|
|
int rdln::readline_buffer::process()
|
|
|
|
{
|
2017-06-27 15:10:26 +00:00
|
|
|
process_mutex.lock();
|
2017-05-29 22:39:49 +00:00
|
|
|
if(m_cout_buf == NULL)
|
2017-06-27 15:10:26 +00:00
|
|
|
{
|
|
|
|
process_mutex.unlock();
|
|
|
|
boost::this_thread::sleep_for(boost::chrono::milliseconds( 1 ));
|
2017-05-29 22:39:49 +00:00
|
|
|
return 0;
|
2017-06-27 15:10:26 +00:00
|
|
|
}
|
|
|
|
int count = process_input();
|
|
|
|
process_mutex.unlock();
|
|
|
|
boost::this_thread::sleep_for(boost::chrono::milliseconds( 1 ));
|
|
|
|
return count;
|
2017-05-29 22:39:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int rdln::readline_buffer::sync()
|
|
|
|
{
|
|
|
|
std::lock_guard<std::mutex> lock(sync_mutex);
|
|
|
|
char* saved_line;
|
|
|
|
int saved_point;
|
|
|
|
|
|
|
|
saved_point = rl_point;
|
|
|
|
saved_line = rl_copy_text(0, rl_end);
|
|
|
|
|
|
|
|
rl_set_prompt("");
|
|
|
|
rl_replace_line("", 0);
|
|
|
|
rl_redisplay();
|
|
|
|
|
|
|
|
do
|
|
|
|
{
|
2017-07-07 19:40:32 +00:00
|
|
|
m_cout_buf->sputc( this->sgetc() );
|
2017-05-29 22:39:49 +00:00
|
|
|
}
|
|
|
|
while ( this->snextc() != EOF );
|
|
|
|
|
|
|
|
rl_set_prompt(last_prompt.c_str());
|
|
|
|
rl_replace_line(saved_line, 0);
|
|
|
|
rl_point = saved_point;
|
|
|
|
rl_redisplay();
|
|
|
|
free(saved_line);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int process_input()
|
|
|
|
{
|
|
|
|
int count;
|
|
|
|
struct timeval t;
|
2017-06-27 15:12:14 +00:00
|
|
|
fd_set fds;
|
2017-05-29 22:39:49 +00:00
|
|
|
|
|
|
|
t.tv_sec = 0;
|
2017-06-23 12:21:50 +00:00
|
|
|
t.tv_usec = 1000;
|
2017-05-29 22:39:49 +00:00
|
|
|
|
|
|
|
FD_ZERO(&fds);
|
|
|
|
FD_SET(STDIN_FILENO, &fds);
|
2017-06-27 15:12:14 +00:00
|
|
|
count = select(STDIN_FILENO + 1, &fds, NULL, NULL, &t);
|
2017-05-29 22:39:49 +00:00
|
|
|
if (count < 1)
|
|
|
|
{
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
rl_callback_read_char();
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void handle_line(char* line)
|
|
|
|
{
|
2017-07-24 13:54:27 +00:00
|
|
|
// This function never gets called now as we are trapping newlines.
|
|
|
|
// However, it still needs to be present for readline to know we are
|
|
|
|
// manually handling lines.
|
|
|
|
rl_done = 1;
|
|
|
|
return;
|
2017-05-29 22:39:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int handle_enter(int x, int y)
|
|
|
|
{
|
|
|
|
std::lock_guard<std::mutex> lock(sync_mutex);
|
|
|
|
char* line = NULL;
|
2017-07-07 19:40:32 +00:00
|
|
|
|
2017-05-29 22:39:49 +00:00
|
|
|
line = rl_copy_text(0, rl_end);
|
2017-07-24 13:54:27 +00:00
|
|
|
std::string test_line = line;
|
|
|
|
boost::trim_right(test_line);
|
|
|
|
|
2017-07-07 19:40:32 +00:00
|
|
|
rl_crlf();
|
|
|
|
rl_on_new_line();
|
2017-07-24 13:54:27 +00:00
|
|
|
|
|
|
|
if(test_line.empty())
|
|
|
|
{
|
|
|
|
last_line = "";
|
|
|
|
rl_set_prompt(last_prompt.c_str());
|
|
|
|
rl_replace_line("", 1);
|
|
|
|
rl_redisplay();
|
|
|
|
have_line.notify_one();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-29 22:39:49 +00:00
|
|
|
rl_set_prompt("");
|
|
|
|
rl_replace_line("", 1);
|
|
|
|
rl_redisplay();
|
|
|
|
|
2017-07-24 13:54:27 +00:00
|
|
|
if (!test_line.empty())
|
2017-05-29 22:39:49 +00:00
|
|
|
{
|
2017-07-07 19:40:32 +00:00
|
|
|
last_line = test_line;
|
|
|
|
add_history(test_line.c_str());
|
2017-07-24 13:54:27 +00:00
|
|
|
history_set_pos(history_length);
|
2017-05-29 22:39:49 +00:00
|
|
|
}
|
|
|
|
free(line);
|
2017-07-07 19:40:32 +00:00
|
|
|
|
|
|
|
if(last_line != "exit" && last_line != "q")
|
2017-06-20 13:22:55 +00:00
|
|
|
{
|
|
|
|
rl_set_prompt(last_prompt.c_str());
|
2017-07-24 13:54:27 +00:00
|
|
|
rl_replace_line("", 1);
|
2017-06-20 13:22:55 +00:00
|
|
|
rl_redisplay();
|
|
|
|
}
|
2017-07-07 19:40:32 +00:00
|
|
|
|
2017-07-24 13:54:27 +00:00
|
|
|
have_line.notify_one();
|
2017-05-29 22:39:49 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int startup_hook()
|
|
|
|
{
|
|
|
|
rl_bind_key(RETURN, handle_enter);
|
|
|
|
rl_bind_key(NEWLINE, handle_enter);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-07-07 19:40:32 +00:00
|
|
|
static char* completion_matches(const char* text, int state)
|
|
|
|
{
|
|
|
|
static size_t list_index;
|
|
|
|
static size_t len;
|
|
|
|
|
|
|
|
if(state == 0)
|
|
|
|
{
|
|
|
|
list_index = 0;
|
|
|
|
len = strlen(text);
|
|
|
|
}
|
|
|
|
|
|
|
|
const std::vector<std::string>& completions = rdln::readline_buffer::get_completions();
|
|
|
|
for(; list_index<completions.size(); )
|
|
|
|
{
|
|
|
|
const std::string& cmd = completions[list_index++];
|
|
|
|
if(cmd.compare(0, len, text) == 0)
|
|
|
|
{
|
|
|
|
return strdup(cmd.c_str());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char** attempted_completion(const char* text, int start, int end)
|
|
|
|
{
|
|
|
|
rl_attempted_completion_over = 1;
|
|
|
|
return rl_completion_matches(text, completion_matches);
|
|
|
|
}
|
|
|
|
|
2017-05-29 22:39:49 +00:00
|
|
|
static void install_line_handler()
|
|
|
|
{
|
|
|
|
rl_startup_hook = startup_hook;
|
2017-07-07 19:40:32 +00:00
|
|
|
rl_attempted_completion_function = attempted_completion;
|
2017-05-29 22:39:49 +00:00
|
|
|
rl_callback_handler_install("", handle_line);
|
2017-07-24 13:54:27 +00:00
|
|
|
stifle_history(500);
|
2017-05-29 22:39:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void remove_line_handler()
|
|
|
|
{
|
2017-07-07 19:40:32 +00:00
|
|
|
rl_replace_line("", 0);
|
|
|
|
rl_set_prompt("");
|
|
|
|
rl_redisplay();
|
2017-05-29 22:39:49 +00:00
|
|
|
rl_unbind_key(RETURN);
|
2017-07-07 19:40:32 +00:00
|
|
|
rl_unbind_key(NEWLINE);
|
2017-05-29 22:39:49 +00:00
|
|
|
rl_callback_handler_remove();
|
|
|
|
}
|
|
|
|
|