TUI stdin pipe following #540

Author: genivia-inc

lib/input.cpp

@@ -1033,6 +1033,7 @@ bool Input::file_ready()
 #if (defined(__WIN32__) || defined(_WIN32) || defined(WIN32) || defined(_WIN64) || defined(__BORLANDC__)) && !defined(__CYGWIN__) && !defined(__MINGW32__) && !defined(__MINGW64__)
   return !ferror(file_);
 #else
+  int fd = fileno(file_);
   if (ferror(file_))
   {
     if (errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR)
@@ -1042,7 +1043,7 @@ bool Input::file_ready()
     if (errno == EAGAIN)
     {
       struct stat buf;
-      if (fstat(fileno(file_), &buf) == 0 && S_ISREG(buf.st_mode))
+      if (fstat(fd, &buf) == 0 && S_ISREG(buf.st_mode))
         return false;
     }
 #endif
@@ -1053,13 +1054,13 @@ bool Input::file_ready()
     fd_set rfds, efds;
     FD_ZERO(&rfds);
     FD_ZERO(&efds);
-    FD_SET(0, &rfds);
-    FD_SET(0, &efds);
+    FD_SET(fd, &rfds);
+    FD_SET(fd, &efds);
     tv.tv_sec = 0;
-    tv.tv_usec = 1000; // 1ms timeout
-    clearerr(file_);   // unset EAGAIN etc
-    if (::select(fileno(file_) + 1, &rfds, NULL, &efds, &tv) >= 0)
-      return FD_ISSET(fileno(file_), &efds) == 0;
+    tv.tv_usec = 10000; // 10ms timeout
+    clearerr(file_);    // unset EAGAIN etc
+    if (::select(fd + 1, &rfds, NULL, &efds, &tv) >= 0)
+      return FD_ISSET(fd, &efds) == 0;
     if (errno != EINTR)
       return false;
   }

lib/pattern.cpp

@@ -4423,7 +4423,7 @@ void Pattern::gen_min(std::set<DFA::State*>& states)
   // find min between 0 and Const::BITS
   min_ = Const::BITS;
   std::set<DFA::State*> prev, next(states);
-  for (size_t level = 0; level < min_; ++level)
+  for (uint16_t level = 0; level < min_; ++level)
   {
     bool none = true;
     prev.clear();

src/query.cpp

@@ -581,7 +581,7 @@ void Query::draw()
 void Query::disp(int row)
 {
   Screen::normal();
-  if (row < rows_)
+  if (row < rows_ + append_)
   {
     if (selected_[row])
       Screen::select();
@@ -683,7 +683,7 @@ void Query::redraw()
   }
   else
   {
-    // do not show dots
+    // reset to 4 to do not show dots
     tick_ = 4;
 
     if (error_ == -1)
@@ -698,7 +698,7 @@ void Query::redraw()
       if (row_ < 0)
         row_ = 0;
 
-      int end = row_ + maxrows_ - 2;
+      int end = row_ + append_ + maxrows_ - 2;
 
       for (int i = row_; i < end; ++i)
         disp(i);
@@ -919,6 +919,7 @@ void Query::query()
     search_thread_.join();
 
   // join the stdin sender thread
+  stdin_stop = true;
   if (stdin_thread_.joinable())
     stdin_thread_.join();
 }
@@ -1482,6 +1483,8 @@ void Query::query_ui()
 // start a new search, cancel the previous search when still running
 void Query::search()
 {
+  stop_stdin();
+
   bool cancel = !eof_;
 
   if (cancel)
@@ -1494,6 +1497,22 @@ void Query::search()
     Static::cancel_ugrep();
   }
 
+  if (search_thread_.joinable())
+  {
+    if (cancel && error_ == -1)
+    {
+      const int banlen = 256;
+      char banner[banlen];
+      snprintf(banner, banlen, "restarting: please be patient while I cancel searching large files...%*s", banlen - 70, "");
+      Screen::normal();
+      Screen::invert();
+      Screen::put(maxrows_ - 1, 0, banner);
+      Screen::normal();
+    }
+
+    search_thread_.join();
+  }
+
 #ifdef OS_WIN
 
   hPipe_ = nonblocking_pipe(search_pipe_);
@@ -1522,23 +1541,8 @@ void Query::search()
 
 #endif
 
-  if (search_thread_.joinable())
-  {
-    if (cancel && error_ == -1)
-    {
-      const int banlen = 256;
-      char banner[banlen];
-      snprintf(banner, banlen, "restarting: please be patient while I cancel searching large files...%*s", banlen - 70, "");
-      Screen::normal();
-      Screen::invert();
-      Screen::put(maxrows_ - 1, 0, banner);
-      Screen::normal();
-    }
-
-    search_thread_.join();
-  }
-
   eof_ = false;
+  append_ = false;
   row_ = 0;
   rows_ = 0;
   skip_ = 0;
@@ -1568,7 +1572,7 @@ void Query::search()
 
   set_flags();
 
-  set_stdin();
+  start_stdin();
 
   if (error_ == -1)
   {
@@ -1668,19 +1672,19 @@ bool Query::update()
   fetch(row_ - (row_ % Screen::rows) + 2 * Screen::rows);
 
   // display the viewable portion when updated
-  if (rows_ > begin && begin < row_ + maxrows_ - 2)
+  if (rows_ + append_ > begin && begin < row_ + append_ + maxrows_ - 2)
   {
     Screen::normal();
 
-    if (begin + maxrows_ - 2 > rows_)
-      begin = rows_ - maxrows_ + 2;
+    int end = rows_ + append_;
+
+    if (begin + maxrows_ - 2 > end)
+      begin = end - maxrows_ + 2;
     if (begin < 0)
       begin = 0;
     if (begin < row_)
       begin = row_;
 
-    int end = rows_;
-
     if (end > row_ + maxrows_ - 2)
       end = row_ + maxrows_ - 2;
 
@@ -1690,9 +1694,11 @@ bool Query::update()
 
   if (error_ == -1)
   {
-    if (tick_ < 8 && rows_ < row_ + maxrows_ - 2)
+    int end = rows_ + append_;
+
+    if (tick_ < 8 && end < row_ + maxrows_ - 2)
     {
-      int row = rows_ - row_ + 1;
+      int row = end - row_ + 1;
 
       // no dots and clear below when we hit eof
       if (eof_)
@@ -4115,34 +4121,22 @@ void Query::get_stdin()
   // if standard input is searched, then buffer all its text
   if (flag_stdin)
   {
-    reflex::BufferedInput input(stdin, flag_encoding_type);
+#ifndef OS_WIN
+    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
+#endif
 
-    while (true)
-    {
-      size_t len = input.get(buffer_, QUERY_BUFFER_SIZE);
-      if (len == 0)
-        break;
-      stdin_buffer_.append(buffer_, len);
-    }
+    stdin_input_ = stdin;
+    stdin_input_.file_encoding(flag_encoding_type);
+    stdin_buffer_.clear();
   }
 }
 
-void Query::set_stdin()
+// start a new stdin sender thread and pipe from sender to the search engine
+void Query::start_stdin()
 {
   // if standard input is searched, start thread to reproduce its text on demand
   if (flag_stdin)
   {
-    // close the stdin pipe when open
-    if (Static::source != stdin && Static::source != NULL)
-    {
-      fclose(Static::source);
-      Static::source = NULL;
-    }
-
-    // join the stdin_sender
-    if (stdin_thread_.joinable())
-      stdin_thread_.join();
-
     // create a new pipe
     if (pipe(stdin_pipe_) < 0)
     {
@@ -4156,19 +4150,61 @@ void Query::set_stdin()
     Static::source = fdopen(stdin_pipe_[0], "rb");
 
     // run stdin_sender in the background to push buffered standard input down the pipe
+    stdin_stop = false;
     stdin_thread_ = std::thread(Query::stdin_sender, stdin_pipe_[1]);
   }
 }
 
+// stop stdin sender thread
+void Query::stop_stdin()
+{
+  if (flag_stdin)
+  {
+    // close the stdin pipe when open
+    if (Static::source != stdin && Static::source != NULL)
+      fclose(Static::source);
+
+    // join the stdin_sender
+    stdin_stop = true;
+    if (stdin_thread_.joinable())
+      stdin_thread_.join();
+  }
+}
+
 // push standard input down the specified pipe fd
-ssize_t Query::stdin_sender(int fd)
+void Query::stdin_sender(int fd)
 {
   // write the stdin data all at once, we can ignore the return value
-  ssize_t nwritten = write(fd, stdin_buffer_.c_str(), stdin_buffer_.size());
+  ssize_t len = stdin_buffer_.size(), nwritten = write(fd, stdin_buffer_.c_str(), len);
 
-  close(fd);
+#ifndef OS_WIN
+  while (!stdin_stop && !feof(stdin) && nwritten == len)
+  {
+    len = stdin_input_.file_get(buffer_, QUERY_BUFFER_SIZE);
+    if (len == 0)
+    {
+      struct timeval tv;
+      fd_set rfds, efds;
+      FD_ZERO(&rfds);
+      FD_ZERO(&efds);
+      FD_SET(0, &rfds);
+      FD_SET(0, &efds);
+      tv.tv_sec = 0;
+      tv.tv_usec = 10000; // 10ms timeout
+      clearerr(stdin);
+      if (::select(0 + 1, &rfds, NULL, &efds, &tv) >= 0 && FD_ISSET(0, &efds) != 0)
+        break;
+      nwritten = 0;
+    }
+    else
+    {
+      stdin_buffer_.append(buffer_, len);
+      nwritten = write(fd, buffer_, len);
+    }
+  }
+#endif
 
-  return nwritten;
+  close(fd);
 }
 
 // true if view_[ref] has a valid filename/filepath identified by three \0 markers and differs from the given filename, then assigns filename
@@ -4413,9 +4449,11 @@ size_t                     Query::buflen_              = 0;
 char                       Query::buffer_[QUERY_BUFFER_SIZE];
 int                        Query::search_pipe_[2];
 std::thread                Query::search_thread_;
+reflex::Input              Query::stdin_input_;
 std::string                Query::stdin_buffer_;
 int                        Query::stdin_pipe_[2];
 std::thread                Query::stdin_thread_;
+volatile bool              Query::stdin_stop           = false;
 size_t                     Query::searched_            = 0;
 size_t                     Query::found_               = 0;
 int                        Query::tick_                = 0;

src/query.hpp

@@ -263,9 +263,10 @@ class Query {
 
   static void get_stdin();
 
-  static void set_stdin();
+  static void start_stdin();
+  static void stop_stdin();
 
-  static ssize_t stdin_sender(int fd);
+  static void stdin_sender(int fd);
 
   static bool find_filename(int ref, std::string& filename, bool compare_dir = false, bool find_path = false, std::string *partname = NULL);
 
@@ -310,14 +311,16 @@ class Query {
   static std::vector<std::string> view_;        // search output text to display, incrementally fetched
   static std::vector<bool>        selected_;    // marked lines in view_[] selected in selection mode
   static bool                     eof_;         // end of results, no more results can be fetched
-  static bool                     append_;
+  static bool                     append_;      // flag to append search output to the last incomplete line
   static size_t                   buflen_;
   static char                     buffer_[QUERY_BUFFER_SIZE];
   static int                      search_pipe_[2];
   static std::thread              search_thread_;
+  static reflex::Input            stdin_input_;
   static std::string              stdin_buffer_;
   static int                      stdin_pipe_[2];
   static std::thread              stdin_thread_;
+  static volatile bool            stdin_stop;
   static size_t                   searched_;    // last update number of files searched
   static size_t                   found_;       // last update number of files found
   static int                      tick_;        // 100ms tick 0 to 7 or steady 8