[tidy] start to replace strerror()

Author: tstack

src/base/auto_fd.cc

@@ -29,12 +29,17 @@
  * @file auto_fd.cc
  */
 
+#include <string>
+
 #include "auto_fd.hh"
 
 #include <fcntl.h>
 #include <unistd.h>
 
+#include "fmt/format.h"
+#include "intern_string.hh"
 #include "lnav_log.hh"
+#include "result.h"
 
 int
 auto_fd::pipe(auto_fd* af)
@@ -73,24 +78,18 @@ auto_fd::openpt(int flags)
     auto rc = posix_openpt(flags);
     if (rc == -1) {
         return Err(fmt::format(FMT_STRING("posix_openpt() failed: {}"),
-                               strerror(errno)));
+                               lnav::from_errno()));
     }
 
     return Ok(auto_fd{rc});
 }
 
-auto_fd::
-auto_fd(int fd)
-    : af_fd(fd)
+auto_fd::auto_fd(int fd) : af_fd(fd)
 {
     require(fd >= -1);
 }
 
-auto_fd::
-auto_fd(auto_fd&& af) noexcept
-    : af_fd(af.release())
-{
-}
+auto_fd::auto_fd(auto_fd&& af) noexcept : af_fd(af.release()) {}
 
 auto_fd
 auto_fd::dup() const
@@ -104,8 +103,7 @@ auto_fd::dup() const
     return auto_fd{new_fd};
 }
 
-auto_fd::~
-auto_fd()
+auto_fd::~auto_fd()
 {
     this->reset();
 }
@@ -191,14 +189,13 @@ auto_pipe::for_child_fd(int child_fd)
     auto_pipe retval(child_fd);
 
     if (retval.open() == -1) {
-        return Err(std::string(strerror(errno)));
+        return Err(lnav::from_errno().message());
     }
 
     return Ok(std::move(retval));
 }
 
-auto_pipe::
-auto_pipe(int child_fd, int child_flags)
+auto_pipe::auto_pipe(int child_fd, int child_flags)
     : ap_child_flags(child_flags), ap_child_fd(child_fd)
 {
     switch (child_fd) {

src/base/fs_util.cc

@@ -29,6 +29,8 @@
 
 #include <filesystem>
 #include <fstream>
+#include <optional>
+#include <string>
 #include <utility>
 
 #include "fs_util.hh"
@@ -84,7 +86,8 @@ self_path()
 
     auto rc = proc_pidpath(pid, pathbuf, sizeof(pathbuf));
     if (rc <= 0) {
-        log_error("unable to determine self path: %s", strerror(errno));
+        log_error("unable to determine self path: %s",
+                  lnav::from_errno().message().c_str());
     } else {
         log_info("self path: %s", pathbuf);
         return std::filesystem::path(pathbuf);
@@ -351,7 +354,7 @@ realpath(const std::filesystem::path& path)
     auto rc = ::realpath(path.c_str(), resolved);
 
     if (rc == nullptr) {
-        return Err(std::string(strerror(errno)));
+        return Err(lnav::from_errno().message());
     }
 
     return Ok(std::filesystem::path(resolved));
@@ -365,7 +368,7 @@ create_file(const std::filesystem::path& path, int flags, mode_t mode)
     if (fd == -1) {
         return Err(fmt::format(FMT_STRING("Failed to open: {} -- {}"),
                                path.string(),
-                               strerror(errno)));
+                               lnav::from_errno()));
     }
 
     return Ok(auto_fd(fd));
@@ -379,7 +382,7 @@ open_file(const std::filesystem::path& path, int flags)
     if (fd == -1) {
         return Err(fmt::format(FMT_STRING("Failed to open: {} -- {}"),
                                path.string(),
-                               strerror(errno)));
+                               lnav::from_errno()));
     }
 
     return Ok(auto_fd(fd));
@@ -406,7 +409,7 @@ open_temp_file(const std::filesystem::path& pattern)
         return Err(
             fmt::format(FMT_STRING("unable to create temporary file: {} -- {}"),
                         pattern.string(),
-                        strerror(errno)));
+                        lnav::from_errno()));
     }
 
     return Ok(std::make_pair(std::filesystem::path(pattern_copy), auto_fd(fd)));
@@ -419,7 +422,7 @@ read_file(const std::filesystem::path& path)
         std::ifstream file_stream(path);
 
         if (!file_stream) {
-            return Err(std::string(strerror(errno)));
+            return Err(lnav::from_errno().message());
         }
 
         std::string retval;
@@ -449,7 +452,7 @@ write_file(const std::filesystem::path& path,
                 return Err(fmt::format(
                     FMT_STRING("unable to write to temporary file {}: {}"),
                     tmp_pair.first.string(),
-                    strerror(errno)));
+                    lnav::from_errno()));
             }
 
             if (bytes_written != sf.length()) {
@@ -535,7 +538,7 @@ stat_file(const std::filesystem::path& path)
 
     return Err(fmt::format(FMT_STRING("failed to find file: {} -- {}"),
                            path.string(),
-                           strerror(errno)));
+                           lnav::from_errno()));
 }
 
 file_lock::file_lock(const std::filesystem::path& archive_path)

src/base/intern_string.hh

@@ -36,6 +36,7 @@
 #include <ostream>
 #include <string>
 #include <string_view>
+#include <system_error>
 #include <tuple>
 #include <vector>
 
@@ -818,10 +819,7 @@ public:
 
     virtual ~string_fragment_producer() {}
 
-    virtual size_t estimated_size() const
-    {
-        return 1024;
-    }
+    virtual size_t estimated_size() const { return 1024; }
 
     virtual next_result next() = 0;
 
@@ -979,16 +977,25 @@ struct formatter<intern_string_t> : formatter<string_view> {
     template<typename FormatContext>
     auto format(const intern_string_t& is, FormatContext& ctx)
     {
-        return formatter<string_view>::format(
-            string_view{is.get(), (size_t) is.size()}, ctx);
+        return formatter<string_view>::format(string_view{is.get(), is.size()},
+                                              ctx);
+    }
+};
+
+template<>
+struct formatter<std::error_code> : formatter<string_view> {
+    template<typename FormatContext>
+    auto format(const std::error_code& ec, FormatContext& ctx)
+    {
+        return formatter<string_view>::format(ec.message(), ctx);
     }
 };
 }  // namespace fmt
 
 namespace std {
 template<>
 struct hash<const intern_string_t> {
-    std::size_t operator()(const intern_string_t& ist) const
+    std::size_t operator()(const intern_string_t& ist) const noexcept
     {
         return ist.hash();
     }
@@ -1035,7 +1042,7 @@ operator==(const string_fragment& left, const intern_string_t& right)
 }
 
 constexpr string_fragment
-operator"" _frag(const char* str, std::size_t len)
+operator""_frag(const char* str, std::size_t len)
 {
     return string_fragment{str, 0, (int) len};
 }
@@ -1092,4 +1099,12 @@ struct intern_hasher {
     }
 };
 
+namespace lnav {
+inline std::error_code
+from_errno()
+{
+    return std::error_code{errno, std::generic_category()};
+}
+}  // namespace lnav
+
 #endif

src/base/lnav.console.hh

@@ -118,7 +118,7 @@ struct user_message {
 
     user_message& with_errno_reason()
     {
-        this->um_reason = strerror(errno);
+        this->um_reason = lnav::from_errno().message();
         return *this;
     }
 

src/base/network.tcp.cc

@@ -65,7 +65,7 @@ connect(const char* hostname, const char* servname)
         return Err(fmt::format(FMT_STRING("unable to connect to {}:{} -- {}"),
                                hostname,
                                servname,
-                               strerror(errno)));
+                               lnav::from_errno()));
     }
 
     return Ok(std::move(retval));

src/base/piper.file.cc

@@ -35,6 +35,7 @@
 #include "base/injector.hh"
 #include "base/lnav_log.hh"
 #include "base/paths.hh"
+#include "intern_string.hh"
 
 namespace lnav::piper {
 
@@ -69,7 +70,8 @@ read_header(int fd, const char* first8)
     }
     auto meta_prc = pread(fd, meta_buf.in(), meta_size, 8);
     if (meta_prc != meta_size) {
-        log_error("failed to read piper header: %s", strerror(errno));
+        log_error("failed to read piper header: %s",
+                  lnav::from_errno().message().c_str());
         return std::nullopt;
     }
     meta_buf.resize(meta_size);

src/cmds.io.cc

@@ -1846,7 +1846,7 @@ com_pipe_to(exec_context& ec,
                         == -1)
                     {
                         return ec.make_error("Unable to write to pipe -- {}",
-                                             strerror(errno));
+                                             lnav::from_errno());
                     }
                     log_perror(write(child_fds[0].write_end(), "\n", 1));
                 } else {
@@ -1856,7 +1856,7 @@ com_pipe_to(exec_context& ec,
                         == -1)
                     {
                         return ec.make_error("Unable to write to pipe -- {}",
-                                             strerror(errno));
+                                             lnav::from_errno());
                     }
                     log_perror(write(child_fds[0].write_end(), "\n", 1));
                 }
@@ -1870,7 +1870,7 @@ com_pipe_to(exec_context& ec,
                         == -1)
                     {
                         return ec.make_error("Unable to write to pipe -- {}",
-                                             strerror(errno));
+                                             lnav::from_errno());
                     }
                     log_perror(write(child_fds[0].write_end(), "\n", 1));
                 }

src/command_executor.cc

@@ -762,7 +762,7 @@ execute_file(exec_context& ec, const std::string& path_and_args)
         extract_metadata_from_file(meta);
         paths_to_exec.push_back(meta);
     } else if (errno != ENOENT) {
-        open_error = strerror(errno);
+        open_error = lnav::from_errno().message();
     } else {
         auto script_path = std::filesystem::path(script_name);
 
@@ -777,7 +777,7 @@ execute_file(exec_context& ec, const std::string& path_and_args)
             extract_metadata_from_file(meta);
             paths_to_exec.push_back(meta);
         } else if (errno != ENOENT) {
-            open_error = strerror(errno);
+            open_error = lnav::from_errno().message();
         }
     }
 

src/file_collection.cc

@@ -369,16 +369,16 @@ file_collection::watch_logfile(const std::string& filename,
     }
     if (rc == -1) {
         if (required) {
+            auto ec = lnav::from_errno();
             log_error("failed to open required file: %s -- %s",
                       filename.c_str(),
-                      strerror(errno));
+                      ec.message().c_str());
             file_collection retval;
-            retval.fc_name_to_errors->writeAccess()->emplace(
-                filename,
-                file_error_info{
-                    time(nullptr),
-                    std::string(strerror(errno)),
-                });
+            retval.fc_name_to_errors->writeAccess()->emplace(filename,
+                                                             file_error_info{
+                                                                 time(nullptr),
+                                                                 ec.message(),
+                                                             });
             return lnav::futures::make_ready_future(std::move(retval));
         }
         return std::nullopt;

src/file_format.cc

@@ -69,7 +69,7 @@ detect_file_format(const std::filesystem::path& filename)
                       filename.c_str(),
                       strerror(errno));
         } else {
-            static auto SQLITE3_HEADER = "SQLite format 3";
+            static const auto* SQLITE3_HEADER = "SQLite format 3";
             auto header_frag = string_fragment::from_bytes(buffer, rc);
 
             if (header_frag.startswith(SQLITE3_HEADER)) {