Simplify readline support

And don't use std::mutex

contrib/epee/include/console_handler.h

@@ -52,11 +52,10 @@ namespace epee
       , m_has_read_request(false)
       , m_read_status(state_init)
     {
-      m_reader_thread = boost::thread(std::bind(&async_stdin_reader::reader_thread_func, this));
 #ifdef HAVE_READLINE
       m_readline_buffer.start();
-      m_readline_thread = boost::thread(std::bind(&async_stdin_reader::readline_thread_func, this));
 #endif
+      m_reader_thread = boost::thread(std::bind(&async_stdin_reader::reader_thread_func, this));
     }
 
     ~async_stdin_reader()
@@ -115,7 +114,6 @@ namespace epee
         m_reader_thread.join();
 #ifdef HAVE_READLINE
         m_readline_buffer.stop();
-        m_readline_thread.join();
 #endif
       }
     }
@@ -193,16 +191,6 @@ namespace epee
       return true;
     }
 
-#ifdef HAVE_READLINE
-    void readline_thread_func()
-    {
-      while (m_run.load(std::memory_order_relaxed))
-      {
-        m_readline_buffer.process();
-      }
-    }
-#endif
-
     void reader_thread_func()
     {
       while (true)
@@ -212,12 +200,20 @@ namespace epee
 
         std::string line;
         bool read_ok = true;
+#ifdef HAVE_READLINE
+reread:
+#endif
         if (wait_stdin_data())
         {
           if (m_run.load(std::memory_order_relaxed))
           {
 #ifdef HAVE_READLINE
-            m_readline_buffer.get_line(line);
+            switch (m_readline_buffer.get_line(line))
+            {
+            case rdln::empty:   goto eof;
+            case rdln::partial: goto reread;
+            case rdln::full:    break;
+            }
 #else
             std::getline(std::cin, line);
 #endif
@@ -229,6 +225,9 @@ namespace epee
           read_ok = false;
         }
         if (std::cin.eof()) {
+#ifdef HAVE_READLINE
+eof:
+#endif
           m_read_status = state_eos;
           m_response_cv.notify_one();
           break;
@@ -263,7 +262,6 @@ namespace epee
     boost::thread m_reader_thread;
     std::atomic<bool> m_run;
 #ifdef HAVE_READLINE
-    boost::thread m_readline_thread;
     rdln::readline_buffer m_readline_buffer;
 #endif
 

contrib/epee/include/readline_buffer.h

@@ -8,18 +8,18 @@
 
 namespace rdln
 {
+  typedef enum { empty, partial, full } linestatus;
   class readline_buffer : public std::stringbuf
   {
   public:
     readline_buffer();
     void start();
     void stop();
-    int process();
     bool is_running() const
     {
       return m_cout_buf != NULL;
     }
-    void get_line(std::string& line) const;
+    linestatus get_line(std::string& line) const;
     void set_prompt(const std::string& prompt);
     static void add_completion(const std::string& command);
     static const std::vector<std::string>& get_completions();

contrib/epee/src/readline_buffer.cpp

@@ -3,19 +3,15 @@
 #include <readline/history.h>
 #include <sys/select.h>
 #include <unistd.h>
-#include <mutex>
-#include <condition_variable>
 #include <boost/thread.hpp>
 #include <boost/algorithm/string.hpp>
 
-static int process_input();
 static void install_line_handler();
 static void remove_line_handler();
 
-static std::string last_line;
+static boost::mutex sync_mutex;
-static std::string last_prompt;
+static rdln::linestatus line_stat;
-static std::mutex line_mutex, sync_mutex, process_mutex;
+static char *the_line;
-static std::condition_variable have_line;
 
 namespace
 {
@@ -55,7 +51,6 @@ rdln::readline_buffer::readline_buffer()
 
 void rdln::readline_buffer::start()
 {
-  std::unique_lock<std::mutex> lock(process_mutex);
   if(m_cout_buf != NULL)
     return;
   m_cout_buf = std::cout.rdbuf();
@@ -65,9 +60,6 @@ void rdln::readline_buffer::start()
 
 void rdln::readline_buffer::stop()
 {
-  std::unique_lock<std::mutex> lock_process(process_mutex);
-  std::unique_lock<std::mutex> lock_sync(sync_mutex);
-  have_line.notify_all();
   if(m_cout_buf == NULL)
     return;
   std::cout.rdbuf(m_cout_buf);
@@ -75,20 +67,26 @@ void rdln::readline_buffer::stop()
   remove_line_handler();
 }
 
-void rdln::readline_buffer::get_line(std::string& line) const
+rdln::linestatus rdln::readline_buffer::get_line(std::string& line) const
 {
-  std::unique_lock<std::mutex> lock(line_mutex);
+  boost::lock_guard<boost::mutex> lock(sync_mutex);
-  have_line.wait(lock);
+  line_stat = rdln::partial;
-  line = last_line;
+  rl_callback_read_char();
+  if (line_stat == rdln::full)
+  {
+    line = the_line;
+    free(the_line);
+    the_line = NULL;
+  }
+  return line_stat;
 }
 
 void rdln::readline_buffer::set_prompt(const std::string& prompt)
 {
-  last_prompt = prompt;
   if(m_cout_buf == NULL)
     return;
-  std::lock_guard<std::mutex> lock(sync_mutex);
+  boost::lock_guard<boost::mutex> lock(sync_mutex);
-  rl_set_prompt(last_prompt.c_str());
+  rl_set_prompt(prompt.c_str());
   rl_redisplay();
 }
 
@@ -104,33 +102,30 @@ const std::vector<std::string>& rdln::readline_buffer::get_completions()
   return completion_commands();
 }
 
-int rdln::readline_buffer::process()
-{
-  process_mutex.lock();
-  if(m_cout_buf == NULL)
-  {
-    process_mutex.unlock();
-    boost::this_thread::sleep_for(boost::chrono::milliseconds( 1 ));
-    return 0;
-  }
-  int count = process_input();
-  process_mutex.unlock();
-  boost::this_thread::sleep_for(boost::chrono::milliseconds( 1 ));
-  return count;
-}
-
 int rdln::readline_buffer::sync()
 {
-  std::lock_guard<std::mutex> lock(sync_mutex);
+  boost::lock_guard<boost::mutex> lock(sync_mutex);
-  char* saved_line;
+#if RL_READLINE_VERSION < 0x0700
-  int saved_point;
+  char lbuf[2] = {0,0};
+  char *line = NULL;
+  int end = 0, point = 0;
+#endif
 
-  saved_point = rl_point;
+  if (rl_end || *rl_prompt)
-  saved_line = rl_copy_text(0, rl_end);
+  {
-  
+#if RL_READLINE_VERSION >= 0x0700
-  rl_set_prompt("");
+    rl_clear_visible_line();
-  rl_replace_line("", 0);
+#else
+    line = rl_line_buffer;
+    end = rl_end;
+    point = rl_point;
+    rl_line_buffer = lbuf;
+    rl_end = 0;
+    rl_point = 0;
+    rl_save_prompt();
     rl_redisplay();
+#endif
+  }
 
   do
   {
@@ -138,92 +133,47 @@ int rdln::readline_buffer::sync()
   }
   while ( this->snextc() != EOF );
 
-  rl_set_prompt(last_prompt.c_str());
+#if RL_READLINE_VERSION < 0x0700
-  rl_replace_line(saved_line, 0);
+  if (end || *rl_prompt)
-  rl_point = saved_point;
+  {
+    rl_restore_prompt();
+    rl_line_buffer = line;
+    rl_end = end;
+    rl_point = point;
+  }
+#endif
+  rl_on_new_line();
   rl_redisplay();
-  free(saved_line);
 
   return 0;
 }
 
-static int process_input()
-{
-  int count;
-  struct timeval t;
-  fd_set fds;
-  
-  t.tv_sec = 0;
-  t.tv_usec = 1000;
-  
-  FD_ZERO(&fds);
-  FD_SET(STDIN_FILENO, &fds);
-  count = select(STDIN_FILENO + 1, &fds, NULL, NULL, &t);
-  if (count < 1)
-  {
-    return count;
-  }
-  rl_callback_read_char();
-  return count;
-}
-
 static void handle_line(char* line)
 {
-  free(line);
+  bool exit = false;
-  rl_done = 1;
+  if (line)
-  return;
+  {
-}
+    line_stat = rdln::full;
-
+    the_line = line;
-static int handle_enter(int x, int y)
-{
-  std::lock_guard<std::mutex> lock(sync_mutex);
-  char* line = NULL;
-
-  line = rl_copy_text(0, rl_end);
     std::string test_line = line;
-  free(line);
     boost::trim_right(test_line);
-
+    if(!test_line.empty())
-  rl_crlf();
-  rl_on_new_line();
-
-  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;
-  }
-
-  rl_set_prompt("");
-  rl_replace_line("", 1);
-  rl_redisplay();
-  
-  if (!test_line.empty())
-  {
-    last_line = test_line;
       add_history(test_line.c_str());
       history_set_pos(history_length);
+      if (test_line == "exit" || test_line == "q")
+        exit = true;
     }
-
+  } else
-  if(last_line != "exit" && last_line != "q")
+  /* EOF */
   {
-    rl_set_prompt(last_prompt.c_str());
+    line_stat = rdln::empty;
-    rl_replace_line("", 1);
+    exit = true;
-    rl_redisplay();
   }
-
+  rl_done = 1;
-  have_line.notify_one();
+  if (exit)
-  return 0;
+    rl_set_prompt("");
-}
+  return;
-
-static int startup_hook()
-{
-  rl_bind_key(RETURN, handle_enter);
-  rl_bind_key(NEWLINE, handle_enter);
-  return 0;
 }
 
 static char* completion_matches(const char* text, int state)
@@ -258,7 +208,6 @@ static char** attempted_completion(const char* text, int start, int end)
 
 static void install_line_handler()
 {
-  rl_startup_hook = startup_hook;
   rl_attempted_completion_function = attempted_completion;
   rl_callback_handler_install("", handle_line);
   stifle_history(500);
@@ -269,8 +218,6 @@ static void remove_line_handler()
   rl_replace_line("", 0);
   rl_set_prompt("");
   rl_redisplay();
-  rl_unbind_key(RETURN);
-  rl_unbind_key(NEWLINE);
   rl_callback_handler_remove();
 }