Removed exceptions and cleaned up process pipe api

Author: mikucionisaau

source/matplot/backend/gnuplot.cpp

@@ -72,16 +72,16 @@ namespace matplot::backend {
         // Open the gnuplot pipe_
         int perr;
         if constexpr (windows_should_persist_by_default) {
-            perr = popen2("gnuplot --persist", "w", &pipe_);
+            perr = pipe_open(&pipe_, "gnuplot --persist", "w");
         } else {
-            perr = popen2("gnuplot", "w", &pipe_);
+            perr = pipe_open(&pipe_, "gnuplot", "w");
         }
 
         // Check if everything is OK
-        if (perr != 0) {
-            std::cerr << "Opening the gnuplot pipe_ failed: " std::strerror(perr) << std::endl;
-            std::cerr
-                << "Please install gnuplot 5.2.6+: http://www.gnuplot.info"
+        if (perr != 0 || !pipe_is_valid(pipe_)) {
+            std::cerr << "Opening the gnuplot pipe_ failed: " 
+                << std::strerror(perr) << std::endl;
+            std::cerr << "Please install gnuplot 5.2.6+: http://www.gnuplot.info"
                 << std::endl;
         }
     }
@@ -98,8 +98,8 @@ namespace matplot::backend {
         flush_commands();
         run_command("exit");
         flush_commands();
-        if (pipe_.file != nullptr) {
-            pclose2(&pipe_);
+        if (pipe_is_valid(pipe_)) {
+            pipe_close(&pipe_);
         }
     }
 
@@ -282,7 +282,7 @@ namespace matplot::backend {
         if constexpr (dont_let_it_close_too_fast) {
             last_flush_ = std::chrono::high_resolution_clock::now();
         }
-        proc_flush(&pipe_, "\n");
+        pipe_flush(&pipe_, "\n");
         if constexpr (trace_commands) {
             std::cout << "\n\n\n\n" << std::endl;
         }
@@ -294,7 +294,7 @@ namespace matplot::backend {
     }
 
     void gnuplot::run_command(const std::string &command) {
-        if (pipe_.file != nullptr) {
+        if (!pipe_is_valid(pipe_)) {
             return;
         }
         size_t pipe_capacity = gnuplot_pipe_capacity(pipe_.file);
@@ -303,10 +303,10 @@ namespace matplot::backend {
             bytes_in_pipe_ = 0;
         }
         if (!command.empty()) {
-            proc_write(&pipe_, command);
+            pipe_write(&pipe_, command);
         }
         // proc_write(&pipe_, "; ");
-        proc_write(&pipe_, "\n");
+        pipe_write(&pipe_, "\n");
         bytes_in_pipe_ += command.size();
         if constexpr (trace_commands) {
             std::cout << command << std::endl;
@@ -323,11 +323,9 @@ namespace matplot::backend {
         static std::string terminal_type;
         const bool dont_know_term_type = terminal_type.empty();
         if (dont_know_term_type) {
-            terminal_type =
-                run_and_get_output("gnuplot -e \"show terminal\" 2>&1");
-            terminal_type = std::regex_replace(
-                terminal_type, std::regex("[^]*terminal type is ([^ ]+)[^]*"),
-                "$1");
+            terminal_type = run_and_get_output("gnuplot -e \"show terminal\" 2>&1");
+            terminal_type = std::regex_replace(terminal_type,
+                    std::regex("[^]*terminal type is ([^ ]+)[^]*"), "$1");
             const bool still_dont_know_term_type = terminal_type.empty();
             if (still_dont_know_term_type) {
                 terminal_type = "qt";
@@ -337,9 +335,8 @@ namespace matplot::backend {
     }
 
     bool gnuplot::terminal_is_available(std::string_view term) {
-        std::string msg =
-            run_and_get_output("gnuplot -e \"set terminal " +
-                               std::string(term.data()) + "\" 2>&1");
+        std::string msg = run_and_get_output("gnuplot -e \"set terminal " +
+                                     std::string(term.data()) + "\" 2>&1");
         return msg.empty();
     }
 

source/matplot/util/common.cpp

@@ -51,7 +51,9 @@ namespace matplot {
     }
 
     std::string run_and_get_output(const std::string &cmd) {
-        return shell_read(cmd);
+        auto res = std::string{};
+        shell_read(cmd, res);
+        return res;
     }
 
     std::string escape(std::string_view label) {

source/matplot/util/popen.cpp

@@ -5,7 +5,7 @@
 
 #include <io.h>
 
-int popen2(const char *cmd, const char* mode, ProcPipe *pipe)
+int pipe_open(ProcPipe *pipe, const char *cmd, const char *mode) 
 {
     if (cmd == nullptr || mode == nullptr || (mode[0] != 'r' && mode[0] != 'w') ||
         pipe == nullptr)
@@ -88,11 +88,11 @@ int popen2(const char *cmd, const char* mode, ProcPipe *pipe)
     return 0;
 }
 
-int pclose2(ProcPipe *pipe, int *exit_code)
+int pipe_close(ProcPipe *pipe, int *exit_code)
 {
     // The following does not work for GetExitCodeProcess:
     // HANDLE hFile = (HANDLE)_get_osfhandle(_fileno(file));
-    if (pipe == nullptr || pipe->file == nullptr)
+    if (!pipe_is_valid(pipe))
         return EINVAL;
     // Close the pipe to process:
     fclose(pipe->file);
@@ -123,7 +123,7 @@ int pclose2(ProcPipe *pipe, int *exit_code)
 #include <cerrno>
 #include <sys/wait.h> // waitpid
 
-int popen2(const char *cmd, const char *mode, ProcPipe *p)
+int pipe_open(ProcPipe *p, const char *cmd, const char *mode) 
 {
     constexpr auto READ = 0u;
     constexpr auto WRITE = 1u;
@@ -161,9 +161,9 @@ int popen2(const char *cmd, const char *mode, ProcPipe *p)
 }
 
 /// Closes the pipe opened by popen2 and waits for termination
-int pclose2(ProcPipe *pipe, int *exit_code)
+int pipe_close(ProcPipe *pipe, int *exit_code)
 {
-    if (pipe == nullptr || pipe->file == nullptr)
+    if (!proc_is_good(pipe))
         return EINVAL;
     fclose(pipe->file);
     while (waitpid(pipe->pid, exit_code, 0) == -1) {
@@ -172,35 +172,67 @@ int pclose2(ProcPipe *pipe, int *exit_code)
             break;
         }
     }
+    pipe->file = nullptr;
     return 0;
 }
 
 #endif // POSIX implementation
 
-void shell_write(const std::string &cmd, std::string_view input)
+int pipe_write(ProcPipe *p, std::string_view data) 
+{
+    constexpr auto CSIZE = sizeof(std::string_view::value_type);
+    if (!pipe_is_valid(p))
+        return EINVAL;
+    if (auto sz = std::fwrite(data.data(), CSIZE, data.length(), p->file);
+        sz != data.size()) {
+        if (auto err = std::ferror(p->file); err != 0)
+            return EIO;
+        if (auto err = std::feof(p->file); err != 0)
+            return EIO;
+    }
+    if (auto res = std::fflush(p->file); res != 0)
+        return errno;
+    return 0;
+}
+
+int pipe_flush(ProcPipe *p, std::string_view data) 
+{
+    if (!pipe_is_valid(p))
+        return EINVAL;
+    if (!data.empty())
+        if (auto err = pipe_write(p, data); err != 0)
+            return err;
+    if (auto res = std::fflush(p->file); res != 0)
+        return errno;
+    return 0;
+}
+
+int shell_write(const std::string &cmd, std::string_view data)
 {
     auto pipe = ProcPipe{};
-    if (auto e = popen2(cmd.c_str(), "w", &pipe); e != 0)
-        throw std::system_error{e, std::system_category(), "popen2"};
-    if (!input.empty())
-        proc_flush(&pipe, input);
-    if (auto e = pclose2(&pipe); e != 0)
-        throw std::system_error{e, std::system_category(), "pclose2"};
+    if (auto err = pipe_open(&pipe, cmd.c_str(), "w"); err != 0)
+        return err;
+    if (!data.empty())
+        if (auto err = pipe_flush(&pipe, data); err != 0)
+            return err;
+    if (auto err = pipe_close(&pipe); err != 0)
+        return err;
+    return 0;
 }
 
-std::string shell_read(const std::string &cmd)
+int shell_read(const std::string &cmd, std::string &data)
 {
     auto pipe = ProcPipe{};
-    if (auto e = popen2(cmd.c_str(), "r", &pipe); e != 0)
-        throw std::system_error{e, std::system_category(), "popen2"};
-    auto res = std::string{};
+    if (auto err = pipe_open(&pipe, cmd.c_str(), "r"); err != 0)
+        return err;
+    data.clear();
     auto buffer = std::array<char, 128>{};
-    while (!feof(pipe.file) && !ferror(pipe.file)) {
-        auto count = fread(buffer.data(), sizeof(char), buffer.size(), pipe.file);
+    while (!std::feof(pipe.file) && !std::ferror(pipe.file)) {
+        auto count = std::fread(buffer.data(), sizeof(char), buffer.size(), pipe.file);
         if (count > 0)
-            res.append(buffer.data(), count);
+            data.append(buffer.data(), count);
     }
-    if (auto e = pclose2(&pipe); e != 0)
-        throw std::system_error{e, std::system_category(), "pclose2"};
-    return res;
+    if (auto err = pipe_close(&pipe); err != 0)
+        return err;
+    return 0;
 }

source/matplot/util/popen.h

@@ -43,49 +43,43 @@ struct ProcPipe
  * @param pipe the piped file and child process handle
  * @returns 0 upon success and system error number upon failure
  */
-int popen2(const char *command, const char *mode, ProcPipe *pipe);
+int pipe_open(ProcPipe *pipe, const char *command, const char *mode);
+
+/// Return true if pipe represents a valid handle
+inline bool pipe_is_valid(ProcPipe *pipe)
+{
+    return pipe != nullptr && pipe->file != nullptr;
+}
 
 /** Closes the pipe opened by popen2 and waits for the process to terminate.
  * @param pipe the handle to close and wait for exit
  * @param exit_code to store the process exit code
  * @returns 0 upon success and system error number (errno) upon failure
  */
-int pclose2(ProcPipe *pipe, int *exit_code = nullptr);
+int pipe_close(ProcPipe *pipe, int *exit_code = nullptr);
 
 #ifdef __cplusplus
 
 #include <string>
 #include <string_view>
-#include <system_error>
 
-/// Writes data into the process pipe without flushing
-inline void proc_write(ProcPipe *p, std::string_view data)
+/// Return true if pipe represents a valid handle
+inline bool pipe_is_valid(ProcPipe &pipe) 
 {
-    constexpr auto CSIZE = sizeof(std::string_view::value_type);
-    if (auto sz = fwrite(data.data(), CSIZE, data.size(), p->file); sz != data.size()) {
-        if (auto e = ferror(p->file); e != 0)
-            throw std::runtime_error{"fwrite failed after "+std::to_string(sz)};
-        if (auto e = feof(p->file); e != 0)
-            throw std::runtime_error{"fwrite reached end-of-file after "+std::to_string(sz)};
-    }
-    if (auto e = fflush(p->file); e != 0)
-        throw std::system_error{errno, std::system_category(), "fflush"};
+    return pipe.file != nullptr;
 }
 
-/// Writes data into process pipe followed by a flush
-inline void proc_flush(ProcPipe *p, std::string_view data = {})
-{
-    if (!data.empty())
-        proc_write(p, data);
-    if (auto e = fflush(p->file); e != 0)
-        throw std::system_error{errno, std::system_category(), "fflush"};
-}
+/// Writes data into the process pipe without flushing, returns errno if failed
+int pipe_write(ProcPipe *pipe, std::string_view data);
+
+/// Writes data into the process pipe followed by a flush, returns errno if failed
+int pipe_flush(ProcPipe *pipe, std::string_view data = {});
 
-/// Launches a shell command, writes data to its input stream and waits for completion.
-void shell_write(const std::string &cmd, std::string_view data = {});
+/// Launches the shell command, writes data to input stream and waits for completion, returns errno if failed
+int shell_write(const std::string &command, std::string_view data = {});
 
-/// Launches a shell command, reads data from its output stream and waits for completion.
-std::string shell_read(const std::string &cmd);
+/// Launches the shell command, reads data from output stream and waits for completion, returns errno if failed
+int shell_read(const std::string &command, std::string& data);
 
 #endif // __cplusplus